@provablehq/aleo-bridge-sdk 0.1.0

package/dist/createBridgeClient-DzmEyXfG.d.ts

@@ -0,0 +1,1058 @@
+import { WalletClient, TransactionInput, ProvingProgressHandler, Transaction, Client } from '@provablehq/veil-core';
+import { a as BridgeReceipt, c as BridgePlan, n as BridgeEndpoint, S as SolanaClient, P as PrepareParameters, q as BridgeFee, e as SolanaHyperlaneTransferQuote, d as BridgeCheckpoint, g as SolanaHyperlaneTransferExecution, b as BridgeProgress, w as BridgeStatus, B as BridgeRegistry, h as BridgeEnvironment } from './solana-D5Qr6SLa.js';
+import { Address, Hex, Hash, LocalAccount, PublicClient, WalletClient as WalletClient$1 } from 'viem';
+
+/**
+ * Supplies a fetch-compatible HTTP response for Circle attestation requests.
+ *
+ * @property ok Whether the response status is successful.
+ * @property status Numeric HTTP status used to distinguish pending attestations.
+ * @property json Parses the response body as JSON.
+ */
+type XReserveHttpResponse = {
+    ok: boolean;
+    status: number;
+    json: () => Promise<unknown>;
+};
+/** Sends an HTTP request without coupling the bridge client to a runtime global. */
+type XReserveHttpTransport = (url: string, init?: {
+    signal?: AbortSignal;
+}) => Promise<XReserveHttpResponse>;
+/**
+ * Captures reviewed Ethereum-to-Aleo xReserve deployment values.
+ *
+ * @property xReserveContract Ethereum contract receiving deposits.
+ * @property sourceChainId Expected EIP-155 wallet chain id.
+ * @property sourceDomain Circle domain included in the deposit nonce.
+ * @property remoteDomain Aleo Circle domain passed to `depositToRemote`.
+ * @property remoteTokenBytes32 Aleo USDCx token identifier in Circle wire form.
+ * @property minimumAmountAtomic Smallest supported deposit in USDC base units.
+ * @property maxFeeAtomic Maximum Circle fee in USDC base units.
+ * @property bridgeProgram Aleo program handling public and record mints.
+ * @property wrapperProgram Aleo program handling private wrapper mints.
+ * @property attestationBaseUrl Circle endpoint prefix for individual message hashes.
+ */
+type EvmXReserveRouteMetadata = {
+    xReserveContract: Address;
+    sourceChainId: number;
+    sourceDomain: number;
+    remoteDomain: number;
+    remoteTokenBytes32: Hex;
+    minimumAmountAtomic: bigint;
+    maxFeeAtomic: bigint;
+    bridgeProgram: string;
+    wrapperProgram: string;
+    attestationBaseUrl: string;
+};
+/**
+ * Supplies an Ethereum-to-Aleo xReserve transfer for current balance and allowance checks.
+ *
+ * @property plan Route, amount, Aleo recipient, and privacy preference selected for the transfer.
+ * @property privateMintSecretNonce Secret Aleo scalar committed by private hook data. Defaults to `0scalar`.
+ */
+type QuoteEvmXReserveTransferParameters = {
+    plan: BridgePlan;
+    privateMintSecretNonce?: string | undefined;
+};
+/**
+ * Captures atomic values and allowance state required by an xReserve deposit.
+ *
+ * @property routeId Reviewed route used for the quote.
+ * @property xReserveContract Contract receiving the deposit.
+ * @property tokenAddress USDC contract approved and deposited.
+ * @property sourceChainId Expected EIP-155 wallet chain id.
+ * @property remoteDomain Aleo Circle domain supplied to the contract.
+ * @property remoteRecipientBytes32 User or wrapper address in wire form.
+ * @property amountAtomic Deposit amount in USDC base units.
+ * @property maxFeeAtomic Maximum Circle fee in USDC base units.
+ * @property hookData Fixed 65-byte Aleo mint instruction.
+ * @property balanceAtomic Connected account balance in USDC base units.
+ * @property allowanceAtomic Current xReserve allowance in USDC base units.
+ * @property approvalRequired Whether execution must submit an approval first.
+ */
+type EvmXReserveTransferQuote = {
+    routeId: string;
+    xReserveContract: Address;
+    tokenAddress: Address;
+    sourceChainId: number;
+    remoteDomain: number;
+    remoteRecipientBytes32: Hex;
+    amountAtomic: bigint;
+    maxFeeAtomic: bigint;
+    hookData: Hex;
+    balanceAtomic: bigint;
+    allowanceAtomic: bigint;
+    approvalRequired: boolean;
+};
+/**
+ * Configures an Ethereum-to-Aleo xReserve deposit submission.
+ *
+ * @property plan Route, amount, Aleo recipient, and privacy preference selected for the transfer.
+ * @property privateMintSecretNonce Secret Aleo scalar committed by private hook data. Defaults to `0scalar`.
+ * @property pollingIntervalMs Delay between receipt checks. Defaults to 1,000 milliseconds.
+ * @property confirmationTimeoutMs Maximum receipt wait per transaction. Defaults to 120,000 milliseconds.
+ * @property resume Previously checkpointed source receipt. When supplied, execution
+ *   verifies that transaction and never repeats its submission.
+ * @property onSubmitted Durable checkpoint hook called immediately after an approval
+ *   or deposit is broadcast and before receipt polling begins.
+ */
+type ExecuteEvmXReserveTransferParameters = {
+    plan: BridgePlan;
+    privateMintSecretNonce?: string | undefined;
+    pollingIntervalMs?: number | undefined;
+    confirmationTimeoutMs?: number | undefined;
+    resume?: BridgeReceipt | undefined;
+    onSubmitted?: ((receipt: BridgeReceipt) => void | Promise<void>) | undefined;
+};
+/**
+ * Captures wallet transactions and resumable xReserve progress after execution.
+ *
+ * @property receipt Protocol-neutral status plus Circle payload identifiers.
+ * @property approvalTxIds ERC-20 approvals submitted before the deposit.
+ */
+type EvmXReserveTransferExecution = {
+    receipt: BridgeReceipt;
+    approvalTxIds: Hash[];
+};
+/**
+ * Selects a Circle attestation by its 32-byte message hash.
+ *
+ * @property routeId Route supplying the environment-specific Circle endpoint.
+ * @property messageHash Keccak-256 hash returned by deposit execution.
+ * @property signal Optional cancellation signal. Defaults to no cancellation.
+ */
+type GetXReserveAttestationParameters = {
+    routeId: string;
+    messageHash: Hash;
+    signal?: AbortSignal | undefined;
+};
+/** Reports whether Circle has produced the signature for an xReserve message. */
+type XReserveAttestationResult = {
+    status: 'pending';
+    messageHash: Hash;
+} | {
+    status: 'complete';
+    messageHash: Hash;
+    payload: Hex;
+    attestation: Hex;
+};
+
+/**
+ * Submits one Aleo program execution through an application-provided wallet client.
+ *
+ * The required method is available on Veil wallet clients and connected Aleo
+ * wallet adapters.
+ *
+ * @property executeTransaction Prompts the wallet to prove, sign, and broadcast a program call.
+ */
+type AleoWalletClient = Pick<WalletClient, 'executeTransaction'>;
+/**
+ * Controls conversion of a public Aleo token balance into a private record.
+ *
+ * @property asset Aleo chain and token selected for the private conversion. The token MUST support shielding.
+ * @property amount Positive decimal amount in the asset's display units.
+ * @property recipient Optional Aleo recipient for ARC-22 assets. Defaults to the active wallet address.
+ * @property privateFee Whether the Aleo wallet pays its fee privately. Defaults to false.
+ * @property onProgress Optional awaited callback for proving and submission boundaries.
+ * @property onPrepared Optional awaited callback receiving the proved transaction before broadcast.
+ */
+type ShieldParameters = {
+    asset: BridgeEndpoint;
+    amount: string;
+    recipient?: string | undefined;
+    privateFee?: boolean | undefined;
+    onProgress?: ProvingProgressHandler | undefined;
+    onPrepared?: ((transaction: Transaction) => void | Promise<void>) | undefined;
+};
+/**
+ * Controls conversion of an Aleo private record into a public token balance.
+ *
+ * @property asset Aleo chain and token selected for the public conversion. The token MUST support unshielding.
+ * @property amount Positive decimal amount in the asset's display units.
+ * @property record Optional encoded `Token` record or wallet record request. Defaults to wallet selection by minimum amount.
+ * @property recipient Optional Aleo public recipient for ARC-22 assets. Defaults to the active wallet address.
+ * @property merkleProof Optional ARC-22 freeze-list proof literal. Defaults to the canonical empty-tree proof pair.
+ * @property privateFee Whether the Aleo wallet pays its fee privately. Defaults to false.
+ * @property onProgress Optional awaited callback for proving and submission boundaries.
+ * @property onPrepared Optional awaited callback receiving the proved transaction before broadcast.
+ */
+type UnshieldParameters = {
+    asset: BridgeEndpoint;
+    amount: string;
+    record?: TransactionInput | undefined;
+    recipient?: string | undefined;
+    merkleProof?: string | undefined;
+    privateFee?: boolean | undefined;
+    onProgress?: ProvingProgressHandler | undefined;
+    onPrepared?: ((transaction: Transaction) => void | Promise<void>) | undefined;
+};
+/**
+ * Captures a submitted Aleo public/private asset conversion.
+ *
+ * @property transactionId Aleo transaction id returned by the wallet.
+ * @property assetId Chain-scoped asset identifier converted by the transaction.
+ * @property amount Original decimal amount supplied by the caller.
+ * @property amountAtomic Exact amount submitted as a u128 atomic value.
+ */
+type AleoPrivacyExecution = {
+    transactionId: string;
+    assetId: string;
+    amount: string;
+    amountAtomic: bigint;
+};
+/**
+ * Configures submission of the user-authorized USDCx wrapper mint.
+ *
+ * @property plan Original private-mint transfer plan.
+ * @property privateMintSecretNonce Secret Aleo scalar committed by the source deposit. Defaults to `0scalar`.
+ * @property deposit Confirmed EVM deposit receipt carrying the canonical payload.
+ * @property attestation Completed Circle payload and signature response.
+ * @property privateFee Whether the Aleo wallet should pay its fee privately. Defaults to false.
+ * @property onSubmitted Durable checkpoint hook called immediately after the wallet returns a transaction id.
+ * @property onProgress Optional awaited callback for Aleo proving and submission boundaries.
+ * @property onPrepared Durable callback invoked with a fully proved transaction before network broadcast.
+ */
+type ExecuteXReservePrivateMintParameters = {
+    plan: BridgePlan;
+    privateMintSecretNonce?: string | undefined;
+    deposit: BridgeReceipt;
+    attestation: XReserveAttestationResult;
+    privateFee?: boolean | undefined;
+    onSubmitted?: ((receipt: BridgeReceipt) => void | Promise<void>) | undefined;
+    onProgress?: ProvingProgressHandler | undefined;
+    onPrepared?: ((transaction: Transaction) => void | Promise<void>) | undefined;
+};
+/**
+ * Captures the submitted wrapper transaction and resumable destination state.
+ *
+ * @property transactionId Aleo transaction id returned by the connected wallet.
+ * @property receipt Transfer state retaining source, Circle, and destination identifiers.
+ */
+type XReservePrivateMintExecution = {
+    transactionId: string;
+    receipt: BridgeReceipt;
+};
+/** Selects which deployed USDCx burn transition the Aleo wallet calls. */
+type XReserveBurnMode = 'private' | 'public' | 'public-as-signer';
+/**
+ * Describes one validated Aleo USDCx burn call without submitting it.
+ *
+ * @property routeId Aleo-to-Ethereum xReserve route used for the burn.
+ * @property mode Transition variant selected by the caller.
+ * @property program Deployed bridge or wrapper program receiving the transaction.
+ * @property function Exact burn transition invoked by the wallet.
+ * @property inputs Ordered Aleo literals and wallet record requests.
+ * @property amountAtomic Burn amount in USDCx base units.
+ * @property nativeDomain Circle Ethereum destination domain, fixed to 0.
+ * @property nativeRecipientBytes32 Ethereum recipient left-padded to 32 bytes.
+ */
+type XReserveBurnCall = {
+    routeId: string;
+    mode: XReserveBurnMode;
+    program: string;
+    function: 'burn_public_as_signer' | 'burn_public' | 'private_burn';
+    inputs: TransactionInput[];
+    amountAtomic: bigint;
+    nativeDomain: number;
+    nativeRecipientBytes32: `0x${string}`;
+};
+/**
+ * Configures an Aleo USDCx burn destined for Ethereum USDC.
+ *
+ * @property plan Aleo-to-Ethereum plan returned with the transfer quote.
+ * @property mode Burn transition to submit. Defaults to `private`.
+ * @property userRecord Wallet record request or encoded USDCx token record. Required only for `private`.
+ * @property merkleProof Encoded `[MerkleProof; 2]` Aleo literal. Required only for `private`.
+ * @property privateFee Whether the Aleo wallet should pay its fee privately. Defaults to false.
+ * @property onSubmitted Durable checkpoint hook called immediately after the wallet returns a transaction id.
+ * @property onProgress Optional awaited callback for Aleo proving and submission boundaries.
+ * @property onPrepared Durable callback invoked with a fully proved transaction before network broadcast.
+ */
+type ExecuteXReserveBurnParameters = {
+    plan: BridgePlan;
+    mode?: XReserveBurnMode | undefined;
+    userRecord?: TransactionInput | undefined;
+    merkleProof?: string | undefined;
+    privateFee?: boolean | undefined;
+    onSubmitted?: ((receipt: BridgeReceipt) => void | Promise<void>) | undefined;
+    onProgress?: ProvingProgressHandler | undefined;
+    onPrepared?: ((transaction: Transaction) => void | Promise<void>) | undefined;
+};
+/**
+ * Captures the submitted Aleo burn and the service-managed delivery state.
+ *
+ * @property transactionId Aleo transaction id returned by the connected wallet.
+ * @property receipt Transfer state retained while the Aleo attestation service forwards the burn to Circle.
+ */
+type XReserveBurnExecution = {
+    transactionId: string;
+    receipt: BridgeReceipt;
+};
+/**
+ * Configures one live Hyperlane hook gas payment quote.
+ *
+ * @property routeId Aleo-origin Hyperlane route whose destination gas is quoted.
+ */
+type QuoteAleoHyperlaneGasPaymentParameters = {
+    routeId: string;
+};
+/**
+ * Captures one live destination gas quote for an Aleo-origin Hyperlane transfer.
+ *
+ * The on-chain hook asserts that the paid amount exactly equals the quote it
+ * recomputes at finalization, so the caller should quote shortly before submission.
+ *
+ * @property routeId Route the quote applies to.
+ * @property gasLimit Destination gas limit charged by the route, after the on-chain 50000 zero-limit fallback.
+ * @property gasOverhead Destination gas overhead added by the interchain gas paymaster.
+ * @property gasPrice Destination gas price reported by the on-chain oracle.
+ * @property exchangeRate Destination-to-Aleo exchange rate reported by the on-chain oracle.
+ * @property paymentMicrocredits Exact hook payment in microcredits (u64) the transfer must allow.
+ * @property executionFeeMicrocredits Always `null`; calculating the Aleo execution fee requires building an account-authorized execution.
+ * @property totalMicrocredits Always `null` until an execution fee is available. The hook payment alone is not the sender's total cost.
+ */
+type AleoHyperlaneGasQuote = {
+    routeId: string;
+    gasLimit: bigint;
+    gasOverhead: bigint;
+    gasPrice: bigint;
+    exchangeRate: bigint;
+    paymentMicrocredits: bigint;
+    executionFeeMicrocredits: null;
+    totalMicrocredits: null;
+};
+/**
+ * Describes one locally constructed Aleo Hyperlane transfer call.
+ *
+ * @property routeId Directional Hyperlane route used to construct the call.
+ * @property program Aleo Warp Route program receiving the transaction.
+ * @property function Exact Warp Route transition invoked by the wallet.
+ * @property inputs Seven ordered Aleo literals expected by the selected transfer transition.
+ * @property amountAtomic Source amount expressed in the Aleo token's base units.
+ * @property usesPlaceholderConfiguration Whether unresolved deployment values make the call unsafe to submit.
+ * @property placeholderFields Registry fields that must be replaced before submission is enabled.
+ */
+type AleoHyperlaneTransferRemoteCall = {
+    routeId: string;
+    program: string;
+    function: 'transfer_remote' | 'transfer_remote_as_signer';
+    inputs: TransactionInput[];
+    amountAtomic: bigint;
+    usesPlaceholderConfiguration: boolean;
+    placeholderFields: readonly string[];
+};
+/**
+ * Configures construction or submission of an Aleo Hyperlane withdrawal.
+ *
+ * @property plan Aleo-origin Hyperlane plan returned with the transfer quote.
+ * @property mode Whether the program burns from `self.caller` or the EOA-bound `self.signer`. Defaults to `caller`.
+ * @property privateFee Whether the Aleo wallet should pay its fee privately. Defaults to false.
+ * @property gasPaymentMicrocredits Live hook payment in microcredits (u64) from `quote`. Optional for inspection-only call construction; required by the route-specific execution implementation.
+ * @property onSubmitted Durable checkpoint hook called immediately after the wallet
+ *   returns a transaction id.
+ * @property onProgress Optional awaited callback for Aleo proving and submission boundaries.
+ * @property onPrepared Durable callback invoked with a fully proved transaction before network broadcast.
+ */
+type ExecuteAleoHyperlaneTransferRemoteParameters = {
+    plan: BridgePlan;
+    mode?: 'caller' | 'signer' | undefined;
+    privateFee?: boolean | undefined;
+    gasPaymentMicrocredits?: bigint | undefined;
+    onSubmitted?: ((receipt: BridgeReceipt) => void | Promise<void>) | undefined;
+    onProgress?: ProvingProgressHandler | undefined;
+    onPrepared?: ((transaction: Transaction) => void | Promise<void>) | undefined;
+};
+/**
+ * Captures a submitted Aleo Hyperlane dispatch.
+ *
+ * @property transactionId Aleo transaction id returned by the connected wallet.
+ * @property receipt Resumable receipt awaiting Hyperlane delivery.
+ */
+type AleoHyperlaneTransferRemoteExecution = {
+    transactionId: string;
+    receipt: BridgeReceipt;
+};
+
+/**
+ * Configures Aleo network and optional wallet access for one named bridge chain.
+ * @property publicClient Required Veil public client used for chain reads.
+ * @property account Optional Veil-compatible wallet client used for execution.
+ */
+type AleoClientConfig = {
+    publicClient: Client;
+    account?: AleoWalletClient | undefined;
+};
+/**
+ * Holds materialized Aleo public and wallet capabilities.
+ * @property family Prevents this client from being used for an EVM or Solana route stored under the wrong chain identifier.
+ * @property publicClient Required Veil public client.
+ * @property walletClient Optional Veil-compatible execution client.
+ */
+type AleoClient = {
+    family: 'aleo';
+    publicClient: Client;
+    walletClient?: AleoWalletClient | undefined;
+};
+/**
+ * Selects the Aleo wallet that may authorize bridge and privacy transactions.
+ *
+ * The wallet retains custody of its account and proving configuration. This
+ * helper does not connect to Aleo, request approval, or move funds.
+ *
+ * @param client Veil wallet client or compatible wallet adapter supplied by the application.
+ * @returns The same wallet with only its transaction-execution capability exposed to the bridge.
+ * @example const account = aleoWallet(aleoWalletClient)
+ */
+declare function aleoWallet(client: AleoWalletClient): AleoWalletClient;
+/**
+ * Creates the Aleo client used to read bridge state and optionally authorize transactions.
+ *
+ * Construction stores the supplied clients without contacting Aleo or prompting
+ * the wallet. Read-only actions need only `publicClient`; fund-moving actions
+ * also require `account`.
+ *
+ * @param config Aleo network access and optional wallet authorization supplied by the application.
+ * @returns Aleo read and optional wallet capabilities used by bridge actions.
+ * @throws BridgeError When the public client is absent.
+ * @example const client = createAleoClient({ publicClient, account: walletClient })
+ */
+declare function createAleoClient(config: AleoClientConfig): AleoClient;
+
+/**
+ * Sends one EIP-1193-compatible request.
+ *
+ * @param args JSON-RPC method and parameters.
+ * @returns The provider's decoded JSON-RPC result.
+ */
+type EvmRequest = (args: {
+    method: string;
+    params?: readonly unknown[] | Record<string, unknown> | undefined;
+}) => Promise<unknown>;
+/**
+ * Configures Fetch API behavior for an EVM HTTP transport.
+ *
+ * @property fetch Optional Fetch API implementation used instead of the client-level transport.
+ */
+type EvmHttpOptions = {
+    fetch?: typeof globalThis.fetch | undefined;
+};
+/** Stores either an HTTP endpoint or custom EIP-1193 request function without contacting Ethereum. */
+type EvmTransport = {
+    type: 'http';
+    url: string;
+    fetch?: typeof globalThis.fetch | undefined;
+} | {
+    type: 'custom';
+    request: EvmRequest;
+};
+/** Selects whether an injected provider or application-held viem account authorizes transactions. */
+type EvmAccount = {
+    type: 'provider';
+    provider: {
+        request: EvmRequest;
+    };
+    account?: Address | undefined;
+} | {
+    type: 'local';
+    account: LocalAccount;
+};
+/**
+ * Configures EVM network and optional wallet access for one named bridge chain.
+ *
+ * @property transport Lazy public JSON-RPC transport.
+ * @property publicClient Existing viem public client used directly.
+ * @property account Injected-provider or local signing authority.
+ * @property walletClient Existing viem wallet client used directly.
+ */
+type EvmClientConfig = {
+    transport?: EvmTransport | undefined;
+    publicClient?: PublicClient | undefined;
+    account?: EvmAccount | undefined;
+    walletClient?: WalletClient$1 | undefined;
+};
+/**
+ * Describes an EVM call used by bridge protocol actions.
+ *
+ * @property to Contract address.
+ * @property data ABI-encoded calldata.
+ * @property account Optional call sender.
+ */
+type EvmCallParameters = {
+    to: Address;
+    data: Hex;
+    account?: Address | undefined;
+};
+/**
+ * Describes an EVM transaction used by bridge protocol actions.
+ *
+ * @property chainId Expected EIP-155 chain id, checked immediately before submission.
+ * @property from Optional expected sender, checked against the connected account.
+ * @property to Transaction destination.
+ * @property data ABI-encoded calldata.
+ * @property value Optional native-token value in wei.
+ */
+type EvmTransactionParameters = {
+    chainId: number;
+    from?: Address | undefined;
+    to: Address;
+    data: Hex;
+    value?: bigint | undefined;
+};
+/**
+ * Represents normalized EVM receipt fields consumed by bridge actions.
+ *
+ * @property status Viem-normalized execution result.
+ * @property transactionHash Canonical transaction hash when returned by the client.
+ * @property blockNumber Block containing the transaction when available.
+ * @property logs Receipt-log envelopes used to verify protocol events.
+ */
+type EvmReceipt = {
+    status: 'success' | 'reverted';
+    transactionHash: Hash;
+    blockNumber?: bigint | undefined;
+    logs: readonly {
+        address?: Address | undefined;
+        data: Hex;
+        topics: readonly Hex[];
+        logIndex?: number | undefined;
+    }[];
+};
+/**
+ * Represents one finalized EVM log used to recover a source bridge submission.
+ *
+ * @property address Contract that emitted the event.
+ * @property blockNumber Block containing the event.
+ * @property transactionHash Transaction that emitted the event.
+ * @property logIndex Event position used by protocols such as xReserve.
+ * @property data ABI-encoded non-indexed event values.
+ * @property topics ABI event signature and indexed values.
+ */
+type EvmLog = {
+    address: Address;
+    blockNumber: bigint;
+    transactionHash: Hash;
+    logIndex: number;
+    data: Hex;
+    topics: readonly Hex[];
+};
+/**
+ * Represents the source transaction fields needed to identify a recovered bridge submission.
+ *
+ * @property hash Canonical transaction identifier.
+ * @property blockNumber Block containing the transaction, or `null` while pending.
+ * @property from Account that authorized the transaction.
+ * @property to Destination contract, or `null` for contract creation.
+ * @property input ABI-encoded call data.
+ */
+type EvmTransaction = {
+    hash: Hash;
+    blockNumber: bigint | null;
+    from: Address;
+    to: Address | null;
+    input: Hex;
+};
+/**
+ * Selects one contract and inclusive block range for a recovery event scan.
+ *
+ * @property address Contract whose events should be returned.
+ * @property fromBlock First block included in the scan.
+ * @property toBlock Last block included in the scan. Defaults to the latest block.
+ */
+type EvmGetLogsParameters = {
+    address: Address;
+    fromBlock: bigint;
+    toBlock?: bigint | undefined;
+};
+/**
+ * Exposes account-free EVM operations used by bridge actions.
+ *
+ * @property getChainId Reads the current EIP-155 chain id.
+ * @property getBalance Reads one account's native-currency balance in atomic units.
+ * @property call Executes a read-only EVM call.
+ * @property getTransactionReceipt Reads a receipt or returns `null` while unavailable.
+ * @property getLogs Reads finalized contract events within an inclusive block range.
+ * @property getTransaction Reads a transaction or returns `null` while unavailable.
+ */
+type EvmPublicClient = {
+    getChainId: () => Promise<number>;
+    getBalance: (address: Address) => Promise<bigint>;
+    call: (params: EvmCallParameters) => Promise<Hex>;
+    getTransactionReceipt: (hash: Hash) => Promise<EvmReceipt | null>;
+    getLogs: (params: EvmGetLogsParameters) => Promise<readonly EvmLog[]>;
+    getTransaction: (hash: Hash) => Promise<EvmTransaction | null>;
+};
+/**
+ * Exposes account-authorized EVM operations used by bridge actions.
+ *
+ * @property getAddress Resolves the active account.
+ * @property sendTransaction Validates chain and sender, then signs and broadcasts.
+ */
+type EvmWalletClient = {
+    getAddress: () => Promise<Address>;
+    sendTransaction: (params: EvmTransactionParameters) => Promise<Hash>;
+};
+/**
+ * Holds materialized EVM public and wallet capabilities.
+ *
+ * @property family Prevents this client from being used for a Solana or Aleo route stored under the wrong chain identifier.
+ * @property publicClient Required read capability.
+ * @property walletClient Optional signing capability.
+ */
+type EvmClient = {
+    family: 'evm';
+    publicClient: EvmPublicClient;
+    walletClient?: EvmWalletClient | undefined;
+};
+/**
+ * Defines the EVM JSON-RPC endpoint used when a bridge action reads or submits.
+ *
+ * Creating the transport does not contact the endpoint.
+ *
+ * @param url EVM JSON-RPC endpoint contacted by the resulting client.
+ * @param options Optional Fetch API implementation. Defaults to `globalThis.fetch` when the client is created.
+ * @returns Deferred HTTP configuration accepted by `createEvmClient`.
+ * @example const transport = evmHttp('https://rpc.example')
+ */
+declare function evmHttp(url: string, options?: EvmHttpOptions): EvmTransport;
+/**
+ * Defines EVM network access through an application-supplied EIP-1193 request function.
+ *
+ * Creating the transport does not call the request function.
+ *
+ * @param request Function that sends JSON-RPC methods when a bridge action needs network access.
+ * @returns Deferred custom transport configuration accepted by `createEvmClient`.
+ * @example const transport = evmCustom(window.ethereum.request.bind(window.ethereum))
+ */
+declare function evmCustom(request: EvmRequest): EvmTransport;
+/**
+ * Selects an injected EIP-1193 wallet to authorize EVM bridge transactions.
+ *
+ * The provider retains custody of the account and controls every signature
+ * request. This helper does not connect to the wallet or request a signature.
+ *
+ * @param provider Browser or application wallet exposing an EIP-1193 `request` function.
+ * @param options Optional account that MUST authorize transactions. Defaults to the first account returned by `eth_accounts` at submission time.
+ * @returns Deferred wallet configuration accepted by `createEvmClient`.
+ * @example const account = evmProvider(window.ethereum)
+ */
+declare function evmProvider(provider: {
+    request: EvmRequest;
+}, options?: {
+    account?: Address | undefined;
+}): EvmAccount;
+/**
+ * Selects an application-held EVM private key for unattended bridge transactions.
+ *
+ * The key is converted to a viem account that signs on the caller's device or
+ * server. This helper does not contact a chain or submit a transaction; the
+ * application remains responsible for keeping the key secret.
+ *
+ * @param privateKey Secret 32-byte hexadecimal key held by the application.
+ * @returns Deferred local signing configuration accepted by `createEvmClient`.
+ * @example const account = evmPrivateKey(process.env.EVM_PRIVATE_KEY as Hex)
+ */
+declare function evmPrivateKey(privateKey: Hex): EvmAccount;
+/**
+ * Selects an existing viem local account for unattended bridge transactions.
+ *
+ * The account signs on the caller's device or server. This helper does not
+ * contact a chain, request an external wallet approval, or submit a transaction.
+ *
+ * @param account Viem account whose signer and address remain owned by the application.
+ * @returns Deferred local signing configuration accepted by `createEvmClient`.
+ * @example const account = evmLocalAccount(privateKeyToAccount(privateKey))
+ */
+declare function evmLocalAccount(account: LocalAccount): EvmAccount;
+/**
+ * Creates the EVM client used to read bridge state and optionally authorize transactions.
+ *
+ * Construction wires together existing clients or deferred transports without
+ * making an RPC request. Read-only actions need only a transport or public
+ * client; fund-moving actions also require an account or wallet client.
+ *
+ * @param config EVM network access and optional wallet authorization supplied by the application.
+ * @returns EVM read and optional wallet capabilities used by bridge actions.
+ * @throws BridgeError When multiple alternatives are supplied for one capability, no capability is supplied, or a local signer has no network access.
+ * @example const client = createEvmClient({ transport: evmHttp(rpcUrl), account: evmPrivateKey(key) })
+ */
+declare function createEvmClient(config: EvmClientConfig): EvmClient;
+
+/** Represents the EVM, Solana, or Aleo network access stored for one registry chain. */
+type BridgeChainClient = EvmClient | SolanaClient | AleoClient;
+/** Stores network and optional wallet access under the same chain identifiers used by routes. */
+type BridgeChainClients = Readonly<Record<string, BridgeChainClient>>;
+
+/** Identifies the Ethereum Hyperlane router's collateral model. */
+type EvmHyperlaneRouterType = 'native' | 'collateral';
+/**
+ * Captures the reviewed metadata required to dispatch an Ethereum Warp Route transfer.
+ *
+ * @property routerAddress Contract receiving `transferRemote`.
+ * @property sourceChainId EIP-155 chain id expected from the connected wallet.
+ * @property destinationDomain Hyperlane domain passed to `transferRemote` as a uint32.
+ * @property routerType Whether the router locks native ETH or ERC-20 collateral.
+ * @property tokenAddress ERC-20 collateral contract. Required for collateral routers.
+ * @property destinationRouter Protocol-native identifier of the enrolled Aleo router.
+ * @property mailboxAddress Ethereum Hyperlane Mailbox used by the reviewed deployment.
+ * @property interchainGasPaymaster Ethereum gas-paymaster identifier used by the reviewed deployment.
+ * @property interchainSecurityModule Route-specific ISM, or the zero address when the Mailbox default applies.
+ * @property registryCommit Hyperlane Registry commit containing the deployment snapshot.
+ * @property requiresApprovalReset Whether a non-zero ERC-20 allowance must be reset before changing it.
+ */
+type EvmHyperlaneRouteMetadata = {
+    routerAddress: Address;
+    sourceChainId: number;
+    destinationDomain: number;
+    routerType: EvmHyperlaneRouterType;
+    tokenAddress?: Address | undefined;
+    destinationRouter: string;
+    mailboxAddress: Address;
+    interchainGasPaymaster: Address;
+    interchainSecurityModule: Address;
+    registryCommit: string;
+    requiresApprovalReset?: boolean | undefined;
+};
+/**
+ * Supplies an Ethereum-to-Aleo Hyperlane transfer for current fee calculation.
+ *
+ * @property plan Route, assets, amount, and recipient selected for the transfer.
+ * @property recipientBytes32 Aleo recipient in the exact 32-byte encoding expected by the enrolled Warp Route.
+ */
+type QuoteEvmHyperlaneTransferParameters = {
+    plan: BridgePlan;
+    recipientBytes32: Hex;
+};
+/**
+ * Captures the atomic values required by an Ethereum Warp Route transaction.
+ *
+ * @property routeId Route whose deployment and amount were quoted.
+ * @property routerAddress Contract that supplied the quote.
+ * @property sourceChainId EIP-155 chain id on which submission must occur.
+ * @property destinationDomain Hyperlane destination domain supplied to the router.
+ * @property recipientBytes32 Wire-format destination recipient.
+ * @property amountAtomic Asset amount passed to `transferRemote`.
+ * @property nativeValueAtomic Total `msg.value` required by the router.
+ * @property nativeFeeAtomic Native fee above the bridged amount for native routes, or the full native fee for collateral routes.
+ * @property tokenAmountAtomic ERC-20 amount requiring allowance for collateral routes.
+ * @property tokenAddress ERC-20 collateral contract for collateral routes.
+ */
+type EvmHyperlaneTransferQuote = {
+    routeId: string;
+    routerAddress: Address;
+    sourceChainId: number;
+    destinationDomain: number;
+    recipientBytes32: Hex;
+    amountAtomic: bigint;
+    nativeValueAtomic: bigint;
+    nativeFeeAtomic: bigint;
+    tokenAmountAtomic?: bigint | undefined;
+    tokenAddress?: Address | undefined;
+};
+/**
+ * Configures an Ethereum Hyperlane submission.
+ *
+ * The action requotes immediately before submission. ERC-20 allowance is
+ * checked first and only insufficient allowances generate approval calls.
+ *
+ * @property plan Route, assets, amount, and recipient selected for the transfer.
+ * @property recipientBytes32 Aleo recipient in the exact 32-byte encoding expected by the enrolled Warp Route.
+ * @property pollingIntervalMs Delay between transaction-receipt checks. Defaults to 1,000 milliseconds.
+ * @property confirmationTimeoutMs Maximum time to wait for each approval or dispatch receipt. Defaults to 120,000 milliseconds; a timeout returns resumable pending state.
+ * @property resume Previously checkpointed approval or source receipt. Verification resumes without repeating its transaction.
+ * @property onSubmitted Durable checkpoint hook called after each approval or dispatch broadcast and before receipt polling begins.
+ */
+type ExecuteEvmHyperlaneTransferParameters = {
+    plan: BridgePlan;
+    recipientBytes32: Hex;
+    pollingIntervalMs?: number | undefined;
+    confirmationTimeoutMs?: number | undefined;
+    resume?: BridgeReceipt | undefined;
+    onSubmitted?: ((receipt: BridgeReceipt) => void | Promise<void>) | undefined;
+};
+/**
+ * Captures wallet transactions and resumable Hyperlane progress after execution.
+ *
+ * @property receipt Protocol-neutral transfer state, including the source transaction and message id when confirmed.
+ * @property approvalTxIds ERC-20 approval transactions submitted before dispatch.
+ */
+type EvmHyperlaneTransferExecution = {
+    receipt: BridgeReceipt;
+    approvalTxIds: Hash[];
+};
+
+/**
+ * Describes the cross-chain transfer whose current cost is calculated.
+ *
+ * The same source, destination, amount, and recipient become the plan returned
+ * with the quote, so the caller can execute exactly what was priced.
+ *
+ * @property privateMintSecretNonce Secret Aleo scalar committed by a private xReserve deposit. Defaults to `0scalar` and is never persisted in a checkpoint.
+ */
+type QuoteParameters = PrepareParameters & {
+    privateMintSecretNonce?: string | undefined;
+};
+/** Identifies the route implementation that produced a transfer quote. */
+type BridgeQuoteKind = 'aleo-hyperlane' | 'aleo-xreserve' | 'evm-hyperlane' | 'evm-xreserve' | 'solana-hyperlane';
+/**
+ * Reports the locally known values for an Aleo-origin xReserve burn.
+ *
+ * The route has no separate source-chain quote call, so the result carries
+ * the prepared amount and fees with a `not-queried` status.
+ *
+ * @property kind Aleo-origin xReserve route discriminator.
+ * @property routeId Directional route selected by the plan.
+ * @property protocol Circle xReserve protocol discriminator.
+ * @property amountIn Decimal source amount.
+ * @property amountOut Decimal destination amount when locally determinable.
+ * @property fees Fee categories known during preparation.
+ * @property status Indicates that no live quote endpoint was queried.
+ */
+type AleoXReserveQuote = {
+    kind: 'aleo-xreserve';
+    routeId: string;
+    protocol: 'xreserve';
+    amountIn: string;
+    amountOut?: string | undefined;
+    fees: BridgeFee[];
+    status: 'not-queried';
+};
+/** Captures every quote returned by the protocol-neutral transfer action. */
+type BridgeQuote = ({
+    plan: BridgePlan;
+}) & (({
+    kind: 'aleo-hyperlane';
+} & AleoHyperlaneGasQuote) | AleoXReserveQuote | ({
+    kind: 'evm-hyperlane';
+} & EvmHyperlaneTransferQuote) | ({
+    kind: 'evm-xreserve';
+} & EvmXReserveTransferQuote) | ({
+    kind: 'solana-hyperlane';
+} & SolanaHyperlaneTransferQuote));
+/**
+ * Controls how the source wallet begins a cross-chain transfer.
+ *
+ * Current fees and approval requirements are recalculated before funds are
+ * committed, so a previously displayed quote is not treated as final.
+ *
+ * @property plan Route, assets, amount, and recipient selected for the transfer.
+ * @property pollingIntervalMs Delay between source confirmation checks. Defaults to 1,000 milliseconds where polling applies.
+ * @property confirmationTimeoutMs Maximum source confirmation wait. Defaults to 120,000 milliseconds where polling applies.
+ * @property onCheckpoint Optional durable hook receiving compact recovery state before supported local Aleo broadcasts and after every submission.
+ * @property mode Aleo Hyperlane caller mode or xReserve burn mode. Defaults to `caller` for Hyperlane and `private` for xReserve.
+ * @property userRecord Wallet record request or encoded USDCx record required by a private Aleo xReserve burn.
+ * @property merkleProof Encoded `[MerkleProof; 2]` literal required by a private Aleo xReserve burn.
+ * @property privateFee Whether an Aleo wallet pays its execution fee privately. Defaults to false.
+ * @property gasPaymentMicrocredits Optional exact Aleo Hyperlane hook payment override. Defaults to a fresh live quote.
+ * @property privateMintSecretNonce Secret Aleo scalar committed by a private xReserve deposit. Defaults to `0scalar` and is never persisted in a checkpoint.
+ * @property onProgress Optional awaited callback for Aleo proving and submission boundaries. Non-Aleo routes emit no events.
+ */
+type ExecuteParameters = {
+    plan: BridgePlan;
+    pollingIntervalMs?: number | undefined;
+    confirmationTimeoutMs?: number | undefined;
+    onCheckpoint?: ((checkpoint: BridgeCheckpoint) => void | Promise<void>) | undefined;
+    mode?: 'caller' | 'signer' | XReserveBurnMode | undefined;
+    userRecord?: TransactionInput | undefined;
+    merkleProof?: string | undefined;
+    privateFee?: boolean | undefined;
+    gasPaymentMicrocredits?: bigint | undefined;
+    privateMintSecretNonce?: string | undefined;
+    onProgress?: ProvingProgressHandler | undefined;
+};
+/** Identifies the route implementation that submitted a transfer. */
+type BridgeExecutionKind = 'aleo-hyperlane' | 'aleo-xreserve' | 'evm-hyperlane' | 'evm-xreserve' | 'solana-hyperlane';
+/** Captures every result returned by the protocol-neutral execution action. */
+type BridgeExecution = ({
+    kind: 'aleo-hyperlane';
+} & AleoHyperlaneTransferRemoteExecution) | ({
+    kind: 'aleo-xreserve';
+} & XReserveBurnExecution) | ({
+    kind: 'evm-hyperlane';
+} & EvmHyperlaneTransferExecution) | ({
+    kind: 'evm-xreserve';
+} & EvmXReserveTransferExecution) | ({
+    kind: 'solana-hyperlane';
+} & SolanaHyperlaneTransferExecution);
+/**
+ * Supplies an in-progress cross-chain transfer for one status check.
+ *
+ * @property plan Route, assets, amount, and recipient for the transfer.
+ * @property receipt Latest known state and submitted transaction identifiers.
+ * @property signal Optional cancellation signal for protocol HTTP reads. Defaults to no cancellation.
+ */
+type GetStatusParameters = {
+    plan: BridgePlan;
+    receipt: BridgeReceipt;
+    signal?: AbortSignal | undefined;
+};
+/**
+ * Controls the wallet transaction that privately delivers USDCx on Aleo.
+ *
+ * @property privateMintSecretNonce Secret Aleo scalar required by a private xReserve mint. Defaults to `0scalar`.
+ * @property privateFee Whether the Aleo wallet pays its fee privately. Defaults to false.
+ * @property onCheckpoint Durable hook called before supported local Aleo broadcast and again after destination submission.
+ * @property onProgress Optional awaited callback for Aleo proving and submission boundaries.
+ */
+type CompleteOptions = {
+    privateMintSecretNonce?: string | undefined;
+    privateFee?: boolean | undefined;
+    onCheckpoint?: ((checkpoint: BridgeCheckpoint) => void | Promise<void>) | undefined;
+    onProgress?: ProvingProgressHandler | undefined;
+};
+/**
+ * Supplies the state and wallet preferences required to receive private USDCx on Aleo.
+ *
+ * An application returning after an interruption passes recovered progress. An
+ * application that stayed open passes the original transfer details and latest
+ * receipt.
+ *
+ * @property progress Recovered progress whose next operation is `complete`.
+ * @property plan Route, assets, amount, and recipient retained while the application stayed open.
+ * @property receipt Circle-attested transfer state retained while the application stayed open.
+ * @property privateMintSecretNonce Secret Aleo scalar required by a private xReserve mint. Defaults to `0scalar` and must match the source deposit.
+ * @property privateFee Whether the Aleo wallet pays its fee privately. Defaults to false.
+ * @property onCheckpoint Optional durable hook called before supported local Aleo broadcast and again after destination submission.
+ */
+type CompleteParameters = CompleteOptions & ({
+    progress: Extract<BridgeProgress, {
+        next: 'complete';
+    }>;
+    plan?: never;
+    receipt?: never;
+} | {
+    progress?: never;
+    plan: BridgePlan;
+    receipt: BridgeReceipt;
+});
+/**
+ * Supplies saved public transfer information for recovery after an interruption.
+ *
+ * @property checkpoint Compact checkpoint emitted at a wallet submission boundary.
+ * @property signal Optional cancellation signal. Defaults to no cancellation.
+ */
+type RecoverParameters = {
+    checkpoint: BridgeCheckpoint;
+    signal?: AbortSignal | undefined;
+};
+/**
+ * Controls submission of a source-chain transaction left unfinished after an interruption.
+ *
+ * @property progress Recovery result whose next operation is `resume`.
+ * @property privateMintSecretNonce Secret Aleo scalar required to resume a private xReserve deposit. Defaults to `0scalar` and must match the checkpointed hook.
+ * @property pollingIntervalMs Delay between source confirmation reads. Defaults to 1,000 milliseconds.
+ * @property confirmationTimeoutMs Maximum source confirmation wait. Defaults to 120,000 milliseconds.
+ * @property onCheckpoint Optional durable hook called immediately after a new transaction is broadcast.
+ */
+type ResumeParameters = {
+    progress: Extract<BridgeProgress, {
+        next: 'resume';
+    }>;
+    privateMintSecretNonce?: string | undefined;
+    pollingIntervalMs?: number | undefined;
+    confirmationTimeoutMs?: number | undefined;
+    onCheckpoint?: ((checkpoint: BridgeCheckpoint) => void | Promise<void>) | undefined;
+};
+/**
+ * Controls how a recovered cross-chain transfer is followed until it finishes or needs a wallet.
+ *
+ * @property progress Current transfer details, receipt, and required next operation.
+ * @property until Optional protocol statuses that also stop polling. Defaults to wallet authorization and terminal boundaries.
+ * @property pollingIntervalMs Delay between reads. Defaults to 15,000 milliseconds.
+ * @property timeoutMs Maximum polling duration. Defaults to 1,200,000 milliseconds.
+ * @property onUpdate Optional callback invoked after each receipt transition.
+ * @property signal Optional cancellation signal. Defaults to no cancellation.
+ */
+type WaitParameters = {
+    progress: BridgeProgress;
+    until?: readonly BridgeStatus[] | undefined;
+    pollingIntervalMs?: number | undefined;
+    timeoutMs?: number | undefined;
+    onUpdate?: ((progress: BridgeProgress) => void | Promise<void>) | undefined;
+    signal?: AbortSignal | undefined;
+};
+
+/**
+ * Carries validated registry and materialized client state into bound actions.
+ * @property registry Validated deployment registry.
+ * @property clients Materialized chain capabilities keyed by registry chain id.
+ * @property fetch Fetch implementation used for protocol HTTP requests.
+ */
+type BridgeActionsConfig = {
+    registry: BridgeRegistry;
+    clients: BridgeChainClients;
+    fetch: typeof globalThis.fetch;
+};
+/**
+ * Groups the complete cross-chain transfer lifecycle exposed by a bridge client.
+ *
+ * Quoting validates the transfer and reads chains or providers where current
+ * costs are available. Execution, resumption, completion, shielding, and
+ * unshielding can request wallet authorization and move funds.
+ */
+type BridgeActions = {
+    quote: (params: QuoteParameters) => Promise<BridgeQuote>;
+    execute: (params: ExecuteParameters) => Promise<BridgeExecution>;
+    getStatus: (params: GetStatusParameters) => Promise<BridgeReceipt>;
+    complete: (params: CompleteParameters) => Promise<BridgeExecution>;
+    recover: (params: RecoverParameters) => Promise<BridgeProgress>;
+    resume: (params: ResumeParameters) => Promise<BridgeExecution>;
+    wait: (params: WaitParameters) => Promise<BridgeProgress>;
+    shield: (params: ShieldParameters) => Promise<AleoPrivacyExecution>;
+    unshield: (params: UnshieldParameters) => Promise<AleoPrivacyExecution>;
+};
+/**
+ * Binds configured chains, wallets, and provider HTTP access to every bridge action.
+ *
+ * Calling this function only creates closures; it does not contact a chain,
+ * request a signature, submit a transaction, move funds, or store state.
+ */
+declare function bridgeActions(config: BridgeActionsConfig): BridgeActions;
+
+/**
+ * Configures the chains, wallets, providers, and route catalog available to a bridge client.
+ *
+ * @property environment Default route environment. Defaults to `mainnet`.
+ * @property registry Optional replacement catalog of supported assets, routes, and reviewed provider deployments. Defaults to the package catalog.
+ * @property clients Network and optional wallet access keyed by the matching chain identifier in the catalog.
+ * @property fetch Optional Fetch API implementation used for provider status requests. Defaults to `globalThis.fetch`.
+ * @property key Stable client key. Defaults to `bridge`.
+ * @property name Display name. Defaults to `Bridge Client`.
+ */
+type BridgeClientConfig = {
+    environment?: BridgeEnvironment | undefined;
+    registry?: BridgeRegistry | undefined;
+    clients?: BridgeChainClients | undefined;
+    fetch?: typeof globalThis.fetch | undefined;
+    key?: string | undefined;
+    name?: string | undefined;
+};
+/**
+ * Exposes the actions for discovering, pricing, submitting, following, and recovering cross-chain transfers.
+ *
+ * @property key Stable client key.
+ * @property name Client display name.
+ * @property environment Default route environment.
+ * @property registry Validated catalog of supported assets, routes, and provider deployments.
+ */
+type BridgeClient = BridgeActions & {
+    key: string;
+    name: string;
+    environment: BridgeEnvironment;
+    registry: BridgeRegistry;
+};
+/**
+ * Creates a client for discovering, pricing, submitting, following, and recovering cross-chain transfers.
+ *
+ * Construction validates the configured catalog and stores the supplied network
+ * and wallet clients. It does not contact a chain or provider, request a
+ * signature, submit a transaction, move funds, or manage application storage.
+ *
+ * @param config Networks, wallets, provider HTTP access, and optional replacement route catalog.
+ * @returns Bridge actions bound to the configured chains, wallets, providers, and environment.
+ * @throws BridgeError When the route catalog contains duplicate, missing, or incompatible references.
+ * @example
+ * const bridge = createBridgeClient({ environment: 'mainnet' })
+ */
+declare function createBridgeClient(config?: BridgeClientConfig): BridgeClient;
+
+export { type EvmLog as $, type AleoPrivacyExecution as A, type BridgeChainClients as B, type CompleteParameters as C, type AleoClient as D, type ExecuteParameters as E, type AleoClientConfig as F, type GetStatusParameters as G, type BridgeActions as H, type BridgeActionsConfig as I, type BridgeChainClient as J, type BridgeClient as K, type BridgeClientConfig as L, type BridgeExecutionKind as M, type BridgeQuoteKind as N, type EvmAccount as O, type EvmCallParameters as P, type QuoteParameters as Q, type RecoverParameters as R, type ShieldParameters as S, type EvmClientConfig as T, type UnshieldParameters as U, type EvmGetLogsParameters as V, type WaitParameters as W, type XReserveHttpTransport as X, type EvmHttpOptions as Y, type EvmHyperlaneRouteMetadata as Z, type EvmHyperlaneRouterType as _, type BridgeExecution as a, type EvmPublicClient as a0, type EvmReceipt as a1, type EvmRequest as a2, type EvmTransaction as a3, type EvmTransactionParameters as a4, type EvmTransport as a5, type EvmXReserveRouteMetadata as a6, type XReserveBurnMode as a7, type XReserveHttpResponse as a8, aleoWallet as a9, bridgeActions as aa, createAleoClient as ab, createBridgeClient as ac, createEvmClient as ad, evmCustom as ae, evmHttp as af, evmLocalAccount as ag, evmPrivateKey as ah, evmProvider as ai, type BridgeQuote as b, type ResumeParameters as c, type QuoteAleoHyperlaneGasPaymentParameters as d, type AleoHyperlaneGasQuote as e, type AleoWalletClient as f, type ExecuteAleoHyperlaneTransferRemoteParameters as g, type AleoHyperlaneTransferRemoteExecution as h, type EvmClient as i, type QuoteEvmHyperlaneTransferParameters as j, type EvmHyperlaneTransferQuote as k, type EvmWalletClient as l, type ExecuteEvmHyperlaneTransferParameters as m, type EvmHyperlaneTransferExecution as n, type QuoteEvmXReserveTransferParameters as o, type EvmXReserveTransferQuote as p, type ExecuteEvmXReserveTransferParameters as q, type EvmXReserveTransferExecution as r, type GetXReserveAttestationParameters as s, type XReserveAttestationResult as t, type ExecuteXReservePrivateMintParameters as u, type XReservePrivateMintExecution as v, type ExecuteXReserveBurnParameters as w, type XReserveBurnExecution as x, type XReserveBurnCall as y, type AleoHyperlaneTransferRemoteCall as z };