@crypto-dex-sdk/currency/dist/index.mjs

Zenlink Currency

var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
  for (var prop in b || (b = {}))
    if (__hasOwnProp.call(b, prop))
      __defNormalProp(a, prop, b[prop]);
  if (__getOwnPropSymbols)
    for (var prop of __getOwnPropSymbols(b)) {
      if (__propIsEnum.call(b, prop))
        __defNormalProp(a, prop, b[prop]);
    }
  return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));

// src/Amount.ts
import { Big as Big2, Fraction as Fraction2, JSBI as JSBI2, MAX_UINT256, Rounding as Rounding2, ZERO as ZERO2 } from "@crypto-dex-sdk/math";
import invariant2 from "tiny-invariant";

// src/Share.ts
import { Big, Fraction, JSBI, MAX_UINT128, Rounding, ZERO } from "@crypto-dex-sdk/math";
import invariant from "tiny-invariant";
var Share = class _Share extends Fraction {
  static fromRawShare(currency, rawShare) {
    return new _Share(currency, rawShare);
  }
  constructor(currency, numerator, denominator) {
    super(numerator, denominator);
    invariant(JSBI.lessThanOrEqual(this.quotient, MAX_UINT128), "SHARE");
    this.currency = currency;
    this.scale = JSBI.exponentiate(JSBI.BigInt(10), JSBI.BigInt(currency.decimals));
  }
  toAmount(rebase, roundUp = false) {
    if (JSBI.EQ(rebase.base, ZERO))
      return Amount.fromRawAmount(this.currency, this.quotient);
    const elastic = JSBI.divide(JSBI.multiply(this.quotient, rebase.elastic), rebase.base);
    if (roundUp && JSBI.LT(JSBI.divide(JSBI.multiply(elastic, rebase.base), rebase.elastic), this.quotient))
      return Amount.fromRawAmount(this.currency, JSBI.add(elastic, JSBI.BigInt(1)));
    return Amount.fromRawAmount(this.currency, elastic);
  }
  /**
   * Construct a currency share with a denominator that is not equal to 1
   * @param currency the currency
   * @param numerator the numerator of the fractional token share
   * @param denominator the denominator of the fractional token share
   */
  static fromFractionalShare(currency, numerator, denominator) {
    return new _Share(currency, numerator, denominator);
  }
  add(other) {
    invariant(this.currency.equals(other.currency), "CURRENCY");
    const added = super.add(other);
    return _Share.fromFractionalShare(this.currency, added.numerator, added.denominator);
  }
  subtract(other) {
    invariant(this.currency.equals(other.currency), "CURRENCY");
    const subtracted = super.subtract(other);
    return _Share.fromFractionalShare(this.currency, subtracted.numerator, subtracted.denominator);
  }
  multiply(other) {
    const multiplied = super.multiply(other);
    return _Share.fromFractionalShare(this.currency, multiplied.numerator, multiplied.denominator);
  }
  divide(other) {
    const divided = super.divide(other);
    return _Share.fromFractionalShare(this.currency, divided.numerator, divided.denominator);
  }
  toSignificant(significantDigits = 6, format, rounding = Rounding.ROUND_DOWN) {
    return super.divide(this.scale).toSignificant(significantDigits, format, rounding);
  }
  toFixed(decimalPlaces = this.currency.decimals, format, rounding = Rounding.ROUND_DOWN) {
    invariant(decimalPlaces <= this.currency.decimals, "DECIMALS");
    return super.divide(this.scale).toFixed(decimalPlaces, format, rounding);
  }
  toExact(format = { groupSeparator: "" }) {
    Big.DP = this.currency.decimals;
    return new Big(this.quotient.toString()).div(this.scale.toString()).toFormat(format);
  }
};

// src/Amount.ts
var Amount = class _Amount extends Fraction2 {
  /**
   * Returns a new currency amount instance from the unitless amount of token, i.e. the raw amount
   * @param currency the currency in the amount
   * @param rawAmount the raw token or ether amount
   */
  static fromRawAmount(currency, rawAmount) {
    return new _Amount(currency, rawAmount);
  }
  static fromShare(currency, shares, rebase, roundUp = false) {
    if (JSBI2.EQ(rebase.base, ZERO2))
      return new _Amount(currency, shares);
    const elastic = JSBI2.divide(JSBI2.multiply(JSBI2.BigInt(shares), rebase.elastic), rebase.base);
    if (roundUp && JSBI2.LT(JSBI2.divide(JSBI2.multiply(elastic, rebase.base), rebase.elastic), JSBI2.BigInt(shares)))
      return new _Amount(currency, JSBI2.add(elastic, JSBI2.BigInt(1)));
    return new _Amount(currency, elastic);
  }
  toShare(rebase, roundUp = false) {
    if (JSBI2.EQ(rebase.elastic, ZERO2))
      return Share.fromRawShare(this.currency, this.quotient);
    const base = JSBI2.divide(JSBI2.multiply(this.quotient, rebase.base), rebase.elastic);
    if (roundUp && JSBI2.LT(JSBI2.divide(JSBI2.multiply(base, rebase.elastic), rebase.base), this.quotient))
      return Share.fromRawShare(this.currency, JSBI2.add(base, JSBI2.BigInt(1)));
    return Share.fromRawShare(this.currency, base);
  }
  /**
   * Construct a currency amount with a denominator that is not equal to 1
   * @param currency the currency
   * @param numerator the numerator of the fractional token amount
   * @param denominator the denominator of the fractional token amount
   */
  static fromFractionalAmount(currency, numerator, denominator) {
    return new _Amount(currency, numerator, denominator);
  }
  constructor(currency, numerator, denominator) {
    super(numerator, denominator);
    invariant2(JSBI2.lessThanOrEqual(this.quotient, MAX_UINT256), "AMOUNT");
    this.currency = currency;
    this.scale = JSBI2.exponentiate(JSBI2.BigInt(10), JSBI2.BigInt(currency.decimals));
  }
  add(other) {
    invariant2(this.currency.equals(other.currency), "CURRENCY");
    const added = super.add(other);
    return _Amount.fromFractionalAmount(this.currency, added.numerator, added.denominator);
  }
  subtract(other) {
    invariant2(this.currency.equals(other.currency), "CURRENCY");
    const subtracted = super.subtract(other);
    return _Amount.fromFractionalAmount(this.currency, subtracted.numerator, subtracted.denominator);
  }
  multiply(other) {
    const multiplied = super.multiply(other);
    return _Amount.fromFractionalAmount(this.currency, multiplied.numerator, multiplied.denominator);
  }
  divide(other) {
    const divided = super.divide(other);
    return _Amount.fromFractionalAmount(this.currency, divided.numerator, divided.denominator);
  }
  toSignificant(significantDigits = 6, format, rounding = Rounding2.ROUND_DOWN) {
    return super.divide(this.scale).toSignificant(significantDigits, format, rounding);
  }
  toFixed(decimalPlaces = this.currency.decimals, format, rounding = Rounding2.ROUND_DOWN) {
    invariant2(decimalPlaces <= this.currency.decimals, "DECIMALS");
    return super.divide(this.scale).toFixed(decimalPlaces, format, rounding);
  }
  toHex() {
    return `0x${this.quotient.toString(16)}`;
  }
  toExact(format = { groupSeparator: "" }) {
    Big2.DP = this.currency.decimals;
    return new Big2(this.quotient.toString()).div(this.scale.toString()).toFormat(format);
  }
  get wrapped() {
    if (this.currency.isToken)
      return this;
    return _Amount.fromFractionalAmount(this.currency.wrapped, this.numerator, this.denominator);
  }
};

// src/constants/tokenAddresses.ts
import { ParachainId } from "@crypto-dex-sdk/chain";
var WNATIVE_ADDRESS = {
  [ParachainId.MOONRIVER]: "0x98878B06940aE243284CA214f92Bb71a2b032B8A",
  [ParachainId.MOONBEAM]: "0xAcc15dC74880C9944775448304B263D191c6077F",
  [ParachainId.ASTAR]: "0xAeaaf0e2c81Af264101B9129C00F4440cCF0F720",
  [ParachainId.ARBITRUM_ONE]: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
  [ParachainId.BIFROST_KUSAMA]: "2001-0-0",
  [ParachainId.BIFROST_POLKADOT]: "2030-0-0",
  [ParachainId.SCROLL_ALPHA]: "0xa1EA0B2354F5A344110af2b6AD68e75545009a03",
  [ParachainId.SCROLL]: "0x5300000000000000000000000000000000000004",
  [ParachainId.BASE]: "0x4200000000000000000000000000000000000006",
  [ParachainId.AMPLITUDE]: "2124-0-0",
  [ParachainId.PENDULUM]: "2094-0-0"
};
var WETH9_ADDRESS = {
  [ParachainId.ARBITRUM_ONE]: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
  [ParachainId.BASE]: "0x4200000000000000000000000000000000000006",
  [ParachainId.SCROLL]: "0x5300000000000000000000000000000000000004"
};
var WBTC_ADDRESS = {
  [ParachainId.ARBITRUM_ONE]: "0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f",
  [ParachainId.SCROLL]: "0x3C1BCa5a656e69edCD0D4E36BEbb3FcDAcA60Cf1"
};
var UNI_ADDRESS = {
  [ParachainId.ARBITRUM_ONE]: "0xFa7F8980b0f1E64A2062791cc3b0871572f1F7f0"
};
var ZLK_ADDRESS = {
  [ParachainId.ASTAR]: "0x998082c488e548820f970df5173bd2061ce90635",
  [ParachainId.MOONRIVER]: "0x0f47ba9d9bde3442b42175e51d6a367928a1173b",
  [ParachainId.MOONBEAM]: "0x3fd9b6c9a24e09f67b7b706d72864aebb439100c",
  [ParachainId.BIFROST_KUSAMA]: "2001-2-519",
  [ParachainId.BIFROST_POLKADOT]: "2030-2-519"
};
var axlUSDC_ADDRESS = {
  [ParachainId.BASE]: "0xEB466342C4d449BC9f53A865D5Cb90586f405215",
  [ParachainId.SCROLL]: "0xEB466342C4d449BC9f53A865D5Cb90586f405215"
};
var axlDAI_ADDRESS = {
  [ParachainId.BASE]: "0x5C7e299CF531eb66f2A1dF637d37AbB78e6200C7"
};
var USDC_ADDRESS = {
  [ParachainId.MOONRIVER]: "0xE3F5a90F9cb311505cd691a46596599aA1A0AD7D",
  [ParachainId.ASTAR]: "0x6a2d262D56735DbA19Dd70682B39F6bE9a931D98",
  [ParachainId.ARBITRUM_ONE]: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
  [ParachainId.SCROLL_ALPHA]: "0x67aE69Fd63b4fc8809ADc224A9b82Be976039509",
  [ParachainId.SCROLL]: "0x06eFdBFf2a14a7c8E15944D1F4A48F9F95F663A4",
  [ParachainId.BASE]: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
  [ParachainId.AMPLITUDE]: "2124-2-513"
};
var USDT_ADDRESS = {
  [ParachainId.MOONRIVER]: "0xB44a9B6905aF7c801311e8F4E76932ee959c663C",
  [ParachainId.ASTAR]: "0xffffffff000000000000000000000001000007c0",
  [ParachainId.ARBITRUM_ONE]: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
  [ParachainId.BIFROST_KUSAMA]: "2001-2-2048",
  [ParachainId.SCROLL]: "0xf55BEC9cafDbE8730f096Aa55dad6D22d44099Df",
  [ParachainId.AMPLITUDE]: "2124-2-257"
};
var DAI_ADDRESS = {
  [ParachainId.ASTAR]: "0x6De33698e9e9b787e09d3Bd7771ef63557E148bb",
  [ParachainId.ARBITRUM_ONE]: "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1",
  [ParachainId.SCROLL_ALPHA]: "0x4702E5AEb70BdC05B11F8d8E701ad000dc85bD44",
  [ParachainId.BASE]: "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb",
  [ParachainId.SCROLL]: "0xcA77eB3fEFe3725Dc33bccB54eDEFc3D9f764f97"
};
var FRAX_ADDRESS = {
  [ParachainId.MOONRIVER]: "0x1A93B23281CC1CDE4C4741353F3064709A16197d",
  [ParachainId.MOONBEAM]: "0x322E86852e492a7Ee17f28a78c663da38FB33bfb",
  [ParachainId.ARBITRUM_ONE]: "0x17FC002b466eEc40DaE837Fc4bE5c67993ddBd6F"
};
var XCAUSD_ADDRESS = {
  [ParachainId.MOONRIVER]: "0xFfFffFFfa1B026a00FbAA67c86D5d1d5BF8D8228",
  [ParachainId.MOONBEAM]: "0xfFfFFFFF52C56A9257bB97f4B2b6F7B2D624ecda",
  [ParachainId.BIFROST_KUSAMA]: "2001-2-770"
};
var KSM_ADDRESS = {
  [ParachainId.BIFROST_KUSAMA]: "2001-2-516",
  [ParachainId.AMPLITUDE]: "2124-2-256"
};
var DOT_ADDRESS = {
  [ParachainId.ASTAR]: "0xffffffffffffffffffffffffffffffffffffffff",
  [ParachainId.MOONBEAM]: "0xffffffff1fcacbd218edc0eba20fc2308c778080",
  [ParachainId.BIFROST_POLKADOT]: "2030-2-2048",
  [ParachainId.PENDULUM]: "2094-2-256"
};
var LINK_ADDRESS = {
  [ParachainId.ARBITRUM_ONE]: "0xf97f4df75117a78c1A5a0DBb814Af92458539FB4"
};
var ARB_ADDRESS = {
  [ParachainId.ARBITRUM_ONE]: "0x912CE59144191C1204E64559FE8253a0e49E6548"
};

// src/constants/tokens.ts
import { ParachainId as ParachainId2 } from "@crypto-dex-sdk/chain";

// src/Token.ts
import { addressToZenlinkAssetId, isZenlinkAddress } from "@crypto-dex-sdk/format";
import { getAddress, isAddress } from "@ethersproject/address";
import invariant4 from "tiny-invariant";

// src/Currency.ts
import invariant3 from "tiny-invariant";
var Currency = class {
  constructor({
    chainId,
    decimals,
    symbol,
    name
  }) {
    invariant3(Number.isSafeInteger(Number(chainId)), "CHAIN_ID");
    invariant3(Number(decimals) >= 0 && Number(decimals) < 255 && Number.isInteger(Number(decimals)), "DECIMALS");
    this.chainId = Number(chainId);
    this.decimals = Number(decimals);
    this.symbol = symbol;
    this.name = name;
  }
};

// src/Token.ts
var Token = class extends Currency {
  constructor(token) {
    super(token);
    this.isNative = false;
    this.isToken = true;
    try {
      if (isZenlinkAddress(token.address))
        this.address = token.address;
      else
        this.address = getAddress(token.address);
    } catch (e) {
      throw new Error(`${token.address} is not a valid address`);
    }
  }
  /**
   * Returns true if the two tokens are equivalent, i.e. have the same chainId and address.
   * @param other other token to compare
   */
  equals(other) {
    return other.isToken && this.chainId === other.chainId && this.address === other.address;
  }
  /**
   * Returns true if the address of this token sorts before the address of the other token
   * @param other other token to compare
   * @throws if the tokens have the same address
   * @throws if the tokens are on different chains
   */
  sortsBefore(other) {
    invariant4(this.chainId === other.chainId, "CHAIN_IDS");
    invariant4(this.address !== other.address, "ADDRESSES");
    if (!isAddress(this.address) && isZenlinkAddress(this.address)) {
      const { chainId, assetType, assetIndex } = addressToZenlinkAssetId(this.address);
      const otherTokenAssetId = addressToZenlinkAssetId(other.address);
      return chainId < otherTokenAssetId.chainId || assetType < otherTokenAssetId.assetType || assetIndex < otherTokenAssetId.assetIndex;
    }
    return this.address.toLowerCase() < other.address.toLowerCase();
  }
  /**
   * Return this token, which does not need to be wrapped
   */
  get wrapped() {
    return this;
  }
};

// src/addressMapToTokenMap.ts
function addressMapToTokenMap({ decimals, symbol, name }, map) {
  return Object.fromEntries(
    Object.entries(map).map(([chainId, address]) => [
      chainId,
      new Token({
        chainId,
        address,
        decimals,
        symbol,
        name
      })
    ])
  );
}

// src/constants/tokens.ts
var WNATIVE = {
  [ParachainId2.MOONRIVER]: new Token({
    chainId: ParachainId2.MOONRIVER,
    address: WNATIVE_ADDRESS[ParachainId2.MOONRIVER],
    decimals: 18,
    symbol: "WMOVR",
    name: "Wrapped Moonriver"
  }),
  [ParachainId2.MOONBEAM]: new Token({
    chainId: ParachainId2.MOONBEAM,
    address: WNATIVE_ADDRESS[ParachainId2.MOONBEAM],
    decimals: 18,
    symbol: "WGLMR",
    name: "Wrapped Glimmer"
  }),
  [ParachainId2.ASTAR]: new Token({
    chainId: ParachainId2.ASTAR,
    address: WNATIVE_ADDRESS[ParachainId2.ASTAR],
    decimals: 18,
    symbol: "WASTR",
    name: "Wrapped Astar"
  }),
  [ParachainId2.ARBITRUM_ONE]: new Token({
    chainId: ParachainId2.ARBITRUM_ONE,
    address: WNATIVE_ADDRESS[ParachainId2.ARBITRUM_ONE],
    decimals: 18,
    name: "Wrapped Ether",
    symbol: "WETH"
  }),
  [ParachainId2.BIFROST_KUSAMA]: new Token({
    chainId: ParachainId2.BIFROST_KUSAMA,
    address: WNATIVE_ADDRESS[ParachainId2.BIFROST_KUSAMA],
    decimals: 12,
    symbol: "BNC",
    name: "Bifrost"
  }),
  [ParachainId2.BIFROST_POLKADOT]: new Token({
    chainId: ParachainId2.BIFROST_POLKADOT,
    address: WNATIVE_ADDRESS[ParachainId2.BIFROST_POLKADOT],
    decimals: 12,
    symbol: "BNC",
    name: "Bifrost"
  }),
  [ParachainId2.SCROLL_ALPHA]: new Token({
    chainId: ParachainId2.SCROLL_ALPHA,
    address: WNATIVE_ADDRESS[ParachainId2.SCROLL_ALPHA],
    decimals: 18,
    name: "Wrapped Ether",
    symbol: "WETH"
  }),
  [ParachainId2.SCROLL]: new Token({
    chainId: ParachainId2.SCROLL,
    address: WNATIVE_ADDRESS[ParachainId2.SCROLL],
    decimals: 18,
    name: "Wrapped Ether",
    symbol: "WETH"
  }),
  [ParachainId2.BASE]: new Token({
    chainId: ParachainId2.BASE,
    address: WNATIVE_ADDRESS[ParachainId2.BASE],
    decimals: 18,
    name: "Wrapped Ether",
    symbol: "WETH"
  }),
  [ParachainId2.AMPLITUDE]: new Token({
    chainId: ParachainId2.AMPLITUDE,
    address: WNATIVE_ADDRESS[ParachainId2.AMPLITUDE],
    decimals: 12,
    name: "Amplitude",
    symbol: "AMPE"
  }),
  [ParachainId2.PENDULUM]: new Token({
    chainId: ParachainId2.PENDULUM,
    address: WNATIVE_ADDRESS[ParachainId2.PENDULUM],
    decimals: 12,
    name: "Pendulum",
    symbol: "PEN"
  })
};
var WETH9 = addressMapToTokenMap(
  {
    decimals: 18,
    symbol: "WETH",
    name: "Wrapped Ether"
  },
  WETH9_ADDRESS
);
var WBTC = addressMapToTokenMap(
  {
    decimals: 8,
    symbol: "WBTC",
    name: "Wrapped BTC"
  },
  WBTC_ADDRESS
);
var UNI = addressMapToTokenMap(
  {
    symbol: "UNI",
    decimals: 18,
    name: "Uniswap"
  },
  UNI_ADDRESS
);
var ZLK = __spreadValues({}, addressMapToTokenMap(
  {
    decimals: 18,
    symbol: "ZLK",
    name: "Zenlink Network Token"
  },
  ZLK_ADDRESS
));
var USDC = __spreadProps(__spreadValues({}, addressMapToTokenMap(
  {
    decimals: 6,
    symbol: "USDC",
    name: "USD Coin"
  },
  USDC_ADDRESS
)), {
  [ParachainId2.MOONBEAM]: new Token({
    chainId: ParachainId2.MOONBEAM,
    address: "0xFFfffffF7D2B0B761Af01Ca8e25242976ac0aD7D",
    decimals: 6,
    symbol: "xcUSDC",
    name: "USD Coin (Xcm)"
  })
});
var USDT = __spreadProps(__spreadValues({}, addressMapToTokenMap(
  {
    decimals: 6,
    symbol: "USDT",
    name: "Tether USD"
  },
  USDT_ADDRESS
)), {
  [ParachainId2.MOONBEAM]: new Token({
    chainId: ParachainId2.MOONBEAM,
    address: "0xffffffffea09fb06d082fd1275cd48b191cbcd1d",
    decimals: 6,
    symbol: "xcUSDT",
    name: "Tether USD (Xcm)"
  }),
  [ParachainId2.SCROLL_ALPHA]: new Token({
    chainId: ParachainId2.SCROLL_ALPHA,
    address: "0x63fEF8791bdbe25A77337Cc265Ad732f200450AF",
    decimals: 18,
    symbol: "USDT",
    name: "Tether USD"
  })
});
var DAI = __spreadValues({}, addressMapToTokenMap(
  {
    decimals: 18,
    symbol: "DAI",
    name: "Dai Stablecoin"
  },
  DAI_ADDRESS
));
var FRAX = addressMapToTokenMap(
  {
    decimals: 18,
    symbol: "FRAX",
    name: "Frax"
  },
  FRAX_ADDRESS
);
var XCAUSD = addressMapToTokenMap(
  {
    decimals: 12,
    symbol: "xcaUSD",
    name: "Acala Dollar"
  },
  XCAUSD_ADDRESS
);
var KSM = addressMapToTokenMap(
  {
    decimals: 12,
    symbol: "KSM",
    name: "Kusama"
  },
  KSM_ADDRESS
);
var DOT = addressMapToTokenMap(
  {
    decimals: 10,
    symbol: "DOT",
    name: "Polkadot"
  },
  DOT_ADDRESS
);
var LINK = addressMapToTokenMap(
  {
    decimals: 18,
    symbol: "LINK",
    name: "ChainLink Token"
  },
  LINK_ADDRESS
);
var ARB = addressMapToTokenMap(
  {
    decimals: 18,
    symbol: "ARB",
    name: "Arbitrum"
  },
  ARB_ADDRESS
);

// src/getCurrencyCombinations.ts
import { ParachainId as ParachainId3 } from "@crypto-dex-sdk/chain";
import flatMap from "lodash.flatmap";
var BASES_TO_CHECK_TRADES_AGAINST = {
  [ParachainId3.MOONRIVER]: [
    WNATIVE[ParachainId3.MOONRIVER],
    USDC[ParachainId3.MOONRIVER],
    FRAX[ParachainId3.MOONRIVER],
    XCAUSD[ParachainId3.MOONRIVER],
    USDT[ParachainId3.MOONRIVER],
    ZLK[ParachainId3.MOONRIVER]
  ],
  [ParachainId3.MOONBEAM]: [
    WNATIVE[ParachainId3.MOONBEAM],
    USDC[ParachainId3.MOONBEAM],
    FRAX[ParachainId3.MOONBEAM],
    XCAUSD[ParachainId3.MOONBEAM],
    USDT[ParachainId3.MOONBEAM],
    ZLK[ParachainId3.MOONBEAM],
    new Token({
      chainId: ParachainId3.MOONBEAM,
      address: "0xc234a67a4f840e61ade794be47de455361b52413",
      decimals: 18,
      symbol: "madDAI",
      name: "Dai Stablecoin"
    }),
    new Token({
      chainId: ParachainId3.MOONBEAM,
      address: "0x8f552a71efe5eefc207bf75485b356a0b3f01ec9",
      decimals: 6,
      symbol: "madUSDC",
      name: "USD Coin"
    }),
    new Token({
      chainId: ParachainId3.MOONBEAM,
      address: "0x8e70cd5b4ff3f62659049e74b6649c6603a0e594",
      decimals: 6,
      symbol: "madUSDT",
      name: "Tether USD"
    }),
    new Token({
      chainId: ParachainId3.MOONBEAM,
      address: "0x81ecac0d6be0550a00ff064a4f9dd2400585fe9c",
      decimals: 6,
      symbol: "ceUSDT",
      name: "Tether USD (Celer)"
    }),
    new Token({
      chainId: ParachainId3.MOONBEAM,
      address: "0x6a2d262d56735dba19dd70682b39f6be9a931d98",
      decimals: 6,
      symbol: "ceUSDC",
      name: "USD Coin (Celer)"
    }),
    new Token({
      chainId: ParachainId3.MOONBEAM,
      address: "0xa649325aa7c5093d12d6f98eb4378deae68ce23f",
      decimals: 18,
      symbol: "anyBUSD",
      name: "Binance-Peg BUSD Token"
    }),
    new Token({
      chainId: ParachainId3.MOONBEAM,
      address: "0x765277eebeca2e31912c9946eae1021199b39c61",
      decimals: 18,
      symbol: "anyDAI",
      name: "Dai Stablecoin"
    })
  ],
  [ParachainId3.ASTAR]: [
    WNATIVE[ParachainId3.ASTAR],
    USDC[ParachainId3.ASTAR],
    DAI[ParachainId3.ASTAR],
    USDT[ParachainId3.ASTAR],
    DOT[ParachainId3.ASTAR],
    ZLK[ParachainId3.ASTAR],
    new Token({
      chainId: ParachainId3.ASTAR,
      address: "0x4Bf769b05E832FCdc9053fFFBC78Ca889aCb5E1E",
      decimals: 18,
      symbol: "BUSD",
      name: "Binance USD"
    }),
    new Token({
      chainId: ParachainId3.ASTAR,
      address: "0x733ebcC6DF85f8266349DEFD0980f8Ced9B45f35",
      decimals: 18,
      symbol: "BAI",
      name: "BAI Stablecoin"
    })
  ],
  [ParachainId3.BIFROST_KUSAMA]: [
    WNATIVE[ParachainId3.BIFROST_KUSAMA],
    USDT[ParachainId3.BIFROST_KUSAMA],
    XCAUSD[ParachainId3.BIFROST_KUSAMA],
    KSM[ParachainId3.BIFROST_KUSAMA],
    ZLK[ParachainId3.BIFROST_KUSAMA]
  ],
  [ParachainId3.BIFROST_POLKADOT]: [
    WNATIVE[ParachainId3.BIFROST_POLKADOT],
    DOT[ParachainId3.BIFROST_POLKADOT],
    new Token({
      chainId: ParachainId3.BIFROST_POLKADOT,
      address: "2030-2-2304",
      decimals: 10,
      symbol: "vDOT",
      name: "Voucher DOT"
    }),
    new Token({
      chainId: ParachainId3.BIFROST_POLKADOT,
      address: "2030-2-2560",
      decimals: 10,
      symbol: "vsDOT",
      name: "Voucher Slot DOT"
    })
  ],
  [ParachainId3.AMPLITUDE]: [
    WNATIVE[ParachainId3.AMPLITUDE],
    KSM[ParachainId3.AMPLITUDE]
  ],
  [ParachainId3.PENDULUM]: [
    WNATIVE[ParachainId3.PENDULUM],
    DOT[ParachainId3.PENDULUM]
  ]
};
var ADDITIONAL_BASES = {
  [ParachainId3.MOONRIVER]: {
    "0x3b25BC1dC591D24d60560d0135D6750A561D4764": [
      new Token({
        chainId: ParachainId3.MOONRIVER,
        address: "0x639A647fbe20b6c8ac19E48E2de44ea792c62c5C",
        decimals: 18,
        symbol: "ETH",
        name: "BAI Ethereum"
      })
    ],
    "0x639A647fbe20b6c8ac19E48E2de44ea792c62c5C": [
      new Token({
        chainId: ParachainId3.MOONRIVER,
        address: "0x3b25BC1dC591D24d60560d0135D6750A561D4764",
        decimals: 18,
        symbol: "vETH",
        name: "Voucher Ethereum"
      })
    ]
  }
};
var CUSTOM_BASES = {};
function getCurrencyCombinations(chainId, currencyA, currencyB) {
  var _a, _b, _c, _d;
  const [tokenA, tokenB] = chainId ? [currencyA == null ? void 0 : currencyA.wrapped, currencyB == null ? void 0 : currencyB.wrapped] : [void 0, void 0];
  const common = chainId in BASES_TO_CHECK_TRADES_AGAINST ? BASES_TO_CHECK_TRADES_AGAINST[chainId] : [];
  const additionalA = tokenA ? (_b = (_a = ADDITIONAL_BASES[chainId]) == null ? void 0 : _a[tokenA.address]) != null ? _b : [] : [];
  const additionalB = tokenB ? (_d = (_c = ADDITIONAL_BASES[chainId]) == null ? void 0 : _c[tokenB.address]) != null ? _d : [] : [];
  const bases = [...common, ...additionalA, ...additionalB];
  const basePairs = flatMap(bases, (base) => bases.map((otherBase) => [base, otherBase]));
  if (!tokenA || !tokenB)
    return [];
  const cacheMap = {};
  return [
    // the direct pair
    [tokenA, tokenB],
    // token A against all bases
    ...bases.map((base) => [tokenA, base]),
    // token B against all bases
    ...bases.map((base) => [tokenB, base]),
    // each base against all bases
    ...basePairs
  ].filter((tokens) => Boolean(tokens[0] && tokens[1])).filter(([t0, t1]) => t0.address !== t1.address && t0.chainId === t1.chainId).filter(([tokenA2, tokenB2]) => {
    const cacheKey = tokenA2.sortsBefore(tokenB2) ? `${tokenA2.address}${tokenB2.address}` : `${tokenB2.address}${tokenA2.address}`;
    if (cacheMap[cacheKey])
      return false;
    return cacheMap[cacheKey] = true;
  }).filter(([tokenA2, tokenB2]) => {
    if (!chainId)
      return true;
    const customBases = CUSTOM_BASES[chainId];
    const customBasesA = customBases == null ? void 0 : customBases[tokenA2.address];
    const customBasesB = customBases == null ? void 0 : customBases[tokenB2.address];
    if (!customBasesA && !customBasesB)
      return true;
    if (customBasesA && !customBasesA.find((base) => tokenB2.equals(base)))
      return false;
    if (customBasesB && !customBasesB.find((base) => tokenA2.equals(base)))
      return false;
    return true;
  });
}

// src/Native.ts
import CHAIN from "@crypto-dex-sdk/chain";
import invariant5 from "tiny-invariant";
var _Native = class _Native extends Currency {
  constructor(native) {
    super(native);
    this.isNative = true;
    this.isToken = false;
    this.symbol = native.symbol;
    this.name = native.name;
  }
  get wrapped() {
    const wnative = WNATIVE[this.chainId];
    invariant5(!!wnative, "WRAPPED");
    return wnative;
  }
  static onChain(chainId) {
    if (chainId in this.cache)
      return this.cache[chainId];
    invariant5(!!(chainId in CHAIN), "CHAINS");
    const { nativeCurrency } = CHAIN[chainId];
    invariant5(!!nativeCurrency, "NATIVE_CURRENCY");
    const { decimals, name, symbol } = nativeCurrency;
    return this.cache[chainId] = new _Native({ chainId, decimals, name, symbol });
  }
  equals(other) {
    return other.isNative && other.chainId === this.chainId;
  }
};
_Native.cache = {};
var Native = _Native;

// src/Price.ts
import { Fraction as Fraction3, JSBI as JSBI3 } from "@crypto-dex-sdk/math";
import invariant6 from "tiny-invariant";
var Price = class _Price extends Fraction3 {
  // used to adjust the raw fraction w/r/t the decimals of the {base,quote}Token
  /**
   * Construct a price, either with the base and quote currency amount, or the
   * @param args
   */
  constructor(...args) {
    let baseCurrency, quoteCurrency, denominator, numerator;
    if (args.length === 4) {
      [baseCurrency, quoteCurrency, denominator, numerator] = args;
    } else {
      const result = args[0].quoteAmount.divide(args[0].baseAmount);
      [baseCurrency, quoteCurrency, denominator, numerator] = [
        args[0].baseAmount.currency,
        args[0].quoteAmount.currency,
        result.denominator,
        result.numerator
      ];
    }
    super(numerator, denominator);
    this.baseCurrency = baseCurrency;
    this.quoteCurrency = quoteCurrency;
    this.scalar = new Fraction3(
      JSBI3.exponentiate(JSBI3.BigInt(10), JSBI3.BigInt(baseCurrency.decimals)),
      JSBI3.exponentiate(JSBI3.BigInt(10), JSBI3.BigInt(quoteCurrency.decimals))
    );
  }
  /**
   * Flip the price, switching the base and quote currency
   */
  invert() {
    return new _Price(this.quoteCurrency, this.baseCurrency, this.numerator, this.denominator);
  }
  /**
   * Multiply the price by another price, returning a new price. The other price must have the same base currency as this price's quote currency
   * @param other the other price
   */
  multiply(other) {
    invariant6(this.quoteCurrency.equals(other.baseCurrency), "TOKEN");
    const fraction = super.multiply(other);
    return new _Price(this.baseCurrency, other.quoteCurrency, fraction.denominator, fraction.numerator);
  }
  /**
   * Return the amount of quote currency corresponding to a given amount of the base currency
   * @param currencyAmount the amount of base currency to quote against the price
   */
  quote(currencyAmount) {
    invariant6(currencyAmount.currency.equals(this.baseCurrency), "TOKEN");
    const result = super.multiply(currencyAmount);
    return Amount.fromFractionalAmount(this.quoteCurrency, result.numerator, result.denominator);
  }
  /**
   * Get the value scaled by decimals for formatting
   * @private
   */
  get adjustedForDecimals() {
    return super.multiply(this.scalar);
  }
  toSignificant(significantDigits = 6, format, rounding) {
    return this.adjustedForDecimals.toSignificant(significantDigits, format, rounding);
  }
  toFixed(decimalPlaces = 4, format, rounding) {
    return this.adjustedForDecimals.toFixed(decimalPlaces, format, rounding);
  }
};

// src/tryParseAmount.ts
import { JSBI as JSBI4 } from "@crypto-dex-sdk/math";
import { parseUnits } from "@ethersproject/units";
function tryParseAmount(value, currency) {
  if (!value || !currency)
    return void 0;
  try {
    const typedValueParsed = parseUnits(value, currency.decimals).toString();
    if (typedValueParsed !== "0")
      return Amount.fromRawAmount(currency, JSBI4.BigInt(typedValueParsed));
  } catch (error) {
    console.debug(`Failed to parse input amount: "${value}"`, error);
  }
  return void 0;
}

// src/useCurrencyCombinations.ts
function useCurrencyCombinations(chainId, currencyA, currencyB) {
  return chainId && currencyA && currencyB ? getCurrencyCombinations(chainId, currencyA, currencyB) : [];
}

// src/useNativeCurrency.ts
import { ParachainId as ParachainId4 } from "@crypto-dex-sdk/chain";
function useNativeCurrency({ chainId = ParachainId4.ASTAR }) {
  return Native.onChain(chainId);
}
export {
  ADDITIONAL_BASES,
  ARB,
  ARB_ADDRESS,
  Amount,
  BASES_TO_CHECK_TRADES_AGAINST,
  CUSTOM_BASES,
  DAI,
  DAI_ADDRESS,
  DOT,
  DOT_ADDRESS,
  FRAX,
  FRAX_ADDRESS,
  KSM,
  KSM_ADDRESS,
  LINK,
  LINK_ADDRESS,
  Native,
  Price,
  Share,
  Token,
  UNI,
  UNI_ADDRESS,
  USDC,
  USDC_ADDRESS,
  USDT,
  USDT_ADDRESS,
  WBTC,
  WBTC_ADDRESS,
  WETH9,
  WETH9_ADDRESS,
  WNATIVE,
  WNATIVE_ADDRESS,
  XCAUSD,
  XCAUSD_ADDRESS,
  ZLK,
  ZLK_ADDRESS,
  axlDAI_ADDRESS,
  axlUSDC_ADDRESS,
  getCurrencyCombinations,
  tryParseAmount,
  useCurrencyCombinations,
  useNativeCurrency
};