@sip-protocol/sdk 0.1.0

package/src/proofs/mock.ts

@@ -0,0 +1,258 @@
+/**
+ * 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.
+ */
+
+import type { ZKProof, HexString } from '@sip-protocol/types'
+import { sha256 } from '@noble/hashes/sha256'
+import { bytesToHex, randomBytes } from '@noble/hashes/utils'
+import type {
+  ProofProvider,
+  ProofFramework,
+  FundingProofParams,
+  ValidityProofParams,
+  FulfillmentProofParams,
+  ProofResult,
+} from './interface'
+import { ProofGenerationError } from './interface'
+import { ProofError, ErrorCode } from '../errors'
+
+/**
+ * Mock proof marker - all mock proofs start with this prefix
+ * This allows easy identification of mock proofs
+ */
+const MOCK_PROOF_PREFIX = '0x4d4f434b' // "MOCK" in hex
+
+/**
+ * Console warning message for mock provider usage
+ */
+const WARNING_MESSAGE = `
+╔══════════════════════════════════════════════════════════════╗
+║  ⚠️  MOCK PROOF PROVIDER - NOT FOR PRODUCTION USE  ⚠️         ║
+║                                                              ║
+║  Mock proofs provide NO cryptographic security guarantees.   ║
+║  Use NoirProofProvider for production deployments.           ║
+╚══════════════════════════════════════════════════════════════╝
+`
+
+/**
+ * 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
+ * })
+ * ```
+ */
+export class MockProofProvider implements ProofProvider {
+  readonly framework: ProofFramework = 'mock'
+  private _isReady = false
+  private _warningShown = false
+
+  get isReady(): boolean {
+    return this._isReady
+  }
+
+  /**
+   * Initialize the mock provider
+   *
+   * Logs a warning to console about mock usage.
+   */
+  async initialize(): Promise<void> {
+    if (!this._warningShown) {
+      console.warn(WARNING_MESSAGE)
+      this._warningShown = true
+    }
+    this._isReady = true
+  }
+
+  /**
+   * Generate a mock funding proof
+   *
+   * ⚠️ This proof provides NO cryptographic guarantees!
+   */
+  async generateFundingProof(params: FundingProofParams): Promise<ProofResult> {
+    this.ensureReady()
+
+    // Validate parameters (actual validation, not cryptographic)
+    if (params.balance < params.minimumRequired) {
+      throw new ProofGenerationError(
+        'funding',
+        'Balance is less than minimum required',
+      )
+    }
+
+    // Generate deterministic mock proof
+    const proofData = this.generateMockProofData('funding', params)
+
+    return {
+      proof: {
+        type: 'funding',
+        proof: proofData,
+        publicInputs: [
+          this.hashToHex(params.assetId),
+          `0x${params.minimumRequired.toString(16).padStart(16, '0')}`,
+        ],
+      },
+      publicInputs: [
+        this.hashToHex(params.assetId),
+        `0x${params.minimumRequired.toString(16).padStart(16, '0')}`,
+      ],
+    }
+  }
+
+  /**
+   * Generate a mock validity proof
+   *
+   * ⚠️ This proof provides NO cryptographic guarantees!
+   */
+  async generateValidityProof(params: ValidityProofParams): Promise<ProofResult> {
+    this.ensureReady()
+
+    // Validate parameters
+    if (params.timestamp >= params.expiry) {
+      throw new ProofGenerationError(
+        'validity',
+        'Intent has already expired',
+      )
+    }
+
+    // Generate deterministic mock proof
+    const proofData = this.generateMockProofData('validity', params)
+
+    return {
+      proof: {
+        type: 'validity',
+        proof: proofData,
+        publicInputs: [
+          params.intentHash,
+          `0x${params.timestamp.toString(16)}`,
+          `0x${params.expiry.toString(16)}`,
+        ],
+      },
+      publicInputs: [
+        params.intentHash,
+        `0x${params.timestamp.toString(16)}`,
+        `0x${params.expiry.toString(16)}`,
+      ],
+    }
+  }
+
+  /**
+   * Generate a mock fulfillment proof
+   *
+   * ⚠️ This proof provides NO cryptographic guarantees!
+   */
+  async generateFulfillmentProof(params: FulfillmentProofParams): Promise<ProofResult> {
+    this.ensureReady()
+
+    // Validate parameters
+    if (params.outputAmount < params.minOutputAmount) {
+      throw new ProofGenerationError(
+        'fulfillment',
+        'Output amount is less than minimum required',
+      )
+    }
+
+    if (params.fulfillmentTime > params.expiry) {
+      throw new ProofGenerationError(
+        'fulfillment',
+        'Fulfillment time is after expiry',
+      )
+    }
+
+    // Generate deterministic mock proof
+    const proofData = this.generateMockProofData('fulfillment', params)
+
+    return {
+      proof: {
+        type: 'fulfillment',
+        proof: proofData,
+        publicInputs: [
+          params.intentHash,
+          params.recipientStealth,
+          `0x${params.minOutputAmount.toString(16).padStart(16, '0')}`,
+        ],
+      },
+      publicInputs: [
+        params.intentHash,
+        params.recipientStealth,
+        `0x${params.minOutputAmount.toString(16).padStart(16, '0')}`,
+      ],
+    }
+  }
+
+  /**
+   * Verify a mock proof
+   *
+   * Only verifies that the proof has the mock prefix.
+   * ⚠️ This provides NO cryptographic verification!
+   */
+  async verifyProof(proof: ZKProof): Promise<boolean> {
+    this.ensureReady()
+
+    // Mock verification: just check the prefix
+    return proof.proof.startsWith(MOCK_PROOF_PREFIX)
+  }
+
+  /**
+   * Check if a proof is a mock proof
+   */
+  static isMockProof(proof: ZKProof): boolean {
+    return proof.proof.startsWith(MOCK_PROOF_PREFIX)
+  }
+
+  // ─── Private Methods ───────────────────────────────────────────────────────
+
+  private ensureReady(): void {
+    if (!this._isReady) {
+      throw new ProofError(
+        'MockProofProvider not initialized. Call initialize() first.',
+        ErrorCode.PROOF_PROVIDER_NOT_READY
+      )
+    }
+  }
+
+  private generateMockProofData(
+    proofType: string,
+    params: unknown,
+  ): HexString {
+    // Create deterministic proof data from inputs
+    const input = JSON.stringify({ type: proofType, params }, (_, v) =>
+      typeof v === 'bigint' ? v.toString() : v,
+    )
+    const hash = sha256(new TextEncoder().encode(input))
+
+    // Add some random bytes to make each proof unique
+    const random = randomBytes(16)
+
+    // Combine: MOCK prefix + hash + random
+    const combined = new Uint8Array(4 + hash.length + random.length)
+    combined.set(new TextEncoder().encode('MOCK'), 0)
+    combined.set(hash, 4)
+    combined.set(random, 4 + hash.length)
+
+    return `${MOCK_PROOF_PREFIX}${bytesToHex(combined.slice(4))}` as HexString
+  }
+
+  private hashToHex(data: string): HexString {
+    const hash = sha256(new TextEncoder().encode(data))
+    return `0x${bytesToHex(hash)}` as HexString
+  }
+}

package/src/proofs/noir.ts

@@ -0,0 +1,233 @@
+/**
+ * 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
+ */
+
+import type { ZKProof } from '@sip-protocol/types'
+import type {
+  ProofProvider,
+  ProofFramework,
+  FundingProofParams,
+  ValidityProofParams,
+  FulfillmentProofParams,
+  ProofResult,
+} from './interface'
+import { ProofGenerationError } from './interface'
+import { ProofError, ErrorCode } from '../errors'
+
+/**
+ * Noir circuit artifacts paths
+ * These will be populated when circuits are compiled (#14, #15, #16)
+ */
+interface NoirCircuitArtifacts {
+  fundingCircuit?: unknown
+  validityCircuit?: unknown
+  fulfillmentCircuit?: unknown
+}
+
+/**
+ * Noir Proof Provider Configuration
+ */
+export 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
+ * })
+ * ```
+ */
+export class NoirProofProvider implements ProofProvider {
+  readonly framework: ProofFramework = 'noir'
+  private _isReady = false
+  private config: NoirProviderConfig
+  private artifacts: NoirCircuitArtifacts = {}
+
+  constructor(config: NoirProviderConfig = {}) {
+    this.config = {
+      backend: 'barretenberg',
+      verbose: false,
+      ...config,
+    }
+  }
+
+  get isReady(): boolean {
+    return this._isReady
+  }
+
+  /**
+   * Initialize the Noir provider
+   *
+   * Loads circuit artifacts and initializes the proving backend.
+   *
+   * @throws Error if circuits are not yet implemented
+   */
+  async initialize(): Promise<void> {
+    // TODO: Implement when circuits are ready (#14, #15, #16)
+    //
+    // Implementation will:
+    // 1. Load compiled circuit artifacts from artifactsPath
+    // 2. Initialize Barretenberg backend
+    // 3. Load proving/verification keys
+    //
+    // Dependencies:
+    // - @noir-lang/noir_js
+    // - @noir-lang/backend_barretenberg
+    //
+    // Example:
+    // ```typescript
+    // import { Noir } from '@noir-lang/noir_js'
+    // import { BarretenbergBackend } from '@noir-lang/backend_barretenberg'
+    //
+    // const circuit = await import('./circuits/funding/target/funding.json')
+    // const backend = new BarretenbergBackend(circuit)
+    // const noir = new Noir(circuit, backend)
+    // ```
+
+    throw new ProofError(
+      'NoirProofProvider not yet implemented. ' +
+      'Circuits must be compiled first. See issues #14, #15, #16.',
+      ErrorCode.PROOF_NOT_IMPLEMENTED,
+      { context: { issues: ['#14', '#15', '#16'] } }
+    )
+  }
+
+  /**
+   * Generate a Funding Proof using Noir circuits
+   *
+   * @see docs/specs/FUNDING-PROOF.md
+   */
+  async generateFundingProof(_params: FundingProofParams): Promise<ProofResult> {
+    this.ensureReady()
+
+    // TODO: Implement when circuit is ready (#14)
+    //
+    // Implementation will:
+    // 1. Prepare witness inputs from params
+    // 2. Execute circuit to generate proof
+    // 3. Extract public inputs
+    //
+    // Example:
+    // ```typescript
+    // const witness = {
+    //   balance: params.balance,
+    //   minimum_required: params.minimumRequired,
+    //   blinding: params.blindingFactor,
+    //   // ... other inputs
+    // }
+    //
+    // const proof = await this.fundingCircuit.generateProof(witness)
+    // return { proof, publicInputs: proof.publicInputs }
+    // ```
+
+    throw new ProofGenerationError(
+      'funding',
+      'Noir circuit not yet implemented. See #14.',
+    )
+  }
+
+  /**
+   * Generate a Validity Proof using Noir circuits
+   *
+   * @see docs/specs/VALIDITY-PROOF.md
+   */
+  async generateValidityProof(_params: ValidityProofParams): Promise<ProofResult> {
+    this.ensureReady()
+
+    // TODO: Implement when circuit is ready (#15)
+    throw new ProofGenerationError(
+      'validity',
+      'Noir circuit not yet implemented. See #15.',
+    )
+  }
+
+  /**
+   * Generate a Fulfillment Proof using Noir circuits
+   *
+   * @see docs/specs/FULFILLMENT-PROOF.md
+   */
+  async generateFulfillmentProof(_params: FulfillmentProofParams): Promise<ProofResult> {
+    this.ensureReady()
+
+    // TODO: Implement when circuit is ready (#16)
+    throw new ProofGenerationError(
+      'fulfillment',
+      'Noir circuit not yet implemented. See #16.',
+    )
+  }
+
+  /**
+   * Verify a Noir proof
+   */
+  async verifyProof(_proof: ZKProof): Promise<boolean> {
+    this.ensureReady()
+
+    // TODO: Implement when circuits are ready
+    //
+    // Implementation will:
+    // 1. Determine proof type from proof.type
+    // 2. Use appropriate verifier circuit
+    // 3. Return verification result
+    //
+    // Example:
+    // ```typescript
+    // const verified = await this.backend.verifyProof(proof)
+    // return verified
+    // ```
+
+    throw new ProofError(
+      'Noir proof verification not yet implemented.',
+      ErrorCode.PROOF_NOT_IMPLEMENTED
+    )
+  }
+
+  // ─── Private Methods ───────────────────────────────────────────────────────
+
+  private ensureReady(): void {
+    if (!this._isReady) {
+      throw new ProofError(
+        'NoirProofProvider not initialized. Call initialize() first.',
+        ErrorCode.PROOF_PROVIDER_NOT_READY
+      )
+    }
+  }
+}