Decoding Polkadot/Kusama transactions in Rust

Question

I would like to inspect transactions (extrinsics) in a given block to potentially:

• Find different types of transactions and their parameters
• Look through all transactions included in the block and act on them based on type, sender etc.

So far I am able to query the block using subtx and see all transactions in raw form. I do not know how can I decode them to Rust types and act on them:

#[subxt::subxt(runtime_metadata_path = "../specs/kusama.spec.scale")]
pub mod kusama_client {}

...

    let api = OnlineClient::<PolkadotConfig>::from_url(rpc_url)
        .await.unwrap();

    let block = api.rpc().block(None).await.unwrap().unwrap();

    for tx in block.block.extrinsics {
        println!("tx: {:?}", tx);

        // TODO: Decode transactions and act on them based on types etc...
        // ex. ImOnline etc...
    }

I know that the transactions are SCALE encoded, but I do not know what to decode them to Rust types, I do not even know what Rust types to use (I assume those generated from metadata, but how do I find appropriate type to decode to?).

I would also like to do the similar thing with other construct such as offences:

   let offences_addr = kusama_client::storage().offences().reports_by_kind_index(offence_kind);

    let offences = api
        .storage()
        .at(None)
        .await.unwrap()
        .fetch(&offences_addr)
        .await.unwrap()
        .unwrap();

     // TODO: decode and inspect offences

I would appreciate any pointers in the right direction, or examples if such exists.

Answer 1

Also, Subxt doesn't currently have a means to decode transactions, but you can obtain the bytes for each transaction back currently eg:

let extrinsics = api.blocks().at(hash).await?.body().await?.extrinsics();
for ext in extrinsics {
    let bytes = ext.bytes();
    // decode bytes
}

I've updated https://github.com/paritytech/subxt/issues/622 to go into more detail about what sort of interface Subxt could add here to this ext value.

While Subxt doesn't support it at the moment, you can manually look into how to decode the extrinsic bytes. Some pointers for this:

• Start by reading about the extrinsic format (eg see https://docs.substrate.io/reference/transaction-format/ or look at how Subxt encodes them starting at https://github.com/paritytech/subxt/blob/a69b3e45e71b5f6c3fd4aeeb7a38353f989ad9ea/subxt/src/tx/tx_client.rs#L197)
• Once you've learned about the format of the extrinsic signature, you'll see that "extra" params are encoded as part of it. If you look into the node metadata you'll see that each "extra" param has a type ID assocaietd with it here, which describes the shape of it: https://github.com/paritytech/frame-metadata/blob/438a5b098bb9d5b5a09bdc5b68275b2c5e63a010/frame-metadata/src/v14.rs#L117
• You can use scale-decode to decode types from bytes based on their metadata description: https://github.com/paritytech/scale-decode/blob/9164b12da2949f74eef5c6f02ed4fe82a9dc9907/scale-decode/src/lib.rs#L177. scale-decode also provides a generic Value type that anything can decode into, and a Visitor thing that you can use to skip over bytes you just want to ignore, given the type ID that they should decode to.
• With all of that in mind, you can decode or skip over the signature portion of an extrinsic and are left with the pallet index, call index and then call data. You can look the call type up in the metadata given these indexes, and again get a type Id that you can pass to scale-decode to decode the call data into some type (either one of the statically generated types in Subxt or a Value type).

.. You can see why it's something that we should add to Subxt in any case, as there are a number of steps to it :)

Answer 2

Subxt currently exposes only the bytes of the extrinsic to users. We plan on adding support for decoding to a concrete type generated by the subxt macro.

In the meanwhile, polkadot-introspector here is decoding manually the extrinsics.

For example, polkadot-introspector is interested only in finding the ParaInherent event.

Steps to decode the ParaInherent events:

1. Obtain the extrinsic data (example)

Extrinsics are encoded in memory as:

• Compact u32: Length of the extrinsic
• first byte: abbbbbbb (a = 0 for unsigned, 1 for signed, b = version)
• signature
• extrinsic data

Note: this makes the assumption that the ParaInherent is unsigned, please adjust this per your needs.

2. Decode the extrinsic date to RuntimeCall generated by subxt macro (may be similar to kusama_client::runtime_types::kusama_runtime::RuntimeCall for your use case)
3. Match and inspect data (ie ParaInherent data - similar to here)

Answer 3

For anyone that stumbles upon this now, it has been implemented in subtx since posting the question in https://github.com/paritytech/subxt/pull/929.

Example code:

use subxt::OnlineClient;
use subxt::PolkadotConfig;

#[tokio::main]
async fn main() {
    let rpc_url = "wss://kusama-rpc.polkadot.io:443/";

    let api = OnlineClient::<PolkadotConfig>::from_url(rpc_url)
        .await.unwrap();
    let block = api.blocks().at_latest().await.unwrap();

    for extrinsic in block.body().await.unwrap().extrinsics().iter() {
        let extrinsic = extrinsic.expect("error getting extrinsic");
        println!("Extrinsic {}::{}", extrinsic.pallet_name().unwrap(), extrinsic.variant_name().unwrap());
        // Do whatever you want with the extrinsic...
    }
}

Tested with subxt version ^0.31.

Answer 4

You can decode extrinsic's and parse blocks with Libuptest: https://uptest-sc.github.io/code/decode.html