@sip-protocol/sdk 0.7.3 → 0.7.4

package/src/privacy-backends/privacycash.ts

@@ -69,6 +69,12 @@ import {
   type PoolInfo,
   type IPrivacyCashSDK,
 } from './privacycash-types'
+import { createPrivacyLogger } from '../privacy-logger'
+
+/** Privacy-aware logger for PrivacyCash backend */
+const privacyCashLogger = createPrivacyLogger('PrivacyCash')
+
+import { randomBytes, bytesToHex } from '@noble/hashes/utils'
 
 /**
  * Default estimated anonymity set size
@@ -219,9 +225,8 @@ export class PrivacyCashBackend implements PrivacyBackend {
 
     // Viewing keys are not supported - warn if provided
     if (params.viewingKey) {
-      console.warn(
-        '[PrivacyCash] Viewing keys are not supported. ' +
-        'Use SIP Native backend for compliance features.'
+      privacyCashLogger.warn(
+        'Viewing keys are not supported. Use SIP Native backend for compliance features.'
       )
     }
 
@@ -432,22 +437,13 @@ export class PrivacyCashBackend implements PrivacyBackend {
 
   /**
    * Generate a simulated withdrawal note
-   * In production, this comes from the deposit transaction
+   *
+   * Uses cryptographically secure random bytes.
+   * In production, this comes from the deposit transaction.
    */
   private generateSimulatedNote(): string {
-    const randomBytes = new Uint8Array(32)
-    if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
-      crypto.getRandomValues(randomBytes)
-    } else {
-      for (let i = 0; i < 32; i++) {
-        randomBytes[i] = Math.floor(Math.random() * 256)
-      }
-    }
-    // Convert to hex string (browser-compatible, no Buffer dependency)
-    const hex = Array.from(randomBytes)
-      .map(b => b.toString(16).padStart(2, '0'))
-      .join('')
-    return `privacycash:${hex}`
+    const bytes = randomBytes(32)
+    return `privacycash:${bytesToHex(bytes)}`
   }
 
   /**

package/src/privacy-backends/private-swap.ts

@@ -0,0 +1,570 @@
+/**
+ * Private Swap Integration
+ *
+ * Combines SIP Native (stealth addresses), C-SPL (encrypted amounts),
+ * and Arcium (MPC swap logic) for fully private DeFi swaps.
+ *
+ * ## Privacy Stack
+ *
+ * ```
+ * ┌─────────────────────────────────────────────────────────────┐
+ * │  FULL PRIVACY SWAP                                          │
+ * │                                                             │
+ * │  1. SIP Native → Hidden recipient (stealth address)         │
+ * │  2. C-SPL      → Hidden amounts (encrypted balances)        │
+ * │  3. Arcium     → Hidden swap logic (MPC computation)        │
+ * │                                                             │
+ * │  Result: No one can see who swapped what for how much       │
+ * └─────────────────────────────────────────────────────────────┘
+ * ```
+ *
+ * ## Use Cases
+ *
+ * - Private DEX trading (no front-running)
+ * - Institutional OTC swaps
+ * - Private portfolio rebalancing
+ * - Confidential DeFi operations
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   PrivateSwap,
+ *   SIPNativeBackend,
+ *   ArciumBackend,
+ *   CSPLClient,
+ * } from '@sip-protocol/sdk'
+ *
+ * const swap = new PrivateSwap({
+ *   sipBackend: new SIPNativeBackend(),
+ *   arciumBackend: new ArciumBackend(),
+ *   csplClient: new CSPLClient(),
+ * })
+ *
+ * const result = await swap.execute({
+ *   inputToken: { mint: 'SOL_MINT', ... },
+ *   outputToken: { mint: 'USDC_MINT', ... },
+ *   inputAmount: 1_000_000_000n, // 1 SOL
+ *   minOutputAmount: 50_000_000n, // Min 50 USDC
+ *   user: walletAddress,
+ * })
+ * ```
+ *
+ * @see https://docs.arcium.com
+ */
+
+import type { ComputationResult } from './interface'
+import type { SIPNativeBackend } from './sip-native'
+import type { ArciumBackend } from './arcium'
+import type { CSPLClient } from './cspl'
+import type {
+  CSPLToken,
+  ConfidentialSwapParams,
+  ConfidentialSwapResult,
+  EncryptedAmount,
+} from './cspl-types'
+
+import { sha256 } from '@noble/hashes/sha256'
+import { bytesToHex } from '@noble/hashes/utils'
+
+// ─── Configuration ────────────────────────────────────────────────────────────
+
+/**
+ * Configuration for PrivateSwap
+ */
+export interface PrivateSwapConfig {
+  /** SIP Native backend for stealth addresses */
+  sipBackend: SIPNativeBackend
+  /** Arcium backend for MPC swap logic */
+  arciumBackend: ArciumBackend
+  /** C-SPL client for confidential tokens */
+  csplClient: CSPLClient
+  /** Default slippage in basis points */
+  defaultSlippageBps?: number
+  /** Swap deadline in seconds from now */
+  defaultDeadlineSeconds?: number
+}
+
+/**
+ * Parameters for executing a private swap
+ */
+export interface PrivateSwapParams {
+  /** Input token being sold */
+  inputToken: CSPLToken
+  /** Output token being bought */
+  outputToken: CSPLToken
+  /** Input amount (plaintext, will be encrypted) */
+  inputAmount: bigint
+  /** Minimum output amount (slippage protection) */
+  minOutputAmount?: bigint
+  /** Slippage in basis points (overrides default) */
+  slippageBps?: number
+  /** Deadline timestamp (overrides default) */
+  deadline?: number
+  /** User's wallet address */
+  user: string
+  /** Use stealth address for output (full privacy) */
+  useStealthOutput?: boolean
+  /** Viewing key for compliance (optional) */
+  viewingKey?: string
+}
+
+/**
+ * Result of a private swap
+ */
+export interface PrivateSwapResult {
+  /** Whether swap succeeded */
+  success: boolean
+  /** Combined transaction signatures */
+  signatures: string[]
+  /** Arcium computation ID */
+  computationId?: string
+  /** Output amount received (if decryption available) */
+  outputAmount?: bigint
+  /** Stealth address used for output (if enabled) */
+  stealthAddress?: string
+  /** Total fees paid */
+  totalFees?: bigint
+  /** Swap route taken */
+  route?: string[]
+  /** Error message if failed */
+  error?: string
+  /** Detailed step results */
+  steps?: PrivateSwapStep[]
+}
+
+/**
+ * Individual step in a private swap
+ */
+export interface PrivateSwapStep {
+  /** Step name */
+  name: string
+  /** Step status */
+  status: 'pending' | 'processing' | 'completed' | 'failed'
+  /** Transaction signature (if applicable) */
+  signature?: string
+  /** Duration in milliseconds */
+  durationMs?: number
+  /** Error if step failed */
+  error?: string
+}
+
+// ─── Private Swap Class ───────────────────────────────────────────────────────
+
+/**
+ * Private Swap Orchestrator
+ *
+ * Coordinates SIP Native, C-SPL, and Arcium for fully private swaps.
+ */
+export class PrivateSwap {
+  private sipBackend: SIPNativeBackend
+  private arciumBackend: ArciumBackend
+  private csplClient: CSPLClient
+  private defaultSlippageBps: number
+  private defaultDeadlineSeconds: number
+
+  /**
+   * Create a new PrivateSwap instance
+   *
+   * @param config - Configuration with required backends
+   */
+  constructor(config: PrivateSwapConfig) {
+    if (!config.sipBackend) {
+      throw new Error('SIPNativeBackend is required')
+    }
+    if (!config.arciumBackend) {
+      throw new Error('ArciumBackend is required')
+    }
+    if (!config.csplClient) {
+      throw new Error('CSPLClient is required')
+    }
+
+    this.sipBackend = config.sipBackend
+    this.arciumBackend = config.arciumBackend
+    this.csplClient = config.csplClient
+    this.defaultSlippageBps = config.defaultSlippageBps ?? 50 // 0.5%
+    this.defaultDeadlineSeconds = config.defaultDeadlineSeconds ?? 300 // 5 minutes
+  }
+
+  /**
+   * Execute a fully private swap
+   *
+   * Steps:
+   * 1. Wrap input tokens to C-SPL (if not already)
+   * 2. Encrypt input amount
+   * 3. Execute swap via Arcium MPC
+   * 4. Receive output to stealth address (if enabled)
+   *
+   * @param params - Swap parameters
+   * @returns Swap result
+   */
+  async execute(params: PrivateSwapParams): Promise<PrivateSwapResult> {
+    const steps: PrivateSwapStep[] = []
+    const signatures: string[] = []
+    let startTime = Date.now()
+
+    try {
+      // ─── Step 1: Validate Inputs ──────────────────────────────────────────────
+      const validation = this.validateParams(params)
+      if (!validation.valid) {
+        return {
+          success: false,
+          signatures: [],
+          error: validation.error,
+        }
+      }
+
+      // ─── Step 2: Wrap Input Token to C-SPL ────────────────────────────────────
+      steps.push({ name: 'wrap_input', status: 'processing' })
+      const wrapResult = await this.csplClient.wrapToken({
+        mint: params.inputToken.mint,
+        amount: params.inputAmount,
+        owner: params.user,
+      })
+
+      if (!wrapResult.success) {
+        steps[steps.length - 1].status = 'failed'
+        steps[steps.length - 1].error = wrapResult.error
+        return {
+          success: false,
+          signatures,
+          error: `Failed to wrap input token: ${wrapResult.error}`,
+          steps,
+        }
+      }
+
+      steps[steps.length - 1].status = 'completed'
+      steps[steps.length - 1].signature = wrapResult.signature
+      steps[steps.length - 1].durationMs = Date.now() - startTime
+      if (wrapResult.signature) signatures.push(wrapResult.signature)
+      startTime = Date.now()
+
+      // ─── Step 3: Encrypt Input Amount ─────────────────────────────────────────
+      steps.push({ name: 'encrypt_amount', status: 'processing' })
+      const encryptedInput = await this.csplClient.encryptAmount({
+        amount: params.inputAmount,
+      })
+      steps[steps.length - 1].status = 'completed'
+      steps[steps.length - 1].durationMs = Date.now() - startTime
+      startTime = Date.now()
+
+      // ─── Step 4: Encrypt Min Output (Slippage Protection) ─────────────────────
+      let encryptedMinOutput: EncryptedAmount | undefined
+      if (params.minOutputAmount) {
+        steps.push({ name: 'encrypt_min_output', status: 'processing' })
+        encryptedMinOutput = await this.csplClient.encryptAmount({
+          amount: params.minOutputAmount,
+        })
+        steps[steps.length - 1].status = 'completed'
+        steps[steps.length - 1].durationMs = Date.now() - startTime
+        startTime = Date.now()
+      }
+
+      // ─── Step 5: Generate Stealth Address (if enabled) ────────────────────────
+      let stealthAddress: string | undefined
+      if (params.useStealthOutput) {
+        steps.push({ name: 'generate_stealth', status: 'processing' })
+        // In production: Use SIP Native to generate stealth address
+        // const stealthResult = await this.sipBackend.generateStealthAddress(...)
+        stealthAddress = this.generateSimulatedStealthAddress(params.user)
+        steps[steps.length - 1].status = 'completed'
+        steps[steps.length - 1].durationMs = Date.now() - startTime
+        startTime = Date.now()
+      }
+
+      // ─── Step 6: Execute Swap via Arcium MPC ──────────────────────────────────
+      steps.push({ name: 'arcium_swap', status: 'processing' })
+      const swapResult = await this.executeArciumSwap({
+        inputToken: params.inputToken,
+        outputToken: params.outputToken,
+        encryptedInputAmount: encryptedInput.ciphertext,
+        encryptedMinOutput: encryptedMinOutput?.ciphertext,
+        slippageBps: params.slippageBps ?? this.defaultSlippageBps,
+        deadline: params.deadline ?? this.calculateDeadline(),
+        user: stealthAddress ?? params.user,
+      })
+
+      if (!swapResult.success) {
+        steps[steps.length - 1].status = 'failed'
+        steps[steps.length - 1].error = swapResult.error
+        return {
+          success: false,
+          signatures,
+          computationId: swapResult.computationId,
+          error: `Arcium swap failed: ${swapResult.error}`,
+          steps,
+        }
+      }
+
+      steps[steps.length - 1].status = 'completed'
+      steps[steps.length - 1].durationMs = Date.now() - startTime
+      if (swapResult.computationId) {
+        // Track computation
+      }
+
+      // ─── Step 7: Unwrap Output (Optional) ─────────────────────────────────────
+      // In a full implementation, user would decide whether to keep output
+      // as C-SPL or unwrap to regular SPL
+
+      return {
+        success: true,
+        signatures,
+        computationId: swapResult.computationId,
+        outputAmount: swapResult.decryptedOutputAmount,
+        stealthAddress,
+        totalFees: this.estimateTotalFees(params),
+        route: [params.inputToken.symbol ?? 'INPUT', params.outputToken.symbol ?? 'OUTPUT'],
+        steps,
+      }
+    } catch (error) {
+      return {
+        success: false,
+        signatures,
+        error: error instanceof Error ? error.message : 'Unknown error during swap',
+        steps,
+      }
+    }
+  }
+
+  /**
+   * Get a quote for a private swap (estimate only)
+   *
+   * @param params - Swap parameters
+   * @returns Estimated output and fees
+   */
+  async getQuote(params: Omit<PrivateSwapParams, 'user'>): Promise<{
+    estimatedOutput: bigint
+    estimatedFees: bigint
+    priceImpact: number
+    route: string[]
+  }> {
+    // In production: Query AMM/DEX for actual quote
+    // This is a simplified simulation
+
+    // Simulate price (1 input token = 50 output tokens for demo)
+    const mockPrice = BigInt(50)
+    const estimatedOutput = params.inputAmount * mockPrice / BigInt(10 ** (params.inputToken.decimals - params.outputToken.decimals))
+
+    const estimatedFees = this.estimateTotalFees({
+      ...params,
+      user: 'quote',
+    })
+
+    // Simplified price impact (larger trades = more impact)
+    const priceImpact = Math.min(
+      Number(params.inputAmount) / 1e12, // Normalize
+      5.0 // Max 5%
+    )
+
+    return {
+      estimatedOutput,
+      estimatedFees,
+      priceImpact,
+      route: [
+        params.inputToken.symbol ?? 'INPUT',
+        params.outputToken.symbol ?? 'OUTPUT',
+      ],
+    }
+  }
+
+  /**
+   * Check if a swap is possible
+   *
+   * @param params - Swap parameters
+   * @returns Whether swap can be executed
+   */
+  async canSwap(params: PrivateSwapParams): Promise<{
+    canSwap: boolean
+    reason?: string
+  }> {
+    const validation = this.validateParams(params)
+    if (!validation.valid) {
+      return { canSwap: false, reason: validation.error }
+    }
+
+    // Check Arcium availability
+    const arciumAvailable = await this.arciumBackend.checkAvailability({
+      chain: 'solana',
+      circuitId: 'confidential-swap',
+      encryptedInputs: [new Uint8Array(64)],
+    })
+
+    if (!arciumAvailable.available) {
+      return { canSwap: false, reason: arciumAvailable.reason }
+    }
+
+    return { canSwap: true }
+  }
+
+  // ─── Private Methods ──────────────────────────────────────────────────────────
+
+  /**
+   * Validate swap parameters
+   */
+  private validateParams(params: PrivateSwapParams): {
+    valid: boolean
+    error?: string
+  } {
+    if (!params.inputToken || !params.inputToken.mint) {
+      return { valid: false, error: 'Input token is required' }
+    }
+    if (!params.outputToken || !params.outputToken.mint) {
+      return { valid: false, error: 'Output token is required' }
+    }
+    if (params.inputAmount <= BigInt(0)) {
+      return { valid: false, error: 'Input amount must be greater than 0' }
+    }
+    if (!params.user || params.user.trim() === '') {
+      return { valid: false, error: 'User address is required' }
+    }
+    if (params.inputToken.mint === params.outputToken.mint) {
+      return { valid: false, error: 'Cannot swap token for itself' }
+    }
+    if (params.minOutputAmount && params.minOutputAmount <= BigInt(0)) {
+      return { valid: false, error: 'Min output amount must be greater than 0' }
+    }
+    if (params.slippageBps && (params.slippageBps < 0 || params.slippageBps > 10000)) {
+      return { valid: false, error: 'Slippage must be between 0 and 10000 bps' }
+    }
+
+    return { valid: true }
+  }
+
+  /**
+   * Execute swap via Arcium MPC
+   */
+  private async executeArciumSwap(
+    params: ConfidentialSwapParams
+  ): Promise<ConfidentialSwapResult> {
+    // Prepare encrypted inputs for Arcium MPC
+    const encryptedInputs = [
+      params.encryptedInputAmount,
+      params.encryptedMinOutput ?? new Uint8Array(64),
+      new TextEncoder().encode(params.inputToken.confidentialMint),
+      new TextEncoder().encode(params.outputToken.confidentialMint),
+    ]
+
+    // Execute via Arcium
+    const result: ComputationResult = await this.arciumBackend.executeComputation({
+      chain: 'solana',
+      circuitId: 'confidential-swap-v1',
+      encryptedInputs,
+      options: {
+        slippageBps: params.slippageBps,
+        deadline: params.deadline,
+        user: params.user,
+      },
+    })
+
+    if (!result.success) {
+      return {
+        success: false,
+        error: result.error,
+        computationId: result.computationId,
+      }
+    }
+
+    // Await computation completion
+    const completion = await this.arciumBackend.awaitComputation(
+      result.computationId!
+    )
+
+    if (!completion.success) {
+      return {
+        success: false,
+        error: completion.error,
+        computationId: result.computationId,
+      }
+    }
+
+    return {
+      success: true,
+      computationId: result.computationId,
+      encryptedOutputAmount: completion.output,
+      // In production: Decrypt output for user
+      decryptedOutputAmount: this.simulateOutputAmount(params),
+      metadata: {
+        dex: 'arcium-amm',
+        route: [params.inputToken.symbol ?? 'INPUT', params.outputToken.symbol ?? 'OUTPUT'],
+      },
+    }
+  }
+
+  /**
+   * Calculate deadline timestamp
+   */
+  private calculateDeadline(): number {
+    return Math.floor(Date.now() / 1000) + this.defaultDeadlineSeconds
+  }
+
+  /**
+   * Estimate total fees for a swap
+   */
+  private estimateTotalFees(params: PrivateSwapParams): bigint {
+    void params // Used in real implementation
+    // C-SPL wrap + Arcium computation + network fees
+    const wrapFee = BigInt(5_000)
+    const arciumFee = BigInt(50_000_000) // ~0.05 SOL for MPC
+    const networkFee = BigInt(10_000)
+
+    return wrapFee + arciumFee + networkFee
+  }
+
+  /**
+   * Generate simulated stealth address
+   */
+  private generateSimulatedStealthAddress(user: string): string {
+    const timestamp = Date.now().toString(36)
+    const hash = this.simpleHash(user + timestamp)
+    return `stealth_${hash}`
+  }
+
+  /**
+   * Simulate output amount (for testing)
+   */
+  private simulateOutputAmount(params: ConfidentialSwapParams): bigint {
+    void params // Would use actual price in production
+    // Simulate ~50:1 price ratio
+    return BigInt(50_000_000) // 50 USDC for 1 SOL
+  }
+
+  /**
+   * Secure hash for simulation
+   *
+   * Uses SHA-256 for collision-resistant hashing.
+   */
+  private simpleHash(input: string): string {
+    const encoder = new TextEncoder()
+    const hash = sha256(encoder.encode(input))
+    return bytesToHex(hash).slice(0, 16)
+  }
+
+  // ─── Getters ────────────────────────────────────────────────────────────────
+
+  /**
+   * Get default slippage
+   */
+  getDefaultSlippageBps(): number {
+    return this.defaultSlippageBps
+  }
+
+  /**
+   * Get default deadline
+   */
+  getDefaultDeadlineSeconds(): number {
+    return this.defaultDeadlineSeconds
+  }
+
+  /**
+   * Get SIP backend name
+   */
+  getSIPBackendName(): string {
+    return this.sipBackend.name
+  }
+
+  /**
+   * Get Arcium backend name
+   */
+  getArciumBackendName(): string {
+    return this.arciumBackend.name
+  }
+}