@elsoul/erpc-sdk 0.7.0 → 0.8.0

package/dist/index.js

@@ -7,11 +7,88 @@ var credentialVariants = (credential) => {
     componentEncoded = encodeURIComponent(credential);
   } catch {
   }
-  return [.../* @__PURE__ */ new Set([credential, componentEncoded, queryEncoded])].filter((value) => Boolean(value)).sort((left, right) => right.length - left.length);
+  return [
+    .../* @__PURE__ */ new Set([
+      credential,
+      componentEncoded,
+      queryEncoded
+    ])
+  ].filter((value) => Boolean(value)).sort((left, right) => right.length - left.length);
+};
+var directEndpointVariants = (endpoint) => {
+  const values = [];
+  const add = (value) => {
+    if (value) values.push(value);
+  };
+  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("&")) {
+    const separator = part.indexOf("=");
+    const rawValue = separator === -1 ? "" : part.slice(separator + 1);
+    add(rawValue);
+    if (rawValue) {
+      try {
+        add(decodeURIComponent(rawValue.replaceAll("+", " ")));
+      } catch {
+      }
+    }
+  }
+  return values;
+};
+var headerVariants = (headers) => {
+  const values = [];
+  for (const [name, value] of Object.entries(headers)) {
+    values.push(value);
+    if (name.toLowerCase() !== "authorization" && name.toLowerCase() !== "proxy-authorization") continue;
+    const match = /^\s*[^\s]+\s+(.+?)\s*$/u.exec(value);
+    if (match?.[1]) values.push(match[1]);
+    if (match?.[1] && /^basic$/iu.test(value.trim().split(/\s+/u, 1)[0] ?? "")) {
+      try {
+        const decoded = globalThis.atob(match[1]);
+        values.push(decoded);
+        const separator = decoded.indexOf(":");
+        if (separator !== -1) {
+          values.push(decoded.slice(0, separator), decoded.slice(separator + 1));
+        }
+      } catch {
+      }
+    }
+  }
+  return values;
+};
+var directRedactionVariants = (endpoint, headers = {}) => [.../* @__PURE__ */ new Set([...directEndpointVariants(endpoint), ...headerVariants(headers)])].flatMap((value) => credentialVariants(value)).filter((value, index, all) => all.indexOf(value) === index).sort((left, right) => right.length - left.length);
+var escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+var hexCharacterPattern = (value) => {
+  const lower = value.toLowerCase();
+  const upper = value.toUpperCase();
+  if (lower === upper) return escapeRegex(value);
+  return `[${lower}${upper}]`;
+};
+var percentTripletPattern = (value) => {
+  const pattern = /%([0-9a-f])([0-9a-f])/giu;
+  let result = "";
+  let offset = 0;
+  for (const match of value.matchAll(pattern)) {
+    const index = match.index ?? 0;
+    result += escapeRegex(value.slice(offset, index));
+    result += `%${hexCharacterPattern(match[1] ?? "")}${hexCharacterPattern(
+      match[2] ?? ""
+    )}`;
+    offset = index + match[0].length;
+  }
+  return result + escapeRegex(value.slice(offset));
 };
 var redactString = (value, variants) => {
   let redacted = value;
-  for (const variant of variants) redacted = redacted.replaceAll(variant, REDACTED);
+  for (const variant of variants) {
+    if (!variant) continue;
+    const pattern = percentTripletPattern(variant);
+    if (pattern === escapeRegex(variant)) {
+      redacted = redacted.replaceAll(variant, REDACTED);
+    } else {
+      redacted = redacted.replace(new RegExp(pattern, "gu"), REDACTED);
+    }
+  }
   return redacted;
 };
 var redactValue = (value, variants, seen, depth) => {
@@ -24,7 +101,7 @@ var redactValue = (value, variants, seen, depth) => {
   }
   const result = {};
   for (const [key, item] of Object.entries(value)) {
-    Object.defineProperty(result, key, {
+    Object.defineProperty(result, redactString(key, variants), {
       configurable: true,
       enumerable: true,
       value: redactValue(item, variants, seen, depth + 1),
@@ -33,9 +110,12 @@ var redactValue = (value, variants, seen, depth) => {
   }
   return result;
 };
-var redactJsonRpcError = (error, credential) => {
-  if (!credential) return error;
-  const variants = credentialVariants(credential);
+var redactJsonRpcError = (error, credential, additionalCredentials = []) => {
+  const variants = [.../* @__PURE__ */ new Set([
+    ...credential ? credentialVariants(credential) : [],
+    ...additionalCredentials
+  ])].sort((left, right) => right.length - left.length);
+  if (variants.length === 0) return error;
   const result = {
     code: error.code,
     message: redactString(error.message, variants)
@@ -59,6 +139,14 @@ var ErpcConfigError = class extends ErpcError {
     this.name = "ErpcConfigError";
   }
 };
+var ErpcNotConfiguredError = class extends ErpcError {
+  namespace;
+  constructor(namespace) {
+    super("ERPC_NOT_CONFIGURED", `ERPC namespace '${namespace}' is not configured`);
+    this.name = "ErpcNotConfiguredError";
+    this.namespace = namespace;
+  }
+};
 var ErpcTransportError = class extends ErpcError {
   constructor(message, options) {
     super("ERPC_TRANSPORT", message, options);
@@ -165,12 +253,14 @@ var RestTransport = class {
   #fetch;
   #headers;
   #timeoutMs;
+  #unavailableNamespace;
   constructor(config) {
-    this.#apiKey = config.apiKey;
+    this.#apiKey = config.apiKey ?? "";
     this.#endpoint = new URL(config.endpoint);
     this.#fetch = config.fetch;
     this.#headers = config.headers;
     this.#timeoutMs = config.timeoutMs;
+    this.#unavailableNamespace = config.unavailableNamespace;
     const endpoint = new URL(config.endpoint);
     endpoint.search = "";
     endpoint.hash = "";
@@ -184,6 +274,9 @@ var RestTransport = class {
     return url;
   }
   async get(path, query, options = {}) {
+    if (this.#unavailableNamespace !== void 0) {
+      throw new ErpcNotConfiguredError(this.#unavailableNamespace);
+    }
     const controlled = controlledSignal(this.#timeoutMs, options.signal);
     try {
       const response = await this.#get(path, query, controlled.signal);
@@ -201,6 +294,9 @@ var RestTransport = class {
     }
   }
   async stream(path, query, options = {}) {
+    if (this.#unavailableNamespace !== void 0) {
+      throw new ErpcNotConfiguredError(this.#unavailableNamespace);
+    }
     const controlled = controlledSignal(this.#timeoutMs, options.signal);
     try {
       const response = await this.#get(path, query, controlled.signal);
@@ -217,13 +313,16 @@ var RestTransport = class {
     }
   }
   #get(path, query, signal) {
+    const headers = {
+      ...this.#headers,
+      accept: "application/json"
+    };
+    if (this.#unavailableNamespace === void 0) {
+      headers.authorization = `Bearer ${this.#apiKey}`;
+    }
     return this.#fetch(this.url(path, query), {
       method: "GET",
-      headers: {
-        ...this.#headers,
-        authorization: `Bearer ${this.#apiKey}`,
-        accept: "application/json"
-      },
+      headers,
       signal
     });
   }
@@ -2447,22 +2546,97 @@ var requireFetch = (provided) => {
   }
   return implementation;
 };
+var normalizeLegacyEndpoint = (endpoint) => {
+  endpoint.search = "";
+  endpoint.hash = "";
+  endpoint.pathname = endpoint.pathname.replace(/\/+$/, "") || "/";
+  return endpoint;
+};
+var explicitAuthority = (value) => /^[a-z][a-z\d+.-]*:\/\//iu.test(value);
+var hasUserInfo = (value) => {
+  const separator = value.indexOf("://");
+  if (separator === -1) return false;
+  const authorityAndPath = value.slice(separator + 3);
+  const authority = authorityAndPath.split(/[/?#]/u, 1)[0] ?? "";
+  return authority.length === 0 || authority.includes("@");
+};
+var parseDirectUrl = (value, namespace, kind) => {
+  if (typeof value !== "string") {
+    throw new ErpcConfigError(`${namespace} URL must be an absolute ${kind} URL`);
+  }
+  const input = value.trim();
+  if (!input || !explicitAuthority(input) || input.includes("#") || hasUserInfo(input)) {
+    throw new ErpcConfigError(`${namespace} URL must be an absolute ${kind} URL`);
+  }
+  let url;
+  try {
+    url = new URL(input);
+  } catch {
+    throw new ErpcConfigError(`${namespace} URL must be an absolute ${kind} URL`);
+  }
+  const allowed = kind === "HTTP(S)" ? url.protocol === "http:" || url.protocol === "https:" : url.protocol === "ws:" || url.protocol === "wss:";
+  if (!allowed || !url.hostname || url.username || url.password) {
+    throw new ErpcConfigError(`${namespace} URL must be an absolute ${kind} URL`);
+  }
+  return url;
+};
+var directHeaders = (value, namespace) => {
+  if (value === void 0) return {};
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new ErpcConfigError(`${namespace} headers must be string values`);
+  }
+  const result = {};
+  for (const [name, header] of Object.entries(value)) {
+    if (typeof header !== "string") {
+      throw new ErpcConfigError(`${namespace} headers must be string values`);
+    }
+    result[name] = header;
+  }
+  return Object.freeze(result);
+};
+var resolveRpcEndpoint = (value, namespace) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new ErpcConfigError(`${namespace} must define an HTTP(S) URL`);
+  }
+  const config = value;
+  const httpUrl = parseDirectUrl(config.httpUrl, `${namespace}.httpUrl`, "HTTP(S)");
+  const webSocketUrl = config.webSocketUrl === void 0 ? void 0 : parseDirectUrl(
+    config.webSocketUrl,
+    `${namespace}.webSocketUrl`,
+    "WS(S)"
+  );
+  const headers = directHeaders(config.headers, namespace);
+  return {
+    headers,
+    httpUrl,
+    ...webSocketUrl === void 0 ? {} : { webSocketUrl }
+  };
+};
 var resolveConfig = (config) => {
-  const apiKey = config.apiKey.trim();
-  if (!apiKey) throw new ErpcConfigError("apiKey must not be empty");
+  const configuredApiKey = config.apiKey === void 0 ? void 0 : typeof config.apiKey === "string" ? config.apiKey.trim() : (() => {
+    throw new ErpcConfigError("apiKey must be a string");
+  })();
+  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;
+  if (!configuredApiKey && !hasDirectRpc) {
+    throw new ErpcConfigError("apiKey must not be empty");
+  }
+  const apiKey = configuredApiKey || void 0;
   let endpoint;
   let avalancheEndpoint;
   let accountEndpoint;
   let userEndpoint;
   try {
-    endpoint = new URL(config.endpoint ?? DEFAULT_ENDPOINT);
-    avalancheEndpoint = new URL(
+    endpoint = normalizeLegacyEndpoint(new URL(config.endpoint ?? DEFAULT_ENDPOINT));
+    avalancheEndpoint = normalizeLegacyEndpoint(new URL(
       config.avalancheEndpoint ?? DEFAULT_AVALANCHE_ENDPOINT
-    );
-    accountEndpoint = new URL(
+    ));
+    accountEndpoint = normalizeLegacyEndpoint(new URL(
       config.accountEndpoint ?? DEFAULT_ACCOUNT_ENDPOINT
-    );
-    userEndpoint = new URL(config.userEndpoint ?? DEFAULT_USER_ENDPOINT);
+    ));
+    userEndpoint = normalizeLegacyEndpoint(new URL(config.userEndpoint ?? DEFAULT_USER_ENDPOINT));
   } catch {
     throw new ErpcConfigError("endpoint must be an absolute HTTP(S) URL");
   }
@@ -2478,31 +2652,22 @@ var resolveConfig = (config) => {
   if (userEndpoint.protocol !== "https:" && userEndpoint.protocol !== "http:") {
     throw new ErpcConfigError("userEndpoint must use HTTP or HTTPS");
   }
-  endpoint.search = "";
-  endpoint.hash = "";
-  endpoint.pathname = endpoint.pathname.replace(/\/+$/, "") || "/";
-  avalancheEndpoint.search = "";
-  avalancheEndpoint.hash = "";
-  avalancheEndpoint.pathname = avalancheEndpoint.pathname.replace(/\/+$/, "") || "/";
-  accountEndpoint.search = "";
-  accountEndpoint.hash = "";
-  accountEndpoint.pathname = accountEndpoint.pathname.replace(/\/+$/, "") || "/";
-  userEndpoint.search = "";
-  userEndpoint.hash = "";
-  userEndpoint.pathname = userEndpoint.pathname.replace(/\/+$/, "") || "/";
   const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
     throw new ErpcConfigError("timeoutMs must be a positive finite number");
   }
   return {
     accountEndpoint,
-    apiKey,
     avalancheEndpoint,
     endpoint,
     fetch: requireFetch(config.fetch),
     headers: config.headers ?? {},
     timeoutMs,
     userEndpoint,
+    ...apiKey === void 0 ? {} : { apiKey },
+    ...avalancheCRpc === void 0 ? {} : { avalancheCRpc },
+    ...ethereumRpc === void 0 ? {} : { ethereumRpc },
+    ...solanaRpc === void 0 ? {} : { solanaRpc },
     ...config.webSocket === void 0 ? {} : { webSocket: config.webSocket }
   };
 };
@@ -2844,16 +3009,16 @@ var nativeNamespace = (transport, methodPrefix) => createRpcNamespace({
   transport,
   validateBatch: rejectNativeBatch
 });
-var createAvalancheClient = (transport, indexTransports) => ({
+var createAvalancheClient = (transport, indexTransports, nativeTransport = transport) => ({
   ...createEthereumClient(transport),
-  avax: nativeNamespace(transport, "avax"),
-  xChain: nativeNamespace(transport, "avm"),
-  pChain: nativeNamespace(transport, "platform"),
+  avax: nativeNamespace(nativeTransport, "avax"),
+  xChain: nativeNamespace(nativeTransport, "avm"),
+  pChain: nativeNamespace(nativeTransport, "platform"),
   proposerVm: nativeNamespace(
-    transport,
+    nativeTransport,
     "proposervm"
   ),
-  info: nativeNamespace(transport, "info"),
+  info: nativeNamespace(nativeTransport, "info"),
   index: {
     cChainBlocks: nativeNamespace(
       indexTransports.cChainBlocks,
@@ -3028,7 +3193,9 @@ var WebSocketJsonRpcTransport = class {
   #credential;
   #listeners = /* @__PURE__ */ new Set();
   #pending = /* @__PURE__ */ new Map();
+  #redactionVariants;
   #timeoutMs;
+  #unavailableNamespace;
   #webSocket;
   #connectPromise;
   #nextId = 1;
@@ -3040,21 +3207,38 @@ var WebSocketJsonRpcTransport = class {
     this.#connectionUrl = config.endpoint.toString();
     this.endpoint = publicEndpoint(config.endpoint);
     this.maxBatchSize = config.maxBatchSize ?? 256;
+    this.#redactionVariants = directRedactionVariants(
+      config.endpoint,
+      config.redactionHeaders
+    );
     this.#timeoutMs = config.timeoutMs;
+    this.#unavailableNamespace = config.unavailableNamespace;
   }
   async connect() {
     if (this.#socket?.readyState === 1) return;
     if (this.#connectPromise) return this.#connectPromise;
+    if (this.#unavailableNamespace !== void 0) {
+      throw new ErpcNotConfiguredError(this.#unavailableNamespace);
+    }
     if (!this.#webSocket) {
       throw new ErpcConfigError(
         "A WebSocket implementation is required for subscriptions"
       );
     }
     this.#connectPromise = new Promise((resolve, reject) => {
-      const socket = new this.#webSocket(this.#connectionUrl);
+      let socket;
+      try {
+        socket = new this.#webSocket(this.#connectionUrl);
+      } catch {
+        reject(new ErpcTransportError("Unable to connect to ERPC WebSocket"));
+        return;
+      }
       this.#socket = socket;
       const timeout = setTimeout(() => {
-        socket.close();
+        try {
+          socket.close();
+        } catch {
+        }
         reject(new ErpcTimeoutError(this.#timeoutMs));
       }, this.#timeoutMs);
       socket.addEventListener(
@@ -3108,6 +3292,9 @@ var WebSocketJsonRpcTransport = class {
     return promise;
   }
   async batch(calls, options = {}) {
+    if (this.#unavailableNamespace !== void 0) {
+      throw new ErpcNotConfiguredError(this.#unavailableNamespace);
+    }
     if (calls.length === 0) return [];
     if (calls.length > this.maxBatchSize) {
       throw new ErpcInvalidResponseError(
@@ -3214,7 +3401,11 @@ var WebSocketJsonRpcTransport = class {
       if (isRpcError(message.error)) {
         pending.reject(
           new ErpcJsonRpcError(
-            redactJsonRpcError(message.error, this.#credential)
+            redactJsonRpcError(
+              message.error,
+              this.#credential,
+              this.#redactionVariants
+            )
           )
         );
       } else if ("result" in message) pending.resolve(message.result);
@@ -3905,6 +4096,13 @@ function normalizeEvmAddress2(address) {
   return address.toLowerCase();
 }
 
+// src/generated/swap_execution_capabilities.ts
+var SWAP_EXECUTION_CAPABILITIES_JSON = '[{"swapExecutionCapabilityId":"swap-execution-0001","chainId":"eip155:1","dexDeploymentId":"dex-deployment-0001","poolDefinitionId":"pool-0001","factoryAddress":"0x5c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f","routerAddress":"0x7a250d5630b4cf539739df2c5dacb4c659f2488d","routerKind":"uniswap-v2-router02","adapterKind":"evm-constant-product-v2","token0DeploymentId":"deployment-0008","token0Address":"0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48","token0Standard":"erc20","token1DeploymentId":"deployment-0002","token1Address":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2","token1Standard":"erc20","wrappedNativeTokenDeploymentId":"deployment-0002","wrappedNativeTokenAddress":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2","wrappedNativeFunctionSelector":"0xad5c4648","functionKind":"exact-input-erc20-to-erc20","functionSignature":"swapExactTokensForTokens(uint256,uint256,address[],address,uint256)","functionSelector":"0x38ed1739","status":"active"},{"swapExecutionCapabilityId":"swap-execution-0002","chainId":"eip155:43114","dexDeploymentId":"dex-deployment-0002","poolDefinitionId":"pool-0002","factoryAddress":"0x9ad6c38be94206ca50bb0d90783181662f0cfa10","routerAddress":"0x60ae616a2155ee3d9a68541ba4544862310933d4","routerKind":"joe-v1-router02","adapterKind":"evm-constant-product-v2","token0DeploymentId":"deployment-0004","token0Address":"0xb31f66aa3c1e785363f0875a1b74e27b85fd66c7","token0Standard":"erc20","token1DeploymentId":"deployment-0009","token1Address":"0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e","token1Standard":"erc20","wrappedNativeTokenDeploymentId":"deployment-0004","wrappedNativeTokenAddress":"0xb31f66aa3c1e785363f0875a1b74e27b85fd66c7","wrappedNativeFunctionSelector":"0x73b295c2","functionKind":"exact-input-erc20-to-erc20","functionSignature":"swapExactTokensForTokens(uint256,uint256,address[],address,uint256)","functionSelector":"0x38ed1739","status":"active"}]';
+var SWAP_EXECUTION_CAPABILITIES_CONTENT_DIGEST = "84424dc48687e2cb1dd0c9a2446f820efd2c311e71ce5acacfeb6e882811875f";
+var SWAP_EXECUTION_CAPABILITIES_AS_OF_DATE = "2026-09-16";
+var SWAP_EXECUTION_FUNCTION_SIGNATURE = "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)";
+var SWAP_EXECUTION_FUNCTION_SELECTOR = "0x38ed1739";
+
 // src/swap.ts
 var SWAP_QUOTE_ERROR_MESSAGES = Object.freeze({
   SWAP_INVALID_ARGUMENT: "Swap request is invalid",
@@ -3931,6 +4129,22 @@ var SwapQuoteError = class extends Error {
     this.code = code;
   }
 };
+var SWAP_EXECUTION_ERROR_MESSAGES = Object.freeze({
+  SWAP_EXECUTION_INVALID_ARGUMENT: "Swap execution request is invalid",
+  SWAP_UNSUPPORTED_EXECUTION: "Swap execution is unsupported for the selected records",
+  SWAP_PROGRAM_MISMATCH: "Swap program does not match the selected records",
+  SWAP_INSUFFICIENT_ALLOWANCE: "Swap allowance is insufficient",
+  SWAP_SIMULATION_REVERTED: "Swap simulation reverted",
+  SWAP_INVALID_SIMULATION: "Swap simulation result is invalid"
+});
+var SwapExecutionError = class extends Error {
+  code;
+  constructor(code) {
+    super(SWAP_EXECUTION_ERROR_MESSAGES[code]);
+    this.name = "SwapExecutionError";
+    this.code = code;
+  }
+};
 var SUPPORTED_QUOTE_ADAPTER = "evm-constant-product-v2";
 var SUPPORTED_QUOTE_CAPABILITIES = Object.freeze([
   Object.freeze({
@@ -4023,9 +4237,15 @@ var PAIR_FACTORY_SELECTOR = "0xc45a0155";
 var PAIR_TOKEN0_SELECTOR = "0x0dfe1681";
 var PAIR_TOKEN1_SELECTOR = "0xd21220a7";
 var PAIR_GET_RESERVES_SELECTOR = "0x0902f1ac";
+var ROUTER_FACTORY_SELECTOR = "0xc45a0155";
+var ROUTER_GET_AMOUNTS_OUT_SELECTOR = "0xd06ca61f";
+var ERC20_ALLOWANCE_SELECTOR = "0xdd62ed3e";
 function swapFail(code) {
   throw new SwapQuoteError(code);
 }
+function executionFail(code) {
+  throw new SwapExecutionError(code);
+}
 var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var isKnownChain2 = (value) => value === DEX_CHAIN_IDS.ethereum || value === DEX_CHAIN_IDS.solana || value === DEX_CHAIN_IDS.avalancheC;
 var isOpaqueId = (value) => /^[A-Za-z0-9][A-Za-z0-9._:-]*$/u.test(value);
@@ -4215,6 +4435,43 @@ var uintWord = (value, maximum = UINT256_MAX) => {
   if (parsed > maximum) swapFail("SWAP_INVALID_POOL_STATE");
   return parsed;
 };
+var parseExecutionHexBytes = (value, expectedBytes, code = "SWAP_INVALID_SIMULATION") => {
+  if (typeof value !== "string") executionFail(code);
+  if (!HEX_BYTES.test(value) || value.length % 2 !== 0 || expectedBytes !== void 0 && value.length !== expectedBytes * 2 + 2) {
+    executionFail(code);
+  }
+  return value.toLowerCase();
+};
+var executionAddressWord = (value, code = "SWAP_INVALID_SIMULATION") => {
+  const bytes = parseExecutionHexBytes(value, 32, code);
+  const word = bytes.slice(2);
+  if (!/^0{24}[0-9a-f]{40}$/u.test(word)) executionFail(code);
+  return `0x${word.slice(24)}`;
+};
+var executionUintWord = (value, code = "SWAP_INVALID_SIMULATION") => {
+  const bytes = parseExecutionHexBytes(value, 32, code);
+  try {
+    return BigInt(`0x${bytes.slice(2)}`);
+  } catch {
+    executionFail(code);
+  }
+};
+var executionUintArrayOfTwo = (value) => {
+  const bytes = parseExecutionHexBytes(value);
+  const payload = bytes.slice(2);
+  if (payload.length % 64 !== 0 || payload.length < 256) {
+    executionFail("SWAP_INVALID_SIMULATION");
+  }
+  const offset = BigInt(`0x${payload.slice(0, 64)}`);
+  const length = BigInt(`0x${payload.slice(64, 128)}`);
+  if (offset !== 0x20n || length !== 2n || payload.length !== 256) {
+    executionFail("SWAP_INVALID_SIMULATION");
+  }
+  return [
+    executionUintWord(`0x${payload.slice(128, 192)}`),
+    executionUintWord(`0x${payload.slice(192, 256)}`)
+  ];
+};
 var reserveWords = (value) => {
   const bytes = parseHexBytes(value, 96);
   const payload = bytes.slice(2);
@@ -4260,8 +4517,101 @@ var currentClockSeconds = (clock) => {
   if (!Number.isSafeInteger(value)) swapFail("SWAP_INVALID_ARGUMENT");
   return value;
 };
-var assertFreshness = (state, freshness, clock) => {
-  const now = BigInt(currentClockSeconds(clock));
+var EXECUTION_REQUEST_KEYS = /* @__PURE__ */ new Set([
+  "chainId",
+  "poolDefinitionId",
+  "inputTokenDeploymentId",
+  "outputTokenDeploymentId",
+  "amountIn",
+  "freshness",
+  "sender",
+  "recipient",
+  "slippageBps",
+  "deadline"
+]);
+var snapshotExecutionRequest = (request) => {
+  if (!isRecord3(request)) executionFail("SWAP_EXECUTION_INVALID_ARGUMENT");
+  if (Object.keys(request).some((key) => !EXECUTION_REQUEST_KEYS.has(key))) {
+    executionFail("SWAP_EXECUTION_INVALID_ARGUMENT");
+  }
+  const freshness = request.freshness;
+  const freshnessSnapshot = isRecord3(freshness) ? { ...freshness } : freshness;
+  const quoteRequest = {
+    chainId: request.chainId,
+    poolDefinitionId: request.poolDefinitionId,
+    inputTokenDeploymentId: request.inputTokenDeploymentId,
+    outputTokenDeploymentId: request.outputTokenDeploymentId,
+    amountIn: request.amountIn,
+    ...freshnessSnapshot === void 0 ? {} : { freshness: freshnessSnapshot }
+  };
+  return {
+    quoteRequest,
+    sender: request.sender,
+    recipient: request.recipient,
+    slippageBps: request.slippageBps,
+    deadline: request.deadline
+  };
+};
+var normalizeExecutionAddress = (value) => {
+  if (typeof value !== "string" || !/^0x[0-9a-fA-F]{40}$/u.test(value)) {
+    executionFail("SWAP_EXECUTION_INVALID_ARGUMENT");
+  }
+  const normalized = value.toLowerCase();
+  if (normalized === `0x${"0".repeat(40)}`) {
+    executionFail("SWAP_EXECUTION_INVALID_ARGUMENT");
+  }
+  return normalized;
+};
+var normalizeExecutionSlippage = (value) => {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0 || value > 9999) {
+    executionFail("SWAP_EXECUTION_INVALID_ARGUMENT");
+  }
+  return value;
+};
+var parseExecutionDeadline = (value) => {
+  if (typeof value !== "string" || !UINT256_DECIMAL.test(value) || value.length > 78) {
+    executionFail("SWAP_EXECUTION_INVALID_ARGUMENT");
+  }
+  let parsed;
+  try {
+    parsed = BigInt(value);
+  } catch {
+    executionFail("SWAP_EXECUTION_INVALID_ARGUMENT");
+  }
+  if (parsed <= 0n || parsed > UINT256_MAX) {
+    executionFail("SWAP_EXECUTION_INVALID_ARGUMENT");
+  }
+  return { source: value, value: parsed };
+};
+var normalizeExecutionRequest = (request, clock) => {
+  const snapshot = snapshotExecutionRequest(request);
+  const sender = normalizeExecutionAddress(snapshot.sender);
+  const recipient = normalizeExecutionAddress(snapshot.recipient);
+  const slippageBps = normalizeExecutionSlippage(snapshot.slippageBps);
+  const deadline = parseExecutionDeadline(snapshot.deadline);
+  const initialClock = BigInt(currentClockSeconds(clock));
+  if (deadline.value <= initialClock) {
+    executionFail("SWAP_EXECUTION_INVALID_ARGUMENT");
+  }
+  let normalized;
+  try {
+    normalized = normalizeQuoteRequest(snapshot.quoteRequest);
+  } catch (error) {
+    if (error instanceof SwapQuoteError && (error.code === "SWAP_UNKNOWN_POOL" || error.code === "SWAP_UNSUPPORTED_ADAPTER" || error.code === "SWAP_UNSUPPORTED_TOKEN" || error.code === "SWAP_UNSUPPORTED_TOKEN_STANDARD")) {
+      executionFail("SWAP_UNSUPPORTED_EXECUTION");
+    }
+    throw error;
+  }
+  return {
+    normalized,
+    sender,
+    recipient,
+    slippageBps,
+    deadline: deadline.source,
+    deadlineValue: deadline.value
+  };
+};
+var assertFreshnessAtNow = (state, freshness, now) => {
   const initialAge = now - state.initial.timestamp;
   if (initialAge < -BigInt(freshness.maxClockSkewSeconds) || initialAge > BigInt(freshness.maxBlockAgeSeconds)) {
     swapFail("SWAP_STATE_STALE");
@@ -4283,6 +4633,54 @@ var assertFreshness = (state, freshness, clock) => {
     swapFail("SWAP_STATE_STALE");
   }
 };
+var assertFreshness = (state, freshness, clock) => {
+  assertFreshnessAtNow(
+    state,
+    freshness,
+    BigInt(currentClockSeconds(clock))
+  );
+};
+var executionCapabilityFor = (normalized) => {
+  const capability = EXECUTION_CAPABILITIES.find(
+    (entry) => entry.poolDefinitionId === normalized.pool.poolDefinitionId
+  );
+  if (!capability || capability.status !== "active") {
+    executionFail("SWAP_UNSUPPORTED_EXECUTION");
+  }
+  const token0 = getTokenDeployment(capability.token0DeploymentId);
+  const token1 = getTokenDeployment(capability.token1DeploymentId);
+  const wrapped = getTokenDeployment(capability.wrappedNativeTokenDeploymentId);
+  const nativeWrap = NATIVE_WRAP_DEFINITIONS.find(
+    (entry) => entry.chainId === capability.chainId && entry.wrappedTokenDeploymentId === capability.wrappedNativeTokenDeploymentId
+  );
+  const matchesCapabilityToken = (token, deploymentId, address, standard) => token?.deploymentId === deploymentId && token.chainId === capability.chainId && token.address === address && token.standard === standard && token.status === "active";
+  const inputMatches = matchesCapabilityToken(
+    normalized.input,
+    capability.token0DeploymentId,
+    capability.token0Address,
+    capability.token0Standard
+  ) || matchesCapabilityToken(
+    normalized.input,
+    capability.token1DeploymentId,
+    capability.token1Address,
+    capability.token1Standard
+  );
+  const outputMatches = matchesCapabilityToken(
+    normalized.output,
+    capability.token0DeploymentId,
+    capability.token0Address,
+    capability.token0Standard
+  ) || matchesCapabilityToken(
+    normalized.output,
+    capability.token1DeploymentId,
+    capability.token1Address,
+    capability.token1Standard
+  );
+  if (capability.chainId !== normalized.pool.chainId || capability.dexDeploymentId !== normalized.pool.dexDeploymentId || capability.adapterKind !== SUPPORTED_QUOTE_ADAPTER || capability.functionKind !== "exact-input-erc20-to-erc20" || capability.functionSignature !== SWAP_EXECUTION_FUNCTION_SIGNATURE || capability.functionSelector !== SWAP_EXECUTION_FUNCTION_SELECTOR || normalized.dex.status !== "active" || normalized.dex.programAddress !== capability.factoryAddress || normalized.dex.adapterKind !== capability.adapterKind || normalized.pool.status !== "active" || normalized.pool.adapter.kind !== capability.adapterKind || normalized.pool.adapter.feeNumerator !== "3" || normalized.pool.adapter.feeDenominator !== "1000" || normalized.pool.token0DeploymentId !== capability.token0DeploymentId || normalized.pool.token1DeploymentId !== capability.token1DeploymentId || !inputMatches || !outputMatches || !token0 || !token1 || !wrapped || wrapped.chainId !== capability.chainId || wrapped.address !== capability.wrappedNativeTokenAddress || wrapped.standard !== "erc20" || wrapped.status !== "active" || !nativeWrap || nativeWrap.status !== "active" || nativeWrap.wrappedTokenDeploymentId !== capability.wrappedNativeTokenDeploymentId) {
+    executionFail("SWAP_UNSUPPORTED_EXECUTION");
+  }
+  return capability;
+};
 var readEvmState = async (transport, normalized, clock, options) => {
   const { pool, dex } = normalized;
   const chainId = await rpcRequest(transport, "eth_chainId", [], options);
@@ -4415,14 +4813,269 @@ var quoteResult = (normalized, state, result) => {
   };
   return deepFreeze5(output);
 };
+var transportForNormalized = (normalized, options) => {
+  const transport = normalized.pool.chainId === DEX_CHAIN_IDS.ethereum ? options.ethereum : normalized.pool.chainId === DEX_CHAIN_IDS.avalancheC ? options.avalanche : void 0;
+  if (!transport) swapFail("SWAP_UNSUPPORTED_ADAPTER");
+  return transport;
+};
+var encodeUint256Word = (value) => ensureUint256(value).toString(16).padStart(64, "0");
+var executionTokenAddress = (token) => {
+  if (typeof token.address !== "string" || !EVM_ADDRESS.test(token.address)) {
+    executionFail("SWAP_INVALID_SIMULATION");
+  }
+  return token.address.toLowerCase();
+};
+var executionGetAmountsOutData = (amountIn, inputAddress, outputAddress) => `${ROUTER_GET_AMOUNTS_OUT_SELECTOR}${encodeUint256Word(amountIn)}${encodeUint256Word(
+  0x40n
+)}${encodeUint256Word(2n)}${encodeAddressArgument(
+  inputAddress
+)}${encodeAddressArgument(outputAddress)}`;
+var executionSwapData = (amountIn, minimumAmountOut, inputAddress, outputAddress, recipient, deadline) => `${SWAP_EXECUTION_FUNCTION_SELECTOR}${encodeUint256Word(
+  amountIn
+)}${encodeUint256Word(minimumAmountOut)}${encodeUint256Word(
+  0xa0n
+)}${encodeAddressArgument(recipient)}${encodeUint256Word(
+  deadline
+)}${encodeUint256Word(2n)}${encodeAddressArgument(
+  inputAddress
+)}${encodeAddressArgument(outputAddress)}`;
+var buildExecutionPreparation = (execution, capability, quote) => {
+  const inputAddress = executionTokenAddress(execution.normalized.input);
+  const outputAddress = executionTokenAddress(execution.normalized.output);
+  const quoteAmountOut = parseDecimalQuantity(quote.amountOut, "SWAP_ARITHMETIC");
+  const minimumAmountOut = ensureUint256(
+    quoteAmountOut * BigInt(1e4 - execution.slippageBps),
+    "SWAP_ARITHMETIC"
+  ) / 10000n;
+  if (minimumAmountOut <= 0n) {
+    executionFail("SWAP_EXECUTION_INVALID_ARGUMENT");
+  }
+  const path = [
+    {
+      tokenDeploymentId: execution.normalized.input.deploymentId,
+      address: inputAddress,
+      standard: "erc20",
+      representationKind: execution.normalized.input.representationKind
+    },
+    {
+      tokenDeploymentId: execution.normalized.output.deploymentId,
+      address: outputAddress,
+      standard: "erc20",
+      representationKind: execution.normalized.output.representationKind
+    }
+  ];
+  const transaction = {
+    kind: "evm-unsigned-transaction",
+    chainId: quote.chainId,
+    from: execution.sender,
+    to: capability.routerAddress,
+    data: executionSwapData(
+      execution.normalized.amountIn,
+      minimumAmountOut,
+      inputAddress,
+      outputAddress,
+      execution.recipient,
+      execution.deadlineValue
+    ),
+    value: "0"
+  };
+  return deepFreeze5({
+    preparationKind: "evm-router-v2-exact-input",
+    executionCapabilityId: capability.swapExecutionCapabilityId,
+    executionCapabilityDigest: SWAP_EXECUTION_CAPABILITIES_CONTENT_DIGEST,
+    quote,
+    minimumAmountOut: minimumAmountOut.toString(10),
+    slippageBps: execution.slippageBps,
+    deadline: execution.deadline,
+    recipient: execution.recipient,
+    path,
+    transaction,
+    allowance: {
+      tokenDeploymentId: execution.normalized.input.deploymentId,
+      tokenAddress: inputAddress,
+      owner: execution.sender,
+      spender: capability.routerAddress,
+      requiredAmount: quote.amountIn
+    }
+  });
+};
+var assertExecutionDeadline = (execution, quoteTimestamp, completionClock) => {
+  if (execution.deadlineValue <= quoteTimestamp || execution.deadlineValue <= completionClock) {
+    executionFail("SWAP_EXECUTION_INVALID_ARGUMENT");
+  }
+};
+var prepareExecutionContext = async (execution, capability, transport, options, requestOptions) => {
+  const state = await readEvmState(
+    transport,
+    execution.normalized,
+    options.clock,
+    requestOptions
+  );
+  assertFreshness(state, execution.normalized.freshness, options.clock);
+  const quote = quoteResult(
+    execution.normalized,
+    state,
+    calculateQuote(execution.normalized, state)
+  );
+  if (execution.deadlineValue <= state.initial.timestamp) {
+    executionFail("SWAP_EXECUTION_INVALID_ARGUMENT");
+  }
+  const inputAddress = executionTokenAddress(execution.normalized.input);
+  const outputAddress = executionTokenAddress(execution.normalized.output);
+  const selector = rpcSelector(state.initial.hash);
+  const routerCodeRaw = await rpcRequest(transport, "eth_getCode", [
+    capability.routerAddress,
+    selector
+  ], requestOptions);
+  const routerCode = parseExecutionHexBytes(routerCodeRaw);
+  if (routerCode.length <= 2) executionFail("SWAP_INVALID_SIMULATION");
+  const routerFactoryRaw = await rpcRequest(transport, "eth_call", [
+    abiCall(capability.routerAddress, ROUTER_FACTORY_SELECTOR),
+    selector
+  ], requestOptions);
+  const routerFactory = executionAddressWord(routerFactoryRaw);
+  if (routerFactory !== capability.factoryAddress) {
+    executionFail("SWAP_PROGRAM_MISMATCH");
+  }
+  const wrappedNativeRaw = await rpcRequest(transport, "eth_call", [
+    abiCall(capability.routerAddress, capability.wrappedNativeFunctionSelector),
+    selector
+  ], requestOptions);
+  const wrappedNative = executionAddressWord(wrappedNativeRaw);
+  if (wrappedNative !== capability.wrappedNativeTokenAddress) {
+    executionFail("SWAP_PROGRAM_MISMATCH");
+  }
+  const amountsOutRaw = await rpcRequest(transport, "eth_call", [
+    abiCall(
+      capability.routerAddress,
+      executionGetAmountsOutData(
+        execution.normalized.amountIn,
+        inputAddress,
+        outputAddress
+      )
+    ),
+    selector
+  ], requestOptions);
+  const amountsOut = executionUintArrayOfTwo(amountsOutRaw);
+  const quoteAmountOut = parseDecimalQuantity(quote.amountOut, "SWAP_ARITHMETIC");
+  if (amountsOut[0] !== execution.normalized.amountIn || amountsOut[1] !== quoteAmountOut) {
+    executionFail("SWAP_INVALID_SIMULATION");
+  }
+  const latestAfterRouterReads = blockHeader(
+    await rpcRequest(
+      transport,
+      "eth_getBlockByNumber",
+      ["latest", false],
+      requestOptions
+    )
+  );
+  const completionClock = BigInt(currentClockSeconds(options.clock));
+  assertFreshnessAtNow(
+    {
+      initial: state.initial,
+      latestAfterReads: latestAfterRouterReads
+    },
+    execution.normalized.freshness,
+    completionClock
+  );
+  const preparation = buildExecutionPreparation(execution, capability, quote);
+  assertExecutionDeadline(
+    execution,
+    state.initial.timestamp,
+    BigInt(currentClockSeconds(options.clock))
+  );
+  return { normalized: execution, capability, transport, state, quote, preparation };
+};
+var isRecognizedExecutionRevert = (error) => {
+  if (!(error instanceof ErpcJsonRpcError)) return false;
+  if (![3, -32e3, -32015, -32603].includes(error.rpcCode)) return false;
+  const message = error.message.toLowerCase();
+  return message.includes("execution reverted") || message.includes("transaction reverted") || message.includes("vm execution error") || /^revert(?:ed)?(?:\b|:)/u.test(message);
+};
+var simulateExecutionContext = async (context, options, requestOptions) => {
+  const { normalized, capability, transport, state, preparation } = context;
+  const selector = rpcSelector(state.initial.hash);
+  const inputAddress = preparation.allowance.tokenAddress;
+  const allowanceData = `${ERC20_ALLOWANCE_SELECTOR}${encodeAddressArgument(
+    normalized.sender
+  )}${encodeAddressArgument(capability.routerAddress)}`;
+  const allowanceRaw = await rpcRequest(transport, "eth_call", [
+    abiCall(inputAddress, allowanceData),
+    selector
+  ], requestOptions);
+  const currentAllowance = executionUintWord(
+    allowanceRaw,
+    "SWAP_INSUFFICIENT_ALLOWANCE"
+  );
+  if (currentAllowance < normalized.normalized.amountIn) {
+    executionFail("SWAP_INSUFFICIENT_ALLOWANCE");
+  }
+  let simulationRaw;
+  try {
+    simulationRaw = await rpcRequest(transport, "eth_call", [
+      {
+        from: preparation.transaction.from,
+        to: preparation.transaction.to,
+        data: preparation.transaction.data,
+        value: "0x0"
+      },
+      selector
+    ], requestOptions);
+  } catch (error) {
+    if (isRecognizedExecutionRevert(error)) {
+      executionFail("SWAP_SIMULATION_REVERTED");
+    }
+    throw error;
+  }
+  const latestAfterSimulation = blockHeader(
+    await rpcRequest(
+      transport,
+      "eth_getBlockByNumber",
+      ["latest", false],
+      requestOptions
+    )
+  );
+  const completionClock = BigInt(currentClockSeconds(options.clock));
+  assertFreshnessAtNow(
+    { initial: state.initial, latestAfterReads: latestAfterSimulation },
+    normalized.normalized.freshness,
+    completionClock
+  );
+  const amounts = executionUintArrayOfTwo(simulationRaw);
+  const quoteAmountOut = parseDecimalQuantity(
+    preparation.quote.amountOut,
+    "SWAP_ARITHMETIC"
+  );
+  const minimumAmountOut = parseDecimalQuantity(
+    preparation.minimumAmountOut,
+    "SWAP_ARITHMETIC"
+  );
+  if (amounts[0] !== normalized.normalized.amountIn || amounts[1] !== quoteAmountOut || amounts[1] < minimumAmountOut) {
+    executionFail("SWAP_INVALID_SIMULATION");
+  }
+  assertExecutionDeadline(
+    normalized,
+    state.initial.timestamp,
+    BigInt(currentClockSeconds(options.clock))
+  );
+  return deepFreeze5({
+    simulationKind: "evm-call",
+    preparation,
+    snapshot: preparation.quote.snapshot,
+    currentAllowance: currentAllowance.toString(10),
+    amounts: [
+      amounts[0].toString(10),
+      amounts[1].toString(10)
+    ],
+    amountOut: amounts[1].toString(10)
+  });
+};
 var quoteExactInputWithTransports = async (request, options, requestOptions) => {
   const normalized = normalizeQuoteRequest(request);
   if (normalized.pool.adapter.kind !== SUPPORTED_QUOTE_ADAPTER) {
     swapFail("SWAP_UNSUPPORTED_ADAPTER");
   }
-  const transport = normalized.pool.chainId === DEX_CHAIN_IDS.ethereum ? options.ethereum : normalized.pool.chainId === DEX_CHAIN_IDS.avalancheC ? options.avalanche : void 0;
-  if (!transport) swapFail("SWAP_UNSUPPORTED_ADAPTER");
-  const selectedTransport = transport;
+  const selectedTransport = transportForNormalized(normalized, options);
   const state = await readEvmState(
     selectedTransport,
     normalized,
@@ -4432,6 +5085,32 @@ var quoteExactInputWithTransports = async (request, options, requestOptions) =>
   assertFreshness(state, normalized.freshness, options.clock);
   return quoteResult(normalized, state, calculateQuote(normalized, state));
 };
+var prepareExactInputSwapWithTransports = async (request, options, requestOptions) => {
+  const normalized = normalizeExecutionRequest(request, options.clock);
+  const capability = executionCapabilityFor(normalized.normalized);
+  const transport = transportForNormalized(normalized.normalized, options);
+  const context = await prepareExecutionContext(
+    normalized,
+    capability,
+    transport,
+    options,
+    requestOptions
+  );
+  return context.preparation;
+};
+var simulateExactInputSwapWithTransports = async (request, options, requestOptions) => {
+  const normalized = normalizeExecutionRequest(request, options.clock);
+  const capability = executionCapabilityFor(normalized.normalized);
+  const transport = transportForNormalized(normalized.normalized, options);
+  const context = await prepareExecutionContext(
+    normalized,
+    capability,
+    transport,
+    options,
+    requestOptions
+  );
+  return simulateExecutionContext(context, options, requestOptions);
+};
 var deepFreeze5 = (value) => {
   if (value && typeof value === "object" && !Object.isFrozen(value)) {
     Object.freeze(value);
@@ -4441,8 +5120,13 @@ var deepFreeze5 = (value) => {
   }
   return value;
 };
+var EXECUTION_CAPABILITIES = deepFreeze5(
+  JSON.parse(SWAP_EXECUTION_CAPABILITIES_JSON)
+);
 var createSwapClient = (options) => Object.freeze({
-  quoteExactInput: (request, requestOptions) => quoteExactInputWithTransports(request, options, requestOptions)
+  quoteExactInput: (request, requestOptions) => quoteExactInputWithTransports(request, options, requestOptions),
+  prepareExactInputSwap: (request, requestOptions) => prepareExactInputSwapWithTransports(request, options, requestOptions),
+  simulateExactInputSwap: (request, requestOptions) => simulateExactInputSwapWithTransports(request, options, requestOptions)
 });
 
 // src/transport/http.ts
@@ -4474,19 +5158,45 @@ var parseJson = (text) => {
     throw new ErpcInvalidResponseError("ERPC returned malformed JSON");
   }
 };
+var directRequestHeaders = (headers) => {
+  try {
+    const result = new Headers(headers);
+    result.set("accept", "application/json");
+    result.set("content-type", "application/json");
+    return result;
+  } catch {
+    const result = {};
+    for (const [name, value] of Object.entries(headers)) {
+      const lowerName = name.toLowerCase();
+      if (lowerName === "accept" || lowerName === "content-type") continue;
+      result[name] = value;
+    }
+    result.accept = "application/json";
+    result["content-type"] = "application/json";
+    return result;
+  }
+};
 var HttpJsonRpcTransport = class {
   endpoint;
   maxBatchSize;
   #apiKey;
+  #direct;
+  #requestEndpoint;
   #fetch;
   #headers;
+  #redactionVariants;
   #timeoutMs;
+  #unavailableNamespace;
   #nextId = 1;
   constructor(config) {
-    this.#apiKey = config.apiKey;
+    this.#apiKey = config.apiKey ?? "";
+    this.#direct = config.direct ?? false;
+    this.#requestEndpoint = new URL(config.endpoint);
     this.#fetch = config.fetch;
     this.#headers = config.headers;
+    this.#redactionVariants = this.#direct ? directRedactionVariants(this.#requestEndpoint, this.#headers) : [];
     this.#timeoutMs = config.timeoutMs;
+    this.#unavailableNamespace = config.unavailableNamespace;
     this.maxBatchSize = config.maxBatchSize ?? 256;
     const endpoint = new URL(config.endpoint);
     endpoint.search = "";
@@ -4494,12 +5204,14 @@ var HttpJsonRpcTransport = class {
     this.endpoint = endpoint.toString();
   }
   async request(method, params, options = {}) {
+    this.#ensureConfigured();
     const id = this.#id();
     const request = this.#request(id, method, params);
     const response = await this.#post(request, options);
     return this.#unwrap(response, id);
   }
   async batch(calls, options = {}) {
+    this.#ensureConfigured();
     if (calls.length === 0) return [];
     if (calls.length > this.maxBatchSize) {
       throw new ErpcInvalidResponseError(
@@ -4513,7 +5225,13 @@ var HttpJsonRpcTransport = class {
     const raw = await this.#post(requests, options);
     if (!Array.isArray(raw)) {
       if (isFailure(raw)) {
-        throw new ErpcJsonRpcError(redactJsonRpcError(raw.error, this.#apiKey));
+        throw new ErpcJsonRpcError(
+          redactJsonRpcError(
+            raw.error,
+            this.#direct ? void 0 : this.#apiKey,
+            this.#redactionVariants
+          )
+        );
       }
       throw new ErpcInvalidResponseError("ERPC returned a non-array batch response");
     }
@@ -4555,24 +5273,34 @@ var HttpJsonRpcTransport = class {
     this.#nextId = id >= Number.MAX_SAFE_INTEGER ? 1 : id + 1;
     return id;
   }
+  #ensureConfigured() {
+    if (this.#unavailableNamespace !== void 0) {
+      throw new ErpcNotConfiguredError(this.#unavailableNamespace);
+    }
+  }
   #request(id, method, params) {
     const request = { jsonrpc: "2.0", id, method };
     if (params !== void 0) request.params = params;
     return request;
   }
   async #post(body, options) {
-    const url = new URL(this.endpoint);
-    url.searchParams.set("api-key", this.#apiKey);
+    this.#ensureConfigured();
+    const url = new URL(this.#requestEndpoint);
+    if (!this.#direct) url.searchParams.set("api-key", this.#apiKey);
     const controlled = controlledSignal2(this.#timeoutMs, options.signal);
     try {
       const response = await this.#fetch(url, {
         method: "POST",
-        headers: {
+        headers: this.#direct ? directRequestHeaders(this.#headers) : {
           ...this.#headers,
           "content-type": "application/json"
         },
         body: JSON.stringify(body),
-        signal: controlled.signal
+        signal: controlled.signal,
+        ...this.#direct ? {
+          credentials: "omit",
+          redirect: "manual"
+        } : {}
       });
       const text = await response.text();
       if (!response.ok) throw new ErpcHttpError(response.status);
@@ -4595,7 +5323,11 @@ var HttpJsonRpcTransport = class {
     }
     if (isFailure(response)) {
       throw new ErpcJsonRpcError(
-        redactJsonRpcError(response.error, this.#apiKey)
+        redactJsonRpcError(
+          response.error,
+          this.#direct ? void 0 : this.#apiKey,
+          this.#redactionVariants
+        )
       );
     }
     if (!("result" in response)) throw new ErpcInvalidResponseError();
@@ -4689,62 +5421,81 @@ var UsageClient = class {
 };
 
 // src/client.ts
+var unavailableEndpoint = (namespace) => new URL(
+  `https://unconfigured.invalid/${namespace.replace(/[^a-z\d._-]+/giu, "-")}`
+);
 var createErpcClient = (config) => {
   const resolved = resolveConfig(config);
-  const sharedTransport = {
-    apiKey: resolved.apiKey,
+  const legacyTransport = {
     fetch: resolved.fetch,
     headers: resolved.headers,
-    timeoutMs: resolved.timeoutMs
+    timeoutMs: resolved.timeoutMs,
+    ...resolved.apiKey === void 0 ? {} : { apiKey: resolved.apiKey }
   };
-  const solanaTransport = new HttpJsonRpcTransport({
-    ...sharedTransport,
-    endpoint: resolved.endpoint
-  });
-  const ethereumEndpoint = endpointWithPath(resolved.endpoint, "/eth");
-  const ethereumTransport = new HttpJsonRpcTransport({
-    ...sharedTransport,
-    endpoint: ethereumEndpoint
-  });
-  const avalancheTransport = new HttpJsonRpcTransport({
-    ...sharedTransport,
-    endpoint: endpointWithPath(resolved.avalancheEndpoint, "/ava")
-  });
-  const avalancheIndexTransport = (path) => new HttpJsonRpcTransport({
-    ...sharedTransport,
-    endpoint: endpointWithPath(resolved.avalancheEndpoint, path)
-  });
-  const solanaWebSocket = new WebSocketJsonRpcTransport({
-    endpoint: websocketUrl(resolved.endpoint, resolved.apiKey),
+  const createUnavailableHttp = (namespace) => new HttpJsonRpcTransport({
+    endpoint: unavailableEndpoint(namespace),
+    fetch: resolved.fetch,
+    headers: {},
     timeoutMs: resolved.timeoutMs,
-    ...resolved.webSocket === void 0 ? {} : { webSocket: resolved.webSocket }
+    unavailableNamespace: namespace
   });
-  const ethereumWebSocket = new WebSocketJsonRpcTransport({
-    endpoint: websocketUrl(resolved.endpoint, resolved.apiKey, "/eth"),
+  const createUnavailableWebSocket = (namespace) => new WebSocketJsonRpcTransport({
+    endpoint: unavailableEndpoint(namespace),
     timeoutMs: resolved.timeoutMs,
-    ...resolved.webSocket === void 0 ? {} : { webSocket: resolved.webSocket }
+    unavailableNamespace: namespace
   });
-  const avalancheWebSocket = new WebSocketJsonRpcTransport({
-    endpoint: websocketUrl(
-      resolved.avalancheEndpoint,
-      resolved.apiKey,
-      "/ava-ws"
-    ),
+  const createDirectHttp = (endpoint) => new HttpJsonRpcTransport({
+    direct: true,
+    endpoint: endpoint.httpUrl,
+    fetch: resolved.fetch,
+    headers: endpoint.headers,
+    timeoutMs: resolved.timeoutMs
+  });
+  const createDirectWebSocket = (endpoint, namespace) => {
+    if (endpoint.webSocketUrl === void 0) {
+      return createUnavailableWebSocket(namespace);
+    }
+    return new WebSocketJsonRpcTransport({
+      endpoint: endpoint.webSocketUrl,
+      redactionHeaders: endpoint.headers,
+      timeoutMs: resolved.timeoutMs,
+      ...resolved.webSocket === void 0 ? {} : { webSocket: resolved.webSocket }
+    });
+  };
+  const createLegacyHttp = (endpoint) => new HttpJsonRpcTransport({ ...legacyTransport, endpoint });
+  const createLegacyWebSocket = (endpoint) => new WebSocketJsonRpcTransport({
+    endpoint,
     timeoutMs: resolved.timeoutMs,
     ...resolved.webSocket === void 0 ? {} : { webSocket: resolved.webSocket }
   });
-  const priceTransport = new RestTransport({
-    ...sharedTransport,
-    endpoint: resolved.endpoint
+  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 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");
+  const ethereumWebSocket = resolved.ethereumRpc === void 0 ? resolved.apiKey === void 0 ? createUnavailableWebSocket("ethereum.subscriptions") : createLegacyWebSocket(
+    websocketUrl(resolved.endpoint, resolved.apiKey, "/eth")
+  ) : createDirectWebSocket(resolved.ethereumRpc, "ethereum.subscriptions");
+  const avalancheWebSocket = resolved.avalancheCRpc === void 0 ? resolved.apiKey === void 0 ? createUnavailableWebSocket("avalanche.subscriptions") : createLegacyWebSocket(
+    websocketUrl(resolved.avalancheEndpoint, resolved.apiKey, "/ava-ws")
+  ) : createDirectWebSocket(
+    resolved.avalancheCRpc,
+    "avalanche.subscriptions"
+  );
+  const createUnavailableRest = (namespace) => new RestTransport({
+    endpoint: unavailableEndpoint(namespace),
+    fetch: resolved.fetch,
+    headers: {},
+    timeoutMs: resolved.timeoutMs,
+    unavailableNamespace: namespace
   });
-  const accountTransport = new RestTransport({
-    ...sharedTransport,
+  const priceTransport = resolved.apiKey === void 0 ? createUnavailableRest("price") : new RestTransport({ ...legacyTransport, endpoint: resolved.endpoint });
+  const accountTransport = resolved.apiKey === void 0 ? createUnavailableRest("account") : new RestTransport({
+    ...legacyTransport,
     endpoint: resolved.accountEndpoint
   });
-  const userTransport = new RestTransport({
-    ...sharedTransport,
-    endpoint: resolved.userEndpoint
-  });
+  const userTransport = resolved.apiKey === void 0 ? createUnavailableRest("usage") : new RestTransport({ ...legacyTransport, endpoint: resolved.userEndpoint });
   const solana = {
     ...createSolanaClient(solanaTransport),
     subscriptions: new SolanaSubscriptions(solanaWebSocket)
@@ -4755,11 +5506,23 @@ var createErpcClient = (config) => {
   };
   const avalanche = {
     ...createAvalancheClient(avalancheTransport, {
-      cChainBlocks: avalancheIndexTransport("/ava/ext/index/C/block"),
-      pChainBlocks: avalancheIndexTransport("/ava/ext/index/P/block"),
-      xChainBlocks: avalancheIndexTransport("/ava/ext/index/X/block"),
-      xChainTransactions: avalancheIndexTransport("/ava/ext/index/X/tx")
-    }),
+      cChainBlocks: avalancheIndexTransport(
+        "/ava/ext/index/C/block",
+        "avalanche.index.cChainBlocks"
+      ),
+      pChainBlocks: avalancheIndexTransport(
+        "/ava/ext/index/P/block",
+        "avalanche.index.pChainBlocks"
+      ),
+      xChainBlocks: avalancheIndexTransport(
+        "/ava/ext/index/X/block",
+        "avalanche.index.xChainBlocks"
+      ),
+      xChainTransactions: avalancheIndexTransport(
+        "/ava/ext/index/X/tx",
+        "avalanche.index.xChainTransactions"
+      )
+    }, avalancheNativeTransport),
     subscriptions: new EthereumSubscriptions(avalancheWebSocket)
   };
   const swap = createSwapClient({
@@ -4998,6 +5761,1611 @@ var createErpcCloudClient = (config) => {
   };
 };
 
-export { AVALANCHE_AVAX_METHODS, AVALANCHE_INDEX_METHODS, AVALANCHE_INFO_METHODS, AVALANCHE_PROPOSER_VM_METHODS, AVALANCHE_P_CHAIN_METHODS, AVALANCHE_X_CHAIN_METHODS, AccountClient, CloudCatalogClient, CloudCreditClient, CloudResourcesClient, DEFAULT_ACCOUNT_ENDPOINT, DEFAULT_AVALANCHE_ENDPOINT, DEFAULT_ENDPOINT, DEFAULT_TIMEOUT_MS, DEFAULT_USER_ENDPOINT, DEX_ALIASES, DEX_CATALOG_AS_OF_DATE, DEX_CATALOG_CONTENT_DIGEST, DEX_CATALOG_VERSION, DEX_CHAIN_IDS, DEX_DEPLOYMENTS, ETHEREUM_RPC_METHODS, ETHEREUM_SUBSCRIPTION_METHODS, ErpcAbortedError, ErpcBatchPolicyError, ErpcConfigError, ErpcError, ErpcHttpError, ErpcInvalidResponseError, ErpcJsonRpcError, ErpcTimeoutError, ErpcTransportError, EthereumSubscriptions, NATIVE_WRAP_DEFINITIONS, POOL_DEFINITIONS, PendingRpcBatchRequest, PendingRpcRequest, PriceClient, RpcSubscription, SOLANA_ANALYTICS_METHODS, SOLANA_DAS_METHODS, SOLANA_ENHANCED_SUBSCRIPTION_METHODS, SOLANA_HISTORY_METHODS, SOLANA_LEADER_METHODS, SOLANA_RPC_METHODS, SWAP_QUOTE_ERROR_MESSAGES, SolanaSubscriptions, SwapQuoteError, TOKEN_ALIASES, TOKEN_ASSETS, TOKEN_CATALOG_AS_OF_DATE, TOKEN_CATALOG_CONTENT_DIGEST, TOKEN_CATALOG_VERSION, TOKEN_CHAIN_IDS, TOKEN_DEPLOYMENTS, TOKEN_RANKINGS, TOKEN_RANKINGS_BY_CHAIN, TOKEN_RANKINGS_CONTENT_DIGEST, TOKEN_RANKINGS_METADATA, UsageClient, createErpcClient, createErpcCloudClient, dexes, findPoolDefinitionByAddress, findPoolDefinitionsByPair, findTokenDeploymentByAddress, findTokenDeploymentsBySymbol, getDexDeployment, getNativeTokenDeployment, getNativeWrapDefinition, getPoolDefinition, getTokenAsset, getTokenDeployment, listPoolDefinitions, listTokenDeployments, listTokenRankings, pools, tokens };
+// 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";
+
+// src/bridge.ts
+var BRIDGE_ERROR_MESSAGES = Object.freeze({
+  BRIDGE_INVALID_ARGUMENT: "Bridge request is invalid",
+  BRIDGE_UNSUPPORTED_ROUTE: "Bridge route is unsupported",
+  BRIDGE_PROVIDER_AUTH_REQUIRED: "Bridge provider authentication is required",
+  BRIDGE_PROVIDER_TRANSPORT: "Bridge provider transport failed",
+  BRIDGE_PROVIDER_HTTP: "Bridge provider HTTP request failed",
+  BRIDGE_PROVIDER_INVALID_RESPONSE: "Bridge provider response is invalid",
+  BRIDGE_QUOTE_UNAVAILABLE: "Bridge quote is unavailable",
+  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_STATUS_NOT_FOUND: "Bridge status was not found",
+  BRIDGE_TIMEOUT: "Bridge provider request timed out",
+  BRIDGE_ABORTED: "Bridge provider request was aborted"
+});
+var BridgeError = class extends Error {
+  code;
+  status;
+  constructor(code, status) {
+    super(BRIDGE_ERROR_MESSAGES[code]);
+    this.name = "BridgeError";
+    this.code = code;
+    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_NAME = "ethereum";
+var SOLANA_NAME = "solana";
+var ETHEREUM_PROVIDER_CHAIN_ID = 1;
+var SOLANA_PROVIDER_CHAIN_ID = 0;
+var ETHEREUM_WORMHOLE_CHAIN_ID = 2;
+var SOLANA_WORMHOLE_CHAIN_ID = 1;
+var ETHEREUM_EURC_DEPLOYMENT_ID = "deployment-0011";
+var SOLANA_EURC_DEPLOYMENT_ID = "deployment-0013";
+var ETHEREUM_USDC_DEPLOYMENT_ID = "deployment-0008";
+var SOLANA_USDC_DEPLOYMENT_ID = "deployment-0010";
+var ETHEREUM_EURC_ADDRESS = "0x1abaea1f7c830bd89acc67ec4af516284b1bc33c";
+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 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_RAW_QUOTE_BYTES = 256 * 1024;
+var MAX_JSON_DEPTH = 32;
+var MAX_QUOTES = 16;
+var UINT64_MAX = (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_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 BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u;
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var DEPENDENCIES = Object.freeze([
+  "mayan-hosted-quote-api",
+  "mayan-hosted-transaction-builder",
+  "mayan-hosted-source-swap-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)) {
+    Object.freeze(value);
+    for (const child of Object.values(value)) deepFreeze6(child);
+  }
+  return value;
+};
+var parsedCapabilities = JSON.parse(BRIDGE_CAPABILITIES_JSON);
+var BRIDGE_CAPABILITIES = deepFreeze6(
+  Array.isArray(parsedCapabilities) ? parsedCapabilities : isRecord4(parsedCapabilities) && Array.isArray(parsedCapabilities.capabilities) ? parsedCapabilities.capabilities : []
+);
+var fail = (code, status) => {
+  throw new BridgeError(code, status);
+};
+var requireRecord = (value, code) => {
+  if (!isRecord4(value)) fail(code);
+  return value;
+};
+var requireString = (value, code, nonempty = true) => {
+  if (typeof value !== "string" || nonempty && value.length === 0) fail(code);
+  return value;
+};
+var normalizeEvmAddress3 = (value, code) => {
+  const address = requireString(value, code);
+  if (!EVM_ADDRESS2.test(address) || /^0x0{40}$/iu.test(address)) fail(code);
+  return address.toLowerCase();
+};
+var normalizePositiveUint64 = (value, code) => {
+  const source = requireString(value, code);
+  if (!POSITIVE_UINT64.test(source) || source.length > 20) fail(code);
+  let parsed;
+  try {
+    parsed = BigInt(source);
+  } catch {
+    return fail(code);
+  }
+  const valueParsed = parsed;
+  if (valueParsed <= 0n || valueParsed > UINT64_MAX) fail(code);
+  return { source, value: valueParsed };
+};
+var normalizeCanonicalUint64 = (value, code) => {
+  const source = requireString(value, code);
+  if (!CANONICAL_UINT64.test(source) || source.length > 20) fail(code);
+  let parsed;
+  try {
+    parsed = BigInt(source);
+  } catch {
+    return fail(code);
+  }
+  const valueParsed = parsed;
+  if (valueParsed > UINT64_MAX) fail(code);
+  return { source, value: valueParsed };
+};
+var normalizeSlippage = (value, code) => {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0 || value > 500) {
+    fail(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) {
+    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,
+      sourceTokenStandard: "erc20",
+      destinationTokenStandard: "spl-token",
+      sourceProviderChainId: ETHEREUM_PROVIDER_CHAIN_ID,
+      destinationProviderChainId: SOLANA_PROVIDER_CHAIN_ID,
+      sourceWormholeChainId: ETHEREUM_WORMHOLE_CHAIN_ID,
+      destinationWormholeChainId: SOLANA_WORMHOLE_CHAIN_ID,
+      sourceName: ETHEREUM_NAME,
+      destinationName: SOLANA_NAME,
+      sourceEurcMint: "",
+      destinationEurcMint: SOLANA_EURC_ADDRESS,
+      sourceUsdcDeploymentId: ETHEREUM_USDC_DEPLOYMENT_ID,
+      sourceUsdcAddress: ETHEREUM_USDC_ADDRESS,
+      sourceUsdcStandard: "erc20",
+      swiftContract: ETHEREUM_SWIFT_CONTRACT
+    };
+  }
+  if (sourceChainId === SOLANA_CHAIN_ID && destinationChainId === ETHEREUM_CHAIN_ID) {
+    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,
+      sourceTokenStandard: "spl-token",
+      destinationTokenStandard: "erc20",
+      sourceProviderChainId: SOLANA_PROVIDER_CHAIN_ID,
+      destinationProviderChainId: ETHEREUM_PROVIDER_CHAIN_ID,
+      sourceWormholeChainId: SOLANA_WORMHOLE_CHAIN_ID,
+      destinationWormholeChainId: ETHEREUM_WORMHOLE_CHAIN_ID,
+      sourceName: SOLANA_NAME,
+      destinationName: ETHEREUM_NAME,
+      sourceEurcMint: SOLANA_EURC_ADDRESS,
+      destinationEurcMint: "",
+      sourceUsdcDeploymentId: SOLANA_USDC_DEPLOYMENT_ID,
+      sourceUsdcAddress: SOLANA_USDC_ADDRESS,
+      sourceUsdcStandard: "spl-token",
+      swiftContract: SOLANA_SWIFT_PROGRAM
+    };
+  }
+  return fail("BRIDGE_UNSUPPORTED_ROUTE");
+};
+var findCapability = (facts) => {
+  const capability = BRIDGE_CAPABILITIES.find(
+    (entry) => entry.bridgeCapabilityId === facts.bridgeCapabilityId && entry.sourceChainId === facts.sourceChainId && entry.destinationChainId === facts.destinationChainId && entry.sourceTokenDeploymentId === facts.sourceTokenDeploymentId && entry.destinationTokenDeploymentId === facts.destinationTokenDeploymentId
+  );
+  if (!capability) fail("BRIDGE_UNSUPPORTED_ROUTE");
+  return capability;
+};
+var validateCatalogDirection = (facts) => {
+  const sourceToken = getTokenDeployment(facts.sourceTokenDeploymentId);
+  const destinationToken = getTokenDeployment(facts.destinationTokenDeploymentId);
+  const sourceUsdc = getTokenDeployment(facts.sourceUsdcDeploymentId);
+  if (!catalogTokenMatches(sourceToken, {
+    deploymentId: facts.sourceTokenDeploymentId,
+    chainId: facts.sourceChainId,
+    address: facts.sourceTokenAddress,
+    standard: facts.sourceTokenStandard,
+    decimals: 6
+  }) || !catalogTokenMatches(destinationToken, {
+    deploymentId: facts.destinationTokenDeploymentId,
+    chainId: facts.destinationChainId,
+    address: facts.destinationTokenAddress,
+    standard: facts.destinationTokenStandard,
+    decimals: 6
+  }) || !catalogTokenMatches(sourceUsdc, {
+    deploymentId: facts.sourceUsdcDeploymentId,
+    chainId: facts.sourceChainId,
+    address: facts.sourceUsdcAddress,
+    standard: facts.sourceUsdcStandard,
+    decimals: 6
+  })) {
+    fail("BRIDGE_UNSUPPORTED_ROUTE");
+  }
+};
+var validateCapability = (capability, facts) => {
+  const expected = {
+    bridgeCapabilityId: facts.bridgeCapabilityId,
+    providerId: "mayan-swift-v2",
+    capabilityKind: "external-provider-dynamic",
+    sourceChainId: facts.sourceChainId,
+    destinationChainId: facts.destinationChainId,
+    sourceTokenDeploymentId: facts.sourceTokenDeploymentId,
+    destinationTokenDeploymentId: facts.destinationTokenDeploymentId,
+    sourceTokenAddress: facts.sourceTokenAddress,
+    destinationTokenAddress: facts.destinationTokenAddress,
+    sourceTokenStandard: facts.sourceTokenStandard,
+    destinationTokenStandard: facts.destinationTokenStandard,
+    sourceTokenDecimals: 6,
+    destinationTokenDecimals: 6,
+    sourceProviderChainName: facts.sourceName,
+    destinationProviderChainName: facts.destinationName,
+    sourceProviderChainId: facts.sourceProviderChainId,
+    destinationProviderChainId: facts.destinationProviderChainId,
+    sourceWormholeChainId: facts.sourceWormholeChainId,
+    destinationWormholeChainId: facts.destinationWormholeChainId,
+    sourceUsdcDeploymentId: facts.sourceUsdcDeploymentId,
+    sourceUsdcAddress: facts.sourceUsdcAddress,
+    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,
+    builderEndpoint: DEFAULT_BUILDER_ENDPOINT,
+    explorerEndpoint: DEFAULT_EXPLORER_ENDPOINT,
+    dependencies: facts.sourceChainId === SOLANA_CHAIN_ID ? [...DEPENDENCIES, "jupiter-v6-source-swap"] : [...DEPENDENCIES],
+    status: "active"
+  };
+  const actualKeys = Object.keys(capability).sort();
+  const expectedKeys = Object.keys(expected).sort();
+  if (actualKeys.length !== expectedKeys.length || actualKeys.some((key, index) => key !== expectedKeys[index])) {
+    fail("BRIDGE_UNSUPPORTED_ROUTE");
+  }
+  for (const key of expectedKeys) {
+    const actual = capability[key];
+    const wanted = expected[key];
+    if (Array.isArray(actual) || Array.isArray(wanted)) {
+      if (JSON.stringify(actual) !== JSON.stringify(wanted)) fail("BRIDGE_UNSUPPORTED_ROUTE");
+    } else if (actual !== wanted) {
+      fail("BRIDGE_UNSUPPORTED_ROUTE");
+    }
+  }
+};
+var validateBridgeRoute = (request) => {
+  const value = requireRecord(request, "BRIDGE_INVALID_ARGUMENT");
+  const keys = /* @__PURE__ */ new Set([
+    "sourceChainId",
+    "destinationChainId",
+    "sourceTokenDeploymentId",
+    "destinationTokenDeploymentId",
+    "amountIn",
+    "slippageBps"
+  ]);
+  if (Object.keys(value).some((key) => !keys.has(key))) fail("BRIDGE_INVALID_ARGUMENT");
+  const sourceChainId = requireString(value.sourceChainId, "BRIDGE_INVALID_ARGUMENT");
+  const destinationChainId = requireString(value.destinationChainId, "BRIDGE_INVALID_ARGUMENT");
+  const sourceTokenDeploymentId = requireString(
+    value.sourceTokenDeploymentId,
+    "BRIDGE_INVALID_ARGUMENT"
+  );
+  const destinationTokenDeploymentId = requireString(
+    value.destinationTokenDeploymentId,
+    "BRIDGE_INVALID_ARGUMENT"
+  );
+  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");
+  }
+  validateCatalogDirection(facts);
+  const capability = findCapability(facts);
+  validateCapability(capability, facts);
+  return {
+    request: {
+      sourceChainId,
+      destinationChainId,
+      sourceTokenDeploymentId,
+      destinationTokenDeploymentId,
+      amountIn: amountIn.source,
+      slippageBps
+    },
+    facts,
+    capability
+  };
+};
+var isJsonWhitespace = (character) => character === " " || character === "\n" || character === "\r" || character === "	";
+var StrictJsonParser = class {
+  #source;
+  #index = 0;
+  constructor(source) {
+    this.#source = source;
+  }
+  parse() {
+    this.#skipWhitespace();
+    const value = this.#value(0);
+    this.#skipWhitespace();
+    if (this.#index !== this.#source.length) this.#invalid();
+    return value;
+  }
+  #value(depth) {
+    if (depth > MAX_JSON_DEPTH) this.#invalid();
+    const start = this.#index;
+    const character = this.#source[this.#index];
+    if (character === "{") return this.#object(start, depth);
+    if (character === "[") return this.#array(start, depth);
+    if (character === '"') {
+      const value = this.#string();
+      return { value, start, end: this.#index };
+    }
+    if (character === "t" && this.#source.startsWith("true", this.#index)) {
+      this.#index += 4;
+      return { value: true, start, end: this.#index };
+    }
+    if (character === "f" && this.#source.startsWith("false", this.#index)) {
+      this.#index += 5;
+      return { value: false, start, end: this.#index };
+    }
+    if (character === "n" && this.#source.startsWith("null", this.#index)) {
+      this.#index += 4;
+      return { value: null, start, end: this.#index };
+    }
+    if (character === "-" || character !== void 0 && /[0-9]/u.test(character)) {
+      const rawNumber = this.#number();
+      const value = Number(rawNumber);
+      if (!Number.isFinite(value)) this.#invalid();
+      return { value, start, end: this.#index, rawNumber };
+    }
+    return this.#invalid();
+  }
+  #object(start, depth) {
+    this.#index += 1;
+    this.#skipWhitespace();
+    const object = /* @__PURE__ */ Object.create(null);
+    const entries = /* @__PURE__ */ new Map();
+    if (this.#source[this.#index] === "}") {
+      this.#index += 1;
+      return { value: object, start, end: this.#index, objectEntries: entries };
+    }
+    while (true) {
+      if (this.#source[this.#index] !== '"') this.#invalid();
+      const key = this.#string();
+      if (entries.has(key)) this.#invalid();
+      this.#skipWhitespace();
+      if (this.#source[this.#index] !== ":") this.#invalid();
+      this.#index += 1;
+      this.#skipWhitespace();
+      const child = this.#value(depth + 1);
+      Object.defineProperty(object, key, {
+        configurable: true,
+        enumerable: true,
+        value: child.value,
+        writable: true
+      });
+      entries.set(key, child);
+      this.#skipWhitespace();
+      const delimiter = this.#source[this.#index];
+      if (delimiter === "}") {
+        this.#index += 1;
+        return {
+          value: object,
+          start,
+          end: this.#index,
+          objectEntries: entries
+        };
+      }
+      if (delimiter !== ",") this.#invalid();
+      this.#index += 1;
+      this.#skipWhitespace();
+    }
+  }
+  #array(start, depth) {
+    this.#index += 1;
+    this.#skipWhitespace();
+    const items = [];
+    if (this.#source[this.#index] === "]") {
+      this.#index += 1;
+      return { value: items, start, end: this.#index, arrayItems: items };
+    }
+    while (true) {
+      items.push(this.#value(depth + 1));
+      this.#skipWhitespace();
+      const delimiter = this.#source[this.#index];
+      if (delimiter === "]") {
+        this.#index += 1;
+        return { value: items, start, end: this.#index, arrayItems: items };
+      }
+      if (delimiter !== ",") this.#invalid();
+      this.#index += 1;
+      this.#skipWhitespace();
+    }
+  }
+  #string() {
+    const start = this.#index;
+    this.#index += 1;
+    while (this.#index < this.#source.length) {
+      const character = this.#source[this.#index];
+      if (character === '"') {
+        this.#index += 1;
+        const raw = this.#source.slice(start, this.#index);
+        try {
+          return JSON.parse(raw);
+        } catch {
+          this.#invalid();
+        }
+      }
+      if (character === "\\") {
+        this.#index += 1;
+        const escape = this.#source[this.#index];
+        if (escape === "u") {
+          const digits = this.#source.slice(this.#index + 1, this.#index + 5);
+          if (!/^[0-9a-fA-F]{4}$/u.test(digits)) this.#invalid();
+          this.#index += 5;
+          continue;
+        }
+        if (escape === void 0 || !'"\\/bfnrt'.includes(escape)) this.#invalid();
+        this.#index += 1;
+        continue;
+      }
+      if (character === void 0 || character.charCodeAt(0) < 32) this.#invalid();
+      this.#index += 1;
+    }
+    return this.#invalid();
+  }
+  #number() {
+    const match = /-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/uy.exec(
+      this.#source.slice(this.#index)
+    );
+    if (!match) this.#invalid();
+    const raw = match?.[0];
+    this.#index += raw.length;
+    return raw;
+  }
+  #skipWhitespace() {
+    while (this.#index < this.#source.length && isJsonWhitespace(this.#source[this.#index] ?? "")) {
+      this.#index += 1;
+    }
+  }
+  #invalid() {
+    return fail("BRIDGE_PROVIDER_INVALID_RESPONSE");
+  }
+};
+var parseProviderResponse = (text) => {
+  let root;
+  try {
+    root = new StrictJsonParser(text).parse();
+  } catch (error) {
+    if (error instanceof BridgeError) throw error;
+    return fail("BRIDGE_PROVIDER_INVALID_RESPONSE");
+  }
+  return { text, root };
+};
+var objectEntry = (node, key) => node.objectEntries?.get(key);
+var objectValue5 = (node, key) => objectEntry(node, key)?.value;
+var byteLength = (value) => new TextEncoder().encode(value).byteLength;
+var requestAbortError = () => new DOMException("The bridge provider request was aborted", "AbortError");
+var throwIfRequestAborted = (controlled, external) => {
+  if (controlled.timedOut()) fail("BRIDGE_TIMEOUT");
+  if (external?.aborted) fail("BRIDGE_ABORTED");
+};
+var readWithSignal = async (reader, signal) => {
+  if (signal.aborted) throw signal.reason ?? requestAbortError();
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = () => {
+      signal.removeEventListener("abort", onAbort);
+    };
+    const onAbort = () => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(signal.reason ?? requestAbortError());
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    let read;
+    try {
+      read = reader.read();
+    } catch (error) {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(error);
+      return;
+    }
+    void read.then(
+      (result) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        resolve(result);
+      },
+      (error) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(error);
+      }
+    );
+  });
+};
+var cancelResponseBody = (response) => {
+  const body = response.body;
+  if (body === null || response.bodyUsed) return;
+  try {
+    void body.cancel().catch(() => void 0);
+  } catch {
+  }
+};
+var decodeResponseBody = async (response, controlled, external) => {
+  throwIfRequestAborted(controlled, external);
+  const contentLength = response.headers.get("content-length");
+  if (contentLength !== null && /^\d+$/u.test(contentLength)) {
+    try {
+      if (BigInt(contentLength) > BigInt(MAX_RESPONSE_BYTES)) {
+        fail("BRIDGE_PROVIDER_INVALID_RESPONSE");
+      }
+    } catch {
+    }
+  }
+  const body = response.body;
+  if (body === null) return "";
+  let reader;
+  try {
+    reader = body.getReader();
+  } catch {
+    return fail("BRIDGE_PROVIDER_TRANSPORT");
+  }
+  const chunks = [];
+  let totalBytes = 0;
+  let bodyComplete = false;
+  const releaseReader = () => {
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  };
+  try {
+    while (true) {
+      let result;
+      try {
+        result = await readWithSignal(reader, controlled.signal);
+      } catch (error) {
+        throwIfRequestAborted(controlled, external);
+        if (error instanceof BridgeError) throw error;
+        return fail("BRIDGE_PROVIDER_TRANSPORT");
+      }
+      throwIfRequestAborted(controlled, external);
+      if (result.done) {
+        bodyComplete = true;
+        break;
+      }
+      const chunk = result.value;
+      if (!(chunk instanceof Uint8Array)) return fail("BRIDGE_PROVIDER_TRANSPORT");
+      totalBytes += chunk.byteLength;
+      if (totalBytes > MAX_RESPONSE_BYTES) {
+        fail("BRIDGE_PROVIDER_INVALID_RESPONSE");
+      }
+      chunks.push(chunk);
+    }
+    throwIfRequestAborted(controlled, external);
+    const bytes = new Uint8Array(totalBytes);
+    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 {
+      return fail("BRIDGE_PROVIDER_INVALID_RESPONSE");
+    }
+  } finally {
+    if (!bodyComplete) {
+      try {
+        const cancellation = reader.cancel();
+        void cancellation.then(releaseReader, releaseReader);
+      } catch {
+      }
+    }
+    releaseReader();
+  }
+};
+var CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "builderEndpoint",
+  "explorerEndpoint",
+  "builderApiKey",
+  "allowUnauthenticatedBuild",
+  "minimumQuoteValiditySeconds",
+  "timeoutMs",
+  "fetch"
+]);
+var endpointWithPath2 = (base, path) => new URL(path.replace(/^\/+/, ""), `${base.toString().replace(/\/+$/u, "")}/`);
+var normalizeProviderEndpoint = (value, fallback, label) => {
+  const sourceValue = value === void 0 ? fallback : value;
+  if (typeof sourceValue !== "string") return fail("BRIDGE_INVALID_ARGUMENT");
+  const source = sourceValue;
+  if (source.length === 0 || source.trim() !== source) {
+    fail("BRIDGE_INVALID_ARGUMENT");
+  }
+  if (!/^[a-z][a-z\d+.-]*:\/\//iu.test(source) || source.includes("#")) {
+    fail("BRIDGE_INVALID_ARGUMENT");
+  }
+  const authorityStart = source.indexOf("://") + 3;
+  const authority = source.slice(authorityStart).split(/[/?#]/u, 1)[0] ?? "";
+  if (authority.length === 0 || authority.includes("@")) fail("BRIDGE_INVALID_ARGUMENT");
+  let endpoint;
+  try {
+    endpoint = new URL(source);
+  } catch {
+    return fail("BRIDGE_INVALID_ARGUMENT");
+  }
+  if (endpoint.protocol !== "https:" && !(endpoint.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]", "::1"].includes(endpoint.hostname))) {
+    fail("BRIDGE_INVALID_ARGUMENT");
+  }
+  if (!endpoint.hostname || endpoint.username || endpoint.password || source.includes("?") || endpoint.search || endpoint.hash) {
+    fail("BRIDGE_INVALID_ARGUMENT");
+  }
+  if (endpoint.port !== "" && (!/^\d+$/u.test(endpoint.port) || Number(endpoint.port) > 65535)) {
+    fail("BRIDGE_INVALID_ARGUMENT");
+  }
+  endpoint.pathname = endpoint.pathname.replace(/\/+$/u, "") || "/";
+  if (!endpoint.pathname.startsWith("/")) fail("BRIDGE_INVALID_ARGUMENT");
+  return endpoint;
+};
+var normalizeBridgeConfig = (config) => {
+  const value = config === void 0 ? {} : requireRecord(config, "BRIDGE_INVALID_ARGUMENT");
+  if (Object.keys(value).some((key) => !CONFIG_KEYS.has(key))) {
+    fail("BRIDGE_INVALID_ARGUMENT");
+  }
+  const builderEndpoint = normalizeProviderEndpoint(
+    value.builderEndpoint,
+    DEFAULT_BUILDER_ENDPOINT);
+  const explorerEndpoint = normalizeProviderEndpoint(
+    value.explorerEndpoint,
+    DEFAULT_EXPLORER_ENDPOINT);
+  let builderApiKey;
+  if (value.builderApiKey !== void 0) {
+    const builderApiKeyValue = value.builderApiKey;
+    if (typeof builderApiKeyValue !== "string" || /[\u0000-\u001f\u007f]/u.test(builderApiKeyValue)) {
+      fail("BRIDGE_INVALID_ARGUMENT");
+    }
+    const validatedBuilderApiKey = builderApiKeyValue;
+    builderApiKey = validatedBuilderApiKey.length === 0 ? void 0 : validatedBuilderApiKey;
+  }
+  const allowUnauthenticatedBuildValue = value.allowUnauthenticatedBuild ?? false;
+  if (typeof allowUnauthenticatedBuildValue !== "boolean") {
+    fail("BRIDGE_INVALID_ARGUMENT");
+  }
+  const allowUnauthenticatedBuild = allowUnauthenticatedBuildValue;
+  const minimumQuoteValiditySecondsValue = value.minimumQuoteValiditySeconds ?? 60;
+  if (typeof minimumQuoteValiditySecondsValue !== "number" || !Number.isSafeInteger(minimumQuoteValiditySecondsValue) || minimumQuoteValiditySecondsValue < 0 || minimumQuoteValiditySecondsValue > 300) {
+    fail("BRIDGE_INVALID_ARGUMENT");
+  }
+  const minimumQuoteValiditySeconds = minimumQuoteValiditySecondsValue;
+  const timeoutMsValue = value.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+  if (typeof timeoutMsValue !== "number" || !Number.isSafeInteger(timeoutMsValue) || timeoutMsValue <= 0) {
+    fail("BRIDGE_INVALID_ARGUMENT");
+  }
+  const timeoutMs = timeoutMsValue;
+  const implementation = value.fetch ?? globalThis.fetch;
+  if (typeof implementation !== "function") fail("BRIDGE_INVALID_ARGUMENT");
+  return Object.freeze({
+    builderEndpoint,
+    explorerEndpoint,
+    ...builderApiKey === void 0 ? {} : { builderApiKey },
+    allowUnauthenticatedBuild,
+    minimumQuoteValiditySeconds,
+    timeoutMs,
+    fetch: implementation
+  });
+};
+var requestSignal = (timeoutMs, external) => {
+  const controller = new AbortController();
+  let timedOut = false;
+  const timeout = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, timeoutMs);
+  const onAbort = () => controller.abort();
+  if (external?.aborted) controller.abort();
+  else external?.addEventListener("abort", onAbort, { once: true });
+  return {
+    signal: controller.signal,
+    timedOut: () => timedOut,
+    cleanup: () => {
+      clearTimeout(timeout);
+      external?.removeEventListener("abort", onAbort);
+    }
+  };
+};
+var providerRequest = async (config, endpoint, method, body, includeBuilderKey, options) => {
+  if (options?.signal?.aborted) fail("BRIDGE_ABORTED");
+  const controlled = requestSignal(config.timeoutMs, options?.signal);
+  try {
+    const headers = {};
+    headers.accept = "application/json";
+    if (body !== void 0) headers["content-type"] = "application/json";
+    if (includeBuilderKey && config.builderApiKey !== void 0) {
+      headers["x-api-key"] = config.builderApiKey;
+    }
+    let response;
+    try {
+      response = await config.fetch(endpoint, {
+        method,
+        headers,
+        ...body === void 0 ? {} : { body },
+        signal: controlled.signal,
+        credentials: "omit",
+        redirect: "manual"
+      });
+      if (controlled.timedOut()) fail("BRIDGE_TIMEOUT");
+      if (options?.signal?.aborted) fail("BRIDGE_ABORTED");
+    } catch {
+      if (controlled.timedOut()) fail("BRIDGE_TIMEOUT");
+      if (options?.signal?.aborted) fail("BRIDGE_ABORTED");
+      return fail("BRIDGE_PROVIDER_TRANSPORT");
+    }
+    return {
+      response,
+      controlled,
+      external: options?.signal
+    };
+  } catch (error) {
+    controlled.cleanup();
+    if (error instanceof BridgeError) throw error;
+    if (controlled.timedOut()) fail("BRIDGE_TIMEOUT");
+    if (options?.signal?.aborted) fail("BRIDGE_ABORTED");
+    return fail("BRIDGE_PROVIDER_TRANSPORT");
+  }
+};
+var providerHttpStatus = (response, kind) => {
+  if (kind === "status" && response.status === 404) fail("BRIDGE_STATUS_NOT_FOUND");
+  if (response.status >= 300 && response.status < 400) {
+    fail("BRIDGE_PROVIDER_TRANSPORT");
+  }
+  if (kind === "build" && (response.status === 401 || response.status === 403)) {
+    fail("BRIDGE_PROVIDER_AUTH_REQUIRED");
+  }
+  if (response.status !== 200 && response.status !== 201) {
+    fail("BRIDGE_PROVIDER_HTTP", response.status);
+  }
+};
+var providerJson = async (request, kind) => {
+  try {
+    providerHttpStatus(request.response, kind);
+    const text = await decodeResponseBody(
+      request.response,
+      request.controlled,
+      request.external
+    );
+    throwIfRequestAborted(request.controlled, request.external);
+    const parsed = parseProviderResponse(text);
+    throwIfRequestAborted(request.controlled, request.external);
+    return parsed;
+  } finally {
+    cancelResponseBody(request.response);
+    request.controlled.cleanup();
+  }
+};
+var encodeBase58 = (bytes) => {
+  let zeroes = 0;
+  while (zeroes < bytes.length && bytes[zeroes] === 0) zeroes += 1;
+  if (zeroes === bytes.length) return "1".repeat(zeroes);
+  const digits = [0];
+  for (const byte of bytes) {
+    let carry = byte;
+    for (let index = 0; index < digits.length; index += 1) {
+      const value = (digits[index] ?? 0) * 256 + carry;
+      digits[index] = value % 58;
+      carry = Math.floor(value / 58);
+    }
+    while (carry > 0) {
+      digits.push(carry % 58);
+      carry = Math.floor(carry / 58);
+    }
+  }
+  let result = "1".repeat(zeroes);
+  for (let index = digits.length - 1; index >= 0; index -= 1) {
+    result += BASE58_ALPHABET[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))) {
+    fail(code);
+  }
+  const bytes = [0];
+  for (const char of text) {
+    const digit = BASE58_ALPHABET.indexOf(char);
+    let carry = digit;
+    for (let index = 0; index < bytes.length; index += 1) {
+      const current = (bytes[index] ?? 0) * 58 + carry;
+      bytes[index] = current % 256;
+      carry = Math.floor(current / 256);
+    }
+    while (carry > 0) {
+      bytes.push(carry % 256);
+      carry = Math.floor(carry / 256);
+    }
+  }
+  let zeroes = 0;
+  while (zeroes < text.length && text[zeroes] === "1") zeroes += 1;
+  const result = new Uint8Array(zeroes + (bytes.length === 1 && bytes[0] === 0 ? 0 : bytes.length));
+  for (let index = 0; index < bytes.length && !(bytes.length === 1 && bytes[0] === 0); index += 1) {
+    result[result.length - 1 - index] = bytes[index] ?? 0;
+  }
+  if (result.length !== expectedBytes || encodeBase58(result) !== text) fail(code);
+  return result;
+};
+var decodeBase64 = (value, code) => {
+  const text = requireString(value, code);
+  if (!BASE64.test(text)) fail(code);
+  let binary;
+  try {
+    binary = globalThis.atob(text);
+  } catch {
+    return fail(code);
+  }
+  const result = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+  let canonical;
+  try {
+    canonical = globalThis.btoa(binary);
+  } catch {
+    return fail(code);
+  }
+  if (canonical !== text) fail(code);
+  return result;
+};
+var readBytes = (cursor, count, code) => {
+  if (!Number.isSafeInteger(count) || count < 0 || cursor.index + count > cursor.bytes.length) fail(code);
+  const value = cursor.bytes.slice(cursor.index, cursor.index + count);
+  cursor.index += count;
+  return value;
+};
+var readShortVec = (cursor, maximum, code) => {
+  let value = 0;
+  let shift = 0;
+  for (let count = 0; count < 5; count += 1) {
+    const byte = readBytes(cursor, 1, code)[0] ?? 0;
+    const payload = byte & 127;
+    if (shift >= 28 || payload > Math.floor(Number.MAX_SAFE_INTEGER / 2 ** shift)) fail(code);
+    value += payload * 2 ** shift;
+    if ((byte & 128) === 0) {
+      if (count > 0 && payload === 0) fail(code);
+      if (!Number.isSafeInteger(value) || value > maximum) fail(code);
+      return value;
+    }
+    shift += 7;
+  }
+  return fail(code);
+};
+var allZero = (bytes) => bytes.every((byte) => byte === 0);
+var validateSolanaTransaction = (encoded, feePayer) => {
+  const bytes = decodeBase64(encoded, "BRIDGE_BUILD_INVALID");
+  if (bytes.byteLength === 0 || bytes.byteLength > 1232) fail("BRIDGE_BUILD_INVALID");
+  const cursor = { bytes, index: 0 };
+  const signatureCount = readShortVec(cursor, 1, "BRIDGE_BUILD_INVALID");
+  if (signatureCount !== 1 || !allZero(readBytes(cursor, 64, "BRIDGE_BUILD_INVALID"))) {
+    fail("BRIDGE_BUILD_INVALID");
+  }
+  const version = readBytes(cursor, 1, "BRIDGE_BUILD_INVALID")[0];
+  if (version !== 128) fail("BRIDGE_BUILD_INVALID");
+  const requiredSignatures = readBytes(cursor, 1, "BRIDGE_BUILD_INVALID")[0] ?? 0;
+  const readonlySigned = readBytes(cursor, 1, "BRIDGE_BUILD_INVALID")[0] ?? 0;
+  const readonlyUnsigned = readBytes(cursor, 1, "BRIDGE_BUILD_INVALID")[0] ?? 0;
+  if (requiredSignatures !== 1 || readonlySigned !== 0) fail("BRIDGE_BUILD_INVALID");
+  const staticKeyCount = readShortVec(cursor, 64, "BRIDGE_BUILD_INVALID");
+  if (staticKeyCount === 0 || readonlyUnsigned >= staticKeyCount) fail("BRIDGE_BUILD_INVALID");
+  const staticKeys = readBytes(cursor, staticKeyCount * 32, "BRIDGE_BUILD_INVALID");
+  const payerBytes = decodeBase58(feePayer, 32, "BRIDGE_BUILD_INVALID");
+  if (!staticKeys.slice(0, 32).every((byte, index) => byte === payerBytes[index])) fail("BRIDGE_BUILD_INVALID");
+  readBytes(cursor, 32, "BRIDGE_BUILD_INVALID");
+  const instructionCount = readShortVec(cursor, 64, "BRIDGE_BUILD_INVALID");
+  let largestAccountIndex = -1;
+  for (let instruction = 0; instruction < instructionCount; instruction += 1) {
+    largestAccountIndex = Math.max(
+      largestAccountIndex,
+      readBytes(cursor, 1, "BRIDGE_BUILD_INVALID")[0] ?? 0
+    );
+    const accountCount = readShortVec(cursor, 64, "BRIDGE_BUILD_INVALID");
+    const accountIndices = readBytes(cursor, accountCount, "BRIDGE_BUILD_INVALID");
+    for (const index of accountIndices) largestAccountIndex = Math.max(largestAccountIndex, index);
+    const dataLength = readShortVec(cursor, 1024, "BRIDGE_BUILD_INVALID");
+    readBytes(cursor, dataLength, "BRIDGE_BUILD_INVALID");
+  }
+  const lookupCount = readShortVec(cursor, 32, "BRIDGE_BUILD_INVALID");
+  let loadedAddressCount = 0;
+  for (let lookup = 0; lookup < lookupCount; lookup += 1) {
+    readBytes(cursor, 32, "BRIDGE_BUILD_INVALID");
+    const writableCount = readShortVec(cursor, 64, "BRIDGE_BUILD_INVALID");
+    readBytes(cursor, writableCount, "BRIDGE_BUILD_INVALID");
+    const readonlyCount = readShortVec(cursor, 64, "BRIDGE_BUILD_INVALID");
+    readBytes(cursor, readonlyCount, "BRIDGE_BUILD_INVALID");
+    loadedAddressCount += writableCount + readonlyCount;
+    if (loadedAddressCount > 256) fail("BRIDGE_BUILD_INVALID");
+  }
+  if (largestAccountIndex >= staticKeyCount + loadedAddressCount || cursor.index !== bytes.length) {
+    fail("BRIDGE_BUILD_INVALID");
+  }
+  return requireString(encoded, "BRIDGE_BUILD_INVALID");
+};
+var providerInvalid = () => fail("BRIDGE_PROVIDER_INVALID_RESPONSE");
+var requiredNode = (node, key) => {
+  const child = objectEntry(node, key);
+  if (!child) providerInvalid();
+  return child;
+};
+var providerString = (node, key, allowEmpty = false) => {
+  const value = requiredNode(node, key).value;
+  if (typeof value !== "string" || !allowEmpty && value.length === 0) {
+    providerInvalid();
+  }
+  return value;
+};
+var providerBoolean = (node, key) => {
+  const value = requiredNode(node, key).value;
+  if (typeof value !== "boolean") providerInvalid();
+  return value;
+};
+var providerNumber = (node, key) => {
+  const value = requiredNode(node, key).value;
+  if (typeof value !== "number" || !Number.isFinite(value)) providerInvalid();
+  return value;
+};
+var providerInteger = (node, key) => {
+  const value = providerNumber(node, key);
+  if (!Number.isSafeInteger(value)) providerInvalid();
+  return value;
+};
+var providerAddress = (node, key, expected) => {
+  const value = providerString(node, key);
+  if (!providerAddressEquals(value, expected)) providerInvalid();
+  return EVM_ADDRESS2.test(value) ? value.toLowerCase() : value;
+};
+var providerUint64 = (node, key, positive) => {
+  const value = providerString(node, key);
+  try {
+    return positive ? normalizePositiveUint64(value, "BRIDGE_PROVIDER_INVALID_RESPONSE") : normalizeCanonicalUint64(value, "BRIDGE_PROVIDER_INVALID_RESPONSE");
+  } catch (error) {
+    if (error instanceof BridgeError) throw error;
+    return providerInvalid();
+  }
+};
+var providerToken = (node, expected) => {
+  if (!isRecord4(node.value)) providerInvalid();
+  const contract = providerString(node, "contract");
+  if (!providerAddressEquals(contract, expected.address)) providerInvalid();
+  const mint = providerString(node, "mint", true);
+  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, "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 ensureQuoteDeadline = (deadlineValue, margin) => {
+  const now = BigInt(Math.floor(Date.now() / 1e3));
+  if (!Number.isSafeInteger(Number(now)) || deadlineValue < now + BigInt(margin)) {
+    fail("BRIDGE_QUOTE_EXPIRED");
+  }
+};
+var validateProviderQuote = (node, text, request, facts, config) => {
+  if (!isRecord4(node.value)) providerInvalid();
+  const raw = text.slice(node.start, node.end);
+  if (byteLength(raw) > MAX_RAW_QUOTE_BYTES) providerInvalid();
+  if (providerString(node, "type") !== "SWIFT") providerInvalid();
+  if (providerString(node, "swiftVersion") !== "V2") providerInvalid();
+  if (providerBoolean(node, "gasless")) providerInvalid();
+  if (providerString(node, "fromChain") !== facts.sourceName) providerInvalid();
+  if (providerString(node, "toChain") !== facts.destinationName) providerInvalid();
+  if (providerInteger(node, "slippageBps") !== request.slippageBps) providerInvalid();
+  if (providerBoolean(node, "onlyBridging")) providerInvalid();
+  const effectiveAmount = providerUint64(node, "effectiveAmountIn64", true);
+  if (effectiveAmount.source !== request.amountIn) providerInvalid();
+  const expectedAmountOut = providerUint64(node, "expectedAmountOutBaseUnits", true);
+  const minimumAmountOut = providerUint64(node, "minAmountOutBaseUnits", true);
+  const minimumReceived = providerUint64(node, "minReceivedBaseUnits", true);
+  if (minimumAmountOut.value > expectedAmountOut.value || minimumReceived.value > minimumAmountOut.value) {
+    providerInvalid();
+  }
+  const deadline = providerUint64(node, "deadline64", true);
+  ensureQuoteDeadline(deadline.value, config.minimumQuoteValiditySeconds);
+  const sourceToken = requiredNode(node, "fromToken");
+  const destinationToken = requiredNode(node, "toToken");
+  providerToken(sourceToken, {
+    address: facts.sourceTokenAddress,
+    standard: facts.sourceChainId === ETHEREUM_CHAIN_ID ? "erc20" : "spl",
+    chainId: facts.sourceProviderChainId,
+    wormholeChainId: facts.sourceWormholeChainId,
+    mint: facts.sourceEurcMint
+  });
+  providerToken(destinationToken, {
+    address: facts.destinationTokenAddress,
+    standard: facts.destinationChainId === ETHEREUM_CHAIN_ID ? "erc20" : "spl",
+    chainId: facts.destinationProviderChainId,
+    wormholeChainId: facts.destinationWormholeChainId,
+    mint: facts.destinationEurcMint
+  });
+  const sourceUsdcStandard = quoteProviderStandard(facts);
+  if (providerAddress(node, "swiftInputContract", facts.sourceUsdcAddress) !== facts.sourceUsdcAddress) {
+    providerInvalid();
+  }
+  if (providerString(node, "swiftInputContractStandard") !== sourceUsdcStandard) providerInvalid();
+  if (providerInteger(node, "swiftInputDecimals") !== 6) providerInvalid();
+  if (providerAddress(node, "swiftMayanContract", facts.swiftContract) !== facts.swiftContract) {
+    providerInvalid();
+  }
+  const middleNode = requiredNode(node, "minMiddleAmount");
+  if (middleNode.rawNumber === void 0 || typeof middleNode.value !== "number" || !Number.isFinite(middleNode.value) || middleNode.value <= 0) {
+    providerInvalid();
+  }
+  let routerAddress;
+  let routerKind;
+  if (facts.sourceChainId === ETHEREUM_CHAIN_ID) {
+    routerAddress = normalizeEvmAddress3(
+      providerString(node, "evmSwapRouterAddress"),
+      "BRIDGE_PROVIDER_INVALID_RESPONSE"
+    );
+    routerKind = "provider-selected-evm";
+  } else {
+    routerAddress = SOLANA_JUPITER_V6;
+    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 quote = {
+    quoteKind: "mayan-swift-v2",
+    providerId: "mayan-swift-v2",
+    sourceChainId: request.sourceChainId,
+    destinationChainId: request.destinationChainId,
+    sourceTokenDeploymentId: request.sourceTokenDeploymentId,
+    destinationTokenDeploymentId: request.destinationTokenDeploymentId,
+    amountIn: effectiveAmount.source,
+    expectedAmountOut: expectedAmountOut.source,
+    minimumAmountOut: minimumAmountOut.source,
+    minimumReceived: minimumReceived.source,
+    deadline: deadline.source,
+    slippageBps: request.slippageBps,
+    quoteId: quoteId.toLowerCase(),
+    providerSignature: signature.toLowerCase(),
+    sourceSwap: {
+      required: true,
+      inputTokenDeploymentId: facts.sourceTokenDeploymentId,
+      intermediateTokenDeploymentId: facts.sourceUsdcDeploymentId,
+      intermediateTokenAddress: facts.sourceUsdcAddress,
+      intermediateTokenStandard: sourceUsdcStandard,
+      intermediateTokenDecimals: 6,
+      providerMinimumAmount: middleNode.rawNumber,
+      routerKind,
+      routerAddress
+    },
+    dependencies,
+    quoteVerification: "provider-signed-not-locally-verified",
+    rawSignedQuoteJson: raw
+  };
+  return {
+    quote: deepFreeze6(quote),
+    rawNode: node,
+    deadlineValue: deadline.value
+  };
+};
+var QUOTE_KEYS = [
+  "quoteKind",
+  "providerId",
+  "sourceChainId",
+  "destinationChainId",
+  "sourceTokenDeploymentId",
+  "destinationTokenDeploymentId",
+  "amountIn",
+  "expectedAmountOut",
+  "minimumAmountOut",
+  "minimumReceived",
+  "deadline",
+  "slippageBps",
+  "quoteId",
+  "providerSignature",
+  "sourceSwap",
+  "dependencies",
+  "quoteVerification",
+  "rawSignedQuoteJson"
+];
+var SOURCE_SWAP_KEYS = [
+  "required",
+  "inputTokenDeploymentId",
+  "intermediateTokenDeploymentId",
+  "intermediateTokenAddress",
+  "intermediateTokenStandard",
+  "intermediateTokenDecimals",
+  "providerMinimumAmount",
+  "routerKind",
+  "routerAddress"
+];
+var exactObjectKeys = (value, expected, code) => {
+  const actual = Object.keys(value).sort();
+  const wanted = [...expected].sort();
+  if (actual.length !== wanted.length || actual.some((key, index) => key !== wanted[index])) {
+    fail(code);
+  }
+};
+var stableJson = (value) => {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (isRecord4(value)) {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+};
+var cloneQuote = (quote) => {
+  try {
+    return JSON.parse(JSON.stringify(quote));
+  } catch {
+    return fail("BRIDGE_INVALID_ARGUMENT");
+  }
+};
+var validateNormalizedQuoteShape = (quote, code) => {
+  const value = requireRecord(quote, code);
+  exactObjectKeys(value, QUOTE_KEYS, 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 amountIn = normalizePositiveUint64(value.amountIn, code);
+  const expectedAmountOut = normalizePositiveUint64(value.expectedAmountOut, code);
+  const minimumAmountOut = normalizePositiveUint64(value.minimumAmountOut, code);
+  const minimumReceived = normalizePositiveUint64(value.minimumReceived, code);
+  if (minimumAmountOut.value > expectedAmountOut.value || minimumReceived.value > minimumAmountOut.value) fail(code);
+  const deadline = normalizePositiveUint64(value.deadline, code);
+  const slippageBps = normalizeSlippage(value.slippageBps, code);
+  if (value.quoteVerification !== "provider-signed-not-locally-verified") fail(code);
+  const quoteId = requireString(value.quoteId, code);
+  if (!/^0x[0-9a-fA-F]{32}$/u.test(quoteId)) fail(code);
+  const signature = requireString(value.providerSignature, 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.intermediateTokenAddress !== facts.sourceUsdcAddress) fail(code);
+  const providerStandard = quoteProviderStandard(facts);
+  if (sourceSwap.intermediateTokenStandard !== providerStandard || 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) {
+    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);
+    normalizedRouterAddress = routerAddress.toLowerCase();
+    normalizedRouterKind = "provider-selected-evm";
+  } else if (sourceSwap.routerKind !== "jupiter-v6" || sourceSwap.routerAddress !== SOLANA_JUPITER_V6) {
+    return fail(code);
+  } else {
+    normalizedRouterAddress = SOLANA_JUPITER_V6;
+    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 rawSignedQuoteJson = requireString(value.rawSignedQuoteJson, code);
+  if (byteLength(rawSignedQuoteJson) > MAX_RAW_QUOTE_BYTES) fail(code);
+  return {
+    quoteKind: "mayan-swift-v2",
+    providerId: "mayan-swift-v2",
+    sourceChainId,
+    destinationChainId,
+    sourceTokenDeploymentId: facts.sourceTokenDeploymentId,
+    destinationTokenDeploymentId: facts.destinationTokenDeploymentId,
+    amountIn: amountIn.source,
+    expectedAmountOut: expectedAmountOut.source,
+    minimumAmountOut: minimumAmountOut.source,
+    minimumReceived: minimumReceived.source,
+    deadline: deadline.source,
+    slippageBps,
+    quoteId: quoteId.toLowerCase(),
+    providerSignature: signature.toLowerCase(),
+    sourceSwap: {
+      required: true,
+      inputTokenDeploymentId: facts.sourceTokenDeploymentId,
+      intermediateTokenDeploymentId: facts.sourceUsdcDeploymentId,
+      intermediateTokenAddress: facts.sourceUsdcAddress,
+      intermediateTokenStandard: providerStandard,
+      intermediateTokenDecimals: 6,
+      providerMinimumAmount,
+      routerKind: normalizedRouterKind,
+      routerAddress: normalizedRouterAddress
+    },
+    dependencies: wantedDependencies,
+    quoteVerification: "provider-signed-not-locally-verified",
+    rawSignedQuoteJson
+  };
+};
+var quoteRequestBody = (route) => JSON.stringify({
+  fromToken: route.facts.sourceTokenAddress,
+  fromChain: route.facts.sourceName,
+  toToken: route.facts.destinationTokenAddress,
+  toChain: route.facts.destinationName,
+  amountIn64: route.request.amountIn,
+  slippageBps: route.request.slippageBps,
+  swift: true,
+  mctp: false,
+  fastMctp: false,
+  wormhole: false,
+  monoChain: false,
+  gasless: false,
+  fullList: true,
+  guaranteedOutput: true,
+  gasDrop: 0
+});
+var quoteFromResponse = (response, request, facts, config) => {
+  if (!isRecord4(response.root.value) || response.root.objectEntries === void 0) {
+    providerInvalid();
+  }
+  if (objectValue5(response.root, "success") !== true) providerInvalid();
+  const quotesNode = requiredNode(response.root, "quotes");
+  const quoteNodes = quotesNode.arrayItems;
+  if (!quoteNodes || quoteNodes.length > MAX_QUOTES) return providerInvalid();
+  const selected = [];
+  for (const quoteNode of quoteNodes) {
+    if (!isRecord4(quoteNode.value)) continue;
+    if (quoteNode.value.type !== "SWIFT" || quoteNode.value.swiftVersion !== "V2" || quoteNode.value.gasless !== false) continue;
+    const validated = validateProviderQuote(
+      quoteNode,
+      response.text,
+      request,
+      facts,
+      config
+    );
+    selected.push(validated.quote);
+  }
+  if (selected.length === 0) fail("BRIDGE_QUOTE_UNAVAILABLE");
+  for (const quote of selected) {
+    ensureQuoteDeadline(
+      normalizePositiveUint64(quote.deadline, "BRIDGE_PROVIDER_INVALID_RESPONSE").value,
+      config.minimumQuoteValiditySeconds
+    );
+  }
+  return deepFreeze6(selected);
+};
+var buildRequestSnapshot = (value) => {
+  const request = requireRecord(value, "BRIDGE_INVALID_ARGUMENT");
+  const allowed = /* @__PURE__ */ new Set(["quote", "swapperAddress", "destinationAddress", "refundAddress"]);
+  if (Object.keys(request).some((key) => !allowed.has(key))) fail("BRIDGE_INVALID_ARGUMENT");
+  if (!Object.hasOwn(request, "quote") || !Object.hasOwn(request, "swapperAddress") || !Object.hasOwn(request, "destinationAddress")) {
+    fail("BRIDGE_INVALID_ARGUMENT");
+  }
+  const rawQuote = request.quote;
+  if (!isRecord4(rawQuote)) fail("BRIDGE_INVALID_ARGUMENT");
+  let quote;
+  try {
+    quote = cloneQuote(rawQuote);
+  } catch {
+    return fail("BRIDGE_INVALID_ARGUMENT");
+  }
+  return {
+    quote,
+    swapperAddress: request.swapperAddress,
+    destinationAddress: request.destinationAddress,
+    refundAddress: request.refundAddress
+  };
+};
+var normalizeChainAddress = (value, chainId, code) => {
+  if (chainId === ETHEREUM_CHAIN_ID) return normalizeEvmAddress3(value, code);
+  const address = requireString(value, code);
+  decodeBase58(address, 32, code);
+  return address;
+};
+var isCanonicalSolanaAddress = (value) => {
+  if (typeof value !== "string") return false;
+  try {
+    decodeBase58(value, 32, "BRIDGE_INVALID_ARGUMENT");
+    return true;
+  } catch {
+    return false;
+  }
+};
+var rejectAddressFromOtherChain = (value, expectedChainId) => {
+  const isEvm = typeof value === "string" && EVM_ADDRESS2.test(value) && !/^0x0{40}$/iu.test(value);
+  const isSolana = isCanonicalSolanaAddress(value);
+  if (expectedChainId === ETHEREUM_CHAIN_ID && isSolana || expectedChainId === SOLANA_CHAIN_ID && isEvm) {
+    fail("BRIDGE_QUOTE_MISMATCH");
+  }
+};
+var normalizeDestinationAddress = (value, destinationChainId) => {
+  return normalizeChainAddress(value, destinationChainId, "BRIDGE_INVALID_ARGUMENT");
+};
+var buildRouteFromQuote = (quote) => {
+  let normalizedQuote;
+  try {
+    normalizedQuote = validateNormalizedQuoteShape(quote, "BRIDGE_QUOTE_MISMATCH");
+  } catch (error) {
+    if (error instanceof BridgeError) throw error;
+    return fail("BRIDGE_QUOTE_MISMATCH");
+  }
+  if (stableJson(quote) !== stableJson(normalizedQuote)) fail("BRIDGE_QUOTE_MISMATCH");
+  const route = validateBridgeRoute({
+    sourceChainId: normalizedQuote.sourceChainId,
+    destinationChainId: normalizedQuote.destinationChainId,
+    sourceTokenDeploymentId: normalizedQuote.sourceTokenDeploymentId,
+    destinationTokenDeploymentId: normalizedQuote.destinationTokenDeploymentId,
+    amountIn: normalizedQuote.amountIn,
+    slippageBps: normalizedQuote.slippageBps
+  });
+  return { route, normalizedQuote };
+};
+var validateRawQuoteForBuild = (quote, route, config) => {
+  let response;
+  try {
+    response = parseProviderResponse(quote.rawSignedQuoteJson);
+  } catch (error) {
+    if (error instanceof BridgeError && error.code === "BRIDGE_QUOTE_EXPIRED") throw error;
+    return fail("BRIDGE_QUOTE_MISMATCH");
+  }
+  if (!isRecord4(response.root.value) || response.root.start !== 0 || response.root.end !== response.text.length) {
+    fail("BRIDGE_QUOTE_MISMATCH");
+  }
+  let rebuilt;
+  try {
+    rebuilt = validateProviderQuote(
+      response.root,
+      response.text,
+      route.request,
+      route.facts,
+      config
+    );
+  } catch (error) {
+    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");
+  return deepFreeze6(quote);
+};
+var numericZero = (value) => {
+  if (typeof value === "number") return Number.isFinite(value) && value === 0;
+  if (typeof value !== "string") return false;
+  if (value === "0") return true;
+  return /^0x0+$/iu.test(value);
+};
+var validateEvmBuildResult = (wrapper, swapperAddress) => {
+  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();
+  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) {
+    providerInvalid();
+  }
+  return {
+    kind: "evm-unsigned-transaction",
+    chainId: "eip155:1",
+    from: swapperAddress,
+    to: ETHEREUM_FORWARDER,
+    data,
+    value: "0"
+  };
+};
+var validateSolanaBuildResult = (wrapper, swapperAddress) => {
+  if (providerString(wrapper, "chainCategory") !== "svm") providerInvalid();
+  if (providerString(wrapper, "quoteType") !== "SWIFT") providerInvalid();
+  const gaslessNode = objectEntry(wrapper, "gasless");
+  if (gaslessNode !== void 0 && gaslessNode.value !== false) providerInvalid();
+  const transaction = requiredNode(wrapper, "transaction");
+  const encoded = validateSolanaTransaction(transaction.value, swapperAddress);
+  return {
+    kind: "solana-v0-unsigned-transaction",
+    chainId: SOLANA_CHAIN_ID,
+    feePayer: swapperAddress,
+    transactionBase64: encoded
+  };
+};
+var validateBuildResponse = (response, quote, facts, swapperAddress) => {
+  if (!isRecord4(response.root.value) || objectValue5(response.root, "success") !== true) {
+    fail("BRIDGE_BUILD_INVALID");
+  }
+  const wrapper = requiredNode(response.root, "transaction");
+  if (!isRecord4(wrapper.value)) fail("BRIDGE_BUILD_INVALID");
+  const signers = objectValue5(wrapper, "signers");
+  if (signers !== void 0 && signers !== null && (!Array.isArray(signers) || signers.length !== 0)) {
+    fail("BRIDGE_BUILD_INVALID");
+  }
+  const swapMessageV0Params = objectValue5(wrapper, "swapMessageV0Params");
+  if (swapMessageV0Params !== void 0 && swapMessageV0Params !== null) {
+    fail("BRIDGE_BUILD_INVALID");
+  }
+  let transaction;
+  try {
+    transaction = facts.sourceChainId === ETHEREUM_CHAIN_ID ? validateEvmBuildResult(wrapper, swapperAddress) : validateSolanaBuildResult(wrapper, swapperAddress);
+  } catch (error) {
+    if (error instanceof BridgeError) {
+      if (error.code === "BRIDGE_BUILD_INVALID") throw error;
+      return fail("BRIDGE_BUILD_INVALID");
+    }
+    return fail("BRIDGE_BUILD_INVALID");
+  }
+  return deepFreeze6({
+    buildKind: "mayan-swift-v2-unsigned",
+    providerId: "mayan-swift-v2",
+    quote,
+    sourceChainId: quote.sourceChainId,
+    destinationChainId: quote.destinationChainId,
+    transaction,
+    allowance: facts.sourceChainId === ETHEREUM_CHAIN_ID ? {
+      tokenDeploymentId: "deployment-0011",
+      tokenAddress: ETHEREUM_EURC_ADDRESS,
+      owner: swapperAddress,
+      spender: ETHEREUM_FORWARDER,
+      requiredAmount: quote.amountIn
+    } : null,
+    validation: {
+      level: "structural",
+      quoteSignatureLocallyVerified: false,
+      transactionSemanticsLocallyVerified: false,
+      settlementLocallyVerified: false
+    },
+    rawProviderBuildJson: response.text
+  });
+};
+var boundedProviderString = (value, code, maximum = 1024) => {
+  if (typeof value !== "string" || value.length === 0 || value.length > maximum) fail(code);
+  return value;
+};
+var statusRequestSnapshot = (value) => {
+  const request = requireRecord(value, "BRIDGE_INVALID_ARGUMENT");
+  exactObjectKeys(request, ["sourceChainId", "sourceTransactionHash"], "BRIDGE_INVALID_ARGUMENT");
+  return {
+    sourceChainId: requireString(request.sourceChainId, "BRIDGE_INVALID_ARGUMENT"),
+    sourceTransactionHash: requireString(request.sourceTransactionHash, "BRIDGE_INVALID_ARGUMENT")
+  };
+};
+var normalizeStatusRequest = (value) => {
+  const request = statusRequestSnapshot(value);
+  if (request.sourceChainId === ETHEREUM_CHAIN_ID) {
+    if (!EVM_HASH.test(request.sourceTransactionHash)) fail("BRIDGE_INVALID_ARGUMENT");
+    return {
+      sourceChainId: request.sourceChainId,
+      sourceTransactionHash: request.sourceTransactionHash.toLowerCase()
+    };
+  }
+  if (request.sourceChainId === SOLANA_CHAIN_ID) {
+    decodeBase58(request.sourceTransactionHash, 64, "BRIDGE_INVALID_ARGUMENT");
+    return request;
+  }
+  return fail("BRIDGE_UNSUPPORTED_ROUTE");
+};
+var statusFromResponse = (response, request) => {
+  if (!isRecord4(response.root.value)) fail("BRIDGE_PROVIDER_INVALID_RESPONSE");
+  const providerClientStatus = boundedProviderString(
+    objectValue5(response.root, "clientStatus"),
+    "BRIDGE_PROVIDER_INVALID_RESPONSE",
+    128
+  );
+  const providerStatusValue = objectValue5(response.root, "status");
+  if (providerStatusValue !== null && providerStatusValue !== void 0 && (typeof providerStatusValue !== "string" || providerStatusValue.length > 1024)) {
+    fail("BRIDGE_PROVIDER_INVALID_RESPONSE");
+  }
+  const providerStatus = providerStatusValue === void 0 ? null : providerStatusValue;
+  const state = providerClientStatus === "INPROGRESS" ? "in-progress" : providerClientStatus === "COMPLETED" ? "completed" : providerClientStatus === "REFUNDED" ? "refunded" : "unknown";
+  return deepFreeze6({
+    statusKind: "mayan-explorer-index",
+    providerId: "mayan-swift-v2",
+    sourceChainId: request.sourceChainId,
+    sourceTransactionHash: request.sourceTransactionHash,
+    state,
+    providerClientStatus,
+    providerStatus,
+    statusVerification: "provider-indexed-not-locally-verified",
+    rawProviderStatusJson: response.text
+  });
+};
+var buildBody = (quote, sourceChainId, swapperAddress, destinationAddress, refundAddress) => {
+  const params = {
+    swapperAddress,
+    destinationAddress
+  };
+  if (sourceChainId === ETHEREUM_CHAIN_ID) params.signerChainId = 1;
+  if (refundAddress !== void 0) params.swiftRefundAddress = refundAddress;
+  return `{"quote":${quote.rawSignedQuoteJson},"params":${JSON.stringify(params)}}`;
+};
+var quoteRequestBodyForRoute = (route) => quoteRequestBody(route);
+var MayanSwiftV2BridgeClient = class {
+  #config;
+  constructor(config) {
+    this.#config = normalizeBridgeConfig(config);
+  }
+  async quoteExactInput(request, options) {
+    const route = validateBridgeRoute(request);
+    const response = await providerRequest(
+      this.#config,
+      endpointWithPath2(this.#config.builderEndpoint, "/quote"),
+      "POST",
+      quoteRequestBodyForRoute(route),
+      false,
+      options
+    );
+    const parsed = await providerJson(response, "quote");
+    const quotes = quoteFromResponse(parsed, route.request, route.facts, this.#config);
+    return deepFreeze6([...quotes]);
+  }
+  async buildUnsigned(request, options) {
+    const snapshot = buildRequestSnapshot(request);
+    const { route, normalizedQuote } = buildRouteFromQuote(snapshot.quote);
+    rejectAddressFromOtherChain(snapshot.swapperAddress, route.facts.sourceChainId);
+    const sourceAddress = normalizeChainAddress(
+      snapshot.swapperAddress,
+      route.facts.sourceChainId,
+      "BRIDGE_INVALID_ARGUMENT"
+    );
+    const destinationAddress = normalizeDestinationAddress(
+      snapshot.destinationAddress,
+      route.facts.destinationChainId
+    );
+    let refundAddress;
+    if (snapshot.refundAddress !== void 0) {
+      refundAddress = normalizeChainAddress(
+        snapshot.refundAddress,
+        route.facts.sourceChainId,
+        "BRIDGE_INVALID_ARGUMENT"
+      );
+    }
+    if (this.#config.builderApiKey === void 0 && !this.#config.allowUnauthenticatedBuild) {
+      fail("BRIDGE_PROVIDER_AUTH_REQUIRED");
+    }
+    const quote = validateRawQuoteForBuild(normalizedQuote, route, this.#config);
+    const response = await providerRequest(
+      this.#config,
+      endpointWithPath2(this.#config.builderEndpoint, "/build"),
+      "POST",
+      buildBody(quote, route.facts.sourceChainId, sourceAddress, destinationAddress, refundAddress),
+      true,
+      options
+    );
+    const parsed = await providerJson(response, "build");
+    ensureQuoteDeadline(
+      normalizePositiveUint64(quote.deadline, "BRIDGE_QUOTE_EXPIRED").value,
+      this.#config.minimumQuoteValiditySeconds
+    );
+    return validateBuildResponse(parsed, quote, route.facts, sourceAddress);
+  }
+  async getStatus(request, options) {
+    const normalized = normalizeStatusRequest(request);
+    const response = await providerRequest(
+      this.#config,
+      endpointWithPath2(
+        this.#config.explorerEndpoint,
+        `/swap/trx/${encodeURIComponent(normalized.sourceTransactionHash)}`
+      ),
+      "GET",
+      void 0,
+      false,
+      options
+    );
+    const parsed = await providerJson(response, "status");
+    return statusFromResponse(parsed, normalized);
+  }
+  close() {
+  }
+};
+var createMayanSwiftV2BridgeClient = (config) => new MayanSwiftV2BridgeClient(config);
+
+export { AVALANCHE_AVAX_METHODS, AVALANCHE_INDEX_METHODS, AVALANCHE_INFO_METHODS, AVALANCHE_PROPOSER_VM_METHODS, AVALANCHE_P_CHAIN_METHODS, AVALANCHE_X_CHAIN_METHODS, AccountClient, BRIDGE_CAPABILITIES_AS_OF_DATE, BRIDGE_CAPABILITIES_CONTENT_DIGEST, BRIDGE_CAPABILITIES_JSON, BRIDGE_ERROR_MESSAGES, BridgeError, CloudCatalogClient, CloudCreditClient, CloudResourcesClient, DEFAULT_ACCOUNT_ENDPOINT, DEFAULT_AVALANCHE_ENDPOINT, DEFAULT_ENDPOINT, DEFAULT_TIMEOUT_MS, DEFAULT_USER_ENDPOINT, DEX_ALIASES, DEX_CATALOG_AS_OF_DATE, DEX_CATALOG_CONTENT_DIGEST, DEX_CATALOG_VERSION, DEX_CHAIN_IDS, DEX_DEPLOYMENTS, ETHEREUM_RPC_METHODS, ETHEREUM_SUBSCRIPTION_METHODS, ErpcAbortedError, ErpcBatchPolicyError, ErpcConfigError, ErpcError, ErpcHttpError, ErpcInvalidResponseError, ErpcJsonRpcError, ErpcNotConfiguredError, ErpcTimeoutError, ErpcTransportError, EthereumSubscriptions, MayanSwiftV2BridgeClient, NATIVE_WRAP_DEFINITIONS, POOL_DEFINITIONS, PendingRpcBatchRequest, PendingRpcRequest, PriceClient, RpcSubscription, SOLANA_ANALYTICS_METHODS, SOLANA_DAS_METHODS, SOLANA_ENHANCED_SUBSCRIPTION_METHODS, SOLANA_HISTORY_METHODS, SOLANA_LEADER_METHODS, SOLANA_RPC_METHODS, SWAP_EXECUTION_CAPABILITIES_AS_OF_DATE, SWAP_EXECUTION_CAPABILITIES_CONTENT_DIGEST, SWAP_EXECUTION_CAPABILITIES_JSON, SWAP_EXECUTION_ERROR_MESSAGES, SWAP_EXECUTION_FUNCTION_SELECTOR, SWAP_EXECUTION_FUNCTION_SIGNATURE, SWAP_QUOTE_ERROR_MESSAGES, SolanaSubscriptions, SwapExecutionError, SwapQuoteError, TOKEN_ALIASES, TOKEN_ASSETS, TOKEN_CATALOG_AS_OF_DATE, TOKEN_CATALOG_CONTENT_DIGEST, TOKEN_CATALOG_VERSION, TOKEN_CHAIN_IDS, TOKEN_DEPLOYMENTS, TOKEN_RANKINGS, TOKEN_RANKINGS_BY_CHAIN, TOKEN_RANKINGS_CONTENT_DIGEST, TOKEN_RANKINGS_METADATA, UsageClient, createErpcClient, createErpcCloudClient, createMayanSwiftV2BridgeClient, dexes, findPoolDefinitionByAddress, findPoolDefinitionsByPair, findTokenDeploymentByAddress, findTokenDeploymentsBySymbol, getDexDeployment, getNativeTokenDeployment, getNativeWrapDefinition, getPoolDefinition, getTokenAsset, getTokenDeployment, listPoolDefinitions, listTokenDeployments, listTokenRankings, pools, tokens };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map