@sky-mavis/ronin-dex 0.0.1

package/dist/index.mjs

@@ -0,0 +1,4835 @@
+// src/internals/types/blockchain.ts
+var Blockchain = /* @__PURE__ */ ((Blockchain2) => {
+  Blockchain2["EVM"] = "evm";
+  Blockchain2["SOLANA"] = "solana";
+  return Blockchain2;
+})(Blockchain || {});
+var EVMChainId = /* @__PURE__ */ ((EVMChainId2) => {
+  EVMChainId2[EVMChainId2["ETHEREUM"] = 1] = "ETHEREUM";
+  EVMChainId2[EVMChainId2["BSC"] = 56] = "BSC";
+  EVMChainId2[EVMChainId2["POLYGON"] = 137] = "POLYGON";
+  EVMChainId2[EVMChainId2["RONIN"] = 2020] = "RONIN";
+  EVMChainId2[EVMChainId2["ARBITRUM"] = 42161] = "ARBITRUM";
+  EVMChainId2[EVMChainId2["BASE"] = 8453] = "BASE";
+  EVMChainId2[EVMChainId2["GOERLI"] = 5] = "GOERLI";
+  EVMChainId2[EVMChainId2["SEPOLIA"] = 11155111] = "SEPOLIA";
+  EVMChainId2[EVMChainId2["SAIGON"] = 2021] = "SAIGON";
+  EVMChainId2[EVMChainId2["MUMBAI"] = 80001] = "MUMBAI";
+  EVMChainId2[EVMChainId2["BSC_TESTNET"] = 97] = "BSC_TESTNET";
+  EVMChainId2[EVMChainId2["BASE_SEPOLIA"] = 84532] = "BASE_SEPOLIA";
+  return EVMChainId2;
+})(EVMChainId || {});
+var NATIVE_ADDRESS = "0x0000000000000000000000000000000000000000";
+var WalletType = /* @__PURE__ */ ((WalletType2) => {
+  WalletType2["SEED_PHRASE"] = "SEED_PHRASE";
+  WalletType2["PRIVATE_KEY"] = "PRIVATE_KEY";
+  WalletType2["TREZOR"] = "TREZOR";
+  WalletType2["LEDGER"] = "LEDGER";
+  WalletType2["MPC"] = "MPC";
+  WalletType2["ADDRESS"] = "ADDRESS";
+  WalletType2["OTHER"] = "OTHER";
+  return WalletType2;
+})(WalletType || {});
+
+// src/internals/utils/chain.ts
+import BigNumber from "bignumber.js";
+var chainIdToNumber = (chainId) => {
+  return new BigNumber(chainId.toString()).toNumber();
+};
+
+// src/internals/utils/signature-id.ts
+var SEPARATOR = "_";
+function createSignatureId(rpcUrl, tokenAddress) {
+  return `${rpcUrl}${SEPARATOR}${tokenAddress}`;
+}
+function parseSignatureId(sigil) {
+  const separatorIndex = sigil.indexOf(SEPARATOR);
+  if (separatorIndex === -1) {
+    throw new Error("Invalid sigil format");
+  }
+  const rpcUrl = sigil.substring(0, separatorIndex);
+  const tokenAddress = sigil.substring(separatorIndex + 1);
+  return [rpcUrl, tokenAddress];
+}
+
+// src/internals/lib/event-emitter/TypedEventEmitter.ts
+var TypedEventEmitter = class {
+  events = {};
+  maxListeners = Infinity;
+  emit = (event, ...args) => {
+    if (this.events[event]) {
+      const len = this.events[event].length;
+      const events = Array.from(this.events[event]);
+      for (const e of events) {
+        e(...args);
+      }
+      return !!len;
+    }
+    return false;
+  };
+  on = (event, listener) => {
+    this.addListener(event, listener);
+    return this;
+  };
+  once = (event, listener) => {
+    const onceListener = ((...args) => {
+      listener(...args);
+      this.removeListener(event, onceListener);
+    });
+    this.addListener(event, onceListener);
+    return this;
+  };
+  addListener = (event, listener) => {
+    if (!(event in this.events)) {
+      this.events[event] = [listener];
+    } else {
+      this.events[event].push(listener);
+    }
+    if (this.maxListeners !== Infinity && this.maxListeners <= this.events[event].length) {
+      console.warn(`Maximum event listeners for "${String(event)}" event!`);
+    }
+    return this;
+  };
+  removeListener = (event, listener) => {
+    if (event in this.events) {
+      const i = this.events[event].indexOf(listener);
+      if (i !== -1) {
+        this.events[event].splice(i, 1);
+      }
+    }
+    return this;
+  };
+  hasListeners = (event) => {
+    return this.events[event] && !!this.events[event].length;
+  };
+  prependListener = (event, listener) => {
+    if (!(event in this.events)) {
+      this.events[event] = [listener];
+    } else {
+      this.events[event].unshift(listener);
+    }
+    return this;
+  };
+  prependOnceListener = (event, listener) => {
+    const onceListener = ((...args) => {
+      listener(...args);
+      this.removeListener(event, onceListener);
+    });
+    this.prependListener(event, onceListener);
+    return this;
+  };
+  off = (event, listener) => {
+    return this.removeListener(event, listener);
+  };
+  removeAllListeners = (event) => {
+    delete this.events[event];
+    return this;
+  };
+  setMaxListeners = (n) => {
+    this.maxListeners = n;
+    return this;
+  };
+  getMaxListeners = () => {
+    return this.maxListeners;
+  };
+  listeners = (event) => {
+    return [...this.events[event]];
+  };
+  rawListeners = (event) => {
+    return this.events[event];
+  };
+  eventNames = () => {
+    return Object.keys(this.events);
+  };
+  listenerCount = (type) => {
+    return this.events[type] && this.events[type].length || 0;
+  };
+};
+
+// src/internals/utils/zod.ts
+function $safeArray(data, schema, options) {
+  try {
+    if (!Array.isArray(data)) {
+      return [];
+    }
+    return data.reduce((accumulator, item) => {
+      const parsed = schema.safeParse({ ...item, ...options?.modifier?.(item) });
+      if (!parsed.success && options?.debug) {
+        const message = options?.schemaName ? `[${options.schemaName}] parsing error: ` : "parsing error: ";
+        console.error(message, {
+          errorData: item,
+          error: parsed.error
+        });
+        return accumulator;
+      }
+      return accumulator.concat(parsed.data);
+    }, []);
+  } catch (error) {
+    options?.debug && console.error("$safeArray", error);
+    return [];
+  }
+}
+
+// src/internals/utils/fetch-mate/FetchMateResponse.ts
+var FetchMateResponse = class _FetchMateResponse {
+  result;
+  constructor(result) {
+    this.result = result;
+  }
+  static success(data) {
+    return new _FetchMateResponse({ success: true, data });
+  }
+  static error(error) {
+    let errorInstance;
+    if (error instanceof Error) {
+      errorInstance = error;
+    } else if (typeof error === "string") {
+      errorInstance = new Error(error);
+    } else {
+      try {
+        const stringified = JSON.stringify(error);
+        errorInstance = new Error(stringified);
+      } catch {
+        errorInstance = new Error("An error occurred");
+      }
+    }
+    return new _FetchMateResponse({ success: false, error: errorInstance });
+  }
+  get data() {
+    return this.result.success ? this.result.data : void 0;
+  }
+  get error() {
+    return this.result.success ? void 0 : this.result.error;
+  }
+  isSuccess() {
+    return this.result.success;
+  }
+  isError() {
+    return !this.result.success;
+  }
+  unwrap() {
+    if (this.result.success) {
+      return this.result.data;
+    } else {
+      throw new Error(
+        "Called unwrap on an error result: " + String(this.result.error)
+      );
+    }
+  }
+  unwrapOr(defaultValue) {
+    return this.result.success ? this.result.data : defaultValue;
+  }
+  unwrapOrElse(fn) {
+    return this.result.success ? this.result.data : fn(this.result.error);
+  }
+  map(fn) {
+    if (this.result.success) {
+      return _FetchMateResponse.success(fn(this.result.data));
+    } else {
+      return _FetchMateResponse.error(
+        this.result.error
+      );
+    }
+  }
+  flatMap(fn) {
+    if (this.result.success) {
+      return fn(this.result.data);
+    } else {
+      return _FetchMateResponse.error(
+        this.result.error
+      );
+    }
+  }
+};
+var FetchMateResponse_default = FetchMateResponse;
+
+// src/internals/utils/fetch-mate/FetchMate.ts
+var FetchMate = class _FetchMate {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      headers: { "Content-Type": "application/json" },
+      timeout: 3e4,
+      ...config
+    };
+  }
+  static create(config) {
+    return new _FetchMate(config);
+  }
+  buildUrl(url, params) {
+    const baseURL = this.config.baseUrl || "";
+    if (!url.startsWith("http")) url = `${baseURL}${url}`;
+    if (!params) return url;
+    const searchParams = new URLSearchParams();
+    Object.entries(params).forEach(([key, value]) => {
+      searchParams.append(key, String(value));
+    });
+    return `${url}${url.includes("?") ? "&" : "?"}${searchParams.toString()}`;
+  }
+  async request(method, url, body, options = {}) {
+    try {
+      const {
+        timeout = this.config.timeout,
+        params,
+        ...requestOptions
+      } = options;
+      const fullURL = this.buildUrl(url, params);
+      const requestInit = {
+        method,
+        headers: {
+          ...this.config.headers,
+          ...requestOptions.headers
+        },
+        credentials: this.config.credentials,
+        ...requestOptions
+      };
+      if (body !== void 0) {
+        if (typeof body === "object" && !(body instanceof FormData)) {
+          requestInit.body = JSON.stringify(body);
+        } else {
+          requestInit.body = body;
+        }
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      try {
+        const response = await fetch(fullURL, {
+          ...requestInit,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        return FetchMateResponse_default.success(response);
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof Error && error.name === "AbortError") {
+          return FetchMateResponse_default.error(
+            new Error(`Request timeout after ${timeout}ms`)
+          );
+        }
+        return FetchMateResponse_default.error(error);
+      }
+    } catch (error) {
+      return FetchMateResponse_default.error(error);
+    }
+  }
+  async requestJson(method, url, body, options = {}) {
+    const responseResult = await this.request(method, url, body, options);
+    if (responseResult.isError()) {
+      return responseResult;
+    }
+    const response = responseResult.unwrap();
+    if (!response.ok) {
+      return FetchMateResponse_default.error(
+        new Error(`HTTP ${response.status}: ${response.statusText}`)
+      );
+    }
+    try {
+      const data = await response.json();
+      return FetchMateResponse_default.success(data);
+    } catch (error) {
+      return FetchMateResponse_default.error(error);
+    }
+  }
+  // HTTP Methods - automatically parse JSON
+  async get(url, options) {
+    return this.requestJson("GET", url, void 0, options);
+  }
+  async post(url, body, options) {
+    return this.requestJson("POST", url, body, options);
+  }
+  async put(url, body, options) {
+    return this.requestJson("PUT", url, body, options);
+  }
+  async patch(url, body, options) {
+    return this.requestJson("PATCH", url, body, options);
+  }
+  async delete(url, options) {
+    return this.requestJson("DELETE", url, void 0, options);
+  }
+  async head(url, options) {
+    return this.requestJson("HEAD", url, void 0, options);
+  }
+  async options(url, options) {
+    return this.requestJson("OPTIONS", url, void 0, options);
+  }
+  // Raw response method (for cases where you need the Response object)
+  async raw(method, url, body, options) {
+    return this.request(method.toUpperCase(), url, body, options);
+  }
+  // Configuration methods
+  baseUrl(url) {
+    this.config.baseUrl = url;
+  }
+  header(key, value) {
+    if (!this.config.headers) {
+      this.config.headers = {};
+    }
+    this.config.headers[key] = value;
+  }
+  headers(headers) {
+    if (!this.config.headers) {
+      this.config.headers = {};
+    }
+    this.config.headers = { ...this.config.headers, ...headers };
+  }
+  timeout(timeout) {
+    this.config.timeout = timeout;
+  }
+  credentials(credentials) {
+    this.config.credentials = credentials;
+  }
+};
+var FetchMate_default = FetchMate;
+
+// src/core/aggregator/schemas.ts
+import { CurrencyAmount as CurrencyAmount3, Percent as Percent4 } from "@uniswap/sdk-core";
+import BigNumber2 from "bignumber.js";
+import { getAddress } from "ethers";
+import JSBI3 from "jsbi";
+import { z as z2 } from "zod";
+
+// src/utils/common.ts
+import { CurrencyAmount, Percent as Percent2 } from "@uniswap/sdk-core";
+import JSBI from "jsbi";
+import { v4 } from "uuid";
+
+// src/configs/common.ts
+import { Percent } from "@uniswap/sdk-core";
+
+// src/types/common.ts
+var Field = /* @__PURE__ */ ((Field2) => {
+  Field2["TokenIn"] = "tokenIn";
+  Field2["TokenOut"] = "tokenOut";
+  return Field2;
+})(Field || {});
+var WrapType = /* @__PURE__ */ ((WrapType2) => {
+  WrapType2["NOT_APPLICABLE"] = "not-applicable";
+  WrapType2["WRAP"] = "wrap";
+  WrapType2["UNWRAP"] = "unwrap";
+  return WrapType2;
+})(WrapType || {});
+var PriceImpactLevel = /* @__PURE__ */ ((PriceImpactLevel2) => {
+  PriceImpactLevel2[PriceImpactLevel2["LOW"] = 0] = "LOW";
+  PriceImpactLevel2[PriceImpactLevel2["MEDIUM"] = 3] = "MEDIUM";
+  PriceImpactLevel2[PriceImpactLevel2["HIGH"] = 5] = "HIGH";
+  PriceImpactLevel2[PriceImpactLevel2["BLOCKED"] = 15] = "BLOCKED";
+  return PriceImpactLevel2;
+})(PriceImpactLevel || {});
+
+// src/types/quote.ts
+var AggregatedQuoteFeeType = /* @__PURE__ */ ((AggregatedQuoteFeeType2) => {
+  AggregatedQuoteFeeType2["DEVELOPMENT"] = "development";
+  AggregatedQuoteFeeType2["PROTOCOL"] = "protocol";
+  AggregatedQuoteFeeType2["NETWORK"] = "network";
+  return AggregatedQuoteFeeType2;
+})(AggregatedQuoteFeeType || {});
+
+// src/types/events.ts
+var DexHandleQuoteState = /* @__PURE__ */ ((DexHandleQuoteState2) => {
+  DexHandleQuoteState2["Authorizing"] = "authorizing";
+  DexHandleQuoteState2["Authorized"] = "authorized";
+  DexHandleQuoteState2["AuthorizeFailed"] = "authorize-failed";
+  DexHandleQuoteState2["ApprovingToken"] = "approving-token";
+  DexHandleQuoteState2["ApprovedToken"] = "approved-token";
+  DexHandleQuoteState2["ApproveTokenFailed"] = "approve-token-failed";
+  DexHandleQuoteState2["SigningPermit"] = "signing-permit";
+  DexHandleQuoteState2["SignedPermit"] = "signed-permit";
+  DexHandleQuoteState2["SignPermitFailed"] = "sign-permit-failed";
+  DexHandleQuoteState2["Wrapping"] = "wrapping";
+  DexHandleQuoteState2["Wrapped"] = "wrapped";
+  DexHandleQuoteState2["Unwrapping"] = "unwrapping";
+  DexHandleQuoteState2["Unwrapped"] = "unwrapped";
+  DexHandleQuoteState2["PopulatingTransaction"] = "populating-transaction";
+  DexHandleQuoteState2["SigningTransaction"] = "signing-transaction";
+  DexHandleQuoteState2["SignedTransaction"] = "signed-transaction";
+  DexHandleQuoteState2["TransactionSubmitted"] = "transaction-submitted";
+  DexHandleQuoteState2["WaitingForNextTransaction"] = "waiting-for-next-transaction";
+  DexHandleQuoteState2["WaitingForReceipt"] = "waiting-for-receipt";
+  DexHandleQuoteState2["Computing"] = "computing";
+  DexHandleQuoteState2["Success"] = "success";
+  DexHandleQuoteState2["Failed"] = "failed";
+  return DexHandleQuoteState2;
+})(DexHandleQuoteState || {});
+
+// src/types/fee.ts
+var NetworkFeeLevel = /* @__PURE__ */ ((NetworkFeeLevel3) => {
+  NetworkFeeLevel3["Low"] = "low";
+  NetworkFeeLevel3["Medium"] = "medium";
+  NetworkFeeLevel3["High"] = "high";
+  NetworkFeeLevel3["Custom"] = "custom";
+  return NetworkFeeLevel3;
+})(NetworkFeeLevel || {});
+
+// src/configs/common.ts
+var NETWORK_PRIMITIVE_FEE_LEVELS = [
+  "low" /* Low */,
+  "medium" /* Medium */,
+  "high" /* High */
+];
+var MIN_SLIPPAGE = new Percent(10, 1e4);
+var DEFAULT_SLIPPAGE = new Percent(50, 1e4);
+var MAX_SLIPPAGE = new Percent(30, 100);
+var PORTION_BIPS = 50;
+var BIPS_BASE = 1e4;
+var DEFAULT_GAS_LIMIT = "21000";
+var DEFAULT_SWAP_GAS_LIMIT = "300000";
+var DEVELOPMENT_FEE_PERCENT = new Percent(PORTION_BIPS, BIPS_BASE);
+var DEFAULT_DEADLINE_FROM_NOW = 60 * 30;
+var MIN_FEE_FOR_GAS = {
+  [1 /* ETHEREUM */]: 10 ** 16,
+  [137 /* POLYGON */]: 10 ** 17,
+  [56 /* BSC */]: 10 ** 16,
+  [8453 /* BASE */]: 10 ** 14,
+  [2020 /* RONIN */]: 2 * 10 ** 16,
+  [42161 /* ARBITRUM */]: 10 ** 14
+};
+var ALLOWED_PRICE_IMPACT_LOW = new Percent(1, 100);
+var ALLOWED_PRICE_IMPACT_MEDIUM = new Percent(3, 100);
+var ALLOWED_PRICE_IMPACT_HIGH = new Percent(5, 100);
+var BLOCKED_PRICE_IMPACT_NON_EXPERT = new Percent(15, 100);
+var IMPACT_TIERS = [
+  BLOCKED_PRICE_IMPACT_NON_EXPERT,
+  ALLOWED_PRICE_IMPACT_HIGH,
+  ALLOWED_PRICE_IMPACT_MEDIUM,
+  ALLOWED_PRICE_IMPACT_LOW
+];
+
+// src/configs/tokens.ts
+import { Token, WETH9 } from "@uniswap/sdk-core";
+var EVM_WETH9 = {
+  ...WETH9,
+  [2020 /* RONIN */]: new Token(
+    2020 /* RONIN */,
+    "0xe514d9deb7966c8be0ca922de8a064264ea6bcd4",
+    18,
+    "WRON",
+    "Wrapped RON"
+  ),
+  [2021 /* SAIGON */]: new Token(
+    2021 /* SAIGON */,
+    "0xa959726154953bae111746e265e6d754f48570e6",
+    18,
+    "WRON",
+    "Wrapped Ronin"
+  )
+};
+
+// src/configs/routers.ts
+var MULTICALL3_ROUTER = "0xca11bde05977b3631167028862be2a173976ca11";
+var UNIVERSAL_DEFAULT_ROUTERS = {
+  katana: "0x5f0acdd3ec767514ff1bf7e79949640bf94576bd",
+  kyberswap: "0x6131b5fae19ea4f9d964eac0408e4408b66337b5",
+  relay: void 0
+};
+
+// src/core/platform/wrap-tokens.ts
+var WRAPPED_TOKENS = /* @__PURE__ */ new Map();
+
+// src/utils/common.ts
+import isNil from "lodash/isNil";
+import get from "lodash/get";
+
+// src/internals/utils/async.ts
+function sleepAsync(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var isReactNative = () => {
+  return typeof navigator !== "undefined" && navigator?.product === "ReactNative";
+};
+
+// src/utils/common.ts
+var ZERO = JSBI.BigInt(0);
+var SOLANA_MIN_FEE_LAMPORTS = 5e5;
+function maxAmountSpend(currencyAmount) {
+  if (!currencyAmount) return void 0;
+  if (currencyAmount.currency.isToken) return currencyAmount;
+  let minForGas;
+  if (currencyAmount.currency?.symbol.toLowerCase() === "sol" && currencyAmount.currency?.decimals === 9) {
+    minForGas = SOLANA_MIN_FEE_LAMPORTS;
+  } else {
+    minForGas = MIN_FEE_FOR_GAS?.[currencyAmount.currency.chainId];
+  }
+  if (!minForGas) return void 0;
+  const subtractedGas = JSBI.subtract(
+    currencyAmount.quotient,
+    JSBI.BigInt(minForGas)
+  );
+  const maxSpend = JSBI.greaterThan(subtractedGas, ZERO) ? subtractedGas : ZERO;
+  return CurrencyAmount.fromRawAmount(currencyAmount.currency, maxSpend);
+}
+function getWrapType(currencyIn, currencyOut) {
+  try {
+    if (currencyIn.chainId !== currencyOut.chainId) {
+      return { type: "not-applicable" /* NOT_APPLICABLE */ };
+    }
+    const chainId = currencyIn.chainId;
+    const wrappedNative = WRAPPED_TOKENS.get(chainId);
+    if (currencyIn.isNative && wrappedNative?.equals(currencyOut)) {
+      return { type: "wrap" /* WRAP */, method: "wrap" };
+    }
+    if (currencyOut.isNative && wrappedNative?.equals(currencyIn)) {
+      return { type: "unwrap" /* UNWRAP */, method: "unwrap" };
+    }
+    return { type: "not-applicable" /* NOT_APPLICABLE */ };
+  } catch (error) {
+    console.error("getting wrap type error:", error);
+    return { type: "not-applicable" /* NOT_APPLICABLE */ };
+  }
+}
+function getQuoteUuid(quote) {
+  try {
+    const fragments = [
+      quote.provider,
+      quote.__origin.payload.direction,
+      quote.__origin.payload.amount,
+      String(quote.chainId),
+      quote.currencyIn.address,
+      quote.currencyOut.address
+    ].filter(Boolean);
+    return fragments.join("#");
+  } catch (error) {
+    return v4();
+  }
+}
+function formatPurePercent(value) {
+  value = typeof value === "string" ? parseFloat(value) : value;
+  if (isNaN(value)) throw new Error(`invalid percent: ${value}`);
+  const bips = Math.round(value * 100);
+  return new Percent2(JSBI.BigInt(bips), BIPS_BASE);
+}
+function sortQuotesByPriority(direction, computedQuotes) {
+  try {
+    if (computedQuotes.length === 0) {
+      throw new Error("No quotes found, skip sorting");
+    }
+    computedQuotes.sort((a, b) => {
+      const field = direction === "exactIn" ? "tokenOut" /* TokenOut */ : "tokenIn" /* TokenIn */;
+      const aAmount = a.amounts[field];
+      const bAmount = b.amounts[field];
+      if (aAmount && bAmount) {
+        if (!aAmount.equalTo(bAmount)) {
+          if (direction === "exactIn") {
+            return bAmount.greaterThan(aAmount) ? 1 : -1;
+          } else {
+            return aAmount.lessThan(bAmount) ? -1 : 1;
+          }
+        }
+      } else if (aAmount && !bAmount) {
+        return -1;
+      } else if (!aAmount && bAmount) {
+        return 1;
+      }
+      const aImpact = a.priceImpact?.value;
+      const bImpact = b.priceImpact?.value;
+      if (aImpact && bImpact) {
+        if (!aImpact.equalTo(bImpact)) return aImpact.lessThan(bImpact) ? -1 : 1;
+      } else if (aImpact && !bImpact) {
+        return -1;
+      } else if (!aImpact && bImpact) {
+        return 1;
+      }
+      return 0;
+    });
+    if (computedQuotes.length > 0 && computedQuotes[0]) {
+      computedQuotes[0].isBestTrade = true;
+    }
+    return computedQuotes;
+  } catch (issue) {
+    if (computedQuotes.length > 0 && computedQuotes[0]) {
+      computedQuotes[0].isBestTrade = true;
+    }
+    return computedQuotes;
+  }
+}
+function safetyKyberRouter(calldataBuilder) {
+  try {
+    const data = get(calldataBuilder, "data");
+    if (isNil(data)) throw "";
+    const origin = JSON.parse(data);
+    return get(origin, "routerAddress");
+  } catch (error) {
+    return get(UNIVERSAL_DEFAULT_ROUTERS, "kyberswap");
+  }
+}
+function getUniveralRouterAddress(provider, calldataBuilder) {
+  const router = get(UNIVERSAL_DEFAULT_ROUTERS, provider);
+  if (!router && provider === "kyberswap") {
+    return safetyKyberRouter(calldataBuilder);
+  }
+  return router;
+}
+function tradeMeaningfullyDiffers(quote, nextQuote) {
+  try {
+    const direction0 = get(quote, "__origin.payload.direction");
+    const direction1 = get(nextQuote, "__origin.payload.direction");
+    return direction0 !== direction1 || !quote.amountIn.currency.equals(nextQuote.amountIn.currency) || !quote.amountOut.currency.equals(nextQuote.amountOut.currency) || nextQuote.worstExecutionPrice.lessThan(quote.worstExecutionPrice);
+  } catch (error) {
+    console.error("error in comparing current and next quote:", error);
+    return false;
+  }
+}
+
+// src/utils/compute.ts
+import { TradeType } from "@sky-mavis/katana-swap";
+import { ZERO_PERCENT } from "@sky-mavis/katana-core";
+import { CurrencyAmount as CurrencyAmount2, Fraction, Percent as Percent3 } from "@uniswap/sdk-core";
+import { BigNumber as EthersBigNumber } from "@ethersproject/bignumber";
+import { FeeAmount } from "@uniswap/v3-sdk";
+import { Pair } from "@uniswap/v2-sdk";
+import JSBI2 from "jsbi";
+import isEmpty from "lodash/isEmpty";
+import get2 from "lodash/get";
+var WARNING_SEVERITY_CACHE = /* @__PURE__ */ new Map();
+var MAX_CACHE_SIZE = 1e3;
+function warningSeverity(priceImpact) {
+  if (!priceImpact) {
+    return 0;
+  }
+  if (priceImpact.lessThan(0)) {
+    return 0;
+  }
+  const key = `${priceImpact.numerator.toString()}-${priceImpact.denominator.toString()}`;
+  if (WARNING_SEVERITY_CACHE.has(key)) {
+    return WARNING_SEVERITY_CACHE.get(key);
+  }
+  let impact = IMPACT_TIERS.length;
+  for (const impactLevel of IMPACT_TIERS) {
+    if (impactLevel.lessThan(priceImpact)) {
+      if (WARNING_SEVERITY_CACHE.size >= MAX_CACHE_SIZE) {
+        const firstKey = WARNING_SEVERITY_CACHE.keys().next().value;
+        if (firstKey !== void 0) {
+          WARNING_SEVERITY_CACHE.delete(firstKey);
+        }
+      }
+      WARNING_SEVERITY_CACHE.set(key, impact);
+      return impact;
+    }
+    impact--;
+  }
+  WARNING_SEVERITY_CACHE.set(key, 0);
+  return 0;
+}
+var BI_1 = new Fraction(JSBI2.BigInt(1));
+var computeMaximumAmountIn = (amountIn, slippageTolerance, tradeType = TradeType.EXACT_INPUT) => {
+  if (tradeType === TradeType.EXACT_INPUT) {
+    return amountIn;
+  }
+  const slippageAdjustedAmountIn = BI_1.add(slippageTolerance).multiply(
+    amountIn.quotient
+  ).quotient;
+  return CurrencyAmount2.fromRawAmount(
+    amountIn.currency,
+    slippageAdjustedAmountIn
+  );
+};
+var computeMinimumAmountOut = (amountOut, slippageTolerance, tradeType = TradeType.EXACT_INPUT) => {
+  if (tradeType === TradeType.EXACT_OUTPUT) {
+    return amountOut;
+  }
+  const slippageAdjustedAmountOut = BI_1.add(slippageTolerance).invert().multiply(amountOut.quotient).quotient;
+  return CurrencyAmount2.fromRawAmount(
+    amountOut.currency,
+    slippageAdjustedAmountOut
+  );
+};
+var MAX_PERCENTAGE = 1e4;
+var THIRTY_BIPS_FEE = new Percent3(JSBI2.BigInt(30), MAX_PERCENTAGE);
+var ONE_HUNDRED_PERCENT = new Percent3(MAX_PERCENTAGE, MAX_PERCENTAGE);
+var INPUT_FRACTION_AFTER_FEE = ONE_HUNDRED_PERCENT.subtract(THIRTY_BIPS_FEE);
+function computeNetworkCost(feeData, gasLimit) {
+  try {
+    let effectiveFee;
+    const isLegacy = "gasPrice" in feeData;
+    if (isLegacy) {
+      effectiveFee = EthersBigNumber.from(get2(feeData, "gasPrice"));
+    } else {
+      const baseFeePerGas = EthersBigNumber.from(get2(feeData, "baseFeePerGas"));
+      const maxFeePerGas = EthersBigNumber.from(get2(feeData, "maxFeePerGas"));
+      const maxPriorityFeePerGas = EthersBigNumber.from(
+        get2(feeData, "maxPriorityFeePerGas")
+      );
+      effectiveFee = baseFeePerGas.add(maxPriorityFeePerGas).gt(maxFeePerGas) ? maxFeePerGas : baseFeePerGas.add(maxPriorityFeePerGas);
+    }
+    if (!effectiveFee || isEmpty(effectiveFee)) {
+      throw new Error("invalid multiplier");
+    }
+    return EthersBigNumber.from(gasLimit).mul(effectiveFee);
+  } catch (error) {
+    console.error("compute network cost failed:", {
+      error,
+      origin: {
+        feeData,
+        gasLimit
+      }
+    });
+    return void 0;
+  }
+}
+
+// src/schema/common.ts
+import { z } from "zod";
+
+// src/model/Token.ts
+import {
+  NativeCurrency as _NativeCurrency,
+  Token as Token2
+} from "@uniswap/sdk-core";
+import get3 from "lodash/get";
+var NativeCurrency = class _NativeCurrency2 extends _NativeCurrency {
+  address;
+  logoUrl;
+  tags;
+  static #cache = {};
+  constructor(payload) {
+    super(payload.chainId, payload.decimals, payload.symbol, payload.name);
+    this.address = get3(payload, "address", NATIVE_ADDRESS);
+    this.logoUrl = get3(payload, "logoUrl");
+    this.tags = get3(payload, "tags");
+  }
+  get wrapped() {
+    const token = WRAPPED_TOKENS.get(this.chainId);
+    if (!token) throw new Error(`wrapped token unsupported: ${this.chainId}`);
+    return token;
+  }
+  equals(other) {
+    return other.isNative && other.chainId === this.chainId;
+  }
+  static onChain(payload) {
+    const cache = get3(this.#cache, payload.chainId);
+    if (cache) return cache;
+    const token = new _NativeCurrency2(payload);
+    this.#cache[payload.chainId] = token;
+    return token;
+  }
+};
+var DexToken = class extends Token2 {
+  logoUrl;
+  tags;
+  constructor(payload) {
+    super(
+      payload.chainId,
+      payload.address || NATIVE_ADDRESS,
+      payload.decimals,
+      payload.symbol,
+      payload.name,
+      payload.bypassChecksum,
+      payload.buyFeeBps,
+      payload.sellFeeBps
+    );
+    this.logoUrl = get3(payload, "logoUrl");
+    this.tags = get3(payload, "tags");
+  }
+};
+var SolanaDexToken = class extends DexToken {
+  constructor(payload) {
+    const solanaAddress = payload.address;
+    super({ ...payload, address: NATIVE_ADDRESS });
+    Object.defineProperty(this, "address", {
+      value: solanaAddress,
+      writable: false,
+      enumerable: true,
+      configurable: false
+    });
+  }
+};
+
+// src/schema/common.ts
+var $chainId = z.number().int().positive().refine((val) => val > 0 && val <= 2147483647, {
+  message: "Invalid chain ID - must be a positive integer within valid range"
+});
+var $address = z.string();
+var $nativeCurrency = z.instanceof(
+  NativeCurrency
+);
+var $dexCurrency = z.union([z.instanceof(DexToken), $nativeCurrency]);
+
+// src/core/aggregator/schemas.ts
+import camelCase from "lodash/camelCase";
+import isNil2 from "lodash/isNil";
+var $token = z2.object({
+  chain_id: $chainId,
+  address: $address,
+  decimal: z2.number().int(),
+  token_standard: z2.enum(["native", "erc20"]),
+  name: z2.string().nullish(),
+  symbol: z2.string().nullish(),
+  logo_uri: z2.string().nullish(),
+  tags: z2.array(z2.string()).nullish()
+});
+var $findRoutesPayload = z2.object({
+  amount: z2.string(),
+  account: $address,
+  currencyIn: $dexCurrency,
+  currencyOut: $dexCurrency,
+  direction: z2.enum(["exactIn", "exactOut"]),
+  slippageToleranceBps: z2.instanceof(Percent4)
+});
+var $calldataBuilder = z2.object({
+  strategy: z2.string(),
+  request_id: z2.string().nullish(),
+  data: z2.string()
+});
+var $gas = z2.object({
+  gas: z2.string().nullish(),
+  gas_price: z2.string().nullish(),
+  gas_usd: z2.string().nullish()
+}).transform((data) => ({
+  gasLimit: data.gas,
+  gasPrice: data.gas_price,
+  gasUsd: data.gas_usd
+}));
+var $extraFee = z2.object({
+  token: $token,
+  recipient: $address.nullish(),
+  amount: z2.string().nullish(),
+  amount_usd: z2.string().nullish(),
+  percentage: z2.string().nullish()
+}).transform((data) => {
+  let percentage;
+  try {
+    percentage = formatPurePercent(data.percentage);
+  } catch (error) {
+    console.error("extra fee percentage error:", error);
+  }
+  return {
+    token: data.token,
+    recipient: data.recipient,
+    amount: data.amount,
+    amountUsd: data.amount_usd,
+    percentage
+  };
+});
+var $baseQuote = z2.object({
+  // required fields
+  provider: z2.string(),
+  address_in: $address,
+  address_out: $address,
+  chain_id: z2.number(),
+  chain_id_out: z2.number().nullish(),
+  amount_in: z2.string(),
+  amount_out: z2.string(),
+  routes: z2.array(z2.unknown()),
+  token_in: $token,
+  token_out: $token,
+  calldata_builder: $calldataBuilder,
+  // optional fields
+  gas: $gas.nullish(),
+  extra_fee: $extraFee.nullish(),
+  amount_in_usd: z2.string().nullish(),
+  amount_out_usd: z2.string().nullish(),
+  price_impact: z2.string().nullish(),
+  permit2_address: $address.nullish(),
+  universal_router_address: $address.nullish(),
+  provider_route_id: z2.string().nullish(),
+  // custom fields
+  __origin: z2.object({ payload: $findRoutesPayload }),
+  create_dex_currency: z2.function().args(z2.any()).returns($dexCurrency)
+});
+var $quote = $baseQuote.transform((data) => {
+  const currencyIn = data.create_dex_currency({
+    chainId: data.token_in.chain_id,
+    address: data.token_in.address,
+    symbol: data.token_in.symbol,
+    name: data.token_in.name,
+    decimals: data.token_in.decimal,
+    standard: data.token_in.token_standard,
+    logoUrl: data.token_in.logo_uri,
+    tags: data.token_in.tags
+  });
+  const currencyOut = data.create_dex_currency({
+    chainId: data.token_out.chain_id,
+    address: data.token_out.address,
+    symbol: data.token_out.symbol,
+    name: data.token_out.name,
+    decimals: data.token_out.decimal,
+    standard: data.token_out.token_standard,
+    logoUrl: data.token_out.logo_uri,
+    tags: data.token_out.tags
+  });
+  const amountIn = CurrencyAmount3.fromRawAmount(
+    currencyIn,
+    JSBI3.BigInt(data.amount_in)
+  );
+  const amountInUsd = data.amount_in_usd && typeof parseFloat(data.amount_in_usd) === "number" ? new BigNumber2(data.amount_in_usd) : void 0;
+  const amountOut = CurrencyAmount3.fromRawAmount(
+    currencyOut,
+    JSBI3.BigInt(data.amount_out)
+  );
+  const amountOutUsd = data.amount_out_usd && typeof parseFloat(data.amount_out_usd) === "number" ? new BigNumber2(data.amount_out_usd) : void 0;
+  const priceImpactPercent = data.price_impact ? new Percent4(
+    JSBI3.BigInt(Math.round(parseFloat(data.price_impact) * 100)),
+    BIPS_BASE
+  ) : void 0;
+  const priceImpact = priceImpactPercent ? {
+    value: priceImpactPercent,
+    severity: warningSeverity(priceImpactPercent)
+  } : void 0;
+  const permit2Address = !isNil2(data.permit2_address) ? getAddress(data.permit2_address) : void 0;
+  const universalRouterAddress = !isNil2(data.universal_router_address) ? getAddress(data.universal_router_address) : getUniveralRouterAddress(data.provider, data.calldata_builder);
+  const chainId = data.chain_id !== currencyIn.chainId ? currencyIn.chainId : data.chain_id;
+  const chainIdOut = data.chain_id_out !== currencyOut.chainId ? currencyOut.chainId : data.chain_id_out;
+  return {
+    chainId,
+    chainIdOut,
+    amountIn,
+    amountInUsd,
+    amountOut,
+    amountOutUsd,
+    currencyIn,
+    currencyOut,
+    permit2Address,
+    universalRouterAddress,
+    priceImpact,
+    provider: data.provider,
+    addressIn: data.address_in,
+    addressOut: data.address_out,
+    calldataBuilder: data.calldata_builder,
+    routes: data.routes,
+    routeNotFound: data.routes.length === 0,
+    extraFee: data.extra_fee,
+    gas: data.gas,
+    __origin: data.__origin
+  };
+});
+var $buildRoutesPayload = z2.object({
+  chainId: $chainId,
+  chainIdOut: $chainId.nullish(),
+  provider: z2.string(),
+  sender: $address,
+  recipient: $address,
+  calldataBuilder: $calldataBuilder,
+  slippageToleranceBps: z2.instanceof(Percent4)
+});
+var $originBuiltRoutesCalldata = z2.record(z2.string(), z2.unknown());
+var $builtRoutesCalldata = $originBuiltRoutesCalldata.transform(
+  (data) => Object.entries(data).reduce(
+    (accumulator, [key, value]) => ({
+      ...accumulator,
+      [camelCase(key)]: value
+    }),
+    {}
+  )
+);
+
+// src/core/aggregator/Aggregator.ts
+import isNil3 from "lodash/isNil";
+import get4 from "lodash/get";
+
+// src/core/CoreDexShared.ts
+var DependencyValidator = class {
+  static validate(dependency, dependencyName, expectedType) {
+    if (!dependency) {
+      throw new Error(`${dependencyName} is required but was ${dependency}`);
+    }
+    if (expectedType && !(dependency instanceof expectedType)) {
+      throw new Error(
+        `Invalid ${dependencyName}. Expected instance of ${expectedType.name}`
+      );
+    }
+    return dependency;
+  }
+  /**
+   * Validates that a service has been properly initialized
+   */
+  static strict(dependency, serviceName, dependencyName) {
+    if (!dependency) {
+      throw new Error(
+        `${serviceName} not initialized. Call use(${dependencyName}) first.`
+      );
+    }
+    return dependency;
+  }
+};
+var CoreDexShared = class {
+  coredex;
+  use(coredex) {
+    this.coredex = DependencyValidator.validate(coredex, "CoreDex", CoreDex);
+    return this;
+  }
+  useCoreDex() {
+    return DependencyValidator.strict(
+      this.coredex,
+      this.constructor.name,
+      "CoreDex"
+    );
+  }
+};
+
+// src/core/aggregator/Aggregator.ts
+var Aggregator = class extends CoreDexShared {
+  api = new FetchMate_default({
+    headers: { "Content-Type": "application/json" }
+  });
+  constructor() {
+    super();
+  }
+  use(coredex) {
+    super.use(coredex);
+    this.api.baseUrl(coredex.dependencies.apiUrl);
+    return this;
+  }
+  getAccount = async (chainId, baseAddress) => {
+    const platform = this.coredex.platform.fromChainId(chainId);
+    return await platform.getAccount(baseAddress);
+  };
+  createDexCurrency = (payload) => {
+    return this.coredex.platform.fromChainId(payload.chainId).createDexCurrency(payload);
+  };
+  async tokens(chainId, options) {
+    const response = await this.api.get(
+      "/proxy/v3/public/swap/tokens",
+      { params: { chainId, ...options } }
+    );
+    const {
+      data: { tokens, pagination }
+    } = response.unwrap();
+    const results = tokens.reduce(
+      (accumulator, token) => {
+        try {
+          const sigil = this.coredex.createSignatureId(token.chain_id, token.address);
+          const dexToken = this.createDexCurrency({
+            chainId: token.chain_id,
+            decimals: token.decimal,
+            symbol: token.symbol,
+            name: token.name,
+            standard: token.token_standard,
+            address: token.address,
+            logoUrl: token.logo_uri,
+            tags: token.tags
+          });
+          accumulator.ids.push(sigil);
+          accumulator.data[sigil] = dexToken;
+          return accumulator;
+        } catch (error) {
+          return accumulator;
+        }
+      },
+      { ids: [], data: {} }
+    );
+    return { ...results, pagination };
+  }
+  async handleAddresses(ownerAddress, currencyIn, currencyOut) {
+    const chainId = currencyIn.chainId;
+    const addresses = {
+      chain_id: chainId,
+      user_address: ownerAddress
+    };
+    try {
+      const chainIdOut = currencyOut.chainId;
+      const isCrossChain = chainId !== chainIdOut;
+      if (!isCrossChain) {
+        const account = await this.getAccount(chainId, ownerAddress);
+        Object.assign(addresses, { user_address: account.address });
+      } else {
+        const [account, destAccount] = await Promise.all([
+          this.getAccount(chainId, ownerAddress),
+          this.getAccount(chainIdOut, ownerAddress)
+        ]);
+        Object.assign(addresses, {
+          chain_id: chainId,
+          user_address: account.address,
+          chain_id_out: chainIdOut,
+          dest_user_address: destAccount.address
+        });
+      }
+    } catch (error) {
+      this.coredex.console.error("failed to get account", error);
+      throw error;
+    }
+    return addresses;
+  }
+  async find(payload) {
+    const addresses = await this.handleAddresses(
+      payload.account,
+      payload.currencyIn,
+      payload.currencyOut
+    );
+    const body = {
+      ...addresses,
+      token_in: payload.currencyIn.address,
+      token_out: payload.currencyOut.address,
+      slippage_tolerance_bps: parseFloat(
+        payload.slippageToleranceBps.numerator.toString()
+      ),
+      ...payload.direction === "exactIn" ? { amount_in: payload.amount } : { amount_out: payload.amount }
+    };
+    this.coredex.console.info("find quote payload >>>", body);
+    const response = await this.api.post(
+      "/proxy/v3/public/swap/routes/find",
+      body
+    );
+    const { data } = response.unwrap();
+    this.coredex.console.info("find quote response >>>", data);
+    return $safeArray(data, $quote, {
+      modifier: (item) => ({
+        ...item,
+        __origin: { payload },
+        create_dex_currency: this.createDexCurrency
+      }),
+      debug: Boolean(this.coredex.dependencies.debug)
+    }).filter((quote) => !isNil3(quote));
+  }
+  async build(payload) {
+    const body = {
+      chain_id: payload.chainId,
+      sender: payload.sender,
+      recipient: payload.recipient,
+      provider: payload.provider,
+      calldata_builder: payload.calldataBuilder,
+      slippage_tolerance_bps: parseFloat(
+        payload.slippageToleranceBps.numerator.toString()
+      )
+    };
+    const account = await this.getAccount(payload.chainId, payload.sender);
+    Object.assign(body, {
+      sender: account.address,
+      recipient: account.address
+    });
+    this.coredex.console.info("build quote body >>>", body);
+    const response = await this.api.post(
+      "/proxy/v3/public/swap/routes/build",
+      body
+    );
+    this.coredex.console.info("build quote response >>>", response);
+    const { data } = response.unwrap();
+    return $safeArray(get4(data, "calldata"), $builtRoutesCalldata, {
+      debug: Boolean(this.coredex.dependencies.debug)
+    });
+  }
+  async getPrice(chain_id, address) {
+    const response = await this.api.post("/proxy/v3/public/fiat/tokens", {
+      tokens: [{ chain_id, address }]
+    });
+    return parseFloat(get4(response.unwrap(), "data.items.0.usd_price"));
+  }
+};
+
+// src/core/platform/EVM/AbstractedEVM.ts
+import { BigNumber as EthersBigNumber2 } from "@ethersproject/bignumber";
+import {
+  isAddress as isAddress2,
+  formatUnits
+} from "ethers";
+import BigNumber6 from "bignumber.js";
+
+// src/contracts/typed/factories/AggregateRouter__factory.ts
+import { Contract, Interface } from "ethers";
+
+// src/contracts/typed/factories/Erc1155__factory.ts
+import { Contract as Contract2, Interface as Interface2 } from "ethers";
+
+// src/contracts/typed/factories/Erc20__factory.ts
+import { Contract as Contract3, Interface as Interface3 } from "ethers";
+var _abi = [
+  {
+    inputs: [],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "constructor"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "_oldAdmin",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "_newAdmin",
+        type: "address"
+      }
+    ],
+    name: "AdminChanged",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "_oldAdmin",
+        type: "address"
+      }
+    ],
+    name: "AdminRemoved",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "_owner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "_spender",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "_value",
+        type: "uint256"
+      }
+    ],
+    name: "Approval",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "_minter",
+        type: "address"
+      }
+    ],
+    name: "MinterAdded",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "_minter",
+        type: "address"
+      }
+    ],
+    name: "MinterRemoved",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [],
+    name: "Paused",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "_spender",
+        type: "address"
+      }
+    ],
+    name: "SpenderUnwhitelisted",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "_spender",
+        type: "address"
+      }
+    ],
+    name: "SpenderWhitelisted",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "_from",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "_to",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "_value",
+        type: "uint256"
+      }
+    ],
+    name: "Transfer",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [],
+    name: "Unpaused",
+    type: "event"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        internalType: "address[]",
+        name: "_addedMinters",
+        type: "address[]"
+      }
+    ],
+    name: "addMinters",
+    outputs: [],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "admin",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [
+      {
+        internalType: "address",
+        name: "_owner",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "_spender",
+        type: "address"
+      }
+    ],
+    name: "allowance",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "_value",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        internalType: "address",
+        name: "_spender",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "_value",
+        type: "uint256"
+      }
+    ],
+    name: "approve",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "_success",
+        type: "bool"
+      }
+    ],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    name: "balanceOf",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_value",
+        type: "uint256"
+      }
+    ],
+    name: "burn",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "_success",
+        type: "bool"
+      }
+    ],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        internalType: "address",
+        name: "_from",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "_value",
+        type: "uint256"
+      }
+    ],
+    name: "burnFrom",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "_success",
+        type: "bool"
+      }
+    ],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "cappedSupply",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        internalType: "address",
+        name: "_newAdmin",
+        type: "address"
+      }
+    ],
+    name: "changeAdmin",
+    outputs: [],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "decimals",
+    outputs: [
+      {
+        internalType: "uint8",
+        name: "",
+        type: "uint8"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [
+      {
+        internalType: "address",
+        name: "_addr",
+        type: "address"
+      }
+    ],
+    name: "isMinter",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        internalType: "address",
+        name: "_to",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "_value",
+        type: "uint256"
+      }
+    ],
+    name: "mint",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "_success",
+        type: "bool"
+      }
+    ],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    name: "minter",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    name: "minters",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "name",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [],
+    name: "pause",
+    outputs: [],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "paused",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [],
+    name: "removeAdmin",
+    outputs: [],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        internalType: "address[]",
+        name: "_removedMinters",
+        type: "address[]"
+      }
+    ],
+    name: "removeMinters",
+    outputs: [],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "symbol",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "totalSupply",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        internalType: "address",
+        name: "_to",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "_value",
+        type: "uint256"
+      }
+    ],
+    name: "transfer",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "_success",
+        type: "bool"
+      }
+    ],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        internalType: "address",
+        name: "_from",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "_to",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "_value",
+        type: "uint256"
+      }
+    ],
+    name: "transferFrom",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "_success",
+        type: "bool"
+      }
+    ],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [],
+    name: "unpause",
+    outputs: [],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        internalType: "address",
+        name: "_spender",
+        type: "address"
+      }
+    ],
+    name: "unwhitelist",
+    outputs: [],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        internalType: "address",
+        name: "_spender",
+        type: "address"
+      }
+    ],
+    name: "whitelist",
+    outputs: [],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    name: "whitelisted",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var Erc20__factory = class {
+  static abi = _abi;
+  static createInterface() {
+    return new Interface3(_abi);
+  }
+  static connect(address, runner) {
+    return new Contract3(address, _abi, runner);
+  }
+};
+
+// src/contracts/typed/factories/Erc721__factory.ts
+import { Contract as Contract4, Interface as Interface4 } from "ethers";
+
+// src/contracts/typed/factories/Multicall2__factory.ts
+import { Contract as Contract5, Interface as Interface5 } from "ethers";
+var _abi2 = [
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: "address",
+            name: "target",
+            type: "address"
+          },
+          {
+            internalType: "bytes",
+            name: "callData",
+            type: "bytes"
+          }
+        ],
+        internalType: "struct Multicall2.Call[]",
+        name: "calls",
+        type: "tuple[]"
+      }
+    ],
+    name: "aggregate",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "blockNumber",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes[]",
+        name: "returnData",
+        type: "bytes[]"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: "address",
+            name: "target",
+            type: "address"
+          },
+          {
+            internalType: "bytes",
+            name: "callData",
+            type: "bytes"
+          }
+        ],
+        internalType: "struct Multicall2.Call[]",
+        name: "calls",
+        type: "tuple[]"
+      }
+    ],
+    name: "blockAndAggregate",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "blockNumber",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes32",
+        name: "blockHash",
+        type: "bytes32"
+      },
+      {
+        components: [
+          {
+            internalType: "bool",
+            name: "success",
+            type: "bool"
+          },
+          {
+            internalType: "bytes",
+            name: "returnData",
+            type: "bytes"
+          }
+        ],
+        internalType: "struct Multicall2.Result[]",
+        name: "returnData",
+        type: "tuple[]"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "blockNumber",
+        type: "uint256"
+      }
+    ],
+    name: "getBlockHash",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "blockHash",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getBlockNumber",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "blockNumber",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getCurrentBlockCoinbase",
+    outputs: [
+      {
+        internalType: "address",
+        name: "coinbase",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getCurrentBlockDifficulty",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "difficulty",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getCurrentBlockGasLimit",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "gaslimit",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getCurrentBlockTimestamp",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "timestamp",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "addr",
+        type: "address"
+      }
+    ],
+    name: "getRonBalance",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "balance",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getLastBlockHash",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "blockHash",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bool",
+        name: "requireSuccess",
+        type: "bool"
+      },
+      {
+        components: [
+          {
+            internalType: "address",
+            name: "target",
+            type: "address"
+          },
+          {
+            internalType: "bytes",
+            name: "callData",
+            type: "bytes"
+          }
+        ],
+        internalType: "struct Multicall2.Call[]",
+        name: "calls",
+        type: "tuple[]"
+      }
+    ],
+    name: "tryAggregate",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "bool",
+            name: "success",
+            type: "bool"
+          },
+          {
+            internalType: "bytes",
+            name: "returnData",
+            type: "bytes"
+          }
+        ],
+        internalType: "struct Multicall2.Result[]",
+        name: "returnData",
+        type: "tuple[]"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bool",
+        name: "requireSuccess",
+        type: "bool"
+      },
+      {
+        components: [
+          {
+            internalType: "address",
+            name: "target",
+            type: "address"
+          },
+          {
+            internalType: "bytes",
+            name: "callData",
+            type: "bytes"
+          }
+        ],
+        internalType: "struct Multicall2.Call[]",
+        name: "calls",
+        type: "tuple[]"
+      }
+    ],
+    name: "tryBlockAndAggregate",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "blockNumber",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes32",
+        name: "blockHash",
+        type: "bytes32"
+      },
+      {
+        components: [
+          {
+            internalType: "bool",
+            name: "success",
+            type: "bool"
+          },
+          {
+            internalType: "bytes",
+            name: "returnData",
+            type: "bytes"
+          }
+        ],
+        internalType: "struct Multicall2.Result[]",
+        name: "returnData",
+        type: "tuple[]"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+var Multicall2__factory = class {
+  static abi = _abi2;
+  static createInterface() {
+    return new Interface5(_abi2);
+  }
+  static connect(address, runner) {
+    return new Contract5(address, _abi2, runner);
+  }
+};
+
+// src/contracts/typed/factories/Permit2__factory.ts
+import { Contract as Contract6, Interface as Interface6 } from "ethers";
+var _abi3 = [
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    name: "allowance",
+    outputs: [
+      {
+        internalType: "uint160",
+        name: "amount",
+        type: "uint160"
+      },
+      {
+        internalType: "uint48",
+        name: "expiration",
+        type: "uint48"
+      },
+      {
+        internalType: "uint48",
+        name: "nonce",
+        type: "uint48"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "wordPos",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "mask",
+        type: "uint256"
+      }
+    ],
+    name: "invalidateUnorderedNonces",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+var Permit2__factory = class {
+  static abi = _abi3;
+  static createInterface() {
+    return new Interface6(_abi3);
+  }
+  static connect(address, runner) {
+    return new Contract6(address, _abi3, runner);
+  }
+};
+
+// src/contracts/typed/factories/WrapToken__factory.ts
+import { Contract as Contract7, Interface as Interface7 } from "ethers";
+var _abi4 = [
+  {
+    constant: true,
+    inputs: [],
+    name: "name",
+    outputs: [
+      {
+        name: "",
+        type: "string"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        name: "guy",
+        type: "address"
+      },
+      {
+        name: "wad",
+        type: "uint256"
+      }
+    ],
+    name: "approve",
+    outputs: [
+      {
+        name: "",
+        type: "bool"
+      }
+    ],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "totalSupply",
+    outputs: [
+      {
+        name: "",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        name: "src",
+        type: "address"
+      },
+      {
+        name: "dst",
+        type: "address"
+      },
+      {
+        name: "wad",
+        type: "uint256"
+      }
+    ],
+    name: "transferFrom",
+    outputs: [
+      {
+        name: "",
+        type: "bool"
+      }
+    ],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        name: "wad",
+        type: "uint256"
+      }
+    ],
+    name: "withdraw",
+    outputs: [],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "decimals",
+    outputs: [
+      {
+        name: "",
+        type: "uint8"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [
+      {
+        name: "",
+        type: "address"
+      }
+    ],
+    name: "balanceOf",
+    outputs: [
+      {
+        name: "",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "symbol",
+    outputs: [
+      {
+        name: "",
+        type: "string"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        name: "dst",
+        type: "address"
+      },
+      {
+        name: "wad",
+        type: "uint256"
+      }
+    ],
+    name: "transfer",
+    outputs: [
+      {
+        name: "",
+        type: "bool"
+      }
+    ],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [],
+    name: "deposit",
+    outputs: [],
+    payable: true,
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [
+      {
+        name: "",
+        type: "address"
+      },
+      {
+        name: "",
+        type: "address"
+      }
+    ],
+    name: "allowance",
+    outputs: [
+      {
+        name: "",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    payable: true,
+    stateMutability: "payable",
+    type: "fallback"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        name: "src",
+        type: "address"
+      },
+      {
+        indexed: true,
+        name: "guy",
+        type: "address"
+      },
+      {
+        indexed: false,
+        name: "wad",
+        type: "uint256"
+      }
+    ],
+    name: "Approval",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        name: "src",
+        type: "address"
+      },
+      {
+        indexed: true,
+        name: "dst",
+        type: "address"
+      },
+      {
+        indexed: false,
+        name: "wad",
+        type: "uint256"
+      }
+    ],
+    name: "Transfer",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        name: "dst",
+        type: "address"
+      },
+      {
+        indexed: false,
+        name: "wad",
+        type: "uint256"
+      }
+    ],
+    name: "Deposit",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        name: "src",
+        type: "address"
+      },
+      {
+        indexed: false,
+        name: "wad",
+        type: "uint256"
+      }
+    ],
+    name: "Withdrawal",
+    type: "event"
+  }
+];
+var WrapToken__factory = class {
+  static abi = _abi4;
+  static createInterface() {
+    return new Interface7(_abi4);
+  }
+  static connect(address, runner) {
+    return new Contract7(address, _abi4, runner);
+  }
+};
+
+// src/contracts/index.ts
+var Erc20 = Erc20__factory.createInterface();
+
+// src/core/platform/AbstractedPlatform.ts
+import { CurrencyAmount as CurrencyAmount4, Price } from "@uniswap/sdk-core";
+import get5 from "lodash/get";
+import isEmpty2 from "lodash/isEmpty";
+import BigNumber3 from "bignumber.js";
+import isNil4 from "lodash/isNil";
+
+// src/internals/utils/address.ts
+var normalizeAddress = (address, blockchain) => {
+  if (blockchain === "solana") {
+    return address;
+  }
+  if (address.startsWith("0x")) {
+    return address.toLowerCase();
+  }
+  return address;
+};
+
+// src/core/platform/AbstractedPlatform.ts
+var Noop = () => Promise.resolve(void 0);
+var AbstractedPlatform = class extends CoreDexShared {
+  tokenFactory = {
+    ["evm" /* EVM */]: (payload) => new DexToken(payload),
+    ["solana" /* SOLANA */]: (payload) => new SolanaDexToken(payload)
+  };
+  isCustom = false;
+  constructor() {
+    super();
+  }
+  use(coredex) {
+    super.use(coredex);
+    return this;
+  }
+  createDexCurrency(payload) {
+    const _payload = { ...payload };
+    if (payload.standard === "native" || this.isNativeAddress(get5(payload, "address", ""))) {
+      _payload.address = this.nativeAddress;
+      return NativeCurrency.onChain(_payload);
+    }
+    return this.tokenFactory[this.blockchain](_payload);
+  }
+  isNativeAddress(tokenAddress) {
+    try {
+      return tokenAddress === this.nativeAddress;
+    } catch (error) {
+      console.error(
+        `failed to check if {${tokenAddress}/${this.nativeAddress}} is native address`,
+        error
+      );
+      return false;
+    }
+  }
+  getNativeCurrency(chainId) {
+    const chainConfig = this.coredex.getChainConfig(chainId);
+    return NativeCurrency.onChain({
+      chainId,
+      address: this.nativeAddress,
+      decimals: chainConfig.nativeToken.decimals,
+      symbol: chainConfig.nativeToken.symbol,
+      name: chainConfig.nativeToken.name,
+      standard: "native"
+    });
+  }
+  async getAccount(baseAddress) {
+    try {
+      const accounts = await this.coredex.dependencies.getAccounts(baseAddress);
+      if (!Array.isArray(accounts) || accounts.length === 0) {
+        throw new Error(`cannot retrieve account list`);
+      }
+      const baseAccount = accounts.find(
+        (account2) => normalizeAddress(account2.address) === normalizeAddress(baseAddress)
+      );
+      if (!baseAccount)
+        throw new Error(
+          `missing ${this.blockchain} account (baseAddress: ${baseAddress})`
+        );
+      if (baseAccount.type === "PRIVATE_KEY" /* PRIVATE_KEY */) {
+        return baseAccount;
+      }
+      const account = accounts.find(
+        (account2) => account2.index === baseAccount.index && account2.blockchain === this.blockchain
+      );
+      if (!account)
+        throw new Error(
+          `missing ${this.blockchain} account (baseAddress: ${baseAddress})`
+        );
+      return account;
+    } catch (error) {
+      console.error(
+        `failed to get ${this.blockchain} account (baseAddress: ${baseAddress})`
+      );
+      throw error;
+    }
+  }
+  async buildQuote(quote, _options) {
+    const payload = quote.__origin.payload;
+    const builts = await this.coredex.aggregator.build({
+      chainId: payload.currencyIn.chainId,
+      chainIdOut: payload.currencyOut.chainId,
+      provider: quote.provider,
+      sender: payload.account,
+      recipient: payload.account,
+      calldataBuilder: quote.calldataBuilder,
+      slippageToleranceBps: payload.slippageToleranceBps
+    });
+    if (!Array.isArray(builts)) throw new Error("invalid built routes response");
+    return builts;
+  }
+  async computeQuote(quote) {
+    const params = quote.__origin.payload;
+    const exactIn = params.direction === "exactIn";
+    const exactOut = params.direction === "exactOut";
+    const parsedAmount = CurrencyAmount4.fromRawAmount(
+      exactIn ? params.currencyIn : params.currencyOut,
+      params.amount
+    );
+    const amounts = {
+      ["tokenIn" /* TokenIn */]: exactIn ? parsedAmount : quote.amountIn,
+      ["tokenOut" /* TokenOut */]: exactOut ? parsedAmount : quote.amountOut
+    };
+    const maximumAmountIn = computeMaximumAmountIn(
+      quote.amountIn,
+      params.slippageToleranceBps
+    );
+    const minimumAmountOut = computeMinimumAmountOut(
+      quote.amountOut,
+      params.slippageToleranceBps
+    );
+    const executionPrice = new Price(
+      quote.amountIn.currency,
+      quote.amountOut.currency,
+      quote.amountIn.quotient,
+      quote.amountOut.quotient
+    );
+    const worstExecutionPrice = new Price(
+      quote.amountIn.currency,
+      quote.amountOut.currency,
+      maximumAmountIn.quotient,
+      minimumAmountOut.quotient
+    );
+    const aggregatedQuote = {
+      amounts,
+      maximumAmountIn,
+      minimumAmountOut,
+      executionPrice,
+      worstExecutionPrice,
+      ...this.getDefaultQuote(quote)
+    };
+    return Promise.resolve(aggregatedQuote);
+  }
+  getDefaultQuote(quote) {
+    const defaultQuote = {
+      __origin: quote.__origin,
+      quoteId: "",
+      chainId: quote.chainId,
+      provider: quote.provider,
+      addressIn: quote.addressIn,
+      addressOut: quote.addressOut,
+      currencyIn: quote.currencyIn,
+      currencyOut: quote.currencyOut,
+      amountIn: quote.amountIn,
+      amountOut: quote.amountOut,
+      amountInUsd: quote.amountInUsd,
+      amountOutUsd: quote.amountOutUsd,
+      calldataBuilder: quote.calldataBuilder,
+      permit2Address: quote.permit2Address,
+      universalRouterAddress: quote.universalRouterAddress,
+      routes: quote.routes,
+      priceImpact: quote.priceImpact,
+      extraFee: quote.extraFee,
+      getAllocatedFee: Noop,
+      getNetworkFees: Noop
+    };
+    defaultQuote.quoteId = getQuoteUuid(quote);
+    defaultQuote.getAllocatedFee = () => this.getAllocatedFee(defaultQuote);
+    defaultQuote.getNetworkFees = () => this.getNetworkFees(defaultQuote);
+    return defaultQuote;
+  }
+  async getAllocatedFee(quote) {
+    const developmentFee = await this.computeDevelopmentFee(quote);
+    const allocatedFee = {
+      totalFeeUsd: developmentFee?.amountUsd,
+      allocation: [developmentFee]
+    };
+    return allocatedFee;
+  }
+  computeDevelopmentFee(quote) {
+    try {
+      const extraFee = get5(quote, "extraFee");
+      if (!extraFee || isEmpty2(extraFee)) throw new Error("invalid extra fee");
+      const amount = get5(extraFee, "amount");
+      if (!amount || isNil4(amount)) throw new Error("invalid amount");
+      const amountUsd = get5(extraFee, "amountUsd");
+      const totalFeeUsd = !isNil4(amountUsd) ? new BigNumber3(amountUsd) : void 0;
+      const currency = this.createDexCurrency({
+        chainId: quote.chainId,
+        decimals: extraFee.token.decimal,
+        symbol: extraFee.token.symbol,
+        name: extraFee.token.name,
+        standard: extraFee.token.token_standard,
+        address: extraFee.token.address,
+        logoUrl: extraFee.token.logo_uri,
+        tags: extraFee.token.tags
+      });
+      return Promise.resolve({
+        type: "development",
+        percent: get5(extraFee, "percentage"),
+        amountUsd: totalFeeUsd,
+        amount: CurrencyAmount4.fromRawAmount(currency, amount)
+      });
+    } catch (error) {
+      console.error("cannot compute development fee:", error);
+      return Promise.resolve(void 0);
+    }
+  }
+};
+var AbstractedPlatform_default = AbstractedPlatform;
+
+// src/core/platform/EVM/AbstractedEVM.ts
+import isNil5 from "lodash/isNil";
+
+// src/internals/utils/ethers-error.ts
+import get6 from "lodash/get";
+import isEmpty3 from "lodash/isEmpty";
+var STRIP_PATTERN = / \([^)]*=/;
+function strip(message) {
+  if (message === "") return message;
+  const match = message.match(STRIP_PATTERN);
+  if (match && match.index !== void 0) {
+    message = message.slice(0, match.index);
+  }
+  const trimmed = message.trim();
+  if (isEmpty3(trimmed)) return message;
+  return trimmed.charAt(0).toUpperCase() + trimmed.slice(1);
+}
+function typedEtherError(error) {
+  const code = get6(error, "code", "UNKNOWN_ERROR" /* UNKNOWN_ERROR */);
+  const message = strip(get6(error, "message", ""));
+  return { code, message, error };
+}
+
+// src/core/platform/EVM/GasEstimator.ts
+import { isAddress } from "ethers";
+import BigNumber4 from "bignumber.js";
+import isEmpty4 from "lodash/isEmpty";
+import get7 from "lodash/get";
+
+// src/schema/networkFee.ts
+import { z as z3 } from "zod";
+var $legacyFee = z3.object({ gas_price: z3.string().nullish() }).transform((data) => ({ gasPrice: data.gas_price }));
+var $eip1559 = z3.object({
+  base_fee_per_gas: z3.string().nullish(),
+  max_fee_per_gas: z3.string().nullish(),
+  max_priority_fee_per_gas: z3.string().nullish()
+}).transform((data) => ({
+  baseFeePerGas: data.base_fee_per_gas,
+  maxFeePerGas: data.max_fee_per_gas,
+  maxPriorityFeePerGas: data.max_priority_fee_per_gas
+}));
+var $sharedSuggestItemBase = z3.object({
+  chain_name: z3.string(),
+  exact_base_fee: z3.string().nullish(),
+  base_fee_per_gas: z3.string().nullish()
+});
+var $networkFeeSuggestion = z3.discriminatedUnion("type", [
+  z3.object({ type: z3.literal("legacy") }).merge(
+    z3.object({
+      low: $legacyFee.nullish(),
+      medium: $legacyFee.nullish(),
+      high: $legacyFee.nullish()
+    })
+  ).merge($sharedSuggestItemBase),
+  z3.object({ type: z3.literal("eip-1559") }).merge(
+    z3.object({
+      low: $eip1559.nullish(),
+      medium: $eip1559.nullish(),
+      high: $eip1559.nullish()
+    })
+  ).merge($sharedSuggestItemBase)
+]).transform(({ chain_name, exact_base_fee, base_fee_per_gas, ...data }) => {
+  if (data.type === "eip-1559") {
+    if (data.low) data.low.baseFeePerGas = base_fee_per_gas;
+    if (data.medium) data.medium.baseFeePerGas = base_fee_per_gas;
+    if (data.high) data.high.baseFeePerGas = base_fee_per_gas;
+  }
+  return {
+    chainName: chain_name,
+    exactBaseFee: exact_base_fee,
+    ...data
+  };
+});
+
+// src/core/platform/EVM/GasEstimator.ts
+var DEFAULT_LEGACY_FEE_DATA = { gasPrice: "2000000000" };
+var GasEstimator = class {
+  constructor(coredex) {
+    this.coredex = coredex;
+  }
+  async compute(tx, options) {
+    try {
+      if (!tx.chainId) throw new Error("chainId is required");
+      if (!tx.data) throw new Error("data is required");
+      if (!isAddress(tx.from) || !isAddress(tx.to)) {
+        throw new Error("from/to address is invalid");
+      }
+      const gasLimit = await this.estimate(tx);
+      if (!isEmpty4(options?.networkFee)) {
+        return { ...tx, ...options.networkFee, gasLimit };
+      }
+      const feeData = await this.getFeeData(Number(tx.chainId));
+      return { ...tx, ...feeData, gasLimit };
+    } catch (error) {
+      console.error("error populating transaction: ", error);
+      throw error;
+    }
+  }
+  async estimate(tx, options) {
+    try {
+      delete tx.gasLimit;
+      delete tx.gasPrice;
+      delete tx.maxFeePerGas;
+      delete tx.maxPriorityFeePerGas;
+      const chainId = chainIdToNumber(tx.chainId);
+      const provider = this.coredex.platform.fromChainId(chainId).getProvider(chainId);
+      const gasLimit = await provider.estimateGas(tx);
+      if (!gasLimit) throw new Error("invalid gas estimation");
+      return gasLimit.toString();
+    } catch (error) {
+      const typedError = typedEtherError(error);
+      if (typedError.code === "CALL_EXCEPTION" && options?.bypassApproval === true) {
+        return await this.estimateWithApprovalBypass(tx);
+      }
+      console.error("estimating gas limit failed:", error);
+      return DEFAULT_GAS_LIMIT;
+    }
+  }
+  /**
+   * Estimate gas limit with approval bypass for displaying network fee purpose
+   * @param tx - Transaction request
+   * @returns Bypassing approval estimation gas limit
+   */
+  async estimateWithApprovalBypass(tx) {
+    try {
+      const txData = tx.data || "0x";
+      const dataLength = txData.length;
+      let complexityMultiplier = 1;
+      if (dataLength > 1e3) complexityMultiplier = 1.2;
+      if (dataLength > 2e3) complexityMultiplier = 1.4;
+      if (dataLength > 4e3) complexityMultiplier = 1.6;
+      const estimatedGas = new BigNumber4(DEFAULT_SWAP_GAS_LIMIT).multipliedBy(complexityMultiplier).multipliedBy(1.1).toFixed(0);
+      return estimatedGas;
+    } catch (error) {
+      console.error("enhanced estimation failed:", error);
+      return DEFAULT_SWAP_GAS_LIMIT;
+    }
+  }
+  async getFeeData(chainId, feeLevel = "medium" /* Medium */) {
+    try {
+      const data = await this.suggestion(chainId);
+      return get7(data, feeLevel);
+    } catch (error) {
+      console.error("error getting fee suggestion: ", error);
+      return this.getProviderFeeData(chainId);
+    }
+  }
+  async suggestion(chainId) {
+    const chainConfig = this.coredex.dependencies.providerManager.getChainConfigs().find((config) => config.chainId === chainId);
+    if (!chainConfig) throw new Error("chain config not found");
+    const response = await this.coredex.aggregator.api.get(
+      `/proxy/public/v1/${chainConfig.chainName}/gas-suggestion`
+    );
+    const parsed = $networkFeeSuggestion.safeParse(response);
+    if (!parsed.success) {
+      console.error("invalid gas suggestion:", parsed.error);
+      throw new Error("invalid gas suggestion");
+    }
+    return parsed.data;
+  }
+  async getProviderFeeData(chainId) {
+    try {
+      const provider = this.coredex.platform.fromChainId(chainId).getProvider(chainId);
+      const feeData = await provider.getFeeData();
+      if (feeData.gasPrice && !feeData.maxFeePerGas) {
+        return { gasPrice: feeData.gasPrice.toString() };
+      }
+      if (feeData.maxFeePerGas) {
+        const maxFeePerGas = feeData.maxFeePerGas.toString();
+        const maxPriorityFeePerGas = feeData.maxPriorityFeePerGas?.toString() ?? "0";
+        const baseFeePerGas = new BigNumber4(maxFeePerGas).minus(new BigNumber4(maxPriorityFeePerGas)).toString();
+        return {
+          maxFeePerGas,
+          maxPriorityFeePerGas,
+          baseFeePerGas
+        };
+      }
+      return DEFAULT_LEGACY_FEE_DATA;
+    } catch (error) {
+      console.error("provider fee data failed: ", error);
+      return DEFAULT_LEGACY_FEE_DATA;
+    }
+  }
+};
+var GasEstimator_default = GasEstimator;
+
+// src/core/platform/EVM/Approval.ts
+import { createPermitObj } from "@sky-mavis/katana-swap";
+import { CurrencyAmount as CurrencyAmount5 } from "@uniswap/sdk-core";
+import { AllowanceTransfer } from "@uniswap/permit2-sdk";
+import { _TypedDataEncoder } from "@ethersproject/hash";
+import { BigNumber as BigNumber5 } from "@ethersproject/bignumber";
+import { MaxUint256 } from "ethers";
+import get8 from "lodash/get";
+var Approval = class {
+  constructor(coredex) {
+    this.coredex = coredex;
+  }
+  signatures = /* @__PURE__ */ new Map();
+  async approve(quoteId, account, spender, token, amountInWei = MaxUint256.toString()) {
+    try {
+      const amount = CurrencyAmount5.fromRawAmount(token, amountInWei);
+      this.coredex.notify(quoteId, {
+        state: "approving-token" /* ApprovingToken */,
+        data: { amount }
+      });
+      const chainId = amount.currency.chainId;
+      const platform = this.coredex.platform.fromChainId(
+        chainId
+      );
+      const signer = await platform.invokeSigner(
+        amount.currency.chainId,
+        account
+      );
+      const contract = Erc20__factory.connect(amount.currency.address, signer);
+      const params = [spender, amount.quotient.toString()];
+      const calldata = Erc20.encodeFunctionData("approve", params);
+      const populatedTx = await platform.populateTransaction({
+        chainId,
+        from: account,
+        to: amount.currency.address,
+        data: calldata
+      });
+      const response = await contract.approve(...params, {
+        gasLimit: populatedTx.gasLimit,
+        maxFeePerGas: populatedTx.maxFeePerGas,
+        maxPriorityFeePerGas: populatedTx.maxPriorityFeePerGas
+      });
+      if (response) {
+        const confirmationBlocks = this.coredex.confirmationBlocks(chainId);
+        const provider = platform.getProvider(chainId);
+        const receipt = await provider?.waitForTransaction(
+          response.hash,
+          confirmationBlocks
+        );
+        const status = receipt ? get8(receipt, "status", 0) : 0;
+        this.coredex.notify(quoteId, {
+          state: status === 1 ? "approved-token" /* ApprovedToken */ : "approve-token-failed" /* ApproveTokenFailed */
+        });
+      }
+      return response;
+    } catch (error) {
+      this.coredex.notify(quoteId, {
+        state: "approve-token-failed" /* ApproveTokenFailed */,
+        error: typedEtherError(error)
+      });
+      console.error("approve error: ", error);
+      throw error;
+    }
+  }
+  async allowance(account, amount, approveSpender) {
+    try {
+      const chainId = amount.currency.chainId;
+      const tokenAddress = amount.currency.address;
+      const platform = this.coredex.platform.fromChainId(
+        chainId
+      );
+      const contract = Erc20__factory.connect(
+        tokenAddress,
+        platform.getProvider(chainId)
+      );
+      const rawAllowance = await contract.allowance(account, approveSpender);
+      return CurrencyAmount5.fromRawAmount(
+        amount.currency,
+        rawAllowance.toString()
+      );
+    } catch (error) {
+      console.error("get allowance error: ", error);
+      throw error;
+    }
+  }
+  async getPermitAllowance(chainId, account, amount, permitRouter, permitSpender) {
+    const platform = this.coredex.platform.fromChainId(chainId);
+    const contract = Permit2__factory.connect(
+      permitRouter,
+      platform.getProvider(chainId)
+    );
+    const [amountInWei, expiration, nonce] = await contract.allowance(
+      account,
+      amount.currency.address,
+      permitSpender
+    );
+    return [
+      CurrencyAmount5.fromRawAmount(amount.currency, amountInWei.toString()),
+      BigNumber5.from(expiration).toNumber(),
+      BigNumber5.from(nonce).toNumber()
+    ];
+  }
+  async signPermitSignature(quote, amount, nonce) {
+    try {
+      const chainId = amount.currency.chainId;
+      const tokenAddress = amount.currency.address;
+      const platform = this.coredex.platform.fromChainId(
+        chainId
+      );
+      const signer = await platform.invokeSigner(
+        chainId,
+        quote.__origin.payload.account
+      );
+      const permit = createPermitObj({
+        chainId,
+        token: tokenAddress,
+        nonce,
+        spender: quote.universalRouterAddress
+      });
+      const permitData = AllowanceTransfer.getPermitData(
+        permit,
+        quote.permit2Address,
+        chainId
+      );
+      const populated = await _TypedDataEncoder.resolveNames(
+        permitData.domain,
+        permitData.types,
+        permitData.values,
+        (name) => signer.resolveName(name)
+      );
+      const message = JSON.stringify(
+        _TypedDataEncoder.getPayload(
+          populated.domain,
+          permitData.types,
+          populated.value
+        )
+      );
+      this.coredex.notify(quote.quoteId, {
+        state: "signing-permit" /* SigningPermit */,
+        data: { message }
+      });
+      const signature = await signer.signTypedDataV4(message);
+      const permitSignature = { ...permit, signature };
+      this.signatures.set(
+        this.createPermitSigId(quote.__origin.payload),
+        permitSignature
+      );
+      this.coredex.notify(quote.quoteId, {
+        state: "signed-permit" /* SignedPermit */
+      });
+      return permitSignature;
+    } catch (error) {
+      this.coredex.notify(quote.quoteId, {
+        state: "sign-permit-failed" /* SignPermitFailed */,
+        error
+      });
+      throw error;
+    }
+  }
+  createPermitSigId(params) {
+    return [
+      params.account,
+      params.currencyIn.chainId,
+      params.currencyIn.address
+    ].join("#");
+  }
+  getPermitSignature(quote) {
+    const signatureId = this.createPermitSigId(quote.__origin.payload);
+    return this.signatures.get(signatureId);
+  }
+};
+var Approval_default = Approval;
+
+// src/utils/error.ts
+function normalizeError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  if (typeof error === "string") {
+    return new Error(error);
+  }
+  if (error && typeof error === "object" && "message" in error && typeof error.message === "string") {
+    return new Error(error.message);
+  }
+  return new Error(String(error));
+}
+
+// src/core/platform/EVM/AbstractedEVM.ts
+var AVERAGE_RONIN_L1_BLOCK_TIME = 3e3;
+var AbstractedEVM = class extends AbstractedPlatform_default {
+  blockchain = "evm" /* EVM */;
+  name = `abstracted-${this.blockchain}`;
+  nativeAddress = NATIVE_ADDRESS;
+  approval;
+  gas;
+  constructor() {
+    super();
+  }
+  use(coredex) {
+    super.use(coredex);
+    this.initiate();
+    this.approval = new Approval_default(this.useCoreDex());
+    this.gas = new GasEstimator_default(this.useCoreDex());
+    return this;
+  }
+  _initiated = false;
+  initiate() {
+    try {
+      if (this._initiated) return;
+      for (const wrapToken of Object.values(EVM_WETH9)) {
+        WRAPPED_TOKENS.set(
+          wrapToken.chainId,
+          new DexToken({
+            chainId: wrapToken.chainId,
+            address: wrapToken.address,
+            decimals: wrapToken.decimals,
+            symbol: wrapToken.symbol,
+            name: wrapToken.name,
+            standard: "erc20"
+          })
+        );
+      }
+      this._initiated = true;
+    } catch (error) {
+      console.error(
+        `failed to initiate ${this.blockchain} wrapped tokens`,
+        error
+      );
+      throw error;
+    }
+  }
+  getProvider(chainId) {
+    const provider = this.coredex.dependencies.providerManager.getProvider(
+      chainId
+    );
+    if (!provider) throw new Error(`missing provider (chainId: ${chainId})`);
+    return provider;
+  }
+  async getSigner(address) {
+    const signer = await this.coredex.dependencies.getSignerForAddress(address);
+    if (!signer) throw new Error(`missing signer (address: ${address})`);
+    return signer;
+  }
+  async invokeSigner(chainId, fromAddress) {
+    const signer = await this.getSigner(fromAddress);
+    return signer.connect(this.getProvider(chainId));
+  }
+  async authorize(quote) {
+    try {
+      const amount = "maximumAmountIn" in quote && quote.maximumAmountIn?.currency.isToken ? quote.maximumAmountIn : "amounts" in quote && quote.amounts?.["tokenIn" /* TokenIn */]?.currency.isToken ? quote.amounts["tokenIn" /* TokenIn */] : void 0;
+      if (!amount || !quote.permit2Address) {
+        return Promise.resolve(void 0);
+      }
+      const chainId = amount.currency.chainId;
+      if (amount.currency.isNative || amount.currency.address === NATIVE_ADDRESS) {
+        this.coredex.notify(quote.quoteId, {
+          state: "authorized" /* Authorized */
+        });
+        return Promise.resolve(void 0);
+      }
+      this.coredex.notify(quote.quoteId, {
+        state: "authorizing" /* Authorizing */
+      });
+      const account = quote.__origin.payload.account;
+      const allowance = await this.approval.allowance(
+        account,
+        amount,
+        quote.permit2Address
+      );
+      const approved = allowance.greaterThan(amount) || allowance.equalTo(amount);
+      let signed = false;
+      let permitted = false;
+      let signature = this.approval.getPermitSignature(quote);
+      if (quote.provider !== "kyberswap") {
+        const [permitAllowance, permitExpiration, nonce] = await this.approval.getPermitAllowance(
+          chainId,
+          account,
+          amount,
+          quote.permit2Address,
+          quote.universalRouterAddress
+        );
+        const now = Math.floor(
+          (Date.now() + AVERAGE_RONIN_L1_BLOCK_TIME) / 1e3
+        );
+        if (typeof signature === "object") {
+          signed = signature.details.token === amount.currency.address && signature.spender === quote.universalRouterAddress && signature.sigDeadline >= now;
+        }
+        permitted = (permitAllowance.greaterThan(amount) || permitAllowance.equalTo(amount)) && permitExpiration >= now;
+        if (!approved) {
+          await this.approval.approve(
+            quote.quoteId,
+            account,
+            quote.permit2Address,
+            amount.currency
+          );
+        }
+        const shouldSignPermit = !(permitted || signed);
+        if (shouldSignPermit) {
+          signature = await this.approval.signPermitSignature(
+            quote,
+            amount,
+            nonce
+          );
+          signed = signature?.details?.token === amount.currency.address && signature?.spender === quote.universalRouterAddress && signature?.sigDeadline >= now;
+        }
+      } else if (!approved) {
+        await this.approval.approve(
+          quote.quoteId,
+          account,
+          quote.permit2Address,
+          amount.currency
+        );
+      }
+      this.coredex.notify(quote.quoteId, {
+        state: "authorized" /* Authorized */
+      });
+      return !permitted && signed ? signature : void 0;
+    } catch (error) {
+      this.coredex.notify(quote.quoteId, {
+        state: "authorize-failed" /* AuthorizeFailed */,
+        error
+      });
+      console.error(`[${quote.provider}] authorize failed:`, error);
+      throw error;
+    }
+  }
+  async balanceOf(chainId, baseAddress, tokenAddress) {
+    try {
+      const account = await this.getAccount(baseAddress);
+      if (this.isNativeAddress(tokenAddress)) {
+        return await this.nativeBalanceOf(chainId, account.address);
+      }
+      const contract = Erc20__factory.connect(
+        tokenAddress,
+        this.getProvider(chainId)
+      );
+      return await contract.balanceOf(account.address);
+    } catch (error) {
+      console.error(`Error getting balance for ${tokenAddress}:`, error);
+      throw error;
+    }
+  }
+  async batchBalanceOf(chainId, account, tokenAddresses, callLimit = 100) {
+    const results = {};
+    const nativeTokens = tokenAddresses.filter(
+      (address) => this.isNativeAddress(address)
+    );
+    const erc20Tokens = tokenAddresses.filter(
+      (address) => !this.isNativeAddress(address)
+    );
+    if (nativeTokens.length > 0) {
+      const nativeBalance = await this.nativeBalanceOf(chainId, account);
+      for (const nativeToken of nativeTokens) {
+        results[nativeToken] = nativeBalance;
+      }
+    }
+    if (erc20Tokens.length > 0) {
+      const erc20Balances = await this.multicallErc20Balances(
+        chainId,
+        account,
+        erc20Tokens,
+        callLimit
+      );
+      Object.assign(results, erc20Balances);
+    }
+    return results;
+  }
+  async buildQuote(quote) {
+    await this.authorize(quote);
+    const payload = quote.__origin.payload;
+    const builts = await super.buildQuote(quote);
+    return builts.map((built) => ({
+      chainId: payload.currencyIn.chainId,
+      from: payload.account,
+      ...built
+    }));
+  }
+  async populateTransaction(tx) {
+    return await this.gas.compute(tx);
+  }
+  async getNetworkFees(quote, options) {
+    try {
+      const totalGasLimit = await this.estimateGasLimit(quote, {
+        ...options,
+        bypassApproval: true
+      });
+      const nativeCurrency = this.getNativeCurrency(quote.chainId);
+      if (!nativeCurrency) throw new Error("cannot get native currency");
+      const networkFees = [];
+      const gasSuggestion = await this.gas.suggestion(quote.chainId);
+      for (const [key, feeData] of Object.entries(gasSuggestion)) {
+        if (!["low", "medium", "high"].includes(key) || isNil5(feeData)) {
+          continue;
+        }
+        const networkCostInWei = computeNetworkCost(
+          feeData,
+          totalGasLimit.toString()
+        );
+        if (!networkCostInWei) {
+          this.coredex.console.warn("cannot compute network cost:", {
+            origin: {
+              feeData,
+              totalGasLimit
+            }
+          });
+          continue;
+        }
+        const amount = new BigNumber6(
+          formatUnits(networkCostInWei.toString(), nativeCurrency.decimals)
+        );
+        networkFees.push({
+          amount,
+          feeData,
+          level: key,
+          currency: nativeCurrency
+        });
+      }
+      return networkFees;
+    } catch (error) {
+      console.error(
+        `cannot get network fee (chainId: ${quote.chainId}):`,
+        error
+      );
+      return void 0;
+    }
+  }
+  async sendTransaction(chainId, from, txRequest, options) {
+    try {
+      const account = await this.getAccount(from);
+      const fromAddress = account.address;
+      if (!isAddress2(fromAddress)) throw new Error("invalid from address");
+      const computedTx = await this.gas.compute(txRequest, {
+        networkFee: options?.networkFee
+      });
+      this.coredex.console.info(
+        `[${this.name}] sending transaction -> `,
+        computedTx
+      );
+      const signer = await this.invokeSigner(chainId, fromAddress);
+      const txResponse = await signer.sendTransaction(computedTx);
+      options?.onSubmitted?.(txResponse);
+      if (!options?.waitForReceipt) return txResponse;
+      options?.onWaitingForReceipt?.(txResponse);
+      const confirmationBlocks = this.coredex.confirmationBlocks(chainId);
+      const provider = this.getProvider(chainId);
+      const receipt = await provider?.waitForTransaction(
+        txResponse.hash,
+        confirmationBlocks
+      );
+      if (receipt && receipt.status === 1) options?.onSuccess?.(receipt);
+      else
+        throw new Error(
+          `network cannot confirm transaction [${txResponse.hash}]`
+        );
+      return txResponse;
+    } catch (error) {
+      options?.onFailure?.(error);
+      const normalizedError = normalizeError(error);
+      const enhancedError = new Error(
+        `Transaction failed: ${normalizedError.message}`
+      );
+      if (normalizedError instanceof Error && normalizedError.stack) {
+        enhancedError.stack = normalizedError.stack;
+      }
+      throw enhancedError;
+    }
+  }
+  async sendBatchTransaction(chainId, from, txRequests, { onSuccess, onFailure, ...options } = {}) {
+    const responses = [];
+    for (let index = 0; index < txRequests.length; index++) {
+      try {
+        const txRequest = txRequests[index];
+        const isLastCall = index === txRequests.length - 1;
+        const txResponse = await this.sendTransaction(
+          chainId,
+          from,
+          txRequest,
+          !isLastCall ? options : { ...options, onSuccess, onFailure }
+        );
+        responses.push(txResponse);
+      } catch (error) {
+        const normalizedError = normalizeError(error);
+        const enhancedError = new Error(
+          `Transaction ${index + 1}/${txRequests.length} failed: ${normalizedError.message}`
+        );
+        if (normalizedError instanceof Error && normalizedError.stack) {
+          enhancedError.stack = normalizedError.stack;
+        }
+        throw enhancedError;
+      }
+    }
+    return responses;
+  }
+  async multicallErc20Balances(chainId, baseAddress, tokenAddresses, callLimit) {
+    const account = await this.getAccount(baseAddress);
+    const multicallContract = Multicall2__factory.connect(
+      MULTICALL3_ROUTER,
+      this.getProvider(chainId)
+    );
+    const totalPages = Math.ceil(tokenAddresses.length / callLimit);
+    const multicallPromises = [];
+    for (let page = 0; page < totalPages; page++) {
+      const pageTokens = tokenAddresses.slice(
+        page * callLimit,
+        (page + 1) * callLimit
+      );
+      const calls = pageTokens.map((tokenAddress) => ({
+        target: tokenAddress,
+        callData: Erc20.encodeFunctionData("balanceOf", [account.address])
+      }));
+      multicallPromises.push(
+        multicallContract.tryAggregate.staticCall(false, calls)
+      );
+    }
+    const multicallResults = await Promise.all(multicallPromises);
+    const results = {};
+    let tokenIndex = 0;
+    for (const batchResults of multicallResults) {
+      for (const result of batchResults) {
+        const tokenAddress = tokenAddresses[tokenIndex];
+        try {
+          if (result.success && result.returnData && result.returnData !== "0x") {
+            const decoded = Erc20.decodeFunctionResult(
+              "balanceOf",
+              result.returnData
+            );
+            results[tokenAddress] = decoded[0];
+          } else {
+            results[tokenAddress] = 0n;
+          }
+        } catch (error) {
+          console.error(`Error decoding balance for ${tokenAddress}:`, error);
+          results[tokenAddress] = 0n;
+        }
+        tokenIndex++;
+      }
+    }
+    return results;
+  }
+  async gasSuggestion(chainId) {
+    return await this.gas.suggestion(chainId);
+  }
+  async estimateGasLimit(quote, options) {
+    try {
+      const txs = await this.buildQuote(quote);
+      const promises = txs.map((tx) => this.gas.estimate(tx, options));
+      const gasLimits = await Promise.all(promises);
+      return gasLimits.reduce(
+        (accumulator, gasLimit) => accumulator.add(EthersBigNumber2.from(gasLimit)),
+        EthersBigNumber2.from(0)
+      );
+    } catch (error) {
+      this.coredex.console.warn("cannot estimate gas limit:", error);
+      return EthersBigNumber2.from(DEFAULT_GAS_LIMIT);
+    }
+  }
+  async nativeBalanceOf(chainId, baseAddress) {
+    const account = await this.getAccount(baseAddress);
+    return await this.getProvider(chainId).getBalance(account.address);
+  }
+  async wrap(baseAddress, amount, options) {
+    try {
+      options?.onHandling?.();
+      const account = await this.getAccount(baseAddress);
+      const wrappedToken = WRAPPED_TOKENS.get(amount.currency.chainId);
+      const signer = await this.invokeSigner(
+        amount.currency.chainId,
+        account.address
+      );
+      const contract = WrapToken__factory.connect(wrappedToken.address, signer);
+      const txRequest = {
+        chainId: wrappedToken.chainId,
+        from: account.address,
+        to: wrappedToken.address,
+        data: contract.interface.encodeFunctionData("deposit"),
+        value: `0x${amount.quotient.toString(16)}`
+      };
+      const populatedTx = await this.gas.compute(txRequest);
+      const txResponse = await contract.deposit({
+        value: `0x${amount.quotient.toString(16)}`,
+        gasLimit: populatedTx.gasLimit,
+        maxFeePerGas: populatedTx.maxFeePerGas,
+        maxPriorityFeePerGas: populatedTx.maxPriorityFeePerGas
+      });
+      const receipt = await this.getProvider(
+        wrappedToken.chainId
+      )?.waitForTransaction(txResponse.hash);
+      if (receipt.status === 1) options?.onSuccess?.(receipt);
+      return txResponse;
+    } catch (error) {
+      console.error("wrap error:", error);
+      options?.onFailure?.(error);
+      throw error;
+    }
+  }
+  async unwrap(baseAddress, amount, options) {
+    try {
+      options?.onHandling?.();
+      const account = await this.getAccount(baseAddress);
+      const wrappedToken = WRAPPED_TOKENS.get(amount.currency.chainId);
+      const signer = await this.invokeSigner(
+        amount.currency.chainId,
+        account.address
+      );
+      const contract = WrapToken__factory.connect(wrappedToken.address, signer);
+      const value = `0x${amount.quotient.toString(16)}`;
+      const txRequest = {
+        to: wrappedToken.address,
+        from: account.address,
+        chainId: wrappedToken.chainId,
+        data: contract.interface.encodeFunctionData("withdraw", [value])
+      };
+      const populatedTx = await this.gas.compute(txRequest);
+      const txResponse = await contract.withdraw(value, {
+        gasLimit: populatedTx.gasLimit,
+        maxFeePerGas: populatedTx.maxFeePerGas,
+        maxPriorityFeePerGas: populatedTx.maxPriorityFeePerGas
+      });
+      const receipt = await this.getProvider(
+        wrappedToken.chainId
+      ).waitForTransaction(txResponse.hash);
+      if (receipt.status === 1) options?.onSuccess?.(receipt);
+      return txResponse;
+    } catch (error) {
+      console.error("unwrap error:", error);
+      options?.onFailure?.(error);
+      throw error;
+    }
+  }
+};
+var AbstractedEVM_default = AbstractedEVM;
+
+// src/core/platform/SVM/AbstractedSVM.ts
+import {
+  PublicKey,
+  Transaction,
+  VersionedTransaction,
+  SystemProgram,
+  Keypair
+} from "@solana/web3.js";
+
+// src/core/platform/SVM/@solana/spl-token.ts
+var splTokenLoader;
+var splToken;
+var loadSplToken = () => {
+  if (!splTokenLoader) {
+    splTokenLoader = import("@solana/spl-token").then((module) => {
+      splToken = module;
+      return module;
+    }).catch((error) => {
+      console.error("failed to import @solana/spl-token", error);
+      throw error;
+    });
+  }
+  return splTokenLoader;
+};
+loadSplToken();
+var get9 = () => {
+  if (!splToken) {
+    throw new Error(
+      "@solana/spl-token is not loaded yet. Ensure the module is initialized before use."
+    );
+  }
+  return splToken;
+};
+var NATIVE_MINT = () => get9().NATIVE_MINT;
+var TOKEN_PROGRAM_ID = () => get9().TOKEN_PROGRAM_ID;
+var TOKEN_2022_PROGRAM_ID = () => get9().TOKEN_2022_PROGRAM_ID;
+var getAssociatedTokenAddress = (mint, owner, allowOwnerOffCurve, programId, associatedTokenProgramId) => get9().getAssociatedTokenAddress(
+  mint,
+  owner,
+  allowOwnerOffCurve,
+  programId,
+  associatedTokenProgramId
+);
+var createSyncNativeInstruction = (account, programId) => get9().createSyncNativeInstruction(account, programId);
+var createCloseAccountInstruction = (account, destination, authority, multiSigners, programId) => get9().createCloseAccountInstruction(
+  account,
+  destination,
+  authority,
+  multiSigners,
+  programId
+);
+var createAssociatedTokenAccountInstruction = (payer, associatedToken, owner, mint, programId, associatedTokenProgramId) => get9().createAssociatedTokenAccountInstruction(
+  payer,
+  associatedToken,
+  owner,
+  mint,
+  programId,
+  associatedTokenProgramId
+);
+var createTransferInstruction = (source, destination, owner, amount, multiSigners, programId) => get9().createTransferInstruction(
+  source,
+  destination,
+  owner,
+  amount,
+  multiSigners,
+  programId
+);
+
+// src/core/platform/SVM/AbstractedSVM.ts
+import get10 from "lodash/get";
+import BigNumber7 from "bignumber.js";
+var SVM_NATIVE_ADDRESS = "11111111111111111111111111111111";
+var WAIT_FOR_TX_MAX_RETRIES = 60;
+var RETRY_INTERVALMS = 1e3;
+var AbstractedSVM = class extends AbstractedPlatform_default {
+  blockchain = "solana" /* SOLANA */;
+  name = `abstracted-${this.blockchain}`;
+  nativeAddress = SVM_NATIVE_ADDRESS;
+  constructor() {
+    super();
+  }
+  use(coredex) {
+    super.use(coredex);
+    this.initiate();
+    return this;
+  }
+  _initiated = false;
+  initiate() {
+    try {
+      if (this._initiated) return;
+      const solConfig = this.coredex.getAllChainConfigs().find((config) => config.blockchain === "solana" /* SOLANA */);
+      if (!solConfig) {
+        throw new Error(`missing chain config (blockchain: ${this.blockchain})`);
+      }
+      this.nativeAddress = get10(
+        solConfig,
+        "nativeTokenAddress",
+        SVM_NATIVE_ADDRESS
+      );
+      try {
+        WRAPPED_TOKENS.set(
+          solConfig.chainId,
+          new SolanaDexToken({
+            chainId: solConfig.chainId,
+            address: NATIVE_MINT().toString(),
+            decimals: solConfig.nativeToken.decimals,
+            symbol: solConfig.nativeToken.symbol,
+            name: solConfig.nativeToken.name,
+            standard: "erc20"
+          })
+        );
+      } catch (error) {
+        if (error?.message?.includes("not loaded yet")) {
+          loadSplToken().then(() => {
+            try {
+              WRAPPED_TOKENS.set(
+                solConfig.chainId,
+                new SolanaDexToken({
+                  chainId: solConfig.chainId,
+                  address: NATIVE_MINT().toString(),
+                  decimals: solConfig.nativeToken.decimals,
+                  symbol: solConfig.nativeToken.symbol,
+                  name: solConfig.nativeToken.name,
+                  standard: "erc20"
+                })
+              );
+            } catch (err) {
+              console.error(
+                `failed to set wrapped token for ${this.blockchain} after module load`,
+                err
+              );
+            }
+          });
+        } else {
+          throw error;
+        }
+      }
+      this._initiated = true;
+    } catch (error) {
+      console.error(`failed to initiate ${this.blockchain} platform`, error);
+      throw error;
+    }
+  }
+  getProvider(chainId) {
+    if (!chainId) {
+      const chainConfig = this.coredex.getAllChainConfigs().find((config) => config.blockchain === this.blockchain);
+      if (!chainConfig) {
+        throw new Error(`missing chain config (blockchain: ${this.blockchain})`);
+      }
+      chainId = chainConfig.chainId;
+    }
+    const provider = this.coredex.dependencies.providerManager.getProvider(chainId);
+    if (!provider) throw new Error(`missing provider (chainId: ${chainId})`);
+    return provider;
+  }
+  async getSigner(address) {
+    const account = await this.getAccount(address);
+    const signer = await this.coredex.dependencies.getSignerForAddress(
+      account.address
+    );
+    if (!signer) throw new Error(`missing signer (address: ${address})`);
+    return signer;
+  }
+  async invokeSigner(chainId, fromAddress) {
+    const provider = this.getProvider(chainId);
+    const signer = await this.getSigner(fromAddress);
+    return signer.connect(provider);
+  }
+  async buildQuote(quote) {
+    const builts = await super.buildQuote(quote);
+    return builts.map((built) => this.populateTransaction(get10(built, "data")));
+  }
+  async wrap(baseAccount, amount, options) {
+    try {
+      options?.onHandling?.();
+      const account = await this.getAccount(baseAccount);
+      const signer = await this.invokeSigner(
+        amount.currency.chainId,
+        account.address
+      );
+      const ownerAccount = new PublicKey(account.address);
+      const wSolAccount = await this.wSolAccount(account.address);
+      const accountInfo = await this.getAccountInfo(wSolAccount);
+      const lamports = BigInt(amount.quotient.toString());
+      const transaction = new Transaction();
+      if (!accountInfo) {
+        transaction.add(
+          createAssociatedTokenAccountInstruction(
+            ownerAccount,
+            wSolAccount,
+            ownerAccount,
+            NATIVE_MINT(),
+            TOKEN_PROGRAM_ID()
+          )
+        );
+      }
+      transaction.add(
+        SystemProgram.transfer({
+          fromPubkey: ownerAccount,
+          toPubkey: wSolAccount,
+          lamports: Number(lamports)
+        })
+      );
+      transaction.add(
+        createSyncNativeInstruction(wSolAccount, TOKEN_PROGRAM_ID())
+      );
+      transaction.feePayer = ownerAccount;
+      transaction.recentBlockhash = (await this.getLatestBlockhash(amount.currency.chainId)).blockhash;
+      const txHash = await signer.sendTransaction(transaction);
+      options?.onSubmitted?.(txHash);
+      if (!options?.waitForReceipt) return txHash;
+      options?.onWaitingForReceipt?.(txHash);
+      const receipt = await this.waitForReceipt(txHash);
+      this.coredex.console.info("receipt", receipt);
+      if (receipt.value.err) {
+        const errorMessage = JSON.stringify(receipt.value.err);
+        throw new Error(`Transaction confirmation failed: ${errorMessage}`);
+      }
+      options?.onSuccess?.(txHash);
+      return txHash;
+    } catch (error) {
+      console.error(`${this.name} wrap error:`, error);
+      options?.onFailure?.(error);
+      throw error;
+    }
+  }
+  async unwrap(baseAccount, amount, options) {
+    try {
+      options?.onHandling?.();
+      const account = await this.getAccount(baseAccount);
+      const signer = await this.invokeSigner(
+        amount.currency.chainId,
+        account.address
+      );
+      const wSolAccount = await this.wSolAccount(account.address);
+      const accountInfo = await this.getAccountInfo(wSolAccount);
+      if (!accountInfo) {
+        throw new Error("wSOL account does not exist. Nothing to unwrap.");
+      }
+      const currentBalance = await this.getWSolBalance(account.address);
+      const currentWSol = BigInt(currentBalance.value.amount);
+      const unwrapAmount = BigInt(amount.quotient.toString());
+      if (unwrapAmount < currentWSol) {
+        return await this.handlePartialUnwrap(
+          amount.currency.chainId,
+          account,
+          amount,
+          options
+        );
+      }
+      const transaction = new Transaction();
+      const ownerAccount = new PublicKey(account.address);
+      transaction.add(
+        createCloseAccountInstruction(
+          wSolAccount,
+          ownerAccount,
+          ownerAccount,
+          [],
+          TOKEN_PROGRAM_ID()
+        )
+      );
+      transaction.feePayer = ownerAccount;
+      transaction.recentBlockhash = (await this.getLatestBlockhash(amount.currency.chainId)).blockhash;
+      const txHash = await signer.sendTransaction(transaction);
+      options?.onSubmitted?.(txHash);
+      if (!options?.waitForReceipt) return txHash;
+      options?.onWaitingForReceipt?.(txHash);
+      const receipt = await this.waitForReceipt(txHash);
+      this.coredex.console.info("receipt", receipt);
+      if (receipt.value.err) {
+        const errorMessage = JSON.stringify(receipt.value.err);
+        throw new Error(`Transaction confirmation failed: ${errorMessage}`);
+      }
+      options?.onSuccess?.(txHash);
+      return txHash;
+    } catch (error) {
+      console.error(`${this.name} unwrap error:`, error);
+      options?.onFailure?.(error);
+      throw error;
+    }
+  }
+  async sendTransaction(chainId, from, txRequest, options) {
+    try {
+      const signer = await this.invokeSigner(chainId, from);
+      const txHash = await signer.sendTransaction(txRequest);
+      options?.onSubmitted?.(txHash);
+      if (!options?.waitForReceipt) return txHash;
+      options?.onWaitingForReceipt?.(txHash);
+      const receipt = await this.waitForReceipt(txHash);
+      this.coredex.console.info("receipt", receipt);
+      if (receipt.value.err) {
+        const errorMessage = JSON.stringify(receipt.value.err);
+        throw new Error(`Transaction confirmation failed: ${errorMessage}`);
+      }
+      options?.onSuccess?.(txHash);
+      return txHash;
+    } catch (error) {
+      options?.onFailure?.(error);
+      const normalizedError = normalizeError(error);
+      const enhancedError = new Error(
+        `Transaction failed: ${normalizedError.message}`
+      );
+      if (normalizedError instanceof Error && normalizedError.stack) {
+        enhancedError.stack = normalizedError.stack;
+      }
+      throw enhancedError;
+    }
+  }
+  async sendBatchTransaction(chainId, from, txRequests, { onSuccess, onFailure, ...options } = {}) {
+    const txHashes = [];
+    for (let index = 0; index < txRequests.length; index++) {
+      try {
+        const txRequest = txRequests[index];
+        const isLastCall = index === txRequests.length - 1;
+        const txHash = await this.sendTransaction(
+          chainId,
+          from,
+          txRequest,
+          !isLastCall ? options : { ...options, onSuccess, onFailure }
+        );
+        txHashes.push(txHash);
+      } catch (error) {
+        const normalizedError = normalizeError(error);
+        const enhancedError = new Error(
+          `Transaction failed: ${normalizedError.message}`
+        );
+        if (normalizedError instanceof Error && normalizedError.stack) {
+          enhancedError.stack = normalizedError.stack;
+        }
+        throw enhancedError;
+      }
+    }
+    return txHashes;
+  }
+  async nativeBalanceOf(chainId, account) {
+    const connection = this.getProvider(chainId);
+    const publicKey = new PublicKey(account);
+    const balance = await connection.getBalance(publicKey);
+    return BigInt(balance);
+  }
+  async balanceOf(chainId, account, tokenAddress) {
+    try {
+      if (this.isNativeAddress(tokenAddress)) {
+        return await this.nativeBalanceOf(chainId, account);
+      }
+      const connection = this.getProvider(chainId);
+      const ownerPublicKey = new PublicKey(account);
+      const mintPublicKey = new PublicKey(tokenAddress);
+      const tokenProgramId = await this.getTokenProgramId(tokenAddress);
+      const associatedTokenAddress = await getAssociatedTokenAddress(
+        mintPublicKey,
+        ownerPublicKey,
+        false,
+        tokenProgramId
+      );
+      const accountInfo = await connection.getAccountInfo(
+        associatedTokenAddress
+      );
+      if (!accountInfo) {
+        return 0n;
+      }
+      const tokenBalance = await connection.getTokenAccountBalance(
+        associatedTokenAddress
+      );
+      return BigInt(tokenBalance.value.amount);
+    } catch (error) {
+      console.error(`Error getting balance for ${tokenAddress}:`, error);
+      throw error;
+    }
+  }
+  async batchBalanceOf(chainId, account, tokenAddresses) {
+    const results = {};
+    const nativeTokens = tokenAddresses.filter(
+      (address) => this.isNativeAddress(address)
+    );
+    const splTokens = tokenAddresses.filter(
+      (address) => !this.isNativeAddress(address)
+    );
+    if (nativeTokens.length > 0) {
+      const nativeBalance = await this.nativeBalanceOf(chainId, account);
+      for (const nativeToken of nativeTokens) {
+        results[nativeToken] = nativeBalance;
+      }
+    }
+    if (splTokens.length > 0) {
+      const splBalances = await this.batchSplTokenBalances(
+        chainId,
+        account,
+        splTokens
+      );
+      Object.assign(results, splBalances);
+    }
+    return results;
+  }
+  async getNetworkFees(quote) {
+    try {
+      const builts = await this.buildQuote(quote);
+      if (!Array.isArray(builts)) {
+        throw new Error("invalid built routes response");
+      }
+      const nativeCurrency = this.getNativeCurrency(quote.chainId);
+      if (!nativeCurrency) throw new Error("cannot get native currency");
+      const fees = await Promise.all(builts.map((tx) => this.computeTxFee(tx)));
+      const totalFeeLamports = fees.reduce((sum, fee) => sum + (fee || 0), 0);
+      this.coredex.console.info(
+        `Total estimated fee: ${totalFeeLamports} lamports (${builts.length} transaction(s))`
+      );
+      const amount = new BigNumber7(totalFeeLamports).dividedBy(
+        new BigNumber7(10).pow(nativeCurrency.decimals)
+      );
+      const networkFees = [
+        {
+          level: "medium" /* Medium */,
+          amount,
+          currency: nativeCurrency
+        }
+      ];
+      return networkFees;
+    } catch (error) {
+      console.error(
+        `cannot get network fee (chainId: ${quote.chainId}):`,
+        error
+      );
+      return void 0;
+    }
+  }
+  async getTransactionFeeFromTxHash(txHash) {
+    try {
+      const connection = this.getProvider();
+      const parsedTx = await connection.getParsedTransaction(txHash, {
+        maxSupportedTransactionVersion: 0
+      });
+      if (!parsedTx || !parsedTx.meta) {
+        this.coredex.console.warn(
+          `Transaction ${txHash} not found or has no meta`
+        );
+        return void 0;
+      }
+      return parsedTx.meta.fee;
+    } catch (error) {
+      console.error(`Error getting actual fee for tx ${txHash}:`, error);
+      return void 0;
+    }
+  }
+  async verifyNetworkFee(quote, txHash) {
+    try {
+      const estimatedFees = await this.getNetworkFees(quote);
+      const estimatedFee = estimatedFees?.[0]?.amount;
+      if (!estimatedFee) {
+        throw new Error("Could not get estimated fee");
+      }
+      const actualFeeLamports = await this.getTransactionFeeFromTxHash(txHash);
+      if (actualFeeLamports === void 0) {
+        return {
+          estimated: estimatedFee,
+          actual: void 0,
+          actualLamports: void 0,
+          difference: void 0,
+          match: false
+        };
+      }
+      const nativeCurrency = this.getNativeCurrency(quote.chainId);
+      if (!nativeCurrency) {
+        throw new Error("cannot get native currency");
+      }
+      const actualFee = new BigNumber7(actualFeeLamports).dividedBy(
+        new BigNumber7(10).pow(nativeCurrency.decimals)
+      );
+      const difference = estimatedFee.minus(actualFee);
+      const match = difference.abs().isLessThan(new BigNumber7(1e-6));
+      this.coredex.console.info("Fee verification:", {
+        estimated: `${estimatedFee.toString()} SOL (${estimatedFee.multipliedBy(new BigNumber7(10).pow(nativeCurrency.decimals)).toString()} lamports)`,
+        actual: `${actualFee.toString()} SOL (${actualFeeLamports} lamports)`,
+        difference: `${difference.toString()} SOL`,
+        match,
+        txHash
+      });
+      return {
+        estimated: estimatedFee,
+        actual: actualFee,
+        actualLamports: actualFeeLamports,
+        difference,
+        match
+      };
+    } catch (error) {
+      console.error("Error verifying network fee:", error);
+      throw error;
+    }
+  }
+  async getAccountInfo(publicKey, commitmentOrConfig) {
+    const connection = this.getProvider();
+    return await connection.getAccountInfo(publicKey, commitmentOrConfig);
+  }
+  async wSolAccount(owner, targetMint = NATIVE_MINT()) {
+    const wSolAccount = await getAssociatedTokenAddress(
+      targetMint,
+      new PublicKey(owner)
+    );
+    return wSolAccount;
+  }
+  async getWSolBalance(owner) {
+    const connection = this.getProvider();
+    const wSolAccount = await this.wSolAccount(owner);
+    return await connection.getTokenAccountBalance(wSolAccount);
+  }
+  /**
+   * Handle partial unwrap: create a temporary wSOL account, transfer the amount,
+   * then close it to convert wSOL back to SOL.
+   * This requires both the temporary owner and main owner to sign the transaction.
+   */
+  async handlePartialUnwrap(chainId, account, amount, options) {
+    const partialUnwrapOwner = Keypair.generate();
+    const partialWrapSolAccount = await getAssociatedTokenAddress(
+      NATIVE_MINT(),
+      partialUnwrapOwner.publicKey
+    );
+    const transaction = new Transaction();
+    const connection = this.getProvider(chainId);
+    const ownerAccount = new PublicKey(account.address);
+    const rentLamports = await connection.getMinimumBalanceForRentExemption(0);
+    transaction.add(
+      SystemProgram.createAccount({
+        fromPubkey: ownerAccount,
+        newAccountPubkey: partialUnwrapOwner.publicKey,
+        lamports: rentLamports,
+        programId: SystemProgram.programId,
+        space: 0
+      })
+    );
+    const wSolAccount = await this.wSolAccount(
+      account.address,
+      new PublicKey(amount.currency.address)
+      // "So11111111111111111111111111111111111111112"
+    );
+    transaction.add(
+      createAssociatedTokenAccountInstruction(
+        ownerAccount,
+        partialWrapSolAccount,
+        partialUnwrapOwner.publicKey,
+        NATIVE_MINT(),
+        TOKEN_PROGRAM_ID()
+      )
+    );
+    transaction.add(
+      createTransferInstruction(
+        wSolAccount,
+        partialWrapSolAccount,
+        ownerAccount,
+        BigInt(amount.quotient.toString()),
+        [],
+        TOKEN_PROGRAM_ID()
+      )
+    );
+    transaction.add(
+      createCloseAccountInstruction(
+        partialWrapSolAccount,
+        ownerAccount,
+        // destination for the SOL
+        partialUnwrapOwner.publicKey,
+        // authority (owner of the token account)
+        [],
+        TOKEN_PROGRAM_ID()
+      )
+    );
+    transaction.feePayer = ownerAccount;
+    transaction.recentBlockhash = (await this.getLatestBlockhash(chainId)).blockhash;
+    const bs58 = await import("bs58");
+    const mainOwnerKeypair = Keypair.fromSecretKey(
+      bs58.default.decode(account.privateKey)
+    );
+    transaction.sign(partialUnwrapOwner, mainOwnerKeypair);
+    const txHash = await connection.sendRawTransaction(
+      transaction.serialize(),
+      { skipPreflight: false }
+    );
+    options?.onSubmitted?.(txHash);
+    if (!options?.waitForReceipt) return txHash;
+    options?.onWaitingForReceipt?.(txHash);
+    const receipt = await this.waitForReceipt(txHash);
+    this.coredex.console.info("receipt", receipt);
+    if (receipt.value.err) {
+      const errorMessage = JSON.stringify(receipt.value.err);
+      throw new Error(`Transaction confirmation failed: ${errorMessage}`);
+    }
+    options?.onSuccess?.(txHash);
+    return txHash;
+  }
+  async getLatestBlockhash(chainId) {
+    const connection = this.getProvider(chainId);
+    return await connection.getLatestBlockhash();
+  }
+  async getTokenProgramId(tokenAddress) {
+    try {
+      const accountInfo = await this.getAccountInfo(new PublicKey(tokenAddress));
+      if (!accountInfo)
+        throw new Error(`Token account not found for ${tokenAddress}`);
+      const { owner } = accountInfo;
+      if (owner.equals(TOKEN_PROGRAM_ID())) return TOKEN_PROGRAM_ID();
+      if (owner.equals(TOKEN_2022_PROGRAM_ID())) return TOKEN_2022_PROGRAM_ID();
+      return owner;
+    } catch (error) {
+      this.coredex.console.warn(
+        `Error getting token program id for ${tokenAddress}:`,
+        error
+      );
+      this.coredex.console.warn(
+        `Using default token program id: ${TOKEN_PROGRAM_ID().toString()}`
+      );
+      return TOKEN_PROGRAM_ID();
+    }
+  }
+  populateTransaction(signature) {
+    if (!signature || typeof signature !== "string") {
+      throw new Error(`invalid  signature`);
+    }
+    const buffer = Buffer.from(signature, "base64");
+    const uint8Array = new Uint8Array(buffer);
+    try {
+      return VersionedTransaction.deserialize(uint8Array);
+    } catch (error) {
+      return Transaction.from(buffer);
+    }
+  }
+  async waitForReceipt(txHash) {
+    const connection = this.getProvider();
+    for (let attempt = 0; attempt < WAIT_FOR_TX_MAX_RETRIES; attempt++) {
+      const response = await connection.getSignatureStatus(txHash, {
+        searchTransactionHistory: true
+      });
+      const status = get10(response, "value");
+      if (!status) {
+        await sleepAsync(RETRY_INTERVALMS);
+        continue;
+      }
+      if (status.err) {
+        return { value: { err: status.err } };
+      }
+      if (status.confirmationStatus === "confirmed" || status.confirmationStatus === "finalized") {
+        return { value: { status, err: null } };
+      }
+      await sleepAsync(RETRY_INTERVALMS);
+    }
+    throw new Error(
+      `waitForReceipt timeout: signature ${txHash} was not confirmed within ${WAIT_FOR_TX_MAX_RETRIES * RETRY_INTERVALMS}ms`
+    );
+  }
+  async computeTxFee(tx) {
+    try {
+      const connection = this.getProvider();
+      if (tx instanceof VersionedTransaction && "message" in tx) {
+        const fee2 = await connection.getFeeForMessage(tx.message);
+        return fee2.value || 0;
+      }
+      const msg = tx.compileMessage();
+      const fee = await connection.getFeeForMessage(msg);
+      return fee.value || 0;
+    } catch (error) {
+      console.error("unable to compute tx fee", error);
+      return 0;
+    }
+  }
+  async batchSplTokenBalances(chainId, account, tokenAddresses) {
+    const connection = this.getProvider(chainId);
+    const ownerPublicKey = new PublicKey(account);
+    const results = {};
+    try {
+      const associatedTokenAddresses = await Promise.all(
+        tokenAddresses.map(async (tokenAddress) => {
+          const mintPublicKey = new PublicKey(tokenAddress);
+          const tokenProgramId = await this.getTokenProgramId(tokenAddress);
+          return await getAssociatedTokenAddress(
+            mintPublicKey,
+            ownerPublicKey,
+            false,
+            tokenProgramId
+          );
+        })
+      );
+      const accountInfos = await connection.getMultipleAccountsInfo(
+        associatedTokenAddresses
+      );
+      for (let i = 0; i < tokenAddresses.length; i++) {
+        const tokenAddress = tokenAddresses[i];
+        const accountInfo = accountInfos[i];
+        try {
+          if (!accountInfo) {
+            results[tokenAddress] = 0n;
+          } else {
+            const tokenBalance = await connection.getTokenAccountBalance(
+              associatedTokenAddresses[i]
+            );
+            results[tokenAddress] = BigInt(tokenBalance.value.amount);
+          }
+        } catch (error) {
+          console.error(`Error decoding balance for ${tokenAddress}:`, error);
+          results[tokenAddress] = 0n;
+        }
+      }
+    } catch (error) {
+      console.error("Error in batch SPL token balance fetch:", error);
+      for (const tokenAddress of tokenAddresses) {
+        try {
+          results[tokenAddress] = await this.balanceOf(
+            chainId,
+            account,
+            tokenAddress
+          );
+        } catch (err) {
+          console.error(`Error getting balance for ${tokenAddress}:`, err);
+          results[tokenAddress] = 0n;
+        }
+      }
+    }
+    return results;
+  }
+};
+var AbstractedSVM_default = AbstractedSVM;
+
+// src/core/platform/PlatformFactory.ts
+var PlatformFactory = class extends CoreDexShared {
+  platform = /* @__PURE__ */ new Map();
+  constructor() {
+    super();
+  }
+  use(coredex) {
+    super.use(coredex);
+    const configuredBlockchains = new Set(
+      this.coredex.getAllChainConfigs().map((c) => c.blockchain)
+    );
+    if (configuredBlockchains.has("evm" /* EVM */)) {
+      if (!this.platform.has("evm" /* EVM */)) {
+        this.platform.set("evm" /* EVM */, new AbstractedEVM_default());
+      }
+    }
+    if (configuredBlockchains.has("solana" /* SOLANA */)) {
+      if (!this.platform.has("solana" /* SOLANA */)) {
+        this.platform.set("solana" /* SOLANA */, new AbstractedSVM_default());
+      }
+    }
+    this.platform.forEach((platform) => platform.use(this.coredex));
+    return this;
+  }
+  fromChainId(chainId) {
+    const chainConfig = this.coredex.getChainConfig(chainId);
+    const platform = this.platform.get(chainConfig.blockchain);
+    if (!platform) {
+      throw new Error(`missing platform (chainId: ${chainId})`);
+    }
+    return platform;
+  }
+  fromQuote(quote) {
+    if (["katana" /* Katana */].includes(quote.provider) && quote.calldataBuilder.strategy === "uniswap_like") {
+      return this.platform.get("katana" /* Katana */);
+    }
+    return this.fromChainId(quote.chainId);
+  }
+};
+var PlatformFactory_default = PlatformFactory;
+
+// src/core/CoreDex.ts
+import castArray from "lodash/castArray";
+import groupBy from "lodash/groupBy";
+import get11 from "lodash/get";
+var CoreDex = class {
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+    this.install_dependencies(dependencies);
+  }
+  aggregator = new Aggregator();
+  platform = new PlatformFactory_default();
+  updating = false;
+  emitter = new TypedEventEmitter();
+  install_dependencies(dependencies) {
+    this.dependencies = dependencies;
+    this.aggregator.use(this);
+    this.platform.use(this);
+  }
+  async updateDependencies(dependencies) {
+    this.updating = true;
+    this.dependencies = { ...this.dependencies, ...dependencies };
+    this.install_dependencies(this.dependencies);
+    return Promise.resolve(this.updating = false);
+  }
+  getNativeAsset(chainId) {
+    const chainConfigs = this.getChainConfig(chainId);
+    return chainConfigs.nativeToken.symbol.toUpperCase();
+  }
+  getChainConfigId(chainConfig) {
+    if (get11(chainConfig, "isCustom", false)) return chainConfig.rpcUrl;
+    return String(chainConfig.chainId);
+  }
+  getAllChainConfigs() {
+    return this.dependencies.providerManager.getChainConfigs();
+  }
+  getChainConfig(chainId) {
+    const chainConfig = this.getAllChainConfigs().find(
+      (chainConfig2) => chainConfig2.chainId === chainId
+    );
+    if (!chainConfig) throw new Error("chain config not found");
+    return chainConfig;
+  }
+  createSignatureId(chainId, tokenAddress) {
+    const chainConfig = this.getChainConfig(chainId);
+    return createSignatureId(chainConfig.rpcUrl, tokenAddress);
+  }
+  confirmationBlocks(chainId) {
+    if ([2020 /* RONIN */, 2021 /* SAIGON */].includes(chainId)) return 1;
+    return void 0;
+  }
+  async mixedBalanceOf(ownerAddress, currencies) {
+    const castedCurrencies = castArray(currencies);
+    if (castedCurrencies.length === 1) {
+      const chainId = castedCurrencies[0].chainId;
+      const tokenAddress = castedCurrencies[0].address;
+      const platform = this.platform.fromChainId(chainId);
+      const account = await platform.getAccount(ownerAddress);
+      const balance = await platform.balanceOf(
+        chainId,
+        account.address,
+        tokenAddress
+      );
+      const singleBalance = {
+        [chainId]: {
+          [tokenAddress]: balance
+        }
+      };
+      return singleBalance;
+    }
+    const groupedByChainId = Object.entries(
+      groupBy(castedCurrencies, "chainId")
+    );
+    if (groupedByChainId.length === 0) {
+      throw new Error("failed to batch balances (no currencies found)");
+    }
+    const balances = {};
+    const promises = groupedByChainId.reduce(
+      (accumulator, currency) => {
+        try {
+          const chainId = chainIdToNumber(get11(currency, "0"));
+          const tokenAddresses = get11(currency, "1", []).map(
+            (currency2) => currency2.address
+          );
+          if (tokenAddresses.length === 0) return accumulator;
+          accumulator.push({
+            chainId,
+            getBalances: (address) => this.platform.fromChainId(chainId).batchBalanceOf(chainId, address, tokenAddresses)
+          });
+          return accumulator;
+        } catch (error) {
+          return accumulator;
+        }
+      },
+      []
+    );
+    for await (const { chainId, getBalances } of promises) {
+      const account = await this.platform.fromChainId(chainId).getAccount(ownerAddress);
+      const rawBalances = await getBalances(account.address);
+      balances[chainId] = rawBalances;
+    }
+    return balances;
+  }
+  notify(quoteId, event) {
+    this.emitter.emit(quoteId, event);
+  }
+  get console() {
+    const logger = {
+      log: (..._args) => void 0,
+      warn: (..._args) => void 0,
+      info: (..._args) => void 0,
+      error: (..._args) => void 0
+    };
+    if (!this.dependencies.debug) {
+      return logger;
+    }
+    logger.log = (...args) => console.log(...args);
+    logger.warn = (...args) => console.warn(...args);
+    logger.info = (...args) => console.info(...args);
+    logger.error = (...args) => console.error(...args);
+    return logger;
+  }
+};
+
+// src/internals/types/signer.ts
+import { AbstractSigner } from "ethers";
+
+// src/internals/types/provider.ts
+var TokenStandard = /* @__PURE__ */ ((TokenStandard2) => {
+  TokenStandard2["ERC20"] = "erc20";
+  TokenStandard2["NATIVE"] = "native";
+  TokenStandard2["ERC721"] = "erc721";
+  TokenStandard2["ERC1155"] = "erc1155";
+  return TokenStandard2;
+})(TokenStandard || {});
+
+// src/core/services/DexQuoteRacer.ts
+var DEFAULT_MAX_CONCURRENT_QUOTES = 5;
+var DEFAULT_QUOTE_TIMEOUT_MS = 1e4;
+var REACT_NATIVE_MAX_CONCURRENT_QUOTES = 3;
+var REACT_NATIVE_QUOTE_TIMEOUT_MS = 8e3;
+var getPlatformConfig = () => {
+  const defaultConfig = {
+    maxConcurrentQuotes: DEFAULT_MAX_CONCURRENT_QUOTES,
+    quoteTimeoutMs: DEFAULT_QUOTE_TIMEOUT_MS,
+    delayBetweenBatches: 0
+  };
+  if (isReactNative()) {
+    defaultConfig.maxConcurrentQuotes = REACT_NATIVE_MAX_CONCURRENT_QUOTES;
+    defaultConfig.quoteTimeoutMs = REACT_NATIVE_QUOTE_TIMEOUT_MS;
+  }
+  return defaultConfig;
+};
+var DexQuoteRacer = class {
+  quoteTimeoutMs;
+  maxConcurrentQuotes;
+  delayBetweenBatches;
+  constructor(config = getPlatformConfig()) {
+    this.quoteTimeoutMs = config.quoteTimeoutMs;
+    this.maxConcurrentQuotes = config.maxConcurrentQuotes;
+    this.delayBetweenBatches = config.delayBetweenBatches;
+  }
+  async handle(items, processor, maxConcurrency = this.maxConcurrentQuotes) {
+    const awaited = [];
+    for (let i = 0; i < items.length; i += maxConcurrency) {
+      const batch = items.slice(i, i + maxConcurrency);
+      const promises = batch.map(
+        (item, batchIndex) => this.raceAsync(processor(item, i + batchIndex), this.quoteTimeoutMs)
+      );
+      const results = await Promise.all(promises);
+      awaited.push(...results);
+      if (this.delayBetweenBatches > 0 && i + maxConcurrency < items.length) {
+        await sleepAsync(this.delayBetweenBatches);
+      }
+    }
+    return awaited;
+  }
+  raceAsync(promise, timeoutMs = this.quoteTimeoutMs, error = "operation timed out") {
+    return Promise.race([
+      promise,
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error(error)), timeoutMs)
+      )
+    ]);
+  }
+};
+var DexQuoteRacer_default = DexQuoteRacer;
+
+// src/utils/simulate-wrap-quote.ts
+import { CurrencyAmount as CurrencyAmount6 } from "@uniswap/sdk-core";
+import isNil6 from "lodash/isNil";
+function simulateWrapQuote(payload) {
+  try {
+    const amountIn = CurrencyAmount6.fromRawAmount(
+      payload.currencyIn,
+      payload.amount
+    );
+    const amountOut = CurrencyAmount6.fromRawAmount(
+      payload.currencyOut,
+      payload.amount
+    );
+    const amounts = { ["tokenIn" /* TokenIn */]: amountIn, ["tokenOut" /* TokenOut */]: amountOut };
+    const wrapInfo = getWrapType(payload.currencyIn, payload.currencyOut);
+    const quote = {
+      __origin: { payload },
+      amounts,
+      wrapInfo,
+      quoteId: "",
+      provider: "wrap",
+      routes: [],
+      chainId: payload.currencyIn.chainId,
+      currencyIn: payload.currencyIn,
+      currencyOut: payload.currencyOut,
+      calldataBuilder: {},
+      permit2Address: "",
+      universalRouterAddress: "",
+      isBestTrade: true,
+      amountIn,
+      amountOut,
+      amountInUsd: void 0,
+      amountOutUsd: void 0,
+      priceImpact: void 0,
+      extraFee: void 0,
+      getAllocatedFee: async () => void 0,
+      getNetworkFees: async () => void 0
+    };
+    quote.quoteId = getQuoteUuid(quote);
+    return quote;
+  } catch (error) {
+    console.error("simulate wrap quote error: ", error);
+    throw error;
+  }
+}
+function shouldHandleWrap(quote) {
+  return !isNil6(quote?.wrapInfo) && quote.wrapInfo.type !== "not-applicable" /* NOT_APPLICABLE */;
+}
+
+// src/DexFactory.ts
+import castArray2 from "lodash/castArray";
+import groupBy2 from "lodash/groupBy";
+import isNil7 from "lodash/isNil";
+import get12 from "lodash/get";
+var DexFactory = class {
+  constructor(coredex) {
+    this.coredex = coredex;
+  }
+  racer = new DexQuoteRacer_default();
+  setLocation(location) {
+    this.coredex.aggregator.api.header("x-region-code", location);
+  }
+  async updateDeps(dependencies) {
+    await this.coredex.updateDependencies(dependencies);
+  }
+  getCurrencySigil(currency) {
+    return this.coredex.createSignatureId(currency.chainId, currency.address);
+  }
+  getNativeCurrency(chainId) {
+    return this.coredex.platform.fromChainId(chainId).getNativeCurrency(chainId);
+  }
+  async balanceOf(account, currency) {
+    const currencies = castArray2(currency);
+    const groupedByChainId = Object.entries(groupBy2(currencies, "chainId"));
+    if (groupedByChainId.length === 0) {
+      throw new Error("no currencies provided");
+    }
+    const responses = await this.coredex.mixedBalanceOf(account, currencies);
+    const flattened = Object.entries(responses);
+    const ids = [];
+    const data = {};
+    for (const currency2 of currencies) {
+      try {
+        const sigil = this.coredex.createSignatureId(
+          currency2.chainId,
+          currency2.address
+        );
+        ids.push(sigil);
+        const balances = flattened.find(
+          ([chainId]) => chainIdToNumber(chainId) === currency2.chainId
+        );
+        data[sigil] = get12(balances, `1.${currency2.address}`, "0").toString();
+      } catch (error) {
+        console.error(error);
+        continue;
+      }
+    }
+    return { ids, data };
+  }
+  async getDexTokens(chainId, options) {
+    return await this.coredex.aggregator.tokens(chainId, options);
+  }
+  async getQuotes(payload) {
+    if (payload.slippageToleranceBps.lessThan(MIN_SLIPPAGE)) {
+      throw new Error(
+        "Slippage tolerance must be equal to or greater than 0.1%"
+      );
+    }
+    if (payload.slippageToleranceBps.greaterThan(MAX_SLIPPAGE)) {
+      throw new Error("Slippage tolerance must be equal to or less than 30%");
+    }
+    const wrapInfo = getWrapType(payload.currencyIn, payload.currencyOut);
+    if (wrapInfo?.type !== "not-applicable" /* NOT_APPLICABLE */) {
+      return Promise.resolve([simulateWrapQuote(payload)]);
+    }
+    const quotes = await this.coredex.aggregator.find(payload);
+    const results = await this.racer.handle(quotes, async (quote) => {
+      try {
+        const platform = this.coredex.platform.fromQuote(quote);
+        return await platform.computeQuote(quote);
+      } catch (error) {
+        console.error(error);
+        return void 0;
+      }
+    });
+    return sortQuotesByPriority(
+      payload.direction,
+      results.filter((result) => !isNil7(result))
+    );
+  }
+  async build(quote, options) {
+    return await this.coredex.platform.fromQuote(quote).buildQuote(quote, options);
+  }
+  async handle(quote, {
+    waitForReceipt = true,
+    ...options
+  } = {}) {
+    const getPayload = (response) => ({
+      txHash: typeof response === "string" ? response : response.hash,
+      amountIn: quote.amounts["tokenIn" /* TokenIn */],
+      amountOut: quote.amounts["tokenOut" /* TokenOut */]
+    });
+    try {
+      const platform = this.coredex.platform.fromQuote(quote);
+      this.coredex.console.info(`[${platform.name}] handling transaction`);
+      const handleOptions = {
+        waitForReceipt,
+        ...options
+      };
+      if (shouldHandleWrap(quote)) {
+        const { method } = quote.wrapInfo;
+        const amount = quote.amounts["tokenIn" /* TokenIn */];
+        const response2 = await platform[method](
+          quote.__origin.payload.account,
+          amount,
+          {
+            ...handleOptions,
+            onHandling: () => {
+              this.coredex.notify(quote.quoteId, {
+                state: quote.wrapInfo.type === "wrap" /* WRAP */ ? "wrapping" /* Wrapping */ : "unwrapping" /* Unwrapping */,
+                data: { amount }
+              });
+            },
+            onSuccess: () => {
+              this.coredex.notify(quote.quoteId, {
+                state: quote.wrapInfo.type === "wrap" /* WRAP */ ? "wrapped" /* Wrapped */ : "unwrapped" /* Unwrapped */,
+                data: { amount }
+              });
+            }
+          }
+        );
+        this.coredex.console.info("tx hash", get12(response2, "hash", response2));
+        return response2;
+      }
+      this.coredex.notify(quote.quoteId, {
+        state: "computing" /* Computing */
+      });
+      let permitSignature;
+      if (platform instanceof AbstractedEVM_default && platform.blockchain === "evm" /* EVM */) {
+        permitSignature = await platform.authorize(quote);
+      }
+      let response;
+      const builts = await this.build(quote, { permitSignature });
+      Object.assign(handleOptions, {
+        onSubmitted: (response2) => {
+          this.coredex.notify(quote.quoteId, {
+            state: "transaction-submitted" /* TransactionSubmitted */,
+            data: getPayload(response2)
+          });
+        },
+        onWaitingForReceipt: (response2) => {
+          this.coredex.notify(quote.quoteId, {
+            state: "waiting-for-receipt" /* WaitingForReceipt */,
+            data: getPayload(response2)
+          });
+        },
+        onSuccess: (receipt) => {
+          this.coredex.notify(quote.quoteId, {
+            state: "success" /* Success */,
+            data: getPayload(receipt)
+          });
+        },
+        onFailure: (error) => {
+          this.coredex.notify(quote.quoteId, {
+            state: "failed" /* Failed */,
+            error: typedEtherError(error),
+            data: {
+              amountIn: quote.amounts["tokenIn" /* TokenIn */],
+              amountOut: quote.amounts["tokenOut" /* TokenOut */]
+            }
+          });
+        }
+      });
+      if (builts.length === 1) {
+        response = await platform.sendTransaction(
+          quote.chainId,
+          quote.__origin.payload.account,
+          builts[0],
+          handleOptions
+        );
+      } else {
+        response = await platform.sendBatchTransaction(
+          quote.chainId,
+          quote.__origin.payload.account,
+          builts,
+          handleOptions
+        );
+      }
+      this.coredex.console.info("tx hash", get12(response, "hash", response));
+      return response;
+    } catch (error) {
+      this.coredex.notify(quote.quoteId, {
+        state: "failed" /* Failed */,
+        error: typedEtherError(error),
+        data: getPayload(error)
+      });
+      throw error;
+    } finally {
+      this.coredex.emitter.removeAllListeners();
+    }
+  }
+  createDexCurrency(payload) {
+    return this.coredex.platform.fromChainId(payload.chainId).createDexCurrency(payload);
+  }
+  subscribe(quoteId, callback) {
+    this.coredex.emitter.on(quoteId, callback);
+    return () => this.coredex.emitter.off(quoteId, callback);
+  }
+};
+export {
+  AbstractedEVM_default as AbstractedEVM,
+  AbstractedPlatform_default as AbstractedPlatform,
+  AbstractedSVM_default as AbstractedSVM,
+  AggregatedQuoteFeeType,
+  BIPS_BASE,
+  Blockchain as BlockchainEnum,
+  CoreDex,
+  DEFAULT_DEADLINE_FROM_NOW,
+  DEFAULT_SLIPPAGE,
+  DexHandleQuoteState,
+  DexToken,
+  EVMChainId as EVMChainIdEnum,
+  Field,
+  GasEstimator_default as GasEstimator,
+  NATIVE_ADDRESS,
+  NativeCurrency,
+  NetworkFeeLevel,
+  PlatformFactory_default as PlatformFactory,
+  PriceImpactLevel,
+  SolanaDexToken,
+  TokenStandard as TokenStandardEnum,
+  WalletType as WalletTypeEnum,
+  WrapType,
+  computeNetworkCost,
+  createSignatureId,
+  DexFactory as default,
+  maxAmountSpend,
+  parseSignatureId,
+  tradeMeaningfullyDiffers
+};