Struct RenegadeClient 

pub struct RenegadeClient {
    pub config: RenegadeClientConfig,
    pub secrets: AccountSecrets,
    pub relayer_client: RelayerHttpClient,
    pub admin_relayer_client: Option<RelayerHttpClient>,
    pub historical_state_client: Arc<RelayerHttpClient>,
    pub websocket_client: RenegadeWebsocketClient,
}

The Renegade wallet client

Fields

config: RenegadeClientConfig

The client config

secrets: AccountSecrets

The account secrets

relayer_client: RelayerHttpClient

The relayer HTTP client

admin_relayer_client: Option<RelayerHttpClient>

The admin relayer HTTP client

historical_state_client: Arc<RelayerHttpClient>

The historical state HTTP client.

Also a RelayerHttpClient as it mirrors the relayer’s historical state API.

websocket_client: RenegadeWebsocketClient

The websocket client

Implementations

impl RenegadeClient

pub async fn admin_assign_order_to_pool( &self, _order_id: Uuid, _matching_pool: String, ) -> Result<(), RenegadeClientError>

Assigns an order to a specific matching pool via the admin API.

This is an admin action that requires the client to be configured with an admin HMAC key.

impl RenegadeClient

pub async fn admin_create_matching_pool( &self, matching_pool: String, ) -> Result<(), RenegadeClientError>

Creates a new matching pool via the admin API.

Orders can only be matched with other orders in the same matching pool. If the specified matching pool already exists, this is a no-op.

This is an admin action that requires the client to be configured with an admin HMAC key.

impl RenegadeClient

pub async fn admin_get_account_orders( &self, account_id: Uuid, ) -> Result<Vec<ApiAdminOrder>, RenegadeClientError>

Fetches all orders for the given account (admin).

This method will paginate through all of the account’s orders across multiple requests, returning them all.

impl RenegadeClient

pub async fn admin_get_open_orders( &self, ) -> Result<Vec<ApiAdminOrder>, RenegadeClientError>

Fetches all open orders managed by the relayer.

This method will paginate through all of the orders across multiple requests, returning them all.

pub async fn admin_get_open_orders_in_matching_pool( &self, matching_pool: String, ) -> Result<Vec<ApiAdminOrder>, RenegadeClientError>

Fetches all open orders managed by the relayer in the given matching pool.

This method will paginate through all of the orders across multiple requests, returning them all.

impl RenegadeClient

pub async fn admin_get_order( &self, order_id: Uuid, ) -> Result<ApiAdminOrder, RenegadeClientError>

Look up an order by its ID

impl RenegadeClient

pub async fn admin_is_task_queue_paused( &self, account_id: Uuid, ) -> Result<bool, RenegadeClientError>

Check if the given account’s task queue is paused

impl RenegadeClient

pub fn new_admin_order_builder(&self) -> AdminOrderBuilder

Create a new admin order builder with the client’s account address as the owner

pub async fn admin_place_order_in_pool( &self, built_order: BuiltAdminOrder, ) -> Result<(), RenegadeClientError>

Places an order in a specific matching pool via the admin API. Waits for the order creation task to complete before returning.

This is an admin action that requires the client to be configured with an admin HMAC key.

pub async fn enqueue_admin_order_placement_in_pool( &self, built_order: BuiltAdminOrder, ) -> Result<TaskWaiter, RenegadeClientError>

Enqueues an order placement task in a specific matching pool via the admin API. Returns the expected order to be created, and a TaskWaiter that can be used to await task completion.

This is an admin action that requires the client to be configured with an admin HMAC key.

impl RenegadeClient

pub fn build_erc20_approval_tx( &self, token: Address, amount: U256, ) -> TransactionRequest

Build a transaction to approve the Permit2 contract as a spender for the given ERC20 token.

Arguments

• token - The ERC20 token address to approve
• amount - The amount to approve for spending

Returns

A TransactionRequest that can be executed by the user with their provider

pub fn build_permit2_allowance_tx( &self, token: Address, amount: U160, expiration: U48, ) -> TransactionRequest

Build a transaction to approve the darkpool as a spender through Permit2’s AllowanceTransfer interface.

Arguments

• token - The ERC20 token address to approve
• amount - The amount to approve for spending (uint160)
• expiration - The Unix timestamp when this approval expires (uint48)

Returns

A TransactionRequest that can be executed by the user with their provider

impl RenegadeClient

pub async fn cancel_order( &self, order_id: Uuid, ) -> Result<(), RenegadeClientError>

Cancels the order with the given ID. Waits for the order cancellation task to complete before returning.

pub async fn enqueue_order_cancellation( &self, order_id: Uuid, ) -> Result<TaskWaiter, RenegadeClientError>

Enqueues an order cancellation task in the relayer. Returns a TaskWaiter that can be used to await task completion.

impl RenegadeClient

pub async fn create_account(&self) -> Result<(), RenegadeClientError>

Create an account with the relayer.

This method will register the account credentials with the relayer, but will not yet result in any state being committed onchain in the darkpool.

impl RenegadeClient

pub async fn deposit( &self, mint: Address, amount: Amount, ) -> Result<(), RenegadeClientError>

Deposit funds into an account balance. Waits for the deposit task to complete before returning the post-deposit balance.

pub async fn enqueue_deposit( &self, mint: Address, amount: Amount, ) -> Result<TaskWaiter, RenegadeClientError>

Enqueues a deposit task in the relayer. Returns the post-deposit balance, and a TaskWaiter that can be used to await task completion.

impl RenegadeClient

pub async fn get_account(&self) -> Result<ApiAccount, RenegadeClientError>

Look up an account by its ID

Returns the account’s orders and balances

impl RenegadeClient

pub async fn get_account_seeds( &self, ) -> Result<(PoseidonCSPRNG, PoseidonCSPRNG), RenegadeClientError>

Get an account’s seed CSPRNG states from the relayer. These are the CSPRNGs used to sample seeds with which to create new state objects.

Returns a tuple of (recovery stream seeds CSPRNG, share stream seeds CSPRNG)

impl RenegadeClient

pub async fn get_balance_by_mint( &self, mint: Address, ) -> Result<ApiBalance, RenegadeClientError>

Get the account’s balance for a given mint

impl RenegadeClient

pub async fn get_balances(&self) -> Result<Vec<ApiBalance>, RenegadeClientError>

Fetches all balances in the account.

impl RenegadeClient

pub async fn get_order( &self, order_id: Uuid, ) -> Result<ApiOrder, RenegadeClientError>

Look up an order by its ID

impl RenegadeClient

pub async fn get_orders( &self, include_historic_orders: bool, ) -> Result<Vec<ApiOrder>, RenegadeClientError>

Fetches all orders in the account, optionally including historic (inactive) orders.

This method will paginate through all of the account’s orders across multiple requests, returning them all.

impl RenegadeClient

pub async fn get_task( &self, task_id: Uuid, ) -> Result<ApiTask, RenegadeClientError>

Look up a task by its ID

impl RenegadeClient

pub async fn get_tasks( &self, include_historic_tasks: bool, ) -> Result<Vec<ApiTask>, RenegadeClientError>

Fetches all tasks in the account, optionally including historic tasks.

This method will paginate through all of the account’s tasks across multiple requests, returning them all.

impl RenegadeClient

pub fn new_order_builder(&self) -> OrderBuilder

Create a new order builder with the client’s account address as the owner

pub async fn place_order( &self, built_order: BuiltOrder, ) -> Result<(), RenegadeClientError>

Places an order via the relayer. Waits for the order creation task to complete before returning the created order.

Orders will only be committed to onchain state upon their first fill. As such, this method alone just registers this order as an intent to trade with the relayer.

pub async fn enqueue_order_placement( &self, built_order: BuiltOrder, ) -> Result<TaskWaiter, RenegadeClientError>

Enqueues an order placement task in the relayer. Returns the expected order to be created, and a TaskWaiter that can be used to await task completion.

Orders will only be committed to onchain state upon their first fill. As such, this method alone just registers this order as an intent to trade with the relayer.

impl RenegadeClient

pub async fn sync_account(&self) -> Result<(), RenegadeClientError>

Sync an account with onchain state. Awaits the completion of the sync task before returning.

pub async fn enqueue_sync_account( &self, ) -> Result<TaskWaiter, RenegadeClientError>

Enqueues a sync task in the relayer. Returns a TaskWaiter that can be used to await task completion.

impl RenegadeClient

pub async fn update_order( &self, order_update_config: OrderUpdateConfig, ) -> Result<ApiOrder, RenegadeClientError>

Updates an order.

Currently, the only parameters which can updated are the order’s min_fill_size, and whether to allow_external_matches.

impl RenegadeClient

pub async fn withdraw( &self, mint: Address, amount: Amount, ) -> Result<(), RenegadeClientError>

Withdraw funds from an account balance. Waits for the withdrawal task to complete before returning.

pub async fn enqueue_withdrawal( &self, mint: Address, amount: Amount, ) -> Result<TaskWaiter, RenegadeClientError>

Enqueues a withdrawal task in the relayer. Returns a TaskWaiter that can be used to await task completion.

impl RenegadeClient

pub fn new(config: RenegadeClientConfig) -> Result<Self, RenegadeClientError>

Derive the wallet secrets from an ethereum private key

pub fn new_arbitrum_sepolia( key: &PrivateKeySigner, ) -> Result<Self, RenegadeClientError>

Create a new wallet on Arbitrum Sepolia

pub fn new_arbitrum_sepolia_admin( key: &PrivateKeySigner, admin_hmac_key: HmacKey, ) -> Result<Self, RenegadeClientError>

Create a new admin wallet on Arbitrum Sepolia

pub fn new_arbitrum_one( key: &PrivateKeySigner, ) -> Result<Self, RenegadeClientError>

Create a new wallet on Arbitrum One

pub fn new_arbitrum_one_admin( key: &PrivateKeySigner, admin_hmac_key: HmacKey, ) -> Result<Self, RenegadeClientError>

Create a new admin wallet on Arbitrum One

pub fn new_base_sepolia( key: &PrivateKeySigner, ) -> Result<Self, RenegadeClientError>

Create a new wallet on Base Sepolia

pub fn new_base_sepolia_admin( key: &PrivateKeySigner, admin_hmac_key: HmacKey, ) -> Result<Self, RenegadeClientError>

Create a new admin wallet on Base Sepolia

pub fn new_base_mainnet( key: &PrivateKeySigner, ) -> Result<Self, RenegadeClientError>

Create a new wallet on Base Mainnet

pub fn new_ethereum_sepolia_admin( key: &PrivateKeySigner, admin_hmac_key: HmacKey, ) -> Result<Self, RenegadeClientError>

Create a new admin wallet on Ethereum Sepolia

pub fn new_ethereum_sepolia( key: &PrivateKeySigner, ) -> Result<Self, RenegadeClientError>

Create a new admin wallet on Ethereum Sepolia

pub fn new_base_mainnet_admin( key: &PrivateKeySigner, admin_hmac_key: HmacKey, ) -> Result<Self, RenegadeClientError>

Create a new admin wallet on Base Mainnet

pub fn is_solidity_chain(&self) -> bool

Whether the client is on a chain in which Renegade is deployed as a solidity contract

pub async fn watch_task( &self, task_id: Uuid, timeout: Duration, ) -> Result<TaskWaiter, RenegadeClientError>

Create a TaskWaiter which can be used to watch a task until it completes or times out

pub async fn subscribe_task_updates( &self, ) -> Result<impl Stream<Item = TaskUpdateMessage>, RenegadeClientError>

Subscribe to the account’s task updates stream

pub async fn subscribe_balance_updates( &self, ) -> Result<impl Stream<Item = BalanceUpdateMessage>, RenegadeClientError>

Subscribe to the account’s balance updates stream

pub async fn subscribe_order_updates( &self, ) -> Result<impl Stream<Item = OrderUpdateMessage>, RenegadeClientError>

Subscribe to the account’s order updates stream

pub async fn subscribe_fills( &self, ) -> Result<impl Stream<Item = FillMessage>, RenegadeClientError>

Subscribe to the account’s fills stream

pub async fn subscribe_admin_balance_updates( &self, ) -> Result<impl Stream<Item = AdminBalanceUpdateMessage>, RenegadeClientError>

Subscribe to the admin balances updates stream

pub async fn subscribe_admin_order_updates( &self, ) -> Result<impl Stream<Item = AdminOrderUpdateMessage>, RenegadeClientError>

Subscribe to the admin order updates stream

pub fn get_admin_client( &self, ) -> Result<&RelayerHttpClient, RenegadeClientError>

Get a reference to the admin relayer client, returning an error if one has not been configured.

pub fn get_account_id(&self) -> Uuid

Get the ID of the account

pub fn get_master_view_seed(&self) -> Scalar

Get the master view seed

pub fn get_auth_hmac_key(&self) -> HmacKey

Get the HMAC key used to authenticate account API actions

pub fn get_account_signer(&self) -> &PrivateKeySigner

Get the signing key client is configured with

pub fn get_account_address(&self) -> Address

Get the address of the account associated with the private key the client is configured with

pub fn schnorr_sign<T: BaseType>( &self, message: &T, ) -> Result<SchnorrSignature, RenegadeClientError>

Get the Schnorr private key client is configured with

pub fn get_schnorr_public_key(&self) -> SchnorrPublicKey

Get the public key associated with the Schnorr private key the client is configured with

pub fn get_executor_address(&self) -> Address

Get the relayer’s executor address, which it uses to sign public order settlement obligations

pub fn get_relayer_fee_recipient(&self) -> Address

Get the relayer’s fee recipient address

pub fn get_chain_id(&self) -> u64

Get the chain ID the client is configured for

pub fn get_permit2_address(&self) -> Address

Get the permit2 address the client is configured for

pub fn get_darkpool_address(&self) -> Address

Get the darkpool address the client is configured for

Trait Implementations

impl Clone for RenegadeClient

fn clone(&self) -> RenegadeClient

Returns a duplicate of the value.

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

Performs copy-assignment from source.