system_properties – Mythos JSON-RPC Method

Description

Returns network-specific properties for the Mythos blockchain including token symbols, decimal precision, and SS58 address format. This method provides essential chain configuration data that wallets, explorers, and applications need to correctly format token amounts and blockchain addresses. The properties returned are fundamental for ensuring accurate display of balances, proper address encoding, and multi-token support in applications.

Parameters

This method does not require any parameters.

Returns

Field	Type	Description
tokenSymbol	array	Array of token symbols supported by the chain
tokenDecimals	array	Array of decimal places for each token
ss58Format	number	SS58 address format identifier for the chain

Use Cases

1. Wallet Integration: Configure token display settings and address formatting in wallets
2. Balance Formatting: Convert raw token amounts to human-readable values with correct decimals
3. Address Validation: Encode and decode addresses using the correct SS58 format
4. Multi-Token Support: Handle multiple native tokens with different decimal configurations
5. Explorer Development: Display addresses and balances correctly in block explorers
6. DApp Configuration: Initialize web3 applications with proper chain-specific settings

Request Example

curl -s https://api-mythos.n.dwellir.com/YOUR_API_KEY \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "system_properties",
    "params": [],
    "id": 1
  }'

Response Example

{
  "jsonrpc": "2.0",
  "result": {
    "ss58Format": 29972,
    "tokenDecimals": [18],
    "tokenSymbol": ["MYTH"]
  },
  "id": 1
}

Code Examples

TypeScript (@polkadot/api)

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

const api = await ApiPromise.create({
  provider: new WsProvider('wss://api-mythos.n.dwellir.com/YOUR_API_KEY')
});
const properties = await api.rpc.system.properties();

const ss58Format = properties.ss58Format.unwrapOr(29972);
const tokenDecimals = properties.tokenDecimals.unwrapOr([18]);
const tokenSymbol = properties.tokenSymbol.unwrapOr(['MYTH']);

// Configure formatBalance with chain properties
formatBalance.setDefaults({
  decimals: tokenDecimals.map(d => d.toNumber()),
  unit: tokenSymbol.map(s => s.toString())
});

console.log(`Chain uses ${tokenSymbol[0]} with ${tokenDecimals[0]} decimals`);
console.log(`SS58 Format: ${ss58Format}`);

Python

import requests
import json
from decimal import Decimal

def get_chain_properties():
    url = "https://api-mythos.n.dwellir.com/YOUR_API_KEY"
    payload = {
        "jsonrpc": "2.0",
        "method": "system_properties",
        "params": [],
        "id": 1
    }
    response = requests.post(url, json=payload)
    return response.json()["result"]

properties = get_chain_properties()
token_symbol = properties["tokenSymbol"][0]
token_decimals = properties["tokenDecimals"][0]
ss58_format = properties["ss58Format"]

print(f"Token: {token_symbol}")
print(f"Decimals: {token_decimals}")
print(f"SS58 Format: {ss58_format}")

# Format token amounts
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)

formatter = TokenFormatter(token_decimals, token_symbol)
print(formatter.format_amount(1000000000000000000))  # 1.0000 MYTH

JavaScript

async function getChainProperties() {
  const response = await fetch('https://api-mythos.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;
}

const properties = await getChainProperties();
const { tokenSymbol, tokenDecimals, ss58Format } = properties;

console.log(`Token: ${tokenSymbol[0]}`);
console.log(`Decimals: ${tokenDecimals[0]}`);
console.log(`SS58 Format: ${ss58Format}`);

// Format balance helper
function formatBalance(rawAmount, decimals, symbol) {
  const amount = rawAmount / Math.pow(10, decimals);
  return `${amount.toFixed(4)} ${symbol}`;
}

console.log(formatBalance(1000000000000000000, tokenDecimals[0], tokenSymbol[0]));

Best Practices

• Cache chain properties during application initialization to reduce RPC calls
• Use token decimals to convert between raw and display amounts consistently
• Validate SS58 format when encoding/decoding addresses
• Handle multiple tokens by iterating through tokenSymbol and tokenDecimals arrays
• Store properties in application configuration for offline reference
• Update UI components with correct token symbols and precision

Related Methods

• system_chain - Get the chain name
• system_version - Get node implementation version
• state_getRuntimeVersion - Get runtime version