system_properties - JSON-RPC Method

Description#

Returns the chain properties including token decimals, token symbol, and SS58 address format. This JSON-RPC method provides essential configuration information needed for properly formatting addresses and token amounts in applications.

Parameters#

This method does not require any parameters.

Returns#

Field	Type	Description
`tokenDecimals`	number \| number[]	Primary token decimals (Hydration uses 12)
`tokenSymbol`	string \| string[]	Primary token symbol (Hydration uses HDX)
`ss58Format`	number (optional)	SS58 address prefix if provided (default to 63 when omitted)

Request Example#

{
  "jsonrpc": "2.0",
  "method": "system_properties",
  "params": [],
  "id": 1
}

Response Example#

{
  "jsonrpc": "2.0",
  "result": {
    "tokenDecimals": 12,
    "tokenSymbol": "HDX"
  },
  "id": 1
}

Code Examples#

Python
JavaScript
TypeScript (@polkadot/api)

import requests
import json
from decimal import Decimal

def get_system_properties():
    url = "https://api-hydration.n.dwellir.com/YOUR_API_KEY"
    headers = {
        "Content-Type": "application/json"
    }
    
    payload = {
        "jsonrpc": "2.0",
        "method": "system_properties",
        "params": [],
        "id": 1
    }
    
    response = requests.post(url, headers=headers, data=json.dumps(payload))
    return response.json()["result"]

# Get and use chain properties
properties = get_system_properties()
decimals = properties["tokenDecimals"][0]
symbol = properties["tokenSymbol"][0]
ss58_format = properties.get("ss58Format", 63)

print(f"Token: {symbol}")
print(f"Decimals: {decimals}")
print(f"SS58 Format: {ss58_format}")

# Create formatter class
class TokenFormatter:
    def __init__(self, decimals, symbol):
        self.decimals = decimals
        self.symbol = symbol
        self.unit = Decimal(10) ** decimals
    
    def format_amount(self, raw_amount):
        amount = Decimal(raw_amount) / self.unit
        return f"{amount:.4f} {self.symbol}"
    
    def to_raw(self, amount):
        return int(Decimal(amount) * self.unit)

# Usage
formatter = TokenFormatter(decimals, symbol)
print(formatter.format_amount(1_000_000_000_000))  # 1.0000 HDX
print(formatter.to_raw(1.5))  # 1500000000000

const getChainProperties = async () => {
  const response = await fetch('https://api-hydration.n.dwellir.com/YOUR_API_KEY', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      jsonrpc: '2.0',
      method: 'system_properties',
      params: [],
      id: 1
    })
  });
  
  const data = await response.json();
  return data.result;
};

// Use properties to format values
const properties = await getChainProperties();
const decimals = Array.isArray(properties.tokenDecimals)
  ? properties.tokenDecimals[0]
  : properties.tokenDecimals;
const symbol = Array.isArray(properties.tokenSymbol)
  ? properties.tokenSymbol[0]
  : properties.tokenSymbol;
const ss58Format = properties.ss58Format ?? 63;

console.log(`Chain uses ${symbol} with ${decimals} decimals`);
console.log(`SS58 Format: ${ss58Format}`);

// Format token amount
const rawAmount = 1_000_000_000_000; // 1 HDX in planck units (10^12)
const formattedAmount = rawAmount / Math.pow(10, decimals);
console.log(`Amount: ${formattedAmount} ${symbol}`);

// Helper function to format balance
function formatBalance(rawBalance) {
  const balance = rawBalance / Math.pow(10, decimals);
  return `${balance.toFixed(4)} ${symbol}`;
}

import { ApiPromise, WsProvider } from '@polkadot/api';
import { formatBalance } from '@polkadot/util';

async function getAndUseProperties() {
  const provider = new WsProvider('wss://api-hydration.n.dwellir.com/YOUR_API_KEY');
  const api = await ApiPromise.create({ provider });
  
  // Get properties via RPC
  const properties = await api.rpc.system.properties();
  
  console.log('Chain Properties:', properties.toHuman());
  
  // Access individual properties
  const ss58Format = properties.ss58Format.unwrapOr(63);
  const tokenDecimals = properties.tokenDecimals.unwrapOr([12]);
  const tokenSymbol = properties.tokenSymbol.unwrapOr(['HDX']);
  
  console.log(`SS58 Format: ${ss58Format}`);
  console.log(`Token: ${tokenSymbol[0]} with ${tokenDecimals[0]} decimals`);
  
  // Configure formatBalance with chain properties
  formatBalance.setDefaults({
    decimals: tokenDecimals.map(d => d.toNumber()),
    unit: tokenSymbol.map(s => s.toString())
  });
  
  // Now format balances correctly
  const balance = api.createType('Balance', 10000000000);
  console.log('Formatted:', formatBalance(balance));
  
  await api.disconnect();
}

// Advanced: Multi-token chains
async function handleMultiTokenChain() {
  const api = await ApiPromise.create({ 
    provider: new WsProvider('wss://api-hydration.n.dwellir.com/YOUR_API_KEY') 
  });
  
  const properties = await api.rpc.system.properties();
  const decimals = properties.tokenDecimals.unwrapOr([]);
  const symbols = properties.tokenSymbol.unwrapOr([]);
  
  // Handle multiple tokens
  symbols.forEach((symbol, index) => {
    const decimal = decimals[index] || 12;
    console.log(`Token ${index}: ${symbol} (${decimal} decimals)`);
  });
  
  // Create formatters for each token
  const formatters = symbols.map((symbol, index) => ({
    symbol: symbol.toString(),
    decimals: decimals[index]?.toNumber() || 12,
    format: (amount: any) => {
      const divisor = Math.pow(10, decimals[index]?.toNumber() || decimals[0]?.toNumber() || 12);
      return `${(amount / divisor).toFixed(4)} ${symbol}`;
    }
  }));
  
  await api.disconnect();
  return formatters;
}

Common Chain Properties#

Chain	SS58 Format	Symbol	Decimals
Hydration	63	HDX	12
Basilisk	10041	BSX	12
Generic Substrate	42	UNIT	12

Address Formatting Example#

import { encodeAddress, decodeAddress } from '@polkadot/util-crypto';

async function formatAddressForChain(address) {
  const properties = await getChainProperties();
  const ss58Format = properties.ss58Format;
  
  // Decode from any format
  const decoded = decodeAddress(address);
  
  // Re-encode with chain's format
  const formatted = encodeAddress(decoded, ss58Format);
  
  console.log(`Original: ${address}`);
  console.log(`Formatted for chain: ${formatted}`);
  
  return formatted;
}

// Example
const genericAddress = "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY";
const chainAddress = await formatAddressForChain(genericAddress);

Use Cases#

UI Configuration: Set up correct token display in interfaces
Address Formatting: Format addresses for the specific chain
Balance Display: Show balances with correct decimals
Transaction Creation: Calculate fees and amounts correctly
Multi-chain Support: Handle different chains dynamically

Notes#

Properties are chain-specific and may vary
Some chains support multiple tokens
SS58 format determines address encoding
Always use these properties for formatting
Properties rarely change but should be fetched on init

system_chain - Get chain name
system_version - Get node version
state_getMetadata - Get full chain metadata
system_health - Get node health status