@coinbase/cdp-core 0.0.0 → 0.0.5

package/README.md

@@ -0,0 +1,255 @@
+This package contains core business logic for the CDP Frontend SDK.
+It is intended for non-React applications that use pure Typescript.
+
+## Quickstart
+
+This guide will help you get started with `@coinbase/cdp-core`. You'll learn how to install the package,
+initialize the SDK, and make your first API call.
+
+### Installation
+
+First, add the package to your project using your preferred package manager.
+
+```bash
+# With pnpm
+pnpm add @coinbase/cdp-core
+
+# With yarn
+yarn add @coinbase/cdp-core
+
+# With npm
+npm install @coinbase/cdp-core
+```
+
+### Gather your CDP Project information
+
+1. Sign in or create an account on the [CDP Portal](https://portal.cdp.coinbase.com)
+2. On your dashboard, select a project from the dropdown at the at the top, and copy the Project ID
+
+### Initialize the SDK
+
+Before calling any methods in the SDK, you must first initialize it:
+
+```ts
+import { Config, initialize } from "@coinbase/cdp-core";
+
+const config: Config = {
+  // Copy and paste your project ID here.
+  projectId: "your-project-id",
+}
+
+await initialize(config);
+```
+
+### Sign In a User
+
+You're now ready to start calling the APIs provided by the package!
+The following code signs in an end user:
+
+```ts
+import { signInWithEmail, verifyEmailOTP } from "@coinbase/cdp-core";
+
+// Send an email to user@example.com with a One Time Password (OTP).
+const authResult = await signInWithEmail({
+  email: "user@example.com"
+});
+
+// Input the OTP sent to user@example.com.
+const verifyResult = await verifyEmailOTP({
+  flowId: authResult.flowId,
+  otp: "123456", // Hardcoded for convenience here.
+});
+
+// Get the authenticated end user.
+const user = verifyResult.user;
+```
+
+### View User Information
+Once the end user has signed in, you can display their information in your application:
+
+```typescript
+import { getCurrentUser, isSignedIn } from "@coinbase/cdp-core";
+
+// Check if user is signed in
+const signedIn = await isSignedIn();
+
+if (signedIn) {
+  // Get the user's information
+  const user = await getCurrentUser();
+  console.log("User ID:", user.userId);
+  console.log("EVM Accounts:", user.evmAccounts);
+}
+```
+
+### Send a Transaction
+We support signing and sending a Blockchain transaction in a single call on Base or Base Sepolia:
+
+```typescript
+import { sendEvmTransaction, getCurrentUser } from "@coinbase/cdp-core";
+
+const user = await getCurrentUser();
+const evmAccount = user.evmAccounts[0];
+
+const result = await sendEvmTransaction({
+  evmAccount,
+  transaction: {
+    to: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    value: 100000000000000n, // 0.0001 ETH in wei
+    nonce: 0,
+    gas: 21000n,
+    maxFeePerGas: 30000000000n,
+    maxPriorityFeePerGas: 1000000000n,
+    chainId: 84532, // Base Sepolia
+    type: "eip1559",
+  }
+});
+
+console.log("Transaction Hash:", result.transactionHash);
+```
+
+For networks other than Base or Base Sepolia, your end user must sign the transaction, and then
+you must broadcast the transaction yourself. This example uses the public client from `viem` to broadcast the transaction. 
+
+```typescript
+import { signEvmTransaction, getCurrentUser } from "@coinbase/cdp-core";
+import { http, createPublicClient } from "viem";
+import { sepolia } from "viem/chains";
+
+const user = await getCurrentUser();
+const evmAccount = user.evmAccounts[0];
+
+// Sign the transaction
+const { signedTransaction } = await signEvmTransaction({
+  evmAccount,
+  transaction: {
+    to: "0x...",
+    value: 100000000000000n,
+    nonce: 0,
+    gas: 21000n,
+    maxFeePerGas: 30000000000n,
+    maxPriorityFeePerGas: 1000000000n,
+    chainId: 11155111, // Sepolia
+    type: "eip1559",
+  }
+});
+
+// Broadcast signed transaction to non-Base chain
+const client = createPublicClient({
+  chain: sepolia,
+  transport: http()
+});
+
+const hash = await client.sendRawTransaction({
+  serializedTransaction: signedTransaction
+});
+```
+
+### Sign Messages and Typed Data
+
+End users can sign EVM messages, hashes, and typed data to generate signatures for various onchain applications.
+
+```typescript
+import { signEvmMessage, signEvmTypedData, getCurrentUser } from "@coinbase/cdp-core";
+
+const user = await getCurrentUser();
+const evmAccount = user.evmAccounts[0];
+
+// Sign a message
+const messageResult = await signEvmMessage({
+  evmAccount,
+  message: "Hello World"
+});
+
+// Sign typed data (EIP-712)
+const typedDataResult = await signEvmTypedData({
+  evmAccount,
+  typedData: {
+    domain: {
+      name: "Example DApp",
+      version: "1",
+      chainId: 84532,
+    },
+    types: {
+      Person: [
+        { name: "name", type: "string" },
+        { name: "wallet", type: "address" }
+      ]
+    },
+    primaryType: "Person",
+    message: {
+      name: "Bob",
+      wallet: evmAccount
+    }
+  }
+});
+```
+
+### Export Private Key
+
+End users can export their private keys from their embedded wallet, allowing them to import it into an EVM-compatible wallet of their choice.
+
+```typescript
+import { exportEvmAccount, getCurrentUser } from "@coinbase/cdp-core";
+
+const user = await getCurrentUser();
+const evmAccount = user.evmAccounts[0];
+
+const { privateKey } = await exportEvmAccount({
+  evmAccount
+});
+
+// WARNING: Handle private keys with extreme care!
+console.log("Private Key:", privateKey);
+```
+
+### EIP-1193 Provider
+
+The core package includes an EIP-1193 compatible provider. This provider can be used to sign and send transactions.
+
+The provider is created by calling `createCDPEmbeddedWallet`, which exposes a `.provider` attribute. `createCDPEmbeddedWallet` must be called with the desired chains to support as well as the transports for these chains. 
+
+The provider will initially connect to the first chain in the `chains` array. The transports are typically HTTP RPC endpoints, which are used internally for broadcasting non-Base transactions. For more information on transports, see [Wagmi's `createConfig` setup](https://wagmi.sh/react/api/createConfig).
+```typescript
+import { base, mainnet } from "viem/chains";
+import { http } from "viem"
+
+// Basic usage with default configuration
+const wallet = createCDPEmbeddedWallet({
+  chains:[base, mainnet],
+  transports: {
+    [base.id]: http(),
+    [mainnet.id]: http()
+  }
+});
+const provider = wallet.provider;
+
+// Request account access
+const accounts = await provider.request({
+  method: "eth_requestAccounts"
+});
+
+// Sign a message
+const signature = await provider.request({
+  method: "personal_sign",
+  params: ["Hello, World!", accounts[0]]
+});
+
+// Send a transaction
+const txHash = await provider.request({
+  method: "eth_sendTransaction",
+  params: [{
+    from: accounts[0],
+    to: "0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6",
+    value: "0x1000000000000000000"
+  }]
+});
+
+// Listen for connection events
+provider.on("connect", (connectInfo) => {
+  console.log("Connected to chain:", connectInfo.chainId);
+});
+
+provider.on("disconnect", () => {
+  console.log("Disconnected from wallet");
+});
+```

package/dist/esm/index.js

@@ -0,0 +1,21 @@
+import { exportEvmAccount as n, getCurrentUser as r, initialize as t, isSignedIn as a, onAuthStateChange as s, sendEvmTransaction as o, signEvmHash as E, signEvmMessage as m, signEvmTransaction as g, signEvmTypedData as v, signInWithEmail as d, signOut as c, verifyEmailOTP as l } from "./index2.js";
+import { createCDPEmbeddedWallet as D } from "./index3.js";
+import { EIP1193ProviderError as f, STANDARD_ERROR_CODES as h } from "./index4.js";
+export {
+  f as EIP1193ProviderError,
+  h as STANDARD_ERROR_CODES,
+  D as createCDPEmbeddedWallet,
+  n as exportEvmAccount,
+  r as getCurrentUser,
+  t as initialize,
+  a as isSignedIn,
+  s as onAuthStateChange,
+  o as sendEvmTransaction,
+  E as signEvmHash,
+  m as signEvmMessage,
+  g as signEvmTransaction,
+  v as signEvmTypedData,
+  d as signInWithEmail,
+  c as signOut,
+  l as verifyEmailOTP
+};

package/dist/esm/index10.js

@@ -0,0 +1,119 @@
+import { mockUser as e } from "./index11.js";
+class h {
+  authState = null;
+  authStateChangeCallback = null;
+  /**
+   * Initializes the mock auth manager.
+   *
+   * @param _projectId - The project ID (unused in mock implementation).
+   */
+  constructor(t) {
+  }
+  /**
+   * Awaitable method whose promise only resolves when the auth manager is ready to be used.
+   *
+   * @returns A promise that resolves when the auth manager is ready to be used.
+   */
+  async ensureInitialized() {
+    return Promise.resolve();
+  }
+  /**
+   * Gets the current user, or null if there is no user signed in.
+   *
+   * @returns The current mock user if signed in, null otherwise.
+   */
+  async getUser() {
+    return this.authState?.user ?? null;
+  }
+  /**
+   * Returns whether the user is signed in - i.e., whether there is an unexpired
+   * access token and user.
+   *
+   * @returns True if the mock user is signed in and token is not expired, false otherwise.
+   */
+  async isSignedIn() {
+    return this.authState ? Promise.resolve(this.authState.expiresAt > Date.now()) : Promise.resolve(!1);
+  }
+  /**
+   * Signs out the user, clearing all authentication state.
+   * In the mock implementation, this simply clears the local auth state.
+   */
+  async signOut() {
+    await this.clearAuthState();
+  }
+  /**
+   * Sets a callback to be called when the auth state changes.
+   * The callback is immediately called with the current auth state.
+   *
+   * @param callback - The function to call when the auth state changes.
+   *                  Will be called with the current user or null.
+   */
+  addAuthStateChangeCallback(t) {
+    this.authStateChangeCallback = t, t(this.authState?.user ?? null);
+  }
+  /**
+   * Gets the access token. For mock, this always returns a valid token if signed in.
+   * If the current token is expired, it will be refreshed automatically.
+   *
+   * @returns The mock access token if signed in, null otherwise.
+   */
+  async getToken() {
+    return this.authState ? (this.authState.expiresAt <= Date.now() && await this.refreshToken(), this.authState?.accessToken ?? null) : null;
+  }
+  /**
+   * Gets the currentlly registered wallet secret ID.
+   *
+   * @returns The wallet secret ID.
+   */
+  async getWalletSecretId() {
+    return "mock-wallet-secret-id";
+  }
+  /**
+   * Gets the X-Wallet-Auth header value.
+   *
+   * @param _options - The options for the request.
+   * @param _options.requestMethod - The HTTP method of the request.
+   * @param _options.requestHost - The host of the request.
+   * @param _options.requestPath - The path of the request.
+   * @param _options.requestData - The data of the request.
+   * @returns The X-Wallet-Auth header value.
+   */
+  async getXWalletAuth(t) {
+    if (!this.authState)
+      throw new Error("User not signed in");
+    return "x-wallet-auth";
+  }
+  /**
+   * Sets the authentication state.
+   * This will trigger the auth state change callback if one is registered.
+   *
+   * @param authState - The new authentication state to set.
+   */
+  async setAuthState(t) {
+    this.authState = t, this.authStateChangeCallback && this.authStateChangeCallback(this.authState?.user ?? null);
+  }
+  /**
+   * Clears the authentication state.
+   * This will trigger the auth state change callback if one is registered.
+   */
+  async clearAuthState() {
+    this.authState = null, this.authStateChangeCallback && this.authStateChangeCallback(null);
+  }
+  /**
+   * Refreshes the mock token.
+   * Only refreshes if there is an existing auth state (user is signed in).
+   * Sets a new mock token with a 24-hour expiration.
+   *
+   * @private
+   */
+  async refreshToken() {
+    this.authState && await this.setAuthState({
+      accessToken: "mock-access-token",
+      expiresAt: Date.now() + 1e3 * 60 * 60 * 24,
+      user: e
+    });
+  }
+}
+export {
+  h as MockAuthManager
+};

package/dist/esm/index100.js

@@ -0,0 +1,19 @@
+import n from "./index82.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
+};

package/dist/esm/index101.js

@@ -0,0 +1,83 @@
+import { JOSENotSupported as s } from "./index68.js";
+function n(e) {
+  let a, r;
+  switch (e.kty) {
+    case "RSA": {
+      switch (e.alg) {
+        case "PS256":
+        case "PS384":
+        case "PS512":
+          a = { name: "RSA-PSS", hash: `SHA-${e.alg.slice(-3)}` }, r = e.d ? ["sign"] : ["verify"];
+          break;
+        case "RS256":
+        case "RS384":
+        case "RS512":
+          a = { name: "RSASSA-PKCS1-v1_5", hash: `SHA-${e.alg.slice(-3)}` }, r = e.d ? ["sign"] : ["verify"];
+          break;
+        case "RSA-OAEP":
+        case "RSA-OAEP-256":
+        case "RSA-OAEP-384":
+        case "RSA-OAEP-512":
+          a = {
+            name: "RSA-OAEP",
+            hash: `SHA-${parseInt(e.alg.slice(-3), 10) || 1}`
+          }, r = e.d ? ["decrypt", "unwrapKey"] : ["encrypt", "wrapKey"];
+          break;
+        default:
+          throw new s('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
+      }
+      break;
+    }
+    case "EC": {
+      switch (e.alg) {
+        case "ES256":
+          a = { name: "ECDSA", namedCurve: "P-256" }, r = e.d ? ["sign"] : ["verify"];
+          break;
+        case "ES384":
+          a = { name: "ECDSA", namedCurve: "P-384" }, r = e.d ? ["sign"] : ["verify"];
+          break;
+        case "ES512":
+          a = { name: "ECDSA", namedCurve: "P-521" }, r = e.d ? ["sign"] : ["verify"];
+          break;
+        case "ECDH-ES":
+        case "ECDH-ES+A128KW":
+        case "ECDH-ES+A192KW":
+        case "ECDH-ES+A256KW":
+          a = { name: "ECDH", namedCurve: e.crv }, r = e.d ? ["deriveBits"] : [];
+          break;
+        default:
+          throw new s('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
+      }
+      break;
+    }
+    case "OKP": {
+      switch (e.alg) {
+        case "Ed25519":
+        case "EdDSA":
+          a = { name: "Ed25519" }, r = e.d ? ["sign"] : ["verify"];
+          break;
+        case "ECDH-ES":
+        case "ECDH-ES+A128KW":
+        case "ECDH-ES+A192KW":
+        case "ECDH-ES+A256KW":
+          a = { name: e.crv }, r = e.d ? ["deriveBits"] : [];
+          break;
+        default:
+          throw new s('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
+      }
+      break;
+    }
+    default:
+      throw new s('Invalid or unsupported JWK "kty" (Key Type) Parameter value');
+  }
+  return { algorithm: a, keyUsages: r };
+}
+const i = async (e) => {
+  if (!e.alg)
+    throw new TypeError('"alg" argument is required when "jwk.alg" is not present');
+  const { algorithm: a, keyUsages: r } = n(e), t = { ...e };
+  return delete t.alg, delete t.use, crypto.subtle.importKey("jwk", t, a, e.ext ?? !e.d, e.key_ops ?? r);
+};
+export {
+  i as default
+};

package/dist/esm/index102.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/index11.js

@@ -0,0 +1,8 @@
+const s = "0x0000000000000000000000000000000000000000", c = {
+  userId: "mock-user-id",
+  evmAccounts: [s]
+};
+export {
+  s as mockAddress,
+  c as mockUser
+};

package/dist/esm/index12.js

@@ -0,0 +1,18 @@
+import { SendEvmTransactionWithEndUserAccountBodyNetwork as i } from "@coinbase/cdp-api-client";
+const n = (e) => !e || typeof e != "object" ? e : Array.isArray(e) ? e.map(n) : Object.keys(e).sort().reduce(
+  (r, t) => (r[t] = n(e[t]), r),
+  {}
+), o = (e) => Object.values(i).includes(
+  e
+), s = {
+  "base-sepolia": 84532,
+  base: 8453
+}, c = Object.fromEntries(
+  Object.entries(s).map(([e, r]) => [r, e])
+), p = (e) => Object.values(s).includes(e);
+export {
+  c as chainIdToNameMapping,
+  p as isChainIdSupportedForCDPSends,
+  o as isChainSupportedForCDPSends,
+  n as sortKeys
+};