@elsoul/erpc-sdk 0.8.0 → 0.9.0

package/dist/index.cjs

@@ -1,5 +1,9 @@
 'use strict';
 
+var ed25519_js = require('@noble/curves/ed25519.js');
+var sha2_js = require('@noble/hashes/sha2.js');
+var sha3_js = require('@noble/hashes/sha3.js');
+
 // src/errors.ts
 var REDACTED = "[REDACTED]";
 var credentialVariants = (credential) => {
@@ -22,6 +26,16 @@ var directEndpointVariants = (endpoint) => {
   const add = (value) => {
     if (value) values.push(value);
   };
+  const addPathValue = (value) => {
+    add(value);
+    try {
+      add(decodeURIComponent(value));
+    } catch {
+    }
+  };
+  for (const component of endpoint.pathname.split("/")) {
+    if (component) addPathValue(component);
+  }
   for (const value of endpoint.searchParams.values()) add(value);
   const rawQuery = endpoint.search.startsWith("?") ? endpoint.search.slice(1) : endpoint.search;
   for (const part of rawQuery.split("&")) {
@@ -349,13 +363,14 @@ var deepFreeze = (value) => {
   }
   return value;
 };
-var TOKEN_CATALOG_VERSION = "1.0.0";
-var TOKEN_CATALOG_AS_OF_DATE = "2026-09-15";
-var TOKEN_CATALOG_CONTENT_DIGEST = "28318f4f6a6bc2cdeef51368eeb17c86685c6f12d1723b0b4dd27f7e54d7235d";
+var TOKEN_CATALOG_VERSION = "1.1.0";
+var TOKEN_CATALOG_AS_OF_DATE = "2026-09-26";
+var TOKEN_CATALOG_CONTENT_DIGEST = "cca180df1846def0ec98f4e55b84cc46614c60d7a8c4a91c66dc9715c710ba73";
 var TOKEN_CHAIN_IDS = deepFreeze({
   "ethereumMainnet": "eip155:1",
   "solanaMainnet": "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
-  "avalancheCMainnet": "eip155:43114"
+  "avalancheCMainnet": "eip155:43114",
+  "baseMainnet": "eip155:8453"
 });
 var tokens = deepFreeze({
   "avalancheC": {
@@ -377,6 +392,11 @@ var tokens = deepFreeze({
     "USDT": "deployment-0015",
     "WAVAX": "deployment-0004"
   },
+  "base": {
+    "ETH": "deployment-0061",
+    "EURC": "deployment-0063",
+    "USDC": "deployment-0062"
+  },
   "ethereum": {
     "AAVE": "deployment-0056",
     "AUSD": "deployment-0034",
@@ -1790,6 +1810,54 @@ var TOKEN_DEPLOYMENTS = deepFreeze([
     "status": "active",
     "replacedByDeploymentId": null
   },
+  {
+    "deploymentId": "deployment-0061",
+    "assetId": "asset-0001",
+    "name": "Ether",
+    "representationKind": "native",
+    "stableCurrency": null,
+    "underlyingAssetId": null,
+    "economicReferenceAssetId": null,
+    "chainId": "eip155:8453",
+    "symbol": "ETH",
+    "decimals": 18,
+    "standard": "native",
+    "address": null,
+    "status": "active",
+    "replacedByDeploymentId": null
+  },
+  {
+    "deploymentId": "deployment-0062",
+    "assetId": "asset-0007",
+    "name": "USD Coin",
+    "representationKind": "issued",
+    "stableCurrency": "USD",
+    "underlyingAssetId": null,
+    "economicReferenceAssetId": null,
+    "chainId": "eip155:8453",
+    "symbol": "USDC",
+    "decimals": 6,
+    "standard": "erc20",
+    "address": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+    "status": "active",
+    "replacedByDeploymentId": null
+  },
+  {
+    "deploymentId": "deployment-0063",
+    "assetId": "asset-0008",
+    "name": "Euro Coin",
+    "representationKind": "issued",
+    "stableCurrency": "EUR",
+    "underlyingAssetId": null,
+    "economicReferenceAssetId": null,
+    "chainId": "eip155:8453",
+    "symbol": "EURC",
+    "decimals": 6,
+    "standard": "erc20",
+    "address": "0x60a3e35cc302bfa44cb288bc5a4f316fdb1adb42",
+    "status": "active",
+    "replacedByDeploymentId": null
+  },
   {
     "deploymentId": "discovered-token-054d80a64e1f36a756129763ca2f1e7a140b50b04c83876ff01dd5fd497a74c5",
     "assetId": "discovered-token-054d80a64e1f36a756129763ca2f1e7a140b50b04c83876ff01dd5fd497a74c5",
@@ -1969,6 +2037,9 @@ var TOKEN_ALIASES = deepFreeze([
   { namespace: "avalancheC", name: "USDC_E", deploymentId: tokens.avalancheC.USDC_E },
   { namespace: "avalancheC", name: "USDT", deploymentId: tokens.avalancheC.USDT },
   { namespace: "avalancheC", name: "WAVAX", deploymentId: tokens.avalancheC.WAVAX },
+  { namespace: "base", name: "ETH", deploymentId: tokens.base.ETH },
+  { namespace: "base", name: "EURC", deploymentId: tokens.base.EURC },
+  { namespace: "base", name: "USDC", deploymentId: tokens.base.USDC },
   { namespace: "ethereum", name: "AAVE", deploymentId: tokens.ethereum.AAVE },
   { namespace: "ethereum", name: "AUSD", deploymentId: tokens.ethereum.AUSD },
   { namespace: "ethereum", name: "DAI", deploymentId: tokens.ethereum.DAI },
@@ -2113,13 +2184,13 @@ function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isKnownChainId(value) {
-  return value === TOKEN_CHAIN_IDS.ethereumMainnet || value === TOKEN_CHAIN_IDS.solanaMainnet || value === TOKEN_CHAIN_IDS.avalancheCMainnet;
+  return value === TOKEN_CHAIN_IDS.ethereumMainnet || value === TOKEN_CHAIN_IDS.solanaMainnet || value === TOKEN_CHAIN_IDS.avalancheCMainnet || value === TOKEN_CHAIN_IDS.baseMainnet;
 }
 function isStableCurrency(value) {
   return value === "USD" || value === "EUR" || value === "JPY";
 }
 function isEvmChain(chainId) {
-  return chainId === TOKEN_CHAIN_IDS.ethereumMainnet || chainId === TOKEN_CHAIN_IDS.avalancheCMainnet;
+  return chainId === TOKEN_CHAIN_IDS.ethereumMainnet || chainId === TOKEN_CHAIN_IDS.avalancheCMainnet || chainId === TOKEN_CHAIN_IDS.baseMainnet;
 }
 function normalizeEvmAddress(address) {
   if (!/^0x[0-9a-fA-F]{40}$/.test(address)) return void 0;
@@ -2479,8 +2550,8 @@ var parseOffering = (value) => {
   const offering = objectValue(value);
   if (offering === null || typeof offering.id !== "string" || typeof offering.kind !== "string" || !resourceKinds.includes(offering.kind) || typeof offering.name !== "string" || typeof offering.description !== "string" || offering.mode !== void 0 && (typeof offering.mode !== "string" || !resourceModes.includes(offering.mode))) return null;
   const regions = stringArray(offering.regions);
-  const capabilities = stringArray(offering.capabilities);
-  if (regions === null || capabilities === null) return null;
+  const capabilities2 = stringArray(offering.capabilities);
+  if (regions === null || capabilities2 === null) return null;
   const compute = offering.compute === void 0 ? void 0 : objectValue(offering.compute);
   if (compute !== void 0 && (compute === null || compute.tenancy !== "virtual-machine" && compute.tenancy !== "bare-metal")) return null;
   const solana = offering.solana === void 0 ? void 0 : objectValue(offering.solana);
@@ -2493,7 +2564,7 @@ var parseOffering = (value) => {
     name: offering.name,
     description: offering.description,
     regions,
-    capabilities,
+    capabilities: capabilities2,
     ...typeof offering.mode === "string" ? { mode: offering.mode } : {},
     ...compute && (compute.tenancy === "virtual-machine" || compute.tenancy === "bare-metal") ? { compute: { tenancy: compute.tenancy } } : {},
     ...solana && (solana.transport === "grpc" || solana.transport === "shredstream") ? { solana: { transport: solana.transport } } : {},
@@ -2533,9 +2604,13 @@ var CloudCatalogClient = class {
   }
 };
 
+// src/transport/fetch.ts
+var wrapFetch = (implementation) => (input, init) => implementation(input, init);
+
 // src/config.ts
 var DEFAULT_ENDPOINT = "https://edge.erpc.global";
 var DEFAULT_AVALANCHE_ENDPOINT = "https://ava-rpc.erpc.global";
+var DEFAULT_BASE_ENDPOINT = "https://base.erpc.global";
 var DEFAULT_ACCOUNT_ENDPOINT = "https://solana-rpc.erpc.global";
 var DEFAULT_USER_ENDPOINT = "https://user-api.erpc.global";
 var DEFAULT_TIMEOUT_MS = 3e4;
@@ -2546,7 +2621,7 @@ var requireFetch = (provided) => {
       "A Fetch API implementation is required in this runtime"
     );
   }
-  return implementation;
+  return wrapFetch(implementation);
 };
 var normalizeLegacyEndpoint = (endpoint) => {
   endpoint.search = "";
@@ -2614,6 +2689,15 @@ var resolveRpcEndpoint = (value, namespace) => {
     ...webSocketUrl === void 0 ? {} : { webSocketUrl }
   };
 };
+var resolveBaseRpcEndpoint = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new ErpcConfigError("baseRpc must define an HTTP(S) URL");
+  }
+  const config = value;
+  const httpUrl = parseDirectUrl(config.httpUrl, "baseRpc.httpUrl", "HTTP(S)");
+  const headers = directHeaders(config.headers, "baseRpc");
+  return { headers, httpUrl };
+};
 var resolveConfig = (config) => {
   const configuredApiKey = config.apiKey === void 0 ? void 0 : typeof config.apiKey === "string" ? config.apiKey.trim() : (() => {
     throw new ErpcConfigError("apiKey must be a string");
@@ -2621,13 +2705,15 @@ var resolveConfig = (config) => {
   const solanaRpc = config.solanaRpc === void 0 ? void 0 : resolveRpcEndpoint(config.solanaRpc, "solanaRpc");
   const ethereumRpc = config.ethereumRpc === void 0 ? void 0 : resolveRpcEndpoint(config.ethereumRpc, "ethereumRpc");
   const avalancheCRpc = config.avalancheCRpc === void 0 ? void 0 : resolveRpcEndpoint(config.avalancheCRpc, "avalancheCRpc");
-  const hasDirectRpc = solanaRpc !== void 0 || ethereumRpc !== void 0 || avalancheCRpc !== void 0;
+  const baseRpc = config.baseRpc === void 0 ? void 0 : resolveBaseRpcEndpoint(config.baseRpc);
+  const hasDirectRpc = solanaRpc !== void 0 || ethereumRpc !== void 0 || avalancheCRpc !== void 0 || baseRpc !== void 0;
   if (!configuredApiKey && !hasDirectRpc) {
     throw new ErpcConfigError("apiKey must not be empty");
   }
   const apiKey = configuredApiKey || void 0;
   let endpoint;
   let avalancheEndpoint;
+  let baseEndpoint;
   let accountEndpoint;
   let userEndpoint;
   try {
@@ -2635,6 +2721,9 @@ var resolveConfig = (config) => {
     avalancheEndpoint = normalizeLegacyEndpoint(new URL(
       config.avalancheEndpoint ?? DEFAULT_AVALANCHE_ENDPOINT
     ));
+    baseEndpoint = normalizeLegacyEndpoint(new URL(
+      config.baseEndpoint ?? DEFAULT_BASE_ENDPOINT
+    ));
     accountEndpoint = normalizeLegacyEndpoint(new URL(
       config.accountEndpoint ?? DEFAULT_ACCOUNT_ENDPOINT
     ));
@@ -2648,6 +2737,9 @@ var resolveConfig = (config) => {
   if (avalancheEndpoint.protocol !== "https:" && avalancheEndpoint.protocol !== "http:") {
     throw new ErpcConfigError("avalancheEndpoint must use HTTP or HTTPS");
   }
+  if (baseEndpoint.protocol !== "https:" && baseEndpoint.protocol !== "http:") {
+    throw new ErpcConfigError("baseEndpoint must use HTTP or HTTPS");
+  }
   if (accountEndpoint.protocol !== "https:" && accountEndpoint.protocol !== "http:") {
     throw new ErpcConfigError("accountEndpoint must use HTTP or HTTPS");
   }
@@ -2661,6 +2753,7 @@ var resolveConfig = (config) => {
   return {
     accountEndpoint,
     avalancheEndpoint,
+    baseEndpoint,
     endpoint,
     fetch: requireFetch(config.fetch),
     headers: config.headers ?? {},
@@ -2668,6 +2761,7 @@ var resolveConfig = (config) => {
     userEndpoint,
     ...apiKey === void 0 ? {} : { apiKey },
     ...avalancheCRpc === void 0 ? {} : { avalancheCRpc },
+    ...baseRpc === void 0 ? {} : { baseRpc },
     ...ethereumRpc === void 0 ? {} : { ethereumRpc },
     ...solanaRpc === void 0 ? {} : { solanaRpc },
     ...config.webSocket === void 0 ? {} : { webSocket: config.webSocket }
@@ -3041,6 +3135,19 @@ var createAvalancheClient = (transport, indexTransports, nativeTransport = trans
   }
 });
 
+// src/rpc/base.ts
+var createBaseClient = (transport) => {
+  const ethereumRpc = createEthereumClient(transport).rpc;
+  return {
+    rpc: {
+      endpoint: ethereumRpc.endpoint,
+      eth_chainId: ethereumRpc.eth_chainId,
+      eth_getBalance: ethereumRpc.eth_getBalance,
+      eth_call: ethereumRpc.eth_call
+    }
+  };
+};
+
 // src/rpc/solana.ts
 var SOLANA_RPC_METHODS = [
   "getAccountInfo",
@@ -5201,8 +5308,14 @@ var HttpJsonRpcTransport = class {
     this.#unavailableNamespace = config.unavailableNamespace;
     this.maxBatchSize = config.maxBatchSize ?? 256;
     const endpoint = new URL(config.endpoint);
-    endpoint.search = "";
-    endpoint.hash = "";
+    if (this.#direct) {
+      endpoint.pathname = "/";
+      endpoint.search = "";
+      endpoint.hash = "";
+    } else {
+      endpoint.search = "";
+      endpoint.hash = "";
+    }
     this.endpoint = endpoint.toString();
   }
   async request(method, params, options = {}) {
@@ -5473,6 +5586,7 @@ var createErpcClient = (config) => {
   const solanaTransport = resolved.solanaRpc === void 0 ? resolved.apiKey === void 0 ? createUnavailableHttp("solana.rpc") : createLegacyHttp(resolved.endpoint) : createDirectHttp(resolved.solanaRpc);
   const ethereumTransport = resolved.ethereumRpc === void 0 ? resolved.apiKey === void 0 ? createUnavailableHttp("ethereum.rpc") : createLegacyHttp(endpointWithPath(resolved.endpoint, "/eth")) : createDirectHttp(resolved.ethereumRpc);
   const avalancheTransport = resolved.avalancheCRpc === void 0 ? resolved.apiKey === void 0 ? createUnavailableHttp("avalanche.rpc") : createLegacyHttp(endpointWithPath(resolved.avalancheEndpoint, "/ava")) : createDirectHttp(resolved.avalancheCRpc);
+  const baseTransport = resolved.baseRpc === void 0 ? resolved.apiKey === void 0 ? createUnavailableHttp("base") : createLegacyHttp(resolved.baseEndpoint) : createDirectHttp(resolved.baseRpc);
   const avalancheNativeTransport = resolved.apiKey === void 0 ? createUnavailableHttp("avalanche.native") : createLegacyHttp(endpointWithPath(resolved.avalancheEndpoint, "/ava"));
   const avalancheIndexTransport = (path, namespace) => resolved.apiKey === void 0 ? createUnavailableHttp(namespace) : createLegacyHttp(endpointWithPath(resolved.avalancheEndpoint, path));
   const solanaWebSocket = resolved.solanaRpc === void 0 ? resolved.apiKey === void 0 ? createUnavailableWebSocket("solana.subscriptions") : createLegacyWebSocket(websocketUrl(resolved.endpoint, resolved.apiKey)) : createDirectWebSocket(resolved.solanaRpc, "solana.subscriptions");
@@ -5535,6 +5649,7 @@ var createErpcClient = (config) => {
     solana,
     ethereum,
     avalanche,
+    base: createBaseClient(baseTransport),
     price: new PriceClient(priceTransport),
     account: new AccountClient(accountTransport),
     swap,
@@ -5721,7 +5836,7 @@ var requireFetch2 = (provided) => {
       "A Fetch API implementation is required in this runtime"
     );
   }
-  return implementation;
+  return wrapFetch(implementation);
 };
 var cloudEndpoint = (value) => {
   let endpoint;
@@ -5764,9 +5879,1514 @@ var createErpcCloudClient = (config) => {
 };
 
 // src/generated/bridge_capabilities.ts
-var BRIDGE_CAPABILITIES_JSON = '[{"bridgeCapabilityId":"bridge-mayan-swift-v2-eurc-eth-sol","providerId":"mayan-swift-v2","capabilityKind":"external-provider-dynamic","sourceChainId":"eip155:1","destinationChainId":"solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp","sourceTokenDeploymentId":"deployment-0011","destinationTokenDeploymentId":"deployment-0013","sourceTokenAddress":"0x1abaea1f7c830bd89acc67ec4af516284b1bc33c","destinationTokenAddress":"HzwqbKZw8HxMN6bF2yFZNrht3c2iXXzpKcFu7uBEDKtr","sourceTokenStandard":"erc20","destinationTokenStandard":"spl-token","sourceTokenDecimals":6,"destinationTokenDecimals":6,"sourceProviderChainName":"ethereum","destinationProviderChainName":"solana","sourceProviderChainId":1,"destinationProviderChainId":0,"sourceWormholeChainId":2,"destinationWormholeChainId":1,"sourceUsdcDeploymentId":"deployment-0008","sourceUsdcAddress":"0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48","sourceUsdcStandard":"erc20","sourceUsdcDecimals":6,"swiftContract":"0x40ffe85a28dc9993541449464d7529a922142960","forwarderAddress":"0x337685fdab40d39bd02028545a4ffa7d287cc3e2","forwarderFunctionSelector":"0x30dedc57","jupiterProgramAddress":null,"builderEndpoint":"https://tx-builder.mayan.finance","explorerEndpoint":"https://explorer-api.mayan.finance/v3","dependencies":["mayan-hosted-quote-api","mayan-hosted-transaction-builder","mayan-hosted-source-swap-builder","swift-auction-solvers","relayers","wormhole-guardian-messaging","mayan-explorer-indexer"],"status":"active"},{"bridgeCapabilityId":"bridge-mayan-swift-v2-eurc-sol-eth","providerId":"mayan-swift-v2","capabilityKind":"external-provider-dynamic","sourceChainId":"solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp","destinationChainId":"eip155:1","sourceTokenDeploymentId":"deployment-0013","destinationTokenDeploymentId":"deployment-0011","sourceTokenAddress":"HzwqbKZw8HxMN6bF2yFZNrht3c2iXXzpKcFu7uBEDKtr","destinationTokenAddress":"0x1abaea1f7c830bd89acc67ec4af516284b1bc33c","sourceTokenStandard":"spl-token","destinationTokenStandard":"erc20","sourceTokenDecimals":6,"destinationTokenDecimals":6,"sourceProviderChainName":"solana","destinationProviderChainName":"ethereum","sourceProviderChainId":0,"destinationProviderChainId":1,"sourceWormholeChainId":1,"destinationWormholeChainId":2,"sourceUsdcDeploymentId":"deployment-0010","sourceUsdcAddress":"EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v","sourceUsdcStandard":"spl-token","sourceUsdcDecimals":6,"swiftContract":"mayan34VedncxdK2XobtvWFDXQASUTBXhUVzt2kKgny","forwarderAddress":null,"forwarderFunctionSelector":null,"jupiterProgramAddress":"JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4","builderEndpoint":"https://tx-builder.mayan.finance","explorerEndpoint":"https://explorer-api.mayan.finance/v3","dependencies":["mayan-hosted-quote-api","mayan-hosted-transaction-builder","mayan-hosted-source-swap-builder","swift-auction-solvers","relayers","wormhole-guardian-messaging","mayan-explorer-indexer","jupiter-v6-source-swap"],"status":"active"}]';
-var BRIDGE_CAPABILITIES_CONTENT_DIGEST = "fe698f99218057f8cb40b3e24421d1d78e4e2cd7508cf6e3eb2457b329e5141b";
-var BRIDGE_CAPABILITIES_AS_OF_DATE = "2026-09-16";
+var BRIDGE_CAPABILITIES_JSON = '[{"bridgeCapabilityId":"bridge-mayan-swift-v2-eurc-eth-sol","providerId":"mayan-swift-v2","capabilityKind":"external-provider-dynamic","sourceChainId":"eip155:1","destinationChainId":"solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp","sourceTokenDeploymentId":"deployment-0011","destinationTokenDeploymentId":"deployment-0013","sourceTokenAddress":"0x1abaea1f7c830bd89acc67ec4af516284b1bc33c","destinationTokenAddress":"HzwqbKZw8HxMN6bF2yFZNrht3c2iXXzpKcFu7uBEDKtr","sourceTokenStandard":"erc20","destinationTokenStandard":"spl-token","sourceTokenDecimals":6,"destinationTokenDecimals":6,"sourceProviderChainName":"ethereum","destinationProviderChainName":"solana","sourceProviderChainId":1,"destinationProviderChainId":0,"sourceWormholeChainId":2,"destinationWormholeChainId":1,"sourceUsdcDeploymentId":"deployment-0008","sourceUsdcAddress":"0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48","sourceUsdcStandard":"erc20","sourceUsdcDecimals":6,"swiftContract":"0x40ffe85a28dc9993541449464d7529a922142960","forwarderAddress":"0x337685fdab40d39bd02028545a4ffa7d287cc3e2","forwarderFunctionSelector":"0x30dedc57","jupiterProgramAddress":null,"builderEndpoint":"https://tx-builder.mayan.finance","explorerEndpoint":"https://explorer-api.mayan.finance/v3","dependencies":["mayan-hosted-quote-api","mayan-hosted-transaction-builder","mayan-hosted-source-swap-builder","swift-auction-solvers","relayers","wormhole-guardian-messaging","mayan-explorer-indexer"],"status":"active"},{"bridgeCapabilityId":"bridge-mayan-swift-v2-eurc-sol-eth","providerId":"mayan-swift-v2","capabilityKind":"external-provider-dynamic","sourceChainId":"solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp","destinationChainId":"eip155:1","sourceTokenDeploymentId":"deployment-0013","destinationTokenDeploymentId":"deployment-0011","sourceTokenAddress":"HzwqbKZw8HxMN6bF2yFZNrht3c2iXXzpKcFu7uBEDKtr","destinationTokenAddress":"0x1abaea1f7c830bd89acc67ec4af516284b1bc33c","sourceTokenStandard":"spl-token","destinationTokenStandard":"erc20","sourceTokenDecimals":6,"destinationTokenDecimals":6,"sourceProviderChainName":"solana","destinationProviderChainName":"ethereum","sourceProviderChainId":0,"destinationProviderChainId":1,"sourceWormholeChainId":1,"destinationWormholeChainId":2,"sourceUsdcDeploymentId":"deployment-0010","sourceUsdcAddress":"EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v","sourceUsdcStandard":"spl-token","sourceUsdcDecimals":6,"swiftContract":"mayan34VedncxdK2XobtvWFDXQASUTBXhUVzt2kKgny","forwarderAddress":null,"forwarderFunctionSelector":null,"jupiterProgramAddress":"JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4","builderEndpoint":"https://tx-builder.mayan.finance","explorerEndpoint":"https://explorer-api.mayan.finance/v3","dependencies":["mayan-hosted-quote-api","mayan-hosted-transaction-builder","mayan-hosted-source-swap-builder","swift-auction-solvers","relayers","wormhole-guardian-messaging","mayan-explorer-indexer","jupiter-v6-source-swap"],"status":"active"},{"bridgeCapabilityId":"bridge-mayan-swift-v2-usdc-eth-sol","providerId":"mayan-swift-v2","capabilityKind":"external-provider-dynamic","sourceChainId":"eip155:1","destinationChainId":"solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp","sourceTokenDeploymentId":"deployment-0008","destinationTokenDeploymentId":"deployment-0010","sourceTokenAddress":"0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48","destinationTokenAddress":"EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v","sourceTokenStandard":"erc20","destinationTokenStandard":"spl-token","sourceTokenDecimals":6,"destinationTokenDecimals":6,"sourceProviderChainName":"ethereum","destinationProviderChainName":"solana","sourceProviderChainId":1,"destinationProviderChainId":0,"sourceWormholeChainId":2,"destinationWormholeChainId":1,"sourceUsdcDeploymentId":"deployment-0008","sourceUsdcAddress":"0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48","sourceUsdcStandard":"erc20","sourceUsdcDecimals":6,"swiftContract":"0x40ffe85a28dc9993541449464d7529a922142960","forwarderAddress":"0x337685fdab40d39bd02028545a4ffa7d287cc3e2","forwarderFunctionSelector":"0xe4269fc4","jupiterProgramAddress":null,"builderEndpoint":"https://tx-builder.mayan.finance","explorerEndpoint":"https://explorer-api.mayan.finance/v3","dependencies":["mayan-hosted-quote-api","mayan-hosted-transaction-builder","swift-auction-solvers","relayers","wormhole-guardian-messaging","mayan-explorer-indexer"],"status":"active"},{"bridgeCapabilityId":"bridge-mayan-swift-v2-usdc-sol-eth","providerId":"mayan-swift-v2","capabilityKind":"external-provider-dynamic","sourceChainId":"solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp","destinationChainId":"eip155:1","sourceTokenDeploymentId":"deployment-0010","destinationTokenDeploymentId":"deployment-0008","sourceTokenAddress":"EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v","destinationTokenAddress":"0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48","sourceTokenStandard":"spl-token","destinationTokenStandard":"erc20","sourceTokenDecimals":6,"destinationTokenDecimals":6,"sourceProviderChainName":"solana","destinationProviderChainName":"ethereum","sourceProviderChainId":0,"destinationProviderChainId":1,"sourceWormholeChainId":1,"destinationWormholeChainId":2,"sourceUsdcDeploymentId":"deployment-0010","sourceUsdcAddress":"EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v","sourceUsdcStandard":"spl-token","sourceUsdcDecimals":6,"swiftContract":"mayan34VedncxdK2XobtvWFDXQASUTBXhUVzt2kKgny","forwarderAddress":null,"forwarderFunctionSelector":null,"jupiterProgramAddress":null,"builderEndpoint":"https://tx-builder.mayan.finance","explorerEndpoint":"https://explorer-api.mayan.finance/v3","dependencies":["mayan-hosted-quote-api","mayan-hosted-transaction-builder","swift-auction-solvers","relayers","wormhole-guardian-messaging","mayan-explorer-indexer"],"status":"active"}]';
+var BRIDGE_CAPABILITIES_CONTENT_DIGEST = "691a77498c5ff876dadc437a8265d8288ec51cbc1d44f8beacb746626bf5b98d";
+var BRIDGE_CAPABILITIES_AS_OF_DATE = "2026-09-17";
+var ETHEREUM_CHAIN_ID = TOKEN_CHAIN_IDS.ethereumMainnet;
+var SOLANA_CHAIN_ID = TOKEN_CHAIN_IDS.solanaMainnet;
+var ETHEREUM_FORWARDER = "0x337685fdab40d39bd02028545a4ffa7d287cc3e2";
+var ETHEREUM_FORWARDER_PROVIDER = "0x337685fdaB40D39bd02028545a4FfA7D287cC3E2";
+var SOLANA_SWIFT_PROGRAM = "mayan34VedncxdK2XobtvWFDXQASUTBXhUVzt2kKgny";
+var SOLANA_JUPITER_V6 = "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4";
+var SOLANA_TOKEN_PROGRAM = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+var SOLANA_ASSOCIATED_TOKEN_PROGRAM = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+var SOLANA_SYSTEM_PROGRAM = "11111111111111111111111111111111";
+var SOLANA_SYSVAR_RENT = "SysvarRent111111111111111111111111111111111";
+var SOLANA_COMPUTE_BUDGET_PROGRAM = "ComputeBudget111111111111111111111111111111";
+var SOLANA_CPI_PROXY_PROGRAM = "D8C8iW6zmoKg5TRr8nQ7h14TMWqQX8FiBdj2ju5MF3wa";
+var SOLANA_ANCHOR_EVENT_AUTHORITY = "D8cy77BBepLMngZx6ZukaTff5hCt1HrWyKk3Hnd9oitf";
+var SOLANA_FEE_MANAGER_PROGRAM = "5VtQHnhs2pfVEr68qQsbTRwKh4JV5GTu9mBHgHFxpHeQ";
+var SOLANA_MAINNET_GENESIS_HASH = "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d";
+var SOLANA_MAYAN_LOOKUP_TABLE = "Ff3yi1meWQQ19VPZMzGg6H8JQQeRudiV7QtVtyzJyoht";
+var SOLANA_ADDRESS_LOOKUP_TABLE_OWNER = "AddressLookupTab1e1111111111111111111111111";
+var SOLANA_ROUTE_V2_DISCRIMINATOR = "bb64facc31c4af14";
+var SOLANA_ROUTE_V2_WHIRLPOOL_TAIL = "000001000000110010270001";
+var SOLANA_ROUTE_V2_RAYDIUM_TAIL = "0000010000001a10270001";
+var SOLANA_WHIRLPOOL_PROGRAM = "whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc";
+var SOLANA_WHIRLPOOL_POOL = "ArisQNcbjXPJD7RgPRvysatX3xcfHPTbcTkfD8kDoZ9i";
+var SOLANA_RAYDIUM_CLMM_PROGRAM = "CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK";
+var SOLANA_RAYDIUM_CLMM_POOL = "2zVV22uNWdJNmkXpj5vCrMzwHGBoJdsyV7qACh29sK1w";
+var SOLANA_INIT_ORDER_DISCRIMINATOR = "204c290c27a284db";
+var EVM_SOURCE_SWAP_SELECTOR = "0x3f0bde25";
+var SOLANA_MAYAN_SOURCE_SWAP_ENDPOINT = "https://price-api.mayan.finance/v3";
+var MAYAN_REFERENCE_COMMIT = "c4c98031aaad9264d17630d7b4de0cb18688cf78";
+var MAYAN_ORACLE_SDK_VERSION = "15_2_2";
+var MAX_RESPONSE_BYTES = 1024 * 1024;
+var MAX_JSON_DEPTH = 32;
+var MAX_ROUTER_CALLDATA_BYTES = 16384;
+var MAX_SOLANA_SWAP_ACCOUNTS = 64;
+var MAX_SOLANA_SWAP_DATA_BYTES = 4096;
+var MAX_LOOKUP_TABLES = 8;
+var MAX_LOOKUP_TABLE_ADDRESSES = 256;
+var MAX_SOLANA_TRANSACTION_BYTES = 1232;
+var UINT64_MAX = (1n << 64n) - 1n;
+var EVM_ADDRESS2 = /^0x[0-9a-fA-F]{40}$/u;
+var HEX_BYTES2 = /^0x(?:[0-9a-fA-F]{2})*$/u;
+var UINT64 = /^(0|[1-9][0-9]*)$/u;
+var NONCE = /^0x[0-9a-f]{32}$/u;
+var PLAIN_DECIMAL = /^(?:0|[1-9][0-9]*)(?:\.[0-9]+)?$/u;
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var capabilities = JSON.parse(BRIDGE_CAPABILITIES_JSON);
+var concatBytes = (...parts) => {
+  const length = parts.reduce((sum, part) => sum + part.length, 0);
+  const result = new Uint8Array(length);
+  let offset = 0;
+  for (const part of parts) {
+    result.set(part, offset);
+    offset += part.length;
+  }
+  return result;
+};
+var bytesToHex = (bytes) => [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+var hexToBytes = (value) => {
+  const normalized = value.startsWith("0x") ? value.slice(2) : value;
+  if (!/^(?:[0-9a-fA-F]{2})*$/u.test(normalized)) throw new Error("invalid hex");
+  const bytes = new Uint8Array(normalized.length / 2);
+  for (let index = 0; index < bytes.length; index += 1) {
+    bytes[index] = Number.parseInt(normalized.slice(index * 2, index * 2 + 2), 16);
+  }
+  return bytes;
+};
+var sha256Hex = (value) => bytesToHex(sha2_js.sha256(typeof value === "string" ? new TextEncoder().encode(value) : value));
+var keccakHex = (value) => bytesToHex(sha3_js.keccak_256(value));
+var stableJson = (value) => {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const object = value;
+    return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stableJson(object[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+};
+var cloneJson = (value) => JSON.parse(JSON.stringify(value));
+var assertJsonDepth = (value, depth = 0) => {
+  if (depth > MAX_JSON_DEPTH) throw new Error("json depth");
+  if (Array.isArray(value)) {
+    for (const child of value) assertJsonDepth(child, depth + 1);
+  } else if (value !== null && typeof value === "object") {
+    for (const child of Object.values(value)) assertJsonDepth(child, depth + 1);
+  }
+};
+var parseJsonObject = (text) => {
+  if (new TextEncoder().encode(text).length > MAX_RESPONSE_BYTES) throw new Error("response too large");
+  const value = JSON.parse(text);
+  assertJsonDepth(value);
+  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("object expected");
+  return value;
+};
+var normalizeEvmAddress3 = (value) => {
+  if (typeof value !== "string" || !EVM_ADDRESS2.test(value) || /^0x0{40}$/iu.test(value)) throw new Error("EVM address");
+  return value.toLowerCase();
+};
+var base58Decode = (value) => {
+  if (typeof value !== "string" || value.length === 0) throw new Error("base58");
+  let result = 0n;
+  for (const character of value) {
+    const digit = BASE58_ALPHABET.indexOf(character);
+    if (digit < 0) throw new Error("base58");
+    result = result * 58n + BigInt(digit);
+  }
+  const bytes = [];
+  while (result > 0n) {
+    bytes.push(Number(result & 0xffn));
+    result >>= 8n;
+  }
+  bytes.reverse();
+  let leading = 0;
+  while (leading < value.length && value[leading] === "1") leading += 1;
+  return Uint8Array.from([...new Uint8Array(leading), ...bytes]);
+};
+var base58Encode = (value) => {
+  let number = 0n;
+  for (const byte of value) number = number * 256n + BigInt(byte);
+  let result = "";
+  while (number > 0n) {
+    const digit = Number(number % 58n);
+    result = BASE58_ALPHABET[digit] + result;
+    number /= 58n;
+  }
+  let leading = 0;
+  while (leading < value.length && value[leading] === 0) leading += 1;
+  return `${"1".repeat(leading)}${result}`;
+};
+var canonicalSolanaAddress = (value) => {
+  const bytes = base58Decode(value);
+  if (bytes.length !== 32 || base58Encode(bytes) !== value) throw new Error("Solana address");
+  return value;
+};
+var uint64 = (value, positive = false) => {
+  if (typeof value !== "string" || !UINT64.test(value) || value.length > 20) throw new Error("uint64");
+  const parsed = BigInt(value);
+  if (parsed > UINT64_MAX || positive && parsed === 0n) throw new Error("uint64");
+  return parsed;
+};
+var wordUint = (value) => {
+  if (value < 0n || value >= 1n << 256n) throw new Error("ABI uint");
+  const result = new Uint8Array(32);
+  let remaining = value;
+  for (let index = 31; index >= 0; index -= 1) {
+    result[index] = Number(remaining & 0xffn);
+    remaining >>= 8n;
+  }
+  return result;
+};
+var wordAddress = (value) => {
+  const bytes = hexToBytes(normalizeEvmAddress3(value));
+  return concatBytes(new Uint8Array(12), bytes);
+};
+var wordBytes32 = (value) => {
+  if (value.length !== 32) throw new Error("bytes32");
+  return value;
+};
+var pad32 = (value) => {
+  const padded = new Uint8Array(Math.ceil(value.length / 32) * 32);
+  padded.set(value);
+  return padded;
+};
+var encodeAbiBytes = (value) => concatBytes(wordUint(BigInt(value.length)), pad32(value));
+var encodeAbiWithDynamics = (head, dynamics) => {
+  const headSize = (head.length + dynamics.length) * 32;
+  let offset = headSize;
+  const offsets = dynamics.map((value) => {
+    const current = offset;
+    offset += 32 + Math.ceil(value.length / 32) * 32;
+    return current;
+  });
+  return concatBytes(
+    ...head.map((word) => word),
+    ...offsets.map((entry) => wordUint(BigInt(entry))),
+    ...dynamics.map(encodeAbiBytes)
+  );
+};
+var nativeAddressBytes = (value, chainId) => {
+  if (chainId === ETHEREUM_CHAIN_ID) return wordAddress(value);
+  canonicalSolanaAddress(value);
+  return base58Decode(value);
+};
+var routeForQuote = (quote) => {
+  const route = capabilities.find((entry) => entry.sourceChainId === quote.sourceChainId && entry.destinationChainId === quote.destinationChainId && entry.sourceTokenDeploymentId === quote.sourceTokenDeploymentId && entry.destinationTokenDeploymentId === quote.destinationTokenDeploymentId);
+  if (!route) throw new Error("route");
+  return route;
+};
+var sourceIsUsdc = (route) => route.bridgeCapabilityId.includes("-usdc-");
+var providerStandard = (chainId) => chainId === ETHEREUM_CHAIN_ID ? "erc20" : "spl";
+var assertCatalogToken = (deploymentId, chainId, address, standard) => {
+  const token = getTokenDeployment(deploymentId);
+  if (!token || token.chainId !== chainId || token.address === null || token.standard !== standard || token.decimals !== 6 || token.status !== "active" || (chainId === ETHEREUM_CHAIN_ID ? token.address.toLowerCase() !== address.toLowerCase() : token.address !== address)) throw new Error("token");
+  return token;
+};
+var validateLocalRoute = (quote) => {
+  const route = routeForQuote(quote);
+  if (route.providerId !== "mayan-swift-v2" || route.status !== "active") throw new Error("route");
+  assertCatalogToken(route.sourceTokenDeploymentId, route.sourceChainId, route.sourceTokenAddress, route.sourceTokenStandard);
+  assertCatalogToken(route.destinationTokenDeploymentId, route.destinationChainId, route.destinationTokenAddress, route.destinationTokenStandard);
+  assertCatalogToken(route.sourceUsdcDeploymentId, route.sourceChainId, route.sourceUsdcAddress, route.sourceUsdcStandard);
+  if (quote.sourceSwap.required !== !sourceIsUsdc(route)) throw new Error("quote");
+  if (quote.sourceSwap.inputTokenDeploymentId !== route.sourceTokenDeploymentId || quote.sourceSwap.intermediateTokenDeploymentId !== route.sourceUsdcDeploymentId || quote.sourceSwap.intermediateTokenAddress !== route.sourceUsdcAddress || quote.sourceSwap.intermediateTokenStandard !== providerStandard(route.sourceChainId) || quote.sourceSwap.intermediateTokenDecimals !== 6) throw new Error("quote");
+  if (sourceIsUsdc(route)) {
+    if (quote.sourceSwap.routerKind !== null || quote.sourceSwap.routerAddress !== null) throw new Error("quote");
+    if (JSON.stringify(quote.dependencies) !== JSON.stringify(route.dependencies)) throw new Error("quote");
+  } else if (route.sourceChainId === ETHEREUM_CHAIN_ID && (quote.sourceSwap.routerKind !== "provider-selected-evm" || quote.sourceSwap.routerAddress === null) || route.sourceChainId === SOLANA_CHAIN_ID && (quote.sourceSwap.routerKind !== "jupiter-v6" || quote.sourceSwap.routerAddress !== SOLANA_JUPITER_V6) || JSON.stringify(quote.dependencies) !== JSON.stringify(route.dependencies)) throw new Error("quote");
+  const raw = parseJsonObject(quote.rawSignedQuoteJson);
+  if (raw.swiftWrapAndLock !== void 0 && raw.swiftWrapAndLock !== false) throw new Error("quote");
+  if (!sourceIsUsdc(route) && route.sourceChainId === ETHEREUM_CHAIN_ID) {
+    if (raw.evmSwapRouterAddress !== void 0 && !rawAddressEquals(raw.evmSwapRouterAddress, quote.sourceSwap.routerAddress ?? "")) throw new Error("quote");
+    if (raw.evmSwapRouterCalldata !== void 0 && (typeof raw.evmSwapRouterCalldata !== "string" || !HEX_BYTES2.test(raw.evmSwapRouterCalldata) || raw.evmSwapRouterCalldata === "0x" || hexToBytes(raw.evmSwapRouterCalldata).length > MAX_ROUTER_CALLDATA_BYTES)) throw new Error("quote");
+  }
+  const mode = raw.swiftAuctionMode;
+  if (mode !== 2 && mode !== 3) throw new Error("quote");
+  if (mode !== (sourceIsUsdc(route) ? 3 : 2)) throw new Error("quote");
+  if (mode === 3 && (raw.expectedAmountOutBaseUnits !== raw.minAmountOutBaseUnits || raw.minAmountOutBaseUnits !== raw.minReceivedBaseUnits)) throw new Error("quote");
+  const forbidden = ["customPayload", "memoHex", "referrer", "referrerAddress", "swiftRefundAddress", "permit", "approval", "approvalBatch", "separateSwapTx", "jito", "extraInstructions"];
+  for (const key of forbidden) if (Object.hasOwn(raw, key) && raw[key] !== null && raw[key] !== false && raw[key] !== "") throw new Error("quote");
+  return route;
+};
+var extractRawNumberLexeme = (raw, key) => {
+  const expression = new RegExp(`"${key}"\\s*:\\s*([^,}\\s]+)`, "gu");
+  const matches = [...raw.matchAll(expression)];
+  const match = matches[0];
+  if (matches.length !== 1 || match === void 0 || match[1] === void 0) throw new Error("number");
+  return match[1];
+};
+var parsePlainDecimal = (value) => {
+  if (!PLAIN_DECIMAL.test(value)) throw new Error("decimal");
+  const separator = value.indexOf(".");
+  const integerPart = separator === -1 ? value : value.slice(0, separator);
+  const fractionalPart = separator === -1 ? "" : value.slice(separator + 1);
+  const integer = BigInt(integerPart);
+  const keptFraction = fractionalPart.slice(0, 6).padEnd(6, "0");
+  const result = integer * 1000000n + BigInt(keptFraction || "0");
+  if (result <= 0n || result > UINT64_MAX) throw new Error("decimal");
+  return { source: value, integer: result, scale: fractionalPart.length };
+};
+var binary64RoundedDecimalUnits = (value) => {
+  const number = Number(value);
+  if (!Number.isFinite(number) || number <= 0 || number === 0) throw new Error("decimal");
+  const bits = new DataView(new ArrayBuffer(8));
+  bits.setFloat64(0, number, false);
+  const high = BigInt(bits.getUint32(0, false));
+  const low = BigInt(bits.getUint32(4, false));
+  const encoded = high << 32n | low;
+  const exponent = Number(encoded >> 52n & 0x7ffn);
+  const fraction = encoded & (1n << 52n) - 1n;
+  const mantissa = exponent === 0 ? fraction : 1n << 52n | fraction;
+  const binaryExponent = exponent === 0 ? -1074 : exponent - 1023 - 52;
+  let numerator = mantissa * 10000000n;
+  let denominator = 1n;
+  if (binaryExponent >= 0) numerator <<= BigInt(binaryExponent);
+  else denominator <<= BigInt(-binaryExponent);
+  let rounded = numerator / denominator;
+  const remainder = numerator % denominator;
+  if (remainder * 2n >= denominator) rounded += 1n;
+  const result = rounded / 10n;
+  if (result <= 0n || result > UINT64_MAX) throw new Error("decimal");
+  return result;
+};
+var exactIntermediateAmount = (raw, direct, amountIn) => {
+  const decimal = parsePlainDecimal(raw);
+  const exact = decimal.integer;
+  if (direct) {
+    if (exact !== uint64(amountIn, true)) throw new Error("decimal");
+    return exact.toString();
+  }
+  if (binary64RoundedDecimalUnits(raw) !== exact) throw new Error("decimal");
+  return exact.toString();
+};
+var validateDestinationMinimumCompatibility = (raw, canonical) => {
+  const units = uint64(canonical, true);
+  const lexeme = extractRawNumberLexeme(raw, "minAmountOut");
+  if (parsePlainDecimal(lexeme).integer !== units || binary64RoundedDecimalUnits(lexeme) !== units) {
+    throw new Error("destination minimum");
+  }
+};
+var rawUint64 = (raw, key, required = true) => {
+  const value = raw[key];
+  if (value === void 0 && !required) return 0n;
+  return uint64(value, false);
+};
+var rawAddressEquals = (value, expected) => typeof value === "string" && (EVM_ADDRESS2.test(expected) ? value.toLowerCase() === expected.toLowerCase() : value === expected);
+var isOnCurveZip215 = (bytes) => {
+  try {
+    ed25519_js.ed25519.Point.fromBytes(bytes, true);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var findProgramAddress = (seeds, programId) => {
+  if (seeds.length > 16 || seeds.some((seed) => seed.length > 32)) throw new Error("PDA seeds");
+  const program = base58Decode(programId);
+  if (program.length !== 32) throw new Error("PDA program");
+  const suffix = new TextEncoder().encode("ProgramDerivedAddress");
+  for (let bump = 255; bump >= 0; bump -= 1) {
+    const candidate = sha2_js.sha256(concatBytes(...seeds, Uint8Array.from([bump]), program, suffix));
+    if (!isOnCurveZip215(candidate)) return { address: base58Encode(candidate), bump };
+  }
+  throw new Error("PDA unavailable");
+};
+var associatedTokenAddress = (owner, mint, allowOwnerOffCurve) => {
+  const ownerBytes = base58Decode(owner);
+  const mintBytes = base58Decode(mint);
+  if (ownerBytes.length !== 32 || mintBytes.length !== 32) throw new Error("ATA address");
+  if (!allowOwnerOffCurve && isOnCurveZip215(ownerBytes) === false) throw new Error("ATA owner");
+  return findProgramAddress(
+    [ownerBytes, base58Decode(SOLANA_TOKEN_PROGRAM), mintBytes],
+    SOLANA_ASSOCIATED_TOKEN_PROGRAM
+  ).address;
+};
+var parseSourceQuote = (quote, route) => {
+  const raw = parseJsonObject(quote.rawSignedQuoteJson);
+  const minimumLexeme = extractRawNumberLexeme(quote.rawSignedQuoteJson, "minMiddleAmount");
+  const modeValue = raw.swiftAuctionMode;
+  if (modeValue !== 2 && modeValue !== 3) throw new Error("mode");
+  const mode = modeValue === 2 || modeValue === 3 ? modeValue : sourceIsUsdc(route) ? 3 : 2;
+  if (mode !== (sourceIsUsdc(route) ? 3 : 2)) throw new Error("mode");
+  if (mode === 3 && (raw.expectedAmountOutBaseUnits !== raw.minAmountOutBaseUnits || raw.minAmountOutBaseUnits !== raw.minReceivedBaseUnits)) throw new Error("guaranteed output");
+  const minimumIntermediateAmount = exactIntermediateAmount(minimumLexeme, sourceIsUsdc(route), quote.amountIn);
+  if (quote.sourceSwap.providerMinimumAmount !== minimumLexeme) throw new Error("provider minimum");
+  if (!sourceIsUsdc(route)) {
+    const numeric = Number(minimumLexeme);
+    if (!Number.isFinite(numeric) || numeric <= 0) throw new Error("number");
+  }
+  return {
+    raw,
+    minimumIntermediateAmount,
+    mode,
+    cancelFee: rawUint64(raw, "cancelRelayerFee64"),
+    refundFee: rawUint64(raw, "refundRelayerFee64"),
+    submitFee: rawUint64(raw, "submitRelayerFee64")
+  };
+};
+var swiftRandom = (quoteId, orderNonce) => concatBytes(hexToBytes(quoteId), hexToBytes(orderNonce));
+var writeUint16Be = (value) => {
+  if (!Number.isSafeInteger(value) || value < 0 || value > 65535) throw new Error("uint16");
+  return Uint8Array.from([value >>> 8 & 255, value & 255]);
+};
+var writeUint64Be = (value) => {
+  if (value < 0n || value > UINT64_MAX) throw new Error("uint64");
+  const result = new Uint8Array(8);
+  let current = value;
+  for (let index = 7; index >= 0; index -= 1) {
+    result[index] = Number(current & 0xffn);
+    current >>= 8n;
+  }
+  return result;
+};
+var writeUint64Le = (value) => {
+  const result = writeUint64Be(value);
+  return Uint8Array.from([...result].reverse());
+};
+var writeUint16Le = (value) => {
+  const result = writeUint16Be(value);
+  return Uint8Array.from([result[1], result[0]]);
+};
+var zero32 = () => new Uint8Array(32);
+var orderPreimage = (quote, route, swapperAddress, destinationAddress, orderNonce, minimumIntermediateAmount, cancelFee, refundFee, mode) => {
+  const destinationMinimum = uint64(quote.minimumAmountOut, true);
+  const parts = [
+    Uint8Array.from([1]),
+    nativeAddressBytes(swapperAddress, route.sourceChainId),
+    writeUint16Be(route.sourceWormholeChainId),
+    nativeAddressBytes(route.sourceUsdcAddress, route.sourceChainId),
+    nativeAddressBytes(destinationAddress, route.destinationChainId),
+    writeUint16Be(route.destinationWormholeChainId),
+    nativeAddressBytes(route.destinationTokenAddress, route.destinationChainId),
+    writeUint64Be(destinationMinimum),
+    writeUint64Be(0n),
+    writeUint64Be(cancelFee),
+    writeUint64Be(refundFee),
+    writeUint64Be(uint64(quote.deadline, true)),
+    zero32(),
+    Uint8Array.from([0, 0, mode]),
+    swiftRandom(quote.quoteId, orderNonce),
+    zero32()
+  ];
+  const result = concatBytes(...parts);
+  if (result.length !== 272) throw new Error("order preimage");
+  return result;
+};
+var hashOrder = (quote, route, swapperAddress, destinationAddress, orderNonce, minimumIntermediateAmount, cancelFee, refundFee, mode) => `0x${keccakHex(orderPreimage(quote, route, swapperAddress, destinationAddress, orderNonce, minimumIntermediateAmount, cancelFee, refundFee, mode))}`;
+var quoteBindingHash = (route, quote, rawQuoteSha256, orderNonce, swapperAddress, destinationAddress) => sha256Hex(stableJson({
+  capabilityId: route.bridgeCapabilityId,
+  destinationAddress,
+  destinationChainId: route.destinationChainId,
+  destinationTokenDeploymentId: route.destinationTokenDeploymentId,
+  orderNonce,
+  quoteId: quote.quoteId,
+  rawQuoteSha256,
+  sourceChainId: route.sourceChainId,
+  sourceTokenDeploymentId: route.sourceTokenDeploymentId,
+  swapperAddress
+}));
+var sourceSwapHashProjection = (sourceSwap) => {
+  if (sourceSwap.kind === "none") return sourceSwap;
+  if (sourceSwap.kind === "evm-router") {
+    const { rawProviderSourceSwapJson: _raw2, ...value2 } = sourceSwap;
+    return value2;
+  }
+  const { rawProviderSourceSwapJson: _raw, ...value } = sourceSwap;
+  return value;
+};
+var planHash = (binding, sourceSwap) => sha256Hex(stableJson({ quoteBindingHash: binding, sourceSwap: sourceSwapHashProjection(sourceSwap) }));
+var endpointUrl = (value) => {
+  const source = value === void 0 ? SOLANA_MAYAN_SOURCE_SWAP_ENDPOINT : value;
+  if (typeof source !== "string" || source.length === 0 || source.trim() !== source) throw new Error("endpoint");
+  let endpoint;
+  try {
+    endpoint = new URL(source);
+  } catch {
+    throw new Error("endpoint");
+  }
+  if (endpoint.username || endpoint.password || endpoint.search || endpoint.hash || endpoint.protocol !== "https:" && !(endpoint.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]", "::1"].includes(endpoint.hostname))) throw new Error("endpoint");
+  endpoint.pathname = endpoint.pathname.replace(/\/+$/u, "") || "/";
+  return endpoint;
+};
+var sourceSwapUrl = (endpoint, chain, params) => {
+  const result = new URL(endpoint);
+  const basePath = result.pathname.replace(/\/+$/u, "");
+  result.pathname = `${basePath}/get-swap/${chain}`.replace(/\/{2,}/gu, "/");
+  for (const [key, value] of params) result.searchParams.append(key, String(value));
+  return result;
+};
+var SourceResponseInvalidError = class extends Error {
+  constructor() {
+    super("invalid source response");
+    this.name = "SourceResponseInvalidError";
+  }
+};
+var disposeResponseBody = (response) => {
+  if (response.body === null) return;
+  try {
+    const reader = response.body.getReader();
+    void reader.cancel().catch(() => void 0);
+    reader.releaseLock();
+  } catch {
+  }
+};
+var readSourceResponseText = async (response, signal) => {
+  const declaredLength = response.headers.get("content-length");
+  if (declaredLength !== null && /^\d+$/u.test(declaredLength) && Number(declaredLength) > MAX_RESPONSE_BYTES) {
+    disposeResponseBody(response);
+    throw new SourceResponseInvalidError();
+  }
+  if (response.body === null) return "";
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  let complete = false;
+  let abortListener;
+  try {
+    while (true) {
+      if (signal.aborted) throw new DOMException("aborted", "AbortError");
+      const abortPromise = new Promise((_resolve, reject) => {
+        abortListener = () => reject(new DOMException("aborted", "AbortError"));
+        signal.addEventListener("abort", abortListener, { once: true });
+      });
+      let result;
+      try {
+        result = await Promise.race([reader.read(), abortPromise]);
+      } finally {
+        if (abortListener !== void 0) signal.removeEventListener("abort", abortListener);
+        abortListener = void 0;
+      }
+      if (result.done) {
+        complete = true;
+        break;
+      }
+      if (!(result.value instanceof Uint8Array)) throw new SourceResponseInvalidError();
+      total += result.value.byteLength;
+      if (total > MAX_RESPONSE_BYTES) throw new SourceResponseInvalidError();
+      chunks.push(result.value);
+    }
+  } finally {
+    if (!complete) {
+      try {
+        await reader.cancel();
+      } catch {
+      }
+    }
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    throw new SourceResponseInvalidError();
+  }
+};
+var fetchSourceSwap = async (runtime, url, options) => {
+  const controller = new AbortController();
+  let timedOut = false;
+  const timeout = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, runtime.timeoutMs);
+  const abort = () => controller.abort();
+  if (options?.signal?.aborted) controller.abort();
+  else options?.signal?.addEventListener("abort", abort, { once: true });
+  try {
+    const response = await runtime.fetch(url, {
+      method: "GET",
+      headers: { accept: "application/json" },
+      credentials: "omit",
+      redirect: "manual",
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      disposeResponseBody(response);
+      runtime.fail("BRIDGE_PROVIDER_HTTP");
+    }
+    const text = await readSourceResponseText(response, controller.signal);
+    let root;
+    try {
+      root = parseJsonObject(text);
+    } catch {
+      runtime.fail("BRIDGE_PROVIDER_INVALID_RESPONSE");
+    }
+    return { text, root };
+  } catch (error) {
+    if (error instanceof Error && error.name === "BridgeError") throw error;
+    if (error instanceof SourceResponseInvalidError) runtime.fail("BRIDGE_PROVIDER_INVALID_RESPONSE");
+    if (runtime.fail && timedOut) runtime.fail("BRIDGE_TIMEOUT");
+    if (options?.signal?.aborted) runtime.fail("BRIDGE_ABORTED");
+    if (error instanceof ErpcHttpError) runtime.fail("BRIDGE_PROVIDER_HTTP");
+    runtime.fail("BRIDGE_PROVIDER_TRANSPORT");
+  } finally {
+    clearTimeout(timeout);
+    options?.signal?.removeEventListener("abort", abort);
+  }
+};
+var base64Decode = (value, maximumBytes = MAX_SOLANA_SWAP_DATA_BYTES) => {
+  if (typeof value !== "string" || value.length > Math.ceil(maximumBytes * 4 / 3) + 4 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(value)) throw new Error("base64");
+  const bytes = Uint8Array.from(Buffer.from(value, "base64"));
+  if (bytes.length > maximumBytes || Buffer.from(bytes).toString("base64") !== value) throw new Error("base64");
+  return bytes;
+};
+var instructionFromRaw = (value) => {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("instruction");
+  const source = value;
+  if (Object.keys(source).sort().join(",") !== "accounts,data,programId") throw new Error("instruction");
+  const programId = canonicalSolanaAddress(source.programId);
+  if (!Array.isArray(source.accounts) || source.accounts.length > MAX_SOLANA_SWAP_ACCOUNTS) throw new Error("instruction");
+  const accounts = source.accounts.map((entry) => {
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry)) throw new Error("account");
+    const account = entry;
+    if (Object.keys(account).sort().join(",") !== "isSigner,isWritable,pubkey" || typeof account.isSigner !== "boolean" || typeof account.isWritable !== "boolean") throw new Error("account");
+    return {
+      pubkey: canonicalSolanaAddress(account.pubkey),
+      isSigner: account.isSigner,
+      isWritable: account.isWritable
+    };
+  });
+  const dataBase64 = source.data;
+  base64Decode(dataBase64);
+  return { programId, accounts, dataBase64 };
+};
+var encodeInstructionData = (value) => base64Decode(value);
+var accountAt = (instruction, index) => {
+  const value = instruction.accounts[index];
+  if (!value) throw new Error("account");
+  return value;
+};
+var assertAccount = (account, pubkey, isSigner, isWritable) => {
+  if (account.pubkey !== pubkey || account.isSigner !== isSigner || account.isWritable !== isWritable) {
+    throw new Error("account");
+  }
+};
+var validateComputeInstructions = (instructions) => {
+  if (instructions.length > 2) throw new Error("compute");
+  const tags = /* @__PURE__ */ new Set();
+  for (const instruction of instructions) {
+    if (instruction.programId !== SOLANA_COMPUTE_BUDGET_PROGRAM || instruction.accounts.length !== 0) throw new Error("compute");
+    const data = encodeInstructionData(instruction.dataBase64);
+    const tag = data[0];
+    if (tag !== 2 && tag !== 3 || tags.has(tag)) throw new Error("compute");
+    tags.add(tag);
+    if (tag === 2) {
+      if (data.length !== 5 || new DataView(data.buffer, data.byteOffset, data.byteLength).getUint32(1, true) > 14e5) throw new Error("compute");
+    } else if (data.length !== 9 || new DataView(data.buffer, data.byteOffset, data.byteLength).getBigUint64(1, true) > 100000n) {
+      throw new Error("compute");
+    }
+  }
+};
+var validateAtaSetup = (instructions, swapperAddress, stateAddress, sourceUsdcAddress) => {
+  if (instructions.length === 0 || instructions.length > 2) throw new Error("setup");
+  const tokenProgram = SOLANA_TOKEN_PROGRAM;
+  const owners = /* @__PURE__ */ new Set();
+  for (const instruction of instructions) {
+    if (instruction.programId !== SOLANA_ASSOCIATED_TOKEN_PROGRAM || instruction.accounts.length !== 6) throw new Error("setup");
+    const payer = accountAt(instruction, 0);
+    assertAccount(payer, swapperAddress, true, true);
+    const owner = accountAt(instruction, 2).pubkey;
+    if (owner !== swapperAddress && owner !== stateAddress) throw new Error("setup");
+    if (owners.has(owner)) throw new Error("setup");
+    owners.add(owner);
+    const expectedAta = associatedTokenAddress(owner, sourceUsdcAddress, owner === stateAddress);
+    assertAccount(accountAt(instruction, 2), owner, false, false);
+    assertAccount(accountAt(instruction, 1), expectedAta, false, true);
+    assertAccount(accountAt(instruction, 3), sourceUsdcAddress, false, false);
+    assertAccount(accountAt(instruction, 4), SOLANA_SYSTEM_PROGRAM, false, false);
+    assertAccount(accountAt(instruction, 5), tokenProgram, false, false);
+    const data = encodeInstructionData(instruction.dataBase64);
+    if (data.length !== 0 && (data.length !== 1 || data[0] !== 1)) throw new Error("setup");
+  }
+  if (!owners.has(stateAddress)) throw new Error("setup");
+};
+var validateJupiterInstruction = (instruction, route, quote, stateTokenAccount, swapperAddress, minimumIntermediateAmount, sourceSwapRaw) => {
+  if (instruction.programId !== SOLANA_JUPITER_V6 || instruction.accounts.length < 8 || instruction.accounts.length > MAX_SOLANA_SWAP_ACCOUNTS) throw new Error("jupiter");
+  const data = encodeInstructionData(instruction.dataBase64);
+  if (bytesToHex(data.slice(0, 8)) !== SOLANA_ROUTE_V2_DISCRIMINATOR) throw new Error("jupiter");
+  const quoteResponse = sourceSwapRaw.quoteResponse;
+  if (quoteResponse === null || typeof quoteResponse !== "object" || Array.isArray(quoteResponse)) throw new Error("jupiter");
+  const quoteResponseRaw = quoteResponse.raw;
+  if (quoteResponseRaw === null || typeof quoteResponseRaw !== "object" || Array.isArray(quoteResponseRaw)) throw new Error("jupiter");
+  const routePlan = quoteResponseRaw.routePlan;
+  if (!Array.isArray(routePlan) || routePlan.length !== 1) throw new Error("jupiter");
+  const swapInfo = routePlan[0]?.swapInfo;
+  if (swapInfo === null || typeof swapInfo !== "object" || Array.isArray(swapInfo)) throw new Error("jupiter");
+  const swapInfoRecord = swapInfo;
+  const quoteResponseRecord = quoteResponse;
+  const quoteResponseRawRecord = quoteResponseRaw;
+  if (!rawAddressEquals(quoteResponseRecord.inputMint, route.sourceTokenAddress) || !rawAddressEquals(quoteResponseRecord.outputMint, route.sourceUsdcAddress) || !rawAddressEquals(quoteResponseRawRecord.inputMint, route.sourceTokenAddress) || !rawAddressEquals(quoteResponseRawRecord.outputMint, route.sourceUsdcAddress) || !rawAddressEquals(swapInfoRecord.inputMint, route.sourceTokenAddress) || !rawAddressEquals(swapInfoRecord.outputMint, route.sourceUsdcAddress) || typeof swapInfoRecord.inAmount !== "string" || typeof swapInfoRecord.outAmount !== "string" || uint64(swapInfoRecord.inAmount, true) !== uint64(quote.amountIn, true) || uint64(swapInfoRecord.outAmount, true) < uint64(minimumIntermediateAmount, true)) throw new Error("jupiter");
+  const label = swapInfo.label;
+  const expectedTail = label === "Whirlpool" ? SOLANA_ROUTE_V2_WHIRLPOOL_TAIL : label === "Raydium CLMM" ? SOLANA_ROUTE_V2_RAYDIUM_TAIL : null;
+  if (expectedTail === null || data.length !== 28 + expectedTail.length / 2 || bytesToHex(data.slice(28)) !== expectedTail) throw new Error("jupiter");
+  const expectedAccountCount = label === "Whirlpool" ? 22 : 25;
+  const expectedAccounts = label === "Whirlpool" ? [
+    [swapperAddress, true, false],
+    [associatedTokenAddress(swapperAddress, route.sourceTokenAddress, false), false, true],
+    [associatedTokenAddress(swapperAddress, route.sourceUsdcAddress, false), false, true],
+    [route.sourceTokenAddress, false, false],
+    [route.sourceUsdcAddress, false, false],
+    [SOLANA_TOKEN_PROGRAM, false, false],
+    [SOLANA_TOKEN_PROGRAM, false, false],
+    [stateTokenAccount, false, true],
+    [SOLANA_ANCHOR_EVENT_AUTHORITY, false, false],
+    [SOLANA_JUPITER_V6, false, false],
+    [SOLANA_WHIRLPOOL_PROGRAM, false, false],
+    [SOLANA_TOKEN_PROGRAM, false, false],
+    [swapperAddress, false, false],
+    [SOLANA_WHIRLPOOL_POOL, false, true],
+    [associatedTokenAddress(swapperAddress, route.sourceUsdcAddress, false), false, true],
+    ["6i68TM44UYSawGAS4Bx1vX31Af7QNZaRNBLUbc4r8exB", false, true],
+    [associatedTokenAddress(swapperAddress, route.sourceTokenAddress, false), false, true],
+    ["8aq9zUXe37KLtXSaEYt7oq65oNAJiu1my2kRNMRPhTD5", false, true],
+    ["7qscKXFXCd1WQinZJvSDLsGLTTEwjmd88a871pz2V3Ja", false, true],
+    ["CaohZGaBaLmXyFQ4cLc83wGZTET7Mt9xMtUqR9EGaMHF", false, true],
+    ["7Mr4WYMiGPAXkyt9ePsHHmV6ust3U6dHwBmyfMRiHPA7", false, true],
+    ["9BjNZYSCZ3ac3XUYVKte4YYtmBGd7ATKfRshTGN99NxQ", false, false]
+  ] : [
+    [swapperAddress, true, false],
+    [associatedTokenAddress(swapperAddress, route.sourceTokenAddress, false), false, true],
+    [associatedTokenAddress(swapperAddress, route.sourceUsdcAddress, false), false, true],
+    [route.sourceTokenAddress, false, false],
+    [route.sourceUsdcAddress, false, false],
+    [SOLANA_TOKEN_PROGRAM, false, false],
+    [SOLANA_TOKEN_PROGRAM, false, false],
+    [stateTokenAccount, false, true],
+    [SOLANA_ANCHOR_EVENT_AUTHORITY, false, false],
+    [SOLANA_JUPITER_V6, false, false],
+    [SOLANA_RAYDIUM_CLMM_PROGRAM, false, false],
+    [swapperAddress, false, false],
+    ["9iFER3bpjf1PTTCQCfTRu17EJgvsxo9pVyA9QWwEuX4x", false, false],
+    [SOLANA_RAYDIUM_CLMM_POOL, false, true],
+    [associatedTokenAddress(swapperAddress, route.sourceTokenAddress, false), false, true],
+    [associatedTokenAddress(swapperAddress, route.sourceUsdcAddress, false), false, true],
+    ["GFwsANMCPK8W3WhqTnwVP8JiwHaAr3cNDe5TJqgHHSPe", false, true],
+    ["ECw2X1TYbsrqFgdiYApNpn2ggznbj8pL5tREpY9Fb8jY", false, true],
+    ["2UQncszfVU7igwDiGN3jq2sUKzziLxDZqNsJEXzEob5x", false, true],
+    [SOLANA_TOKEN_PROGRAM, false, false],
+    ["BVvv13QAQjPYKTWrpX7wQbhBAu3pbWwTb8P9SAqgRNKQ", false, true],
+    ["4HSR9WBSHgw7n5V8WGYYhLW8g92RPSrgnf2CHzbeQrrr", false, true],
+    ["HssFpWsQcNbJXBro1NVWCFAYEh8jp6NJV2nyFhE1zMGj", false, true],
+    ["DKcmVcrXuiF5FZre6h8GqurR2sKChUGBakxdTX7dSDw9", false, true],
+    [SOLANA_JUPITER_V6, false, false]
+  ];
+  const expectedPool = label === "Whirlpool" ? SOLANA_WHIRLPOOL_POOL : SOLANA_RAYDIUM_CLMM_POOL;
+  if (instruction.accounts.length !== expectedAccountCount || expectedAccounts.length !== instruction.accounts.length) throw new Error("jupiter");
+  for (const [index, [pubkey, isSigner, isWritable]] of expectedAccounts.entries()) {
+    assertAccount(accountAt(instruction, index), pubkey, isSigner, isWritable);
+  }
+  if (typeof swapInfoRecord.ammKey !== "string" || swapInfoRecord.ammKey !== expectedPool) throw new Error("jupiter");
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const inputAmount = view.getBigUint64(8, true);
+  const quotedOutput = view.getBigUint64(16, true);
+  const slippageBps = view.getUint16(24, true);
+  const platformBps = view.getUint16(26, true);
+  if (inputAmount !== uint64(quote.amountIn, true) || quotedOutput < uint64(minimumIntermediateAmount, true) || platformBps !== 0 || slippageBps > 1e4) throw new Error("jupiter");
+};
+var wrapInCpiProxy = (instruction) => ({
+  programId: SOLANA_CPI_PROXY_PROGRAM,
+  accounts: [
+    { pubkey: instruction.programId, isSigner: false, isWritable: false },
+    ...instruction.accounts
+  ],
+  dataBase64: instruction.dataBase64
+});
+var makeAtaInstruction = (swapperAddress, owner, mint, allowOwnerOffCurve) => ({
+  programId: SOLANA_ASSOCIATED_TOKEN_PROGRAM,
+  accounts: [
+    { pubkey: swapperAddress, isSigner: true, isWritable: true },
+    { pubkey: associatedTokenAddress(owner, mint, allowOwnerOffCurve), isSigner: false, isWritable: true },
+    { pubkey: owner, isSigner: false, isWritable: false },
+    { pubkey: mint, isSigner: false, isWritable: false },
+    { pubkey: SOLANA_SYSTEM_PROGRAM, isSigner: false, isWritable: false },
+    { pubkey: SOLANA_TOKEN_PROGRAM, isSigner: false, isWritable: false },
+    { pubkey: SOLANA_SYSVAR_RENT, isSigner: false, isWritable: false }
+  ],
+  dataBase64: "AQ=="
+});
+var makeSplTransferInstruction = (source, destination, owner, amount) => ({
+  programId: SOLANA_TOKEN_PROGRAM,
+  accounts: [
+    { pubkey: source, isSigner: false, isWritable: true },
+    { pubkey: destination, isSigner: false, isWritable: true },
+    { pubkey: owner, isSigner: true, isWritable: false }
+  ],
+  dataBase64: Buffer.from(Uint8Array.from([3, ...writeUint64Le(amount)])).toString("base64")
+});
+var makeComputeUnitPriceInstruction = (microLamports) => ({
+  programId: SOLANA_COMPUTE_BUDGET_PROGRAM,
+  accounts: [],
+  dataBase64: Buffer.from(Uint8Array.from([3, ...writeUint64Le(microLamports)])).toString("base64")
+});
+var makeSwiftInitInstruction = (quote, route, swapperAddress, destinationAddress, stateAddress, stateTokenAccount, minimumIntermediateAmount, cancelFee, refundFee, submitFee, mode, orderNonce) => {
+  const relayerAccount = associatedTokenAddress(swapperAddress, route.sourceUsdcAddress, false);
+  const data = new Uint8Array(198);
+  data.set(hexToBytes(`0x${SOLANA_INIT_ORDER_DISCRIMINATOR}`), 0);
+  data.set(writeUint64Le(uint64(minimumIntermediateAmount, true)), 8);
+  data[16] = 0;
+  data.set(writeUint64Le(submitFee), 17);
+  data.set(nativeAddressBytes(destinationAddress, route.destinationChainId), 25);
+  data.set(writeUint16Le(route.destinationWormholeChainId), 57);
+  data.set(nativeAddressBytes(route.destinationTokenAddress, route.destinationChainId), 59);
+  data.set(writeUint64Le(uint64(quote.minimumAmountOut, true)), 91);
+  data.set(writeUint64Le(0n), 99);
+  data.set(writeUint64Le(cancelFee), 107);
+  data.set(writeUint64Le(refundFee), 115);
+  data.set(writeUint64Le(uint64(quote.deadline, true)), 123);
+  data.set(zero32(), 131);
+  data[163] = 0;
+  data[164] = 0;
+  data[165] = mode;
+  data.set(swiftRandom(quote.quoteId, orderNonce), 166);
+  const accounts = [
+    { pubkey: swapperAddress, isSigner: false, isWritable: false },
+    { pubkey: swapperAddress, isSigner: true, isWritable: true },
+    { pubkey: stateAddress, isSigner: false, isWritable: true },
+    { pubkey: stateTokenAccount, isSigner: false, isWritable: true },
+    { pubkey: relayerAccount, isSigner: false, isWritable: true },
+    { pubkey: SOLANA_SWIFT_PROGRAM, isSigner: false, isWritable: false },
+    { pubkey: route.sourceUsdcAddress, isSigner: false, isWritable: false },
+    { pubkey: SOLANA_FEE_MANAGER_PROGRAM, isSigner: false, isWritable: false },
+    { pubkey: SOLANA_TOKEN_PROGRAM, isSigner: false, isWritable: false },
+    { pubkey: SOLANA_SYSTEM_PROGRAM, isSigner: false, isWritable: false }
+  ];
+  return {
+    programId: SOLANA_SWIFT_PROGRAM,
+    accounts,
+    dataBase64: Buffer.from(data).toString("base64")
+  };
+};
+var encodeShortVec = (value) => {
+  if (!Number.isSafeInteger(value) || value < 0 || value > 65535) throw new Error("shortvec");
+  const bytes = [];
+  let current = value;
+  do {
+    let element = current & 127;
+    current >>>= 7;
+    if (current !== 0) element |= 128;
+    bytes.push(element);
+  } while (current !== 0);
+  return Uint8Array.from(bytes);
+};
+var compileSolanaV0 = (payer, recentBlockhash, instructions, lookupTables) => {
+  const keyMeta = /* @__PURE__ */ new Map();
+  const getOrInsert = (address) => {
+    const existing = keyMeta.get(address);
+    if (existing) return existing;
+    const value = { signer: false, writable: false, invoked: false };
+    keyMeta.set(address, value);
+    return value;
+  };
+  const payerMeta = getOrInsert(payer);
+  payerMeta.signer = true;
+  payerMeta.writable = true;
+  for (const instruction of instructions) {
+    getOrInsert(instruction.programId).invoked = true;
+    for (const account of instruction.accounts) {
+      const meta = getOrInsert(account.pubkey);
+      meta.signer ||= account.isSigner;
+      meta.writable ||= account.isWritable;
+    }
+  }
+  const lookupTableLookups = [];
+  const writableLookupKeys = [];
+  const readonlyLookupKeys = [];
+  for (const table of lookupTables) {
+    const writableIndexes = [];
+    const readonlyIndexes = [];
+    for (const [address, meta] of [...keyMeta.entries()]) {
+      if (meta.signer || meta.invoked || !meta.writable) continue;
+      const index = table.addresses.indexOf(address);
+      if (index >= 0) {
+        if (index > 255) throw new Error("ALT index");
+        writableIndexes.push(index);
+        writableLookupKeys.push(address);
+        keyMeta.delete(address);
+      }
+    }
+    for (const [address, meta] of [...keyMeta.entries()]) {
+      if (meta.signer || meta.invoked || meta.writable) continue;
+      const index = table.addresses.indexOf(address);
+      if (index >= 0) {
+        if (index > 255) throw new Error("ALT index");
+        readonlyIndexes.push(index);
+        readonlyLookupKeys.push(address);
+        keyMeta.delete(address);
+      }
+    }
+    if (writableIndexes.length > 0 || readonlyIndexes.length > 0) {
+      lookupTableLookups.push({ accountKey: table.address, writableIndexes, readonlyIndexes });
+    }
+  }
+  if (keyMeta.size > 256 || lookupTableLookups.length > MAX_LOOKUP_TABLES) throw new Error("account keys");
+  const entries = [...keyMeta.entries()];
+  const writableSigners = entries.filter(([, meta]) => meta.signer && meta.writable);
+  const readonlySigners = entries.filter(([, meta]) => meta.signer && !meta.writable);
+  const writableNonSigners = entries.filter(([, meta]) => !meta.signer && meta.writable);
+  const readonlyNonSigners = entries.filter(([, meta]) => !meta.signer && !meta.writable);
+  if (writableSigners.length !== 1 || readonlySigners.length !== 0 || writableSigners[0]?.[0] !== payer) throw new Error("payer");
+  const staticKeys = [
+    ...writableSigners.map(([address]) => address),
+    ...readonlySigners.map(([address]) => address),
+    ...writableNonSigners.map(([address]) => address),
+    ...readonlyNonSigners.map(([address]) => address)
+  ];
+  const allKeys = [...staticKeys, ...writableLookupKeys, ...readonlyLookupKeys];
+  if (allKeys.length > 256) throw new Error("account index");
+  const keyIndexes = new Map(allKeys.map((address, index) => [address, index]));
+  const compiled = instructions.map((instruction) => {
+    const programIdIndex = keyIndexes.get(instruction.programId);
+    if (programIdIndex === void 0) throw new Error("program index");
+    const accountKeyIndexes = instruction.accounts.map((account) => {
+      const index = keyIndexes.get(account.pubkey);
+      if (index === void 0) throw new Error("account index");
+      return index;
+    });
+    return { programIdIndex, accountKeyIndexes, data: encodeInstructionData(instruction.dataBase64) };
+  });
+  const header = Uint8Array.from([
+    writableSigners.length + readonlySigners.length,
+    readonlySigners.length,
+    readonlyNonSigners.length
+  ]);
+  const compiledInstructionBytes = concatBytes(
+    encodeShortVec(compiled.length),
+    ...compiled.map((instruction) => concatBytes(
+      Uint8Array.from([instruction.programIdIndex]),
+      encodeShortVec(instruction.accountKeyIndexes.length),
+      Uint8Array.from(instruction.accountKeyIndexes),
+      encodeShortVec(instruction.data.length),
+      instruction.data
+    ))
+  );
+  const lookupBytes = concatBytes(
+    encodeShortVec(lookupTableLookups.length),
+    ...lookupTableLookups.map((lookup) => concatBytes(
+      base58Decode(lookup.accountKey),
+      encodeShortVec(lookup.writableIndexes.length),
+      Uint8Array.from(lookup.writableIndexes),
+      encodeShortVec(lookup.readonlyIndexes.length),
+      Uint8Array.from(lookup.readonlyIndexes)
+    ))
+  );
+  const message = concatBytes(
+    Uint8Array.from([128]),
+    header,
+    encodeShortVec(staticKeys.length),
+    ...staticKeys.map((address) => base58Decode(address)),
+    base58Decode(canonicalSolanaAddress(recentBlockhash)),
+    compiledInstructionBytes,
+    lookupBytes
+  );
+  const requiredSignatures = writableSigners.length + readonlySigners.length;
+  const transaction = concatBytes(
+    encodeShortVec(requiredSignatures),
+    new Uint8Array(requiredSignatures * 64),
+    message
+  );
+  if (transaction.length > MAX_SOLANA_TRANSACTION_BYTES) throw new Error("transaction size");
+  return {
+    transactionBase64: Buffer.from(transaction).toString("base64"),
+    lookupTableLookups
+  };
+};
+var validateSourceSwapEnvelope = (quote, route, raw, stateAddress, stateTokenAccount, swapperAddress, minimumIntermediateAmount) => {
+  const direct = sourceIsUsdc(route);
+  if (direct) throw new Error("direct source swap");
+  if (route.sourceChainId === ETHEREUM_CHAIN_ID) {
+    if (Object.keys(raw).sort().join(",") !== "swapRouterAddress,swapRouterCalldata") throw new Error("source swap");
+    const routerAddress = normalizeEvmAddress3(raw.swapRouterAddress);
+    if (quote.sourceSwap.routerAddress !== routerAddress || quote.sourceSwap.routerKind !== "provider-selected-evm") throw new Error("source swap");
+    if (typeof raw.swapRouterCalldata !== "string" || !HEX_BYTES2.test(raw.swapRouterCalldata) || raw.swapRouterCalldata === "0x" || !raw.swapRouterCalldata.toLowerCase().startsWith(EVM_SOURCE_SWAP_SELECTOR) || hexToBytes(raw.swapRouterCalldata).length > MAX_ROUTER_CALLDATA_BYTES) throw new Error("source swap");
+    return {
+      kind: "evm-router",
+      routerAddress,
+      calldata: raw.swapRouterCalldata.toLowerCase(),
+      rawResponseSha256: "",
+      rawProviderSourceSwapJson: ""
+    };
+  }
+  if (Object.hasOwn(raw, "tokenLedgerInstruction") && raw.tokenLedgerInstruction !== null) throw new Error("source swap");
+  if (!Array.isArray(raw.computeBudgetInstructions) || !Array.isArray(raw.setupInstructions) || raw.swapInstruction === void 0 || raw.swapInstruction === null) throw new Error("source swap");
+  if (raw.cleanupInstruction !== null && raw.cleanupInstruction !== void 0) throw new Error("source swap");
+  if (!Array.isArray(raw.otherInstructions) || raw.otherInstructions.length !== 0) throw new Error("source swap");
+  if (raw.simulationError !== null && raw.simulationError !== void 0) throw new Error("source swap");
+  if (raw.separateSwapTx !== void 0 && raw.separateSwapTx !== false) throw new Error("source swap");
+  if (raw.jito !== void 0 && raw.jito !== false && raw.jito !== null) throw new Error("source swap");
+  const compute = raw.computeBudgetInstructions.map(instructionFromRaw);
+  const setup = raw.setupInstructions.map(instructionFromRaw);
+  const swap = instructionFromRaw(raw.swapInstruction);
+  validateComputeInstructions(compute);
+  validateAtaSetup(setup, swapperAddress, stateAddress, route.sourceUsdcAddress);
+  validateJupiterInstruction(swap, route, quote, stateTokenAccount, swapperAddress, minimumIntermediateAmount, raw);
+  const providerAlts = raw.addressLookupTableAddresses;
+  if (!Array.isArray(providerAlts) || providerAlts.length > MAX_LOOKUP_TABLES || providerAlts.some((address) => {
+    try {
+      canonicalSolanaAddress(address);
+      return false;
+    } catch {
+      return true;
+    }
+  })) throw new Error("source swap");
+  const addressLookupTableAddresses = providerAlts;
+  if (raw.prioritizationFeeLamports !== void 0 && (typeof raw.prioritizationFeeLamports !== "number" || !Number.isSafeInteger(raw.prioritizationFeeLamports) || raw.prioritizationFeeLamports < 0)) throw new Error("source swap");
+  if (raw.computeUnitLimit !== void 0 && (typeof raw.computeUnitLimit !== "number" || !Number.isSafeInteger(raw.computeUnitLimit) || raw.computeUnitLimit > 14e5)) throw new Error("source swap");
+  return {
+    kind: "solana-jupiter-v6",
+    instructions: [...compute, ...setup, swap],
+    addressLookupTableAddresses,
+    rawResponseSha256: "",
+    rawProviderSourceSwapJson: ""
+  };
+};
+var preparePlan = (context, runtime, options) => {
+  const snapshot = cloneJson(context);
+  return (async () => {
+    const context2 = {
+      ...snapshot,
+      quote: runtime.validateQuote(snapshot.quote, "BRIDGE_LOCAL_PLAN_INVALID")
+    };
+    let route;
+    let rawQuote;
+    let swapperAddress;
+    let destinationAddress;
+    let orderNonce;
+    try {
+      if (context2 === null || typeof context2 !== "object" || Array.isArray(context2)) throw new Error("context");
+      const keys = Object.keys(context2).sort().join(",");
+      if (keys !== "destinationAddress,orderNonce,quote,swapperAddress") throw new Error("context");
+      route = validateLocalRoute(context2.quote);
+      rawQuote = parseSourceQuote(context2.quote, route);
+      swapperAddress = route.sourceChainId === ETHEREUM_CHAIN_ID ? normalizeEvmAddress3(context2.swapperAddress) : canonicalSolanaAddress(context2.swapperAddress);
+      destinationAddress = route.destinationChainId === ETHEREUM_CHAIN_ID ? normalizeEvmAddress3(context2.destinationAddress) : canonicalSolanaAddress(context2.destinationAddress);
+      orderNonce = context2.orderNonce;
+      if (typeof orderNonce !== "string" || !NONCE.test(orderNonce)) throw new Error("nonce");
+      validateDestinationMinimumCompatibility(context2.quote.rawSignedQuoteJson, context2.quote.minimumAmountOut);
+      if (Math.floor(Date.now() / 1e3) + runtime.minimumQuoteValiditySeconds > Number(uint64(context2.quote.deadline, true))) runtime.fail("BRIDGE_QUOTE_EXPIRED");
+    } catch (error) {
+      if (error instanceof Error && error.name === "BridgeError") throw error;
+      runtime.fail("BRIDGE_LOCAL_PLAN_INVALID");
+    }
+    const rawQuoteSha256 = sha256Hex(context2.quote.rawSignedQuoteJson);
+    const orderHash = hashOrder(context2.quote, route, swapperAddress, destinationAddress, orderNonce, rawQuote.minimumIntermediateAmount, rawQuote.cancelFee, rawQuote.refundFee, rawQuote.mode);
+    const binding = quoteBindingHash(route, context2.quote, rawQuoteSha256, orderNonce, swapperAddress, destinationAddress);
+    let sourceSwap;
+    if (sourceIsUsdc(route)) {
+      sourceSwap = { kind: "none" };
+    } else {
+      const endpoint = endpointUrl(runtime.localBuild?.sourceSwapEndpoint);
+      const sourceChain = route.sourceChainId === ETHEREUM_CHAIN_ID ? "evm" : "solana";
+      let url;
+      if (sourceChain === "evm") {
+        url = sourceSwapUrl(endpoint, sourceChain, [
+          ["forwarderAddress", ETHEREUM_FORWARDER_PROVIDER],
+          ["slippageBps", context2.quote.slippageBps],
+          ["fromToken", String(rawQuote.raw.fromToken.contract)],
+          ["middleToken", route.sourceUsdcAddress],
+          ["chainName", route.sourceProviderChainName],
+          ["amountIn64", context2.quote.amountIn],
+          ["sdkVersion", MAYAN_ORACLE_SDK_VERSION]
+        ]);
+      } else {
+        const state = findProgramAddress([
+          new TextEncoder().encode("STATE_SOURCE"),
+          hexToBytes(orderHash),
+          writeUint16Le(2)
+        ], SOLANA_SWIFT_PROGRAM);
+        const sourceMinimum = extractRawNumberLexeme(context2.quote.rawSignedQuoteJson, "minMiddleAmount");
+        url = sourceSwapUrl(endpoint, sourceChain, [
+          ["minMiddleAmount", Number(sourceMinimum)],
+          ["middleToken", route.sourceUsdcAddress],
+          ["userWallet", swapperAddress],
+          ["slippageBps", context2.quote.slippageBps],
+          ["fromToken", route.sourceTokenAddress],
+          ["amountIn64", context2.quote.amountIn],
+          ["depositMode", "SWIFT"],
+          ["fillMaxAccounts", false],
+          ["chainName", route.sourceProviderChainName],
+          ["userLedger", state.address],
+          ["sdkVersion", MAYAN_ORACLE_SDK_VERSION]
+        ]);
+      }
+      try {
+        const response = await fetchSourceSwap(runtime, url, options);
+        const state = route.sourceChainId === SOLANA_CHAIN_ID ? findProgramAddress([new TextEncoder().encode("STATE_SOURCE"), hexToBytes(orderHash), writeUint16Le(2)], SOLANA_SWIFT_PROGRAM).address : "";
+        const stateTokenAccount = route.sourceChainId === SOLANA_CHAIN_ID ? associatedTokenAddress(state, route.sourceUsdcAddress, true) : "";
+        sourceSwap = validateSourceSwapEnvelope(context2.quote, route, response.root, state, stateTokenAccount, swapperAddress, rawQuote.minimumIntermediateAmount);
+        if (sourceSwap.kind === "none") throw new Error("source swap");
+        sourceSwap = {
+          ...sourceSwap,
+          rawResponseSha256: sha256Hex(response.text),
+          rawProviderSourceSwapJson: response.text
+        };
+      } catch (error) {
+        if (error instanceof Error && error.name === "BridgeError") throw error;
+        runtime.fail("BRIDGE_LOCAL_PLAN_INVALID");
+      }
+    }
+    const plan = {
+      planKind: "mayan-swift-v2-local-source-swap",
+      providerId: "mayan-swift-v2",
+      capabilityId: route.bridgeCapabilityId,
+      sourceChainId: route.sourceChainId,
+      destinationChainId: route.destinationChainId,
+      sourceTokenDeploymentId: route.sourceTokenDeploymentId,
+      destinationTokenDeploymentId: route.destinationTokenDeploymentId,
+      quoteId: context2.quote.quoteId,
+      rawQuoteSha256,
+      orderNonce,
+      swapperAddress,
+      destinationAddress,
+      orderHash,
+      quoteBindingHash: binding,
+      minimumIntermediateAmount: rawQuote.minimumIntermediateAmount,
+      sourceSwap,
+      planHash: planHash(binding, sourceSwap)
+    };
+    return plan;
+  })();
+};
+var sourceRpcError = (runtime, error) => {
+  if (error instanceof Error && error.name === "BridgeError") throw error;
+  if (error instanceof ErpcInvalidResponseError || error instanceof ErpcJsonRpcError) {
+    return runtime.fail("BRIDGE_SOURCE_RPC_INVALID_RESPONSE");
+  }
+  if (error instanceof ErpcAbortedError) return runtime.fail("BRIDGE_ABORTED");
+  if (error instanceof ErpcTimeoutError) return runtime.fail("BRIDGE_TIMEOUT");
+  if (error instanceof ErpcHttpError || error instanceof ErpcTransportError) {
+    return runtime.fail("BRIDGE_SOURCE_RPC_TRANSPORT");
+  }
+  if (error instanceof ErpcConfigError) return runtime.fail("BRIDGE_LOCAL_BUILD_INVALID");
+  return runtime.fail("BRIDGE_SOURCE_RPC_INVALID_RESPONSE");
+};
+var directRpc = (endpoint, runtime, code, chain) => {
+  if (endpoint === void 0 || endpoint === null) runtime.fail(code);
+  if (endpoint === null || typeof endpoint !== "object" || Array.isArray(endpoint)) runtime.fail("BRIDGE_LOCAL_BUILD_INVALID");
+  const rpcFetch = async (input, init) => {
+    const requestBody = init?.body;
+    if (typeof requestBody !== "string") return runtime.fetch(input, init);
+    let request;
+    try {
+      const parsed2 = JSON.parse(requestBody);
+      if (parsed2 === null || typeof parsed2 !== "object" || Array.isArray(parsed2)) return runtime.fetch(input, init);
+      request = parsed2;
+    } catch {
+      return runtime.fetch(input, init);
+    }
+    const requestId = request.id;
+    request.id = 1;
+    const response = await runtime.fetch(input, { ...init, body: JSON.stringify(request) });
+    let responseBody;
+    try {
+      const signal = init?.signal ?? new AbortController().signal;
+      responseBody = await readSourceResponseText(response, signal);
+    } catch (error) {
+      if (error instanceof SourceResponseInvalidError) {
+        return new Response("null", {
+          status: response.status,
+          statusText: response.statusText,
+          headers: response.headers
+        });
+      }
+      throw error;
+    }
+    if (!response.ok) {
+      return new Response(responseBody, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      });
+    }
+    let parsed;
+    try {
+      parsed = parseJsonObject(responseBody);
+    } catch {
+      return new Response("null", {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      });
+    }
+    if (parsed.jsonrpc !== "2.0" || typeof parsed.id !== "number" || !Number.isSafeInteger(parsed.id) || parsed.id !== 1) {
+      return new Response("null", {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      });
+    }
+    parsed.id = requestId;
+    responseBody = JSON.stringify(parsed);
+    return new Response(responseBody, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  };
+  return createErpcClient({
+    ...chain === "ethereum" ? { ethereumRpc: endpoint } : { solanaRpc: endpoint },
+    fetch: rpcFetch,
+    timeoutMs: runtime.timeoutMs
+  });
+};
+var parseRpcAccount = (value) => {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("account");
+  const account = value;
+  if (!Array.isArray(account.data) || account.data.length !== 2 || typeof account.data[0] !== "string" || account.data[1] !== "base64" || typeof account.owner !== "string" || account.executable !== false) throw new Error("account");
+  const data = base64Decode(account.data[0], 16384);
+  return { data, owner: canonicalSolanaAddress(account.owner) };
+};
+var decodeLookupTable = (address, account, accountContextSlot) => {
+  if (account.owner !== SOLANA_ADDRESS_LOOKUP_TABLE_OWNER || account.data.length < 56 || (account.data.length - 56) % 32 !== 0) throw new Error("ALT");
+  const view = new DataView(account.data.buffer, account.data.byteOffset, account.data.byteLength);
+  if (view.getUint32(0, true) !== 1) throw new Error("ALT");
+  const deactivationSlot = view.getBigUint64(4, true);
+  if (deactivationSlot !== UINT64_MAX) throw new Error("ALT");
+  const lastExtendedSlot = view.getBigUint64(12, true);
+  if (lastExtendedSlot > BigInt(accountContextSlot)) throw new Error("ALT");
+  const lastExtendedStartIndex = account.data[20];
+  const authorityOption = account.data[21];
+  if (lastExtendedStartIndex === void 0 || authorityOption === void 0 || authorityOption !== 0 && authorityOption !== 1) throw new Error("ALT");
+  for (let index = 54; index < 56; index += 1) {
+    if (account.data[index] !== 0) throw new Error("ALT");
+  }
+  if (authorityOption === 0) {
+    for (let index = 22; index < 54; index += 1) {
+      if (account.data[index] !== 0) throw new Error("ALT");
+    }
+  }
+  const addresses = [];
+  for (let offset = 56; offset < account.data.length; offset += 32) addresses.push(base58Encode(account.data.slice(offset, offset + 32)));
+  if (addresses.length > MAX_LOOKUP_TABLE_ADDRESSES || lastExtendedStartIndex > addresses.length) throw new Error("ALT");
+  const activeCount = lastExtendedSlot === BigInt(accountContextSlot) ? lastExtendedStartIndex : addresses.length;
+  return { address, addresses: addresses.slice(0, activeCount) };
+};
+var fetchSourceRpc = async (route, plan, runtime, options) => {
+  const endpoint = route.sourceChainId === ETHEREUM_CHAIN_ID ? runtime.localBuild?.ethereumRpc : runtime.localBuild?.solanaRpc;
+  let erpc;
+  try {
+    erpc = directRpc(endpoint, runtime, "BRIDGE_LOCAL_RPC_REQUIRED", route.sourceChainId === ETHEREUM_CHAIN_ID ? "ethereum" : "solana");
+  } catch (error) {
+    return sourceRpcError(runtime, error);
+  }
+  const rpcOptions = options?.signal === void 0 ? void 0 : { signal: options.signal };
+  try {
+    if (route.sourceChainId === ETHEREUM_CHAIN_ID) {
+      const rpcChainId = await erpc.ethereum.rpc.eth_chainId().send(rpcOptions);
+      if (rpcChainId.toLowerCase() !== "0x1") throw new Error("chain");
+      const codeAddresses = [ETHEREUM_FORWARDER, route.swiftContract];
+      if (plan.sourceSwap.kind === "evm-router") codeAddresses.push(plan.sourceSwap.routerAddress);
+      const code = [];
+      for (const address of codeAddresses) {
+        const bytecode = await erpc.ethereum.rpc.eth_getCode(address, "latest").send(rpcOptions);
+        if (typeof bytecode !== "string" || !HEX_BYTES2.test(bytecode) || bytecode === "0x") throw new Error("code");
+        code.push({ address: normalizeEvmAddress3(address), keccak256: `0x${keccakHex(hexToBytes(bytecode))}` });
+      }
+      return {
+        erpc,
+        evidence: { kind: "evm", rpcChainId: "0x1", code },
+        lookupTables: [],
+        recentBlockhash: null
+      };
+    }
+    const genesisHash = await erpc.solana.rpc.getGenesisHash().send(rpcOptions);
+    if (genesisHash !== SOLANA_MAINNET_GENESIS_HASH) throw new Error("genesis");
+    const blockhashResult = await erpc.solana.rpc.getLatestBlockhash({ commitment: "confirmed" }).send(rpcOptions);
+    if (blockhashResult === null || typeof blockhashResult !== "object" || Array.isArray(blockhashResult)) throw new Error("blockhash");
+    const blockhashWrapper = blockhashResult;
+    const blockhashContext = blockhashWrapper.context;
+    const blockhashValue = blockhashWrapper.value;
+    if (blockhashContext === null || typeof blockhashContext !== "object" || Array.isArray(blockhashContext) || blockhashValue === null || typeof blockhashValue !== "object" || Array.isArray(blockhashValue)) throw new Error("blockhash");
+    const blockhashSlot = blockhashContext.slot;
+    const recentBlockhash = blockhashValue.blockhash;
+    const lastValidBlockHeight = blockhashValue.lastValidBlockHeight;
+    if (typeof blockhashSlot !== "number" || !Number.isSafeInteger(blockhashSlot) || blockhashSlot < 0 || typeof recentBlockhash !== "string" || typeof lastValidBlockHeight !== "number" || !Number.isSafeInteger(lastValidBlockHeight) || lastValidBlockHeight < 0 || !canonicalSolanaAddress(recentBlockhash)) throw new Error("blockhash");
+    const providerAlts = plan.sourceSwap.kind === "solana-jupiter-v6" ? plan.sourceSwap.addressLookupTableAddresses : [];
+    const altAddresses = [.../* @__PURE__ */ new Set([SOLANA_MAYAN_LOOKUP_TABLE, ...providerAlts])];
+    if (altAddresses.length > MAX_LOOKUP_TABLES) throw new Error("ALT");
+    const accountsResult = await erpc.solana.rpc.getMultipleAccounts(
+      altAddresses,
+      { encoding: "base64", commitment: "confirmed", minContextSlot: blockhashSlot }
+    ).send(rpcOptions);
+    if (accountsResult === null || typeof accountsResult !== "object" || Array.isArray(accountsResult)) throw new Error("accounts");
+    const accountsWrapper = accountsResult;
+    const accountContext = accountsWrapper.context;
+    const accountValues = accountsWrapper.value;
+    if (accountContext === null || typeof accountContext !== "object" || Array.isArray(accountContext) || !Array.isArray(accountValues)) throw new Error("accounts");
+    const accountSlot = accountContext.slot;
+    if (typeof accountSlot !== "number" || !Number.isSafeInteger(accountSlot) || accountSlot < 0 || typeof blockhashSlot !== "number" || accountSlot < blockhashSlot || accountValues.length !== altAddresses.length) throw new Error("accounts");
+    const lookupTables = altAddresses.map((address, index) => decodeLookupTable(address, parseRpcAccount(accountValues[index]), accountSlot));
+    return {
+      erpc,
+      evidence: {
+        kind: "solana",
+        genesisHash,
+        blockhashContextSlot: String(blockhashSlot),
+        accountContextSlot: String(accountSlot),
+        recentBlockhash,
+        lastValidBlockHeight: String(lastValidBlockHeight),
+        lookupTables: lookupTables.map((table) => ({ address: table.address, dataSha256: sha256Hex(parseRpcAccount(accountValues[altAddresses.indexOf(table.address)]).data) }))
+      },
+      lookupTables,
+      recentBlockhash
+    };
+  } catch (error) {
+    erpc.close();
+    return sourceRpcError(runtime, error);
+  }
+};
+var exactKeys = (value, expected) => {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const actual = Object.keys(value).sort();
+  const wanted = [...expected].sort();
+  return actual.length === wanted.length && actual.every((key, index) => key === wanted[index]);
+};
+var validatePlan = (request, route, rawQuote, plan, rawQuoteSha256, orderHash, binding, swapperAddress, destinationAddress) => {
+  if (!exactKeys(plan, [
+    "planKind",
+    "providerId",
+    "capabilityId",
+    "sourceChainId",
+    "destinationChainId",
+    "sourceTokenDeploymentId",
+    "destinationTokenDeploymentId",
+    "quoteId",
+    "rawQuoteSha256",
+    "orderNonce",
+    "swapperAddress",
+    "destinationAddress",
+    "orderHash",
+    "quoteBindingHash",
+    "minimumIntermediateAmount",
+    "sourceSwap",
+    "planHash"
+  ])) throw new Error("plan");
+  if (plan.planKind !== "mayan-swift-v2-local-source-swap" || plan.providerId !== "mayan-swift-v2" || plan.capabilityId !== route.bridgeCapabilityId || plan.sourceChainId !== route.sourceChainId || plan.destinationChainId !== route.destinationChainId || plan.sourceTokenDeploymentId !== route.sourceTokenDeploymentId || plan.destinationTokenDeploymentId !== route.destinationTokenDeploymentId || plan.quoteId !== request.quote.quoteId || plan.rawQuoteSha256 !== rawQuoteSha256 || plan.orderNonce !== request.orderNonce || plan.swapperAddress !== swapperAddress || plan.destinationAddress !== destinationAddress || plan.orderHash !== orderHash || plan.quoteBindingHash !== binding || plan.minimumIntermediateAmount !== rawQuote.minimumIntermediateAmount) throw new Error("plan");
+  let normalizedSwap;
+  if (sourceIsUsdc(route)) {
+    if (!exactKeys(plan.sourceSwap, ["kind"]) || plan.sourceSwap.kind !== "none") throw new Error("plan");
+    normalizedSwap = { kind: "none" };
+  } else {
+    const state = route.sourceChainId === SOLANA_CHAIN_ID ? findProgramAddress([new TextEncoder().encode("STATE_SOURCE"), hexToBytes(orderHash), writeUint16Le(2)], SOLANA_SWIFT_PROGRAM).address : "";
+    const stateTokenAccount = route.sourceChainId === SOLANA_CHAIN_ID ? associatedTokenAddress(state, route.sourceUsdcAddress, true) : "";
+    if (plan.sourceSwap.kind === "none") throw new Error("plan");
+    const sourceRaw = parseJsonObject(plan.sourceSwap.rawProviderSourceSwapJson);
+    if (plan.sourceSwap.rawResponseSha256 !== sha256Hex(plan.sourceSwap.rawProviderSourceSwapJson)) throw new Error("plan");
+    const expected = validateSourceSwapEnvelope(request.quote, route, sourceRaw, state, stateTokenAccount, swapperAddress, rawQuote.minimumIntermediateAmount);
+    if (stableJson(expected) !== stableJson({ ...plan.sourceSwap, rawResponseSha256: "", rawProviderSourceSwapJson: "" })) throw new Error("plan");
+    normalizedSwap = plan.sourceSwap;
+  }
+  if (plan.planHash !== planHash(binding, normalizedSwap)) throw new Error("plan");
+  return plan;
+};
+var localBuildDependencies = (route) => [
+  ...route.dependencies.filter((dependency) => dependency !== "mayan-hosted-transaction-builder"),
+  route.sourceChainId === ETHEREUM_CHAIN_ID ? "configured-ethereum-rpc" : "configured-solana-rpc"
+];
+var buildEvmOrderCall = (quote, route, plan, swapperAddress, destinationAddress, minimumIntermediateAmount, cancelFee, refundFee, mode, orderNonce) => {
+  const orderWords = [
+    wordUint(1n),
+    wordBytes32(nativeAddressBytes(swapperAddress, route.sourceChainId)),
+    wordBytes32(nativeAddressBytes(destinationAddress, route.destinationChainId)),
+    wordUint(BigInt(route.destinationWormholeChainId)),
+    wordBytes32(zero32()),
+    wordBytes32(nativeAddressBytes(route.destinationTokenAddress, route.destinationChainId)),
+    wordUint(uint64(quote.minimumAmountOut, true)),
+    wordUint(0n),
+    wordUint(cancelFee),
+    wordUint(refundFee),
+    wordUint(uint64(quote.deadline, true)),
+    wordUint(0n),
+    wordUint(BigInt(mode)),
+    wordBytes32(swiftRandom(quote.quoteId, orderNonce))
+  ];
+  const swiftCallData = `0xa3a30834${bytesToHex(encodeAbiWithDynamics([
+    wordAddress(route.sourceUsdcAddress),
+    wordUint(uint64(quote.amountIn, true)),
+    ...orderWords
+  ], [new Uint8Array()]))}`;
+  if (plan.sourceSwap.kind === "none") {
+    return `0xe4269fc4${bytesToHex(encodeAbiWithDynamics([
+      wordAddress(route.sourceUsdcAddress),
+      wordUint(uint64(quote.amountIn, true)),
+      ...[wordUint(0n), wordUint(0n), wordUint(0n), wordBytes32(zero32()), wordBytes32(zero32())],
+      wordAddress(route.swiftContract)
+    ], [hexToBytes(swiftCallData)]))}`;
+  }
+  if (plan.sourceSwap.kind !== "evm-router") throw new Error("plan");
+  const routerData = hexToBytes(plan.sourceSwap.calldata);
+  const routerOffset = 13 * 32;
+  const swiftOffset = routerOffset + 32 + Math.ceil(routerData.length / 32) * 32;
+  const head = [
+    wordAddress(route.sourceTokenAddress),
+    wordUint(uint64(quote.amountIn, true)),
+    wordUint(0n),
+    wordUint(0n),
+    wordUint(0n),
+    wordBytes32(zero32()),
+    wordBytes32(zero32()),
+    wordAddress(plan.sourceSwap.routerAddress),
+    wordUint(BigInt(routerOffset)),
+    wordAddress(route.sourceUsdcAddress),
+    wordUint(uint64(minimumIntermediateAmount, true)),
+    wordAddress(route.swiftContract),
+    wordUint(BigInt(swiftOffset))
+  ];
+  return `0x30dedc57${bytesToHex(concatBytes(
+    ...head,
+    encodeAbiBytes(routerData),
+    encodeAbiBytes(hexToBytes(swiftCallData))
+  ))}`;
+};
+var buildSolanaInstructions = (quote, route, plan, swapperAddress, destinationAddress, minimumIntermediateAmount, cancelFee, refundFee, submitFee, mode, orderNonce, raw) => {
+  const state = findProgramAddress([
+    new TextEncoder().encode("STATE_SOURCE"),
+    hexToBytes(hashOrder(quote, route, swapperAddress, destinationAddress, orderNonce, minimumIntermediateAmount, cancelFee, refundFee, mode)),
+    writeUint16Le(2)
+  ], SOLANA_SWIFT_PROGRAM).address;
+  const stateTokenAccount = associatedTokenAddress(state, route.sourceUsdcAddress, true);
+  const init = makeSwiftInitInstruction(
+    quote,
+    route,
+    swapperAddress,
+    destinationAddress,
+    state,
+    stateTokenAccount,
+    minimumIntermediateAmount,
+    cancelFee,
+    refundFee,
+    submitFee,
+    mode,
+    orderNonce
+  );
+  if (sourceIsUsdc(route)) {
+    const instructions = [];
+    const suggestedPriorityFee = raw.suggestedPriorityFee;
+    if (typeof suggestedPriorityFee === "number" && Number.isSafeInteger(suggestedPriorityFee) && suggestedPriorityFee > 0) {
+      if (suggestedPriorityFee > 1e5) throw new Error("compute");
+      instructions.push(makeComputeUnitPriceInstruction(BigInt(suggestedPriorityFee)));
+    }
+    instructions.push(wrapInCpiProxy(makeAtaInstruction(swapperAddress, state, route.sourceUsdcAddress, true)));
+    instructions.push(wrapInCpiProxy(makeSplTransferInstruction(
+      associatedTokenAddress(swapperAddress, route.sourceUsdcAddress, false),
+      stateTokenAccount,
+      swapperAddress,
+      uint64(quote.amountIn, true)
+    )));
+    instructions.push(wrapInCpiProxy(init));
+    return instructions;
+  }
+  if (plan.sourceSwap.kind !== "solana-jupiter-v6") throw new Error("plan");
+  const computeCount = plan.sourceSwap.instructions.filter((instruction) => instruction.programId === SOLANA_COMPUTE_BUDGET_PROGRAM).length;
+  const compute = plan.sourceSwap.instructions.slice(0, computeCount);
+  const remainder = plan.sourceSwap.instructions.slice(computeCount);
+  const swapIndex = remainder.findIndex((instruction) => instruction.programId === SOLANA_JUPITER_V6);
+  if (swapIndex < 1) throw new Error("source swap");
+  const setup = remainder.slice(0, swapIndex);
+  const swap = remainder[swapIndex];
+  if (!swap || remainder.slice(swapIndex + 1).length !== 0) throw new Error("source swap");
+  return [
+    ...compute,
+    ...setup.map(wrapInCpiProxy),
+    swap,
+    wrapInCpiProxy(init)
+  ];
+};
+var buildLocalPlan = (context, runtime, options) => {
+  const snapshot = cloneJson(context);
+  return (async () => {
+    const context2 = {
+      ...snapshot,
+      quote: runtime.validateQuote(snapshot.quote, "BRIDGE_LOCAL_BUILD_INVALID")
+    };
+    let route;
+    let rawQuote;
+    let swapperAddress;
+    let destinationAddress;
+    try {
+      if (context2 === null || typeof context2 !== "object" || Array.isArray(context2)) throw new Error("context");
+      const keys = Object.keys(context2).sort().join(",");
+      if (keys !== "destinationAddress,orderNonce,quote,sourceSwapPlan,swapperAddress") throw new Error("context");
+      route = validateLocalRoute(context2.quote);
+      rawQuote = parseSourceQuote(context2.quote, route);
+      swapperAddress = route.sourceChainId === ETHEREUM_CHAIN_ID ? normalizeEvmAddress3(context2.swapperAddress) : canonicalSolanaAddress(context2.swapperAddress);
+      destinationAddress = route.destinationChainId === ETHEREUM_CHAIN_ID ? normalizeEvmAddress3(context2.destinationAddress) : canonicalSolanaAddress(context2.destinationAddress);
+      if (typeof context2.orderNonce !== "string" || !NONCE.test(context2.orderNonce)) throw new Error("nonce");
+      validateDestinationMinimumCompatibility(context2.quote.rawSignedQuoteJson, context2.quote.minimumAmountOut);
+      if (Math.floor(Date.now() / 1e3) + runtime.minimumQuoteValiditySeconds > Number(uint64(context2.quote.deadline, true))) runtime.fail("BRIDGE_QUOTE_EXPIRED");
+    } catch (error) {
+      if (error instanceof Error && error.name === "BridgeError") throw error;
+      runtime.fail("BRIDGE_LOCAL_BUILD_INVALID");
+    }
+    const rawQuoteSha256 = sha256Hex(context2.quote.rawSignedQuoteJson);
+    const orderHash = hashOrder(context2.quote, route, swapperAddress, destinationAddress, context2.orderNonce, rawQuote.minimumIntermediateAmount, rawQuote.cancelFee, rawQuote.refundFee, rawQuote.mode);
+    const binding = quoteBindingHash(route, context2.quote, rawQuoteSha256, context2.orderNonce, swapperAddress, destinationAddress);
+    try {
+      const plan = validatePlan(context2, route, rawQuote, context2.sourceSwapPlan, rawQuoteSha256, orderHash, binding, swapperAddress, destinationAddress);
+      const rpc = await fetchSourceRpc(route, plan, runtime, options);
+      try {
+        let transaction;
+        if (route.sourceChainId === ETHEREUM_CHAIN_ID) {
+          const data = buildEvmOrderCall(context2.quote, route, plan, swapperAddress, destinationAddress, rawQuote.minimumIntermediateAmount, rawQuote.cancelFee, rawQuote.refundFee, rawQuote.mode, context2.orderNonce);
+          transaction = {
+            kind: "evm-unsigned-transaction",
+            chainId: ETHEREUM_CHAIN_ID,
+            from: swapperAddress,
+            to: ETHEREUM_FORWARDER,
+            data,
+            value: "0"
+          };
+        } else {
+          const instructions = buildSolanaInstructions(context2.quote, route, plan, swapperAddress, destinationAddress, rawQuote.minimumIntermediateAmount, rawQuote.cancelFee, rawQuote.refundFee, rawQuote.submitFee, rawQuote.mode, context2.orderNonce, rawQuote.raw);
+          if (rpc.recentBlockhash === null) throw new Error("blockhash");
+          const compiled = compileSolanaV0(swapperAddress, rpc.recentBlockhash, instructions, rpc.lookupTables);
+          transaction = {
+            kind: "solana-v0-unsigned-transaction",
+            chainId: SOLANA_CHAIN_ID,
+            feePayer: swapperAddress,
+            transactionBase64: compiled.transactionBase64
+          };
+        }
+        const allowance = route.sourceChainId === ETHEREUM_CHAIN_ID ? {
+          tokenDeploymentId: route.sourceTokenDeploymentId,
+          tokenAddress: route.sourceTokenAddress,
+          owner: swapperAddress,
+          spender: ETHEREUM_FORWARDER,
+          requiredAmount: context2.quote.amountIn
+        } : null;
+        return {
+          buildKind: "mayan-swift-v2-local-unsigned",
+          providerId: "mayan-swift-v2",
+          capabilityId: route.bridgeCapabilityId,
+          quote: cloneJson(context2.quote),
+          sourceChainId: route.sourceChainId,
+          destinationChainId: route.destinationChainId,
+          sourceSwapPlan: cloneJson(plan),
+          transaction,
+          allowance,
+          construction: {
+            mode: "local",
+            referenceCommit: MAYAN_REFERENCE_COMMIT,
+            orderNonce: context2.orderNonce,
+            orderHash,
+            minimumIntermediateAmount: rawQuote.minimumIntermediateAmount,
+            effectiveDependencies: localBuildDependencies(route),
+            sourceRpcEvidence: rpc.evidence
+          },
+          validation: {
+            level: "local-structural",
+            quoteSignatureLocallyVerified: false,
+            planBindingLocallyVerified: true,
+            transactionBytesLocallyConstructed: true,
+            settlementLocallyVerified: false
+          }
+        };
+      } finally {
+        rpc.erpc.close();
+      }
+    } catch (error) {
+      if (error instanceof Error && error.name === "BridgeError") throw error;
+      runtime.fail("BRIDGE_LOCAL_BUILD_INVALID");
+    }
+  })();
+};
+var prepareSourceSwap = (context, runtime, options) => preparePlan(context, runtime, options);
+var buildLocalUnsigned = (request, runtime, options) => buildLocalPlan(request, runtime, options);
 
 // src/bridge.ts
 var BRIDGE_ERROR_MESSAGES = Object.freeze({
@@ -5780,6 +7400,11 @@ var BRIDGE_ERROR_MESSAGES = Object.freeze({
   BRIDGE_QUOTE_EXPIRED: "Bridge quote is expired",
   BRIDGE_QUOTE_MISMATCH: "Bridge quote does not match the request",
   BRIDGE_BUILD_INVALID: "Bridge provider build is invalid",
+  BRIDGE_LOCAL_RPC_REQUIRED: "Bridge local source RPC is required",
+  BRIDGE_SOURCE_RPC_TRANSPORT: "Bridge source RPC transport failed",
+  BRIDGE_SOURCE_RPC_INVALID_RESPONSE: "Bridge source RPC response is invalid",
+  BRIDGE_LOCAL_PLAN_INVALID: "Bridge local source-swap plan is invalid",
+  BRIDGE_LOCAL_BUILD_INVALID: "Bridge local unsigned build is invalid",
   BRIDGE_STATUS_NOT_FOUND: "Bridge status was not found",
   BRIDGE_TIMEOUT: "Bridge provider request timed out",
   BRIDGE_ABORTED: "Bridge provider request was aborted"
@@ -5794,8 +7419,8 @@ var BridgeError = class extends Error {
     if (status !== void 0) this.status = status;
   }
 };
-var ETHEREUM_CHAIN_ID = TOKEN_CHAIN_IDS.ethereumMainnet;
-var SOLANA_CHAIN_ID = TOKEN_CHAIN_IDS.solanaMainnet;
+var ETHEREUM_CHAIN_ID2 = TOKEN_CHAIN_IDS.ethereumMainnet;
+var SOLANA_CHAIN_ID2 = TOKEN_CHAIN_IDS.solanaMainnet;
 var ETHEREUM_NAME = "ethereum";
 var SOLANA_NAME = "solana";
 var ETHEREUM_PROVIDER_CHAIN_ID = 1;
@@ -5811,26 +7436,28 @@ var SOLANA_EURC_ADDRESS = "HzwqbKZw8HxMN6bF2yFZNrht3c2iXXzpKcFu7uBEDKtr";
 var ETHEREUM_USDC_ADDRESS = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48";
 var SOLANA_USDC_ADDRESS = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
 var ETHEREUM_SWIFT_CONTRACT = "0x40ffe85a28dc9993541449464d7529a922142960";
-var SOLANA_SWIFT_PROGRAM = "mayan34VedncxdK2XobtvWFDXQASUTBXhUVzt2kKgny";
-var ETHEREUM_FORWARDER = "0x337685fdab40d39bd02028545a4ffa7d287cc3e2";
-var SOLANA_JUPITER_V6 = "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4";
-var ETHEREUM_FORWARDER_SELECTOR = "0x30dedc57";
+var SOLANA_SWIFT_PROGRAM2 = "mayan34VedncxdK2XobtvWFDXQASUTBXhUVzt2kKgny";
+var ETHEREUM_FORWARDER2 = "0x337685fdab40d39bd02028545a4ffa7d287cc3e2";
+var SOLANA_JUPITER_V62 = "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4";
+var ETHEREUM_EURC_FORWARDER_SELECTOR = "0x30dedc57";
+var ETHEREUM_USDC_FORWARDER_SELECTOR = "0xe4269fc4";
+var MAYAN_USDC_MINT = "A9mUU4qviSctJVPJdBJWkb28deg915LYJKrzQ19ji3FM";
 var DEFAULT_BUILDER_ENDPOINT = "https://tx-builder.mayan.finance";
 var DEFAULT_EXPLORER_ENDPOINT = "https://explorer-api.mayan.finance/v3";
 var DEFAULT_TIMEOUT_MS2 = 3e4;
-var MAX_RESPONSE_BYTES = 1024 * 1024;
+var MAX_RESPONSE_BYTES2 = 1024 * 1024;
 var MAX_RAW_QUOTE_BYTES = 256 * 1024;
-var MAX_JSON_DEPTH = 32;
+var MAX_JSON_DEPTH2 = 32;
 var MAX_QUOTES = 16;
-var UINT64_MAX = (1n << 64n) - 1n;
+var UINT64_MAX2 = (1n << 64n) - 1n;
 var CANONICAL_UINT64 = /^(0|[1-9][0-9]*)$/u;
 var POSITIVE_UINT64 = /^[1-9][0-9]*$/u;
-var EVM_ADDRESS2 = /^0x[0-9a-fA-F]{40}$/u;
+var EVM_ADDRESS3 = /^0x[0-9a-fA-F]{40}$/u;
 var EVM_HASH = /^0x[0-9a-fA-F]{64}$/u;
 var EVM_SIGNATURE = /^0x[0-9a-fA-F]{130}$/u;
-var HEX_BYTES2 = /^0x[0-9a-fA-F]*$/u;
+var HEX_BYTES3 = /^0x[0-9a-fA-F]*$/u;
 var BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u;
-var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var BASE58_ALPHABET2 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
 var DEPENDENCIES = Object.freeze([
   "mayan-hosted-quote-api",
   "mayan-hosted-transaction-builder",
@@ -5840,6 +7467,14 @@ var DEPENDENCIES = Object.freeze([
   "wormhole-guardian-messaging",
   "mayan-explorer-indexer"
 ]);
+var DIRECT_USDC_DEPENDENCIES = Object.freeze([
+  "mayan-hosted-quote-api",
+  "mayan-hosted-transaction-builder",
+  "swift-auction-solvers",
+  "relayers",
+  "wormhole-guardian-messaging",
+  "mayan-explorer-indexer"
+]);
 var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var deepFreeze6 = (value) => {
   if (value && typeof value === "object" && !Object.isFrozen(value)) {
@@ -5863,9 +7498,9 @@ var requireString = (value, code, nonempty = true) => {
   if (typeof value !== "string" || nonempty && value.length === 0) fail(code);
   return value;
 };
-var normalizeEvmAddress3 = (value, code) => {
+var normalizeEvmAddress4 = (value, code) => {
   const address = requireString(value, code);
-  if (!EVM_ADDRESS2.test(address) || /^0x0{40}$/iu.test(address)) fail(code);
+  if (!EVM_ADDRESS3.test(address) || /^0x0{40}$/iu.test(address)) fail(code);
   return address.toLowerCase();
 };
 var normalizePositiveUint64 = (value, code) => {
@@ -5878,7 +7513,7 @@ var normalizePositiveUint64 = (value, code) => {
     return fail(code);
   }
   const valueParsed = parsed;
-  if (valueParsed <= 0n || valueParsed > UINT64_MAX) fail(code);
+  if (valueParsed <= 0n || valueParsed > UINT64_MAX2) fail(code);
   return { source, value: valueParsed };
 };
 var normalizeCanonicalUint64 = (value, code) => {
@@ -5891,7 +7526,7 @@ var normalizeCanonicalUint64 = (value, code) => {
     return fail(code);
   }
   const valueParsed = parsed;
-  if (valueParsed > UINT64_MAX) fail(code);
+  if (valueParsed > UINT64_MAX2) fail(code);
   return { source, value: valueParsed };
 };
 var normalizeSlippage = (value, code) => {
@@ -5900,18 +7535,22 @@ var normalizeSlippage = (value, code) => {
   }
   return value;
 };
-var providerAddressEquals = (value, expected) => typeof value === "string" && (EVM_ADDRESS2.test(value) ? value.toLowerCase() === expected.toLowerCase() : value === expected);
-var catalogTokenMatches = (token, expected) => token?.deploymentId === expected.deploymentId && token.chainId === expected.chainId && token.address !== null && (expected.chainId === ETHEREUM_CHAIN_ID ? token.address.toLowerCase() === expected.address.toLowerCase() : token.address === expected.address) && token.standard === expected.standard && token.decimals === expected.decimals && token.status === "active";
-var directionFacts = (sourceChainId, destinationChainId) => {
-  if (sourceChainId === ETHEREUM_CHAIN_ID && destinationChainId === SOLANA_CHAIN_ID) {
+var providerAddressEquals = (value, expected) => typeof value === "string" && (EVM_ADDRESS3.test(value) ? value.toLowerCase() === expected.toLowerCase() : value === expected);
+var catalogTokenMatches = (token, expected) => token?.deploymentId === expected.deploymentId && token.chainId === expected.chainId && token.address !== null && (expected.chainId === ETHEREUM_CHAIN_ID2 ? token.address.toLowerCase() === expected.address.toLowerCase() : token.address === expected.address) && token.standard === expected.standard && token.decimals === expected.decimals && token.status === "active";
+var directionFacts = (sourceChainId, destinationChainId, sourceTokenDeploymentId, destinationTokenDeploymentId) => {
+  if (sourceChainId === ETHEREUM_CHAIN_ID2 && destinationChainId === SOLANA_CHAIN_ID2) {
+    const isEurc = sourceTokenDeploymentId === ETHEREUM_EURC_DEPLOYMENT_ID && destinationTokenDeploymentId === SOLANA_EURC_DEPLOYMENT_ID;
+    const isUsdc = sourceTokenDeploymentId === ETHEREUM_USDC_DEPLOYMENT_ID && destinationTokenDeploymentId === SOLANA_USDC_DEPLOYMENT_ID;
+    if (!isEurc && !isUsdc) return fail("BRIDGE_UNSUPPORTED_ROUTE");
     return {
       sourceChainId,
       destinationChainId,
-      bridgeCapabilityId: "bridge-mayan-swift-v2-eurc-eth-sol",
-      sourceTokenDeploymentId: ETHEREUM_EURC_DEPLOYMENT_ID,
-      destinationTokenDeploymentId: SOLANA_EURC_DEPLOYMENT_ID,
-      sourceTokenAddress: ETHEREUM_EURC_ADDRESS,
-      destinationTokenAddress: SOLANA_EURC_ADDRESS,
+      asset: isEurc ? "eurc" : "usdc",
+      bridgeCapabilityId: isEurc ? "bridge-mayan-swift-v2-eurc-eth-sol" : "bridge-mayan-swift-v2-usdc-eth-sol",
+      sourceTokenDeploymentId,
+      destinationTokenDeploymentId,
+      sourceTokenAddress: isEurc ? ETHEREUM_EURC_ADDRESS : ETHEREUM_USDC_ADDRESS,
+      destinationTokenAddress: isEurc ? SOLANA_EURC_ADDRESS : SOLANA_USDC_ADDRESS,
       sourceTokenStandard: "erc20",
       destinationTokenStandard: "spl-token",
       sourceProviderChainId: ETHEREUM_PROVIDER_CHAIN_ID,
@@ -5920,23 +7559,31 @@ var directionFacts = (sourceChainId, destinationChainId) => {
       destinationWormholeChainId: SOLANA_WORMHOLE_CHAIN_ID,
       sourceName: ETHEREUM_NAME,
       destinationName: SOLANA_NAME,
-      sourceEurcMint: "",
-      destinationEurcMint: SOLANA_EURC_ADDRESS,
+      sourceTokenName: isEurc ? "EuroC" : "USD Coin",
+      destinationTokenName: isEurc ? "EuroC" : "USD Coin",
+      sourceTokenMint: isEurc ? "" : MAYAN_USDC_MINT,
+      destinationTokenMint: isEurc ? SOLANA_EURC_ADDRESS : SOLANA_USDC_ADDRESS,
       sourceUsdcDeploymentId: ETHEREUM_USDC_DEPLOYMENT_ID,
       sourceUsdcAddress: ETHEREUM_USDC_ADDRESS,
       sourceUsdcStandard: "erc20",
-      swiftContract: ETHEREUM_SWIFT_CONTRACT
+      swiftContract: ETHEREUM_SWIFT_CONTRACT,
+      forwarderAddress: ETHEREUM_FORWARDER2,
+      forwarderFunctionSelector: isUsdc ? ETHEREUM_USDC_FORWARDER_SELECTOR : ETHEREUM_EURC_FORWARDER_SELECTOR
     };
   }
-  if (sourceChainId === SOLANA_CHAIN_ID && destinationChainId === ETHEREUM_CHAIN_ID) {
+  if (sourceChainId === SOLANA_CHAIN_ID2 && destinationChainId === ETHEREUM_CHAIN_ID2) {
+    const isEurc = sourceTokenDeploymentId === SOLANA_EURC_DEPLOYMENT_ID && destinationTokenDeploymentId === ETHEREUM_EURC_DEPLOYMENT_ID;
+    const isUsdc = sourceTokenDeploymentId === SOLANA_USDC_DEPLOYMENT_ID && destinationTokenDeploymentId === ETHEREUM_USDC_DEPLOYMENT_ID;
+    if (!isEurc && !isUsdc) return fail("BRIDGE_UNSUPPORTED_ROUTE");
     return {
       sourceChainId,
       destinationChainId,
-      bridgeCapabilityId: "bridge-mayan-swift-v2-eurc-sol-eth",
-      sourceTokenDeploymentId: SOLANA_EURC_DEPLOYMENT_ID,
-      destinationTokenDeploymentId: ETHEREUM_EURC_DEPLOYMENT_ID,
-      sourceTokenAddress: SOLANA_EURC_ADDRESS,
-      destinationTokenAddress: ETHEREUM_EURC_ADDRESS,
+      asset: isEurc ? "eurc" : "usdc",
+      bridgeCapabilityId: isEurc ? "bridge-mayan-swift-v2-eurc-sol-eth" : "bridge-mayan-swift-v2-usdc-sol-eth",
+      sourceTokenDeploymentId,
+      destinationTokenDeploymentId,
+      sourceTokenAddress: isEurc ? SOLANA_EURC_ADDRESS : SOLANA_USDC_ADDRESS,
+      destinationTokenAddress: isEurc ? ETHEREUM_EURC_ADDRESS : ETHEREUM_USDC_ADDRESS,
       sourceTokenStandard: "spl-token",
       destinationTokenStandard: "erc20",
       sourceProviderChainId: SOLANA_PROVIDER_CHAIN_ID,
@@ -5945,12 +7592,16 @@ var directionFacts = (sourceChainId, destinationChainId) => {
       destinationWormholeChainId: ETHEREUM_WORMHOLE_CHAIN_ID,
       sourceName: SOLANA_NAME,
       destinationName: ETHEREUM_NAME,
-      sourceEurcMint: SOLANA_EURC_ADDRESS,
-      destinationEurcMint: "",
+      sourceTokenName: isEurc ? "EuroC" : "USD Coin",
+      destinationTokenName: isEurc ? "EuroC" : "USD Coin",
+      sourceTokenMint: isEurc ? SOLANA_EURC_ADDRESS : SOLANA_USDC_ADDRESS,
+      destinationTokenMint: isEurc ? "" : MAYAN_USDC_MINT,
       sourceUsdcDeploymentId: SOLANA_USDC_DEPLOYMENT_ID,
       sourceUsdcAddress: SOLANA_USDC_ADDRESS,
       sourceUsdcStandard: "spl-token",
-      swiftContract: SOLANA_SWIFT_PROGRAM
+      swiftContract: SOLANA_SWIFT_PROGRAM2,
+      forwarderAddress: null,
+      forwarderFunctionSelector: null
     };
   }
   return fail("BRIDGE_UNSUPPORTED_ROUTE");
@@ -6014,12 +7665,12 @@ var validateCapability = (capability, facts) => {
     sourceUsdcStandard: facts.sourceUsdcStandard,
     sourceUsdcDecimals: 6,
     swiftContract: facts.swiftContract,
-    forwarderAddress: facts.sourceChainId === ETHEREUM_CHAIN_ID ? ETHEREUM_FORWARDER : null,
-    forwarderFunctionSelector: facts.sourceChainId === ETHEREUM_CHAIN_ID ? "0x30dedc57" : null,
-    jupiterProgramAddress: facts.sourceChainId === SOLANA_CHAIN_ID ? SOLANA_JUPITER_V6 : null,
+    forwarderAddress: facts.sourceChainId === ETHEREUM_CHAIN_ID2 ? ETHEREUM_FORWARDER2 : null,
+    forwarderFunctionSelector: facts.sourceChainId === ETHEREUM_CHAIN_ID2 ? facts.asset === "usdc" ? ETHEREUM_USDC_FORWARDER_SELECTOR : ETHEREUM_EURC_FORWARDER_SELECTOR : null,
+    jupiterProgramAddress: facts.sourceChainId === SOLANA_CHAIN_ID2 && facts.asset === "eurc" ? SOLANA_JUPITER_V62 : null,
     builderEndpoint: DEFAULT_BUILDER_ENDPOINT,
     explorerEndpoint: DEFAULT_EXPLORER_ENDPOINT,
-    dependencies: facts.sourceChainId === SOLANA_CHAIN_ID ? [...DEPENDENCIES, "jupiter-v6-source-swap"] : [...DEPENDENCIES],
+    dependencies: facts.asset === "usdc" ? [...DIRECT_USDC_DEPENDENCIES] : facts.sourceChainId === SOLANA_CHAIN_ID2 ? [...DEPENDENCIES, "jupiter-v6-source-swap"] : [...DEPENDENCIES],
     status: "active"
   };
   const actualKeys = Object.keys(capability).sort();
@@ -6060,10 +7711,12 @@ var validateBridgeRoute = (request) => {
   );
   const amountIn = normalizePositiveUint64(value.amountIn, "BRIDGE_INVALID_ARGUMENT");
   const slippageBps = normalizeSlippage(value.slippageBps, "BRIDGE_INVALID_ARGUMENT");
-  const facts = directionFacts(sourceChainId, destinationChainId);
-  if (sourceTokenDeploymentId !== facts.sourceTokenDeploymentId || destinationTokenDeploymentId !== facts.destinationTokenDeploymentId) {
-    fail("BRIDGE_UNSUPPORTED_ROUTE");
-  }
+  const facts = directionFacts(
+    sourceChainId,
+    destinationChainId,
+    sourceTokenDeploymentId,
+    destinationTokenDeploymentId
+  );
   validateCatalogDirection(facts);
   const capability = findCapability(facts);
   validateCapability(capability, facts);
@@ -6095,7 +7748,7 @@ var StrictJsonParser = class {
     return value;
   }
   #value(depth) {
-    if (depth > MAX_JSON_DEPTH) this.#invalid();
+    if (depth > MAX_JSON_DEPTH2) this.#invalid();
     const start = this.#index;
     const character = this.#source[this.#index];
     if (character === "{") return this.#object(start, depth);
@@ -6307,7 +7960,7 @@ var decodeResponseBody = async (response, controlled, external) => {
   const contentLength = response.headers.get("content-length");
   if (contentLength !== null && /^\d+$/u.test(contentLength)) {
     try {
-      if (BigInt(contentLength) > BigInt(MAX_RESPONSE_BYTES)) {
+      if (BigInt(contentLength) > BigInt(MAX_RESPONSE_BYTES2)) {
         fail("BRIDGE_PROVIDER_INVALID_RESPONSE");
       }
     } catch {
@@ -6348,7 +8001,7 @@ var decodeResponseBody = async (response, controlled, external) => {
       const chunk = result.value;
       if (!(chunk instanceof Uint8Array)) return fail("BRIDGE_PROVIDER_TRANSPORT");
       totalBytes += chunk.byteLength;
-      if (totalBytes > MAX_RESPONSE_BYTES) {
+      if (totalBytes > MAX_RESPONSE_BYTES2) {
         fail("BRIDGE_PROVIDER_INVALID_RESPONSE");
       }
       chunks.push(chunk);
@@ -6383,7 +8036,8 @@ var CONFIG_KEYS = /* @__PURE__ */ new Set([
   "allowUnauthenticatedBuild",
   "minimumQuoteValiditySeconds",
   "timeoutMs",
-  "fetch"
+  "fetch",
+  "localBuild"
 ]);
 var endpointWithPath2 = (base, path) => new URL(path.replace(/^\/+/, ""), `${base.toString().replace(/\/+$/u, "")}/`);
 var normalizeProviderEndpoint = (value, fallback, label) => {
@@ -6455,6 +8109,15 @@ var normalizeBridgeConfig = (config) => {
   const timeoutMs = timeoutMsValue;
   const implementation = value.fetch ?? globalThis.fetch;
   if (typeof implementation !== "function") fail("BRIDGE_INVALID_ARGUMENT");
+  let localBuild;
+  if (value.localBuild !== void 0) {
+    const localBuildValue = requireRecord(value.localBuild, "BRIDGE_INVALID_ARGUMENT");
+    const localBuildKeys = /* @__PURE__ */ new Set(["sourceSwapEndpoint", "ethereumRpc", "solanaRpc"]);
+    if (Object.keys(localBuildValue).some((key) => !localBuildKeys.has(key))) {
+      fail("BRIDGE_INVALID_ARGUMENT");
+    }
+    localBuild = localBuildValue;
+  }
   return Object.freeze({
     builderEndpoint,
     explorerEndpoint,
@@ -6462,7 +8125,8 @@ var normalizeBridgeConfig = (config) => {
     allowUnauthenticatedBuild,
     minimumQuoteValiditySeconds,
     timeoutMs,
-    fetch: implementation
+    fetch: wrapFetch(implementation),
+    ...localBuild === void 0 ? {} : { localBuild }
   });
 };
 var requestSignal = (timeoutMs, external) => {
@@ -6572,18 +8236,18 @@ var encodeBase58 = (bytes) => {
   }
   let result = "1".repeat(zeroes);
   for (let index = digits.length - 1; index >= 0; index -= 1) {
-    result += BASE58_ALPHABET[digits[index] ?? 0] ?? "";
+    result += BASE58_ALPHABET2[digits[index] ?? 0] ?? "";
   }
   return result === "" ? "1" : result;
 };
 var decodeBase58 = (value, expectedBytes, code) => {
   const text = requireString(value, code);
-  if (text.length > expectedBytes * 2 || [...text].some((char) => !BASE58_ALPHABET.includes(char))) {
+  if (text.length > expectedBytes * 2 || [...text].some((char) => !BASE58_ALPHABET2.includes(char))) {
     fail(code);
   }
   const bytes = [0];
   for (const char of text) {
-    const digit = BASE58_ALPHABET.indexOf(char);
+    const digit = BASE58_ALPHABET2.indexOf(char);
     let carry = digit;
     for (let index = 0; index < bytes.length; index += 1) {
       const current = (bytes[index] ?? 0) * 58 + carry;
@@ -6727,7 +8391,7 @@ var providerInteger = (node, key) => {
 var providerAddress = (node, key, expected) => {
   const value = providerString(node, key);
   if (!providerAddressEquals(value, expected)) providerInvalid();
-  return EVM_ADDRESS2.test(value) ? value.toLowerCase() : value;
+  return EVM_ADDRESS3.test(value) ? value.toLowerCase() : value;
 };
 var providerUint64 = (node, key, positive) => {
   const value = providerString(node, key);
@@ -6746,14 +8410,14 @@ var providerToken = (node, expected) => {
   if (mint !== expected.mint) providerInvalid();
   const realOrigin = providerString(node, "realOriginContractAddress");
   if (!providerAddressEquals(realOrigin, expected.address)) providerInvalid();
-  if (providerString(node, "name") !== "EuroC") providerInvalid();
+  if (providerString(node, "name") !== expected.name) providerInvalid();
   if (providerString(node, "standard") !== expected.standard) providerInvalid();
   if (providerInteger(node, "chainId") !== expected.chainId) providerInvalid();
   if (providerInteger(node, "wChainId") !== expected.wormholeChainId) providerInvalid();
   if (providerInteger(node, "realOriginChainId") !== expected.wormholeChainId) providerInvalid();
   if (providerInteger(node, "decimals") !== 6) providerInvalid();
 };
-var quoteProviderStandard = (facts) => facts.sourceChainId === ETHEREUM_CHAIN_ID ? "erc20" : "spl";
+var quoteProviderStandard = (facts) => facts.sourceChainId === ETHEREUM_CHAIN_ID2 ? "erc20" : "spl";
 var ensureQuoteDeadline = (deadlineValue, margin) => {
   const now = BigInt(Math.floor(Date.now() / 1e3));
   if (!Number.isSafeInteger(Number(now)) || deadlineValue < now + BigInt(margin)) {
@@ -6785,17 +8449,19 @@ var validateProviderQuote = (node, text, request, facts, config) => {
   const destinationToken = requiredNode(node, "toToken");
   providerToken(sourceToken, {
     address: facts.sourceTokenAddress,
-    standard: facts.sourceChainId === ETHEREUM_CHAIN_ID ? "erc20" : "spl",
+    standard: facts.sourceChainId === ETHEREUM_CHAIN_ID2 ? "erc20" : "spl",
     chainId: facts.sourceProviderChainId,
     wormholeChainId: facts.sourceWormholeChainId,
-    mint: facts.sourceEurcMint
+    mint: facts.sourceTokenMint,
+    name: facts.sourceTokenName
   });
   providerToken(destinationToken, {
     address: facts.destinationTokenAddress,
-    standard: facts.destinationChainId === ETHEREUM_CHAIN_ID ? "erc20" : "spl",
+    standard: facts.destinationChainId === ETHEREUM_CHAIN_ID2 ? "erc20" : "spl",
     chainId: facts.destinationProviderChainId,
     wormholeChainId: facts.destinationWormholeChainId,
-    mint: facts.destinationEurcMint
+    mint: facts.destinationTokenMint,
+    name: facts.destinationTokenName
   });
   const sourceUsdcStandard = quoteProviderStandard(facts);
   if (providerAddress(node, "swiftInputContract", facts.sourceUsdcAddress) !== facts.sourceUsdcAddress) {
@@ -6812,23 +8478,27 @@ var validateProviderQuote = (node, text, request, facts, config) => {
   }
   let routerAddress;
   let routerKind;
-  if (facts.sourceChainId === ETHEREUM_CHAIN_ID) {
-    routerAddress = normalizeEvmAddress3(
+  const evmRouter = objectValue5(node, "evmSwapRouterAddress");
+  if (facts.asset === "usdc") {
+    if (evmRouter !== void 0 && evmRouter !== null) providerInvalid();
+    routerAddress = null;
+    routerKind = null;
+  } else if (facts.sourceChainId === ETHEREUM_CHAIN_ID2) {
+    routerAddress = normalizeEvmAddress4(
       providerString(node, "evmSwapRouterAddress"),
       "BRIDGE_PROVIDER_INVALID_RESPONSE"
     );
     routerKind = "provider-selected-evm";
   } else {
-    routerAddress = SOLANA_JUPITER_V6;
+    routerAddress = SOLANA_JUPITER_V62;
     routerKind = "jupiter-v6";
-    const evmRouter = objectValue5(node, "evmSwapRouterAddress");
     if (evmRouter !== void 0 && evmRouter !== null) providerInvalid();
   }
   const quoteId = providerString(node, "quoteId");
   if (!/^0x[0-9a-fA-F]{32}$/u.test(quoteId)) providerInvalid();
   const signature = providerString(node, "signature");
   if (!EVM_SIGNATURE.test(signature)) providerInvalid();
-  const dependencies = facts.sourceChainId === SOLANA_CHAIN_ID ? [...DEPENDENCIES, "jupiter-v6-source-swap"] : [...DEPENDENCIES];
+  const dependencies = facts.asset === "usdc" ? [...DIRECT_USDC_DEPENDENCIES] : facts.sourceChainId === SOLANA_CHAIN_ID2 ? [...DEPENDENCIES, "jupiter-v6-source-swap"] : [...DEPENDENCIES];
   const quote = {
     quoteKind: "mayan-swift-v2",
     providerId: "mayan-swift-v2",
@@ -6845,8 +8515,8 @@ var validateProviderQuote = (node, text, request, facts, config) => {
     quoteId: quoteId.toLowerCase(),
     providerSignature: signature.toLowerCase(),
     sourceSwap: {
-      required: true,
-      inputTokenDeploymentId: facts.sourceTokenDeploymentId,
+      required: facts.asset === "eurc",
+      inputTokenDeploymentId: facts.asset === "usdc" ? facts.sourceUsdcDeploymentId : facts.sourceTokenDeploymentId,
       intermediateTokenDeploymentId: facts.sourceUsdcDeploymentId,
       intermediateTokenAddress: facts.sourceUsdcAddress,
       intermediateTokenStandard: sourceUsdcStandard,
@@ -6903,10 +8573,10 @@ var exactObjectKeys = (value, expected, code) => {
     fail(code);
   }
 };
-var stableJson = (value) => {
-  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+var stableJson2 = (value) => {
+  if (Array.isArray(value)) return `[${value.map(stableJson2).join(",")}]`;
   if (isRecord4(value)) {
-    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson2(value[key])}`).join(",")}}`;
   }
   return JSON.stringify(value);
 };
@@ -6923,8 +8593,23 @@ var validateNormalizedQuoteShape = (quote, code) => {
   if (value.quoteKind !== "mayan-swift-v2" || value.providerId !== "mayan-swift-v2") fail(code);
   const sourceChainId = requireString(value.sourceChainId, code);
   const destinationChainId = requireString(value.destinationChainId, code);
-  const facts = directionFacts(sourceChainId, destinationChainId);
-  if (value.sourceTokenDeploymentId !== facts.sourceTokenDeploymentId || value.destinationTokenDeploymentId !== facts.destinationTokenDeploymentId) fail(code);
+  const sourceTokenDeploymentId = requireString(value.sourceTokenDeploymentId, code);
+  const destinationTokenDeploymentId = requireString(value.destinationTokenDeploymentId, code);
+  let facts;
+  try {
+    facts = directionFacts(
+      sourceChainId,
+      destinationChainId,
+      sourceTokenDeploymentId,
+      destinationTokenDeploymentId
+    );
+  } catch (error) {
+    if (error instanceof BridgeError && error.code === "BRIDGE_UNSUPPORTED_ROUTE") {
+      return fail(code);
+    }
+    throw error;
+  }
+  if (sourceTokenDeploymentId !== facts.sourceTokenDeploymentId || destinationTokenDeploymentId !== facts.destinationTokenDeploymentId) fail(code);
   const amountIn = normalizePositiveUint64(value.amountIn, code);
   const expectedAmountOut = normalizePositiveUint64(value.expectedAmountOut, code);
   const minimumAmountOut = normalizePositiveUint64(value.minimumAmountOut, code);
@@ -6939,29 +8624,33 @@ var validateNormalizedQuoteShape = (quote, code) => {
   if (!EVM_SIGNATURE.test(signature)) fail(code);
   const sourceSwap = requireRecord(value.sourceSwap, code);
   exactObjectKeys(sourceSwap, SOURCE_SWAP_KEYS, code);
-  if (sourceSwap.required !== true) fail(code);
-  if (sourceSwap.inputTokenDeploymentId !== facts.sourceTokenDeploymentId || sourceSwap.intermediateTokenDeploymentId !== facts.sourceUsdcDeploymentId) fail(code);
+  if (sourceSwap.required !== (facts.asset === "eurc")) fail(code);
+  if (sourceSwap.inputTokenDeploymentId !== (facts.asset === "usdc" ? facts.sourceUsdcDeploymentId : facts.sourceTokenDeploymentId) || sourceSwap.intermediateTokenDeploymentId !== facts.sourceUsdcDeploymentId) fail(code);
   if (sourceSwap.intermediateTokenAddress !== facts.sourceUsdcAddress) fail(code);
-  const providerStandard = quoteProviderStandard(facts);
-  if (sourceSwap.intermediateTokenStandard !== providerStandard || sourceSwap.intermediateTokenDecimals !== 6) fail(code);
+  const providerStandard2 = quoteProviderStandard(facts);
+  if (sourceSwap.intermediateTokenStandard !== providerStandard2 || sourceSwap.intermediateTokenDecimals !== 6) fail(code);
   const providerMinimumAmount = sourceSwap.providerMinimumAmount;
   if (typeof providerMinimumAmount !== "string" || providerMinimumAmount.length === 0) fail(code);
   let normalizedRouterAddress;
   let normalizedRouterKind;
-  if (facts.sourceChainId === ETHEREUM_CHAIN_ID) {
+  if (facts.asset === "usdc") {
+    if (sourceSwap.routerKind !== null || sourceSwap.routerAddress !== null) fail(code);
+    normalizedRouterAddress = null;
+    normalizedRouterKind = null;
+  } else if (facts.sourceChainId === ETHEREUM_CHAIN_ID2) {
     const routerAddress = sourceSwap.routerAddress;
-    if (sourceSwap.routerKind !== "provider-selected-evm" || typeof routerAddress !== "string" || !EVM_ADDRESS2.test(routerAddress) || /^0x0{40}$/iu.test(routerAddress)) return fail(code);
+    if (sourceSwap.routerKind !== "provider-selected-evm" || typeof routerAddress !== "string" || !EVM_ADDRESS3.test(routerAddress) || /^0x0{40}$/iu.test(routerAddress)) return fail(code);
     normalizedRouterAddress = routerAddress.toLowerCase();
     normalizedRouterKind = "provider-selected-evm";
-  } else if (sourceSwap.routerKind !== "jupiter-v6" || sourceSwap.routerAddress !== SOLANA_JUPITER_V6) {
+  } else if (sourceSwap.routerKind !== "jupiter-v6" || sourceSwap.routerAddress !== SOLANA_JUPITER_V62) {
     return fail(code);
   } else {
-    normalizedRouterAddress = SOLANA_JUPITER_V6;
+    normalizedRouterAddress = SOLANA_JUPITER_V62;
     normalizedRouterKind = "jupiter-v6";
   }
   if (!Array.isArray(value.dependencies)) fail(code);
-  const wantedDependencies = facts.sourceChainId === SOLANA_CHAIN_ID ? [...DEPENDENCIES, "jupiter-v6-source-swap"] : [...DEPENDENCIES];
-  if (stableJson(value.dependencies) !== stableJson(wantedDependencies)) fail(code);
+  const wantedDependencies = facts.asset === "usdc" ? [...DIRECT_USDC_DEPENDENCIES] : facts.sourceChainId === SOLANA_CHAIN_ID2 ? [...DEPENDENCIES, "jupiter-v6-source-swap"] : [...DEPENDENCIES];
+  if (stableJson2(value.dependencies) !== stableJson2(wantedDependencies)) fail(code);
   const rawSignedQuoteJson = requireString(value.rawSignedQuoteJson, code);
   if (byteLength(rawSignedQuoteJson) > MAX_RAW_QUOTE_BYTES) fail(code);
   return {
@@ -6980,11 +8669,11 @@ var validateNormalizedQuoteShape = (quote, code) => {
     quoteId: quoteId.toLowerCase(),
     providerSignature: signature.toLowerCase(),
     sourceSwap: {
-      required: true,
-      inputTokenDeploymentId: facts.sourceTokenDeploymentId,
+      required: facts.asset === "eurc",
+      inputTokenDeploymentId: facts.asset === "usdc" ? facts.sourceUsdcDeploymentId : facts.sourceTokenDeploymentId,
       intermediateTokenDeploymentId: facts.sourceUsdcDeploymentId,
       intermediateTokenAddress: facts.sourceUsdcAddress,
-      intermediateTokenStandard: providerStandard,
+      intermediateTokenStandard: providerStandard2,
       intermediateTokenDecimals: 6,
       providerMinimumAmount,
       routerKind: normalizedRouterKind,
@@ -7065,7 +8754,7 @@ var buildRequestSnapshot = (value) => {
   };
 };
 var normalizeChainAddress = (value, chainId, code) => {
-  if (chainId === ETHEREUM_CHAIN_ID) return normalizeEvmAddress3(value, code);
+  if (chainId === ETHEREUM_CHAIN_ID2) return normalizeEvmAddress4(value, code);
   const address = requireString(value, code);
   decodeBase58(address, 32, code);
   return address;
@@ -7080,9 +8769,9 @@ var isCanonicalSolanaAddress = (value) => {
   }
 };
 var rejectAddressFromOtherChain = (value, expectedChainId) => {
-  const isEvm = typeof value === "string" && EVM_ADDRESS2.test(value) && !/^0x0{40}$/iu.test(value);
+  const isEvm = typeof value === "string" && EVM_ADDRESS3.test(value) && !/^0x0{40}$/iu.test(value);
   const isSolana = isCanonicalSolanaAddress(value);
-  if (expectedChainId === ETHEREUM_CHAIN_ID && isSolana || expectedChainId === SOLANA_CHAIN_ID && isEvm) {
+  if (expectedChainId === ETHEREUM_CHAIN_ID2 && isSolana || expectedChainId === SOLANA_CHAIN_ID2 && isEvm) {
     fail("BRIDGE_QUOTE_MISMATCH");
   }
 };
@@ -7097,7 +8786,7 @@ var buildRouteFromQuote = (quote) => {
     if (error instanceof BridgeError) throw error;
     return fail("BRIDGE_QUOTE_MISMATCH");
   }
-  if (stableJson(quote) !== stableJson(normalizedQuote)) fail("BRIDGE_QUOTE_MISMATCH");
+  if (stableJson2(quote) !== stableJson2(normalizedQuote)) fail("BRIDGE_QUOTE_MISMATCH");
   const route = validateBridgeRoute({
     sourceChainId: normalizedQuote.sourceChainId,
     destinationChainId: normalizedQuote.destinationChainId,
@@ -7132,7 +8821,9 @@ var validateRawQuoteForBuild = (quote, route, config) => {
     if (error instanceof BridgeError && error.code === "BRIDGE_QUOTE_EXPIRED") throw error;
     return fail("BRIDGE_QUOTE_MISMATCH");
   }
-  if (stableJson(rebuilt.quote) !== stableJson(quote)) fail("BRIDGE_QUOTE_MISMATCH");
+  if (stableJson2(rebuilt.quote) !== stableJson2(quote)) {
+    fail("BRIDGE_QUOTE_MISMATCH");
+  }
   return deepFreeze6(quote);
 };
 var numericZero = (value) => {
@@ -7141,26 +8832,29 @@ var numericZero = (value) => {
   if (value === "0") return true;
   return /^0x0+$/iu.test(value);
 };
-var validateEvmBuildResult = (wrapper, swapperAddress) => {
+var validateEvmBuildResult = (wrapper, swapperAddress, facts) => {
+  const forwarderAddress = facts.forwarderAddress ?? providerInvalid();
+  const forwarderFunctionSelector = facts.forwarderFunctionSelector ?? providerInvalid();
   if (providerString(wrapper, "chainCategory") !== "evm") providerInvalid();
   if (providerString(wrapper, "quoteType") !== "SWIFT") providerInvalid();
   if (providerBoolean(wrapper, "gasless")) providerInvalid();
   const transaction = requiredNode(wrapper, "transaction");
   if (!isRecord4(transaction.value)) providerInvalid();
   const to = providerString(transaction, "to");
-  if (!providerAddressEquals(to, ETHEREUM_FORWARDER)) providerInvalid();
+  if (!providerAddressEquals(to, forwarderAddress)) providerInvalid();
   const chainId = providerInteger(transaction, "chainId");
   if (chainId !== ETHEREUM_PROVIDER_CHAIN_ID) providerInvalid();
   if (!numericZero(objectValue5(transaction, "value"))) providerInvalid();
   const data = providerString(transaction, "data").toLowerCase();
-  if (!HEX_BYTES2.test(data) || data.length % 2 !== 0 || !data.startsWith(ETHEREUM_FORWARDER_SELECTOR) || data.length < 2 + 8 + 13 * 64) {
+  const minimumWords = facts.asset === "usdc" ? 10 : 13;
+  if (!HEX_BYTES3.test(data) || data.length % 2 !== 0 || !data.startsWith(forwarderFunctionSelector) || data.length < 2 + 8 + minimumWords * 64) {
     providerInvalid();
   }
   return {
     kind: "evm-unsigned-transaction",
     chainId: "eip155:1",
     from: swapperAddress,
-    to: ETHEREUM_FORWARDER,
+    to: forwarderAddress,
     data,
     value: "0"
   };
@@ -7174,7 +8868,7 @@ var validateSolanaBuildResult = (wrapper, swapperAddress) => {
   const encoded = validateSolanaTransaction(transaction.value, swapperAddress);
   return {
     kind: "solana-v0-unsigned-transaction",
-    chainId: SOLANA_CHAIN_ID,
+    chainId: SOLANA_CHAIN_ID2,
     feePayer: swapperAddress,
     transactionBase64: encoded
   };
@@ -7195,7 +8889,7 @@ var validateBuildResponse = (response, quote, facts, swapperAddress) => {
   }
   let transaction;
   try {
-    transaction = facts.sourceChainId === ETHEREUM_CHAIN_ID ? validateEvmBuildResult(wrapper, swapperAddress) : validateSolanaBuildResult(wrapper, swapperAddress);
+    transaction = facts.sourceChainId === ETHEREUM_CHAIN_ID2 ? validateEvmBuildResult(wrapper, swapperAddress, facts) : validateSolanaBuildResult(wrapper, swapperAddress);
   } catch (error) {
     if (error instanceof BridgeError) {
       if (error.code === "BRIDGE_BUILD_INVALID") throw error;
@@ -7210,11 +8904,11 @@ var validateBuildResponse = (response, quote, facts, swapperAddress) => {
     sourceChainId: quote.sourceChainId,
     destinationChainId: quote.destinationChainId,
     transaction,
-    allowance: facts.sourceChainId === ETHEREUM_CHAIN_ID ? {
-      tokenDeploymentId: "deployment-0011",
-      tokenAddress: ETHEREUM_EURC_ADDRESS,
+    allowance: facts.sourceChainId === ETHEREUM_CHAIN_ID2 ? {
+      tokenDeploymentId: facts.sourceTokenDeploymentId,
+      tokenAddress: facts.sourceTokenAddress,
       owner: swapperAddress,
-      spender: ETHEREUM_FORWARDER,
+      spender: facts.forwarderAddress,
       requiredAmount: quote.amountIn
     } : null,
     validation: {
@@ -7240,14 +8934,14 @@ var statusRequestSnapshot = (value) => {
 };
 var normalizeStatusRequest = (value) => {
   const request = statusRequestSnapshot(value);
-  if (request.sourceChainId === ETHEREUM_CHAIN_ID) {
+  if (request.sourceChainId === ETHEREUM_CHAIN_ID2) {
     if (!EVM_HASH.test(request.sourceTransactionHash)) fail("BRIDGE_INVALID_ARGUMENT");
     return {
       sourceChainId: request.sourceChainId,
       sourceTransactionHash: request.sourceTransactionHash.toLowerCase()
     };
   }
-  if (request.sourceChainId === SOLANA_CHAIN_ID) {
+  if (request.sourceChainId === SOLANA_CHAIN_ID2) {
     decodeBase58(request.sourceTransactionHash, 64, "BRIDGE_INVALID_ARGUMENT");
     return request;
   }
@@ -7283,7 +8977,7 @@ var buildBody = (quote, sourceChainId, swapperAddress, destinationAddress, refun
     swapperAddress,
     destinationAddress
   };
-  if (sourceChainId === ETHEREUM_CHAIN_ID) params.signerChainId = 1;
+  if (sourceChainId === ETHEREUM_CHAIN_ID2) params.signerChainId = 1;
   if (refundAddress !== void 0) params.swiftRefundAddress = refundAddress;
   return `{"quote":${quote.rawSignedQuoteJson},"params":${JSON.stringify(params)}}`;
 };
@@ -7363,6 +9057,37 @@ var MayanSwiftV2BridgeClient = class {
     const parsed = await providerJson(response, "status");
     return statusFromResponse(parsed, normalized);
   }
+  async prepareSourceSwap(context, options) {
+    return prepareSourceSwap(context, this.#localRuntime(), options);
+  }
+  async buildLocalUnsigned(request, options) {
+    return buildLocalUnsigned(request, this.#localRuntime(), options);
+  }
+  #localRuntime() {
+    return {
+      localBuild: this.#config.localBuild,
+      fetch: this.#config.fetch,
+      timeoutMs: this.#config.timeoutMs,
+      minimumQuoteValiditySeconds: this.#config.minimumQuoteValiditySeconds,
+      validateQuote: (quote, invalidCode) => {
+        try {
+          const { route, normalizedQuote } = buildRouteFromQuote(quote);
+          const validationQuote = /[ \t\r\n]$/u.test(normalizedQuote.rawSignedQuoteJson) ? {
+            ...normalizedQuote,
+            rawSignedQuoteJson: normalizedQuote.rawSignedQuoteJson.replace(/[ \t\r\n]+$/gu, "")
+          } : normalizedQuote;
+          validateRawQuoteForBuild(validationQuote, route, this.#config);
+          return quote;
+        } catch (error) {
+          if (error instanceof BridgeError && error.code === "BRIDGE_QUOTE_EXPIRED") {
+            throw error;
+          }
+          return fail(invalidCode);
+        }
+      },
+      fail
+    };
+  }
   close() {
   }
 };
@@ -7385,6 +9110,7 @@ exports.CloudCreditClient = CloudCreditClient;
 exports.CloudResourcesClient = CloudResourcesClient;
 exports.DEFAULT_ACCOUNT_ENDPOINT = DEFAULT_ACCOUNT_ENDPOINT;
 exports.DEFAULT_AVALANCHE_ENDPOINT = DEFAULT_AVALANCHE_ENDPOINT;
+exports.DEFAULT_BASE_ENDPOINT = DEFAULT_BASE_ENDPOINT;
 exports.DEFAULT_ENDPOINT = DEFAULT_ENDPOINT;
 exports.DEFAULT_TIMEOUT_MS = DEFAULT_TIMEOUT_MS;
 exports.DEFAULT_USER_ENDPOINT = DEFAULT_USER_ENDPOINT;