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
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