@coinbase/cdp-core 0.0.92 → 0.0.94

package/dist/esm/index.native4.js

@@ -1,110 +1,206 @@
-import { ModuleResolutionError as n } from "./index.native72.js";
-import { decodeBase64 as c, encodeBase64 as a } from "./index.native76.js";
-import "@coinbase/cdp-api-client";
+import { APIError as c, generateAttestationChallenge as l, registerAttestation as u } from "@coinbase/cdp-api-client";
+import { getConfig as f } from "./index.native62.js";
 import "viem";
-const l = {
+import { nativeDeviceInfo as w } from "./index.native6.js";
+let n = null, d = !1;
+const h = {
+  isEnabled: !1,
+  cloudProjectNumber: void 0,
   /**
-   * Creates a secp256r1 key pair for React Native.
+   * Check if device attestation is supported on this device.
    *
-   * @returns A promise that resolves to a key pair.
+   * @returns Promise resolving to true if attestation is supported.
    */
-  async createKeyPair() {
-    if (typeof crypto > "u" || !crypto.subtle)
-      throw new n("react-native-quick-crypto", "crypto.subtle");
-    const e = await crypto.subtle.generateKey(
-      {
-        name: "ECDSA",
-        namedCurve: "P-256"
-        // secp256r1
-      },
-      !1,
-      // Do not allow key export for security
-      ["sign", "verify"]
-      // Key usages
-    ), t = await crypto.subtle.exportKey("spki", e.publicKey), r = new Uint8Array(t), o = a(r);
-    return e.privateKey[Symbol.toStringTag] || Object.defineProperty(e.privateKey, Symbol.toStringTag, {
-      value: "CryptoKey",
-      configurable: !1,
-      enumerable: !1,
-      writable: !1
-    }), {
-      privateKey: e.privateKey,
-      publicKeyBase64: o
-    };
+  async isSupported() {
+    try {
+      return await (await import("@coinbase/cdp-app-attest")).isSupported();
+    } catch (t) {
+      return t instanceof Error && t.message.includes("Cannot resolve module") ? console.warn(
+        "cdp-app-attest module not found. Please install @coinbase/cdp-app-attest and rebuild your app with a custom development build or EAS Build."
+      ) : console.warn(`Failed to check attestation support: ${t}`), !1;
+    }
   },
   /**
-   * Creates an RSA key pair that allows private key export.
+   * Initialize the attestation service.
+   *
+   * Android: Initializes the Play Integrity token provider (requires cloudProjectNumber).
+   * iOS: Performs attestation registration with the CDP backend if not already registered.
+   *   1. Checks for an existing registered key — returns early if found.
+   *   2. Fetches a challenge from the backend.
+   *   3. Attests the app with Apple's DCAppAttestService.
+   *   4. Registers the resulting public key with the CDP backend.
+   *   5. Confirms registration locally.
    *
-   * @returns A promise that resolves to a key pair.
+   * @param config - Platform-specific configuration (cloudProjectNumber required for Android).
+   * @returns Promise that resolves when initialization is complete.
+   * @throws Error if initialization or iOS registration fails.
    */
-  async createExportKeyPair() {
-    if (typeof crypto > "u" || !crypto.subtle)
-      throw new n("react-native-quick-crypto", "crypto.subtle");
-    const e = await crypto.subtle.generateKey(
-      {
-        name: "RSA-OAEP",
-        modulusLength: 2048,
-        publicExponent: new Uint8Array([1, 0, 1]),
-        hash: "SHA-256"
-      },
-      !0,
-      // Allow key export
-      ["encrypt", "decrypt"]
-    ), t = await crypto.subtle.exportKey("spki", e.publicKey), r = a(new Uint8Array(t));
-    return { privateKey: e.privateKey, publicKeyBase64: r };
+  async initialize(t) {
+    return n || (n = (async () => {
+      try {
+        const { force: e } = t ?? {}, r = await import("@coinbase/cdp-app-attest");
+        if (!await r.isSupported()) {
+          console.warn("Attestation not supported on this device");
+          return;
+        }
+        if (typeof r.initialize == "function" && await r.initialize({ cloudProjectNumber: this.cloudProjectNumber }), w.getPlatform?.() === "android")
+          return;
+        if (await r.getRegisteredKeyId()) {
+          if (!e)
+            return;
+          await r.clearAttestation();
+        }
+        const p = f(), { challenge: s } = await l(p.projectId);
+        if (!s)
+          throw new Error("Backend returned empty challenge");
+        const a = await r.attest(s);
+        if (!a.ios)
+          return;
+        await u(p.projectId, {
+          challenge: s,
+          ios: {
+            keyId: a.ios.keyId,
+            attestation: a.ios.attestation,
+            bundleId: a.ios.bundleId
+          }
+        }), await r.confirmRegistration(a.ios.keyId);
+      } catch (e) {
+        throw e instanceof Error && e.message.includes("Cannot resolve module") ? new Error(
+          "cdp-app-attest module not found. Please install @coinbase/cdp-app-attest and rebuild your app with a custom development build or EAS Build."
+        ) : e;
+      } finally {
+        n = null;
+      }
+    })(), n);
   },
   /**
-   * Computes a hash of the given data.
+   * Attest with a server-provided challenge (iOS only).
+   *
+   * iOS: Generates a device key, attests it with Apple, and returns attestation data
+   * to be registered with the backend for public key storage.
+   *
+   * Android: Not used - Android skips attestation and uses Play Integrity tokens directly.
    *
-   * @param data - The data to hash.
-   * @returns A promise that resolves to the hex-encoded hash.
+   * iOS Flow:
+   * 1. Call attest(challenge) with server-provided challenge
+   * 2. Send attestation result to /attestation/register endpoint
+   * 3. Backend verifies attestation and stores public key
+   * 4. Store key ID locally with storeKeyId()
+   * 5. Use generateAssertion() for subsequent requests
+   *
+   * @param challenge - Server-provided challenge (base64-encoded).
+   * @returns Promise resolving to attestation result (iOS only).
    */
-  async hash(e) {
-    if (typeof crypto > "u" || !crypto.subtle)
-      throw new n("react-native-quick-crypto", "crypto.subtle");
-    const t = await crypto.subtle.digest("SHA-256", e), r = new Uint8Array(t);
-    return Array.from(r).map((y) => y.toString(16).padStart(2, "0")).join("");
+  async attest(t) {
+    try {
+      const e = await import("@coinbase/cdp-app-attest");
+      if (!await e.isSupported())
+        throw new Error("Attestation not supported on this device");
+      const i = await e.attest(t);
+      return i.ios ? {
+        attestation: i.ios.attestation,
+        appIdentifier: i.ios.bundleId,
+        platform: "ios",
+        keyId: i.ios.keyId
+      } : {
+        attestation: "",
+        appIdentifier: "",
+        platform: "android"
+      };
+    } catch (e) {
+      throw e instanceof Error && e.message.includes("Cannot resolve module") ? new Error(
+        "cdp-app-attest module not found. Please install @coinbase/cdp-app-attest and rebuild your app."
+      ) : e;
+    }
   },
   /**
-   * Generates a cryptographically secure random identifier.
+   * Mark attestation as successfully registered with the backend (iOS only).
    *
-   * @returns A random hex-encoded identifier.
+   * @param keyId - The key ID that was registered with the backend.
    */
-  generateRandomId() {
-    if (typeof crypto > "u" || !crypto.getRandomValues)
-      throw new n("react-native-quick-crypto", "crypto.getRandomValues");
-    const e = new Uint8Array(16);
-    return crypto.getRandomValues(e), Array.from(e, (t) => t.toString(16).padStart(2, "0")).join("");
+  async confirmRegistration(t) {
+    try {
+      await (await import("@coinbase/cdp-app-attest")).confirmRegistration(t);
+    } catch (e) {
+      throw console.error("Failed to confirm attestation registration:", e), e;
+    }
   },
   /**
-   * Generates a cryptographically secure random salt.
+   * Get the registered key ID (iOS only).
+   *
+   * Returns null if attestation hasn't been performed or registration wasn't confirmed.
    *
-   * @returns A random bigint salt.
+   * @returns Promise resolving to the registered key ID, or null if not found.
    */
-  generateRandomSalt() {
-    if (typeof crypto > "u" || !crypto.getRandomValues)
-      throw new n("react-native-quick-crypto", "crypto.getRandomValues");
-    const e = new Uint8Array(32);
-    crypto.getRandomValues(e);
-    let t = 0n;
-    for (let r = 0; r < e.length; r++)
-      t = (t << 8n) + BigInt(e[r]);
-    return t;
+  async getRegisteredKeyId() {
+    try {
+      return await (await import("@coinbase/cdp-app-attest")).getRegisteredKeyId();
+    } catch (t) {
+      return console.warn("Failed to retrieve registered key ID:", t), null;
+    }
   },
   /**
-   * Decrypts data using a private key with RSA-OAEP algorithm.
+   * Clear all attestation state, allowing re-attestation with a new key.
    *
-   * @param privateKey - The private key to use for decryption.
-   * @param encryptedData - The base64-encoded encrypted data.
-   * @returns A promise that resolves to the decrypted string.
+   * This should be called when:
+   * - Backend returns "Attestation key not found" (public key lost)
+   * - User explicitly requests re-attestation
+   * - Testing/debugging scenarios
+   *
+   * Important: After clearing, you MUST call initialize() again to generate
+   * a new key and perform fresh attestation.
    */
-  async decryptWithPrivateKey(e, t) {
-    if (typeof crypto > "u" || !crypto.subtle)
-      throw new n("react-native-quick-crypto", "crypto.subtle");
-    const r = c(t);
-    return await crypto.subtle.decrypt("RSA-OAEP", e, r);
+  async clearAttestation() {
+    try {
+      await (await import("@coinbase/cdp-app-attest")).clearAttestation(), d = !1;
+    } catch (t) {
+      throw t instanceof Error && t.message.includes("Cannot resolve module") ? new Error(
+        "cdp-app-attest module not found. Please install @coinbase/cdp-app-attest and rebuild your app."
+      ) : (console.error("Failed to clear attestation key:", t), t);
+    }
+  },
+  /**
+   * Generate an assertion/integrity token for an API request.
+   *
+   * Returns null when attestation is not yet enabled (project config hasn't confirmed
+   * this app's bundle ID), signalling callers to skip assertion headers.
+   *
+   * On first failure, retries by calling initialize() once — covering the case where
+   * no key is registered yet (e.g. background init hadn't completed). Subsequent
+   * failures propagate immediately; initRetried resets only on clearAttestation().
+   *
+   * iOS: Creates a cryptographic assertion signed with the device's attested key.
+   * Android: Generates a fresh Play Integrity token (no prior attestation needed).
+   *
+   * @param clientData - Client data to include in assertion (base64-encoded).
+   * @returns Promise resolving to assertion result, or null if attestation is disabled.
+   */
+  async generateAssertion(t) {
+    if (!this.isEnabled) return null;
+    const e = async () => {
+      const r = await import("@coinbase/cdp-app-attest");
+      if (!await r.isSupported())
+        throw new Error("Attestation not supported on this device");
+      const o = await r.createAssertion(t);
+      if (o.ios)
+        return { assertion: o.ios.assertion, keyId: o.ios.keyId };
+      if (o.android)
+        return { assertion: o.android.integrityToken };
+      throw new Error("No assertion data returned from native module");
+    };
+    try {
+      return await e();
+    } catch (r) {
+      if (r instanceof Error && r.message.includes("Cannot resolve module"))
+        throw new Error(
+          "cdp-app-attest module not found. Please install @coinbase/cdp-app-attest and rebuild your app."
+        );
+      const i = r instanceof c && r.statusCode === 404, o = r instanceof Error && r.message.includes("com.apple.devicecheck.error error 2");
+      if (d || !i && !o) throw r;
+      return o ? (console.warn("[Attestation] DCAppAttest key invalidated — clearing and re-initializing"), await this.clearAttestation()) : console.warn("[Attestation] Key not registered on backend (404) — retrying initialize"), d = !0, await this.initialize({ force: o }), await e();
+    }
   }
 };
 export {
-  l as nativeCrypto
+  h as nativeAttestation
 };

package/dist/esm/index.native40.js

@@ -1,25 +1,40 @@
-import { revokeSpendPermissionWithEndUserAccount as a } from "@coinbase/cdp-api-client";
-import { Analytics as n } from "./index.native2.js";
+import { createSpendPermissionWithEndUserAccount as s } from "@coinbase/cdp-api-client";
+import { Analytics as o } from "./index.native2.js";
 import "./index.native3.js";
-import { withAuth as m } from "./index.native77.js";
-import { getConfig as r, getCoreAuthManager as o } from "./index.native58.js";
-const y = async (e) => (n.sendActionCallEvent({ name: "revoke_spend_permission" }), r().useMock ? {
+import { withAuth as m } from "./index.native82.js";
+import { toSpendPermission as i } from "./index.native83.js";
+import { getConfig as t, getCoreAuthManager as c } from "./index.native62.js";
+const f = async (e) => (o.sendActionCallEvent({ name: "create_spend_permission" }), t().useMock ? {
   userOperationHash: "0x1234567890123456789012345678901234567890123456789012345678901234"
-} : m(e, o(), async ({ user: s, walletSecretId: t }) => ({
-  userOperationHash: (await a(
-    r().projectId,
-    s.userId,
-    e.evmSmartAccount,
-    {
-      permissionHash: e.permissionHash,
-      walletSecretId: t,
-      network: e.network,
-      useCdpPaymaster: e.useCdpPaymaster ?? !1,
-      paymasterUrl: e.paymasterUrl
-    },
-    e.idempotencyKey
-  )).userOpHash
-})));
+} : m(e, c(), async ({ user: n, walletSecretId: a }) => {
+  const r = i(
+    { ...e, account: e.evmSmartAccount },
+    e.network
+  );
+  return {
+    userOperationHash: (await s(
+      t().projectId,
+      n.userId,
+      e.evmSmartAccount,
+      {
+        // spend permission options
+        spender: r.spender,
+        token: r.token,
+        allowance: r.allowance.toString(),
+        period: r.period.toString(),
+        start: r.start.toString(),
+        end: r.end.toString(),
+        salt: r.salt.toString(),
+        // api options
+        walletSecretId: a,
+        network: e.network,
+        useCdpPaymaster: e.useCdpPaymaster ?? !1,
+        paymasterUrl: e.paymasterUrl
+      },
+      e.idempotencyKey
+    )).userOpHash
+  };
+}));
 export {
-  y as revokeSpendPermission
+  f as createSpendPermission
 };

package/dist/esm/index.native41.js

@@ -1,9 +1,44 @@
-import { Analytics as r } from "./index.native2.js";
+import { listSpendPermissionsWithEndUserAccount as a } from "@coinbase/cdp-api-client";
+import { Analytics as i } from "./index.native2.js";
 import "./index.native3.js";
-import { getCoreAuthManager as t } from "./index.native58.js";
-import "@coinbase/cdp-api-client";
-import "viem";
-const s = () => (r.sendActionCallEvent({ name: "get_current_user_sync" }), t().getUser());
+import { withAuth as o } from "./index.native82.js";
+import { getConfig as r, getCoreAuthManager as m } from "./index.native62.js";
+const k = async (e) => (i.sendActionCallEvent({ name: "list_spend_permissions" }), r().useMock ? {
+  spendPermissions: [
+    {
+      permission: {
+        account: e.evmSmartAccount,
+        spender: "0x5678901234567890123456789012345678901234",
+        token: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+        allowance: "1000000000000000000",
+        period: "86400",
+        start: "1640995200",
+        end: "1672531200",
+        salt: "123456789",
+        extraData: "0x"
+      },
+      permissionHash: "0x1234567890123456789012345678901234567890123456789012345678901234",
+      revoked: !1,
+      createdAt: "2024-01-01T00:00:00Z",
+      network: e.network
+    }
+  ],
+  hasNextPage: !1
+} : o(e, m(), async ({ user: t }) => {
+  const n = {};
+  e.pageSize !== void 0 && (n.pageSize = e.pageSize), e.pageToken !== void 0 && (n.pageToken = e.pageToken);
+  const s = await a(
+    r().projectId,
+    t.userId,
+    e.evmSmartAccount,
+    n
+  );
+  return {
+    spendPermissions: s.spendPermissions,
+    hasNextPage: !!s.nextPageToken,
+    nextPageToken: s.nextPageToken
+  };
+}));
 export {
-  s as getCurrentUserSync
+  k as listSpendPermissions
 };

package/dist/esm/index.native42.js

@@ -1,46 +1,25 @@
-import { isAddress as n } from "viem";
-import { getCurrentUserSync as h } from "./index.native41.js";
-import { toTransactionSigner as s } from "./index.native79.js";
-import { toViemAccount as c } from "./index.native71.js";
-function g(e = {}) {
-  const a = e.fetch ?? globalThis.fetch;
-  let r = null;
-  return { fetchWithPayment: async (...d) => {
-    if (!r) {
-      const t = h();
-      if (!t)
-        throw new Error("User not authenticated");
-      const o = (() => {
-        if (e.address && n(e.address))
-          return c(e.address);
-        if (e.address && !n(e.address))
-          return s(e.address);
-        if (t.evmSmartAccountObjects?.length)
-          return c(t.evmSmartAccountObjects[0].address);
-        if (t.evmAccountObjects?.length)
-          return c(t.evmAccountObjects[0].address);
-        if (t.solanaAccountObjects?.length)
-          return s(t.solanaAccountObjects[0].address);
-        throw new Error("No account found");
-      })();
-      try {
-        const { wrapFetchWithPayment: u } = await import("x402-fetch");
-        r = u(
-          a,
-          o,
-          e.maxValue,
-          e.paymentRequirementsSelector,
-          e.config
-        );
-      } catch {
-        throw new Error(
-          "x402-fetch is not installed. Make sure x402-fetch is installed and try again."
-        );
-      }
-    }
-    return r(...d);
-  } };
-}
+import { revokeSpendPermissionWithEndUserAccount as a } from "@coinbase/cdp-api-client";
+import { Analytics as n } from "./index.native2.js";
+import "./index.native3.js";
+import { withAuth as m } from "./index.native82.js";
+import { getConfig as r, getCoreAuthManager as o } from "./index.native62.js";
+const y = async (e) => (n.sendActionCallEvent({ name: "revoke_spend_permission" }), r().useMock ? {
+  userOperationHash: "0x1234567890123456789012345678901234567890123456789012345678901234"
+} : m(e, o(), async ({ user: s, walletSecretId: t }) => ({
+  userOperationHash: (await a(
+    r().projectId,
+    s.userId,
+    e.evmSmartAccount,
+    {
+      permissionHash: e.permissionHash,
+      walletSecretId: t,
+      network: e.network,
+      useCdpPaymaster: e.useCdpPaymaster ?? !1,
+      paymasterUrl: e.paymasterUrl
+    },
+    e.idempotencyKey
+  )).userOpHash
+})));
 export {
-  g as fetchWithX402
+  y as revokeSpendPermission
 };

package/dist/esm/index.native43.js

@@ -1,19 +1,9 @@
-import { initiateAuthentication as o } from "@coinbase/cdp-api-client";
-import { Analytics as e } from "./index.native2.js";
+import { Analytics as r } from "./index.native2.js";
 import "./index.native3.js";
-import { getPlatformOAuth as i } from "./index.native8.js";
-import { getCoreAuthManager as n, getConfig as r } from "./index.native58.js";
-async function u() {
-  if (e.sendActionCallEvent({ name: "link_google" }), !await n().isSignedIn())
-    throw new Error("User must be signed in to link a Google account");
-  const t = await o(r().projectId, {
-    type: "google",
-    redirectUrl: i().getRedirectUrl()
-  });
-  if (!("authUrl" in t))
-    throw new Error("Failed to initiate Google authentication");
-  i().initiateOAuthFlow(t.authUrl);
-}
+import { getCoreAuthManager as t } from "./index.native62.js";
+import "@coinbase/cdp-api-client";
+import "viem";
+const s = () => (r.sendActionCallEvent({ name: "get_current_user_sync" }), t().getUser());
 export {
-  u as linkGoogle
+  s as getCurrentUserSync
 };

package/dist/esm/index.native44.js

@@ -1,23 +1,46 @@
-import { initiateAuthentication as t } from "@coinbase/cdp-api-client";
-import { Analytics as o } from "./index.native2.js";
-import "./index.native3.js";
-import { getCoreAuthManager as s, getConfig as r } from "./index.native58.js";
-async function d(n, i) {
-  if (o.sendActionCallEvent({ name: "link_sms" }), !await s().isSignedIn())
-    throw new Error("User must be signed in to link a phone number");
-  const e = await t(
-    r().projectId,
-    {
-      phoneNumber: n,
-      type: "sms"
-    },
-    i?.idempotencyKey
-  );
-  return {
-    flowId: e.flowId,
-    message: "message" in e ? e.message : ""
-  };
+import { isAddress as n } from "viem";
+import { getCurrentUserSync as h } from "./index.native43.js";
+import { toTransactionSigner as s } from "./index.native80.js";
+import { toViemAccount as c } from "./index.native75.js";
+function g(e = {}) {
+  const a = e.fetch ?? globalThis.fetch;
+  let r = null;
+  return { fetchWithPayment: async (...d) => {
+    if (!r) {
+      const t = h();
+      if (!t)
+        throw new Error("User not authenticated");
+      const o = (() => {
+        if (e.address && n(e.address))
+          return c(e.address);
+        if (e.address && !n(e.address))
+          return s(e.address);
+        if (t.evmSmartAccountObjects?.length)
+          return c(t.evmSmartAccountObjects[0].address);
+        if (t.evmAccountObjects?.length)
+          return c(t.evmAccountObjects[0].address);
+        if (t.solanaAccountObjects?.length)
+          return s(t.solanaAccountObjects[0].address);
+        throw new Error("No account found");
+      })();
+      try {
+        const { wrapFetchWithPayment: u } = await import("x402-fetch");
+        r = u(
+          a,
+          o,
+          e.maxValue,
+          e.paymentRequirementsSelector,
+          e.config
+        );
+      } catch {
+        throw new Error(
+          "x402-fetch is not installed. Make sure x402-fetch is installed and try again."
+        );
+      }
+    }
+    return r(...d);
+  } };
 }
 export {
-  d as linkSms
+  g as fetchWithX402
 };

package/dist/esm/index.native45.js

@@ -1,23 +1,19 @@
-import { initiateAuthentication as t } from "@coinbase/cdp-api-client";
-import { Analytics as o } from "./index.native2.js";
+import { initiateAuthentication as o } from "@coinbase/cdp-api-client";
+import { Analytics as e } from "./index.native2.js";
 import "./index.native3.js";
-import { getCoreAuthManager as a, getConfig as r } from "./index.native58.js";
-async function d(i, n) {
-  if (o.sendActionCallEvent({ name: "link_email" }), !await a().isSignedIn())
-    throw new Error("User must be signed in to link an email");
-  const e = await t(
-    r().projectId,
-    {
-      email: i,
-      type: "email"
-    },
-    n?.idempotencyKey
-  );
-  return {
-    flowId: e.flowId,
-    message: "message" in e ? e.message : ""
-  };
+import { getPlatformOAuth as i } from "./index.native10.js";
+import { getCoreAuthManager as n, getConfig as r } from "./index.native62.js";
+async function u() {
+  if (e.sendActionCallEvent({ name: "link_google" }), !await n().isSignedIn())
+    throw new Error("User must be signed in to link a Google account");
+  const t = await o(r().projectId, {
+    type: "google",
+    redirectUrl: i().getRedirectUrl()
+  });
+  if (!("authUrl" in t))
+    throw new Error("Failed to initiate Google authentication");
+  i().initiateOAuthFlow(t.authUrl);
 }
 export {
-  d as linkEmail
+  u as linkGoogle
 };