@coinbase/cdp-core 0.0.24 → 0.0.26

package/dist/esm/index.native5.js

@@ -0,0 +1,256 @@
+import { configureCdpApiClient as A, setAuthManager as v, initiateAuthentication as S, createEndUserEvmAccount as E, createEndUserEvmSmartAccount as p, verifyEmailAuthentication as k, verifySmsAuthentication as U, signEvmHashWithEndUserAccount as M, signEvmTransactionWithEndUserAccount as T, sendEvmTransactionWithEndUserAccount as P, signEvmMessageWithEndUserAccount as j, signEvmTypedDataWithEndUserAccount as C, sendUserOperationWithEndUserAccount as O, getUserOperationWithEndUserAccount as x, exportEndUserEvmAccount as H } from "@coinbase/cdp-api-client";
+import { AuthManager as W } from "./index.native6.js";
+import { toAuthState as m } from "./index.native13.js";
+import { withAuth as o } from "./index.native14.js";
+import { MockAuthManager as b } from "./index.native15.js";
+import { mockUser as h } from "./index.native16.js";
+import { getPlatformCrypto as K } from "./index.native4.js";
+import { isChainSupportedForCDPSends as D } from "./index.native17.js";
+import { getConfig as t, setCoreAuthManager as w, getCoreAuthManager as s, setConfig as z } from "./index.native18.js";
+import "viem";
+import { serializeTransaction as y } from "./index.native19.js";
+const Y = async (e) => {
+  if (!e.projectId)
+    throw new Error("Project ID is required");
+  let n;
+  try {
+    n = t().projectId !== e.projectId;
+  } catch {
+    n = !0;
+  }
+  if (z(e), t().useMock) {
+    w(new b(t().projectId));
+    return;
+  }
+  if (A({
+    debugging: t().debugging,
+    basePath: t().basePath
+  }), n) {
+    const r = new W(t().projectId);
+    w(r), v(r);
+  }
+  await s().ensureInitialized();
+}, Z = async (e) => l({
+  email: e.email,
+  type: "email"
+}), _ = async (e) => l({
+  phoneNumber: e.phoneNumber,
+  type: "sms"
+}), ee = async (e) => f(
+  e,
+  "Mock email OTP verified",
+  (n, r) => k(n, r)
+), te = async (e) => f(
+  e,
+  "Mock SMS OTP verified",
+  (n, r) => U(n, r)
+), re = async () => s().getUser(), ne = async () => s().isSignedIn(), se = async () => {
+  if (t().useMock) {
+    await s().signOut();
+    return;
+  }
+  if (!await s().isSignedIn())
+    throw new Error("User not signed in");
+  await s().signOut();
+}, ae = async () => s().getToken(), ce = (e) => {
+  s().addAuthStateChangeCallback(e);
+}, ie = async (e) => t().useMock ? { signature: "0x0" } : o(e, s(), async ({ user: n, walletSecretId: r }) => ({
+  signature: (await M(t().projectId, n.userId, {
+    hash: e.hash,
+    address: e.evmAccount,
+    walletSecretId: r
+  })).signature
+})), oe = async (e) => t().useMock ? { signedTransaction: "0x0" } : o(e, s(), async ({ user: n, walletSecretId: r }) => {
+  const i = y(e.transaction);
+  return {
+    signedTransaction: (await T(
+      t().projectId,
+      n.userId,
+      {
+        transaction: i,
+        address: e.evmAccount,
+        walletSecretId: r
+      }
+    )).signedTransaction
+  };
+}), ue = async (e) => {
+  if (!D(e.network))
+    throw new Error(`Chain ${e.network} is not supported by the CDP Apis`);
+  if (t().useMock)
+    return { transactionHash: "0x0" };
+  const n = y(e.transaction);
+  return o(e, s(), async ({ user: r, walletSecretId: i }) => ({
+    transactionHash: (await P(
+      t().projectId,
+      r.userId,
+      {
+        transaction: n,
+        address: e.evmAccount,
+        walletSecretId: i,
+        network: e.network
+      }
+    )).transactionHash
+  }));
+}, de = async (e) => t().useMock ? { signature: "0x0" } : o(e, s(), async ({ user: n, walletSecretId: r }) => ({
+  signature: (await j(t().projectId, n.userId, {
+    message: e.message,
+    address: e.evmAccount,
+    walletSecretId: r
+  })).signature
+})), me = async (e) => t().useMock ? { signature: "0x0" } : o(e, s(), async ({ user: n, walletSecretId: r }) => ({
+  signature: (await C(t().projectId, n.userId, {
+    typedData: e.typedData,
+    address: e.evmAccount,
+    walletSecretId: r
+  })).signature
+})), ge = async (e) => t().useMock ? {
+  userOperationHash: "0x1234567890123456789012345678901234567890123456789012345678901234"
+} : o(e, s(), async ({ user: n, walletSecretId: r }) => ({
+  userOperationHash: (await O(
+    t().projectId,
+    n.userId,
+    e.evmSmartAccount,
+    {
+      network: e.network,
+      calls: e.calls.map((a) => ({
+        to: a.to,
+        value: String(a.value ?? 0n),
+        data: a.data ?? "0x"
+      })),
+      walletSecretId: r,
+      useCdpPaymaster: e.useCdpPaymaster ?? !1,
+      paymasterUrl: e.paymasterUrl
+    }
+  )).userOpHash
+})), pe = async (e) => t().useMock ? {
+  userOpHash: e.userOperationHash,
+  network: e.network,
+  calls: [
+    {
+      to: "0x1234567890123456789012345678901234567890",
+      value: "0",
+      data: "0x"
+    }
+  ],
+  status: "complete",
+  transactionHash: "0x9876543210987654321098765432109876543210987654321098765432109876",
+  receipts: []
+} : o(e, s(), async ({ user: n }) => await x(
+  t().projectId,
+  n.userId,
+  e.evmSmartAccount,
+  e.userOperationHash
+)), he = async (e) => {
+  if (t().useMock)
+    return {
+      privateKey: "mock-private-key"
+    };
+  const n = K(), r = await n.createExportKeyPair();
+  return o(e, s(), async ({ user: i, walletSecretId: a }) => {
+    const c = await H(t().projectId, i.userId, {
+      address: e.evmAccount,
+      walletSecretId: a,
+      exportEncryptionKey: r.publicKeyBase64
+    });
+    return {
+      privateKey: await n.decryptWithPrivateKey(
+        r.privateKey,
+        c.encryptedPrivateKey
+      )
+    };
+  });
+}, l = async (e) => {
+  if (t().useMock)
+    return {
+      message: "Mock sign in initiated",
+      flowId: "mock-flow-id"
+    };
+  if (await s().isSignedIn())
+    throw new Error("User is already authenticated. Please sign out first.");
+  const r = await S(t().projectId, e);
+  return {
+    flowId: r.flowId,
+    message: r.message
+  };
+}, f = async (e, n, r) => {
+  if (t().useMock)
+    return await s().setAuthState({
+      accessToken: "mock-access-token",
+      expiresAt: Date.now() + 1e3 * 60 * 60 * 24,
+      user: h
+    }), {
+      message: n,
+      user: h,
+      isNewUser: !1
+    };
+  if (await s().isSignedIn())
+    throw new Error("User is already authenticated. Please sign out first.");
+  const a = await r(t().projectId, {
+    flowId: e.flowId,
+    otp: e.otp
+  });
+  let c = m(a.accessToken, a.validUntil, a.endUser);
+  if (await s().setAuthState(c), !c.user.evmAccounts || c.user.evmAccounts.length === 0)
+    try {
+      const u = await s().getWalletSecretId();
+      let d = await E(t().projectId, c.user.userId, {
+        walletSecretId: u
+      });
+      if (t().createAccountOnLogin === "evm-smart") {
+        const [I] = d.evmAccounts;
+        d = await p(
+          t().projectId,
+          c.user.userId,
+          {
+            owner: I,
+            enableSpendPermissions: !1
+            // Defaulting to false until the feature is ready.
+          }
+        );
+      }
+      c = m(a.accessToken, a.validUntil, d), await s().setAuthState(c);
+    } catch (u) {
+      throw new Error(`Failed to create EVM account: ${u}`);
+    }
+  if (t().createAccountOnLogin === "evm-smart" && (!c.user.evmSmartAccounts || c.user.evmSmartAccounts.length === 0))
+    try {
+      const [u] = c.user.evmAccounts, d = await p(
+        t().projectId,
+        c.user.userId,
+        {
+          owner: u,
+          enableSpendPermissions: !1
+          // Defaulting to false until the feature is ready.
+        }
+      );
+      c = m(a.accessToken, a.validUntil, d), await s().setAuthState(c);
+    } catch (u) {
+      throw new Error(`Failed to create EVM Smart Account: ${u}`);
+    }
+  const g = await s().getUser();
+  return {
+    message: a.message,
+    user: g,
+    isNewUser: a.isNewEndUser
+  };
+};
+export {
+  he as exportEvmAccount,
+  ae as getAccessToken,
+  re as getCurrentUser,
+  pe as getUserOperation,
+  Y as initialize,
+  ne as isSignedIn,
+  ce as onAuthStateChange,
+  ue as sendEvmTransaction,
+  ge as sendUserOperation,
+  ie as signEvmHash,
+  de as signEvmMessage,
+  oe as signEvmTransaction,
+  me as signEvmTypedData,
+  Z as signInWithEmail,
+  _ as signInWithSms,
+  se as signOut,
+  ee as verifyEmailOTP,
+  te as verifySmsOTP
+};

package/dist/esm/index.native50.js

@@ -0,0 +1,45 @@
+import { BaseError as l } from "./index.native51.js";
+import { createCursor as r } from "./index.native52.js";
+import { hexToBytes as g } from "./index.native33.js";
+import { bytesToHex as u } from "./index.native31.js";
+function m(n, e = "hex") {
+  const i = s(n), h = r(new Uint8Array(i.length));
+  return i.encode(h), e === "hex" ? u(h.bytes) : h.bytes;
+}
+function s(n) {
+  return Array.isArray(n) ? p(n.map((e) => s(e))) : y(n);
+}
+function p(n) {
+  const e = n.reduce((t, f) => t + f.length, 0), i = o(e);
+  return {
+    length: e <= 55 ? 1 + e : 1 + i + e,
+    encode(t) {
+      e <= 55 ? t.pushByte(192 + e) : (t.pushByte(247 + i), i === 1 ? t.pushUint8(e) : i === 2 ? t.pushUint16(e) : i === 3 ? t.pushUint24(e) : t.pushUint32(e));
+      for (const { encode: f } of n)
+        f(t);
+    }
+  };
+}
+function y(n) {
+  const e = typeof n == "string" ? g(n) : n, i = o(e.length);
+  return {
+    length: e.length === 1 && e[0] < 128 ? 1 : e.length <= 55 ? 1 + e.length : 1 + i + e.length,
+    encode(t) {
+      e.length === 1 && e[0] < 128 ? t.pushBytes(e) : e.length <= 55 ? (t.pushByte(128 + e.length), t.pushBytes(e)) : (t.pushByte(183 + i), i === 1 ? t.pushUint8(e.length) : i === 2 ? t.pushUint16(e.length) : i === 3 ? t.pushUint24(e.length) : t.pushUint32(e.length), t.pushBytes(e));
+    }
+  };
+}
+function o(n) {
+  if (n < 2 ** 8)
+    return 1;
+  if (n < 2 ** 16)
+    return 2;
+  if (n < 2 ** 24)
+    return 3;
+  if (n < 2 ** 32)
+    return 4;
+  throw new l("Length is too large.");
+}
+export {
+  m as toRlp
+};

package/dist/esm/index.native51.js

@@ -0,0 +1,58 @@
+import { version as o } from "./index.native79.js";
+let r = {
+  getDocsUrl: ({ docsBaseUrl: s, docsPath: t = "", docsSlug: e }) => t ? `${s ?? "https://viem.sh"}${t}${e ? `#${e}` : ""}` : void 0,
+  version: `viem@${o}`
+};
+class u extends Error {
+  constructor(t, e = {}) {
+    const i = e.cause instanceof u ? e.cause.details : e.cause?.message ? e.cause.message : e.details, n = e.cause instanceof u && e.cause.docsPath || e.docsPath, a = r.getDocsUrl?.({ ...e, docsPath: n }), l = [
+      t || "An error occurred.",
+      "",
+      ...e.metaMessages ? [...e.metaMessages, ""] : [],
+      ...a ? [`Docs: ${a}`] : [],
+      ...i ? [`Details: ${i}`] : [],
+      ...r.version ? [`Version: ${r.version}`] : []
+    ].join(`
+`);
+    super(l, e.cause ? { cause: e.cause } : void 0), Object.defineProperty(this, "details", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "docsPath", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "metaMessages", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "shortMessage", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "version", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "name", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: "BaseError"
+    }), this.details = i, this.docsPath = n, this.metaMessages = e.metaMessages, this.name = e.name ?? this.name, this.shortMessage = t, this.version = o;
+  }
+  walk(t) {
+    return c(this, t);
+  }
+}
+function c(s, t) {
+  return t?.(s) ? s : s && typeof s == "object" && "cause" in s && s.cause !== void 0 ? c(s.cause, t) : t ? null : s;
+}
+export {
+  u as BaseError
+};

package/dist/esm/index.native52.js

@@ -0,0 +1,130 @@
+import { NegativeOffsetError as o, PositionOutOfBoundsError as e, RecursiveReadLimitExceededError as n } from "./index.native80.js";
+const h = {
+  bytes: new Uint8Array(),
+  dataView: new DataView(new ArrayBuffer(0)),
+  position: 0,
+  positionReadCount: /* @__PURE__ */ new Map(),
+  recursiveReadCount: 0,
+  recursiveReadLimit: Number.POSITIVE_INFINITY,
+  assertReadLimit() {
+    if (this.recursiveReadCount >= this.recursiveReadLimit)
+      throw new n({
+        count: this.recursiveReadCount + 1,
+        limit: this.recursiveReadLimit
+      });
+  },
+  assertPosition(t) {
+    if (t < 0 || t > this.bytes.length - 1)
+      throw new e({
+        length: this.bytes.length,
+        position: t
+      });
+  },
+  decrementPosition(t) {
+    if (t < 0)
+      throw new o({ offset: t });
+    const i = this.position - t;
+    this.assertPosition(i), this.position = i;
+  },
+  getReadCount(t) {
+    return this.positionReadCount.get(t || this.position) || 0;
+  },
+  incrementPosition(t) {
+    if (t < 0)
+      throw new o({ offset: t });
+    const i = this.position + t;
+    this.assertPosition(i), this.position = i;
+  },
+  inspectByte(t) {
+    const i = t ?? this.position;
+    return this.assertPosition(i), this.bytes[i];
+  },
+  inspectBytes(t, i) {
+    const s = i ?? this.position;
+    return this.assertPosition(s + t - 1), this.bytes.subarray(s, s + t);
+  },
+  inspectUint8(t) {
+    const i = t ?? this.position;
+    return this.assertPosition(i), this.bytes[i];
+  },
+  inspectUint16(t) {
+    const i = t ?? this.position;
+    return this.assertPosition(i + 1), this.dataView.getUint16(i);
+  },
+  inspectUint24(t) {
+    const i = t ?? this.position;
+    return this.assertPosition(i + 2), (this.dataView.getUint16(i) << 8) + this.dataView.getUint8(i + 2);
+  },
+  inspectUint32(t) {
+    const i = t ?? this.position;
+    return this.assertPosition(i + 3), this.dataView.getUint32(i);
+  },
+  pushByte(t) {
+    this.assertPosition(this.position), this.bytes[this.position] = t, this.position++;
+  },
+  pushBytes(t) {
+    this.assertPosition(this.position + t.length - 1), this.bytes.set(t, this.position), this.position += t.length;
+  },
+  pushUint8(t) {
+    this.assertPosition(this.position), this.bytes[this.position] = t, this.position++;
+  },
+  pushUint16(t) {
+    this.assertPosition(this.position + 1), this.dataView.setUint16(this.position, t), this.position += 2;
+  },
+  pushUint24(t) {
+    this.assertPosition(this.position + 2), this.dataView.setUint16(this.position, t >> 8), this.dataView.setUint8(this.position + 2, t & 255), this.position += 3;
+  },
+  pushUint32(t) {
+    this.assertPosition(this.position + 3), this.dataView.setUint32(this.position, t), this.position += 4;
+  },
+  readByte() {
+    this.assertReadLimit(), this._touch();
+    const t = this.inspectByte();
+    return this.position++, t;
+  },
+  readBytes(t, i) {
+    this.assertReadLimit(), this._touch();
+    const s = this.inspectBytes(t);
+    return this.position += i ?? t, s;
+  },
+  readUint8() {
+    this.assertReadLimit(), this._touch();
+    const t = this.inspectUint8();
+    return this.position += 1, t;
+  },
+  readUint16() {
+    this.assertReadLimit(), this._touch();
+    const t = this.inspectUint16();
+    return this.position += 2, t;
+  },
+  readUint24() {
+    this.assertReadLimit(), this._touch();
+    const t = this.inspectUint24();
+    return this.position += 3, t;
+  },
+  readUint32() {
+    this.assertReadLimit(), this._touch();
+    const t = this.inspectUint32();
+    return this.position += 4, t;
+  },
+  get remaining() {
+    return this.bytes.length - this.position;
+  },
+  setPosition(t) {
+    const i = this.position;
+    return this.assertPosition(t), this.position = t, () => this.position = i;
+  },
+  _touch() {
+    if (this.recursiveReadLimit === Number.POSITIVE_INFINITY)
+      return;
+    const t = this.getReadCount();
+    this.positionReadCount.set(this.position, t + 1), t > 0 && this.recursiveReadCount++;
+  }
+};
+function a(t, { recursiveReadLimit: i = 8192 } = {}) {
+  const s = Object.create(h);
+  return s.bytes = t, s.dataView = new DataView(t.buffer, t.byteOffset, t.byteLength), s.positionReadCount = /* @__PURE__ */ new Map(), s.recursiveReadLimit = i, s;
+}
+export {
+  a as createCursor
+};

package/dist/esm/index.native53.js

@@ -0,0 +1,15 @@
+import { BaseError as t } from "./index.native51.js";
+class $ extends t {
+  constructor({ max: e, min: r, signed: s, size: n, value: a }) {
+    super(`Number "${a}" is not in safe ${n ? `${n * 8}-bit ${s ? "signed" : "unsigned"} ` : ""}integer range ${e ? `(${r} to ${e})` : `(above ${r})`}`, { name: "IntegerOutOfRangeError" });
+  }
+}
+class c extends t {
+  constructor({ givenSize: e, maxSize: r }) {
+    super(`Size cannot exceed ${r} bytes. Given size: ${e} bytes.`, { name: "SizeOverflowError" });
+  }
+}
+export {
+  $ as IntegerOutOfRangeError,
+  c as SizeOverflowError
+};

package/dist/esm/index.native54.js

@@ -0,0 +1,107 @@
+import { split as L, rotlSH as T, rotlSL as S, rotlBH as m, rotlBL as F } from "./index.native81.js";
+import { createHasher as X, Hash as E, anumber as d, u32 as U, swap32IfBE as I, aexists as x, toBytes as P, abytes as k, aoutput as M, clean as y } from "./index.native82.js";
+const R = BigInt(0), f = BigInt(1), j = BigInt(2), q = BigInt(7), v = BigInt(256), z = BigInt(113), _ = [], g = [], B = [];
+for (let n = 0, t = f, s = 1, i = 0; n < 24; n++) {
+  [s, i] = [i, (2 * s + 3 * i) % 5], _.push(2 * (5 * i + s)), g.push((n + 1) * (n + 2) / 2 % 64);
+  let o = R;
+  for (let r = 0; r < 7; r++)
+    t = (t << f ^ (t >> q) * z) % v, t & j && (o ^= f << (f << /* @__PURE__ */ BigInt(r)) - f);
+  B.push(o);
+}
+const A = L(B, !0), C = A[0], D = A[1], O = (n, t, s) => s > 32 ? m(n, t, s) : T(n, t, s), w = (n, t, s) => s > 32 ? F(n, t, s) : S(n, t, s);
+function G(n, t = 24) {
+  const s = new Uint32Array(10);
+  for (let i = 24 - t; i < 24; i++) {
+    for (let e = 0; e < 10; e++)
+      s[e] = n[e] ^ n[e + 10] ^ n[e + 20] ^ n[e + 30] ^ n[e + 40];
+    for (let e = 0; e < 10; e += 2) {
+      const h = (e + 8) % 10, l = (e + 2) % 10, u = s[l], c = s[l + 1], b = O(u, c, 1) ^ s[h], H = w(u, c, 1) ^ s[h + 1];
+      for (let a = 0; a < 50; a += 10)
+        n[e + a] ^= b, n[e + a + 1] ^= H;
+    }
+    let o = n[2], r = n[3];
+    for (let e = 0; e < 24; e++) {
+      const h = g[e], l = O(o, r, h), u = w(o, r, h), c = _[e];
+      o = n[c], r = n[c + 1], n[c] = l, n[c + 1] = u;
+    }
+    for (let e = 0; e < 50; e += 10) {
+      for (let h = 0; h < 10; h++)
+        s[h] = n[e + h];
+      for (let h = 0; h < 10; h++)
+        n[e + h] ^= ~s[(h + 2) % 10] & s[(h + 4) % 10];
+    }
+    n[0] ^= C[i], n[1] ^= D[i];
+  }
+  y(s);
+}
+class p extends E {
+  // NOTE: we accept arguments in bytes instead of bits here.
+  constructor(t, s, i, o = !1, r = 24) {
+    if (super(), this.pos = 0, this.posOut = 0, this.finished = !1, this.destroyed = !1, this.enableXOF = !1, this.blockLen = t, this.suffix = s, this.outputLen = i, this.enableXOF = o, this.rounds = r, d(i), !(0 < t && t < 200))
+      throw new Error("only keccak-f1600 function is supported");
+    this.state = new Uint8Array(200), this.state32 = U(this.state);
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  keccak() {
+    I(this.state32), G(this.state32, this.rounds), I(this.state32), this.posOut = 0, this.pos = 0;
+  }
+  update(t) {
+    x(this), t = P(t), k(t);
+    const { blockLen: s, state: i } = this, o = t.length;
+    for (let r = 0; r < o; ) {
+      const e = Math.min(s - this.pos, o - r);
+      for (let h = 0; h < e; h++)
+        i[this.pos++] ^= t[r++];
+      this.pos === s && this.keccak();
+    }
+    return this;
+  }
+  finish() {
+    if (this.finished)
+      return;
+    this.finished = !0;
+    const { state: t, suffix: s, pos: i, blockLen: o } = this;
+    t[i] ^= s, (s & 128) !== 0 && i === o - 1 && this.keccak(), t[o - 1] ^= 128, this.keccak();
+  }
+  writeInto(t) {
+    x(this, !1), k(t), this.finish();
+    const s = this.state, { blockLen: i } = this;
+    for (let o = 0, r = t.length; o < r; ) {
+      this.posOut >= i && this.keccak();
+      const e = Math.min(i - this.posOut, r - o);
+      t.set(s.subarray(this.posOut, this.posOut + e), o), this.posOut += e, o += e;
+    }
+    return t;
+  }
+  xofInto(t) {
+    if (!this.enableXOF)
+      throw new Error("XOF is not possible for this instance");
+    return this.writeInto(t);
+  }
+  xof(t) {
+    return d(t), this.xofInto(new Uint8Array(t));
+  }
+  digestInto(t) {
+    if (M(t, this), this.finished)
+      throw new Error("digest() was already called");
+    return this.writeInto(t), this.destroy(), t;
+  }
+  digest() {
+    return this.digestInto(new Uint8Array(this.outputLen));
+  }
+  destroy() {
+    this.destroyed = !0, y(this.state);
+  }
+  _cloneInto(t) {
+    const { blockLen: s, suffix: i, outputLen: o, rounds: r, enableXOF: e } = this;
+    return t || (t = new p(s, i, o, e, r)), t.state32.set(this.state32), t.pos = this.pos, t.posOut = this.posOut, t.finished = this.finished, t.rounds = r, t.suffix = i, t.outputLen = o, t.enableXOF = e, t.destroyed = this.destroyed, t;
+  }
+}
+const J = (n, t, s) => X(() => new p(t, n, s)), Q = J(1, 136, 256 / 8);
+export {
+  p as Keccak,
+  G as keccakP,
+  Q as keccak_256
+};

package/dist/esm/index.native55.js

@@ -0,0 +1,9 @@
+import { sha256 as o } from "./index.native56.js";
+import { isHex as s } from "./index.native38.js";
+import { toBytes as r } from "./index.native33.js";
+function p(t, i) {
+  return o(s(t, { strict: !1 }) ? r(t) : t);
+}
+export {
+  p as sha256
+};

package/dist/esm/index.native56.js

@@ -0,0 +1,5 @@
+import { sha256 as s } from "./index.native83.js";
+const o = s;
+export {
+  o as sha256
+};

package/dist/esm/index.native57.js

@@ -0,0 +1,17 @@
+import { InvalidSerializableTransactionError as f } from "./index.native58.js";
+function d(e) {
+  if (e.type)
+    return e.type;
+  if (typeof e.authorizationList < "u")
+    return "eip7702";
+  if (typeof e.blobs < "u" || typeof e.blobVersionedHashes < "u" || typeof e.maxFeePerBlobGas < "u" || typeof e.sidecars < "u")
+    return "eip4844";
+  if (typeof e.maxFeePerGas < "u" || typeof e.maxPriorityFeePerGas < "u")
+    return "eip1559";
+  if (typeof e.gasPrice < "u")
+    return typeof e.accessList < "u" ? "eip2930" : "legacy";
+  throw new f({ transaction: e });
+}
+export {
+  d as getTransactionType
+};

package/dist/esm/index.native58.js

@@ -0,0 +1,45 @@
+import { BaseError as t } from "./index.native51.js";
+function i(n) {
+  const r = Object.entries(n).map(([a, e]) => e === void 0 || e === !1 ? null : [a, e]).filter(Boolean), o = r.reduce((a, [e]) => Math.max(a, e.length), 0);
+  return r.map(([a, e]) => `  ${`${a}:`.padEnd(o + 1)}  ${e}`).join(`
+`);
+}
+class c extends t {
+  constructor({ v: r }) {
+    super(`Invalid \`v\` value "${r}". Expected 27 or 28.`, {
+      name: "InvalidLegacyVError"
+    });
+  }
+}
+class d extends t {
+  constructor({ transaction: r }) {
+    super("Cannot infer a transaction type from provided transaction.", {
+      metaMessages: [
+        "Provided Transaction:",
+        "{",
+        i(r),
+        "}",
+        "",
+        "To infer the type, either provide:",
+        "- a `type` to the Transaction, or",
+        "- an EIP-1559 Transaction with `maxFeePerGas`, or",
+        "- an EIP-2930 Transaction with `gasPrice` & `accessList`, or",
+        "- an EIP-4844 Transaction with `blobs`, `blobVersionedHashes`, `sidecars`, or",
+        "- an EIP-7702 Transaction with `authorizationList`, or",
+        "- a Legacy Transaction with `gasPrice`"
+      ],
+      name: "InvalidSerializableTransactionError"
+    });
+  }
+}
+class l extends t {
+  constructor({ storageKey: r }) {
+    super(`Size for storage key "${r}" is invalid. Expected 32 bytes. Got ${Math.floor((r.length - 2) / 2)} bytes.`, { name: "InvalidStorageKeySizeError" });
+  }
+}
+export {
+  c as InvalidLegacyVError,
+  d as InvalidSerializableTransactionError,
+  l as InvalidStorageKeySizeError,
+  i as prettyPrint
+};