Struct SubmittableTransaction 

pub struct SubmittableTransaction {
    pub call: ExtrinsicCall,
    /* private fields */
}

Builder that keeps an encoded call together with the client connection and exposes helpers for signing, submitting, and querying execution costs.

Fields

call: ExtrinsicCall

Implementations

impl SubmittableTransaction

pub fn new(client: Client, call: ExtrinsicCall) -> Self

Creates a transaction builder from an encoded call.

The builder is inert until one of the async helpers is invoked. By default it inherits the client’s retry policy, but this can be customised via set_retry_on_error.

pub async fn sign_and_submit( &self, signer: &Keypair, options: Options, ) -> Result<SubmittedTransaction, Error>

Signs the call with the provided keypair and submits it to the chain in a single RPC round-trip.

Returns

• Ok(SubmittedTransaction) when the node accepts the extrinsic and returns its hash along with metadata inferred from options.
• Err(Error) when signing fails, submission is rejected by the node, or any underlying RPC call (potentially retried according to the configured policy) returns an error.

The submission uses options (nonce, tip, mortality) exactly as provided; no additional mutation happens inside this helper.

pub async fn sign( &self, signer: &Keypair, options: Options, ) -> Result<GenericExtrinsic<'_>, Error>

Signs the call without submitting it, returning the encoded extrinsic bytes that would be sent to the network.

Returns

• Ok(GenericExtrinsic<'_>) containing the SCALE-encoded payload ready for submission.
• Err(Error) when the signing operation fails (for example, due to a bad signer, stale account information, or RPC issues while fetching metadata).

pub async fn estimate_call_fees( &self, at: Option<H256>, ) -> Result<FeeDetails, RpcError>

Estimates fee details for the underlying call using runtime information at at without signing or submitting anything.

Returns

• Ok(FeeDetails) containing the partial fee breakdown the runtime reports for the call.
• Err(RpcError) if the node rejects the dry-run query (e.g. bad call data, missing runtime exposes) or if transport errors occur.

pub async fn estimate_extrinsic_fees( &self, signer: &Keypair, options: Options, at: Option<H256>, ) -> Result<FeeDetails, Error>

Signs the call with the provided options and queries the chain for the cost of submitting that exact extrinsic.

Returns

• Ok(FeeDetails) containing the fee components returned by the runtime.
• Err(Error) if signing the call fails or if the fee query returns an error (in which case the underlying RpcError is wrapped in the returned Error).

pub async fn call_info( &self, at: Option<H256>, ) -> Result<RuntimeDispatchInfo, RpcError>

Returns runtime dispatch information for the call, including weight, class, and partial fee estimation based on the provided block context.

Returns

• Ok(RuntimeDispatchInfo) with weight and class metadata.
• Err(RpcError) if the node cannot evaluate the call (bad parameters, runtime error, or RPC transport failure).

pub fn should_retry_on_error(&self) -> bool

Resolves whether RPC calls performed through this builder should be retried on transient failures.

The method returns the explicit override set by set_retry_on_error, falling back to the client’s global retry configuration when no override is present.

pub fn set_retry_on_error(&mut self, value: Option<bool>)

Controls retry behaviour for RPC calls sent via this builder.

Parameters

• Some(true): force retries regardless of the client’s global setting.
• Some(false): disable retries for requests issued through this builder.
• None: fall back to the client’s global retry configuration.

pub fn from_encodable<T: HasHeader + Encode>( client: Client, value: T, ) -> SubmittableTransaction

Converts any encodable call into a SubmittableTransaction based on its pallet and call indices. The provided value is SCALE-encoded immediately; failures propagate as panics originating from the underlying encoding implementation.

pub fn call_hash(&self) -> [u8; 32]

Hashes the call payload as it would appear in an extrinsic, returning the blake2 hash used by the runtime for call identification.

Trait Implementations

impl Clone for SubmittableTransaction

fn clone(&self) -> SubmittableTransaction

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl From<&SubmittableTransaction> for ExtrinsicCall

fn from(value: &SubmittableTransaction) -> Self

Converts to this type from the input type.

impl From<SubmittableTransaction> for ExtrinsicCall

fn from(value: SubmittableTransaction) -> Self

Converts to this type from the input type.