@coinbase/cdp-core 0.0.25 → 0.0.26

package/dist/native-types/shared/utils.d.ts

@@ -0,0 +1,32 @@
+import { EvmUserOperationNetwork, SendEvmTransactionWithEndUserAccountBodyNetwork } from '@coinbase/cdp-api-client';
+export declare const sortKeys: (obj: any) => any;
+export declare const isChainSupportedForCDPSends: (chainName: SendEvmTransactionWithEndUserAccountBodyNetwork) => boolean;
+declare const sendTransactionNameToChainIdMapping: {
+    "base-sepolia": 84532;
+    base: 8453;
+    ethereum: 1;
+    "ethereum-sepolia": 11155111;
+    avalanche: 43114;
+    polygon: 137;
+    optimism: 10;
+    arbitrum: 42161;
+};
+type SendTransactionSupportedChainId = (typeof sendTransactionNameToChainIdMapping)[keyof typeof sendTransactionNameToChainIdMapping];
+export declare const sendTransactionChainIdToNameMapping: Record<SendTransactionSupportedChainId, SendEvmTransactionWithEndUserAccountBodyNetwork>;
+export declare const isChainIdSupportedForCDPSends: (chainId: number) => boolean;
+export declare const userOperationNameToChainIdMapping: {
+    "base-sepolia": 84532;
+    base: 8453;
+    ethereum: 1;
+    "ethereum-sepolia": 11155111;
+    avalanche: 43114;
+    polygon: 137;
+    optimism: 10;
+    arbitrum: 42161;
+    zora: 7777777;
+    bnb: 56;
+};
+type SendUserOperationSupportedChainId = (typeof userOperationNameToChainIdMapping)[keyof typeof userOperationNameToChainIdMapping];
+export declare const userOperationChainIdToNameMapping: Record<SendUserOperationSupportedChainId, EvmUserOperationNetwork>;
+export declare const isChainIdSupportedForCDPUserOps: (chainId: number) => boolean;
+export {};

package/dist/native-types/state.d.ts

@@ -0,0 +1,7 @@
+import { IAuthManager } from './auth/types.js';
+import { Config } from './types.js';
+export declare const setConfig: (cfg: Config) => void;
+export declare const getConfig: () => Config;
+export declare const setCoreAuthManager: (manager: IAuthManager) => void;
+export declare const getCoreAuthManager: () => IAuthManager;
+export declare const resetState: () => void;

package/dist/native-types/types.d.ts

@@ -0,0 +1,145 @@
+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?: string;
+}
+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/native-types/viem/toViemAccount.d.ts

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

package/dist/types/auth/authManager.d.ts

@@ -0,0 +1,30 @@
+import { OnAuthStateChangeFn, User } from '../types.js';
+import { AuthState, IAuthManager } from './types.js';
+export declare class AuthManager implements IAuthManager {
+    private projectId;
+    private authState;
+    private walletSecret;
+    private authStateChangeCallbacks;
+    private initPromise;
+    constructor(projectId: string);
+    getUser(): Promise<User | null>;
+    isSignedIn(): Promise<boolean>;
+    signOut(): Promise<void>;
+    addAuthStateChangeCallback(callback: OnAuthStateChangeFn): void;
+    getToken(): Promise<string | null>;
+    getWalletSecretId(): Promise<string>;
+    getXWalletAuth(options: {
+        requestMethod: string;
+        requestHost: string;
+        requestPath: string;
+        requestData?: Record<string, unknown>;
+    }): Promise<string>;
+    setAuthState(authState: AuthState): Promise<void>;
+    clearAuthState(): Promise<void>;
+    ensureInitialized(): Promise<void>;
+    private _doInitialize;
+    private shouldRefreshToken;
+    private refreshAccessToken;
+    private shouldRefreshWalletSecret;
+    private refreshWalletSecret;
+}

package/dist/types/auth/toAuthState.d.ts

@@ -0,0 +1,3 @@
+import { EndUser } from '@coinbase/cdp-api-client';
+import { AuthState } from './types.js';
+export declare const toAuthState: (accessToken: string, expiresAt: string, endUser: EndUser) => AuthState;

package/dist/types/auth/types.d.ts

@@ -0,0 +1,29 @@
+import { KeyPair } from '../shared/types.js';
+import { OnAuthStateChangeFn, User } from '../types.js';
+export interface AuthState {
+    accessToken: string;
+    expiresAt: number;
+    user: User;
+}
+export interface WalletSecret {
+    walletSecretId: string;
+    keyPair: KeyPair;
+    expiresAt: number;
+}
+export interface IAuthManager {
+    getUser(): Promise<User | null>;
+    isSignedIn(): Promise<boolean>;
+    signOut(): Promise<void>;
+    addAuthStateChangeCallback(callback: OnAuthStateChangeFn): void;
+    getToken(): Promise<string | null>;
+    getWalletSecretId(): Promise<string>;
+    getXWalletAuth(options: {
+        requestMethod: string;
+        requestHost: string;
+        requestPath: string;
+        requestData?: Record<string, unknown>;
+    }): Promise<string>;
+    setAuthState(authState: AuthState): Promise<void>;
+    clearAuthState(): Promise<void>;
+    ensureInitialized(): Promise<void>;
+}

package/dist/types/auth/withAuth.d.ts

@@ -0,0 +1,13 @@
+import { EvmAddress, User } from '../types.js';
+import { IAuthManager } from './types.js';
+export declare const isSignedIn: (authManager: IAuthManager) => Promise<boolean>;
+type AuthenticatedFunction<T, R> = (params: T & {
+    user: User;
+    walletSecretId: string;
+}) => Promise<R>;
+export declare function withAuth<T, R>(options: T & ({
+    evmAccount: EvmAddress;
+} | {
+    evmSmartAccount: EvmAddress;
+}), authManager: IAuthManager, fn: AuthenticatedFunction<T, R>): Promise<R>;
+export {};

package/dist/types/constants.d.ts

@@ -0,0 +1 @@
+export declare const ERROR_DOCS_PAGE_URL = "https://docs.cdp.coinbase.com/api-v2/docs/errors";

package/dist/types/core.d.ts

@@ -0,0 +1,19 @@
+import { Config, User, SignInWithEmailOptions, SignInWithEmailResult, SignInWithSmsOptions, SignInWithSmsResult, VerifySmsOTPOptions, VerifySmsOTPResult, SignEvmHashOptions, SignEvmHashResult, VerifyEmailOTPOptions, VerifyEmailOTPResult, OnAuthStateChangeFn, SendEvmTransactionResult, SignEvmTransactionOptions, SignEvmTransactionResult, SignEvmTypedDataOptions, SignEvmTypedDataResult, SignEvmMessageOptions, ExportEvmAccountResult, SendEvmTransactionOptions, ExportEvmAccountOptions, SendUserOperationOptions, SendUserOperationResult, GetUserOperationOptions, GetUserOperationResult } from './types.js';
+export declare const initialize: (cfg: Config) => Promise<void>;
+export declare const signInWithEmail: (options: SignInWithEmailOptions) => Promise<SignInWithEmailResult>;
+export declare const signInWithSms: (options: SignInWithSmsOptions) => Promise<SignInWithSmsResult>;
+export declare const verifyEmailOTP: (options: VerifyEmailOTPOptions) => Promise<VerifyEmailOTPResult>;
+export declare const verifySmsOTP: (options: VerifySmsOTPOptions) => Promise<VerifySmsOTPResult>;
+export declare const getCurrentUser: () => Promise<User | null>;
+export declare const isSignedIn: () => Promise<boolean>;
+export declare const signOut: () => Promise<void>;
+export declare const getAccessToken: () => Promise<string | null>;
+export declare const onAuthStateChange: (callback: OnAuthStateChangeFn) => void;
+export declare const signEvmHash: (options: SignEvmHashOptions) => Promise<SignEvmHashResult>;
+export declare const signEvmTransaction: (options: SignEvmTransactionOptions) => Promise<SignEvmTransactionResult>;
+export declare const sendEvmTransaction: (options: SendEvmTransactionOptions) => Promise<SendEvmTransactionResult>;
+export declare const signEvmMessage: (options: SignEvmMessageOptions) => Promise<SignEvmHashResult>;
+export declare const signEvmTypedData: (options: SignEvmTypedDataOptions) => Promise<SignEvmTypedDataResult>;
+export declare const sendUserOperation: (options: SendUserOperationOptions) => Promise<SendUserOperationResult>;
+export declare const getUserOperation: (options: GetUserOperationOptions) => Promise<GetUserOperationResult>;
+export declare const exportEvmAccount: (options: ExportEvmAccountOptions) => Promise<ExportEvmAccountResult>;

package/dist/types/eip1193/errors.d.ts

@@ -0,0 +1,48 @@
+import { Provider as ox_Provider } from 'ox';
+import { Chain } from 'viem';
+import { EvmAddress } from '../types.js';
+export declare const STANDARD_ERROR_CODES: {
+    rpc: {
+        invalidInput: -32000;
+        resourceNotFound: -32001;
+        resourceUnavailable: -32002;
+        transactionRejected: -32003;
+        methodNotSupported: -32004;
+        limitExceeded: -32005;
+        parse: -32700;
+        invalidRequest: -32600;
+        methodNotFound: -32601;
+        invalidParams: -32602;
+        internal: -32603;
+    };
+    provider: {
+        userRejectedRequest: 4001;
+        unauthorized: 4100;
+        unsupportedMethod: 4200;
+        disconnected: 4900;
+        chainDisconnected: 4901;
+        unsupportedChain: 4902;
+    };
+};
+export type ErrorCodes = typeof STANDARD_ERROR_CODES;
+export type EIP1193ErrorCode = (typeof STANDARD_ERROR_CODES)["provider"][keyof (typeof STANDARD_ERROR_CODES)["provider"]];
+export type RPCErrorCode = (typeof STANDARD_ERROR_CODES)["rpc"][keyof (typeof STANDARD_ERROR_CODES)["rpc"]];
+export declare const errorValues: Record<`${EIP1193ErrorCode | RPCErrorCode}`, {
+    standard: string;
+    message: string;
+}>;
+export declare class EIP1193ProviderError extends Error {
+    code: EIP1193ErrorCode;
+    constructor(code: EIP1193ErrorCode, message: string);
+}
+export declare class RPCRequestError extends Error {
+    code: RPCErrorCode;
+    constructor(code: RPCErrorCode, message: string);
+}
+export declare function validateRequest(request: Parameters<ReturnType<typeof ox_Provider.from>["request"]>[0], { chains }: {
+    chains: readonly [Chain, ...Chain[]];
+}): void;
+export declare function validateUserConnected(): Promise<import('../types.js').User>;
+export declare function validateUserOwnsAddress(address: EvmAddress): Promise<import('../types.js').User>;
+export declare function validateUserHasEvmAccount(): Promise<import('../types.js').User>;
+export declare function validateUserHasEvmSmartAccount(): Promise<import('../types.js').User>;

package/dist/types/eip1193/eventEmitter.d.ts

@@ -0,0 +1,8 @@
+export type SupportedEvent = "accountsChanged" | "chainChanged" | "connect" | "disconnect";
+export declare class EventEmitter {
+    private events;
+    on(event: SupportedEvent, listener: (...args: unknown[]) => void): void;
+    removeListener(event: SupportedEvent, listener: (...args: unknown[]) => void): void;
+    emit(event: SupportedEvent, ...args: unknown[]): void;
+    removeAllListeners(event?: SupportedEvent): void;
+}

package/dist/types/eip1193/index.d.ts

@@ -0,0 +1,3 @@
+import { Chain } from 'viem/chains';
+import { CDPEmbeddedWallet, CDPEmbeddedWalletConfig } from './types.js';
+export declare function createCDPEmbeddedWallet<chains extends readonly [Chain, ...Chain[]]>(_parameters: CDPEmbeddedWalletConfig<chains>): CDPEmbeddedWallet;

package/dist/types/eip1193/internal.d.ts

@@ -0,0 +1,31 @@
+import { Transport, WalletGetCallsStatusReturnType } from 'viem';
+import { Hex, EvmAddress } from '../types.js';
+import { EventEmitter } from './eventEmitter.js';
+import { PersonalSignRequest, SendTransactionRequest, SignTypedDataRequest, EthSignRequest, SwitchEthereumChainRequest, ProviderStoreInstance, SendTransactionRequestParams, SendCallsRequest, GetCallsStatusRequest, WalletCapabilities } from './types.js';
+export declare function shimProviderTxRequest(transaction: SendTransactionRequestParams[0]): {
+    to: EvmAddress;
+    data: `0x${string}` | undefined;
+    value: bigint | undefined;
+    nonce: number | undefined;
+    gas: bigint | undefined;
+    maxFeePerGas: bigint | undefined;
+    maxPriorityFeePerGas: bigint | undefined;
+    type: "eip1559";
+};
+export declare function shimProviderCallsRequest(calls: SendCallsRequest["params"][0]["calls"]): {
+    to: EvmAddress;
+    data: `0x${string}` | undefined;
+    value: bigint | undefined;
+}[];
+export declare function handleAccounts(): Promise<EvmAddress[]>;
+export declare function handleRequestAccounts(eventEmitter: EventEmitter, store: ProviderStoreInstance): Promise<EvmAddress[]>;
+export declare function handlePersonalSign(params: PersonalSignRequest["params"]): Promise<Hex>;
+export declare function handleSignTypedData(params: SignTypedDataRequest["params"]): Promise<Hex>;
+export declare function handleSendTransaction(params: SendTransactionRequest["params"], store: ProviderStoreInstance, transports: Record<number, Transport>): Promise<Hex>;
+export declare function handleEthSign(params: EthSignRequest["params"]): Promise<Hex>;
+export declare function handleChainId(store: ProviderStoreInstance): Promise<Hex>;
+export declare function handleDisconnect(): Promise<void>;
+export declare function handleSwitchEthereumChain(params: SwitchEthereumChainRequest["params"], store: ProviderStoreInstance): void;
+export declare function handleSendCalls(params: SendCallsRequest["params"], store: ProviderStoreInstance): Promise<`0x${string}`>;
+export declare function handleGetCallsStatus(params: GetCallsStatusRequest["params"], store: ProviderStoreInstance): Promise<WalletGetCallsStatusReturnType>;
+export declare function handleGetCapabilities(): Promise<WalletCapabilities>;

package/dist/types/eip1193/types.d.ts

@@ -0,0 +1,109 @@
+import { Provider as ox_Provider } from 'ox';
+import { Call, Chain, Transport } from 'viem';
+import { Mutate, StoreApi } from 'zustand';
+import { EvmAddress, Hex, User } from '../types.js';
+export type CDPEmbeddedWalletConfig<chains extends readonly [Chain, ...Chain[]] = readonly [Chain, ...Chain[]]> = {
+    chains: chains;
+    transports: Record<chains[number]["id"], Transport>;
+    announceProvider?: boolean;
+};
+export type EIP1193Provider = ox_Provider.Provider;
+export type CDPEmbeddedWallet = {
+    provider: EIP1193Provider;
+};
+export type EIP1193RequestFunctionType = ox_Provider.Provider;
+export type AccountsRequest = {
+    method: "eth_accounts";
+    params: [];
+};
+export type RequestAccountsRequest = {
+    method: "eth_requestAccounts";
+    params: [];
+};
+export type PersonalSignRequest = {
+    method: "personal_sign";
+    params: [`0x${string}`, `0x${string}`];
+};
+export type SendTransactionRequestParams = [
+    {
+        chainId?: `0x${string}`;
+        data?: Hex;
+        from: EvmAddress;
+        to: EvmAddress;
+        value: Hex;
+        nonce?: Hex;
+        gas?: Hex;
+        maxFeePerGas?: Hex;
+        maxPriorityFeePerGas?: Hex;
+        type?: "eip1559";
+    }
+];
+export type SendTransactionRequest = {
+    method: "eth_sendTransaction";
+    params: SendTransactionRequestParams;
+};
+export type SignTypedDataRequest = {
+    method: "eth_signTypedData_v4";
+    params: [EvmAddress, string];
+};
+export type EthSignRequest = {
+    method: "eth_sign";
+    params: [Hex, EvmAddress];
+};
+export type ChainIdRequest = {
+    method: "eth_chainId";
+    params: [];
+};
+export type WalletDisconnectRequest = {
+    method: "wallet_disconnect";
+    params: [];
+};
+export type SwitchEthereumChainRequest = {
+    method: "wallet_switchEthereumChain";
+    params: [{
+        chainId: string;
+    }];
+};
+export type SendCallsRequest = {
+    method: "wallet_sendCalls";
+    params: [{
+        calls: Call[];
+    }];
+};
+export type GetCallsStatusRequest = {
+    method: "wallet_getCallsStatus";
+    params: [`0x${string}`];
+};
+export type GetCapabilitiesRequest = {
+    method: "wallet_getCapabilities";
+    params: [];
+};
+export type UnknownRequest = {
+    method: string;
+    params: unknown[];
+};
+export type ProviderRequest = AccountsRequest | RequestAccountsRequest | PersonalSignRequest | SendTransactionRequest | SignTypedDataRequest | EthSignRequest | ChainIdRequest | WalletDisconnectRequest | SwitchEthereumChainRequest | SendCallsRequest | GetCallsStatusRequest | GetCapabilitiesRequest;
+export type ExactPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? ExactPartial<T[P]> : T[P];
+};
+export type ProviderState = {
+    chainId: number;
+    setChainId: (chainId: number) => void;
+    chains: readonly [Chain, ...Chain[]];
+    user: User | null;
+    setUser: (user: User | null) => void;
+};
+export type ProviderStoreInstance = Mutate<StoreApi<ProviderState>, [
+    ["zustand/subscribeWithSelector", never],
+    ["zustand/persist", ProviderState]
+]>;
+export type WalletCapabilities = {
+    [chainId: Hex]: {
+        atomic: {
+            status: "supported" | "unsupported";
+        };
+        paymasterService: {
+            supported: boolean;
+        };
+    };
+};

package/dist/types/errors.d.ts

@@ -0,0 +1,5 @@
+export declare class ModuleResolutionError extends Error {
+    moduleName: string;
+    requiredFor: string;
+    constructor(moduleName: string, requiredFor: string, message?: string);
+}