@coinbase/cdp-core 0.0.24 → 0.0.26

package/dist/esm/index.native92.js

@@ -0,0 +1,81 @@
+import { Hash as g, createView as l, aexists as b, toBytes as a, abytes as d, aoutput as x, clean as w } from "./index.native82.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);
+}
+function U(o, t, s) {
+  return o & t ^ ~o & s;
+}
+function _(o, t, s) {
+  return o & t ^ o & s ^ t & s;
+}
+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 {
+  U as Chi,
+  m as HashMD,
+  _ as Maj,
+  B as SHA256_IV,
+  y as setBigUint64
+};

package/dist/esm/index.native93.js

@@ -0,0 +1,12 @@
+import { contracts as o } from "./index.native103.js";
+import { formatters as r } from "./index.native104.js";
+import { serializers as t } from "./index.native105.js";
+const e = {
+  blockTime: 2e3,
+  contracts: o,
+  formatters: r,
+  serializers: t
+};
+export {
+  e as chainConfig
+};

package/dist/esm/index.native96.js

@@ -0,0 +1,30 @@
+import { JOSENotSupported as r } from "./index.native27.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/esm/index.native98.js

@@ -0,0 +1,13 @@
+import { checkSigCryptoKey as i } from "./index.native106.js";
+import o from "./index.native99.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/esm/index.web.js

@@ -0,0 +1,47 @@
+import { setPlatformServices as r } from "./index.web2.js";
+import { webCrypto as e } from "./index.web3.js";
+import { webStorage as o } from "./index.web4.js";
+import { exportEvmAccount as g, getAccessToken as c, getCurrentUser as f, getUserOperation as d, initialize as v, isSignedIn as T, onAuthStateChange as u, sendEvmTransaction as A, sendUserOperation as S, signEvmHash as l, signEvmMessage as x, signEvmTransaction as y, signEvmTypedData as h, signInWithEmail as O, signInWithSms as P, signOut as C, verifyEmailOTP as D, verifySmsOTP as I } from "./index.web5.js";
+import { AuthManager as U } from "./index.web6.js";
+import { APIError as b, ErrorType as w, HttpErrorType as M, SendEvmTransactionWithEndUserAccountBodyNetwork as k } from "@coinbase/cdp-api-client";
+import "viem";
+import { createCDPEmbeddedWallet as N } from "./index.web7.js";
+import { EIP1193ProviderError as z, STANDARD_ERROR_CODES as B } from "./index.web8.js";
+import "ox";
+import "zustand";
+import { toViemAccount as j } from "./index.web9.js";
+import { ModuleResolutionError as F } from "./index.web10.js";
+r({
+  crypto: e,
+  storage: o
+});
+export {
+  b as APIError,
+  U as AuthManager,
+  z as EIP1193ProviderError,
+  w as ErrorType,
+  M as HttpErrorType,
+  F as ModuleResolutionError,
+  B as STANDARD_ERROR_CODES,
+  k as SendEvmTransactionWithEndUserAccountBodyNetwork,
+  N as createCDPEmbeddedWallet,
+  g as exportEvmAccount,
+  c as getAccessToken,
+  f as getCurrentUser,
+  d as getUserOperation,
+  v as initialize,
+  T as isSignedIn,
+  u as onAuthStateChange,
+  A as sendEvmTransaction,
+  S as sendUserOperation,
+  l as signEvmHash,
+  x as signEvmMessage,
+  y as signEvmTransaction,
+  h as signEvmTypedData,
+  O as signInWithEmail,
+  P as signInWithSms,
+  C as signOut,
+  j as toViemAccount,
+  D as verifyEmailOTP,
+  I as verifySmsOTP
+};

package/dist/esm/index.web10.js

@@ -0,0 +1,24 @@
+class i extends Error {
+  /**
+   * The name of the missing module.
+   */
+  moduleName;
+  /**
+   * The API or feature that requires the missing module.
+   */
+  requiredFor;
+  /**
+   * Creates a new ModuleResolutionError.
+   *
+   * @param moduleName - The name of the missing module.
+   * @param requiredFor - The API or feature that requires the module.
+   * @param message - Optional custom error message.
+   */
+  constructor(e, s, r) {
+    const o = `${s} is not available in this React Native environment. Please ensure ${e} is installed.`;
+    super(r || o), this.name = "ModuleResolutionError", this.moduleName = e, this.requiredFor = s;
+  }
+}
+export {
+  i as ModuleResolutionError
+};

package/dist/esm/index.web100.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/esm/index.web101.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/esm/{index103.js → index.web102.js}

@@ -1,4 +1,4 @@
-import n from "./index84.js";
+import n from "./index.web34.js";
 function r(t) {
   return n(t) && typeof t.kty == "string";
 }

package/dist/esm/{index104.js → index.web103.js}

@@ -1,4 +1,4 @@
-import { JOSENotSupported as s } from "./index71.js";
+import { JOSENotSupported as s } from "./index.web26.js";
 function n(e) {
   let a, r;
   switch (e.kty) {

package/dist/esm/index.web104.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/esm/index.web105.js

@@ -0,0 +1,81 @@
+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);
+}
+export {
+  u as checkSigCryptoKey
+};

package/dist/esm/index.web11.js

@@ -0,0 +1,34 @@
+function a(e) {
+  if (typeof btoa < "u")
+    return btoa(
+      Array.from(e).map((t) => String.fromCharCode(t)).join("")
+    );
+  const c = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  let r = "";
+  for (let t = 0; t < e.length; t += 3) {
+    const h = e[t], n = t + 1 < e.length ? e[t + 1] : 0, s = t + 2 < e.length ? e[t + 2] : 0, o = h << 16 | n << 8 | s;
+    r += c.charAt(o >> 18 & 63), r += c.charAt(o >> 12 & 63), r += t + 1 < e.length ? c.charAt(o >> 6 & 63) : "=", r += t + 2 < e.length ? c.charAt(o & 63) : "=";
+  }
+  return r;
+}
+function g(e) {
+  if (typeof atob < "u") {
+    const n = atob(e), s = new Uint8Array(n.length);
+    for (let o = 0; o < n.length; o++)
+      s[o] = n.charCodeAt(o);
+    return s;
+  }
+  const c = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", r = {};
+  for (let n = 0; n < c.length; n++)
+    r[c[n]] = n;
+  const t = e.replace(/[^A-Za-z0-9+/]/g, ""), h = [];
+  for (let n = 0; n < t.length; n += 4) {
+    const s = r[t[n]] || 0, o = r[t[n + 1]] || 0, l = r[t[n + 2]] || 0, f = r[t[n + 3]] || 0, i = s << 18 | o << 12 | l << 6 | f;
+    h.push(i >> 16 & 255), n + 2 < t.length && h.push(i >> 8 & 255), n + 3 < t.length && h.push(i & 255);
+  }
+  return new Uint8Array(h);
+}
+export {
+  g as decodeBase64,
+  a as encodeBase64
+};

package/dist/esm/index.web12.js

@@ -0,0 +1,17 @@
+import "@coinbase/cdp-api-client";
+const r = (u, c, e) => {
+  const s = new Date(c).getTime(), m = {
+    userId: e.userId,
+    evmAccounts: e.evmAccounts?.map((t) => t) ?? [],
+    evmSmartAccounts: e.evmSmartAccounts?.map((t) => t) ?? [],
+    authenticationMethods: e.authenticationMethods.reduce((t, o) => (t[o.type] = o, t), {})
+  };
+  return {
+    accessToken: u,
+    expiresAt: s,
+    user: m
+  };
+};
+export {
+  r as toAuthState
+};

package/dist/esm/index.web13.js

@@ -0,0 +1,18 @@
+import "@coinbase/cdp-api-client";
+import "viem";
+const o = async (t) => await t.isSignedIn();
+async function w(t, n, e) {
+  if (!await o(n))
+    throw new Error("User not signed in");
+  const r = await n.getUser();
+  if ("evmAccount" in t && !r.evmAccounts?.find((c) => c === t.evmAccount))
+    throw new Error("EVM account not found");
+  if ("evmSmartAccount" in t && !r.evmSmartAccounts?.find((c) => c === t.evmSmartAccount))
+    throw new Error("EVM Smart Account not found");
+  const i = await n.getWalletSecretId();
+  return e({ ...t, user: r, walletSecretId: i });
+}
+export {
+  o as isSignedIn,
+  w as withAuth
+};

package/dist/esm/{index11.js → index.web14.js}

@@ -1,6 +1,6 @@
 import "@coinbase/cdp-api-client";
 import "viem";
-import { mockUser as e } from "./index12.js";
+import { mockUser as e } from "./index.web15.js";
 class r {
   authState = null;
   authStateChangeCallback = null;

package/dist/esm/index.web15.js

@@ -0,0 +1,16 @@
+import "@coinbase/cdp-api-client";
+import "viem";
+const t = "0x0000000000000000000000000000000000000000", s = {
+  userId: "mock-user-id",
+  evmAccounts: [t],
+  authenticationMethods: {
+    email: {
+      type: "email",
+      email: "test@test.com"
+    }
+  }
+};
+export {
+  t as mockAddress,
+  s as mockUser
+};

package/dist/esm/index.web16.js

@@ -0,0 +1,44 @@
+import { SendEvmTransactionWithEndUserAccountBodyNetwork as i } from "@coinbase/cdp-api-client";
+const t = (e) => !e || typeof e != "object" ? e : Array.isArray(e) ? e.map(t) : Object.keys(e).sort().reduce(
+  (r, n) => (r[n] = t(e[n]), r),
+  {}
+), p = (e) => Object.values(i).includes(
+  e
+), s = {
+  "base-sepolia": 84532,
+  base: 8453,
+  ethereum: 1,
+  "ethereum-sepolia": 11155111,
+  avalanche: 43114,
+  polygon: 137,
+  optimism: 10,
+  arbitrum: 42161
+}, c = Object.fromEntries(
+  Object.entries(s).map(([e, r]) => [r, e])
+), u = (e) => Object.values(s).includes(
+  e
+), a = {
+  "base-sepolia": 84532,
+  base: 8453,
+  ethereum: 1,
+  "ethereum-sepolia": 11155111,
+  avalanche: 43114,
+  polygon: 137,
+  optimism: 10,
+  arbitrum: 42161,
+  zora: 7777777,
+  bnb: 56
+}, m = Object.fromEntries(
+  Object.entries(a).map(([e, r]) => [r, e])
+), d = (e) => Object.values(a).includes(
+  e
+);
+export {
+  u as isChainIdSupportedForCDPSends,
+  d as isChainIdSupportedForCDPUserOps,
+  p as isChainSupportedForCDPSends,
+  c as sendTransactionChainIdToNameMapping,
+  t as sortKeys,
+  m as userOperationChainIdToNameMapping,
+  a as userOperationNameToChainIdMapping
+};

package/dist/esm/index.web17.js

@@ -0,0 +1,22 @@
+import "@coinbase/cdp-api-client";
+import "viem";
+let n = null, r = null;
+const i = (t) => {
+  n = t;
+}, a = () => {
+  if (!n)
+    throw new Error("SDK not initialized");
+  return n;
+}, g = (t) => {
+  r = t;
+}, l = () => {
+  if (!r)
+    throw new Error("SDK not initialized");
+  return r;
+};
+export {
+  a as getConfig,
+  l as getCoreAuthManager,
+  i as setConfig,
+  g as setCoreAuthManager
+};

package/dist/esm/{index15.js → index.web18.js}

@@ -1,16 +1,16 @@
-import { InvalidLegacyVError as H } from "./index54.js";
-import { serializeAuthorizationList as g } from "./index26.js";
-import { blobsToCommitments as B } from "./index62.js";
-import { blobsToProofs as V } from "./index63.js";
-import { commitmentsToVersionedHashes as C } from "./index64.js";
-import { toBlobSidecars as k } from "./index65.js";
-import { concatHex as h } from "./index33.js";
-import { trim as T } from "./index39.js";
-import { numberToHex as o, bytesToHex as w } from "./index27.js";
-import { toRlp as b } from "./index46.js";
-import { assertTransactionEIP1559 as S, assertTransactionEIP2930 as _, assertTransactionEIP4844 as R, assertTransactionEIP7702 as Y, assertTransactionLegacy as j } from "./index55.js";
-import { getTransactionType as q } from "./index53.js";
-import { serializeAccessList as v } from "./index66.js";
+import { InvalidLegacyVError as H } from "./index.web63.js";
+import { serializeAuthorizationList as g } from "./index.web36.js";
+import { blobsToCommitments as B } from "./index.web70.js";
+import { blobsToProofs as V } from "./index.web71.js";
+import { commitmentsToVersionedHashes as C } from "./index.web72.js";
+import { toBlobSidecars as k } from "./index.web73.js";
+import { concatHex as h } from "./index.web42.js";
+import { trim as T } from "./index.web48.js";
+import { numberToHex as o, bytesToHex as w } from "./index.web37.js";
+import { toRlp as b } from "./index.web55.js";
+import { assertTransactionEIP1559 as S, assertTransactionEIP2930 as _, assertTransactionEIP4844 as R, assertTransactionEIP7702 as Y, assertTransactionLegacy as j } from "./index.web64.js";
+import { getTransactionType as q } from "./index.web62.js";
+import { serializeAccessList as v } from "./index.web74.js";
 function te(e, r) {
   const i = q(e);
   return i === "eip1559" ? K(e, r) : i === "eip2930" ? M(e, r) : i === "eip4844" ? J(e, r) : i === "eip7702" ? D(e, r) : N(e, r);

package/dist/esm/{index17.js → index.web19.js}

@@ -1,6 +1,6 @@
-import { CompactSign as i } from "./index70.js";
-import { JWTInvalid as r } from "./index71.js";
-import { JWTClaimsBuilder as n } from "./index72.js";
+import { CompactSign as i } from "./index.web25.js";
+import { JWTInvalid as r } from "./index.web26.js";
+import { JWTClaimsBuilder as n } from "./index.web27.js";
 class d {
   #s;
   #t;

package/dist/esm/index.web2.js

@@ -0,0 +1,23 @@
+let r = null;
+function t(o) {
+  r = o;
+}
+function e() {
+  if (!r)
+    throw new Error(
+      "Platform services not initialized. This usually means the core package was not properly imported for your platform. For web apps, make sure you're importing from '@coinbase/cdp-core'. For React Native apps, ensure you have the proper platform resolution configured."
+    );
+  return r;
+}
+function a() {
+  return e().crypto;
+}
+function n() {
+  return e().storage;
+}
+export {
+  a as getPlatformCrypto,
+  e as getPlatformServices,
+  n as getPlatformStorage,
+  t as setPlatformServices
+};

package/dist/esm/{index16.js → index.web20.js}

@@ -1,5 +1,5 @@
-import { InvalidAddressError as s } from "./index58.js";
-import { isAddress as a } from "./index32.js";
+import { InvalidAddressError as s } from "./index.web28.js";
+import { isAddress as a } from "./index.web29.js";
 function r(n) {
   if (typeof n == "string") {
     if (!a(n, { strict: !1 }))