Rosetta Server for Substrate Chains

This Project contains BlockchainClient implementation of substrate chains.

Methods implemented are:

• config
• genesis_block
• node_version
• current_block
• balance
• faucet
• metadata
• submit
• block
• block_transaction
• call

config:

This method returns BlockchainConfig which contains the configuration specific details for polkadot chain.

genesis_block:

Returns genesis block identifier.

node_version:

Returns node client version.

current_block:

Fetches current block using RPC and returns its identifier.

balance:

Fetches account balance from on chain and returns it. It takes two arguments: address: Address of account we want to fetch balance of. block: block identifier of block at which we want to fetch balance of account.

block:

This function takes PartialBlockIdentifier which contains a block index or hash and returns block transaction and operations happened in that transaction.

block_transaction:

This function takes: block: Which is a block identifier of block from which we want to fetch transaction from. tx: Transaction identifier of transaction we want to fetch. And returns a specific transaction and its operations within specified block.

faucet:

This method is used to fund an account with some amount of tokens in testnet. It takes two arguments: address: Address of account we want to fund. amount: Amount of tokens we want to fund.

metadata:

This call is used to fetch nonce of account, It takes two arguments: public_key: This is the public key of sender. options: This is Params needed to create metadata. For polkadot chain it takes pallet_name: name of pallet. call_name: function of pallet. call_args: parameters of pallet.

It returns PolkadotMetadata which includes nonce, runtime specs, genesis hash and pallet related information.

submit:

It takes transaction bytes which is signed transaction bytes and it Submits signed transaction to chain and return its transaction id.

call:

To fetch Storage or any Constant from a Substrate chain, you can use the Call function. This method takes a CallRequest as input and returns a json Value as output. The CallRequest contains the following fields:

• NetworkIdentifier - The network to make the call on.
• Method - A string contains - seperated the name of pallet, function of pallet and type of query e.g. Storage, Constant.
• Parameters - A Array containing the parameters required for that pallet function.

Passing paramters

Enums and Struct are passed in paramter as array values lets say we have an enum:

enum TestEnum {
    A,
    B(u32),
    C,
}

and we want to pass TestEnum::A as parameter then we pass ["A", ""] as parameter. Second value in array is for the paramter of enum variant. In this case its will be empty since enum does not contain any paramter. if we want to pass TestEnum::B(10) as parameter then we pass ["B", 10] as parameter. Here we passed 10 as a Json Number in array.

Now lets take a look if a function call requires a some complex enum like:

#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, Debug)]
pub enum MultiAddress<AccountId, AccountIndex> {
    /// It's an account ID (pubkey).
    Id(AccountId),
    /// It's an account index.
    Index(#[codec(compact)] AccountIndex),
    /// It's some arbitrary raw bytes.
    Raw(Vec<u8>),
    /// It's a 32 byte representation.
    Address32([u8; 32]),
    /// Its a 20 byte representation.
    Address20([u8; 20]),
}

we need to pass Id variant of this enum now this variant takes a parameter which is AccountId type. Type of AccountId is

type AccountId = AccountId32;

where AccountId32 is a struct with 32 byte vector.

#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, Debug)]
pub struct AccountId32(pub [u8; 32]);

So we need to pass AccountId32 as a parameter. We can pass it as [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] which is a 32 byte array. and complete enum param will look like this

{
    "params": [
        ["Id", [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
    ]
}

Similarly if we want to pass a Struct in parameters then we pass it as array of values as well. let's say we have a struct:

struct TestStruct {
    a: u32,
    b: u32,
    c: u32,
}

and we want to pass TestStruct { a: 1, b: 2, c: 3 } as parameter then we pass [1, 2, 3] as parameter array. So passing those both as a paramter list should look like this

{
    "method": "pallet_name-storage_name-query_type",
    "params": [
        ["A", ""], //representing TestEnum::A
        [1, 2, 3] //representing TestStruct { a: 1, b: 2, c: 3 }
    ]
}

Other primitive types are passed as they are. e.g.

{
    "method": "pallet_name-storage_name-query_type",
    "params": [
        1,          //representing u32
        "test",     //representing String
        false,      //representing bool
    ]
}