Struct FyndClient 

pub struct FyndClient<P = RootProvider<Ethereum>>
where
    P: Provider<Ethereum> + Clone + Send + Sync + 'static,
{ /* private fields */ }

The main entry point for interacting with the Fynd DEX router.

Construct via FyndClientBuilder. All methods are async and require a Tokio runtime.

The type parameter P is the alloy provider used for Ethereum RPC calls. In production code this is RootProvider<Ethereum> (the default). In tests a mocked provider can be used.

Implementations

impl<P> FyndClient<P>

where P: Provider<Ethereum> + Clone + Send + Sync + 'static,

pub async fn quote(&self, params: QuoteParams) -> Result<Quote, FyndError>

Request a quote for one or more swap orders.

The returned Quote has token_out and receiver populated on each OrderQuote from the corresponding input Order (matched by index).

Retries automatically on transient failures according to the client’s RetryConfig.

pub async fn health(&self) -> Result<HealthStatus, FyndError>

Get the health status of the Fynd RPC server.

pub async fn swap_payload( &self, quote: Quote, hints: &SigningHints, ) -> Result<SwapPayload, FyndError>

Build a swap payload for a given order quote, ready for signing.

For BackendKind::Fynd quotes, this resolves the sender nonce and EIP-1559 fee parameters from the RPC node (unless overridden via hints), then constructs an unsigned EIP-1559 transaction targeting the RouterV3 contract.

BackendKind::Turbine is not yet implemented and returns FyndError::Protocol.

token_out and receiver are read directly from the quote (populated during quote()). Pass &SigningHints::default() to auto-resolve all transaction parameters.

pub async fn execute_swap( &self, order: SignedSwap, options: &ExecutionOptions, ) -> Result<ExecutionReceipt, FyndError>

Broadcast a signed swap and return an ExecutionReceipt that resolves once the transaction is mined.

Pass ExecutionOptions::default for standard on-chain submission. Set ExecutionOptions::dry_run to true to simulate only — the receipt resolves immediately with values derived from eth_call (settled amount) and eth_estimateGas (gas cost).

For real submissions, this method returns immediately after broadcasting. The inner future polls every 2 seconds and has no built-in timeout; wrap with tokio::time::timeout to bound the wait.

pub async fn info(&self) -> Result<&InstanceInfo, FyndError>

Fetch and cache static instance metadata from GET /v1/info.

The result is fetched at most once per FyndClient instance; subsequent calls return the cached value without making a network request.

pub async fn approval( &self, params: &ApprovalParams, hints: &SigningHints, ) -> Result<Option<ApprovalPayload>, FyndError>

Build an unsigned EIP-1559 approve(spender, amount) transaction for the given token, or None if the allowance is already sufficient.

1. Calls info() to resolve the spender address from params.spender.
2. If params.check_allowance is true, checks the current ERC-20 allowance and returns None immediately if it is already sufficient (skipping nonce and fee resolution).
3. Resolves nonce and EIP-1559 fees via hints (same semantics as swap_payload).
4. Encodes the approve(spender, amount) calldata using the ERC-20 ABI.

Gas defaults to hints.gas_limit().unwrap_or(65_000).

pub async fn execute_approval( &self, approval: SignedApproval, ) -> Result<TxReceipt, FyndError>

Broadcast a signed approval transaction and return a TxReceipt that resolves once the transaction is mined.

This method returns immediately after broadcasting. The inner future polls every 2 seconds and has no built-in timeout; wrap with tokio::time::timeout to bound the wait.