astra-modal-test 1.0.5 → 1.0.6

package/dist/astra-sdk.es390.js

@@ -0,0 +1,9 @@
+function f(e, { dir: n = "left" } = {}) {
+  let t = typeof e == "string" ? e.replace("0x", "") : e, i = 0;
+  for (let l = 0; l < t.length - 1 && t[n === "left" ? l : t.length - l - 1].toString() === "0"; l++)
+    i++;
+  return t = n === "left" ? t.slice(i) : t.slice(0, t.length - i), typeof e == "string" ? (t.length === 1 && n === "right" && (t = `${t}0`), `0x${t.length % 2 === 1 ? `0${t}` : t}`) : t;
+}
+export {
+  f as trim
+};

package/dist/astra-sdk.es391.js

@@ -0,0 +1,11 @@
+import { numberToHex as c } from "./astra-sdk.es416.js";
+async function i(t, { address: n, blockNumber: e, blockTag: a = "latest" }) {
+  const o = e ? c(e) : void 0, r = await t.request({
+    method: "eth_getBalance",
+    params: [n, o || a]
+  });
+  return BigInt(r);
+}
+export {
+  i as getBalance
+};

package/dist/astra-sdk.es392.js

@@ -0,0 +1,11 @@
+function i(e, n = {}) {
+  let t;
+  try {
+    t = e.getClient(n);
+  } catch {
+  }
+  return t;
+}
+export {
+  i as getClient
+};

package/dist/astra-sdk.es393.js

@@ -0,0 +1,6 @@
+function e(r) {
+  return typeof r == "string" ? { address: r, type: "json-rpc" } : r;
+}
+export {
+  e as parseAccount
+};

package/dist/astra-sdk.es394.js

@@ -0,0 +1,34 @@
+import { parseAccount as k } from "./astra-sdk.es393.js";
+import { uid as m } from "./astra-sdk.es598.js";
+function O(n) {
+  const { batch: d, cacheTime: l = n.pollingInterval ?? 4e3, ccipRead: r, key: a = "base", name: f = "Base Client", pollingInterval: c = 4e3, type: b = "base" } = n, e = n.chain, g = n.account ? k(n.account) : void 0, { config: p, request: x, value: h } = n.transport({
+    chain: e,
+    pollingInterval: c
+  }), v = { ...p, ...h }, t = {
+    account: g,
+    batch: d,
+    cacheTime: l,
+    ccipRead: r,
+    chain: e,
+    key: a,
+    name: f,
+    pollingInterval: c,
+    request: x,
+    transport: v,
+    type: b,
+    uid: m()
+  };
+  function o(i) {
+    return (y) => {
+      const s = y(i);
+      for (const j in t)
+        delete s[j];
+      const u = { ...i, ...s };
+      return Object.assign(u, { extend: o(u) });
+    };
+  }
+  return Object.assign(t, { extend: o(t) });
+}
+export {
+  O as createClient
+};

package/dist/astra-sdk.es395.js

@@ -0,0 +1,15 @@
+import { createTransport as s } from "./astra-sdk.es599.js";
+function y(t, r = {}) {
+  const { key: e = "custom", name: o = "Custom Provider", retryDelay: u } = r;
+  return ({ retryCount: n }) => s({
+    key: e,
+    name: o,
+    request: t.request.bind(t),
+    retryCount: r.retryCount ?? n,
+    retryDelay: u,
+    type: "custom"
+  });
+}
+export {
+  y as custom
+};

package/dist/astra-sdk.es396.js

@@ -0,0 +1,58 @@
+import { addressResolverAbi as f, universalResolverResolveAbi as h } from "./astra-sdk.es582.js";
+import { decodeFunctionResult as p } from "./astra-sdk.es587.js";
+import { encodeFunctionData as A } from "./astra-sdk.es589.js";
+import { getChainContractAddress as R } from "./astra-sdk.es590.js";
+import { trim as C } from "./astra-sdk.es390.js";
+import { toHex as w } from "./astra-sdk.es416.js";
+import { isNullUniversalResolverError as x } from "./astra-sdk.es740.js";
+import { namehash as i } from "./astra-sdk.es672.js";
+import { packetToBytes as b } from "./astra-sdk.es741.js";
+import { getAction as B } from "./astra-sdk.es577.js";
+import { readContract as E } from "./astra-sdk.es404.js";
+async function G(o, { blockNumber: d, blockTag: m, coinType: t, name: e, gatewayUrls: l, strict: v, universalResolverAddress: g }) {
+  let n = g;
+  if (!n) {
+    if (!o.chain)
+      throw new Error("client chain not configured. universalResolverAddress is required.");
+    n = R({
+      blockNumber: d,
+      chain: o.chain,
+      contract: "ensUniversalResolver"
+    });
+  }
+  try {
+    const r = A({
+      abi: f,
+      functionName: "addr",
+      ...t != null ? { args: [i(e), BigInt(t)] } : { args: [i(e)] }
+    }), s = {
+      address: n,
+      abi: h,
+      functionName: "resolve",
+      args: [w(b(e)), r],
+      blockNumber: d,
+      blockTag: m
+    }, c = B(o, E, "readContract"), u = l ? await c({
+      ...s,
+      args: [...s.args, l]
+    }) : await c(s);
+    if (u[0] === "0x")
+      return null;
+    const a = p({
+      abi: f,
+      args: t != null ? [i(e), BigInt(t)] : void 0,
+      functionName: "addr",
+      data: u[0]
+    });
+    return a === "0x" || C(a) === "0x00" ? null : a;
+  } catch (r) {
+    if (v)
+      throw r;
+    if (x(r, "resolve"))
+      return null;
+    throw r;
+  }
+}
+export {
+  G as getEnsAddress
+};

package/dist/astra-sdk.es397.js

@@ -0,0 +1,27 @@
+import { parseAvatarRecord as m } from "./astra-sdk.es742.js";
+import { getAction as u } from "./astra-sdk.es577.js";
+import { getEnsText as f } from "./astra-sdk.es607.js";
+async function y(t, { blockNumber: a, blockTag: e, assetGatewayUrls: n, name: o, gatewayUrls: c, strict: i, universalResolverAddress: s }) {
+  const r = await u(t, f, "getEnsText")({
+    blockNumber: a,
+    blockTag: e,
+    key: "avatar",
+    name: o,
+    universalResolverAddress: s,
+    gatewayUrls: c,
+    strict: i
+  });
+  if (!r)
+    return null;
+  try {
+    return await m(t, {
+      record: r,
+      gatewayUrls: n
+    });
+  } catch {
+    return null;
+  }
+}
+export {
+  y as getEnsAvatar
+};

package/dist/astra-sdk.es398.js

@@ -0,0 +1,43 @@
+import { universalResolverReverseAbi as f } from "./astra-sdk.es582.js";
+import { getChainContractAddress as u } from "./astra-sdk.es590.js";
+import { toHex as h } from "./astra-sdk.es416.js";
+import { isNullUniversalResolverError as p } from "./astra-sdk.es740.js";
+import { packetToBytes as C } from "./astra-sdk.es741.js";
+import { getAction as w } from "./astra-sdk.es577.js";
+import { readContract as A } from "./astra-sdk.es404.js";
+async function b(e, { address: t, blockNumber: s, blockTag: i, gatewayUrls: a, strict: c, universalResolverAddress: d }) {
+  let o = d;
+  if (!o) {
+    if (!e.chain)
+      throw new Error("client chain not configured. universalResolverAddress is required.");
+    o = u({
+      blockNumber: s,
+      chain: e.chain,
+      contract: "ensUniversalResolver"
+    });
+  }
+  const v = `${t.toLowerCase().substring(2)}.addr.reverse`;
+  try {
+    const r = {
+      address: o,
+      abi: f,
+      functionName: "reverse",
+      args: [h(C(v))],
+      blockNumber: s,
+      blockTag: i
+    }, n = w(e, A, "readContract"), [l, m] = a ? await n({
+      ...r,
+      args: [...r.args, a]
+    }) : await n(r);
+    return t.toLowerCase() !== m.toLowerCase() ? null : l;
+  } catch (r) {
+    if (c)
+      throw r;
+    if (p(r, "reverse"))
+      return null;
+    throw r;
+  }
+}
+export {
+  b as getEnsName
+};

package/dist/astra-sdk.es399.js

@@ -0,0 +1,106 @@
+import { getEnsAddress as e } from "./astra-sdk.es396.js";
+import { getEnsAvatar as a } from "./astra-sdk.es397.js";
+import { getEnsName as m } from "./astra-sdk.es398.js";
+import { getEnsResolver as s } from "./astra-sdk.es606.js";
+import { getEnsText as i } from "./astra-sdk.es607.js";
+import { call as g } from "./astra-sdk.es412.js";
+import { createBlockFilter as p } from "./astra-sdk.es608.js";
+import { createContractEventFilter as f } from "./astra-sdk.es609.js";
+import { createEventFilter as n } from "./astra-sdk.es610.js";
+import { createPendingTransactionFilter as c } from "./astra-sdk.es611.js";
+import { estimateContractGas as C } from "./astra-sdk.es612.js";
+import { estimateFeesPerGas as F } from "./astra-sdk.es613.js";
+import { estimateGas as T } from "./astra-sdk.es386.js";
+import { estimateMaxPriorityFeePerGas as E } from "./astra-sdk.es614.js";
+import { getBalance as v } from "./astra-sdk.es391.js";
+import { getBlobBaseFee as d } from "./astra-sdk.es615.js";
+import { getBlock as u } from "./astra-sdk.es616.js";
+import { getBlockNumber as B } from "./astra-sdk.es617.js";
+import { getBlockTransactionCount as w } from "./astra-sdk.es618.js";
+import { getChainId as h } from "./astra-sdk.es619.js";
+import { getCode as o } from "./astra-sdk.es620.js";
+import { getContractEvents as P } from "./astra-sdk.es575.js";
+import { getEip712Domain as y } from "./astra-sdk.es579.js";
+import { getFeeHistory as k } from "./astra-sdk.es621.js";
+import { getFilterChanges as G } from "./astra-sdk.es622.js";
+import { getFilterLogs as R } from "./astra-sdk.es623.js";
+import { getGasPrice as b } from "./astra-sdk.es624.js";
+import { getLogs as A } from "./astra-sdk.es578.js";
+import { getProof as M } from "./astra-sdk.es625.js";
+import { getStorageAt as N } from "./astra-sdk.es626.js";
+import { getTransaction as x } from "./astra-sdk.es411.js";
+import { getTransactionConfirmations as D } from "./astra-sdk.es627.js";
+import { getTransactionCount as L } from "./astra-sdk.es628.js";
+import { getTransactionReceipt as S } from "./astra-sdk.es629.js";
+import { multicall as q } from "./astra-sdk.es401.js";
+import { readContract as H } from "./astra-sdk.es404.js";
+import { simulateContract as I } from "./astra-sdk.es630.js";
+import { uninstallFilter as j } from "./astra-sdk.es631.js";
+import { verifyMessage as l } from "./astra-sdk.es632.js";
+import { verifyTypedData as z } from "./astra-sdk.es633.js";
+import { waitForTransactionReceipt as J } from "./astra-sdk.es410.js";
+import { watchBlockNumber as K } from "./astra-sdk.es634.js";
+import { watchBlocks as O } from "./astra-sdk.es635.js";
+import { watchContractEvent as Q } from "./astra-sdk.es636.js";
+import { watchEvent as U } from "./astra-sdk.es637.js";
+import { watchPendingTransactions as V } from "./astra-sdk.es409.js";
+import { verifySiweMessage as W } from "./astra-sdk.es638.js";
+import { prepareTransactionRequest as X } from "./astra-sdk.es402.js";
+import { sendRawTransaction as Y } from "./astra-sdk.es639.js";
+function Ur(t) {
+  return {
+    call: (r) => g(t, r),
+    createBlockFilter: () => p(t),
+    createContractEventFilter: (r) => f(t, r),
+    createEventFilter: (r) => n(t, r),
+    createPendingTransactionFilter: () => c(t),
+    estimateContractGas: (r) => C(t, r),
+    estimateGas: (r) => T(t, r),
+    getBalance: (r) => v(t, r),
+    getBlobBaseFee: () => d(t),
+    getBlock: (r) => u(t, r),
+    getBlockNumber: (r) => B(t, r),
+    getBlockTransactionCount: (r) => w(t, r),
+    getBytecode: (r) => o(t, r),
+    getChainId: () => h(t),
+    getCode: (r) => o(t, r),
+    getContractEvents: (r) => P(t, r),
+    getEip712Domain: (r) => y(t, r),
+    getEnsAddress: (r) => e(t, r),
+    getEnsAvatar: (r) => a(t, r),
+    getEnsName: (r) => m(t, r),
+    getEnsResolver: (r) => s(t, r),
+    getEnsText: (r) => i(t, r),
+    getFeeHistory: (r) => k(t, r),
+    estimateFeesPerGas: (r) => F(t, r),
+    getFilterChanges: (r) => G(t, r),
+    getFilterLogs: (r) => R(t, r),
+    getGasPrice: () => b(t),
+    getLogs: (r) => A(t, r),
+    getProof: (r) => M(t, r),
+    estimateMaxPriorityFeePerGas: (r) => E(t, r),
+    getStorageAt: (r) => N(t, r),
+    getTransaction: (r) => x(t, r),
+    getTransactionConfirmations: (r) => D(t, r),
+    getTransactionCount: (r) => L(t, r),
+    getTransactionReceipt: (r) => S(t, r),
+    multicall: (r) => q(t, r),
+    prepareTransactionRequest: (r) => X(t, r),
+    readContract: (r) => H(t, r),
+    sendRawTransaction: (r) => Y(t, r),
+    simulateContract: (r) => I(t, r),
+    verifyMessage: (r) => l(t, r),
+    verifySiweMessage: (r) => W(t, r),
+    verifyTypedData: (r) => z(t, r),
+    uninstallFilter: (r) => j(t, r),
+    waitForTransactionReceipt: (r) => J(t, r),
+    watchBlocks: (r) => O(t, r),
+    watchBlockNumber: (r) => K(t, r),
+    watchContractEvent: (r) => Q(t, r),
+    watchEvent: (r) => U(t, r),
+    watchPendingTransactions: (r) => V(t, r)
+  };
+}
+export {
+  Ur as publicActions
+};

package/dist/astra-sdk.es4.js

@@ -0,0 +1,18 @@
+import { defineChain as a } from "./astra-sdk.es376.js";
+const n = a({
+  id: "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+  name: "Solana",
+  network: "solana-mainnet",
+  nativeCurrency: { name: "Solana", symbol: "SOL", decimals: 9 },
+  rpcUrls: {
+    default: { http: ["https://rpc.walletconnect.org/v1"] }
+  },
+  blockExplorers: { default: { name: "Solscan", url: "https://solscan.io" } },
+  testnet: !1,
+  chainNamespace: "solana",
+  caipNetworkId: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+  deprecatedCaipNetworkId: "solana:4sGjMW1sUnHzSxGspuhpqLDx6wiyjNtZ"
+});
+export {
+  n as solana
+};

package/dist/astra-sdk.es40.js

@@ -0,0 +1,167 @@
+import { j as a } from "./astra-sdk.es2.js";
+import { useState as x, useEffect as b } from "react";
+import { message as j, Flex as M, Modal as T } from "antd";
+import w from "./astra-sdk.es41.js";
+import n, { createGlobalStyle as C } from "./astra-sdk.es166.js";
+import D from "./astra-sdk.es167.js";
+import { MODAL_DISPLAY_TYPE as i } from "./astra-sdk.es43.js";
+import S from "./astra-sdk.es168.js";
+import z from "./astra-sdk.es169.js";
+import { useGetPairs as I } from "./astra-sdk.es170.js";
+import L from "./astra-sdk.es171.js";
+import G from "./astra-sdk.es172.js";
+import { useChains as k } from "./astra-sdk.es173.js";
+import { useChainId as A } from "./astra-sdk.es174.js";
+const R = C`
+  @font-face {
+    font-family: 'ClashDisplay';
+    src: url(${G});
+  }
+`, F = n.div`
+  .astra-logo {
+    width: 26px;
+    height: 26px;
+  }
+  .modal-title {
+    width: 100%;
+    text-align: left;
+  }
+`, _ = n(T)`
+  * {
+    font-family: "ClashDisplay";
+  }
+  .astra-modal-content {
+    font-family: "Clash Display", sans-serif !important;
+    background: rgba(51, 51, 51, 0.2);
+    border: 1px solid;
+    border-image-source: linear-gradient(
+      147.76deg,
+      #333333 0.7%,
+      rgba(51, 51, 51, 0) 98.42%
+    );
+    backdrop-filter: blur(50px);
+    padding: 20px 30px;
+
+    .astra-modal-header {
+      background: transparent;
+
+      .modal-title {
+        font-size: 20px;
+        font-weight: 500;
+      }
+    }
+    .colorcaff33 {
+      color: #caff33;
+    }
+    .astra-col {
+      font-family: "ClashDisplay";
+    }
+    .astra-typography {
+      font-family: "ClashDisplay";
+    }
+  }
+
+  @media (max-width: 768px) {
+    font-size: 10px;
+
+    .astra-modal-content {
+      padding: 20px 10px;
+      background: rgba(24, 30, 35, 1);
+      .astra-modal-header .modal-title {
+        font-size: 18px;
+      }
+      .astra-form .astra-form-item {
+        font-size: 12px;
+        margin-bottom: 10px;
+      }
+      .astra-form-item .astra-form-item-label > label {
+        font-size: 12px;
+      }
+      .astra-typography {
+        font-size: 12px;
+      }
+    }
+  }
+  @media (max-width: 575px) {
+    .astra-form .astra-form-item .astra-form-item-label,
+    .astra-form .astra-form-item .astra-form-item-control {
+      flex: auto !important;
+      max-width: auto !important;
+    }
+  }
+  @media (max-width: 575px) {
+    .astra-modal-content {
+      padding: 15px 8px;
+      background: rgba(24, 30, 35, 1);
+      .astra-modal-header .modal-title {
+        font-size: 16px;
+      }
+    }
+  }
+`, E = n.div`
+  padding-top: 10px;
+`;
+function U() {
+  const m = k(), o = A(), {
+    setTargetNetwork: d,
+    targetNetwork: t,
+    setAstraModalShow: c,
+    astraModalShow: p,
+    modalDisplayType: s
+  } = w(), [e, h] = j.useMessage(), [f, r] = x(!1), [g, l] = x(null), u = () => {
+    c(!1);
+  };
+  return I(), b(() => {
+    o && d(m.find((y) => y.id === o));
+  }, [o, m, d]), /* @__PURE__ */ a.jsxs(a.Fragment, { children: [
+    /* @__PURE__ */ a.jsx(R, {}),
+    /* @__PURE__ */ a.jsxs("div", { children: [
+      p ? /* @__PURE__ */ a.jsx(
+        _,
+        {
+          title: /* @__PURE__ */ a.jsx(F, { children: /* @__PURE__ */ a.jsx(M, { align: "center", children: /* @__PURE__ */ a.jsx("span", { className: "modal-title", children: s === i.TO_LIGHTNING ? `${t == null ? void 0 : t.name} to Lightning` : `Lightning to ${t == null ? void 0 : t.name}` }) }) }),
+          width: "500px",
+          footer: null,
+          open: p,
+          onCancel: u,
+          maskClosable: !1,
+          zIndex: 998,
+          mask: !1,
+          children: /* @__PURE__ */ a.jsxs(E, { children: [
+            s === i.TO_LIGHTNING && /* @__PURE__ */ a.jsx(
+              S,
+              {
+                messageApi: e,
+                setResultModalShow: r,
+                setResultModalRequest: l
+              }
+            ),
+            s === i.TO_EVM && /* @__PURE__ */ a.jsx(
+              z,
+              {
+                messageApi: e,
+                setResultModalShow: r,
+                setResultModalRequest: l
+              }
+            ),
+            /* @__PURE__ */ a.jsx(D, {})
+          ] })
+        }
+      ) : /* @__PURE__ */ a.jsx(a.Fragment, {}),
+      h
+    ] }),
+    f ? /* @__PURE__ */ a.jsx(
+      L,
+      {
+        messageApi: e,
+        resultModalShow: f,
+        requestData: g,
+        setResultModalRequest: l,
+        setResultModalShow: r
+      }
+    ) : /* @__PURE__ */ a.jsx(a.Fragment, {})
+  ] });
+}
+export {
+  U as default
+};

package/dist/astra-sdk.es400.js

@@ -0,0 +1,13 @@
+import { getAction as r } from "./astra-sdk.es384.js";
+import { multicall as e } from "./astra-sdk.es401.js";
+async function f(t, l) {
+  const { allowFailure: c = !0, chainId: i, contracts: n, ...o } = l, a = t.getClient({ chainId: i });
+  return r(a, e, "multicall")({
+    allowFailure: c,
+    contracts: n,
+    ...o
+  });
+}
+export {
+  f as multicall
+};

package/dist/astra-sdk.es401.js

@@ -0,0 +1,118 @@
+import { multicall3Abi as x } from "./astra-sdk.es582.js";
+import { AbiDecodingZeroDataError as P } from "./astra-sdk.es644.js";
+import { BaseError as _ } from "./astra-sdk.es585.js";
+import { RawContractError as v } from "./astra-sdk.es405.js";
+import { decodeFunctionResult as q } from "./astra-sdk.es587.js";
+import { encodeFunctionData as B } from "./astra-sdk.es589.js";
+import { getChainContractAddress as O } from "./astra-sdk.es590.js";
+import { getContractError as E } from "./astra-sdk.es721.js";
+import { getAction as T } from "./astra-sdk.es577.js";
+import { readContract as Z } from "./astra-sdk.es404.js";
+async function W(n, w) {
+  var A;
+  const { allowFailure: u = !0, batchSize: F, blockNumber: b, blockTag: j, multicallAddress: y, stateOverride: N } = w, h = w.contracts, p = F ?? (typeof ((A = n.batch) == null ? void 0 : A.multicall) == "object" && n.batch.multicall.batchSize || 1024);
+  let d = y;
+  if (!d) {
+    if (!n.chain)
+      throw new Error("client chain not configured. multicallAddress is required.");
+    d = O({
+      blockNumber: b,
+      chain: n.chain,
+      contract: "multicall3"
+    });
+  }
+  const e = [[]];
+  let a = 0, f = 0;
+  for (let t = 0; t < h.length; t++) {
+    const { abi: o, address: s, args: r, functionName: i } = h[t];
+    try {
+      const c = B({ abi: o, args: r, functionName: i });
+      f += (c.length - 2) / 2, // Check if batching is enabled.
+      p > 0 && // Check if the current size of the batch exceeds the size limit.
+      f > p && // Check if the current chunk is not already empty.
+      e[a].length > 0 && (a++, f = (c.length - 2) / 2, e[a] = []), e[a] = [
+        ...e[a],
+        {
+          allowFailure: !0,
+          callData: c,
+          target: s
+        }
+      ];
+    } catch (c) {
+      const g = E(c, {
+        abi: o,
+        address: s,
+        args: r,
+        docsPath: "/docs/contract/multicall",
+        functionName: i
+      });
+      if (!u)
+        throw g;
+      e[a] = [
+        ...e[a],
+        {
+          allowFailure: !0,
+          callData: "0x",
+          target: s
+        }
+      ];
+    }
+  }
+  const C = await Promise.allSettled(e.map((t) => T(n, Z, "readContract")({
+    abi: x,
+    address: d,
+    args: [t],
+    blockNumber: b,
+    blockTag: j,
+    functionName: "aggregate3",
+    stateOverride: N
+  }))), l = [];
+  for (let t = 0; t < C.length; t++) {
+    const o = C[t];
+    if (o.status === "rejected") {
+      if (!u)
+        throw o.reason;
+      for (let r = 0; r < e[t].length; r++)
+        l.push({
+          status: "failure",
+          error: o.reason,
+          result: void 0
+        });
+      continue;
+    }
+    const s = o.value;
+    for (let r = 0; r < s.length; r++) {
+      const { returnData: i, success: c } = s[r], { callData: g } = e[t][r], { abi: D, address: R, functionName: S, args: k } = h[l.length];
+      try {
+        if (g === "0x")
+          throw new P();
+        if (!c)
+          throw new v({ data: i });
+        const m = q({
+          abi: D,
+          args: k,
+          data: i,
+          functionName: S
+        });
+        l.push(u ? { result: m, status: "success" } : m);
+      } catch (m) {
+        const z = E(m, {
+          abi: D,
+          address: R,
+          args: k,
+          docsPath: "/docs/contract/multicall",
+          functionName: S
+        });
+        if (!u)
+          throw z;
+        l.push({ error: z, result: void 0, status: "failure" });
+      }
+    }
+  }
+  if (l.length !== h.length)
+    throw new _("multicall results mismatch");
+  return l;
+}
+export {
+  W as multicall
+};