TaifoonTAIFOON
TaifoonTAIFOON
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)

You're Proof-Backed!

Your infrastructure now provides verifiable responses. Every API call includes a cryptographic proof that consumers can validate on-chain.

Infrastructure Use Cases

DePIN Networks
Energy grids, wireless networks, storage
Oracle Providers
Price feeds, weather, sports scores
RPC Providers
Verifiable RPC responses
Indexers
Proof-backed query results
Data APIs
Any off-chain data source
IoT Networks
Sensor data with proofs

Join the Grid — bring a resource

Run an RPC endpoint or a GPU box and earn GRID points for uptime we measure ourselves. A submission is a claim; a probe is evidence; only evidence earns. No wallet signature, no staking, no account — an address is enough to be paid. Every number on your console comes from the oracle's own probes, never from what you told us.

1

Check what is open and what it pays

bash
curl https://www.taifoon.io/api/grid/join
# → kinds.rpc  { open: true,  earnsPoints: true,  pointsPerHealthyProbe: 10 }
#   kinds.gpu  { open: true,  earnsPoints: false } # benchmarked + ranked, earns 0 until real GPU work exists
#   kinds.tee  { open: false }                     # no quote verification yet — a claim would earn nothing
2

Bring an RPC endpoint — one request

bash
curl -X POST https://www.taifoon.io/api/grid/join \
  -H 'content-type: application/json' \
  -d '{"kind":"rpc","chainId":8453,"endpoint":"https://your-node.example/rpc","owner":"0xYourAddress"}'
# We probe it and verify it serves chain 8453 via eth_chainId.
# A wrong chain is rejected with both numbers: "serves chain 1, not 8453".
# accepted:true means it was RECORDED and will be probed; points start at the first healthy probe.
3

Bring a GPU — solve the challenge, get ranked

bash
# ask to join → you receive {seed, difficulty, expiresAt}
curl -X POST https://www.taifoon.io/api/grid/join \
  -H 'content-type: application/json' \
  -d '{"kind":"gpu","endpoint":"https://your-box.example","owner":"0xYourAddress"}'

# solve keccak256(seed || nonce) to the difficulty (2-minute window), then:
curl -X POST https://www.taifoon.io/api/grid/benchmark \
  -H 'content-type: application/json' \
  -d '{"endpoint":"…","owner":"0x…","nonce":"…","digest":"0x…","elapsedMs":1234,"challenge":{…}}'
# We recompute the digest rather than trust it; throughput is derived from work over your wall time.
4

Watch it earn — your console

Sign in with the owner wallet at taifoon.io/hosting/resources: every resource, its trust level (proven · measured · claimed), live health, GRID pending, and your 70% share under the Taifoon Sustainable Use License. MCP clients: call taifoon_grid_status then taifoon_grid_join at POST https://www.taifoon.io/api/mcp.

Honest limits, stated up front: GRID points are a non-transferable record of measured work — the on-chain settlement contract is not yet deployed, so points accrue but do not settle. Endpoints must be https:// or wss:// hostnames (never a raw IP, never embedded credentials). Regions are never self-reported.