Struct TransactionManager 

pub struct TransactionManager { /* private fields */ }

Transaction manager responsible for wallet, sequence tracking, and transaction building.

This is the single source of truth for:

• Wallet and signing operations
• Sequence numbers (ensuring concurrent order operations don’t race)
• Authenticator resolution for permissioned key trading

Thread Safety

All methods are safe to call from multiple tasks concurrently. Sequence allocation uses atomic compare-exchange operations for lock-free performance.

Implementations

impl TransactionManager

pub fn new( grpc_client: DydxGrpcClient, private_key: &str, wallet_address: String, chain_id: ChainId, ) -> Result<Self, DydxError>

Creates a new transaction manager.

Creates wallet from private key internally. The sequence number is initialized to SEQUENCE_UNINITIALIZED and will be fetched from chain on first use, or can be proactively initialized by calling Self::initialize_sequence.

Errors

Returns error if wallet creation from private key fails.

pub async fn initialize_sequence(&self) -> Result<u64, DydxError>

Proactively initializes the sequence number from chain.

Call this during connect() to ensure orders can be submitted immediately without first-transaction latency penalty. Also catches auth errors early.

Returns the initialized sequence number.

Errors

Returns error if chain query fails.

pub async fn resolve_authenticators(&self) -> Result<(), DydxError>

Resolves authenticator IDs if using permissioned keys (API wallet).

Compares the wallet’s signing address with the main account address. If they differ, fetches authenticators from chain and finds the one matching this wallet’s public key.

Call this during connect() after creating the TransactionManager.

Errors

Returns error if:

• Using permissioned key but no authenticators found for main account
• No authenticator matches the wallet’s public key
• gRPC query fails

Panics

Panics if the internal RwLock is poisoned.

pub async fn allocate_sequence(&self) -> Result<u64, DydxError>

Allocates the next sequence number atomically.

If the sequence is uninitialized (0), fetches from chain first. Uses compare-exchange for lock-free concurrent access.

Errors

Returns error if chain query fails during initialization.

pub async fn allocate_sequences( &self, count: usize, ) -> Result<Vec<u64>, DydxError>

Allocates N sequence numbers for optimistic parallel broadcast.

Returns a vector of consecutive sequences that can be used concurrently. The caller is responsible for handling partial failures by resyncing.

Arguments

• count - Number of sequences to allocate

Errors

Returns error if chain query fails during initialization.

Example

let sequences = tx_manager.allocate_sequences(3).await?;
// sequences = [10, 11, 12] - three consecutive sequence numbers

pub async fn resync_sequence(&self) -> Result<(), DydxError>

Resyncs the sequence counter from chain after a mismatch error.

Called by the broadcaster’s retry logic when a sequence mismatch is detected. Unconditionally stores the chain’s current sequence.

Errors

Returns error if chain query fails.

pub fn current_sequence(&self) -> u64

Returns the current sequence value without allocation.

Useful for logging and debugging. Returns SEQUENCE_UNINITIALIZED if not yet initialized.

pub async fn get_cached_sequence(&self) -> Result<u64, DydxError>

Returns the cached sequence for short-term orders without incrementing.

Errors

Returns error if chain query fails during initialization.

pub async fn build_transaction( &self, msgs: Vec<Any>, sequence: u64, operation: &str, ) -> Result<PreparedTransaction, DydxError>

Builds and signs a transaction with the given messages and sequence.

Uses cached account_number (fetched once from chain) to avoid repeated queries.

Arguments

• msgs - Proto messages to include in transaction
• sequence - Pre-allocated sequence number
• operation - Human-readable name for logging

Errors

Returns error if account lookup fails or transaction building fails.

Panics

Panics if the internal RwLock is poisoned.

pub async fn prepare_transaction( &self, msgs: Vec<Any>, operation: &str, ) -> Result<PreparedTransaction, DydxError>

Convenience method: allocate sequence, build, and return prepared transaction.

This is the typical flow for single transaction submission.

Arguments

• msgs - Proto messages to include in transaction
• operation - Human-readable name for logging

Errors

Returns error if sequence allocation or transaction building fails.

pub fn wallet_address(&self) -> &str

Returns the wallet address.

pub fn chain_id(&self) -> &ChainId

Returns the chain ID.

Trait Implementations

impl Debug for TransactionManager

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.