@swapkit/helpers 1.0.0-rc.0

package/dist/index.es.js

@@ -0,0 +1,651 @@
+var rt = Object.defineProperty;
+var st = (n, t, e) => t in n ? rt(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var _ = (n, t, e) => (st(n, typeof t != "symbol" ? t + "" : t, e), e), it = (n, t, e) => {
+  if (!t.has(n))
+    throw TypeError("Cannot " + e);
+};
+var p = (n, t, e) => {
+  if (t.has(n))
+    throw TypeError("Cannot add the same private member more than once");
+  t instanceof WeakSet ? t.add(n) : t.set(n, e);
+};
+var d = (n, t, e) => (it(n, t, "access private method"), e);
+import { FeeOption as x, BaseDecimal as h, Chain as i, ChainToRPC as at, MemoType as f } from "@swapkit/types";
+const vt = (n) => {
+  if (n < 0)
+    throw new Error("Invalid number of year");
+  return 10 + n;
+}, St = (n) => {
+  if (n.length > 30)
+    return !1;
+  const t = /^[a-zA-Z0-9+_-]+$/g;
+  return !!n.match(t);
+}, Ct = ([n, t, e, r, s]) => `${n}'/${t}'/${e}'/${r}${typeof s != "number" ? "" : `/${s}`}`, Tt = async (n, t) => {
+  const e = Object.entries(t || {}).reduce(
+    (s, [a, c]) => (c && (s[a] = c), s),
+    {}
+  );
+  return (await fetch(
+    `${n}${t ? `?${new URLSearchParams(e).toString()}` : ""}`,
+    { method: "GET", mode: "cors", credentials: "omit", referrer: "https://sk.thorswap.net" }
+  )).json();
+}, ct = async (n, t, e, r = !1) => {
+  const s = await fetch(`${n}`, {
+    body: t,
+    headers: e,
+    method: "POST",
+    referrer: "https://sk.thorswap.net"
+  });
+  return r ? s.text() : s.json();
+}, ot = "0x313ce567", z = async ({ chain: n, to: t }) => {
+  try {
+    const e = await ct(
+      at[n],
+      JSON.stringify({
+        method: "eth_call",
+        params: [{ to: t.toLowerCase(), data: ot }, "latest"],
+        id: 44,
+        jsonrpc: "2.0"
+      }),
+      { accept: "*/*", "cache-control": "no-cache", "content-type": "application/json" },
+      !0
+    ), { result: r } = JSON.parse(e);
+    return parseInt(BigInt(r).toString());
+  } catch (e) {
+    return console.error(e), h[n];
+  }
+}, ut = async (n) => {
+  if (n === i.Ethereum)
+    return h.ETH;
+  const [, t] = n.split("-");
+  return t != null && t.startsWith("0x") ? z({ chain: i.Ethereum, to: t }) : h.ETH;
+}, lt = async (n) => {
+  const [, t] = n.split("-");
+  return t != null && t.startsWith("0x") ? z({ chain: i.Avalanche, to: t.toLowerCase() }) : h.AVAX;
+}, dt = async (n) => n === i.BinanceSmartChain ? h.BSC : h.BSC, X = async ({ chain: n, symbol: t }) => {
+  switch (n) {
+    case i.Ethereum:
+      return ut(t);
+    case i.Avalanche:
+      return lt(t);
+    case i.BinanceSmartChain:
+      return dt(t);
+    default:
+      return h[n];
+  }
+}, yt = {
+  [x.Average]: 1.2,
+  [x.Fast]: 1.5,
+  [x.Fastest]: 2
+}, mt = ({ chain: n, symbol: t }) => {
+  switch (n) {
+    case i.Bitcoin:
+    case i.BitcoinCash:
+    case i.Litecoin:
+    case i.Dogecoin:
+    case i.Binance:
+    case i.Ethereum:
+    case i.Avalanche:
+      return t === n;
+    case i.Arbitrum:
+    case i.Optimism:
+      return t === "ETH";
+    case i.Maya:
+      return t === "CACAO";
+    case i.Cosmos:
+      return t === "ATOM";
+    case i.Polygon:
+      return t === "MATIC";
+    case i.BinanceSmartChain:
+      return t === "BNB";
+    case i.THORChain:
+      return t === "RUNE";
+  }
+}, ht = (n) => {
+  switch (n) {
+    case "ETH.THOR":
+      return { identifier: "ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044", decimal: 18 };
+    case "ETH.vTHOR":
+      return { identifier: "ETH.vTHOR-0x815c23eca83261b6ec689b60cc4a58b54bc24d8d", decimal: 18 };
+    case i.Cosmos:
+      return { identifier: "GAIA.ATOM", decimal: h[n] };
+    case i.THORChain:
+      return { identifier: "THOR.RUNE", decimal: h[n] };
+    case i.BinanceSmartChain:
+      return { identifier: "BSC.BNB", decimal: h[n] };
+    case i.Maya:
+      return { identifier: "MAYA.CACAO", decimal: h.MAYA };
+    case "MAYA.MAYA":
+      return { identifier: "MAYA.MAYA", decimal: 4 };
+    case i.Arbitrum:
+    case i.Optimism:
+    case i.BitcoinCash:
+    case i.Litecoin:
+    case i.Dogecoin:
+    case i.Binance:
+    case i.Avalanche:
+    case i.Polygon:
+    case i.Bitcoin:
+    case i.Ethereum:
+      return { identifier: `${n}.${n}`, decimal: h[n] };
+  }
+}, _t = ({ chain: n, symbol: t }) => {
+  if (t.includes("/"))
+    return "Synth";
+  switch (n) {
+    case i.Bitcoin:
+    case i.BitcoinCash:
+    case i.Dogecoin:
+    case i.Litecoin:
+    case i.Maya:
+    case i.THORChain:
+      return "Native";
+    case i.Cosmos:
+      return t === "ATOM" ? "Native" : "GAIA";
+    case i.Binance:
+      return t === i.Binance ? "Native" : "BEP2";
+    case i.BinanceSmartChain:
+      return t === i.Binance ? "Native" : "BEP20";
+    case i.Ethereum:
+      return t === i.Ethereum ? "Native" : "ERC20";
+    case i.Avalanche:
+      return t === i.Avalanche ? "Native" : "AVAX";
+    case i.Polygon:
+      return t === i.Polygon ? "Native" : "POLYGON";
+    case i.Arbitrum:
+      return [i.Ethereum, i.Arbitrum].includes(t) ? "Native" : "ARBITRUM";
+    case i.Optimism:
+      return [i.Ethereum, i.Optimism].includes(t) ? "Native" : "OPTIMISM";
+  }
+}, Bt = (n) => {
+  var c;
+  const [t, ...e] = n.split("."), r = n.includes("/"), s = e.join("."), a = (c = s == null ? void 0 : s.split("-")) == null ? void 0 : c[0];
+  return { chain: t, symbol: s, ticker: a, synth: r };
+}, gt = ({
+  liquidityUnits: n,
+  poolUnits: t,
+  runeDepth: e
+}) => {
+  const r = m(n), s = m(t), a = m(e), c = r.mul(a), o = s.mul(s).mul(2), l = s.mul(r).mul(2), u = r.mul(r), g = s.mul(s).mul(s);
+  return c.mul(o.sub(l).add(u)).div(g);
+}, pt = ({
+  liquidityUnits: n,
+  poolUnits: t,
+  assetDepth: e
+}) => {
+  const r = m(n), s = m(t), a = m(e), c = r.mul(a), o = s.mul(s).mul(2), l = s.mul(r).mul(2), u = r.mul(r), g = c.mul(o.sub(l).add(u)), $ = s.mul(s).mul(s);
+  return g.div($);
+}, Mt = ({
+  percent: n,
+  runeDepth: t,
+  liquidityUnits: e,
+  poolUnits: r
+}) => gt({ runeDepth: t, liquidityUnits: e, poolUnits: r }).mul(n), Et = ({
+  percent: n,
+  assetDepth: t,
+  liquidityUnits: e,
+  poolUnits: r
+}) => pt({ assetDepth: t, liquidityUnits: e, poolUnits: r }).mul(n), m = (n) => new wt({ value: n, decimal: h.THOR }), Vt = ({
+  liquidityUnits: n,
+  poolUnits: t,
+  runeDepth: e,
+  assetDepth: r,
+  percent: s
+}) => ({
+  assetAmount: m(r).mul(n).div(t).mul(s),
+  runeAmount: m(e).mul(n).div(t).mul(s)
+}), Ot = ({
+  runeDepth: n,
+  poolUnits: t,
+  assetDepth: e,
+  liquidityUnits: r,
+  runeAmount: s,
+  assetAmount: a
+}) => {
+  const c = m(n), o = m(e), l = m(t), u = m(s), g = m(a), $ = u.mul(o), S = g.mul(c), D = u.mul(g), K = c.mul(o), tt = l.mul($.add(S.add(D.mul(2)))), et = $.add(S.add(K.mul(2))), G = tt.div(et), H = m(r).add(G);
+  if (G.baseValueNumber === 0)
+    return H.div(l).baseValueNumber;
+  const nt = l.add(H);
+  return H.div(nt).baseValueNumber;
+}, Nt = ({
+  runeAmount: n,
+  assetAmount: t,
+  runeDepth: e,
+  assetDepth: r
+}) => {
+  const s = m(e), a = m(r), c = m(t), o = m(n), l = c.mul(s).sub(a.mul(o)), u = a.mul(o).add(s.mul(a));
+  return Math.abs(l.div(u).baseValueNumber);
+}, ft = ({
+  symbol: n,
+  ticker: t,
+  chain: e
+}) => e === "ETH" && t !== "ETH" ? `${t}-${n.slice(-3)}` : n, Rt = (n, t) => {
+  switch (n) {
+    case f.LEAVE:
+    case f.BOND: {
+      const { address: e } = t;
+      return `${n}:${e}`;
+    }
+    case f.UNBOND: {
+      const { address: e, unbondAmount: r } = t;
+      return `${n}:${e}:${r * 10 ** 8}`;
+    }
+    case f.THORNAME_REGISTER: {
+      const { name: e, chain: r, address: s, owner: a } = t;
+      return `${n}:${e}:${r}:${s}${a ? `:${a}` : ""}`;
+    }
+    case f.DEPOSIT: {
+      const { chain: e, symbol: r, address: s, singleSide: a } = t;
+      return a ? `${n}:${e}/${r}::t:0` : `${n}:${e}.${r}:${s || ""}:t:0`;
+    }
+    case f.WITHDRAW: {
+      const { chain: e, ticker: r, symbol: s, basisPoints: a, targetAssetString: c, singleSide: o } = t, l = !o && c ? `:${c}` : "", u = ft({ chain: e, symbol: s, ticker: r });
+      return `${n}:${e}${o ? "/" : "."}${u}:${a}${l}`;
+    }
+    case f.OPEN_LOAN:
+    case f.CLOSE_LOAN: {
+      const { asset: e, address: r } = t;
+      return `${n}:${e}:${r}`;
+    }
+    default:
+      return "";
+  }
+}, B = 8, U = ({
+  value: n,
+  bigIntDecimal: t = B,
+  decimal: e = B
+}) => {
+  const r = n < 0n;
+  let s = n.toString().substring(r ? 1 : 0);
+  const a = e - (s.length - 1);
+  a > 0 && (s = "0".repeat(a) + s);
+  const c = s.length - e;
+  let o = s.slice(-e);
+  return parseInt(o[t]) >= 5 ? o = `${o.substring(0, t - 1)}${(parseInt(o[t - 1]) + 1).toString()}` : o = o.substring(0, t), `${r ? "-" : ""}${s.slice(0, c)}.${o}`.replace(
+    /\.?0*$/,
+    ""
+  );
+}, W = Object.values(i), At = (n = "") => {
+  const t = n.toUpperCase(), [e] = t.split(".");
+  if (W.includes(e))
+    return !0;
+  const [r] = t.split("/");
+  if (W.includes(r))
+    return !0;
+  throw new Error(
+    `Invalid identifier: ${n}. Expected format: <Chain>.<Ticker> or <Chain>.<Ticker>-<ContractAddress>`
+  );
+}, I = (n) => 10n ** BigInt(n), C = (n) => Math.log10(parseFloat(n.toString()));
+var w, T, R, J, k, Q, V, P, b, y, O, q, v, N;
+const M = class M {
+  constructor(t) {
+    p(this, w);
+    p(this, R);
+    p(this, k);
+    p(this, V);
+    p(this, b);
+    p(this, O);
+    p(this, v);
+    _(this, "decimalMultiplier", 10n ** 8n);
+    _(this, "bigIntValue", 0n);
+    _(this, "decimal");
+    const e = typeof t == "object", r = e ? t.value : t;
+    this.decimal = e ? t.decimal : void 0, this.decimalMultiplier = I(
+      Math.max(d(this, O, q).call(this, d(this, b, y).call(this, r)), this.decimal || 0)
+    ), d(this, R, J).call(this, r);
+  }
+  static fromBigInt(t, e) {
+    return new M({
+      decimal: e,
+      value: U({ value: t, bigIntDecimal: e, decimal: e })
+    });
+  }
+  static shiftDecimals({
+    value: t,
+    from: e,
+    to: r
+  }) {
+    return M.fromBigInt(
+      new M(t).bigIntValue * I(r) / I(e),
+      r
+    );
+  }
+  get unsafeNumber() {
+    return parseFloat((this.bigIntValue / this.decimalMultiplier).toString());
+  }
+  get baseValue() {
+    return d(this, v, N).call(this, "string");
+  }
+  get baseValueNumber() {
+    return d(this, v, N).call(this, "number");
+  }
+  get baseValueBigInt() {
+    return d(this, v, N).call(this, "number");
+  }
+  get value() {
+    return this.formatBigIntToSafeValue(
+      this.bigIntValue,
+      this.decimal || C(this.decimalMultiplier)
+    );
+  }
+  add(...t) {
+    return d(this, w, T).call(this, "add", ...t);
+  }
+  sub(...t) {
+    return d(this, w, T).call(this, "sub", ...t);
+  }
+  mul(...t) {
+    return d(this, w, T).call(this, "mul", ...t);
+  }
+  div(...t) {
+    return d(this, w, T).call(this, "div", ...t);
+  }
+  gt(t) {
+    return this.bigIntValue > this.getBigIntValue(t);
+  }
+  gte(t) {
+    return this.bigIntValue >= this.getBigIntValue(t);
+  }
+  lt(t) {
+    return this.bigIntValue < this.getBigIntValue(t);
+  }
+  lte(t) {
+    return this.bigIntValue <= this.getBigIntValue(t);
+  }
+  eqValue(t) {
+    return this.bigIntValue === this.getBigIntValue(t);
+  }
+  getBigIntValue(t, e) {
+    return !e && typeof t == "object" ? t.bigIntValue : (t = typeof t == "object" ? t.value : t, d(this, V, P).call(this, d(this, b, y).call(this, t), e));
+  }
+  formatBigIntToSafeValue(t, e) {
+    const r = e || this.decimal || B, s = Math.max(
+      r,
+      C(this.decimalMultiplier)
+    ), a = t < 0n;
+    let c = t.toString().substring(a ? 1 : 0);
+    const o = s - (c.length - 1);
+    o > 0 && (c = "0".repeat(o) + c);
+    const l = c.length - s;
+    let u = c.slice(-s);
+    return parseInt(u[r]) >= 5 ? u = `${u.substring(0, r - 1)}${(parseInt(u[r - 1]) + 1).toString()}` : u = u.substring(0, r), `${a ? "-" : ""}${c.slice(0, l)}.${u}`.replace(
+      /\.?0*$/,
+      ""
+    );
+  }
+  toSignificant(t) {
+    const e = this.value.split("."), r = e[0], s = e[1];
+    return s ? `${r}.${s.slice(0, t || this.decimal)}`.replace(
+      /\.?0*$/,
+      ""
+    ) : r;
+  }
+};
+w = new WeakSet(), T = function(t, ...e) {
+  const r = d(this, k, Q).call(this, this, ...e), s = I(r), a = e.reduce(
+    (o, l) => {
+      const u = this.getBigIntValue(l, r);
+      if (t === "div" && u === 0n)
+        throw new RangeError("Division by zero");
+      return t === "add" ? o + u : t === "sub" ? o - u : t === "mul" ? o * u / s : o * s / u;
+    },
+    //normalize is to precision multiplier base
+    this.bigIntValue * s / this.decimalMultiplier
+  ), c = U({
+    bigIntDecimal: r,
+    decimal: Math.max(r, C(this.decimalMultiplier)),
+    value: a
+  });
+  return new this.constructor({ decimal: this.decimal, value: c, identifier: this.toString() });
+}, R = new WeakSet(), J = function(t, e) {
+  const r = d(this, b, y).call(this, t) || "0";
+  this.bigIntValue = e || d(this, V, P).call(this, r);
+}, k = new WeakSet(), Q = function(...t) {
+  const e = t.map(
+    (r) => typeof r == "object" ? r.decimal || C(r.decimalMultiplier) : d(this, O, q).call(this, d(this, b, y).call(this, r))
+  ).filter(Boolean);
+  return Math.max(...e, B);
+}, V = new WeakSet(), P = function(t, e) {
+  const r = e ? I(e) : this.decimalMultiplier, s = C(r), [a, c = ""] = t.split(".");
+  return BigInt(`${a}${c.padEnd(s, "0")}`);
+}, b = new WeakSet(), y = function(t) {
+  const r = `${typeof t == "number" ? Number(t).toLocaleString("fullwide", {
+    useGrouping: !1,
+    maximumFractionDigits: 20
+  }) : t}`.replaceAll(",", ".").split(".");
+  return r.length > 1 ? `${r.slice(0, -1).join("")}.${r.at(-1)}` : r[0];
+}, O = new WeakSet(), q = function(t) {
+  var r;
+  const e = ((r = t.split(".")[1]) == null ? void 0 : r.length) || 0;
+  return Math.max(e, B);
+}, v = new WeakSet(), N = function(t) {
+  const e = this.decimalMultiplier / I(this.decimal || 0), r = this.bigIntValue / e;
+  switch (t) {
+    case "number":
+      return Number(r);
+    case "string":
+      return r.toString();
+    default:
+      return r;
+  }
+};
+let E = M, j;
+const L = (n) => {
+  if (!j)
+    throw new Error("Static assets not loaded, call await AssetValue.loadStaticAssets() first");
+  return j.get(n.toUpperCase()) || { decimal: h.THOR, identifier: "" };
+}, Y = async (n, t = 0) => {
+  At(n);
+  const e = await X(F(n));
+  return new A({ decimal: e, value: t, identifier: n });
+};
+class A extends E {
+  constructor(e) {
+    super(
+      e.value instanceof E ? e.value : { decimal: e.decimal, value: e.value }
+    );
+    _(this, "address");
+    _(this, "chain");
+    _(this, "isSynthetic", !1);
+    _(this, "isGasAsset", !1);
+    _(this, "symbol");
+    _(this, "ticker");
+    _(this, "type");
+    const r = "identifier" in e ? e.identifier : `${e.chain}.${e.symbol}`, s = F(r);
+    this.type = _t(s), this.chain = s.chain, this.ticker = s.ticker, this.symbol = s.symbol, this.address = s.address, this.isSynthetic = s.isSynthetic, this.isGasAsset = s.isGasAsset;
+  }
+  static async fromString(e, r = 0) {
+    return Y(e, r);
+  }
+  static fromStringSync(e, r = 0) {
+    const { decimal: s, identifier: a } = L(
+      e
+    );
+    return a ? new A({ decimal: s, identifier: a, value: r }) : void 0;
+  }
+  static async fromIdentifier(e, r = 0) {
+    return Y(e, r);
+  }
+  static fromIdentifierSync(e, r = 0) {
+    const { decimal: s, identifier: a } = L(e);
+    return new A({ decimal: s, identifier: a, value: r });
+  }
+  static fromChainOrSignature(e, r = 0) {
+    const { decimal: s, identifier: a } = ht(e);
+    return new A({ value: r, decimal: s, identifier: a });
+  }
+  static async fromTCQuote(e, r = 0) {
+    const s = await X(F(e)), a = this.shiftDecimals({ value: r, from: h.THOR, to: s });
+    return new A({ value: a, identifier: e, decimal: s });
+  }
+  static fromTCQuoteStatic(e, r = 0) {
+    const s = L(e), a = this.shiftDecimals({
+      value: r,
+      from: h.THOR,
+      to: s.decimal
+    });
+    return new A({ ...s, value: a });
+  }
+  static async loadStaticAssets() {
+    return new Promise(
+      async (e, r) => {
+        try {
+          const {
+            // Omit ThorchainList from import to avoid decimals conflict (TC uses 8 for all)
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            ThorchainList: s,
+            NativeList: a,
+            ...c
+          } = await import("./index.es-8503fb04.js");
+          j = [a, ...Object.values(c)].reduce(
+            (l, { tokens: u }) => (u.forEach(({ identifier: g, chain: $, ...S }) => {
+              const D = "decimals" in S ? S.decimals : h[$];
+              l.set(g, { identifier: g, decimal: D });
+            }), l),
+            /* @__PURE__ */ new Map()
+          ), e({ ok: !0 });
+        } catch (s) {
+          console.error(s), r({
+            ok: !1,
+            error: s,
+            message: "Couldn't load static assets. Ensure you have installed @swapkit/tokens package"
+          });
+        }
+      }
+    );
+  }
+  get assetValue() {
+    return `${this.value} ${this.ticker}`;
+  }
+  toString() {
+    return `${this.chain}.${this.symbol}`;
+  }
+  eq({ chain: e, symbol: r }) {
+    return this.chain === e && this.symbol === r;
+  }
+}
+const kt = (n) => {
+  const t = A.fromChainOrSignature(n);
+  switch (n) {
+    case i.Bitcoin:
+    case i.Litecoin:
+    case i.BitcoinCash:
+      return t.add(10001);
+    case i.Dogecoin:
+      return t.add(100000001);
+    case i.Avalanche:
+    case i.Ethereum:
+      return t.add(10 * 10 ** 9);
+    case i.THORChain:
+    case i.Maya:
+      return t.add(0);
+    default:
+      return t.add(1);
+  }
+}, F = (n) => {
+  const t = n.slice(0, 14).includes("/"), e = n.includes(".") ? n : `${i.THORChain}.${n}`, [r, s] = e.split("."), [a, c] = s.split("-");
+  return {
+    address: c == null ? void 0 : c.toLowerCase(),
+    chain: r,
+    isGasAsset: mt({ chain: r, symbol: s }),
+    isSynthetic: t,
+    symbol: c ? `${a}-${(c == null ? void 0 : c.toLowerCase()) ?? ""}` : s,
+    ticker: t ? s : a
+  };
+}, $t = {
+  /**
+   * Core
+   */
+  core_wallet_connection_not_found: 10001,
+  core_estimated_max_spendable_chain_not_supported: 10002,
+  core_extend_error: 10003,
+  core_inbound_data_not_found: 10004,
+  core_approve_asset_address_or_from_not_found: 10005,
+  core_chain_halted: 10099,
+  /**
+   * Core - Wallet Connection
+   */
+  core_wallet_xdefi_not_installed: 10101,
+  core_wallet_evmwallet_not_installed: 10102,
+  core_wallet_walletconnect_not_installed: 10103,
+  core_wallet_keystore_not_installed: 10104,
+  core_wallet_ledger_not_installed: 10105,
+  core_wallet_trezor_not_installed: 10106,
+  core_wallet_keplr_not_installed: 10107,
+  core_wallet_okx_not_installed: 10108,
+  /**
+   * Core - Swap
+   */
+  core_swap_invalid_params: 10200,
+  core_swap_route_not_complete: 10201,
+  core_swap_asset_not_recognized: 10202,
+  core_swap_contract_not_found: 10203,
+  core_swap_route_transaction_not_found: 10204,
+  core_swap_contract_not_supported: 10205,
+  core_swap_transaction_error: 10206,
+  core_swap_quote_mode_not_supported: 10207,
+  /**
+   * Core - Transaction
+   */
+  core_transaction_deposit_error: 10301,
+  core_transaction_create_liquidity_rune_error: 10302,
+  core_transaction_create_liquidity_asset_error: 10303,
+  core_transaction_create_liquidity_invalid_params: 10304,
+  core_transaction_add_liquidity_invalid_params: 10305,
+  core_transaction_add_liquidity_no_rune_address: 10306,
+  core_transaction_add_liquidity_rune_error: 10307,
+  core_transaction_add_liquidity_asset_error: 10308,
+  core_transaction_withdraw_error: 10309,
+  core_transaction_deposit_to_pool_error: 10310,
+  core_transaction_deposit_insufficient_funds_error: 10311,
+  core_transaction_deposit_gas_error: 10312,
+  core_transaction_deposit_server_error: 10313,
+  /**
+   * Wallets
+   */
+  wallet_ledger_connection_error: 20001,
+  /**
+   * Helpers
+   */
+  helpers_number_different_decimals: 99101
+};
+class Z extends Error {
+  constructor(t, e) {
+    console.error(e), super(t, { cause: { code: $t[t], message: t } }), Object.setPrototypeOf(this, Z.prototype);
+  }
+}
+class wt extends E {
+  eq(t) {
+    return this.eqValue(t);
+  }
+  toString() {
+    return this.value;
+  }
+}
+export {
+  A as AssetValue,
+  B as DEFAULT_DECIMAL,
+  Z as SwapKitError,
+  wt as SwapKitNumber,
+  Bt as assetFromString,
+  Ct as derivationPathToString,
+  U as formatBigIntToSafeValue,
+  yt as gasFeeMultiplier,
+  _t as getAssetType,
+  pt as getAsymmetricAssetShare,
+  Et as getAsymmetricAssetWithdrawAmount,
+  gt as getAsymmetricRuneShare,
+  Mt as getAsymmetricRuneWithdrawAmount,
+  ht as getCommonAssetInfo,
+  X as getDecimal,
+  Ot as getEstimatedPoolShare,
+  Nt as getLiquiditySlippage,
+  Rt as getMemoFor,
+  kt as getMinAmountByChain,
+  Tt as getRequest,
+  Vt as getSymmetricWithdraw,
+  vt as getTHORNameCost,
+  mt as isGasAsset,
+  ct as postRequest,
+  St as validateTHORName
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "author": "swapkit-oss-team",
+  "description": "SwapKit Lib swapkit-helpers",
+  "devDependencies": {
+    "@vitest/coverage-istanbul": "0.34.4",
+    "vite": "4.4.9",
+    "vitest": "0.34.4",
+    "@internal/config": "0.0.0-internal.0",
+    "@swapkit/tokens": "1.0.0-rc.0",
+    "@swapkit/types": "1.0.0-rc.0"
+  },
+  "eslintConfig": {
+    "extends": "../../../internal/eslint-config"
+  },
+  "peerDependencies": {
+    "@swapkit/types": "1.0.0-rc.0"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.es.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "src/",
+    "dist/"
+  ],
+  "homepage": "https://github.com/thorswap/SwapKit",
+  "license": "Apache-2.0",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.es.js",
+  "name": "@swapkit/helpers",
+  "publishConfig": {
+    "access": "public"
+  },
+  "react-native": "./src/index.ts",
+  "repository": "https://github.com/thorswap/SwapKit.git",
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "version": "1.0.0-rc.0",
+  "scripts": {
+    "build": "vite build",
+    "clean": "rm -rf dist vite.config.ts.* .turbo node_modules",
+    "lint": "eslint ./ --ext .ts,.tsx --fix; tsc --noEmit",
+    "test": "vitest --run",
+    "test:coverage": "vitest run --coverage"
+  }
+}