@nerochain/mpc-sdk 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,656 @@
+import { K as KeyShare, W as WalletInfo, c as StorageAdapter, P as ProtocolMessage, d as ProtocolMessageType, A as APIClient, D as DKGResult, e as SigningRequest, f as SigningResult, E as EIP1193Provider } from './nero-sdk-Cm8gzHZJ.mjs';
+export { g as AddEthereumChainParameter, h as AuthTokens, C as ConnectionStatus, i as DKGCommitment, j as DKGRound, k as DKGSessionState, l as DKGShare, m as DeviceFingerprint, n as EIP1193_ERROR_CODES, o as EncryptedKeyShare, L as LoginProvider, N as NeroMpcSDK, a as NeroSDKState, O as OAuthProvider, p as PartialSignature, q as ProviderConnectInfo, r as ProviderMessage, s as ProviderRpcError, R as RequestArguments, S as SDKConfig, t as SDKError, b as Signature, u as SigningRound, v as SigningSessionState, w as SmartWallet, x as SmartWalletConfig, T as TransactionParams, y as TransactionRequest, z as TypedDataDomain, B as TypedDataField, F as TypedDataMessage, G as TypedDataTypes, H as UIConfig, U as User, I as UserInfo, J as WatchAssetParams, M as createNeroSDK, Q as createProviderRpcError, V as createSmartWallet } from './nero-sdk-Cm8gzHZJ.mjs';
+export { NeroProvider, NeroProviderConfig, createNeroProvider } from './no-modal.mjs';
+import { secp256k1 } from '@noble/curves/secp256k1';
+export { C as ChainConfig, a as ChainManager, b as ChainNamespace, R as RpcConnection, S as SupportedChainId, T as TransactionReceipt, c as createChainManager } from './chain-manager-C3eHsVt9.mjs';
+export { ARBITRUM_ONE, BASE_MAINNET, BUILTIN_CHAINS, ETHEREUM_MAINNET, ETHEREUM_SEPOLIA, NERO_MAINNET, NERO_TESTNET, POLYGON_MAINNET, getAllChains, getChainConfig, getMainnetChains, getTestnetChains } from './chains.mjs';
+export { BundlerClient, BundlerClientConfig, GasEstimate, PaymasterClient, PaymasterClientConfig, PaymasterContext, PaymasterResult, SimpleAccount, SimpleAccountConfig, SimpleAccountFactoryData, UserOperation, UserOperationHex, UserOperationReceipt, createBundlerClient, createPaymasterClient, createSimpleAccount, userOpFromHex, userOpToHex } from './aa.mjs';
+import React__default from 'react';
+export { bytesToHex, hexToBytes, utf8ToBytes } from '@noble/hashes/utils';
+
+interface KeyManagerConfig {
+    storagePrefix?: string;
+}
+declare class ClientKeyManager {
+    private storage;
+    private currentUserId;
+    private cachedKeyShare;
+    private cachedPartyShares;
+    constructor(deviceKey: string, config?: KeyManagerConfig);
+    initialize(userId: string): Promise<void>;
+    hasKeyShare(): Promise<boolean>;
+    getKeyShare(): Promise<KeyShare | null>;
+    storeKeyShare(keyShare: KeyShare): Promise<void>;
+    getPartyPublicShares(): Promise<Map<number, string> | null>;
+    storePartyPublicShares(shares: Map<number, string>): Promise<void>;
+    deleteKeyShare(): Promise<void>;
+    rotateKeyShare(newKeyShare: KeyShare): Promise<void>;
+    exportBackup(password: string): Promise<string>;
+    importBackup(backupString: string, password: string): Promise<KeyShare>;
+    getWalletInfo(publicKey: string, chainId: number): WalletInfo;
+    private deriveEOAAddress;
+    clear(): Promise<void>;
+}
+declare function generateDeviceKey(): string;
+declare function deriveDeviceKey(userAgent: string, userId: string, additionalEntropy?: string): string;
+
+declare class IndexedDBStorage implements StorageAdapter {
+    private prefix;
+    constructor(prefix?: string);
+    private prefixKey;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+declare class MemoryStorage implements StorageAdapter {
+    private store;
+    private prefix;
+    constructor(prefix?: string);
+    private prefixKey;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+declare class SecureKeyStorage {
+    private storage;
+    private deviceKey;
+    constructor(storage: StorageAdapter, deviceKey: string);
+    private getStorageKey;
+    private getPartySharesKey;
+    storeKeyShare(userId: string, keyShare: KeyShare): Promise<void>;
+    getKeyShare(userId: string): Promise<KeyShare | null>;
+    hasKeyShare(userId: string): Promise<boolean>;
+    deleteKeyShare(userId: string): Promise<void>;
+    storePartyPublicShares(userId: string, shares: Map<number, string>): Promise<void>;
+    getPartyPublicShares(userId: string): Promise<Map<number, string> | null>;
+    deletePartyPublicShares(userId: string): Promise<void>;
+    clearAll(): Promise<void>;
+}
+declare function createSecureStorage(deviceKey: string, prefix?: string): SecureKeyStorage;
+
+declare function deriveKeyFromPassword(password: string, salt: Uint8Array): Promise<CryptoKey>;
+declare function deriveKeyFromDeviceInfo(deviceId: string, userId: string): Promise<CryptoKey>;
+interface EncryptionResult {
+    ciphertext: string;
+    iv: string;
+    salt: string;
+}
+declare function encryptWithPassword(plaintext: string, password: string): Promise<EncryptionResult>;
+declare function decryptWithPassword(encrypted: EncryptionResult, password: string): Promise<string>;
+declare function encryptWithKey(plaintext: string, key: CryptoKey): Promise<{
+    ciphertext: string;
+    iv: string;
+}>;
+declare function decryptWithKey(ciphertext: string, iv: string, key: CryptoKey): Promise<string>;
+declare function generateRandomBytes(length: number): Uint8Array;
+declare function generateRandomHex(length: number): string;
+declare function hashSha256(data: string | Uint8Array): string;
+declare function computeCommitment(value: string, blinding: string): string;
+
+type MessageHandler = (message: ProtocolMessage) => void;
+type ConnectionHandler = () => void;
+type ErrorHandler = (error: Error) => void;
+declare class WebSocketClient {
+    private ws;
+    private url;
+    private accessToken;
+    private messageHandlers;
+    private globalHandlers;
+    private onConnectHandlers;
+    private onDisconnectHandlers;
+    private onErrorHandlers;
+    private reconnectAttempt;
+    private reconnectTimeout;
+    private pingInterval;
+    private messageQueue;
+    private isConnecting;
+    constructor(url: string);
+    setAccessToken(token: string): void;
+    connect(): Promise<void>;
+    disconnect(): void;
+    isConnected(): boolean;
+    send(message: ProtocolMessage): void;
+    on(type: ProtocolMessageType, handler: MessageHandler): () => void;
+    onAny(handler: MessageHandler): () => void;
+    onConnect(handler: ConnectionHandler): () => void;
+    onDisconnect(handler: ConnectionHandler): () => void;
+    onError(handler: ErrorHandler): () => void;
+    waitForMessage(type: ProtocolMessageType, sessionId: string, timeout?: number): Promise<ProtocolMessage>;
+    private handleMessage;
+    private queueMessage;
+    private flushMessageQueue;
+    private scheduleReconnect;
+    private stopReconnect;
+    private startPingInterval;
+    private stopPingInterval;
+}
+
+interface DKGClientConfig {
+    apiClient: APIClient;
+    wsClient?: WebSocketClient;
+    timeout?: number;
+}
+declare class DKGClient {
+    private apiClient;
+    private wsClient?;
+    private timeout;
+    private state;
+    private polynomial;
+    private ephemeralKeyPair;
+    private receivedCommitments;
+    private receivedShares;
+    constructor(config: DKGClientConfig);
+    execute(): Promise<DKGResult>;
+    private initializeSession;
+    private runCommitmentPhase;
+    private runShareExchangePhase;
+    private runVerificationPhase;
+    private completeProtocol;
+    getKeyShare(): KeyShare | null;
+    getPartyPublicShares(): Map<number, string>;
+    private waitForCommitments;
+    private waitForShares;
+    private deriveWalletAddress;
+    private computeShareCommitment;
+    private delay;
+    cleanup(): void;
+}
+
+declare const CURVE_ORDER: bigint;
+declare function generatePolynomial(degree: number): bigint[];
+declare function evaluatePolynomial(coefficients: bigint[], x: bigint): bigint;
+declare function computeCommitments(coefficients: bigint[]): string[];
+declare function verifyShareAgainstCommitments(share: bigint, partyIndex: bigint, commitments: string[]): boolean;
+declare function combinePublicKeys(commitments: string[][]): string;
+declare function computeLagrangeCoefficient(partyIndex: bigint, participatingIndices: bigint[]): bigint;
+declare function aggregateShares(receivedShares: Map<number, bigint>, ownShare: bigint): bigint;
+declare function scalarToHex(scalar: bigint): string;
+declare function hexToScalar(hex: string): bigint;
+
+interface PedersenCommitment {
+    commitment: string;
+    value: bigint;
+    blinding: bigint;
+}
+declare function createPedersenCommitment(value: bigint): PedersenCommitment;
+declare function verifyPedersenCommitment(commitment: string, value: bigint, blinding: bigint): boolean;
+interface VSSSCommitment {
+    partyId: number;
+    coefficientCommitments: string[];
+    proofOfKnowledge: string;
+}
+declare function createVSSSCommitments(partyId: number, coefficients: bigint[]): VSSSCommitment;
+declare function verifyVSSSCommitment(commitment: VSSSCommitment, share: bigint, receiverPartyId: number): boolean;
+declare function verifyProofOfKnowledge(proof: string, partyId: number, publicCommitment: string): boolean;
+declare function combineVSSSCommitments(commitments: VSSSCommitment[]): string;
+
+interface EncryptedShare {
+    fromPartyId: number;
+    toPartyId: number;
+    ephemeralPublicKey: string;
+    ciphertext: string;
+    nonce: string;
+    tag: string;
+}
+interface DecryptedShare {
+    fromPartyId: number;
+    share: bigint;
+}
+declare function encryptShare(share: bigint, fromPartyId: number, toPartyId: number, recipientPublicKey: string): Promise<EncryptedShare>;
+declare function decryptShare(encryptedShare: EncryptedShare, recipientPrivateKey: bigint): Promise<DecryptedShare>;
+declare function generateEphemeralKeyPair(): {
+    privateKey: bigint;
+    publicKey: string;
+};
+declare function serializeEncryptedShare(share: EncryptedShare): string;
+declare function deserializeEncryptedShare(data: string): EncryptedShare;
+
+interface SigningClientConfig {
+    apiClient: APIClient;
+    wsClient?: WebSocketClient;
+    keyShare: KeyShare;
+    partyPublicShares: Map<number, string>;
+    timeout?: number;
+}
+declare class SigningClient {
+    private apiClient;
+    private wsClient?;
+    private keyShare;
+    private timeout;
+    private state;
+    private nonceShare;
+    private receivedCommitments;
+    private expectedPublicShares;
+    private r;
+    constructor(config: SigningClientConfig);
+    sign(request: SigningRequest): Promise<SigningResult>;
+    private initializeSession;
+    private runNonceCommitmentPhase;
+    private runPartialSignaturePhase;
+    private waitForPartialSignatures;
+    private verifyOtherPartials;
+    private completeProtocol;
+    private waitForNonceCommitments;
+    private waitForSigningResult;
+    private delay;
+    private cleanup;
+}
+declare function createSigningClient(apiClient: APIClient, keyShare: KeyShare, partyPublicShares: Map<number, string>, wsClient?: WebSocketClient): SigningClient;
+
+interface NonceShare {
+    k: bigint;
+    gamma: bigint;
+}
+interface NonceCommitment {
+    partyId: number;
+    D: string;
+    E: string;
+    proof: string;
+}
+interface NonceDecommitment {
+    partyId: number;
+    k: bigint;
+    gamma: bigint;
+}
+declare function generateNonceShare(): NonceShare;
+declare function createNonceCommitment(partyId: number, nonce: NonceShare): NonceCommitment;
+declare function verifyNonceCommitment(commitment: NonceCommitment): boolean;
+declare function combineNonceCommitments(commitments: NonceCommitment[]): {
+    R: string;
+    combinedGamma: string;
+};
+declare function computeR(combinedE: string): {
+    r: bigint;
+    R: string;
+    rPoint: {
+        x: bigint;
+        y: bigint;
+    };
+};
+
+interface PartialSignatureData {
+    partyId: number;
+    sigma: bigint;
+    publicShare: string;
+    nonceCommitment: string;
+}
+declare function computePartialSignature(partyId: number, keyShare: bigint, nonceK: bigint, _nonceGamma: bigint, messageHash: bigint, r: bigint, participatingParties: number[]): PartialSignatureData;
+declare function combinePartialSignatures(partials: PartialSignatureData[], r: bigint, combinedRPoint: {
+    x: bigint;
+    y: bigint;
+}): {
+    r: bigint;
+    s: bigint;
+    v: number;
+};
+declare function verifyPartialSignature(partial: PartialSignatureData, expectedPublicShare: string, expectedNonceCommitment: string, r: bigint, messageHash: bigint, participatingParties: number[]): boolean;
+declare function formatSignature(r: bigint, s: bigint, v: number): string;
+declare function parseMessageHash(hash: string): bigint;
+
+/**
+ * DKLS SDK Types
+ *
+ * Type definitions for DKLS threshold ECDSA protocol.
+ * Multiplicative secret sharing: sk = sk_A × sk_B (mod q)
+ */
+interface DKLSKeyShare {
+    partyId: number;
+    secretShare: string;
+    publicShare: string;
+    jointPublicKey: string;
+}
+interface DKLSSchnorrProof {
+    commitment: string;
+    challenge: string;
+    response: string;
+}
+interface DKLSKeygenCommitment {
+    partyId: number;
+    commitment: string;
+}
+interface DKLSKeygenPublicShare {
+    partyId: number;
+    publicShare: string;
+    proof: DKLSSchnorrProof;
+}
+interface DKLSNonceCommitment {
+    partyId: number;
+    R: string;
+    commitment: string;
+}
+interface DKLSSigningResult {
+    signature: string;
+    r: string;
+    s: string;
+    v: number;
+    messageHash: string;
+    walletAddress?: string | null;
+}
+interface DKLSKeygenSessionState {
+    sessionId: string;
+    status: "initialized" | "commitment_sent" | "commitment_received" | "complete";
+    backendCommitment?: DKLSKeygenCommitment;
+    backendPublicShare?: DKLSKeygenPublicShare;
+    clientKeyShare?: DKLSKeyShare;
+}
+interface DKLSSigningSessionState {
+    sessionId: string;
+    status: "initialized" | "nonce_committed" | "nonce_exchanged" | "mta_round1_complete" | "mta_round2_complete" | "partial_computed" | "completed" | "failed";
+    messageHash: string;
+    messageType: "message" | "transaction" | "typed_data";
+    backendNonceCommitment?: DKLSNonceCommitment;
+    r?: string;
+    rValue?: string;
+    result?: DKLSSigningResult;
+    error?: string;
+}
+interface DKLSSignRequest {
+    messageHash: string;
+    messageType?: "message" | "transaction" | "typed_data";
+    dkgSessionId: string;
+}
+
+/**
+ * DKLS Client
+ *
+ * SDK client for DKLS threshold ECDSA key generation and signing.
+ * Communicates with the V2 DKLS API endpoints.
+ */
+
+interface DKLSClientConfig {
+    apiClient: APIClient;
+    storage: StorageAdapter;
+}
+declare class DKLSClient {
+    private apiClient;
+    private storage;
+    private keygenState;
+    private signingState;
+    private mtaState;
+    private keyShare;
+    private dkgSessionId;
+    constructor(config: DKLSClientConfig);
+    loadKeyShare(): Promise<DKLSKeyShare | null>;
+    private saveKeyShare;
+    hasKeyShare(): Promise<boolean>;
+    getWalletAddress(): Promise<string | null>;
+    executeKeygen(): Promise<{
+        walletAddress: string;
+        jointPublicKey: string;
+    }>;
+    sign(request: DKLSSignRequest): Promise<DKLSSigningResult>;
+    signMessage(message: string): Promise<DKLSSigningResult>;
+    signTypedData(domain: Record<string, unknown>, types: Record<string, Array<{
+        name: string;
+        type: string;
+    }>>, value: Record<string, unknown>): Promise<DKLSSigningResult>;
+    clearKeyShare(): Promise<void>;
+}
+declare function createDKLSClient(apiClient: APIClient, storage: StorageAdapter): DKLSClient;
+
+type Point = ReturnType<typeof secp256k1.ProjectivePoint.fromHex>;
+interface DKLSKeygenClientState {
+    partyId: number;
+    secretShare: bigint;
+    publicShare: Point;
+    commitment: Uint8Array;
+    peerCommitment: Uint8Array | null;
+    peerPublicShare: Point | null;
+    jointPublicKey: Point | null;
+}
+declare function keygenInitClient(): {
+    state: DKLSKeygenClientState;
+    commitment: DKLSKeygenCommitment;
+};
+declare function keygenProcessBackendCommitment(state: DKLSKeygenClientState, backendCommitment: DKLSKeygenCommitment): DKLSKeygenClientState;
+declare function generateSchnorrProof(secretKey: bigint, publicKey: Point): DKLSSchnorrProof;
+declare function keygenGenerateReveal(state: DKLSKeygenClientState): DKLSKeygenPublicShare;
+declare function keygenComplete(state: DKLSKeygenClientState, backendPublicShare: DKLSKeygenPublicShare): DKLSKeyShare;
+interface DKLSSigningClientState {
+    partyId: number;
+    keyShare: DKLSKeyShare;
+    messageHash: bigint;
+    messageHashBytes: Uint8Array;
+    nonceShare: bigint;
+    noncePublic: Point;
+    nonceCommitment: Uint8Array;
+    peerNonceCommitment: Uint8Array | null;
+    peerNoncePublic: Point | null;
+    combinedNonce: Point | null;
+    rValue: bigint | null;
+}
+declare function signingInit(keyShare: DKLSKeyShare, messageHash: string): {
+    state: DKLSSigningClientState;
+    nonceCommitment: DKLSNonceCommitment;
+};
+declare function signingProcessBackendNonce(state: DKLSSigningClientState, backendNonceReveal: {
+    partyId: number;
+    R: string;
+}): DKLSSigningClientState;
+declare function serializeKeyShare(keyShare: DKLSKeyShare): DKLSKeyShare;
+declare function deriveEthereumAddress(jointPublicKeyHex: string): string;
+
+declare function deriveEOAAddress(publicKey: string): string;
+/**
+ * @deprecated This function produces incorrect addresses.
+ * Use SmartWallet.getSmartWalletAddress() or SimpleAccount.getAccountAddress()
+ * which call the factory's getAddress() method via RPC.
+ */
+declare function deriveSmartWalletAddress(_factoryAddress: string, _ownerAddress: string, _salt?: bigint): string;
+declare function computeCreate2Address(factoryAddress: string, salt: string, initCodeHash: string): string;
+declare function checksumAddress(address: string): string;
+declare function isValidAddress(address: string): boolean;
+
+interface WalletServicesConfig {
+    chainId: number;
+    walletAddress: string;
+    explorerUrl?: string;
+    fundingProviders?: FundingProvider[];
+}
+interface FundingProvider {
+    id: string;
+    name: string;
+    logoUrl?: string;
+    url: string;
+    supportedChains: number[];
+}
+interface FundingOptions {
+    amount?: string;
+    token?: string;
+    provider?: string;
+}
+interface TransactionHistoryItem {
+    hash: string;
+    from: string;
+    to: string;
+    value: string;
+    timestamp: number;
+    status: "pending" | "confirmed" | "failed";
+    type: "send" | "receive" | "contract";
+}
+interface TokenBalance {
+    address: string;
+    symbol: string;
+    name: string;
+    decimals: number;
+    balance: string;
+    logoUrl?: string;
+    valueUsd?: string;
+}
+
+interface WalletServicesPlugin {
+    showWalletUi(): Promise<void>;
+    showFunding(options?: FundingOptions): Promise<void>;
+    showReceive(): Promise<void>;
+    getTokenBalances(): Promise<TokenBalance[]>;
+    getTransactionHistory(): Promise<TransactionHistoryItem[]>;
+}
+type ModalType = "wallet" | "funding" | "receive" | null;
+type ModalListener = (modal: ModalType, options?: FundingOptions) => void;
+declare class WalletServicesPluginImpl implements WalletServicesPlugin {
+    private config;
+    private listeners;
+    constructor(config: WalletServicesConfig);
+    showWalletUi(): Promise<void>;
+    showFunding(options?: FundingOptions): Promise<void>;
+    showReceive(): Promise<void>;
+    getTokenBalances(): Promise<TokenBalance[]>;
+    getTransactionHistory(): Promise<TransactionHistoryItem[]>;
+    onModalOpen(listener: ModalListener): () => void;
+    private notifyListeners;
+    getConfig(): WalletServicesConfig;
+    updateConfig(config: Partial<WalletServicesConfig>): void;
+}
+declare function createWalletServicesPlugin(config: WalletServicesConfig): WalletServicesPluginImpl;
+
+interface WalletUIProps {
+    isOpen: boolean;
+    onClose: () => void;
+    walletInfo: WalletInfo | null;
+    tokens?: TokenBalance[];
+    transactions?: TransactionHistoryItem[];
+    onSend?: () => void;
+    onReceive?: () => void;
+    onFunding?: () => void;
+    onSwap?: () => void;
+}
+declare function WalletUI({ isOpen, onClose, walletInfo, tokens, transactions, onSend, onReceive, onFunding, onSwap, }: WalletUIProps): React__default.ReactElement;
+
+interface ReceiveModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    address: string;
+    chainName?: string;
+}
+declare function ReceiveModal({ isOpen, onClose, address, chainName, }: ReceiveModalProps): React__default.ReactElement;
+
+interface FundingModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    address: string;
+    chainId: number;
+    providers?: FundingProvider[];
+    onSelectProvider?: (provider: FundingProvider) => void;
+}
+declare function FundingModal({ isOpen, onClose, address, chainId, providers, onSelectProvider, }: FundingModalProps): React__default.ReactElement;
+
+type AdapterStatus = "disconnected" | "connecting" | "connected" | "errored";
+interface AdapterConfig {
+    chainId?: number;
+    autoConnect?: boolean;
+}
+interface WalletAdapterEvents {
+    connect: (info: {
+        chainId: number;
+        accounts: string[];
+    }) => void;
+    disconnect: (error?: Error) => void;
+    accountsChanged: (accounts: string[]) => void;
+    chainChanged: (chainId: number) => void;
+    error: (error: Error) => void;
+}
+declare abstract class BaseWalletAdapter {
+    abstract readonly name: string;
+    abstract readonly icon: string;
+    abstract readonly url: string;
+    protected _status: AdapterStatus;
+    protected _accounts: string[];
+    protected _chainId: number | null;
+    protected _provider: EIP1193Provider | null;
+    private listeners;
+    get status(): AdapterStatus;
+    get connected(): boolean;
+    get accounts(): string[];
+    get chainId(): number | null;
+    get provider(): EIP1193Provider | null;
+    abstract connect(config?: AdapterConfig): Promise<string[]>;
+    abstract disconnect(): Promise<void>;
+    abstract switchChain(chainId: number): Promise<void>;
+    on<K extends keyof WalletAdapterEvents>(event: K, listener: WalletAdapterEvents[K]): this;
+    off<K extends keyof WalletAdapterEvents>(event: K, listener: WalletAdapterEvents[K]): this;
+    protected emit<K extends keyof WalletAdapterEvents>(event: K, ...args: Parameters<WalletAdapterEvents[K]>): void;
+    protected setStatus(status: AdapterStatus): void;
+    protected setAccounts(accounts: string[]): void;
+    protected setChainId(chainId: number): void;
+    protected handleConnect(chainId: number, accounts: string[]): void;
+    protected handleDisconnect(error?: Error): void;
+    protected handleError(error: Error): void;
+}
+type WalletAdapterConstructor = new (config?: AdapterConfig) => BaseWalletAdapter;
+
+interface WalletConnectConfig extends AdapterConfig {
+    projectId: string;
+    chains?: number[];
+    showQrModal?: boolean;
+    qrModalOptions?: {
+        themeMode?: "light" | "dark";
+        themeVariables?: Record<string, string>;
+    };
+}
+declare class WalletConnectAdapter extends BaseWalletAdapter {
+    readonly name = "WalletConnect";
+    readonly icon = "https://walletconnect.com/walletconnect-logo.png";
+    readonly url = "https://walletconnect.com";
+    private ethereumProvider;
+    connect(config?: WalletConnectConfig): Promise<string[]>;
+    disconnect(): Promise<void>;
+    switchChain(chainId: number): Promise<void>;
+    private loadEthereumProvider;
+    private setupEventListeners;
+}
+declare function createWalletConnectAdapter(): WalletConnectAdapter;
+
+interface MetaMaskConfig extends AdapterConfig {
+    infuraApiKey?: string;
+    dappMetadata?: {
+        name: string;
+        url?: string;
+        iconUrl?: string;
+    };
+}
+declare global {
+    interface Window {
+        ethereum?: EIP1193Provider & {
+            isMetaMask?: boolean;
+            providers?: Array<EIP1193Provider & {
+                isMetaMask?: boolean;
+            }>;
+        };
+    }
+}
+declare class MetaMaskAdapter extends BaseWalletAdapter {
+    readonly name = "MetaMask";
+    readonly icon = "https://metamask.io/images/metamask-fox.svg";
+    readonly url = "https://metamask.io";
+    private config;
+    connect(config?: MetaMaskConfig): Promise<string[]>;
+    disconnect(): Promise<void>;
+    switchChain(chainId: number): Promise<void>;
+    isInstalled(): boolean;
+    private getMetaMaskProvider;
+    private checkMetaMaskSDK;
+    private setupEventListeners;
+}
+declare function createMetaMaskAdapter(): MetaMaskAdapter;
+
+interface CoinbaseConfig extends AdapterConfig {
+    appName: string;
+    appLogoUrl?: string;
+    darkMode?: boolean;
+}
+declare class CoinbaseAdapter extends BaseWalletAdapter {
+    readonly name = "Coinbase Wallet";
+    readonly icon = "https://www.coinbase.com/img/favicon/favicon-256.png";
+    readonly url = "https://www.coinbase.com/wallet";
+    private coinbaseWallet;
+    connect(config?: CoinbaseConfig): Promise<string[]>;
+    disconnect(): Promise<void>;
+    switchChain(chainId: number): Promise<void>;
+    private loadCoinbaseSDK;
+    private setupEventListeners;
+}
+declare function createCoinbaseAdapter(): CoinbaseAdapter;
+
+export { APIClient, type AdapterConfig, type AdapterStatus, BaseWalletAdapter, CURVE_ORDER, ClientKeyManager, CoinbaseAdapter, type CoinbaseConfig, DKGClient, type DKGClientConfig, DKGResult, DKLSClient, type DKLSClientConfig, type DKLSKeyShare, type DKLSKeygenClientState, type DKLSKeygenCommitment, type DKLSKeygenPublicShare, type DKLSKeygenSessionState, type DKLSNonceCommitment, type DKLSSchnorrProof, type DKLSSignRequest, type DKLSSigningClientState, type DKLSSigningResult, type DKLSSigningSessionState, type DecryptedShare, EIP1193Provider, type EncryptedShare, type EncryptionResult, FundingModal, type FundingModalProps, type FundingOptions, type FundingProvider, IndexedDBStorage, type KeyManagerConfig, KeyShare, MemoryStorage, MetaMaskAdapter, type MetaMaskConfig, type NonceCommitment, type NonceDecommitment, type NonceShare, type PartialSignatureData, type PedersenCommitment, ProtocolMessage, ProtocolMessageType, ReceiveModal, type ReceiveModalProps, SecureKeyStorage, SigningClient, type SigningClientConfig, SigningRequest, SigningResult, StorageAdapter, type TokenBalance, type TransactionHistoryItem, type VSSSCommitment, type WalletAdapterConstructor, type WalletAdapterEvents, WalletConnectAdapter, type WalletConnectConfig, WalletInfo, type WalletServicesConfig, type WalletServicesPlugin, WalletServicesPluginImpl, WalletUI, type WalletUIProps, WebSocketClient, aggregateShares, checksumAddress, combineNonceCommitments, combinePartialSignatures, combinePublicKeys, combineVSSSCommitments, computeCommitment, computeCommitments, computeCreate2Address, computeLagrangeCoefficient, computePartialSignature, computeR, createCoinbaseAdapter, createDKLSClient, createMetaMaskAdapter, createNonceCommitment, createPedersenCommitment, createSecureStorage, createSigningClient, createVSSSCommitments, createWalletConnectAdapter, createWalletServicesPlugin, decryptShare, decryptWithKey, decryptWithPassword, deriveDeviceKey, deriveEOAAddress, deriveEthereumAddress, deriveKeyFromDeviceInfo, deriveKeyFromPassword, deriveSmartWalletAddress, deserializeEncryptedShare, encryptShare, encryptWithKey, encryptWithPassword, evaluatePolynomial, formatSignature, generateDeviceKey, generateEphemeralKeyPair, generateNonceShare, generatePolynomial, generateRandomBytes, generateRandomHex, generateSchnorrProof, hashSha256, hexToScalar, isValidAddress, keygenComplete, keygenGenerateReveal, keygenInitClient, keygenProcessBackendCommitment, parseMessageHash, scalarToHex, serializeEncryptedShare, serializeKeyShare, signingInit, signingProcessBackendNonce, verifyNonceCommitment, verifyPartialSignature, verifyPedersenCommitment, verifyProofOfKnowledge, verifyShareAgainstCommitments, verifyVSSSCommitment };