Centrifuge RPC API Documentation

Overview

Centrifuge is the leading Real-World Asset (RWA) protocol and Polkadot parachain, providing infrastructure for tokenizing, managing, and investing in real-world financial assets. Built on the Substrate framework, Centrifuge bridges traditional finance with DeFi, enabling businesses to access instant, bankless liquidity through tokenized credit, real estate, treasuries, and other real-world assets.

This documentation provides comprehensive coverage of Centrifuge's JSON-RPC API methods, enabling developers to interact with Centrifuge nodes for building applications, wallets, explorers, and other blockchain tools.

Network Information

Mainnet (Centrifuge)

• Parachain ID: 2031
• Native Token: CFG
• Token Decimals: 18
• SS58 Prefix: 36
• Consensus: Nominated Proof-of-Stake (NPoS) via Polkadot
• Framework: Substrate
• Genesis Hash: 0xb3db41421702df9a7fcac62b53ffeac85f7853cc4e689e0b93aeb3db18c09d82

Connection Endpoints

HTTPS Endpoint

https://api-centrifuge.n.dwellir.com/{YOUR_API_KEY}

WebSocket Endpoint

wss://api-centrifuge.n.dwellir.com/{YOUR_API_KEY}

Authentication

Authentication is done via the URL path. Replace {YOUR_API_KEY} with your actual API key obtained from dwellir.com.

API Categories

Centrifuge's RPC API is organized into the following method categories:

Core APIs

Author Methods

Submit and manage extrinsics (transactions) on the network.

Chain Methods

Query blockchain data including blocks, headers, and finalized state.

State Methods

Access runtime storage, metadata, and proof generation.

System Methods

Node information, health checks, and network properties.

Specialized APIs

BEEFY Methods

Bridge Efficiency Enabling Finality Yielder protocol operations.

Grandpa Methods

GRANDPA finality gadget operations and proofs.

Child State Methods

Manage child storage tries for contracts and parachains.

Sync State Methods

Monitor and manage node synchronization state.

Quick Start Examples

Get Latest Block

const response = await fetch('https://api-centrifuge.n.dwellir.com/YOUR_API_KEY', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    jsonrpc: '2.0',
    method: 'chain_getBlock',
    params: [],
    id: 1
  })
});

const data = await response.json();
console.log('Latest block:', data.result);

Submit Transaction

import requests
import json

url = "https://api-centrifuge.n.dwellir.com/YOUR_API_KEY"
headers = {
    "Content-Type": "application/json"
}

# Properly formatted and signed extrinsic
extrinsic = "0x..."

payload = {
    "jsonrpc": "2.0",
    "method": "author_submitExtrinsic",
    "params": [extrinsic],
    "id": 1
}

response = requests.post(url, headers=headers, data=json.dumps(payload))
tx_hash = response.json()["result"]
print(f"Transaction hash: {tx_hash}")

Subscribe to New Blocks (WebSocket)

const WebSocket = require('ws');

const ws = new WebSocket('wss://api-centrifuge.n.dwellir.com/YOUR_API_KEY');

ws.on('open', () => {
  ws.send(JSON.stringify({
    jsonrpc: '2.0',
    method: 'chain_subscribeNewHeads',
    params: [],
    id: 1
  }));
});

ws.on('message', (data) => {
  const response = JSON.parse(data);
  if (response.params?.result) {
    console.log('New block:', response.params.result);
  }
});

Error Handling

Centrifuge RPC errors follow the JSON-RPC 2.0 error format:

{
  "jsonrpc": "2.0",
  "error": {
    "code": -32602,
    "message": "Invalid params",
    "data": "Expected hex-encoded hash"
  },
  "id": 1
}

Common Error Codes

Code	Message	Description
-32700	Parse error	Invalid JSON
-32600	Invalid request	Missing required fields
-32601	Method not found	Unknown RPC method
-32602	Invalid params	Invalid method parameters
-32603	Internal error	Node processing error
-32000	Server error	Custom server errors

Best Practices

1. Connection Management

• Use WebSocket connections for subscriptions and real-time updates
• Implement reconnection logic for WebSocket disconnections
• Use HTTPS for single queries and transactions

2. Error Handling

• Always check for error responses before processing results
• Implement retry logic with exponential backoff
• Log errors for debugging and monitoring

3. Performance Optimization

• Batch multiple queries when possible
• Cache frequently accessed data like metadata
• Use specific block hashes for deterministic queries

4. Security

• Never expose API keys in client-side code
• Validate all input data before submission
• Use secure storage for private keys

SDK Support

Official Libraries

• @polkadot/api - JavaScript/TypeScript SDK (compatible with Centrifuge)
• py-substrate-interface - Python SDK
• subxt - Rust SDK
• go-substrate-rpc-client - Go SDK

Integration Example

// Using @polkadot/api
const { ApiPromise, WsProvider } = require('@polkadot/api');

async function connect() {
  const provider = new WsProvider('wss://api-centrifuge.n.dwellir.com/YOUR_API_KEY');

  const api = await ApiPromise.create({ provider });

  // Query chain data
  const chain = await api.rpc.system.chain();
  console.log(`Connected to ${chain}`);

  // Get account balance
  const account = 'YOUR_ADDRESS';
  const { data: balance } = await api.query.system.account(account);
  console.log(`Balance: ${balance.free.toString()}`);

  return api;
}

Centrifuge Features

Real-World Asset Tokenization

Centrifuge is the leading protocol for tokenizing real-world assets, with $270 million in active loans and nearly $500 million in total financed assets. The platform enables:

• Private Credit - Tokenization of private credit and lending markets
• Real Estate - Property-backed tokenized assets
• Treasuries - Government bond tokenization
• Invoice Financing - SME invoice and receivables tokenization

DeFi Integration

Centrifuge bridges traditional finance with DeFi through:

• Multichain Support - Integration across Polkadot, Ethereum, and other chains via Wormhole
• Liquidity Pools - Tinlake protocol for asset-backed lending pools
• Institutional Grade - Compliance-ready infrastructure for regulated assets

CFG Token

The CFG token serves multiple purposes:

• Governance - Community-driven protocol upgrades and parameter changes
• Staking - Network security through Polkadot's NPoS
• Utility - Access to protocol features and services

Polkadot Integration

As a Polkadot parachain, Centrifuge benefits from:

• Shared Security - Protected by Polkadot's validator network
• Cross-Chain Interoperability - Seamless communication with other parachains
• Scalability - Leveraging Polkadot's multi-chain architecture

Additional Resources

• Centrifuge Website
• Centrifuge Documentation
• Centrifuge GitHub
• Centrifuge Explorer
• Polkadot Parachains Info
• Substrate Documentation

Support

For additional support or questions:

• Email: support@dwellir.com
• Documentation: docs.dwellir.com

---

Method Categories

Select a category below to explore detailed method documentation: