Integration Examples

import { ProofClient, VisibilityLevel } from '@proof-protocol/sdk';

const proof = new ProofClient({
  privateKey: process.env.PROOF_PRIVATE_KEY
});

// Wrap any fetch call
const response = await proof.record(
  fetch('https://api.example.com/data')
);

const data = await response.json();
console.log('Record ID:', response.proof.recordId);
console.log('Transaction:', response.proof.transactionHash);

import express from 'express';
import { ProofClient } from '@proof-protocol/sdk';

const app = express();
const proof = new ProofClient({
  privateKey: process.env.PROOF_PRIVATE_KEY
});

// Middleware to record all POST/PUT/DELETE requests
app.use(async (req, res, next) => {
  if (['POST', 'PUT', 'DELETE'].includes(req.method)) {
    const originalSend = res.send;

    res.send = async function(data) {
      // Record the request + response
      await proof.record(
        Promise.resolve({
          url: req.originalUrl,
          method: req.method,
          body: req.body,
          response: data
        }),
        {
          visibility: VisibilityLevel.PRIVATE,
          metadata: {
            userId: req.user?.id,
            endpoint: req.path,
            timestamp: new Date().toISOString()
          }
        }
      );

      originalSend.call(this, data);
    };
  }
  next();
});

app.post('/api/trade', async (req, res) => {
  // Your trade logic here
  const result = await processTrade(req.body);
  res.json(result);
  // Automatically recorded by middleware!
});

app.listen(3000);

// pages/api/trade.js
import { ProofClient, VisibilityLevel } from '@proof-protocol/sdk';

const proof = new ProofClient({
  privateKey: process.env.PROOF_PRIVATE_KEY
});

export default async function handler(req, res) {
  if (req.method !== 'POST') {
    return res.status(405).json({ error: 'Method not allowed' });
  }

  try {
    // Your business logic
    const tradeResult = await executeTrade(req.body);

    // Record on blockchain
    const proofResponse = await proof.record(
      Promise.resolve({
        endpoint: '/api/trade',
        request: req.body,
        response: tradeResult,
        user: req.session.user.id
      }),
      {
        visibility: VisibilityLevel.PRIVATE,
        metadata: {
          userId: req.session.user.id,
          tradeId: tradeResult.id,
          amount: req.body.amount,
          asset: req.body.asset
        }
      }
    );

    // Return result with proof
    res.status(200).json({
      success: true,
      trade: tradeResult,
      proof: {
        txHash: proofResponse.proof.transactionHash,
        recordId: proofResponse.proof.recordId,
        timestamp: proofResponse.proof.timestamp
      }
    });
  } catch (error) {
    console.error('Trade failed:', error);
    res.status(500).json({ error: 'Trade execution failed' });
  }
}

import { ProofClient, VisibilityLevel } from '@proof-protocol/sdk';

const proof = new ProofClient({
  privateKey: process.env.PROOF_PRIVATE_KEY
});

// PUBLIC: Regulatory filings (fully transparent)
await proof.record(
  fetch('/api/quarterly-report'),
  { visibility: VisibilityLevel.PUBLIC }
);

// PRIVATE: Client data (only you can access)
await proof.record(
  fetch('/api/client/sensitive-data'),
  {
    visibility: VisibilityLevel.PRIVATE,
    metadata: { clientId: 'client_123' }
  }
);

// SHARED: Multi-party access (Professional+ plan)
await proof.record(
  fetch('/api/consortium/shared-data'),
  {
    visibility: VisibilityLevel.SHARED,
    sharedWith: [
      '0x1234...', // Regulator address
      '0x5678...'  // Auditor address
    ],
    metadata: { dataType: 'audit_trail' }
  }
);