fenine_getContractConstants

curl --request GET \
  --url https://api.example.com/fenine_getContractConstants

const options = {method: 'GET'};

fetch('https://api.example.com/fenine_getContractConstants', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.example.com/fenine_getContractConstants",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.example.com/fenine_getContractConstants"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://api.example.com/fenine_getContractConstants")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

{
  "systemContractAddress": "<string>",
  "blockEpoch": 123,
  "maxValidators": 123,
  "minValidatorStake": "<string>",
  "minDelegatorStake": "<string>",
  "validatorLockPeriod": 123,
  "delegatorLockPeriod": 123,
  "defaultCommission": 123,
  "maxCommission": 123
}

GET

fenine_getContractConstants

curl --request GET \
  --url https://api.example.com/fenine_getContractConstants

const options = {method: 'GET'};

fetch('https://api.example.com/fenine_getContractConstants', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.example.com/fenine_getContractConstants",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.example.com/fenine_getContractConstants"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://api.example.com/fenine_getContractConstants")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

{
  "systemContractAddress": "<string>",
  "blockEpoch": 123,
  "maxValidators": 123,
  "minValidatorStake": "<string>",
  "minDelegatorStake": "<string>",
  "validatorLockPeriod": 123,
  "delegatorLockPeriod": 123,
  "defaultCommission": 123,
  "maxCommission": 123
}

Overview

Returns important contract constants and configuration values from the FenineSystem contract. Useful for understanding network parameters without querying the contract directly.

Parameters

None

Response

string

FenineSystem contract address (always 0x0000000000000000000000000000000000001000)

number

Number of blocks per epoch (200)

number

Maximum number of active validators (101)

string

Minimum validator self-stake in wei (10,000 FEN = “10000000000000000000000”)

string

Minimum delegator stake in wei (1,000 FEN = “1000000000000000000000”)

number

Validator unstake lock period in blocks (50,000 ≈ 3.5 days)

number

Delegator unstake lock period in blocks (25,000 ≈ 1.75 days)

number

Default commission rate in basis points (500 = 5%)

number

Maximum commission rate in basis points (1000 = 10%)

Examples

curl -X POST https://rpc.fene.app \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "fenine_getContractConstants",
    "params": [],
    "id": 1
  }'

const Web3 = require('web3');
const web3 = new Web3('https://rpc.fene.app');

web3.extend({
  methods: [{
    name: 'getContractConstants',
    call: 'fenine_getContractConstants',
    params: 0
  }]
});

const constants = await web3.getContractConstants();

console.log('Network Configuration:');
console.log('Epoch Length:', constants.blockEpoch, 'blocks');
console.log('Max Validators:', constants.maxValidators);
console.log('Min VA Stake:', web3.utils.fromWei(constants.minValidatorStake, 'ether'), 'FEN');
console.log('Min DC Stake:', web3.utils.fromWei(constants.minDelegatorStake, 'ether'), 'FEN');
console.log('VA Lock Period:', constants.validatorLockPeriod, 'blocks');
console.log('Default Commission:', constants.defaultCommission / 100, '%');

from web3 import Web3

w3 = Web3(Web3.HTTPProvider('https://rpc.fene.app'))

result = w3.provider.make_request(
    'fenine_getContractConstants',
    []
)

constants = result['result']

print('Network Configuration:')
print(f"Epoch Length: {constants['blockEpoch']} blocks")
print(f"Max Validators: {constants['maxValidators']}")
print(f"Min VA Stake: {Web3.from_wei(int(constants['minValidatorStake']), 'ether')} FEN")
print(f"Default Commission: {constants['defaultCommission'] / 100}%")

Response Example

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "systemContractAddress": "0x0000000000000000000000000000000000001000",
    "blockEpoch": 200,
    "maxValidators": 101,
    "minValidatorStake": "10000000000000000000000",
    "minDelegatorStake": "1000000000000000000000",
    "validatorLockPeriod": 50000,
    "delegatorLockPeriod": 25000,
    "defaultCommission": 500,
    "maxCommission": 1000
  }
}

Use Cases

Validate User Input

const constants = await web3.getContractConstants();
const stakeAmount = web3.utils.toWei('5000', 'ether');

if (BigInt(stakeAmount) < BigInt(constants.minValidatorStake)) {
  throw new Error(`Minimum stake is ${web3.utils.fromWei(constants.minValidatorStake, 'ether')} FEN`);
}

Calculate Epoch Times

const constants = await web3.getContractConstants();
const currentBlock = await web3.eth.getBlockNumber();
const currentEpoch = Math.floor(currentBlock / constants.blockEpoch);
const blocksUntilNextEpoch = constants.blockEpoch - (currentBlock % constants.blockEpoch);
const estimatedSeconds = blocksUntilNextEpoch * 3; // 3s block time

console.log(`Current epoch: ${currentEpoch}`);
console.log(`Next epoch in ~${Math.floor(estimatedSeconds / 60)} minutes`);

Display Lock Period Info

const constants = await web3.getContractConstants();
const lockPeriodDays = (constants.validatorLockPeriod * 3) / (60 * 60 * 24);

console.log(`Unstaking lock period: ~${lockPeriodDays.toFixed(1)} days`);

Helper Functions

// Convert basis points to percentage
function bpsToPercent(bps) {
  return bps / 100;
}

// Convert blocks to approximate time
function blocksToTime(blocks, blockTime = 3) {
  const seconds = blocks * blockTime;
  const days = seconds / (60 * 60 * 24);
  return {
    seconds,
    minutes: seconds / 60,
    hours: seconds / 3600,
    days
  };
}

// Usage
const constants = await web3.getContractConstants();
console.log('Default commission:', bpsToPercent(constants.defaultCommission), '%');
console.log('Lock period:', blocksToTime(constants.validatorLockPeriod).days, 'days');

fenine_getSystemContractAddress

Get System Contract address

getCurrentEpoch

Get current epoch number

Overview

RPC Endpoints

Smart Contracts

fenine_getContractConstants

Overview

Parameters

Response

Examples

Response Example

Use Cases

Helper Functions

fenine_getSystemContractAddress

getCurrentEpoch

​Overview

​Parameters

​Response

​Examples

​Response Example

​Use Cases

​Helper Functions

​Related Methods

fenine_getSystemContractAddress

getCurrentEpoch

Overview

Parameters

Response

Examples

Response Example

Use Cases

Helper Functions

Related Methods