@coinbase/cdp-core 0.0.44 → 0.0.45

package/dist/types/actions/revokeSpendPermission.d.ts

@@ -0,0 +1,13 @@
+import { SpendPermissionNetwork } from '@coinbase/cdp-api-client';
+import { EvmAddress, Hex } from '../types.js';
+export type RevokeSpendPermissionOptions = {
+    evmSmartAccount: EvmAddress;
+    network: SpendPermissionNetwork;
+    permissionHash: string;
+    useCdpPaymaster?: boolean;
+    paymasterUrl?: string;
+};
+export type RevokeSpendPermissionResult = {
+    userOperationHash: Hex;
+};
+export declare const revokeSpendPermission: (options: RevokeSpendPermissionOptions) => Promise<RevokeSpendPermissionResult>;

package/dist/types/index.d.ts

@@ -1,5 +1,8 @@
 export * from './core.js';
 export { createSpendPermission, type CreateSpendPermissionOptions, type CreateSpendPermissionResult, } from './actions/createSpendPermission.js';
+export { listSpendPermissions, type ListSpendPermissionsOptions, type ListSpendPermissionsResult, } from './actions/listSpendPermissions.js';
+export { type SpendPermissionNetwork } from '@coinbase/cdp-api-client';
+export { revokeSpendPermission, type RevokeSpendPermissionOptions, type RevokeSpendPermissionResult, } from './actions/revokeSpendPermission.js';
 export * from './types.js';
 export * from './provider.js';
 export * from './viem/toViemAccount.js';

package/dist/types/index.native.d.ts

@@ -1,5 +1,8 @@
 export * from './core.js';
 export { createSpendPermission, type CreateSpendPermissionOptions, type CreateSpendPermissionResult, } from './actions/createSpendPermission.js';
+export { listSpendPermissions, type ListSpendPermissionsOptions, type ListSpendPermissionsResult, } from './actions/listSpendPermissions.js';
+export { type SpendPermissionNetwork } from '@coinbase/cdp-api-client';
+export { revokeSpendPermission, type RevokeSpendPermissionOptions, type RevokeSpendPermissionResult, } from './actions/revokeSpendPermission.js';
 export * from './auth/authManager.js';
 export * from './types.js';
 export * from './provider.js';

package/dist/types/index.web.d.ts

@@ -1,5 +1,8 @@
 export * from './core.js';
 export { createSpendPermission, type CreateSpendPermissionOptions, type CreateSpendPermissionResult, } from './actions/createSpendPermission.js';
+export { listSpendPermissions, type ListSpendPermissionsOptions, type ListSpendPermissionsResult, } from './actions/listSpendPermissions.js';
+export { type SpendPermissionNetwork } from '@coinbase/cdp-api-client';
+export { revokeSpendPermission, type RevokeSpendPermissionOptions, type RevokeSpendPermissionResult, } from './actions/revokeSpendPermission.js';
 export * from './auth/authManager.js';
 export * from './types.js';
 export * from './provider.js';

package/dist/types/mocks/config.d.ts

@@ -0,0 +1,2 @@
+import { Config } from '../types.js';
+export declare function createConfig(options?: Partial<Config>): Config;

package/dist/web/index.web.js

@@ -1,55 +1,59 @@
 import { setPlatformServices as r } from "./index.web2.js";
 import { webCrypto as o } from "./index.web3.js";
 import { webStorage as e } from "./index.web4.js";
-import { exportEvmAccount as E, exportSolanaAccount as g, getAccessToken as d, getCurrentUser as S, getUserOperation as f, initialize as l, isSignedIn as T, onAuthStateChange as u, sendEvmTransaction as v, sendSolanaTransaction as A, sendUserOperation as x, signEvmHash as y, signEvmMessage as h, signEvmTransaction as P, signEvmTypedData as O, signInWithEmail as I, signInWithSms as C, signOut as D, signSolanaMessage as R, signSolanaTransaction as U, verifyEmailOTP as W, verifySmsOTP as w } from "./index.web5.js";
-import { createSpendPermission as b } from "./index.web6.js";
-import { AuthManager as N } from "./index.web7.js";
+import { exportEvmAccount as E, exportSolanaAccount as d, getAccessToken as g, getCurrentUser as S, getUserOperation as f, initialize as l, isSignedIn as T, onAuthStateChange as u, sendEvmTransaction as v, sendSolanaTransaction as x, sendUserOperation as A, signEvmHash as P, signEvmMessage as y, signEvmTransaction as h, signEvmTypedData as O, signInWithEmail as I, signInWithSms as C, signOut as D, signSolanaMessage as R, signSolanaTransaction as U, verifyEmailOTP as W, verifySmsOTP as k } from "./index.web5.js";
+import { createSpendPermission as M } from "./index.web6.js";
+import { listSpendPermissions as N } from "./index.web7.js";
 import { APIError as H, ErrorType as V, HttpErrorType as _, SendEvmTransactionWithEndUserAccountBodyNetwork as z, SendSolanaTransactionWithEndUserAccountBodyNetwork as j } from "@coinbase/cdp-api-client";
+import { revokeSpendPermission as F } from "./index.web8.js";
+import { AuthManager as J } from "./index.web9.js";
 import "viem";
-import { createCDPEmbeddedWallet as F } from "./index.web8.js";
-import { EIP1193ProviderError as J, STANDARD_ERROR_CODES as K } from "./index.web9.js";
+import { createCDPEmbeddedWallet as L } from "./index.web10.js";
+import { EIP1193ProviderError as X, STANDARD_ERROR_CODES as Y } from "./index.web11.js";
 import "ox";
 import "zustand";
-import { toViemAccount as Q } from "./index.web10.js";
-import { InputValidationError as Y, ModuleResolutionError as Z } from "./index.web11.js";
+import { toViemAccount as $ } from "./index.web12.js";
+import { InputValidationError as or, ModuleResolutionError as er } from "./index.web13.js";
 r({
   crypto: o,
   storage: e
 });
 export {
   H as APIError,
-  N as AuthManager,
-  J as EIP1193ProviderError,
+  J as AuthManager,
+  X as EIP1193ProviderError,
   V as ErrorType,
   _ as HttpErrorType,
-  Y as InputValidationError,
-  Z as ModuleResolutionError,
-  K as STANDARD_ERROR_CODES,
+  or as InputValidationError,
+  er as ModuleResolutionError,
+  Y as STANDARD_ERROR_CODES,
   z as SendEvmTransactionWithEndUserAccountBodyNetwork,
   j as SendSolanaTransactionWithEndUserAccountBodyNetwork,
-  F as createCDPEmbeddedWallet,
-  b as createSpendPermission,
+  L as createCDPEmbeddedWallet,
+  M as createSpendPermission,
   E as exportEvmAccount,
-  g as exportSolanaAccount,
-  d as getAccessToken,
+  d as exportSolanaAccount,
+  g as getAccessToken,
   S as getCurrentUser,
   f as getUserOperation,
   l as initialize,
   T as isSignedIn,
+  N as listSpendPermissions,
   u as onAuthStateChange,
+  F as revokeSpendPermission,
   v as sendEvmTransaction,
-  A as sendSolanaTransaction,
-  x as sendUserOperation,
-  y as signEvmHash,
-  h as signEvmMessage,
-  P as signEvmTransaction,
+  x as sendSolanaTransaction,
+  A as sendUserOperation,
+  P as signEvmHash,
+  y as signEvmMessage,
+  h as signEvmTransaction,
   O as signEvmTypedData,
   I as signInWithEmail,
   C as signInWithSms,
   D as signOut,
   R as signSolanaMessage,
   U as signSolanaTransaction,
-  Q as toViemAccount,
+  $ as toViemAccount,
   W as verifyEmailOTP,
-  w as verifySmsOTP
+  k as verifySmsOTP
 };

package/dist/web/index.web10.js

@@ -1,118 +1,121 @@
-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.web5.js";
+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.web32.js";
+import { validateRequest as I, EIP1193ProviderError as w, STANDARD_ERROR_CODES as C } from "./index.web11.js";
+import { EventEmitter as b } from "./index.web33.js";
+import { getPlatformStorage as _ } from "./index.web2.js";
 import "@coinbase/cdp-api-client";
-import { COINBASE_SMART_WALLET_FACTORY_ADDRESS as y, COINBASE_SMART_WALLET_FACTORY_ABI as p } from "./index.web23.js";
-import { signAndWrapTypedDataForSmartAccount as v } from "./index.web24.js";
-import { toAccount as w } from "./index.web25.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"
-    );
-  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;
+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.web34.js";
+import { onAuthStateChange as L } from "./index.web5.js";
+import { baseSepolia as l } from "./index.web35.js";
+function M(r, n, s) {
+  n.subscribe(
+    (t) => t.chainId,
+    (t, e) => {
+      t !== e && r.emit("chainChanged", t);
+    }
+  ), 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());
+          return;
+        }
+        if (t && t.evmAccounts?.length && (!e || e.evmAccounts?.length === 0)) {
+          const a = n.getState().chainId;
+          r.emit("connect", { chainId: a });
+          return;
+        }
       }
-    },
-    /**
-     * 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;
     }
+  );
+  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) {
+        case "eth_accounts":
+          return G();
+        case "eth_requestAccounts":
+          return O(r, n);
+        case "personal_sign":
+          return N(e.params);
+        case "eth_sendTransaction":
+          return q(e.params, n, s.transports);
+        case "wallet_disconnect":
+          return T();
+        case "wallet_switchEthereumChain":
+          return y(e.params, n);
+        case "eth_sign":
+          return R(e.params);
+        case "eth_signTypedData_v4":
+          return E(e.params);
+        case "eth_chainId":
+          return P(n);
+        case "wallet_sendCalls":
+          return D(e.params, n);
+        case "wallet_getCallsStatus":
+          return v(e.params, n);
+        case "wallet_getCapabilities":
+          return A();
+        // Catch-all for any unknown method
+        default:
+          throw new w(
+            C.provider.unsupportedMethod,
+            `Method ${e.method} not supported`
+          );
+      }
+    },
+    // Event emitter methods - only the ones required by the interface
+    on: r.on.bind(r),
+    removeListener: r.removeListener.bind(r)
   });
 }
+const u = {
+  chains: [l],
+  transports: {
+    [l.id]: m()
+  }
+};
+function Q(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;
+  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) => ({
+          chainId: n[0].id,
+          setChainId: (a) => e({ chainId: a }),
+          chains: n,
+          user: null,
+          setUser: (a) => e({ user: a })
+        }),
+        {
+          name: "cdp-provider-store",
+          storage: S(() => d)
+        }
+      )
+    )
+  );
+  return c.persist.rehydrate(), L((e) => {
+    c.getState().setUser(e);
+  }), {
+    provider: M(i, c, {
+      chains: n,
+      transports: s
+    })
+  };
+}
 export {
-  F as toViemAccount
+  Q as createCDPEmbeddedWallet
 };

package/dist/web/index.web100.js

@@ -1,96 +1,12 @@
-import { withAlg as n } from "./index.web109.js";
-import c from "./index.web110.js";
-import { isJWK as p, isSecretJWK as a, isPublicJWK as y, isPrivateJWK as f } from "./index.web111.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);
+import n from "./index.web108.js";
+import s from "./index.web109.js";
+import a from "./index.web110.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 {
-  d as default
+  y as default
 };

package/dist/web/index.web101.js

@@ -1,23 +1,22 @@
-import { JOSENotSupported as f } from "./index.web35.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`);
+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 new Set(e.crit);
+  return !0;
 };
 export {
-  w as default
+  a as default
 };