Send a Transaction While Paying the Fee with a Different Token¶

1. Create a new directory and initialize the project:

   mkdir fee-payment-tutorial && cd fee-payment-tutorial
   

2. Initialize the project:

   npm init -y
   

3. Install dev dependencies:

   npm install --save-dev @types/node@^22.12.0 ts-node@^10.9.2 typescript@^5.7.3
   

4. Install dependencies:

   npm install --save @polkadot-labs/hdkd@0.0.26 @polkadot-labs/hdkd-helpers@0.0.27 polkadot-api@1.23.3
   

5. Create TypeScript configuration:

   npx tsc --init && npm pkg set type=module
   

6. Generate Polkadot API types for Polkadot Hub:

   npx papi add assetHub -n polkadot_asset_hub
   

7. Create a new file called fee-payment-transaction.ts:

   touch fee-payment-transaction.ts
   

1. Create a new directory and initialize the project:

   mkdir fee-payment-tutorial && cd fee-payment-tutorial
   

2. Initialize the project:

   npm init -y && npm pkg set type=module
   

3. Install dependencies:

   npm install @polkadot/api@16.5.4
   

4. Create a new file called fee-payment-transaction.js:

   touch fee-payment-transaction.js
   

1. Create a new Rust project:

   cargo new subxt-fee-payment-example && cd subxt-fee-payment-example
   

2. Install the Subxt CLI to download chain metadata:

   cargo install subxt-cli@0.44.2
   

3. Download Polkadot Hub metadata from the local Chopsticks fork:

   mkdir metadata && \
   subxt metadata --url ws://localhost:8000 -o metadata/asset_hub.scale
   

   Note

   Ensure your Chopsticks fork is running at ws://localhost:8000 before downloading the metadata.

4. Update Cargo.toml with the required dependencies:

   Cargo.toml

   [package]
   name = "subxt-fee-payment-example"
   version = "0.1.0"
   edition = "2021"
   
   [[bin]]
   name = "fee_payment_transaction"
   path = "src/bin/fee_payment_transaction.rs"
   
   [dependencies]
   codec = { package = "parity-scale-codec", version = "3", features = ["derive"] }
   subxt = { version = "0.44.2", features = ["jsonrpsee", "native"] }
   subxt-signer = { version = "0.44.2", features = ["sr25519"] }
   tokio = { version = "1.44.2", features = ["macros", "rt-multi-thread"] }
   

5. Create the source file:

   mkdir -p src/bin && touch src/bin/fee_payment_transaction.rs
   

In Subxt, you first generate types from the chain metadata using the #[subxt::subxt()] macro. The derive_for_type attribute ensures the Location type implements the traits needed for encoding. You also define a custom AssetHubConfig where type AssetId = Location, which enables specifying an XCM location as the fee payment asset:

use std::str::FromStr;
use subxt::config::{Config, DefaultExtrinsicParams, DefaultExtrinsicParamsBuilder, PolkadotConfig};
use subxt::utils::AccountId32;
use subxt::{OnlineClient, SubstrateConfig};

// Generate types from the Polkadot Hub metadata with Location trait derives
#[subxt::subxt(
    runtime_metadata_path = "metadata/asset_hub.scale",
    derive_for_type(
        path = "staging_xcm::v5::location::Location",
        derive = "Clone, Eq, PartialEq, codec::Encode",
        recursive
    )
)]
pub mod asset_hub {}

// Import XCM location types from the generated metadata module
use asset_hub::runtime_types::staging_xcm::v5::{
    junction::Junction,
    junctions::Junctions,
    location::Location,
};

// Define a custom config where AssetId is an XCM Location
pub enum AssetHubConfig {}

impl Config for AssetHubConfig {
    type AccountId = <PolkadotConfig as Config>::AccountId;
    type Address = <PolkadotConfig as Config>::Address;
    type Signature = <PolkadotConfig as Config>::Signature;
    type Hasher = <PolkadotConfig as Config>::Hasher;
    type Header = <SubstrateConfig as Config>::Header;
    type ExtrinsicParams = DefaultExtrinsicParams<AssetHubConfig>;
    type AssetId = Location;
}

const POLKADOT_HUB_RPC: &str = "ws://localhost:8000";
const TARGET_ADDRESS: &str = "14E5nqKAp3oAJcmzgZhUD2RcptBeUBScxKHgJKU4HPNcKVf3";
const TRANSFER_AMOUNT: u128 = 3_000_000_000; // 3 DOT
const USDT_ASSET_ID: u128 = 1984;

The cryptoWaitReady() call ensures the underlying WASM cryptographic libraries are initialized before creating the keyring:

async function main() {
  // Wait for crypto libraries to be ready
  await cryptoWaitReady();

  // Create a keyring instance and add Alice's account
  const keyring = new Keyring({ type: 'sr25519' });
  const alice = keyring.addFromUri('//Alice');

  // Connect to the local Chopsticks Polkadot Hub fork
  const wsProvider = new WsProvider('ws://localhost:8000');
  const api = await ApiPromise.create({ provider: wsProvider });
  console.log('Connected to Polkadot Hub (Chopsticks fork)');

Notice that the OnlineClient is parameterized with AssetHubConfig instead of the default PolkadotConfig:

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Connect to the local Chopsticks Polkadot Hub fork
    let api = OnlineClient::<AssetHubConfig>::from_url(POLKADOT_HUB_RPC).await?;
    println!("Connected to Polkadot Hub (Chopsticks fork)");

    // Create Alice's dev keypair
    let alice = subxt_signer::sr25519::dev::alice();
    println!("Sender (Alice): {}", AccountId32::from(alice.public_key()));

In PAPI, you specify the alternative asset through the asset parameter in the signAndSubmit options:

const signer = await createSigner();

const result = await tx.signAndSubmit(signer, {
  asset: {
    parents: 0,
    interior: {
      type: "X2",
      value: [
        { type: "PalletInstance", value: 50 },
        { type: "GeneralIndex", value: BigInt(USDT_ASSET_ID) },
      ],
    },
  },
});

const { txHash, ok, block, events } = result;
console.log(`Tx finalized: ${txHash} (ok=${ok})`);
console.log(`Block: #${block.number} ${block.hash} [tx index ${block.index}]`);

console.log("Events:");
for (const ev of events) {
  const type = (ev as any).type ?? "unknown";
  console.log(`- ${type}`);
}

process.exit(0);

In Polkadot.js, you define the asset as an XCM multi-location object and pass it as the assetId option to signAndSend:

// Define the USDT asset as an XCM multi-location for fee payment
const assetId = {
  parents: 0,
  interior: {
    X2: [{ PalletInstance: 50 }, { GeneralIndex: USDT_ASSET_ID }],
  },
};

// Sign and send the transaction, paying fees with USDT
console.log('Signing and submitting transaction...');
await new Promise((resolve, reject) => {
  let unsubscribe;
  tx
    .signAndSend(
      alice,
      { assetId },
      ({ status, events, txHash, dispatchError }) => {
        if (status.isFinalized) {
          console.log(
            `\nTransaction finalized in block: ${status.asFinalized.toHex()}`
          );
          console.log(`Transaction hash: ${txHash.toHex()}`);

          // Display all events
          console.log('\nEvents:');
          events.forEach(({ event }) => {
            console.log(`  ${event.section}.${event.method}`);
          });

          if (unsubscribe) {
            unsubscribe();
          }

          if (dispatchError) {
            if (dispatchError.isModule) {
              const decoded = api.registry.findMetaError(
                dispatchError.asModule
              );
              const { docs, name, section } = decoded;
              reject(new Error(`${section}.${name}: ${docs.join(' ')}`));
            } else {
              reject(new Error(dispatchError.toString()));
            }
          } else {
            resolve();
          }
        }
      }
    )
    .then((unsub) => {
      unsubscribe = unsub;
    })
    .catch((error) => {
      if (unsubscribe) {
        unsubscribe();
      }
      reject(error);
    });
});

In Subxt, you use DefaultExtrinsicParamsBuilder with tip_of(0, asset_location) to specify the fee asset. The first argument is the tip amount (0), and the second is the XCM Location. Instead of calling sign_and_submit_then_watch_default, you pass the custom tx_params to sign_and_submit_then_watch:

// Define the USDT asset location in XCM format
let asset_location = Location {
    parents: 0,
    interior: Junctions::X2([
        Junction::PalletInstance(50),
        Junction::GeneralIndex(USDT_ASSET_ID),
    ]),
};

// Build transaction params to pay fees with the alternative asset
let tx_params = DefaultExtrinsicParamsBuilder::<AssetHubConfig>::new()
    .tip_of(0, asset_location)
    .build();

// Sign, submit, and watch for finalization
println!("Signing and submitting transaction...");
let progress = api
    .tx()
    .sign_and_submit_then_watch(&tx, &alice, tx_params)
    .await?;

let in_block = progress.wait_for_finalized().await?;
let block_hash = in_block.block_hash();
let events = in_block.wait_for_success().await?;

Connected to Polkadot Hub (Chopsticks fork)
Signing and submitting transaction...

Transaction finalized in block: 0x1f4849218bb4c04564a6c6f69c9e40a3940dcdabdc089da01bb49fb471a2c049 Transaction hash: 0x9c967bb79fd09579f5e530a0446ce0171efe9241ba5957d6bcba80bccd5f66da

Events: assets.Withdrawn balances.Withdraw assets.Deposited assetConversion.SwapCreditExecuted balances.Upgraded system.NewAccount balances.Endowed balances.Transfer balances.Deposit assetTxPayment.AssetTxFeePaid system.ExtrinsicSuccess