Accept Crypto Payments for Your Business

<!-- Include snarkjs library -->
<script src="https://cdn.jsdelivr.net/npm/snarkjs@latest/build/snarkjs.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/circomlibjs@latest/build/main.js"></script>

<!-- Or via npm -->
npm install snarkjs circomlibjs

import { buildPoseidon } from 'circomlibjs';

async function prepareWitnessInput(paymentData) {
  const poseidon = await buildPoseidon();
  
  // User's ShadowID commitment (from registration)
  const senderSecret = BigInt(localStorage.getItem('shadowid_secret'));
  const senderCommitment = poseidon.F.toString(poseidon([senderSecret]));
  
  // Get Merkle proof for sender
  const merkleProof = await fetch('https://shadow.radr.fun/shadowpay/api/shadowid/proof', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ commitment: senderCommitment })
  }).then(r => r.json());
  
  // Prepare witness input for circuit
  const witnessInput = {
    // Private inputs
    sender_commitment: senderCommitment,
    sender_secret: senderSecret.toString(),
    receiver_commitment: paymentData.merchantCommitment,
    amount: paymentData.amount.toString(), // lamports
    token_mint: "0", // 0 = SOL
    salt: generateRandomSalt(),
    merkle_path: merkleProof.proof.pathElements,
    path_indices: merkleProof.proof.pathIndices,
    
    // ElGamal encryption inputs
    encrypted_amount_c1: paymentData.elgamal.c1,
    encrypted_amount_c2: paymentData.elgamal.c2,
    elgamal_randomness: paymentData.elgamal.randomness,
    
    // Public inputs
    shadowid_root: merkleProof.proof.root,
    max_amount: (paymentData.amount * 2).toString(), // 2x buffer
    receiver_elgamal_pubkey: paymentData.merchantElGamalPubkey
  };
  
  return witnessInput;
}

function generateRandomSalt() {
  const randomBytes = new Uint8Array(32);
  crypto.getRandomValues(randomBytes);
  return BigInt('0x' + Array.from(randomBytes).map(b => b.toString(16).padStart(2, '0')).join(''));
}

async function generateGroth16Proof(witnessInput) {
  console.log('🔐 Generating Groth16 proof...');
  const startTime = Date.now();
  
  // Load circuit artifacts from cache (see Step 4 in Quick Start)
  const wasmB64 = localStorage.getItem('shadowpay_elgamal_wasm');
  const zkeyB64 = localStorage.getItem('shadowpay_elgamal_zkey');
  
  if (!wasmB64 || !zkeyB64) {
    throw new Error('Circuit artifacts not loaded. Run shadowpay.init() first.');
  }
  
  // Convert base64 to Uint8Array
  const wasmBytes = Uint8Array.from(atob(wasmB64), c => c.charCodeAt(0));
  const zkeyBytes = Uint8Array.from(atob(zkeyB64), c => c.charCodeAt(0));
  
  // Generate proof using snarkjs
  const { proof, publicSignals } = await snarkjs.groth16.fullProve(
    witnessInput,
    wasmBytes,
    zkeyBytes
  );
  
  const duration = Date.now() - startTime;
  console.log(`✅ Proof generated in ${duration}ms`);
  
  return {
    proof: {
      pi_a: proof.pi_a.slice(0, 2),
      pi_b: proof.pi_b.slice(0, 2).map(x => x.slice(0, 2)),
      pi_c: proof.pi_c.slice(0, 2),
      protocol: proof.protocol,
      curve: proof.curve
    },
    publicSignals: {
      shadowid_root: publicSignals[0],
      payment_commitment: publicSignals[1],
      payment_nullifier: publicSignals[2],
      encrypted_amount_commitment: publicSignals[3]
    },
    generationTime: duration
  };
}

async function makeZKPayment(merchantWallet, amount) {
  try {
    // 1. Encrypt amount with ElGamal (see ElGamal section)
    const elgamal = await encryptAmount(amount, merchantElGamalPubkey);
    
    // 2. Prepare witness input
    const witnessInput = await prepareWitnessInput({
      merchantCommitment: merchantWallet,
      merchantElGamalPubkey: merchantElGamalPubkey,
      amount: amount,
      elgamal: elgamal
    });
    
    // 3. Generate Groth16 proof
    const proofData = await generateGroth16Proof(witnessInput);
    
    // 4. Send to ShadowPay for verification and settlement
    const response = await fetch('https://shadow.radr.fun/shadowpay/settle', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        x402Version: 1,
        scheme: 'zkproof',
        network: 'solana-mainnet',
        proof: proofData.proof,
        publicSignals: proofData.publicSignals,
        encryptedAmount: {
          c1: elgamal.c1,
          c2: elgamal.c2
        },
        timestamp: Math.floor(Date.now() / 1000)
      })
    });
    
    const result = await response.json();
    
    if (result.success) {
      console.log('✅ Payment settled on-chain:', result.txHash);
      return {
        accessToken: result.accessToken,
        txHash: result.txHash,
        proofTime: proofData.generationTime
      };
    }
    
  } catch (error) {
    console.error('❌ Payment failed:', error);
    throw error;
  }
}

import { buildPoseidon } from 'circomlibjs';

class ElGamalEncryptor {
  constructor() {
    this.poseidon = null;
  }
  
  async init() {
    this.poseidon = await buildPoseidon();
  }
  
  /**
   * Encrypt a payment amount using ElGamal
   * @param {number} amount - Amount in lamports
   * @param {string} recipientPublicKey - Merchant's ElGamal public key
   * @returns {object} - { c1, c2, randomness }
   */
  encryptAmount(amount, recipientPublicKey) {
    if (!this.poseidon) {
      throw new Error('ElGamal not initialized. Call init() first.');
    }
    
    // Generate random value r
    const randomBytes = new Uint8Array(32);
    crypto.getRandomValues(randomBytes);
    const randomness = BigInt('0x' + Array.from(randomBytes)
      .map(b => b.toString(16).padStart(2, '0'))
      .join('')
    );
    
    // c1 = g^r = Poseidon(r)
    const c1 = this.poseidon.F.toString(
      this.poseidon([randomness])
    );
    
    // c2 = h^r + m = Poseidon(pubkey, r) + amount
    const sharedSecret = this.poseidon.F.toString(
      this.poseidon([BigInt(recipientPublicKey), randomness])
    );
    const c2 = (BigInt(sharedSecret) + BigInt(amount)).toString();
    
    return {
      c1: c1,
      c2: c2,
      randomness: randomness.toString()
    };
  }
  
  /**
   * For merchants: Decrypt a payment amount with secret key
   * @param {string} c1 - ElGamal ciphertext component 1
   * @param {string} c2 - ElGamal ciphertext component 2
   * @param {string} secretKey - Merchant's ElGamal secret key
   * @returns {string} - Decrypted amount in lamports
   */
  decryptAmount(c1, c2, secretKey) {
    if (!this.poseidon) {
      throw new Error('ElGamal not initialized. Call init() first.');
    }
    
    // Reconstruct public key from secret key
    const publicKey = this.poseidon.F.toString(
      this.poseidon([BigInt(secretKey)])
    );
    
    // Decrypt: m = c2 - Poseidon(publicKey, c1)
    const sharedSecret = this.poseidon.F.toString(
      this.poseidon([BigInt(publicKey), BigInt(c1)])
    );
    
    let amount = BigInt(c2) - BigInt(sharedSecret);
    
    // Handle negative values (field arithmetic wrap-around)
    const FIELD_SIZE = 2n ** 254n;
    if (amount < 0n) {
      amount += FIELD_SIZE;
    }
    
    return amount.toString();
  }
}

// Usage example
const elgamal = new ElGamalEncryptor();
await elgamal.init();

// Encrypt payment amount
const encrypted = elgamal.encryptAmount(
  1000000, // 0.001 SOL in lamports
  merchantElGamalPubkey
);

console.log('Encrypted amount:', {
  c1: encrypted.c1,
  c2: encrypted.c2
  // randomness is kept secret, used in ZK proof
});

// For merchants: Decrypt received payment
const decrypted = elgamal.decryptAmount(
  encrypted.c1,
  encrypted.c2,
  merchantElGamalSecretKey
);

console.log('Decrypted amount:', decrypted, 'lamports');

async function integratedPaymentExample() {
  // Initialize ElGamal
  const elgamal = new ElGamalEncryptor();
  await elgamal.init();
  
  // Get merchant's ElGamal public key
  const merchantInfo = await fetch(
    `https://shadow.radr.fun/api/merchant/info/${merchantWallet}`
  ).then(r => r.json());
  
  const merchantElGamalPubkey = merchantInfo.elgamal_public_key;
  
  // Encrypt payment amount
  const amount = 1000000; // 0.001 SOL
  const encrypted = elgamal.encryptAmount(amount, merchantElGamalPubkey);
  
  console.log('📦 Encrypted payment amount');
  console.log('   c1:', encrypted.c1.substring(0, 20) + '...');
  console.log('   c2:', encrypted.c2.substring(0, 20) + '...');
  
  // Use encrypted amount in ZK proof generation
  const proofData = await generateGroth16Proof({
    // ... other witness inputs
    encrypted_amount_c1: encrypted.c1,
    encrypted_amount_c2: encrypted.c2,
    elgamal_randomness: encrypted.randomness,
    receiver_elgamal_pubkey: merchantElGamalPubkey
  });
  
  // Payment is now private - only merchant can decrypt the amount!
  return { encrypted, proofData };
}