@coinbase/cdp-core 0.0.25 → 0.0.27

package/dist/web/index.web90.js

@@ -0,0 +1,23 @@
+import { JOSENotSupported as f } from "./index.web27.js";
+const w = (n, r, a, e, s) => {
+  if (s.crit !== void 0 && e?.crit === void 0)
+    throw new n('"crit" (Critical) Header Parameter MUST be integrity protected');
+  if (!e || e.crit === void 0)
+    return /* @__PURE__ */ new Set();
+  if (!Array.isArray(e.crit) || e.crit.length === 0 || e.crit.some((i) => typeof i != "string" || i.length === 0))
+    throw new n('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present');
+  let t;
+  a !== void 0 ? t = new Map([...Object.entries(a), ...r.entries()]) : t = r;
+  for (const i of e.crit) {
+    if (!t.has(i))
+      throw new f(`Extension Header Parameter "${i}" is not recognized`);
+    if (s[i] === void 0)
+      throw new n(`Extension Header Parameter "${i}" is missing`);
+    if (t.get(i) && e[i] === void 0)
+      throw new n(`Extension Header Parameter "${i}" MUST be integrity protected`);
+  }
+  return new Set(e.crit);
+};
+export {
+  w as default
+};

package/dist/web/index.web91.js

@@ -0,0 +1,120 @@
+import { isJWK as p } from "./index.web101.js";
+import { decode as m } from "./index.web86.js";
+import y from "./index.web102.js";
+import { isCryptoKey as S, isKeyObject as K } from "./index.web100.js";
+let c;
+const f = async (e, r, s, i = !1) => {
+  c ||= /* @__PURE__ */ new WeakMap();
+  let n = c.get(e);
+  if (n?.[s])
+    return n[s];
+  const t = await y({ ...r, alg: s });
+  return i && Object.freeze(e), n ? n[s] = t : c.set(e, { [s]: t }), t;
+}, E = (e, r) => {
+  c ||= /* @__PURE__ */ new WeakMap();
+  let s = c.get(e);
+  if (s?.[r])
+    return s[r];
+  const i = e.type === "public", n = !!i;
+  let t;
+  if (e.asymmetricKeyType === "x25519") {
+    switch (r) {
+      case "ECDH-ES":
+      case "ECDH-ES+A128KW":
+      case "ECDH-ES+A192KW":
+      case "ECDH-ES+A256KW":
+        break;
+      default:
+        throw new TypeError("given KeyObject instance cannot be used for this algorithm");
+    }
+    t = e.toCryptoKey(e.asymmetricKeyType, n, i ? [] : ["deriveBits"]);
+  }
+  if (e.asymmetricKeyType === "ed25519") {
+    if (r !== "EdDSA" && r !== "Ed25519")
+      throw new TypeError("given KeyObject instance cannot be used for this algorithm");
+    t = e.toCryptoKey(e.asymmetricKeyType, n, [
+      i ? "verify" : "sign"
+    ]);
+  }
+  if (e.asymmetricKeyType === "rsa") {
+    let a;
+    switch (r) {
+      case "RSA-OAEP":
+        a = "SHA-1";
+        break;
+      case "RS256":
+      case "PS256":
+      case "RSA-OAEP-256":
+        a = "SHA-256";
+        break;
+      case "RS384":
+      case "PS384":
+      case "RSA-OAEP-384":
+        a = "SHA-384";
+        break;
+      case "RS512":
+      case "PS512":
+      case "RSA-OAEP-512":
+        a = "SHA-512";
+        break;
+      default:
+        throw new TypeError("given KeyObject instance cannot be used for this algorithm");
+    }
+    if (r.startsWith("RSA-OAEP"))
+      return e.toCryptoKey({
+        name: "RSA-OAEP",
+        hash: a
+      }, n, i ? ["encrypt"] : ["decrypt"]);
+    t = e.toCryptoKey({
+      name: r.startsWith("PS") ? "RSA-PSS" : "RSASSA-PKCS1-v1_5",
+      hash: a
+    }, n, [i ? "verify" : "sign"]);
+  }
+  if (e.asymmetricKeyType === "ec") {
+    const o = (/* @__PURE__ */ new Map([
+      ["prime256v1", "P-256"],
+      ["secp384r1", "P-384"],
+      ["secp521r1", "P-521"]
+    ])).get(e.asymmetricKeyDetails?.namedCurve);
+    if (!o)
+      throw new TypeError("given KeyObject instance cannot be used for this algorithm");
+    r === "ES256" && o === "P-256" && (t = e.toCryptoKey({
+      name: "ECDSA",
+      namedCurve: o
+    }, n, [i ? "verify" : "sign"])), r === "ES384" && o === "P-384" && (t = e.toCryptoKey({
+      name: "ECDSA",
+      namedCurve: o
+    }, n, [i ? "verify" : "sign"])), r === "ES512" && o === "P-521" && (t = e.toCryptoKey({
+      name: "ECDSA",
+      namedCurve: o
+    }, n, [i ? "verify" : "sign"])), r.startsWith("ECDH-ES") && (t = e.toCryptoKey({
+      name: "ECDH",
+      namedCurve: o
+    }, n, i ? [] : ["deriveBits"]));
+  }
+  if (!t)
+    throw new TypeError("given KeyObject instance cannot be used for this algorithm");
+  return s ? s[r] = t : c.set(e, { [r]: t }), t;
+}, d = async (e, r) => {
+  if (e instanceof Uint8Array || S(e))
+    return e;
+  if (K(e)) {
+    if (e.type === "secret")
+      return e.export();
+    if ("toCryptoKey" in e && typeof e.toCryptoKey == "function")
+      try {
+        return E(e, r);
+      } catch (i) {
+        if (i instanceof TypeError)
+          throw i;
+      }
+    let s = e.export({ format: "jwk" });
+    return f(e, s, r);
+  }
+  if (p(e))
+    return e.k ? m(e.k) : f(e, e, r, !0);
+  throw new Error("unreachable");
+};
+export {
+  d as default
+};

package/dist/web/index.web92.js

@@ -0,0 +1,12 @@
+import { contracts as o } from "./index.web103.js";
+import { formatters as r } from "./index.web104.js";
+import { serializers as t } from "./index.web105.js";
+const e = {
+  blockTime: 2e3,
+  contracts: o,
+  formatters: r,
+  serializers: t
+};
+export {
+  e as chainConfig
+};

package/dist/web/index.web93.js

@@ -0,0 +1,81 @@
+import { Hash as g, createView as l, aexists as b, toBytes as a, abytes as d, aoutput as x, clean as w } from "./index.web82.js";
+function y(o, t, s, n) {
+  if (typeof o.setBigUint64 == "function")
+    return o.setBigUint64(t, s, n);
+  const i = BigInt(32), h = BigInt(4294967295), e = Number(s >> i & h), r = Number(s & h), c = n ? 4 : 0, u = n ? 0 : 4;
+  o.setUint32(t + c, e, n), o.setUint32(t + u, r, n);
+}
+function U(o, t, s) {
+  return o & t ^ ~o & s;
+}
+function _(o, t, s) {
+  return o & t ^ o & s ^ t & s;
+}
+class m extends g {
+  constructor(t, s, n, i) {
+    super(), this.finished = !1, this.length = 0, this.pos = 0, this.destroyed = !1, this.blockLen = t, this.outputLen = s, this.padOffset = n, this.isLE = i, this.buffer = new Uint8Array(t), this.view = l(this.buffer);
+  }
+  update(t) {
+    b(this), t = a(t), d(t);
+    const { view: s, buffer: n, blockLen: i } = this, h = t.length;
+    for (let e = 0; e < h; ) {
+      const r = Math.min(i - this.pos, h - e);
+      if (r === i) {
+        const c = l(t);
+        for (; i <= h - e; e += i)
+          this.process(c, e);
+        continue;
+      }
+      n.set(t.subarray(e, e + r), this.pos), this.pos += r, e += r, this.pos === i && (this.process(s, 0), this.pos = 0);
+    }
+    return this.length += t.length, this.roundClean(), this;
+  }
+  digestInto(t) {
+    b(this), x(t, this), this.finished = !0;
+    const { buffer: s, view: n, blockLen: i, isLE: h } = this;
+    let { pos: e } = this;
+    s[e++] = 128, w(this.buffer.subarray(e)), this.padOffset > i - e && (this.process(n, 0), e = 0);
+    for (let f = e; f < i; f++)
+      s[f] = 0;
+    y(n, i - 8, BigInt(this.length * 8), h), this.process(n, 0);
+    const r = l(t), c = this.outputLen;
+    if (c % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const u = c / 4, p = this.get();
+    if (u > p.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let f = 0; f < u; f++)
+      r.setUint32(4 * f, p[f], h);
+  }
+  digest() {
+    const { buffer: t, outputLen: s } = this;
+    this.digestInto(t);
+    const n = t.slice(0, s);
+    return this.destroy(), n;
+  }
+  _cloneInto(t) {
+    t || (t = new this.constructor()), t.set(...this.get());
+    const { blockLen: s, buffer: n, length: i, finished: h, destroyed: e, pos: r } = this;
+    return t.destroyed = e, t.finished = h, t.length = i, t.pos = r, i % s && t.buffer.set(n), t;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+}
+const B = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+export {
+  U as Chi,
+  m as HashMD,
+  _ as Maj,
+  B as SHA256_IV,
+  y as setBigUint64
+};

package/dist/web/index.web94.js

@@ -0,0 +1,7 @@
+const e = 32, s = 4096, t = 131072, l = 761855;
+export {
+  t as bytesPerBlob,
+  e as bytesPerFieldElement,
+  s as fieldElementsPerBlob,
+  l as maxBytesPerTransaction
+};

package/dist/web/index.web95.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.web96.js

@@ -0,0 +1,30 @@
+import { JOSENotSupported as r } from "./index.web27.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.web97.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.web98.js

@@ -0,0 +1,13 @@
+import { checkSigCryptoKey as i } from "./index.web106.js";
+import o from "./index.web99.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/index.web99.js

@@ -0,0 +1,15 @@
+function i(n, e, ...o) {
+  if (o = o.filter(Boolean), o.length > 2) {
+    const f = o.pop();
+    n += `one of type ${o.join(", ")}, or ${f}.`;
+  } else o.length === 2 ? n += `one of type ${o[0]} or ${o[1]}.` : n += `of type ${o[0]}.`;
+  return e == null ? n += ` Received ${e}` : typeof e == "function" && e.name ? n += ` Received function ${e.name}` : typeof e == "object" && e != null && e.constructor?.name && (n += ` Received an instance of ${e.constructor.name}`), n;
+}
+const r = (n, ...e) => i("Key must be ", n, ...e);
+function t(n, e, ...o) {
+  return i(`Key for the ${n} algorithm must be `, e, ...o);
+}
+export {
+  r as default,
+  t as withAlg
+};

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';