@coinbase/cdp-core 0.0.48 → 0.0.50

package/dist/esm/index.web109.js

@@ -1,7 +1,106 @@
-const e = 32, s = 4096, t = 131072, l = 761855;
+import { HashMD as D, SHA256_IV as b, Chi as g, Maj as p } from "./index.web118.js";
+import { createHasher as u, clean as C, rotr as i } from "./index.web108.js";
+const B = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]), h = /* @__PURE__ */ new Uint32Array(64);
+class E extends D {
+  constructor(o = 32) {
+    super(64, o, 8, !1), this.A = b[0] | 0, this.B = b[1] | 0, this.C = b[2] | 0, this.D = b[3] | 0, this.E = b[4] | 0, this.F = b[5] | 0, this.G = b[6] | 0, this.H = b[7] | 0;
+  }
+  get() {
+    const { A: o, B: r, C: t, D: s, E: a, F: f, G: c, H: e } = this;
+    return [o, r, t, s, a, f, c, e];
+  }
+  // prettier-ignore
+  set(o, r, t, s, a, f, c, e) {
+    this.A = o | 0, this.B = r | 0, this.C = t | 0, this.D = s | 0, this.E = a | 0, this.F = f | 0, this.G = c | 0, this.H = e | 0;
+  }
+  process(o, r) {
+    for (let x = 0; x < 16; x++, r += 4)
+      h[x] = o.getUint32(r, !1);
+    for (let x = 16; x < 64; x++) {
+      const H = h[x - 15], d = h[x - 2], m = i(H, 7) ^ i(H, 18) ^ H >>> 3, l = i(d, 17) ^ i(d, 19) ^ d >>> 10;
+      h[x] = l + h[x - 7] + m + h[x - 16] | 0;
+    }
+    let { A: t, B: s, C: a, D: f, E: c, F: e, G: n, H: A } = this;
+    for (let x = 0; x < 64; x++) {
+      const H = i(c, 6) ^ i(c, 11) ^ i(c, 25), d = A + H + g(c, e, n) + B[x] + h[x] | 0, l = (i(t, 2) ^ i(t, 13) ^ i(t, 22)) + p(t, s, a) | 0;
+      A = n, n = e, e = c, c = f + d | 0, f = a, a = s, s = t, t = d + l | 0;
+    }
+    t = t + this.A | 0, s = s + this.B | 0, a = a + this.C | 0, f = f + this.D | 0, c = c + this.E | 0, e = e + this.F | 0, n = n + this.G | 0, A = A + this.H | 0, this.set(t, s, a, f, c, e, n, A);
+  }
+  roundClean() {
+    C(h);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0), C(this.buffer);
+  }
+}
+const y = /* @__PURE__ */ u(() => new E());
 export {
-  t as bytesPerBlob,
-  e as bytesPerFieldElement,
-  s as fieldElementsPerBlob,
-  l as maxBytesPerTransaction
+  E as SHA256,
+  y as sha256
 };

package/dist/esm/index.web11.js

@@ -1,29 +1,29 @@
-import { Provider as h } from "ox";
-import { http as m } from "viem";
-import { createStore as p } from "zustand";
-import { subscribeWithSelector as g, persist as f, createJSONStorage as S } from "./index.web31.js";
-import { validateRequest as I, EIP1193ProviderError as w, STANDARD_ERROR_CODES as C } from "./index.web12.js";
-import { EventEmitter as b } from "./index.web32.js";
-import { getPlatformStorage as _ } from "./index.web2.js";
+import { DisconnectedError as u, from as m } from "./index.web32.js";
+import { http as p } from "viem";
+import { createStore as g } from "zustand";
+import { subscribeWithSelector as f, persist as S, createJSONStorage as I } from "./index.web33.js";
+import { validateRequest as w, EIP1193ProviderError as C, STANDARD_ERROR_CODES as b } from "./index.web12.js";
+import { EventEmitter as _ } from "./index.web34.js";
+import { getPlatformStorage as A } from "./index.web2.js";
 import "@coinbase/cdp-api-client";
-import { handleGetCapabilities as A, handleGetCallsStatus as v, handleSendCalls as D, handleChainId as P, handleSignTypedData as E, handleEthSign as R, handleSwitchEthereumChain as y, handleDisconnect as T, handleSendTransaction as q, handlePersonalSign as N, handleRequestAccounts as O, handleAccounts as G } from "./index.web33.js";
-import { onAuthStateChange as L } from "./index.web6.js";
-import { baseSepolia as l } from "./index.web34.js";
-function M(r, n, s) {
+import { handleGetCapabilities as v, handleGetCallsStatus as D, handleSendCalls as E, handleChainId as P, handleSignTypedData as R, handleEthSign as y, handleSwitchEthereumChain as T, handleDisconnect as q, handleSendTransaction as N, handlePersonalSign as O, handleRequestAccounts as G, handleAccounts as L } from "./index.web35.js";
+import { onAuthStateChange as M } from "./index.web6.js";
+import { baseSepolia as h } from "./index.web36.js";
+function W(r, n, s) {
   n.subscribe(
-    (t) => t.chainId,
-    (t, e) => {
-      t !== e && r.emit("chainChanged", t);
+    (e) => e.chainId,
+    (e, t) => {
+      e !== t && r.emit("chainChanged", e);
     }
   ), n.subscribe(
-    (t) => t.user,
-    (t, e) => {
-      if (!(t?.userId === e?.userId && t?.evmAccounts?.length === e?.evmAccounts?.length)) {
-        if (!t && e) {
-          r.emit("disconnect", new h.DisconnectedError());
+    (e) => e.user,
+    (e, t) => {
+      if (!(e?.userId === t?.userId && e?.evmAccounts?.length === t?.evmAccounts?.length)) {
+        if (!e && t) {
+          r.emit("disconnect", new u());
           return;
         }
-        if (t && t.evmAccounts?.length && (!e || e.evmAccounts?.length === 0)) {
+        if (e && e.evmAccounts?.length && (!t || t.evmAccounts?.length === 0)) {
           const a = n.getState().chainId;
           r.emit("connect", { chainId: a });
           return;
@@ -32,40 +32,40 @@ function M(r, n, s) {
     }
   );
   const { chainId: i, setChainId: o } = n.getState(), d = i || s.chains[0].id;
-  return i || o(d), h.from({
-    request: async (t) => {
-      I(t, s);
-      const e = t;
-      switch (e.method) {
+  return i || o(d), m({
+    request: async (e) => {
+      w(e, s);
+      const t = e;
+      switch (t.method) {
         case "eth_accounts":
-          return G();
+          return L();
         case "eth_requestAccounts":
-          return O(r, n);
+          return G(r, n);
         case "personal_sign":
-          return N(e.params);
+          return O(t.params);
         case "eth_sendTransaction":
-          return q(e.params, n, s.transports);
+          return N(t.params, n, s.transports);
         case "wallet_disconnect":
-          return T();
+          return q();
         case "wallet_switchEthereumChain":
-          return y(e.params, n);
+          return T(t.params, n);
         case "eth_sign":
-          return R(e.params);
+          return y(t.params);
         case "eth_signTypedData_v4":
-          return E(e.params);
+          return R(t.params);
         case "eth_chainId":
           return P(n);
         case "wallet_sendCalls":
-          return D(e.params, n);
+          return E(t.params, n);
         case "wallet_getCallsStatus":
-          return v(e.params, n);
+          return D(t.params, n);
         case "wallet_getCapabilities":
-          return A();
+          return v();
         // Catch-all for any unknown method
         default:
-          throw new w(
-            C.provider.unsupportedMethod,
-            `Method ${e.method} not supported`
+          throw new C(
+            b.provider.unsupportedMethod,
+            `Method ${t.method} not supported`
           );
       }
     },
@@ -74,48 +74,48 @@ function M(r, n, s) {
     removeListener: r.removeListener.bind(r)
   });
 }
-const u = {
-  chains: [l],
+const l = {
+  chains: [h],
   transports: {
-    [l.id]: m()
+    [h.id]: p()
   }
 };
-function Q(r) {
+function V(r) {
   if (r?.chains.length === 0)
     throw new Error("At least one chain must be configured");
-  const n = r?.chains ?? u.chains, s = r?.transports ?? u.transports;
+  const n = r?.chains ?? l.chains, s = r?.transports ?? l.transports;
   if (n.length === 0)
     throw new Error("No chains found in configuration");
-  const i = new b(), o = _(), d = {
-    getItem: (e) => o.getItem(e),
-    setItem: (e, a) => o.setItem(e, a),
-    removeItem: (e) => o.removeItem(e)
-  }, c = p()(
-    g(
-      f(
-        (e) => ({
+  const i = new _(), o = A(), d = {
+    getItem: (t) => o.getItem(t),
+    setItem: (t, a) => o.setItem(t, a),
+    removeItem: (t) => o.removeItem(t)
+  }, c = g()(
+    f(
+      S(
+        (t) => ({
           chainId: n[0].id,
-          setChainId: (a) => e({ chainId: a }),
+          setChainId: (a) => t({ chainId: a }),
           chains: n,
           user: null,
-          setUser: (a) => e({ user: a })
+          setUser: (a) => t({ user: a })
         }),
         {
           name: "cdp-provider-store",
-          storage: S(() => d)
+          storage: I(() => d)
         }
       )
     )
   );
-  return c.persist.rehydrate(), L((e) => {
-    c.getState().setUser(e);
+  return c.persist.rehydrate(), M((t) => {
+    c.getState().setUser(t);
   }), {
-    provider: M(i, c, {
+    provider: W(i, c, {
       chains: n,
       transports: s
     })
   };
 }
 export {
-  Q as createCDPEmbeddedWallet
+  V as createCDPEmbeddedWallet
 };

package/dist/esm/index.web110.js

@@ -1,20 +1,35 @@
-function o(t) {
-  if (Uint8Array.prototype.toBase64)
-    return t.toBase64();
-  const e = 32768, n = [];
-  for (let r = 0; r < t.length; r += e)
-    n.push(String.fromCharCode.apply(null, t.subarray(r, r + e)));
-  return btoa(n.join(""));
-}
-function a(t) {
-  if (Uint8Array.fromBase64)
-    return Uint8Array.fromBase64(t);
-  const e = atob(t), n = new Uint8Array(e.length);
-  for (let r = 0; r < e.length; r++)
-    n[r] = e.charCodeAt(r);
-  return n;
+import { maxBytesPerTransaction as y, bytesPerBlob as a, fieldElementsPerBlob as f, bytesPerFieldElement as p } from "./index.web123.js";
+import { EmptyBlobError as c, BlobSizeTooLargeError as h } from "./index.web80.js";
+import { createCursor as B } from "./index.web69.js";
+import { size as u } from "./index.web58.js";
+import { hexToBytes as x } from "./index.web50.js";
+import { bytesToHex as d } from "./index.web48.js";
+function S(e) {
+  const m = e.to ?? (typeof e.data == "string" ? "hex" : "bytes"), i = typeof e.data == "string" ? x(e.data) : e.data, o = u(i);
+  if (!o)
+    throw new c();
+  if (o > y)
+    throw new h({
+      maxSize: y,
+      size: o
+    });
+  const s = [];
+  let n = !0, r = 0;
+  for (; n; ) {
+    const t = B(new Uint8Array(a));
+    let l = 0;
+    for (; l < f; ) {
+      const b = i.slice(r, r + (p - 1));
+      if (t.pushByte(0), t.pushBytes(b), b.length < 31) {
+        t.pushByte(128), n = !1;
+        break;
+      }
+      l++, r += 31;
+    }
+    s.push(t);
+  }
+  return m === "bytes" ? s.map((t) => t.bytes) : s.map((t) => d(t.bytes));
 }
 export {
-  a as decodeBase64,
-  o as encodeBase64
+  S as toBlobs
 };

package/dist/esm/index.web111.js

@@ -1,30 +1,9 @@
-import { JOSENotSupported as r } from "./index.web40.js";
-const S = (e, s) => {
-  const a = `SHA-${e.slice(-3)}`;
-  switch (e) {
-    case "HS256":
-    case "HS384":
-    case "HS512":
-      return { hash: a, name: "HMAC" };
-    case "PS256":
-    case "PS384":
-    case "PS512":
-      return { hash: a, name: "RSA-PSS", saltLength: parseInt(e.slice(-3), 10) >> 3 };
-    case "RS256":
-    case "RS384":
-    case "RS512":
-      return { hash: a, name: "RSASSA-PKCS1-v1_5" };
-    case "ES256":
-    case "ES384":
-    case "ES512":
-      return { hash: a, name: "ECDSA", namedCurve: s.namedCurve };
-    case "Ed25519":
-    case "EdDSA":
-      return { name: "Ed25519" };
-    default:
-      throw new r(`alg ${e} is not supported either by JOSE or your javascript runtime`);
-  }
-};
+import { bytesToHex as i } from "./index.web48.js";
+import { sha256 as m } from "./index.web72.js";
+function f(t) {
+  const { commitment: e, version: s = 1 } = t, n = t.to ?? (typeof e == "string" ? "hex" : "bytes"), o = m(e);
+  return o.set([s], 0), n === "bytes" ? o : i(o);
+}
 export {
-  S as default
+  f as commitmentToVersionedHash
 };

package/dist/esm/index.web112.js

@@ -1,10 +1,23 @@
-const o = (t, r) => {
-  if (t.startsWith("RS") || t.startsWith("PS")) {
-    const { modulusLength: e } = r.algorithm;
-    if (typeof e != "number" || e < 2048)
-      throw new TypeError(`${t} requires key modulusLength to be 2048 bits or larger`);
+import { encoder as t, decoder as o } from "./index.web92.js";
+import { encodeBase64 as c, decodeBase64 as a } from "./index.web124.js";
+function i(r) {
+  if (Uint8Array.fromBase64)
+    return Uint8Array.fromBase64(typeof r == "string" ? r : o.decode(r), {
+      alphabet: "base64url"
+    });
+  let e = r;
+  e instanceof Uint8Array && (e = o.decode(e)), e = e.replace(/-/g, "+").replace(/_/g, "/").replace(/\s/g, "");
+  try {
+    return a(e);
+  } catch {
+    throw new TypeError("The input to be decoded is not correctly encoded.");
   }
-};
+}
+function p(r) {
+  let e = r;
+  return typeof e == "string" && (e = t.encode(e)), Uint8Array.prototype.toBase64 ? e.toBase64({ alphabet: "base64url", omitPadding: !0 }) : c(e).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
 export {
-  o as default
+  i as decode,
+  p as encode
 };

package/dist/esm/index.web113.js

@@ -1,13 +1,12 @@
-import { checkSigCryptoKey as i } from "./index.web121.js";
-import o from "./index.web114.js";
-const s = async (t, r, e) => {
-  if (r instanceof Uint8Array) {
-    if (!t.startsWith("HS"))
-      throw new TypeError(o(r, "CryptoKey", "KeyObject", "JSON Web Key"));
-    return crypto.subtle.importKey("raw", r, { hash: `SHA-${t.slice(-3)}`, name: "HMAC" }, !1, [e]);
-  }
-  return i(r, t, e), r;
+import n from "./index.web125.js";
+import s from "./index.web126.js";
+import a from "./index.web127.js";
+const y = async (t, o, e) => {
+  const r = await a(t, o, "sign");
+  s(t, r);
+  const i = await crypto.subtle.sign(n(t, r.algorithm), r, e);
+  return new Uint8Array(i);
 };
 export {
-  s as default
+  y as default
 };

package/dist/esm/index.web114.js

@@ -1,15 +1,22 @@
-function i(n, e, ...o) {
-  if (o = o.filter(Boolean), o.length > 2) {
-    const f = o.pop();
-    n += `one of type ${o.join(", ")}, or ${f}.`;
-  } else o.length === 2 ? n += `one of type ${o[0]} or ${o[1]}.` : n += `of type ${o[0]}.`;
-  return e == null ? n += ` Received ${e}` : typeof e == "function" && e.name ? n += ` Received function ${e.name}` : typeof e == "object" && e != null && e.constructor?.name && (n += ` Received an instance of ${e.constructor.name}`), n;
-}
-const r = (n, ...e) => i("Key must be ", n, ...e);
-function t(n, e, ...o) {
-  return i(`Key for the ${n} algorithm must be `, e, ...o);
-}
+const a = (...o) => {
+  const t = o.filter(Boolean);
+  if (t.length === 0 || t.length === 1)
+    return !0;
+  let e;
+  for (const s of t) {
+    const r = Object.keys(s);
+    if (!e || e.size === 0) {
+      e = new Set(r);
+      continue;
+    }
+    for (const n of r) {
+      if (e.has(n))
+        return !1;
+      e.add(n);
+    }
+  }
+  return !0;
+};
 export {
-  r as default,
-  t as withAlg
+  a as default
 };

package/dist/esm/index.web115.js

@@ -1,12 +1,96 @@
-function e(t) {
-  return t?.[Symbol.toStringTag] === "CryptoKey";
-}
-function r(t) {
-  return t?.[Symbol.toStringTag] === "KeyObject";
-}
-const n = (t) => e(t) || r(t);
+import { withAlg as n } from "./index.web128.js";
+import c from "./index.web129.js";
+import { isJWK as p, isSecretJWK as a, isPublicJWK as y, isPrivateJWK as f } from "./index.web130.js";
+const s = (r) => r?.[Symbol.toStringTag], o = (r, e, t) => {
+  if (e.use !== void 0) {
+    let i;
+    switch (t) {
+      case "sign":
+      case "verify":
+        i = "sig";
+        break;
+      case "encrypt":
+      case "decrypt":
+        i = "enc";
+        break;
+    }
+    if (e.use !== i)
+      throw new TypeError(`Invalid key for this operation, its "use" must be "${i}" when present`);
+  }
+  if (e.alg !== void 0 && e.alg !== r)
+    throw new TypeError(`Invalid key for this operation, its "alg" must be "${r}" when present`);
+  if (Array.isArray(e.key_ops)) {
+    let i;
+    switch (!0) {
+      case t === "sign":
+      case r === "dir":
+      case r.includes("CBC-HS"):
+        i = t;
+        break;
+      case r.startsWith("PBES2"):
+        i = "deriveBits";
+        break;
+      case /^A\d{3}(?:GCM)?(?:KW)?$/.test(r):
+        !r.includes("GCM") && r.endsWith("KW") ? i = "unwrapKey" : i = t;
+        break;
+      case t === "encrypt":
+        i = "wrapKey";
+        break;
+      case t === "decrypt":
+        i = r.startsWith("RSA") ? "unwrapKey" : "deriveBits";
+        break;
+    }
+    if (i && e.key_ops?.includes?.(i) === !1)
+      throw new TypeError(`Invalid key for this operation, its "key_ops" must include "${i}" when present`);
+  }
+  return !0;
+}, h = (r, e, t) => {
+  if (!(e instanceof Uint8Array)) {
+    if (p(e)) {
+      if (a(e) && o(r, e, t))
+        return;
+      throw new TypeError('JSON Web Key for symmetric algorithms must have JWK "kty" (Key Type) equal to "oct" and the JWK "k" (Key Value) present');
+    }
+    if (!c(e))
+      throw new TypeError(n(r, e, "CryptoKey", "KeyObject", "JSON Web Key", "Uint8Array"));
+    if (e.type !== "secret")
+      throw new TypeError(`${s(e)} instances for symmetric algorithms must be of type "secret"`);
+  }
+}, m = (r, e, t) => {
+  if (p(e))
+    switch (t) {
+      case "decrypt":
+      case "sign":
+        if (f(e) && o(r, e, t))
+          return;
+        throw new TypeError("JSON Web Key for this operation be a private JWK");
+      case "encrypt":
+      case "verify":
+        if (y(e) && o(r, e, t))
+          return;
+        throw new TypeError("JSON Web Key for this operation be a public JWK");
+    }
+  if (!c(e))
+    throw new TypeError(n(r, e, "CryptoKey", "KeyObject", "JSON Web Key"));
+  if (e.type === "secret")
+    throw new TypeError(`${s(e)} instances for asymmetric algorithms must not be of type "secret"`);
+  if (e.type === "public")
+    switch (t) {
+      case "sign":
+        throw new TypeError(`${s(e)} instances for asymmetric algorithm signing must be of type "private"`);
+      case "decrypt":
+        throw new TypeError(`${s(e)} instances for asymmetric algorithm decryption must be of type "private"`);
+    }
+  if (e.type === "private")
+    switch (t) {
+      case "verify":
+        throw new TypeError(`${s(e)} instances for asymmetric algorithm verifying must be of type "public"`);
+      case "encrypt":
+        throw new TypeError(`${s(e)} instances for asymmetric algorithm encryption must be of type "public"`);
+    }
+}, d = (r, e, t) => {
+  r.startsWith("HS") || r === "dir" || r.startsWith("PBES2") || /^A(?:128|192|256)(?:GCM)?(?:KW)?$/.test(r) || /^A(?:128|192|256)CBC-HS(?:256|384|512)$/.test(r) ? h(r, e, t) : m(r, e, t);
+};
 export {
-  n as default,
-  e as isCryptoKey,
-  r as isKeyObject
+  d as default
 };

package/dist/esm/index.web116.js

@@ -1,19 +1,23 @@
-import n from "./index.web93.js";
-function r(t) {
-  return n(t) && typeof t.kty == "string";
-}
-function o(t) {
-  return t.kty !== "oct" && typeof t.d == "string";
-}
-function e(t) {
-  return t.kty !== "oct" && typeof t.d > "u";
-}
-function c(t) {
-  return t.kty === "oct" && typeof t.k == "string";
-}
+import { JOSENotSupported as f } from "./index.web42.js";
+const w = (n, r, a, e, s) => {
+  if (s.crit !== void 0 && e?.crit === void 0)
+    throw new n('"crit" (Critical) Header Parameter MUST be integrity protected');
+  if (!e || e.crit === void 0)
+    return /* @__PURE__ */ new Set();
+  if (!Array.isArray(e.crit) || e.crit.length === 0 || e.crit.some((i) => typeof i != "string" || i.length === 0))
+    throw new n('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present');
+  let t;
+  a !== void 0 ? t = new Map([...Object.entries(a), ...r.entries()]) : t = r;
+  for (const i of e.crit) {
+    if (!t.has(i))
+      throw new f(`Extension Header Parameter "${i}" is not recognized`);
+    if (s[i] === void 0)
+      throw new n(`Extension Header Parameter "${i}" is missing`);
+    if (t.get(i) && e[i] === void 0)
+      throw new n(`Extension Header Parameter "${i}" MUST be integrity protected`);
+  }
+  return new Set(e.crit);
+};
 export {
-  r as isJWK,
-  o as isPrivateJWK,
-  e as isPublicJWK,
-  c as isSecretJWK
+  w as default
 };