@coinbase/cdp-core 0.0.98 → 0.0.100

package/dist/web/index.web97.js

@@ -1,28 +1,31 @@
-import { Analytics as E } from "./index.web2.js";
-import "./index.web3.js";
-import { VERSION as r } from "./index.web8.js";
-import { APIError as c, ErrorType as P, EvmEip7702DelegationNetwork as U, HttpErrorType as F, OAuth2ProviderType as I, SendEvmTransactionWithEndUserAccountBodyNetwork as d, SendSolanaTransactionWithEndUserAccountBodyNetwork as s } from "@coinbase/cdp-api-client";
-import "jose";
+import "@coinbase/cdp-api-client";
 import "viem";
-import "./index.web85.js";
-import { DEFAULT_SECURE_IFRAME_BASE_PATH as y, DEFAULT_SECURE_IFRAME_THEME as M, SECURE_IFRAME_EVENT_TYPE as C, SECURE_IFRAME_EVENT_TYPE_PREFIX as V, SECURE_IFRAME_KEY_EXPORT_EVENT_TYPE as f } from "./index.web80.js";
-import "./index.web86.js";
-import "@solana/web3.js";
-import "bs58";
-import "@solana/kit";
-import "zustand";
-E.registerPackageVersion("core", r);
+const t = "0x0000000000000000000000000000000000000000", s = {
+  userId: "mock-user-id",
+  evmAccounts: [t],
+  evmSmartAccounts: [],
+  solanaAccounts: ["5fNfvyp5f3BB9T24s6bC8QjDXuJqvU8WjziJpEQi9PWT"],
+  evmAccountObjects: [
+    {
+      address: t,
+      createdAt: "2024-01-01T00:00:00Z"
+    }
+  ],
+  evmSmartAccountObjects: [],
+  solanaAccountObjects: [
+    {
+      address: "5fNfvyp5f3BB9T24s6bC8QjDXuJqvU8WjziJpEQi9PWT",
+      createdAt: "2024-01-01T00:00:00Z"
+    }
+  ],
+  authenticationMethods: {
+    email: {
+      type: "email",
+      email: "test@test.com"
+    }
+  }
+};
 export {
-  c as APIError,
-  y as DEFAULT_SECURE_IFRAME_BASE_PATH,
-  M as DEFAULT_SECURE_IFRAME_THEME,
-  P as ErrorType,
-  U as EvmEip7702DelegationNetwork,
-  F as HttpErrorType,
-  I as OAuth2ProviderType,
-  C as SECURE_IFRAME_EVENT_TYPE,
-  V as SECURE_IFRAME_EVENT_TYPE_PREFIX,
-  f as SECURE_IFRAME_KEY_EXPORT_EVENT_TYPE,
-  d as SendEvmTransactionWithEndUserAccountBodyNetwork,
-  s as SendSolanaTransactionWithEndUserAccountBodyNetwork
+  t as mockAddress,
+  s as mockUser
 };

package/dist/web/index.web98.js

@@ -1,75 +1,43 @@
-import { DisconnectedError as l, from as d } from "./index.web113.js";
-import { validateRequest as h, EIP1193ProviderError as m, STANDARD_ERROR_CODES as _ } from "./index.web78.js";
-import { createEOAHandlers as p } from "./index.web114.js";
-import { createSmartAccountHandlers as g } from "./index.web115.js";
-import "viem";
-import "zustand";
-import "@coinbase/cdp-api-client";
-function v(c, a, r) {
-  a.subscribe(
-    (e) => e.chainId,
-    (e, t) => {
-      e !== t && c.emit("chainChanged", e);
-    }
-  ), a.subscribe(
-    (e) => e.user,
-    (e, t) => {
-      if (!(e?.userId === t?.userId && e?.evmAccounts?.length === t?.evmAccounts?.length)) {
-        if (!e && t) {
-          c.emit("disconnect", new l());
-          return;
-        }
-        if (e && e.evmAccounts?.length && (!t || t.evmAccounts?.length === 0)) {
-          const s = a.getState().chainId;
-          c.emit("connect", { chainId: s });
-          return;
-        }
-      }
-    }
-  );
-  const { chainId: i, setChainId: o } = a.getState(), u = i || r.chains[0].id;
-  return i || o(u), d({
-    request: async (e) => {
-      h(e, r);
-      const t = e, s = a.getState().user, n = !!(s?.evmSmartAccounts && s.evmSmartAccounts.length > 0) ? g() : p();
-      switch (t.method) {
-        case "eth_accounts":
-          return n.eth_accounts();
-        case "eth_requestAccounts":
-          return n.eth_requestAccounts(c, a);
-        case "personal_sign":
-          return n.personal_sign(t.params, a);
-        case "eth_sendTransaction":
-          return n.eth_sendTransaction(t.params, a, r.transports);
-        case "wallet_disconnect":
-          return n.wallet_disconnect();
-        case "wallet_switchEthereumChain":
-          return n.wallet_switchEthereumChain(t.params, a);
-        case "eth_sign":
-          return n.eth_sign(t.params, a);
-        case "eth_signTypedData_v4":
-          return n.eth_signTypedData_v4(t.params, a);
-        case "eth_chainId":
-          return n.eth_chainId(a);
-        case "wallet_sendCalls":
-          return n.wallet_sendCalls(t.params, a);
-        case "wallet_getCallsStatus":
-          return n.wallet_getCallsStatus(t.params, a);
-        case "wallet_getCapabilities":
-          return n.wallet_getCapabilities();
-        // Catch-all for any unknown method
-        default:
-          throw new m(
-            _.provider.unsupportedMethod,
-            `Method ${t.method} not supported`
-          );
-      }
-    },
-    // Event emitter methods - only the ones required by the interface
-    on: c.on.bind(c),
-    removeListener: c.removeListener.bind(c)
-  });
+import { CompactSign as i } from "./index.web117.js";
+import { JWTInvalid as r } from "./index.web118.js";
+import { JWTClaimsBuilder as n } from "./index.web119.js";
+class d {
+  #s;
+  #t;
+  constructor(t = {}) {
+    this.#t = new n(t);
+  }
+  setIssuer(t) {
+    return this.#t.iss = t, this;
+  }
+  setSubject(t) {
+    return this.#t.sub = t, this;
+  }
+  setAudience(t) {
+    return this.#t.aud = t, this;
+  }
+  setJti(t) {
+    return this.#t.jti = t, this;
+  }
+  setNotBefore(t) {
+    return this.#t.nbf = t, this;
+  }
+  setExpirationTime(t) {
+    return this.#t.exp = t, this;
+  }
+  setIssuedAt(t) {
+    return this.#t.iat = t, this;
+  }
+  setProtectedHeader(t) {
+    return this.#s = t, this;
+  }
+  async sign(t, e) {
+    const s = new i(this.#t.data());
+    if (s.setProtectedHeader(this.#s), Array.isArray(this.#s?.crit) && this.#s.crit.includes("b64") && this.#s.b64 === !1)
+      throw new r("JWTs MUST NOT use unencoded payload");
+    return s.sign(t, e);
+  }
 }
 export {
-  v as createProvider
+  d as SignJWT
 };

package/dist/web/index.web99.js

@@ -1,11 +1,51 @@
-import { AuthManager as r } from "./index.web72.js";
-import { CustomAuthManager as o } from "./index.web106.js";
-import "@coinbase/cdp-api-client";
-import "viem";
-import { getConfig as n } from "./index.web61.js";
-function a(t) {
-  return n().customAuth?.getJwt ? new o(t) : new r(t);
-}
+const t = "0xba5ed110efdba3d005bfc882d75358acbbb85842", e = [
+  {
+    inputs: [{ name: "implementation_", type: "address" }],
+    stateMutability: "payable",
+    type: "constructor"
+  },
+  { inputs: [], name: "OwnerRequired", type: "error" },
+  {
+    inputs: [
+      { name: "owners", type: "bytes[]" },
+      { name: "nonce", type: "uint256" }
+    ],
+    name: "createAccount",
+    outputs: [
+      {
+        name: "account",
+        type: "address"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "owners", type: "bytes[]" },
+      { name: "nonce", type: "uint256" }
+    ],
+    name: "getAddress",
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "implementation",
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "initCodeHash",
+    outputs: [{ name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
 export {
-  a as createAuthManager
+  e as COINBASE_SMART_WALLET_FACTORY_ABI,
+  t as COINBASE_SMART_WALLET_FACTORY_ADDRESS
 };

package/dist/web-types/actions/authenticateWithJWT.d.ts

@@ -1,4 +1,68 @@
 import { AuthenticateWithJWTResult } from '../types.js';
+/**
+ * Authenticates an end user using a developer-issued JWT from a third-party identity provider
+ * (e.g., Auth0, Firebase, Cognito, custom OIDC).
+ *
+ * This function validates the JWT, auto-creates the user if they don't exist, and provisions
+ * wallets based on your configuration.
+ *
+ * @param options - Optional options for the authentication.
+ * @param options.idempotencyKey - Optional idempotency key for safe retries.
+ *
+ * **Important**: Before using this function, you must:
+ * 1. Configure custom auth in the CDP Portal (JWKS endpoint, issuer, etc.)
+ * 2. Provide a `customAuth.getJwt` callback in your config to handle JWT refresh
+ *
+ * @example
+ * ```typescript lines
+ * // React - With Auth0
+ * import { useAuth0 } from '@auth0/auth0-react';
+ * import { initialize, authenticateWithJWT } from '@coinbase/cdp-core';
+ *
+ * const { getAccessTokenSilently } = useAuth0();
+ *
+ * await initialize({
+ *   projectId: 'my-project',
+ *   customAuth: {
+ *     getJwt: getAccessTokenSilently
+ *   },
+ *   ethereum: { createOnLogin: 'eoa' }
+ * });
+ *
+ * const result = await authenticateWithJWT();
+ * console.log(result.user); // Authenticated user with wallet
+ * ```
+ *
+ * @example
+ * ```typescript lines
+ * // React Native - With Auth0
+ * import { useAuth0 } from 'react-native-auth0';
+ * import { initialize, authenticateWithJWT } from '@coinbase/cdp-core';
+ *
+ * const { authorize, getCredentials } = useAuth0();
+ *
+ * await initialize({
+ *   projectId: 'my-project',
+ *   customAuth: {
+ *     getJwt: async () => {
+ *       const creds = await getCredentials();
+ *       return creds?.accessToken;
+ *     }
+ *   },
+ *   ethereum: { createOnLogin: 'eoa' }
+ * });
+ *
+ * // User clicks sign in - triggers Auth0 login
+ * await authorize();
+ *
+ * // Then authenticate with CDP
+ * const result = await authenticateWithJWT();
+ * console.log(result.user); // Authenticated user with wallet
+ * ```
+ *
+ * @returns The authentication result with user and wallet information
+ * @throws {CustomAuthError} If customAuth.getJwt callback is not configured or JWT retrieval fails
+ */
 export declare const authenticateWithJWT: (options?: {
     idempotencyKey?: string;
 }) => Promise<AuthenticateWithJWTResult>;

package/dist/web-types/actions/cancelMfaVerification.d.ts

@@ -1 +1,20 @@
+/**
+ * Cancels the current MFA verification flow.
+ *
+ * Call this when the user dismisses the MFA UI without completing verification.
+ * The original operation that triggered MFA will reject with an error.
+ *
+ * @example
+ * ```typescript
+ * // In your MFA modal's cancel button handler
+ * function MfaModal() {
+ *   const handleCancel = () => {
+ *     cancelMfaVerification();
+ *     closeModal();
+ *   };
+ *
+ *   return <button onClick={handleCancel}>Cancel</button>;
+ * }
+ * ```
+ */
 export declare const cancelMfaVerification: () => void;

package/dist/web-types/actions/createDelegation.d.ts

@@ -1,8 +1,26 @@
+/**
+ * Options for creating a delegation that allows a developer to sign on behalf of an end user.
+ */
 export type CreateDelegationOptions = {
+    /** The date until which the delegation is valid (ISO 8601 string). */
     expiresAt: string;
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/**
+ * Result of creating a delegation for an end user.
+ */
 export type CreateDelegationResult = {
+    /** The unique identifier for the delegation. */
     delegationId: string;
 };
+/**
+ * Creates a delegation that allows a developer to sign on behalf of an end user for the specified duration.
+ * The end user must be authenticated to authorize this delegation.
+ *
+ * @param options - Options for creating the delegation.
+ * @returns The delegation ID.
+ * @throws {InputValidationError} If `expiresAt` is not a valid date or is not in the future.
+ * @throws Error if the user is not signed in.
+ */
 export declare function createDelegation(options: CreateDelegationOptions): Promise<CreateDelegationResult>;

package/dist/web-types/actions/createEvmEip7702Delegation.d.ts

@@ -1,12 +1,39 @@
 import { EvmAddress } from '../types.js';
 import { EvmEip7702DelegationNetwork } from '@coinbase/cdp-api-client';
+/**
+ * Result of creating an EIP-7702 delegation.
+ */
 export type CreateEvmEip7702DelegationResult = {
+    /** The unique identifier for the delegation operation. Use this to poll the operation status. */
     delegationOperationId: string;
 };
+/**
+ * Options for creating an EIP-7702 delegation for an EVM EOA account.
+ */
 export type CreateEvmEip7702DelegationOptions = {
+    /** The 0x-prefixed address of the EVM EOA account to delegate. Must belong to the current user. */
     address: EvmAddress;
+    /** The network to create the delegation on. */
     network: EvmEip7702DelegationNetwork;
+    /**
+     * Whether to configure spend permissions for the upgraded, delegated account.
+     * When enabled, the account can grant permissions for third parties to spend on its behalf.
+     * Defaults to false.
+     */
     enableSpendPermissions?: boolean;
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/**
+ * Creates an EIP-7702 delegation for an end user's EVM EOA account, upgrading it with smart account capabilities.
+ *
+ * This endpoint retrieves delegation artifacts from onchain, signs the EIP-7702 authorization,
+ * submits a Type 4 transaction, and creates an associated smart account object. After success,
+ * the local auth state is refreshed so the new smart account appears in the user's account list.
+ *
+ * @param options - Options for creating the EIP-7702 delegation.
+ * @returns The delegation operation ID for polling the operation status.
+ * @throws Error if the user is not signed in.
+ * @throws Error if the address does not belong to the current user.
+ */
 export declare function createEvmEip7702Delegation(options: CreateEvmEip7702DelegationOptions): Promise<CreateEvmEip7702DelegationResult>;

package/dist/web-types/actions/createEvmEoaAccount.d.ts

@@ -1,5 +1,17 @@
 import { Address } from 'viem';
+/**
+ * Options for creating an EVM EOA account.
+ */
 export type CreateEvmEoaAccountOptions = {
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/**
+ * Creates an EVM EOA (Externally Owned Account) for the current user.
+ * Multiple EVM EOA accounts can be created per user.
+ *
+ * @param options - Optional options for creating the account.
+ * @returns The address of the newly created EVM EOA account.
+ * @throws Error if the user is not signed in.
+ */
 export declare function createEvmEoaAccount(options?: CreateEvmEoaAccountOptions): Promise<Address>;

package/dist/web-types/actions/createEvmSmartAccount.d.ts

@@ -1,7 +1,32 @@
 import { EvmAddress } from '../types.js';
+/**
+ * Options for creating a Smart Account.
+ */
 export type CreateEvmSmartAccountOptions = {
+    /**
+     * Optional owner address for the smart account.
+     * If not provided, a new EOA will be created as the owner.
+     * If the owner already controls a smart account, an error will be thrown.
+     */
     owner?: EvmAddress;
+    /**
+     * Whether to enable spend permissions for the smart account.
+     * Setting this to true is necessary in order to create spend permissions.
+     * Only new accounts can be created with spend permissions enabled.
+     * Defaults to false.
+     */
     enableSpendPermissions?: boolean;
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/**
+ * Creates an EVM Smart Account for the current user.
+ * Multiple EVM Smart Accounts can be created per user.
+ * If no owner is provided, a new EVM EOA account will be created automatically as the owner.
+ *
+ * @param options - Options for creating the EVM Smart Account.
+ * @returns The address of the newly created EVM Smart Account.
+ * @throws Error if the user is not signed in.
+ * @throws Error if the provided owner already controls a smart account.
+ */
 export declare function createEvmSmartAccount(options?: CreateEvmSmartAccountOptions): Promise<EvmAddress>;

package/dist/web-types/actions/createKeyExportIframe.d.ts

@@ -1,18 +1,166 @@
 import { SecureIframeStatus, SecureIframeTheme } from '../secureIframe/types.js';
+/**
+ * Options for setting up a key export iframe.
+ */
 export interface CreateKeyExportIframeOptions {
+    /**
+     * The address of the account to export.
+     */
     address: string;
+    /**
+     * The target element: either a CSS selector string or an HTMLElement container.
+     * An iframe will be created and appended to the target container.
+     */
     target: string | HTMLElement;
+    /**
+     * The project ID for authentication.
+     */
     projectId: string;
+    /**
+     * The label for the button displayed in the iframe.
+     */
     label?: string;
+    /**
+     * The label to display when the key is copied successfully.
+     */
     copiedLabel?: string;
+    /**
+     * Whether to show an icon in the button.
+     *
+     * @default true
+     */
     icon?: boolean;
+    /**
+     * Theme overrides for the iframe button.
+     */
     theme?: Partial<SecureIframeTheme>;
+    /**
+     * Callback invoked when the iframe status changes.
+     */
     onStatusUpdate?: (status: SecureIframeStatus, message?: string) => void;
 }
+/**
+ * Result of setting up a key export iframe.
+ */
 export interface CreateKeyExportIframeResult {
+    /**
+     * The iframe element that was set up.
+     */
     iframe: HTMLIFrameElement;
+    /**
+     * Function to clean up event listeners and remove the iframe.
+     */
     cleanup: () => void;
+    /**
+     * Function to update the theme of the iframe.
+     */
     updateTheme: (theme: Partial<SecureIframeTheme>) => void;
 }
+/**
+ * Sets up a secure iframe for exporting EVM private keys.
+ *
+ * This function handles the communication with a secure iframe that safely
+ * exports EVM private keys to the user's clipboard without exposing them to the
+ * JavaScript context.
+ *
+ * The iframe will be automatically cleaned up when the session expires (status "expired").
+ * The `cleanup` function is idempotent, so it's safe to call it in your teardown code
+ * even if the iframe has already been cleaned up due to expiration.
+ *
+ * @param {CreateKeyExportIframeOptions} options - Configuration options for the EVM key export iframe.
+ * @returns {CreateKeyExportIframeResult} An object containing the iframe element, cleanup function, and theme update function.
+ *
+ * @example
+ * ```typescript
+ * // Using a CSS selector for the container
+ * const { iframe, cleanup } = await createEvmKeyExportIframe({
+ *   address: "0x1234...",
+ *   target: "#key-export-container",
+ *   projectId: "your-project-id",
+ *   label: "Copy Private Key",
+ *   onStatusUpdate: (status, message) => {
+ *     if (status === "success") {
+ *       console.log("Key copied!");
+ *     } else if (status === "error") {
+ *       console.error("Error:", message);
+ *     }
+ *   }
+ * });
+ *
+ * // Later, clean up. Iframe will auto cleanup when it expires.
+ * cleanup();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using an HTMLElement container directly
+ * const container = document.getElementById("my-container") as HTMLElement;
+ * const { cleanup, updateTheme } = await createEvmKeyExportIframe({
+ *   address: "0x1234...",
+ *   target: container,
+ *   projectId: "your-project-id",
+ *   theme: {
+ *     buttonBg: "#0052ff",
+ *     buttonText: "#ffffff"
+ *   }
+ * });
+ *
+ * // Update theme later
+ * updateTheme({ buttonBg: "#ff0000" });
+ * ```
+ */
 export declare function createEvmKeyExportIframe(options: CreateKeyExportIframeOptions): Promise<CreateKeyExportIframeResult>;
+/**
+ * Sets up a secure iframe for exporting Solana private keys.
+ *
+ * This function handles the communication with a secure iframe that safely
+ * exports Solana private keys to the user's clipboard without exposing them to the
+ * JavaScript context.
+ *
+ * The iframe will be automatically cleaned up when the session expires (status "expired").
+ * The `cleanup` function is idempotent, so it's safe to call it in your teardown code
+ * even if the iframe has already been cleaned up due to expiration.
+ *
+ * @param {CreateKeyExportIframeOptions} options - Configuration options for the Solana key export iframe.
+ * @returns {CreateKeyExportIframeResult} An object containing the iframe element, cleanup function, and theme update function.
+ *
+ * @example
+ * ```typescript
+ * // Using a CSS selector for the container
+ * const { iframe, cleanup } = await createSolanaKeyExportIframe({
+ *   address: "9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM",
+ *   target: "#key-export-container",
+ *   projectId: "your-project-id",
+ *   label: "Copy Private Key",
+ *   onStatusUpdate: (status, message) => {
+ *     if (status === "success") {
+ *       console.log("Key copied!");
+ *     } else if (status === "error") {
+ *       console.error("Error:", message);
+ *     }
+ *   }
+ * });
+ *
+ * // Later, clean up. Iframe will auto cleanup when it expires.
+ * cleanup();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using an HTMLElement container directly
+ * const container = document.getElementById("my-container") as HTMLElement;
+ * const { cleanup, updateTheme } = await createSolanaKeyExportIframe({
+ *   address: "9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM",
+ *   target: container,
+ *   projectId: "your-project-id",
+ *   theme: {
+ *     buttonBg: "#9945ff",
+ *     buttonText: "#ffffff"
+ *   }
+ * });
+ *
+ * // Update theme later
+ * updateTheme({ buttonBg: "#ff0000" });
+ * ```
+ */
 export declare function createSolanaKeyExportIframe(options: CreateKeyExportIframeOptions): Promise<CreateKeyExportIframeResult>;

package/dist/web-types/actions/createSolanaAccount.d.ts

@@ -1,5 +1,17 @@
 import { SolanaAddress } from '../types.js';
+/**
+ * Options for creating a Solana account.
+ */
 export type CreateSolanaAccountOptions = {
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/**
+ * Creates a Solana account for the current user.
+ * Multiple Solana accounts can be created per user.
+ *
+ * @param options - Optional options for creating the account.
+ * @returns The address of the newly created Solana account.
+ * @throws Error if the user is not signed in.
+ */
 export declare function createSolanaAccount(options?: CreateSolanaAccountOptions): Promise<SolanaAddress>;