@human.tech/waap-sdk 1.2.4 → 2.0.0

package/dist/index.d.mts

@@ -0,0 +1,967 @@
+import { CredentialType, RequestPermissionTokenParams, ProjectConfig, CustomConfig, AuthenticationMethod, RequestPermissionTokenResult, SilkNotificationData, SILK_METHOD, SilkResponse, SilkRequest, AsyncTxConfirmedEvent, AsyncTxFailedEvent, AsyncSignCompleteEvent, AsyncTxPendingEvent } from '@human.tech/waap-interface-core';
+export { Async2faRequiredEvent, AsyncEvent, AsyncEventType, AsyncSignCompleteEvent, AsyncSignFailedEvent, AsyncSignPendingEvent, AsyncTxConfirmedEvent, AsyncTxFailedEvent, AsyncTxPendingEvent, AsyncTxResponse, AuthenticationMethod, CredentialType, ProjectConfig, RequestPermissionTokenParams, RequestPermissionTokenResult, SILK_METHOD, SilkOptions, SocialProvider, StylesConfig, SILK_METHOD as WAAP_METHOD } from '@human.tech/waap-interface-core';
+import { EventEmitter } from 'events';
+export { rpcMethodRequiresUI } from '@human.tech/waap-constants';
+
+interface RequestArguments {
+    method: string;
+    params?: unknown[] | object;
+    async?: boolean;
+    withPT?: boolean;
+}
+interface EthereumProviderInterface {
+    enable(): Promise<unknown>;
+    isConnected(): boolean;
+    request(args: RequestArguments): Promise<unknown>;
+    on(event: string, listener: (...args: any[]) => void): this;
+    removeListener(event: string, listener: (...args: any[]) => void): this;
+}
+type LoginResponse = 'waap' | 'human' | 'injected' | 'walletconnect' | null;
+interface SilkEthereumProviderInterface extends EthereumProviderInterface {
+    isSilk: boolean;
+    connected: boolean;
+    login(customProvider?: any): Promise<LoginResponse>;
+    logout(): Promise<unknown>;
+    getLoginMethod(): LoginResponse;
+    requestEmail(): Promise<unknown>;
+    requestSBT(type: CredentialType): Promise<unknown>;
+    requestPermissionToken(params: RequestPermissionTokenParams): Promise<unknown>;
+    toggleDarkMode(): Promise<void>;
+}
+interface InitSilkOptions {
+    referralCode?: string;
+    project?: ProjectConfig;
+    config?: CustomConfig;
+    useStaging?: boolean;
+    walletConnectProjectId?: string;
+    /**
+     * When true, eth_sendTransaction resolves with the pre-calculated tx hash
+     * immediately after signing. Broadcasting and confirmation continue in the
+     * background with events (waap_sign_complete, waap_tx_pending, waap_tx_confirmed, waap_tx_failed).
+     * Other signing methods (personal_sign, eth_signTypedData_v4, eth_signTransaction)
+     * are unaffected — they always resolve with the signature directly.
+     * Applies to ALL eth_sendTransaction calls for this SDK instance.
+     * Default: false
+     */
+    asyncTxs?: boolean;
+    /** @deprecated Use `asyncTxs` instead. */
+    asyncSigning?: boolean;
+}
+type SilkProvider = SilkEthereumProviderInterface;
+
+/**
+ * @param referralCode - WaaP points referral code
+ * @param customConfig - WaaP custom UI configuration
+ * @param project - WaaP project configuration
+ * @param useStaging - Whether to use the staging environment
+ * @param walletConnectProjectId - WalletConnect project ID (only required when passing `wallet` to `authenticationMethods`)
+ * @param walletConnectOptionalChains - Optional chains to use for WalletConnect
+ */
+declare const initWaaP: (params?: InitSilkOptions) => SilkEthereumProviderInterface;
+
+/**
+ * WaaP Component
+ *
+ * A custom HTML element that allows developers to control where the WaaP wallet
+ * renders in their UI. When present, the wallet will render inside this component
+ * instead of as a centered modal with backdrop.
+ *
+ * Usage in HTML:
+ * ```html
+ * <waap-wallet></waap-wallet>
+ * ```
+ *
+ * Usage in React/JSX:
+ * ```tsx
+ * function App() {
+ *   return <waap-wallet style={{ width: '400px', height: '600px' }} />
+ * }
+ * ```
+ */
+/**
+ * Custom HTML element for WaaP wallet
+ * Only defined in browser environments to avoid SSR issues
+ */
+declare let WaapWalletElement: any;
+
+/**
+ * A Ethereum provder API (from EIP 1193) for Silk.
+ * https://eips.ethereum.org/EIPS/eip-1193
+ */
+/**
+ * Resources:
+ * - EIP-2255: Wallet Permissions System: https://eips.ethereum.org/EIPS/eip-2255
+ */
+
+declare class EthereumProviderExtension extends EventEmitter implements EthereumProviderInterface {
+    readonly isSilk = true;
+    connected: boolean;
+    config: CustomConfig;
+    constructor(customConfig?: CustomConfig);
+    sendToExtension(args: RequestArguments): Promise<unknown>;
+    request(args: RequestArguments): Promise<unknown>;
+    enable(): Promise<unknown>;
+    isConnected(): boolean;
+    login(): Promise<unknown>;
+    requestSBT(type: CredentialType): Promise<unknown>;
+    toggleDarkMode(): Promise<void>;
+    safe(): Promise<unknown>;
+}
+
+declare class SilkWalletConnect {
+    private static instance;
+    private static projectId;
+    private static chains;
+    /**
+     * Set the WalletConnect project ID programmatically
+     * Use this if environment variables aren't working in your setup
+     *
+     * @param id - The WalletConnect project ID to use
+     */
+    static setProjectId(id: string): void;
+    static getProjectIdFromEnv(): string | undefined;
+    static getInstance(): Promise<any>;
+    static listenToAccountChangeEvent(): Promise<void>;
+    /**
+     * Wait for WalletConnect to be properly initialized and connected
+     * @returns Promise<boolean> - true if connected, false if timeout reached
+     */
+    static waitForReadyAndCheckConnection(): Promise<boolean>;
+    /**
+     * Check if WalletConnect is currently connected (immediate check, no waiting)
+     * @returns boolean - true if connected, false otherwise
+     */
+    static isConnected(): boolean;
+    /**
+     * Get the wallet provider from the WalletConnect instance
+     * @returns The wallet provider or null if not available
+     */
+    static getWalletProvider(): any;
+}
+
+/**
+ * Type definitions for Sui Wallet Standard integration.
+ *
+ * @see https://docs.sui.io/standards/wallet-standard
+ */
+/**
+ * Sui chain identifiers.
+ */
+type SuiChain = 'sui:mainnet' | 'sui:testnet' | 'sui:devnet' | 'sui:localnet';
+/**
+ * Sui account representation following Wallet Standard.
+ */
+interface SuiAccount {
+    /** Sui address (32 bytes, 0x-prefixed hex string) */
+    readonly address: string;
+    /** Compressed public key bytes (33 bytes for Secp256k1) */
+    readonly publicKey: Uint8Array;
+    /** Supported chains for this account */
+    readonly chains: readonly SuiChain[];
+    /** Supported features for this account */
+    readonly features: readonly string[];
+    /** Optional display label */
+    readonly label?: string;
+}
+/**
+ * Input for sui:signPersonalMessage feature.
+ */
+interface SuiSignPersonalMessageInput {
+    /** Message bytes to sign */
+    message: Uint8Array;
+    /** Account to sign with */
+    account: SuiAccount;
+    /** Optional chain identifier */
+    chain?: SuiChain;
+}
+/**
+ * Output from sui:signPersonalMessage feature.
+ */
+interface SuiSignPersonalMessageOutput {
+    /** Base64-encoded message bytes */
+    bytes: string;
+    /** Base64-encoded signature (98 bytes for Secp256k1) */
+    signature: string;
+}
+/**
+ * Input for sui:signTransaction feature.
+ */
+interface SuiSignTransactionInput {
+    /** BCS-serialized transaction bytes */
+    transaction: Uint8Array;
+    /** Account to sign with */
+    account: SuiAccount;
+    /** Optional chain identifier */
+    chain?: SuiChain;
+}
+/**
+ * Output from sui:signTransaction feature.
+ */
+interface SuiSignTransactionOutput {
+    /** Base64-encoded transaction bytes */
+    bytes: string;
+    /** Base64-encoded signature */
+    signature: string;
+}
+/**
+ * Input for sui:signAndExecuteTransaction feature.
+ */
+interface SuiSignAndExecuteTransactionInput {
+    /** BCS-serialized transaction bytes */
+    transaction: Uint8Array;
+    /** Account to sign with */
+    account: SuiAccount;
+    /** Optional chain identifier */
+    chain?: SuiChain;
+    /** Options for execution */
+    options?: unknown;
+    /** Request type */
+    requestType?: 'WaitForEffectsCert' | 'WaitForLocalExecution';
+}
+/**
+ * Output from sui:signAndExecuteTransaction feature.
+ */
+interface SuiSignAndExecuteTransactionOutput {
+    digest: string;
+    effects?: unknown;
+    errors?: unknown[];
+    [key: string]: unknown;
+}
+/**
+ * Connect input options.
+ */
+interface SuiConnectInput {
+    /** If true, attempt silent connection without UI prompt */
+    silent?: boolean;
+}
+/**
+ * Connect output with accounts.
+ */
+interface SuiConnectOutput {
+    /** Connected accounts */
+    accounts: readonly SuiAccount[];
+}
+/**
+ * Input for legacy sui:signTransactionBlock feature.
+ */
+interface SuiSignTransactionBlockInput {
+    /** BCS-serialized transaction block bytes */
+    transactionBlock: Uint8Array;
+    /** Account to sign with */
+    account: SuiAccount;
+    /** Optional chain identifier */
+    chain?: SuiChain;
+}
+/**
+ * Output for legacy sui:signTransactionBlock feature.
+ */
+interface SuiSignTransactionBlockOutput extends SuiSignTransactionOutput {
+}
+/**
+ * Input for legacy sui:signAndExecuteTransactionBlock feature.
+ */
+interface SuiSignAndExecuteTransactionBlockInput {
+    /** BCS-serialized transaction block bytes */
+    transactionBlock: Uint8Array;
+    /** Account to sign with */
+    account: SuiAccount;
+    /** Optional chain identifier */
+    chain?: SuiChain;
+    /** Options for execution */
+    options?: unknown;
+    /** Request type */
+    requestType?: 'WaitForEffectsCert' | 'WaitForLocalExecution';
+}
+/**
+ * Output for legacy sui:signAndExecuteTransactionBlock feature.
+ */
+interface SuiSignAndExecuteTransactionBlockOutput extends SuiSignAndExecuteTransactionOutput {
+}
+/**
+ * Wallet change event properties.
+ */
+interface SuiWalletChangeProperties {
+    chains?: readonly SuiChain[];
+    accounts?: readonly SuiAccount[];
+    features?: Record<string, unknown>;
+}
+/**
+ * Event listener types.
+ */
+type SuiWalletEventListener = (properties: SuiWalletChangeProperties) => void;
+/**
+ * Wallet icon type (data URL).
+ */
+type WalletIcon = `data:image/${'svg+xml' | 'webp' | 'png' | 'gif'};base64,${string}`;
+/**
+ * Wallet Standard features object.
+ */
+interface WaaPSuiWalletFeatures {
+    'standard:connect': {
+        version: '1.0.0';
+        connect: (input?: SuiConnectInput) => Promise<SuiConnectOutput>;
+    };
+    'standard:disconnect': {
+        version: '1.0.0';
+        disconnect: () => Promise<void>;
+    };
+    'standard:events': {
+        version: '1.0.0';
+        on: (event: 'change', listener: SuiWalletEventListener) => () => void;
+    };
+    'sui:signPersonalMessage': {
+        version: '1.1.0';
+        signPersonalMessage: (input: SuiSignPersonalMessageInput) => Promise<SuiSignPersonalMessageOutput>;
+    };
+    'sui:signTransaction': {
+        version: '2.0.0';
+        signTransaction: (input: SuiSignTransactionInput) => Promise<SuiSignTransactionOutput>;
+    };
+    'sui:switchChain': {
+        version: '1.0.0';
+        switchChain: (input: {
+            chain: SuiChain;
+        }) => Promise<void>;
+    };
+    'sui:signAndExecuteTransaction': {
+        version: '1.0.0';
+        signAndExecuteTransaction: (input: SuiSignAndExecuteTransactionInput) => Promise<SuiSignAndExecuteTransactionOutput>;
+    };
+    'sui:signTransactionBlock': {
+        version: '2.0.0';
+        signTransactionBlock: (input: SuiSignTransactionBlockInput) => Promise<SuiSignTransactionBlockOutput>;
+    };
+    'sui:signAndExecuteTransactionBlock': {
+        version: '1.0.0';
+        signAndExecuteTransactionBlock: (input: SuiSignAndExecuteTransactionBlockInput) => Promise<SuiSignAndExecuteTransactionBlockOutput>;
+    };
+}
+/**
+ * WaaP Sui Wallet interface.
+ */
+interface WaaPSuiWalletInterface {
+    /** Wallet name */
+    readonly name: string;
+    /** Wallet version */
+    readonly version: string;
+    /** Wallet icon */
+    readonly icon: WalletIcon;
+    /** Supported chains */
+    readonly chains: readonly SuiChain[];
+    /** Connected accounts */
+    readonly accounts: readonly SuiAccount[];
+    /** Wallet Standard features */
+    readonly features: WaaPSuiWalletFeatures;
+    /**
+     * Connect to the wallet.
+     */
+    connect(input?: SuiConnectInput): Promise<SuiConnectOutput>;
+    /**
+     * Disconnect from the wallet.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Switch the active chain.
+     */
+    switchChain(input: {
+        chain: SuiChain;
+    }): Promise<void>;
+    /**
+     * Sign a personal message.
+     */
+    signPersonalMessage(input: SuiSignPersonalMessageInput): Promise<SuiSignPersonalMessageOutput>;
+    /**
+     * Sign and execute a transaction.
+     */
+    signAndExecuteTransaction(input: SuiSignAndExecuteTransactionInput): Promise<SuiSignAndExecuteTransactionOutput>;
+    /**
+     * Sign a transaction block (Legacy).
+     */
+    signTransactionBlock(input: SuiSignTransactionBlockInput): Promise<SuiSignTransactionBlockOutput>;
+    /**
+     * Sign and execute a transaction block (Legacy).
+     */
+    signAndExecuteTransactionBlock(input: SuiSignAndExecuteTransactionBlockInput): Promise<SuiSignAndExecuteTransactionBlockOutput>;
+    /**
+     * Subscribe to wallet events.
+     * @returns Unsubscribe function
+     */
+    on(event: 'change', listener: SuiWalletEventListener): () => void;
+    /** custom WaaP features */
+    /**
+     * Request the user's email address.
+     * @returns Promise resolving to the user's email address
+     */
+    requestEmail(): Promise<string>;
+    /**
+     * Request a Permission Token from the user.
+     * Allows pre-authorised batches of Sui transactions without individual confirmations.
+     *
+     * @param params - Allowed addresses, chainId (e.g. "sui:mainnet"), spend limit, expiry
+     * @returns Promise resolving to a RequestPermissionTokenResult
+     */
+    requestPermissionToken(params: RequestPermissionTokenParams): Promise<RequestPermissionTokenResult>;
+}
+
+/**
+ * Sui-supported authentication methods (no 'wallet/walletconnect' support yet)
+ * Also it is not necessary as @mysten/dapp-kit handles wallet choices
+ * todo: maybe add a modal to list out Sui wallets discovered as per Wallet Standard
+ */
+type SuiAuthenticationMethod = Exclude<AuthenticationMethod, 'wallet'>;
+/**
+ * Sui-specific custom configuration
+ */
+interface SuiCustomConfig extends Omit<CustomConfig, 'authenticationMethods'> {
+    authenticationMethods?: SuiAuthenticationMethod[];
+}
+/**
+ * Initialization options for WaaP Sui Wallet.
+ */
+interface InitWaaPSuiOptions {
+    /** Use staging environment */
+    useStaging?: boolean;
+    /** WaaP points referral code */
+    referralCode?: string;
+    /** WaaP project configuration */
+    project?: ProjectConfig;
+    /** WaaP custom UI configuration */
+    config?: SuiCustomConfig;
+}
+
+/**
+ * UIMessageManager emits events whose intended recipient is the UI
+ * of the silk-wallet-sdk. It is used by EthereumProvider to
+ * communicate with the UI.
+ *
+ * Note that the UI part of silk-wallet-sdk is not the Silk
+ * website but rather the actual iframe tag that gets embedded
+ * in the host site.
+ */
+
+declare enum UI_EVENT_NAMES {
+    show_modal = "show_modal",
+    hide_modal = "hide_modal"
+}
+declare class UIMessageManager extends EventEmitter {
+    constructor();
+}
+
+/**
+ * WaaP Sui Wallet implementation.
+ *
+ * Implements the Sui Wallet Standard to allow dApps to:
+ * - Connect/disconnect
+ * - Sign personal messages
+ * - (Future) Sign and execute transactions
+ */
+declare class WaaPSuiWallet implements WaaPSuiWalletInterface {
+    readonly name = "WaaP";
+    readonly version = "1.0.0";
+    readonly icon: WalletIcon;
+    private _accounts;
+    private _chains;
+    private walletMessageManager;
+    private uiMessageManager;
+    private internalEventEmitter;
+    private changeListeners;
+    /**
+     * Creates a new WaaPSuiWallet instance.
+     *
+     * @param iframeWindow - The contentWindow of the WaaP iframe
+     * @param options - Initialization options
+     */
+    constructor(iframeWindow: Window, options?: InitWaaPSuiOptions);
+    /**
+     * Refresh accounts by making a silent connect request.
+     * Used internally when account changes are detected.
+     */
+    private refreshAccounts;
+    /**
+     * Supported chains.
+     */
+    get chains(): readonly SuiChain[];
+    /**
+     * Connected accounts.
+     */
+    get accounts(): readonly SuiAccount[];
+    /**
+     * UI message manager for showing/hiding modal.
+     */
+    get ui(): UIMessageManager;
+    /**
+     * Connect to the wallet.
+     */
+    connect(input?: SuiConnectInput): Promise<SuiConnectOutput>;
+    /**
+     * Disconnect from the wallet.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Sign a personal message.
+     *
+     * @param input - Sign personal message input
+     * @returns Signed message result with bytes and signature
+     */
+    signPersonalMessage(input: SuiSignPersonalMessageInput): Promise<SuiSignPersonalMessageOutput>;
+    /**
+     * Extract the destination addresses from BCS-serialized Sui transaction bytes.
+     *
+     * Unlike EVM transactions where `to` is a top-level field, Sui transaction
+     * destinations are embedded in BCS-encoded programmable transaction blocks.
+     * We deserialize with Transaction.from() and inspect TransferObjects commands.
+     *
+     * Only TransferObjects destinations are extracted — MoveCall package addresses
+     * are not user-facing recipients and should not be validated against a PT's
+     * allowedAddresses list.
+     *
+     * Returns an empty array if no TransferObjects are found or deserialization fails.
+     */
+    private extractTransferAddresses;
+    /**
+     * Helper to resolve transaction bytes from various input formats.
+     * If the input is a Transaction/TransactionBlock object, it builds it.
+     */
+    private resolveTransactionBytes;
+    /**
+     * Sign a transaction.
+     *
+     * @param input - Sign transaction input with transaction
+     * @returns Signed transaction result with bytes and signature
+     */
+    signTransaction(input: {
+        transaction: unknown;
+        account: SuiAccount;
+        chain?: SuiChain;
+    }): Promise<{
+        bytes: string;
+        signature: string;
+    }>;
+    /**
+     * Sign and execute a transaction.
+     *
+     * @param input - Sign and execute transaction input
+     */
+    signAndExecuteTransaction(input: SuiSignAndExecuteTransactionInput): Promise<SuiSignAndExecuteTransactionOutput>;
+    /**
+     * Switch the active chain.
+     */
+    switchChain(input: {
+        chain: SuiChain;
+    }): Promise<void>;
+    /**
+     * Subscribe to wallet change events.
+     *
+     * @param event - Event name (currently only 'change')
+     * @param listener - Event listener callback
+     * @returns Unsubscribe function
+     */
+    on(event: 'change', listener: SuiWalletEventListener): () => void;
+    /**
+     * Wallet Standard features property.
+     * Required by @mysten/wallet-standard registerWallet.
+     */
+    get features(): {
+        readonly 'standard:connect': {
+            readonly version: "1.0.0";
+            readonly connect: (input?: SuiConnectInput) => Promise<SuiConnectOutput>;
+        };
+        readonly 'standard:disconnect': {
+            readonly version: "1.0.0";
+            readonly disconnect: () => Promise<void>;
+        };
+        readonly 'standard:events': {
+            readonly version: "1.0.0";
+            readonly on: (event: "change", listener: SuiWalletEventListener) => () => void;
+        };
+        readonly 'sui:signPersonalMessage': {
+            readonly version: "1.1.0";
+            readonly signPersonalMessage: (input: SuiSignPersonalMessageInput) => Promise<SuiSignPersonalMessageOutput>;
+        };
+        readonly 'sui:signTransaction': {
+            readonly version: "2.0.0";
+            readonly signTransaction: (input: {
+                transaction: unknown;
+                account: SuiAccount;
+                chain?: SuiChain;
+            }) => Promise<{
+                bytes: string;
+                signature: string;
+            }>;
+        };
+        readonly 'sui:signAndExecuteTransaction': {
+            readonly version: "1.0.0";
+            readonly signAndExecuteTransaction: (input: SuiSignAndExecuteTransactionInput) => Promise<SuiSignAndExecuteTransactionOutput>;
+        };
+        readonly 'sui:signTransactionBlock': {
+            readonly version: "2.0.0";
+            readonly signTransactionBlock: (input: SuiSignTransactionBlockInput) => Promise<SuiSignTransactionBlockOutput>;
+        };
+        readonly 'sui:signAndExecuteTransactionBlock': {
+            readonly version: "1.0.0";
+            readonly signAndExecuteTransactionBlock: (input: SuiSignAndExecuteTransactionBlockInput) => Promise<SuiSignAndExecuteTransactionBlockOutput>;
+        };
+        readonly 'sui:switchChain': {
+            readonly version: "1.0.0";
+            readonly switchChain: (input: {
+                chain: SuiChain;
+            }) => Promise<void>;
+        };
+    };
+    /**
+     * Legacy method for signing a transaction block.
+     * Maps to signTransaction.
+     */
+    signTransactionBlock(input: SuiSignTransactionBlockInput): Promise<SuiSignTransactionBlockOutput>;
+    /**
+     * Legacy method for signing and executing a transaction block.
+     * Maps to signAndExecuteTransaction.
+     */
+    signAndExecuteTransactionBlock(input: SuiSignAndExecuteTransactionBlockInput): Promise<SuiSignAndExecuteTransactionBlockOutput>;
+    /**
+     * Request a Permission Token from the user.
+     * Allows pre-authorised batches of Sui transactions without individual confirmations.
+     *
+     * @param params - Allowed addresses, chainId (e.g. "sui:mainnet"), spend limit, expiry
+     */
+    requestPermissionToken(params: RequestPermissionTokenParams): Promise<RequestPermissionTokenResult>;
+    /**
+     * Request the user's email address.
+     *
+     * @returns Promise resolving to the user's email address
+     */
+    requestEmail(): Promise<string>;
+    /**
+     * Post a request to the iframe and wait for response.
+     */
+    private postRequestAndWait;
+    /**
+     * Notify all change listeners.
+     */
+    private notifyChange;
+}
+
+/**
+ * Initialization function for WaaP Sui Wallet.
+ */
+
+/**
+ * Initialize WaaP Sui Wallet.
+ *
+ * This creates the WaaP iframe (if needed) and returns a SuiWallet instance
+ * that implements the Sui Wallet Standard.
+ *
+ * @param options - Initialization options
+ * @returns WaaPSuiWallet instance
+ *
+ * @example
+ * ```typescript
+ * import { initWaaPSui } from '@silk-wallet/silk-wallet-sdk'
+ *
+ * const suiWallet = initWaaPSui()
+ *
+ * // Connect to get accounts
+ * const { accounts } = await suiWallet.connect()
+ *
+ * // Sign a message
+ * const result = await suiWallet.signPersonalMessage({
+ *   message: new TextEncoder().encode('Hello, Sui!'),
+ *   account: accounts[0]
+ * })
+ * ```
+ */
+declare function initWaaPSui(options?: InitWaaPSuiOptions): WaaPSuiWalletInterface;
+
+/**
+ * WaaP Sui Wallet Registration
+ *
+ * Registers the WaaP Sui wallet with the Wallet Standard registry,
+ * making it discoverable by dApps using @mysten/dapp-kit.
+ *
+ * @see https://docs.sui.io/standards/wallet-standard
+ */
+
+/**
+ * Register WaaP Sui Wallet with the Wallet Standard.
+ *
+ * This makes the wallet discoverable by dApps using @mysten/dapp-kit.
+ * The wallet will appear in the wallet selection UI of any dApp
+ * that uses the Sui Wallet Standard.
+ *
+ * @param iframeWindow - The contentWindow of the WaaP iframe
+ * @param options - Initialization options
+ * @returns The registered WaaPSuiWallet instance
+ *
+ * @example
+ * ```typescript
+ * import { registerWaaPSuiWallet } from '@silk-wallet/silk-wallet-sdk'
+ *
+ * // Get the iframe element
+ * const iframe = document.getElementById('waap-wallet-iframe') as HTMLIFrameElement
+ *
+ * // Register the wallet (makes it discoverable by dApps)
+ * const wallet = registerWaaPSuiWallet(iframe.contentWindow!, { useStaging: false })
+ *
+ * // The wallet is now available in dapp-kit's wallet list
+ * ```
+ */
+declare function registerWaaPSuiWallet(iframeWindow: Window, options?: InitWaaPSuiOptions): WaaPSuiWalletInterface;
+
+/**
+ * WalletMessageManager handles messages between the wallet (in the Silk iframe)
+ * and the wallet SDK (in the top frame). It is used by EthereumProvider
+ * to communicate with the wallet.
+ */
+
+type PostSilkRequestArgs = {
+    method: keyof typeof SILK_METHOD;
+    params: any[];
+    interactionRequired: boolean;
+    silkOptions?: {
+        async?: boolean;
+    };
+};
+/**
+ * Async transaction notification from iframe
+ */
+interface AsyncTxNotification {
+    type: string;
+    payload: any;
+}
+/**
+ * Listener interface for WalletMessageManager
+ */
+interface MessageListenerConfig {
+    handleResponse: (response: SilkResponse) => void;
+    handleRequest: (request: SilkRequest) => void;
+    onReceiveConnectNotif?: () => void;
+    onAccountChanged?: (newAccount: string) => void;
+    onAsyncTxNotification?: (notification: AsyncTxNotification) => void;
+}
+declare class WalletMessageManager {
+    private iframeWindow;
+    private walletOrigin;
+    constructor(iframeWindow: Window, useStaging: boolean);
+    /**
+     * Post a Silk notification to the given iframeWindow
+     */
+    postSilkNotification(data: SilkNotificationData): void;
+    postReadyNotification(): void;
+    postConnectNotification(): void;
+    /**
+     * Post a 'ready' notification to the iframe, and wait
+     * for the iframe to respond with a 'ready' notification.
+     */
+    pingIframe(): Promise<void>;
+    /**
+     * Post a SilkRequest to the iframeWindow. Don't wait for a response.
+     */
+    postSilkRequest(req: PostSilkRequestArgs): Promise<string>;
+    /**
+     * Add a message listener to the window in which this is called (which should be the top frame).
+     * It handles all messages from the Silk iframe posted to the top frame.
+     * @param config - Configuration that includes callbacks for handling specific messages.
+     */
+    addListener(config: MessageListenerConfig): void;
+}
+
+/**
+ * A Ethereum provder API (from EIP 1193) for Silk.
+ * https://eips.ethereum.org/EIPS/eip-1193
+ */
+/**
+ * Resources:
+ * - EIP-2255: Wallet Permissions System: https://eips.ethereum.org/EIPS/eip-2255
+ */
+
+declare class EthereumProvider extends EventEmitter implements SilkEthereumProviderInterface {
+    readonly isSilk = true;
+    readonly isWaaP = true;
+    connected: boolean;
+    walletMessageManager: WalletMessageManager;
+    uiMessageManager: UIMessageManager;
+    config: CustomConfig;
+    private currentAccount;
+    private walletConnectProvider;
+    /**
+     * When true, eth_sendTransaction resolves with the pre-calculated tx hash
+     * after signing. Broadcasting continues in the background with events.
+     */
+    private asyncTxs;
+    /**
+     * When true, sends `asyncSigning: true` in silkOptions instead of `async: true`.
+     * This mimics the v1 SDK protocol for backward compatibility testing.
+     * @internal
+     */
+    private legacyAsyncSigning;
+    private persistedMethods;
+    /**
+     * We use the internalEventEmitter to emit as events
+     * Silk messages posted to the window.
+     */
+    internalEventEmitter: EventEmitter;
+    /**
+     * @param iframeWindow - The contentWindow of the iframe of the Silk website.
+     * @param referralCode - Silk points referral code
+     * @param customConfig - Silk custom UI configuration
+     * @param project - Silk project configuration
+     * @param useStaging - Whether to use the staging environment
+     * @param asyncTxs - When true, eth_sendTransaction resolves with tx hash after signing
+     * @param legacyAsyncSigning - When true, sends asyncSigning in silkOptions (v1 compat)
+     */
+    constructor(iframeWindow: Window, referralCode?: string, customConfig?: CustomConfig, project?: ProjectConfig, useStaging?: boolean, asyncTxs?: boolean, legacyAsyncSigning?: boolean);
+    private initializeWalletConnect;
+    enable(): Promise<unknown>;
+    isConnected(): boolean;
+    request(args: RequestArguments): Promise<unknown>;
+    login(customProvider?: EthereumProviderInterface): Promise<LoginResponse>;
+    logout(): Promise<unknown>;
+    private cleanupInvalidLoginState;
+    /**
+     * Helper method to set up window.waap for WaaP
+     */
+    private setupWaaP;
+    /**
+     * Helper method to set up window.silk for injected wallets (e.g., MetaMask)
+     */
+    private setupInjectedWallet;
+    /**
+     * Helper method to set up window.silk for WalletConnect
+     */
+    private setupWalletConnect;
+    /**
+     * Helper method to set up window.silk for auto-connect with injected wallets
+     */
+    private setupAutoConnectInjected;
+    /**
+     * Helper method to set up window.silk for auto-connect with WalletConnect
+     */
+    private setupAutoConnectWalletConnect;
+    /**
+     * Attempts to auto-connect using previously stored login method
+     * @param method - The RPC method being called
+     * @returns Promise<unknown> if auto-connect succeeds, null if it should fall through to normal flow
+     */
+    private attemptAutoConnect;
+    getLoginMethod(): LoginResponse;
+    toggleDarkMode(): Promise<void>;
+    safe(): Promise<void>;
+    orcid(): Promise<void>;
+    /**
+     * INTERNAL METHOD: Gas tank administration operations
+     * This method is ONLY accessible from the Dev Portal domain
+     * It's not included in the public typing to hide it from regular dApps
+     */
+    portal(feature: 'gastank' | 'customization' | 'project', operation: 'get' | 'update' | 'topup' | 'init', payload?: any): Promise<unknown>;
+    requestEmail(): Promise<unknown>;
+    /**
+     * Request a Permission Token from the user.
+     * Allows pre-authorized transactions without individual confirmations.
+     * @param params - Permission token parameters (allowed addresses, chain, limits, expiry)
+     * @returns Promise<RequestPermissionTokenResult>
+     */
+    requestPermissionToken(params: RequestPermissionTokenParams): Promise<unknown>;
+    /**
+     * Prompt the user to mint a Zeronym SBT.
+     * @returns string or null - The address of the owner of the SBT, or null
+     * if the user already minted the SBT.
+     */
+    requestSBT(type: CredentialType): Promise<unknown>;
+}
+
+/**
+ * Options passed to iframe for transaction behavior
+ */
+interface SilkOptions {
+    async?: boolean;
+    withPT?: boolean;
+}
+/**
+ * Send request to wallet in iframe, and upon receiving the wallet's response
+ * or error, hide modal and return wallet's response or throw wallet's error.
+ */
+declare function handleWalletRequestAndResponse(args: RequestArguments, interactionRequired: boolean, walletMessageManager: WalletMessageManager, internalProviderEventEmitter: EventEmitter, silkOptions?: SilkOptions): Promise<unknown>;
+
+/**
+ * Transaction state tracked by the hook.
+ * Keyed by txHash (pre-calculated from keccak256(serializedSignedTx)).
+ */
+interface TxState {
+    status: 'signed' | 'tx_pending' | 'confirmed' | 'failed';
+    txHash: string;
+    /** @deprecated Use `txHash` instead. */
+    pendingTxId?: string;
+    signature?: string;
+    serializedTx?: string;
+    receipt?: AsyncTxConfirmedEvent['receipt'];
+    error?: string;
+    stage?: AsyncTxFailedEvent['stage'];
+}
+/**
+ * Options for useWaapTransaction hook
+ */
+interface UseWaapTransactionOptions {
+    onSigned?: (event: AsyncSignCompleteEvent) => void;
+    onTxPending?: (event: AsyncTxPendingEvent) => void;
+    onConfirmed?: (event: AsyncTxConfirmedEvent) => void;
+    onFailed?: (event: AsyncTxFailedEvent) => void;
+    /** @deprecated No longer emitted in v2. */
+    onPending?: (event: any) => void;
+    /** @deprecated No longer emitted in v2. */
+    on2faRequired?: (event: any) => void;
+    /** @deprecated Use `onFailed` instead. */
+    onSignFailed?: (event: any) => void;
+}
+/**
+ * Return type for useWaapTransaction hook
+ */
+interface UseWaapTransactionReturn {
+    /**
+     * Send a transaction using eth_sendTransaction.
+     * When asyncTxs is enabled, resolves with the pre-calculated txHash
+     * after signing. Broadcasting continues in the background with events.
+     */
+    sendTransaction: (txRequest: RequestArguments['params']) => Promise<string>;
+    /**
+     * Sign a transaction without broadcasting using eth_signTransaction.
+     * Always resolves with the signature directly.
+     */
+    signTransaction: (txRequest: RequestArguments['params']) => Promise<string>;
+    /**
+     * Map of transaction hashes to their current state
+     */
+    pendingTransactions: Map<string, TxState>;
+    /**
+     * Whether there are any pending transactions
+     */
+    isAnyPending: boolean;
+}
+/**
+ * React hook for handling async transactions with WaaP SDK.
+ *
+ * When `asyncTxs` is enabled (via `initWaaP({ asyncTxs: true })` or per-request `{ async: true }`):
+ * - `eth_sendTransaction` resolves with the pre-calculated tx hash after signing
+ * - Broadcasting and confirmation happen in the background with events
+ * - Use the callbacks to track transaction lifecycle
+ *
+ * Other signing methods (`personal_sign`, `eth_signTypedData_v4`, `eth_signTransaction`)
+ * always resolve with the signature directly — no events needed.
+ *
+ * @example
+ * ```tsx
+ * const { sendTransaction, pendingTransactions, isAnyPending } = useWaapTransaction({
+ *   onSigned: ({ txHash }) => console.log('Signed:', txHash),
+ *   onTxPending: ({ txHash }) => console.log('Broadcasting:', txHash),
+ *   onConfirmed: ({ txHash, receipt }) => console.log('Confirmed:', txHash),
+ *   onFailed: ({ txHash, error }) => console.error('Failed:', txHash, error)
+ * });
+ *
+ * const handleSend = async () => {
+ *   const txHash = await sendTransaction([{ to: '0x...', value: '0x...' }]);
+ *   console.log('Got tx hash:', txHash);
+ * };
+ * ```
+ */
+declare function useWaapTransaction(options?: UseWaapTransactionOptions): UseWaapTransactionReturn;
+
+export { EthereumProvider, EthereumProviderExtension, type InitSilkOptions, type InitSilkOptions as InitWaaPOptions, type InitWaaPSuiOptions, type PostSilkRequestArgs, type PostSilkRequestArgs as PostWaaPRequestArgs, type SilkEthereumProviderInterface, type SilkProvider, SilkWalletConnect, type SuiAccount, type SuiChain, type SuiConnectInput, type SuiConnectOutput, type SuiSignPersonalMessageInput, type SuiSignPersonalMessageOutput, type TxState, UIMessageManager, UI_EVENT_NAMES, type UseWaapTransactionOptions, type UseWaapTransactionReturn, WaapWalletElement as WaaP, type SilkEthereumProviderInterface as WaaPEthereumProviderInterface, type SilkProvider as WaaPProvider, WaaPSuiWallet, type WaaPSuiWalletFeatures, type WaaPSuiWalletInterface, SilkWalletConnect as WaaPWalletConnect, WalletMessageManager, handleWalletRequestAndResponse, initWaaP, initWaaPSui, registerWaaPSuiWallet, useWaapTransaction };