@coinbase/cdp-core 0.0.91 → 0.0.93

package/dist/native/index.native4.js

@@ -1,110 +1,162 @@
-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 "viem";
-const l = {
+const s = {
   /**
-   * 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 (e) {
+      return e instanceof Error && e.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: ${e}`), !1;
+    }
   },
   /**
-   * Creates an RSA key pair that allows private key export.
+   * Initialize the attestation service.
    *
-   * @returns A promise that resolves to a key pair.
+   * iOS: No-op (not required).
+   * Android: Required - initializes Play Integrity token provider.
+   *
+   * @param config - Platform-specific configuration (required for Android).
+   * @returns Promise that resolves when initialization is complete.
+   */
+  async initialize(e) {
+    try {
+      const t = await import("@coinbase/cdp-app-attest");
+      if (!await t.isSupported()) {
+        console.warn("Attestation not supported on this device");
+        return;
+      }
+      typeof t.initialize == "function" && await t.initialize(e);
+    } catch (t) {
+      console.warn("Failed to initialize attestation:", t);
+    }
+  },
+  /**
+   * 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.
+   *
+   * 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 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 attest(e) {
+    try {
+      const t = await import("@coinbase/cdp-app-attest");
+      if (!await t.isSupported())
+        throw new Error("Attestation not supported on this device");
+      const o = await t.attest(e);
+      return o.ios ? {
+        attestation: o.ios.attestation,
+        appIdentifier: o.ios.bundleId,
+        platform: "ios",
+        keyId: o.ios.keyId
+      } : {
+        attestation: "",
+        appIdentifier: "",
+        platform: "android"
+      };
+    } 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."
+      ) : t;
+    }
   },
   /**
-   * Computes a hash of the given data.
+   * Mark attestation as successfully registered with the backend (iOS only).
    *
-   * @param data - The data to hash.
-   * @returns A promise that resolves to the hex-encoded hash.
+   * @param keyId - The key ID that was registered with the backend.
    */
-  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 confirmRegistration(e) {
+    try {
+      await (await import("@coinbase/cdp-app-attest")).confirmRegistration(e), console.log("Attestation registration confirmed");
+    } catch (t) {
+      throw console.error("Failed to confirm attestation registration:", t), t;
+    }
   },
   /**
-   * Generates a cryptographically secure random identifier.
+   * Get the registered key ID (iOS only).
+   *
+   * Returns null if attestation hasn't been performed or registration wasn't confirmed.
    *
-   * @returns A random hex-encoded identifier.
+   * @returns Promise resolving to the registered key ID, or null if not found.
    */
-  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 getRegisteredKeyId() {
+    try {
+      return await (await import("@coinbase/cdp-app-attest")).getRegisteredKeyId();
+    } catch (e) {
+      return console.warn("Failed to retrieve registered key ID:", e), null;
+    }
   },
   /**
-   * Generates a cryptographically secure random salt.
+   * Clear all attestation state, allowing re-attestation with a new key.
    *
-   * @returns A random bigint salt.
+   * This should be called when:
+   * - Backend returns "Attestation key not found" (public key expired or lost)
+   * - Backend's stored public key has expired (90-day TTL)
+   * - User explicitly requests re-attestation
+   * - Testing/debugging scenarios
+   *
+   * Important: After clearing, you MUST call attest() again to generate
+   * a new key and perform fresh attestation.
    */
-  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 clearAttestation() {
+    try {
+      await (await import("@coinbase/cdp-app-attest")).clearAttestation(), console.log("Attestation key cleared");
+    } 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."
+      ) : (console.error("Failed to clear attestation key:", e), e);
+    }
   },
   /**
-   * Decrypts data using a private key with RSA-OAEP algorithm.
+   * Generate an assertion/integrity token for an API request.
+   *
+   * iOS: Creates a cryptographic assertion signed with the device's attested key.
+   * Must call attest() first to generate and register the key.
+   *
+   * Android: Generates a fresh Play Integrity token (no prior attestation needed).
    *
-   * @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.
+   * @param clientData - Client data to include in assertion (base64-encoded).
+   * @returns Promise resolving to assertion result.
    */
-  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 generateAssertion(e) {
+    try {
+      const t = await import("@coinbase/cdp-app-attest");
+      if (!await t.isSupported())
+        throw new Error("Attestation not supported on this device");
+      const o = await t.createAssertion(e);
+      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");
+    } 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."
+      ) : t;
+    }
   }
 };
 export {
-  l as nativeCrypto
+  s as nativeAttestation
 };

package/dist/native/index.native40.js

@@ -1,25 +1,44 @@
-import { revokeSpendPermissionWithEndUserAccount as a } from "@coinbase/cdp-api-client";
-import { Analytics as n } 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 { 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 ? {
-  userOperationHash: "0x1234567890123456789012345678901234567890123456789012345678901234"
-} : m(e, o(), async ({ user: s, walletSecretId: t }) => ({
-  userOperationHash: (await a(
+import { withAuth as o } from "./index.native81.js";
+import { getConfig as r, getCoreAuthManager as m } from "./index.native61.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,
-    s.userId,
+    t.userId,
     e.evmSmartAccount,
-    {
-      permissionHash: e.permissionHash,
-      walletSecretId: t,
-      network: e.network,
-      useCdpPaymaster: e.useCdpPaymaster ?? !1,
-      paymasterUrl: e.paymasterUrl
-    },
-    e.idempotencyKey
-  )).userOpHash
-})));
+    n
+  );
+  return {
+    spendPermissions: s.spendPermissions,
+    hasNextPage: !!s.nextPageToken,
+    nextPageToken: s.nextPageToken
+  };
+}));
 export {
-  y as revokeSpendPermission
+  k as listSpendPermissions
 };

package/dist/native/index.native41.js

@@ -1,9 +1,25 @@
-import { Analytics as r } from "./index.native2.js";
+import { revokeSpendPermissionWithEndUserAccount as a } from "@coinbase/cdp-api-client";
+import { Analytics as n } 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 m } from "./index.native81.js";
+import { getConfig as r, getCoreAuthManager as o } from "./index.native61.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 {
-  s as getCurrentUserSync
+  y as revokeSpendPermission
 };

package/dist/native/index.native42.js

@@ -1,46 +1,9 @@
-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 { Analytics as r } from "./index.native2.js";
+import "./index.native3.js";
+import { getCoreAuthManager as t } from "./index.native61.js";
+import "@coinbase/cdp-api-client";
+import "viem";
+const s = () => (r.sendActionCallEvent({ name: "get_current_user_sync" }), t().getUser());
 export {
-  g as fetchWithX402
+  s as getCurrentUserSync
 };

package/dist/native/index.native43.js

@@ -1,19 +1,46 @@
-import { initiateAuthentication as o } from "@coinbase/cdp-api-client";
-import { Analytics as e } 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 { isAddress as n } from "viem";
+import { getCurrentUserSync as h } from "./index.native42.js";
+import { toTransactionSigner as s } from "./index.native79.js";
+import { toViemAccount as c } from "./index.native74.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 {
-  u as linkGoogle
+  g as fetchWithX402
 };

package/dist/native/index.native44.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 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 { getPlatformOAuth as i } from "./index.native9.js";
+import { getCoreAuthManager as n, getConfig as r } from "./index.native61.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 linkSms
+  u as linkGoogle
 };

package/dist/native/index.native45.js

@@ -1,17 +1,17 @@
 import { initiateAuthentication as t } from "@coinbase/cdp-api-client";
 import { Analytics as o } 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");
+import { getCoreAuthManager as s, getConfig as r } from "./index.native61.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,
     {
-      email: i,
-      type: "email"
+      phoneNumber: n,
+      type: "sms"
     },
-    n?.idempotencyKey
+    i?.idempotencyKey
   );
   return {
     flowId: e.flowId,
@@ -19,5 +19,5 @@ async function d(i, n) {
   };
 }
 export {
-  d as linkEmail
+  d as linkSms
 };

package/dist/native/index.native46.js

@@ -1,56 +1,23 @@
-import { initiateAuthentication as u } from "@coinbase/cdp-api-client";
-import { Analytics as l } from "./index.native2.js";
+import { initiateAuthentication as t } from "@coinbase/cdp-api-client";
+import { Analytics as o } from "./index.native2.js";
 import "./index.native3.js";
-import "jose";
-import "viem";
-import { getPlatformOAuth as i, getPlatformServices as m } from "./index.native8.js";
-import "./index.native80.js";
-import { getCoreAuthManager as c, getConfig as h, getCoreOAuthManager as o } from "./index.native58.js";
-import { verifyTelegramOAuth as w } from "./index.native17.js";
-import "./index.native81.js";
-import "@solana/web3.js";
-import "bs58";
-async function P(t, n) {
-  if (l.sendActionCallEvent({ name: "link_oauth" }), !await c().isSignedIn())
-    throw new Error("User must be signed in to link an OAuth account");
-  const e = await u(
-    h().projectId,
+import { getCoreAuthManager as a, getConfig as r } from "./index.native61.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,
     {
-      type: t,
-      redirectUrl: i().getRedirectUrl()
+      email: i,
+      type: "email"
     },
     n?.idempotencyKey
   );
-  if (!("authUrl" in e))
-    throw new Error(`Failed to initiate ${t} authentication`);
-  if (t === "telegram") {
-    const a = m().oauth.openTelegramOAuthPopup;
-    if (!a)
-      throw new Error("Telegram OAuth is not supported on this platform");
-    try {
-      await o().setOAuthFlowState({ providerType: t, status: "pending" });
-      const r = await a(e.authUrl);
-      if (!r) {
-        await o().setOAuthFlowState({
-          providerType: t,
-          status: "error",
-          errorDescription: "Telegram auth was cancelled"
-        });
-        return;
-      }
-      await w({ flowId: e.flowId, telegramData: r }), await o().setOAuthFlowState({ providerType: t, status: "success" });
-    } catch (r) {
-      const s = r instanceof Error ? r.message : "Unknown error";
-      throw await o().setOAuthFlowState({
-        providerType: t,
-        status: "error",
-        errorDescription: s
-      }), r;
-    }
-    return;
-  }
-  i().initiateOAuthFlow(e.authUrl);
+  return {
+    flowId: e.flowId,
+    message: "message" in e ? e.message : ""
+  };
 }
 export {
-  P as linkOAuth
+  d as linkEmail
 };