@coinbase/cdp-core 0.0.24 → 0.0.26

package/dist/web/index.web9.js

@@ -0,0 +1,97 @@
+import { getTypesForEIP712Domain as a } from "viem";
+import { getCurrentUser as s, signEvmHash as i, signEvmTypedData as c, signEvmTransaction as u, signEvmMessage as m } from "./index.web5.js";
+import "@coinbase/cdp-api-client";
+import { toAccount as g } from "./index.web20.js";
+async function w(r) {
+  const n = await s();
+  if (!n || !n.evmAccounts || n.evmAccounts.length === 0)
+    throw new Error(
+      "No accounts found - user must be authenticated and have at least one EVM account"
+    );
+  if (!n.evmAccounts.includes(r))
+    throw new Error(`Cannot sign for address ${r} - not authorized for this account`);
+  return g({
+    address: r,
+    /**
+     * Signs a message using CDP's message signing functionality.
+     * Supports string messages, hex strings, and byte arrays.
+     *
+     * @param root0 - The parameters object
+     * @param root0.message - The message to sign, can be a string, hex string, or byte array
+     * @returns The signature as a hex string
+     */
+    async signMessage({ message: e }) {
+      let t;
+      if (typeof e == "string")
+        t = e;
+      else if ("raw" in e)
+        typeof e.raw == "string" ? t = e.raw : t = new TextDecoder().decode(e.raw);
+      else
+        throw new Error("Unsupported message format");
+      return (await m({
+        evmAccount: r,
+        message: t
+      })).signature;
+    },
+    /**
+     * Signs a transaction using CDP's transaction signing functionality.
+     * Converts Viem's transaction format to CDP's AllowedEvmTransactionType.
+     *
+     * @param transaction - The transaction to sign in Viem's format
+     * @returns The signature as a hex string
+     */
+    async signTransaction(e) {
+      const t = {
+        to: e.to,
+        value: e.value,
+        data: e.data,
+        nonce: e.nonce,
+        gas: e.gas,
+        chainId: e.chainId ?? 1
+      };
+      return e.gasPrice !== void 0 ? (t.maxFeePerGas = e.gasPrice, t.maxPriorityFeePerGas = e.gasPrice) : (t.maxFeePerGas = e.maxFeePerGas, t.maxPriorityFeePerGas = e.maxPriorityFeePerGas), (await u({
+        evmAccount: r,
+        transaction: t
+      })).signedTransaction;
+    },
+    /**
+     * Signs EIP-712 typed data using CDP's typed data signing functionality.
+     * Handles domain separation and type encoding according to the EIP-712 specification.
+     *
+     * @param params - The typed data parameters following the EIP-712 specification
+     * @returns The signature as a hex string
+     */
+    async signTypedData(e) {
+      const t = {
+        domain: e.domain,
+        types: {
+          EIP712Domain: a({
+            domain: e.domain
+          }),
+          ...e.types
+        },
+        primaryType: e.primaryType,
+        message: e.message
+      };
+      return (await c({
+        evmAccount: r,
+        typedData: t
+      })).signature;
+    },
+    /**
+     * Signs a raw message hash using CDP's message signing functionality.
+     *
+     * @param message - The message hash to sign
+     * @returns The signature as a hex string
+     */
+    async sign(e) {
+      return (await i({
+        evmAccount: r,
+        hash: e.hash
+      })).signature;
+    }
+  });
+}
+export {
+  w as toViemAccount
+};

package/dist/web/index.web90.js

@@ -0,0 +1,22 @@
+const o = /* @__PURE__ */ BigInt(4294967295), i = /* @__PURE__ */ BigInt(32);
+function s(t, r = !1) {
+  return r ? { h: Number(t & o), l: Number(t >> i & o) } : { h: Number(t >> i & o) | 0, l: Number(t & o) | 0 };
+}
+function h(t, r = !1) {
+  const n = t.length;
+  let l = new Uint32Array(n), c = new Uint32Array(n);
+  for (let e = 0; e < n; e++) {
+    const { h: u, l: f } = s(t[e], r);
+    [l[e], c[e]] = [u, f];
+  }
+  return [l, c];
+}
+const m = (t, r, n) => t << n | r >>> 32 - n, A = (t, r, n) => r << n | t >>> 32 - n, B = (t, r, n) => r << n - 32 | t >>> 64 - n, a = (t, r, n) => t << n - 32 | r >>> 64 - n;
+export {
+  s as fromBig,
+  B as rotlBH,
+  a as rotlBL,
+  m as rotlSH,
+  A as rotlSL,
+  h as split
+};

package/dist/web/index.web91.js

@@ -0,0 +1,35 @@
+import { maxBytesPerTransaction as y, bytesPerBlob as a, fieldElementsPerBlob as f, bytesPerFieldElement as p } from "./index.web104.js";
+import { EmptyBlobError as c, BlobSizeTooLargeError as h } from "./index.web67.js";
+import { createCursor as B } from "./index.web57.js";
+import { size as u } from "./index.web46.js";
+import { hexToBytes as x } from "./index.web39.js";
+import { bytesToHex as d } from "./index.web37.js";
+function S(e) {
+  const m = e.to ?? (typeof e.data == "string" ? "hex" : "bytes"), i = typeof e.data == "string" ? x(e.data) : e.data, o = u(i);
+  if (!o)
+    throw new c();
+  if (o > y)
+    throw new h({
+      maxSize: y,
+      size: o
+    });
+  const s = [];
+  let n = !0, r = 0;
+  for (; n; ) {
+    const t = B(new Uint8Array(a));
+    let l = 0;
+    for (; l < f; ) {
+      const b = i.slice(r, r + (p - 1));
+      if (t.pushByte(0), t.pushBytes(b), b.length < 31) {
+        t.pushByte(128), n = !1;
+        break;
+      }
+      l++, r += 31;
+    }
+    s.push(t);
+  }
+  return m === "bytes" ? s.map((t) => t.bytes) : s.map((t) => d(t.bytes));
+}
+export {
+  S as toBlobs
+};

package/dist/web/index.web92.js

@@ -0,0 +1,9 @@
+import { bytesToHex as i } from "./index.web37.js";
+import { sha256 as m } from "./index.web60.js";
+function f(t) {
+  const { commitment: e, version: s = 1 } = t, n = t.to ?? (typeof e == "string" ? "hex" : "bytes"), o = m(e);
+  return o.set([s], 0), n === "bytes" ? o : i(o);
+}
+export {
+  f as commitmentToVersionedHash
+};

package/dist/web/index.web93.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.web94.js

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

@@ -0,0 +1,44 @@
+import { InvalidAddressError as a } from "./index.web28.js";
+import { isAddress as f } from "./index.web29.js";
+import { concatHex as p } from "./index.web42.js";
+import { toHex as i } from "./index.web37.js";
+import { toRlp as x } from "./index.web55.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.web96.js

@@ -0,0 +1,20 @@
+function o(t) {
+  if (Uint8Array.prototype.toBase64)
+    return t.toBase64();
+  const e = 32768, n = [];
+  for (let r = 0; r < t.length; r += e)
+    n.push(String.fromCharCode.apply(null, t.subarray(r, r + e)));
+  return btoa(n.join(""));
+}
+function a(t) {
+  if (Uint8Array.fromBase64)
+    return Uint8Array.fromBase64(t);
+  const e = atob(t), n = new Uint8Array(e.length);
+  for (let r = 0; r < e.length; r++)
+    n[r] = e.charCodeAt(r);
+  return n;
+}
+export {
+  a as decodeBase64,
+  o as encodeBase64
+};

package/dist/web/index.web97.js

@@ -0,0 +1,30 @@
+import { JOSENotSupported as r } from "./index.web26.js";
+const S = (e, s) => {
+  const a = `SHA-${e.slice(-3)}`;
+  switch (e) {
+    case "HS256":
+    case "HS384":
+    case "HS512":
+      return { hash: a, name: "HMAC" };
+    case "PS256":
+    case "PS384":
+    case "PS512":
+      return { hash: a, name: "RSA-PSS", saltLength: parseInt(e.slice(-3), 10) >> 3 };
+    case "RS256":
+    case "RS384":
+    case "RS512":
+      return { hash: a, name: "RSASSA-PKCS1-v1_5" };
+    case "ES256":
+    case "ES384":
+    case "ES512":
+      return { hash: a, name: "ECDSA", namedCurve: s.namedCurve };
+    case "Ed25519":
+    case "EdDSA":
+      return { name: "Ed25519" };
+    default:
+      throw new r(`alg ${e} is not supported either by JOSE or your javascript runtime`);
+  }
+};
+export {
+  S as default
+};

package/dist/web/index.web98.js

@@ -0,0 +1,10 @@
+const o = (t, r) => {
+  if (t.startsWith("RS") || t.startsWith("PS")) {
+    const { modulusLength: e } = r.algorithm;
+    if (typeof e != "number" || e < 2048)
+      throw new TypeError(`${t} requires key modulusLength to be 2048 bits or larger`);
+  }
+};
+export {
+  o as default
+};

package/dist/web/index.web99.js

@@ -0,0 +1,13 @@
+import { checkSigCryptoKey as i } from "./index.web105.js";
+import o from "./index.web100.js";
+const s = async (t, r, e) => {
+  if (r instanceof Uint8Array) {
+    if (!t.startsWith("HS"))
+      throw new TypeError(o(r, "CryptoKey", "KeyObject", "JSON Web Key"));
+    return crypto.subtle.importKey("raw", r, { hash: `SHA-${t.slice(-3)}`, name: "HMAC" }, !1, [e]);
+  }
+  return i(r, t, e), r;
+};
+export {
+  s as default
+};

package/dist/web-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/web-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/web-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/web-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/web-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/web-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/web-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/web-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/web-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/web-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/web-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/web-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);
+}

package/dist/web-types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './core.js';
+export * from './types.js';
+export * from './provider.js';
+export * from './viem/toViemAccount.js';
+export * from './errors.js';