Struct TransactionSubmitter 

pub struct TransactionSubmitter {
    pub(crate) event_bus: Arc<dyn EventBusTrait>,
    pub(crate) tx_relayer: Arc<dyn TxRelayerTrait>,
    pub(crate) exchange_address: Address,
    pub(crate) db: Option<Arc<dyn AsyncDirectiveOutboxWriter>>,
    pub(crate) submitter_store: Option<Arc<dyn AsyncTransactionSubmitterStore>>,
    pub(crate) nonce_lock: Arc<Mutex<()>>,
}

Delivers signed directive requests to chain and publishes delivery status.

Signer-specific crates own key custody and signer construction. This type owns the operational path around those signers: encode, submit, reconcile, publish status, and persist outbox delivery updates.

Fields

event_bus: Arc<dyn EventBusTrait>

tx_relayer: Arc<dyn TxRelayerTrait>

exchange_address: Address

db: Option<Arc<dyn AsyncDirectiveOutboxWriter>>

Optional direct DB handle for outbox delivery status updates.

This keeps direct-submission deployments from relying only on the in-process event bus to record terminal delivery state.

submitter_store: Option<Arc<dyn AsyncTransactionSubmitterStore>>

Optional submitter-owned persistence for submissions and replacement attempts.

nonce_lock: Arc<Mutex<()>>

Serializes nonce allocation and the first submit attempt for this submitter instance.

This mirrors the Sanguine submitter invariant: no later request may observe or allocate around a nonce while an earlier request is still in the undecided window between nonce selection and durable submitter state.

Implementations

impl TransactionSubmitter

pub async fn new_direct( event_bus: Arc<dyn EventBusTrait>, config: &TransactionSubmitterConfig, exchange_contract_address: &str, secrets: &TransactionSubmitterSecrets, ) -> EyreResult<Self>

Creates TransactionSubmitter with direct RPC submission using the configured signer key.

pub async fn new_aws_kms( event_bus: Arc<dyn EventBusTrait>, config: &TransactionSubmitterConfig, exchange_contract_address: &str, ) -> EyreResult<Self>

Creates TransactionSubmitter with direct RPC submission using AWS KMS.

pub fn new_mock( event_bus: Arc<dyn EventBusTrait>, exchange_contract_address: &str, ) -> EyreResult<Self>

Creates TransactionSubmitter with no-op mock for local tests and disabled delivery.

pub fn with_db(self, db: Arc<dyn AsyncDirectiveOutboxWriter>) -> Self

Attach a database handler for direct outbox persistence. When set, outbox updates are written to Postgres directly, independent of the event bus consumer.

pub fn with_submitter_store( self, submitter_store: Arc<dyn AsyncTransactionSubmitterStore>, ) -> Self

pub fn start(self: Arc<Self>) -> Result<JoinHandle<()>, String>

Start the transaction submission service (legacy, no shutdown support). For graceful shutdown support, use start_with_shutdown.

pub fn start_with_shutdown( self: Arc<Self>, shutdown_rx: Receiver<()>, ) -> Result<JoinHandle<()>, String>

Start the transaction submission service with shutdown support.

Returns a JoinHandle for integration with TaskGroup for coordinated shutdown.

pub(crate) async fn spawn_persisted_pending_submissions(&self)

pub(crate) async fn process_transaction_request( &self, tx_req: TransactionRequest, )

Process a single transaction request

pub(crate) async fn handle_signed_directive( &self, request_id: &str, account_contract: &WalletAddress, directive: &SignedDirectiveTx, encoder: fn(Address, Bytes, Bytes, Option<String>) -> Result<ContractCall>, log_label: &str, )

Orchestrate signed directive submission with status updates.

pub(crate) async fn submit_signed_directive( &self, request_id: &str, signed_directive: &SignedDirectiveTx, encoder: fn(Address, Bytes, Bytes, Option<String>) -> Result<ContractCall>, log_label: &str, ) -> Result<SubmittedTransaction, RelayDirectiveError>

Build a submitter-owned contract call from SignedDirectiveTx and submit it.

pub(crate) async fn submit_contract_call( &self, request_id: &str, contract_call: ContractCall, ) -> EyreResult<SubmittedTransaction>

pub(crate) async fn send_update( &self, request_id: &str, status: TransactionStatus, tx_hash: Option<String>, error: Option<String>, )

Send transaction status update

pub(crate) async fn persist_outbox_update( &self, request_id: &str, status: TransactionStatus, tx_hash: Option<String>, error_msg: Option<String>, )

Persist outbox delivery status directly through the DB writer interface.

pub(crate) async fn persist_outbox_update_with_db( db: Arc<dyn AsyncDirectiveOutboxWriter>, request_id: String, status: TransactionStatus, tx_hash: Option<String>, error_msg: Option<String>, )

pub(crate) async fn persist_created_submitter_submission( &self, submitter: SubmitterId, nonce: SubmittedNonce, ) -> EyreResult<()>

pub(crate) async fn persist_submitter_submission_with_db( submitter_store: Arc<dyn AsyncTransactionSubmitterStore>, record: SubmissionRecord, attempts: Vec<SubmissionAttemptRecord>, ) -> EyreResult<()>

pub(crate) async fn persist_submitter_status_with_db( submitter_store: Arc<dyn AsyncTransactionSubmitterStore>, submitter: SubmitterId, nonce: SubmittedNonce, status: SubmissionStatus, primary_tx_hash: Option<String>, terminal_error: Option<String>, )

pub(crate) async fn persist_directive_submitter_pointer( &self, request_id: &str, submitter: SubmitterId, nonce: SubmittedNonce, ) -> EyreResult<()>

pub(crate) async fn persist_directive_submitter_pointer_with_db( db: Arc<dyn AsyncDirectiveOutboxWriter>, request_id: String, submitter: SubmitterId, nonce: SubmittedNonce, ) -> EyreResult<()>

pub(crate) fn spawn_pending_reconciliation( &self, request_id: String, submitter: SubmitterId, nonce: SubmittedNonce, tx_hashes: Vec<String>, )

pub(crate) fn spawn_pending_submitter_reconciliation( &self, submitter: SubmitterId, nonce: SubmittedNonce, tx_hashes: Vec<String>, )