@provablehq/aleo-bridge-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,3882 @@
+import {
+  BridgeError,
+  DEFAULT_SOLANA_RPC_URL,
+  aleoAddressToBytes32,
+  aleoProgramAddress,
+  buildTransferRemoteInstruction,
+  buildXReserveDepositPayload,
+  buildXReserveHookData,
+  bytes32ToAleoAddress,
+  calculateXReserveDepositNonce,
+  calculateXReserveMessageHash,
+  createSolanaClient,
+  evmAddressToXReserveBytes32,
+  loadKit,
+  quoteIgpGasPayment,
+  solanaCustom,
+  solanaHttp,
+  solanaKeyPair,
+  solanaWallet,
+  xReserveDepositNonceFromPayload,
+  xReserveHexToAleoBytes
+} from "./chunk-OU6GVGG7.js";
+
+// src/connections/resolve.ts
+function resolve(registry, clients, chainId, family) {
+  const chain = registry.chains.find((entry) => entry.id === chainId);
+  if (!chain) throw new BridgeError(`Unknown bridge chain: "${chainId}"`);
+  const client = clients[chainId];
+  if (!client) throw new BridgeError(`No client is configured for chain "${chainId}"`);
+  if (client.family !== chain.family || client.family !== family) {
+    throw new BridgeError(`Client "${chainId}" has family "${client.family}"; the registry declares "${chain.family}"`);
+  }
+  return client;
+}
+function requireEvmClient(registry, clients, chainId) {
+  return resolve(registry, clients, chainId, "evm");
+}
+function requireEvmClientWithWallet(registry, clients, chainId, action) {
+  const client = requireEvmClient(registry, clients, chainId);
+  if (!client.walletClient) throw new BridgeError(`EVM wallet client is required to ${action} on chain "${chainId}"`);
+  return client;
+}
+function requireSolanaClient(registry, clients, chainId) {
+  return resolve(registry, clients, chainId, "solana");
+}
+function requireSolanaClientWithWallet(registry, clients, chainId, action) {
+  const client = requireSolanaClient(registry, clients, chainId);
+  if (!client.walletClient) throw new BridgeError(`Solana wallet client is required to ${action} on chain "${chainId}"`);
+  return client;
+}
+function requireAleoClient(registry, clients, chainId) {
+  return resolve(registry, clients, chainId, "aleo");
+}
+function requireAleoClientWithWallet(registry, clients, chainId, action) {
+  const client = requireAleoClient(registry, clients, chainId);
+  if (!client.walletClient) throw new BridgeError(`Aleo wallet client is required to ${action} on chain "${chainId}"`);
+  return client;
+}
+
+// src/protocols/hyperlane/aleo.ts
+import { parsePlaintextValue, readContract } from "@provablehq/veil-core";
+
+// src/utils/hyperlane.ts
+import bs58 from "bs58";
+import { getAddress, hexToBytes, isAddress, padHex } from "viem";
+function littleEndianU128(bytes) {
+  let value = 0n;
+  for (let index = 0; index < bytes.length; index++) {
+    value |= BigInt(bytes[index]) << BigInt(index * 8);
+  }
+  return value;
+}
+function evmAddressToAleoHyperlaneRecipient(address) {
+  if (!isAddress(address)) throw new BridgeError(`Invalid Ethereum Hyperlane recipient: ${address}`);
+  const recipient = hexToBytes(padHex(getAddress(address), { size: 32 }));
+  return [
+    littleEndianU128(recipient.slice(0, 16)),
+    littleEndianU128(recipient.slice(16, 32))
+  ];
+}
+function solanaAddressToAleoHyperlaneRecipient(address) {
+  try {
+    const recipient = bs58.decode(address);
+    if (recipient.length !== 32) throw new Error("invalid public key width");
+    return [
+      littleEndianU128(recipient.slice(0, 16)),
+      littleEndianU128(recipient.slice(16, 32))
+    ];
+  } catch (cause) {
+    throw new BridgeError(`Invalid Solana Hyperlane recipient: ${address}`, { cause });
+  }
+}
+
+// src/utils/units.ts
+function parseDecimalAmount(amount, decimals) {
+  const match = /^(\d+)(?:\.(\d+))?$/.exec(amount.trim());
+  if (!match) {
+    throw new BridgeError(`Invalid decimal amount "${amount}"`);
+  }
+  const whole = match[1];
+  const frac = match[2] ?? "";
+  if (frac.length > decimals) {
+    throw new BridgeError(
+      `Amount "${amount}" has ${frac.length} fractional digits but the asset supports ${decimals}`
+    );
+  }
+  return BigInt(whole + frac.padEnd(decimals, "0"));
+}
+function formatDecimalAmount(amount, decimals) {
+  if (amount < 0n) throw new BridgeError("Atomic amount must be non-negative");
+  if (!Number.isSafeInteger(decimals) || decimals < 0) {
+    throw new BridgeError("Asset decimals must be a non-negative safe integer");
+  }
+  if (decimals === 0) return amount.toString();
+  const digits = amount.toString().padStart(decimals + 1, "0");
+  const whole = digits.slice(0, -decimals);
+  const fraction = digits.slice(-decimals).replace(/0+$/, "");
+  return fraction ? `${whole}.${fraction}` : whole;
+}
+
+// src/protocols/hyperlane/aleo.ts
+var MAX_U64 = (1n << 64n) - 1n;
+var GAS_QUOTE_SCALE = 10000000000n;
+var ZERO_GAS_LIMIT_FALLBACK = 50000n;
+var PLACEHOLDER_FIELDS = [
+  "aleoTokenType",
+  "aleoTokenOwner",
+  "aleoIsm",
+  "aleoHook",
+  "aleoTokenId",
+  "aleoMailboxDefaultHook",
+  "aleoMailboxRequiredHook",
+  "aleoRemoteRouterRecipient",
+  "aleoRemoteRouterGas",
+  "aleoRecipient",
+  "aleoAllowanceSpender0",
+  "aleoAllowanceAmount0",
+  "aleoAllowanceSpender1",
+  "aleoAllowanceAmount1",
+  "aleoAllowanceSpender2",
+  "aleoAllowanceAmount2",
+  "aleoAllowanceSpender3",
+  "aleoAllowanceAmount3"
+];
+var APP_METADATA_FIELDS = /* @__PURE__ */ new Set([
+  "aleoTokenType",
+  "aleoTokenOwner",
+  "aleoIsm",
+  "aleoHook",
+  "aleoTokenId"
+]);
+var MAILBOX_STATE_FIELDS = /* @__PURE__ */ new Set([
+  "aleoMailboxDefaultHook",
+  "aleoMailboxRequiredHook"
+]);
+var REMOTE_ROUTER_FIELDS = /* @__PURE__ */ new Set([
+  "aleoRemoteRouterRecipient",
+  "aleoRemoteRouterGas"
+]);
+var ALLOWANCE_SPENDER_FIELDS = /* @__PURE__ */ new Set([
+  "aleoAllowanceSpender0",
+  "aleoAllowanceSpender1",
+  "aleoAllowanceSpender2",
+  "aleoAllowanceSpender3"
+]);
+var UNUSED_ALLOWANCE_AMOUNT_FIELDS = /* @__PURE__ */ new Set([
+  "aleoAllowanceAmount1",
+  "aleoAllowanceAmount2",
+  "aleoAllowanceAmount3"
+]);
+function metadataString(route2, key) {
+  const value = route2.metadata?.[key];
+  if (typeof value !== "string" || value.length === 0) throw new BridgeError(`Hyperlane route metadata ${key} is missing: ${route2.id}`);
+  return value;
+}
+function metadataNumber(route2, key) {
+  const value = route2.metadata?.[key];
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw new BridgeError(`Hyperlane route metadata ${key} is invalid: ${route2.id}`);
+  return value;
+}
+function optionalMetadataNumber(route2, key, fallback) {
+  return route2.metadata?.[key] == null ? fallback : metadataNumber(route2, key);
+}
+function validatedRoute(registry, params) {
+  const { plan } = params;
+  if (plan.protocol !== "hyperlane" || plan.route.protocol !== "hyperlane") throw new BridgeError("Aleo transfer_remote requires a Hyperlane transfer plan");
+  if (plan.registryVersion !== registry.version) throw new BridgeError(`Transfer plan uses registry ${plan.registryVersion}; expected ${registry.version}`);
+  const route2 = registry.routes.find((entry) => entry.id === plan.route.id);
+  if (!route2 || route2.protocol !== "hyperlane") throw new BridgeError(`Hyperlane route is not configured: ${plan.route.id}`);
+  if (route2.sourceAssetId !== plan.sourceAsset.id || route2.destinationAssetId !== plan.destinationAsset.id) throw new BridgeError(`Transfer plan assets do not match configured route: ${route2.id}`);
+  const sourceChain = registry.chains.find((chain) => chain.id === plan.sourceAsset.chainId);
+  if (sourceChain?.family !== "aleo") throw new BridgeError("transfer_remote requires an Aleo source asset");
+  const destinationChain = registry.chains.find((chain) => chain.id === plan.destinationAsset.chainId);
+  if (!destinationChain) throw new BridgeError(`Destination chain is not configured: ${plan.destinationAsset.chainId}`);
+  const program = metadataString(route2, "aleoRouterProgram");
+  if (!program.endsWith(".aleo")) throw new BridgeError(`Aleo Warp Route program is invalid: ${route2.id}`);
+  return { route: route2, program, destinationChain };
+}
+function allowance(route2, index, amountOverride) {
+  const amount = amountOverride ?? metadataString(route2, `aleoAllowanceAmount${index}`);
+  return `{ spender: ${metadataString(route2, `aleoAllowanceSpender${index}`)}, amount: ${amount}u64 }`;
+}
+function gasConfigBigint(config, field, routeId) {
+  const value = config[field];
+  if (typeof value !== "bigint" || value < 0n) throw new BridgeError(`Hyperlane gas configuration field ${field} is invalid: ${routeId}`);
+  return value;
+}
+async function quote(registry, client, params) {
+  const route2 = registry.routes.find((entry) => entry.id === params.routeId);
+  if (!route2 || route2.protocol !== "hyperlane") throw new BridgeError(`Hyperlane route is not configured: ${params.routeId}`);
+  const sourceAsset = registry.assets.find((asset) => asset.id === route2.sourceAssetId);
+  const sourceChain = registry.chains.find((chain) => chain.id === sourceAsset?.chainId);
+  if (sourceChain?.family !== "aleo") throw new BridgeError(`Hyperlane gas quotes require an Aleo source asset: ${params.routeId}`);
+  const hookManager = metadataString(route2, "aleoHookManagerProgram");
+  const igp = metadataString(route2, "aleoMailboxDefaultHook");
+  const destination = metadataNumber(route2, "aleoDestinationDomain");
+  const gasLimitMetadata = BigInt(metadataString(route2, "aleoRemoteRouterGas"));
+  const literal = await readContract(client, {
+    programId: hookManager,
+    mapping: "destination_gas_configs",
+    key: `{ igp: ${igp}, destination: ${destination}u32 }`
+  });
+  if (literal == null) throw new BridgeError(`Hyperlane destination gas configuration is missing on chain: ${params.routeId}`);
+  const config = parsePlaintextValue(literal);
+  if (typeof config !== "object" || Array.isArray(config)) throw new BridgeError(`Hyperlane destination gas configuration is malformed: ${params.routeId}`);
+  const gasOverhead = gasConfigBigint(config, "gas_overhead", route2.id);
+  const exchangeRate = gasConfigBigint(config, "exchange_rate", route2.id);
+  const gasPrice = gasConfigBigint(config, "gas_price", route2.id);
+  if (exchangeRate === 0n || gasPrice === 0n) throw new BridgeError(`Hyperlane destination gas configuration is unpriced: ${params.routeId}`);
+  const gasLimit = gasLimitMetadata === 0n ? ZERO_GAS_LIMIT_FALLBACK : gasLimitMetadata;
+  const paymentMicrocredits = (gasLimit + gasOverhead) * gasPrice * exchangeRate / GAS_QUOTE_SCALE;
+  if (paymentMicrocredits <= 0n || paymentMicrocredits > MAX_U64) {
+    throw new BridgeError(`Hyperlane hook payment does not fit a positive u64: ${paymentMicrocredits}`);
+  }
+  return {
+    routeId: route2.id,
+    gasLimit,
+    gasOverhead,
+    gasPrice,
+    exchangeRate,
+    paymentMicrocredits,
+    // A public quote cannot authorize the program execution needed to price
+    // its Aleo network fee. Keep the absent total explicit so callers do not
+    // mistake the Hyperlane hook payment for their complete balance need.
+    executionFeeMicrocredits: null,
+    totalMicrocredits: null
+  };
+}
+function buildTransferRemoteCall(registry, params) {
+  if (params.mode != null && params.mode !== "caller" && params.mode !== "signer") {
+    throw new BridgeError(`Unsupported Aleo Hyperlane transfer mode: ${String(params.mode)}`);
+  }
+  const gasPayment = params.gasPaymentMicrocredits;
+  if (gasPayment != null && (gasPayment <= 0n || gasPayment > MAX_U64)) {
+    throw new BridgeError(`gasPaymentMicrocredits must be a positive u64: ${gasPayment}`);
+  }
+  const { route: route2, program, destinationChain } = validatedRoute(registry, params);
+  const amountAtomic = parseDecimalAmount(params.plan.amountIn, params.plan.sourceAsset.decimals);
+  const destination = metadataNumber(route2, "aleoDestinationDomain");
+  const localDecimals = optionalMetadataNumber(route2, "aleoLocalDecimals", params.plan.sourceAsset.decimals);
+  const remoteDecimals = optionalMetadataNumber(route2, "aleoRemoteDecimals", params.plan.destinationAsset.decimals);
+  const appMetadata = `{ token_type: ${metadataString(route2, "aleoTokenType")}u8, token_owner: ${metadataString(route2, "aleoTokenOwner")}, ism: ${metadataString(route2, "aleoIsm")}, hook: ${metadataString(route2, "aleoHook")}, token_id: ${metadataString(route2, "aleoTokenId")}, local_decimals: ${localDecimals}u8, remote_decimals: ${remoteDecimals}u8 }`;
+  const mailboxState = `{ default_hook: ${metadataString(route2, "aleoMailboxDefaultHook")}, required_hook: ${metadataString(route2, "aleoMailboxRequiredHook")} }`;
+  const remoteRouter = `{ domain: ${destination}u32, recipient: ${metadataString(route2, "aleoRemoteRouterRecipient")}, gas: ${metadataString(route2, "aleoRemoteRouterGas")}u128 }`;
+  const recipientLimbs = destinationChain.family === "evm" ? evmAddressToAleoHyperlaneRecipient(params.plan.recipient) : destinationChain.family === "solana" ? solanaAddressToAleoHyperlaneRecipient(params.plan.recipient) : void 0;
+  const recipient = recipientLimbs ? `[${recipientLimbs[0]}u128, ${recipientLimbs[1]}u128]` : metadataString(route2, "aleoRecipient");
+  const allowances = `[${[0, 1, 2, 3].map((index) => allowance(route2, index, index === 0 ? gasPayment?.toString() : void 0)).join(", ")}]`;
+  const usesPlaceholderConfiguration = route2.metadata?.aleoPlaceholderConfiguration === true;
+  let placeholderFields = route2.metadata?.aleoAppMetadataVerified === true ? PLACEHOLDER_FIELDS.filter((field) => !APP_METADATA_FIELDS.has(field)) : PLACEHOLDER_FIELDS;
+  if (route2.metadata?.aleoMailboxStateVerified === true) {
+    placeholderFields = placeholderFields.filter((field) => !MAILBOX_STATE_FIELDS.has(field));
+  }
+  if (route2.metadata?.aleoRemoteRouterVerified === true) {
+    placeholderFields = placeholderFields.filter((field) => !REMOTE_ROUTER_FIELDS.has(field));
+  }
+  if (route2.metadata?.aleoAllowanceSpendersVerified === true) {
+    placeholderFields = placeholderFields.filter((field) => !ALLOWANCE_SPENDER_FIELDS.has(field));
+  }
+  if (route2.metadata?.aleoUnusedAllowancesVerified === true) {
+    placeholderFields = placeholderFields.filter((field) => !UNUSED_ALLOWANCE_AMOUNT_FIELDS.has(field));
+  }
+  if (recipientLimbs) {
+    placeholderFields = placeholderFields.filter((field) => field !== "aleoRecipient");
+  }
+  if (gasPayment != null) {
+    placeholderFields = placeholderFields.filter((field) => field !== "aleoAllowanceAmount0");
+  }
+  const functionName = params.mode === "signer" ? "transfer_remote_as_signer" : "transfer_remote";
+  return {
+    routeId: route2.id,
+    program,
+    function: functionName,
+    inputs: [
+      appMetadata,
+      mailboxState,
+      remoteRouter,
+      `${destination}u32`,
+      recipient,
+      `${amountAtomic}u128`,
+      allowances
+    ],
+    amountAtomic,
+    usesPlaceholderConfiguration,
+    placeholderFields: usesPlaceholderConfiguration ? placeholderFields : gasPayment == null ? ["aleoAllowanceAmount0"] : []
+  };
+}
+async function execute(registry, client, params) {
+  const call = buildTransferRemoteCall(registry, params);
+  if (call.usesPlaceholderConfiguration) {
+    throw new BridgeError(`Aleo Hyperlane route contains non-executable placeholder configuration: ${call.routeId}`);
+  }
+  const route2 = registry.routes.find((entry) => entry.id === call.routeId);
+  if (route2?.availability !== "active") {
+    throw new BridgeError(`Aleo Hyperlane route is not active: ${call.routeId}`);
+  }
+  if (params.gasPaymentMicrocredits == null) {
+    throw new BridgeError(`Aleo Hyperlane execution requires a live hook gas payment; call quote first: ${call.routeId}`);
+  }
+  const transactionId = await client.executeTransaction({
+    program: call.program,
+    function: call.function,
+    inputs: call.inputs,
+    privateFee: params.privateFee ?? false,
+    onProgress: async (event) => {
+      await params.onProgress?.(event);
+      if (event.type === "transaction-prepared") await params.onPrepared?.(event.transaction);
+    }
+  });
+  if (!transactionId) throw new BridgeError("Aleo wallet returned an empty Hyperlane transaction id");
+  const receipt = {
+    id: transactionId,
+    protocol: "hyperlane",
+    status: "SOURCE_CONFIRMING",
+    sourceTxId: transactionId,
+    protocolState: { routeId: call.routeId, sourceProgram: call.program, sourceFunction: call.function }
+  };
+  await params.onSubmitted?.(receipt);
+  return {
+    transactionId,
+    receipt
+  };
+}
+
+// src/protocols/hyperlane/evm.ts
+import {
+  decodeEventLog,
+  decodeFunctionResult,
+  encodeFunctionData,
+  getAddress as getAddress2,
+  isAddress as isAddress2,
+  isHash,
+  parseAbi,
+  zeroAddress
+} from "viem";
+var WARP_ROUTE_ABI = parseAbi([
+  "function quoteTransferRemote(uint32 destination, bytes32 recipient, uint256 amount) view returns ((address token, uint256 amount)[] quotes)",
+  "function transferRemote(uint32 destination, bytes32 recipient, uint256 amount) payable returns (bytes32 messageId)",
+  "event SentTransferRemote(uint32 indexed destination, bytes32 indexed recipient, uint256 amount)"
+]);
+var ERC20_ABI = parseAbi([
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function approve(address spender, uint256 amount) returns (bool)"
+]);
+var DISPATCH_ID_ABI = parseAbi(["event DispatchId(bytes32 indexed messageId)"]);
+function isHexOfBytes(value, bytes) {
+  return new RegExp(`^0x[0-9a-fA-F]{${bytes * 2}}$`).test(value);
+}
+function routeMetadata(registry, plan) {
+  if (plan.protocol !== "hyperlane" || plan.route.protocol !== "hyperlane") {
+    throw new BridgeError("Ethereum Hyperlane actions require a Hyperlane transfer plan");
+  }
+  if (plan.registryVersion !== registry.version) {
+    throw new BridgeError(`Transfer plan uses registry ${plan.registryVersion}; expected ${registry.version}`);
+  }
+  const route2 = registry.routes.find((entry) => entry.id === plan.route.id);
+  if (!route2 || route2.protocol !== "hyperlane") {
+    throw new BridgeError(`Hyperlane route is not present in the configured registry: ${plan.route.id}`);
+  }
+  if (route2.sourceAssetId !== plan.sourceAsset.id || route2.destinationAssetId !== plan.destinationAsset.id) {
+    throw new BridgeError(`Transfer plan assets do not match configured route: ${route2.id}`);
+  }
+  if (route2.availability !== "active") {
+    throw new BridgeError(`Hyperlane route is not executable: ${route2.id}`);
+  }
+  const metadata2 = route2.metadata;
+  if (!metadata2) throw new BridgeError(`Hyperlane route metadata is missing: ${plan.route.id}`);
+  const routerAddress = metadata2.routerAddress;
+  const sourceChainId = metadata2.sourceChainId;
+  const destinationDomain = metadata2.destinationDomain;
+  const routerType = metadata2.routerType;
+  const tokenAddress = metadata2.tokenAddress;
+  const destinationRouter = metadata2.destinationRouter;
+  const mailboxAddress = metadata2.mailboxAddress;
+  const interchainGasPaymaster = metadata2.interchainGasPaymaster;
+  const interchainSecurityModule = metadata2.interchainSecurityModule;
+  const registryCommit = metadata2.registryCommit;
+  if (typeof routerAddress !== "string" || !isAddress2(routerAddress)) {
+    throw new BridgeError(`Hyperlane route has an invalid routerAddress: ${plan.route.id}`);
+  }
+  if (!Number.isInteger(sourceChainId) || typeof sourceChainId !== "number" || sourceChainId <= 0) {
+    throw new BridgeError(`Hyperlane route has an invalid sourceChainId: ${plan.route.id}`);
+  }
+  if (!Number.isInteger(destinationDomain) || typeof destinationDomain !== "number" || destinationDomain < 0 || destinationDomain > 4294967295) {
+    throw new BridgeError(`Hyperlane route has an invalid destinationDomain: ${plan.route.id}`);
+  }
+  if (routerType !== "native" && routerType !== "collateral") {
+    throw new BridgeError(`Hyperlane route has an invalid routerType: ${plan.route.id}`);
+  }
+  if (routerType === "collateral" && (typeof tokenAddress !== "string" || !isAddress2(tokenAddress))) {
+    throw new BridgeError(`Collateral Hyperlane route has an invalid tokenAddress: ${plan.route.id}`);
+  }
+  if (typeof destinationRouter !== "string" || destinationRouter.length === 0) {
+    throw new BridgeError(`Hyperlane route has an invalid destinationRouter: ${plan.route.id}`);
+  }
+  if (typeof mailboxAddress !== "string" || !isAddress2(mailboxAddress)) {
+    throw new BridgeError(`Hyperlane route has an invalid mailboxAddress: ${plan.route.id}`);
+  }
+  if (typeof interchainGasPaymaster !== "string" || !isAddress2(interchainGasPaymaster)) {
+    throw new BridgeError(`Hyperlane route has an invalid interchainGasPaymaster: ${plan.route.id}`);
+  }
+  if (typeof interchainSecurityModule !== "string" || !isAddress2(interchainSecurityModule)) {
+    throw new BridgeError(`Hyperlane route has an invalid interchainSecurityModule: ${plan.route.id}`);
+  }
+  if (typeof registryCommit !== "string" || !/^[0-9a-f]{40}$/i.test(registryCommit)) {
+    throw new BridgeError(`Hyperlane route has an invalid registryCommit: ${plan.route.id}`);
+  }
+  return {
+    routerAddress: getAddress2(routerAddress),
+    sourceChainId,
+    destinationDomain,
+    routerType,
+    ...typeof tokenAddress === "string" && isAddress2(tokenAddress) ? { tokenAddress: getAddress2(tokenAddress) } : {},
+    destinationRouter,
+    mailboxAddress: getAddress2(mailboxAddress),
+    interchainGasPaymaster: getAddress2(interchainGasPaymaster),
+    interchainSecurityModule: getAddress2(interchainSecurityModule),
+    registryCommit,
+    requiresApprovalReset: metadata2.requiresApprovalReset === true
+  };
+}
+function validateRecipient(recipientBytes32) {
+  if (!isHexOfBytes(recipientBytes32, 32)) {
+    throw new BridgeError("Hyperlane recipientBytes32 must contain exactly 32 bytes");
+  }
+}
+async function rpcCall(client, to, data) {
+  const result = await client.publicClient.call({ to, data });
+  if (typeof result !== "string" || !result.startsWith("0x")) {
+    throw new BridgeError("EVM public client returned an invalid eth_call result");
+  }
+  return result;
+}
+async function assertChain(client, expectedChainId) {
+  const actual = await client.publicClient.getChainId();
+  if (actual !== expectedChainId) {
+    throw new BridgeError(`EVM wallet is connected to chain ${actual}; expected ${expectedChainId}`);
+  }
+}
+async function resolveAccount(client, plan) {
+  const account2 = await client.walletClient.getAddress();
+  if (!isAddress2(account2)) throw new BridgeError("EVM wallet client account is invalid");
+  const normalized = getAddress2(account2);
+  if (plan.sender && (!isAddress2(plan.sender) || getAddress2(plan.sender) !== normalized)) {
+    throw new BridgeError(`Prepared sender ${plan.sender} does not match connected account ${normalized}`);
+  }
+  return normalized;
+}
+async function sendTransaction(client, chainId, transaction) {
+  const result = await client.walletClient.sendTransaction({
+    chainId,
+    from: transaction.from,
+    to: transaction.to,
+    data: transaction.data,
+    ...transaction.value ? { value: BigInt(transaction.value) } : {}
+  });
+  if (!isHash(result)) {
+    throw new BridgeError("EVM wallet client returned an invalid transaction hash");
+  }
+  return result;
+}
+async function waitForReceipt(client, hash, timeoutMs, pollingIntervalMs) {
+  const deadline = Date.now() + timeoutMs;
+  do {
+    const result = await client.publicClient.getTransactionReceipt(hash);
+    if (result != null && typeof result === "object") return result;
+    if (Date.now() >= deadline) return void 0;
+    await new Promise((resolve2) => setTimeout(resolve2, pollingIntervalMs));
+  } while (true);
+}
+function assertSuccessfulReceipt(receipt, hash) {
+  if (receipt.status === "reverted") throw new BridgeError(`EVM transaction reverted: ${hash}`);
+}
+function messageIdFromReceipt(receipt) {
+  for (const log of receipt.logs ?? []) {
+    try {
+      const signature = log.topics[0];
+      if (!signature) continue;
+      const decoded = decodeEventLog({
+        abi: DISPATCH_ID_ABI,
+        data: log.data,
+        topics: [signature, ...log.topics.slice(1)],
+        strict: false
+      });
+      const messageId = decoded.args.messageId;
+      if (decoded.eventName === "DispatchId" && messageId && isHash(messageId)) return messageId;
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function quote2(registry, client, params) {
+  validateRecipient(params.recipientBytes32);
+  const metadata2 = routeMetadata(registry, params.plan);
+  await assertChain(client, metadata2.sourceChainId);
+  const sourceAsset = registry.assets.find((asset) => asset.id === params.plan.sourceAsset.id);
+  const amountAtomic = parseDecimalAmount(params.plan.amountIn, sourceAsset.decimals);
+  const data = encodeFunctionData({
+    abi: WARP_ROUTE_ABI,
+    functionName: "quoteTransferRemote",
+    args: [metadata2.destinationDomain, params.recipientBytes32, amountAtomic]
+  });
+  const encoded = await rpcCall(client, metadata2.routerAddress, data);
+  const quotes = decodeFunctionResult({
+    abi: WARP_ROUTE_ABI,
+    functionName: "quoteTransferRemote",
+    data: encoded
+  });
+  const nativeValueAtomic = quotes.filter((quote6) => getAddress2(quote6.token) === zeroAddress).reduce((sum, quote6) => sum + quote6.amount, 0n);
+  if (metadata2.routerType === "native") {
+    if (nativeValueAtomic < amountAtomic) {
+      throw new BridgeError("Native Hyperlane quote does not cover the transfer amount");
+    }
+    return {
+      routeId: params.plan.route.id,
+      routerAddress: metadata2.routerAddress,
+      sourceChainId: metadata2.sourceChainId,
+      destinationDomain: metadata2.destinationDomain,
+      recipientBytes32: params.recipientBytes32,
+      amountAtomic,
+      nativeValueAtomic,
+      nativeFeeAtomic: nativeValueAtomic - amountAtomic
+    };
+  }
+  const tokenAddress = metadata2.tokenAddress;
+  const tokenAmountAtomic = quotes.filter((quote6) => getAddress2(quote6.token) === tokenAddress).reduce((sum, quote6) => sum + quote6.amount, 0n);
+  if (tokenAmountAtomic < amountAtomic) {
+    throw new BridgeError("Collateral Hyperlane quote does not cover the transfer amount");
+  }
+  return {
+    routeId: params.plan.route.id,
+    routerAddress: metadata2.routerAddress,
+    sourceChainId: metadata2.sourceChainId,
+    destinationDomain: metadata2.destinationDomain,
+    recipientBytes32: params.recipientBytes32,
+    amountAtomic,
+    nativeValueAtomic,
+    nativeFeeAtomic: nativeValueAtomic,
+    tokenAmountAtomic,
+    tokenAddress
+  };
+}
+function executionReceipt(plan, status, id, quote6, approvalTxIds, sourceSender, sourceTxId, messageId) {
+  return {
+    id,
+    protocol: "hyperlane",
+    status,
+    ...sourceTxId ? { sourceTxId } : {},
+    ...messageId ? { messageId } : {},
+    protocolState: {
+      routeId: plan.route.id,
+      approvalTxIds: [...approvalTxIds],
+      sourceSender,
+      recipientBytes32: quote6.recipientBytes32,
+      destinationDomain: quote6.destinationDomain,
+      nativeValueAtomic: quote6.nativeValueAtomic.toString(),
+      amountAtomic: quote6.amountAtomic.toString()
+    }
+  };
+}
+function checkpointApprovalIds(receipt) {
+  const ids = receipt.protocolState.approvalTxIds;
+  if (!Array.isArray(ids) || ids.some((id) => typeof id !== "string" || !isHash(id))) {
+    throw new BridgeError("Hyperlane checkpoint contains invalid approval transaction ids");
+  }
+  return [...ids];
+}
+function validateCheckpoint(registry, plan, metadata2, recipientBytes32, receipt) {
+  const state = receipt.protocolState;
+  const sourceAsset = registry.assets.find((asset) => asset.id === plan.sourceAsset.id);
+  if (!sourceAsset) throw new BridgeError(`Hyperlane source asset is not present in the configured registry: ${plan.sourceAsset.id}`);
+  const amountAtomic = parseDecimalAmount(plan.amountIn, sourceAsset.decimals).toString();
+  if (receipt.protocol !== "hyperlane" || state.routeId !== plan.route.id || state.destinationDomain !== metadata2.destinationDomain || state.amountAtomic !== amountAtomic || typeof state.recipientBytes32 !== "string" || state.recipientBytes32.toLowerCase() !== recipientBytes32.toLowerCase()) {
+    throw new BridgeError("Hyperlane checkpoint does not match the prepared transfer");
+  }
+}
+async function approvalScanBlock(client, approvalTxIds) {
+  let blockNumber;
+  for (const approvalTxId of approvalTxIds) {
+    const receipt = await client.publicClient.getTransactionReceipt(approvalTxId);
+    if (!receipt) continue;
+    assertSuccessfulReceipt(receipt, approvalTxId);
+    if (typeof receipt.blockNumber === "bigint" && (blockNumber === void 0 || receipt.blockNumber > blockNumber)) {
+      blockNumber = receipt.blockNumber;
+    }
+  }
+  return blockNumber;
+}
+async function recoverDispatchFromHistory(client, metadata2, recipientBytes32, receipt, approvalTxIds, options) {
+  const sourceSender = receipt.protocolState.sourceSender;
+  if (typeof sourceSender !== "string" || !isAddress2(sourceSender)) {
+    if (options.required) throw new BridgeError("Cannot safely resume Hyperlane without the source account used by the approval");
+    return void 0;
+  }
+  const fromBlock = await approvalScanBlock(client, approvalTxIds);
+  if (fromBlock === void 0) {
+    if (options.required) {
+      throw new BridgeError("Cannot safely resume Hyperlane because no confirmed approval block is available for source history verification");
+    }
+    return void 0;
+  }
+  const amountAtomic = receipt.protocolState.amountAtomic;
+  if (typeof amountAtomic !== "string" || !/^\d+$/.test(amountAtomic)) {
+    throw new BridgeError("Hyperlane checkpoint contains an invalid source amount");
+  }
+  const logs = await client.publicClient.getLogs({ address: metadata2.routerAddress, fromBlock });
+  const candidates = /* @__PURE__ */ new Set();
+  for (const log of logs) {
+    try {
+      const decoded = decodeEventLog({
+        abi: WARP_ROUTE_ABI,
+        data: log.data,
+        topics: log.topics
+      });
+      if (decoded.eventName === "SentTransferRemote" && decoded.args.destination === metadata2.destinationDomain && decoded.args.recipient.toLowerCase() === recipientBytes32.toLowerCase() && decoded.args.amount === BigInt(amountAtomic)) {
+        candidates.add(log.transactionHash);
+      }
+    } catch {
+    }
+  }
+  const matches = [];
+  for (const transactionHash of candidates) {
+    const [transaction, sourceReceipt] = await Promise.all([
+      client.publicClient.getTransaction(transactionHash),
+      client.publicClient.getTransactionReceipt(transactionHash)
+    ]);
+    if (!transaction || !sourceReceipt || getAddress2(transaction.from) !== getAddress2(sourceSender) || !transaction.to || getAddress2(transaction.to) !== metadata2.routerAddress) continue;
+    assertSuccessfulReceipt(sourceReceipt, transactionHash);
+    const messageId = messageIdFromReceipt(sourceReceipt);
+    matches.push({
+      ...receipt,
+      id: messageId ?? transactionHash,
+      status: "DELIVERY_PENDING",
+      sourceTxId: transactionHash,
+      ...messageId ? { messageId } : {}
+    });
+  }
+  if (matches.length > 1) {
+    throw new BridgeError("Multiple matching Hyperlane dispatches were found; recovery cannot safely choose one source transaction");
+  }
+  return matches[0];
+}
+async function getSourceStatus(registry, client, plan, recipientBytes32, receipt) {
+  const metadata2 = routeMetadata(registry, plan);
+  await assertChain(client, metadata2.sourceChainId);
+  validateCheckpoint(registry, plan, metadata2, recipientBytes32, receipt);
+  if (receipt.status !== "SOURCE_CONFIRMING") {
+    throw new BridgeError("Hyperlane source status requires a source-confirming receipt");
+  }
+  const sourceTxId = receipt.sourceTxId;
+  if (!sourceTxId || !isHash(sourceTxId)) {
+    throw new BridgeError("Hyperlane checkpoint is missing the source transaction id");
+  }
+  const sourceReceipt = await client.publicClient.getTransactionReceipt(sourceTxId);
+  if (!sourceReceipt) return receipt;
+  assertSuccessfulReceipt(sourceReceipt, sourceTxId);
+  const messageId = messageIdFromReceipt(sourceReceipt);
+  return {
+    ...receipt,
+    id: messageId ?? sourceTxId,
+    status: "DELIVERY_PENDING",
+    ...messageId ? { messageId } : {}
+  };
+}
+async function recoverSourceCheckpoint(registry, client, plan, recipientBytes32, checkpoint) {
+  if (checkpoint.version !== 1 || checkpoint.intent.bridgeProtocol !== "hyperlane" || checkpoint.route.id !== plan.route.id) {
+    throw new BridgeError("Bridge checkpoint does not match the prepared route");
+  }
+  const metadata2 = routeMetadata(registry, plan);
+  const sourceAsset = registry.assets.find((asset) => asset.id === plan.sourceAsset.id);
+  if (!sourceAsset) throw new BridgeError(`Hyperlane source asset is not present in the configured registry: ${plan.sourceAsset.id}`);
+  const approvals = [...checkpoint.source?.approvalTransactionIds ?? []];
+  if (approvals.some((id) => !isHash(id))) throw new BridgeError("Bridge checkpoint contains an invalid approval transaction id");
+  const approvalTxIds = approvals;
+  const protocolState = {
+    routeId: plan.route.id,
+    approvalTxIds,
+    recipientBytes32,
+    destinationDomain: metadata2.destinationDomain,
+    nativeValueAtomic: "0",
+    amountAtomic: parseDecimalAmount(plan.amountIn, sourceAsset.decimals).toString(),
+    ...plan.sender && isAddress2(plan.sender) ? { sourceSender: getAddress2(plan.sender) } : {}
+  };
+  if (!checkpoint.source?.transactionId) {
+    const approvalTxId = approvalTxIds.at(-1);
+    if (!approvalTxId) throw new BridgeError("Bridge checkpoint contains no submitted transaction");
+    const pending2 = {
+      id: approvalTxId,
+      protocol: "hyperlane",
+      status: "SOURCE_APPROVAL_PENDING",
+      protocolState
+    };
+    const approvalReceipt = await client.publicClient.getTransactionReceipt(approvalTxId);
+    if (!approvalReceipt) return pending2;
+    assertSuccessfulReceipt(approvalReceipt, approvalTxId);
+    const recovered = await recoverDispatchFromHistory(
+      client,
+      metadata2,
+      recipientBytes32,
+      pending2,
+      approvalTxIds,
+      { required: false }
+    );
+    if (recovered) return recovered;
+    return { ...pending2, status: "SOURCE_SUBMISSION_PENDING" };
+  }
+  if (!isHash(checkpoint.source.transactionId)) throw new BridgeError("Bridge checkpoint contains an invalid source transaction id");
+  const pending = {
+    id: checkpoint.source.transactionId,
+    protocol: "hyperlane",
+    status: "SOURCE_CONFIRMING",
+    sourceTxId: checkpoint.source.transactionId,
+    protocolState
+  };
+  const observed = await getSourceStatus(registry, client, plan, recipientBytes32, pending);
+  if (observed !== pending) return observed;
+  return await recoverDispatchFromHistory(
+    client,
+    metadata2,
+    recipientBytes32,
+    pending,
+    approvalTxIds,
+    { required: false }
+  ) ?? observed;
+}
+async function execute2(registry, client, params) {
+  const pollingIntervalMs = params.pollingIntervalMs ?? 1e3;
+  const confirmationTimeoutMs = params.confirmationTimeoutMs ?? 12e4;
+  if (!Number.isFinite(pollingIntervalMs) || pollingIntervalMs < 0) {
+    throw new BridgeError("pollingIntervalMs must be a non-negative finite number");
+  }
+  if (!Number.isFinite(confirmationTimeoutMs) || confirmationTimeoutMs < 0) {
+    throw new BridgeError("confirmationTimeoutMs must be a non-negative finite number");
+  }
+  const metadata2 = routeMetadata(registry, params.plan);
+  await assertChain(client, metadata2.sourceChainId);
+  let approvalTxIds = [];
+  if (params.resume) {
+    validateCheckpoint(registry, params.plan, metadata2, params.recipientBytes32, params.resume);
+    approvalTxIds = checkpointApprovalIds(params.resume);
+    if (params.resume.status === "DELIVERY_PENDING") {
+      return { approvalTxIds, receipt: params.resume };
+    }
+    if (params.resume.status === "SOURCE_CONFIRMING") {
+      const sourceTxId2 = params.resume.sourceTxId;
+      if (!sourceTxId2 || !isHash(sourceTxId2)) throw new BridgeError("Hyperlane checkpoint is missing the source transaction id");
+      const sourceReceipt2 = await waitForReceipt(client, sourceTxId2, confirmationTimeoutMs, pollingIntervalMs);
+      if (!sourceReceipt2) return { approvalTxIds, receipt: params.resume };
+      assertSuccessfulReceipt(sourceReceipt2, sourceTxId2);
+      const messageId2 = messageIdFromReceipt(sourceReceipt2);
+      return {
+        approvalTxIds,
+        receipt: {
+          ...params.resume,
+          id: messageId2 ?? sourceTxId2,
+          status: "DELIVERY_PENDING",
+          ...messageId2 ? { messageId: messageId2 } : {}
+        }
+      };
+    }
+    if (params.resume.status === "SOURCE_SUBMISSION_PENDING") {
+      const recovered = await recoverDispatchFromHistory(
+        client,
+        metadata2,
+        params.recipientBytes32,
+        params.resume,
+        approvalTxIds,
+        { required: true }
+      );
+      if (recovered) return { approvalTxIds, receipt: recovered };
+    } else if (params.resume.status === "SOURCE_APPROVAL_PENDING") {
+      const approvalTxId = approvalTxIds.at(-1);
+      if (!approvalTxId) throw new BridgeError("Hyperlane checkpoint is missing the approval transaction id");
+      const approvalReceipt = await waitForReceipt(client, approvalTxId, confirmationTimeoutMs, pollingIntervalMs);
+      if (!approvalReceipt) return { approvalTxIds, receipt: params.resume };
+      assertSuccessfulReceipt(approvalReceipt, approvalTxId);
+    } else {
+      throw new BridgeError(`Unsupported Hyperlane resume status: ${params.resume.status}`);
+    }
+  }
+  const transferQuote = await quote2(registry, client, params);
+  const account2 = await resolveAccount(client, params.plan);
+  if (metadata2.routerType === "collateral") {
+    const allowanceData = encodeFunctionData({
+      abi: ERC20_ABI,
+      functionName: "allowance",
+      args: [account2, metadata2.routerAddress]
+    });
+    const allowanceResult = await rpcCall(client, metadata2.tokenAddress, allowanceData);
+    const allowance2 = decodeFunctionResult({
+      abi: ERC20_ABI,
+      functionName: "allowance",
+      data: allowanceResult
+    });
+    const required = transferQuote.tokenAmountAtomic;
+    const approveAndConfirm = async (amount) => {
+      const data = encodeFunctionData({
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [metadata2.routerAddress, amount]
+      });
+      const hash = await sendTransaction(client, metadata2.sourceChainId, { from: account2, to: metadata2.tokenAddress, data });
+      approvalTxIds.push(hash);
+      const checkpoint2 = executionReceipt(params.plan, "SOURCE_APPROVAL_PENDING", hash, transferQuote, approvalTxIds, account2);
+      await params.onSubmitted?.(checkpoint2);
+      const receipt = await waitForReceipt(client, hash, confirmationTimeoutMs, pollingIntervalMs);
+      if (!receipt) return false;
+      assertSuccessfulReceipt(receipt, hash);
+      return true;
+    };
+    if (allowance2 < required) {
+      if (allowance2 > 0n && metadata2.requiresApprovalReset) {
+        if (!await approveAndConfirm(0n)) {
+          return {
+            approvalTxIds,
+            receipt: executionReceipt(params.plan, "SOURCE_APPROVAL_PENDING", approvalTxIds.at(-1), transferQuote, approvalTxIds, account2)
+          };
+        }
+      }
+      if (!await approveAndConfirm(required)) {
+        return {
+          approvalTxIds,
+          receipt: executionReceipt(params.plan, "SOURCE_APPROVAL_PENDING", approvalTxIds.at(-1), transferQuote, approvalTxIds, account2)
+        };
+      }
+    }
+  }
+  const transferData = encodeFunctionData({
+    abi: WARP_ROUTE_ABI,
+    functionName: "transferRemote",
+    args: [transferQuote.destinationDomain, transferQuote.recipientBytes32, transferQuote.amountAtomic]
+  });
+  const sourceTxId = await sendTransaction(client, metadata2.sourceChainId, {
+    from: account2,
+    to: transferQuote.routerAddress,
+    data: transferData,
+    value: `0x${transferQuote.nativeValueAtomic.toString(16)}`
+  });
+  const checkpoint = executionReceipt(params.plan, "SOURCE_CONFIRMING", sourceTxId, transferQuote, approvalTxIds, account2, sourceTxId);
+  await params.onSubmitted?.(checkpoint);
+  const sourceReceipt = await waitForReceipt(
+    client,
+    sourceTxId,
+    confirmationTimeoutMs,
+    pollingIntervalMs
+  );
+  if (!sourceReceipt) {
+    return {
+      approvalTxIds,
+      receipt: checkpoint
+    };
+  }
+  assertSuccessfulReceipt(sourceReceipt, sourceTxId);
+  const messageId = messageIdFromReceipt(sourceReceipt);
+  return {
+    approvalTxIds,
+    receipt: executionReceipt(
+      params.plan,
+      "DELIVERY_PENDING",
+      messageId ?? sourceTxId,
+      transferQuote,
+      approvalTxIds,
+      account2,
+      sourceTxId,
+      messageId
+    )
+  };
+}
+
+// src/solana/extractHyperlaneMessageId.ts
+var DISPATCHED_MESSAGE_LOG_PATTERN = /Dispatched message to \d+, ID (0x[0-9a-fA-F]{64})/;
+function extractSolanaHyperlaneMessageId(logs) {
+  if (!logs) return void 0;
+  for (const line of logs) {
+    const match = DISPATCHED_MESSAGE_LOG_PATTERN.exec(line);
+    if (match) return match[1];
+  }
+  return void 0;
+}
+
+// src/protocols/hyperlane/solanaMetadata.ts
+var SOLANA_PUBKEY = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
+function requirePubkey(value, field, routeId) {
+  if (typeof value !== "string" || !SOLANA_PUBKEY.test(value)) {
+    throw new BridgeError(`Solana Hyperlane route has an invalid ${field}: ${routeId}`);
+  }
+  return value;
+}
+function solanaRouteMetadata(registry, plan) {
+  if (plan.protocol !== "hyperlane" || plan.route.protocol !== "hyperlane") {
+    throw new BridgeError("Solana Hyperlane actions require a Hyperlane transfer plan");
+  }
+  if (plan.registryVersion !== registry.version) {
+    throw new BridgeError(`Transfer plan uses registry ${plan.registryVersion}; expected ${registry.version}`);
+  }
+  const route2 = registry.routes.find((entry) => entry.id === plan.route.id);
+  if (!route2 || route2.protocol !== "hyperlane") {
+    throw new BridgeError(`Hyperlane route is not present in the configured registry: ${plan.route.id}`);
+  }
+  if (route2.sourceAssetId !== plan.sourceAsset.id || route2.destinationAssetId !== plan.destinationAsset.id) {
+    throw new BridgeError(`Transfer plan assets do not match configured route: ${route2.id}`);
+  }
+  if (route2.availability !== "active") {
+    throw new BridgeError(`Hyperlane route is not executable: ${route2.id}`);
+  }
+  const metadata2 = route2.metadata;
+  if (!metadata2) throw new BridgeError(`Solana Hyperlane route metadata is missing: ${plan.route.id}`);
+  const routeId = plan.route.id;
+  const warpProgramAddress = requirePubkey(metadata2.warpProgramAddress, "warpProgramAddress", routeId);
+  const tokenPda = requirePubkey(metadata2.tokenPda, "tokenPda", routeId);
+  const nativeCollateralPda = requirePubkey(metadata2.nativeCollateralPda, "nativeCollateralPda", routeId);
+  const dispatchAuthorityPda = requirePubkey(metadata2.dispatchAuthorityPda, "dispatchAuthorityPda", routeId);
+  const mailboxProgramAddress = requirePubkey(metadata2.mailboxProgramAddress, "mailboxProgramAddress", routeId);
+  const mailboxOutboxPda = requirePubkey(metadata2.mailboxOutboxPda, "mailboxOutboxPda", routeId);
+  const igpProgramAddress = requirePubkey(metadata2.igpProgramAddress, "igpProgramAddress", routeId);
+  const igpProgramDataPda = requirePubkey(metadata2.igpProgramDataPda, "igpProgramDataPda", routeId);
+  const igpAccount = requirePubkey(metadata2.igpAccount, "igpAccount", routeId);
+  const splNoopProgramAddress = requirePubkey(metadata2.splNoopProgramAddress, "splNoopProgramAddress", routeId);
+  const igpOverheadAccountRaw = metadata2.igpOverheadAccount;
+  const igpOverheadAccount = igpOverheadAccountRaw == null ? void 0 : requirePubkey(igpOverheadAccountRaw, "igpOverheadAccount", routeId);
+  const destinationDomain = metadata2.destinationDomain;
+  if (typeof destinationDomain !== "number" || !Number.isInteger(destinationDomain) || destinationDomain < 0 || destinationDomain > 4294967295) {
+    throw new BridgeError(`Solana Hyperlane route has an invalid destinationDomain: ${routeId}`);
+  }
+  const destinationGasAmount = metadata2.destinationGasAmount;
+  if (typeof destinationGasAmount !== "string" || !/^\d+$/.test(destinationGasAmount)) {
+    throw new BridgeError(`Solana Hyperlane route has an invalid destinationGasAmount: ${routeId}`);
+  }
+  const registryCommit = metadata2.registryCommit;
+  if (typeof registryCommit !== "string" || !/^[0-9a-f]{40}$/i.test(registryCommit)) {
+    throw new BridgeError(`Solana Hyperlane route has an invalid registryCommit: ${routeId}`);
+  }
+  const solanaReviewedAt = metadata2.solanaReviewedAt;
+  if (typeof solanaReviewedAt !== "string" || Number.isNaN(Date.parse(solanaReviewedAt))) {
+    throw new BridgeError(`Solana Hyperlane route has an invalid solanaReviewedAt: ${routeId}`);
+  }
+  const solanaConfigSource = metadata2.solanaConfigSource;
+  if (typeof solanaConfigSource !== "string" || solanaConfigSource.length === 0) {
+    throw new BridgeError(`Solana Hyperlane route has an invalid solanaConfigSource: ${routeId}`);
+  }
+  return {
+    warpProgramAddress,
+    tokenPda,
+    nativeCollateralPda,
+    dispatchAuthorityPda,
+    mailboxProgramAddress,
+    mailboxOutboxPda,
+    igpProgramAddress,
+    igpProgramDataPda,
+    igpAccount,
+    ...igpOverheadAccount == null ? {} : { igpOverheadAccount },
+    splNoopProgramAddress,
+    destinationDomain,
+    destinationGasAmount,
+    registryCommit,
+    solanaReviewedAt,
+    solanaConfigSource
+  };
+}
+
+// src/protocols/hyperlane/solana.ts
+var GAS_PAYMENT_ACCOUNT_DATA_LENGTH = 141;
+var DISPATCHED_MESSAGE_ACCOUNT_DATA_LENGTH = 194;
+var SOLANA_HYPERLANE_COMPUTE_UNIT_LIMIT = 4e5;
+function accountRole(kit, account2) {
+  if (account2.signer && account2.writable) return kit.AccountRole.WRITABLE_SIGNER;
+  if (account2.signer) return kit.AccountRole.READONLY_SIGNER;
+  if (account2.writable) return kit.AccountRole.WRITABLE;
+  return kit.AccountRole.READONLY;
+}
+async function quote3(registry, client, params) {
+  const metadata2 = solanaRouteMetadata(registry, params.plan);
+  const rpc = client.publicClient;
+  const amountLamports = parseDecimalAmount(params.plan.amountIn, params.plan.sourceAsset.decimals);
+  const igpAccountData = await rpc.getAccountData(metadata2.igpAccount);
+  if (!igpAccountData) throw new BridgeError(`Solana IGP account does not exist: ${metadata2.igpAccount}`);
+  const igpPaymentLamports = quoteIgpGasPayment({
+    igpAccountData,
+    destinationDomain: metadata2.destinationDomain,
+    gasAmount: BigInt(metadata2.destinationGasAmount)
+  });
+  if (!params.plan.sender) throw new BridgeError("Solana sender is required to quote the transaction fee");
+  const kit = await loadKit();
+  const uniqueMessageSigner = await kit.generateKeyPairSigner();
+  const built = await buildTransferRemoteInstruction({
+    metadata: metadata2,
+    senderAddress: params.plan.sender,
+    uniqueMessageAddress: uniqueMessageSigner.address,
+    recipientAleoAddress: params.plan.recipient,
+    amountLamports
+  });
+  const { blockhash, lastValidBlockHeight } = await rpc.getLatestBlockhash();
+  const message = kit.pipe(
+    kit.createTransactionMessage({ version: 0 }),
+    (transaction) => kit.setTransactionMessageFeePayer(kit.address(params.plan.sender), transaction),
+    (transaction) => kit.setTransactionMessageLifetimeUsingBlockhash({ blockhash: kit.blockhash(blockhash), lastValidBlockHeight }, transaction),
+    (transaction) => kit.setTransactionMessageComputeUnitLimit(SOLANA_HYPERLANE_COMPUTE_UNIT_LIMIT, transaction),
+    (transaction) => kit.appendTransactionMessageInstruction({
+      programAddress: kit.address(built.programAddress),
+      accounts: built.accounts.map((account2) => ({ address: kit.address(account2.address), role: accountRole(kit, account2) })),
+      data: built.data
+    }, transaction)
+  );
+  const compiled = kit.compileTransaction(message);
+  const [networkFeeLamports, gasPaymentRent, dispatchedMessageRent, senderRent] = await Promise.all([
+    rpc.getFeeForMessage(new Uint8Array(compiled.messageBytes)),
+    rpc.getMinimumBalanceForRentExemption(GAS_PAYMENT_ACCOUNT_DATA_LENGTH),
+    rpc.getMinimumBalanceForRentExemption(DISPATCHED_MESSAGE_ACCOUNT_DATA_LENGTH),
+    rpc.getMinimumBalanceForRentExemption(0)
+  ]);
+  const rentLamports = gasPaymentRent + dispatchedMessageRent + senderRent;
+  return {
+    routeId: params.plan.route.id,
+    amountLamports,
+    igpPaymentLamports,
+    networkFeeLamports,
+    rentLamports,
+    totalLamports: amountLamports + igpPaymentLamports + networkFeeLamports + rentLamports
+  };
+}
+async function pollForConfirmation(rpc, signature, pollingIntervalMs, confirmationTimeoutMs, blockhash) {
+  const deadline = Date.now() + confirmationTimeoutMs;
+  do {
+    let status;
+    try {
+      status = await rpc.getSignatureStatus(signature);
+    } catch {
+      status = null;
+    }
+    if (status === "failed") {
+      throw new BridgeError(`Solana Hyperlane transfer failed on-chain: ${signature}`);
+    }
+    if (status === "confirmed" || status === "finalized") return status;
+    try {
+      if (!await rpc.isBlockhashValid(blockhash)) return "expired";
+    } catch {
+    }
+    if (Date.now() >= deadline) return void 0;
+    await new Promise((resolve2) => setTimeout(resolve2, pollingIntervalMs));
+  } while (true);
+}
+function buildReceipt(status, signature, routeId, metadata2, uniqueMessageAddress, quote6, blockhash, lastValidBlockHeight, messageId, blockhashExpired = false) {
+  return {
+    id: messageId ?? signature,
+    protocol: "hyperlane",
+    status,
+    sourceTxId: signature,
+    ...messageId ? { messageId } : {},
+    protocolState: {
+      routeId,
+      signature,
+      uniqueMessageAddress,
+      destinationDomain: metadata2.destinationDomain,
+      quotedLamports: quote6.totalLamports.toString(),
+      blockhash,
+      lastValidBlockHeight: lastValidBlockHeight.toString(),
+      ...blockhashExpired ? { blockhashExpired: true } : {},
+      // The transaction confirmed but the Mailbox dispatch log line was
+      // absent or unparsable — note it rather than throwing.
+      ...status === "DELIVERY_PENDING" && !messageId ? { messageIdUnavailable: true } : {}
+    }
+  };
+}
+async function getSourceStatus2(client, receipt) {
+  if (receipt.protocol !== "hyperlane" || receipt.status !== "SOURCE_CONFIRMING" || !receipt.sourceTxId) {
+    throw new BridgeError("Solana Hyperlane source status requires a source-confirming receipt");
+  }
+  const status = await client.publicClient.getSignatureStatus(receipt.sourceTxId);
+  if (status == null) {
+    const { blockhash, lastValidBlockHeight } = receipt.protocolState;
+    if (blockhash === void 0 && lastValidBlockHeight === void 0) return receipt;
+    if (typeof blockhash !== "string" || !blockhash || typeof lastValidBlockHeight !== "string" || !/^\d+$/.test(lastValidBlockHeight)) {
+      throw new BridgeError("Solana Hyperlane source receipt has an invalid blockhash lifetime");
+    }
+    try {
+      if (!await client.publicClient.isBlockhashValid(blockhash)) {
+        return {
+          ...receipt,
+          status: "EXPIRED",
+          protocolState: {
+            ...receipt.protocolState,
+            blockhashExpired: true,
+            sourceError: `Solana transaction expired before confirmation: ${receipt.sourceTxId}`
+          }
+        };
+      }
+    } catch {
+      return receipt;
+    }
+    return receipt;
+  }
+  if (status === "processed") return receipt;
+  if (status === "failed") throw new BridgeError(`Solana Hyperlane transfer failed on-chain: ${receipt.sourceTxId}`);
+  const messageId = extractSolanaHyperlaneMessageId(await client.publicClient.getTransactionLogs(receipt.sourceTxId));
+  return {
+    ...receipt,
+    id: messageId ?? receipt.sourceTxId,
+    status: "DELIVERY_PENDING",
+    ...messageId ? { messageId } : {},
+    protocolState: {
+      ...receipt.protocolState,
+      ...!messageId ? { messageIdUnavailable: true } : {}
+    }
+  };
+}
+async function execute3(registry, client, params) {
+  const rpc = client.publicClient;
+  const walletClient = client.walletClient;
+  const requestedPollingIntervalMs = params.pollingIntervalMs ?? 1e3;
+  const confirmationTimeoutMs = params.confirmationTimeoutMs ?? 12e4;
+  if (!Number.isFinite(requestedPollingIntervalMs) || requestedPollingIntervalMs < 0) {
+    throw new BridgeError("pollingIntervalMs must be a non-negative finite number");
+  }
+  if (!Number.isFinite(confirmationTimeoutMs) || confirmationTimeoutMs < 0) {
+    throw new BridgeError("confirmationTimeoutMs must be a non-negative finite number");
+  }
+  const pollingIntervalMs = Math.max(requestedPollingIntervalMs, 100);
+  const metadata2 = solanaRouteMetadata(registry, params.plan);
+  if (params.resume) {
+    const receipt = params.resume;
+    const state = receipt.protocolState;
+    if (receipt.protocol !== "hyperlane" || receipt.status !== "SOURCE_CONFIRMING" && receipt.status !== "DELIVERY_PENDING" || typeof receipt.sourceTxId !== "string" || state.routeId !== params.plan.route.id || state.destinationDomain !== metadata2.destinationDomain) {
+      throw new BridgeError("Solana Hyperlane resume receipt does not match the prepared route");
+    }
+    if (receipt.status === "DELIVERY_PENDING" || state.blockhashExpired === true) {
+      return { receipt };
+    }
+    if (typeof state.blockhash !== "string" || typeof state.lastValidBlockHeight !== "string" || !/^\d+$/.test(state.lastValidBlockHeight)) {
+      throw new BridgeError("Solana Hyperlane resume receipt is missing its blockhash lifetime");
+    }
+    const signature2 = receipt.sourceTxId;
+    try {
+      const confirmation = await pollForConfirmation(
+        client.publicClient,
+        signature2,
+        pollingIntervalMs,
+        confirmationTimeoutMs,
+        state.blockhash
+      );
+      if (!confirmation) return { receipt };
+      if (confirmation === "expired") {
+        return { receipt: { ...receipt, protocolState: { ...state, blockhashExpired: true } } };
+      }
+      const messageId = extractSolanaHyperlaneMessageId(await client.publicClient.getTransactionLogs(signature2));
+      return {
+        receipt: {
+          ...receipt,
+          id: messageId ?? signature2,
+          status: "DELIVERY_PENDING",
+          ...messageId ? { messageId } : {},
+          protocolState: {
+            ...state,
+            ...!messageId ? { messageIdUnavailable: true } : {}
+          }
+        }
+      };
+    } catch (error) {
+      if (error instanceof BridgeError && error.message.includes(signature2)) throw error;
+      const message2 = error instanceof Error ? error.message : String(error);
+      throw new BridgeError(`Solana Hyperlane transfer ${signature2} was submitted, but confirmation failed: ${message2}`);
+    }
+  }
+  const senderAddress = await walletClient.getAddress();
+  if (params.plan.sender && params.plan.sender !== senderAddress) {
+    throw new BridgeError(`Prepared sender ${params.plan.sender} does not match connected account ${senderAddress}`);
+  }
+  const transferQuote = await quote3(registry, client, { plan: { ...params.plan, sender: senderAddress } });
+  const requiredLamports = transferQuote.totalLamports;
+  const balance = await rpc.getBalance(senderAddress);
+  if (balance < requiredLamports) {
+    throw new BridgeError(
+      `Insufficient Solana balance for this Hyperlane transfer: balance ${balance} lamports, required ${requiredLamports} lamports (amount ${transferQuote.amountLamports} + gas ${transferQuote.igpPaymentLamports + transferQuote.networkFeeLamports} + rent ${transferQuote.rentLamports})`
+    );
+  }
+  const kit = await loadKit();
+  const uniqueMessageSigner = await kit.generateKeyPairSigner();
+  const built = await buildTransferRemoteInstruction({
+    metadata: metadata2,
+    senderAddress,
+    uniqueMessageAddress: uniqueMessageSigner.address,
+    recipientAleoAddress: params.plan.recipient,
+    amountLamports: transferQuote.amountLamports
+  });
+  const instruction = {
+    programAddress: kit.address(built.programAddress),
+    accounts: built.accounts.map((account2) => ({
+      address: kit.address(account2.address),
+      role: accountRole(kit, account2)
+    })),
+    data: built.data
+  };
+  const { blockhash, lastValidBlockHeight } = await rpc.getLatestBlockhash();
+  const message = kit.pipe(
+    kit.createTransactionMessage({ version: 0 }),
+    (tx) => kit.setTransactionMessageFeePayer(kit.address(senderAddress), tx),
+    (tx) => kit.setTransactionMessageLifetimeUsingBlockhash(
+      { blockhash: kit.blockhash(blockhash), lastValidBlockHeight },
+      tx
+    ),
+    (tx) => kit.setTransactionMessageComputeUnitLimit(SOLANA_HYPERLANE_COMPUTE_UNIT_LIMIT, tx),
+    (tx) => kit.appendTransactionMessageInstruction(instruction, tx)
+  );
+  const compiledTransaction = kit.compileTransaction(message);
+  const signedTransaction = await kit.partiallySignTransaction(
+    [uniqueMessageSigner.keyPair],
+    compiledTransaction
+  );
+  const wireTransaction = new Uint8Array(kit.getTransactionEncoder().encode(signedTransaction));
+  const { signature } = await walletClient.sendTransaction(wireTransaction);
+  const submittedReceipt = buildReceipt(
+    "SOURCE_CONFIRMING",
+    signature,
+    params.plan.route.id,
+    metadata2,
+    uniqueMessageSigner.address,
+    transferQuote,
+    blockhash,
+    lastValidBlockHeight
+  );
+  await params.onSubmitted?.(submittedReceipt);
+  try {
+    const confirmation = await pollForConfirmation(rpc, signature, pollingIntervalMs, confirmationTimeoutMs, blockhash);
+    if (!confirmation) {
+      return {
+        receipt: submittedReceipt
+      };
+    }
+    if (confirmation === "expired") {
+      return {
+        receipt: buildReceipt("SOURCE_CONFIRMING", signature, params.plan.route.id, metadata2, uniqueMessageSigner.address, transferQuote, blockhash, lastValidBlockHeight, void 0, true)
+      };
+    }
+    const logs = await rpc.getTransactionLogs(signature);
+    const messageId = extractSolanaHyperlaneMessageId(logs);
+    return {
+      receipt: buildReceipt("DELIVERY_PENDING", signature, params.plan.route.id, metadata2, uniqueMessageSigner.address, transferQuote, blockhash, lastValidBlockHeight, messageId)
+    };
+  } catch (error) {
+    if (error instanceof BridgeError && error.message.includes(signature)) throw error;
+    const message2 = error instanceof Error ? error.message : String(error);
+    throw new BridgeError(`Solana Hyperlane transfer ${signature} failed after broadcast: ${message2}`, { cause: error });
+  }
+}
+
+// src/protocols/xreserve/aleoToEvm.ts
+var ETHEREUM_DESTINATION_DOMAIN = 0;
+function validatedRoute2(registry, params) {
+  const { plan } = params;
+  if (plan.protocol !== "xreserve" || plan.route.protocol !== "xreserve") throw new BridgeError("USDCx burn requires an xReserve transfer plan");
+  if (plan.registryVersion !== registry.version) throw new BridgeError(`Transfer plan uses registry ${plan.registryVersion}; expected ${registry.version}`);
+  const route2 = registry.routes.find((entry) => entry.id === plan.route.id);
+  if (!route2 || route2.protocol !== "xreserve" || route2.availability !== "active") throw new BridgeError(`xReserve route is not executable: ${plan.route.id}`);
+  const sourceChain = registry.chains.find((chain) => chain.id === plan.sourceAsset.chainId);
+  const destinationChain = registry.chains.find((chain) => chain.id === plan.destinationAsset.chainId);
+  if (sourceChain?.family !== "aleo" || destinationChain?.family !== "evm") throw new BridgeError("USDCx burn action requires an Aleo-to-Ethereum route");
+  if (route2.sourceAssetId !== plan.sourceAsset.id || route2.destinationAssetId !== plan.destinationAsset.id) throw new BridgeError(`Transfer plan assets do not match configured route: ${route2.id}`);
+  const bridgeProgram = route2.metadata?.bridgeProgram;
+  const wrapperProgram = route2.metadata?.wrapperProgram;
+  const tokenProgram = route2.metadata?.remoteToken;
+  const nativeDomain = route2.metadata?.ethereumDestinationDomain;
+  const withdrawalFee = route2.metadata?.withdrawalFeeAtomic;
+  if (typeof bridgeProgram !== "string" || !bridgeProgram.endsWith(".aleo")) throw new BridgeError(`xReserve bridge program is invalid: ${route2.id}`);
+  if (typeof wrapperProgram !== "string" || !wrapperProgram.endsWith(".aleo")) throw new BridgeError(`xReserve wrapper program is invalid: ${route2.id}`);
+  if (typeof tokenProgram !== "string" || !tokenProgram.endsWith(".aleo")) throw new BridgeError(`xReserve token program is invalid: ${route2.id}`);
+  if (typeof withdrawalFee !== "string" || !/^\d+$/.test(withdrawalFee)) throw new BridgeError(`xReserve withdrawal fee is invalid: ${route2.id}`);
+  if (nativeDomain !== ETHEREUM_DESTINATION_DOMAIN) throw new BridgeError(`xReserve Ethereum destination domain must be ${ETHEREUM_DESTINATION_DOMAIN}: ${route2.id}`);
+  return { route: route2, bridgeProgram, wrapperProgram, tokenProgram, nativeDomain, withdrawalFeeAtomic: BigInt(withdrawalFee) };
+}
+function assertPrivateInputs(userRecord, merkleProof, tokenProgram) {
+  if (userRecord == null) throw new BridgeError("private_burn requires a USDCx userRecord input");
+  if (typeof userRecord === "object") {
+    if (userRecord.type !== "record" || userRecord.program !== tokenProgram || userRecord.recordname !== "Token") {
+      throw new BridgeError(`private_burn record requests must select ${tokenProgram}/Token`);
+    }
+  }
+  if (typeof merkleProof !== "string" || !merkleProof.startsWith("[") || !merkleProof.endsWith("]")) {
+    throw new BridgeError("private_burn requires an encoded [MerkleProof; 2] Aleo literal");
+  }
+}
+function buildBurnCall(registry, params) {
+  const deployment = validatedRoute2(registry, params);
+  const mode = params.mode ?? "private";
+  if (mode !== "public-as-signer" && mode !== "public" && mode !== "private") throw new BridgeError(`Unsupported USDCx burn mode: ${String(mode)}`);
+  const amountAtomic = parseDecimalAmount(params.plan.amountIn, params.plan.sourceAsset.decimals);
+  if (amountAtomic <= 0n) throw new BridgeError("USDCx burn amount must be greater than zero");
+  if (amountAtomic <= deployment.withdrawalFeeAtomic) {
+    const fee = formatDecimalAmount(deployment.withdrawalFeeAtomic, params.plan.sourceAsset.decimals);
+    throw new BridgeError(`USDCx burn amount must exceed the ${fee} ${params.plan.sourceAsset.symbol} withdrawal fee`);
+  }
+  const nativeRecipientBytes32 = evmAddressToXReserveBytes32(params.plan.recipient);
+  const amount = `${amountAtomic}u128`;
+  const nativeDomain = `${deployment.nativeDomain}u32`;
+  const nativeRecipient = xReserveHexToAleoBytes(nativeRecipientBytes32, 32);
+  if (mode === "private") {
+    assertPrivateInputs(params.userRecord, params.merkleProof, deployment.tokenProgram);
+    return {
+      routeId: deployment.route.id,
+      mode,
+      program: deployment.wrapperProgram,
+      function: "private_burn",
+      inputs: [params.userRecord, amount, nativeDomain, nativeRecipient, params.merkleProof],
+      amountAtomic,
+      nativeDomain: deployment.nativeDomain,
+      nativeRecipientBytes32
+    };
+  }
+  return {
+    routeId: deployment.route.id,
+    mode,
+    program: deployment.bridgeProgram,
+    function: mode === "public" ? "burn_public" : "burn_public_as_signer",
+    inputs: [amount, nativeDomain, nativeRecipient],
+    amountAtomic,
+    nativeDomain: deployment.nativeDomain,
+    nativeRecipientBytes32
+  };
+}
+async function execute4(registry, client, params) {
+  const call = buildBurnCall(registry, params);
+  const transactionId = await client.executeTransaction({
+    program: call.program,
+    function: call.function,
+    inputs: call.inputs,
+    privateFee: params.privateFee ?? false,
+    onProgress: async (event) => {
+      await params.onProgress?.(event);
+      if (event.type === "transaction-prepared") await params.onPrepared?.(event.transaction);
+    }
+  });
+  if (!transactionId) throw new BridgeError("Aleo wallet returned an empty burn transaction id");
+  const receipt = {
+    id: transactionId,
+    protocol: "xreserve",
+    status: "SOURCE_CONFIRMING",
+    sourceTxId: transactionId,
+    protocolState: {
+      routeId: call.routeId,
+      burnMode: call.mode,
+      amountAtomic: call.amountAtomic.toString(),
+      nativeDomain: call.nativeDomain,
+      nativeRecipientBytes32: call.nativeRecipientBytes32,
+      sourceProgram: call.program,
+      sourceFunction: call.function,
+      forwardingService: "aleo-burn-attestation"
+    }
+  };
+  await params.onSubmitted?.(receipt);
+  return { transactionId, receipt };
+}
+
+// src/protocols/xreserve/evmToAleo.ts
+import {
+  decodeEventLog as decodeEventLog2,
+  decodeFunctionResult as decodeFunctionResult2,
+  encodeFunctionData as encodeFunctionData2,
+  getAddress as getAddress3,
+  isAddress as isAddress3,
+  isHash as isHash2,
+  isHex,
+  parseAbi as parseAbi2
+} from "viem";
+var ERC20_ABI2 = parseAbi2([
+  "function balanceOf(address owner) view returns (uint256)",
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function approve(address spender, uint256 amount) returns (bool)"
+]);
+var XRESERVE_ABI = parseAbi2([
+  "function depositToRemote(uint256 value, uint32 remoteDomain, bytes32 remoteRecipient, address localToken, uint256 maxFee, bytes hookData)",
+  "event DepositedToRemote(address indexed localToken, uint256 value, address indexed localDepositor, bytes32 indexed remoteRecipient, uint32 remoteDomain, bytes32 remoteToken, uint256 maxFee, bytes hookData)"
+]);
+function metadata(registry, plan) {
+  if (plan.protocol !== "xreserve" || plan.route.protocol !== "xreserve") throw new BridgeError("xReserve actions require an xReserve transfer plan");
+  if (plan.registryVersion !== registry.version) throw new BridgeError(`Transfer plan uses registry ${plan.registryVersion}; expected ${registry.version}`);
+  const route2 = registry.routes.find((entry) => entry.id === plan.route.id);
+  if (!route2 || route2.availability !== "active") throw new BridgeError(`xReserve route is not executable: ${plan.route.id}`);
+  if (route2.sourceAssetId !== plan.sourceAsset.id || route2.destinationAssetId !== plan.destinationAsset.id) throw new BridgeError(`Transfer plan assets do not match configured route: ${route2.id}`);
+  const sourceChain = registry.chains.find((chain) => chain.id === plan.sourceAsset.chainId);
+  if (sourceChain?.family !== "evm" || plan.destinationAsset.chainId !== (route2.environment === "mainnet" ? "aleo" : "aleo-testnet")) {
+    throw new BridgeError("This action supports Ethereum-to-Aleo xReserve deposits only");
+  }
+  const raw = route2.metadata ?? {};
+  const xReserveContract = raw.xReserveContract;
+  const sourceChainId = raw.sourceChainId;
+  const sourceDomain = raw.sourceDomain;
+  const remoteDomain = raw.remoteDomain;
+  const remoteTokenBytes32 = raw.remoteTokenBytes32;
+  const minimumAmountAtomic = raw.minimumAmountAtomic;
+  const maxFeeAtomic = raw.maxFeeAtomic;
+  const bridgeProgram = raw.bridgeProgram;
+  const wrapperProgram = raw.wrapperProgram;
+  const attestationBaseUrl = raw.attestationBaseUrl;
+  if (typeof xReserveContract !== "string" || !isAddress3(xReserveContract)) throw new BridgeError(`xReserve contract is invalid: ${route2.id}`);
+  if (typeof sourceChainId !== "number" || !Number.isSafeInteger(sourceChainId) || sourceChainId <= 0) throw new BridgeError(`xReserve sourceChainId is invalid: ${route2.id}`);
+  if (typeof sourceDomain !== "number" || !Number.isInteger(sourceDomain) || sourceDomain < 0) throw new BridgeError(`xReserve sourceDomain is invalid: ${route2.id}`);
+  if (typeof remoteDomain !== "number" || !Number.isInteger(remoteDomain) || remoteDomain < 0) throw new BridgeError(`xReserve remoteDomain is invalid: ${route2.id}`);
+  if (typeof remoteTokenBytes32 !== "string" || !/^0x[0-9a-f]{64}$/i.test(remoteTokenBytes32)) throw new BridgeError(`xReserve remote token is invalid: ${route2.id}`);
+  if (typeof minimumAmountAtomic !== "string" || !/^\d+$/.test(minimumAmountAtomic)) throw new BridgeError(`xReserve minimum amount is invalid: ${route2.id}`);
+  if (typeof maxFeeAtomic !== "string" || !/^\d+$/.test(maxFeeAtomic)) throw new BridgeError(`xReserve max fee is invalid: ${route2.id}`);
+  if (typeof bridgeProgram !== "string" || !bridgeProgram.endsWith(".aleo")) throw new BridgeError(`xReserve bridge program is invalid: ${route2.id}`);
+  if (typeof wrapperProgram !== "string" || !wrapperProgram.endsWith(".aleo")) throw new BridgeError(`xReserve wrapper program is invalid: ${route2.id}`);
+  if (typeof attestationBaseUrl !== "string" || !attestationBaseUrl.startsWith("https://")) throw new BridgeError(`xReserve attestation URL is invalid: ${route2.id}`);
+  return { xReserveContract: getAddress3(xReserveContract), sourceChainId, sourceDomain, remoteDomain, remoteTokenBytes32, minimumAmountAtomic: BigInt(minimumAmountAtomic), maxFeeAtomic: BigInt(maxFeeAtomic), bridgeProgram, wrapperProgram, attestationBaseUrl };
+}
+async function assertChain2(client, expected) {
+  const chain = await client.publicClient.getChainId();
+  if (chain !== expected) throw new BridgeError(`EVM client is connected to chain ${chain}; expected ${expected}`);
+}
+async function observedAccount(client, plan, receipt) {
+  const saved = receipt?.protocolState.sourceSender;
+  const candidate = typeof saved === "string" ? saved : plan.sender;
+  if (candidate && isAddress3(candidate)) return getAddress3(candidate);
+  if (client.walletClient) return account(client, plan);
+  throw new BridgeError("Read-only EVM access requires the prepared sender address");
+}
+async function account(client, plan) {
+  const value = await client.walletClient.getAddress();
+  if (typeof value !== "string" || !isAddress3(value)) throw new BridgeError("EVM wallet client has no connected account");
+  const resolved = getAddress3(value);
+  if (plan.sender && (!isAddress3(plan.sender) || getAddress3(plan.sender) !== resolved)) throw new BridgeError(`Prepared sender ${plan.sender} does not match connected account ${resolved}`);
+  return resolved;
+}
+async function callUint(client, to, data, functionName) {
+  const result = await client.publicClient.call({ to, data });
+  if (typeof result !== "string" || !isHex(result)) throw new BridgeError("EVM public client returned an invalid contract result");
+  return decodeFunctionResult2({ abi: ERC20_ABI2, functionName, data: result });
+}
+async function send(client, chainId, transaction) {
+  const hash = await client.walletClient.sendTransaction({ chainId, ...transaction });
+  if (typeof hash !== "string" || !isHash2(hash)) throw new BridgeError("EVM wallet client returned an invalid transaction hash");
+  return hash;
+}
+async function wait(client, hash, timeout, interval) {
+  const deadline = Date.now() + timeout;
+  do {
+    const result = await client.publicClient.getTransactionReceipt(hash);
+    if (result && typeof result === "object") return result;
+    if (Date.now() >= deadline) return void 0;
+    await new Promise((resolve2) => setTimeout(resolve2, interval));
+  } while (true);
+}
+function successful(receipt, hash) {
+  if (receipt.status === "reverted") throw new BridgeError(`EVM transaction reverted: ${hash}`);
+}
+async function quote4(registry, client, params) {
+  const route2 = metadata(registry, params.plan);
+  await assertChain2(client, route2.sourceChainId);
+  const owner = await observedAccount(client, params.plan);
+  const token = params.plan.sourceAsset.locator?.value;
+  if (params.plan.sourceAsset.locator?.kind !== "evm-contract" || !token || !isAddress3(token)) throw new BridgeError("xReserve source token contract is missing");
+  const amountAtomic = parseDecimalAmount(params.plan.amountIn, params.plan.sourceAsset.decimals);
+  if (amountAtomic < route2.minimumAmountAtomic) throw new BridgeError(`xReserve minimum deposit is ${route2.minimumAmountAtomic} atomic units`);
+  const environment = params.plan.route.environment;
+  const hookData = await buildXReserveHookData(
+    params.plan.mintMode,
+    params.plan.recipient,
+    environment,
+    params.privateMintSecretNonce ?? "0scalar"
+  );
+  const recipient = params.plan.mintMode === "private" ? await aleoProgramAddress(route2.wrapperProgram, environment) : params.plan.recipient;
+  const remoteRecipientBytes32 = aleoAddressToBytes32(recipient);
+  const balanceData = encodeFunctionData2({ abi: ERC20_ABI2, functionName: "balanceOf", args: [owner] });
+  const allowanceData = encodeFunctionData2({ abi: ERC20_ABI2, functionName: "allowance", args: [owner, route2.xReserveContract] });
+  const [balanceAtomic, allowanceAtomic] = await Promise.all([
+    callUint(client, getAddress3(token), balanceData, "balanceOf"),
+    callUint(client, getAddress3(token), allowanceData, "allowance")
+  ]);
+  if (balanceAtomic < amountAtomic) throw new BridgeError(`Insufficient ${params.plan.sourceAsset.symbol} balance`);
+  return { routeId: params.plan.route.id, xReserveContract: route2.xReserveContract, tokenAddress: getAddress3(token), sourceChainId: route2.sourceChainId, remoteDomain: route2.remoteDomain, remoteRecipientBytes32, amountAtomic, maxFeeAtomic: route2.maxFeeAtomic, hookData, balanceAtomic, allowanceAtomic, approvalRequired: allowanceAtomic < amountAtomic };
+}
+function pendingReceipt(plan, status, id, approvalTxIds, quote6, sourceSender, sourceTxId) {
+  return { id, protocol: "xreserve", status, ...sourceTxId ? { sourceTxId } : {}, protocolState: { routeId: plan.route.id, approvalTxIds, sourceSender, mintMode: plan.mintMode, intendedRecipient: plan.recipient, xReserveContract: quote6.xReserveContract, tokenAddress: quote6.tokenAddress, sourceChainId: quote6.sourceChainId, remoteDomain: quote6.remoteDomain, remoteRecipientBytes32: quote6.remoteRecipientBytes32, hookData: quote6.hookData, amountAtomic: quote6.amountAtomic.toString(), maxFeeAtomic: quote6.maxFeeAtomic.toString() } };
+}
+function resumeQuote(plan, receipt) {
+  const state = receipt.protocolState;
+  if (receipt.protocol !== "xreserve" || state.routeId !== plan.route.id) {
+    throw new BridgeError("Checkpoint does not match the prepared xReserve route");
+  }
+  if (state.mintMode !== plan.mintMode || state.intendedRecipient !== plan.recipient) {
+    throw new BridgeError("Checkpoint does not match the prepared xReserve recipient");
+  }
+  if (typeof state.xReserveContract !== "string" || !isAddress3(state.xReserveContract) || typeof state.tokenAddress !== "string" || !isAddress3(state.tokenAddress) || typeof state.sourceChainId !== "number" || typeof state.remoteDomain !== "number" || typeof state.remoteRecipientBytes32 !== "string" || !isHex(state.remoteRecipientBytes32) || typeof state.hookData !== "string" || !isHex(state.hookData) || typeof state.amountAtomic !== "string" || !/^\d+$/.test(state.amountAtomic) || typeof state.maxFeeAtomic !== "string" || !/^\d+$/.test(state.maxFeeAtomic)) {
+    throw new BridgeError("Checkpoint contains invalid xReserve submission state");
+  }
+  return {
+    routeId: plan.route.id,
+    xReserveContract: getAddress3(state.xReserveContract),
+    tokenAddress: getAddress3(state.tokenAddress),
+    sourceChainId: state.sourceChainId,
+    remoteDomain: state.remoteDomain,
+    remoteRecipientBytes32: state.remoteRecipientBytes32,
+    amountAtomic: BigInt(state.amountAtomic),
+    maxFeeAtomic: BigInt(state.maxFeeAtomic),
+    hookData: state.hookData,
+    balanceAtomic: 0n,
+    allowanceAtomic: 0n,
+    approvalRequired: false
+  };
+}
+function approvalIds(receipt) {
+  const ids = receipt.protocolState.approvalTxIds;
+  if (!Array.isArray(ids) || ids.some((id) => typeof id !== "string" || !isHash2(id))) {
+    throw new BridgeError("Checkpoint contains invalid xReserve approval transaction ids");
+  }
+  return ids;
+}
+function confirmedDepositReceipt(plan, route2, quote6, owner, approvalTxIds, sourceTxId, receipt) {
+  successful(receipt, sourceTxId);
+  let matched;
+  for (const log of receipt.logs ?? []) {
+    if (log.address && getAddress3(log.address) !== route2.xReserveContract) continue;
+    try {
+      const decoded = decodeEventLog2({ abi: XRESERVE_ABI, data: log.data, topics: log.topics });
+      if (decoded.eventName === "DepositedToRemote") matched = { log, args: decoded.args };
+    } catch {
+    }
+  }
+  if (!matched) throw new BridgeError("Confirmed receipt does not contain a valid DepositedToRemote event");
+  const { log: eventLog, args } = matched;
+  if (getAddress3(args.localToken) !== quote6.tokenAddress || getAddress3(args.localDepositor) !== owner || args.value !== quote6.amountAtomic || args.remoteDomain !== route2.remoteDomain || args.remoteRecipient.toLowerCase() !== quote6.remoteRecipientBytes32.toLowerCase() || args.remoteToken.toLowerCase() !== route2.remoteTokenBytes32.toLowerCase() || args.maxFee !== route2.maxFeeAtomic || args.hookData.toLowerCase() !== quote6.hookData.toLowerCase()) throw new BridgeError("DepositedToRemote event does not match the prepared transfer");
+  const rawIndex = eventLog.logIndex;
+  const logIndex = typeof rawIndex === "string" ? Number(BigInt(rawIndex)) : rawIndex;
+  if (!Number.isSafeInteger(logIndex) || logIndex == null || logIndex < 0) throw new BridgeError("DepositedToRemote log index is missing or invalid");
+  const nonce = calculateXReserveDepositNonce(route2.sourceDomain, sourceTxId, logIndex);
+  const payload = buildXReserveDepositPayload({ amount: args.value, remoteDomain: args.remoteDomain, remoteToken: args.remoteToken, remoteRecipient: args.remoteRecipient, localToken: args.localToken, depositor: args.localDepositor, maxFee: args.maxFee, nonce, hookData: args.hookData });
+  const messageHash = calculateXReserveMessageHash(payload);
+  return { id: messageHash, protocol: "xreserve", status: "ATTESTATION_PENDING", sourceTxId, protocolState: { ...pendingReceipt(plan, "ATTESTATION_PENDING", messageHash, approvalTxIds, quote6, owner, sourceTxId).protocolState, sourceDomain: route2.sourceDomain, remoteDomain: route2.remoteDomain, depositLogIndex: logIndex, nonce, payload, messageHash, bridgeProgram: route2.bridgeProgram, wrapperProgram: route2.wrapperProgram } };
+}
+async function approvalScanBlock2(client, approvalTxIds) {
+  let blockNumber;
+  for (const approvalTxId of approvalTxIds) {
+    const receipt = await client.publicClient.getTransactionReceipt(approvalTxId);
+    if (!receipt) continue;
+    successful(receipt, approvalTxId);
+    if (typeof receipt.blockNumber === "bigint" && (blockNumber === void 0 || receipt.blockNumber > blockNumber)) {
+      blockNumber = receipt.blockNumber;
+    }
+  }
+  return blockNumber;
+}
+async function recoverConfirmedDepositFromHistory(plan, route2, client, quote6, owner, approvalTxIds, options) {
+  const fromBlock = await approvalScanBlock2(client, approvalTxIds);
+  if (fromBlock === void 0) {
+    if (options.required) {
+      throw new BridgeError("Cannot safely resume xReserve because no confirmed approval block is available for source history verification");
+    }
+    return void 0;
+  }
+  const logs = await client.publicClient.getLogs({ address: route2.xReserveContract, fromBlock });
+  const transactionHashes = [...new Set(logs.map((log) => log.transactionHash))];
+  const matches = [];
+  for (const transactionHash of transactionHashes) {
+    const receipt = await client.publicClient.getTransactionReceipt(transactionHash);
+    if (!receipt) continue;
+    try {
+      matches.push(confirmedDepositReceipt(plan, route2, quote6, owner, approvalTxIds, transactionHash, receipt));
+    } catch (error) {
+      if (!(error instanceof BridgeError)) throw error;
+    }
+  }
+  if (matches.length > 1) {
+    throw new BridgeError("Multiple matching xReserve deposits were found; recovery cannot safely choose one source transaction");
+  }
+  return matches[0];
+}
+async function getSourceStatus3(registry, client, plan, receipt) {
+  if (receipt.status !== "SOURCE_CONFIRMING") {
+    throw new BridgeError("xReserve source status requires a source-confirming receipt");
+  }
+  const route2 = metadata(registry, plan);
+  const owner = await observedAccount(client, plan, receipt);
+  const transferQuote = resumeQuote(plan, receipt);
+  const approvalTxIds = approvalIds(receipt);
+  const sourceTxId = receipt.sourceTxId;
+  if (!sourceTxId || !isHash2(sourceTxId)) {
+    throw new BridgeError("Checkpoint is missing the xReserve source transaction id");
+  }
+  const sourceReceipt = await client.publicClient.getTransactionReceipt(sourceTxId);
+  if (!sourceReceipt) return receipt;
+  return confirmedDepositReceipt(plan, route2, transferQuote, owner, approvalTxIds, sourceTxId, sourceReceipt);
+}
+async function recoverSourceCheckpoint2(registry, client, plan, checkpoint) {
+  if (checkpoint.version !== 1 || checkpoint.intent.bridgeProtocol !== "xreserve" || checkpoint.route.id !== plan.route.id) {
+    throw new BridgeError("Bridge checkpoint does not match the prepared route");
+  }
+  const route2 = metadata(registry, plan);
+  await assertChain2(client, route2.sourceChainId);
+  const owner = await observedAccount(client, plan);
+  const token = plan.sourceAsset.locator?.value;
+  if (plan.sourceAsset.locator?.kind !== "evm-contract" || !token || !isAddress3(token)) {
+    throw new BridgeError("xReserve source token contract is missing");
+  }
+  const amountAtomic = parseDecimalAmount(plan.amountIn, plan.sourceAsset.decimals);
+  const storedHookData = checkpoint.source?.hookData;
+  if (storedHookData !== void 0 && (!isHex(storedHookData, { strict: true }) || storedHookData.length !== 132)) {
+    throw new BridgeError("Bridge checkpoint contains invalid xReserve hook data");
+  }
+  const hookData = storedHookData ?? await buildXReserveHookData(
+    plan.mintMode,
+    plan.recipient,
+    plan.route.environment,
+    "0scalar"
+  );
+  const recipient = plan.mintMode === "private" ? await aleoProgramAddress(route2.wrapperProgram, plan.route.environment) : plan.recipient;
+  const quote6 = {
+    routeId: plan.route.id,
+    xReserveContract: route2.xReserveContract,
+    tokenAddress: getAddress3(token),
+    sourceChainId: route2.sourceChainId,
+    remoteDomain: route2.remoteDomain,
+    remoteRecipientBytes32: aleoAddressToBytes32(recipient),
+    amountAtomic,
+    maxFeeAtomic: route2.maxFeeAtomic,
+    hookData,
+    balanceAtomic: 0n,
+    allowanceAtomic: 0n,
+    approvalRequired: false
+  };
+  const approvals = [...checkpoint.source?.approvalTransactionIds ?? []];
+  if (approvals.some((id) => !isHash2(id))) {
+    throw new BridgeError("Bridge checkpoint contains an invalid approval transaction id");
+  }
+  const approvalTxIds = approvals;
+  if (!checkpoint.source?.transactionId) {
+    const approvalTxId = approvalTxIds.at(-1);
+    if (!approvalTxId) throw new BridgeError("Bridge checkpoint contains no submitted transaction");
+    const pending2 = pendingReceipt(plan, "SOURCE_APPROVAL_PENDING", approvalTxId, approvalTxIds, quote6, owner);
+    const approvalReceipt = await client.publicClient.getTransactionReceipt(approvalTxId);
+    if (!approvalReceipt) return pending2;
+    successful(approvalReceipt, approvalTxId);
+    const recovered = await recoverConfirmedDepositFromHistory(
+      plan,
+      route2,
+      client,
+      quote6,
+      owner,
+      approvalTxIds,
+      { required: false }
+    );
+    if (recovered) return recovered;
+    return { ...pending2, status: "SOURCE_SUBMISSION_PENDING" };
+  }
+  if (!isHash2(checkpoint.source.transactionId)) {
+    throw new BridgeError("Bridge checkpoint contains an invalid source transaction id");
+  }
+  const pending = pendingReceipt(
+    plan,
+    "SOURCE_CONFIRMING",
+    checkpoint.source.transactionId,
+    approvalTxIds,
+    quote6,
+    owner,
+    checkpoint.source.transactionId
+  );
+  const observed = await getSourceStatus3(registry, client, plan, pending);
+  if (observed !== pending) return observed;
+  return await recoverConfirmedDepositFromHistory(
+    plan,
+    route2,
+    client,
+    quote6,
+    owner,
+    approvalTxIds,
+    { required: false }
+  ) ?? observed;
+}
+async function execute5(registry, client, params) {
+  const pollingIntervalMs = params.pollingIntervalMs ?? 1e3;
+  const confirmationTimeoutMs = params.confirmationTimeoutMs ?? 12e4;
+  if (!Number.isFinite(pollingIntervalMs) || pollingIntervalMs < 0 || !Number.isFinite(confirmationTimeoutMs) || confirmationTimeoutMs < 0) throw new BridgeError("Receipt polling controls must be non-negative finite numbers");
+  const route2 = metadata(registry, params.plan);
+  const owner = await account(client, params.plan);
+  let transferQuote;
+  let approvalTxIds = [];
+  if (params.resume?.status === "ATTESTATION_PENDING") {
+    resumeQuote(params.plan, params.resume);
+    return { approvalTxIds: approvalIds(params.resume), receipt: params.resume };
+  }
+  if (params.resume?.status === "SOURCE_CONFIRMING") {
+    transferQuote = resumeQuote(params.plan, params.resume);
+    approvalTxIds = approvalIds(params.resume);
+    const sourceTxId2 = params.resume.sourceTxId;
+    if (!sourceTxId2 || !isHash2(sourceTxId2)) throw new BridgeError("Checkpoint is missing the xReserve source transaction id");
+    const receipt2 = await wait(client, sourceTxId2, confirmationTimeoutMs, pollingIntervalMs);
+    if (!receipt2) return { approvalTxIds, receipt: params.resume };
+    return { approvalTxIds, receipt: confirmedDepositReceipt(params.plan, route2, transferQuote, owner, approvalTxIds, sourceTxId2, receipt2) };
+  }
+  if (params.resume?.status === "SOURCE_SUBMISSION_PENDING") {
+    const checkpointQuote = resumeQuote(params.plan, params.resume);
+    approvalTxIds = approvalIds(params.resume);
+    const recovered = await recoverConfirmedDepositFromHistory(
+      params.plan,
+      route2,
+      client,
+      checkpointQuote,
+      owner,
+      approvalTxIds,
+      { required: true }
+    );
+    if (recovered) return { approvalTxIds, receipt: recovered };
+    transferQuote = await quote4(registry, client, params);
+    if (transferQuote.hookData.toLowerCase() !== checkpointQuote.hookData.toLowerCase()) {
+      throw new BridgeError("Private mint secret nonce does not match the checkpointed approval");
+    }
+    if (transferQuote.approvalRequired) {
+      throw new BridgeError("The recovered xReserve approval allowance is no longer available. Inspect source history before starting another transfer.");
+    }
+  } else if (params.resume?.status === "SOURCE_APPROVAL_PENDING") {
+    resumeQuote(params.plan, params.resume);
+    approvalTxIds = approvalIds(params.resume);
+    const approvalTxId = params.resume.id;
+    if (!isHash2(approvalTxId)) throw new BridgeError("Checkpoint is missing the xReserve approval transaction id");
+    const receipt2 = await wait(client, approvalTxId, confirmationTimeoutMs, pollingIntervalMs);
+    if (!receipt2) return { approvalTxIds, receipt: params.resume };
+    successful(receipt2, approvalTxId);
+    transferQuote = await quote4(registry, client, params);
+  } else if (params.resume) {
+    throw new BridgeError(`Unsupported xReserve resume status: ${params.resume.status}`);
+  } else {
+    transferQuote = await quote4(registry, client, params);
+  }
+  if (transferQuote.approvalRequired) {
+    const data2 = encodeFunctionData2({ abi: ERC20_ABI2, functionName: "approve", args: [route2.xReserveContract, transferQuote.amountAtomic] });
+    const hash = await send(client, route2.sourceChainId, { from: owner, to: transferQuote.tokenAddress, data: data2 });
+    approvalTxIds.push(hash);
+    const submitted2 = pendingReceipt(params.plan, "SOURCE_APPROVAL_PENDING", hash, approvalTxIds, transferQuote, owner);
+    await params.onSubmitted?.(submitted2);
+    const receipt2 = await wait(client, hash, confirmationTimeoutMs, pollingIntervalMs);
+    if (!receipt2) return { approvalTxIds, receipt: submitted2 };
+    successful(receipt2, hash);
+  }
+  const data = encodeFunctionData2({ abi: XRESERVE_ABI, functionName: "depositToRemote", args: [transferQuote.amountAtomic, route2.remoteDomain, transferQuote.remoteRecipientBytes32, transferQuote.tokenAddress, route2.maxFeeAtomic, transferQuote.hookData] });
+  const sourceTxId = await send(client, route2.sourceChainId, { from: owner, to: route2.xReserveContract, data });
+  const submitted = pendingReceipt(params.plan, "SOURCE_CONFIRMING", sourceTxId, approvalTxIds, transferQuote, owner, sourceTxId);
+  await params.onSubmitted?.(submitted);
+  const receipt = await wait(client, sourceTxId, confirmationTimeoutMs, pollingIntervalMs);
+  if (!receipt) return { approvalTxIds, receipt: submitted };
+  return { approvalTxIds, receipt: confirmedDepositReceipt(params.plan, route2, transferQuote, owner, approvalTxIds, sourceTxId, receipt) };
+}
+async function getAttestation(registry, transport, params) {
+  const route2 = registry.routes.find((entry) => entry.id === params.routeId);
+  if (!route2) throw new BridgeError(`Unknown bridge route: ${params.routeId}`);
+  if (route2.protocol !== "xreserve" || route2.availability !== "active") throw new BridgeError(`xReserve route is not executable: ${params.routeId}`);
+  const attestationBaseUrl = route2.metadata?.attestationBaseUrl;
+  if (typeof attestationBaseUrl !== "string" || !attestationBaseUrl.startsWith("https://")) throw new BridgeError(`xReserve attestation URL is invalid: ${params.routeId}`);
+  const response = await transport(`${attestationBaseUrl}/${params.messageHash}`, params.signal ? { signal: params.signal } : void 0);
+  if (response.status === 404) return { status: "pending", messageHash: params.messageHash };
+  if (!response.ok) throw new BridgeError(`Circle attester request failed with HTTP ${response.status}`);
+  const body = await response.json();
+  const value = body.attestation;
+  if (!value || typeof value.payload !== "string" || !isHex(value.payload) || typeof value.attestation !== "string" || !isHex(value.attestation) || typeof value.messageHash !== "string" || !isHash2(value.messageHash) || value.messageHash.toLowerCase() !== params.messageHash.toLowerCase()) throw new BridgeError("Circle attester returned an invalid response");
+  if (calculateXReserveMessageHash(value.payload) !== params.messageHash) throw new BridgeError("Circle attestation payload does not match the requested message hash");
+  return { status: "complete", messageHash: params.messageHash, payload: value.payload, attestation: value.attestation };
+}
+async function complete(registry, client, params) {
+  const { plan, deposit, attestation } = params;
+  if (plan.protocol !== "xreserve" || plan.route.protocol !== "xreserve" || plan.mintMode !== "private") {
+    throw new BridgeError("private_mint requires a private xReserve transfer plan");
+  }
+  if (plan.registryVersion !== registry.version) throw new BridgeError(`Transfer plan uses registry ${plan.registryVersion}; expected ${registry.version}`);
+  const route2 = registry.routes.find((entry) => entry.id === plan.route.id);
+  if (!route2 || route2.protocol !== "xreserve" || route2.availability !== "active") throw new BridgeError(`xReserve route is not executable: ${plan.route.id}`);
+  const wrapperProgram = route2.metadata?.wrapperProgram;
+  if (typeof wrapperProgram !== "string" || !wrapperProgram.endsWith(".aleo")) throw new BridgeError(`xReserve wrapper program is invalid: ${plan.route.id}`);
+  if (deposit.protocol !== "xreserve" || deposit.status !== "ATTESTATION_PENDING") throw new BridgeError("Private mint requires a confirmed xReserve deposit awaiting attestation");
+  if (attestation.status !== "complete") throw new BridgeError("Private mint requires a completed Circle attestation");
+  const depositPayload = deposit.protocolState.payload;
+  const depositHash = deposit.protocolState.messageHash;
+  const intendedRecipient = deposit.protocolState.intendedRecipient;
+  const mintMode = deposit.protocolState.mintMode;
+  if (typeof depositPayload !== "string" || !isHex(depositPayload, { strict: true })) throw new BridgeError("Deposit receipt is missing the canonical xReserve payload");
+  if (typeof depositHash !== "string" || !isHash2(depositHash)) throw new BridgeError("Deposit receipt is missing the Circle message hash");
+  if (typeof intendedRecipient !== "string" || intendedRecipient !== plan.recipient || mintMode !== "private") throw new BridgeError("Deposit receipt does not match the private mint plan");
+  if (attestation.payload.toLowerCase() !== depositPayload.toLowerCase() || attestation.messageHash.toLowerCase() !== depositHash.toLowerCase()) throw new BridgeError("Circle attestation does not match the confirmed deposit");
+  if (calculateXReserveMessageHash(attestation.payload) !== attestation.messageHash) throw new BridgeError("Circle attestation payload has an invalid message hash");
+  const secretNonce = params.privateMintSecretNonce ?? "0scalar";
+  const expectedHookData = await buildXReserveHookData("private", plan.recipient, route2.environment, secretNonce);
+  const attestedHookData = `0x${attestation.payload.slice(-130)}`;
+  if (attestedHookData.toLowerCase() !== expectedHookData.toLowerCase()) {
+    throw new BridgeError("Private mint secret nonce and recipient do not match the attested hook data");
+  }
+  const transactionId = await client.executeTransaction({
+    program: wrapperProgram,
+    function: "private_mint",
+    inputs: [
+      xReserveHexToAleoBytes(attestation.payload, 305),
+      xReserveHexToAleoBytes(attestation.attestation, 65),
+      xReserveHexToAleoBytes(attestation.messageHash, 32),
+      secretNonce,
+      plan.recipient
+    ],
+    privateFee: params.privateFee ?? false,
+    onProgress: async (event) => {
+      await params.onProgress?.(event);
+      if (event.type === "transaction-prepared") await params.onPrepared?.(event.transaction);
+    }
+  });
+  if (!transactionId) throw new BridgeError("Aleo wallet returned an empty private mint transaction id");
+  const receipt = {
+    ...deposit,
+    status: "DESTINATION_CONFIRMING",
+    destinationTxId: transactionId,
+    protocolState: {
+      ...deposit.protocolState,
+      attestation: attestation.attestation,
+      destinationProgram: wrapperProgram,
+      destinationFunction: "private_mint",
+      secretNonce
+    }
+  };
+  await params.onSubmitted?.(receipt);
+  return { transactionId, receipt };
+}
+
+// src/actions/internal/resolveTransferRoute.ts
+function resolveTransferRoute(registry, plan) {
+  if (plan.registryVersion !== registry.version) {
+    throw new BridgeError(`Transfer plan uses registry ${plan.registryVersion}; expected ${registry.version}`);
+  }
+  const route2 = registry.routes.find((entry) => entry.id === plan.route.id);
+  if (!route2 || route2.protocol !== plan.protocol || plan.route.protocol !== plan.protocol) {
+    throw new BridgeError(`Transfer plan route does not match the configured registry: ${plan.route.id}`);
+  }
+  if (route2.sourceAssetId !== plan.sourceAsset.id || route2.destinationAssetId !== plan.destinationAsset.id) {
+    throw new BridgeError(`Transfer plan assets do not match configured route: ${route2.id}`);
+  }
+  const sourceAsset = registry.assets.find((asset) => asset.id === route2.sourceAssetId);
+  const destinationAsset = registry.assets.find((asset) => asset.id === route2.destinationAssetId);
+  if (!sourceAsset || sourceAsset.chainId !== plan.sourceAsset.chainId || !destinationAsset || destinationAsset.chainId !== plan.destinationAsset.chainId) {
+    throw new BridgeError(`Transfer plan asset chains do not match configured route: ${route2.id}`);
+  }
+  const sourceChain = registry.chains.find((chain) => chain.id === sourceAsset.chainId);
+  const destinationChain = registry.chains.find((chain) => chain.id === destinationAsset.chainId);
+  if (!sourceChain || !destinationChain) {
+    throw new BridgeError(`Transfer plan references an unknown chain: ${route2.id}`);
+  }
+  return { route: route2, sourceAsset, destinationAsset, sourceChain, destinationChain };
+}
+
+// src/actions/createBridgeCheckpoint.ts
+function createBridgeCheckpoint(plan, receipt) {
+  if (receipt.protocol !== plan.protocol || receipt.protocolState.routeId !== plan.route.id) {
+    throw new BridgeError("Bridge receipt does not match the prepared route");
+  }
+  const rawApprovals = receipt.protocolState.approvalTxIds;
+  if (rawApprovals !== void 0 && (!Array.isArray(rawApprovals) || rawApprovals.some((value) => typeof value !== "string"))) {
+    throw new BridgeError("Bridge receipt contains invalid approval transaction identifiers");
+  }
+  const approvals = [...rawApprovals ?? []];
+  const sourceSender = receipt.protocolState.sourceSender;
+  if (sourceSender !== void 0 && typeof sourceSender !== "string") {
+    throw new BridgeError("Bridge receipt contains an invalid source sender");
+  }
+  const sender = plan.sender ?? sourceSender;
+  const preparedTransaction = receipt.protocolState.preparedTransaction;
+  if (preparedTransaction !== void 0 && (typeof preparedTransaction !== "string" || !preparedTransaction)) {
+    throw new BridgeError("Bridge receipt contains an invalid prepared transaction");
+  }
+  const preparedDestinationTransaction = receipt.protocolState.preparedDestinationTransaction;
+  if (preparedDestinationTransaction !== void 0 && (typeof preparedDestinationTransaction !== "string" || !preparedDestinationTransaction)) {
+    throw new BridgeError("Bridge receipt contains an invalid prepared destination transaction");
+  }
+  const blockhash = receipt.protocolState.blockhash;
+  const lastValidBlockHeight = receipt.protocolState.lastValidBlockHeight;
+  if ((blockhash !== void 0 || lastValidBlockHeight !== void 0) && (typeof blockhash !== "string" || !blockhash || typeof lastValidBlockHeight !== "string" || !/^\d+$/.test(lastValidBlockHeight))) {
+    throw new BridgeError("Bridge receipt contains an invalid Solana blockhash lifetime");
+  }
+  const source = approvals.length > 0 || receipt.sourceTxId || preparedTransaction ? {
+    ...approvals.length > 0 ? { approvalTransactionIds: approvals } : {},
+    ...receipt.sourceTxId ? { transactionId: receipt.sourceTxId } : {},
+    ...typeof receipt.protocolState.hookData === "string" ? { hookData: receipt.protocolState.hookData } : {},
+    ...typeof blockhash === "string" && typeof lastValidBlockHeight === "string" ? { blockhash, lastValidBlockHeight } : {},
+    ...typeof preparedTransaction === "string" ? { preparedTransaction: { transactionId: receipt.id, serializedTransaction: preparedTransaction } } : {}
+  } : void 0;
+  const balanceBeforeAtomic = receipt.protocolState.destinationBalanceBeforeAtomic;
+  const expectedIncreaseAtomic = receipt.protocolState.expectedDestinationIncreaseAtomic;
+  if ((balanceBeforeAtomic !== void 0 || expectedIncreaseAtomic !== void 0) && (typeof balanceBeforeAtomic !== "string" || !/^\d+$/.test(balanceBeforeAtomic) || typeof expectedIncreaseAtomic !== "string" || !/^\d+$/.test(expectedIncreaseAtomic))) {
+    throw new BridgeError("Bridge receipt contains invalid destination balance verification state");
+  }
+  return {
+    version: 1,
+    intent: {
+      source: { chain: plan.sourceAsset.chainId, asset: plan.sourceAsset.key },
+      destination: { chain: plan.destinationAsset.chainId, asset: plan.destinationAsset.key },
+      bridgeProtocol: plan.protocol,
+      amount: plan.amountIn,
+      recipient: plan.recipient,
+      ...sender ? { sender } : {},
+      ...plan.destinationAsset.locator?.kind === "aleo-program" ? { mintMode: plan.mintMode } : {}
+    },
+    route: { id: plan.route.id, registryVersion: plan.registryVersion },
+    ...source ? { source } : {},
+    ...receipt.destinationTxId || typeof preparedDestinationTransaction === "string" ? {
+      destination: {
+        ...receipt.destinationTxId ? { transactionId: receipt.destinationTxId } : {},
+        ...typeof preparedDestinationTransaction === "string" ? { preparedTransaction: { transactionId: receipt.id, serializedTransaction: preparedDestinationTransaction } } : {}
+      }
+    } : {},
+    ...typeof balanceBeforeAtomic === "string" && typeof expectedIncreaseAtomic === "string" ? { deliveryVerification: { balanceBeforeAtomic, expectedIncreaseAtomic } } : {}
+  };
+}
+
+// src/actions/internal/readDestinationBalance.ts
+import { decodeFunctionResult as decodeFunctionResult3, encodeFunctionData as encodeFunctionData3, getAddress as getAddress4, parseAbi as parseAbi3 } from "viem";
+var ERC20_BALANCE_ABI = parseAbi3(["function balanceOf(address owner) view returns (uint256)"]);
+async function readDestinationBalance(registry, clients, plan) {
+  const chain = registry.chains.find((candidate) => candidate.id === plan.destinationAsset.chainId);
+  if (!chain) throw new BridgeError(`Unknown destination chain: ${plan.destinationAsset.chainId}`);
+  if (!clients[chain.id]) return void 0;
+  if (chain.family === "evm") {
+    const recipient = getAddress4(plan.recipient);
+    const client = requireEvmClient(registry, clients, chain.id).publicClient;
+    if (plan.destinationAsset.locator?.kind === "native") return client.getBalance(recipient);
+    if (plan.destinationAsset.locator?.kind !== "evm-contract") return void 0;
+    const data = encodeFunctionData3({
+      abi: ERC20_BALANCE_ABI,
+      functionName: "balanceOf",
+      args: [recipient]
+    });
+    const result = await client.call({ to: getAddress4(plan.destinationAsset.locator.value), data });
+    return decodeFunctionResult3({ abi: ERC20_BALANCE_ABI, functionName: "balanceOf", data: result });
+  }
+  if (chain.family === "solana" && plan.destinationAsset.locator?.kind === "native") {
+    return requireSolanaClient(registry, clients, chain.id).publicClient.getBalance(plan.recipient);
+  }
+  return void 0;
+}
+
+// src/actions/execute.ts
+function withDeliveryVerification(receipt, verification) {
+  return verification ? { ...receipt, protocolState: { ...receipt.protocolState, ...verification } } : receipt;
+}
+function submissionCheckpoint(params) {
+  return params.onCheckpoint ? async (receipt) => {
+    await params.onCheckpoint?.(createBridgeCheckpoint(params.plan, receipt));
+  } : void 0;
+}
+function preparedAleoCheckpoint(params, verification) {
+  return params.onCheckpoint ? async (transaction) => {
+    await params.onCheckpoint?.(createBridgeCheckpoint(params.plan, {
+      id: transaction.id,
+      protocol: params.plan.protocol,
+      status: "SOURCE_SUBMISSION_PENDING",
+      protocolState: {
+        routeId: params.plan.route.id,
+        preparedTransaction: JSON.stringify(transaction),
+        ...verification
+      }
+    }));
+  } : void 0;
+}
+function aleoHyperlaneMode(mode) {
+  if (mode == null) return void 0;
+  if (mode === "caller" || mode === "signer") return mode;
+  throw new BridgeError(`Aleo Hyperlane does not support execution mode "${mode}"`);
+}
+function xReserveBurnMode(mode) {
+  if (mode == null) return void 0;
+  if (mode === "private" || mode === "public" || mode === "public-as-signer") return mode;
+  throw new BridgeError(`Aleo xReserve does not support execution mode "${mode}"`);
+}
+async function execute6(registry, clients, params) {
+  const chain = resolveTransferRoute(registry, params.plan).sourceChain;
+  const chainId = chain.id;
+  const onSubmitted = submissionCheckpoint(params);
+  if (params.plan.protocol === "hyperlane" && chain.family === "evm") {
+    const execution = await execute2(
+      registry,
+      requireEvmClientWithWallet(registry, clients, chainId, "execute Hyperlane transfer"),
+      {
+        plan: params.plan,
+        recipientBytes32: aleoAddressToBytes32(params.plan.recipient),
+        pollingIntervalMs: params.pollingIntervalMs,
+        confirmationTimeoutMs: params.confirmationTimeoutMs,
+        onSubmitted
+      }
+    );
+    return { kind: "evm-hyperlane", ...execution };
+  }
+  if (params.plan.protocol === "hyperlane" && chain.family === "solana") {
+    const execution = await execute3(
+      registry,
+      requireSolanaClientWithWallet(registry, clients, chainId, "execute Hyperlane transfer"),
+      {
+        plan: params.plan,
+        pollingIntervalMs: params.pollingIntervalMs,
+        confirmationTimeoutMs: params.confirmationTimeoutMs,
+        onSubmitted
+      }
+    );
+    return { kind: "solana-hyperlane", ...execution };
+  }
+  if (params.plan.protocol === "hyperlane" && chain.family === "aleo") {
+    const client = requireAleoClientWithWallet(registry, clients, chainId, "execute Hyperlane transfer");
+    const destinationBalanceBefore = await readDestinationBalance(registry, clients, params.plan);
+    const verification = destinationBalanceBefore === void 0 ? void 0 : {
+      destinationBalanceBeforeAtomic: destinationBalanceBefore.toString(),
+      expectedDestinationIncreaseAtomic: parseDecimalAmount(
+        params.plan.amountIn,
+        params.plan.destinationAsset.decimals
+      ).toString()
+    };
+    const onAleoSubmitted = params.onCheckpoint ? async (receipt) => {
+      await params.onCheckpoint?.(createBridgeCheckpoint(
+        params.plan,
+        withDeliveryVerification(receipt, verification)
+      ));
+    } : void 0;
+    const gasPaymentMicrocredits = params.gasPaymentMicrocredits ?? (await quote(
+      registry,
+      requireAleoClient(registry, clients, chainId).publicClient,
+      { routeId: params.plan.route.id }
+    )).paymentMicrocredits;
+    const execution = await execute(registry, client.walletClient, {
+      plan: params.plan,
+      mode: aleoHyperlaneMode(params.mode),
+      privateFee: params.privateFee,
+      gasPaymentMicrocredits,
+      onSubmitted: onAleoSubmitted,
+      onProgress: params.onProgress,
+      onPrepared: preparedAleoCheckpoint(params, verification)
+    });
+    return {
+      kind: "aleo-hyperlane",
+      ...execution,
+      receipt: withDeliveryVerification(execution.receipt, verification)
+    };
+  }
+  if (params.plan.protocol === "xreserve" && chain.family === "evm") {
+    const execution = await execute5(
+      registry,
+      requireEvmClientWithWallet(registry, clients, chainId, "execute xReserve transfer"),
+      {
+        plan: params.plan,
+        pollingIntervalMs: params.pollingIntervalMs,
+        confirmationTimeoutMs: params.confirmationTimeoutMs,
+        onSubmitted,
+        privateMintSecretNonce: params.privateMintSecretNonce
+      }
+    );
+    return { kind: "evm-xreserve", ...execution };
+  }
+  if (params.plan.protocol === "xreserve" && chain.family === "aleo") {
+    const execution = await execute4(
+      registry,
+      requireAleoClientWithWallet(registry, clients, chainId, "execute xReserve burn").walletClient,
+      {
+        plan: params.plan,
+        mode: xReserveBurnMode(params.mode),
+        userRecord: params.userRecord,
+        merkleProof: params.merkleProof,
+        privateFee: params.privateFee,
+        onSubmitted,
+        onProgress: params.onProgress,
+        onPrepared: preparedAleoCheckpoint(params)
+      }
+    );
+    return { kind: "aleo-xreserve", ...execution };
+  }
+  throw new BridgeError(`Unsupported ${params.plan.protocol} source chain family: ${chain.family}`);
+}
+
+// src/actions/prepare.ts
+function executor(chain) {
+  if (chain.family === "aleo") return "aleo-wallet";
+  if (chain.family === "evm") return "evm-wallet";
+  return "solana-wallet";
+}
+function xreserveSteps(route2, source, destination, sourceChain, destinationChain, mintMode) {
+  if (sourceChain.family === "evm" && destinationChain.family === "aleo") {
+    return [
+      { key: "source-approval", kind: "approve", chainId: source.chainId, executor: "evm-wallet", description: `Approve the Circle xReserve contract to spend ${source.symbol}.`, irreversible: false },
+      { key: "source-deposit", kind: "deposit", chainId: source.chainId, executor: "evm-wallet", description: `Deposit ${source.symbol} into Circle xReserve for Aleo.`, irreversible: true },
+      { key: "deposit-attestation", kind: "wait-attestation", executor: "protocol", description: "Wait for Circle to attest the confirmed reserve deposit.", irreversible: false },
+      { key: "destination-mint", kind: "mint", chainId: destination.chainId, executor: mintMode === "private" ? "aleo-wallet" : "protocol", description: mintMode === "private" ? `Submit private_mint to mint attested ${destination.symbol} through the shielded wrapper.` : `Wait for attested ${destination.symbol} to mint as an Aleo ${mintMode === "record" ? "record" : "public balance"}.`, irreversible: false }
+    ];
+  }
+  if (sourceChain.family === "aleo" && destinationChain.family === "evm") {
+    return [
+      { key: "source-burn", kind: "burn", chainId: source.chainId, executor: "aleo-wallet", description: `Burn ${source.symbol} and create the xReserve withdrawal intent; private burn is the default.`, irreversible: true },
+      { key: "withdrawal-attestation", kind: "wait-attestation", executor: "protocol", description: "Wait for the Aleo burn attestation service to forward the accepted burn to Circle.", irreversible: false },
+      { key: "destination-withdrawal", kind: "withdraw", chainId: destination.chainId, executor: "protocol", description: `Wait for Circle to release ${destination.symbol} to the native recipient.`, irreversible: false },
+      { key: "destination-confirmation", kind: "confirm-delivery", chainId: destination.chainId, executor: "protocol", description: "Confirm the destination USDC balance change.", irreversible: false }
+    ];
+  }
+  throw new BridgeError(`Unsupported xReserve route direction: ${route2.id}`);
+}
+function hyperlaneSteps(source, destination, sourceChain, destinationChain) {
+  const steps = [];
+  if (source.kind === "token" && sourceChain.family !== "aleo") {
+    steps.push({
+      key: "source-approval",
+      kind: "approve",
+      chainId: source.chainId,
+      executor: executor(sourceChain),
+      description: `Approve the Hyperlane Warp Route to spend ${source.symbol}.`,
+      irreversible: false
+    });
+  }
+  steps.push(
+    { key: "source-dispatch", kind: "dispatch", chainId: source.chainId, executor: executor(sourceChain), description: `Dispatch ${source.symbol} through its Hyperlane Warp Route.`, irreversible: true },
+    { key: "message-delivery", kind: "wait-delivery", executor: "protocol", description: "Wait for the Hyperlane message to be relayed and processed.", irreversible: false },
+    { key: "destination-confirmation", kind: "confirm-delivery", chainId: destination.chainId, executor: "protocol", description: `Confirm relayer delivery of ${destination.symbol} on the destination chain.`, irreversible: false }
+  );
+  return steps;
+}
+function prepare(registry, params) {
+  const sourceAsset = registry.assets.find((asset) => asset.chainId === params.source.chain && asset.key === params.source.asset);
+  if (!sourceAsset) throw new BridgeError(`Unknown source asset ${params.source.asset} on ${params.source.chain}`);
+  const destinationAsset = registry.assets.find((asset) => asset.chainId === params.destination.chain && asset.key === params.destination.asset);
+  if (!destinationAsset) throw new BridgeError(`Unknown destination asset ${params.destination.asset} on ${params.destination.chain}`);
+  const routes2 = registry.routes.filter((entry) => entry.sourceAssetId === sourceAsset.id && entry.destinationAssetId === destinationAsset.id && entry.availability !== "disabled" && (params.bridgeProtocol == null || entry.protocol === params.bridgeProtocol));
+  if (routes2.length === 0) {
+    throw new BridgeError(`No bridge route from ${params.source.chain}/${params.source.asset} to ${params.destination.chain}/${params.destination.asset}`);
+  }
+  if (routes2.length > 1) {
+    throw new BridgeError(`Multiple bridge routes match ${params.source.chain}/${params.source.asset} to ${params.destination.chain}/${params.destination.asset}; specify bridgeProtocol`);
+  }
+  const route2 = routes2[0];
+  const sourceChain = registry.chains.find((chain) => chain.id === sourceAsset.chainId);
+  const destinationChain = registry.chains.find((chain) => chain.id === destinationAsset.chainId);
+  if (params.privateRecipient === true && params.mintMode != null && params.mintMode !== "private") {
+    throw new BridgeError("privateRecipient conflicts with the selected mintMode");
+  }
+  const mintMode = params.mintMode ?? (params.privateRecipient === true ? "private" : "public");
+  if ((params.mintMode != null || params.privateRecipient === true) && destinationChain.family !== "aleo") {
+    throw new BridgeError("Aleo mint mode is only valid when the destination chain is Aleo");
+  }
+  if (route2.protocol !== "xreserve" && mintMode !== "public") {
+    throw new BridgeError("record and private mint modes are only supported by xReserve routes");
+  }
+  const atomic = parseDecimalAmount(params.amount, sourceAsset.decimals);
+  if (atomic <= 0n) throw new BridgeError("Bridge transfer amount must be greater than zero");
+  parseDecimalAmount(params.amount, destinationAsset.decimals);
+  if (destinationAsset.addressValidationRegex) {
+    const regex = new RegExp(destinationAsset.addressValidationRegex);
+    if (!regex.test(params.recipient)) {
+      throw new BridgeError(`Recipient does not match ${destinationAsset.chainId} address format`);
+    }
+  }
+  const steps = route2.protocol === "xreserve" ? xreserveSteps(route2, sourceAsset, destinationAsset, sourceChain, destinationChain, mintMode) : hyperlaneSteps(sourceAsset, destinationAsset, sourceChain, destinationChain);
+  const fees = [];
+  return {
+    registryVersion: registry.version,
+    protocol: route2.protocol,
+    route: route2,
+    sourceAsset,
+    destinationAsset,
+    amountIn: params.amount,
+    // Both current protocols preserve display units before live fee deduction.
+    // Omit a promise about net output until fee quoting is implemented.
+    recipient: params.recipient,
+    ...params.sender == null ? {} : { sender: params.sender },
+    mintMode,
+    privateRecipient: mintMode === "private",
+    fees,
+    steps
+  };
+}
+
+// src/actions/quote.ts
+async function quote5(registry, clients, params) {
+  const plan = prepare(registry, params);
+  const protocolParams = {
+    plan,
+    privateMintSecretNonce: params.privateMintSecretNonce
+  };
+  const chain = resolveTransferRoute(registry, plan).sourceChain;
+  const chainId = chain.id;
+  if (plan.protocol === "hyperlane" && chain.family === "evm") {
+    const client = requireEvmClient(registry, clients, chainId);
+    const quote6 = await quote2(registry, client, {
+      plan,
+      recipientBytes32: aleoAddressToBytes32(plan.recipient)
+    });
+    return { kind: "evm-hyperlane", plan, ...quote6 };
+  }
+  if (plan.protocol === "hyperlane" && chain.family === "solana") {
+    const quote6 = await quote3(
+      registry,
+      requireSolanaClient(registry, clients, chainId),
+      protocolParams
+    );
+    return { kind: "solana-hyperlane", plan, ...quote6 };
+  }
+  if (plan.protocol === "hyperlane" && chain.family === "aleo") {
+    const quote6 = await quote(
+      registry,
+      requireAleoClient(registry, clients, chainId).publicClient,
+      { routeId: plan.route.id }
+    );
+    return { kind: "aleo-hyperlane", plan, ...quote6 };
+  }
+  if (plan.protocol === "xreserve" && chain.family === "evm") {
+    const quote6 = await quote4(
+      registry,
+      requireEvmClient(registry, clients, chainId),
+      protocolParams
+    );
+    return { kind: "evm-xreserve", plan, ...quote6 };
+  }
+  if (plan.protocol === "xreserve" && chain.family === "aleo") {
+    const rawFee = plan.route.metadata?.withdrawalFeeAtomic;
+    if (typeof rawFee !== "string" || !/^\d+$/.test(rawFee)) {
+      throw new BridgeError(`xReserve withdrawal fee is missing or invalid: ${plan.route.id}`);
+    }
+    const feeAtomic = BigInt(rawFee);
+    const amountAtomic = parseDecimalAmount(plan.amountIn, plan.sourceAsset.decimals);
+    const formattedFee = formatDecimalAmount(feeAtomic, plan.sourceAsset.decimals);
+    if (amountAtomic <= feeAtomic) {
+      throw new BridgeError(`xReserve burn amount must exceed the ${formattedFee} ${plan.sourceAsset.symbol} withdrawal fee`);
+    }
+    const amountOutAtomic = amountAtomic - feeAtomic;
+    return {
+      kind: "aleo-xreserve",
+      plan,
+      routeId: plan.route.id,
+      protocol: "xreserve",
+      amountIn: plan.amountIn,
+      // xReserve preserves the displayed denomination across USDC and USDCx.
+      // The remaining atomic amount is still expressed in source units here;
+      // formatting it with destination decimals would change its value.
+      amountOut: formatDecimalAmount(amountOutAtomic, plan.sourceAsset.decimals),
+      fees: [
+        ...plan.fees,
+        {
+          kind: "protocol",
+          chainId,
+          assetId: plan.sourceAsset.id,
+          amount: formattedFee,
+          estimated: false
+        }
+      ],
+      status: "not-queried"
+    };
+  }
+  throw new BridgeError(`Unsupported ${plan.protocol} source chain family: ${chain.family}`);
+}
+
+// src/actions/complete.ts
+import { classifyBroadcastError, DuplicateTransactionError } from "@provablehq/veil-core";
+import { isHash as isHash3, isHex as isHex2 } from "viem";
+async function complete2(registry, clients, params) {
+  let plan;
+  let receipt;
+  if (params.progress) {
+    if (params.progress.next !== "complete") {
+      throw new BridgeError("Bridge progress has no destination action to complete");
+    }
+    plan = params.progress.plan;
+    receipt = params.progress.receipt;
+  } else if (params.plan && params.receipt) {
+    plan = params.plan;
+    receipt = params.receipt;
+  } else {
+    throw new BridgeError("Bridge completion requires recovered progress");
+  }
+  const route2 = resolveTransferRoute(registry, plan);
+  if (receipt.status !== "DESTINATION_ACTION_REQUIRED" || receipt.nextAction?.kind !== "xreserve-private-mint" || receipt.nextAction.chainId !== route2.destinationChain.id) {
+    throw new BridgeError("Bridge receipt has no supported destination action ready");
+  }
+  if (route2.route.protocol !== "xreserve" || route2.sourceChain.family !== "evm" || route2.destinationChain.family !== "aleo") {
+    throw new BridgeError("Destination completion is not implemented for this bridge route");
+  }
+  const payload = receipt.protocolState.payload;
+  const messageHash = receipt.protocolState.messageHash;
+  const attestation = receipt.protocolState.attestation;
+  if (typeof payload !== "string" || !isHex2(payload, { strict: true }) || typeof messageHash !== "string" || !isHash3(messageHash) || typeof attestation !== "string" || !isHex2(attestation, { strict: true })) {
+    throw new BridgeError("Ready xReserve receipt is missing its validated Circle attestation");
+  }
+  const preparedTransaction = receipt.protocolState.preparedDestinationTransaction;
+  if (preparedTransaction !== void 0) {
+    if (typeof preparedTransaction !== "string" || !preparedTransaction) {
+      throw new BridgeError("Prepared Aleo destination recovery is missing its serialized transaction");
+    }
+    let decoded;
+    try {
+      decoded = JSON.parse(preparedTransaction);
+    } catch (error) {
+      throw new BridgeError("Prepared Aleo destination recovery contains an invalid serialized transaction", { cause: error });
+    }
+    const transactionId = decoded && typeof decoded === "object" ? decoded.id : void 0;
+    if (typeof transactionId !== "string" || transactionId !== receipt.id) {
+      throw new BridgeError("Prepared Aleo destination recovery transaction id does not match its payload");
+    }
+    try {
+      const submittedId = await requireAleoClient(
+        registry,
+        clients,
+        route2.destinationChain.id
+      ).publicClient.request({
+        method: "sendTransaction",
+        params: { transaction: preparedTransaction }
+      });
+      if (submittedId !== transactionId) {
+        throw new BridgeError(`Aleo node returned transaction id ${submittedId}; expected ${transactionId}`);
+      }
+    } catch (error) {
+      if (error instanceof BridgeError) throw error;
+      const classified = classifyBroadcastError(error, transactionId);
+      if (!(classified instanceof DuplicateTransactionError)) throw classified;
+    }
+    const { nextAction: _nextAction2, ...ready } = receipt;
+    const submitted = {
+      ...ready,
+      status: "DESTINATION_CONFIRMING",
+      destinationTxId: transactionId,
+      protocolState: {
+        ...ready.protocolState,
+        preparedDestinationTransaction: void 0
+      }
+    };
+    await params.onCheckpoint?.(createBridgeCheckpoint(plan, submitted));
+    return { kind: "aleo-xreserve", transactionId, receipt: submitted };
+  }
+  const { nextAction: _nextAction, ...deposit } = receipt;
+  const result = await complete(
+    registry,
+    requireAleoClientWithWallet(registry, clients, route2.destinationChain.id, "complete xReserve private mint").walletClient,
+    {
+      plan,
+      deposit: { ...deposit, status: "ATTESTATION_PENDING" },
+      attestation: { status: "complete", payload, messageHash, attestation },
+      privateFee: params.privateFee,
+      onProgress: params.onProgress,
+      onPrepared: params.onCheckpoint ? async (transaction) => params.onCheckpoint?.(createBridgeCheckpoint(plan, {
+        ...receipt,
+        id: transaction.id,
+        protocolState: {
+          ...receipt.protocolState,
+          preparedDestinationTransaction: JSON.stringify(transaction)
+        }
+      })) : void 0,
+      privateMintSecretNonce: params.privateMintSecretNonce,
+      onSubmitted: params.onCheckpoint ? async (submitted) => params.onCheckpoint?.(createBridgeCheckpoint(plan, submitted)) : void 0
+    }
+  );
+  return { kind: "aleo-xreserve", ...result };
+}
+
+// src/actions/getStatus.ts
+import { transactionStatus } from "@provablehq/veil-core";
+import { isHash as isHash6 } from "viem";
+
+// src/utils/hyperlaneDelivery.ts
+import { readContract as readContract2 } from "@provablehq/veil-core";
+import { decodeFunctionResult as decodeFunctionResult4, encodeFunctionData as encodeFunctionData4, getAddress as getAddress5, hexToBytes as hexToBytes2, isAddress as isAddress4, isHash as isHash4, parseAbi as parseAbi4 } from "viem";
+var EVM_MAILBOX_ABI = parseAbi4(["function delivered(bytes32 id) view returns (bool)"]);
+function littleEndianU1282(bytes) {
+  let value = 0n;
+  for (let index = 0; index < bytes.length; index++) {
+    value |= BigInt(bytes[index]) << BigInt(index * 8);
+  }
+  return value;
+}
+function aleoDeliveryKey(messageId) {
+  const bytes = hexToBytes2(messageId);
+  const first = littleEndianU1282(bytes.slice(0, 16));
+  const second = littleEndianU1282(bytes.slice(16, 32));
+  return `{ id: [${first}u128, ${second}u128] }`;
+}
+async function readHyperlaneDelivery(client, params) {
+  if (!isHash4(params.messageId)) throw new BridgeError("Hyperlane delivery requires a 32-byte message id");
+  if (client.family === "aleo") {
+    if (!params.mailbox.endsWith(".aleo")) throw new BridgeError(`Invalid Aleo Hyperlane mailbox program: ${params.mailbox}`);
+    return await readContract2(client.publicClient, {
+      programId: params.mailbox,
+      mapping: "deliveries",
+      key: aleoDeliveryKey(params.messageId)
+    }) !== null;
+  }
+  if (!isAddress4(params.mailbox)) throw new BridgeError(`Invalid EVM Hyperlane mailbox address: ${params.mailbox}`);
+  const mailbox = getAddress5(params.mailbox);
+  const data = encodeFunctionData4({
+    abi: EVM_MAILBOX_ABI,
+    functionName: "delivered",
+    args: [params.messageId]
+  });
+  const result = await client.publicClient.call({ to: mailbox, data });
+  return decodeFunctionResult4({ abi: EVM_MAILBOX_ABI, functionName: "delivered", data: result });
+}
+
+// src/utils/xreserveDelivery.ts
+import { readContract as readContract3 } from "@provablehq/veil-core";
+import { isHash as isHash5 } from "viem";
+async function readXReserveDelivery(client, params) {
+  if (!params.bridgeProgram.endsWith(".aleo")) {
+    throw new BridgeError(`Invalid Aleo xReserve bridge program: ${params.bridgeProgram}`);
+  }
+  if (!isHash5(params.nonce)) throw new BridgeError("xReserve delivery requires a 32-byte deposit nonce");
+  const value = await readContract3(client.publicClient, {
+    programId: params.bridgeProgram,
+    mapping: "nullifier",
+    key: xReserveHexToAleoBytes(params.nonce, 32)
+  });
+  if (value === null) return false;
+  if (typeof value !== "string") throw new BridgeError("Aleo xReserve bridge returned an invalid nullifier value");
+  return value.trim() === "true";
+}
+
+// src/actions/getStatus.ts
+function withoutNextAction(receipt) {
+  const { nextAction: _nextAction, ...rest } = receipt;
+  return rest;
+}
+async function getStatus(registry, clients, client, params) {
+  const route2 = resolveTransferRoute(registry, params.plan);
+  const receipt = params.receipt;
+  if (receipt.protocol !== params.plan.protocol || receipt.protocolState.routeId !== params.plan.route.id) {
+    throw new BridgeError("Bridge receipt does not match the prepared route");
+  }
+  if (receipt.status === "COMPLETED" || receipt.status === "FAILED" || receipt.status === "EXPIRED") {
+    return receipt;
+  }
+  if (receipt.status === "SOURCE_APPROVAL_PENDING" && route2.sourceChain.family === "evm") {
+    if (!isHash6(receipt.id)) throw new BridgeError("Bridge receipt is missing its EVM approval transaction id");
+    const evm = requireEvmClient(registry, clients, route2.sourceChain.id);
+    const result = await evm.publicClient.getTransactionReceipt(receipt.id);
+    if (!result) return receipt;
+    if (result.status === "reverted") {
+      return {
+        ...withoutNextAction(receipt),
+        status: "FAILED",
+        protocolState: { ...receipt.protocolState, sourceError: `EVM approval transaction reverted: ${receipt.id}` }
+      };
+    }
+    return { ...receipt, status: "SOURCE_SUBMISSION_PENDING" };
+  }
+  if (receipt.status === "SOURCE_CONFIRMING" && route2.sourceChain.family === "aleo") {
+    const transactionId = receipt.sourceTxId;
+    if (!transactionId) throw new BridgeError("Bridge receipt is missing its Aleo source transaction id");
+    const aleo = requireAleoClient(registry, clients, route2.sourceChain.id);
+    const result = await transactionStatus(aleo.publicClient, { transactionId });
+    if (result.status === "accepted") {
+      return { ...withoutNextAction(receipt), status: "DELIVERY_PENDING" };
+    }
+    if (result.status === "rejected") {
+      return {
+        ...withoutNextAction(receipt),
+        status: "FAILED",
+        protocolState: { ...receipt.protocolState, sourceError: result.error ?? "Aleo transaction was rejected" }
+      };
+    }
+    return receipt;
+  }
+  if (receipt.status === "SOURCE_CONFIRMING" && route2.route.protocol === "hyperlane" && route2.sourceChain.family === "evm") {
+    return getSourceStatus(
+      registry,
+      requireEvmClient(registry, clients, route2.sourceChain.id),
+      params.plan,
+      aleoAddressToBytes32(params.plan.recipient),
+      receipt
+    );
+  }
+  if (receipt.status === "SOURCE_CONFIRMING" && route2.route.protocol === "hyperlane" && route2.sourceChain.family === "solana") {
+    return getSourceStatus2(
+      requireSolanaClient(registry, clients, route2.sourceChain.id),
+      receipt
+    );
+  }
+  if (receipt.status === "DELIVERY_PENDING" && route2.route.protocol === "hyperlane" && receipt.messageId && (route2.destinationChain.family === "aleo" || route2.destinationChain.family === "evm")) {
+    const destinationClient = route2.destinationChain.family === "aleo" ? requireAleoClient(registry, clients, route2.destinationChain.id) : requireEvmClient(registry, clients, route2.destinationChain.id);
+    const mailbox = route2.destinationChain.family === "aleo" ? route2.route.metadata?.aleoMailboxProgram : route2.route.metadata?.mailboxAddress;
+    if (typeof mailbox !== "string" || !mailbox) {
+      throw new BridgeError(`Hyperlane destination mailbox is not configured for ${route2.route.id}`);
+    }
+    const delivered = await readHyperlaneDelivery(destinationClient, { messageId: receipt.messageId, mailbox });
+    if (!delivered) return receipt;
+    return { ...withoutNextAction(receipt), status: "COMPLETED" };
+  }
+  if (receipt.status === "DELIVERY_PENDING" && route2.route.protocol === "hyperlane" && route2.sourceChain.family === "aleo") {
+    const before = receipt.protocolState.destinationBalanceBeforeAtomic;
+    const expected = receipt.protocolState.expectedDestinationIncreaseAtomic;
+    if (typeof before !== "string" || !/^\d+$/.test(before) || typeof expected !== "string" || !/^\d+$/.test(expected)) {
+      return receipt;
+    }
+    const current = await readDestinationBalance(registry, clients, params.plan);
+    if (current === void 0) {
+      throw new BridgeError(`No supported destination balance verifier is configured for ${route2.destinationChain.id}`);
+    }
+    if (current < BigInt(before) + BigInt(expected)) return receipt;
+    return { ...withoutNextAction(receipt), status: "COMPLETED" };
+  }
+  if (route2.route.protocol === "hyperlane") {
+    return receipt;
+  }
+  if (receipt.status === "DELIVERY_PENDING" && route2.route.protocol === "xreserve" && route2.sourceChain.family === "aleo" && route2.destinationChain.family === "evm") {
+    return receipt;
+  }
+  if (route2.route.protocol !== "xreserve" || route2.sourceChain.family !== "evm" || route2.destinationChain.family !== "aleo") {
+    throw new BridgeError("Status refresh is not implemented for this bridge route");
+  }
+  const shouldCheckDelivery = receipt.status === "ATTESTATION_PENDING" || receipt.status === "DELIVERY_PENDING" || receipt.status === "DESTINATION_ACTION_REQUIRED";
+  if (receipt.status === "DELIVERY_PENDING" && !clients[route2.destinationChain.id]) {
+    throw new BridgeError(`An Aleo client is required to verify xReserve delivery on chain "${route2.destinationChain.id}"`);
+  }
+  if (shouldCheckDelivery && clients[route2.destinationChain.id]) {
+    const storedNonce = receipt.protocolState.nonce;
+    const payload = receipt.protocolState.payload;
+    const nonce = typeof storedNonce === "string" ? storedNonce : typeof payload === "string" ? xReserveDepositNonceFromPayload(payload) : void 0;
+    const bridgeProgram = receipt.protocolState.bridgeProgram ?? route2.route.metadata?.bridgeProgram;
+    if (typeof nonce === "string" && typeof bridgeProgram === "string") {
+      const delivered = await readXReserveDelivery(
+        requireAleoClient(registry, clients, route2.destinationChain.id),
+        { bridgeProgram, nonce }
+      );
+      if (delivered) return { ...withoutNextAction(receipt), status: "COMPLETED" };
+    }
+  }
+  if (receipt.status === "SOURCE_CONFIRMING") {
+    return getSourceStatus3(
+      registry,
+      requireEvmClient(registry, clients, route2.sourceChain.id),
+      params.plan,
+      receipt
+    );
+  }
+  if (receipt.status === "ATTESTATION_PENDING") {
+    const messageHash = receipt.protocolState.messageHash;
+    if (typeof messageHash !== "string" || !isHash6(messageHash)) {
+      throw new BridgeError("xReserve receipt is missing its Circle message hash");
+    }
+    const attestation = await getAttestation(registry, client, {
+      routeId: params.plan.route.id,
+      messageHash,
+      signal: params.signal
+    });
+    if (attestation.status === "pending") return receipt;
+    if (params.plan.mintMode !== "private") {
+      return { ...receipt, status: "DELIVERY_PENDING", protocolState: { ...receipt.protocolState, attestation: attestation.attestation } };
+    }
+    return {
+      ...receipt,
+      status: "DESTINATION_ACTION_REQUIRED",
+      nextAction: { kind: "xreserve-private-mint", chainId: route2.destinationChain.id },
+      protocolState: { ...receipt.protocolState, attestation: attestation.attestation }
+    };
+  }
+  if (receipt.status === "DESTINATION_ACTION_REQUIRED") return receipt;
+  if (receipt.status === "DESTINATION_CONFIRMING") {
+    const transactionId = receipt.destinationTxId;
+    if (!transactionId) throw new BridgeError("xReserve receipt is missing its Aleo destination transaction id");
+    const aleo = requireAleoClient(registry, clients, route2.destinationChain.id);
+    const result = await transactionStatus(aleo.publicClient, { transactionId });
+    if (result.status === "accepted") {
+      return { ...withoutNextAction(receipt), status: "COMPLETED" };
+    }
+    if (result.status === "rejected") {
+      return {
+        ...withoutNextAction(receipt),
+        status: "FAILED",
+        protocolState: { ...receipt.protocolState, destinationError: result.error ?? "Aleo transaction was rejected" }
+      };
+    }
+    return receipt;
+  }
+  return receipt;
+}
+
+// src/actions/internal/toBridgeProgress.ts
+function failureMessage(receipt) {
+  const state = receipt.protocolState;
+  const message = state.destinationError ?? state.sourceError;
+  return typeof message === "string" ? message : `Bridge transfer ended in ${receipt.status}`;
+}
+function toBridgeProgress(plan, receipt) {
+  if (receipt.status === "SOURCE_SUBMISSION_PENDING") return { next: "resume", plan, receipt };
+  if (receipt.status === "DESTINATION_ACTION_REQUIRED") return { next: "complete", plan, receipt };
+  if (receipt.status === "COMPLETED") return { next: "done", plan, receipt };
+  if (receipt.status === "FAILED" || receipt.status === "EXPIRED") {
+    return { next: "failed", plan, receipt, error: failureMessage(receipt) };
+  }
+  return { next: "wait", plan, receipt };
+}
+
+// src/actions/recover.ts
+async function recover(registry, clients, client, params) {
+  const checkpoint = params.checkpoint;
+  if (checkpoint.version !== 1 || !checkpoint.intent || !checkpoint.route) {
+    throw new BridgeError("Bridge checkpoint format is invalid or unsupported");
+  }
+  const plan = prepare(registry, checkpoint.intent);
+  const route2 = resolveTransferRoute(registry, plan);
+  if (checkpoint.version !== 1 || checkpoint.route.id !== plan.route.id || checkpoint.route.registryVersion !== plan.registryVersion) {
+    throw new BridgeError("Bridge checkpoint does not match the prepared route");
+  }
+  let receipt;
+  if (route2.sourceChain.family === "aleo") {
+    const deliveryVerification = checkpoint.deliveryVerification ? {
+      destinationBalanceBeforeAtomic: checkpoint.deliveryVerification.balanceBeforeAtomic,
+      expectedDestinationIncreaseAtomic: checkpoint.deliveryVerification.expectedIncreaseAtomic
+    } : {};
+    const prepared = checkpoint.source?.preparedTransaction;
+    if (prepared && !checkpoint.source?.transactionId) {
+      if (checkpoint.destination || (checkpoint.source?.approvalTransactionIds?.length ?? 0) > 0) {
+        throw new BridgeError("Bridge checkpoint contains transactions that are invalid for a prepared Aleo source route");
+      }
+      let decoded;
+      try {
+        decoded = JSON.parse(prepared.serializedTransaction);
+      } catch (error) {
+        throw new BridgeError("Bridge checkpoint contains an invalid prepared Aleo transaction", { cause: error });
+      }
+      if (!decoded || typeof decoded !== "object" || decoded.id !== prepared.transactionId) {
+        throw new BridgeError("Bridge checkpoint prepared Aleo transaction id does not match its payload");
+      }
+      return toBridgeProgress(plan, {
+        id: prepared.transactionId,
+        protocol: plan.protocol,
+        status: "SOURCE_SUBMISSION_PENDING",
+        protocolState: {
+          routeId: checkpoint.route.id,
+          preparedTransaction: prepared.serializedTransaction,
+          ...deliveryVerification
+        }
+      });
+    }
+    if (!checkpoint.source?.transactionId) {
+      throw new BridgeError("Bridge checkpoint contains no submitted source transaction");
+    }
+    if (checkpoint.destination || (checkpoint.source.approvalTransactionIds?.length ?? 0) > 0) {
+      throw new BridgeError("Bridge checkpoint contains transactions that are invalid for an Aleo source route");
+    }
+    receipt = await getStatus(registry, clients, client, {
+      plan,
+      receipt: {
+        id: checkpoint.source.transactionId,
+        protocol: plan.protocol,
+        status: "SOURCE_CONFIRMING",
+        sourceTxId: checkpoint.source.transactionId,
+        protocolState: { routeId: checkpoint.route.id, ...deliveryVerification }
+      },
+      signal: params.signal
+    });
+    return toBridgeProgress(plan, receipt);
+  }
+  if (route2.sourceChain.family === "solana") {
+    if (!checkpoint.source?.transactionId) {
+      throw new BridgeError("Bridge checkpoint contains no submitted source transaction");
+    }
+    if (checkpoint.destination || (checkpoint.source.approvalTransactionIds?.length ?? 0) > 0) {
+      throw new BridgeError("Bridge checkpoint contains transactions that are invalid for a Solana source route");
+    }
+    const { blockhash, lastValidBlockHeight } = checkpoint.source;
+    if ((blockhash !== void 0 || lastValidBlockHeight !== void 0) && (typeof blockhash !== "string" || !blockhash || typeof lastValidBlockHeight !== "string" || !/^\d+$/.test(lastValidBlockHeight))) {
+      throw new BridgeError("Bridge checkpoint contains an invalid Solana blockhash lifetime");
+    }
+    receipt = await getStatus(registry, clients, client, {
+      plan,
+      receipt: {
+        id: checkpoint.source.transactionId,
+        protocol: plan.protocol,
+        status: "SOURCE_CONFIRMING",
+        sourceTxId: checkpoint.source.transactionId,
+        protocolState: {
+          routeId: checkpoint.route.id,
+          ...typeof blockhash === "string" && typeof lastValidBlockHeight === "string" ? { blockhash, lastValidBlockHeight } : {}
+        }
+      },
+      signal: params.signal
+    });
+    return toBridgeProgress(plan, receipt);
+  }
+  if (route2.route.protocol === "hyperlane" && route2.sourceChain.family === "evm") {
+    if (checkpoint.destination) {
+      throw new BridgeError("Bridge checkpoint contains a destination transaction that is invalid for this Hyperlane route");
+    }
+    receipt = await recoverSourceCheckpoint(
+      registry,
+      requireEvmClient(registry, clients, route2.sourceChain.id),
+      plan,
+      aleoAddressToBytes32(plan.recipient),
+      checkpoint
+    );
+    return toBridgeProgress(plan, receipt);
+  }
+  if (route2.route.protocol !== "xreserve" || route2.sourceChain.family !== "evm" || route2.destinationChain.family !== "aleo") {
+    throw new BridgeError("Bridge checkpoint recovery is not implemented for this route");
+  }
+  receipt = await recoverSourceCheckpoint2(
+    registry,
+    requireEvmClient(registry, clients, route2.sourceChain.id),
+    plan,
+    checkpoint
+  );
+  const preparedDestination = checkpoint.destination?.preparedTransaction;
+  if (preparedDestination && checkpoint.destination?.transactionId) {
+    throw new BridgeError("Bridge checkpoint cannot contain both prepared and submitted destination transactions");
+  }
+  if (preparedDestination) {
+    let decoded;
+    try {
+      decoded = JSON.parse(preparedDestination.serializedTransaction);
+    } catch (error) {
+      throw new BridgeError("Bridge checkpoint contains an invalid prepared Aleo destination transaction", { cause: error });
+    }
+    if (!decoded || typeof decoded !== "object" || decoded.id !== preparedDestination.transactionId) {
+      throw new BridgeError("Bridge checkpoint prepared Aleo destination transaction id does not match its payload");
+    }
+  }
+  if (checkpoint.destination?.transactionId) {
+    receipt = {
+      ...receipt,
+      status: "DESTINATION_CONFIRMING",
+      destinationTxId: checkpoint.destination.transactionId
+    };
+  }
+  if (receipt.status === "ATTESTATION_PENDING" || receipt.status === "DESTINATION_CONFIRMING") {
+    receipt = await getStatus(registry, clients, client, {
+      plan,
+      receipt,
+      signal: params.signal
+    });
+  }
+  if (preparedDestination) {
+    if (receipt.status !== "DESTINATION_ACTION_REQUIRED") {
+      throw new BridgeError("Prepared destination transaction is no longer valid for the recovered bridge state");
+    }
+    receipt = {
+      ...receipt,
+      id: preparedDestination.transactionId,
+      protocolState: {
+        ...receipt.protocolState,
+        preparedDestinationTransaction: preparedDestination.serializedTransaction
+      }
+    };
+  }
+  return toBridgeProgress(plan, receipt);
+}
+
+// src/actions/resume.ts
+import { classifyBroadcastError as classifyBroadcastError2, DuplicateTransactionError as DuplicateTransactionError2 } from "@provablehq/veil-core";
+async function resume(registry, clients, params) {
+  const { plan, receipt } = params.progress;
+  if (params.progress.next !== "resume" || receipt.status !== "SOURCE_SUBMISSION_PENDING") {
+    throw new BridgeError("Bridge progress has no source submission to resume");
+  }
+  const route2 = resolveTransferRoute(registry, plan);
+  const onSubmitted = params.onCheckpoint ? async (value) => params.onCheckpoint?.(createBridgeCheckpoint(plan, value)) : void 0;
+  if (route2.sourceChain.family === "aleo") {
+    const serializedTransaction = receipt.protocolState.preparedTransaction;
+    if (typeof serializedTransaction !== "string" || !serializedTransaction) {
+      throw new BridgeError("Prepared Aleo recovery is missing its serialized transaction");
+    }
+    let decoded;
+    try {
+      decoded = JSON.parse(serializedTransaction);
+    } catch (error) {
+      throw new BridgeError("Prepared Aleo recovery contains an invalid serialized transaction", { cause: error });
+    }
+    const transactionId = decoded && typeof decoded === "object" ? decoded.id : void 0;
+    if (typeof transactionId !== "string" || transactionId !== receipt.id) {
+      throw new BridgeError("Prepared Aleo recovery transaction id does not match its payload");
+    }
+    try {
+      const submittedId = await requireAleoClient(
+        registry,
+        clients,
+        route2.sourceChain.id
+      ).publicClient.request({
+        method: "sendTransaction",
+        params: { transaction: serializedTransaction }
+      });
+      if (submittedId !== transactionId) {
+        throw new BridgeError(`Aleo node returned transaction id ${submittedId}; expected ${transactionId}`);
+      }
+    } catch (error) {
+      if (error instanceof BridgeError) throw error;
+      const classified = classifyBroadcastError2(error, transactionId);
+      if (!(classified instanceof DuplicateTransactionError2)) throw classified;
+    }
+    const submitted = {
+      id: transactionId,
+      protocol: plan.protocol,
+      status: "SOURCE_CONFIRMING",
+      sourceTxId: transactionId,
+      protocolState: {
+        routeId: plan.route.id,
+        ...typeof receipt.protocolState.destinationBalanceBeforeAtomic === "string" ? { destinationBalanceBeforeAtomic: receipt.protocolState.destinationBalanceBeforeAtomic } : {},
+        ...typeof receipt.protocolState.expectedDestinationIncreaseAtomic === "string" ? { expectedDestinationIncreaseAtomic: receipt.protocolState.expectedDestinationIncreaseAtomic } : {}
+      }
+    };
+    await onSubmitted?.(submitted);
+    return plan.protocol === "hyperlane" ? { kind: "aleo-hyperlane", transactionId, receipt: submitted } : { kind: "aleo-xreserve", transactionId, receipt: submitted };
+  }
+  if (route2.route.protocol === "xreserve" && route2.sourceChain.family === "evm") {
+    const execution = await execute5(
+      registry,
+      requireEvmClientWithWallet(registry, clients, route2.sourceChain.id, "resume xReserve transfer"),
+      {
+        plan,
+        resume: receipt,
+        pollingIntervalMs: params.pollingIntervalMs,
+        confirmationTimeoutMs: params.confirmationTimeoutMs,
+        onSubmitted,
+        privateMintSecretNonce: params.privateMintSecretNonce
+      }
+    );
+    return { kind: "evm-xreserve", ...execution };
+  }
+  if (route2.route.protocol === "hyperlane" && route2.sourceChain.family === "evm") {
+    const execution = await execute2(
+      registry,
+      requireEvmClientWithWallet(registry, clients, route2.sourceChain.id, "resume Hyperlane transfer"),
+      {
+        plan,
+        recipientBytes32: aleoAddressToBytes32(plan.recipient),
+        resume: receipt,
+        pollingIntervalMs: params.pollingIntervalMs,
+        confirmationTimeoutMs: params.confirmationTimeoutMs,
+        onSubmitted
+      }
+    );
+    return { kind: "evm-hyperlane", ...execution };
+  }
+  throw new BridgeError("Source resumption is not implemented for this bridge route");
+}
+
+// src/actions/wait.ts
+var CALLER_BOUNDARIES = [
+  "SOURCE_SUBMISSION_PENDING",
+  "DESTINATION_ACTION_REQUIRED",
+  "COMPLETED",
+  "FAILED",
+  "EXPIRED"
+];
+async function wait2(registry, clients, client, params) {
+  const { plan, receipt } = params.progress;
+  if (params.until?.length === 0) throw new BridgeError("wait requires at least one target status when until is provided");
+  resolveTransferRoute(registry, plan);
+  if (receipt.protocol !== plan.protocol || receipt.protocolState.routeId !== plan.route.id) {
+    throw new BridgeError("Bridge progress does not match its reconstructed plan");
+  }
+  const current = toBridgeProgress(plan, receipt);
+  const until = [.../* @__PURE__ */ new Set([...CALLER_BOUNDARIES, ...params.until ?? []])];
+  if (current.next !== "wait" || until.includes(receipt.status)) return current;
+  const requestedInterval = params.pollingIntervalMs ?? 15e3;
+  const timeoutMs = params.timeoutMs ?? 20 * 6e4;
+  if (!Number.isFinite(requestedInterval) || requestedInterval < 0 || !Number.isFinite(timeoutMs) || timeoutMs < 0) {
+    throw new BridgeError("Status polling controls must be non-negative finite numbers");
+  }
+  const interval = requestedInterval === 0 ? 0 : Math.max(100, requestedInterval);
+  const deadline = Date.now() + timeoutMs;
+  let updated = receipt;
+  while (true) {
+    if (params.signal?.aborted) throw new BridgeError("Bridge status polling was cancelled");
+    const next = await getStatus(registry, clients, client, { plan, receipt: updated, signal: params.signal });
+    if (next !== updated) await params.onUpdate?.(toBridgeProgress(plan, next));
+    updated = next;
+    if (until.includes(updated.status)) return toBridgeProgress(plan, updated);
+    if (Date.now() >= deadline) throw new BridgeError(`Bridge status polling timed out in state ${updated.status}`);
+    await new Promise((resolve2) => setTimeout(resolve2, interval));
+  }
+}
+
+// src/actions/internal/aleoPrivacy.ts
+var EMPTY_PROOF = `{ siblings: [${Array(16).fill("0field").join(", ")}], leaf_index: 1u32 }`;
+var EMPTY_MERKLE_PROOF_PAIR = `[${EMPTY_PROOF}, ${EMPTY_PROOF}]`;
+function resolvePrivacyAsset(registry, endpoint, operation) {
+  const asset = registry.assets.find((entry) => entry.chainId === endpoint.chain && entry.key === endpoint.asset);
+  if (!asset) throw new BridgeError(`Unknown bridge asset: "${endpoint.chain}/${endpoint.asset}"`);
+  const chain = registry.chains.find((entry) => entry.id === asset.chainId);
+  if (chain?.family !== "aleo" || !asset.privacy) {
+    throw new BridgeError(`Bridge asset "${asset.id}" does not support ${operation}`);
+  }
+  return asset;
+}
+function privacyAmount(asset, amount, operation) {
+  const amountAtomic = parseDecimalAmount(amount, asset.decimals);
+  if (amountAtomic <= 0n) throw new BridgeError(`${operation} amount must be greater than zero`);
+  return { amountAtomic, literal: `${amountAtomic}u128` };
+}
+function privacyRecord(program, amount) {
+  return {
+    type: "record",
+    program,
+    recordname: "Token",
+    filters: { amount: { gte: amount } }
+  };
+}
+
+// src/actions/shield.ts
+async function shield(registry, clients, params) {
+  const asset = resolvePrivacyAsset(registry, params.asset, "shielding");
+  const { amountAtomic, literal } = privacyAmount(asset, params.amount, "Shielding");
+  const { walletClient } = requireAleoClientWithWallet(registry, clients, asset.chainId, `shield ${asset.symbol}`);
+  const inputs = asset.privacy.kind === "arc22" ? [params.recipient ?? { type: "address", label: `${asset.symbol} private recipient` }, literal] : [literal];
+  const transactionId = await walletClient.executeTransaction({
+    program: asset.privacy.program,
+    function: asset.privacy.kind === "arc22" ? "transfer_public_to_private" : "shield",
+    inputs,
+    privateFee: params.privateFee ?? false,
+    onProgress: async (event) => {
+      await params.onProgress?.(event);
+      if (event.type === "transaction-prepared") await params.onPrepared?.(event.transaction);
+    }
+  });
+  if (!transactionId) throw new BridgeError(`Aleo wallet returned an empty ${asset.symbol} shield transaction id`);
+  return { transactionId, assetId: asset.id, amount: params.amount, amountAtomic };
+}
+
+// src/actions/unshield.ts
+async function unshield(registry, clients, params) {
+  const asset = resolvePrivacyAsset(registry, params.asset, "unshielding");
+  const { amountAtomic, literal } = privacyAmount(asset, params.amount, "Unshielding");
+  const { walletClient } = requireAleoClientWithWallet(registry, clients, asset.chainId, `unshield ${asset.symbol}`);
+  const record = params.record ?? privacyRecord(asset.privacy.program, literal);
+  const inputs = asset.privacy.kind === "arc22" ? [
+    params.recipient ?? { type: "address", label: `${asset.symbol} public recipient` },
+    literal,
+    record,
+    params.merkleProof ?? EMPTY_MERKLE_PROOF_PAIR
+  ] : [record, literal];
+  const transactionId = await walletClient.executeTransaction({
+    program: asset.privacy.program,
+    function: asset.privacy.kind === "arc22" ? "transfer_private_to_public" : "unshield",
+    inputs,
+    privateFee: params.privateFee ?? false,
+    onProgress: async (event) => {
+      await params.onProgress?.(event);
+      if (event.type === "transaction-prepared") await params.onPrepared?.(event.transaction);
+    }
+  });
+  if (!transactionId) throw new BridgeError(`Aleo wallet returned an empty ${asset.symbol} unshield transaction id`);
+  return { transactionId, assetId: asset.id, amount: params.amount, amountAtomic };
+}
+
+// src/clients/decorators/bridge.ts
+function bridgeActions(config) {
+  return {
+    // Every closure injects the same validated route catalog and
+    // registry-keyed clients, preventing per-action configuration drift.
+    quote: async (params) => quote5(config.registry, config.clients, params),
+    execute: async (params) => execute6(config.registry, config.clients, params),
+    getStatus: async (params) => getStatus(config.registry, config.clients, config.fetch, params),
+    complete: async (params) => complete2(config.registry, config.clients, params),
+    recover: async (params) => recover(config.registry, config.clients, config.fetch, params),
+    resume: async (params) => resume(config.registry, config.clients, params),
+    wait: async (params) => wait2(config.registry, config.clients, config.fetch, params),
+    shield: async (params) => shield(config.registry, config.clients, params),
+    unshield: async (params) => unshield(config.registry, config.clients, params)
+  };
+}
+
+// src/registry/default.ts
+var EVM_ADDRESS = "^0x[0-9a-fA-F]{40}$";
+var SOLANA_ADDRESS = "^[1-9A-HJ-NP-Za-km-z]{32,44}$";
+var ALEO_ADDRESS = "^aleo1[0-9a-z]{58}$";
+var chains = [
+  { id: "aleo", displayName: "Aleo", family: "aleo", environment: "mainnet", nativeCurrencySymbol: "ALEO", protocolDomains: { xreserve: 10002, hyperlane: 1634493807 } },
+  { id: "ethereum", displayName: "Ethereum", family: "evm", environment: "mainnet", nativeCurrencySymbol: "ETH", protocolDomains: { xreserve: 0, hyperlane: 1 } },
+  { id: "solana", displayName: "Solana", family: "solana", environment: "mainnet", nativeCurrencySymbol: "SOL", protocolDomains: { hyperlane: 1399811149 } },
+  { id: "base", displayName: "Base", family: "evm", environment: "mainnet", nativeCurrencySymbol: "ETH" },
+  { id: "hyperevm", displayName: "HyperEVM", family: "evm", environment: "mainnet", nativeCurrencySymbol: "HYPE" },
+  { id: "aleo-testnet", displayName: "Aleo Testnet", family: "aleo", environment: "testnet", nativeCurrencySymbol: "ALEO", protocolDomains: { xreserve: 10002, hyperlane: 1617853565 } },
+  { id: "sepolia", displayName: "Ethereum Sepolia", family: "evm", environment: "testnet", nativeCurrencySymbol: "ETH", protocolDomains: { hyperlane: 11155111 } }
+];
+var assets = [
+  { id: "aleo/aleo", key: "aleo", chainId: "aleo", symbol: "ALEO", name: "Aleo", decimals: 6, kind: "native", locator: { kind: "aleo-program", value: "credits.aleo" }, addressValidationRegex: ALEO_ADDRESS },
+  { id: "aleo/usdcx", key: "usdcx", chainId: "aleo", symbol: "USDCx", name: "USDCx", decimals: 6, kind: "token", locator: { kind: "aleo-program", value: "usdcx_stablecoin.aleo" }, addressValidationRegex: ALEO_ADDRESS, privacy: { kind: "arc22", program: "usdcx_stablecoin.aleo" } },
+  { id: "aleo/eth", key: "eth", chainId: "aleo", symbol: "ETH", name: "Hyperlane ETH", decimals: 18, kind: "token", locator: { kind: "aleo-program", value: "hyp_warp_token_eth_v2.aleo", tokenId: "aleo1t7f29tq9qng2lfvrkpcuvu59jn24hrmzqdyqfn6p0u5p80npfvqqecmkj8" }, addressValidationRegex: ALEO_ADDRESS, privacy: { kind: "arc20", program: "arc20_eth.aleo" } },
+  { id: "aleo/wbtc", key: "wbtc", chainId: "aleo", symbol: "WBTC", name: "Hyperlane WBTC", decimals: 8, kind: "token", locator: { kind: "aleo-program", value: "hyp_warp_token_wbtc_v2.aleo", tokenId: "aleo1240fsvz2dhmj0cdtt8mc0yc8um9fmu236rqcl2qnlj9703hd2vpsdwyrtf" }, addressValidationRegex: ALEO_ADDRESS, privacy: { kind: "arc20", program: "arc20_wbtc.aleo" } },
+  { id: "aleo/usdt", key: "usdt", chainId: "aleo", symbol: "USDT", name: "Hyperlane USDT", decimals: 6, kind: "token", locator: { kind: "aleo-program", value: "hyp_warp_token_usdt_v2.aleo", tokenId: "aleo18yynfz0lrfx0tund540vy2z7gju7ekgqsueg5jgu28mpm2z42ufq7qua8y" }, addressValidationRegex: ALEO_ADDRESS, privacy: { kind: "arc20", program: "arc20_usdt.aleo" } },
+  { id: "aleo/sol", key: "sol", chainId: "aleo", symbol: "SOL", name: "Hyperlane SOL", decimals: 9, kind: "token", locator: { kind: "aleo-program", value: "hyp_warp_token_sol_v2.aleo", tokenId: "aleo1aa0zt0vg9uwknekpqeefkvad55swp7833wc5crp2prv0lm4djuxs5r7k6v" }, addressValidationRegex: ALEO_ADDRESS, privacy: { kind: "arc20", program: "arc20_sol.aleo" } },
+  { id: "aleo/usad", key: "usad", chainId: "aleo", symbol: "USAD", name: "USAD", decimals: 6, kind: "token", locator: { kind: "aleo-program", value: "usad_stablecoin.aleo" }, addressValidationRegex: ALEO_ADDRESS },
+  { id: "ethereum/usdc", key: "usdc", chainId: "ethereum", symbol: "USDC", name: "USD Coin", decimals: 6, kind: "token", locator: { kind: "evm-contract", value: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" }, addressValidationRegex: EVM_ADDRESS },
+  { id: "ethereum/eth", key: "eth", chainId: "ethereum", symbol: "ETH", name: "Ether", decimals: 18, kind: "native", locator: { kind: "native", value: "ETH" }, addressValidationRegex: EVM_ADDRESS },
+  { id: "ethereum/wbtc", key: "wbtc", chainId: "ethereum", symbol: "WBTC", name: "Wrapped Bitcoin", decimals: 8, kind: "token", locator: { kind: "evm-contract", value: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599" }, addressValidationRegex: EVM_ADDRESS },
+  { id: "ethereum/usdt", key: "usdt", chainId: "ethereum", symbol: "USDT", name: "Tether USD", decimals: 6, kind: "token", locator: { kind: "evm-contract", value: "0xdAC17F958D2ee523a2206206994597C13D831ec7" }, addressValidationRegex: EVM_ADDRESS },
+  { id: "ethereum/aleo", key: "aleo", chainId: "ethereum", symbol: "ALEO", name: "Hyperlane ALEO", decimals: 6, kind: "token", addressValidationRegex: EVM_ADDRESS },
+  { id: "ethereum/usad", key: "usad", chainId: "ethereum", symbol: "USAD", name: "USAD route collateral", decimals: 6, kind: "token", addressValidationRegex: EVM_ADDRESS },
+  { id: "solana/sol", key: "sol", chainId: "solana", symbol: "SOL", name: "Solana", decimals: 9, kind: "native", locator: { kind: "native", value: "SOL" }, addressValidationRegex: SOLANA_ADDRESS },
+  { id: "solana/aleo", key: "aleo", chainId: "solana", symbol: "ALEO", name: "Hyperlane ALEO", decimals: 6, kind: "token", addressValidationRegex: SOLANA_ADDRESS },
+  { id: "base/aleo", key: "aleo", chainId: "base", symbol: "ALEO", name: "Hyperlane ALEO", decimals: 6, kind: "token", addressValidationRegex: EVM_ADDRESS },
+  { id: "hyperevm/aleo", key: "aleo", chainId: "hyperevm", symbol: "ALEO", name: "Hyperlane ALEO", decimals: 6, kind: "token", addressValidationRegex: EVM_ADDRESS },
+  { id: "aleo-testnet/usdcx", key: "usdcx", chainId: "aleo-testnet", symbol: "USDCx", name: "Testnet USDCx", decimals: 6, kind: "token", locator: { kind: "aleo-program", value: "test_usdcx_stablecoin.aleo" }, addressValidationRegex: ALEO_ADDRESS, privacy: { kind: "arc22", program: "test_usdcx_stablecoin.aleo" } },
+  { id: "sepolia/usdc", key: "usdc", chainId: "sepolia", symbol: "USDC", name: "Testnet USD Coin", decimals: 6, kind: "token", locator: { kind: "evm-contract", value: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238" }, addressValidationRegex: EVM_ADDRESS }
+];
+var XRESERVE_SOURCE = "https://developers.circle.com/xreserve/references/supported-blockchains-and-domains";
+var HYPERLANE_REGISTRY_COMMIT = "2621c16f2db1ccb46643265c110dac5ca2c7c51a";
+var HYPERLANE_SOURCE = `https://github.com/hyperlane-xyz/hyperlane-registry/tree/${HYPERLANE_REGISTRY_COMMIT}/deployments/warp_routes`;
+var ALEO_ETH_PROGRAM_SOURCE = "https://explorer.provable.com/program/hyp_warp_token_eth_v2.aleo";
+var ALEO_ETH_APP_METADATA_SOURCE = "https://api.explorer.provable.com/v2/mainnet/program/hyp_warp_token_eth_v2.aleo/mapping/app_metadata/true";
+var ALEO_ETH_REMOTE_ROUTER_SOURCE = "https://api.explorer.provable.com/v2/mainnet/program/hyp_warp_token_eth_v2.aleo/mapping/remote_routers/1u32";
+var ALEO_ETH_SAMPLE_TRANSFER_SOURCE = "https://explorer.provable.com/transaction/at1vu0yckkms887zkl3qz7plnncd56jtf5zeal4uj2808upsjkusy8q7yp9v8";
+var ALEO_WBTC_PROGRAM_SOURCE = "https://explorer.provable.com/program/hyp_warp_token_wbtc_v2.aleo";
+var ALEO_WBTC_APP_METADATA_SOURCE = "https://api.explorer.provable.com/v2/mainnet/program/hyp_warp_token_wbtc_v2.aleo/mapping/app_metadata/true";
+var ALEO_WBTC_REMOTE_ROUTER_SOURCE = "https://api.explorer.provable.com/v2/mainnet/program/hyp_warp_token_wbtc_v2.aleo/mapping/remote_routers/1u32";
+var ALEO_USDT_PROGRAM_SOURCE = "https://explorer.provable.com/program/hyp_warp_token_usdt_v2.aleo";
+var ALEO_USDT_APP_METADATA_SOURCE = "https://api.explorer.provable.com/v2/mainnet/program/hyp_warp_token_usdt_v2.aleo/mapping/app_metadata/true";
+var ALEO_USDT_ETHEREUM_REMOTE_ROUTER_SOURCE = "https://api.explorer.provable.com/v2/mainnet/program/hyp_warp_token_usdt_v2.aleo/mapping/remote_routers/1u32";
+var ALEO_USDT_SAMPLE_TRANSFER_SOURCE = "https://explorer.provable.com/transaction/at19caeeee8v3xc4kfwen4tx89f0tnggrpjp0anrhq2ca3y82xr9q8qyz8a9r";
+var ALEO_USDT_HYPERLANE_CONFIG_SOURCE = "https://github.com/hyperlane-xyz/hyperlane-registry/blob/418056e21734d26a7d14692e0ec5e902cc9e86bf/deployments/warp_routes/USDT/aleo-config.yaml";
+var ALEO_SOL_PROGRAM_SOURCE = "https://explorer.provable.com/program/hyp_warp_token_sol_v2.aleo";
+var ALEO_SOL_APP_METADATA_SOURCE = "https://api.explorer.provable.com/v2/mainnet/program/hyp_warp_token_sol_v2.aleo/mapping/app_metadata/true";
+var ALEO_SOL_REMOTE_ROUTER_SOURCE = "https://api.explorer.provable.com/v2/mainnet/program/hyp_warp_token_sol_v2.aleo/mapping/remote_routers/1399811149u32";
+var ALEO_SOL_HYPERLANE_CONFIG_SOURCE = "https://github.com/hyperlane-xyz/hyperlane-registry/blob/418056e21734d26a7d14692e0ec5e902cc9e86bf/deployments/warp_routes/SOL/aleo-config.yaml";
+var ALEO_MAILBOX_PROGRAM_SOURCE = "https://explorer.provable.com/program/hyp_mailbox.aleo";
+var ALEO_MAILBOX_METADATA_SOURCE = "https://api.explorer.provable.com/v2/mainnet/program/hyp_mailbox.aleo/mapping/mailbox/true";
+var ETHEREUM_HYPERLANE_COMMON = {
+  sourceChainId: 1,
+  destinationDomain: 1634493807,
+  mailboxAddress: "0xc005dc82818d67AF737725bD4bf75435d065D239",
+  interchainGasPaymaster: "0x9e6B1022bE9BBF5aFd152483DAD9b88911bC8611",
+  interchainSecurityModule: "0x0000000000000000000000000000000000000000",
+  registryCommit: HYPERLANE_REGISTRY_COMMIT
+};
+var ETH_HYPERLANE_METADATA = {
+  ...ETHEREUM_HYPERLANE_COMMON,
+  routerAddress: "0x38D447694f5c1f773ae3132cf93bF30B7Ec1Fa5A",
+  routerType: "native",
+  destinationRouter: "hyp_warp_token_eth_v2.aleo/aleo1t7f29tq9qng2lfvrkpcuvu59jn24hrmzqdyqfn6p0u5p80npfvqqecmkj8"
+};
+var WBTC_HYPERLANE_METADATA = {
+  ...ETHEREUM_HYPERLANE_COMMON,
+  routerAddress: "0x20CDC85778b732073F7EecEF3DF25c0d310f8772",
+  routerType: "collateral",
+  tokenAddress: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+  destinationRouter: "hyp_warp_token_wbtc_v2.aleo/aleo1240fsvz2dhmj0cdtt8mc0yc8um9fmu236rqcl2qnlj9703hd2vpsdwyrtf"
+};
+var USDT_HYPERLANE_METADATA = {
+  ...ETHEREUM_HYPERLANE_COMMON,
+  routerAddress: "0x3C2064D78e4578E8F936E3db42aEF044E33FBF31",
+  routerType: "collateral",
+  tokenAddress: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+  destinationRouter: "hyp_warp_token_usdt_v2.aleo/aleo18yynfz0lrfx0tund540vy2z7gju7ekgqsueg5jgu28mpm2z42ufq7qua8y",
+  requiresApprovalReset: true
+};
+var ALEO_PLACEHOLDER_ADDRESS = "aleo1kypwp5m7qtk9mwazgcpg0tq8aal23mnrvwfvug65qgcg9xvsrqgspyjm6n";
+var ALEO_PLACEHOLDER_BYTES32 = `[${Array.from({ length: 32 }, () => "0u8").join(", ")}]`;
+var ALEO_MAILBOX_METADATA = {
+  aleoMailboxStateVerified: true,
+  aleoHookManagerProgram: "hyp_hook_manager.aleo",
+  aleoHookManagerProgramSource: "https://explorer.provable.com/program/hyp_hook_manager.aleo",
+  aleoMailboxProgram: "hyp_mailbox.aleo",
+  aleoMailboxProgramEdition: 0,
+  aleoMailboxProgramSource: ALEO_MAILBOX_PROGRAM_SOURCE,
+  aleoMailboxMetadataSource: ALEO_MAILBOX_METADATA_SOURCE,
+  aleoMailboxMetadataReviewedAt: "2026-08-17",
+  aleoMailboxLocalDomain: 1634493807,
+  aleoMailboxObservedNonce: 170,
+  aleoMailboxObservedProcessCount: 291,
+  aleoMailboxDefaultIsm: "aleo1yvf5kcsdgnescqq2lar83mms79yh3ugvc3y0mdnlgvx4lyh5zugqr9hptk",
+  aleoMailboxDefaultHook: "aleo194tz0jmyq8rd9htvnqppqw4jqerk2p2zd8plzn3sxl06wcgsm5pq9fka74",
+  aleoMailboxRequiredHook: "aleo1yxevh9qgxehej46j7vueplwjcpfdfml2dje3ey4ukzknx7wzasgqnxgq82",
+  aleoMailboxDispatchProxy: "aleo1sge9kmjzs3d8fqrscy4hwn7vf9vw4jcxe877lv0m2w8hay78lsxsqg975s",
+  aleoMailboxOwner: "aleo1ypf8xgvz560ukw25hufj3d77gx69pdcy70nssdfdxd97j80d7cqs98d7x8"
+};
+function aleoHyperlanePlaceholders(program, destinationDomain) {
+  return {
+    aleoRouterProgram: program,
+    aleoDestinationDomain: destinationDomain,
+    aleoPlaceholderConfiguration: true,
+    aleoTokenType: "0",
+    aleoTokenOwner: ALEO_PLACEHOLDER_ADDRESS,
+    aleoIsm: ALEO_PLACEHOLDER_ADDRESS,
+    aleoHook: ALEO_PLACEHOLDER_ADDRESS,
+    aleoTokenId: "0field",
+    aleoRemoteRouterRecipient: ALEO_PLACEHOLDER_BYTES32,
+    aleoRemoteRouterGas: "0",
+    aleoRecipient: "[0u128, 0u128]",
+    aleoAllowanceSpender0: ALEO_PLACEHOLDER_ADDRESS,
+    aleoAllowanceAmount0: "0",
+    aleoAllowanceSpender1: ALEO_PLACEHOLDER_ADDRESS,
+    aleoAllowanceAmount1: "0",
+    aleoAllowanceSpender2: ALEO_PLACEHOLDER_ADDRESS,
+    aleoAllowanceAmount2: "0",
+    aleoAllowanceSpender3: ALEO_PLACEHOLDER_ADDRESS,
+    aleoAllowanceAmount3: "0",
+    ...ALEO_MAILBOX_METADATA
+  };
+}
+var ALEO_WBTC_APP_METADATA = {
+  aleoAppMetadataVerified: true,
+  aleoProgramSource: ALEO_WBTC_PROGRAM_SOURCE,
+  aleoAppMetadataSource: ALEO_WBTC_APP_METADATA_SOURCE,
+  aleoAppMetadataReviewedAt: "2026-08-17",
+  aleoProgramEdition: 0,
+  aleoTokenType: "1",
+  aleoTokenOwner: "aleo14jauje2a5sncm9u5t3mt6qqv3eq2hatkddskccs0dvsy35a0x58q0d6f95",
+  aleoIsm: "aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc",
+  aleoHook: "aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc",
+  aleoTokenId: "1505227928464760254508513036497943623956572091841806589002910775534260084309field",
+  aleoLocalDecimals: 8,
+  aleoRemoteDecimals: 8
+};
+var ALEO_ETH_APP_METADATA = {
+  aleoAppMetadataVerified: true,
+  aleoProgramSource: ALEO_ETH_PROGRAM_SOURCE,
+  aleoAppMetadataSource: ALEO_ETH_APP_METADATA_SOURCE,
+  aleoAppMetadataReviewedAt: "2026-08-17",
+  aleoProgramEdition: 0,
+  aleoTokenType: "1",
+  aleoTokenOwner: "aleo1wq6f6qdqya44avznygz5hae40u3mjg64w0r93a4qfu4utpf8cg9q566f4r",
+  aleoIsm: "aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc",
+  aleoHook: "aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc",
+  aleoTokenId: "133188123661477349522757068766864658505569365361420630212878794317749195359field",
+  aleoLocalDecimals: 18,
+  aleoRemoteDecimals: 18
+};
+var ALEO_USDT_APP_METADATA = {
+  aleoAppMetadataVerified: true,
+  aleoProgramSource: ALEO_USDT_PROGRAM_SOURCE,
+  aleoAppMetadataSource: ALEO_USDT_APP_METADATA_SOURCE,
+  aleoAppMetadataReviewedAt: "2026-08-17",
+  aleoProgramEdition: 1,
+  aleoTokenType: "1",
+  aleoTokenOwner: "aleo1l3gwacmjruxryy9c7c4fn0acyzprf29hucrvthw7f63lpyhd5y9srydq8z",
+  aleoIsm: "aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc",
+  aleoHook: "aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc",
+  aleoTokenId: "8295938150000417034830036849466229528602563851235385582732969109393809606969field",
+  aleoLocalDecimals: 6,
+  aleoRemoteDecimals: 18,
+  aleoScale: "1000000000000",
+  aleoHyperlaneConfigSource: ALEO_USDT_HYPERLANE_CONFIG_SOURCE
+};
+var ALEO_SOL_APP_METADATA = {
+  aleoAppMetadataVerified: true,
+  aleoProgramSource: ALEO_SOL_PROGRAM_SOURCE,
+  aleoAppMetadataSource: ALEO_SOL_APP_METADATA_SOURCE,
+  aleoAppMetadataReviewedAt: "2026-08-17",
+  aleoProgramEdition: 0,
+  aleoTokenType: "1",
+  aleoTokenOwner: "aleo1wr8rfr4ggedjxtg5e23s38zqkgy2j05uc9l8t4akjp5zcw3levpswkwk45",
+  aleoIsm: "aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc",
+  aleoHook: "aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc",
+  aleoTokenId: "6148061383892805373029428966764338809222769879628268522058032128225601478383field",
+  aleoLocalDecimals: 9,
+  aleoRemoteDecimals: 9,
+  aleoHyperlaneConfigSource: ALEO_SOL_HYPERLANE_CONFIG_SOURCE
+};
+var ALEO_ETH_REMOTE_ROUTER = {
+  aleoRemoteRouterVerified: true,
+  aleoRemoteRouterSource: ALEO_ETH_REMOTE_ROUTER_SOURCE,
+  aleoRemoteRouterReviewedAt: "2026-08-17",
+  aleoSampleTransferSource: ALEO_ETH_SAMPLE_TRANSFER_SOURCE,
+  aleoDestinationDomain: 1,
+  aleoRemoteRouterEvmAddress: "0x38D447694f5c1f773ae3132cf93bF30B7Ec1Fa5A",
+  aleoRemoteRouterRecipient: "[0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 56u8, 212u8, 71u8, 105u8, 79u8, 92u8, 31u8, 119u8, 58u8, 227u8, 19u8, 44u8, 249u8, 59u8, 243u8, 11u8, 126u8, 193u8, 250u8, 90u8]",
+  aleoRemoteRouterGas: "44000",
+  aleoAllowanceSpendersVerified: true,
+  aleoUnusedAllowancesVerified: true,
+  aleoAllowanceSpender0: "aleo194tz0jmyq8rd9htvnqppqw4jqerk2p2zd8plzn3sxl06wcgsm5pq9fka74",
+  aleoAllowanceSpender1: "aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc",
+  aleoAllowanceSpender2: "aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc",
+  aleoAllowanceSpender3: "aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc",
+  aleoAllowanceAmount1: "0",
+  aleoAllowanceAmount2: "0",
+  aleoAllowanceAmount3: "0"
+};
+var ALEO_WBTC_REMOTE_ROUTER = {
+  aleoRemoteRouterVerified: true,
+  aleoRemoteRouterSource: ALEO_WBTC_REMOTE_ROUTER_SOURCE,
+  aleoRemoteRouterReviewedAt: "2026-08-17",
+  aleoDestinationDomain: 1,
+  aleoRemoteRouterEvmAddress: "0x20CDC85778b732073F7EecEF3DF25c0d310f8772",
+  aleoRemoteRouterRecipient: "[0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 32u8, 205u8, 200u8, 87u8, 120u8, 183u8, 50u8, 7u8, 63u8, 126u8, 236u8, 239u8, 61u8, 242u8, 92u8, 13u8, 49u8, 15u8, 135u8, 114u8]",
+  aleoRemoteRouterGas: "68000",
+  aleoAllowanceSpendersVerified: true,
+  aleoUnusedAllowancesVerified: true,
+  aleoAllowanceSpender0: "aleo194tz0jmyq8rd9htvnqppqw4jqerk2p2zd8plzn3sxl06wcgsm5pq9fka74",
+  aleoAllowanceSpender1: "aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc",
+  aleoAllowanceSpender2: "aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc",
+  aleoAllowanceSpender3: "aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc",
+  aleoAllowanceAmount1: "0",
+  aleoAllowanceAmount2: "0",
+  aleoAllowanceAmount3: "0"
+};
+var ALEO_USDT_ETHEREUM_REMOTE_ROUTER = {
+  aleoRemoteRouterVerified: true,
+  aleoRemoteRouterSource: ALEO_USDT_ETHEREUM_REMOTE_ROUTER_SOURCE,
+  aleoRemoteRouterReviewedAt: "2026-08-17",
+  aleoSampleTransferSource: ALEO_USDT_SAMPLE_TRANSFER_SOURCE,
+  aleoSampleTransferDestinationDomain: 56,
+  aleoDestinationDomain: 1,
+  aleoRemoteRouterEvmAddress: "0x3C2064D78e4578E8F936E3db42aEF044E33FBF31",
+  aleoRemoteRouterRecipient: "[0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 60u8, 32u8, 100u8, 215u8, 142u8, 69u8, 120u8, 232u8, 249u8, 54u8, 227u8, 219u8, 66u8, 174u8, 240u8, 68u8, 227u8, 63u8, 191u8, 49u8]",
+  aleoRemoteRouterGas: "68000",
+  aleoAllowanceSpendersVerified: true,
+  aleoUnusedAllowancesVerified: true,
+  aleoAllowanceSpender0: "aleo194tz0jmyq8rd9htvnqppqw4jqerk2p2zd8plzn3sxl06wcgsm5pq9fka74",
+  aleoAllowanceSpender1: "aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc",
+  aleoAllowanceSpender2: "aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc",
+  aleoAllowanceSpender3: "aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc",
+  aleoAllowanceAmount1: "0",
+  aleoAllowanceAmount2: "0",
+  aleoAllowanceAmount3: "0"
+};
+var ALEO_SOL_REMOTE_ROUTER = {
+  aleoRemoteRouterVerified: true,
+  aleoRemoteRouterSource: ALEO_SOL_REMOTE_ROUTER_SOURCE,
+  aleoRemoteRouterReviewedAt: "2026-08-17",
+  aleoSampleTransitionId: "au15fg39h53h55tkj0nexrme3k6pvgxngxapcyajdhf06jcg3cyeugq5kd7hg",
+  aleoDestinationDomain: 1399811149,
+  aleoRemoteRouterSolanaAddress: "8YGT2pZwyZe94qBpGzWfY2TMEVcwaQ1bXAE7YAgpUaM7",
+  aleoRemoteRouterRecipient: "[112u8, 4u8, 72u8, 22u8, 219u8, 143u8, 68u8, 202u8, 21u8, 197u8, 236u8, 182u8, 198u8, 142u8, 52u8, 96u8, 142u8, 38u8, 51u8, 113u8, 116u8, 143u8, 96u8, 123u8, 104u8, 126u8, 97u8, 73u8, 7u8, 6u8, 211u8, 122u8]",
+  aleoRemoteRouterGas: "300000",
+  aleoAllowanceSpendersVerified: true,
+  aleoUnusedAllowancesVerified: true,
+  aleoAllowanceSpender0: "aleo194tz0jmyq8rd9htvnqppqw4jqerk2p2zd8plzn3sxl06wcgsm5pq9fka74",
+  aleoAllowanceSpender1: "aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc",
+  aleoAllowanceSpender2: "aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc",
+  aleoAllowanceSpender3: "aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc",
+  aleoAllowanceAmount1: "0",
+  aleoAllowanceAmount2: "0",
+  aleoAllowanceAmount3: "0"
+};
+var ALEO_WITHDRAWAL_ACTIVATION = {
+  aleoPlaceholderConfiguration: false,
+  aleoWithdrawalReviewedAt: "2026-08-26"
+};
+var SOLANA_SOL_DEPOSIT_METADATA = {
+  warpProgramAddress: "8YGT2pZwyZe94qBpGzWfY2TMEVcwaQ1bXAE7YAgpUaM7",
+  tokenPda: "JDkpV5CsSbhyGhHhirC5DjGPTcuKWUVHtBZ5MFsgu3ZW",
+  nativeCollateralPda: "8HY3hxmnrWwqEmcdwkSnfN9wEQFUkyiwZvU1vMbnXgbC",
+  dispatchAuthorityPda: "ATDttjggAZKyS19kcV6Rn56oMi49gDprZGckRou9vkkY",
+  mailboxProgramAddress: "E588QtVUvresuXq2KoNEwAmoifCzYGpRBdHByN9KQMbi",
+  mailboxOutboxPda: "BvZpTuYLAR77mPhH4GtvwEWUTs53GQqkgBNuXpCePVNk",
+  igpProgramAddress: "BhNcatUDC2D5JTyeaqrdSukiVFsEHK7e3hVmKMztwefv",
+  igpProgramDataPda: "8Cv4PHJ6Cf3xY7dse7wYeZKtuQv9SAN6ujt5w22a2uho",
+  igpAccount: "JAvHW21tYXE9dtdG83DReqU2b4LUexFuCbtJT5tF8X6M",
+  igpOverheadAccount: "AkeHBbE5JkwVppujCQQ6WuxsVsJtruBAjUo6fDCFp6fF",
+  splNoopProgramAddress: "noopb9bkMVfRPU8AsbpTUg8AQkHtKwMYZiFUjNRtMmV",
+  destinationDomain: 1634493807,
+  destinationGasAmount: "464000",
+  registryCommit: "418056e21734d26a7d14692e0ec5e902cc9e86bf",
+  solanaReviewedAt: "2026-08-31",
+  solanaConfigSource: ALEO_SOL_HYPERLANE_CONFIG_SOURCE
+};
+function route(id, protocol, environment, sourceAssetId, destinationAssetId, availability, deploymentId, metadata2) {
+  return {
+    id,
+    protocol,
+    environment,
+    sourceAssetId,
+    destinationAssetId,
+    availability,
+    deploymentId,
+    source: protocol === "xreserve" ? XRESERVE_SOURCE : HYPERLANE_SOURCE,
+    ...metadata2 == null ? {} : { metadata: metadata2 }
+  };
+}
+function pair(protocol, environment, left, right, availability, deploymentId, metadata2, reverseAvailability = availability) {
+  return [
+    route(`${protocol}:${left}->${right}`, protocol, environment, left, right, availability, deploymentId, metadata2),
+    route(`${protocol}:${right}->${left}`, protocol, environment, right, left, reverseAvailability, deploymentId, metadata2)
+  ];
+}
+var routes = [
+  ...pair("xreserve", "mainnet", "ethereum/usdc", "aleo/usdcx", "active", "xreserve-usdcx-aleo", {
+    xReserveContract: "0x8888888199b2Df864bf678259607d6D5EBb4e3Ce",
+    sourceChainId: 1,
+    sourceDomain: 0,
+    ethereumDestinationDomain: 0,
+    arcDestinationDomain: 26,
+    remoteDomain: 10002,
+    remoteToken: "usdcx_stablecoin.aleo",
+    remoteTokenBytes32: "0x11ea7dab1d29d5f61500582c63e98c42e1165f9ba050ea9d0c6af9f871987711",
+    minimumAmountAtomic: "2000000",
+    withdrawalFeeAtomic: "2000000",
+    maxFeeAtomic: "100000",
+    bridgeProgram: "usdcx_bridge_v2.aleo",
+    wrapperProgram: "shielded_usdcx_wrapper.aleo",
+    attestationBaseUrl: "https://xreserve-api.circle.com/v1/attestations"
+  }, "active"),
+  ...pair("xreserve", "testnet", "sepolia/usdc", "aleo-testnet/usdcx", "active", "xreserve-usdcx-aleo-testnet", {
+    xReserveContract: "0x008888878f94C0d87defdf0B07f46B93C1934442",
+    sourceChainId: 11155111,
+    sourceDomain: 0,
+    ethereumDestinationDomain: 0,
+    arcDestinationDomain: 26,
+    remoteDomain: 10002,
+    remoteToken: "test_usdcx_stablecoin.aleo",
+    remoteTokenBytes32: "0xb143ed52c774cd1d4a519d0e796f15916be5a9e1d45edcd9852dd23f68f53401",
+    minimumAmountAtomic: "2000000",
+    withdrawalFeeAtomic: "2000000",
+    maxFeeAtomic: "100000",
+    bridgeProgram: "test_usdcx_bridge_v2.aleo",
+    wrapperProgram: "shielded_usdcx_wrapper.aleo",
+    attestationBaseUrl: "https://xreserve-api-testnet.circle.com/v1/attestations"
+  }, "active"),
+  route("hyperlane:ethereum/eth->aleo/eth", "hyperlane", "mainnet", "ethereum/eth", "aleo/eth", "active", "ETH/aleo", { ...ETH_HYPERLANE_METADATA, ...ALEO_MAILBOX_METADATA }),
+  route("hyperlane:aleo/eth->ethereum/eth", "hyperlane", "mainnet", "aleo/eth", "ethereum/eth", "active", "ETH/aleo", { ...ETH_HYPERLANE_METADATA, ...aleoHyperlanePlaceholders("hyp_warp_token_eth_v2.aleo", 1), ...ALEO_ETH_APP_METADATA, ...ALEO_ETH_REMOTE_ROUTER, ...ALEO_WITHDRAWAL_ACTIVATION }),
+  route("hyperlane:ethereum/wbtc->aleo/wbtc", "hyperlane", "mainnet", "ethereum/wbtc", "aleo/wbtc", "active", "WBTC/aleo", { ...WBTC_HYPERLANE_METADATA, ...ALEO_MAILBOX_METADATA }),
+  route("hyperlane:aleo/wbtc->ethereum/wbtc", "hyperlane", "mainnet", "aleo/wbtc", "ethereum/wbtc", "active", "WBTC/aleo", { ...WBTC_HYPERLANE_METADATA, ...aleoHyperlanePlaceholders("hyp_warp_token_wbtc_v2.aleo", 1), ...ALEO_WBTC_APP_METADATA, ...ALEO_WBTC_REMOTE_ROUTER, ...ALEO_WITHDRAWAL_ACTIVATION }),
+  route("hyperlane:ethereum/usdt->aleo/usdt", "hyperlane", "mainnet", "ethereum/usdt", "aleo/usdt", "active", "USDT/aleo", { ...USDT_HYPERLANE_METADATA, ...ALEO_MAILBOX_METADATA }),
+  route("hyperlane:aleo/usdt->ethereum/usdt", "hyperlane", "mainnet", "aleo/usdt", "ethereum/usdt", "active", "USDT/aleo", { ...USDT_HYPERLANE_METADATA, ...aleoHyperlanePlaceholders("hyp_warp_token_usdt_v2.aleo", 1), ...ALEO_USDT_APP_METADATA, ...ALEO_USDT_ETHEREUM_REMOTE_ROUTER, ...ALEO_WITHDRAWAL_ACTIVATION }),
+  route("hyperlane:solana/sol->aleo/sol", "hyperlane", "mainnet", "solana/sol", "aleo/sol", "active", "SOL/aleo", { ...SOLANA_SOL_DEPOSIT_METADATA, ...ALEO_MAILBOX_METADATA }),
+  route("hyperlane:aleo/sol->solana/sol", "hyperlane", "mainnet", "aleo/sol", "solana/sol", "active", "SOL/aleo", { ...aleoHyperlanePlaceholders("hyp_warp_token_sol_v2.aleo", 1399811149), ...ALEO_SOL_APP_METADATA, ...ALEO_SOL_REMOTE_ROUTER, ...ALEO_WITHDRAWAL_ACTIVATION }),
+  ...pair("hyperlane", "mainnet", "aleo/aleo", "ethereum/aleo", "metadata-required", "ALEO/aleo", ALEO_MAILBOX_METADATA),
+  ...pair("hyperlane", "mainnet", "aleo/aleo", "solana/aleo", "metadata-required", "ALEO/aleo", ALEO_MAILBOX_METADATA),
+  ...pair("hyperlane", "mainnet", "aleo/aleo", "base/aleo", "metadata-required", "ALEO/aleo", ALEO_MAILBOX_METADATA),
+  ...pair("hyperlane", "mainnet", "aleo/aleo", "hyperevm/aleo", "metadata-required", "ALEO/aleo", ALEO_MAILBOX_METADATA),
+  route("hyperlane:ethereum/usad->aleo/usad", "hyperlane", "mainnet", "ethereum/usad", "aleo/usad", "metadata-required", "USAD/aleo", ALEO_MAILBOX_METADATA),
+  route("hyperlane:aleo/usad->ethereum/usad", "hyperlane", "mainnet", "aleo/usad", "ethereum/usad", "metadata-required", "USAD/aleo", aleoHyperlanePlaceholders("hyp_warp_token_usad_v2.aleo", 1))
+];
+var DEFAULT_BRIDGE_REGISTRY = Object.freeze({
+  version: "2026-08-31.solana-deposits.1",
+  chains: Object.freeze(chains),
+  assets: Object.freeze(assets),
+  routes: Object.freeze(routes),
+  sources: Object.freeze([XRESERVE_SOURCE, HYPERLANE_SOURCE]),
+  getAssets(params = {}) {
+    const chains2 = new Map(this.chains.map((chain) => [chain.id, chain]));
+    const chainId = params.chainId?.toLowerCase();
+    const symbol = params.symbol?.toLowerCase();
+    return this.assets.filter((asset) => {
+      const chain = chains2.get(asset.chainId);
+      return (params.environment == null || chain?.environment === params.environment) && (chainId == null || asset.chainId.toLowerCase() === chainId) && (symbol == null || asset.symbol.toLowerCase() === symbol);
+    });
+  },
+  getRoutes(params = {}) {
+    const assets2 = new Map(this.assets.map((asset) => [asset.id, asset]));
+    const sourceChainId = params.sourceChainId?.toLowerCase();
+    const destinationChainId = params.destinationChainId?.toLowerCase();
+    const symbol = params.symbol?.toLowerCase();
+    return this.routes.filter((route2) => {
+      const source = assets2.get(route2.sourceAssetId);
+      const destination = assets2.get(route2.destinationAssetId);
+      return (params.includeUnavailable === true || route2.availability !== "disabled") && (params.environment == null || route2.environment === params.environment) && (params.protocol == null || route2.protocol === params.protocol) && (sourceChainId == null || source.chainId.toLowerCase() === sourceChainId) && (destinationChainId == null || destination.chainId.toLowerCase() === destinationChainId) && (symbol == null || source.symbol.toLowerCase() === symbol || destination.symbol.toLowerCase() === symbol);
+    });
+  }
+});
+
+// src/registry/validate.ts
+var REQUIRED_SOLANA_HYPERLANE_METADATA_FIELDS = [
+  "warpProgramAddress",
+  "tokenPda",
+  "nativeCollateralPda",
+  "dispatchAuthorityPda",
+  "mailboxProgramAddress",
+  "mailboxOutboxPda",
+  "igpProgramAddress",
+  "igpProgramDataPda",
+  "igpAccount",
+  "splNoopProgramAddress",
+  "destinationDomain",
+  "destinationGasAmount",
+  "registryCommit",
+  "solanaReviewedAt",
+  "solanaConfigSource"
+];
+function hasCompleteSolanaHyperlaneMetadata(metadata2) {
+  if (!metadata2) return false;
+  return REQUIRED_SOLANA_HYPERLANE_METADATA_FIELDS.every((field) => {
+    const value = metadata2[field];
+    return field === "destinationDomain" ? typeof value === "number" : typeof value === "string" && value.length > 0;
+  });
+}
+function validateBridgeRegistry(registry) {
+  if (!registry.version.trim()) throw new BridgeError("Bridge registry version must not be empty");
+  const chainIds = /* @__PURE__ */ new Set();
+  for (const chain of registry.chains) {
+    if (chainIds.has(chain.id)) throw new BridgeError(`Duplicate bridge chain id: ${chain.id}`);
+    chainIds.add(chain.id);
+  }
+  const assetIds = /* @__PURE__ */ new Set();
+  const assetKeys = /* @__PURE__ */ new Set();
+  for (const asset of registry.assets) {
+    if (assetIds.has(asset.id)) throw new BridgeError(`Duplicate bridge asset id: ${asset.id}`);
+    if (!chainIds.has(asset.chainId)) {
+      throw new BridgeError(`Bridge asset ${asset.id} references unknown chain ${asset.chainId}`);
+    }
+    if (!asset.key.trim()) throw new BridgeError(`Bridge asset ${asset.id} has an empty key`);
+    const scopedKey = `${asset.chainId}/${asset.key}`;
+    if (assetKeys.has(scopedKey)) throw new BridgeError(`Duplicate bridge asset key: ${scopedKey}`);
+    if (!Number.isInteger(asset.decimals) || asset.decimals < 0) {
+      throw new BridgeError(`Bridge asset ${asset.id} has invalid decimals ${asset.decimals}`);
+    }
+    if (asset.addressValidationRegex) {
+      try {
+        new RegExp(asset.addressValidationRegex);
+      } catch (cause) {
+        throw new BridgeError(`Bridge asset ${asset.id} has an invalid address validation regex`, {
+          cause
+        });
+      }
+    }
+    if (asset.privacy) {
+      const chain = registry.chains.find((entry) => entry.id === asset.chainId);
+      if (chain?.family !== "aleo") {
+        throw new BridgeError(`Bridge asset ${asset.id} declares a privacy capability on a non-Aleo chain`);
+      }
+      if (!asset.privacy.program.trim()) {
+        throw new BridgeError(`Bridge asset ${asset.id} has an empty privacy program`);
+      }
+      if (asset.privacy.kind !== "arc20" && asset.privacy.kind !== "arc22") {
+        throw new BridgeError(`Bridge asset ${asset.id} has an unsupported privacy capability kind`);
+      }
+    }
+    assetIds.add(asset.id);
+    assetKeys.add(scopedKey);
+  }
+  const routeIds = /* @__PURE__ */ new Set();
+  for (const route2 of registry.routes) {
+    if (routeIds.has(route2.id)) throw new BridgeError(`Duplicate bridge route id: ${route2.id}`);
+    if (!assetIds.has(route2.sourceAssetId)) {
+      throw new BridgeError(`Bridge route ${route2.id} references unknown source asset ${route2.sourceAssetId}`);
+    }
+    if (!assetIds.has(route2.destinationAssetId)) {
+      throw new BridgeError(`Bridge route ${route2.id} references unknown destination asset ${route2.destinationAssetId}`);
+    }
+    const source = registry.assets.find((asset) => asset.id === route2.sourceAssetId);
+    const destination = registry.assets.find((asset) => asset.id === route2.destinationAssetId);
+    const sourceChain = registry.chains.find((chain) => chain.id === source.chainId);
+    const destinationChain = registry.chains.find((chain) => chain.id === destination.chainId);
+    if (sourceChain.environment !== route2.environment || destinationChain.environment !== route2.environment) {
+      throw new BridgeError(`Bridge route ${route2.id} crosses registry environments`);
+    }
+    if (route2.protocol === "hyperlane" && route2.availability === "active" && sourceChain.family === "solana" && !hasCompleteSolanaHyperlaneMetadata(route2.metadata)) {
+      throw new BridgeError(`Bridge route ${route2.id} is active but missing required Solana Hyperlane metadata`);
+    }
+    routeIds.add(route2.id);
+  }
+  return registry;
+}
+
+// src/clients/createBridgeClient.ts
+function createBridgeClient(config = {}) {
+  const environment = config.environment ?? "mainnet";
+  const registry = validateBridgeRegistry(config.registry ?? DEFAULT_BRIDGE_REGISTRY);
+  const fetch = config.fetch ?? globalThis.fetch;
+  const clients = config.clients ?? {};
+  return {
+    key: config.key ?? "bridge",
+    name: config.name ?? "Bridge Client",
+    environment,
+    registry,
+    ...bridgeActions({ registry, clients, fetch })
+  };
+}
+
+// src/connections/evm.ts
+import {
+  createPublicClient,
+  createWalletClient,
+  custom,
+  defineChain,
+  getAddress as getAddress6,
+  http
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+function evmHttp(url, options = {}) {
+  return { type: "http", url, fetch: options.fetch };
+}
+function evmCustom(request) {
+  return { type: "custom", request };
+}
+function evmProvider(provider, options = {}) {
+  return { type: "provider", provider, account: options.account };
+}
+function evmPrivateKey(privateKey) {
+  return { type: "local", account: privateKeyToAccount(privateKey) };
+}
+function evmLocalAccount(account2) {
+  return { type: "local", account: account2 };
+}
+function createEvmClient(config) {
+  if (config.transport && config.publicClient) {
+    throw new BridgeError("EVM client accepts either transport or publicClient, not both");
+  }
+  if (config.account && config.walletClient) {
+    throw new BridgeError("EVM client accepts either account or walletClient, not both");
+  }
+  if (!config.transport && !config.publicClient && !config.account && !config.walletClient) {
+    throw new BridgeError("EVM client requires a public or wallet capability");
+  }
+  if (config.account?.type === "local" && !config.transport && !config.publicClient) {
+    throw new BridgeError("Local EVM accounts require an EVM transport or public client");
+  }
+  return materializeEvmClient(config, globalThis.fetch);
+}
+function transportFor(transport, defaultFetch) {
+  if (transport.type === "custom") return custom({ request: transport.request });
+  return http(transport.url, { fetchFn: transport.fetch ?? defaultFetch });
+}
+function normalizePublicClient(client) {
+  return {
+    getChainId: () => client.getChainId(),
+    getBalance: (address) => client.getBalance({ address }),
+    call: async (params) => (await client.call(params)).data ?? "0x",
+    getTransactionReceipt: async (hash) => {
+      try {
+        return await client.getTransactionReceipt({ hash });
+      } catch (error) {
+        if (error instanceof Error && error.name === "TransactionReceiptNotFoundError") return null;
+        throw error;
+      }
+    },
+    getLogs: async (params) => client.getLogs(params),
+    getTransaction: async (hash) => {
+      try {
+        return await client.getTransaction({ hash });
+      } catch (error) {
+        if (error instanceof Error && error.name === "TransactionNotFoundError") return null;
+        throw error;
+      }
+    }
+  };
+}
+function normalizeWalletClient(client) {
+  const resolveAddress = async () => {
+    if (client.account) return client.account.address;
+    const [address] = await client.getAddresses();
+    if (!address) throw new BridgeError("EVM wallet has no connected account");
+    return address;
+  };
+  return {
+    getAddress: resolveAddress,
+    sendTransaction: async ({ chainId, from, ...transaction }) => {
+      const currentChainId = await client.getChainId();
+      if (currentChainId !== chainId) {
+        throw new BridgeError(`EVM wallet is connected to chain ${currentChainId}; expected ${chainId}`);
+      }
+      const account2 = await resolveAddress();
+      if (from && getAddress6(from) !== getAddress6(account2)) {
+        throw new BridgeError(`EVM transaction sender ${from} does not match connected account ${account2}`);
+      }
+      return client.sendTransaction({
+        ...transaction,
+        account: client.account ?? account2,
+        // Viem treats an omitted chain as a request to validate against a
+        // configured chain and throws when an account-only client has none.
+        // The adapter already compared getChainId() with the requested id.
+        chain: client.chain ?? null
+      });
+    }
+  };
+}
+function materializeEvmClient(config, defaultFetch) {
+  const transport = config.transport ? transportFor(config.transport, defaultFetch) : void 0;
+  const viemPublic = config.publicClient ?? (transport ? createPublicClient({ transport }) : void 0);
+  let publicClient = viemPublic ? normalizePublicClient(viemPublic) : void 0;
+  let walletClient = config.walletClient ? normalizeWalletClient(config.walletClient) : void 0;
+  if (!publicClient && config.walletClient) {
+    const request = config.walletClient.request;
+    publicClient = normalizePublicClient(createPublicClient({ transport: custom({ request }) }));
+  }
+  if (config.account?.type === "provider") {
+    const provider = config.account.provider;
+    if (!publicClient) publicClient = normalizePublicClient(createPublicClient({ transport: custom(provider) }));
+    const account2 = config.account.account;
+    walletClient = {
+      getAddress: async () => {
+        if (account2) return account2;
+        const addresses = await provider.request({ method: "eth_accounts" });
+        const address = Array.isArray(addresses) ? addresses[0] : void 0;
+        if (typeof address !== "string") throw new BridgeError("EVM wallet has no connected account");
+        return address;
+      },
+      sendTransaction: async ({ chainId, from, to, data, value }) => {
+        const current = await provider.request({ method: "eth_chainId" });
+        if (typeof current !== "string" || Number.parseInt(current, 16) !== chainId) {
+          throw new BridgeError(`EVM wallet is connected to chain ${String(current)}; expected ${chainId}`);
+        }
+        const sender = from ?? await walletClient.getAddress();
+        const hash = await provider.request({
+          method: "eth_sendTransaction",
+          params: [{ from: sender, to, data, ...value === void 0 ? {} : { value: `0x${value.toString(16)}` } }]
+        });
+        if (typeof hash !== "string") throw new BridgeError("EVM wallet returned an invalid transaction hash");
+        return hash;
+      }
+    };
+  } else if (config.account?.type === "local") {
+    if (!viemPublic) throw new BridgeError("Local EVM accounts require an EVM transport or public client");
+    const localAccount = config.account.account;
+    walletClient = {
+      getAddress: async () => localAccount.address,
+      sendTransaction: async ({ chainId, from, ...transaction }) => {
+        const currentChainId = await viemPublic.getChainId();
+        if (currentChainId !== chainId) {
+          throw new BridgeError(`EVM transport is connected to chain ${currentChainId}; expected ${chainId}`);
+        }
+        if (from && getAddress6(from) !== getAddress6(localAccount.address)) {
+          throw new BridgeError(`EVM transaction sender ${from} does not match local account ${localAccount.address}`);
+        }
+        const chain = viemPublic.chain ?? defineChain({
+          id: chainId,
+          name: `EVM chain ${chainId}`,
+          nativeCurrency: { name: "Native token", symbol: "ETH", decimals: 18 },
+          rpcUrls: { default: { http: [] } }
+        });
+        const localWallet = createWalletClient({
+          account: localAccount,
+          chain,
+          transport: custom({ request: viemPublic.request }, { retryCount: 0 })
+        });
+        return localWallet.sendTransaction({ ...transaction, account: localAccount, chain });
+      }
+    };
+  }
+  if (!publicClient) throw new BridgeError("EVM client could not materialize a public client");
+  return { family: "evm", publicClient, walletClient };
+}
+
+// src/connections/aleo.ts
+function aleoWallet(client) {
+  return client;
+}
+function createAleoClient(config) {
+  if (!config.publicClient) throw new BridgeError("Aleo client requires a public client");
+  return { family: "aleo", publicClient: config.publicClient, walletClient: config.account };
+}
+
+// src/protocols/index.ts
+function splitRegistry(params) {
+  const { registry = DEFAULT_BRIDGE_REGISTRY, ...rest } = params;
+  return [registry, rest];
+}
+var hyperlane = {
+  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 })
+     */
+    quote(client, params) {
+      const [registry, actionParams] = splitRegistry(params);
+      return quote(registry, client, actionParams);
+    },
+    /**
+     * 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 })
+     */
+    execute(client, params) {
+      const [registry, actionParams] = splitRegistry(params);
+      return execute(registry, client, actionParams);
+    }
+  },
+  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 })
+     */
+    quote(client, params) {
+      const [registry, actionParams] = splitRegistry(params);
+      return quote2(registry, client, actionParams);
+    },
+    /**
+     * 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 })
+     */
+    execute(client, params) {
+      const [registry, actionParams] = splitRegistry(params);
+      return execute2(registry, client, actionParams);
+    }
+  },
+  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 })
+     */
+    quote(client, params) {
+      const [registry, actionParams] = splitRegistry(params);
+      return quote3(registry, client, actionParams);
+    },
+    /**
+     * 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 })
+     */
+    execute(client, params) {
+      const [registry, actionParams] = splitRegistry(params);
+      return execute3(registry, client, actionParams);
+    }
+  }
+};
+var xreserve = {
+  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 })
+     */
+    quote(client, params) {
+      const [registry, actionParams] = splitRegistry(params);
+      return quote4(registry, client, actionParams);
+    },
+    /**
+     * 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 })
+     */
+    execute(client, params) {
+      const [registry, actionParams] = splitRegistry(params);
+      return execute5(registry, client, actionParams);
+    },
+    /**
+     * 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 })
+     */
+    getAttestation(client, params) {
+      const [registry, actionParams] = splitRegistry(params);
+      return getAttestation(registry, client, actionParams);
+    },
+    /**
+     * 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 })
+     */
+    complete(client, params) {
+      const [registry, actionParams] = splitRegistry(params);
+      return complete(registry, client, actionParams);
+    }
+  },
+  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' })
+     */
+    execute(client, params) {
+      const [registry, actionParams] = splitRegistry(params);
+      return execute4(registry, client, actionParams);
+    }
+  }
+};
+
+// src/builders/buildXReserveBurnCall.ts
+function buildXReserveBurnCall(registry, params) {
+  return buildBurnCall(registry, params);
+}
+
+// src/builders/buildAleoHyperlaneTransferRemoteCall.ts
+function buildAleoHyperlaneTransferRemoteCall(registry, params) {
+  return buildTransferRemoteCall(registry, params);
+}
+export {
+  BridgeError,
+  DEFAULT_BRIDGE_REGISTRY,
+  DEFAULT_SOLANA_RPC_URL,
+  aleoAddressToBytes32,
+  aleoProgramAddress,
+  aleoWallet,
+  bridgeActions,
+  buildAleoHyperlaneTransferRemoteCall,
+  buildXReserveBurnCall,
+  buildXReserveDepositPayload,
+  buildXReserveHookData,
+  bytes32ToAleoAddress,
+  calculateXReserveDepositNonce,
+  calculateXReserveMessageHash,
+  complete2 as complete,
+  createAleoClient,
+  createBridgeCheckpoint,
+  createBridgeClient,
+  createEvmClient,
+  createSolanaClient,
+  evmAddressToAleoHyperlaneRecipient,
+  evmAddressToXReserveBytes32,
+  evmCustom,
+  evmHttp,
+  evmLocalAccount,
+  evmPrivateKey,
+  evmProvider,
+  execute6 as execute,
+  formatDecimalAmount,
+  getStatus,
+  hyperlane,
+  parseDecimalAmount,
+  quote5 as quote,
+  readHyperlaneDelivery,
+  readXReserveDelivery,
+  recover,
+  resume,
+  shield,
+  solanaAddressToAleoHyperlaneRecipient,
+  solanaCustom,
+  solanaHttp,
+  solanaKeyPair,
+  solanaWallet,
+  unshield,
+  validateBridgeRegistry,
+  wait2 as wait,
+  xReserveDepositNonceFromPayload,
+  xReserveHexToAleoBytes,
+  xreserve
+};
+//# sourceMappingURL=index.js.map