@coinbase/cdp-core 0.0.24 → 0.0.26

package/README.md

@@ -37,7 +37,7 @@ in CDP Portal, and click Add origin to include your local app
 
 Before calling any methods in the SDK, you must first initialize it:
 
-```ts
+```ts lines
 import { Config, initialize } from "@coinbase/cdp-core";
 
 const config: Config = {
@@ -52,7 +52,7 @@ await initialize(config);
 
 You can configure the SDK to automatically create Smart Accounts for new users by setting `createAccountOnLogin` to `"evm-smart"`:
 
-```ts
+```ts lines
 const config: Config = {
   projectId: "your-project-id",
   createAccountOnLogin: "evm-smart", // Creates Smart Accounts instead of EOAs
@@ -71,7 +71,7 @@ When `createAccountOnLogin` is set to `"evm-smart"`, the SDK will:
 You're now ready to start calling the APIs provided by the package!
 The following code signs in an end user:
 
-```ts
+```ts lines
 import { signInWithEmail, verifyEmailOTP } from "@coinbase/cdp-core";
 
 // Send an email to user@example.com with a One Time Password (OTP).
@@ -92,7 +92,7 @@ const user = verifyResult.user;
 ### View User Information
 Once the end user has signed in, you can display their information in your application:
 
-```typescript
+```typescript lines
 import { getCurrentUser, isSignedIn } from "@coinbase/cdp-core";
 
 // Check if user is signed in
@@ -122,7 +122,7 @@ We support signing and sending a Blockchain transaction in a single call on the
 - Optimism
 - Polygon
 
-```typescript
+```typescript lines
 import { sendEvmTransaction, getCurrentUser } from "@coinbase/cdp-core";
 
 const user = await getCurrentUser();
@@ -148,7 +148,7 @@ console.log("Transaction Hash:", result.transactionHash);
 For networks other than those supported by the CDP APIs, 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
+```typescript lines
 import { signEvmTransaction, getCurrentUser } from "@coinbase/cdp-core";
 import { http, createPublicClient } from "viem";
 import { tron } from "viem/chains";
@@ -190,7 +190,7 @@ Smart Accounts provide advanced account abstraction features, including user ope
 
 Send user operations from a Smart Account:
 
-```typescript
+```typescript lines
 import { sendUserOperation, getCurrentUser } from "@coinbase/cdp-core";
 
 const user = await getCurrentUser();
@@ -217,7 +217,7 @@ console.log("User Operation Hash:", result.userOperationHash);
 
 After sending a user operation, you can get its status and retrieve the result:
 
-```typescript
+```typescript lines
 import { getUserOperation } from "@coinbase/cdp-core";
 
 // Get the status of a user operation
@@ -241,7 +241,7 @@ if (userOperationResult.status === "complete") {
 
 End users can sign EVM messages, hashes, and typed data to generate signatures for various onchain applications.
 
-```typescript
+```typescript lines
 import { signEvmMessage, signEvmTypedData, getCurrentUser } from "@coinbase/cdp-core";
 
 const user = await getCurrentUser();
@@ -281,7 +281,7 @@ const typedDataResult = await signEvmTypedData({
 
 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
+```typescript lines
 import { exportEvmAccount, getCurrentUser } from "@coinbase/cdp-core";
 
 const user = await getCurrentUser();
@@ -302,7 +302,7 @@ The core package includes an EIP-1193 compatible provider. This provider can be
 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
+```typescript lines
 import { base, mainnet } from "viem/chains";
 import { http } from "viem"
 
@@ -351,7 +351,7 @@ provider.on("disconnect", () => {
 
 The core package includes a `toViemAccount` utility function that enables wrapping an embedded wallet into a Viem account compatible interface. This allows the account to act as a drop-in replacement for any library or framework that accepts Viem accounts.
 
-```typescript
+```typescript lines
 import { toViemAccount, getCurrentUser } from "@coinbase/cdp-core";
 import { createWalletClient } from "viem";
 import { mainnet } from "viem/chains";

package/dist/esm/index.native.js

@@ -0,0 +1,47 @@
+import { nativeCrypto as r } from "./index.native2.js";
+import { nativeStorage as e } from "./index.native3.js";
+import { setPlatformServices as o } from "./index.native4.js";
+import { exportEvmAccount as g, getAccessToken as c, getCurrentUser as f, getUserOperation as v, initialize as d, 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.native5.js";
+import { AuthManager as U } from "./index.native6.js";
+import { APIError as M, ErrorType as k, HttpErrorType as H, SendEvmTransactionWithEndUserAccountBodyNetwork as N } from "@coinbase/cdp-api-client";
+import "viem";
+import { createCDPEmbeddedWallet as b } from "./index.native7.js";
+import { EIP1193ProviderError as z, STANDARD_ERROR_CODES as B } from "./index.native8.js";
+import "ox";
+import "zustand";
+import { toViemAccount as j } from "./index.native9.js";
+import { ModuleResolutionError as F } from "./index.native10.js";
+o({
+  crypto: r,
+  storage: e
+});
+export {
+  M as APIError,
+  U as AuthManager,
+  z as EIP1193ProviderError,
+  k as ErrorType,
+  H as HttpErrorType,
+  F as ModuleResolutionError,
+  B as STANDARD_ERROR_CODES,
+  N as SendEvmTransactionWithEndUserAccountBodyNetwork,
+  b as createCDPEmbeddedWallet,
+  g as exportEvmAccount,
+  c as getAccessToken,
+  f as getCurrentUser,
+  v as getUserOperation,
+  d 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.native10.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.native101.js

@@ -0,0 +1,19 @@
+import n from "./index.native78.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/index.native102.js

@@ -0,0 +1,83 @@
+import { JOSENotSupported as s } from "./index.native27.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/index.native104.js

@@ -0,0 +1,38 @@
+import { hexToBigInt as n } from "./index.native47.js";
+import { defineBlock as r } from "./index.native44.js";
+import { defineTransaction as s, formatTransaction as m } from "./index.native46.js";
+import { defineTransactionReceipt as l } from "./index.native49.js";
+const p = {
+  block: /* @__PURE__ */ r({
+    format(e) {
+      return {
+        transactions: e.transactions?.map((t) => {
+          if (typeof t == "string")
+            return t;
+          const i = m(t);
+          return i.typeHex === "0x7e" && (i.isSystemTx = t.isSystemTx, i.mint = t.mint ? n(t.mint) : void 0, i.sourceHash = t.sourceHash, i.type = "deposit"), i;
+        }),
+        stateRoot: e.stateRoot
+      };
+    }
+  }),
+  transaction: /* @__PURE__ */ s({
+    format(e) {
+      const o = {};
+      return e.type === "0x7e" && (o.isSystemTx = e.isSystemTx, o.mint = e.mint ? n(e.mint) : void 0, o.sourceHash = e.sourceHash, o.type = "deposit"), o;
+    }
+  }),
+  transactionReceipt: /* @__PURE__ */ l({
+    format(e) {
+      return {
+        l1GasPrice: e.l1GasPrice ? n(e.l1GasPrice) : null,
+        l1GasUsed: e.l1GasUsed ? n(e.l1GasUsed) : null,
+        l1Fee: e.l1Fee ? n(e.l1Fee) : null,
+        l1FeeScalar: e.l1FeeScalar ? Number(e.l1FeeScalar) : null
+      };
+    }
+  })
+};
+export {
+  p as formatters
+};

package/dist/esm/index.native105.js

@@ -0,0 +1,44 @@
+import { InvalidAddressError as a } from "./index.native62.js";
+import { isAddress as f } from "./index.native36.js";
+import { concatHex as p } from "./index.native37.js";
+import { toHex as i } from "./index.native31.js";
+import { toRlp as x } from "./index.native50.js";
+import { serializeTransaction as l } from "./index.native19.js";
+function T(r, e) {
+  return h(r) ? z(r) : l(r, e);
+}
+const E = {
+  transaction: T
+};
+function z(r) {
+  w(r);
+  const { sourceHash: e, data: o, from: m, gas: t, isSystemTx: u, mint: s, to: c, value: n } = r, d = [
+    e,
+    m,
+    c ?? "0x",
+    s ? i(s) : "0x",
+    n ? i(n) : "0x",
+    t ? i(t) : "0x",
+    u ? "0x1" : "0x",
+    o ?? "0x"
+  ];
+  return p([
+    "0x7e",
+    x(d)
+  ]);
+}
+function h(r) {
+  return r.type === "deposit" || typeof r.sourceHash < "u";
+}
+function w(r) {
+  const { from: e, to: o } = r;
+  if (e && !f(e))
+    throw new a({ address: e });
+  if (o && !f(o))
+    throw new a({ address: o });
+}
+export {
+  w as assertTransactionDeposit,
+  T as serializeTransaction,
+  E as serializers
+};

package/dist/esm/index.native11.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.native12.js

@@ -0,0 +1,11 @@
+function t(e) {
+  if (typeof TextDecoder < "u")
+    return new TextDecoder().decode(e);
+  let r = "";
+  for (let o = 0; o < e.length; o++)
+    r += String.fromCharCode(e[o]);
+  return decodeURIComponent(escape(r));
+}
+export {
+  t as decodeText
+};

package/dist/esm/index.native15.js

@@ -0,0 +1,121 @@
+import "@coinbase/cdp-api-client";
+import "viem";
+import { mockUser as e } from "./index.native16.js";
+class r {
+  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 {
+  r as MockAuthManager
+};