Struct RelayClient 

pub struct RelayClient { /* private fields */ }

Client for interacting with the Polymarket Builder Relayer.

Implementations

impl RelayClient

pub async fn new( chain_id: u64, signer: LocalWallet, auth: AuthMethod, tx_type: RelayerTxType, ) -> Result<Self>

Create a new RelayClient.

Arguments

• chain_id - Chain ID (137 for Polygon mainnet)
• signer - Ethers LocalWallet for signing transactions
• auth - Authentication method (Builder or RelayerKey)
• tx_type - Wallet type (Safe or Proxy)

pub fn set_url(&mut self, url: String)

Set a custom relayer URL.

pub fn set_rpc_url(&mut self, url: String)

Set an RPC URL for reading the Safe nonce on-chain.

Highly recommended — the relayer API /nonce endpoint can return stale values (e.g., 0), causing GS026 “Invalid owner” errors because the EIP-712 hash is computed with the wrong nonce.

When set, get_nonce() reads the nonce directly from the Safe contract on-chain, falling back to the relayer API only on failure.

pub fn signer_address(&self) -> Address

Get the signer’s EOA address.

pub fn wallet_address(&self) -> Result<Address>

Get the derived wallet address (Safe, Proxy, or EOA).

pub async fn is_deployed(&self) -> Result<bool>

Check if the Safe wallet is deployed.

pub async fn get_nonce(&self) -> Result<u64>

Get the current nonce for the wallet.

For Safe wallets: reads from on-chain nonce() if rpc_url is set, otherwise falls back to the relayer API. The relayer API is known to return stale nonces (e.g., 0) which causes GS026 errors.

pub async fn get_transaction(&self, tx_id: &str) -> Result<TxResult>

Get a transaction’s status by ID.

pub async fn deploy(&self) -> Result<TxResult>

Deploy a Safe wallet (one-time, Safe wallet type only).

pub async fn execute( &self, txs: Vec<Transaction>, description: &str, ) -> Result<TransactionResponseHandle>

Execute one or more transactions through the relayer.

pub async fn execute_sequential( &self, batches: Vec<Vec<Transaction>>, delay: Option<Duration>, on_progress: Option<&dyn Fn(usize, usize)>, ) -> Result<Vec<TxResult>>

Execute multiple groups of transactions sequentially, waiting for each to confirm before submitting the next.

This avoids nonce collisions when the relay bot (Gelato) cannot handle back-to-back requests for the same proxy wallet.

Arguments

• batches - Each inner Vec<Transaction> is submitted as one relay request.
• delay - Wait time between confirmed batches (default 5s if None).
• on_progress - Optional callback (completed, total) after each batch confirms.

Returns a vec of TxResult, one per batch (in order).

pub async fn execute_batch( &self, txs: Vec<Transaction>, description: &str, ) -> Result<TxResult>

Execute multiple transactions as a single batched relay request.

All transactions share one nonce and one relay call, completely avoiding nonce collisions. More gas-efficient than sequential execution.

For Proxy wallets, the gas limit scales with the number of transactions: gas_limit = 150_000 + (extra_txs * 80_000), capped at 400_000.

For Safe wallets, multiple transactions are packed via multiSend (already handled by build_safe_request).

pub async fn approve_usdc_for_ctf(&self) -> Result<TransactionResponseHandle>

Approve USDC.e for CTF Exchange.

pub async fn approve_usdc_for_negrisk( &self, ) -> Result<TransactionResponseHandle>

Approve USDC.e for Neg Risk CTF Exchange.

pub async fn approve_ctf_for_exchange( &self, ) -> Result<TransactionResponseHandle>

Approve CTF tokens (ERC1155) for CTF Exchange.

pub async fn setup_approvals(&self) -> Result<TransactionResponseHandle>

Set up all standard approvals in a single batch.

pub fn derive_deposit_wallet_address(&self) -> Result<Address>

Predict the V2 Deposit Wallet address for the current signer EOA.

Pure CREATE2 derivation — does not query the relayer.

pub async fn deploy_deposit_wallet(&self) -> Result<TxResult>

Deploy a Deposit Wallet via the relayer (gasless, type WALLET-CREATE).

Idempotent on the relayer side: a second call for an already-deployed wallet typically returns Invalid. Use is_deposit_wallet_deployed to gate the call.

pub async fn is_deposit_wallet_deployed(&self) -> Result<bool>

Check whether a Deposit Wallet is already deployed at the derived address, using GET /deployed?address=...&type=WALLET.

pub async fn get_deposit_wallet_nonce(&self) -> Result<u64>

Fetch the Deposit Wallet nonce from the relayer (GET /nonce?type=WALLET).

pub async fn execute_deposit_wallet_batch( &self, calls: Vec<DepositWalletCall>, deposit_wallet_addr: Option<Address>, deadline: u64, metadata: Option<&str>, ) -> Result<TransactionResponseHandle>

Execute a batch of calls through the user’s Deposit Wallet (V2 flow).

Mirrors the TypeScript SDK’s executeDepositWalletBatch:

1. Read the WALLET nonce from /nonce?type=WALLET.
2. EIP-712-sign the Batch{wallet, nonce, deadline, calls[]} struct.
3. POST /submit with type: "WALLET" and depositWalletParams.

The Deposit Wallet must already be deployed (see deploy_deposit_wallet). If deposit_wallet is None the address is derived from the signer.

deadline is a unix timestamp (seconds) after which the batch is invalid. The TS examples typically use now + 4 minutes.

pub async fn setup_approvals_v2(&self) -> Result<TransactionResponseHandle>

Set up all V2 approvals (pUSD + adapters + V2 exchanges) in one batch.

After the V2 migration (2026-04-28) the user-facing collateral is pUSD, so trading and split/merge require fresh approvals against the new contracts. Includes:

• pUSD → V2 CTF Exchange / V2 Neg Risk Exchange (for orderbook trades)
• pUSD → CtfCollateralAdapter / NegRiskCtfCollateralAdapter (for split)
• CTF (ERC-1155) → V2 exchanges + both collateral adapters (for trades / merge)
• CTF (ERC-1155) → NegRiskAdapter (for neg-risk redeem; unchanged from V1)

Note: for Proxy wallets, this is 9 inner calls and will exceed the relayer’s per-tx gas budget — call the individual approvals one by one or use execute_sequential instead. Safe wallets pack these via MultiSend and submit them as one transaction without issue.

Trait Implementations

impl Clone for RelayClient

fn clone(&self) -> RelayClient

Returns a duplicate of the value.

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

Performs copy-assignment from source.