@coinbase/cdp-core 0.0.32 → 0.0.34

package/dist/esm/index.native9.js

@@ -1,118 +1,143 @@
-import { serializeErc6492Signature as i, encodeFunctionData as c, pad as u, getTypesForEIP712Domain as m } from "viem";
-import { getCurrentUser as g, signEvmHash as A, signEvmTypedData as l, signEvmTransaction as d, signEvmMessage as f } from "./index.native5.js";
+import "ox";
+import "viem";
+import "zustand";
 import "@coinbase/cdp-api-client";
-import { COINBASE_SMART_WALLET_FACTORY_ADDRESS as y, COINBASE_SMART_WALLET_FACTORY_ABI as p } from "./index.native21.js";
-import { signAndWrapTypedDataForSmartAccount as v } from "./index.native22.js";
-import { toAccount as w } from "./index.native23.js";
-async function F(n) {
-  const r = await g();
-  if (!r || !r.evmAccounts?.length && !r.evmSmartAccounts?.length)
-    throw new Error(
-      "No accounts found - user must be authenticated and have at least one EVM account or smart account"
+import { getCurrentUser as u } from "./index.native6.js";
+import "./index.native8.js";
+const r = {
+  rpc: {
+    invalidInput: -32e3,
+    resourceNotFound: -32001,
+    resourceUnavailable: -32002,
+    transactionRejected: -32003,
+    methodNotSupported: -32004,
+    limitExceeded: -32005,
+    parse: -32700,
+    invalidRequest: -32600,
+    methodNotFound: -32601,
+    invalidParams: -32602,
+    internal: -32603
+  },
+  provider: {
+    userRejectedRequest: 4001,
+    unauthorized: 4100,
+    unsupportedMethod: 4200,
+    disconnected: 4900,
+    chainDisconnected: 4901,
+    unsupportedChain: 4902
+  }
+};
+class o extends Error {
+  /**
+   * The error code from EIP1193ErrorCode enum.
+   */
+  code;
+  /**
+   * Creates a new EIP-1193 Provider error.
+   *
+   * @param code - The error code from EIP1193ErrorCode enum.
+   * @param message - The error message.
+   */
+  constructor(t, n) {
+    super(n), this.code = t;
+  }
+}
+class c extends Error {
+  /**
+   * The error code from RPCErrorCode type.
+   */
+  code;
+  /**
+   * Creates a new RPC Invalid Params error.
+   *
+   * @param code - The error code from RPCErrorCode type.
+   * @param message - The error message.
+   */
+  constructor(t, n) {
+    super(n), this.code = t;
+  }
+}
+const p = /* @__PURE__ */ new Set([
+  "eth_accounts",
+  "eth_requestAccounts",
+  "personal_sign",
+  "eth_sendTransaction",
+  "eth_signTypedData_v4",
+  "eth_chainId",
+  "eth_sign",
+  "wallet_disconnect",
+  "wallet_switchEthereumChain",
+  "wallet_sendCalls",
+  "wallet_getCallsStatus",
+  "wallet_getCapabilities"
+]);
+function _(e, { chains: t }) {
+  const { method: n, params: a } = e;
+  if (typeof n != "string" || n.length === 0)
+    throw new c(
+      r.rpc.invalidParams,
+      "'method' must be a non-empty string."
+    );
+  const s = (a ?? [])[0]?.chainId;
+  if (typeof s == "string" && !t.some((d) => d.id === Number.parseInt(s, 16)))
+    throw new o(
+      r.provider.unsupportedChain,
+      `Chain ${s} not supported - make sure the provider is configured with the correct chains.`
+    );
+  if (a !== void 0 && !Array.isArray(a))
+    throw new c(
+      r.rpc.invalidParams,
+      "'params' must be an array if provided."
+    );
+  if (!p.has(n))
+    throw new o(
+      r.provider.unsupportedMethod,
+      `Method ${e.method} not supported`
+    );
+}
+async function i() {
+  const e = await u();
+  if (!e)
+    throw new o(
+      r.provider.unauthorized,
+      "User not connected"
+    );
+  return e;
+}
+async function E(e) {
+  const t = await i();
+  if (!t.evmAccounts?.includes(e))
+    throw new o(
+      r.provider.unauthorized,
+      "Address not owned by user"
+    );
+  return t;
+}
+async function y() {
+  const e = await i();
+  if (!e.evmAccounts?.[0])
+    throw new o(
+      r.provider.unauthorized,
+      "No EVM accounts available"
+    );
+  return e;
+}
+async function A() {
+  const e = await i();
+  if (!e.evmSmartAccounts?.[0])
+    throw new o(
+      r.provider.unauthorized,
+      "No EVM smart accounts available"
     );
-  const s = r.evmAccounts?.includes(n) ?? !1, o = r.evmSmartAccounts?.includes(n) ?? !1;
-  if (!s && !o)
-    throw new Error(`Cannot sign for address ${n} - not authorized for this account`);
-  return w({
-    address: n,
-    /**
-     * Signs a message using CDP's message signing functionality.
-     * Supports string messages, hex strings, and byte arrays.
-     *
-     * @param root0 - The parameters object
-     * @param root0.message - The message to sign, can be a string, hex string, or byte array
-     * @returns The signature as a hex string
-     */
-    async signMessage({ message: e }) {
-      let t;
-      if (typeof e == "string")
-        t = e;
-      else if ("raw" in e)
-        typeof e.raw == "string" ? t = e.raw : t = new TextDecoder().decode(e.raw);
-      else
-        throw new Error("Unsupported message format");
-      return (await f({
-        evmAccount: n,
-        message: t
-      })).signature;
-    },
-    /**
-     * Signs a transaction using CDP's transaction signing functionality.
-     * Converts Viem's transaction format to CDP's AllowedEvmTransactionType.
-     *
-     * @param transaction - The transaction to sign in Viem's format
-     * @returns The signature as a hex string
-     */
-    async signTransaction(e) {
-      const t = {
-        to: e.to,
-        value: e.value,
-        data: e.data,
-        nonce: e.nonce,
-        gas: e.gas,
-        chainId: e.chainId ?? 1
-      };
-      return e.gasPrice !== void 0 ? (t.maxFeePerGas = e.gasPrice, t.maxPriorityFeePerGas = e.gasPrice) : (t.maxFeePerGas = e.maxFeePerGas, t.maxPriorityFeePerGas = e.maxPriorityFeePerGas), (await d({
-        evmAccount: n,
-        transaction: t
-      })).signedTransaction;
-    },
-    /**
-     * Signs EIP-712 typed data using CDP's typed data signing functionality.
-     * Handles domain separation and type encoding according to the EIP-712 specification.
-     * For smart accounts, implements replay-safe hash and signature wrapping.
-     *
-     * @param params - The typed data parameters following the EIP-712 specification
-     * @returns The signature as a hex string
-     */
-    async signTypedData(e) {
-      if (o) {
-        const t = await v({
-          smartAccount: n,
-          ownerAddress: r.evmAccounts?.[0],
-          typedData: e
-        });
-        return i({
-          address: y,
-          data: c({
-            abi: p,
-            functionName: "createAccount",
-            args: [[u(r.evmAccounts?.[0])], 0n]
-          }),
-          signature: t.signature
-        });
-      } else {
-        const t = {
-          domain: e.domain,
-          types: {
-            EIP712Domain: m({
-              domain: e.domain
-            }),
-            ...e.types
-          },
-          primaryType: e.primaryType,
-          message: e.message
-        };
-        return (await l({
-          evmAccount: n,
-          typedData: t
-        })).signature;
-      }
-    },
-    /**
-     * Signs a raw message hash using CDP's message signing functionality.
-     *
-     * @param message - The message hash to sign
-     * @returns The signature as a hex string
-     */
-    async sign(e) {
-      return (await A({
-        evmAccount: n,
-        hash: e.hash
-      })).signature;
-    }
-  });
+  return e;
 }
 export {
-  F as toViemAccount
+  o as EIP1193ProviderError,
+  c as RPCRequestError,
+  r as STANDARD_ERROR_CODES,
+  _ as validateRequest,
+  i as validateUserConnected,
+  y as validateUserHasEvmAccount,
+  A as validateUserHasEvmSmartAccount,
+  E as validateUserOwnsAddress
 };

package/dist/esm/index.native90.js

@@ -1,6 +1,6 @@
-import n from "./index.native98.js";
-import s from "./index.native99.js";
-import a from "./index.native100.js";
+import n from "./index.native99.js";
+import s from "./index.native100.js";
+import a from "./index.native101.js";
 const y = async (t, o, e) => {
   const r = await a(t, o, "sign");
   s(t, r);

package/dist/esm/index.native92.js

@@ -1,6 +1,6 @@
-import { withAlg as n } from "./index.native101.js";
-import c from "./index.native102.js";
-import { isJWK as p, isSecretJWK as a, isPublicJWK as y, isPrivateJWK as f } from "./index.native103.js";
+import { withAlg as n } from "./index.native102.js";
+import c from "./index.native103.js";
+import { isJWK as p, isSecretJWK as a, isPublicJWK as y, isPrivateJWK as f } from "./index.native104.js";
 const s = (r) => r?.[Symbol.toStringTag], o = (r, e, t) => {
   if (e.use !== void 0) {
     let i;

package/dist/esm/index.native93.js

@@ -1,4 +1,4 @@
-import { JOSENotSupported as f } from "./index.native29.js";
+import { JOSENotSupported as f } from "./index.native30.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');

package/dist/esm/index.native94.js

@@ -1,7 +1,7 @@
-import { isJWK as p } from "./index.native103.js";
+import { isJWK as p } from "./index.native104.js";
 import { decode as m } from "./index.native89.js";
-import y from "./index.native104.js";
-import { isCryptoKey as S, isKeyObject as K } from "./index.native102.js";
+import y from "./index.native105.js";
+import { isCryptoKey as S, isKeyObject as K } from "./index.native103.js";
 let c;
 const f = async (e, r, s, i = !1) => {
   c ||= /* @__PURE__ */ new WeakMap();

package/dist/esm/index.native95.js

@@ -1,12 +1,81 @@
-import { contracts as o } from "./index.native105.js";
-import { formatters as r } from "./index.native106.js";
-import { serializers as t } from "./index.native107.js";
-const e = {
-  blockTime: 2e3,
-  contracts: o,
-  formatters: r,
-  serializers: t
-};
+import { Hash as g, createView as l, aexists as b, toBytes as a, abytes as d, aoutput as x, clean as w } from "./index.native85.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 {
-  e as chainConfig
+  U as Chi,
+  m as HashMD,
+  _ as Maj,
+  B as SHA256_IV,
+  y as setBigUint64
 };

package/dist/esm/index.native96.js

@@ -1,7 +1,12 @@
-const e = 32, s = 4096, t = 131072, l = 761855;
+import { contracts as o } from "./index.native106.js";
+import { formatters as r } from "./index.native107.js";
+import { serializers as t } from "./index.native108.js";
+const e = {
+  blockTime: 2e3,
+  contracts: o,
+  formatters: r,
+  serializers: t
+};
 export {
-  t as bytesPerBlob,
-  e as bytesPerFieldElement,
-  s as fieldElementsPerBlob,
-  l as maxBytesPerTransaction
+  e as chainConfig
 };

package/dist/esm/index.native97.js

@@ -1,20 +1,7 @@
-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;
-}
+const e = 32, s = 4096, t = 131072, l = 761855;
 export {
-  a as decodeBase64,
-  o as encodeBase64
+  t as bytesPerBlob,
+  e as bytesPerFieldElement,
+  s as fieldElementsPerBlob,
+  l as maxBytesPerTransaction
 };

package/dist/esm/index.native98.js

@@ -1,30 +1,20 @@
-import { JOSENotSupported as r } from "./index.native29.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`);
-  }
-};
+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 {
-  S as default
+  a as decodeBase64,
+  o as encodeBase64
 };

package/dist/esm/index.native99.js

@@ -1,10 +1,30 @@
-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 { JOSENotSupported as r } from "./index.native30.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 {
-  o as default
+  S as default
 };

package/dist/esm/index.web.js

@@ -1,47 +1,50 @@
 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 { webCrypto as o } from "./index.web3.js";
+import { webStorage as e } from "./index.web4.js";
+import { exportEvmAccount as c, getAccessToken as g, getCurrentUser as d, getUserOperation as f, initialize as S, isSignedIn as T, onAuthStateChange as l, sendEvmTransaction as v, sendSolanaTransaction as u, sendUserOperation as A, signEvmHash as y, signEvmMessage as h, signEvmTransaction as x, signEvmTypedData as O, signInWithEmail as P, signInWithSms as C, signOut as D, signSolanaTransaction as I, verifyEmailOTP as R, verifySmsOTP as U } from "./index.web5.js";
+import { AuthManager as w } from "./index.web6.js";
+import { APIError as k, ErrorType as M, HttpErrorType as N, SendEvmTransactionWithEndUserAccountBodyNetwork as B, SendSolanaTransactionWithEndUserAccountBodyNetwork as H } 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 { createCDPEmbeddedWallet as z } from "./index.web7.js";
+import { EIP1193ProviderError as j, STANDARD_ERROR_CODES as q } from "./index.web8.js";
 import "ox";
 import "zustand";
-import { toViemAccount as j } from "./index.web9.js";
-import { ModuleResolutionError as F } from "./index.web10.js";
+import { toViemAccount as G } from "./index.web9.js";
+import { ModuleResolutionError as K } from "./index.web10.js";
 r({
-  crypto: e,
-  storage: o
+  crypto: o,
+  storage: e
 });
 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,
+  k as APIError,
+  w as AuthManager,
+  j as EIP1193ProviderError,
+  M as ErrorType,
+  N as HttpErrorType,
+  K as ModuleResolutionError,
+  q as STANDARD_ERROR_CODES,
+  B as SendEvmTransactionWithEndUserAccountBodyNetwork,
+  H as SendSolanaTransactionWithEndUserAccountBodyNetwork,
+  z as createCDPEmbeddedWallet,
+  c as exportEvmAccount,
+  g as getAccessToken,
+  d as getCurrentUser,
+  f as getUserOperation,
+  S 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
+  l as onAuthStateChange,
+  v as sendEvmTransaction,
+  u as sendSolanaTransaction,
+  A as sendUserOperation,
+  y as signEvmHash,
+  h as signEvmMessage,
+  x as signEvmTransaction,
+  O as signEvmTypedData,
+  P as signInWithEmail,
+  C as signInWithSms,
+  D as signOut,
+  I as signSolanaTransaction,
+  G as toViemAccount,
+  R as verifyEmailOTP,
+  U as verifySmsOTP
 };

package/dist/esm/index.web100.js

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