@nerochain/mpc-sdk 0.1.0

package/dist/nero-sdk-IhuTBrXZ.d.ts

@@ -0,0 +1,684 @@
+import { R as RpcConnection, C as ChainConfig } from './chain-manager-C3eHsVt9.js';
+
+interface KeyShare {
+    partyId: number;
+    privateShare: string;
+    publicShare: string;
+    commitment: string;
+    threshold: number;
+    totalParties: number;
+    protocolVersion: string;
+}
+interface EncryptedKeyShare {
+    ciphertext: string;
+    iv: string;
+    salt: string;
+    version: number;
+}
+interface DKGCommitment {
+    partyId: number;
+    commitments: string[];
+    publicKey: string;
+}
+interface DKGShare {
+    fromPartyId: number;
+    toPartyId: number;
+    encryptedShare: string;
+}
+interface DKGResult {
+    success: boolean;
+    publicKey?: string;
+    walletAddress?: string;
+    partyId?: number;
+    error?: string;
+}
+interface SigningRequest {
+    messageHash: string;
+    messageType: "transaction" | "message" | "typed_data";
+    metadata?: Record<string, unknown>;
+}
+interface PartialSignature {
+    partyId: number;
+    r: string;
+    s: string;
+    publicShare: string;
+    nonceCommitment: string;
+}
+interface Signature {
+    r: string;
+    s: string;
+    v: number;
+    fullSignature: string;
+}
+interface SigningResult {
+    success: boolean;
+    signature?: Signature;
+    error?: string;
+}
+type DKGRound = "commitment" | "share_exchange" | "verification" | "complete";
+interface DKGSessionState {
+    sessionId: string;
+    round: DKGRound;
+    partyId: number;
+    participantCount: number;
+    threshold: number;
+    commitments: Map<number, DKGCommitment>;
+    receivedShares: Map<number, DKGShare>;
+    polynomial?: bigint[];
+    privateShare?: bigint;
+    publicKey?: string;
+}
+type SigningRound = "nonce_commitment" | "nonce_exchange" | "partial_signature" | "complete";
+interface SigningSessionState {
+    sessionId: string;
+    round: SigningRound;
+    messageHash: string;
+    participatingParties: number[];
+    nonceCommitments: Map<number, string>;
+    partialSignatures: Map<number, PartialSignature>;
+}
+interface UIConfig {
+    appName: string;
+    logoLight?: string;
+    logoDark?: string;
+    mode?: "light" | "dark" | "auto";
+    theme?: {
+        primary?: string;
+        secondary?: string;
+        background?: string;
+        text?: string;
+        border?: string;
+    };
+    defaultLanguage?: string;
+}
+interface SDKConfig {
+    backendUrl: string;
+    chainId?: number;
+    wsUrl?: string;
+    storagePrefix?: string;
+    autoConnect?: boolean;
+    uiConfig?: UIConfig;
+    sessionTime?: number;
+    web3AuthClientId?: string;
+}
+interface AuthTokens {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
+}
+interface User {
+    id: string;
+    email?: string;
+    displayName?: string;
+    profilePicture?: string;
+    walletAddress?: string;
+    createdAt: Date;
+}
+interface DeviceFingerprint {
+    userAgent: string;
+    ipAddress?: string;
+    additionalData?: string;
+}
+interface WalletInfo {
+    eoaAddress: string;
+    smartWalletAddress?: string;
+    publicKey: string;
+    chainId: number;
+}
+type ProtocolMessageType = "dkg:commitment" | "dkg:share" | "dkg:verification" | "dkg:complete" | "signing:nonce_commitment" | "signing:nonce" | "signing:partial_signature" | "signing:complete" | "error";
+interface ProtocolMessage {
+    type: ProtocolMessageType;
+    sessionId: string;
+    fromPartyId: number;
+    toPartyId?: number;
+    payload: unknown;
+    timestamp: number;
+    signature?: string;
+}
+interface StorageAdapter {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+declare class SDKError extends Error {
+    code: string;
+    statusCode?: number | undefined;
+    constructor(message: string, code: string, statusCode?: number | undefined);
+}
+
+interface RequestArguments {
+    readonly method: string;
+    readonly params?: readonly unknown[] | object;
+}
+interface ProviderRpcError extends Error {
+    code: number;
+    data?: unknown;
+}
+interface ProviderConnectInfo {
+    readonly chainId: string;
+}
+interface EIP1193Provider {
+    request(args: RequestArguments): Promise<unknown>;
+    on(event: "connect", listener: (info: ProviderConnectInfo) => void): this;
+    on(event: "disconnect", listener: (error: ProviderRpcError) => void): this;
+    on(event: "chainChanged", listener: (chainId: string) => void): this;
+    on(event: "accountsChanged", listener: (accounts: string[]) => void): this;
+    on(event: "message", listener: (message: ProviderMessage) => void): this;
+    on(event: string, listener: (...args: unknown[]) => void): this;
+    removeListener(event: string, listener: (...args: unknown[]) => void): this;
+    removeAllListeners(event?: string): this;
+}
+interface ProviderMessage {
+    readonly type: string;
+    readonly data: unknown;
+}
+interface AddEthereumChainParameter {
+    chainId: string;
+    chainName: string;
+    nativeCurrency: {
+        name: string;
+        symbol: string;
+        decimals: number;
+    };
+    rpcUrls: string[];
+    blockExplorerUrls?: string[];
+    iconUrls?: string[];
+}
+interface WatchAssetParams {
+    type: "ERC20" | "ERC721" | "ERC1155";
+    options: {
+        address: string;
+        symbol?: string;
+        decimals?: number;
+        image?: string;
+        tokenId?: string;
+    };
+}
+interface TransactionParams {
+    from: string;
+    to?: string;
+    value?: string;
+    gas?: string;
+    gasPrice?: string;
+    maxFeePerGas?: string;
+    maxPriorityFeePerGas?: string;
+    data?: string;
+    nonce?: string;
+}
+interface TypedDataDomain {
+    name?: string;
+    version?: string;
+    chainId?: number | string;
+    verifyingContract?: string;
+    salt?: string;
+}
+interface TypedDataField {
+    name: string;
+    type: string;
+}
+type TypedDataTypes = Record<string, TypedDataField[]>;
+interface TypedDataMessage {
+    [key: string]: unknown;
+}
+declare const EIP1193_ERROR_CODES: {
+    readonly USER_REJECTED: 4001;
+    readonly UNAUTHORIZED: 4100;
+    readonly UNSUPPORTED_METHOD: 4200;
+    readonly DISCONNECTED: 4900;
+    readonly CHAIN_DISCONNECTED: 4901;
+    readonly INVALID_PARAMS: -32602;
+    readonly INTERNAL_ERROR: -32603;
+    readonly CHAIN_NOT_ADDED: 4902;
+};
+declare function createProviderRpcError(code: number, message: string, data?: unknown): ProviderRpcError;
+
+declare class APIClient {
+    private baseUrl;
+    private tokens;
+    private refreshPromise;
+    constructor(config: SDKConfig);
+    setTokens(tokens: AuthTokens): void;
+    getTokens(): AuthTokens | null;
+    clearTokens(): void;
+    private request;
+    private refreshAccessToken;
+    getOAuthUrl(provider: "google" | "github" | "apple", redirectUri: string): Promise<{
+        url: string;
+        state: string;
+    }>;
+    handleOAuthCallback(provider: string, code: string, state: string, fingerprint: DeviceFingerprint): Promise<{
+        user: User;
+        tokens: AuthTokens;
+        wallet?: WalletInfo;
+        requiresDKG: boolean;
+    }>;
+    getCurrentUser(): Promise<User>;
+    logout(): Promise<void>;
+    initiateDKG(): Promise<{
+        sessionId: string;
+        partyId: number;
+        participantCount: number;
+        threshold: number;
+    }>;
+    submitDKGCommitment(sessionId: string, commitment: {
+        partyId: number;
+        commitments: string[];
+        publicKey: string;
+        proofOfKnowledge: string;
+    }): Promise<void>;
+    getDKGCommitments(sessionId: string): Promise<{
+        commitments: Array<{
+            partyId: number;
+            commitments: string[];
+            publicKey: string;
+            proofOfKnowledge?: string;
+        }>;
+        ready: boolean;
+    }>;
+    submitDKGShare(sessionId: string, encryptedShare: string, toPartyId: number): Promise<void>;
+    getDKGShares(sessionId: string, partyId: number): Promise<{
+        shares: Array<{
+            fromPartyId: number;
+            encryptedShare: string;
+        }>;
+        ready: boolean;
+    }>;
+    completeDKG(sessionId: string, partyId: number, publicKey: string, walletAddress: string): Promise<{
+        success: boolean;
+        wallet: WalletInfo;
+    }>;
+    initiateSigningSession(messageHash: string, messageType: "transaction" | "message" | "typed_data"): Promise<{
+        sessionId: string;
+        participatingParties: number[];
+    }>;
+    submitNonceCommitment(sessionId: string, partyId: number, commitment: string): Promise<void>;
+    getNonceCommitments(sessionId: string): Promise<{
+        commitments: Map<number, string>;
+        ready: boolean;
+    }>;
+    submitPartialSignature(sessionId: string, partyId: number, partialSignature: {
+        r: string;
+        s: string;
+        publicShare: string;
+        nonceCommitment: string;
+    }): Promise<void>;
+    getPartialSignatures(sessionId: string): Promise<{
+        partials: Array<{
+            partyId: number;
+            s: string;
+            publicShare: string;
+            nonceCommitment: string;
+        }>;
+        ready: boolean;
+    }>;
+    getSigningResult(sessionId: string): Promise<{
+        complete: boolean;
+        signature?: {
+            r: string;
+            s: string;
+            v: number;
+            fullSignature: string;
+        };
+    }>;
+    getWalletInfo(): Promise<WalletInfo>;
+    getPartyPublicShares(): Promise<{
+        shares: Array<{
+            partyId: number;
+            publicShare: string;
+        }>;
+    }>;
+    dklsKeygenInit(): Promise<{
+        sessionId: string;
+        backendCommitment: {
+            partyId: number;
+            commitment: string;
+        };
+    }>;
+    dklsKeygenCommitment(sessionId: string, clientCommitment: {
+        partyId: number;
+        commitment: string;
+    }): Promise<{
+        sessionId: string;
+        backendPublicShare: {
+            partyId: number;
+            publicShare: string;
+            proof: {
+                commitment: string;
+                challenge: string;
+                response: string;
+            };
+        };
+    }>;
+    dklsKeygenComplete(sessionId: string, clientPublicShare: {
+        partyId: number;
+        publicShare: string;
+        proof: {
+            commitment: string;
+            challenge: string;
+            response: string;
+        };
+    }): Promise<{
+        sessionId: string;
+        walletAddress: string;
+        jointPublicKey: string;
+        keyId: string;
+    }>;
+    dklsSigningInit(params: {
+        messageHash: string;
+        messageType?: "message" | "transaction" | "typed_data";
+        dkgSessionId: string;
+    }): Promise<{
+        sessionId: string;
+        status: string;
+        backendNonceCommitment: {
+            partyId: number;
+            commitment: string;
+        };
+        walletAddress: string;
+    }>;
+    dklsSigningNonce(sessionId: string, clientNonceCommitment: {
+        partyId: number;
+        R: string;
+        commitment: string;
+    }): Promise<{
+        sessionId: string;
+        r: string;
+        rValue: string;
+        backendNonceReveal: {
+            partyId: number;
+            R: string;
+        };
+        backendPartialSignature: {
+            partyId: number;
+            sigma: string;
+            R: string;
+        };
+    }>;
+    /**
+     * @deprecated This method defeats threshold security by transmitting the full key share.
+     * Use the MtA-based signing flow instead: dklsMtaRound1 -> dklsMtaRound2 -> dklsSigningPartial.
+     * This endpoint is only available in test mode (DKLS_LOCAL_TESTING_MODE=true).
+     */
+    dklsSigningComplete(sessionId: string, clientKeyShare: {
+        partyId: number;
+        secretShare: string;
+        publicShare: string;
+        jointPublicKey: string;
+    }): Promise<{
+        sessionId: string;
+        signature: string;
+        r: string;
+        s: string;
+        v: number;
+        messageHash: string;
+        walletAddress: string | null;
+        securityLevel: string;
+    }>;
+    dklsSigningStatus(sessionId: string): Promise<{
+        sessionId: string;
+        status: string;
+        messageHash: string;
+        messageType: string;
+        result?: {
+            signature: string;
+            r: string;
+            s: string;
+            v: number;
+        };
+        error?: string;
+        createdAt: string;
+        completedAt?: string;
+    }>;
+    dklsSigningCancel(sessionId: string): Promise<{
+        sessionId: string;
+        message: string;
+    }>;
+    dklsMtaRound1(sessionId: string, mta1Setup: {
+        sessionId: string;
+        setup: {
+            setups: Array<{
+                A: string;
+            }>;
+        };
+    }, mta2Setup: {
+        sessionId: string;
+        setup: {
+            setups: Array<{
+                A: string;
+            }>;
+        };
+    }): Promise<{
+        mta1Response: {
+            sessionId: string;
+            response: {
+                responses: Array<{
+                    B: string;
+                }>;
+            };
+        };
+        mta2Response: {
+            sessionId: string;
+            response: {
+                responses: Array<{
+                    B: string;
+                }>;
+            };
+        };
+    }>;
+    dklsMtaRound2(sessionId: string, mta1Encrypted: {
+        sessionId: string;
+        encrypted: {
+            encrypted: Array<{
+                e0: string;
+                e1: string;
+            }>;
+        };
+    }, mta2Encrypted: {
+        sessionId: string;
+        encrypted: {
+            encrypted: Array<{
+                e0: string;
+                e1: string;
+            }>;
+        };
+    }): Promise<{
+        success: true;
+    }>;
+    dklsSigningPartial(sessionId: string, clientPartialSignature: {
+        partyId: number;
+        s: string;
+    }): Promise<{
+        signature: string;
+        r: string;
+        s: string;
+        v: number;
+    }>;
+    initiateDeviceVerification(fingerprint: DeviceFingerprint, deviceName?: string): Promise<{
+        verificationId: string;
+        expiresAt: string;
+    }>;
+    completeDeviceVerification(verificationId: string, code: string, fingerprint: DeviceFingerprint): Promise<{
+        deviceId: string;
+        trustLevel: string;
+    }>;
+}
+
+interface UserOperation {
+    sender: string;
+    nonce: bigint;
+    initCode: string;
+    callData: string;
+    callGasLimit: bigint;
+    verificationGasLimit: bigint;
+    preVerificationGas: bigint;
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+    paymasterAndData: string;
+    signature: string;
+}
+interface TransactionRequest {
+    to: string;
+    value?: bigint;
+    data?: string;
+}
+interface SmartWalletConfig {
+    apiClient: APIClient;
+    keyShare: KeyShare;
+    partyPublicShares: Map<number, string>;
+    publicKey: string;
+    chainId: number;
+    rpcConnection: RpcConnection;
+    bundlerUrl: string;
+    entryPointAddress?: string;
+    factoryAddress?: string;
+    paymasterUrl?: string;
+}
+declare class SmartWallet {
+    private apiClient;
+    private keyShare;
+    private partyPublicShares;
+    private publicKey;
+    private chainId;
+    private rpcConnection;
+    private bundlerUrl;
+    private entryPointAddress;
+    private factoryAddress;
+    private paymasterUrl?;
+    private _eoaAddress;
+    private _smartWalletAddress;
+    private _isDeployed;
+    private _cachedNonce;
+    constructor(config: SmartWalletConfig);
+    get eoaAddress(): string;
+    /**
+     * @deprecated Use getSmartWalletAddress() instead.
+     */
+    get smartWalletAddress(): string;
+    getSmartWalletAddress(): Promise<string>;
+    getWalletInfo(): Promise<WalletInfo>;
+    buildUserOperation(transactions: TransactionRequest | TransactionRequest[]): Promise<UserOperation>;
+    signUserOperation(userOp: UserOperation): Promise<UserOperation>;
+    sendUserOperation(userOp: UserOperation): Promise<{
+        userOpHash: string;
+        wait: () => Promise<void>;
+    }>;
+    private waitForUserOperationReceipt;
+    private userOpToHex;
+    signMessage(message: string | Uint8Array): Promise<Signature>;
+    signTypedData(domain: Record<string, unknown>, types: Record<string, Array<{
+        name: string;
+        type: string;
+    }>>, primaryType: string, value: Record<string, unknown>): Promise<Signature>;
+    private computeUserOpHash;
+    private packUserOp;
+    private encodeExecuteBatch;
+    private getInitCode;
+    private getNonce;
+    private isDeployed;
+    private getFeeData;
+    private getPaymasterData;
+    private hashTypedDataDomain;
+    private hashTypedDataStruct;
+    private encodeType;
+    private formatType;
+    private findTypeDependencies;
+    private hashType;
+    private hashStruct;
+    private encodeField;
+}
+declare function createSmartWallet(config: SmartWalletConfig): SmartWallet;
+
+type OAuthProvider = "google" | "github" | "apple";
+type LoginProvider = OAuthProvider;
+interface NeroSDKState {
+    isAuthenticated: boolean;
+    isInitialized: boolean;
+    hasWallet: boolean;
+    user: User | null;
+    walletInfo: WalletInfo | null;
+    chainId: number;
+    isConnected: boolean;
+}
+type ConnectionStatus = "connected" | "disconnected" | "connecting" | "errored";
+interface UserInfo {
+    email?: string;
+    name?: string;
+    profileImage?: string;
+    verifier?: string;
+    verifierId?: string;
+    aggregateVerifier?: string;
+    typeOfLogin?: string;
+    dappShare?: string;
+    idToken?: string;
+    oAuthIdToken?: string;
+    oAuthAccessToken?: string;
+}
+declare class NeroMpcSDK {
+    private config;
+    private apiClient;
+    private wsClient;
+    private keyManager;
+    private deviceKey;
+    private chainManager;
+    private _user;
+    private _wallet;
+    private _publicKey;
+    private _partyPublicShares;
+    private _provider;
+    private _chainId;
+    private _connectionStatus;
+    private _customChains;
+    private _cachedWalletInfo;
+    constructor(config: SDKConfig);
+    get isAuthenticated(): boolean;
+    get hasWallet(): boolean;
+    get user(): User | null;
+    get wallet(): SmartWallet | null;
+    get chainId(): number;
+    get connected(): boolean;
+    get status(): ConnectionStatus;
+    get provider(): EIP1193Provider | null;
+    get state(): NeroSDKState;
+    getWalletInfo(): Promise<WalletInfo | null>;
+    initialize(): Promise<void>;
+    getOAuthUrl(provider: OAuthProvider, redirectUri: string): Promise<{
+        url: string;
+        state: string;
+    }>;
+    handleOAuthCallback(provider: OAuthProvider, code: string, state: string): Promise<{
+        user: User;
+        requiresDKG: boolean;
+    }>;
+    loginWithGoogle(redirectUri?: string): Promise<void>;
+    loginWithGithub(redirectUri?: string): Promise<void>;
+    loginWithApple(redirectUri?: string): Promise<void>;
+    generateWallet(): Promise<WalletInfo>;
+    logout(): Promise<void>;
+    connect(): Promise<EIP1193Provider>;
+    disconnect(): Promise<void>;
+    getProvider(): EIP1193Provider | null;
+    getUserInfo(): UserInfo | null;
+    switchChain(chainId: number): Promise<void>;
+    addChain(config: ChainConfig): void;
+    getChainConfig(chainId?: number): ChainConfig | undefined;
+    getSupportedChainIds(): number[];
+    private getAccounts;
+    private signMessageInternal;
+    private signTypedDataInternal;
+    private sendTransactionInternal;
+    private handleChainChanged;
+    private getChainConfigForId;
+    private createSmartWallet;
+    exportBackup(password: string): Promise<string>;
+    importBackup(backupString: string, password: string): Promise<void>;
+    private initializeWallet;
+    private getDeviceFingerprint;
+    private loadOrGenerateDeviceKey;
+    private storeTokens;
+    private loadStoredTokens;
+    private clearStoredTokens;
+}
+declare function createNeroSDK(config: SDKConfig): NeroMpcSDK;
+
+export { APIClient as A, type TypedDataField as B, type ConnectionStatus as C, type DKGResult as D, type EIP1193Provider as E, type TypedDataMessage as F, type TypedDataTypes as G, type UIConfig as H, type UserInfo as I, type WatchAssetParams as J, type KeyShare as K, type LoginProvider as L, createNeroSDK as M, NeroMpcSDK as N, type OAuthProvider as O, type ProtocolMessage as P, createProviderRpcError as Q, type RequestArguments as R, type SDKConfig as S, type TransactionParams as T, type User as U, createSmartWallet as V, type WalletInfo as W, type UserOperation as X, type NeroSDKState as a, type Signature as b, type StorageAdapter as c, type ProtocolMessageType as d, type SigningRequest as e, type SigningResult as f, type AddEthereumChainParameter as g, type AuthTokens as h, type DKGCommitment as i, type DKGRound as j, type DKGSessionState as k, type DKGShare as l, type DeviceFingerprint as m, EIP1193_ERROR_CODES as n, type EncryptedKeyShare as o, type PartialSignature as p, type ProviderConnectInfo as q, type ProviderMessage as r, type ProviderRpcError as s, SDKError as t, type SigningRound as u, type SigningSessionState as v, SmartWallet as w, type SmartWalletConfig as x, type TransactionRequest as y, type TypedDataDomain as z };