author_submitAndWatchExtrinsic

Submit a signed extrinsic to and subscribe to status updates. This WebSocket method provides real-time feedback on transaction progress from submission through finalization.

Use Cases

• Transaction tracking - Monitor extrinsic lifecycle for decentralized AI inference, subnet-specific AI models, TAO staking, and cross-subnet AI collaboration
• UI feedback - Show users real-time transaction status
• Confirmation workflows - Wait for specific finality level before proceeding

Parameters

Parameter	Type	Required	Description
extrinsic	Bytes	Yes	SCALE-encoded signed extrinsic

Returns

Returns a subscription that emits ExtrinsicStatus updates:

Status	Description
future	In future queue (nonce too high)
ready	In ready queue, waiting for block
broadcast	Broadcast to peers
inBlock	Included in block (hash provided)
retracted	Block retracted (reorg)
finalityTimeout	Finality timeout
finalized	Finalized in block (hash provided)
usurped	Replaced by another extrinsic
dropped	Dropped from pool
invalid	Invalid extrinsic

Code Examples

JavaScript

import { ApiPromise, WsProvider, Keyring } from '@polkadot/api';

const provider = new WsProvider('wss://api-bittensor-mainnet.n.dwellir.com/YOUR_API_KEY');
const api = await ApiPromise.create({ provider });
const keyring = new Keyring({ type: 'sr25519' });

// Create and sign a transfer
const sender = keyring.addFromUri('//Alice');
const transfer = api.tx.balances.transferKeepAlive(
  '5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty',
  1000000000000n
);

// Submit and watch
const unsub = await transfer.signAndSend(sender, ({ status, events }) => {
  console.log(`Status: ${status.type}`);

  if (status.isInBlock) {
    console.log(`Included in block: ${status.asInBlock.toHex()}`);
  }

  if (status.isFinalized) {
    console.log(`Finalized in block: ${status.asFinalized.toHex()}`);
    unsub();
  }
});

Python

import asyncio
import websockets
import json

async def submit_and_watch(signed_extrinsic_hex):
    uri = 'wss://api-bittensor-mainnet.n.dwellir.com/YOUR_API_KEY'

    async with websockets.connect(uri) as ws:
        # Submit and subscribe
        await ws.send(json.dumps({
            'jsonrpc': '2.0',
            'method': 'author_submitAndWatchExtrinsic',
            'params': [signed_extrinsic_hex],
            'id': 1
        }))

        # Get subscription ID
        response = json.loads(await ws.recv())
        if 'error' in response:
            print(f"Error: {response['error']}")
            return

        sub_id = response['result']
        print(f'Watching with subscription: {sub_id}')

        # Listen for status updates
        while True:
            message = json.loads(await ws.recv())
            if 'params' in message:
                status = message['params']['result']
                print(f"Status: {status}")

                # Check for finalization
                if isinstance(status, dict) and 'finalized' in status:
                    print(f"Finalized in: {status['finalized']}")
                    break

# asyncio.run(submit_and_watch('0x...'))

Status Flow

ready → broadcast → inBlock → finalized
                  ↘ retracted (if reorg)

Related Methods

• author_submitExtrinsic - Submit without watching (fire-and-forget)
• author_pendingExtrinsics - View transaction pool
• payment_queryInfo - Estimate fees before submission