@coinbase/cdp-core 0.0.49 → 0.0.50

package/dist/native/index.native119.js

@@ -1,15 +1,7 @@
-const s = {
-  gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
-  l1Block: { address: "0x4200000000000000000000000000000000000015" },
-  l2CrossDomainMessenger: {
-    address: "0x4200000000000000000000000000000000000007"
-  },
-  l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
-  l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
-  l2ToL1MessagePasser: {
-    address: "0x4200000000000000000000000000000000000016"
-  }
-};
+import { version as r } from "./index.native133.js";
+function e() {
+  return r;
+}
 export {
-  s as contracts
+  e as getVersion
 };

package/dist/native/index.native12.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.native36.js";
-import { validateRequest as I, EIP1193ProviderError as w, STANDARD_ERROR_CODES as C } from "./index.native13.js";
-import { EventEmitter as b } from "./index.native37.js";
-import { getPlatformStorage as _ } from "./index.native6.js";
+import { DisconnectedError as u, from as m } from "./index.native37.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.native38.js";
+import { validateRequest as w, EIP1193ProviderError as C, STANDARD_ERROR_CODES as b } from "./index.native13.js";
+import { EventEmitter as _ } from "./index.native39.js";
+import { getPlatformStorage as A } from "./index.native6.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.native38.js";
-import { onAuthStateChange as L } from "./index.native7.js";
-import { baseSepolia as l } from "./index.native39.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.native40.js";
+import { onAuthStateChange as M } from "./index.native7.js";
+import { baseSepolia as h } from "./index.native41.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/native/index.native120.js

@@ -1,38 +1,12 @@
-import { hexToBigInt as n } from "./index.native63.js";
-import { defineBlock as r } from "./index.native60.js";
-import { defineTransaction as s, formatTransaction as m } from "./index.native62.js";
-import { defineTransactionReceipt as l } from "./index.native65.js";
-const p = {
-  block: /* @__PURE__ */ r({
-    format(e) {
-      return {
-        transactions: e.transactions?.map((t) => {
-          if (typeof t == "string")
-            return t;
-          const i = m(t);
-          return i.typeHex === "0x7e" && (i.isSystemTx = t.isSystemTx, i.mint = t.mint ? n(t.mint) : void 0, i.sourceHash = t.sourceHash, i.type = "deposit"), i;
-        }),
-        stateRoot: e.stateRoot
-      };
-    }
-  }),
-  transaction: /* @__PURE__ */ s({
-    format(e) {
-      const o = {};
-      return e.type === "0x7e" && (o.isSystemTx = e.isSystemTx, o.mint = e.mint ? n(e.mint) : void 0, o.sourceHash = e.sourceHash, o.type = "deposit"), o;
-    }
-  }),
-  transactionReceipt: /* @__PURE__ */ l({
-    format(e) {
-      return {
-        l1GasPrice: e.l1GasPrice ? n(e.l1GasPrice) : null,
-        l1GasUsed: e.l1GasUsed ? n(e.l1GasUsed) : null,
-        l1Fee: e.l1Fee ? n(e.l1Fee) : null,
-        l1FeeScalar: e.l1FeeScalar ? Number(e.l1FeeScalar) : null
-      };
-    }
-  })
+import { contracts as o } from "./index.native136.js";
+import { formatters as r } from "./index.native137.js";
+import { serializers as t } from "./index.native138.js";
+const e = {
+  blockTime: 2e3,
+  contracts: o,
+  formatters: r,
+  serializers: t
 };
 export {
-  p as formatters
+  e as chainConfig
 };

package/dist/native/index.native121.js

@@ -1,44 +1,81 @@
-import { InvalidAddressError as a } from "./index.native78.js";
-import { isAddress as f } from "./index.native52.js";
-import { concatHex as p } from "./index.native53.js";
-import { toHex as i } from "./index.native47.js";
-import { toRlp as x } from "./index.native66.js";
-import { serializeTransaction as l } from "./index.native26.js";
-function T(r, e) {
-  return h(r) ? z(r) : l(r, e);
+import { Hash as g, createView as l, aexists as b, toBytes as a, abytes as d, aoutput as x, clean as w } from "./index.native109.js";
+function y(o, t, s, n) {
+  if (typeof o.setBigUint64 == "function")
+    return o.setBigUint64(t, s, n);
+  const i = BigInt(32), h = BigInt(4294967295), e = Number(s >> i & h), r = Number(s & h), c = n ? 4 : 0, u = n ? 0 : 4;
+  o.setUint32(t + c, e, n), o.setUint32(t + u, r, n);
 }
-const E = {
-  transaction: T
-};
-function z(r) {
-  w(r);
-  const { sourceHash: e, data: o, from: m, gas: t, isSystemTx: u, mint: s, to: c, value: n } = r, d = [
-    e,
-    m,
-    c ?? "0x",
-    s ? i(s) : "0x",
-    n ? i(n) : "0x",
-    t ? i(t) : "0x",
-    u ? "0x1" : "0x",
-    o ?? "0x"
-  ];
-  return p([
-    "0x7e",
-    x(d)
-  ]);
+function U(o, t, s) {
+  return o & t ^ ~o & s;
 }
-function h(r) {
-  return r.type === "deposit" || typeof r.sourceHash < "u";
+function _(o, t, s) {
+  return o & t ^ o & s ^ t & s;
 }
-function w(r) {
-  const { from: e, to: o } = r;
-  if (e && !f(e))
-    throw new a({ address: e });
-  if (o && !f(o))
-    throw new a({ address: o });
+class m extends g {
+  constructor(t, s, n, i) {
+    super(), this.finished = !1, this.length = 0, this.pos = 0, this.destroyed = !1, this.blockLen = t, this.outputLen = s, this.padOffset = n, this.isLE = i, this.buffer = new Uint8Array(t), this.view = l(this.buffer);
+  }
+  update(t) {
+    b(this), t = a(t), d(t);
+    const { view: s, buffer: n, blockLen: i } = this, h = t.length;
+    for (let e = 0; e < h; ) {
+      const r = Math.min(i - this.pos, h - e);
+      if (r === i) {
+        const c = l(t);
+        for (; i <= h - e; e += i)
+          this.process(c, e);
+        continue;
+      }
+      n.set(t.subarray(e, e + r), this.pos), this.pos += r, e += r, this.pos === i && (this.process(s, 0), this.pos = 0);
+    }
+    return this.length += t.length, this.roundClean(), this;
+  }
+  digestInto(t) {
+    b(this), x(t, this), this.finished = !0;
+    const { buffer: s, view: n, blockLen: i, isLE: h } = this;
+    let { pos: e } = this;
+    s[e++] = 128, w(this.buffer.subarray(e)), this.padOffset > i - e && (this.process(n, 0), e = 0);
+    for (let f = e; f < i; f++)
+      s[f] = 0;
+    y(n, i - 8, BigInt(this.length * 8), h), this.process(n, 0);
+    const r = l(t), c = this.outputLen;
+    if (c % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const u = c / 4, p = this.get();
+    if (u > p.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let f = 0; f < u; f++)
+      r.setUint32(4 * f, p[f], h);
+  }
+  digest() {
+    const { buffer: t, outputLen: s } = this;
+    this.digestInto(t);
+    const n = t.slice(0, s);
+    return this.destroy(), n;
+  }
+  _cloneInto(t) {
+    t || (t = new this.constructor()), t.set(...this.get());
+    const { blockLen: s, buffer: n, length: i, finished: h, destroyed: e, pos: r } = this;
+    return t.destroyed = e, t.finished = h, t.length = i, t.pos = r, i % s && t.buffer.set(n), t;
+  }
+  clone() {
+    return this._cloneInto();
+  }
 }
+const B = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
 export {
-  w as assertTransactionDeposit,
-  T as serializeTransaction,
-  E as serializers
+  U as Chi,
+  m as HashMD,
+  _ as Maj,
+  B as SHA256_IV,
+  y as setBigUint64
 };

package/dist/native/index.native122.js

@@ -1,81 +1,17 @@
-function r(t, e = "algorithm.name") {
-  return new TypeError(`CryptoKey does not support this operation, its ${e} must be ${t}`);
-}
-function o(t, e) {
-  return t.name === e;
-}
-function c(t) {
-  return parseInt(t.name.slice(4), 10);
-}
-function h(t) {
-  switch (t) {
-    case "ES256":
-      return "P-256";
-    case "ES384":
-      return "P-384";
-    case "ES512":
-      return "P-521";
-    default:
-      throw new Error("unreachable");
-  }
-}
-function i(t, e) {
-  if (!t.usages.includes(e))
-    throw new TypeError(`CryptoKey does not support this operation, its usages must include ${e}.`);
-}
-function u(t, e, n) {
-  switch (e) {
-    case "HS256":
-    case "HS384":
-    case "HS512": {
-      if (!o(t.algorithm, "HMAC"))
-        throw r("HMAC");
-      const a = parseInt(e.slice(2), 10);
-      if (c(t.algorithm.hash) !== a)
-        throw r(`SHA-${a}`, "algorithm.hash");
-      break;
-    }
-    case "RS256":
-    case "RS384":
-    case "RS512": {
-      if (!o(t.algorithm, "RSASSA-PKCS1-v1_5"))
-        throw r("RSASSA-PKCS1-v1_5");
-      const a = parseInt(e.slice(2), 10);
-      if (c(t.algorithm.hash) !== a)
-        throw r(`SHA-${a}`, "algorithm.hash");
-      break;
-    }
-    case "PS256":
-    case "PS384":
-    case "PS512": {
-      if (!o(t.algorithm, "RSA-PSS"))
-        throw r("RSA-PSS");
-      const a = parseInt(e.slice(2), 10);
-      if (c(t.algorithm.hash) !== a)
-        throw r(`SHA-${a}`, "algorithm.hash");
-      break;
-    }
-    case "Ed25519":
-    case "EdDSA": {
-      if (!o(t.algorithm, "Ed25519"))
-        throw r("Ed25519");
-      break;
-    }
-    case "ES256":
-    case "ES384":
-    case "ES512": {
-      if (!o(t.algorithm, "ECDSA"))
-        throw r("ECDSA");
-      const a = h(e);
-      if (t.algorithm.namedCurve !== a)
-        throw r(a, "algorithm.namedCurve");
-      break;
-    }
-    default:
-      throw new TypeError("CryptoKey does not support this operation");
-  }
-  i(t, n);
+import { SizeExceedsPaddingSizeError as a } from "./index.native100.js";
+function o(r, i = {}) {
+  const { dir: n, size: e = 32 } = i;
+  if (e === 0)
+    return r;
+  const t = r.replace("0x", "");
+  if (t.length > e * 2)
+    throw new a({
+      size: Math.ceil(t.length / 2),
+      targetSize: e,
+      type: "Hex"
+    });
+  return `0x${t[n === "right" ? "padEnd" : "padStart"](e * 2, "0")}`;
 }
 export {
-  u as checkSigCryptoKey
+  o as pad
 };

package/dist/native/index.native123.js

@@ -0,0 +1,4 @@
+var r = { exports: {} };
+export {
+  r as __module
+};

package/dist/native/index.native124.js

@@ -0,0 +1,7 @@
+const e = 32, s = 4096, t = 131072, l = 761855;
+export {
+  t as bytesPerBlob,
+  e as bytesPerFieldElement,
+  s as fieldElementsPerBlob,
+  l as maxBytesPerTransaction
+};

package/dist/native/index.native125.js

@@ -0,0 +1,20 @@
+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;
+}
+export {
+  a as decodeBase64,
+  o as encodeBase64
+};

package/dist/native/index.native126.js

@@ -0,0 +1,30 @@
+import { JOSENotSupported as r } from "./index.native43.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`);
+  }
+};
+export {
+  S as default
+};

package/dist/native/index.native127.js

@@ -0,0 +1,10 @@
+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`);
+  }
+};
+export {
+  o as default
+};

package/dist/native/index.native128.js

@@ -0,0 +1,13 @@
+import { checkSigCryptoKey as i } from "./index.native139.js";
+import o from "./index.native129.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;
+};
+export {
+  s as default
+};

package/dist/native/index.native129.js

@@ -0,0 +1,15 @@
+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);
+}
+export {
+  r as default,
+  t as withAlg
+};

package/dist/native/index.native13.js

@@ -1,4 +1,3 @@
-import "ox";
 import "viem";
 import "zustand";
 import "@coinbase/cdp-api-client";
@@ -81,7 +80,7 @@ const l = /* @__PURE__ */ new Set([
   "wallet_getCallsStatus",
   "wallet_getCapabilities"
 ]);
-function _(e, { chains: t }) {
+function A(e, { chains: t }) {
   const { method: r, params: s } = e;
   if (typeof r != "string" || r.length === 0)
     throw new c(
@@ -114,7 +113,7 @@ async function i() {
     );
   return e;
 }
-async function y(e) {
+async function _(e) {
   const t = await i();
   if (!t.evmAccounts?.includes(e) && !t.evmSmartAccounts?.includes(e))
     throw new o(
@@ -132,7 +131,7 @@ async function u() {
     );
   return e;
 }
-async function g() {
+async function y() {
   const e = await i();
   if (!e.evmSmartAccounts?.[0])
     throw new o(
@@ -141,7 +140,7 @@ async function g() {
     );
   return e;
 }
-async function S({ errorMessage: e } = {}) {
+async function g({ errorMessage: e } = {}) {
   const t = await u();
   if (await u(), !!t.evmSmartAccounts?.length)
     throw new p(e ?? "Method unsupported.");
@@ -152,10 +151,10 @@ export {
   o as EIP1193ProviderError,
   c as RPCRequestError,
   n as STANDARD_ERROR_CODES,
-  S as validateIsUsingEOA,
-  _ as validateRequest,
+  g as validateIsUsingEOA,
+  A as validateRequest,
   i as validateUserConnected,
   u as validateUserHasEvmAccount,
-  g as validateUserHasEvmSmartAccount,
-  y as validateUserOwnsAddress
+  y as validateUserHasEvmSmartAccount,
+  _ as validateUserOwnsAddress
 };

package/dist/native/index.native130.js

@@ -0,0 +1,12 @@
+function e(t) {
+  return t?.[Symbol.toStringTag] === "CryptoKey";
+}
+function r(t) {
+  return t?.[Symbol.toStringTag] === "KeyObject";
+}
+const n = (t) => e(t) || r(t);
+export {
+  n as default,
+  e as isCryptoKey,
+  r as isKeyObject
+};

package/dist/native/index.native131.js

@@ -0,0 +1,19 @@
+import n from "./index.native96.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";
+}
+export {
+  r as isJWK,
+  o as isPrivateJWK,
+  e as isPublicJWK,
+  c as isSecretJWK
+};