bittensor.core.extrinsics.utils

bittensor.core.extrinsics.utils#

Module with helper functions for extrinsics.

Attributes#

MEV_HOTKEY_USAGE_WARNING

Functions#

apply_pure_proxy_data(response, triggered_events, ...)

Apply pure proxy data to the response object.

compute_coldkey_hash(keypair)

Computes BlakeTwo256 hash of a coldkey AccountId.

get_event_data_by_event_name(events, event_name)

Extracts event data from triggered events by event ID.

get_mev_shielded_ciphertext(signed_ext, ...)

Encrypts a signed extrinsic for MEV Shield submission.

get_old_stakes(wallet, hotkey_ss58s, netuids, all_stakes)

Retrieve the previous staking balances for a wallet's hotkeys across given netuids.

get_transfer_fn_params(amount, destination_ss58, ...)

Helper function to get the transfer call function and call params, depending on the value and keep_alive flag

resolve_mev_shield_period(period)

Return effective era period for MEV Shield extrinsics.

sudo_call_extrinsic(subtensor, wallet, call_function, ...)

Execute a sudo call extrinsic.

verify_coldkey_hash(keypair, expected_hash)

Verifies that a coldkey SS58 address matches the expected BlakeTwo256 hash.

Module Contents#

bittensor.core.extrinsics.utils.MEV_HOTKEY_USAGE_WARNING = 'MeV Shield cannot be used with hotkey-signed extrinsics. The transaction will fail because the...#
bittensor.core.extrinsics.utils.apply_pure_proxy_data(response, triggered_events, block_number, extrinsic_idx, raise_error)#

Apply pure proxy data to the response object.

Parameters:

  • response (bittensor.core.types.ExtrinsicResponse) – The response object to update.

  • triggered_events (list) – The triggered events of the transaction.

  • block_number (int) – The block number of the transaction.

  • extrinsic_idx (int) – The index of the extrinsic in the transaction.

  • raise_error (bool) – Whether to raise an error if the data cannot be applied successfully.

Returns:

True if the data was applied successfully, False otherwise.

Return type:

bittensor.core.types.ExtrinsicResponse

bittensor.core.extrinsics.utils.compute_coldkey_hash(keypair)#

Computes BlakeTwo256 hash of a coldkey AccountId.

This function extracts the AccountId (32-byte public key) from an SS58 address and computes its BlakeTwo256 hash. The hash is used in coldkey swap announcements to verify the new coldkey address when executing the swap.

Parameters:

keypair (bittensor_wallet.Keypair) – keypair for getting hash.

Returns:

Hex string with 0x prefix representing the BlakeTwo256 hash of the AccountId.

Return type:

str

Notes

bittensor.core.extrinsics.utils.get_event_data_by_event_name(events, event_name)#

Extracts event data from triggered events by event ID.

Searches through a list of triggered events and returns the attributes dictionary for the first event matching the specified event_id.

Parameters:

  • events (list) – List of event dictionaries, typically from ExtrinsicReceipt.triggered_events. Each event should have an “module_id”. “event_id” key and an “attributes” key.

  • event_name (str) – The events identifier to search for (e.g. “mevShield.EncryptedSubmitted”, etc).

Returns:

The attributes dictionary of the matching event, or None if no matching event is found.

Return type:

Optional[dict]

bittensor.core.extrinsics.utils.get_mev_shielded_ciphertext(signed_ext, ml_kem_768_public_key)#

Encrypts a signed extrinsic for MEV Shield submission.

This function extracts the raw extrinsic bytes and encrypts them using ML-KEM-768 + XChaCha20Poly1305 with the twox_128 key hash prepended for on-chain validation.

Parameters:

  • signed_ext (scalecodec.types.GenericExtrinsic) – The signed GenericExtrinsic object representing the inner call to be encrypted and executed.

  • ml_kem_768_public_key (bytes) – The ML-KEM-768 public key bytes (1184 bytes) from NextKey storage.

Returns:

[key_hash(16)][u16 kem_len LE][kem_ct][nonce24][aead_ct]

Return type:

The encrypted ciphertext bytes in wire format

bittensor.core.extrinsics.utils.get_old_stakes(wallet, hotkey_ss58s, netuids, all_stakes)#

Retrieve the previous staking balances for a wallet’s hotkeys across given netuids.

This function searches through the provided staking data to find the stake amounts for the specified hotkeys and netuids associated with the wallet’s coldkey. If no match is found for a particular hotkey and netuid combination, a default balance of zero is returned.

Parameters:

  • wallet (bittensor_wallet.Wallet) – The wallet containing the coldkey to compare with stake data.

  • hotkey_ss58s (list[str]) – List of hotkey SS58 addresses for which stakes are retrieved.

  • netuids (list[int]) – List of network unique identifiers (netuids) corresponding to the hotkeys.

  • all_stakes (list[bittensor.core.chain_data.StakeInfo]) – A collection of all staking information to search through.

Returns:

A list of Balances, each representing the stake for a given hotkey and netuid.

Return type:

list[bittensor.utils.balance.Balance]

bittensor.core.extrinsics.utils.get_transfer_fn_params(amount, destination_ss58, keep_alive)#

Helper function to get the transfer call function and call params, depending on the value and keep_alive flag provided.

Parameters:

  • amount (Optional[bittensor.utils.balance.Balance]) – the amount of Tao to transfer. None if transferring all.

  • destination_ss58 (str) – the destination SS58 of the transfer

  • keep_alive (bool) – whether to enforce a retention of the existential deposit in the account after transfer.

Returns:

tuple[call function, call params]

Return type:

tuple[str, dict[str, Union[str, int, bool]]]

bittensor.core.extrinsics.utils.resolve_mev_shield_period(period)#

Return effective era period for MEV Shield extrinsics.

MEV Shield extrinsics must use a short-lived era. If period is omitted or exceeds the MEV limit, the maximum allowed MEV period is applied.

Parameters:

period (Optional[int]) – The period to resolve.

Returns:

The effective period (in blocks).

Return type:

int

bittensor.core.extrinsics.utils.sudo_call_extrinsic(subtensor, wallet, call_function, call_params, call_module='AdminUtils', sign_with='coldkey', use_nonce=False, nonce_key='hotkey', *, period=None, raise_error=False, wait_for_inclusion=True, wait_for_finalization=True, root_call=False)#

Execute a sudo call extrinsic.

Parameters:

  • subtensor (bittensor.core.subtensor.Subtensor) – The Subtensor instance.

  • wallet (bittensor_wallet.Wallet) – The wallet instance.

  • call_function (str) – The call function to execute.

  • call_params (dict) – The call parameters.

  • call_module (str) – The call module.

  • sign_with (str) – The keypair to sign the extrinsic with.

  • use_nonce (bool) – Whether to use a nonce.

  • nonce_key (str) – The key to use for the nonce.

  • period (Optional[int]) – The number of blocks during which the transaction will remain valid after it’s submitted. If the transaction is not included in a block within that number of blocks, it will expire and be rejected. You can think of it as an expiration date for the transaction.

  • raise_error (bool) – Raises a relevant exception rather than returning False if unsuccessful.

  • wait_for_inclusion (bool) – Whether to wait for the inclusion of the transaction.

  • wait_for_finalization (bool) – Whether to wait for the finalization of the transaction.

  • root_call (bool) – False, if the subnet owner makes a call.

Returns:

The result object of the extrinsic execution.

Return type:

ExtrinsicResponse

bittensor.core.extrinsics.utils.verify_coldkey_hash(keypair, expected_hash)#

Verifies that a coldkey SS58 address matches the expected BlakeTwo256 hash.

This function computes the hash of the coldkey AccountId and compares it with the expected hash. Used to verify that the new coldkey address in a swap announcement matches the announced hash.

Parameters:

  • keypair (bittensor_wallet.Keypair) – keypair whose hash needs to be verified.

  • expected_hash (str) – Expected BlakeTwo256 hash (hex string with 0x prefix).

Returns:

True if the computed hash matches the expected hash, False otherwise.

Return type:

bool

Notes