TAIFOON PROTOCOL — INFRASTRUCTURE QUICKSTART

5-Minute Infrastructure Quickstart

Bind any off-chain data response to an on-chain cryptographic anchor. Perfect for DePIN networks, oracle providers, RPC nodes, and indexers.

~4 min

Integration Time

~$0.01

Verification Cost

7 days

Proof Validity

01

Install Proof Anchoring SDK

Install the Taifoon proof anchoring library:

bash

npm install @taifoon/sdk
# or
pip install taifoon-anchor  # Python
# or
go get github.com/taifoon/taifoon-sdk  # Go

02

Anchor Your Data Response

Bind your API response to a specific block on any chain:

typescript

import { ProofClient } from '@taifoon/sdk/proof';

const anchor = new TaifoonAnchor({
  apiKey: process.env.TAIFOON_API_KEY
});

// Example: Oracle providing temperature data
async function provideTemperatureData(sensorId: string) {
  // Your off-chain data
  const temperature = await readSensor(sensorId);
  const timestamp = Date.now();

  // Anchor data to on-chain block
  const proof = await anchor.create({
    chainId: 1,  // Ethereum
    data: { sensorId, temperature, timestamp },
    commitmentType: 'merkle',  // or 'zk', 'signature'
  });

  return {
    temperature,
    timestamp,
    proof: proof.root,  // Merkle root committed on-chain
    verificationUrl: proof.url,
  };
}

03

Serve Data with Proof

Update your API to return proof metadata with every response:

typescript

// Before: Unverifiable response
app.get('/api/temperature/:sensorId', async (req, res) => {
  const temp = await readSensor(req.params.sensorId);
  res.json({ temperature: temp });  // ❌ No proof
});

// After: Proof-backed response
app.get('/api/temperature/:sensorId', async (req, res) => {
  const result = await provideTemperatureData(req.params.sensorId);

  res.json({
    temperature: result.temperature,
    timestamp: result.timestamp,
    // ✅ Proof metadata
    proof: {
      root: result.proof,
      verify: result.verificationUrl,
      chainId: 1,
      blockNumber: result.proof.blockNumber,
    },
  });
});

// Consumers can now verify your data on-chain!

04

Consumers Verify Your Data

Your users can now cryptographically verify your responses:

typescript

// Consumer side (smart contract or off-chain)
import { ProofClient } from '@taifoon/sdk/proof';

const verifier = new TaifoonVerifier();

// Fetch data from your API
const response = await fetch('https://api.yourservice.io/temperature/sensor-1');
const data = await response.json();

// Verify the proof on-chain
const isValid = await verifier.verify({
  chainId: data.proof.chainId,
  root: data.proof.root,
  data: { temperature: data.temperature, timestamp: data.timestamp },
});

if (isValid) {
  console.log('✅ Data is cryptographically verified');
  console.log('Temperature:', data.temperature);
} else {
  console.log('❌ Data verification failed');
}

// ✅ Guarantees:
// - Data existed at the claimed timestamp
// - Data hasn't been tampered with
// - Provider is accountable (proof is on-chain)