Payment Channels

interface ChannelState {
  channelId: string;           // Unique channel identifier
  nonce: number;                // Monotonically increasing sequence
  balances: {
    user: bigint;               // User's channel balance (lamports)
    counterparty: bigint;       // Server's channel balance
  };
  timeout: number;              // Unix timestamp for dispute resolution
  revocationHashes: string[];   // Previous state invalidation proofs
}

interface CommitmentTransaction {
  state: ChannelState;
  signatures: {
    user: string;               // User's TSS signature (share 1+2)
    counterparty: string;       // Server's signature
  };
  merkleProof?: string[];       // Optional: batched channel proof
}

class RevocationChain {
  // Generate revocation secret for state N
  static generateSecret(): Uint8Array {
    return crypto.getRandomValues(new Uint8Array(32));
  }

  // Hash secret to create public revocation hash
  static hashSecret(secret: Uint8Array): string {
    return Buffer.from(
      sha256(secret)
    ).toString('hex');
  }

  // Verify revocation claim
  static verifyRevocation(
    claimedSecret: Uint8Array,
    revocationHash: string
  ): boolean {
    return this.hashSecret(claimedSecret) === revocationHash;
  }
}

// State update protocol
async function updateChannelState(
  currentState: ChannelState,
  newBalances: { user: bigint; counterparty: bigint }
): Promise<ChannelState> {
  // Generate new revocation secret (not revealed yet)
  const newSecret = RevocationChain.generateSecret();
  const newRevocationHash = RevocationChain.hashSecret(newSecret);

  // Increment nonce for new state
  const newState: ChannelState = {
    ...currentState,
    nonce: currentState.nonce + 1,
    balances: newBalances,
    revocationHashes: [
      ...currentState.revocationHashes,
      newRevocationHash
    ]
  };

  // Exchange signatures (2-of-3 TSS)
  const userSig = await signWithThreshold(newState, ['user', 'agent']);
  const counterpartySig = await counterpartySign(newState);

  // Reveal OLD state's revocation secret (invalidate previous)
  await revealSecret(currentState.nonce);

  return newState;
}

// Fraud proof: if old state broadcast, claim channel funds
async function submitFraudProof(
  broadcastState: ChannelState,
  newerState: ChannelState,
  revocationSecret: Uint8Array
): Promise<void> {
  if (newerState.nonce <= broadcastState.nonce) {
    throw new Error('Not a fraud: newer state must have higher nonce');
  }

  // Verify we know the revocation secret for broadcast state
  const isValid = RevocationChain.verifyRevocation(
    revocationSecret,
    broadcastState.revocationHashes[broadcastState.nonce]
  );

  if (!isValid) {
    throw new Error('Invalid revocation secret');
  }

  // Submit fraud proof on-chain → claim all channel funds
  await settlementContract.claimFraud(
    broadcastState,
    newerState,
    revocationSecret
  );
}

import { Connection, PublicKey, Transaction } from '@solana/web3.js';
import { X402ChannelProgram } from '@x402/solana';

class PaymentChannelClient {
  constructor(
    private connection: Connection,
    private program: X402ChannelProgram,
    private userWallet: ThresholdWallet  // 2-of-3 TSS wallet
  ) {}

  /**
   * Open a payment channel with initial deposit
   */
  async openChannel(
    counterparty: PublicKey,
    initialDeposit: bigint  // in lamports (1 USDC = 1e6 lamports)
  ): Promise<string> {
    // Generate unique channel ID
    const channelId = PublicKey.unique();

    // Create funding transaction (on-chain)
    const tx = await this.program.methods
      .openChannel(initialDeposit)
      .accounts({
        channel: channelId,
        user: this.userWallet.publicKey,
        counterparty,
        tokenMint: USDC_MINT,
        systemProgram: SystemProgram.programId,
      })
      .transaction();

    // Sign with 2-of-3 threshold (user + agent shares)
    const signature = await this.userWallet.signTransaction(tx);

    // Broadcast to chain
    await this.connection.sendTransaction(tx, [signature]);

    console.log(`Channel opened: ${channelId.toBase58()}`);
    return channelId.toBase58();
  }

  /**
   * Update channel state (off-chain)
   */
  async updateState(
    channelId: string,
    currentState: ChannelState,
    payment: bigint  // amount to pay counterparty
  ): Promise<ChannelState> {
    // Verify sufficient balance
    if (currentState.balances.user < payment) {
      throw new Error('Insufficient channel balance');
    }

    // Compute new balances
    const newBalances = {
      user: currentState.balances.user - payment,
      counterparty: currentState.balances.counterparty + payment
    };

    // Create new state
    const newState: ChannelState = {
      channelId,
      nonce: currentState.nonce + 1,
      balances: newBalances,
      timeout: Date.now() + 3600_000,  // 1 hour dispute window
      revocationHashes: [
        ...currentState.revocationHashes,
        await this.generateRevocationHash()
      ]
    };

    // Sign with threshold wallet (user + agent)
    const userSig = await this.userWallet.signMessage(
      this.serializeState(newState)
    );

    // Exchange signatures with counterparty (off-chain)
    const counterpartySig = await this.requestCounterpartySignature(newState);

    // Store signed state (local database, not blockchain)
    await this.storeState({
      state: newState,
      signatures: { user: userSig, counterparty: counterpartySig }
    });

    // Reveal revocation secret for previous state
    await this.revealRevocationSecret(currentState.nonce);

    return newState;
  }

  /**
   * Close channel cooperatively (on-chain)
   */
  async closeChannel(
    channelId: string,
    finalState: ChannelState,
    signatures: { user: string; counterparty: string }
  ): Promise<void> {
    // Create settlement transaction
    const tx = await this.program.methods
      .closeChannel(finalState, signatures)
      .accounts({
        channel: new PublicKey(channelId),
        user: this.userWallet.publicKey,
        counterparty: finalState.counterparty,
        tokenMint: USDC_MINT,
      })
      .transaction();

    // Sign with threshold wallet
    const signature = await this.userWallet.signTransaction(tx);

    // Broadcast to chain
    await this.connection.sendTransaction(tx, [signature]);

    console.log(`Channel closed. Final: ${finalState.balances.user} (user), ${finalState.balances.counterparty} (counterparty)`);
  }

  /**
   * Submit fraud proof if counterparty broadcasts old state
   */
  async submitFraudProof(
    channelId: string,
    broadcastState: ChannelState,
    newerState: ChannelState,
    revocationSecret: Uint8Array
  ): Promise<void> {
    const tx = await this.program.methods
      .claimFraud(broadcastState, newerState, revocationSecret)
      .accounts({
        channel: new PublicKey(channelId),
        claimant: this.userWallet.publicKey,
      })
      .transaction();

    const signature = await this.userWallet.signTransaction(tx);
    await this.connection.sendTransaction(tx, [signature]);

    console.log('Fraud proven. Claimed entire channel balance.');
  }

  // Helper methods
  private serializeState(state: ChannelState): Uint8Array {
    return Buffer.from(JSON.stringify(state));
  }

  private async generateRevocationHash(): Promise<string> {
    const secret = crypto.getRandomValues(new Uint8Array(32));
    const hash = await crypto.subtle.digest('SHA-256', secret);
    return Buffer.from(hash).toString('hex');
  }

  private async requestCounterpartySignature(
    state: ChannelState
  ): Promise<string> {
    // Off-chain communication with API server
    const response = await fetch('https://api.example.com/x402/sign', {
      method: 'POST',
      body: JSON.stringify(state),
    });
    return (await response.json()).signature;
  }

  private async storeState(commitment: CommitmentTransaction): Promise<void> {
    // Store in local IndexedDB or server database
    await db.channelStates.put(commitment);
  }

  private async revealRevocationSecret(nonce: number): Promise<void> {
    const secret = await db.revocationSecrets.get(nonce);
    await this.sendToCounterparty({ type: 'revocation', nonce, secret });
  }
}

// Usage example: Agent making API calls via payment channel
async function agentWorkflow() {
  const client = new PaymentChannelClient(
    connection,
    program,
    agentWallet
  );

  // Open channel with 100 USDC
  const channelId = await client.openChannel(
    apiProviderPublicKey,
    100_000_000n  // 100 USDC in lamports
  );

  let state: ChannelState = await client.getInitialState(channelId);

  // Make 1000 API calls (off-chain updates)
  for (let i = 0; i < 1000; i++) {
    // Pay 0.01 USDC per API call
    state = await client.updateState(channelId, state, 10_000n);

    // Make API call (x402 provider verifies state off-chain)
    const result = await fetch('https://api.example.com/inference', {
      headers: {
        'X-Payment-Channel': channelId,
        'X-Payment-State': JSON.stringify(state),
      },
    });

    console.log(`API call ${i + 1}: ${result.status}`);
  }

  // Close channel (only 2 on-chain transactions for 1000 API calls!)
  await client.closeChannel(channelId, state, {
    user: await agentWallet.signMessage(serializeState(state)),
    counterparty: await getCounterpartySignature(state),
  });

  console.log('Workflow complete. Gas cost: ~$0.0002 for 1000 API calls');
}