@sip-protocol/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,3640 @@
+import * as _sip_protocol_types from '@sip-protocol/types';
+import { ZKProof, HexString, Commitment, PrivacyLevel, ShieldedIntent, CreateIntentParams, TrackedIntent, ChainId, StealthMetaAddress, Quote, FulfillmentResult, ViewingKey, StealthAddress, StealthAddressRecovery, EncryptedTransaction, Hash, Asset, IntentInput, IntentOutput, OneClickConfig, OneClickToken, OneClickQuoteRequest, OneClickQuoteResponse, OneClickDepositSubmit, OneClickStatusResponse, OneClickWithdrawal, DefuseAssetId, OneClickSwapStatus, ChainType, SIPSolver, Solver, SolverCapabilities, SolverVisibleIntent, SolverQuote, FulfillmentStatus, ZcashConfig, ZcashAddressInfo, ZcashNewAccount, ZcashReceiverType, ZcashAccountAddress, ZcashAccountBalance, ZcashUnspentNote, ZcashShieldedSendParams, ZcashOperation, ZcashBlockHeader, ZcashBlock, ZcashBlockchainInfo, ZcashNetworkInfo, WalletAdapter as WalletAdapter$1, WalletConnectionState, WalletEventType, WalletEventHandler, WalletEvent, Signature, UnsignedTransaction, SignedTransaction, TransactionReceipt, WalletErrorCodeType, WalletRegistryEntry, WalletInfo, PrivateWalletAdapter, WalletAdapterFactory } from '@sip-protocol/types';
+export { Asset, ChainId, Commitment, CreateIntentParams, DefuseAssetId, FulfillmentCommitment, FulfillmentProof, FulfillmentRequest, FulfillmentResult, FulfillmentStatus, Hash, HexString, WalletAdapter as IWalletAdapter, IntentStatus, NATIVE_TOKENS, OneClickConfig, OneClickDepositMode, OneClickErrorCode, OneClickQuoteRequest, OneClickQuoteResponse, OneClickStatusResponse, OneClickSwapStatus, OneClickSwapType, PrivacyLevel, PrivateWalletAdapter, Quote, SIPSolver, SIP_VERSION, ShieldedIntent, Signature, SignedTransaction, Solver, SolverCapabilities, SolverEvent, SolverEventListener, SolverQuote, SolverVisibleIntent, StealthAddress, StealthAddressRecovery, StealthMetaAddress, SwapRoute, SwapRouteStep, TrackedIntent, TransactionReceipt, UnsignedTransaction, ViewingKey, WalletAccountChangedEvent, WalletAdapterFactory, WalletChainChangedEvent, WalletConnectEvent, WalletConnectionState, WalletDisconnectEvent, WalletErrorCode, WalletErrorEvent, WalletEvent, WalletEventHandler, WalletEventType, WalletInfo, WalletRegistryEntry, WalletShieldedSendParams, WalletShieldedSendResult, ZKProof, ZcashAccountAddress, ZcashAccountBalance, ZcashAddressInfo, ZcashAddressType, ZcashBlock, ZcashBlockHeader, ZcashBlockchainInfo, ZcashConfig, ZcashErrorCode, ZcashNetwork, ZcashNetworkInfo, ZcashNewAccount, ZcashOperation, ZcashOperationError, ZcashOperationStatus, ZcashOperationTxResult, ZcashPool, ZcashPoolBalance, ZcashPrivacyPolicy, ZcashReceiverType, ZcashSendRecipient, ZcashShieldedSendParams, ZcashUnspentNote, isPrivate, supportsViewingKey } from '@sip-protocol/types';
+
+/**
+ * Custom errors for SIP Protocol SDK
+ *
+ * Provides a comprehensive error hierarchy with:
+ * - Machine-readable error codes
+ * - Human-readable messages
+ * - Original cause preservation
+ * - Additional debugging context
+ * - Serialization for logging
+ */
+/**
+ * Machine-readable error codes for programmatic error handling
+ */
+declare enum ErrorCode {
+    UNKNOWN = "SIP_1000",
+    INTERNAL = "SIP_1001",
+    NOT_IMPLEMENTED = "SIP_1002",
+    VALIDATION_FAILED = "SIP_2000",
+    INVALID_INPUT = "SIP_2001",
+    INVALID_CHAIN = "SIP_2002",
+    INVALID_PRIVACY_LEVEL = "SIP_2003",
+    INVALID_AMOUNT = "SIP_2004",
+    INVALID_HEX = "SIP_2005",
+    INVALID_KEY = "SIP_2006",
+    INVALID_ADDRESS = "SIP_2007",
+    MISSING_REQUIRED = "SIP_2008",
+    OUT_OF_RANGE = "SIP_2009",
+    CRYPTO_FAILED = "SIP_3000",
+    ENCRYPTION_FAILED = "SIP_3001",
+    DECRYPTION_FAILED = "SIP_3002",
+    KEY_DERIVATION_FAILED = "SIP_3003",
+    COMMITMENT_FAILED = "SIP_3004",
+    SIGNATURE_FAILED = "SIP_3005",
+    INVALID_CURVE_POINT = "SIP_3006",
+    INVALID_SCALAR = "SIP_3007",
+    PROOF_FAILED = "SIP_4000",
+    PROOF_GENERATION_FAILED = "SIP_4001",
+    PROOF_VERIFICATION_FAILED = "SIP_4002",
+    PROOF_NOT_IMPLEMENTED = "SIP_4003",
+    PROOF_PROVIDER_NOT_READY = "SIP_4004",
+    INVALID_PROOF_PARAMS = "SIP_4005",
+    INTENT_FAILED = "SIP_5000",
+    INTENT_EXPIRED = "SIP_5001",
+    INTENT_CANCELLED = "SIP_5002",
+    INTENT_NOT_FOUND = "SIP_5003",
+    INTENT_INVALID_STATE = "SIP_5004",
+    PROOFS_REQUIRED = "SIP_5005",
+    QUOTE_EXPIRED = "SIP_5006",
+    NETWORK_FAILED = "SIP_6000",
+    NETWORK_TIMEOUT = "SIP_6001",
+    NETWORK_UNAVAILABLE = "SIP_6002",
+    RPC_ERROR = "SIP_6003",
+    API_ERROR = "SIP_6004",
+    RATE_LIMITED = "SIP_6005",
+    WALLET_ERROR = "SIP_7000",
+    WALLET_NOT_CONNECTED = "SIP_7001",
+    WALLET_CONNECTION_FAILED = "SIP_7002",
+    WALLET_SIGNING_FAILED = "SIP_7003",
+    WALLET_TRANSACTION_FAILED = "SIP_7004"
+}
+/**
+ * Serialized error format for logging and transmission
+ */
+interface SerializedError {
+    name: string;
+    code: ErrorCode;
+    message: string;
+    field?: string;
+    context?: Record<string, unknown>;
+    cause?: string;
+    stack?: string;
+    timestamp: string;
+}
+/**
+ * Base error class for SIP Protocol
+ *
+ * All SDK errors extend this class and include:
+ * - `code`: Machine-readable error code for programmatic handling
+ * - `cause`: Original error if this error wraps another
+ * - `context`: Additional debugging information
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await sip.execute(intent, quote)
+ * } catch (e) {
+ *   if (e instanceof SIPError) {
+ *     console.log(`Error ${e.code}: ${e.message}`)
+ *     if (e.cause) console.log('Caused by:', e.cause)
+ *   }
+ * }
+ * ```
+ */
+declare class SIPError extends Error {
+    /** Machine-readable error code */
+    readonly code: ErrorCode;
+    /** Additional debugging context */
+    readonly context?: Record<string, unknown>;
+    /** Timestamp when error was created */
+    readonly timestamp: Date;
+    constructor(message: string, code?: ErrorCode, options?: {
+        cause?: Error;
+        context?: Record<string, unknown>;
+    });
+    /**
+     * Serialize error for logging or transmission
+     */
+    toJSON(): SerializedError;
+    /**
+     * Create a string representation for logging
+     */
+    toString(): string;
+}
+/**
+ * Error thrown when input validation fails
+ *
+ * Provides detailed information about what validation failed
+ * and optionally which field caused the error.
+ *
+ * @example
+ * ```typescript
+ * throw new ValidationError('Amount must be positive', 'input.amount')
+ *
+ * // With error code
+ * throw new ValidationError('Invalid chain ID', 'chain', {
+ *   code: ErrorCode.INVALID_CHAIN,
+ *   context: { received: 'invalid-chain' }
+ * })
+ * ```
+ */
+declare class ValidationError extends SIPError {
+    /** The field that failed validation (if applicable) */
+    readonly field?: string;
+    constructor(message: string, field?: string, context?: Record<string, unknown>, code?: ErrorCode);
+    toJSON(): SerializedError;
+}
+/**
+ * Error thrown when cryptographic operations fail
+ *
+ * Covers encryption, decryption, key derivation, commitments, and signatures.
+ *
+ * @example
+ * ```typescript
+ * throw new CryptoError('Decryption failed', ErrorCode.DECRYPTION_FAILED, {
+ *   cause: originalError,
+ *   context: { operation: 'decryptWithViewing' }
+ * })
+ * ```
+ */
+declare class CryptoError extends SIPError {
+    /** The cryptographic operation that failed */
+    readonly operation?: string;
+    constructor(message: string, code?: ErrorCode, options?: {
+        cause?: Error;
+        context?: Record<string, unknown>;
+        operation?: string;
+    });
+}
+/**
+ * Error thrown when encryption functions are called but not yet implemented
+ *
+ * @deprecated Use CryptoError with ErrorCode.NOT_IMPLEMENTED instead
+ */
+declare class EncryptionNotImplementedError extends CryptoError {
+    /** The type of encryption operation */
+    readonly operationType: 'encrypt' | 'decrypt';
+    /** Reference to the specification document */
+    readonly specReference: string;
+    constructor(operation: 'encrypt' | 'decrypt', specReference: string);
+}
+/**
+ * Error thrown when proof operations fail
+ *
+ * Covers proof generation, verification, and related operations.
+ *
+ * @example
+ * ```typescript
+ * throw new ProofError('Proof verification failed', ErrorCode.PROOF_VERIFICATION_FAILED, {
+ *   context: { proofType: 'funding', publicInputs: [...] }
+ * })
+ * ```
+ */
+declare class ProofError extends SIPError {
+    /** The type of proof involved */
+    readonly proofType?: 'funding' | 'validity' | 'fulfillment' | 'viewing';
+    constructor(message: string, code?: ErrorCode, options?: {
+        cause?: Error;
+        context?: Record<string, unknown>;
+        proofType?: 'funding' | 'validity' | 'fulfillment' | 'viewing';
+    });
+}
+/**
+ * Error thrown when a proof function is called but not yet implemented
+ *
+ * This error indicates that real ZK proof generation is required but not available.
+ *
+ * @example
+ * ```typescript
+ * // Use ProofProvider for proof generation
+ * const provider = new NoirProofProvider(config)
+ * await provider.initialize()
+ * const result = await provider.generateFundingProof(params)
+ * ```
+ */
+declare class ProofNotImplementedError extends ProofError {
+    /** Reference to the specification document */
+    readonly specReference: string;
+    constructor(proofType: 'funding' | 'validity' | 'fulfillment' | 'viewing', specReference: string);
+}
+/**
+ * Error thrown when intent operations fail
+ *
+ * Covers intent creation, execution, and lifecycle errors.
+ *
+ * @example
+ * ```typescript
+ * throw new IntentError('Intent has expired', ErrorCode.INTENT_EXPIRED, {
+ *   context: { intentId, expiry, now: Date.now() }
+ * })
+ * ```
+ */
+declare class IntentError extends SIPError {
+    /** The intent ID involved (if available) */
+    readonly intentId?: string;
+    constructor(message: string, code?: ErrorCode, options?: {
+        cause?: Error;
+        context?: Record<string, unknown>;
+        intentId?: string;
+    });
+}
+/**
+ * Error thrown when external service communication fails
+ *
+ * Covers RPC calls, API requests, and network connectivity issues.
+ *
+ * @example
+ * ```typescript
+ * throw new NetworkError('RPC request failed', ErrorCode.RPC_ERROR, {
+ *   cause: originalError,
+ *   context: { endpoint: 'https://...', method: 'eth_call' }
+ * })
+ * ```
+ */
+declare class NetworkError extends SIPError {
+    /** The endpoint that failed (if applicable) */
+    readonly endpoint?: string;
+    /** HTTP status code (if applicable) */
+    readonly statusCode?: number;
+    constructor(message: string, code?: ErrorCode, options?: {
+        cause?: Error;
+        context?: Record<string, unknown>;
+        endpoint?: string;
+        statusCode?: number;
+    });
+}
+/**
+ * Check if an error is a SIP Protocol error
+ */
+declare function isSIPError(error: unknown): error is SIPError;
+/**
+ * Check if an error has a specific error code
+ */
+declare function hasErrorCode(error: unknown, code: ErrorCode): boolean;
+/**
+ * Wrap an unknown error as a SIPError
+ *
+ * Useful for catching and re-throwing with additional context.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await riskyOperation()
+ * } catch (e) {
+ *   throw wrapError(e, 'Operation failed', ErrorCode.INTERNAL)
+ * }
+ * ```
+ */
+declare function wrapError(error: unknown, message: string, code?: ErrorCode, context?: Record<string, unknown>): SIPError;
+/**
+ * Extract error message from unknown error
+ */
+declare function getErrorMessage(error: unknown): string;
+
+/**
+ * Proof Provider Interface
+ *
+ * Defines a pluggable interface for ZK proof generation and verification.
+ * This allows different backends (Noir, mock for testing) to be swapped.
+ *
+ * @see docs/specs/ZK-ARCHITECTURE.md for framework decision (Noir)
+ */
+
+/**
+ * Supported proof framework types
+ */
+type ProofFramework = 'noir' | 'mock';
+/**
+ * Parameters for generating a Funding Proof
+ *
+ * Proves: balance >= minimumRequired without revealing balance
+ *
+ * @see docs/specs/FUNDING-PROOF.md
+ */
+interface FundingProofParams {
+    /** User's actual balance (private) */
+    balance: bigint;
+    /** Minimum amount required for the intent (public) */
+    minimumRequired: bigint;
+    /** Blinding factor for the commitment (private) */
+    blindingFactor: Uint8Array;
+    /** Asset identifier (public) */
+    assetId: string;
+    /** User's address for ownership proof (private) */
+    userAddress: string;
+    /** Signature proving ownership of the address (private) */
+    ownershipSignature: Uint8Array;
+}
+/**
+ * Parameters for generating a Validity Proof
+ *
+ * Proves: intent is authorized by sender without revealing sender
+ *
+ * @see docs/specs/VALIDITY-PROOF.md
+ */
+interface ValidityProofParams {
+    /** Hash of the intent (public) */
+    intentHash: HexString;
+    /** Sender's address (private) */
+    senderAddress: string;
+    /** Blinding factor for sender commitment (private) */
+    senderBlinding: Uint8Array;
+    /** Sender's secret key (private) */
+    senderSecret: Uint8Array;
+    /** Signature authorizing the intent (private) */
+    authorizationSignature: Uint8Array;
+    /** Nonce for nullifier generation (private) */
+    nonce: Uint8Array;
+    /** Intent timestamp (public) */
+    timestamp: number;
+    /** Intent expiry (public) */
+    expiry: number;
+}
+/**
+ * Parameters for generating a Fulfillment Proof
+ *
+ * Proves: solver delivered output >= minimum to correct recipient
+ *
+ * @see docs/specs/FULFILLMENT-PROOF.md
+ */
+interface FulfillmentProofParams {
+    /** Hash of the original intent (public) */
+    intentHash: HexString;
+    /** Actual output amount delivered (private) */
+    outputAmount: bigint;
+    /** Blinding factor for output commitment (private) */
+    outputBlinding: Uint8Array;
+    /** Minimum required output from intent (public) */
+    minOutputAmount: bigint;
+    /** Recipient's stealth address (public) */
+    recipientStealth: HexString;
+    /** Solver's identifier (public) */
+    solverId: string;
+    /** Solver's secret for authorization (private) */
+    solverSecret: Uint8Array;
+    /** Oracle attestation of delivery (private) */
+    oracleAttestation: OracleAttestation;
+    /** Time of fulfillment (public) */
+    fulfillmentTime: number;
+    /** Intent expiry (public) */
+    expiry: number;
+}
+/**
+ * Oracle attestation for cross-chain verification
+ */
+interface OracleAttestation {
+    /** Recipient who received funds */
+    recipient: HexString;
+    /** Amount received */
+    amount: bigint;
+    /** Transaction hash on destination chain */
+    txHash: HexString;
+    /** Block number containing the transaction */
+    blockNumber: bigint;
+    /** Oracle signature (threshold signature for multi-oracle) */
+    signature: Uint8Array;
+}
+/**
+ * Result of proof generation
+ */
+interface ProofResult {
+    /** The generated proof */
+    proof: ZKProof;
+    /** Public inputs used in the proof */
+    publicInputs: HexString[];
+    /** Commitment (if generated as part of proof) */
+    commitment?: Commitment;
+}
+/**
+ * Proof Provider Interface
+ *
+ * Implementations of this interface provide ZK proof generation and verification.
+ * The SDK uses this interface to remain agnostic to the underlying ZK framework.
+ *
+ * @example
+ * ```typescript
+ * // Use mock provider for testing
+ * const mockProvider = new MockProofProvider()
+ *
+ * // Use Noir provider for production
+ * const noirProvider = new NoirProofProvider()
+ *
+ * // Configure SIP client with provider
+ * const sip = new SIP({
+ *   network: 'testnet',
+ *   proofProvider: noirProvider,
+ * })
+ * ```
+ */
+interface ProofProvider {
+    /**
+     * The ZK framework this provider uses
+     */
+    readonly framework: ProofFramework;
+    /**
+     * Whether the provider is ready to generate proofs
+     * (e.g., circuits compiled, keys loaded)
+     */
+    readonly isReady: boolean;
+    /**
+     * Initialize the provider (compile circuits, load keys, etc.)
+     *
+     * @throws Error if initialization fails
+     */
+    initialize(): Promise<void>;
+    /**
+     * Generate a Funding Proof
+     *
+     * Proves that the user has sufficient balance without revealing the exact amount.
+     *
+     * @param params - Funding proof parameters
+     * @returns The generated proof with public inputs
+     * @throws ProofGenerationError if proof generation fails
+     *
+     * @see docs/specs/FUNDING-PROOF.md (~22,000 constraints)
+     */
+    generateFundingProof(params: FundingProofParams): Promise<ProofResult>;
+    /**
+     * Generate a Validity Proof
+     *
+     * Proves that the intent is authorized without revealing the sender.
+     *
+     * @param params - Validity proof parameters
+     * @returns The generated proof with public inputs
+     * @throws ProofGenerationError if proof generation fails
+     *
+     * @see docs/specs/VALIDITY-PROOF.md (~72,000 constraints)
+     */
+    generateValidityProof(params: ValidityProofParams): Promise<ProofResult>;
+    /**
+     * Generate a Fulfillment Proof
+     *
+     * Proves that the solver correctly delivered the output.
+     *
+     * @param params - Fulfillment proof parameters
+     * @returns The generated proof with public inputs
+     * @throws ProofGenerationError if proof generation fails
+     *
+     * @see docs/specs/FULFILLMENT-PROOF.md (~22,000 constraints)
+     */
+    generateFulfillmentProof(params: FulfillmentProofParams): Promise<ProofResult>;
+    /**
+     * Verify a proof
+     *
+     * @param proof - The proof to verify
+     * @returns true if the proof is valid, false otherwise
+     */
+    verifyProof(proof: ZKProof): Promise<boolean>;
+}
+/**
+ * Error thrown when proof generation fails
+ */
+declare class ProofGenerationError extends Error {
+    readonly proofType: 'funding' | 'validity' | 'fulfillment';
+    readonly cause?: Error;
+    constructor(proofType: 'funding' | 'validity' | 'fulfillment', message: string, cause?: Error);
+}
+
+/**
+ * Mock Proof Provider
+ *
+ * ⚠️ WARNING: FOR TESTING ONLY - DO NOT USE IN PRODUCTION ⚠️
+ *
+ * This provider generates fake proofs that provide NO cryptographic guarantees.
+ * It is intended solely for:
+ * - Unit testing
+ * - Integration testing
+ * - Development/debugging
+ *
+ * The mock proofs are clearly marked and will be rejected by any real verifier.
+ */
+
+/**
+ * Mock Proof Provider for testing
+ *
+ * @example
+ * ```typescript
+ * // Only use in tests
+ * const provider = new MockProofProvider()
+ * await provider.initialize()
+ *
+ * const result = await provider.generateFundingProof({
+ *   balance: 100n,
+ *   minimumRequired: 50n,
+ *   // ... other params
+ * })
+ * ```
+ */
+declare class MockProofProvider implements ProofProvider {
+    readonly framework: ProofFramework;
+    private _isReady;
+    private _warningShown;
+    get isReady(): boolean;
+    /**
+     * Initialize the mock provider
+     *
+     * Logs a warning to console about mock usage.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Generate a mock funding proof
+     *
+     * ⚠️ This proof provides NO cryptographic guarantees!
+     */
+    generateFundingProof(params: FundingProofParams): Promise<ProofResult>;
+    /**
+     * Generate a mock validity proof
+     *
+     * ⚠️ This proof provides NO cryptographic guarantees!
+     */
+    generateValidityProof(params: ValidityProofParams): Promise<ProofResult>;
+    /**
+     * Generate a mock fulfillment proof
+     *
+     * ⚠️ This proof provides NO cryptographic guarantees!
+     */
+    generateFulfillmentProof(params: FulfillmentProofParams): Promise<ProofResult>;
+    /**
+     * Verify a mock proof
+     *
+     * Only verifies that the proof has the mock prefix.
+     * ⚠️ This provides NO cryptographic verification!
+     */
+    verifyProof(proof: ZKProof): Promise<boolean>;
+    /**
+     * Check if a proof is a mock proof
+     */
+    static isMockProof(proof: ZKProof): boolean;
+    private ensureReady;
+    private generateMockProofData;
+    private hashToHex;
+}
+
+/**
+ * Noir Proof Provider
+ *
+ * Production-ready ZK proof provider using Noir (Aztec) circuits.
+ *
+ * This provider generates cryptographically sound proofs using:
+ * - Funding Proof: ~22,000 constraints (docs/specs/FUNDING-PROOF.md)
+ * - Validity Proof: ~72,000 constraints (docs/specs/VALIDITY-PROOF.md)
+ * - Fulfillment Proof: ~22,000 constraints (docs/specs/FULFILLMENT-PROOF.md)
+ *
+ * @see docs/specs/ZK-ARCHITECTURE.md for framework decision
+ */
+
+/**
+ * Noir Proof Provider Configuration
+ */
+interface NoirProviderConfig {
+    /**
+     * Path to compiled circuit artifacts
+     * If not provided, uses bundled artifacts
+     */
+    artifactsPath?: string;
+    /**
+     * Backend to use for proof generation
+     * @default 'barretenberg' (UltraPlonk)
+     */
+    backend?: 'barretenberg';
+    /**
+     * Enable verbose logging for debugging
+     * @default false
+     */
+    verbose?: boolean;
+}
+/**
+ * Noir Proof Provider
+ *
+ * Production ZK proof provider using Noir circuits.
+ *
+ * @example
+ * ```typescript
+ * const provider = new NoirProofProvider({
+ *   artifactsPath: './circuits/target',
+ * })
+ *
+ * await provider.initialize()
+ *
+ * const result = await provider.generateFundingProof({
+ *   balance: 100n,
+ *   minimumRequired: 50n,
+ *   // ... other params
+ * })
+ * ```
+ */
+declare class NoirProofProvider implements ProofProvider {
+    readonly framework: ProofFramework;
+    private _isReady;
+    private config;
+    private artifacts;
+    constructor(config?: NoirProviderConfig);
+    get isReady(): boolean;
+    /**
+     * Initialize the Noir provider
+     *
+     * Loads circuit artifacts and initializes the proving backend.
+     *
+     * @throws Error if circuits are not yet implemented
+     */
+    initialize(): Promise<void>;
+    /**
+     * Generate a Funding Proof using Noir circuits
+     *
+     * @see docs/specs/FUNDING-PROOF.md
+     */
+    generateFundingProof(_params: FundingProofParams): Promise<ProofResult>;
+    /**
+     * Generate a Validity Proof using Noir circuits
+     *
+     * @see docs/specs/VALIDITY-PROOF.md
+     */
+    generateValidityProof(_params: ValidityProofParams): Promise<ProofResult>;
+    /**
+     * Generate a Fulfillment Proof using Noir circuits
+     *
+     * @see docs/specs/FULFILLMENT-PROOF.md
+     */
+    generateFulfillmentProof(_params: FulfillmentProofParams): Promise<ProofResult>;
+    /**
+     * Verify a Noir proof
+     */
+    verifyProof(_proof: ZKProof): Promise<boolean>;
+    private ensureReady;
+}
+
+/**
+ * Options for creating a shielded intent
+ */
+interface CreateIntentOptions {
+    /** Sender address (for ownership proof) */
+    senderAddress?: string;
+    /**
+     * Proof provider for generating ZK proofs
+     * If provided and privacy level requires proofs, they will be generated automatically
+     */
+    proofProvider?: ProofProvider;
+}
+/**
+ * Builder class for creating shielded intents
+ */
+declare class IntentBuilder {
+    private params;
+    private senderAddress?;
+    private proofProvider?;
+    /**
+     * Set the input for the intent
+     *
+     * @throws {ValidationError} If chain or amount is invalid
+     */
+    input(chain: string, token: string, amount: number | bigint, sourceAddress?: string): this;
+    /**
+     * Set the output for the intent
+     *
+     * @throws {ValidationError} If chain is invalid
+     */
+    output(chain: string, token: string, minAmount?: number | bigint): this;
+    /**
+     * Set the privacy level
+     *
+     * @throws {ValidationError} If privacy level is invalid
+     */
+    privacy(level: PrivacyLevel): this;
+    /**
+     * Set the recipient's stealth meta-address
+     *
+     * @throws {ValidationError} If stealth meta-address format is invalid
+     */
+    recipient(metaAddress: string): this;
+    /**
+     * Set slippage tolerance
+     *
+     * @param percent - Slippage percentage (e.g., 1 for 1%)
+     * @throws {ValidationError} If slippage is out of range
+     */
+    slippage(percent: number): this;
+    /**
+     * Set time-to-live in seconds
+     *
+     * @throws {ValidationError} If TTL is not a positive integer
+     */
+    ttl(seconds: number): this;
+    /**
+     * Set the proof provider for automatic proof generation
+     *
+     * @param provider - The proof provider to use
+     * @returns this for chaining
+     *
+     * @example
+     * ```typescript
+     * const intent = await builder
+     *   .input('near', 'NEAR', 100n)
+     *   .output('zcash', 'ZEC', 95n)
+     *   .privacy(PrivacyLevel.SHIELDED)
+     *   .withProvider(mockProvider)
+     *   .build()
+     * ```
+     */
+    withProvider(provider: ProofProvider): this;
+    /**
+     * Build the shielded intent
+     *
+     * If a proof provider is set and the privacy level requires proofs,
+     * they will be generated automatically.
+     *
+     * @returns Promise resolving to the shielded intent
+     */
+    build(): Promise<ShieldedIntent>;
+}
+/**
+ * Create a new shielded intent
+ *
+ * @param params - Intent creation parameters
+ * @param options - Optional configuration (sender address, proof provider)
+ * @returns Promise resolving to the shielded intent
+ *
+ * @example
+ * ```typescript
+ * // Without proof provider (proofs need to be attached later)
+ * const intent = await createShieldedIntent(params)
+ *
+ * // With proof provider (proofs generated automatically for SHIELDED/COMPLIANT)
+ * const intent = await createShieldedIntent(params, {
+ *   senderAddress: wallet.address,
+ *   proofProvider: mockProvider,
+ * })
+ * ```
+ */
+declare function createShieldedIntent(params: CreateIntentParams, options?: CreateIntentOptions): Promise<ShieldedIntent>;
+/**
+ * Attach proofs to a shielded intent
+ *
+ * For SHIELDED and COMPLIANT modes, proofs are required before the intent
+ * can be submitted. This function attaches the proofs to an intent.
+ *
+ * @param intent - The intent to attach proofs to
+ * @param fundingProof - The funding proof (balance >= minimum)
+ * @param validityProof - The validity proof (authorization)
+ * @returns The intent with proofs attached
+ */
+declare function attachProofs(intent: ShieldedIntent, fundingProof: _sip_protocol_types.ZKProof, validityProof: _sip_protocol_types.ZKProof): ShieldedIntent;
+/**
+ * Check if an intent has all required proofs
+ */
+declare function hasRequiredProofs(intent: ShieldedIntent): boolean;
+/**
+ * Wrap a shielded intent with status tracking
+ */
+declare function trackIntent(intent: ShieldedIntent): TrackedIntent;
+/**
+ * Check if an intent has expired
+ */
+declare function isExpired(intent: ShieldedIntent): boolean;
+/**
+ * Get time remaining until intent expires (in seconds)
+ */
+declare function getTimeRemaining(intent: ShieldedIntent): number;
+/**
+ * Serialize a shielded intent to JSON
+ */
+declare function serializeIntent(intent: ShieldedIntent): string;
+/**
+ * Deserialize a shielded intent from JSON
+ */
+declare function deserializeIntent(json: string): ShieldedIntent;
+/**
+ * Get a human-readable summary of the intent
+ */
+declare function getIntentSummary(intent: ShieldedIntent): string;
+
+/**
+ * SIP SDK Main Client
+ *
+ * High-level interface for interacting with the Shielded Intents Protocol.
+ */
+
+/**
+ * SIP SDK configuration
+ */
+interface SIPConfig {
+    /** Network: mainnet or testnet */
+    network: 'mainnet' | 'testnet';
+    /** Default privacy level */
+    defaultPrivacy?: PrivacyLevel;
+    /** RPC endpoints for chains */
+    rpcEndpoints?: Partial<Record<ChainId, string>>;
+    /**
+     * Proof provider for ZK proof generation
+     *
+     * If not provided, proof generation will not be available.
+     * Use MockProofProvider for testing, NoirProofProvider for production.
+     *
+     * @example
+     * ```typescript
+     * import { MockProofProvider } from '@sip-protocol/sdk'
+     *
+     * const sip = new SIP({
+     *   network: 'testnet',
+     *   proofProvider: new MockProofProvider(),
+     * })
+     * ```
+     */
+    proofProvider?: ProofProvider;
+}
+/**
+ * Wallet adapter interface
+ */
+interface WalletAdapter {
+    /** Connected chain */
+    chain: ChainId;
+    /** Wallet address */
+    address: string;
+    /** Sign a message */
+    signMessage(message: string): Promise<string>;
+    /** Sign a transaction */
+    signTransaction(tx: unknown): Promise<unknown>;
+}
+/**
+ * Main SIP SDK class
+ */
+declare class SIP {
+    private config;
+    private wallet?;
+    private stealthKeys?;
+    private proofProvider?;
+    constructor(config: SIPConfig);
+    /**
+     * Get the configured proof provider
+     */
+    getProofProvider(): ProofProvider | undefined;
+    /**
+     * Set or update the proof provider
+     */
+    setProofProvider(provider: ProofProvider): void;
+    /**
+     * Check if proof provider is available and ready
+     */
+    hasProofProvider(): boolean;
+    /**
+     * Connect a wallet
+     */
+    connect(wallet: WalletAdapter): void;
+    /**
+     * Disconnect wallet
+     */
+    disconnect(): void;
+    /**
+     * Check if wallet is connected
+     */
+    isConnected(): boolean;
+    /**
+     * Get connected wallet
+     */
+    getWallet(): WalletAdapter | undefined;
+    /**
+     * Generate and store stealth keys for this session
+     *
+     * @throws {ValidationError} If chain is invalid
+     */
+    generateStealthKeys(chain: ChainId, label?: string): StealthMetaAddress;
+    /**
+     * Get the encoded stealth meta-address for receiving
+     */
+    getStealthAddress(): string | undefined;
+    /**
+     * Create a new intent builder
+     *
+     * The builder is automatically configured with the SIP client's proof provider
+     * (if one is set), so proofs will be generated automatically when `.build()` is called.
+     *
+     * @example
+     * ```typescript
+     * const intent = await sip.intent()
+     *   .input('near', 'NEAR', 100n)
+     *   .output('zcash', 'ZEC', 95n)
+     *   .privacy(PrivacyLevel.SHIELDED)
+     *   .build()
+     * ```
+     */
+    intent(): IntentBuilder;
+    /**
+     * Create a shielded intent directly
+     *
+     * Uses the SIP client's configured proof provider (if any) to generate proofs
+     * automatically for SHIELDED and COMPLIANT privacy levels.
+     */
+    createIntent(params: CreateIntentParams): Promise<TrackedIntent>;
+    /**
+     * Get quotes for an intent (mock implementation)
+     */
+    getQuotes(intent: ShieldedIntent): Promise<Quote[]>;
+    /**
+     * Execute an intent with a selected quote (mock implementation)
+     */
+    execute(intent: TrackedIntent, quote: Quote): Promise<FulfillmentResult>;
+    /**
+     * Generate a viewing key for compliant mode
+     */
+    generateViewingKey(path?: string): ViewingKey;
+    /**
+     * Derive a child viewing key
+     */
+    deriveViewingKey(masterKey: ViewingKey, childPath: string): ViewingKey;
+    /**
+     * Get network configuration
+     */
+    getNetwork(): 'mainnet' | 'testnet';
+}
+/**
+ * Create a new SIP instance with default testnet config
+ */
+declare function createSIP(network?: 'mainnet' | 'testnet'): SIP;
+
+/**
+ * Stealth Address Generation for SIP Protocol
+ *
+ * Implements EIP-5564 style stealth addresses using secp256k1.
+ * Provides unlinkable one-time addresses for privacy-preserving transactions.
+ *
+ * Flow:
+ * 1. Recipient generates stealth meta-address (spending key P, viewing key Q)
+ * 2. Sender generates ephemeral keypair (r, R = r*G)
+ * 3. Sender computes shared secret: S = r * P
+ * 4. Sender derives stealth address: A = Q + hash(S)*G
+ * 5. Recipient scans: for each R, compute S = p * R, check if A matches
+ */
+
+/**
+ * Generate a new stealth meta-address keypair
+ *
+ * @param chain - Target chain for the addresses
+ * @param label - Optional human-readable label
+ * @returns Stealth meta-address and private keys
+ * @throws {ValidationError} If chain is invalid
+ */
+declare function generateStealthMetaAddress(chain: ChainId, label?: string): {
+    metaAddress: StealthMetaAddress;
+    spendingPrivateKey: HexString;
+    viewingPrivateKey: HexString;
+};
+/**
+ * Generate a one-time stealth address for a recipient
+ *
+ * @param recipientMetaAddress - Recipient's published stealth meta-address
+ * @returns Stealth address data (address + ephemeral key for publication)
+ * @throws {ValidationError} If recipientMetaAddress is invalid
+ */
+declare function generateStealthAddress(recipientMetaAddress: StealthMetaAddress): {
+    stealthAddress: StealthAddress;
+    sharedSecret: HexString;
+};
+/**
+ * Derive the private key for a stealth address (for recipient to claim funds)
+ *
+ * @param stealthAddress - The stealth address to recover
+ * @param spendingPrivateKey - Recipient's spending private key
+ * @param viewingPrivateKey - Recipient's viewing private key
+ * @returns Recovery data including derived private key
+ * @throws {ValidationError} If any input is invalid
+ */
+declare function deriveStealthPrivateKey(stealthAddress: StealthAddress, spendingPrivateKey: HexString, viewingPrivateKey: HexString): StealthAddressRecovery;
+/**
+ * Check if a stealth address was intended for this recipient
+ * Uses view tag for efficient filtering before full computation
+ *
+ * @param stealthAddress - Stealth address to check
+ * @param spendingPrivateKey - Recipient's spending private key
+ * @param viewingPrivateKey - Recipient's viewing private key
+ * @returns true if this address belongs to the recipient
+ * @throws {ValidationError} If any input is invalid
+ */
+declare function checkStealthAddress(stealthAddress: StealthAddress, spendingPrivateKey: HexString, viewingPrivateKey: HexString): boolean;
+/**
+ * Encode a stealth meta-address as a string
+ * Format: sip:{chain}:{spendingKey}:{viewingKey}
+ */
+declare function encodeStealthMetaAddress(metaAddress: StealthMetaAddress): string;
+/**
+ * Decode a stealth meta-address from a string
+ *
+ * @param encoded - Encoded stealth meta-address (format: sip:<chain>:<spendingKey>:<viewingKey>)
+ * @returns Decoded StealthMetaAddress
+ * @throws {ValidationError} If format is invalid or keys are malformed
+ */
+declare function decodeStealthMetaAddress(encoded: string): StealthMetaAddress;
+
+/**
+ * Privacy level handling for SIP Protocol
+ *
+ * Provides authenticated encryption using XChaCha20-Poly1305 for viewing key
+ * selective disclosure. This allows transaction details to be encrypted and
+ * later revealed to auditors holding the viewing key.
+ *
+ * ## Security Properties
+ * - **Confidentiality**: Only viewing key holders can decrypt
+ * - **Integrity**: Authentication tag prevents tampering
+ * - **Nonce-misuse resistance**: XChaCha20 uses 24-byte nonces
+ */
+
+/**
+ * Privacy configuration for an intent
+ */
+interface PrivacyConfig {
+    /** The privacy level */
+    level: PrivacyLevel;
+    /** Viewing key (required for compliant mode) */
+    viewingKey?: ViewingKey;
+    /** Whether to use stealth addresses */
+    useStealth: boolean;
+    /** Whether to encrypt transaction data */
+    encryptData: boolean;
+}
+/**
+ * Get privacy configuration for a privacy level
+ */
+declare function getPrivacyConfig(level: PrivacyLevel, viewingKey?: ViewingKey): PrivacyConfig;
+/**
+ * Generate a new viewing key
+ */
+declare function generateViewingKey(path?: string): ViewingKey;
+/**
+ * Derive a child viewing key using BIP32-style hierarchical derivation
+ *
+ * Uses HMAC-SHA512 for proper key derivation:
+ * - childKey = HMAC-SHA512(masterKey, childPath)
+ * - Takes first 32 bytes as the derived key
+ *
+ * This provides:
+ * - Cryptographic standard compliance (similar to BIP32)
+ * - One-way derivation (cannot derive parent from child)
+ * - Non-correlatable keys (different paths produce unrelated keys)
+ */
+declare function deriveViewingKey(masterKey: ViewingKey, childPath: string): ViewingKey;
+/**
+ * Transaction data that can be encrypted for viewing
+ */
+interface TransactionData {
+    sender: string;
+    recipient: string;
+    amount: string;
+    timestamp: number;
+}
+/**
+ * Encrypt transaction data for viewing key holders
+ *
+ * Uses XChaCha20-Poly1305 authenticated encryption with:
+ * - 24-byte random nonce (nonce-misuse resistant)
+ * - HKDF-derived encryption key
+ * - 16-byte authentication tag (included in ciphertext)
+ *
+ * @param data - Transaction data to encrypt
+ * @param viewingKey - Viewing key for encryption
+ * @returns Encrypted transaction with nonce and key hash
+ *
+ * @example
+ * ```typescript
+ * const encrypted = encryptForViewing(
+ *   { sender: '0x...', recipient: '0x...', amount: '100', timestamp: 123 },
+ *   viewingKey
+ * )
+ * // encrypted.ciphertext contains the encrypted data
+ * // encrypted.nonce is needed for decryption
+ * // encrypted.viewingKeyHash identifies which key can decrypt
+ * ```
+ */
+declare function encryptForViewing(data: TransactionData, viewingKey: ViewingKey): EncryptedTransaction;
+/**
+ * Decrypt transaction data with viewing key
+ *
+ * Performs authenticated decryption using XChaCha20-Poly1305.
+ * The authentication tag is verified before returning data.
+ *
+ * @param encrypted - Encrypted transaction data
+ * @param viewingKey - Viewing key for decryption
+ * @returns Decrypted transaction data
+ * @throws {Error} If decryption fails (wrong key, tampered data, etc.)
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const data = decryptWithViewing(encrypted, viewingKey)
+ *   console.log(`Amount: ${data.amount}`)
+ * } catch (e) {
+ *   console.error('Decryption failed - wrong key or tampered data')
+ * }
+ * ```
+ */
+declare function decryptWithViewing(encrypted: EncryptedTransaction, viewingKey: ViewingKey): TransactionData;
+/**
+ * Get human-readable description of privacy level
+ */
+declare function getPrivacyDescription(level: PrivacyLevel): string;
+
+/**
+ * Cryptographic utilities for SIP Protocol
+ *
+ * For ZK proofs, use ProofProvider:
+ * @see ./proofs/interface.ts for the proof provider interface
+ * @see ./proofs/mock.ts for testing
+ * @see ./proofs/noir.ts for production (Noir circuits)
+ *
+ * For Pedersen commitments, use the dedicated commitment module:
+ * @see ./commitment.ts for secure Pedersen commitment implementation
+ */
+
+/**
+ * Create a Pedersen commitment to a value
+ *
+ * @deprecated Use `commit()` from './commitment' for new code.
+ *             This wrapper maintains backward compatibility.
+ *
+ * @param value - The value to commit to
+ * @param blindingFactor - Optional blinding factor (random if not provided)
+ * @returns Commitment object (legacy format)
+ */
+declare function createCommitment(value: bigint, blindingFactor?: Uint8Array): Commitment;
+/**
+ * Verify a Pedersen commitment (requires knowing the value and blinding factor)
+ *
+ * @deprecated Use `verifyOpening()` from './commitment' for new code.
+ */
+declare function verifyCommitment(commitment: Commitment, expectedValue: bigint): boolean;
+/**
+ * Generate a random intent ID
+ */
+declare function generateIntentId(): string;
+/**
+ * Hash data using SHA256
+ */
+declare function hash(data: string | Uint8Array): Hash;
+/**
+ * Generate random bytes
+ */
+declare function generateRandomBytes(length: number): HexString;
+
+/**
+ * Pedersen Commitment Implementation
+ *
+ * Cryptographically secure Pedersen commitments on secp256k1.
+ *
+ * ## Security Properties
+ *
+ * - **Hiding (Computational)**: Cannot determine value from commitment
+ * - **Binding (Computational)**: Cannot open commitment to different value
+ * - **Homomorphic**: C(v1) + C(v2) = C(v1 + v2) when blindings sum
+ *
+ * ## Generator H Construction
+ *
+ * H is constructed using "nothing-up-my-sleeve" (NUMS) method:
+ * - Take a well-known string "SIP-PEDERSEN-GENERATOR-H"
+ * - Hash it to get x-coordinate candidate
+ * - Iterate until we find a valid curve point
+ * - This ensures nobody knows the discrete log of H w.r.t. G
+ *
+ * @see docs/specs/SIP-SPEC.md Section 3.3 - Pedersen Commitment
+ */
+
+/**
+ * A Pedersen commitment with associated blinding factor
+ */
+interface PedersenCommitment {
+    /**
+     * The commitment point C = v*G + r*H (compressed, 33 bytes)
+     */
+    commitment: HexString;
+    /**
+     * The blinding factor r (32 bytes, secret)
+     * Required to open/verify the commitment
+     */
+    blinding: HexString;
+}
+/**
+ * A commitment point without the blinding factor (for public sharing)
+ */
+interface CommitmentPoint {
+    /**
+     * The commitment point (compressed, 33 bytes)
+     */
+    commitment: HexString;
+}
+/**
+ * Create a Pedersen commitment to a value
+ *
+ * C = v*G + r*H
+ *
+ * Where:
+ * - v = value (the amount being committed)
+ * - r = blinding factor (random, keeps value hidden)
+ * - G = base generator
+ * - H = independent generator (NUMS)
+ *
+ * @param value - The value to commit to (must be < curve order)
+ * @param blinding - Optional blinding factor (random 32 bytes if not provided)
+ * @returns The commitment and blinding factor
+ *
+ * @example
+ * ```typescript
+ * // Create a commitment to 100 tokens
+ * const { commitment, blinding } = commit(100n)
+ *
+ * // Later, prove the commitment contains 100
+ * const valid = verifyOpening(commitment, 100n, blinding)
+ * ```
+ */
+declare function commit(value: bigint, blinding?: Uint8Array): PedersenCommitment;
+/**
+ * Verify that a commitment opens to a specific value
+ *
+ * Recomputes C' = v*G + r*H and checks if C' == C
+ *
+ * @param commitment - The commitment point to verify
+ * @param value - The claimed value
+ * @param blinding - The blinding factor used
+ * @returns true if the commitment opens correctly
+ */
+declare function verifyOpening(commitment: HexString, value: bigint, blinding: HexString): boolean;
+/**
+ * Create a commitment to zero with a specific blinding factor
+ *
+ * C = 0*G + r*H = r*H
+ *
+ * Useful for creating balance proofs.
+ *
+ * @param blinding - The blinding factor
+ * @returns Commitment to zero
+ */
+declare function commitZero(blinding: Uint8Array): PedersenCommitment;
+/**
+ * Add two commitments homomorphically
+ *
+ * C1 + C2 = (v1*G + r1*H) + (v2*G + r2*H) = (v1+v2)*G + (r1+r2)*H
+ *
+ * Note: The blinding factors also add. If you need to verify the sum,
+ * you must also sum the blinding factors.
+ *
+ * @param c1 - First commitment point
+ * @param c2 - Second commitment point
+ * @returns Sum of commitments
+ * @throws {ValidationError} If commitments are invalid hex strings
+ */
+declare function addCommitments(c1: HexString, c2: HexString): CommitmentPoint;
+/**
+ * Subtract two commitments homomorphically
+ *
+ * C1 - C2 = (v1-v2)*G + (r1-r2)*H
+ *
+ * @param c1 - First commitment point
+ * @param c2 - Second commitment point (to subtract)
+ * @returns Difference of commitments
+ * @throws {ValidationError} If commitments are invalid
+ */
+declare function subtractCommitments(c1: HexString, c2: HexString): CommitmentPoint;
+/**
+ * Add blinding factors (for use with homomorphic addition)
+ *
+ * When you add commitments, the result commits to (v1+v2) with
+ * blinding (r1+r2). Use this to compute the combined blinding.
+ *
+ * @param b1 - First blinding factor
+ * @param b2 - Second blinding factor
+ * @returns Sum of blindings (mod curve order)
+ */
+declare function addBlindings(b1: HexString, b2: HexString): HexString;
+/**
+ * Subtract blinding factors (for use with homomorphic subtraction)
+ *
+ * @param b1 - First blinding factor
+ * @param b2 - Second blinding factor (to subtract)
+ * @returns Difference of blindings (mod curve order)
+ */
+declare function subtractBlindings(b1: HexString, b2: HexString): HexString;
+/**
+ * Get the generators for ZK proof integration
+ *
+ * Returns the G and H points for use in Noir circuits.
+ */
+declare function getGenerators(): {
+    G: {
+        x: HexString;
+        y: HexString;
+    };
+    H: {
+        x: HexString;
+        y: HexString;
+    };
+};
+/**
+ * Generate a random blinding factor
+ */
+declare function generateBlinding(): HexString;
+
+/**
+ * Input validation utilities for SIP Protocol SDK
+ *
+ * Provides comprehensive validation for all public API inputs.
+ */
+
+/**
+ * Check if a string is a valid chain ID
+ */
+declare function isValidChainId(chain: string): chain is ChainId;
+/**
+ * Check if a value is a valid privacy level
+ */
+declare function isValidPrivacyLevel(level: unknown): level is PrivacyLevel;
+/**
+ * Check if a string is valid hex format (with 0x prefix)
+ */
+declare function isValidHex(value: string): value is HexString;
+/**
+ * Check if a hex string has a specific byte length
+ */
+declare function isValidHexLength(value: string, byteLength: number): boolean;
+/**
+ * Check if an amount is valid (positive bigint)
+ */
+declare function isValidAmount(value: unknown): value is bigint;
+/**
+ * Check if an amount is non-negative
+ */
+declare function isNonNegativeAmount(value: unknown): value is bigint;
+/**
+ * Check if slippage is in valid range (0 to 1, exclusive of 1)
+ */
+declare function isValidSlippage(value: number): boolean;
+/**
+ * Check if a string is a valid stealth meta-address
+ */
+declare function isValidStealthMetaAddress(addr: string): boolean;
+/**
+ * Check if a public key is valid (compressed secp256k1: 33 bytes)
+ */
+declare function isValidCompressedPublicKey(key: string): boolean;
+/**
+ * Check if a private key is valid (32 bytes)
+ */
+declare function isValidPrivateKey(key: string): boolean;
+/**
+ * Validate an asset object
+ */
+declare function validateAsset(asset: unknown, field: string): asserts asset is Asset;
+/**
+ * Validate intent input
+ */
+declare function validateIntentInput(input: unknown, field?: string): asserts input is IntentInput;
+/**
+ * Validate intent output
+ */
+declare function validateIntentOutput(output: unknown, field?: string): asserts output is IntentOutput;
+/**
+ * Validate CreateIntentParams
+ */
+declare function validateCreateIntentParams(params: unknown): asserts params is CreateIntentParams;
+/**
+ * Validate a viewing key (32-byte hex string)
+ */
+declare function validateViewingKey(key: unknown, field?: string): void;
+/**
+ * Check if a bigint is a valid scalar (1 <= x < n)
+ */
+declare function isValidScalar(value: bigint): boolean;
+/**
+ * Validate a scalar value
+ */
+declare function validateScalar(value: unknown, field: string): asserts value is bigint;
+
+/**
+ * NEAR 1Click API HTTP Client
+ *
+ * Provides typed access to the NEAR Intents 1Click API for cross-chain swaps.
+ *
+ * @see https://docs.near-intents.org/near-intents/integration/distribution-channels/1click-api
+ */
+
+/**
+ * HTTP client for NEAR 1Click API
+ *
+ * @example
+ * ```typescript
+ * const client = new OneClickClient({
+ *   jwtToken: process.env.NEAR_INTENTS_JWT,
+ * })
+ *
+ * // Get available tokens
+ * const tokens = await client.getTokens()
+ *
+ * // Request a quote
+ * const quote = await client.quote({
+ *   swapType: OneClickSwapType.EXACT_INPUT,
+ *   originAsset: 'near:mainnet:wrap.near',
+ *   destinationAsset: 'eth:1:native',
+ *   amount: '1000000000000000000000000',
+ *   refundTo: 'user.near',
+ *   recipient: '0x742d35Cc...',
+ *   depositType: 'near',
+ *   refundType: 'near',
+ *   recipientType: 'eth',
+ * })
+ *
+ * // Check status
+ * const status = await client.getStatus(quote.depositAddress)
+ * ```
+ */
+declare class OneClickClient {
+    private readonly baseUrl;
+    private readonly jwtToken?;
+    private readonly timeout;
+    private readonly fetchFn;
+    constructor(config?: OneClickConfig);
+    /**
+     * Get all supported tokens
+     *
+     * @returns Array of supported tokens with metadata
+     */
+    getTokens(): Promise<OneClickToken[]>;
+    /**
+     * Request a swap quote
+     *
+     * @param request - Quote request parameters
+     * @returns Quote response with deposit address and amounts
+     * @throws {NetworkError} On API errors
+     * @throws {ValidationError} On invalid parameters
+     */
+    quote(request: OneClickQuoteRequest): Promise<OneClickQuoteResponse>;
+    /**
+     * Request a dry quote (preview without deposit address)
+     *
+     * Useful for UI price estimates without committing to a swap.
+     *
+     * @param request - Quote request parameters (dry flag set automatically)
+     * @returns Quote preview without deposit address
+     */
+    dryQuote(request: Omit<OneClickQuoteRequest, 'dry'>): Promise<OneClickQuoteResponse>;
+    /**
+     * Submit deposit transaction notification
+     *
+     * Call this after depositing to the depositAddress to speed up detection.
+     *
+     * @param deposit - Deposit submission details
+     * @returns Updated quote response
+     */
+    submitDeposit(deposit: OneClickDepositSubmit): Promise<OneClickQuoteResponse>;
+    /**
+     * Get swap status
+     *
+     * @param depositAddress - Deposit address from quote
+     * @param depositMemo - Optional memo for memo-based deposits
+     * @returns Current swap status
+     */
+    getStatus(depositAddress: string, depositMemo?: string): Promise<OneClickStatusResponse>;
+    /**
+     * Poll status until terminal state or timeout
+     *
+     * @param depositAddress - Deposit address from quote
+     * @param options - Polling options
+     * @returns Final status when terminal state reached
+     */
+    waitForStatus(depositAddress: string, options?: {
+        /** Polling interval in ms (default: 3000) */
+        interval?: number;
+        /** Maximum wait time in ms (default: 300000 = 5 minutes) */
+        timeout?: number;
+        /** Callback on each status check */
+        onStatus?: (status: OneClickStatusResponse) => void;
+    }): Promise<OneClickStatusResponse>;
+    /**
+     * Get withdrawals for ANY_INPUT deposits
+     *
+     * @param depositAddress - Deposit address
+     * @param depositMemo - Optional deposit memo
+     * @param options - Pagination options
+     * @returns Array of withdrawals
+     */
+    getWithdrawals(depositAddress: string, depositMemo?: string, options?: {
+        timestampFrom?: string;
+        page?: number;
+        limit?: number;
+        sortOrder?: 'asc' | 'desc';
+    }): Promise<OneClickWithdrawal[]>;
+    private validateQuoteRequest;
+    private get;
+    private post;
+    private request;
+    private parseError;
+    private mapErrorCode;
+    private delay;
+}
+
+/**
+ * NEAR Intents Adapter for SIP Protocol
+ *
+ * Bridges SIP SDK with NEAR 1Click API, providing privacy-preserving
+ * cross-chain swaps using stealth addresses.
+ */
+
+/**
+ * Swap request parameters (simplified interface for adapter)
+ */
+interface SwapRequest {
+    /** Unique request ID */
+    requestId: string;
+    /** Privacy level for the swap */
+    privacyLevel: PrivacyLevel;
+    /** Input asset */
+    inputAsset: Asset;
+    /** Input amount in smallest units */
+    inputAmount: bigint;
+    /** Output asset */
+    outputAsset: Asset;
+    /** Minimum output amount */
+    minOutputAmount?: bigint;
+}
+/**
+ * Result of preparing a swap with SIP privacy
+ */
+interface PreparedSwap {
+    /** Original swap request */
+    request: SwapRequest;
+    /** 1Click quote request */
+    quoteRequest: OneClickQuoteRequest;
+    /** Generated stealth address (for shielded/compliant modes) */
+    stealthAddress?: {
+        address: HexString;
+        ephemeralPublicKey: HexString;
+        viewTag: number;
+    };
+    /** Shared secret for stealth address derivation (keep private!) */
+    sharedSecret?: HexString;
+}
+/**
+ * Result of executing a swap
+ */
+interface SwapResult {
+    /** Request ID */
+    requestId: string;
+    /** 1Click quote ID */
+    quoteId: string;
+    /** Deposit address for input tokens */
+    depositAddress: string;
+    /** Expected input amount */
+    amountIn: string;
+    /** Expected output amount */
+    amountOut: string;
+    /** Current status */
+    status: OneClickSwapStatus;
+    /** Deposit transaction hash (after deposit) */
+    depositTxHash?: string;
+    /** Settlement transaction hash (after success) */
+    settlementTxHash?: string;
+    /** Stealth address for recipient (if privacy mode) */
+    stealthRecipient?: string;
+    /** Ephemeral public key (for recipient to derive stealth key) */
+    ephemeralPublicKey?: string;
+}
+/**
+ * Configuration for NEAR Intents adapter
+ */
+interface NEARIntentsAdapterConfig {
+    /** OneClickClient instance or config */
+    client?: OneClickClient;
+    /** Base URL for 1Click API */
+    baseUrl?: string;
+    /** JWT token for authentication */
+    jwtToken?: string;
+    /** Default slippage tolerance in basis points (100 = 1%) */
+    defaultSlippage?: number;
+    /** Default deadline offset in seconds */
+    defaultDeadlineOffset?: number;
+    /** Custom asset mappings (merged with defaults) */
+    assetMappings?: Record<string, DefuseAssetId>;
+}
+/**
+ * NEAR Intents Adapter
+ *
+ * Provides privacy-preserving cross-chain swaps via NEAR 1Click API.
+ *
+ * @example
+ * ```typescript
+ * const adapter = new NEARIntentsAdapter({
+ *   jwtToken: process.env.NEAR_INTENTS_JWT,
+ * })
+ *
+ * // Or with custom asset mappings (e.g., testnet)
+ * const testnetAdapter = new NEARIntentsAdapter({
+ *   jwtToken: process.env.NEAR_INTENTS_JWT,
+ *   assetMappings: {
+ *     'near:testUSDC': 'near:testnet:usdc.test',
+ *   },
+ * })
+ *
+ * // Prepare a swap with stealth recipient
+ * const prepared = await adapter.prepareSwap(intent, recipientMetaAddress)
+ *
+ * // Get quote
+ * const quote = await adapter.getQuote(prepared)
+ *
+ * // Execute (after depositing to depositAddress)
+ * const result = await adapter.trackSwap(quote.depositAddress)
+ * ```
+ */
+declare class NEARIntentsAdapter {
+    private readonly client;
+    private readonly defaultSlippage;
+    private readonly defaultDeadlineOffset;
+    private readonly assetMappings;
+    constructor(config?: NEARIntentsAdapterConfig);
+    /**
+     * Get the underlying OneClick client
+     */
+    getClient(): OneClickClient;
+    /**
+     * Prepare a swap request
+     *
+     * For shielded/compliant modes, generates a stealth address for the recipient.
+     *
+     * @param request - Swap request parameters
+     * @param recipientMetaAddress - Recipient's stealth meta-address (for privacy modes)
+     * @param senderAddress - Sender's address for refunds
+     * @returns Prepared swap with quote request
+     */
+    prepareSwap(request: SwapRequest, recipientMetaAddress?: StealthMetaAddress | string, senderAddress?: string): Promise<PreparedSwap>;
+    /**
+     * Get a quote for a prepared swap
+     *
+     * @param prepared - Prepared swap from prepareSwap()
+     * @returns Quote response with deposit address
+     */
+    getQuote(prepared: PreparedSwap): Promise<OneClickQuoteResponse>;
+    /**
+     * Get a dry quote (preview without deposit address)
+     *
+     * @param prepared - Prepared swap
+     * @returns Quote preview
+     */
+    getDryQuote(prepared: PreparedSwap): Promise<OneClickQuoteResponse>;
+    /**
+     * Notify 1Click of deposit transaction
+     *
+     * @param depositAddress - Deposit address from quote
+     * @param txHash - Deposit transaction hash
+     * @param nearAccount - NEAR account (if depositing from NEAR)
+     */
+    notifyDeposit(depositAddress: string, txHash: string, nearAccount?: string): Promise<void>;
+    /**
+     * Get current swap status
+     *
+     * @param depositAddress - Deposit address from quote
+     * @returns Current status
+     */
+    getStatus(depositAddress: string): Promise<OneClickStatusResponse>;
+    /**
+     * Wait for swap to complete
+     *
+     * @param depositAddress - Deposit address from quote
+     * @param options - Polling options
+     * @returns Final status
+     */
+    waitForCompletion(depositAddress: string, options?: {
+        interval?: number;
+        timeout?: number;
+        onStatus?: (status: OneClickStatusResponse) => void;
+    }): Promise<OneClickStatusResponse>;
+    /**
+     * Execute a full swap flow
+     *
+     * This is a convenience method that:
+     * 1. Prepares the swap with stealth address
+     * 2. Gets a quote
+     * 3. Returns all info needed for the user to deposit
+     *
+     * @param request - Swap request parameters
+     * @param recipientMetaAddress - Recipient's stealth meta-address
+     * @param senderAddress - Sender's address for refunds
+     * @returns Swap result with deposit instructions
+     */
+    initiateSwap(request: SwapRequest, recipientMetaAddress?: StealthMetaAddress | string, senderAddress?: string): Promise<SwapResult>;
+    /**
+     * Convert SIP asset to Defuse asset identifier
+     */
+    mapAsset(chain: ChainId, symbol: string): DefuseAssetId;
+    /**
+     * Convert SIP chain ID to 1Click chain type
+     */
+    mapChainType(chain: ChainId): ChainType;
+    private validateRequest;
+    private buildQuoteRequest;
+}
+/**
+ * Create a new NEAR Intents adapter
+ */
+declare function createNEARIntentsAdapter(config?: NEARIntentsAdapterConfig): NEARIntentsAdapter;
+
+/**
+ * Mock Solver Implementation
+ *
+ * Reference implementation of the SIPSolver interface for testing
+ * and development. Demonstrates how solvers should interact with
+ * shielded intents while preserving privacy.
+ */
+
+/**
+ * Configuration for MockSolver
+ */
+interface MockSolverConfig {
+    /** Solver name */
+    name?: string;
+    /** Supported chains */
+    supportedChains?: ChainId[];
+    /** Base fee percentage (0-1) */
+    feePercent?: number;
+    /** Simulated execution time in ms */
+    executionDelay?: number;
+    /** Failure rate for testing (0-1) */
+    failureRate?: number;
+    /** Quote spread percentage (0-1) */
+    spreadPercent?: number;
+}
+/**
+ * Mock implementation of SIPSolver for testing
+ *
+ * This solver demonstrates the privacy-preserving interaction pattern:
+ * - Only accesses visible fields of intents
+ * - Cannot see sender identity or exact input amounts
+ * - Generates valid quotes based on output requirements
+ *
+ * @example
+ * ```typescript
+ * const solver = new MockSolver({ name: 'Test Solver' })
+ *
+ * // Check if solver can handle intent
+ * if (await solver.canHandle(visibleIntent)) {
+ *   const quote = await solver.generateQuote(visibleIntent)
+ *   if (quote) {
+ *     const result = await solver.fulfill(intent, quote)
+ *   }
+ * }
+ * ```
+ */
+declare class MockSolver implements SIPSolver {
+    readonly info: Solver;
+    readonly capabilities: SolverCapabilities;
+    private readonly feePercent;
+    private readonly executionDelay;
+    private readonly failureRate;
+    private readonly spreadPercent;
+    private readonly pendingFulfillments;
+    constructor(config?: MockSolverConfig);
+    /**
+     * Check if this solver can handle the given intent
+     *
+     * Privacy-preserving: Only accesses visible fields
+     */
+    canHandle(intent: SolverVisibleIntent): Promise<boolean>;
+    /**
+     * Generate a quote for the intent
+     *
+     * Privacy-preserving:
+     * - Does NOT access sender identity (only senderCommitment visible)
+     * - Does NOT know exact input amount (only inputCommitment visible)
+     * - Quotes based solely on output requirements
+     */
+    generateQuote(intent: SolverVisibleIntent): Promise<SolverQuote | null>;
+    /**
+     * Fulfill an intent with the given quote
+     *
+     * In production, this would:
+     * 1. Lock collateral
+     * 2. Execute the swap on destination chain
+     * 3. Generate fulfillment proof
+     * 4. Release collateral after verification
+     *
+     * Privacy preserved:
+     * - Funds go to stealth address (unlinkable)
+     * - Solver never learns recipient's real identity
+     */
+    fulfill(intent: ShieldedIntent, quote: SolverQuote): Promise<FulfillmentResult>;
+    /**
+     * Cancel a pending fulfillment
+     */
+    cancel(intentId: string): Promise<boolean>;
+    /**
+     * Get fulfillment status
+     */
+    getStatus(intentId: string): Promise<FulfillmentStatus | null>;
+    /**
+     * Reset solver state (for testing)
+     */
+    reset(): void;
+    private delay;
+}
+/**
+ * Create a mock solver with default configuration
+ */
+declare function createMockSolver(config?: MockSolverConfig): MockSolver;
+
+/**
+ * Zcash RPC Client
+ *
+ * HTTP client for interacting with zcashd node via JSON-RPC.
+ * Supports both mainnet and testnet with automatic retry logic.
+ *
+ * @example
+ * ```typescript
+ * const client = new ZcashRPCClient({
+ *   username: 'rpcuser',
+ *   password: 'rpcpassword',
+ *   testnet: true,
+ * })
+ *
+ * // Create new account and get address
+ * const { account } = await client.createAccount()
+ * const { address } = await client.getAddressForAccount(account)
+ *
+ * // Send shielded transaction
+ * const opId = await client.sendShielded({
+ *   fromAddress: address,
+ *   recipients: [{ address: recipientAddr, amount: 0.1 }],
+ * })
+ *
+ * // Wait for completion
+ * const result = await client.waitForOperation(opId)
+ * ```
+ */
+
+/**
+ * Error thrown when Zcash RPC call fails
+ */
+declare class ZcashRPCError extends Error {
+    readonly code: number;
+    readonly data?: unknown | undefined;
+    constructor(message: string, code: number, data?: unknown | undefined);
+    /**
+     * Check if error is due to insufficient funds
+     */
+    isInsufficientFunds(): boolean;
+    /**
+     * Check if error is due to invalid address
+     */
+    isInvalidAddress(): boolean;
+    /**
+     * Check if error is due to wallet being locked
+     */
+    isWalletLocked(): boolean;
+}
+/**
+ * Zcash RPC Client
+ *
+ * Provides type-safe access to zcashd JSON-RPC API with automatic
+ * retry logic and proper error handling.
+ *
+ * @security IMPORTANT: Always use HTTPS in production environments.
+ * This client uses HTTP Basic Authentication which transmits credentials
+ * in base64-encoded cleartext. Without TLS/HTTPS, credentials and all
+ * RPC data are vulnerable to network sniffing and man-in-the-middle attacks.
+ *
+ * Production configuration should use:
+ * - HTTPS endpoint (e.g., https://your-node.com:8232)
+ * - Valid TLS certificates
+ * - Secure credential storage
+ * - Network-level access controls
+ */
+declare class ZcashRPCClient {
+    private readonly config;
+    private readonly baseUrl;
+    private requestId;
+    constructor(config: ZcashConfig);
+    /**
+     * Validate a Zcash address
+     *
+     * @param address - Address to validate (t-addr, z-addr, or unified)
+     * @returns Address validation info
+     */
+    validateAddress(address: string): Promise<ZcashAddressInfo>;
+    /**
+     * Create a new HD account
+     *
+     * @returns New account number
+     */
+    createAccount(): Promise<ZcashNewAccount>;
+    /**
+     * Get or derive an address for an account
+     *
+     * @param account - Account number
+     * @param receiverTypes - Optional receiver types (default: best shielded + p2pkh)
+     * @param diversifierIndex - Optional specific diversifier index
+     * @returns Account address info
+     */
+    getAddressForAccount(account: number, receiverTypes?: ZcashReceiverType[], diversifierIndex?: number): Promise<ZcashAccountAddress>;
+    /**
+     * Generate a new shielded address (DEPRECATED)
+     *
+     * @deprecated Use createAccount() and getAddressForAccount() instead
+     * @param type - Address type ('sapling' or 'sprout')
+     * @returns New shielded address
+     */
+    generateShieldedAddress(type?: 'sapling' | 'sprout'): Promise<string>;
+    /**
+     * List all shielded addresses in the wallet
+     *
+     * @returns Array of shielded addresses
+     */
+    listAddresses(): Promise<string[]>;
+    /**
+     * Get balance for an account
+     *
+     * @param account - Account number
+     * @param minConf - Minimum confirmations (default: 1)
+     * @returns Account balance by pool
+     */
+    getAccountBalance(account: number, minConf?: number): Promise<ZcashAccountBalance>;
+    /**
+     * Get balance for an address (DEPRECATED)
+     *
+     * @deprecated Use getAccountBalance() instead
+     * @param address - Address to check
+     * @param minConf - Minimum confirmations
+     * @returns Balance in ZEC
+     */
+    getBalance(address: string, minConf?: number): Promise<number>;
+    /**
+     * Get total wallet balance
+     *
+     * @param minConf - Minimum confirmations
+     * @returns Total balances (transparent, private, total)
+     */
+    getTotalBalance(minConf?: number): Promise<{
+        transparent: string;
+        private: string;
+        total: string;
+    }>;
+    /**
+     * List unspent shielded notes
+     *
+     * @param minConf - Minimum confirmations (default: 1)
+     * @param maxConf - Maximum confirmations (default: 9999999)
+     * @param includeWatchonly - Include watchonly addresses
+     * @param addresses - Filter by addresses
+     * @returns Array of unspent notes
+     */
+    listUnspent(minConf?: number, maxConf?: number, includeWatchonly?: boolean, addresses?: string[]): Promise<ZcashUnspentNote[]>;
+    /**
+     * Send a shielded transaction
+     *
+     * @param params - Send parameters
+     * @returns Operation ID for tracking
+     */
+    sendShielded(params: ZcashShieldedSendParams): Promise<string>;
+    /**
+     * Shield coinbase UTXOs to a shielded address
+     *
+     * @param fromAddress - Transparent address with coinbase
+     * @param toAddress - Shielded destination
+     * @param fee - Optional fee
+     * @param limit - Max UTXOs to shield
+     * @returns Operation ID
+     */
+    shieldCoinbase(fromAddress: string, toAddress: string, fee?: number, limit?: number): Promise<{
+        operationid: string;
+        shieldingUTXOs: number;
+        shieldingValue: number;
+    }>;
+    /**
+     * Get status of async operations
+     *
+     * @param operationIds - Optional specific operation IDs
+     * @returns Array of operation statuses
+     */
+    getOperationStatus(operationIds?: string[]): Promise<ZcashOperation[]>;
+    /**
+     * Get and remove completed operation results
+     *
+     * @param operationIds - Optional specific operation IDs
+     * @returns Array of operation results
+     */
+    getOperationResult(operationIds?: string[]): Promise<ZcashOperation[]>;
+    /**
+     * List all operation IDs
+     *
+     * @param status - Optional filter by status
+     * @returns Array of operation IDs
+     */
+    listOperationIds(status?: string): Promise<string[]>;
+    /**
+     * Wait for an operation to complete
+     *
+     * @param operationId - Operation ID to wait for
+     * @param pollInterval - Poll interval in ms (default: 1000)
+     * @param timeout - Max wait time in ms (default: 300000 = 5 min)
+     * @returns Completed operation
+     * @throws ZcashRPCError if operation fails or times out
+     */
+    waitForOperation(operationId: string, pollInterval?: number, timeout?: number): Promise<ZcashOperation>;
+    /**
+     * Get current block count
+     *
+     * @returns Current block height
+     */
+    getBlockCount(): Promise<number>;
+    /**
+     * Get block hash at height
+     *
+     * @param height - Block height
+     * @returns Block hash
+     */
+    getBlockHash(height: number): Promise<string>;
+    /**
+     * Get block header
+     *
+     * @param hashOrHeight - Block hash or height
+     * @returns Block header
+     */
+    getBlockHeader(hashOrHeight: string | number): Promise<ZcashBlockHeader>;
+    /**
+     * Get full block data
+     *
+     * @param hashOrHeight - Block hash or height
+     * @returns Block data
+     */
+    getBlock(hashOrHeight: string | number): Promise<ZcashBlock>;
+    /**
+     * Get blockchain info
+     *
+     * @returns Blockchain information
+     */
+    getBlockchainInfo(): Promise<ZcashBlockchainInfo>;
+    /**
+     * Get network info
+     *
+     * @returns Network information
+     */
+    getNetworkInfo(): Promise<ZcashNetworkInfo>;
+    /**
+     * Export viewing key for address
+     *
+     * @param address - Shielded address
+     * @returns Viewing key
+     */
+    exportViewingKey(address: string): Promise<string>;
+    /**
+     * Import viewing key
+     *
+     * @param viewingKey - The viewing key to import
+     * @param rescan - Rescan the wallet (default: whenkeyisnew)
+     * @param startHeight - Start height for rescan
+     */
+    importViewingKey(viewingKey: string, rescan?: 'yes' | 'no' | 'whenkeyisnew', startHeight?: number): Promise<void>;
+    /**
+     * Make a raw RPC call
+     *
+     * @param method - RPC method name
+     * @param params - Method parameters
+     * @returns RPC response result
+     */
+    call<T>(method: string, params?: unknown[]): Promise<T>;
+    /**
+     * Execute HTTP request to RPC endpoint
+     */
+    private executeRequest;
+    private delay;
+    /**
+     * Check if client is configured for testnet
+     */
+    get isTestnet(): boolean;
+    /**
+     * Get the RPC endpoint URL
+     */
+    get endpoint(): string;
+}
+/**
+ * Create a Zcash RPC client
+ *
+ * @param config - Client configuration
+ * @returns ZcashRPCClient instance
+ *
+ * @security IMPORTANT: Always use HTTPS in production environments.
+ * HTTP Basic Auth transmits credentials in cleartext without TLS/HTTPS.
+ * Configure your zcashd node with TLS certificates and use https:// URLs.
+ *
+ * @example
+ * ```typescript
+ * // ✅ Production (HTTPS)
+ * const client = createZcashClient({
+ *   host: 'https://your-node.com',
+ *   port: 8232,
+ *   username: process.env.ZCASH_RPC_USER,
+ *   password: process.env.ZCASH_RPC_PASS,
+ * })
+ *
+ * // ⚠️ Development only (HTTP)
+ * const testClient = createZcashClient({
+ *   host: '127.0.0.1',
+ *   port: 18232,
+ *   username: 'test',
+ *   password: 'test',
+ *   testnet: true,
+ * })
+ * ```
+ */
+declare function createZcashClient(config: ZcashConfig): ZcashRPCClient;
+
+/**
+ * Zcash Shielded Transaction Service
+ *
+ * High-level service for managing Zcash shielded transactions,
+ * providing integration with SIP Protocol privacy levels.
+ *
+ * @example
+ * ```typescript
+ * const service = new ZcashShieldedService({
+ *   rpcConfig: { username: 'user', password: 'pass', testnet: true },
+ * })
+ *
+ * // Initialize and create account
+ * await service.initialize()
+ *
+ * // Send shielded transaction
+ * const result = await service.sendShielded({
+ *   to: recipientAddress,
+ *   amount: 1.5,
+ *   memo: 'Payment for services',
+ *   privacyLevel: PrivacyLevel.SHIELDED,
+ * })
+ *
+ * // Check incoming transactions
+ * const received = await service.getReceivedNotes()
+ * ```
+ */
+
+/**
+ * Configuration for ZcashShieldedService
+ */
+interface ZcashShieldedServiceConfig {
+    /** RPC client configuration */
+    rpcConfig: ZcashConfig;
+    /** Default account to use (default: 0) */
+    defaultAccount?: number;
+    /** Default minimum confirmations (default: 1) */
+    defaultMinConf?: number;
+    /** Poll interval for operations in ms (default: 1000) */
+    operationPollInterval?: number;
+    /** Operation timeout in ms (default: 300000 = 5 min) */
+    operationTimeout?: number;
+}
+/**
+ * Shielded send parameters
+ */
+interface ShieldedSendParams {
+    /** Recipient address (shielded or unified) */
+    to: string;
+    /** Amount in ZEC */
+    amount: number;
+    /** Optional memo (max 512 bytes) */
+    memo?: string;
+    /** SIP privacy level */
+    privacyLevel?: PrivacyLevel;
+    /** Source address (uses default if not specified) */
+    from?: string;
+    /** Minimum confirmations for inputs */
+    minConf?: number;
+    /** Custom fee (uses ZIP-317 default if not specified) */
+    fee?: number;
+}
+/**
+ * Result of a shielded send operation
+ */
+interface ShieldedSendResult {
+    /** Transaction ID */
+    txid: string;
+    /** Operation ID (for tracking) */
+    operationId: string;
+    /** Amount sent (excluding fee) */
+    amount: number;
+    /** Fee paid */
+    fee: number;
+    /** Recipient address */
+    to: string;
+    /** Sender address */
+    from: string;
+    /** Timestamp */
+    timestamp: number;
+}
+/**
+ * Received note information
+ */
+interface ReceivedNote {
+    /** Transaction ID */
+    txid: string;
+    /** Amount received */
+    amount: number;
+    /** Memo content (if any) */
+    memo?: string;
+    /** Number of confirmations */
+    confirmations: number;
+    /** Whether spendable */
+    spendable: boolean;
+    /** Pool type (sapling/orchard) */
+    pool: 'sapling' | 'orchard';
+    /** Receiving address */
+    address: string;
+    /** Whether this is change */
+    isChange: boolean;
+}
+/**
+ * Shielded balance summary
+ */
+interface ShieldedBalance {
+    /** Total confirmed balance in ZEC */
+    confirmed: number;
+    /** Total unconfirmed balance in ZEC */
+    unconfirmed: number;
+    /** Balance by pool */
+    pools: {
+        transparent: number;
+        sapling: number;
+        orchard: number;
+    };
+    /** Number of spendable notes */
+    spendableNotes: number;
+}
+/**
+ * Viewing key export result
+ */
+interface ExportedViewingKey {
+    /** The viewing key */
+    key: string;
+    /** Associated address */
+    address: string;
+    /** Account number */
+    account: number;
+    /** Creation timestamp */
+    exportedAt: number;
+}
+/**
+ * Zcash Shielded Transaction Service
+ *
+ * Provides high-level operations for Zcash shielded transactions
+ * with SIP Protocol integration.
+ */
+declare class ZcashShieldedService {
+    private readonly client;
+    private readonly config;
+    private initialized;
+    private accountAddress;
+    private account;
+    constructor(config: ZcashShieldedServiceConfig);
+    /**
+     * Initialize the service
+     *
+     * Creates an account if needed and retrieves the default address.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Ensure the service is initialized
+     */
+    private ensureInitialized;
+    /**
+     * Get the default shielded address
+     */
+    getAddress(): string;
+    /**
+     * Generate a new diversified address for the account
+     *
+     * Each address is unlinkable but controlled by the same account.
+     */
+    generateNewAddress(): Promise<string>;
+    /**
+     * Validate an address
+     */
+    validateAddress(address: string): Promise<ZcashAddressInfo>;
+    /**
+     * Check if an address is a shielded address
+     */
+    isShieldedAddress(address: string): Promise<boolean>;
+    /**
+     * Get shielded balance summary
+     */
+    getBalance(minConf?: number): Promise<ShieldedBalance>;
+    /**
+     * Send a shielded transaction
+     *
+     * @param params - Send parameters
+     * @returns Send result with txid
+     */
+    sendShielded(params: ShieldedSendParams): Promise<ShieldedSendResult>;
+    /**
+     * Send shielded transaction with SIP integration
+     *
+     * Higher-level method that handles privacy level mapping.
+     */
+    sendWithPrivacy(to: string, amount: number, privacyLevel: PrivacyLevel, memo?: string): Promise<ShieldedSendResult>;
+    /**
+     * Get received notes (incoming shielded transactions)
+     *
+     * @param minConf - Minimum confirmations
+     * @param onlySpendable - Only return spendable notes
+     */
+    getReceivedNotes(minConf?: number, onlySpendable?: boolean): Promise<ReceivedNote[]>;
+    /**
+     * Get pending (unconfirmed) incoming transactions
+     */
+    getPendingNotes(): Promise<ReceivedNote[]>;
+    /**
+     * Wait for incoming note with specific criteria
+     *
+     * @param predicate - Function to match the expected note
+     * @param timeout - Timeout in ms
+     * @param pollInterval - Poll interval in ms
+     */
+    waitForNote(predicate: (note: ReceivedNote) => boolean, timeout?: number, pollInterval?: number): Promise<ReceivedNote>;
+    /**
+     * Export viewing key for an address
+     *
+     * The viewing key allows monitoring incoming transactions
+     * without spending capability.
+     */
+    exportViewingKey(address?: string): Promise<ExportedViewingKey>;
+    /**
+     * Import viewing key for monitoring
+     *
+     * Allows monitoring transactions to an address without spending.
+     */
+    importViewingKey(viewingKey: string, rescan?: 'yes' | 'no' | 'whenkeyisnew', startHeight?: number): Promise<void>;
+    /**
+     * Export viewing key for compliance/audit
+     *
+     * Specifically for SIP COMPLIANT privacy level.
+     */
+    exportForCompliance(): Promise<{
+        viewingKey: ExportedViewingKey;
+        privacyLevel: PrivacyLevel;
+        disclaimer: string;
+    }>;
+    /**
+     * Get status of an operation
+     */
+    getOperationStatus(operationId: string): Promise<ZcashOperation | null>;
+    /**
+     * List all pending operations
+     */
+    listPendingOperations(): Promise<ZcashOperation[]>;
+    /**
+     * Get current block height
+     */
+    getBlockHeight(): Promise<number>;
+    /**
+     * Check if connected to testnet
+     */
+    isTestnet(): boolean;
+    /**
+     * Map SIP privacy level to Zcash privacy policy
+     */
+    private mapPrivacyLevelToPolicy;
+    /**
+     * Map RPC unspent note to ReceivedNote
+     */
+    private mapNoteToReceived;
+    private delay;
+    /**
+     * Get underlying RPC client for advanced operations
+     */
+    get rpcClient(): ZcashRPCClient;
+    /**
+     * Get current account number
+     */
+    get currentAccount(): number;
+}
+/**
+ * Create a Zcash shielded service instance
+ */
+declare function createZcashShieldedService(config: ZcashShieldedServiceConfig): ZcashShieldedService;
+
+/**
+ * Base Wallet Adapter
+ *
+ * Abstract base class that provides common functionality for wallet adapters.
+ * Chain-specific implementations extend this class.
+ */
+
+/**
+ * Abstract base class for wallet adapters
+ *
+ * Provides:
+ * - Event emitter infrastructure
+ * - Connection state management
+ * - Common validation logic
+ *
+ * Subclasses must implement:
+ * - connect() / disconnect()
+ * - signMessage() / signTransaction() / signAndSendTransaction()
+ * - getBalance() / getTokenBalance()
+ *
+ * @example
+ * ```typescript
+ * class MyWalletAdapter extends BaseWalletAdapter {
+ *   readonly chain = 'solana'
+ *   readonly name = 'my-wallet'
+ *
+ *   async connect(): Promise<void> {
+ *     // Implementation
+ *   }
+ *
+ *   // ... other required methods
+ * }
+ * ```
+ */
+declare abstract class BaseWalletAdapter implements WalletAdapter$1 {
+    abstract readonly chain: ChainId;
+    abstract readonly name: string;
+    protected _address: string;
+    protected _publicKey: HexString | '';
+    protected _connectionState: WalletConnectionState;
+    get address(): string;
+    get publicKey(): HexString | '';
+    get connectionState(): WalletConnectionState;
+    private eventHandlers;
+    /**
+     * Subscribe to wallet events
+     */
+    on<T extends WalletEventType>(event: T, handler: WalletEventHandler<Extract<WalletEvent, {
+        type: T;
+    }>>): void;
+    /**
+     * Unsubscribe from wallet events
+     */
+    off<T extends WalletEventType>(event: T, handler: WalletEventHandler<Extract<WalletEvent, {
+        type: T;
+    }>>): void;
+    /**
+     * Emit a wallet event
+     */
+    protected emit<T extends WalletEvent>(event: T): void;
+    /**
+     * Emit a connect event
+     */
+    protected emitConnect(address: string, chain: ChainId): void;
+    /**
+     * Emit a disconnect event
+     */
+    protected emitDisconnect(reason?: string): void;
+    /**
+     * Emit an account changed event
+     */
+    protected emitAccountChanged(previousAddress: string, newAddress: string): void;
+    /**
+     * Emit a chain changed event
+     */
+    protected emitChainChanged(previousChain: ChainId, newChain: ChainId): void;
+    /**
+     * Emit an error event
+     */
+    protected emitError(code: string, message: string, details?: unknown): void;
+    /**
+     * Check if wallet is connected
+     */
+    isConnected(): boolean;
+    /**
+     * Ensure wallet is connected, throw if not
+     */
+    protected requireConnected(): void;
+    /**
+     * Set connection state and emit events
+     */
+    protected setConnected(address: string, publicKey: HexString): void;
+    /**
+     * Set disconnected state and emit events
+     */
+    protected setDisconnected(reason?: string): void;
+    /**
+     * Set error state and emit events
+     */
+    protected setError(code: string, message: string, details?: unknown): void;
+    abstract connect(): Promise<void>;
+    abstract disconnect(): Promise<void>;
+    abstract signMessage(message: Uint8Array): Promise<Signature>;
+    abstract signTransaction(tx: UnsignedTransaction): Promise<SignedTransaction>;
+    abstract signAndSendTransaction(tx: UnsignedTransaction): Promise<TransactionReceipt>;
+    abstract getBalance(): Promise<bigint>;
+    abstract getTokenBalance(asset: Asset): Promise<bigint>;
+}
+/**
+ * Mock wallet adapter for testing
+ *
+ * Provides a complete wallet implementation with mock data.
+ * Useful for testing and development without real wallet connections.
+ *
+ * @example
+ * ```typescript
+ * const mockWallet = new MockWalletAdapter({
+ *   chain: 'solana',
+ *   address: 'SoLaNaAddReSS...',
+ *   balance: 1000000000n, // 1 SOL
+ * })
+ *
+ * await mockWallet.connect()
+ * const balance = await mockWallet.getBalance()
+ * ```
+ */
+declare class MockWalletAdapter extends BaseWalletAdapter {
+    readonly chain: ChainId;
+    readonly name: string;
+    private mockAddress;
+    private mockPublicKey;
+    private mockBalance;
+    private mockTokenBalances;
+    private shouldFailConnect;
+    private shouldFailSign;
+    constructor(options: {
+        chain: ChainId;
+        address?: string;
+        publicKey?: HexString;
+        balance?: bigint;
+        tokenBalances?: Record<string, bigint>;
+        name?: string;
+        shouldFailConnect?: boolean;
+        shouldFailSign?: boolean;
+    });
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    signMessage(message: Uint8Array): Promise<Signature>;
+    signTransaction(tx: UnsignedTransaction): Promise<SignedTransaction>;
+    signAndSendTransaction(tx: UnsignedTransaction): Promise<TransactionReceipt>;
+    getBalance(): Promise<bigint>;
+    getTokenBalance(asset: Asset): Promise<bigint>;
+    /**
+     * Set mock balance (for testing)
+     */
+    setMockBalance(balance: bigint): void;
+    /**
+     * Set mock token balance (for testing)
+     */
+    setMockTokenBalance(asset: Asset, balance: bigint): void;
+    /**
+     * Simulate account change (for testing)
+     */
+    simulateAccountChange(newAddress: string): void;
+}
+
+/**
+ * Wallet-specific errors for SIP SDK
+ */
+
+/**
+ * Error thrown by wallet adapters
+ */
+declare class WalletError extends SIPError {
+    readonly walletCode: WalletErrorCodeType;
+    constructor(message: string, walletCode?: WalletErrorCodeType, options?: {
+        cause?: Error;
+        context?: Record<string, unknown>;
+    });
+    /**
+     * Check if this is a connection-related error
+     */
+    isConnectionError(): boolean;
+    /**
+     * Check if this is a signing-related error
+     */
+    isSigningError(): boolean;
+    /**
+     * Check if this is a transaction-related error
+     */
+    isTransactionError(): boolean;
+    /**
+     * Check if this is a privacy-related error
+     */
+    isPrivacyError(): boolean;
+    /**
+     * Check if this error was caused by user rejection
+     */
+    isUserRejection(): boolean;
+}
+/**
+ * Create a WalletError for not connected state
+ */
+declare function notConnectedError(): WalletError;
+/**
+ * Create a WalletError for feature not supported
+ */
+declare function featureNotSupportedError(feature: string, code?: WalletErrorCodeType): WalletError;
+
+/**
+ * Wallet Registry
+ *
+ * Manages wallet adapter registration and discovery.
+ * Allows applications to register and detect available wallets.
+ */
+
+/**
+ * Global wallet registry
+ *
+ * Manages available wallet adapters and provides discovery functionality.
+ *
+ * @example
+ * ```typescript
+ * // Register a wallet adapter
+ * walletRegistry.register({
+ *   info: {
+ *     id: 'phantom',
+ *     name: 'Phantom',
+ *     chains: ['solana'],
+ *     supportsPrivacy: false,
+ *   },
+ *   factory: () => new PhantomWalletAdapter(),
+ *   detect: () => typeof window !== 'undefined' && 'phantom' in window,
+ * })
+ *
+ * // Get available wallets for a chain
+ * const solanaWallets = walletRegistry.getAvailableWallets('solana')
+ *
+ * // Create a wallet adapter
+ * const wallet = walletRegistry.create('phantom')
+ * ```
+ */
+declare class WalletRegistry {
+    private entries;
+    /**
+     * Register a wallet adapter
+     *
+     * @param entry - The wallet registry entry
+     */
+    register(entry: WalletRegistryEntry): void;
+    /**
+     * Unregister a wallet adapter
+     *
+     * @param id - The wallet identifier
+     */
+    unregister(id: string): void;
+    /**
+     * Get wallet info by ID
+     *
+     * @param id - The wallet identifier
+     * @returns The wallet info or undefined
+     */
+    getInfo(id: string): WalletInfo | undefined;
+    /**
+     * Get all registered wallet infos
+     *
+     * @returns Array of all wallet infos
+     */
+    getAllWallets(): WalletInfo[];
+    /**
+     * Get wallets that support a specific chain
+     *
+     * @param chain - The chain to filter by
+     * @returns Array of wallet infos that support the chain
+     */
+    getWalletsForChain(chain: ChainId): WalletInfo[];
+    /**
+     * Get available (detected) wallets
+     *
+     * @param chain - Optional chain to filter by
+     * @returns Array of wallet infos for detected wallets
+     */
+    getAvailableWallets(chain?: ChainId): WalletInfo[];
+    /**
+     * Get wallets that support privacy features
+     *
+     * @param chain - Optional chain to filter by
+     * @returns Array of wallet infos with privacy support
+     */
+    getPrivacyWallets(chain?: ChainId): WalletInfo[];
+    /**
+     * Check if a wallet is available (detected)
+     *
+     * @param id - The wallet identifier
+     * @returns True if wallet is detected
+     */
+    isAvailable(id: string): boolean;
+    /**
+     * Create a wallet adapter instance
+     *
+     * @param id - The wallet identifier
+     * @returns A new wallet adapter instance
+     * @throws If wallet is not registered
+     */
+    create(id: string): WalletAdapter$1 | PrivateWalletAdapter;
+    /**
+     * Create and connect a wallet adapter
+     *
+     * @param id - The wallet identifier
+     * @returns A connected wallet adapter
+     * @throws If wallet is not registered or connection fails
+     */
+    connect(id: string): Promise<WalletAdapter$1 | PrivateWalletAdapter>;
+    /**
+     * Clear all registered wallets
+     */
+    clear(): void;
+}
+/**
+ * Global wallet registry instance
+ */
+declare const walletRegistry: WalletRegistry;
+/**
+ * Helper to register a wallet adapter
+ */
+declare function registerWallet(entry: WalletRegistryEntry): void;
+/**
+ * Helper to create a wallet adapter factory
+ */
+declare function createWalletFactory<T extends WalletAdapter$1 | PrivateWalletAdapter>(AdapterClass: new () => T): WalletAdapterFactory;
+/**
+ * Check if an adapter is a PrivateWalletAdapter
+ */
+declare function isPrivateWalletAdapter(adapter: WalletAdapter$1 | PrivateWalletAdapter): adapter is PrivateWalletAdapter;
+
+/**
+ * Solana Wallet Types
+ *
+ * Type definitions for Solana wallet integration.
+ * These types match the interface of injected Solana wallet providers
+ * like Phantom, Solflare, and Backpack.
+ */
+
+/**
+ * Solana public key interface
+ * Matches @solana/web3.js PublicKey
+ */
+interface SolanaPublicKey {
+    toBase58(): string;
+    toBytes(): Uint8Array;
+    toString(): string;
+}
+/**
+ * Solana transaction interface
+ * Matches @solana/web3.js Transaction
+ */
+interface SolanaTransaction {
+    /** Transaction signature after signing */
+    signature?: Uint8Array;
+    /** Serialized transaction */
+    serialize(): Uint8Array;
+    /** Add signature to transaction */
+    addSignature(pubkey: SolanaPublicKey, signature: Uint8Array): void;
+}
+/**
+ * Solana versioned transaction (v0)
+ * Matches @solana/web3.js VersionedTransaction
+ */
+interface SolanaVersionedTransaction {
+    serialize(): Uint8Array;
+    signatures: Uint8Array[];
+}
+/**
+ * Solana send options
+ */
+interface SolanaSendOptions {
+    /** Skip preflight transaction checks */
+    skipPreflight?: boolean;
+    /** Preflight commitment level */
+    preflightCommitment?: 'processed' | 'confirmed' | 'finalized';
+    /** Maximum retries */
+    maxRetries?: number;
+}
+/**
+ * Solana connection interface for RPC calls
+ */
+interface SolanaConnection {
+    /** Get account balance in lamports */
+    getBalance(publicKey: SolanaPublicKey): Promise<number>;
+    /** Get token account balance */
+    getTokenAccountBalance(publicKey: SolanaPublicKey): Promise<{
+        value: {
+            amount: string;
+            decimals: number;
+        };
+    }>;
+    /** Get latest blockhash */
+    getLatestBlockhash(): Promise<{
+        blockhash: string;
+        lastValidBlockHeight: number;
+    }>;
+    /** Send raw transaction */
+    sendRawTransaction(rawTransaction: Uint8Array, options?: SolanaSendOptions): Promise<string>;
+    /** Confirm transaction */
+    confirmTransaction(signature: string, commitment?: 'processed' | 'confirmed' | 'finalized'): Promise<{
+        value: {
+            err: unknown;
+        };
+    }>;
+}
+/**
+ * Injected Solana wallet provider interface
+ * This is what Phantom/Solflare/etc inject into window
+ */
+interface SolanaWalletProvider {
+    /** Provider is Phantom */
+    isPhantom?: boolean;
+    /** Provider is Solflare */
+    isSolflare?: boolean;
+    /** Provider is Backpack */
+    isBackpack?: boolean;
+    /** Public key when connected */
+    publicKey: SolanaPublicKey | null;
+    /** Whether wallet is connected */
+    isConnected: boolean;
+    /** Connect to wallet */
+    connect(options?: {
+        onlyIfTrusted?: boolean;
+    }): Promise<{
+        publicKey: SolanaPublicKey;
+    }>;
+    /** Disconnect from wallet */
+    disconnect(): Promise<void>;
+    /** Sign a message */
+    signMessage(message: Uint8Array, encoding?: 'utf8'): Promise<{
+        signature: Uint8Array;
+    }>;
+    /** Sign a transaction */
+    signTransaction<T extends SolanaTransaction | SolanaVersionedTransaction>(transaction: T): Promise<T>;
+    /** Sign multiple transactions */
+    signAllTransactions<T extends SolanaTransaction | SolanaVersionedTransaction>(transactions: T[]): Promise<T[]>;
+    /** Sign and send transaction */
+    signAndSendTransaction<T extends SolanaTransaction | SolanaVersionedTransaction>(transaction: T, options?: SolanaSendOptions): Promise<{
+        signature: string;
+    }>;
+    /** Event handling */
+    on(event: 'connect' | 'disconnect' | 'accountChanged', handler: (...args: unknown[]) => void): void;
+    off(event: 'connect' | 'disconnect' | 'accountChanged', handler: (...args: unknown[]) => void): void;
+}
+/**
+ * Solana wallet name/type
+ */
+type SolanaWalletName = 'phantom' | 'solflare' | 'backpack' | 'generic';
+/**
+ * Solana network/cluster
+ */
+type SolanaCluster = 'mainnet-beta' | 'testnet' | 'devnet' | 'localnet';
+/**
+ * Solana adapter configuration
+ */
+interface SolanaAdapterConfig {
+    /** Wallet to connect to */
+    wallet?: SolanaWalletName;
+    /** Solana cluster/network */
+    cluster?: SolanaCluster;
+    /** RPC endpoint URL */
+    rpcEndpoint?: string;
+    /** Custom wallet provider (for testing) */
+    provider?: SolanaWalletProvider;
+    /** Custom connection (for testing) */
+    connection?: SolanaConnection;
+}
+/**
+ * Solana-specific unsigned transaction
+ */
+interface SolanaUnsignedTransaction {
+    /** The Solana transaction object */
+    transaction: SolanaTransaction | SolanaVersionedTransaction;
+    /** Whether this is a versioned transaction */
+    isVersioned?: boolean;
+    /** Send options */
+    sendOptions?: SolanaSendOptions;
+}
+/**
+ * Extended signature with Solana-specific data
+ */
+interface SolanaSignature {
+    /** Raw signature bytes */
+    signature: HexString;
+    /** Solana public key (base58) */
+    publicKey: HexString;
+    /** Base58 encoded signature (Solana standard) */
+    base58Signature?: string;
+}
+/**
+ * Get the injected Solana wallet provider
+ */
+declare function getSolanaProvider(wallet?: SolanaWalletName): SolanaWalletProvider | undefined;
+/**
+ * Detect which Solana wallets are installed
+ */
+declare function detectSolanaWallets(): SolanaWalletName[];
+/**
+ * Convert Solana public key to hex string
+ */
+declare function solanaPublicKeyToHex(pubkey: SolanaPublicKey): HexString;
+/**
+ * Convert base58 string to hex
+ */
+declare function base58ToHex(base58: string): HexString;
+
+/**
+ * Solana Wallet Adapter
+ *
+ * Implementation of WalletAdapter for Solana chain.
+ * Supports Phantom, Solflare, Backpack, and generic Solana wallets.
+ */
+
+/**
+ * Solana wallet adapter
+ *
+ * Provides SIP-compatible wallet interface for Solana.
+ * Works with Phantom, Solflare, Backpack, and other Solana wallets.
+ *
+ * @example Browser usage with Phantom
+ * ```typescript
+ * const wallet = new SolanaWalletAdapter({ wallet: 'phantom' })
+ * await wallet.connect()
+ *
+ * const balance = await wallet.getBalance()
+ * console.log(`Balance: ${balance} lamports`)
+ *
+ * // Sign a message
+ * const sig = await wallet.signMessage(new TextEncoder().encode('Hello'))
+ * ```
+ *
+ * @example With custom RPC endpoint
+ * ```typescript
+ * const wallet = new SolanaWalletAdapter({
+ *   wallet: 'phantom',
+ *   cluster: 'devnet',
+ *   rpcEndpoint: 'https://my-rpc.example.com',
+ * })
+ * ```
+ */
+declare class SolanaWalletAdapter extends BaseWalletAdapter {
+    readonly chain: "solana";
+    readonly name: string;
+    private provider;
+    private connection;
+    private walletName;
+    private cluster;
+    private rpcEndpoint;
+    private connectHandler?;
+    private disconnectHandler?;
+    private accountChangedHandler?;
+    constructor(config?: SolanaAdapterConfig);
+    /**
+     * Get the current Solana cluster
+     */
+    getCluster(): SolanaCluster;
+    /**
+     * Get the RPC endpoint
+     */
+    getRpcEndpoint(): string;
+    /**
+     * Set the RPC endpoint
+     */
+    setRpcEndpoint(endpoint: string): void;
+    /**
+     * Get or create a connection for RPC calls
+     */
+    private getConnection;
+    /**
+     * Connect to the wallet
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the wallet
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Sign a message
+     */
+    signMessage(message: Uint8Array): Promise<Signature>;
+    /**
+     * Sign a transaction
+     *
+     * The transaction data should be a SolanaTransaction or SolanaVersionedTransaction
+     */
+    signTransaction(tx: UnsignedTransaction): Promise<SignedTransaction>;
+    /**
+     * Sign and send a transaction
+     */
+    signAndSendTransaction(tx: UnsignedTransaction): Promise<TransactionReceipt>;
+    /**
+     * Sign multiple transactions at once
+     *
+     * Solana-specific method for batch signing
+     */
+    signAllTransactions<T extends SolanaTransaction | SolanaVersionedTransaction>(transactions: T[]): Promise<T[]>;
+    /**
+     * Get native SOL balance
+     */
+    getBalance(): Promise<bigint>;
+    /**
+     * Get SPL token balance
+     */
+    getTokenBalance(asset: Asset): Promise<bigint>;
+    /**
+     * Set up wallet event handlers
+     */
+    private setupEventHandlers;
+    /**
+     * Clean up wallet event handlers
+     */
+    private cleanupEventHandlers;
+}
+/**
+ * Create a Solana wallet adapter with default configuration
+ */
+declare function createSolanaAdapter(config?: SolanaAdapterConfig): SolanaWalletAdapter;
+
+/**
+ * Mock Solana Wallet Adapter
+ *
+ * Testing implementation of Solana wallet adapter.
+ * Provides full mock functionality without requiring browser environment.
+ */
+
+/**
+ * Configuration for mock Solana adapter
+ */
+interface MockSolanaAdapterConfig {
+    /** Mock address (base58) */
+    address?: string;
+    /** Mock balance in lamports */
+    balance?: bigint;
+    /** Token balances by mint address */
+    tokenBalances?: Record<string, bigint>;
+    /** Whether to simulate connection failure */
+    shouldFailConnect?: boolean;
+    /** Whether to simulate signing failure */
+    shouldFailSign?: boolean;
+    /** Whether to simulate transaction failure */
+    shouldFailTransaction?: boolean;
+    /** Simulated cluster */
+    cluster?: SolanaCluster;
+    /** Simulated latency in ms */
+    latency?: number;
+}
+/**
+ * Mock Solana wallet adapter for testing
+ *
+ * Provides full Solana wallet functionality with mock data.
+ * No browser environment or actual wallet required.
+ *
+ * @example
+ * ```typescript
+ * const wallet = new MockSolanaAdapter({
+ *   address: 'TestWalletAddress123',
+ *   balance: 5_000_000_000n, // 5 SOL
+ * })
+ *
+ * await wallet.connect()
+ * const balance = await wallet.getBalance() // 5_000_000_000n
+ *
+ * // Simulate failures
+ * const failingWallet = new MockSolanaAdapter({
+ *   shouldFailSign: true,
+ * })
+ * ```
+ */
+declare class MockSolanaAdapter extends BaseWalletAdapter {
+    readonly chain: "solana";
+    readonly name = "mock-solana";
+    private mockAddress;
+    private mockPublicKey;
+    private mockBalance;
+    private mockTokenBalances;
+    private shouldFailConnect;
+    private shouldFailSign;
+    private shouldFailTransaction;
+    private cluster;
+    private latency;
+    private signedTransactions;
+    private sentTransactions;
+    constructor(config?: MockSolanaAdapterConfig);
+    /**
+     * Get the current Solana cluster
+     */
+    getCluster(): SolanaCluster;
+    /**
+     * Connect to the mock wallet
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the mock wallet
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Sign a message
+     */
+    signMessage(message: Uint8Array): Promise<Signature>;
+    /**
+     * Sign a transaction
+     */
+    signTransaction(tx: UnsignedTransaction): Promise<SignedTransaction>;
+    /**
+     * Sign and send a transaction
+     */
+    signAndSendTransaction(tx: UnsignedTransaction): Promise<TransactionReceipt>;
+    /**
+     * Sign multiple transactions
+     */
+    signAllTransactions<T extends SolanaTransaction | SolanaVersionedTransaction>(transactions: T[]): Promise<T[]>;
+    /**
+     * Get SOL balance
+     */
+    getBalance(): Promise<bigint>;
+    /**
+     * Get token balance
+     */
+    getTokenBalance(asset: Asset): Promise<bigint>;
+    /**
+     * Set mock balance
+     */
+    setMockBalance(balance: bigint): void;
+    /**
+     * Set mock token balance
+     */
+    setMockTokenBalance(mintAddress: string, balance: bigint): void;
+    /**
+     * Get all signed transactions (for verification)
+     */
+    getSignedTransactions(): Array<SolanaTransaction | SolanaVersionedTransaction>;
+    /**
+     * Get all sent transaction signatures (for verification)
+     */
+    getSentTransactions(): string[];
+    /**
+     * Clear transaction history
+     */
+    clearTransactionHistory(): void;
+    /**
+     * Simulate an account change event
+     */
+    simulateAccountChange(newAddress: string): void;
+    /**
+     * Simulate a disconnect event
+     */
+    simulateDisconnect(): void;
+    private simulateLatency;
+}
+/**
+ * Create a mock Solana wallet provider for testing real adapter
+ */
+declare function createMockSolanaProvider(config?: MockSolanaAdapterConfig): SolanaWalletProvider;
+/**
+ * Create a mock Solana connection for testing
+ */
+declare function createMockSolanaConnection(config?: MockSolanaAdapterConfig): SolanaConnection;
+/**
+ * Create a mock Solana adapter
+ */
+declare function createMockSolanaAdapter(config?: MockSolanaAdapterConfig): MockSolanaAdapter;
+
+/**
+ * Ethereum Wallet Types
+ *
+ * Type definitions for Ethereum wallet integration.
+ * Follows EIP-1193 (Provider API) and EIP-712 (Typed Data Signing).
+ */
+
+/**
+ * EIP-1193 Provider interface
+ * Standard interface for Ethereum providers (MetaMask, etc.)
+ */
+interface EIP1193Provider {
+    /** Make an Ethereum JSON-RPC request */
+    request<T = unknown>(args: EIP1193RequestArguments): Promise<T>;
+    /** Event emitter for provider events */
+    on(event: string, handler: (...args: unknown[]) => void): void;
+    removeListener(event: string, handler: (...args: unknown[]) => void): void;
+    /** Provider is MetaMask */
+    isMetaMask?: boolean;
+    /** Provider is Coinbase Wallet */
+    isCoinbaseWallet?: boolean;
+    /** Selected address (may be undefined before connection) */
+    selectedAddress?: string | null;
+    /** Chain ID in hex format */
+    chainId?: string;
+    /** Whether provider is connected */
+    isConnected?(): boolean;
+}
+/**
+ * EIP-1193 Request arguments
+ */
+interface EIP1193RequestArguments {
+    method: string;
+    params?: unknown[] | Record<string, unknown>;
+}
+/**
+ * EIP-1193 Provider events
+ */
+type EIP1193Event = 'connect' | 'disconnect' | 'chainChanged' | 'accountsChanged' | 'message';
+/**
+ * EIP-1193 Connect info
+ */
+interface EIP1193ConnectInfo {
+    chainId: string;
+}
+/**
+ * EIP-1193 Provider RPC error
+ */
+interface EIP1193ProviderRpcError extends Error {
+    code: number;
+    data?: unknown;
+}
+/**
+ * EIP-712 Typed data domain
+ */
+interface EIP712Domain {
+    name?: string;
+    version?: string;
+    chainId?: number;
+    verifyingContract?: string;
+    salt?: string;
+}
+/**
+ * EIP-712 Type definition
+ */
+interface EIP712TypeDefinition {
+    name: string;
+    type: string;
+}
+/**
+ * EIP-712 Types object
+ */
+interface EIP712Types {
+    EIP712Domain?: EIP712TypeDefinition[];
+    [key: string]: EIP712TypeDefinition[] | undefined;
+}
+/**
+ * EIP-712 Typed data for signing
+ */
+interface EIP712TypedData {
+    domain: EIP712Domain;
+    types: EIP712Types;
+    primaryType: string;
+    message: Record<string, unknown>;
+}
+/**
+ * Ethereum transaction request
+ */
+interface EthereumTransactionRequest {
+    /** Sender address */
+    from?: string;
+    /** Recipient address */
+    to?: string;
+    /** Value in wei (hex) */
+    value?: string;
+    /** Transaction data (hex) */
+    data?: string;
+    /** Gas limit (hex) */
+    gas?: string;
+    /** Gas price (hex) - legacy */
+    gasPrice?: string;
+    /** Max fee per gas (hex) - EIP-1559 */
+    maxFeePerGas?: string;
+    /** Max priority fee per gas (hex) - EIP-1559 */
+    maxPriorityFeePerGas?: string;
+    /** Nonce (hex) */
+    nonce?: string;
+    /** Chain ID */
+    chainId?: number;
+}
+/**
+ * Ethereum transaction receipt
+ */
+interface EthereumTransactionReceipt {
+    /** Transaction hash */
+    transactionHash: string;
+    /** Block number */
+    blockNumber: string;
+    /** Block hash */
+    blockHash: string;
+    /** Sender address */
+    from: string;
+    /** Recipient address */
+    to: string | null;
+    /** Gas used */
+    gasUsed: string;
+    /** Effective gas price */
+    effectiveGasPrice: string;
+    /** Status (1 = success, 0 = failure) */
+    status: string;
+    /** Contract address (if deployment) */
+    contractAddress: string | null;
+}
+/**
+ * Token metadata for wallet_watchAsset
+ */
+interface EthereumTokenMetadata {
+    /** Token contract address */
+    address: string;
+    /** Token symbol */
+    symbol: string;
+    /** Token decimals */
+    decimals: number;
+    /** Token image URL (optional) */
+    image?: string;
+}
+/**
+ * Common Ethereum chain IDs
+ */
+declare const EthereumChainId: {
+    readonly MAINNET: 1;
+    readonly GOERLI: 5;
+    readonly SEPOLIA: 11155111;
+    readonly POLYGON: 137;
+    readonly POLYGON_MUMBAI: 80001;
+    readonly ARBITRUM: 42161;
+    readonly ARBITRUM_GOERLI: 421613;
+    readonly OPTIMISM: 10;
+    readonly OPTIMISM_GOERLI: 420;
+    readonly BASE: 8453;
+    readonly BASE_GOERLI: 84531;
+    readonly LOCALHOST: 1337;
+};
+type EthereumChainIdType = (typeof EthereumChainId)[keyof typeof EthereumChainId];
+/**
+ * Chain metadata for wallet_addEthereumChain
+ */
+interface EthereumChainMetadata {
+    chainId: string;
+    chainName: string;
+    nativeCurrency: {
+        name: string;
+        symbol: string;
+        decimals: number;
+    };
+    rpcUrls: string[];
+    blockExplorerUrls?: string[];
+    iconUrls?: string[];
+}
+/**
+ * Ethereum wallet name/type
+ */
+type EthereumWalletName = 'metamask' | 'coinbase' | 'walletconnect' | 'generic';
+/**
+ * Ethereum adapter configuration
+ */
+interface EthereumAdapterConfig {
+    /** Wallet to connect to */
+    wallet?: EthereumWalletName;
+    /** Target chain ID */
+    chainId?: number;
+    /** RPC endpoint URL (for balance queries) */
+    rpcEndpoint?: string;
+    /** Custom provider (for testing) */
+    provider?: EIP1193Provider;
+}
+/**
+ * Get the injected Ethereum provider
+ */
+declare function getEthereumProvider(wallet?: EthereumWalletName): EIP1193Provider | undefined;
+/**
+ * Detect which Ethereum wallets are installed
+ */
+declare function detectEthereumWallets(): EthereumWalletName[];
+/**
+ * Convert number to hex string with 0x prefix
+ */
+declare function toHex(value: number | bigint): HexString;
+/**
+ * Convert hex string to bigint
+ */
+declare function fromHex(hex: string): bigint;
+/**
+ * Convert hex string to number
+ */
+declare function hexToNumber(hex: string): number;
+/**
+ * Pad address to checksum format
+ */
+declare function normalizeAddress(address: string): HexString;
+/**
+ * Get default RPC endpoint for chain
+ */
+declare function getDefaultRpcEndpoint(chainId: number): string;
+
+/**
+ * Ethereum Wallet Adapter
+ *
+ * Implementation of WalletAdapter for Ethereum wallets (MetaMask, Coinbase, etc.).
+ * Uses EIP-1193 provider standard for wallet communication.
+ */
+
+/**
+ * Ethereum wallet adapter implementation
+ *
+ * @example
+ * ```typescript
+ * const adapter = new EthereumWalletAdapter({
+ *   wallet: 'metamask',
+ *   chainId: 1,
+ * })
+ *
+ * await adapter.connect()
+ * const balance = await adapter.getBalance()
+ * ```
+ */
+declare class EthereumWalletAdapter extends BaseWalletAdapter {
+    readonly chain: "ethereum";
+    readonly name: string;
+    private provider;
+    private _chainId;
+    private _rpcEndpoint;
+    private walletType;
+    private boundAccountsChanged;
+    private boundChainChanged;
+    private boundDisconnect;
+    constructor(config?: EthereumAdapterConfig);
+    /**
+     * Get current chain ID
+     */
+    getChainId(): number;
+    /**
+     * Get RPC endpoint URL
+     */
+    getRpcEndpoint(): string;
+    /**
+     * Set RPC endpoint URL
+     */
+    setRpcEndpoint(endpoint: string): void;
+    /**
+     * Connect to Ethereum wallet
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from wallet
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Sign a message
+     */
+    signMessage(message: Uint8Array): Promise<Signature>;
+    /**
+     * Sign typed data (EIP-712)
+     */
+    signTypedData(typedData: EIP712TypedData): Promise<Signature>;
+    /**
+     * Sign a transaction without sending
+     */
+    signTransaction(tx: UnsignedTransaction): Promise<SignedTransaction>;
+    /**
+     * Sign and send a transaction
+     */
+    signAndSendTransaction(tx: UnsignedTransaction): Promise<TransactionReceipt>;
+    /**
+     * Get ETH balance
+     */
+    getBalance(): Promise<bigint>;
+    /**
+     * Get ERC-20 token balance
+     */
+    getTokenBalance(asset: Asset): Promise<bigint>;
+    /**
+     * Switch to a different chain
+     */
+    switchChain(chainId: number): Promise<void>;
+    /**
+     * Wait for transaction confirmation
+     */
+    waitForTransaction(txHash: string, confirmations?: number): Promise<EthereumTransactionReceipt>;
+    /**
+     * Set up provider event listeners
+     */
+    private setupEventListeners;
+    /**
+     * Remove provider event listeners
+     */
+    private removeEventListeners;
+    /**
+     * Handle accounts changed event
+     */
+    private handleAccountsChanged;
+    /**
+     * Handle chain changed event
+     */
+    private handleChainChanged;
+    /**
+     * Handle disconnect event
+     */
+    private handleDisconnect;
+}
+/**
+ * Factory function to create Ethereum adapter
+ */
+declare function createEthereumAdapter(config?: EthereumAdapterConfig): EthereumWalletAdapter;
+
+/**
+ * Mock Ethereum Wallet Adapter
+ *
+ * Mock implementation for testing without browser environment.
+ * Simulates EIP-1193 provider behavior.
+ */
+
+/**
+ * Mock Ethereum adapter configuration
+ */
+interface MockEthereumAdapterConfig {
+    /** Mock address */
+    address?: string;
+    /** Mock chain ID */
+    chainId?: number;
+    /** Initial ETH balance in wei */
+    balance?: bigint;
+    /** Token balances by address */
+    tokenBalances?: Record<string, bigint>;
+    /** Should connection fail */
+    shouldFailConnect?: boolean;
+    /** Should signing fail */
+    shouldFailSign?: boolean;
+    /** Should transaction fail */
+    shouldFailTransaction?: boolean;
+}
+/**
+ * Mock Ethereum wallet adapter for testing
+ *
+ * @example
+ * ```typescript
+ * const adapter = new MockEthereumAdapter({
+ *   address: '0x1234...',
+ *   balance: 1_000_000_000_000_000_000n, // 1 ETH
+ * })
+ *
+ * await adapter.connect()
+ * const balance = await adapter.getBalance()
+ * ```
+ */
+declare class MockEthereumAdapter extends BaseWalletAdapter {
+    readonly chain: "ethereum";
+    readonly name = "mock-ethereum";
+    private _chainId;
+    private _balance;
+    private _tokenBalances;
+    private _mockAddress;
+    private _shouldFailConnect;
+    private _shouldFailSign;
+    private _shouldFailTransaction;
+    private _signedTransactions;
+    private _sentTransactions;
+    private _signatureCounter;
+    private _txCounter;
+    constructor(config?: MockEthereumAdapterConfig);
+    /**
+     * Get current chain ID
+     */
+    getChainId(): number;
+    /**
+     * Connect to mock wallet
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from mock wallet
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Sign a message
+     */
+    signMessage(message: Uint8Array): Promise<Signature>;
+    /**
+     * Sign typed data (EIP-712)
+     */
+    signTypedData(typedData: EIP712TypedData): Promise<Signature>;
+    /**
+     * Sign a transaction
+     */
+    signTransaction(tx: UnsignedTransaction): Promise<SignedTransaction>;
+    /**
+     * Sign and send a transaction
+     */
+    signAndSendTransaction(tx: UnsignedTransaction): Promise<TransactionReceipt>;
+    /**
+     * Get ETH balance
+     */
+    getBalance(): Promise<bigint>;
+    /**
+     * Get ERC-20 token balance
+     */
+    getTokenBalance(asset: Asset): Promise<bigint>;
+    /**
+     * Switch chain (mock)
+     */
+    switchChain(chainId: number): Promise<void>;
+    /**
+     * Set mock ETH balance
+     */
+    setMockBalance(balance: bigint): void;
+    /**
+     * Set mock token balance
+     */
+    setMockTokenBalance(tokenAddress: string, balance: bigint): void;
+    /**
+     * Get signed transactions history
+     */
+    getSignedTransactions(): UnsignedTransaction[];
+    /**
+     * Get sent transaction hashes
+     */
+    getSentTransactions(): string[];
+    /**
+     * Clear transaction history
+     */
+    clearTransactionHistory(): void;
+    /**
+     * Simulate account change
+     */
+    simulateAccountChange(newAddress: string): void;
+    /**
+     * Simulate disconnect
+     */
+    simulateDisconnect(): void;
+}
+/**
+ * Factory function to create mock Ethereum adapter
+ */
+declare function createMockEthereumAdapter(config?: MockEthereumAdapterConfig): MockEthereumAdapter;
+/**
+ * Create a mock EIP-1193 provider for testing
+ */
+declare function createMockEthereumProvider(config?: MockEthereumAdapterConfig): EIP1193Provider;
+
+export { BaseWalletAdapter, type CommitmentPoint, type CreateIntentOptions, CryptoError, type EIP1193ConnectInfo, type EIP1193Event, type EIP1193Provider, type EIP1193ProviderRpcError, type EIP1193RequestArguments, type EIP712Domain, type EIP712TypeDefinition, type EIP712TypedData, type EIP712Types, EncryptionNotImplementedError, ErrorCode, type EthereumAdapterConfig, EthereumChainId, type EthereumChainIdType, type EthereumChainMetadata, type EthereumTokenMetadata, type EthereumTransactionReceipt, type EthereumTransactionRequest, EthereumWalletAdapter, type EthereumWalletName, type ExportedViewingKey, type FulfillmentProofParams, type FundingProofParams, IntentBuilder, IntentError, MockEthereumAdapter, type MockEthereumAdapterConfig, MockProofProvider, MockSolanaAdapter, type MockSolanaAdapterConfig, MockSolver, type MockSolverConfig, MockWalletAdapter, NEARIntentsAdapter, type NEARIntentsAdapterConfig, NetworkError, NoirProofProvider, type NoirProviderConfig, OneClickClient, type OracleAttestation, type PedersenCommitment, type PreparedSwap, type PrivacyConfig, ProofError, type ProofFramework, ProofGenerationError, ProofNotImplementedError, type ProofProvider, type ProofResult, type ReceivedNote, SIP, type SIPConfig, SIPError, type SerializedError, type ShieldedBalance, type ShieldedSendParams, type ShieldedSendResult, type SolanaAdapterConfig, type SolanaCluster, type SolanaConnection, type SolanaPublicKey, type SolanaSendOptions, type SolanaSignature, type SolanaTransaction, type SolanaUnsignedTransaction, type SolanaVersionedTransaction, SolanaWalletAdapter, type SolanaWalletName, type SolanaWalletProvider, type SwapRequest, type SwapResult, type TransactionData, ValidationError, type ValidityProofParams, type WalletAdapter, WalletError, ZcashRPCClient, ZcashRPCError, ZcashShieldedService, type ZcashShieldedServiceConfig, addBlindings, addCommitments, attachProofs, base58ToHex, checkStealthAddress, commit, commitZero, createCommitment, createEthereumAdapter, createMockEthereumAdapter, createMockEthereumProvider, createMockSolanaAdapter, createMockSolanaConnection, createMockSolanaProvider, createMockSolver, createNEARIntentsAdapter, createSIP, createShieldedIntent, createSolanaAdapter, createWalletFactory, createZcashClient, createZcashShieldedService, decodeStealthMetaAddress, decryptWithViewing, deriveStealthPrivateKey, deriveViewingKey, deserializeIntent, detectEthereumWallets, detectSolanaWallets, encodeStealthMetaAddress, encryptForViewing, featureNotSupportedError, fromHex, generateBlinding, generateIntentId, generateRandomBytes, generateStealthAddress, generateStealthMetaAddress, generateViewingKey, getDefaultRpcEndpoint, getErrorMessage, getEthereumProvider, getGenerators, getIntentSummary, getPrivacyConfig, getPrivacyDescription, getSolanaProvider, getTimeRemaining, hasErrorCode, hasRequiredProofs, hash, hexToNumber, isExpired, isNonNegativeAmount, isPrivateWalletAdapter, isSIPError, isValidAmount, isValidChainId, isValidCompressedPublicKey, isValidHex, isValidHexLength, isValidPrivacyLevel, isValidPrivateKey, isValidScalar, isValidSlippage, isValidStealthMetaAddress, normalizeAddress, notConnectedError, registerWallet, serializeIntent, solanaPublicKeyToHex, subtractBlindings, subtractCommitments, toHex, trackIntent, validateAsset, validateCreateIntentParams, validateIntentInput, validateIntentOutput, validateScalar, validateViewingKey, verifyCommitment, verifyOpening, walletRegistry, wrapError };