astra-modal-test 1.0.5 → 1.0.6

package/dist/astra-sdk.es402.js

@@ -0,0 +1,105 @@
+import { parseAccount as x } from "./astra-sdk.es393.js";
+import { internal_estimateFeesPerGas as b } from "./astra-sdk.es613.js";
+import { estimateGas as F } from "./astra-sdk.es386.js";
+import { getBlock as I } from "./astra-sdk.es616.js";
+import { getTransactionCount as T } from "./astra-sdk.es628.js";
+import { MaxFeePerGasTooLowError as k, Eip1559FeesNotSupportedError as C } from "./astra-sdk.es657.js";
+import { blobsToCommitments as H } from "./astra-sdk.es711.js";
+import { blobsToProofs as q } from "./astra-sdk.es715.js";
+import { commitmentsToVersionedHashes as V } from "./astra-sdk.es714.js";
+import { toBlobSidecars as _ } from "./astra-sdk.es716.js";
+import { getAction as p } from "./astra-sdk.es577.js";
+import { assertRequest as B } from "./astra-sdk.es596.js";
+import { getTransactionType as E } from "./astra-sdk.es696.js";
+import { getChainId as A } from "./astra-sdk.es619.js";
+const M = [
+  "blobVersionedHashes",
+  "chainId",
+  "fees",
+  "gas",
+  "nonce",
+  "type"
+];
+async function W(i, a) {
+  const { account: u = i.account, blobs: c, chain: d, gas: g, kzg: y, nonce: w, nonceManager: h, parameters: o = M, type: G } = a, s = u && x(u), e = { ...a, ...s ? { from: s == null ? void 0 : s.address } : {} };
+  let f;
+  async function l() {
+    return f || (f = await p(i, I, "getBlock")({ blockTag: "latest" }), f);
+  }
+  let m;
+  async function P() {
+    return m || (d ? d.id : typeof a.chainId < "u" ? a.chainId : (m = await p(i, A, "getChainId")({}), m));
+  }
+  if ((o.includes("blobVersionedHashes") || o.includes("sidecars")) && c && y) {
+    const t = H({ blobs: c, kzg: y });
+    if (o.includes("blobVersionedHashes")) {
+      const r = V({
+        commitments: t,
+        to: "hex"
+      });
+      e.blobVersionedHashes = r;
+    }
+    if (o.includes("sidecars")) {
+      const r = q({ blobs: c, commitments: t, kzg: y }), n = _({
+        blobs: c,
+        commitments: t,
+        proofs: r,
+        to: "hex"
+      });
+      e.sidecars = n;
+    }
+  }
+  if (o.includes("chainId") && (e.chainId = await P()), o.includes("nonce") && typeof w > "u" && s)
+    if (h) {
+      const t = await P();
+      e.nonce = await h.consume({
+        address: s.address,
+        chainId: t,
+        client: i
+      });
+    } else
+      e.nonce = await p(i, T, "getTransactionCount")({
+        address: s.address,
+        blockTag: "pending"
+      });
+  if ((o.includes("fees") || o.includes("type")) && typeof G > "u")
+    try {
+      e.type = E(e);
+    } catch {
+      const t = await l();
+      e.type = typeof (t == null ? void 0 : t.baseFeePerGas) == "bigint" ? "eip1559" : "legacy";
+    }
+  if (o.includes("fees"))
+    if (e.type !== "legacy" && e.type !== "eip2930") {
+      if (typeof e.maxFeePerGas > "u" || typeof e.maxPriorityFeePerGas > "u") {
+        const t = await l(), { maxFeePerGas: r, maxPriorityFeePerGas: n } = await b(i, {
+          block: t,
+          chain: d,
+          request: e
+        });
+        if (typeof a.maxPriorityFeePerGas > "u" && a.maxFeePerGas && a.maxFeePerGas < n)
+          throw new k({
+            maxPriorityFeePerGas: n
+          });
+        e.maxPriorityFeePerGas = n, e.maxFeePerGas = r;
+      }
+    } else {
+      if (typeof a.maxFeePerGas < "u" || typeof a.maxPriorityFeePerGas < "u")
+        throw new C();
+      const t = await l(), { gasPrice: r } = await b(i, {
+        block: t,
+        chain: d,
+        request: e,
+        type: "legacy"
+      });
+      e.gasPrice = r;
+    }
+  return o.includes("gas") && typeof g > "u" && (e.gas = await p(i, F, "estimateGas")({
+    ...e,
+    account: s && { address: s.address, type: "json-rpc" }
+  })), B(e), delete e.parameters, e;
+}
+export {
+  M as defaultParameters,
+  W as prepareTransactionRequest
+};

package/dist/astra-sdk.es403.js

@@ -0,0 +1,9 @@
+import { getAction as a } from "./astra-sdk.es384.js";
+import { readContract as e } from "./astra-sdk.es404.js";
+function C(t, n) {
+  const { chainId: o, ...r } = n, c = t.getClient({ chainId: o });
+  return a(c, e, "readContract")(r);
+}
+export {
+  C as readContract
+};

package/dist/astra-sdk.es404.js

@@ -0,0 +1,36 @@
+import { decodeFunctionResult as m } from "./astra-sdk.es587.js";
+import { encodeFunctionData as s } from "./astra-sdk.es589.js";
+import { getContractError as f } from "./astra-sdk.es721.js";
+import { getAction as l } from "./astra-sdk.es577.js";
+import { call as p } from "./astra-sdk.es412.js";
+async function x(n, e) {
+  const { abi: t, address: c, args: o, functionName: r, ...d } = e, i = s({
+    abi: t,
+    args: o,
+    functionName: r
+  });
+  try {
+    const { data: a } = await l(n, p, "call")({
+      ...d,
+      data: i,
+      to: c
+    });
+    return m({
+      abi: t,
+      args: o,
+      functionName: r,
+      data: a || "0x"
+    });
+  } catch (a) {
+    throw f(a, {
+      abi: t,
+      address: c,
+      args: o,
+      docsPath: "/docs/contract/readContract",
+      functionName: r
+    });
+  }
+}
+export {
+  x as readContract
+};

package/dist/astra-sdk.es405.js

@@ -0,0 +1,213 @@
+import { parseAccount as $ } from "./astra-sdk.es393.js";
+import { panicReasons as A } from "./astra-sdk.es649.js";
+import { decodeErrorResult as C } from "./astra-sdk.es650.js";
+import { formatAbiItem as w } from "./astra-sdk.es645.js";
+import { formatAbiItemWithArgs as E } from "./astra-sdk.es651.js";
+import { getAbiItem as P } from "./astra-sdk.es576.js";
+import { formatEther as x } from "./astra-sdk.es652.js";
+import { formatGwei as g } from "./astra-sdk.es653.js";
+import { AbiErrorSignatureNotFoundError as j } from "./astra-sdk.es644.js";
+import { BaseError as b } from "./astra-sdk.es585.js";
+import { prettyStateOverride as F } from "./astra-sdk.es654.js";
+import { prettyPrint as v } from "./astra-sdk.es655.js";
+import { getContractAddress as O } from "./astra-sdk.es656.js";
+class H extends b {
+  constructor(e, { account: o, docsPath: c, chain: a, data: d, gas: n, gasPrice: s, maxFeePerGas: r, maxPriorityFeePerGas: t, nonce: i, to: u, value: l, stateOverride: f }) {
+    var y;
+    const m = o ? $(o) : void 0;
+    let h = v({
+      from: m == null ? void 0 : m.address,
+      to: u,
+      value: typeof l < "u" && `${x(l)} ${((y = a == null ? void 0 : a.nativeCurrency) == null ? void 0 : y.symbol) || "ETH"}`,
+      data: d,
+      gas: n,
+      gasPrice: typeof s < "u" && `${g(s)} gwei`,
+      maxFeePerGas: typeof r < "u" && `${g(r)} gwei`,
+      maxPriorityFeePerGas: typeof t < "u" && `${g(t)} gwei`,
+      nonce: i
+    });
+    f && (h += `
+${F(f)}`), super(e.shortMessage, {
+      cause: e,
+      docsPath: c,
+      metaMessages: [
+        ...e.metaMessages ? [...e.metaMessages, " "] : [],
+        "Raw Call Arguments:",
+        h
+      ].filter(Boolean),
+      name: "CallExecutionError"
+    }), Object.defineProperty(this, "cause", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), this.cause = e;
+  }
+}
+class U extends b {
+  constructor(e, { abi: o, args: c, contractAddress: a, docsPath: d, functionName: n, sender: s }) {
+    const r = P({ abi: o, args: c, name: n }), t = r ? E({
+      abiItem: r,
+      args: c,
+      includeFunctionName: !1,
+      includeName: !1
+    }) : void 0, i = r ? w(r, { includeName: !0 }) : void 0, u = v({
+      address: a && O(a),
+      function: i,
+      args: t && t !== "()" && `${[...Array((n == null ? void 0 : n.length) ?? 0).keys()].map(() => " ").join("")}${t}`,
+      sender: s
+    });
+    super(e.shortMessage || `An unknown error occurred while executing the contract function "${n}".`, {
+      cause: e,
+      docsPath: d,
+      metaMessages: [
+        ...e.metaMessages ? [...e.metaMessages, " "] : [],
+        u && "Contract Call:",
+        u
+      ].filter(Boolean),
+      name: "ContractFunctionExecutionError"
+    }), Object.defineProperty(this, "abi", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "args", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "cause", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "contractAddress", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "formattedArgs", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "functionName", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "sender", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), this.abi = o, this.args = c, this.cause = e, this.contractAddress = a, this.functionName = n, this.sender = s;
+  }
+}
+class Y extends b {
+  constructor({ abi: e, data: o, functionName: c, message: a }) {
+    let d, n, s, r;
+    if (o && o !== "0x")
+      try {
+        n = C({ abi: e, data: o });
+        const { abiItem: i, errorName: u, args: l } = n;
+        if (u === "Error")
+          r = l[0];
+        else if (u === "Panic") {
+          const [f] = l;
+          r = A[f];
+        } else {
+          const f = i ? w(i, { includeName: !0 }) : void 0, m = i && l ? E({
+            abiItem: i,
+            args: l,
+            includeFunctionName: !1,
+            includeName: !1
+          }) : void 0;
+          s = [
+            f ? `Error: ${f}` : "",
+            m && m !== "()" ? `       ${[...Array((u == null ? void 0 : u.length) ?? 0).keys()].map(() => " ").join("")}${m}` : ""
+          ];
+        }
+      } catch (i) {
+        d = i;
+      }
+    else a && (r = a);
+    let t;
+    d instanceof j && (t = d.signature, s = [
+      `Unable to decode signature "${t}" as it was not found on the provided ABI.`,
+      "Make sure you are using the correct ABI and that the error exists on it.",
+      `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${t}.`
+    ]), super(r && r !== "execution reverted" || t ? [
+      `The contract function "${c}" reverted with the following ${t ? "signature" : "reason"}:`,
+      r || t
+    ].join(`
+`) : `The contract function "${c}" reverted.`, {
+      cause: d,
+      metaMessages: s,
+      name: "ContractFunctionRevertedError"
+    }), Object.defineProperty(this, "data", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "reason", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "signature", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), this.data = n, this.reason = r, this.signature = t;
+  }
+}
+class J extends b {
+  constructor({ functionName: e }) {
+    super(`The contract function "${e}" returned no data ("0x").`, {
+      metaMessages: [
+        "This could be due to any of the following:",
+        `  - The contract does not have the function "${e}",`,
+        "  - The parameters passed to the contract function may be invalid, or",
+        "  - The address is not a contract."
+      ],
+      name: "ContractFunctionZeroDataError"
+    });
+  }
+}
+class K extends b {
+  constructor({ factory: e }) {
+    super(`Deployment for counterfactual contract call failed${e ? ` for factory "${e}".` : ""}`, {
+      metaMessages: [
+        "Please ensure:",
+        "- The `factory` is a valid contract deployment factory (ie. Create2 Factory, ERC-4337 Factory, etc).",
+        "- The `factoryData` is a valid encoded function call for contract deployment function on the factory."
+      ],
+      name: "CounterfactualDeploymentFailedError"
+    });
+  }
+}
+class L extends b {
+  constructor({ data: e, message: o }) {
+    super(o || "", { name: "RawContractError" }), Object.defineProperty(this, "code", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 3
+    }), Object.defineProperty(this, "data", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), this.data = e;
+  }
+}
+export {
+  H as CallExecutionError,
+  U as ContractFunctionExecutionError,
+  Y as ContractFunctionRevertedError,
+  J as ContractFunctionZeroDataError,
+  K as CounterfactualDeploymentFailedError,
+  L as RawContractError
+};

package/dist/astra-sdk.es406.js

@@ -0,0 +1,126 @@
+import { parseAccount as S } from "./astra-sdk.es393.js";
+import { AccountNotFoundError as _, AccountTypeNotSupportedError as u } from "./astra-sdk.es983.js";
+import { BaseError as G } from "./astra-sdk.es585.js";
+import { recoverAuthorizationAddress as B } from "./astra-sdk.es975.js";
+import { assertCurrentChain as O } from "./astra-sdk.es719.js";
+import { getTransactionError as U } from "./astra-sdk.es984.js";
+import { extract as W } from "./astra-sdk.es592.js";
+import { formatTransactionRequest as j } from "./astra-sdk.es593.js";
+import { getAction as f } from "./astra-sdk.es577.js";
+import { LruMap as k } from "./astra-sdk.es720.js";
+import { assertRequest as D } from "./astra-sdk.es596.js";
+import { getChainId as H } from "./astra-sdk.es619.js";
+import { prepareTransactionRequest as J, defaultParameters as K } from "./astra-sdk.es402.js";
+import { sendRawTransaction as Q } from "./astra-sdk.es639.js";
+const h = new k(128);
+async function dr(t, o) {
+  var M, z, A, F;
+  const { account: d = t.account, chain: e = t.chain, accessList: w, authorizationList: s, blobs: l, data: y, gas: T, gasPrice: g, maxFeePerBlobGas: R, maxFeePerGas: E, maxPriorityFeePerGas: q, nonce: P, value: C, ...N } = o;
+  if (typeof d > "u")
+    throw new _({
+      docsPath: "/docs/actions/wallet/sendTransaction"
+    });
+  const r = d ? S(d) : null;
+  try {
+    D(o);
+    const a = await (async () => {
+      if (o.to)
+        return o.to;
+      if (s && s.length > 0)
+        return await B({
+          authorization: s[0]
+        }).catch(() => {
+          throw new G("`to` is required. Could not infer from `authorizationList`.");
+        });
+    })();
+    if ((r == null ? void 0 : r.type) === "json-rpc" || r === null) {
+      let i;
+      e !== null && (i = await f(t, H, "getChainId")({}), O({
+        currentChainId: i,
+        chain: e
+      }));
+      const c = (A = (z = (M = t.chain) == null ? void 0 : M.formatters) == null ? void 0 : z.transactionRequest) == null ? void 0 : A.format, x = (c || j)({
+        // Pick out extra data that might exist on the chain's transaction request type.
+        ...W(N, { format: c }),
+        accessList: w,
+        authorizationList: s,
+        blobs: l,
+        chainId: i,
+        data: y,
+        from: r == null ? void 0 : r.address,
+        gas: T,
+        gasPrice: g,
+        maxFeePerBlobGas: R,
+        maxFeePerGas: E,
+        maxPriorityFeePerGas: q,
+        nonce: P,
+        to: a,
+        value: C
+      }), b = h.get(t.uid), L = b ? "wallet_sendTransaction" : "eth_sendTransaction";
+      try {
+        return await t.request({
+          method: L,
+          params: [x]
+        }, { retryCount: 0 });
+      } catch (v) {
+        if (b === !1)
+          throw v;
+        const n = v;
+        if (n.name === "InvalidInputRpcError" || n.name === "InvalidParamsRpcError" || n.name === "MethodNotFoundRpcError" || n.name === "MethodNotSupportedRpcError")
+          return await t.request({
+            method: "wallet_sendTransaction",
+            params: [x]
+          }, { retryCount: 0 }).then((m) => (h.set(t.uid, !0), m)).catch((m) => {
+            const p = m;
+            throw p.name === "MethodNotFoundRpcError" || p.name === "MethodNotSupportedRpcError" ? (h.set(t.uid, !1), n) : p;
+          });
+        throw n;
+      }
+    }
+    if ((r == null ? void 0 : r.type) === "local") {
+      const i = await f(t, J, "prepareTransactionRequest")({
+        account: r,
+        accessList: w,
+        authorizationList: s,
+        blobs: l,
+        chain: e,
+        data: y,
+        gas: T,
+        gasPrice: g,
+        maxFeePerBlobGas: R,
+        maxFeePerGas: E,
+        maxPriorityFeePerGas: q,
+        nonce: P,
+        nonceManager: r.nonceManager,
+        parameters: [...K, "sidecars"],
+        value: C,
+        ...N,
+        to: a
+      }), c = (F = e == null ? void 0 : e.serializers) == null ? void 0 : F.transaction, I = await r.signTransaction(i, {
+        serializer: c
+      });
+      return await f(t, Q, "sendRawTransaction")({
+        serializedTransaction: I
+      });
+    }
+    throw (r == null ? void 0 : r.type) === "smart" ? new u({
+      metaMessages: [
+        "Consider using the `sendUserOperation` Action instead."
+      ],
+      docsPath: "/docs/actions/bundler/sendUserOperation",
+      type: "smart"
+    }) : new u({
+      docsPath: "/docs/actions/wallet/sendTransaction",
+      type: r == null ? void 0 : r.type
+    });
+  } catch (a) {
+    throw a instanceof u ? a : U(a, {
+      ...o,
+      account: r,
+      chain: o.chain || void 0
+    });
+  }
+}
+export {
+  dr as sendTransaction
+};

package/dist/astra-sdk.es407.js

@@ -0,0 +1,20 @@
+import { parseAccount as e } from "./astra-sdk.es393.js";
+import { AccountNotFoundError as i } from "./astra-sdk.es983.js";
+import { stringToHex as a, toHex as c } from "./astra-sdk.es416.js";
+async function g(n, { account: o = n.account, message: r }) {
+  if (!o)
+    throw new i({
+      docsPath: "/docs/actions/wallet/signMessage"
+    });
+  const t = e(o);
+  if (t.signMessage)
+    return t.signMessage({ message: r });
+  const s = typeof r == "string" ? a(r) : r.raw instanceof Uint8Array ? c(r.raw) : r.raw;
+  return n.request({
+    method: "personal_sign",
+    params: [s, t.address]
+  }, { retryCount: 0 });
+}
+export {
+  g as signMessage
+};

package/dist/astra-sdk.es408.js

@@ -0,0 +1,25 @@
+import { BaseError as r } from "./astra-sdk.es181.js";
+class n extends r {
+  constructor() {
+    super("Provider not found."), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "ProviderNotFoundError"
+    });
+  }
+}
+class u extends r {
+  constructor({ connector: t }) {
+    super(`"${t.name}" does not support programmatic chain switching.`), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "SwitchChainNotSupportedError"
+    });
+  }
+}
+export {
+  n as ProviderNotFoundError,
+  u as SwitchChainNotSupportedError
+};

package/dist/astra-sdk.es409.js

@@ -0,0 +1,72 @@
+import { getAction as u } from "./astra-sdk.es577.js";
+import { observe as p } from "./astra-sdk.es979.js";
+import { poll as d } from "./astra-sdk.es980.js";
+import { stringify as h } from "./astra-sdk.es664.js";
+import { createPendingTransactionFilter as P } from "./astra-sdk.es611.js";
+import { getFilterChanges as m } from "./astra-sdk.es622.js";
+import { uninstallFilter as w } from "./astra-sdk.es631.js";
+function I(e, { batch: l = !0, onError: s, onTransactions: f, poll: g, pollingInterval: b = e.pollingInterval }) {
+  return (typeof g < "u" ? g : e.transport.type !== "webSocket") ? (() => {
+    const r = h([
+      "watchPendingTransactions",
+      e.uid,
+      l,
+      b
+    ]);
+    return p(r, { onTransactions: f, onError: s }, (n) => {
+      let t;
+      const a = d(async () => {
+        var c;
+        try {
+          if (!t)
+            try {
+              t = await u(e, P, "createPendingTransactionFilter")({});
+              return;
+            } catch (o) {
+              throw a(), o;
+            }
+          const i = await u(e, m, "getFilterChanges")({ filter: t });
+          if (i.length === 0)
+            return;
+          if (l)
+            n.onTransactions(i);
+          else
+            for (const o of i)
+              n.onTransactions([o]);
+        } catch (i) {
+          (c = n.onError) == null || c.call(n, i);
+        }
+      }, {
+        emitOnBegin: !0,
+        interval: b
+      });
+      return async () => {
+        t && await u(e, w, "uninstallFilter")({ filter: t }), a();
+      };
+    });
+  })() : (() => {
+    let r = !0, n = () => r = !1;
+    return (async () => {
+      try {
+        const { unsubscribe: t } = await e.transport.subscribe({
+          params: ["newPendingTransactions"],
+          onData(a) {
+            if (!r)
+              return;
+            const c = a.result;
+            f([c]);
+          },
+          onError(a) {
+            s == null || s(a);
+          }
+        });
+        n = t, r || n();
+      } catch (t) {
+        s == null || s(t);
+      }
+    })(), () => n();
+  })();
+}
+export {
+  I as watchPendingTransactions
+};

package/dist/astra-sdk.es41.js

@@ -0,0 +1,26 @@
+import { MODAL_DISPLAY_TYPE as a } from "./astra-sdk.es43.js";
+import { create as s } from "./astra-sdk.es175.js";
+const A = s((e) => ({
+  astraApiUrl: "",
+  setAstrApiUrl: (r) => e({ astraApiUrl: r }),
+  targetNetwork: null,
+  setTargetNetwork: (r) => e({ targetNetwork: r }),
+  currentAssetPair: null,
+  setCurrentAssetPair: (r) => e({ currentAssetPair: r }),
+  allAssetPairs: [],
+  setAllAssetPairs: (r) => e({ allAssetPairs: r }),
+  astraModalShow: !1,
+  setAstraModalShow: (r) => e({ astraModalShow: r }),
+  receiveArgs: null,
+  setReceiveArgs: (r) => e({ receiveArgs: r }),
+  sendArgs: null,
+  setSendArgs: (r) => e({ sendArgs: r }),
+  modalDisplayType: a.DEFAULT,
+  setModalDisplayType: (r) => e({ modalDisplayType: r }),
+  onAstraInvoice: null,
+  wagmiAdapter: null,
+  setWagmiAdapter: (r) => e({ wagmiAdapter: r })
+}));
+export {
+  A as default
+};