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
ss58Format	number	SS58 address format for this chain
tokenDecimals	array	Array of token decimal places
tokenSymbol	array	Array of token symbols

Request Example

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

Response Example

{
  "jsonrpc": "2.0",
  "result": {
    "ss58Format": 0,
    "tokenDecimals": [10],
    "tokenSymbol": ["DOT"]
  },
  "id": 1
}

Code Examples

Python

import requests
import json
from decimal import Decimal

def get_system_properties():
    url = "https://api-asset-hub-polkadot.n.dwellir.com"
    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["ss58Format"]

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(10000000000))  # 1.0000 DOT
print(formatter.to_raw(1.5))  # 15000000000

JavaScript

const getChainProperties = async () => {
  const response = await fetch('https://api-asset-hub-polkadot.n.dwellir.com', {
    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 = properties.tokenDecimals[0];
const symbol = properties.tokenSymbol[0];
const ss58Format = properties.ss58Format;

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

// Format token amount
const rawAmount = 10000000000; // 1 DOT in smallest unit
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}`;
}

TypeScript (@polkadot/api)

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

async function getAndUseProperties() {
  const provider = new WsProvider('wss://api-asset-hub-polkadot.n.dwellir.com');
  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(42);
  const tokenDecimals = properties.tokenDecimals.unwrapOr([12]);
  const tokenSymbol = properties.tokenSymbol.unwrapOr(['Unit']);
  
  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-asset-hub-polkadot.n.dwellir.com') 
  });
  
  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() || 12);
      return `${(amount / divisor).toFixed(4)} ${symbol}`;
    }
  }));
  
  await api.disconnect();
  return formatters;
}

Common Chain Properties

Chain	SS58 Format	Symbol	Decimals
Polkadot	0	DOT	10
Kusama	2	KSM	12
Westend	42	WND	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

1. UI Configuration: Set up correct token display in interfaces
2. Address Formatting: Format addresses for the specific chain
3. Balance Display: Show balances with correct decimals
4. Transaction Creation: Calculate fees and amounts correctly
5. 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

Related Methods

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