API & RPC Documentation

// Connect to Sahyadri node via WebSocket
const ws = new WebSocket('wss://api.sahyadri.io:27110/ws');

ws.onopen = () => {
  // Call any RPC method
  ws.send(JSON.stringify({
    "id": 1,
    "method": "submitTransaction",
    "params": ["signed_tx_hex_string..."]
  }));
};

ws.onmessage = (event) => {
  const response = JSON.parse(event.data);
  console.log(response);
};

# Connect to Sahyadri node via gRPC (port 26110)
import grpc

# gRPC endpoint: api.sahyadri.io:26110
# Use the Sahyadri protobuf definition to generate client stub
# Then call any RPC method via the bidirectional stream

channel = grpc.insecure_channel('api.sahyadri.io:26110')
# stub = sahyadri_pb2_grpc.SahyadriServiceStub(channel)

# WebSocket RPC via wscat
wscat -c "wss://api.sahyadri.io:27110/ws"
> {"id":1,"method":"getInfo","params":[{}]}

// Request via JSON-RPC over WebSocket
{
  "id": 1,
  "method": "getBlock",
  "params": [{ "blueScore": 6602, "includeTransactions": true }]
}

// Response
{
  "block": {
    "header": {
      "version": 1,
      "hash": "0bea8500abc...",
      "blueScore": 6602,
      "daaScore": 6598,
      "timestamp": 1710255328,
      "bits": 2072554627,
      "nonce": 4521893761,
      "parentBlockHashes": ["7f3c1200...", "a1e93300..."]
    },
    "transactions": ["8f3a9b2...", "2c1e8d4..."],
    "verboseData": {
      "minerAddress": "csm1sp5fndd452...",
      "reward": "25.00000000"
    }
  }
}

{
  "id": 2,
  "method": "getBlocks",
  "params": [{
    "lowHash": "block_hash_start...",
    "includeBlocks": true,
    "includeTransactions": false
  }]
}

// Broadcast a signed transaction
{
  "id": 1,
  "method": "submitTransaction",
  "params": ["serialized_tx_hex_string..."]
}

// Response
{
  "transactionId": "8f3a9b2c1d..."
}

{
  "id": 3,
  "method": "getMempoolEntry",
  "params": [{ "transactionId": "a1b2c3d4...",
    "includeOrphanPool": true,
    "filterTransactionPool": true }]
}

// Response
{
  "mempoolEntry": {
    "transaction": { "transactionId": "a1b2c3d4...", ... },
    "fee": 100000,
    "isOrphan": false
  }
}

{
  "id": 4,
  "method": "getBalanceByAddress",
  "params": ["csm1sp5fndd452tss097m7dhcyhs5nzlwpp..."]
}

// Response
{
  "balance": "2301100000000"
}

{
  "id": 5,
  "method": "getUtxosByAddresses",
  "params": [[
    "csm1sp5fndd452...",
    "csm1sar30mvpd..."
  ]]
}

// Response
{
  "entries": [
    {
      "address": "csm1sp5fndd452...",
      "utxoEntries": [
        {
          "outpoint": {
            "transactionId": "8f3a9b2...",
            "index": 0
          },
          "utxoEntry": {
            "amount": 20000000000,
            "scriptPublicKey": "76a914...",
            "blockDaaScore": 6590
          }
        }
      ]
    }
  ]
}

{
  "id": 6,
  "method": "getInfo",
  "params": [{}]
}

// Response
{
  "serverVersion": "1.1.0",
  "networkId": "sahyadri-mainnet",
  "hasUtxoIndex": true,
  "isSynced": true,
  "mempoolSize": 23,
  "p2pId": "abc123...",
  "hasNotifyCommand": true,
  "hasMessageId": true
}

{
  "id": 7,
  "method": "getCoinSupply",
  "params": [{}]
}

// Response
{
  "circulatingkana": "29145625000000",
  "maxkana": 2100000000000000
}

{
  "id": 8,
  "method": "getSahyadriDagInfo",
  "params": [{}]
}

// Response
{
  "blockCount": 11636,
  "headerCount": 11636,
  "daaScore": 11100,
  "blueScore": 11110,
  "difficulty": 2586428.53,
  "virtualSelectedParentBlueScore": 11108,
  "pastMedianTime": 1710255300,
  "parentMedianBlueScore": 11100,
  "daaScore": 11100
}

{
  "id": 9,
  "method": "getBlockTemplate",
  "params": [{
    "payAddress": "csm1sp5fndd452...",
    "extraData": ""
  }]
}

// Response
{
  "block": {
    "header": {
      "version": 1,
      "parentBlockHashes": ["7f3c1200...", "a1e93300..."],
      "hashMerkleRoot": "00000000...",
      "hash": "00000000...",
      "daaScore": 11101,
      "timestamp": 1710255320,
      "bits": 2072554627,
      "nonce": 0
    },
    "isSynced": true
  }
}

{
  "id": 10,
  "method": "estimateNetworkHashesPerSecond",
  "params": [{ "windowSize": 1000, "startHash": null }]
}

// Response
{
  "networkHashesPerSecond": 12584962340
}

// Subscribe
{
  "id": 1,
  "method": "subscribeVirtualDaaScoreChanged",
  "params": [{}]
}

// Notification received
{
  "type": "VirtualDaaScoreChangedNotification",
  "virtualDaaScore": 11101
}

// Subscribe to specific addresses
{
  "id": 2,
  "method": "subscribeUtxosChanged",
  "params": [[
    "csm1sp5fndd452...",
    "csm1sar30mvpd..."
  ]]
}

// Notification received
{
  "type": "UtxosChangedNotification",
  "address": "csm1sp5fndd452...",
  "added": [{ "outpoint": {...}, "utxoEntry": {...} }],
  "removed": [{ "outpoint": {...} }]
}

// Subscribe
{
  "id": 3,
  "method": "subscribeVirtualChainChanged",
  "params": [{ "includeAcceptedTransactionIds": true }]
}

// Notification received
{
  "type": "VirtualChainChangedNotification",
  "chainBlocks": [{
    "acceptingBlockHash": "0bea8500...",
    "acceptedTransactionIds": ["8f3a9b2..."]
  }]
}

// Connect to Sahyadri RPC via WebSocket
const ws = new WebSocket('wss://api.sahyadri.io:27110/ws');

ws.onopen = () => {
  console.log('Connected to Sahyadri node');

  // Get node info
  ws.send(JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    "method": "getInfo",
    "params": [{}]
  }));

  // Subscribe to new blocks in real-time
  ws.send(JSON.stringify({
    jsonrpc: "2.0",
    id: 2,
    "method": "subscribeVirtualChainChanged",
    "params": [{ "includeAcceptedTransactionIds": true }]
  }));
};

ws.onmessage = (event) => {
  const data = JSON.parse(event.data);

  // Handle subscription notifications
  if (data.type === 'VirtualChainChangedNotification') {
    console.log('New block:', data.chainBlocks);
  }
  // Handle RPC responses
  else {
    console.log('RPC Response:', data);
  }
};

# pip install grpcio grpcio-tools
# Generate stubs: python -m grpc_tools.protoc -I proto/ proto/rpc.proto --python_out=. --grpc_python_out=.

import grpc
from rpc_pb2 import *
from rpc_pb2_grpc import RPCServiceStub

# Connect to Sahyadri gRPC endpoint
channel = grpc.insecure_channel('api.sahyadri.io:26110')
stub = RPCServiceStub(channel)

# Get node info
response = stub.GetInfo(GetInfoRequest())
print(f"Network: {response.serverVersion}")
print(f"UTXO Index: {response.hasUtxoIndex}")
print(f"Synced: {response.isSynced}")

# Get balance for an address (exchange deposit check)
balance = stub.GetBalanceByAddress(
    GetBalanceByAddressRequest(address="csm1qp5fndd452tss097m7dhcyhs5nzlwpp...")
)
print(f"Balance: {int(balance.balance) / 1e8} CSM")

# Install wscat for interactive WebSocket testing
npm install -g wscat

# Connect to Sahyadri node
wscat -c wss://api.sahyadri.io:27110/ws

# Once connected, send RPC calls as JSON:
> {"jsonrpc":"2.0","id":1,"method":"getInfo","params":[{}]}
> {"jsonrpc":"2.0",1,"method":"getCoinSupply","params":[{}]}
> {"jsonrpc":"2.0","id":2,"method":"getBlockTemplate","params":[{"payAddress":"csm1q..."}]}

# Or test with a one-liner (websocat)
echo '{"jsonrpc":"2.0","id":1,"method":"ping"}' | websocat wss://api.sahyadri.io:27110/ws

// 1. Connect WebSocket
const ws = new WebSocket('wss://api.sahyadri.io:27110/ws');

// 2. Subscribe to your hot wallet addresses
ws.onopen = () => {
  ws.send(JSON.stringify({
    "id": 1,
    "method": "subscribeUtxosChanged",
    "params": [[
      "csm1syour_hot_wallet_address...",
      "csm1syour_deposit_address..."
    ]]
  }));
};

// 3. When notification arrives, a deposit was received
ws.onmessage = (event) => {
  const data = JSON.parse(event.data);
  if (data.type === "UtxosChangedNotification") {
    // data.added = new UTXOs (incoming deposit)
    // data.removed = spent UTXOs
    console.log("Deposit detected!", data.added);
    // -> Credit user account in your database
    // -> Wait for confirmations (DAA score)
  }
};

// Broadcast withdrawal transaction
ws.send(JSON.stringify({
  "id": 2,
  "method": "submitTransaction",
  "params": ["signed_transaction_hex_from_your_engine..."]
}));

// Response: { "transactionId": "abc123..." }
// Save this tx ID in your DB for tracking

// Check hot wallet balance (multiple addresses)
ws.send(JSON.stringify({
  "id": 3,
  "method": "getBalancesByAddresses",
  "params": [[
    "csm1syour_hot_wallet...",
    "csm1syour_cold_wallet..."
  ]]
}));

// Response: array of { address, balance }

// First call: get network info
ws.send(JSON.stringify({
  "id": 1,
  "method": "getInfo",
  "params": [{}]
}));
// Response gives: networkId, serverVersion, isSynced, hasUtxoIndex
// Use this to verify you're on sahyadri-mainnet

ws.send(JSON.stringify({
  "id": 2,
  "method": "getBalanceByAddress",
  "params": ["csm1suser_wallet_address..."]
}));
// Response: { "balance": "2301100000000" }
// Divide by 100000000 (8 decimals) = 23011.00000000 CSM

// 1. Get UTXOs to build transaction
ws.send(JSON.stringify({
  "id": 3,
  "method": "getUtxosByAddresses",
  "params": [["csm1syour_address..."]]
}));

// 2. Build signed transaction locally (use Sahyadri SDK)
// 3. Broadcast it
ws.send(JSON.stringify({
  "id": 4,
  "method": "submitTransaction",
  "params": ["signed_tx_hex..."]
}));

// Get latest blocks
ws.send(JSON.stringify({
  "id": 1,
  "method": "getBlocks",
  "params": [{
    "lowHash": null,
    "includeBlocks": true,
    "includeTransactions": false
  }]
}));
// Use getBlockCount first to know the current tip

// Real-time new block notifications
ws.send(JSON.stringify({
  "id": 2,
  "method": "subscribeVirtualChainChanged",
  "params": [{ "includeAcceptedTransactionIds": true }]
}));

ws.onmessage = (event) => {
  const data = JSON.parse(event.data);
  if (data.type === "VirtualChainChangedNotification") {
    // New block accepted: data.chainBlocks[0].acceptingBlockHash
    // Transaction IDs: data.chainBlocks[0].acceptedTransactionIds
  }
};

// For CoinGecko / CMC listing
ws.send(JSON.stringify({
  "id": 3,
  "method": "getCoinSupply",
  "params": [{}]
}));
// Response: { "circulatingkana": "...", "maxkana": 2100000000000000 }
// Divide kana by 100000000 to get CSM

ws.send(JSON.stringify({
  "id": 4,
  "method": "getSahyadriDagInfo",
  "params": [{}]
}));
// Response: blockCount, daaScore, blueScore, difficulty, blockRate

ws.send(JSON.stringify({
  "id": 1,
  "method": "getBlockTemplate",
  "params": [{
    "payAddress": "csm1syour_miner_address...",
    "extraData": "my_pool_id"
  }]
}));
// Response: block header template with parent hashes, bits, DAA score
// Distribute to miners, they find nonce with SahyadriX hash

// Miner found valid nonce, submit the block
ws.send(JSON.stringify({
  "id": 2,
  "method": "submitBlock",
  "params": [{ "block": "serialized_block_hex..." }]
}));

ws.send(JSON.stringify({
  "id": 3,
  "method": "estimateNetworkHashesPerSecond",
  "params": [{ "windowSize": 1000, "startHash": null }]
}));
// Response: { "networkHashesPerSecond": 12584962340 }

# Install wscat
npm install -g wscat

# Connect to Sahyadri node
wscat -c "wss://api.sahyadri.io:27110/ws"

# Test: Get node info
> {"id":1,"method":"getInfo","params":[{}]}
# Response: { id:1, result:{ serverVersion:"1.1.0", networkId:"sahyadri-mainnet", ... } }

# Test: Get coin supply
> {"id":2,"method":"getCoinSupply","params":[{}]}
# Response: { id:2, result:{ circulatingkana:"...", maxkana:2100000000000000 } }

# Test: Get DAG info
> {"id":3,"method":"getSahyadriDagInfo","params":[{}]}
# Response: { id:3, result:{ blockCount:..., daaScore:..., blueScore:..., difficulty:... } }

# Test: Ping
> {"id":4,"method":"ping","params":[{}]}
# Response: { id:4, result:"pong" }

# Install grpcurl
go install github.com/fullstorydev/grpcurl/cmd/grpcurl@latest

# List available gRPC services
grpcurl -plaintext api.sahyadri.io:26110 list

# Call GetInfo
grpcurl -plaintext api.sahyadri.io:26110 sahyadri.rpc/SahyadriService/GetInfo

// Open browser console (F12) on any page and paste:
const ws = new WebSocket('wss://api.sahyadri.io:27110/ws');
ws.onopen = () => {
  ws.send(JSON.stringify({
    "id": 1,
    "method": "getSahyadriDagInfo",
    "params": [{}]
  }));
};
ws.onmessage = (e) => console.log(JSON.parse(e.data));
// Check console for response

// Select a method above and click "Send Request"
// Response will appear here