@coinbase/cdp-core 0.0.25 → 0.0.27

package/dist/types/types.d.ts

@@ -0,0 +1,146 @@
+import { SendEvmTransactionWithEndUserAccountBodyNetwork, APIError, APIErrorType, ErrorType, HttpErrorType, EvmUserOperation } from '@coinbase/cdp-api-client';
+import { TransactionSerializableEIP1559 } from 'viem';
+export { APIError, type APIErrorType, ErrorType, HttpErrorType, SendEvmTransactionWithEndUserAccountBodyNetwork, };
+export type Config = {
+    projectId: string;
+    useMock?: boolean;
+    debugging?: boolean;
+    basePath?: string;
+    createAccountOnLogin?: "evm-eoa" | "evm-smart";
+};
+export type Hex = `0x${string}`;
+export type EvmAddress = `0x${string}`;
+export type AuthenticationMethods = {
+    email?: EmailAuthentication;
+    sms?: SmsAuthentication;
+};
+export type User = {
+    userId: string;
+    authenticationMethods: AuthenticationMethods;
+    evmAccounts?: EvmAddress[];
+    evmSmartAccounts?: EvmAddress[];
+};
+export type EmailAuthentication = {
+    type: "email";
+    email: string;
+};
+export type SmsAuthentication = {
+    type: "sms";
+    phoneNumber: string;
+};
+export type SignInWithEmailOptions = {
+    email: string;
+};
+export type SignInWithEmailResult = {
+    message: string;
+    flowId: string;
+};
+export type SignInWithSmsOptions = {
+    phoneNumber: string;
+};
+export type SignInWithSmsResult = {
+    message: string;
+    flowId: string;
+};
+export type VerifyEmailOTPOptions = {
+    flowId: string;
+    otp: string;
+};
+export type VerifyEmailOTPResult = {
+    user: User;
+    message: string;
+    isNewUser: boolean;
+};
+export type VerifySmsOTPOptions = {
+    flowId: string;
+    otp: string;
+};
+export type VerifySmsOTPResult = {
+    user: User;
+    message: string;
+    isNewUser: boolean;
+};
+export type OnAuthStateChangeFn = (user: User | null) => void;
+export type SignEvmHashOptions = {
+    evmAccount: EvmAddress;
+    hash: Hex;
+};
+export type SignEvmHashResult = {
+    signature: Hex;
+};
+export type AllowedEvmTransactionType = TransactionSerializableEIP1559;
+export type SignEvmTransactionOptions = {
+    evmAccount: EvmAddress;
+    transaction: AllowedEvmTransactionType;
+};
+export type SignEvmTransactionResult = {
+    signedTransaction: Hex;
+};
+export type SendEvmTransactionOptions = {
+    evmAccount: EvmAddress;
+    network: SendEvmTransactionWithEndUserAccountBodyNetwork;
+    transaction: AllowedEvmTransactionType;
+};
+export type SendEvmTransactionResult = {
+    transactionHash: Hex;
+};
+export type SignEvmMessageOptions = {
+    evmAccount: EvmAddress;
+    message: string;
+};
+export type SignEvmMessageResult = {
+    signature: Hex;
+};
+export interface EIP712Domain {
+    name?: string;
+    version?: string;
+    chainId?: number;
+    salt?: Hex;
+    verifyingContract?: EvmAddress;
+}
+export interface EIP712Types {
+    [key: string]: unknown;
+}
+export type EIP712Message = {
+    [key: string]: unknown;
+};
+export interface EIP712TypedData {
+    domain: EIP712Domain;
+    types: EIP712Types;
+    primaryType: string;
+    message: EIP712Message;
+}
+export type SignEvmTypedDataOptions = {
+    evmAccount: EvmAddress;
+    typedData: EIP712TypedData;
+};
+export type EvmCall = {
+    to: EvmAddress;
+    value?: bigint;
+    data?: Hex;
+};
+export type SendUserOperationOptions = {
+    evmSmartAccount: EvmAddress;
+    network: SendEvmTransactionWithEndUserAccountBodyNetwork;
+    calls: EvmCall[];
+    useCdpPaymaster?: boolean;
+    paymasterUrl?: string;
+};
+export type SendUserOperationResult = {
+    userOperationHash: Hex;
+};
+export type GetUserOperationOptions = {
+    userOperationHash: Hex;
+    evmSmartAccount: EvmAddress;
+    network: SendEvmTransactionWithEndUserAccountBodyNetwork;
+};
+export type GetUserOperationResult = EvmUserOperation;
+export type SignEvmTypedDataResult = {
+    signature: Hex;
+};
+export type ExportEvmAccountOptions = {
+    evmAccount: EvmAddress;
+};
+export type ExportEvmAccountResult = {
+    privateKey: string;
+};

package/dist/types/viem/signAndWrapTypedData.d.ts

@@ -0,0 +1,17 @@
+import { EvmAddress, Hex, EIP712TypedData } from '../types.js';
+export interface SignAndWrapTypedDataForSmartAccountOptions {
+    smartAccount: EvmAddress;
+    ownerAddress: EvmAddress;
+    typedData: EIP712TypedData;
+}
+export interface SignAndWrapTypedDataForSmartAccountResult {
+    signature: Hex;
+}
+export declare function signAndWrapTypedDataForSmartAccount(options: SignAndWrapTypedDataForSmartAccountOptions): Promise<SignAndWrapTypedDataForSmartAccountResult>;
+export declare function createReplaySafeTypedData({ typedData, smartAccountAddress, }: {
+    typedData: EIP712TypedData;
+    smartAccountAddress: Hex;
+}): EIP712TypedData;
+export declare function createSmartAccountSignatureWrapper({ signatureHex }: {
+    signatureHex: Hex;
+}): Hex;

package/dist/types/viem/toViemAccount.d.ts

@@ -0,0 +1,2 @@
+import { Address, LocalAccount } from 'viem';
+export declare function toViemAccount(address: Address): Promise<LocalAccount>;

package/dist/web/index.web.js

@@ -0,0 +1,47 @@
+import { setPlatformServices as r } from "./index.web2.js";
+import { webCrypto as e } from "./index.web3.js";
+import { webStorage as o } from "./index.web4.js";
+import { exportEvmAccount as g, getAccessToken as c, getCurrentUser as f, getUserOperation as d, initialize as v, 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.web5.js";
+import { AuthManager as U } from "./index.web6.js";
+import { APIError as b, ErrorType as w, HttpErrorType as M, SendEvmTransactionWithEndUserAccountBodyNetwork as k } from "@coinbase/cdp-api-client";
+import "viem";
+import { createCDPEmbeddedWallet as N } from "./index.web7.js";
+import { EIP1193ProviderError as z, STANDARD_ERROR_CODES as B } from "./index.web8.js";
+import "ox";
+import "zustand";
+import { toViemAccount as j } from "./index.web9.js";
+import { ModuleResolutionError as F } from "./index.web10.js";
+r({
+  crypto: e,
+  storage: o
+});
+export {
+  b as APIError,
+  U as AuthManager,
+  z as EIP1193ProviderError,
+  w as ErrorType,
+  M as HttpErrorType,
+  F as ModuleResolutionError,
+  B as STANDARD_ERROR_CODES,
+  k as SendEvmTransactionWithEndUserAccountBodyNetwork,
+  N as createCDPEmbeddedWallet,
+  g as exportEvmAccount,
+  c as getAccessToken,
+  f as getCurrentUser,
+  d as getUserOperation,
+  v 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/web/index.web10.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/web/index.web100.js

@@ -0,0 +1,12 @@
+function e(t) {
+  return t?.[Symbol.toStringTag] === "CryptoKey";
+}
+function r(t) {
+  return t?.[Symbol.toStringTag] === "KeyObject";
+}
+const n = (t) => e(t) || r(t);
+export {
+  n as default,
+  e as isCryptoKey,
+  r as isKeyObject
+};

package/dist/web/index.web101.js

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

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

@@ -0,0 +1,15 @@
+const s = {
+  gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
+  l1Block: { address: "0x4200000000000000000000000000000000000015" },
+  l2CrossDomainMessenger: {
+    address: "0x4200000000000000000000000000000000000007"
+  },
+  l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
+  l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
+  l2ToL1MessagePasser: {
+    address: "0x4200000000000000000000000000000000000016"
+  }
+};
+export {
+  s as contracts
+};

package/dist/web/index.web104.js

@@ -0,0 +1,38 @@
+import { hexToBigInt as n } from "./index.web47.js";
+import { defineBlock as r } from "./index.web44.js";
+import { defineTransaction as s, formatTransaction as m } from "./index.web46.js";
+import { defineTransactionReceipt as l } from "./index.web49.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/web/index.web105.js

@@ -0,0 +1,44 @@
+import { InvalidAddressError as a } from "./index.web62.js";
+import { isAddress as f } from "./index.web36.js";
+import { concatHex as p } from "./index.web37.js";
+import { toHex as i } from "./index.web31.js";
+import { toRlp as x } from "./index.web50.js";
+import { serializeTransaction as l } from "./index.web18.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/web/index.web106.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/web/index.web11.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/web/index.web12.js

@@ -0,0 +1,17 @@
+import "@coinbase/cdp-api-client";
+const r = (u, c, e) => {
+  const s = new Date(c).getTime(), m = {
+    userId: e.userId,
+    evmAccounts: e.evmAccounts?.map((t) => t) ?? [],
+    evmSmartAccounts: e.evmSmartAccounts?.map((t) => t) ?? [],
+    authenticationMethods: e.authenticationMethods.reduce((t, o) => (t[o.type] = o, t), {})
+  };
+  return {
+    accessToken: u,
+    expiresAt: s,
+    user: m
+  };
+};
+export {
+  r as toAuthState
+};

package/dist/web/index.web13.js

@@ -0,0 +1,18 @@
+import "@coinbase/cdp-api-client";
+import "viem";
+const o = async (t) => await t.isSignedIn();
+async function w(t, n, e) {
+  if (!await o(n))
+    throw new Error("User not signed in");
+  const r = await n.getUser();
+  if ("evmAccount" in t && !r.evmAccounts?.find((c) => c === t.evmAccount))
+    throw new Error("EVM account not found");
+  if ("evmSmartAccount" in t && !r.evmSmartAccounts?.find((c) => c === t.evmSmartAccount))
+    throw new Error("EVM Smart Account not found");
+  const i = await n.getWalletSecretId();
+  return e({ ...t, user: r, walletSecretId: i });
+}
+export {
+  o as isSignedIn,
+  w as withAuth
+};