@provablehq/aleo-bridge-sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,739 @@
+import { B as BridgeChainClients, E as ExecuteParameters, a as BridgeExecution, Q as QuoteParameters, b as BridgeQuote, C as CompleteParameters, X as XReserveHttpTransport, G as GetStatusParameters, R as RecoverParameters, c as ResumeParameters, W as WaitParameters, S as ShieldParameters, A as AleoPrivacyExecution, U as UnshieldParameters, d as QuoteAleoHyperlaneGasPaymentParameters, e as AleoHyperlaneGasQuote, f as AleoWalletClient, g as ExecuteAleoHyperlaneTransferRemoteParameters, h as AleoHyperlaneTransferRemoteExecution, i as EvmClient, j as QuoteEvmHyperlaneTransferParameters, k as EvmHyperlaneTransferQuote, l as EvmWalletClient, m as ExecuteEvmHyperlaneTransferParameters, n as EvmHyperlaneTransferExecution, o as QuoteEvmXReserveTransferParameters, p as EvmXReserveTransferQuote, q as ExecuteEvmXReserveTransferParameters, r as EvmXReserveTransferExecution, s as GetXReserveAttestationParameters, t as XReserveAttestationResult, u as ExecuteXReservePrivateMintParameters, v as XReservePrivateMintExecution, w as ExecuteXReserveBurnParameters, x as XReserveBurnExecution, y as XReserveBurnCall, z as AleoHyperlaneTransferRemoteCall, D as AleoClient } from './createBridgeClient-DzmEyXfG.js';
+export { F as AleoClientConfig, H as BridgeActions, I as BridgeActionsConfig, J as BridgeChainClient, K as BridgeClient, L as BridgeClientConfig, M as BridgeExecutionKind, N as BridgeQuoteKind, O as EvmAccount, P as EvmCallParameters, T as EvmClientConfig, V as EvmGetLogsParameters, Y as EvmHttpOptions, Z as EvmHyperlaneRouteMetadata, _ as EvmHyperlaneRouterType, $ as EvmLog, a0 as EvmPublicClient, a1 as EvmReceipt, a2 as EvmRequest, a3 as EvmTransaction, a4 as EvmTransactionParameters, a5 as EvmTransport, a6 as EvmXReserveRouteMetadata, a7 as XReserveBurnMode, a8 as XReserveHttpResponse, a9 as aleoWallet, aa as bridgeActions, ab as createAleoClient, ac as createBridgeClient, ad as createEvmClient, ae as evmCustom, af as evmHttp, ag as evmLocalAccount, ah as evmPrivateKey, ai as evmProvider } from './createBridgeClient-DzmEyXfG.js';
+import { B as BridgeRegistry, a as BridgeReceipt, b as BridgeProgress, c as BridgePlan, d as BridgeCheckpoint, S as SolanaClient, Q as QuoteSolanaHyperlaneTransferParameters, e as SolanaHyperlaneTransferQuote, f as SolanaWalletClient, E as ExecuteSolanaHyperlaneTransferParameters, g as SolanaHyperlaneTransferExecution, h as BridgeEnvironment, A as AleoMintMode } from './solana-D5Qr6SLa.js';
+export { i as AleoPrivacyCapability, j as AleoPrivacyKind, k as BridgeAssetKind, l as BridgeAssetLocator, m as BridgeChainFamily, n as BridgeEndpoint, o as BridgeExecutionStep, p as BridgeExecutionStepKind, q as BridgeFee, r as BridgeIntent, s as BridgeNextAction, t as BridgeProgressNext, u as BridgeProtocol, v as BridgeRouteAvailability, w as BridgeStatus, x as BridgeStepExecutor, D as DEFAULT_SOLANA_RPC_URL, G as GetAssetsParameters, y as GetRoutesParameters, P as PrepareParameters, z as ProtocolBridgeAsset, C as ProtocolBridgeChain, F as ProtocolBridgeRoute, H as SolanaAccount, I as SolanaClientConfig, J as SolanaHttpOptions, K as SolanaHyperlaneRouteMetadata, L as SolanaPublicClient, M as SolanaRequest, N as SolanaTransport, O as createSolanaClient, R as solanaCustom, T as solanaHttp, U as solanaKeyPair, V as solanaWallet } from './solana-D5Qr6SLa.js';
+import { Client } from '@provablehq/veil-core';
+import { Hex, Address, Hash } from 'viem';
+
+/**
+ * Begins a cross-chain transfer by committing funds on the source chain.
+ *
+ * Token transfers may first require the source wallet to approve the bridge
+ * contract. The action then submits the deposit, burn, or dispatch that commits
+ * the asset to the selected bridge provider.
+ *
+ * The returned receipt identifies the in-progress transfer. Once the source
+ * transaction is accepted, the transfer may no longer be reversible. Each
+ * submitted transaction may incur a network fee even if a later stage fails.
+ *
+ * @param registry Supported chains, assets, and bridge provider deployments.
+ * @param clients Network and wallet access for the source and destination chains.
+ * @param params Transfer details, source wallet preferences, and an optional callback for saving recovery information.
+ * @returns The submitted transaction identifier and the initial state of the in-progress transfer.
+ * @throws BridgeError When the transfer is unsupported, the connected wallet cannot authorize it, current funds or fees are insufficient, or submission fails.
+ * @example const execution = await execute(registry, clients, { plan, onCheckpoint: saveCheckpoint })
+ */
+declare function execute(registry: BridgeRegistry, clients: BridgeChainClients, params: ExecuteParameters): Promise<BridgeExecution>;
+
+/**
+ * Calculates the funds and fees required to begin a cross-chain transfer.
+ *
+ * The caller supplies the intended source, destination, amount, recipient, and
+ * optional provider. The result includes both the validated transfer plan and
+ * the bridge and network costs the selected provider can determine. Depending
+ * on the route, it also reports the expected destination amount, wallet
+ * balance, and token approval requirements.
+ *
+ * Routes with live pricing read current network and provider state; other routes
+ * return their configured costs. The action does not request a wallet signature
+ * or move funds.
+ *
+ * @param registry Supported chains, assets, and bridge provider deployments.
+ * @param clients Network access for the chains involved in the transfer.
+ * @param params Transfer details whose current cost and requirements are calculated.
+ * @returns The amount expected at the destination and the known bridge, network, and approval costs.
+ * @throws BridgeError When the selected provider cannot quote the transfer or required network access is unavailable.
+ * @example const result = await quote(registry, clients, { source, destination, amount: '1', recipient })
+ */
+declare function quote(registry: BridgeRegistry, clients: BridgeChainClients, params: QuoteParameters): Promise<BridgeQuote>;
+
+/**
+ * Submits the destination-chain transaction required to receive bridged funds.
+ *
+ * This currently applies to a private USDC-to-USDCx xReserve transfer after
+ * Circle has attested the source deposit. The Aleo wallet proves, signs, and
+ * submits the private mint that delivers a private record to the recipient.
+ *
+ * The source transaction is never repeated. The destination transaction incurs
+ * an Aleo network fee even if it fails.
+ *
+ * @param registry Supported chains, assets, and bridge provider deployments.
+ * @param clients Network and wallet access for the Aleo destination chain.
+ * @param params Transfer state ready for private delivery, fee preference, secret nonce, and optional callback for saving recovery information.
+ * @returns The Aleo transaction identifier and the destination confirmation state.
+ * @throws BridgeError When no destination transaction is required, the Circle attestation is invalid, required wallet access is unavailable, or submission fails.
+ * @example const execution = await complete(registry, clients, { plan, receipt: ready, onCheckpoint: save })
+ */
+declare function complete(registry: BridgeRegistry, clients: BridgeChainClients, params: CompleteParameters): Promise<BridgeExecution>;
+
+/**
+ * Checks one stage of an in-progress cross-chain transfer.
+ *
+ * The action checks the relevant source chain, bridge provider, or destination
+ * chain once. The result advances when that stage has completed and otherwise
+ * remains unchanged, which suits refresh buttons and scheduled background jobs.
+ *
+ * The action does not request a signature, submit a transaction, or move funds.
+ *
+ * @param registry Supported chains, assets, and bridge provider deployments.
+ * @param clients Network access for the chains involved in the transfer.
+ * @param client HTTP access for bridge provider status checks.
+ * @param params Transfer details, latest receipt, and optional cancellation signal.
+ * @returns The latest known state after one network or provider check.
+ * @throws BridgeError When the receipt does not belong to the transfer, required network access is unavailable, or a provider returns invalid data.
+ * @example const receipt = await getStatus(registry, clients, fetch, { plan, receipt: checkpoint })
+ */
+declare function getStatus(registry: BridgeRegistry, clients: BridgeChainClients, client: XReserveHttpTransport, params: GetStatusParameters): Promise<BridgeReceipt>;
+
+/**
+ * Reconstructs an interrupted cross-chain transfer from a saved checkpoint.
+ *
+ * The action determines which transactions were submitted, which stages have
+ * completed, and whether the transfer is still moving, finished, failed, or
+ * waiting for another wallet authorization.
+ *
+ * Recovery reads existing network and provider state. It never repeats a
+ * transaction or moves funds.
+ *
+ * @param registry Supported chains, assets, and bridge provider deployments.
+ * @param clients Network access for the chains involved in the transfer.
+ * @param client HTTP access for bridge provider status checks.
+ * @param params Saved route, amount, recipient, and submitted transaction identifiers.
+ * @returns The current transfer state and whether to wait, resume source submission, authorize destination completion, or stop.
+ * @throws BridgeError When the saved information is invalid, no longer matches the configured route, or describes an unsupported recovery path.
+ * @example const progress = await recover(registry, clients, fetch, { checkpoint })
+ */
+declare function recover(registry: BridgeRegistry, clients: BridgeChainClients, client: XReserveHttpTransport, params: RecoverParameters): Promise<BridgeProgress>;
+
+/**
+ * Submits the source-chain transaction left unfinished after an interruption.
+ *
+ * This applies when a token approval succeeded without the following deposit,
+ * or an Aleo transaction was fully proved before the application stopped. Only
+ * the pending submission continues. A proved Aleo transaction may be
+ * rebroadcast byte-for-byte with the same transaction identifier, so recovery
+ * cannot create a second transfer.
+ *
+ * The action may request authorization from the source wallet. A submitted
+ * transaction can commit funds and incur a network fee.
+ *
+ * @param registry Supported chains, assets, and bridge provider deployments.
+ * @param clients Network and wallet access for the source chain.
+ * @param params Recovered transfer state, confirmation controls, and an optional callback for saving the new submission.
+ * @returns The submitted transaction identifier and the updated state of the in-progress transfer.
+ * @throws BridgeError When no source transaction remains to be submitted, required wallet access is unavailable, or submission fails.
+ * @example const execution = await resume(registry, clients, { progress })
+ */
+declare function resume(registry: BridgeRegistry, clients: BridgeChainClients, params: ResumeParameters): Promise<BridgeExecution>;
+
+/**
+ * Follows a cross-chain transfer until it finishes or requires another wallet authorization.
+ *
+ * The action monitors source confirmation, provider processing, and destination
+ * delivery where those stages can be verified. The result states whether the
+ * funds arrived, the transfer failed, or another source- or destination-chain
+ * transaction is required.
+ *
+ * Monitoring does not request a signature, submit a transaction, or move funds.
+ *
+ * @param registry Supported chains, assets, and bridge provider deployments.
+ * @param clients Network access for the chains involved in the transfer.
+ * @param client HTTP access for bridge provider status checks.
+ * @param params Current transfer state, optional stopping statuses, polling controls, and optional progress callback.
+ * @returns The completed or failed transfer, or the next transaction the caller must authorize.
+ * @throws BridgeError When the saved state does not belong to the transfer, the wait times out or is cancelled, or a network or provider check fails.
+ * @example const next = await wait(registry, clients, fetch, { progress })
+ */
+declare function wait(registry: BridgeRegistry, clients: BridgeChainClients, client: XReserveHttpTransport, params: WaitParameters): Promise<BridgeProgress>;
+
+/**
+ * Converts an Aleo token balance visible on the public ledger into a private record owned by the recipient.
+ *
+ * A private record stores spendable value without exposing the owner or amount
+ * in a public account balance. The Aleo wallet proves and submits the
+ * conversion, which spends the public balance and incurs an Aleo transaction
+ * fee.
+ *
+ * @param registry Supported Aleo assets and their public-to-private conversion programs.
+ * @param clients Network and wallet access for Aleo.
+ * @param params Asset, amount, optional private recipient, fee preference, and proving progress callbacks.
+ * @returns The submitted Aleo transaction identifier and exact converted amount.
+ * @throws BridgeError When the asset cannot be converted privately, the amount is invalid, required wallet access is unavailable, or submission fails.
+ * @example
+ * await shield(registry, clients, { asset: { chain: 'aleo', asset: 'sol' }, amount: '0.1' })
+ */
+declare function shield(registry: BridgeRegistry, clients: BridgeChainClients, params: ShieldParameters): Promise<AleoPrivacyExecution>;
+
+/**
+ * Converts an Aleo private record into a token balance visible on the public ledger.
+ *
+ * A private record stores spendable value without exposing the owner or amount
+ * in a public account balance. The wallet selects a sufficient record unless
+ * the caller supplies one, then proves and submits the conversion. The public
+ * recipient and amount become visible, and the transaction incurs an Aleo fee.
+ *
+ * @param registry Supported Aleo assets and their private-to-public conversion programs.
+ * @param clients Network and wallet access for Aleo.
+ * @param params Asset, amount, optional private record and public recipient, fee preference, freeze-list proof, and proving progress callbacks.
+ * @returns The submitted Aleo transaction identifier and exact converted amount.
+ * @throws BridgeError When the asset cannot be converted publicly, the amount or private record is invalid, required wallet access is unavailable, or submission fails.
+ * @example
+ * await unshield(registry, clients, { asset: { chain: 'aleo', asset: 'sol' }, amount: '0.1' })
+ */
+declare function unshield(registry: BridgeRegistry, clients: BridgeChainClients, params: UnshieldParameters): Promise<AleoPrivacyExecution>;
+
+/**
+ * Captures the information an application needs to return to a cross-chain transfer after an interruption.
+ *
+ * The result includes the route, assets, amount, recipient, and submitted
+ * transaction identifiers. It excludes private keys, Aleo record contents, and
+ * the secret used for a private xReserve mint.
+ *
+ * Creating a checkpoint does not contact a network or store data on the
+ * caller's behalf. The application decides whether and where to save it.
+ *
+ * @param plan Transfer details that identify the route, assets, amount, and recipient.
+ * @param receipt Latest state returned after a wallet submission.
+ * @returns Public recovery information suitable for optional durable storage.
+ * @throws BridgeError When the receipt belongs to a different transfer route.
+ * @example const checkpoint = createBridgeCheckpoint(plan, execution.receipt)
+ */
+declare function createBridgeCheckpoint(plan: BridgePlan, receipt: BridgeReceipt): BridgeCheckpoint;
+
+/**
+ * Selects a custom registry for a direct protocol helper.
+ *
+ * @property registry Reviewed registry snapshot. Defaults to the package registry.
+ */
+type ProtocolHelperRegistry = {
+    registry?: BridgeRegistry | undefined;
+};
+/**
+ * Exposes chain-specific Hyperlane helpers for direct protocol integrations.
+ *
+ * Helpers use the default reviewed registry unless `params.registry` supplies
+ * a custom snapshot. Most applications should use the protocol-neutral bridge
+ * client actions instead.
+ *
+ * @example const result = await hyperlane.evm.quote(client, { plan, recipientBytes32 })
+ */
+declare const hyperlane: {
+    readonly aleo: {
+        /**
+         * Calculates the Hyperlane relayer payment for a transfer leaving Aleo.
+         *
+         * Reads the current gas oracle on Aleo without requesting a signature or
+         * moving funds. The payment can change before the transfer is submitted.
+         *
+         * @param client Aleo network access used to read the current gas price and exchange rate.
+         * @param params Route selected for the transfer and optional replacement bridge deployments.
+         * @returns Destination gas requirements and the exact payment in Aleo microcredits.
+         * @throws BridgeError When the route is unavailable or its gas configuration is invalid.
+         * @example const result = await hyperlane.aleo.quote(client, { routeId })
+         */
+        readonly quote: (client: Client, params: QuoteAleoHyperlaneGasPaymentParameters & ProtocolHelperRegistry) => Promise<AleoHyperlaneGasQuote>;
+        /**
+         * Begins an Aleo-to-Ethereum or Aleo-to-Solana transfer through Hyperlane.
+         *
+         * The Aleo wallet proves, signs, and submits the source transaction, which
+         * commits the asset and incurs an Aleo network fee.
+         *
+         * @param client Aleo wallet that authorizes and submits the source transaction.
+         * @param params Route, assets, amount, recipient, gas payment, and optional replacement bridge deployments.
+         * @returns The Aleo transaction identifier and state needed to follow delivery.
+         * @throws BridgeError When the transfer is unavailable, its payment is invalid, or wallet submission fails.
+         * @example const result = await hyperlane.aleo.execute(client, { plan, gasPaymentMicrocredits })
+         */
+        readonly execute: (client: AleoWalletClient, params: ExecuteAleoHyperlaneTransferRemoteParameters & ProtocolHelperRegistry) => Promise<AleoHyperlaneTransferRemoteExecution>;
+    };
+    readonly evm: {
+        /**
+         * Calculates the funds required for a Hyperlane transfer leaving an EVM chain.
+         *
+         * Reads the deployed router without requesting a wallet signature or moving
+         * funds. The quoted network payment can change before submission.
+         *
+         * @param client EVM network access used to read the selected Hyperlane router.
+         * @param params Route, assets, amount, encoded Aleo recipient, and optional replacement bridge deployments.
+         * @returns Source token amount and native network payment required by the router.
+         * @throws BridgeError When the route is unavailable or the router returns invalid values.
+         * @example const result = await hyperlane.evm.quote(client, { plan, recipientBytes32 })
+         */
+        readonly quote: (client: EvmClient, params: QuoteEvmHyperlaneTransferParameters & ProtocolHelperRegistry) => Promise<EvmHyperlaneTransferQuote>;
+        /**
+         * Begins an EVM-to-Aleo transfer through Hyperlane.
+         *
+         * An ERC-20 transfer may first request token approval. The wallet then
+         * submits the source dispatch, which commits funds and incurs network fees.
+         *
+         * @param client EVM network and wallet access used to authorize and submit the transfer.
+         * @param params Route, assets, amount, encoded Aleo recipient, confirmation controls, and optional replacement bridge deployments.
+         * @returns Submitted approval identifiers and state needed to follow delivery.
+         * @throws BridgeError When the transfer is unavailable, wallet authorization fails, funds are insufficient, or submission fails.
+         * @example const result = await hyperlane.evm.execute(client, { plan, recipientBytes32 })
+         */
+        readonly execute: (client: EvmClient & {
+            walletClient: EvmWalletClient;
+        }, params: ExecuteEvmHyperlaneTransferParameters & ProtocolHelperRegistry) => Promise<EvmHyperlaneTransferExecution>;
+    };
+    readonly solana: {
+        /**
+         * Calculates the SOL required for a Solana-to-Aleo Hyperlane transfer.
+         *
+         * Reads current gas, transaction fee, and rent requirements without
+         * requesting a wallet signature or moving funds.
+         *
+         * @param client Solana network access used to read account, fee, and rent values.
+         * @param params Route, amount, recipient, and optional replacement bridge deployments.
+         * @returns Transfer amount, relayer payment, network fee, rent, and total required lamports.
+         * @throws BridgeError When the route is unavailable or Solana returns invalid account or fee data.
+         * @example const result = await hyperlane.solana.quote(client, { plan })
+         */
+        readonly quote: (client: SolanaClient, params: QuoteSolanaHyperlaneTransferParameters & ProtocolHelperRegistry) => Promise<SolanaHyperlaneTransferQuote>;
+        /**
+         * Begins a Solana-to-Aleo transfer through Hyperlane.
+         *
+         * The Solana wallet signs and submits the source transaction, which commits
+         * SOL and incurs the relayer payment, network fee, and account rent.
+         *
+         * @param client Solana network and wallet access used to authorize and submit the transfer.
+         * @param params Route, amount, recipient, confirmation controls, and optional replacement bridge deployments.
+         * @returns The Solana signature and state needed to follow delivery.
+         * @throws BridgeError When the route is unavailable, funds are insufficient, wallet authorization fails, or submission fails.
+         * @example const result = await hyperlane.solana.execute(client, { plan })
+         */
+        readonly execute: (client: SolanaClient & {
+            walletClient: SolanaWalletClient;
+        }, params: ExecuteSolanaHyperlaneTransferParameters & ProtocolHelperRegistry) => Promise<SolanaHyperlaneTransferExecution>;
+    };
+};
+/**
+ * Exposes directional Circle xReserve helpers for direct protocol integrations.
+ *
+ * Helpers use the default reviewed registry unless `params.registry` supplies
+ * a custom snapshot. Most applications should use the protocol-neutral bridge
+ * client actions instead.
+ *
+ * @example const result = await xreserve.evmToAleo.quote(client, { plan })
+ */
+declare const xreserve: {
+    readonly evmToAleo: {
+        /**
+         * Calculates the USDC and token approval required for an xReserve transfer to Aleo.
+         *
+         * Reads the prepared sender's USDC balance and existing xReserve allowance
+         * without requesting a signature or moving funds. When the plan omits a
+         * sender, the client resolves it from its optional wallet capability.
+         *
+         * @param client Ethereum network access, plus a wallet when the plan does not identify the source account.
+         * @param params Route, amount, Aleo recipient, privacy preference, and optional replacement bridge deployments.
+         * @returns Deposit amount, maximum provider fee, balance, allowance, and whether approval is required.
+         * @throws BridgeError When the route is unavailable, the account lacks funds, or Ethereum returns invalid state.
+         * @example const result = await xreserve.evmToAleo.quote(client, { plan })
+         */
+        readonly quote: (client: EvmClient, params: QuoteEvmXReserveTransferParameters & ProtocolHelperRegistry) => Promise<EvmXReserveTransferQuote>;
+        /**
+         * Begins a USDC-to-USDCx transfer from Ethereum to Aleo through xReserve.
+         *
+         * The wallet may first approve USDC spending, then submits the reserve
+         * deposit that commits funds and incurs Ethereum network fees.
+         *
+         * @param client Ethereum network and wallet access used to authorize and submit the deposit.
+         * @param params Route, amount, Aleo recipient, privacy preference, confirmation controls, and optional replacement bridge deployments.
+         * @returns Submitted approval identifiers and state needed to obtain Circle's attestation and follow delivery.
+         * @throws BridgeError When the route is unavailable, funds are insufficient, wallet authorization fails, or submission fails.
+         * @example const result = await xreserve.evmToAleo.execute(client, { plan })
+         */
+        readonly execute: (client: EvmClient & {
+            walletClient: EvmWalletClient;
+        }, params: ExecuteEvmXReserveTransferParameters & ProtocolHelperRegistry) => Promise<EvmXReserveTransferExecution>;
+        /**
+         * Checks whether Circle has attested one confirmed xReserve deposit.
+         *
+         * Contacts Circle once and does not request a wallet signature, submit a
+         * transaction, or move funds.
+         *
+         * @param client HTTP access used to contact Circle's attestation service.
+         * @param params Deposit message hash, route, cancellation signal, and optional replacement bridge deployments.
+         * @returns Whether the attestation is pending or the signed attestation is ready.
+         * @throws BridgeError When Circle returns an invalid response.
+         * @example const result = await xreserve.evmToAleo.getAttestation(fetch, { routeId, messageHash })
+         */
+        readonly getAttestation: (client: XReserveHttpTransport, params: GetXReserveAttestationParameters & ProtocolHelperRegistry) => Promise<XReserveAttestationResult>;
+        /**
+         * Delivers a private USDCx record after Circle attests an Ethereum deposit.
+         *
+         * The Aleo wallet proves, signs, and submits the private mint, which incurs
+         * an Aleo network fee. The source deposit is not repeated.
+         *
+         * @param client Aleo wallet that authorizes and submits the private mint.
+         * @param params Transfer details, attested deposit, private mint secret, recovery callback, and optional replacement bridge deployments.
+         * @returns The Aleo transaction identifier and state needed to confirm private delivery.
+         * @throws BridgeError When the attestation or private mint secret is invalid, wallet authorization fails, or submission fails.
+         * @example const result = await xreserve.evmToAleo.complete(client, { plan, deposit, attestation })
+         */
+        readonly complete: (client: AleoWalletClient, params: ExecuteXReservePrivateMintParameters & ProtocolHelperRegistry) => Promise<XReservePrivateMintExecution>;
+    };
+    readonly aleoToEvm: {
+        /**
+         * Begins a USDCx-to-USDC transfer from Aleo to Ethereum through xReserve.
+         *
+         * The Aleo wallet proves, signs, and submits a burn that commits USDCx and
+         * incurs an Aleo network fee. The provider completes Ethereum delivery
+         * without another wallet authorization.
+         *
+         * @param client Aleo wallet that authorizes and submits the USDCx burn.
+         * @param params Route, amount, Ethereum recipient, public or private funding preference, and optional replacement bridge deployments.
+         * @returns The Aleo transaction identifier and state needed to follow provider-managed delivery.
+         * @throws BridgeError When the route or private funding inputs are invalid, wallet authorization fails, or submission fails.
+         * @example const result = await xreserve.aleoToEvm.execute(client, { plan, mode: 'public' })
+         */
+        readonly execute: (client: AleoWalletClient, params: ExecuteXReserveBurnParameters & ProtocolHelperRegistry) => Promise<XReserveBurnExecution>;
+    };
+};
+
+/**
+ * Builds an Aleo xReserve burn call without prompting a wallet.
+ *
+ * Selects the reviewed entrypoint and validates mode-specific inputs without
+ * contacting Aleo or prompting a wallet.
+ *
+ * @param registry Supported assets and reviewed xReserve deployments.
+ * @param params Route, amount, Ethereum recipient, funding mode, and private inputs when applicable.
+ * @returns Aleo program, transition, ordered inputs, atomic amount, destination domain, and encoded recipient.
+ * @throws BridgeError When the route is unavailable, the amount cannot cover the withdrawal fee, the recipient is invalid, or private funding inputs are missing.
+ * @example const call = buildXReserveBurnCall(registry, { plan, mode: 'public' })
+ */
+declare function buildXReserveBurnCall(registry: BridgeRegistry, params: ExecuteXReserveBurnParameters): XReserveBurnCall;
+
+/**
+ * Builds an Aleo Hyperlane `transfer_remote` call without prompting a wallet.
+ *
+ * Validates the transfer details against reviewed route metadata without
+ * contacting Aleo or prompting a wallet.
+ *
+ * @param registry Supported assets and reviewed Hyperlane deployments.
+ * @param params Route, amount, recipient, authorization mode, and optional current relayer payment.
+ * @returns Aleo program, transition, ordered inputs, atomic amount, and any configuration that is not ready for submission.
+ * @throws BridgeError When the transfer conflicts with the deployment or the relayer payment is invalid.
+ * @example const call = buildAleoHyperlaneTransferRemoteCall(registry, { plan, gasPaymentMicrocredits })
+ */
+declare function buildAleoHyperlaneTransferRemoteCall(registry: BridgeRegistry, params: ExecuteAleoHyperlaneTransferRemoteParameters): AleoHyperlaneTransferRemoteCall;
+
+/**
+ * Supplies the initial reviewed protocol-route snapshot.
+ *
+ * xReserve contract identifiers are populated from Circle's published
+ * mainnet and testnet tables. Hyperlane routes intentionally remain
+ * `metadata-required` until their router, domain, ISM, and token identifiers
+ * are pinned from one reviewed registry commit. Reading this snapshot does not
+ * contact any chain or bridge provider.
+ *
+ * @example
+ * const bridge = createBridgeClient({ registry: DEFAULT_BRIDGE_REGISTRY })
+ */
+declare const DEFAULT_BRIDGE_REGISTRY: BridgeRegistry;
+
+/**
+ * Validates the referential integrity of a protocol bridge registry.
+ *
+ * Duplicate identifiers and dangling asset or chain references throw before a
+ * client can describe a misleading transfer. An active Hyperlane route sourced
+ * from a Solana-family chain additionally must carry a complete
+ * `SolanaHyperlaneRouteMetadata` object, so a route cannot be made active ahead
+ * of its metadata being reviewed and filled in. Validation does not contact a
+ * chain or bridge provider.
+ *
+ * @param registry Registry supplied to `createBridgeClient`.
+ * @returns The validated registry unchanged.
+ * @throws BridgeError When identifiers are duplicated, references are
+ *   missing, or an active Solana-source Hyperlane route is missing required
+ *   Sealevel deployment metadata.
+ *
+ * @example
+ * const registry = validateBridgeRegistry(DEFAULT_BRIDGE_REGISTRY)
+ */
+declare function validateBridgeRegistry(registry: BridgeRegistry): BridgeRegistry;
+
+/**
+ * Decodes a checksummed Aleo bech32m address into xReserve bytes32 form.
+ *
+ * Validates the supplied prefix, length, checksum, padding, and payload width
+ * without contacting Aleo or Circle.
+ *
+ * @param address Aleo account address to encode.
+ * @returns Exactly 32 decoded bytes as prefixed hexadecimal.
+ * @throws BridgeError When the address has invalid bech32m structure.
+ *
+ * @example
+ * const recipient = aleoAddressToBytes32('aleo1…')
+ */
+declare function aleoAddressToBytes32(address: string): Hex;
+/**
+ * Restores the Aleo account address carried in a bridge protocol's bytes32 recipient field.
+ *
+ * Call this when reconstructing a transfer from Solana instructions or EVM
+ * events, where the destination address is stored without its human-readable
+ * prefix and checksum.
+ *
+ * @param recipient Exactly 32 Aleo address bytes encoded as prefixed hexadecimal.
+ * @returns The canonical checksummed `aleo1…` account address.
+ * @throws BridgeError When the recipient is not exactly 32 bytes.
+ */
+declare function bytes32ToAleoAddress(recipient: Hex): string;
+/**
+ * Derives the Aleo account address owned by a deployed program id.
+ *
+ * Lazily loads the optional Aleo WASM SDK but performs no network access.
+ *
+ * @param programId Deployed Aleo program id whose account receives funds.
+ * @param environment Consensus environment used for address derivation.
+ * @returns The program-owned `aleo1…` account address.
+ * @throws BridgeError When the optional SDK is unavailable or derivation fails.
+ *
+ * @example
+ * const wrapper = await aleoProgramAddress('shielded_usdcx_wrapper.aleo', 'mainnet')
+ */
+declare function aleoProgramAddress(programId: string, environment: BridgeEnvironment): Promise<string>;
+/**
+ * Builds the fixed 65-byte xReserve hook for public, record, or wrapper-private minting.
+ *
+ * Public and record hooks use only the supplied values. Private hooks lazily
+ * load Aleo WASM to commit the intended recipient with BHP256 and the selected
+ * secret nonce. No chain or bridge provider is contacted.
+ *
+ * @param mode Destination mint transition selected by the caller.
+ * @param recipient Intended Aleo recipient committed by private mode.
+ * @param environment Consensus environment used by private commitment derivation.
+ * @param secretNonce Aleo scalar literal used by the private commitment. Defaults to `0scalar`.
+ * @returns A 65-byte hook whose first byte is 0, 1, or 2.
+ * @throws BridgeError When private derivation lacks the optional SDK or the secret nonce is not a valid Aleo scalar.
+ *
+ * @example
+ * const hook = await buildXReserveHookData('record', recipient, 'testnet')
+ */
+declare function buildXReserveHookData(mode: AleoMintMode, recipient: string, environment: BridgeEnvironment, secretNonce?: string): Promise<Hex>;
+/**
+ * Derives the Circle deposit nonce from source domain, transaction hash, and log index.
+ *
+ * Follows Circle's ABI-padded nonce preimage exactly without contacting Circle
+ * or either chain.
+ *
+ * @param sourceDomain Circle domain of the source xReserve contract.
+ * @param transactionHash Confirmed deposit transaction hash.
+ * @param logIndex Zero-based `DepositedToRemote` receipt log index.
+ * @returns The Keccak-256 deposit nonce.
+ *
+ * @example
+ * const nonce = calculateXReserveDepositNonce(0, txHash, 3)
+ */
+declare function calculateXReserveDepositNonce(sourceDomain: number, transactionHash: Hash, logIndex: number): Hash;
+/**
+ * Builds the canonical 305-byte Circle xReserve v2 deposit payload.
+ *
+ * Rejects fields with invalid wire widths before constructing the payload. It
+ * does not contact Circle or either chain.
+ *
+ * @param params Event-derived deposit values and reviewed route identifiers.
+ * @returns The exact payload submitted to Circle's attester.
+ * @throws BridgeError When a value is invalid or exceeds its wire width.
+ *
+ * @example
+ * const payload = buildXReserveDepositPayload(fields)
+ */
+declare function buildXReserveDepositPayload(params: {
+    amount: bigint;
+    remoteDomain: number;
+    remoteToken: Hex;
+    remoteRecipient: Hex;
+    localToken: Address;
+    depositor: Address;
+    maxFee: bigint;
+    nonce: Hash;
+    hookData: Hex;
+}): Hex;
+/**
+ * Hashes a canonical xReserve deposit payload for Circle attestation lookup.
+ *
+ * Computes Keccak-256 from the supplied payload without contacting Circle.
+ *
+ * @param payload Canonical xReserve deposit bytes.
+ * @returns The 32-byte Circle message hash.
+ *
+ * @example
+ * const messageHash = calculateXReserveMessageHash(payload)
+ */
+declare function calculateXReserveMessageHash(payload: Hex): Hash;
+/**
+ * Reads the deposit nonce from Circle's fixed-width xReserve payload.
+ *
+ * Applications can use the nonce to verify Aleo delivery even when older saved
+ * progress retained the signed payload but omitted the nonce as a separate field.
+ * The payload is decoded in memory and no network or wallet is contacted.
+ *
+ * @param payload Canonical 305-byte xReserve deposit payload returned by Circle.
+ * @returns The 32-byte deposit nonce used by the Aleo bridge nullifier mapping.
+ * @throws BridgeError When the payload has the wrong header, width, or hook length.
+ * @example const nonce = xReserveDepositNonceFromPayload(attestation.payload)
+ */
+declare function xReserveDepositNonceFromPayload(payload: Hex): Hash;
+/**
+ * Formats fixed-width hexadecimal bytes as an Aleo `[u8; N]` literal.
+ *
+ * Validates the exact byte width before formatting inputs for a wallet. It does
+ * not contact Aleo or prompt the wallet.
+ *
+ * @param value Prefixed hexadecimal bytes to format.
+ * @param expectedBytes Required array width from the target Aleo function.
+ * @returns An Aleo array literal containing decimal `u8` values.
+ * @throws BridgeError When the input is malformed or has the wrong width.
+ *
+ * @example
+ * const hashInput = xReserveHexToAleoBytes(messageHash, 32)
+ */
+declare function xReserveHexToAleoBytes(value: Hex, expectedBytes: number): string;
+/**
+ * Encodes an Ethereum address as the 32-byte recipient required by xReserve burns.
+ *
+ * Preserves the 20 address bytes and adds twelve leading zero bytes without
+ * contacting Ethereum or Circle.
+ *
+ * @param address Checksummed or lowercase Ethereum address selected by the caller.
+ * @returns The address left-padded to exactly 32 bytes.
+ * @throws BridgeError When the address is malformed.
+ *
+ * @example
+ * const recipient = evmAddressToXReserveBytes32('0x0000000000000000000000000000000000000001')
+ */
+declare function evmAddressToXReserveBytes32(address: string): Hex;
+
+/**
+ * Encodes an Ethereum account as the two little-endian limbs used by Aleo Warp Routes.
+ *
+ * Validates a 20-byte EVM address, left-pads it to Hyperlane bytes32 form, and
+ * interprets each 16-byte half as an Aleo `u128` without contacting either
+ * chain.
+ *
+ * @param address Destination Ethereum account supplied by the transfer plan.
+ * @returns Two unsigned 128-bit limbs in Hyperlane message order.
+ * @throws BridgeError When the destination is not a valid 20-byte EVM address.
+ *
+ * @example
+ * const recipient = evmAddressToAleoHyperlaneRecipient('0x1e196d0a7d8189054c4db744ab3340c3f1c68b19')
+ */
+declare function evmAddressToAleoHyperlaneRecipient(address: string): readonly [bigint, bigint];
+/**
+ * Encodes a Solana account as the two little-endian limbs used by Aleo Warp Routes.
+ *
+ * Decodes a base58 account to its 32-byte public key and interprets each
+ * 16-byte half as an Aleo `u128` without contacting either chain.
+ *
+ * @param address Destination Solana account supplied by the transfer plan.
+ * @returns Two unsigned 128-bit limbs in Hyperlane message order.
+ * @throws BridgeError When the destination is not a base58-encoded 32-byte account.
+ *
+ * @example
+ * const recipient = solanaAddressToAleoHyperlaneRecipient('11111111111111111111111111111111')
+ */
+declare function solanaAddressToAleoHyperlaneRecipient(address: string): readonly [bigint, bigint];
+
+/**
+ * Selects the destination mailbox and dispatched Hyperlane message to verify.
+ *
+ * @property mailbox Destination Mailbox contract address or Aleo program id.
+ * @property messageId Canonical 32-byte Hyperlane message identifier.
+ */
+type ReadHyperlaneDeliveryParameters = {
+    mailbox: string;
+    messageId: string;
+};
+/**
+ * Checks whether the destination Hyperlane Mailbox accepted a transfer message.
+ *
+ * The Mailbox contract or program is the authoritative delivery record, unlike
+ * a third-party explorer that may lag or omit a route. The helper reads the
+ * destination chain once and never requests a signature or moves funds.
+ *
+ * @param client Destination EVM or Aleo network access used to read the Mailbox.
+ * @param params Hyperlane message identifier and the destination Mailbox contract or program.
+ * @returns Whether the destination chain has recorded the message as delivered.
+ * @throws BridgeError When the message identifier is invalid or the Mailbox does not belong to the destination chain family.
+ * @example const delivered = await readHyperlaneDelivery(client, { messageId, mailbox: 'hyp_mailbox.aleo' })
+ */
+declare function readHyperlaneDelivery(client: AleoClient | EvmClient, params: ReadHyperlaneDeliveryParameters): Promise<boolean>;
+
+/**
+ * Selects the destination xReserve program and deposit to verify.
+ *
+ * @property bridgeProgram Destination Aleo bridge program that mints the asset.
+ * @property nonce Canonical 32-byte Circle deposit nonce emitted on the source chain.
+ */
+type ReadXReserveDeliveryParameters = {
+    bridgeProgram: string;
+    nonce: string;
+};
+/**
+ * Checks whether an inbound xReserve deposit has already minted on Aleo.
+ *
+ * The Aleo bridge program records every completed public, record, and private
+ * mint under the deposit nonce. Call this before offering or retrying a mint so
+ * a refreshed application does not ask the recipient to complete settled funds.
+ *
+ * @param client Destination Aleo network access used to read the bridge program.
+ * @param params Aleo bridge program and Circle deposit nonce emitted on Ethereum.
+ * @returns Whether Aleo has finalized a mint for this deposit.
+ * @throws BridgeError When the bridge program or nonce is malformed.
+ * @example const delivered = await readXReserveDelivery(client, { bridgeProgram: 'usdcx_bridge_v2.aleo', nonce })
+ */
+declare function readXReserveDelivery(client: AleoClient, params: ReadXReserveDeliveryParameters): Promise<boolean>;
+
+/**
+ * Represents protocol bridge configuration and planning failures.
+ *
+ * @example
+ * try {
+ *   await bridge.quote(params)
+ * } catch (error) {
+ *   if (error instanceof BridgeError) console.error(error.message)
+ * }
+ */
+declare class BridgeError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+
+/**
+ * Converts a decimal amount string into the asset's atomic units.
+ *
+ * Protocol inputs use display decimals (`"0.5"` ALEO), while onchain calls
+ * use atomic integers (`500000n` microcredits). String arithmetic keeps the
+ * conversion exact without floating-point rounding or contacting a chain.
+ *
+ * @param amount Decimal amount as a string (e.g. `"0.5"`, `"100"`).
+ * @param decimals The asset's display decimals (e.g. 6 for ALEO/USDC, 18 for ETH).
+ * @returns The atomic amount as a bigint.
+ * @throws BridgeError When the string is not a plain decimal number, or has
+ *   more fractional digits than the asset supports (that precision cannot be
+ *   represented on chain).
+ *
+ * @example
+ * parseDecimalAmount('0.5', 6)   // 500000n
+ * parseDecimalAmount('100', 6)   // 100000000n
+ */
+declare function parseDecimalAmount(amount: string, decimals: number): bigint;
+/**
+ * Formats a non-negative atomic amount as an exact decimal display value.
+ *
+ * String arithmetic removes trailing fractional zeroes without floating-point
+ * rounding and does not read a balance or contact a chain.
+ *
+ * @param amount Atomic amount to format; MUST be non-negative.
+ * @param decimals Number of fractional decimal places used by the asset.
+ * @returns Canonical decimal text with no redundant trailing zeroes.
+ * @throws BridgeError When the amount or decimal width is negative.
+ *
+ * @example
+ * formatDecimalAmount(2_000_001n, 6) // '2.000001'
+ */
+declare function formatDecimalAmount(amount: bigint, decimals: number): string;
+
+export { AleoClient, AleoHyperlaneGasQuote, AleoHyperlaneTransferRemoteCall, AleoHyperlaneTransferRemoteExecution, AleoMintMode, AleoPrivacyExecution, AleoWalletClient, BridgeChainClients, BridgeCheckpoint, BridgeEnvironment, BridgeError, BridgeExecution, BridgePlan, BridgeProgress, BridgeQuote, BridgeReceipt, BridgeRegistry, CompleteParameters, DEFAULT_BRIDGE_REGISTRY, EvmClient, EvmHyperlaneTransferExecution, EvmHyperlaneTransferQuote, EvmWalletClient, EvmXReserveTransferExecution, EvmXReserveTransferQuote, ExecuteAleoHyperlaneTransferRemoteParameters, ExecuteParameters, ExecuteXReserveBurnParameters, ExecuteXReservePrivateMintParameters, GetStatusParameters, GetXReserveAttestationParameters, type ProtocolHelperRegistry, QuoteParameters, type ReadHyperlaneDeliveryParameters, type ReadXReserveDeliveryParameters, RecoverParameters, ResumeParameters, ShieldParameters, SolanaClient, SolanaHyperlaneTransferExecution, SolanaHyperlaneTransferQuote, SolanaWalletClient, UnshieldParameters, WaitParameters, XReserveAttestationResult, XReserveBurnCall, XReserveBurnExecution, XReserveHttpTransport, XReservePrivateMintExecution, aleoAddressToBytes32, aleoProgramAddress, buildAleoHyperlaneTransferRemoteCall, buildXReserveBurnCall, buildXReserveDepositPayload, buildXReserveHookData, bytes32ToAleoAddress, calculateXReserveDepositNonce, calculateXReserveMessageHash, complete, createBridgeCheckpoint, evmAddressToAleoHyperlaneRecipient, evmAddressToXReserveBytes32, execute, formatDecimalAmount, getStatus, hyperlane, parseDecimalAmount, quote, readHyperlaneDelivery, readXReserveDelivery, recover, resume, shield, solanaAddressToAleoHyperlaneRecipient, unshield, validateBridgeRegistry, wait, xReserveDepositNonceFromPayload, xReserveHexToAleoBytes, xreserve };