@sip-protocol/sdk 0.1.8 → 0.2.0

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import * as _sip_protocol_types from '@sip-protocol/types';
-import { ZKProof, HexString, Commitment, PrivacyLevel, ShieldedIntent, CreateIntentParams, TrackedIntent, OneClickConfig, OneClickToken, OneClickQuoteRequest, OneClickQuoteResponse, OneClickDepositSubmit, OneClickStatusResponse, OneClickWithdrawal, DefuseAssetId, Asset, StealthMetaAddress, OneClickSwapStatus, ChainId, Quote, FulfillmentResult, ViewingKey, StealthAddress, StealthAddressRecovery, EncryptedTransaction, Hash, IntentInput, IntentOutput, SIPSolver, Solver, SolverCapabilities, SolverVisibleIntent, SolverQuote, FulfillmentStatus, ZcashConfig, ZcashAddressInfo, ZcashNewAccount, ZcashReceiverType, ZcashAccountAddress, ZcashAccountBalance, ZcashUnspentNote, ZcashShieldedSendParams, ZcashOperation, ZcashBlockHeader, ZcashBlock, ZcashBlockchainInfo, ZcashNetworkInfo, StablecoinSymbol, PaymentPurpose, ShieldedPayment, CreatePaymentParams, TrackedPayment, CreateTreasuryParams, TreasuryConfig, TreasuryMember, CreatePaymentProposalParams, TreasuryProposal, CreateBatchProposalParams, AuditorViewingKey, TreasuryBalance, CreateComplianceConfigParams, ComplianceConfig, RegisterAuditorParams, AuditorRegistration, AuditScope, DisclosedTransaction, DisclosureRequest, GenerateReportParams, ComplianceReport, AuditLogEntry, WalletAdapter as WalletAdapter$1, WalletConnectionState, WalletEventType, WalletEventHandler, WalletEvent, Signature, UnsignedTransaction, SignedTransaction, TransactionReceipt, WalletErrorCodeType, WalletRegistryEntry, WalletInfo, PrivateWalletAdapter, WalletAdapterFactory } from '@sip-protocol/types';
+import { ZKProof, HexString, Commitment, PrivacyLevel, ShieldedIntent, CreateIntentParams, TrackedIntent, OneClickConfig, OneClickToken, OneClickQuoteRequest, OneClickQuoteResponse, OneClickDepositSubmit, OneClickStatusResponse, OneClickWithdrawal, ChainId, StealthMetaAddress, StealthAddress, StealthAddressRecovery, DefuseAssetId, Asset, OneClickSwapStatus, Quote, FulfillmentResult, ViewingKey, EncryptedTransaction, Hash, IntentInput, IntentOutput, SIPSolver, Solver, SolverCapabilities, SolverVisibleIntent, SolverQuote, FulfillmentStatus, ZcashConfig, ZcashAddressInfo, ZcashNewAccount, ZcashReceiverType, ZcashAccountAddress, ZcashAccountBalance, ZcashUnspentNote, ZcashShieldedSendParams, ZcashOperation, ZcashBlockHeader, ZcashBlock, ZcashBlockchainInfo, ZcashNetworkInfo, StablecoinSymbol, PaymentPurpose, ShieldedPayment, CreatePaymentParams, TrackedPayment, CreateTreasuryParams, TreasuryConfig, TreasuryMember, CreatePaymentProposalParams, TreasuryProposal, CreateBatchProposalParams, AuditorViewingKey, TreasuryBalance, CreateComplianceConfigParams, ComplianceConfig, RegisterAuditorParams, AuditorRegistration, AuditScope, DisclosedTransaction, DisclosureRequest, GenerateReportParams, ComplianceReport, AuditLogEntry, WalletAdapter as WalletAdapter$1, WalletConnectionState, WalletEventType, WalletEventHandler, WalletEvent, Signature, UnsignedTransaction, SignedTransaction, TransactionReceipt, WalletErrorCodeType, WalletRegistryEntry, WalletInfo, PrivateWalletAdapter, WalletAdapterFactory } from '@sip-protocol/types';
 export { Asset, AuditLogEntry, AuditScope, AuditorRegistration, AuditorViewingKey, BatchPaymentRecipient, BatchPaymentRequest, ChainId, Commitment, ComplianceConfig, ComplianceReport, ComplianceRole, CreateBatchProposalParams, CreateComplianceConfigParams, CreateIntentParams, CreatePaymentParams, CreatePaymentProposalParams, CreateTreasuryParams, DefuseAssetId, DisclosedTransaction, DisclosureRequest, FulfillmentCommitment, FulfillmentProof, FulfillmentRequest, FulfillmentResult, FulfillmentStatus, GenerateReportParams, Hash, HexString, WalletAdapter as IWalletAdapter, IntentStatus, NATIVE_TOKENS, OneClickConfig, OneClickDepositMode, OneClickErrorCode, OneClickQuoteRequest, OneClickQuoteResponse, OneClickStatusResponse, OneClickSwapStatus, OneClickSwapType, PaymentPurpose, PaymentReceipt, PaymentStatus, PaymentStatusType, PrivacyLevel, PrivateWalletAdapter, ProposalSignature, ProposalStatus, ProposalStatusType, ProposalType, Quote, RegisterAuditorParams, ReportData, ReportFormat, ReportStatus, ReportStatusType, ReportType, SIPSolver, SIP_VERSION, ShieldedIntent, ShieldedPayment, Signature, SignedTransaction, Solver, SolverCapabilities, SolverEvent, SolverEventListener, SolverQuote, SolverVisibleIntent, StablecoinSymbol, StealthAddress, StealthAddressRecovery, StealthMetaAddress, SwapRoute, SwapRouteStep, TrackedIntent, TrackedPayment, TransactionReceipt, TreasuryBalance, TreasuryConfig, TreasuryMember, TreasuryProposal, TreasuryRole, TreasuryTransaction, 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';
 
 /**
@@ -591,7 +591,7 @@ declare class MockProofProvider implements ProofProvider {
 /**
  * Public key coordinates for secp256k1
  */
-interface PublicKeyCoordinates {
+interface PublicKeyCoordinates$1 {
     /** X coordinate as 32-byte array */
     x: number[];
     /** Y coordinate as 32-byte array */
@@ -620,7 +620,7 @@ interface NoirProviderConfig {
      * Oracle public key for verifying attestations in fulfillment proofs
      * Required for production use. If not provided, proofs will use placeholder keys.
      */
-    oraclePublicKey?: PublicKeyCoordinates;
+    oraclePublicKey?: PublicKeyCoordinates$1;
 }
 /**
  * Noir Proof Provider
@@ -684,7 +684,7 @@ declare class NoirProofProvider implements ProofProvider {
      * }
      * ```
      */
-    static derivePublicKey(privateKey: Uint8Array): PublicKeyCoordinates;
+    static derivePublicKey(privateKey: Uint8Array): PublicKeyCoordinates$1;
     /**
      * Initialize the Noir provider
      *
@@ -824,6 +824,219 @@ declare class NoirProofProvider implements ProofProvider {
     private getPublicKeyFromField;
 }
 
+/**
+ * Browser Noir Proof Provider
+ *
+ * Production-ready ZK proof provider for browser environments.
+ * Uses Web Workers for non-blocking proof generation and WASM for computation.
+ *
+ * @example
+ * ```typescript
+ * import { BrowserNoirProvider } from '@sip-protocol/sdk/browser'
+ *
+ * const provider = new BrowserNoirProvider()
+ * await provider.initialize() // Loads WASM
+ *
+ * const proof = await provider.generateFundingProof(inputs)
+ * ```
+ *
+ * @see docs/specs/ZK-ARCHITECTURE.md
+ * @see https://github.com/sip-protocol/sip-protocol/issues/121
+ */
+
+/**
+ * Public key coordinates for secp256k1
+ */
+interface PublicKeyCoordinates {
+    /** X coordinate as 32-byte array */
+    x: number[];
+    /** Y coordinate as 32-byte array */
+    y: number[];
+}
+/**
+ * Browser Noir Provider Configuration
+ */
+interface BrowserNoirProviderConfig {
+    /**
+     * Use Web Workers for proof generation (non-blocking)
+     * @default true
+     */
+    useWorker?: boolean;
+    /**
+     * Enable verbose logging for debugging
+     * @default false
+     */
+    verbose?: boolean;
+    /**
+     * Oracle public key for verifying attestations in fulfillment proofs
+     * Required for production use.
+     */
+    oraclePublicKey?: PublicKeyCoordinates;
+    /**
+     * Maximum time for proof generation before timeout (ms)
+     * @default 60000 (60 seconds)
+     */
+    timeout?: number;
+}
+/**
+ * Proof generation progress callback
+ */
+type ProofProgressCallback = (progress: {
+    stage: 'initializing' | 'witness' | 'proving' | 'verifying' | 'complete';
+    percent: number;
+    message: string;
+}) => void;
+/**
+ * Browser-compatible Noir Proof Provider
+ *
+ * Designed for browser environments with:
+ * - WASM-based proof generation
+ * - Optional Web Worker support for non-blocking UI
+ * - Memory-efficient initialization
+ * - Progress callbacks for UX
+ *
+ * @example
+ * ```typescript
+ * const provider = new BrowserNoirProvider({ useWorker: true })
+ *
+ * await provider.initialize((progress) => {
+ *   console.log(`${progress.stage}: ${progress.percent}%`)
+ * })
+ *
+ * const result = await provider.generateFundingProof(params, (progress) => {
+ *   updateProgressBar(progress.percent)
+ * })
+ * ```
+ */
+declare class BrowserNoirProvider implements ProofProvider {
+    readonly framework: ProofFramework;
+    private _isReady;
+    private config;
+    private fundingNoir;
+    private fundingBackend;
+    private validityNoir;
+    private validityBackend;
+    private fulfillmentNoir;
+    private fulfillmentBackend;
+    private worker;
+    private workerPending;
+    constructor(config?: BrowserNoirProviderConfig);
+    get isReady(): boolean;
+    /**
+     * Get browser environment info
+     */
+    static getBrowserInfo(): {
+        isBrowser: boolean;
+        supportsWorkers: boolean;
+        supportsSharedArrayBuffer: boolean;
+        userAgent: string | null;
+    };
+    /**
+     * Check if browser supports all required features
+     */
+    static checkBrowserSupport(): {
+        supported: boolean;
+        missing: string[];
+    };
+    /**
+     * Derive secp256k1 public key coordinates from a private key
+     */
+    static derivePublicKey(privateKey: Uint8Array): PublicKeyCoordinates;
+    /**
+     * Initialize the browser provider
+     *
+     * Loads WASM and circuit artifacts. This should be called before any
+     * proof generation. Consider showing a loading indicator during init.
+     *
+     * @param onProgress - Optional progress callback
+     */
+    initialize(onProgress?: ProofProgressCallback): Promise<void>;
+    /**
+     * Initialize Web Worker for off-main-thread proof generation
+     */
+    private initializeWorker;
+    /**
+     * Generate a Funding Proof
+     *
+     * Proves: balance >= minimumRequired without revealing balance
+     *
+     * @param params - Funding proof parameters
+     * @param onProgress - Optional progress callback
+     */
+    generateFundingProof(params: FundingProofParams, onProgress?: ProofProgressCallback): Promise<ProofResult>;
+    /**
+     * Generate a Validity Proof
+     *
+     * Proves: Intent is authorized by sender without revealing identity
+     */
+    generateValidityProof(params: ValidityProofParams, onProgress?: ProofProgressCallback): Promise<ProofResult>;
+    /**
+     * Generate a Fulfillment Proof
+     *
+     * Proves: Solver correctly executed the intent
+     */
+    generateFulfillmentProof(params: FulfillmentProofParams, onProgress?: ProofProgressCallback): Promise<ProofResult>;
+    /**
+     * Verify a proof
+     */
+    verifyProof(proof: ZKProof): Promise<boolean>;
+    /**
+     * Destroy the provider and free resources
+     */
+    destroy(): Promise<void>;
+    private ensureReady;
+    private computeCommitmentHash;
+    private assetIdToField;
+    private bytesToField;
+    private bigintToBytes;
+    private hexToField;
+    private fieldToBytes32;
+    private computeSenderCommitment;
+    private computeNullifier;
+    private computeOutputCommitment;
+    private computeSolverId;
+    private computeOracleMessageHash;
+    private getPublicKeyCoordinates;
+}
+
+/**
+ * Browser-compatible utilities for proof generation
+ *
+ * These utilities replace Node.js-specific functions (like Buffer)
+ * with browser-compatible alternatives using Web APIs.
+ *
+ * @module proofs/browser-utils
+ */
+/**
+ * Convert hex string to Uint8Array (browser-compatible)
+ */
+declare function hexToBytes(hex: string): Uint8Array;
+/**
+ * Convert Uint8Array to hex string (browser-compatible)
+ */
+declare function bytesToHex(bytes: Uint8Array): string;
+/**
+ * Check if running in browser environment
+ */
+declare function isBrowser(): boolean;
+/**
+ * Check if Web Workers are available
+ */
+declare function supportsWebWorkers(): boolean;
+/**
+ * Check if SharedArrayBuffer is available (required for some WASM operations)
+ */
+declare function supportsSharedArrayBuffer(): boolean;
+/**
+ * Get browser info for diagnostics
+ */
+declare function getBrowserInfo(): {
+    isBrowser: boolean;
+    supportsWorkers: boolean;
+    supportsSharedArrayBuffer: boolean;
+    userAgent: string | null;
+};
+
 /**
  * Options for creating a shielded intent
  */
@@ -1090,11 +1303,310 @@ declare class OneClickClient {
     private delay;
 }
 
+/**
+ * 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;
+/**
+ * Convert a secp256k1 public key to an Ethereum address
+ *
+ * Algorithm (EIP-5564 style):
+ * 1. Decompress the public key to uncompressed form (65 bytes)
+ * 2. Remove the 0x04 prefix (take last 64 bytes)
+ * 3. keccak256 hash of the 64 bytes
+ * 4. Take the last 20 bytes as the address
+ *
+ * @param publicKey - Compressed (33 bytes) or uncompressed (65 bytes) public key
+ * @returns Ethereum address (20 bytes, checksummed)
+ */
+declare function publicKeyToEthAddress(publicKey: HexString): HexString;
+/**
+ * Check if a chain uses ed25519 for stealth addresses
+ */
+declare function isEd25519Chain(chain: ChainId): boolean;
+/**
+ * Curve type used for stealth addresses
+ */
+type StealthCurve = 'secp256k1' | 'ed25519';
+/**
+ * Get the curve type used by a chain for stealth addresses
+ *
+ * @param chain - Chain identifier
+ * @returns 'ed25519' for Solana/NEAR, 'secp256k1' for EVM chains
+ */
+declare function getCurveForChain(chain: ChainId): StealthCurve;
+/**
+ * Generate a new ed25519 stealth meta-address keypair
+ *
+ * @param chain - Target chain (must be ed25519-compatible: solana, near)
+ * @param label - Optional human-readable label
+ * @returns Stealth meta-address and private keys
+ * @throws {ValidationError} If chain is invalid or not ed25519-compatible
+ */
+declare function generateEd25519StealthMetaAddress(chain: ChainId, label?: string): {
+    metaAddress: StealthMetaAddress;
+    spendingPrivateKey: HexString;
+    viewingPrivateKey: HexString;
+};
+/**
+ * Generate a one-time ed25519 stealth address for a recipient
+ *
+ * Algorithm (DKSAP for ed25519):
+ * 1. Generate ephemeral keypair (r, R = r*G)
+ * 2. Compute shared secret: S = r * P_spend (ephemeral scalar * spending public)
+ * 3. Hash shared secret: h = SHA256(S)
+ * 4. Derive stealth public key: P_stealth = P_view + h*G
+ *
+ * @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 generateEd25519StealthAddress(recipientMetaAddress: StealthMetaAddress): {
+    stealthAddress: StealthAddress;
+    sharedSecret: HexString;
+};
+/**
+ * Derive the private key for an ed25519 stealth address (for recipient to claim funds)
+ *
+ * Algorithm:
+ * 1. Compute shared secret: S = spend_scalar * R (spending scalar * ephemeral public)
+ * 2. Hash shared secret: h = SHA256(S)
+ * 3. Derive stealth private key: s_stealth = s_view + h (mod L)
+ *
+ * **IMPORTANT: Derived Key Format**
+ *
+ * The returned `privateKey` is a **raw scalar** in little-endian format, NOT a standard
+ * ed25519 seed. This is because the stealth private key is derived mathematically
+ * (s_view + hash), not generated from a seed.
+ *
+ * To compute the public key from the derived private key:
+ * ```typescript
+ * // CORRECT: Direct scalar multiplication
+ * const scalar = bytesToBigIntLE(hexToBytes(privateKey.slice(2)))
+ * const publicKey = ed25519.ExtendedPoint.BASE.multiply(scalar)
+ *
+ * // WRONG: Do NOT use ed25519.getPublicKey() - it will hash and clamp the input,
+ * // producing a different (incorrect) public key
+ * ```
+ *
+ * @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 (raw scalar, little-endian)
+ * @throws {ValidationError} If any input is invalid
+ */
+declare function deriveEd25519StealthPrivateKey(stealthAddress: StealthAddress, spendingPrivateKey: HexString, viewingPrivateKey: HexString): StealthAddressRecovery;
+/**
+ * Check if an ed25519 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 checkEd25519StealthAddress(stealthAddress: StealthAddress, spendingPrivateKey: HexString, viewingPrivateKey: HexString): boolean;
+/**
+ * Convert an ed25519 public key (hex) to a Solana address (base58)
+ *
+ * Solana addresses are base58-encoded 32-byte ed25519 public keys.
+ *
+ * @param publicKey - 32-byte ed25519 public key as hex string (with 0x prefix)
+ * @returns Base58-encoded Solana address
+ * @throws {ValidationError} If public key is invalid
+ *
+ * @example
+ * ```typescript
+ * const { stealthAddress } = generateEd25519StealthAddress(metaAddress)
+ * const solanaAddress = ed25519PublicKeyToSolanaAddress(stealthAddress.address)
+ * // Returns: "7Vbmv1jt4vyuqBZcpYPpnVhrqVe5e6ZPBJCyqLqzQPvN" (example)
+ * ```
+ */
+declare function ed25519PublicKeyToSolanaAddress(publicKey: HexString): string;
+/**
+ * Validate a Solana address format
+ *
+ * Checks that the address:
+ * - Is a valid base58 string
+ * - Decodes to exactly 32 bytes (ed25519 public key size)
+ *
+ * @param address - Base58-encoded Solana address
+ * @returns true if valid, false otherwise
+ *
+ * @example
+ * ```typescript
+ * isValidSolanaAddress('7Vbmv1jt4vyuqBZcpYPpnVhrqVe5e6ZPBJCyqLqzQPvN') // true
+ * isValidSolanaAddress('invalid') // false
+ * ```
+ */
+declare function isValidSolanaAddress(address: string): boolean;
+/**
+ * Convert a Solana address (base58) back to ed25519 public key (hex)
+ *
+ * @param address - Base58-encoded Solana address
+ * @returns 32-byte ed25519 public key as hex string (with 0x prefix)
+ * @throws {ValidationError} If address is invalid
+ *
+ * @example
+ * ```typescript
+ * const publicKey = solanaAddressToEd25519PublicKey('7Vbmv1jt4vyuqBZcpYPpnVhrqVe5e6ZPBJCyqLqzQPvN')
+ * // Returns: "0x..." (64 hex characters)
+ * ```
+ */
+declare function solanaAddressToEd25519PublicKey(address: string): HexString;
+/**
+ * Convert ed25519 public key to NEAR implicit account address
+ *
+ * NEAR implicit accounts are lowercase hex-encoded ed25519 public keys (64 characters).
+ * No prefix, just raw 32 bytes as lowercase hex.
+ *
+ * @param publicKey - 32-byte ed25519 public key as hex string (with 0x prefix)
+ * @returns NEAR implicit account address (64 lowercase hex characters, no prefix)
+ * @throws {ValidationError} If public key is invalid
+ *
+ * @example
+ * ```typescript
+ * const { stealthAddress } = generateEd25519StealthAddress(metaAddress)
+ * const nearAddress = ed25519PublicKeyToNearAddress(stealthAddress.address)
+ * // Returns: "ab12cd34..." (64 hex chars)
+ * ```
+ */
+declare function ed25519PublicKeyToNearAddress(publicKey: HexString): string;
+/**
+ * Convert NEAR implicit account address back to ed25519 public key
+ *
+ * @param address - NEAR implicit account address (64 hex characters)
+ * @returns ed25519 public key as HexString (with 0x prefix)
+ * @throws {ValidationError} If address is invalid
+ *
+ * @example
+ * ```typescript
+ * const publicKey = nearAddressToEd25519PublicKey("ab12cd34...")
+ * // Returns: "0xab12cd34..."
+ * ```
+ */
+declare function nearAddressToEd25519PublicKey(address: string): HexString;
+/**
+ * Validate a NEAR implicit account address
+ *
+ * NEAR implicit accounts are:
+ * - Exactly 64 lowercase hex characters
+ * - No prefix (no "0x")
+ * - Represent a 32-byte ed25519 public key
+ *
+ * @param address - Address to validate
+ * @returns true if valid NEAR implicit account address
+ *
+ * @example
+ * ```typescript
+ * isValidNearImplicitAddress("ab12cd34ef...") // true (64 hex chars)
+ * isValidNearImplicitAddress("0xab12...")     // false (has prefix)
+ * isValidNearImplicitAddress("alice.near")   // false (named account)
+ * isValidNearImplicitAddress("AB12CD...")    // false (uppercase)
+ * ```
+ */
+declare function isValidNearImplicitAddress(address: string): boolean;
+/**
+ * Check if a string is a valid NEAR account ID (named or implicit)
+ *
+ * Supports both:
+ * - Named accounts: alice.near, bob.testnet
+ * - Implicit accounts: 64 hex characters
+ *
+ * @param accountId - Account ID to validate
+ * @returns true if valid NEAR account ID
+ *
+ * @example
+ * ```typescript
+ * isValidNearAccountId("alice.near")     // true
+ * isValidNearAccountId("bob.testnet")    // true
+ * isValidNearAccountId("ab12cd34...")    // true (64 hex chars)
+ * isValidNearAccountId("ALICE.near")     // false (uppercase)
+ * isValidNearAccountId("a")              // false (too short)
+ * ```
+ */
+declare function isValidNearAccountId(accountId: string): boolean;
+
 /**
  * NEAR Intents Adapter for SIP Protocol
  *
  * Bridges SIP SDK with NEAR 1Click API, providing privacy-preserving
  * cross-chain swaps using stealth addresses.
+ *
+ * IMPORTANT: NEAR Intents (1Click API) operates on MAINNET ONLY.
+ * There is no testnet deployment. For testing:
+ * - Use `dry: true` for quote-only mode (real quotes, no execution)
+ * - Use MockSolver for unit tests
+ * - Use small mainnet amounts ($5-10) for integration testing
  */
 
 /**
@@ -1130,6 +1642,10 @@ interface PreparedSwap {
     };
     /** Shared secret for stealth address derivation (keep private!) */
     sharedSecret?: HexString;
+    /** Curve used for stealth address (for cross-chain compatibility) */
+    curve?: StealthCurve;
+    /** Native recipient address (converted from stealth public key) */
+    nativeRecipientAddress?: string;
 }
 /**
  * Result of executing a swap
@@ -1538,92 +2054,6 @@ declare function createProductionSIP(config: {
     proofProvider?: ProofProvider;
 }): 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;
-/**
- * Convert a secp256k1 public key to an Ethereum address
- *
- * Algorithm (EIP-5564 style):
- * 1. Decompress the public key to uncompressed form (65 bytes)
- * 2. Remove the 0x04 prefix (take last 64 bytes)
- * 3. keccak256 hash of the 64 bytes
- * 4. Take the last 20 bytes as the address
- *
- * @param publicKey - Compressed (33 bytes) or uncompressed (65 bytes) public key
- * @returns Ethereum address (20 bytes, checksummed)
- */
-declare function publicKeyToEthAddress(publicKey: HexString): HexString;
-
 /**
  * Privacy level handling for SIP Protocol
  *
@@ -2074,6 +2504,10 @@ 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 public key is valid ed25519 (32 bytes)
+ */
+declare function isValidEd25519PublicKey(key: string): boolean;
 /**
  * Check if a private key is valid (32 bytes)
  */
@@ -2107,6 +2541,281 @@ declare function isValidScalar(value: bigint): boolean;
  */
 declare function validateScalar(value: unknown, field: string): asserts value is bigint;
 
+/**
+ * Oracle Attestation Types
+ *
+ * Type definitions for the oracle attestation protocol.
+ *
+ * @see docs/specs/ORACLE-ATTESTATION.md
+ */
+
+/**
+ * Oracle identifier (SHA256 hash of public key)
+ */
+type OracleId = HexString;
+/**
+ * Oracle status in the registry
+ */
+type OracleStatus = 'active' | 'suspended' | 'removed';
+/**
+ * Oracle information stored in registry
+ */
+interface OracleInfo {
+    /** Unique oracle identifier (hash of public key) */
+    id: OracleId;
+    /** Oracle's Ed25519 public key (32 bytes) */
+    publicKey: HexString;
+    /** Human-readable name */
+    name: string;
+    /** Supported destination chains */
+    supportedChains: ChainId[];
+    /** Oracle endpoint URL */
+    endpoint: string;
+    /** Registration timestamp (Unix seconds) */
+    registeredAt: number;
+    /** Current status */
+    status: OracleStatus;
+    /** Reputation score (0-100) */
+    reputation: number;
+    /** Staked amount in smallest unit */
+    stake: bigint;
+}
+/**
+ * The canonical message format that oracles sign
+ *
+ * This structure is serialized deterministically for signing.
+ * Total serialized size: 197 bytes
+ */
+interface OracleAttestationMessage {
+    /** Protocol version (current: 1) */
+    version: number;
+    /** Destination chain numeric ID */
+    chainId: number;
+    /** Hash of original intent (32 bytes) */
+    intentHash: HexString;
+    /** Recipient address, normalized to 32 bytes */
+    recipient: HexString;
+    /** Amount delivered in smallest unit */
+    amount: bigint;
+    /** Asset identifier hash (32 bytes) */
+    assetId: HexString;
+    /** Transaction hash on destination chain (32 bytes) */
+    txHash: HexString;
+    /** Block number containing transaction */
+    blockNumber: bigint;
+    /** Block hash for finality verification (32 bytes) */
+    blockHash: HexString;
+    /** Unix timestamp of attestation creation */
+    timestamp: number;
+}
+/**
+ * A single oracle's signature on an attestation
+ */
+interface OracleSignature {
+    /** Oracle that produced this signature */
+    oracleId: OracleId;
+    /** Ed25519 signature (64 bytes) */
+    signature: HexString;
+}
+/**
+ * Complete attestation with message and signatures
+ */
+interface SignedOracleAttestation {
+    /** The attested message */
+    message: OracleAttestationMessage;
+    /** Signatures from k-of-n oracles */
+    signatures: OracleSignature[];
+}
+/**
+ * Oracle registry containing all registered oracles
+ */
+interface OracleRegistry {
+    /** Registered oracles indexed by ID */
+    oracles: Map<OracleId, OracleInfo>;
+    /** Required signature threshold (k in k-of-n) */
+    threshold: number;
+    /** Total number of oracles (n in k-of-n) */
+    totalOracles: number;
+    /** Registry version for upgrades */
+    version: number;
+    /** Last update timestamp */
+    lastUpdated: number;
+}
+/**
+ * Oracle registry configuration
+ */
+interface OracleRegistryConfig {
+    /** Minimum required signatures (default: 3) */
+    threshold?: number;
+    /** Oracle endpoint timeout in ms (default: 30000) */
+    timeout?: number;
+    /** Custom registry data (for testing) */
+    customOracles?: OracleInfo[];
+}
+/**
+ * Request for oracle attestation
+ */
+interface AttestationRequest {
+    /** Intent hash to attest */
+    intentHash: HexString;
+    /** Destination chain */
+    destinationChain: ChainId;
+    /** Expected recipient address */
+    expectedRecipient: HexString;
+    /** Expected asset identifier */
+    expectedAsset: HexString;
+    /** Minimum amount expected */
+    minAmount: bigint;
+    /** Deadline for fulfillment (Unix timestamp) */
+    deadline: number;
+}
+/**
+ * Result of attestation request
+ */
+interface AttestationResult {
+    /** Whether attestation was successful */
+    success: boolean;
+    /** The signed attestation (if successful) */
+    attestation?: SignedOracleAttestation;
+    /** Error message (if failed) */
+    error?: string;
+    /** Number of oracles that responded */
+    oracleResponses: number;
+    /** Number of valid signatures collected */
+    validSignatures: number;
+}
+/**
+ * Result of attestation verification
+ */
+interface VerificationResult {
+    /** Whether verification passed */
+    valid: boolean;
+    /** Number of valid signatures found */
+    validSignatures: number;
+    /** Required threshold */
+    threshold: number;
+    /** List of oracle IDs with valid signatures */
+    validOracles: OracleId[];
+    /** Error details (if invalid) */
+    errors?: string[];
+}
+/**
+ * Domain separator for attestation signing
+ */
+declare const ORACLE_DOMAIN = "SIP-ORACLE-ATTESTATION-V1";
+/**
+ * Current attestation protocol version
+ */
+declare const ATTESTATION_VERSION = 1;
+/**
+ * Default signature threshold
+ */
+declare const DEFAULT_THRESHOLD = 3;
+/**
+ * Default total oracles
+ */
+declare const DEFAULT_TOTAL_ORACLES = 5;
+/**
+ * Chain numeric IDs for attestation message
+ */
+declare const CHAIN_NUMERIC_IDS: Record<ChainId, number>;
+
+/**
+ * Oracle Attestation Verification
+ *
+ * Verification of oracle signatures on attestation messages.
+ *
+ * @see docs/specs/ORACLE-ATTESTATION.md Section 4
+ */
+
+/**
+ * Derive oracle ID from public key
+ *
+ * OracleId = SHA256(publicKey)
+ */
+declare function deriveOracleId(publicKey: HexString | Uint8Array): OracleId;
+/**
+ * Verify a signed oracle attestation
+ *
+ * Checks:
+ * 1. Sufficient signatures (>= threshold)
+ * 2. All signatures are from registered, active oracles
+ * 3. All signatures are valid Ed25519 signatures
+ * 4. No duplicate oracles
+ */
+declare function verifyAttestation(attestation: SignedOracleAttestation, registry: OracleRegistry): VerificationResult;
+/**
+ * Verify a single oracle signature
+ */
+declare function verifyOracleSignature(signature: OracleSignature, messageHash: Uint8Array, oracle: OracleInfo): boolean;
+/**
+ * Sign an attestation message (for oracle implementations)
+ */
+declare function signAttestationMessage(messageHash: Uint8Array, privateKey: Uint8Array): OracleSignature;
+/**
+ * Create a new oracle registry
+ */
+declare function createOracleRegistry(config?: OracleRegistryConfig): OracleRegistry;
+/**
+ * Add an oracle to the registry
+ */
+declare function addOracle(registry: OracleRegistry, oracle: OracleInfo): void;
+/**
+ * Remove an oracle from the registry
+ */
+declare function removeOracle(registry: OracleRegistry, oracleId: OracleId): boolean;
+/**
+ * Update oracle status
+ */
+declare function updateOracleStatus(registry: OracleRegistry, oracleId: OracleId, status: OracleInfo['status']): boolean;
+/**
+ * Get all active oracles
+ */
+declare function getActiveOracles(registry: OracleRegistry): OracleInfo[];
+/**
+ * Check if registry has enough active oracles for threshold
+ */
+declare function hasEnoughOracles(registry: OracleRegistry): boolean;
+
+/**
+ * Oracle Attestation Serialization
+ *
+ * Canonical serialization of attestation messages for signing and verification.
+ *
+ * @see docs/specs/ORACLE-ATTESTATION.md Section 2.2
+ */
+
+/**
+ * Serialize an attestation message to canonical byte format
+ *
+ * Layout (197 bytes total):
+ * - version: 1 byte
+ * - chainId: 4 bytes (big-endian)
+ * - intentHash: 32 bytes
+ * - recipient: 32 bytes
+ * - amount: 16 bytes (big-endian u128)
+ * - assetId: 32 bytes
+ * - txHash: 32 bytes
+ * - blockNumber: 8 bytes (big-endian)
+ * - blockHash: 32 bytes
+ * - timestamp: 8 bytes (big-endian)
+ */
+declare function serializeAttestationMessage(message: OracleAttestationMessage): Uint8Array;
+/**
+ * Deserialize bytes back to attestation message
+ */
+declare function deserializeAttestationMessage(bytes: Uint8Array): OracleAttestationMessage;
+/**
+ * Compute the hash to be signed for an attestation
+ *
+ * hash = SHA256(domain || serialized_message)
+ */
+declare function computeAttestationHash(message: OracleAttestationMessage): Uint8Array;
+/**
+ * Get the numeric chain ID for a chain identifier
+ */
+declare function getChainNumericId(chain: string): number;
+
 /**
  * Mock Solver Implementation
  *
@@ -5332,4 +6041,4 @@ declare function createMockLedgerAdapter(config: Omit<MockHardwareConfig, 'devic
  */
 declare function createMockTrezorAdapter(config: Omit<MockHardwareConfig, 'deviceType'>): MockTrezorAdapter;
 
-export { BaseWalletAdapter, type CommitmentPoint, ComplianceManager, type CreateIntentOptions, type CreatePaymentOptions, CryptoError, DerivationPath, 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, type HardwareAccount, type HardwareConnectionStatus, type HardwareDeviceInfo, HardwareErrorCode, type HardwareErrorCodeType, type HardwareEthereumTx, type HardwareSignRequest, type HardwareSignature, type HardwareTransport, type HardwareWalletConfig, HardwareWalletError, type HardwareWalletType, IntentBuilder, IntentError, type LedgerConfig, type LedgerModel, LedgerWalletAdapter, MockEthereumAdapter, type MockEthereumAdapterConfig, type MockHardwareConfig, MockLedgerAdapter, MockProofProvider, MockSolanaAdapter, type MockSolanaAdapterConfig, MockSolver, type MockSolverConfig, MockTrezorAdapter, MockWalletAdapter, NEARIntentsAdapter, type NEARIntentsAdapterConfig, NetworkError, NoirProofProvider, type NoirProviderConfig, OneClickClient, type OracleAttestation, PaymentBuilder, type PedersenCommitment, type PreparedSwap, type PrivacyConfig, type ProductionQuote, ProofError, type ProofFramework, ProofGenerationError, ProofNotImplementedError, type ProofProvider, type ProofResult, type ReceivedNote, SIP, type SIPConfig, SIPError, STABLECOIN_ADDRESSES, STABLECOIN_DECIMALS, STABLECOIN_INFO, 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 StablecoinInfo, type SwapRequest, type SwapResult, type TransactionData, type TransportType, Treasury, type TrezorConfig, type TrezorModel, TrezorWalletAdapter, ValidationError, type ValidityProofParams, type WalletAdapter, WalletError, ZcashRPCClient, ZcashRPCError, ZcashShieldedService, type ZcashShieldedServiceConfig, addBlindings, addCommitments, attachProofs, base58ToHex, checkStealthAddress, commit, commitZero, createCommitment, createEthereumAdapter, createLedgerAdapter, createMockEthereumAdapter, createMockEthereumProvider, createMockLedgerAdapter, createMockSolanaAdapter, createMockSolanaConnection, createMockSolanaProvider, createMockSolver, createMockTrezorAdapter, createNEARIntentsAdapter, createProductionSIP, createSIP, createShieldedIntent, createShieldedPayment, createSolanaAdapter, createTrezorAdapter, createWalletFactory, createZcashClient, createZcashShieldedService, decodeStealthMetaAddress, decryptMemo, decryptWithViewing, deriveStealthPrivateKey, deriveViewingKey, deserializeIntent, deserializePayment, detectEthereumWallets, detectSolanaWallets, encodeStealthMetaAddress, encryptForViewing, featureNotSupportedError, formatStablecoinAmount, fromHex, fromStablecoinUnits, generateBlinding, generateIntentId, generateRandomBytes, generateStealthAddress, generateStealthMetaAddress, generateViewingKey, getAvailableTransports, getChainsForStablecoin, getDefaultRpcEndpoint, getDerivationPath, getErrorMessage, getEthereumProvider, getGenerators, getIntentSummary, getPaymentSummary, getPaymentTimeRemaining, getPrivacyConfig, getPrivacyDescription, getSolanaProvider, getStablecoin, getStablecoinInfo, getStablecoinsForChain, getSupportedStablecoins, getTimeRemaining, hasErrorCode, hasRequiredProofs, hash, hexToNumber, isExpired, isNonNegativeAmount, isPaymentExpired, isPrivateWalletAdapter, isSIPError, isStablecoin, isStablecoinOnChain, isValidAmount, isValidChainId, isValidCompressedPublicKey, isValidHex, isValidHexLength, isValidPrivacyLevel, isValidPrivateKey, isValidScalar, isValidSlippage, isValidStealthMetaAddress, normalizeAddress, notConnectedError, publicKeyToEthAddress, registerWallet, secureWipe, secureWipeAll, serializeIntent, serializePayment, solanaPublicKeyToHex, subtractBlindings, subtractCommitments, supportsWebBluetooth, supportsWebHID, supportsWebUSB, toHex, toStablecoinUnits, trackIntent, trackPayment, validateAsset, validateCreateIntentParams, validateIntentInput, validateIntentOutput, validateScalar, validateViewingKey, verifyCommitment, verifyOpening, walletRegistry, withSecureBuffer, withSecureBufferSync, wrapError };
+export { ATTESTATION_VERSION, type AttestationRequest, type AttestationResult, BaseWalletAdapter, BrowserNoirProvider, type BrowserNoirProviderConfig, CHAIN_NUMERIC_IDS, type CommitmentPoint, ComplianceManager, type CreateIntentOptions, type CreatePaymentOptions, CryptoError, DEFAULT_THRESHOLD, DEFAULT_TOTAL_ORACLES, DerivationPath, 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, type HardwareAccount, type HardwareConnectionStatus, type HardwareDeviceInfo, HardwareErrorCode, type HardwareErrorCodeType, type HardwareEthereumTx, type HardwareSignRequest, type HardwareSignature, type HardwareTransport, type HardwareWalletConfig, HardwareWalletError, type HardwareWalletType, IntentBuilder, IntentError, type LedgerConfig, type LedgerModel, LedgerWalletAdapter, MockEthereumAdapter, type MockEthereumAdapterConfig, type MockHardwareConfig, MockLedgerAdapter, MockProofProvider, MockSolanaAdapter, type MockSolanaAdapterConfig, MockSolver, type MockSolverConfig, MockTrezorAdapter, MockWalletAdapter, NEARIntentsAdapter, type NEARIntentsAdapterConfig, NetworkError, NoirProofProvider, type NoirProviderConfig, ORACLE_DOMAIN, OneClickClient, type OracleAttestation, type OracleAttestationMessage, type OracleId, type OracleInfo, type OracleRegistry, type OracleRegistryConfig, type OracleSignature, type OracleStatus, PaymentBuilder, type PedersenCommitment, type PreparedSwap, type PrivacyConfig, type ProductionQuote, ProofError, type ProofFramework, ProofGenerationError, ProofNotImplementedError, type ProofProgressCallback, type ProofProvider, type ProofResult, type ReceivedNote, SIP, type SIPConfig, SIPError, STABLECOIN_ADDRESSES, STABLECOIN_DECIMALS, STABLECOIN_INFO, type SerializedError, type ShieldedBalance, type ShieldedSendParams, type ShieldedSendResult, type SignedOracleAttestation, type SolanaAdapterConfig, type SolanaCluster, type SolanaConnection, type SolanaPublicKey, type SolanaSendOptions, type SolanaSignature, type SolanaTransaction, type SolanaUnsignedTransaction, type SolanaVersionedTransaction, SolanaWalletAdapter, type SolanaWalletName, type SolanaWalletProvider, type StablecoinInfo, type StealthCurve, type SwapRequest, type SwapResult, type TransactionData, type TransportType, Treasury, type TrezorConfig, type TrezorModel, TrezorWalletAdapter, ValidationError, type ValidityProofParams, type VerificationResult, type WalletAdapter, WalletError, ZcashRPCClient, ZcashRPCError, ZcashShieldedService, type ZcashShieldedServiceConfig, addBlindings, addCommitments, addOracle, attachProofs, base58ToHex, bytesToHex as browserBytesToHex, hexToBytes as browserHexToBytes, checkEd25519StealthAddress, checkStealthAddress, commit, commitZero, computeAttestationHash, createCommitment, createEthereumAdapter, createLedgerAdapter, createMockEthereumAdapter, createMockEthereumProvider, createMockLedgerAdapter, createMockSolanaAdapter, createMockSolanaConnection, createMockSolanaProvider, createMockSolver, createMockTrezorAdapter, createNEARIntentsAdapter, createOracleRegistry, createProductionSIP, createSIP, createShieldedIntent, createShieldedPayment, createSolanaAdapter, createTrezorAdapter, createWalletFactory, createZcashClient, createZcashShieldedService, decodeStealthMetaAddress, decryptMemo, decryptWithViewing, deriveEd25519StealthPrivateKey, deriveOracleId, deriveStealthPrivateKey, deriveViewingKey, deserializeAttestationMessage, deserializeIntent, deserializePayment, detectEthereumWallets, detectSolanaWallets, ed25519PublicKeyToNearAddress, ed25519PublicKeyToSolanaAddress, encodeStealthMetaAddress, encryptForViewing, featureNotSupportedError, formatStablecoinAmount, fromHex, fromStablecoinUnits, generateBlinding, generateEd25519StealthAddress, generateEd25519StealthMetaAddress, generateIntentId, generateRandomBytes, generateStealthAddress, generateStealthMetaAddress, generateViewingKey, getActiveOracles, getAvailableTransports, getBrowserInfo, getChainNumericId, getChainsForStablecoin, getCurveForChain, getDefaultRpcEndpoint, getDerivationPath, getErrorMessage, getEthereumProvider, getGenerators, getIntentSummary, getPaymentSummary, getPaymentTimeRemaining, getPrivacyConfig, getPrivacyDescription, getSolanaProvider, getStablecoin, getStablecoinInfo, getStablecoinsForChain, getSupportedStablecoins, getTimeRemaining, hasEnoughOracles, hasErrorCode, hasRequiredProofs, hash, hexToNumber, isBrowser, isEd25519Chain, isExpired, isNonNegativeAmount, isPaymentExpired, isPrivateWalletAdapter, isSIPError, isStablecoin, isStablecoinOnChain, isValidAmount, isValidChainId, isValidCompressedPublicKey, isValidEd25519PublicKey, isValidHex, isValidHexLength, isValidNearAccountId, isValidNearImplicitAddress, isValidPrivacyLevel, isValidPrivateKey, isValidScalar, isValidSlippage, isValidSolanaAddress, isValidStealthMetaAddress, nearAddressToEd25519PublicKey, normalizeAddress, notConnectedError, publicKeyToEthAddress, registerWallet, removeOracle, secureWipe, secureWipeAll, serializeAttestationMessage, serializeIntent, serializePayment, signAttestationMessage, solanaAddressToEd25519PublicKey, solanaPublicKeyToHex, subtractBlindings, subtractCommitments, supportsSharedArrayBuffer, supportsWebBluetooth, supportsWebHID, supportsWebUSB, supportsWebWorkers, toHex, toStablecoinUnits, trackIntent, trackPayment, updateOracleStatus, validateAsset, validateCreateIntentParams, validateIntentInput, validateIntentOutput, validateScalar, validateViewingKey, verifyAttestation, verifyCommitment, verifyOpening, verifyOracleSignature, walletRegistry, withSecureBuffer, withSecureBufferSync, wrapError };