@provablehq/aleo-bridge-sdk 0.8.0-rc.0

package/dist/index.js

@@ -0,0 +1,1627 @@
+// src/clients/createBridgeClient.ts
+import { createClient, createTransport } from "@provablehq/veil-core";
+
+// src/actions/protocolDiscovery.ts
+function getProtocolAssets(registry, params = {}) {
+  const chains2 = new Map(registry.chains.map((chain) => [chain.id, chain]));
+  const chainId = params.chainId?.toLowerCase();
+  const symbol = params.symbol?.toLowerCase();
+  return registry.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);
+  });
+}
+function getProtocolRoutes(registry, params = {}) {
+  const assets2 = new Map(registry.assets.map((asset) => [asset.id, asset]));
+  const sourceChainId = params.sourceChainId?.toLowerCase();
+  const destinationChainId = params.destinationChainId?.toLowerCase();
+  const symbol = params.symbol?.toLowerCase();
+  return registry.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/errors/bridgeErrors.ts
+var BridgeError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "BridgeError";
+  }
+};
+
+// 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"));
+}
+
+// src/actions/prepareTransfer.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 shape: ${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 prepareTransfer(registry, params) {
+  const route2 = registry.routes.find((entry) => entry.id === params.routeId);
+  if (!route2) throw new BridgeError(`Unknown bridge route: ${params.routeId}`);
+  if (route2.availability === "disabled") throw new BridgeError(`Bridge route is disabled: ${params.routeId}`);
+  const sourceAsset = registry.assets.find((asset) => asset.id === route2.sourceAssetId);
+  const destinationAsset = registry.assets.find((asset) => asset.id === route2.destinationAssetId);
+  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.privateMintSecretNonce != null && mintMode !== "private") {
+    throw new BridgeError("privateMintSecretNonce is only valid with private mint mode");
+  }
+  const privateMintSecretNonce = params.privateMintSecretNonce ?? "0scalar";
+  if (mintMode === "private" && !/^(0|[1-9][0-9]*)scalar$/.test(privateMintSecretNonce)) {
+    throw new BridgeError("privateMintSecretNonce must be a non-negative decimal Aleo scalar literal such as 0scalar");
+  }
+  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,
+    ...mintMode === "private" ? { privateMintSecretNonce } : {},
+    privateRecipient: mintMode === "private",
+    quote: {
+      routeId: route2.id,
+      protocol: route2.protocol,
+      amountIn: params.amount,
+      fees,
+      status: "not-queried"
+    },
+    fees,
+    steps
+  };
+}
+
+// src/actions/evmHyperlane.ts
+import {
+  decodeEventLog,
+  decodeFunctionResult,
+  encodeFunctionData,
+  getAddress,
+  isAddress,
+  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)"
+]);
+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" || !isAddress(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" || !isAddress(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" || !isAddress(mailboxAddress)) {
+    throw new BridgeError(`Hyperlane route has an invalid mailboxAddress: ${plan.route.id}`);
+  }
+  if (typeof interchainGasPaymaster !== "string" || !isAddress(interchainGasPaymaster)) {
+    throw new BridgeError(`Hyperlane route has an invalid interchainGasPaymaster: ${plan.route.id}`);
+  }
+  if (typeof interchainSecurityModule !== "string" || !isAddress(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: getAddress(routerAddress),
+    sourceChainId,
+    destinationDomain,
+    routerType,
+    ...typeof tokenAddress === "string" && isAddress(tokenAddress) ? { tokenAddress: getAddress(tokenAddress) } : {},
+    destinationRouter,
+    mailboxAddress: getAddress(mailboxAddress),
+    interchainGasPaymaster: getAddress(interchainGasPaymaster),
+    interchainSecurityModule: getAddress(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(executor2, to, data) {
+  const result = await executor2.request({
+    method: "eth_call",
+    params: [{ to, data }, "latest"]
+  });
+  if (typeof result !== "string" || !result.startsWith("0x")) {
+    throw new BridgeError("EVM executor returned an invalid eth_call result");
+  }
+  return result;
+}
+async function assertChain(executor2, expectedChainId) {
+  const result = await executor2.request({ method: "eth_chainId" });
+  if (typeof result !== "string" || !/^0x[0-9a-f]+$/i.test(result)) {
+    throw new BridgeError("EVM executor returned an invalid eth_chainId result");
+  }
+  const actual = Number(BigInt(result));
+  if (actual !== expectedChainId) {
+    throw new BridgeError(`EVM wallet is connected to chain ${actual}; expected ${expectedChainId}`);
+  }
+}
+async function resolveAccount(executor2, plan) {
+  let account2 = executor2.account;
+  if (!account2) {
+    const result = await executor2.request({ method: "eth_accounts" });
+    if (!Array.isArray(result) || typeof result[0] !== "string" || !isAddress(result[0])) {
+      throw new BridgeError("EVM executor has no connected account");
+    }
+    account2 = getAddress(result[0]);
+  }
+  if (!isAddress(account2)) throw new BridgeError("EVM executor account is invalid");
+  const normalized = getAddress(account2);
+  if (plan.sender && (!isAddress(plan.sender) || getAddress(plan.sender) !== normalized)) {
+    throw new BridgeError(`Prepared sender ${plan.sender} does not match connected account ${normalized}`);
+  }
+  return normalized;
+}
+async function sendTransaction(executor2, transaction) {
+  const result = await executor2.request({ method: "eth_sendTransaction", params: [transaction] });
+  if (typeof result !== "string" || !isHash(result)) {
+    throw new BridgeError("EVM executor returned an invalid transaction hash");
+  }
+  return result;
+}
+async function waitForReceipt(executor2, hash, timeoutMs, pollingIntervalMs) {
+  const deadline = Date.now() + timeoutMs;
+  do {
+    const result = await executor2.request({ method: "eth_getTransactionReceipt", params: [hash] });
+    if (result != null && typeof result === "object") return result;
+    if (Date.now() >= deadline) return void 0;
+    await new Promise((resolve) => setTimeout(resolve, pollingIntervalMs));
+  } while (true);
+}
+function assertSuccessfulReceipt(receipt, hash) {
+  if (receipt.status === "0x0") 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 quoteEvmHyperlaneTransfer(registry, executor2, params) {
+  validateRecipient(params.recipientBytes32);
+  const metadata2 = routeMetadata(registry, params.plan);
+  await assertChain(executor2, 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(executor2, metadata2.routerAddress, data);
+  const quotes = decodeFunctionResult({
+    abi: WARP_ROUTE_ABI,
+    functionName: "quoteTransferRemote",
+    data: encoded
+  });
+  const nativeValueAtomic = quotes.filter((quote) => getAddress(quote.token) === zeroAddress).reduce((sum, quote) => sum + quote.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((quote) => getAddress(quote.token) === tokenAddress).reduce((sum, quote) => sum + quote.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, quote, approvalTxIds, sourceTxId, messageId) {
+  return {
+    id,
+    protocol: "hyperlane",
+    status,
+    ...sourceTxId ? { sourceTxId } : {},
+    ...messageId ? { messageId } : {},
+    protocolState: {
+      routeId: plan.route.id,
+      approvalTxIds,
+      recipientBytes32: quote.recipientBytes32,
+      destinationDomain: quote.destinationDomain,
+      nativeValueAtomic: quote.nativeValueAtomic.toString(),
+      amountAtomic: quote.amountAtomic.toString()
+    }
+  };
+}
+async function executeEvmHyperlaneTransfer(registry, executor2, 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);
+  const quote = await quoteEvmHyperlaneTransfer(registry, executor2, params);
+  const account2 = await resolveAccount(executor2, params.plan);
+  const approvalTxIds = [];
+  if (metadata2.routerType === "collateral") {
+    const allowanceData = encodeFunctionData({
+      abi: ERC20_ABI,
+      functionName: "allowance",
+      args: [account2, metadata2.routerAddress]
+    });
+    const allowanceResult = await rpcCall(executor2, metadata2.tokenAddress, allowanceData);
+    const allowance2 = decodeFunctionResult({
+      abi: ERC20_ABI,
+      functionName: "allowance",
+      data: allowanceResult
+    });
+    const required = quote.tokenAmountAtomic;
+    const approveAndConfirm = async (amount) => {
+      const data = encodeFunctionData({
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [metadata2.routerAddress, amount]
+      });
+      const hash = await sendTransaction(executor2, { from: account2, to: metadata2.tokenAddress, data });
+      approvalTxIds.push(hash);
+      const receipt = await waitForReceipt(executor2, 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), quote, approvalTxIds)
+          };
+        }
+      }
+      if (!await approveAndConfirm(required)) {
+        return {
+          approvalTxIds,
+          receipt: executionReceipt(params.plan, "SOURCE_APPROVAL_PENDING", approvalTxIds.at(-1), quote, approvalTxIds)
+        };
+      }
+    }
+  }
+  const transferData = encodeFunctionData({
+    abi: WARP_ROUTE_ABI,
+    functionName: "transferRemote",
+    args: [quote.destinationDomain, quote.recipientBytes32, quote.amountAtomic]
+  });
+  const sourceTxId = await sendTransaction(executor2, {
+    from: account2,
+    to: quote.routerAddress,
+    data: transferData,
+    value: `0x${quote.nativeValueAtomic.toString(16)}`
+  });
+  const sourceReceipt = await waitForReceipt(
+    executor2,
+    sourceTxId,
+    confirmationTimeoutMs,
+    pollingIntervalMs
+  );
+  if (!sourceReceipt) {
+    return {
+      approvalTxIds,
+      receipt: executionReceipt(params.plan, "SOURCE_CONFIRMING", sourceTxId, quote, approvalTxIds, sourceTxId)
+    };
+  }
+  assertSuccessfulReceipt(sourceReceipt, sourceTxId);
+  const messageId = messageIdFromReceipt(sourceReceipt);
+  return {
+    approvalTxIds,
+    receipt: executionReceipt(
+      params.plan,
+      "DELIVERY_PENDING",
+      messageId ?? sourceTxId,
+      quote,
+      approvalTxIds,
+      sourceTxId,
+      messageId
+    )
+  };
+}
+
+// src/actions/evmXReserve.ts
+import {
+  decodeEventLog as decodeEventLog2,
+  decodeFunctionResult as decodeFunctionResult2,
+  encodeFunctionData as encodeFunctionData2,
+  getAddress as getAddress3,
+  isAddress as isAddress3,
+  isHash as isHash2,
+  isHex as isHex2,
+  parseAbi as parseAbi2
+} from "viem";
+
+// src/utils/xreserve.ts
+import {
+  encodeAbiParameters,
+  getAddress as getAddress2,
+  hexToBytes,
+  isAddress as isAddress2,
+  isHex,
+  keccak256,
+  padHex,
+  toHex
+} from "viem";
+var HOOK_DATA_BYTES = 65;
+var BECH32_ALPHABET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+function bech32Polymod(values) {
+  const generators = [996825010, 642813549, 513874426, 1027748829, 705979059];
+  let checksum = 1;
+  for (const value of values) {
+    const top = checksum >>> 25;
+    checksum = (checksum & 33554431) << 5 ^ value;
+    for (let index = 0; index < 5; index++) if (top >>> index & 1) checksum ^= generators[index];
+  }
+  return checksum >>> 0;
+}
+function decodeAleoBech32m(address) {
+  const separator = address.lastIndexOf("1");
+  const prefix = address.slice(0, separator);
+  const encoded = address.slice(separator + 1);
+  const words = [...encoded].map((character) => BECH32_ALPHABET.indexOf(character));
+  if (prefix !== "aleo" || separator < 1 || words.some((word) => word < 0)) throw new Error("invalid encoding");
+  const expanded = [...prefix].map((character) => character.charCodeAt(0) >>> 5).concat([0], [...prefix].map((character) => character.charCodeAt(0) & 31), words);
+  if (bech32Polymod(expanded) !== 734539939) throw new Error("invalid checksum");
+  const payload = words.slice(0, -6);
+  const bytes = [];
+  let accumulator = 0;
+  let bits = 0;
+  for (const word of payload) {
+    accumulator = accumulator << 5 | word;
+    bits += 5;
+    while (bits >= 8) {
+      bits -= 8;
+      bytes.push(accumulator >>> bits & 255);
+    }
+  }
+  if (bits >= 5 || (accumulator << 8 - bits & 255) !== 0) throw new Error("invalid padding");
+  return Uint8Array.from(bytes);
+}
+function aleoAddressToBytes32(address) {
+  try {
+    if (!address.startsWith("aleo1") || address.length !== 63) throw new Error("invalid prefix or length");
+    const bytes = decodeAleoBech32m(address);
+    if (bytes.length !== 32) throw new Error("invalid payload");
+    return toHex(bytes);
+  } catch (cause) {
+    throw new BridgeError(`Invalid Aleo recipient address: ${address}`, { cause });
+  }
+}
+async function loadAleoSdk(environment) {
+  const moduleName = "@provablehq/sdk/dynamic.js";
+  try {
+    const sdk = await import(moduleName);
+    return sdk.loadNetwork(environment);
+  } catch (cause) {
+    throw new BridgeError("Private xReserve mints require the optional @provablehq/sdk package", { cause });
+  }
+}
+async function aleoProgramAddress(programId, environment) {
+  const sdk = await loadAleoSdk(environment);
+  return sdk.Address.fromProgramId(programId).to_string();
+}
+async function buildXReserveHookData(mode, recipient, environment, secretNonce = "0scalar") {
+  const bytes = new Uint8Array(HOOK_DATA_BYTES);
+  bytes[0] = mode === "public" ? 0 : mode === "record" ? 1 : 2;
+  if (mode === "private") {
+    const sdk = await loadAleoSdk(environment);
+    const bits = sdk.Plaintext.fromString(recipient).toBitsLe();
+    let scalar;
+    try {
+      scalar = sdk.Scalar.fromString(secretNonce);
+    } catch (cause) {
+      throw new BridgeError(`Invalid private mint secret nonce: ${secretNonce}`, { cause });
+    }
+    const commitment = new sdk.BHP256().commit(bits, scalar).toBytesLe();
+    if (commitment.length !== 32) throw new BridgeError("Private mint commitment must contain 32 bytes");
+    bytes.set(commitment, 1);
+  }
+  return toHex(bytes);
+}
+function calculateXReserveDepositNonce(sourceDomain, transactionHash, logIndex) {
+  const domain = encodeAbiParameters([{ type: "uint32" }], [sourceDomain]);
+  const index = encodeAbiParameters([{ type: "uint256" }], [BigInt(logIndex)]);
+  return keccak256(`0x${domain.slice(2)}${transactionHash.slice(2)}${index.slice(2)}`);
+}
+function uintBytes(value, bytes) {
+  if (value < 0n || value >= 1n << BigInt(bytes * 8)) throw new BridgeError(`Unsigned value does not fit in ${bytes} bytes`);
+  return hexToBytes(toHex(value, { size: bytes }));
+}
+function buildXReserveDepositPayload(params) {
+  if (!isHex(params.remoteToken, { strict: true }) || hexToBytes(params.remoteToken).length !== 32) throw new BridgeError("remoteToken must contain 32 bytes");
+  if (!isHex(params.remoteRecipient, { strict: true }) || hexToBytes(params.remoteRecipient).length !== 32) throw new BridgeError("remoteRecipient must contain 32 bytes");
+  if (!isHex(params.hookData, { strict: true }) || hexToBytes(params.hookData).length !== HOOK_DATA_BYTES) throw new BridgeError("hookData must contain 65 bytes");
+  if (!isAddress2(params.localToken) || !isAddress2(params.depositor)) throw new BridgeError("Payload EVM address is invalid");
+  const payload = new Uint8Array(305);
+  payload.set([90, 46, 10, 205, 0, 0, 0, 1], 0);
+  payload.set(uintBytes(params.amount, 32), 8);
+  payload.set(uintBytes(BigInt(params.remoteDomain), 4), 40);
+  payload.set(hexToBytes(params.remoteToken), 44);
+  payload.set(hexToBytes(params.remoteRecipient), 76);
+  payload.set(hexToBytes(padHex(getAddress2(params.localToken), { size: 32 })), 108);
+  payload.set(hexToBytes(padHex(getAddress2(params.depositor), { size: 32 })), 140);
+  payload.set(uintBytes(params.maxFee, 32), 172);
+  payload.set(hexToBytes(params.nonce), 204);
+  payload.set(uintBytes(BigInt(HOOK_DATA_BYTES), 4), 236);
+  payload.set(hexToBytes(params.hookData), 240);
+  return toHex(payload);
+}
+function calculateXReserveMessageHash(payload) {
+  return keccak256(payload);
+}
+function xReserveHexToAleoBytes(value, expectedBytes) {
+  if (!isHex(value, { strict: true })) throw new BridgeError("Aleo byte-array input must be prefixed hexadecimal");
+  const bytes = hexToBytes(value);
+  if (bytes.length !== expectedBytes) throw new BridgeError(`Aleo byte-array input must contain ${expectedBytes} bytes`);
+  return `[${[...bytes].map((byte) => `${byte}u8`).join(",")}]`;
+}
+function evmAddressToXReserveBytes32(address) {
+  if (!isAddress2(address)) throw new BridgeError(`Invalid Ethereum recipient address: ${address}`);
+  return padHex(getAddress2(address), { size: 32 });
+}
+
+// src/actions/evmXReserve.ts
+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 rpc(executor2, method, params) {
+  return executor2.request({ method, ...params ? { params } : {} });
+}
+async function assertChain2(executor2, expected) {
+  const chain = await rpc(executor2, "eth_chainId");
+  if (typeof chain !== "string" || !/^0x[0-9a-f]+$/i.test(chain)) throw new BridgeError("EVM executor returned an invalid chain id");
+  if (Number(BigInt(chain)) !== expected) throw new BridgeError(`EVM wallet is connected to chain ${Number(BigInt(chain))}; expected ${expected}`);
+}
+async function account(executor2, plan) {
+  const value = executor2.account ?? (await rpc(executor2, "eth_accounts"))?.[0];
+  if (typeof value !== "string" || !isAddress3(value)) throw new BridgeError("EVM executor 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(executor2, to, data, functionName) {
+  const result = await rpc(executor2, "eth_call", [{ to, data }, "latest"]);
+  if (typeof result !== "string" || !isHex2(result)) throw new BridgeError("EVM executor returned an invalid contract result");
+  return decodeFunctionResult2({ abi: ERC20_ABI2, functionName, data: result });
+}
+async function send(executor2, transaction) {
+  const hash = await rpc(executor2, "eth_sendTransaction", [transaction]);
+  if (typeof hash !== "string" || !isHash2(hash)) throw new BridgeError("EVM executor returned an invalid transaction hash");
+  return hash;
+}
+async function wait(executor2, hash, timeout, interval) {
+  const deadline = Date.now() + timeout;
+  do {
+    const result = await rpc(executor2, "eth_getTransactionReceipt", [hash]);
+    if (result && typeof result === "object") return result;
+    if (Date.now() >= deadline) return void 0;
+    await new Promise((resolve) => setTimeout(resolve, interval));
+  } while (true);
+}
+function successful(receipt, hash) {
+  if (receipt.status === "0x0") throw new BridgeError(`EVM transaction reverted: ${hash}`);
+}
+async function quoteEvmXReserveTransfer(registry, executor2, params) {
+  const route2 = metadata(registry, params.plan);
+  await assertChain2(executor2, route2.sourceChainId);
+  const owner = await account(executor2, 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.plan.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(executor2, getAddress3(token), balanceData, "balanceOf"),
+    callUint(executor2, 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, quote, sourceTxId) {
+  return { id, protocol: "xreserve", status, ...sourceTxId ? { sourceTxId } : {}, protocolState: { routeId: plan.route.id, approvalTxIds, mintMode: plan.mintMode, intendedRecipient: plan.recipient, remoteRecipientBytes32: quote.remoteRecipientBytes32, hookData: quote.hookData, amountAtomic: quote.amountAtomic.toString(), maxFeeAtomic: quote.maxFeeAtomic.toString() } };
+}
+async function executeEvmXReserveTransfer(registry, executor2, 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 quote = await quoteEvmXReserveTransfer(registry, executor2, params);
+  const owner = await account(executor2, params.plan);
+  const approvalTxIds = [];
+  if (quote.approvalRequired) {
+    const data2 = encodeFunctionData2({ abi: ERC20_ABI2, functionName: "approve", args: [route2.xReserveContract, quote.amountAtomic] });
+    const hash = await send(executor2, { from: owner, to: quote.tokenAddress, data: data2 });
+    approvalTxIds.push(hash);
+    const receipt2 = await wait(executor2, hash, confirmationTimeoutMs, pollingIntervalMs);
+    if (!receipt2) return { approvalTxIds, receipt: pendingReceipt(params.plan, "SOURCE_APPROVAL_PENDING", hash, approvalTxIds, quote) };
+    successful(receipt2, hash);
+  }
+  const data = encodeFunctionData2({ abi: XRESERVE_ABI, functionName: "depositToRemote", args: [quote.amountAtomic, route2.remoteDomain, quote.remoteRecipientBytes32, quote.tokenAddress, route2.maxFeeAtomic, quote.hookData] });
+  const sourceTxId = await send(executor2, { from: owner, to: route2.xReserveContract, data });
+  const receipt = await wait(executor2, sourceTxId, confirmationTimeoutMs, pollingIntervalMs);
+  if (!receipt) return { approvalTxIds, receipt: pendingReceipt(params.plan, "SOURCE_CONFIRMING", sourceTxId, approvalTxIds, quote, sourceTxId) };
+  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) !== quote.tokenAddress || getAddress3(args.localDepositor) !== owner || args.value !== quote.amountAtomic || args.remoteDomain !== route2.remoteDomain || args.remoteRecipient.toLowerCase() !== quote.remoteRecipientBytes32.toLowerCase() || args.remoteToken.toLowerCase() !== route2.remoteTokenBytes32.toLowerCase() || args.maxFee !== route2.maxFeeAtomic || args.hookData.toLowerCase() !== quote.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 { approvalTxIds, receipt: { id: messageHash, protocol: "xreserve", status: "ATTESTATION_PENDING", sourceTxId, protocolState: { ...pendingReceipt(params.plan, "ATTESTATION_PENDING", messageHash, approvalTxIds, quote, sourceTxId).protocolState, sourceDomain: route2.sourceDomain, remoteDomain: route2.remoteDomain, depositLogIndex: logIndex, nonce, payload, messageHash, bridgeProgram: route2.bridgeProgram, wrapperProgram: route2.wrapperProgram } } };
+}
+async function getXReserveAttestation(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" || !isHex2(value.payload) || typeof value.attestation !== "string" || !isHex2(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 };
+}
+
+// src/actions/xreservePrivateMint.ts
+import { isHash as isHash3, isHex as isHex3 } from "viem";
+async function executeXReservePrivateMint(registry, executor2, 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" || !isHex3(depositPayload, { strict: true })) throw new BridgeError("Deposit receipt is missing the canonical xReserve payload");
+  if (typeof depositHash !== "string" || !isHash3(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 = plan.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 result = await executor2.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
+  });
+  const transactionId = typeof result === "string" ? result : result.transactionId;
+  if (!transactionId) throw new BridgeError("Aleo wallet returned an empty private mint transaction id");
+  return {
+    transactionId,
+    receipt: {
+      ...deposit,
+      status: "DESTINATION_CONFIRMING",
+      destinationTxId: transactionId,
+      protocolState: {
+        ...deposit.protocolState,
+        attestation: attestation.attestation,
+        destinationProgram: wrapperProgram,
+        destinationFunction: "private_mint",
+        secretNonce
+      }
+    }
+  };
+}
+
+// src/actions/xreserveBurn.ts
+var ETHEREUM_DESTINATION_DOMAIN = 0;
+function validatedRoute(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;
+  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 (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 };
+}
+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 buildXReserveBurnCall(registry, params) {
+  const deployment = validatedRoute(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");
+  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 executeXReserveBurn(registry, executor2, params) {
+  const call = buildXReserveBurnCall(registry, params);
+  const result = await executor2.executeTransaction({
+    program: call.program,
+    function: call.function,
+    inputs: call.inputs,
+    privateFee: params.privateFee ?? false
+  });
+  const transactionId = typeof result === "string" ? result : result.transactionId;
+  if (!transactionId) throw new BridgeError("Aleo wallet returned an empty burn transaction id");
+  return {
+    transactionId,
+    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"
+      }
+    }
+  };
+}
+
+// src/utils/hyperlane.ts
+import bs58 from "bs58";
+import { getAddress as getAddress4, hexToBytes as hexToBytes2, isAddress as isAddress4, padHex as padHex2 } 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 (!isAddress4(address)) throw new BridgeError(`Invalid Ethereum Hyperlane recipient: ${address}`);
+  const recipient = hexToBytes2(padHex2(getAddress4(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/actions/aleoHyperlane.ts
+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 validatedRoute2(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) {
+  return `{ spender: ${metadataString(route2, `aleoAllowanceSpender${index}`)}, amount: ${metadataString(route2, `aleoAllowanceAmount${index}`)}u64 }`;
+}
+function buildAleoHyperlaneTransferRemoteCall(registry, params) {
+  if (params.mode != null && params.mode !== "caller" && params.mode !== "signer") {
+    throw new BridgeError(`Unsupported Aleo Hyperlane transfer mode: ${String(params.mode)}`);
+  }
+  const { route: route2, program, destinationChain } = validatedRoute2(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)).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");
+  }
+  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 : []
+  };
+}
+async function executeAleoHyperlaneTransferRemote(registry, executor2, params) {
+  const call = buildAleoHyperlaneTransferRemoteCall(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}`);
+  }
+  const result = await executor2.executeTransaction({
+    program: call.program,
+    function: call.function,
+    inputs: call.inputs,
+    privateFee: params.privateFee ?? false
+  });
+  const transactionId = typeof result === "string" ? result : result.transactionId;
+  if (!transactionId) throw new BridgeError("Aleo wallet returned an empty Hyperlane transaction id");
+  return {
+    transactionId,
+    receipt: {
+      id: transactionId,
+      protocol: "hyperlane",
+      status: "SOURCE_CONFIRMING",
+      sourceTxId: transactionId,
+      protocolState: { routeId: call.routeId, sourceProgram: call.program, sourceFunction: call.function }
+    }
+  };
+}
+
+// src/clients/decorators/bridge.ts
+function bridgeActions(_client, config) {
+  const evmExecutor = () => {
+    if (!config.executors?.evm) {
+      throw new BridgeError("An EVM executor is required for Ethereum bridge actions");
+    }
+    return config.executors.evm;
+  };
+  const xReserveTransport = () => {
+    if (!config.xReserveHttpTransport) throw new BridgeError("An xReserve HTTP transport is required for attestation requests");
+    return config.xReserveHttpTransport;
+  };
+  const aleoExecutor = () => {
+    if (!config.executors?.aleo) throw new BridgeError("An Aleo executor is required for Aleo bridge transactions");
+    return config.executors.aleo;
+  };
+  return {
+    getAssets: (params = {}) => getProtocolAssets(config.registry, {
+      ...params,
+      environment: params.environment ?? config.environment
+    }),
+    getRoutes: (params = {}) => getProtocolRoutes(config.registry, {
+      ...params,
+      environment: params.environment ?? config.environment
+    }),
+    prepareTransfer: (params) => prepareTransfer(config.registry, params),
+    quoteEvmHyperlaneTransfer: async (params) => quoteEvmHyperlaneTransfer(config.registry, evmExecutor(), params),
+    executeEvmHyperlaneTransfer: async (params) => executeEvmHyperlaneTransfer(config.registry, evmExecutor(), params),
+    quoteEvmXReserveTransfer: async (params) => quoteEvmXReserveTransfer(config.registry, evmExecutor(), params),
+    executeEvmXReserveTransfer: async (params) => executeEvmXReserveTransfer(config.registry, evmExecutor(), params),
+    getXReserveAttestation: async (params) => getXReserveAttestation(config.registry, xReserveTransport(), params),
+    executeXReservePrivateMint: async (params) => executeXReservePrivateMint(config.registry, aleoExecutor(), params),
+    executeXReserveBurn: async (params) => executeXReserveBurn(config.registry, aleoExecutor(), params),
+    buildAleoHyperlaneTransferRemoteCall: (params) => buildAleoHyperlaneTransferRemoteCall(config.registry, params),
+    executeAleoHyperlaneTransferRemote: async (params) => executeAleoHyperlaneTransferRemote(config.registry, aleoExecutor(), 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", chainId: "aleo", symbol: "ALEO", name: "Aleo", decimals: 6, kind: "native", locator: { kind: "aleo-program", value: "credits.aleo" }, addressValidationRegex: ALEO_ADDRESS },
+  { id: "aleo/usdcx", chainId: "aleo", symbol: "USDCx", name: "USDCx", decimals: 6, kind: "token", locator: { kind: "aleo-program", value: "usdcx_stablecoin.aleo" }, addressValidationRegex: ALEO_ADDRESS },
+  { id: "aleo/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 },
+  { id: "aleo/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 },
+  { id: "aleo/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 },
+  { id: "aleo/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 },
+  { id: "aleo/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", chainId: "ethereum", symbol: "USDC", name: "USD Coin", decimals: 6, kind: "token", locator: { kind: "evm-contract", value: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" }, addressValidationRegex: EVM_ADDRESS },
+  { id: "ethereum/eth", chainId: "ethereum", symbol: "ETH", name: "Ether", decimals: 18, kind: "native", locator: { kind: "native", value: "ETH" }, addressValidationRegex: EVM_ADDRESS },
+  { id: "ethereum/wbtc", chainId: "ethereum", symbol: "WBTC", name: "Wrapped Bitcoin", decimals: 8, kind: "token", locator: { kind: "evm-contract", value: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599" }, addressValidationRegex: EVM_ADDRESS },
+  { id: "ethereum/usdt", chainId: "ethereum", symbol: "USDT", name: "Tether USD", decimals: 6, kind: "token", locator: { kind: "evm-contract", value: "0xdAC17F958D2ee523a2206206994597C13D831ec7" }, addressValidationRegex: EVM_ADDRESS },
+  { id: "ethereum/aleo", chainId: "ethereum", symbol: "ALEO", name: "Hyperlane ALEO", decimals: 6, kind: "token", addressValidationRegex: EVM_ADDRESS },
+  { id: "ethereum/usad", chainId: "ethereum", symbol: "USAD", name: "USAD route collateral", decimals: 6, kind: "token", addressValidationRegex: EVM_ADDRESS },
+  { id: "solana/sol", chainId: "solana", symbol: "SOL", name: "Solana", decimals: 9, kind: "native", locator: { kind: "native", value: "SOL" }, addressValidationRegex: SOLANA_ADDRESS },
+  { id: "solana/aleo", chainId: "solana", symbol: "ALEO", name: "Hyperlane ALEO", decimals: 6, kind: "token", addressValidationRegex: SOLANA_ADDRESS },
+  { id: "base/aleo", chainId: "base", symbol: "ALEO", name: "Hyperlane ALEO", decimals: 6, kind: "token", addressValidationRegex: EVM_ADDRESS },
+  { id: "hyperevm/aleo", chainId: "hyperevm", symbol: "ALEO", name: "Hyperlane ALEO", decimals: 6, kind: "token", addressValidationRegex: EVM_ADDRESS },
+  { id: "aleo-testnet/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 },
+  { id: "sepolia/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,
+  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"
+};
+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",
+    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",
+    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", "metadata-required", "ETH/aleo", { ...ETH_HYPERLANE_METADATA, ...aleoHyperlanePlaceholders("hyp_warp_token_eth_v2.aleo", 1), ...ALEO_ETH_APP_METADATA, ...ALEO_ETH_REMOTE_ROUTER }),
+  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", "metadata-required", "WBTC/aleo", { ...WBTC_HYPERLANE_METADATA, ...aleoHyperlanePlaceholders("hyp_warp_token_wbtc_v2.aleo", 1), ...ALEO_WBTC_APP_METADATA, ...ALEO_WBTC_REMOTE_ROUTER }),
+  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", "metadata-required", "USDT/aleo", { ...USDT_HYPERLANE_METADATA, ...aleoHyperlanePlaceholders("hyp_warp_token_usdt_v2.aleo", 1), ...ALEO_USDT_APP_METADATA, ...ALEO_USDT_ETHEREUM_REMOTE_ROUTER }),
+  route("hyperlane:solana/sol->aleo/sol", "hyperlane", "mainnet", "solana/sol", "aleo/sol", "metadata-required", "SOL/aleo", ALEO_MAILBOX_METADATA),
+  route("hyperlane:aleo/sol->solana/sol", "hyperlane", "mainnet", "aleo/sol", "solana/sol", "metadata-required", "SOL/aleo", { ...aleoHyperlanePlaceholders("hyp_warp_token_sol_v2.aleo", 1399811149), ...ALEO_SOL_APP_METADATA, ...ALEO_SOL_REMOTE_ROUTER }),
+  ...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-17.aleo-sol-router.1",
+  chains: Object.freeze(chains),
+  assets: Object.freeze(assets),
+  routes: Object.freeze(routes),
+  sources: Object.freeze([XRESERVE_SOURCE, HYPERLANE_SOURCE])
+});
+
+// src/registry/validate.ts
+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();
+  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 (!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
+        });
+      }
+    }
+    assetIds.add(asset.id);
+  }
+  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`);
+    }
+    routeIds.add(route2.id);
+  }
+  return registry;
+}
+
+// src/clients/createBridgeClient.ts
+function localBridgeTransport() {
+  return createTransport({
+    key: "protocolBridge",
+    name: "Protocol Bridge Transport",
+    type: "protocolBridge",
+    request: async ({ method }) => {
+      throw new Error(`Protocol bridge method is not implemented: ${method}`);
+    }
+  });
+}
+function createBridgeClient(config = {}) {
+  const {
+    environment = "mainnet",
+    registry = DEFAULT_BRIDGE_REGISTRY,
+    executors = {},
+    xReserveHttpTransport,
+    key = "bridge",
+    name = "Bridge Client"
+  } = config;
+  const validated = validateBridgeRegistry(registry);
+  const client = createClient({ transport: localBridgeTransport(), key, name });
+  return client.extend((inner) => ({
+    environment,
+    registry: validated,
+    ...bridgeActions(inner, { environment, registry: validated, executors, xReserveHttpTransport })
+  }));
+}
+export {
+  BridgeError,
+  DEFAULT_BRIDGE_REGISTRY,
+  aleoAddressToBytes32,
+  aleoProgramAddress,
+  bridgeActions,
+  buildAleoHyperlaneTransferRemoteCall,
+  buildXReserveBurnCall,
+  buildXReserveDepositPayload,
+  buildXReserveHookData,
+  calculateXReserveDepositNonce,
+  calculateXReserveMessageHash,
+  createBridgeClient,
+  evmAddressToAleoHyperlaneRecipient,
+  evmAddressToXReserveBytes32,
+  executeAleoHyperlaneTransferRemote,
+  executeEvmHyperlaneTransfer,
+  executeEvmXReserveTransfer,
+  executeXReserveBurn,
+  executeXReservePrivateMint,
+  getProtocolAssets as getAssets,
+  getProtocolRoutes as getRoutes,
+  getXReserveAttestation,
+  parseDecimalAmount,
+  prepareTransfer,
+  quoteEvmHyperlaneTransfer,
+  quoteEvmXReserveTransfer,
+  solanaAddressToAleoHyperlaneRecipient,
+  validateBridgeRegistry,
+  xReserveHexToAleoBytes
+};
+//# sourceMappingURL=index.js.map