astra-modal-test 1.0.4 → 1.0.6

package/dist/astra-sdk.es410.js

@@ -0,0 +1,96 @@
+import { BlockNotFoundError as A } from "./astra-sdk.es648.js";
+import { WaitForTransactionReceiptTimeoutError as M, TransactionNotFoundError as O, TransactionReceiptNotFoundError as W } from "./astra-sdk.es655.js";
+import { getAction as p } from "./astra-sdk.es577.js";
+import { observe as q } from "./astra-sdk.es979.js";
+import { withResolvers as z } from "./astra-sdk.es982.js";
+import { withRetry as v } from "./astra-sdk.es415.js";
+import { stringify as G } from "./astra-sdk.es664.js";
+import { getBlock as H } from "./astra-sdk.es616.js";
+import { getTransaction as J } from "./astra-sdk.es411.js";
+import { getTransactionReceipt as R } from "./astra-sdk.es629.js";
+import { watchBlockNumber as K } from "./astra-sdk.es634.js";
+async function D(o, {
+  confirmations: n = 1,
+  hash: m,
+  onReplaced: y,
+  pollingInterval: B = o.pollingInterval,
+  retryCount: k = 6,
+  retryDelay: N = ({ count: b }) => ~~(1 << b) * 200,
+  // exponential backoff
+  timeout: w = 18e4
+}) {
+  const b = G(["waitForTransactionReceipt", o.uid, m]);
+  let a, c, r, i = !1;
+  const { promise: h, resolve: F, reject: g } = z(), E = w ? setTimeout(() => g(new M({ hash: m })), w) : void 0, _ = q(b, { onReplaced: y, resolve: F, reject: g }, (e) => {
+    const j = p(o, K, "watchBlockNumber")({
+      emitMissed: !0,
+      emitOnBegin: !0,
+      poll: !0,
+      pollingInterval: B,
+      async onBlockNumber(I) {
+        const l = (f) => {
+          clearTimeout(E), j(), f(), _();
+        };
+        let u = I;
+        if (!i)
+          try {
+            if (r) {
+              if (n > 1 && (!r.blockNumber || u - r.blockNumber + 1n < n))
+                return;
+              l(() => e.resolve(r));
+              return;
+            }
+            if (a || (i = !0, await v(async () => {
+              a = await p(o, J, "getTransaction")({ hash: m }), a.blockNumber && (u = a.blockNumber);
+            }, {
+              delay: N,
+              retryCount: k
+            }), i = !1), r = await p(o, R, "getTransactionReceipt")({ hash: m }), n > 1 && (!r.blockNumber || u - r.blockNumber + 1n < n))
+              return;
+            l(() => e.resolve(r));
+          } catch (f) {
+            if (f instanceof O || f instanceof W) {
+              if (!a) {
+                i = !1;
+                return;
+              }
+              try {
+                c = a, i = !0;
+                const d = await v(() => p(o, H, "getBlock")({
+                  blockNumber: u,
+                  includeTransactions: !0
+                }), {
+                  delay: N,
+                  retryCount: k,
+                  shouldRetry: ({ error: s }) => s instanceof A
+                });
+                i = !1;
+                const t = d.transactions.find(({ from: s, nonce: x }) => s === c.from && x === c.nonce);
+                if (!t || (r = await p(o, R, "getTransactionReceipt")({
+                  hash: t.hash
+                }), n > 1 && (!r.blockNumber || u - r.blockNumber + 1n < n)))
+                  return;
+                let T = "replaced";
+                t.to === c.to && t.value === c.value ? T = "repriced" : t.from === t.to && t.value === 0n && (T = "cancelled"), l(() => {
+                  var s;
+                  (s = e.onReplaced) == null || s.call(e, {
+                    reason: T,
+                    replacedTransaction: c,
+                    transaction: t,
+                    transactionReceipt: r
+                  }), e.resolve(r);
+                });
+              } catch (d) {
+                l(() => e.reject(d));
+              }
+            } else
+              l(() => e.reject(f));
+          }
+      }
+    });
+  });
+  return h;
+}
+export {
+  D as waitForTransactionReceipt
+};

package/dist/astra-sdk.es411.js

@@ -0,0 +1,29 @@
+import { TransactionNotFoundError as p } from "./astra-sdk.es655.js";
+import { numberToHex as s } from "./astra-sdk.es416.js";
+import { formatTransaction as T } from "./astra-sdk.es676.js";
+async function h(e, { blockHash: a, blockNumber: r, blockTag: c, hash: o, index: n }) {
+  var i, u, f;
+  const m = c || "latest", d = r !== void 0 ? s(r) : void 0;
+  let t = null;
+  if (o ? t = await e.request({
+    method: "eth_getTransactionByHash",
+    params: [o]
+  }, { dedupe: !0 }) : a ? t = await e.request({
+    method: "eth_getTransactionByBlockHashAndIndex",
+    params: [a, s(n)]
+  }, { dedupe: !0 }) : t = await e.request({
+    method: "eth_getTransactionByBlockNumberAndIndex",
+    params: [d || m, s(n)]
+  }, { dedupe: !!d }), !t)
+    throw new p({
+      blockHash: a,
+      blockNumber: r,
+      blockTag: m,
+      hash: o,
+      index: n
+    });
+  return (((f = (u = (i = e.chain) == null ? void 0 : i.formatters) == null ? void 0 : u.transaction) == null ? void 0 : f.format) || T)(t);
+}
+export {
+  h as getTransaction
+};

package/dist/astra-sdk.es412.js

@@ -0,0 +1,165 @@
+import { parseAccount as $ } from "./astra-sdk.es393.js";
+import { multicall3Abi as z } from "./astra-sdk.es582.js";
+import { aggregate3Signature as W } from "./astra-sdk.es583.js";
+import { deploylessCallViaBytecodeBytecode as I, deploylessCallViaFactoryBytecode as J } from "./astra-sdk.es584.js";
+import { BaseError as S } from "./astra-sdk.es585.js";
+import { ClientChainNotConfiguredError as O, ChainDoesNotSupportContract as K } from "./astra-sdk.es586.js";
+import { CounterfactualDeploymentFailedError as Q, RawContractError as U } from "./astra-sdk.es405.js";
+import { decodeFunctionResult as X } from "./astra-sdk.es587.js";
+import { encodeDeployData as T } from "./astra-sdk.es588.js";
+import { encodeFunctionData as Y } from "./astra-sdk.es589.js";
+import { getChainContractAddress as Z } from "./astra-sdk.es590.js";
+import { numberToHex as j } from "./astra-sdk.es416.js";
+import { getCallError as tt } from "./astra-sdk.es591.js";
+import { extract as at } from "./astra-sdk.es592.js";
+import { formatTransactionRequest as et } from "./astra-sdk.es593.js";
+import { createBatchScheduler as ot } from "./astra-sdk.es594.js";
+import { serializeStateOverride as rt } from "./astra-sdk.es595.js";
+import { assertRequest as ct } from "./astra-sdk.es596.js";
+import { parseAbi as G } from "./astra-sdk.es597.js";
+async function qt(t, a) {
+  var E, P, V, _;
+  const { account: e = t.account, batch: s = !!((E = t.batch) != null && E.multicall), blockNumber: o, blockTag: h = "latest", accessList: x, blobs: k, code: i, data: n, factory: d, factoryData: l, gas: F, gasPrice: u, maxFeePerBlobGas: B, maxFeePerGas: y, maxPriorityFeePerGas: f, nonce: m, to: r, value: p, stateOverride: g, ...L } = a, w = e ? $(e) : void 0;
+  if (i && (d || l))
+    throw new S("Cannot provide both `code` & `factory`/`factoryData` as parameters.");
+  if (i && r)
+    throw new S("Cannot provide both `code` & `to` as parameters.");
+  const A = i && n, R = d && l && r && n, q = A || R, M = A ? it({
+    code: i,
+    data: n
+  }) : R ? lt({
+    data: n,
+    factory: d,
+    factoryData: l,
+    to: r
+  }) : n;
+  try {
+    ct(a);
+    const c = (o ? j(o) : void 0) || h, b = rt(g), C = (_ = (V = (P = t.chain) == null ? void 0 : P.formatters) == null ? void 0 : V.transactionRequest) == null ? void 0 : _.format, D = (C || et)({
+      // Pick out extra data that might exist on the chain's transaction request type.
+      ...at(L, { format: C }),
+      from: w == null ? void 0 : w.address,
+      accessList: x,
+      blobs: k,
+      data: M,
+      gas: F,
+      gasPrice: u,
+      maxFeePerBlobGas: B,
+      maxFeePerGas: y,
+      maxPriorityFeePerGas: f,
+      nonce: m,
+      to: q ? void 0 : r,
+      value: p
+    });
+    if (s && nt({ request: D }) && !b)
+      try {
+        return await st(t, {
+          ...D,
+          blockNumber: o,
+          blockTag: h
+        });
+      } catch (v) {
+        if (!(v instanceof O) && !(v instanceof K))
+          throw v;
+      }
+    const H = await t.request({
+      method: "eth_call",
+      params: b ? [
+        D,
+        c,
+        b
+      ] : [D, c]
+    });
+    return H === "0x" ? { data: void 0 } : { data: H };
+  } catch (N) {
+    const c = dt(N), { offchainLookup: b, offchainLookupSignature: C } = await import("./astra-sdk.es581.js");
+    if (t.ccipRead !== !1 && (c == null ? void 0 : c.slice(0, 10)) === C && r)
+      return { data: await b(t, { data: c, to: r }) };
+    throw q && (c == null ? void 0 : c.slice(0, 10)) === "0x101bb98d" ? new Q({ factory: d }) : tt(N, {
+      ...a,
+      account: w,
+      chain: t.chain
+    });
+  }
+}
+function nt({ request: t }) {
+  const { data: a, to: e, ...s } = t;
+  return !(!a || a.startsWith(W) || !e || Object.values(s).filter((o) => typeof o < "u").length > 0);
+}
+async function st(t, a) {
+  var y;
+  const { batchSize: e = 1024, wait: s = 0 } = typeof ((y = t.batch) == null ? void 0 : y.multicall) == "object" ? t.batch.multicall : {}, { blockNumber: o, blockTag: h = "latest", data: x, multicallAddress: k, to: i } = a;
+  let n = k;
+  if (!n) {
+    if (!t.chain)
+      throw new O();
+    n = Z({
+      blockNumber: o,
+      chain: t.chain,
+      contract: "multicall3"
+    });
+  }
+  const l = (o ? j(o) : void 0) || h, { schedule: F } = ot({
+    id: `${t.uid}.${l}`,
+    wait: s,
+    shouldSplitBatch(f) {
+      return f.reduce((r, { data: p }) => r + (p.length - 2), 0) > e * 2;
+    },
+    fn: async (f) => {
+      const m = f.map((g) => ({
+        allowFailure: !0,
+        callData: g.data,
+        target: g.to
+      })), r = Y({
+        abi: z,
+        args: [m],
+        functionName: "aggregate3"
+      }), p = await t.request({
+        method: "eth_call",
+        params: [
+          {
+            data: r,
+            to: n
+          },
+          l
+        ]
+      });
+      return X({
+        abi: z,
+        args: [m],
+        functionName: "aggregate3",
+        data: p || "0x"
+      });
+    }
+  }), [{ returnData: u, success: B }] = await F({ data: x, to: i });
+  if (!B)
+    throw new U({ data: u });
+  return u === "0x" ? { data: void 0 } : { data: u };
+}
+function it(t) {
+  const { code: a, data: e } = t;
+  return T({
+    abi: G(["constructor(bytes, bytes)"]),
+    bytecode: I,
+    args: [a, e]
+  });
+}
+function lt(t) {
+  const { data: a, factory: e, factoryData: s, to: o } = t;
+  return T({
+    abi: G(["constructor(address, bytes, address, bytes)"]),
+    bytecode: J,
+    args: [o, a, e, s]
+  });
+}
+function dt(t) {
+  var e;
+  if (!(t instanceof S))
+    return;
+  const a = t.walk();
+  return typeof (a == null ? void 0 : a.data) == "object" ? (e = a.data) == null ? void 0 : e.data : a.data;
+}
+export {
+  qt as call,
+  dt as getRevertErrorData
+};

package/dist/astra-sdk.es413.js

@@ -0,0 +1,38 @@
+import { parseAccount as u } from "./astra-sdk.es393.js";
+import { AccountNotFoundError as p } from "./astra-sdk.es983.js";
+import { encodeFunctionData as w } from "./astra-sdk.es589.js";
+import { getContractError as h } from "./astra-sdk.es721.js";
+import { getAction as C } from "./astra-sdk.es577.js";
+import { sendTransaction as g } from "./astra-sdk.es406.js";
+async function N(r, i) {
+  const { abi: n, account: o = r.account, address: a, args: c, dataSuffix: e, functionName: s, ...d } = i;
+  if (typeof o > "u")
+    throw new p({
+      docsPath: "/docs/contract/writeContract"
+    });
+  const t = o ? u(o) : null, f = w({
+    abi: n,
+    args: c,
+    functionName: s
+  });
+  try {
+    return await C(r, g, "sendTransaction")({
+      data: `${f}${e ? e.replace("0x", "") : ""}`,
+      to: a,
+      account: t,
+      ...d
+    });
+  } catch (m) {
+    throw h(m, {
+      abi: n,
+      address: a,
+      args: c,
+      docsPath: "/docs/contract/writeContract",
+      functionName: s,
+      sender: t == null ? void 0 : t.address
+    });
+  }
+}
+export {
+  N as writeContract
+};

package/dist/astra-sdk.es414.js

@@ -0,0 +1,20 @@
+function u(e, { errorInstance: o = new Error("timed out"), timeout: n, signal: l }) {
+  return new Promise((r, i) => {
+    (async () => {
+      let a;
+      try {
+        const t = new AbortController();
+        n > 0 && (a = setTimeout(() => {
+          l ? t.abort() : i(o);
+        }, n)), r(await e({ signal: (t == null ? void 0 : t.signal) || null }));
+      } catch (t) {
+        (t == null ? void 0 : t.name) === "AbortError" && i(o), i(t);
+      } finally {
+        clearTimeout(a);
+      }
+    })();
+  });
+}
+export {
+  u as withTimeout
+};

package/dist/astra-sdk.es415.js

@@ -0,0 +1,23 @@
+import { wait as w } from "./astra-sdk.es601.js";
+function p(n, { delay: e = 100, retryCount: o = 2, shouldRetry: c = () => !0 } = {}) {
+  return new Promise((s, y) => {
+    const a = async ({ count: r = 0 } = {}) => {
+      const f = async ({ error: t }) => {
+        const i = typeof e == "function" ? e({ count: r, error: t }) : e;
+        i && await w(i), a({ count: r + 1 });
+      };
+      try {
+        const t = await n();
+        s(t);
+      } catch (t) {
+        if (r < o && await c({ count: r, error: t }))
+          return f({ error: t });
+        y(t);
+      }
+    };
+    a();
+  });
+}
+export {
+  p as withRetry
+};

package/dist/astra-sdk.es416.js

@@ -0,0 +1,48 @@
+import { IntegerOutOfRangeError as x } from "./astra-sdk.es658.js";
+import { pad as s } from "./astra-sdk.es688.js";
+import { assertSize as c } from "./astra-sdk.es389.js";
+const b = /* @__PURE__ */ Array.from({ length: 256 }, (n, e) => e.toString(16).padStart(2, "0"));
+function B(n, e = {}) {
+  return typeof n == "number" || typeof n == "bigint" ? y(n, e) : typeof n == "string" ? $(n, e) : typeof n == "boolean" ? z(n, e) : m(n, e);
+}
+function z(n, e = {}) {
+  const t = `0x${Number(n)}`;
+  return typeof e.size == "number" ? (c(t, { size: e.size }), s(t, { size: e.size })) : t;
+}
+function m(n, e = {}) {
+  let t = "";
+  for (let i = 0; i < n.length; i++)
+    t += b[n[i]];
+  const r = `0x${t}`;
+  return typeof e.size == "number" ? (c(r, { size: e.size }), s(r, { dir: "right", size: e.size })) : r;
+}
+function y(n, e = {}) {
+  const { signed: t, size: r } = e, i = BigInt(n);
+  let o;
+  r ? t ? o = (1n << BigInt(r) * 8n - 1n) - 1n : o = 2n ** (BigInt(r) * 8n) - 1n : typeof n == "number" && (o = BigInt(Number.MAX_SAFE_INTEGER));
+  const g = typeof o == "bigint" && t ? -o - 1n : 0;
+  if (o && i > o || i < g) {
+    const f = typeof n == "bigint" ? "n" : "";
+    throw new x({
+      max: o ? `${o}${f}` : void 0,
+      min: `${g}${f}`,
+      signed: t,
+      size: r,
+      value: `${n}${f}`
+    });
+  }
+  const u = `0x${(t && i < 0 ? (1n << BigInt(r * 8)) + BigInt(i) : i).toString(16)}`;
+  return r ? s(u, { size: r }) : u;
+}
+const d = /* @__PURE__ */ new TextEncoder();
+function $(n, e = {}) {
+  const t = d.encode(n);
+  return m(t, e);
+}
+export {
+  z as boolToHex,
+  m as bytesToHex,
+  y as numberToHex,
+  $ as stringToHex,
+  B as toHex
+};

package/dist/astra-sdk.es417.js

@@ -0,0 +1,166 @@
+const H = (d) => (h, r, n) => {
+  const s = n.subscribe;
+  return n.subscribe = (l, a, o) => {
+    let u = l;
+    if (a) {
+      const g = (o == null ? void 0 : o.equalityFn) || Object.is;
+      let f = l(n.getState());
+      u = (m) => {
+        const c = l(m);
+        if (!g(f, c)) {
+          const y = f;
+          a(f = c, y);
+        }
+      }, o != null && o.fireImmediately && a(f, f);
+    }
+    return s(u);
+  }, d(h, r, n);
+}, R = H;
+function F(d, h) {
+  let r;
+  try {
+    r = d();
+  } catch {
+    return;
+  }
+  return {
+    getItem: (s) => {
+      var t;
+      const l = (o) => o === null ? null : JSON.parse(o, void 0), a = (t = r.getItem(s)) != null ? t : null;
+      return a instanceof Promise ? a.then(l) : l(a);
+    },
+    setItem: (s, t) => r.setItem(
+      s,
+      JSON.stringify(t, void 0)
+    ),
+    removeItem: (s) => r.removeItem(s)
+  };
+}
+const I = (d) => (h) => {
+  try {
+    const r = d(h);
+    return r instanceof Promise ? r : {
+      then(n) {
+        return I(n)(r);
+      },
+      catch(n) {
+        return this;
+      }
+    };
+  } catch (r) {
+    return {
+      then(n) {
+        return this;
+      },
+      catch(n) {
+        return I(n)(r);
+      }
+    };
+  }
+}, O = (d, h) => (r, n, s) => {
+  let t = {
+    storage: F(() => localStorage),
+    partialize: (e) => e,
+    version: 0,
+    merge: (e, S) => ({
+      ...S,
+      ...e
+    }),
+    ...h
+  }, l = !1;
+  const a = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Set();
+  let u = t.storage;
+  if (!u)
+    return d(
+      (...e) => {
+        console.warn(
+          `[zustand persist middleware] Unable to update item '${t.name}', the given storage is currently unavailable.`
+        ), r(...e);
+      },
+      n,
+      s
+    );
+  const g = () => {
+    const e = t.partialize({ ...n() });
+    return u.setItem(t.name, {
+      state: e,
+      version: t.version
+    });
+  }, f = s.setState;
+  s.setState = (e, S) => {
+    f(e, S), g();
+  };
+  const m = d(
+    (...e) => {
+      r(...e), g();
+    },
+    n,
+    s
+  );
+  s.getInitialState = () => m;
+  let c;
+  const y = () => {
+    var e, S;
+    if (!u) return;
+    l = !1, a.forEach((i) => {
+      var v;
+      return i((v = n()) != null ? v : m);
+    });
+    const b = ((S = t.onRehydrateStorage) == null ? void 0 : S.call(t, (e = n()) != null ? e : m)) || void 0;
+    return I(u.getItem.bind(u))(t.name).then((i) => {
+      if (i)
+        if (typeof i.version == "number" && i.version !== t.version) {
+          if (t.migrate)
+            return [
+              !0,
+              t.migrate(
+                i.state,
+                i.version
+              )
+            ];
+          console.error(
+            "State loaded from storage couldn't be migrated since no migrate function was provided"
+          );
+        } else
+          return [!1, i.state];
+      return [!1, void 0];
+    }).then((i) => {
+      var v;
+      const [p, _] = i;
+      if (c = t.merge(
+        _,
+        (v = n()) != null ? v : m
+      ), r(c, !0), p)
+        return g();
+    }).then(() => {
+      b == null || b(c, void 0), c = n(), l = !0, o.forEach((i) => i(c));
+    }).catch((i) => {
+      b == null || b(void 0, i);
+    });
+  };
+  return s.persist = {
+    setOptions: (e) => {
+      t = {
+        ...t,
+        ...e
+      }, e.storage && (u = e.storage);
+    },
+    clearStorage: () => {
+      u == null || u.removeItem(t.name);
+    },
+    getOptions: () => t,
+    rehydrate: () => y(),
+    hasHydrated: () => l,
+    onHydrate: (e) => (a.add(e), () => {
+      a.delete(e);
+    }),
+    onFinishHydration: (e) => (o.add(e), () => {
+      o.delete(e);
+    })
+  }, t.skipHydration || y(), c || m;
+}, w = O;
+export {
+  F as createJSONStorage,
+  w as persist,
+  R as subscribeWithSelector
+};

package/dist/astra-sdk.es418.js

@@ -0,0 +1,14 @@
+const S = (s) => {
+  let t;
+  const o = /* @__PURE__ */ new Set(), c = (e, r) => {
+    const n = typeof e == "function" ? e(t) : e;
+    if (!Object.is(n, t)) {
+      const b = t;
+      t = r ?? (typeof n != "object" || n === null) ? n : Object.assign({}, t, n), o.forEach((l) => l(t, b));
+    }
+  }, i = () => t, a = { setState: c, getState: i, getInitialState: () => u, subscribe: (e) => (o.add(e), () => o.delete(e)) }, u = t = s(c, i, a);
+  return a;
+}, d = (s) => s ? S(s) : S;
+export {
+  d as createStore
+};

package/dist/astra-sdk.es419.js

@@ -0,0 +1,39 @@
+import n from "./astra-sdk.es562.js";
+class u {
+  constructor(e) {
+    Object.defineProperty(this, "uid", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: e
+    }), Object.defineProperty(this, "_emitter", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: new n()
+    });
+  }
+  on(e, t) {
+    this._emitter.on(e, t);
+  }
+  once(e, t) {
+    this._emitter.once(e, t);
+  }
+  off(e, t) {
+    this._emitter.off(e, t);
+  }
+  emit(e, ...t) {
+    const i = t[0];
+    this._emitter.emit(e, { uid: this.uid, ...i });
+  }
+  listenerCount(e) {
+    return this._emitter.listenerCount(e);
+  }
+}
+function m(r) {
+  return new u(r);
+}
+export {
+  u as Emitter,
+  m as createEmitter
+};