fenine_getContractConstants
curl --request GET \
--url https://api.example.com/fenine_getContractConstantsimport requests
url = "https://api.example.com/fenine_getContractConstants"
response = requests.get(url)
print(response.text)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))
}HttpResponse<String> response = Unirest.get("https://api.example.com/fenine_getContractConstants")
.asString();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
}fenine_* Methods
fenine_getContractConstants
Get important contract constants and configuration
GET
fenine_getContractConstants
fenine_getContractConstants
curl --request GET \
--url https://api.example.com/fenine_getContractConstantsimport requests
url = "https://api.example.com/fenine_getContractConstants"
response = requests.get(url)
print(response.text)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))
}HttpResponse<String> response = Unirest.get("https://api.example.com/fenine_getContractConstants")
.asString();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
NoneResponse
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
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
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
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');
Related Methods
fenine_getSystemContractAddress
Get System Contract address
getCurrentEpoch
Get current epoch number