실내외 공기질 데이터 생태계와
온체인 데이터 거래 인프라

// ASCII → 20-byte hex (right-padded with zeros)
export const toCurrencyHex = (code: string): string => {
  if (code.length <= 3) return code;              // 3 chars or fewer pass through
  return Buffer.from(code, 'ascii').toString('hex').toUpperCase().padEnd(40, '0');
};

export const WLBN  = toCurrencyHex('WLBN');   // 574C424E00000000000000000000000000000000
export const RLUSD = toCurrencyHex('RLUSD');  // 524C555344000000000000000000000000000000

XRPL_ENDPOINT=wss://s.altnet.rippletest.net:51233
XRPL_NETWORK=testnet

# Cold — bootstrap script only. Never inject into the runtime server
ISSUER_SEED=sEd..............................

# Hot — API server runtime
OPERATIONAL_SEED=sEd..............................
OPERATIONAL_ADDRESS=r..............................

# Mock wallets (testing only)
DEVICE_SEED=sEd..............................
AGENT_SEED=sEd..............................

# Pricing policy
X402_PRICE_WLBN=0.1
X402_PRICE_RLUSD=0.001
X402_DEST_TAG=402001
DEPIN_REWARD_WLBN=1
BURN_RATIO=0.5

import { Client, Wallet, SubmittableTransaction, TxResponse } from 'xrpl';

export class TxError extends Error {
  constructor(public code: string, public hash?: string) {
    super(`XRPL tx failed: ${code}${hash ? ` (${hash})` : ''}`);
  }
}

/** autofill → sign → submitAndWait → verify tesSUCCESS + validated */
export async function submit(
  client: Client, wallet: Wallet, tx: SubmittableTransaction,
): Promise<TxResponse> {
  const prepared = await client.autofill(tx);
  const signed = wallet.sign(prepared);
  const res = await client.submitAndWait(signed.tx_blob);

  const meta = res.result.meta;
  const code = typeof meta === 'object' && meta !== null
    ? (meta as { TransactionResult: string }).TransactionResult
    : 'UNKNOWN';

  if (code !== 'tesSUCCESS') throw new TxError(code, res.result.hash);
  if (res.result.validated !== true) throw new TxError('NOT_VALIDATED', res.result.hash);
  return res;
}

/**
 * Absolute humidity (g/m³) via the Magnus approximation.
 * Dehumidification algorithms and condensation prediction take this, not relative humidity.
 */
export function absoluteHumidity(tempC: number, rh: number): number {
  const es = 6.112 * Math.exp((17.67 * tempC) / (tempC + 243.5));  // saturation vapor pressure, hPa
  const e = es * (rh / 100);                                        // actual vapor pressure, hPa
  return (216.7 * e) / (tempC + 273.15);                            // g/m³
}

/** Dew point (°C) — direct input to the condensation-prevention model */
export function dewPoint(tempC: number, rh: number): number {
  const gamma = (17.67 * tempC) / (tempC + 243.5) + Math.log(rh / 100);
  return (243.5 * gamma) / (17.67 - gamma);
}

// absoluteHumidity(20, 60) → 10.35    absoluteHumidity(30, 60) → 18.21

{
  "schema": "kweather-iaq-telemetry/v1",
  "deviceAddress": "rDeviceWalletAddress...",
  "signature": "3045022100...",
  "batch": [
    {
      "ts": 1786195200,
      "pm1": 6.2, "pm25": 11.4, "pm10": 15.8,
      "co2": 812, "tvoc": 143,
      "tempC": 23.4, "rh": 58.1, "hpa": 1008.3
    },
    {
      "ts": 1786195260,
      "pm1": 6.0, "pm25": 11.1, "pm10": 15.2,
      "co2": 845, "tvoc": 139,
      "tempC": 23.4, "rh": 58.4, "hpa": 1008.2
    }
  ]
}

{
  "schema": "kweather-iaq-device/v1",
  "name": "Kweather IAQ Node #10427",
  "description": "Indoor Air Quality license",
  "device": {
    "serial": "KW-IAQ-10427",
    "model": "KW-AIR-2",
    "sensors": ["pm1", "pm25", "pm10", "co2", "tvoc", "temp", "rh", "hpa"],
    "installed_at": "2026-05-02"
  },
  "context": {
    "geohash5": "wydm9",
    "space_type": "residential",
    "area_bucket": "60-85sqm",
    "floor_bucket": "5-10F",
    "build_year_bucket": "2010-2019",
    "orientation": "S"
  },
  "license": { "tier": "iaq-pro", "reward_multiplier": 2.2, "valid_until": "2029-05-02" }
}

export interface QualityInputs {
  uptimeRatio: number;    // actual submissions / expected submissions, last 24h
  outlierRatio: number;   // share of out-of-range + sudden-jump outliers
  neighborCorr: number;   // temp/PM trend correlation with nodes within 2km (-1 to 1)
  driftDays: number;      // days since last calibration
}

const clamp01 = (x: number) => Math.min(1, Math.max(0, x));

/** 0 to 1. Weights sum to 1.0 */
export function qualityScore(q: QualityInputs): number {
  const uptime = clamp01(q.uptimeRatio);
  const clean  = clamp01(1 - q.outlierRatio * 4);        // 25% outliers scores zero
  const agree  = clamp01((q.neighborCorr - 0.3) / 0.6);  // zero below 0.3, full marks at 0.9
  const fresh  = clamp01(1 - q.driftDays / 365);         // zero after a year without calibration

  const score = 0.40 * uptime + 0.25 * clean + 0.20 * agree + 0.15 * fresh;
  return Math.round(score * 1000) / 1000;
}

import { qualityScore, QualityInputs } from './quality';

export const TIER_MULTIPLIER: Record<string, number> = {
  'iaq-lite': 1.0, 'iaq-standard': 1.6, 'iaq-pro': 2.2,
  'oaq-standard': 1.4, 'oaq-pro': 2.4,
};

export interface NodeEpochStats { address: string; tier: string; quality: QualityInputs; }

/**
 * Reward distribution for one settlement epoch.
 * Total payout never exceeds EPOCH_BUDGET — fixed regardless of node count.
 */
export function distribute(nodes: NodeEpochStats[], epochBudgetWlbn: number) {
  const weighted = nodes.map((n) => ({
    address: n.address,
    weight: (TIER_MULTIPLIER[n.tier] ?? 1) * qualityScore(n.quality),
  })).filter((n) => n.weight > 0);

  const total = weighted.reduce((s, n) => s + n.weight, 0);
  if (total === 0) return [];

  // prevent a single node dominating — per-payout cap is 0.5% of budget
  const perNodeCap = epochBudgetWlbn * 0.005;

  return weighted.map((n) => ({
    address: n.address,
    amount: Math.min((n.weight / total) * epochBudgetWlbn, perNodeCap).toFixed(6),
  }));
}

export const K_MIN = 5;

export interface NodeSummary { geohash5: string; tier: string; hourly: HourlyStats; }
export interface Bucket { geohash: string; precision: number; n: number; stats: HourlyStats; }

/**
 * P4 — roll up to coarser cells until k-anonymity is satisfied.
 * If geohash3 (~156km) is still short, return null and the API refuses to respond.
 */
export function rollupToKAnonymous(nodes: NodeSummary[], geohash: string): Bucket | null {
  for (let precision = Math.min(5, geohash.length); precision >= 3; precision--) {
    const prefix = geohash.slice(0, precision);
    const members = nodes.filter((n) => n.geohash5.startsWith(prefix));

    if (members.length >= K_MIN) {
      return { geohash: prefix, precision, n: members.length, stats: aggregate(members) };
    }
  }
  return null;
}

/** P3 — derive a pseudonymous ID from a salt rotated each epoch */
export function pseudonym(nftokenId: string, epochSalt: string): string {
  return createHmac('sha256', epochSalt).update(nftokenId).digest('hex').slice(0, 16);
}

{
  "region": "wydm",
  "window": { "from": "2026-06-20", "to": "2026-07-20" },
  "filters": [
    { "metric": "ah", "op": "gte", "value": 14.0, "duty": 0.6 },
    { "metric": "area_bucket", "op": "in", "value": ["60-85sqm", "85-135sqm"] }
  ]
}

{
  "cohortSize": 1240,
  "rounding": 5,
  "kAnonymity": { "min": 5, "satisfied": true, "effectiveMin": 25 },
  "profile": {
    "ah_p50": 15.8, "ah_p90": 19.2,
    "hours_above_threshold_p50": 431,
    "top_area_bucket": "60-85sqm"
  },
  "reachable": true,
  "note": "No subject list is provided. Ad delivery is brokered by the platform."
}

{
  "error": "COHORT_TOO_NARROW",
  "minimum": 25,
  "hint": "Relax the filters or reduce region precision. The actual size is not returned."
}

{
  "x402Version": 1,
  "resource": "/api/iaq/aggregate",
  "accepts": [
    {
      "scheme": "xrpl-payment",
      "network": "xrpl-testnet",
      "payTo": "rOperationalWalletAddress...",
      "asset": { "currency": "RLUSD", "issuer": "rIssuerAddress...", "value": "0.002" },
      "destinationTag": 402010,
      "maxTimeoutSeconds": 120
    },
    {
      "scheme": "xrpl-credit",
      "network": "xrpl-testnet",
      "payTo": "rOperationalWalletAddress...",
      "topUpMinimum": { "currency": "RLUSD", "issuer": "rIssuerAddress...", "value": "100" },
      "destinationTag": 402011,
      "unitPrice": "0.002",
      "authScheme": "x402-credit .."
    }
  ]
}

import { verify } from 'ripple-keypairs';
import { verifyPayment } from './x402';

interface CreditAccount { balance: number; currency: 'RLUSD' | 'WLBN'; lastNonce: number; publicKey: string; }
const credits = new Map<string, CreditAccount>();   // use a persistent store in production

/** Top-up — reuses the existing on-chain verification logic as-is */
export async function topUp(txHash: string) {
  const res = await verifyPayment(txHash);          // replay + delivered-amount checks already applied here
  if (!res.ok) return res;

  const acc = credits.get(res.payer) ?? { balance: 0, currency: res.currency, lastNonce: 0, publicKey: res.publicKey };
  acc.balance += Number(res.value);
  credits.set(res.payer, acc);
  return { ok: true as const, balance: acc.balance };
}

/** Call — signature + balance only, no on-chain round trip (~1ms) */
export function spend(header: string, method: string, path: string, unitPrice: number) {
  const [payer, nonceStr, signature] = header.split('.');
  const acc = credits.get(payer);
  if (!acc) return { ok: false as const, reason: 'NO_CREDIT_ACCOUNT' };

  const nonce = Number(nonceStr);
  if (!Number.isInteger(nonce) || nonce <= acc.lastNonce) return { ok: false as const, reason: 'BAD_NONCE' };

  const message = Buffer.from(`${method}:${path}:${nonce}`, 'utf8').toString('hex').toUpperCase();
  if (!verify(message, signature, acc.publicKey)) return { ok: false as const, reason: 'BAD_SIGNATURE' };

  if (acc.balance < unitPrice) return { ok: false as const, reason: 'INSUFFICIENT_CREDIT' };

  acc.balance -= unitPrice;
  acc.lastNonce = nonce;
  return { ok: true as const, remaining: acc.balance };
}

[IN ]  Manufacturer → Operational   RLUSD  (aggregate credit · cohort · report · dataset)
[IN ]  AI agent      → Operational   WLBN / RLUSD  (per-call x402 payment)
[OUT]  Operational   → nodes         WLBN   distribute(nodes, EPOCH_BUDGET)   ← fixed budget
[BURN] Operational   → Issuer        WLBN   50% of payments received
[BURN] Contributor   → Issuer        WLBN   100% of coupon issuance
[SETL] Operational   → manufacturer  RLUSD  coupons redeemed (cap: B2B revenue × 40%)

import { Client } from 'xrpl';
import { env } from '../config/env';

let client: Client | null = null;

export async function getClient(): Promise<Client> {
  if (client?.isConnected()) return client;
  client = new Client(env.XRPL_ENDPOINT, { connectionTimeout: 10_000 });
  client.on('disconnected', (code) => console.warn('[xrpl] disconnected', code));
  await client.connect();
  return client;
}

export async function closeClient(): Promise<void> {
  if (client?.isConnected()) await client.disconnect();
  client = null;
}

import { getClient, closeClient } from '../xrpl/client';

const ROLES = ['ISSUER', 'OPERATIONAL', 'DEVICE', 'AGENT'] as const;

async function main() {
  const client = await getClient();

  for (const role of ROLES) {
    // the Faucet creates the account and funds it with initial XRP
    const { wallet, balance } = await client.fundWallet();
    console.log(`\n# ${role}`);
    console.log(`${role}_SEED=${wallet.seed}`);
    console.log(`${role}_ADDRESS=${wallet.classicAddress}   # balance ${balance} XRP`);
  }

  await closeClient();
}

main().catch((e) => { console.error(e); process.exit(1); });

import { Client, Wallet, AccountSetAsfFlags, TrustSetFlags, IssuedCurrencyAmount } from 'xrpl';
import { submit } from './submit';

/** Issuer account setup — DefaultRipple ON so IOUs can move between holders */
export async function configureIssuer(client: Client, issuer: Wallet) {
  await submit(client, issuer, {
    TransactionType: 'AccountSet',
    Account: issuer.classicAddress,
    SetFlag: AccountSetAsfFlags.asfDefaultRipple,
    Domain: Buffer.from('kweather.example').toString('hex').toUpperCase(),
  });
}

/** Holder TrustLine — NoRipple blocks third-party bridge routing */
export async function setTrustLine(
  client: Client, holder: Wallet, issuerAddress: string,
  currency: string, limit = '1000000000',
) {
  await submit(client, holder, {
    TransactionType: 'TrustSet',
    Account: holder.classicAddress,
    LimitAmount: { currency, issuer: issuerAddress, value: limit },
    Flags: TrustSetFlags.tfSetNoRipple,
  });
}

/** IOU transfer — from the Issuer it is issuance; between holders it is circulation */
export async function sendIOU(
  client: Client, from: Wallet, destination: string,
  amount: IssuedCurrencyAmount, destinationTag?: number,
) {
  return submit(client, from, {
    TransactionType: 'Payment',
    Account: from.classicAddress,
    Destination: destination,
    Amount: amount,
    ...(destinationTag !== undefined ? { DestinationTag: destinationTag } : {}),
  });
}

import { Client, Wallet, NFTokenMintFlags, NFTokenCreateOfferFlags, convertStringToHex } from 'xrpl';
import { submit } from './submit';

export const TAXON = { OAQ: 2026, IAQ: 3026 } as const;   // license collection per network

/** Mint a license NFT → returns the NFTokenID */
export async function mintLicense(
  client: Client, issuer: Wallet, metadataUri: string, taxon: number = TAXON.IAQ,
) {
  const res = await submit(client, issuer, {
    TransactionType: 'NFTokenMint',
    Account: issuer.classicAddress,
    URI: convertStringToHex(metadataUri),      // ipfs://Qm...
    NFTokenTaxon: taxon,
    Flags: NFTokenMintFlags.tfTransferable,
  });

  // meta.nftoken_id is populated by rippled
  const meta = res.result.meta as { nftoken_id?: string };
  if (!meta.nftoken_id) throw new Error('NFTokenID not found in metadata');
  return meta.nftoken_id;
}

/** Create a zero-price sell offer restricted to one recipient */
export async function offerLicenseTo(
  client: Client, issuer: Wallet, nftokenId: string, destination: string,
) {
  const res = await submit(client, issuer, {
    TransactionType: 'NFTokenCreateOffer',
    Account: issuer.classicAddress,
    NFTokenID: nftokenId,
    Amount: '0',
    Destination: destination,                  // only this address can accept
    Flags: NFTokenCreateOfferFlags.tfSellNFToken,
  });

  const meta = res.result.meta as { offer_id?: string };
  if (!meta.offer_id) throw new Error('OfferID not found in metadata');
  return meta.offer_id;
}

/** Device wallet accepts the offer → ownership transfers */
export async function acceptLicense(client: Client, device: Wallet, offerId: string) {
  return submit(client, device, {
    TransactionType: 'NFTokenAcceptOffer',
    Account: device.classicAddress,
    NFTokenSellOffer: offerId,
  });
}

import { env } from '../config/env';

export interface LicenseInfo {
  valid: boolean;
  nftokenId?: string;
  uri?: string;
  taxon?: number;
}

/** Verify on-chain that the address holds a valid license NFT for this network */
export async function verifyDeviceLicense(
  client: Client, walletAddress: string, taxon: number = TAXON.IAQ,
): Promise<LicenseInfo> {
  const res = await client.request({
    command: 'account_nfts',
    account: walletAddress,
    ledger_index: 'validated',
  });

  const hit = res.result.account_nfts.find(
    (n) => n.Issuer === env.ISSUER_ADDRESS && n.NFTokenTaxon === taxon,
  );
  if (!hit) return { valid: false };

  return {
    valid: true,
    nftokenId: hit.NFTokenID,
    taxon: hit.NFTokenTaxon,
    uri: hit.URI ? Buffer.from(hit.URI, 'hex').toString('utf8') : undefined,
  };
}

{
  "schema": "kweather-oaq-device/v1",
  "name": "Kweather OAQ Node #0042",
  "description": "Outdoor Air Quality station license",
  "device": {
    "serial": "KW-OAQ-0042",
    "model": "KW-OUT-1",
    "sensors": ["pm25", "pm10", "o3", "no2", "temp", "rh"],
    "installed_at": "2026-03-11"
  },
  "context": { "geohash5": "wydm9", "space_type": "outdoor" },
  "license": { "tier": "oaq-standard", "reward_multiplier": 1.4, "valid_until": "2028-03-11" }
}

import { getClient } from '../xrpl/client';
import { verifyDeviceLicense } from '../xrpl/nft';
import { sendIOU } from '../xrpl/token';
import { WLBN } from '../config/currency';
import { env, operationalWallet } from '../config/env';

import { absoluteHumidity } from './iaq/humidity';
import { TAXON } from '../xrpl/nft';

export interface IaqReading {
  ts: number;
  pm1: number; pm25: number; pm10: number;
  co2: number; tvoc: number;
  tempC: number; rh: number; hpa: number;
}

const RANGES: Record<keyof IaqReading, [number, number]> = {
  ts: [0, Number.MAX_SAFE_INTEGER],
  pm1: [0, 1000], pm25: [0, 1000], pm10: [0, 1000],
  co2: [350, 5000], tvoc: [0, 60000],
  tempC: [-10, 60], rh: [0, 100], hpa: [850, 1100],
};

const lastSeen = new Map<string, number>();
const MIN_INTERVAL_MS = 4 * 60_000;      // 5-minute batch cadence, 1 minute of slack

export async function ingest(deviceAddress: string, batch: IaqReading[]) {
  // 1) submission interval floor — prevents reward farming
  const prev = lastSeen.get(deviceAddress) ?? 0;
  if (Date.now() - prev < MIN_INTERVAL_MS) throw new HttpError(429, 'RATE_LIMITED');

  // 2) physical plausibility — check the whole batch
  for (const reading of batch) {
    for (const [k, [lo, hi]] of Object.entries(RANGES)) {
      const v = reading[k as keyof IaqReading];
      if (typeof v !== 'number' || v < lo || v > hi) throw new HttpError(422, 'OUT_OF_RANGE');
    }
  }

  // 3) on-chain license check (IAQ Taxon, 60s TTL cache)
  const client = await getClient();
  const license = await verifyDeviceLicense(client, deviceAddress, TAXON.IAQ);
  if (!license.valid) throw new HttpError(403, 'NO_VALID_LICENSE');

  // 4) derive absolute humidity, store off-chain — only the batch Merkle root goes on-ledger
  const enriched = batch.map((r) => ({ ...r, ah: absoluteHumidity(r.tempC, r.rh) }));
  await saveTelemetry(deviceAddress, enriched, license.nftokenId!);

  // 5) no immediate payout — settled in bulk by distribute() in the epoch batch
  await enqueueForEpoch(deviceAddress, license, enriched);

  lastSeen.set(deviceAddress, Date.now());
  return { accepted: batch.length };      // HTTP 202
}

import { Client, Wallet, AMMDepositFlags } from 'xrpl';
import { submit } from './submit';
import { WLBN, RLUSD } from '../config/currency';
import { env } from '../config/env';

const wlbn  = (value: string) => ({ currency: WLBN,  issuer: env.ISSUER_ADDRESS, value });
const rlusd = (value: string) => ({ currency: RLUSD, issuer: env.ISSUER_ADDRESS, value });

/** Initial ratio 100,000 WLBN : 1,000 RLUSD → 1 WLBN ≈ 0.01 RLUSD */
export async function createAmm(client: Client, lp: Wallet) {
  return submit(client, lp, {
    TransactionType: 'AMMCreate',
    Account: lp.classicAddress,
    Amount:  wlbn('100000'),
    Amount2: rlusd('1000'),
    TradingFee: 500,          // 0.5% (unit: 1/100,000)
  });
}

/** Two-asset deposit */
export async function depositBoth(client: Client, lp: Wallet, a: string, b: string) {
  return submit(client, lp, {
    TransactionType: 'AMMDeposit',
    Account: lp.classicAddress,
    Asset:  { currency: WLBN,  issuer: env.ISSUER_ADDRESS },
    Asset2: { currency: RLUSD, issuer: env.ISSUER_ADDRESS },
    Amount: wlbn(a),
    Amount2: rlusd(b),
    Flags: AMMDepositFlags.tfTwoAsset,
  });
}

/** RLUSD → WLBN swap: fixed target amount + max spend cap (slippage defense) */
export async function swapRlusdForWlbn(
  client: Client, buyer: Wallet, targetWlbn: string, maxRlusd: string,
) {
  const paths = await client.request({
    command: 'path_find', subcommand: 'create',
    source_account: buyer.classicAddress,
    destination_account: buyer.classicAddress,
    destination_amount: wlbn(targetWlbn),
    source_currencies: [{ currency: RLUSD, issuer: env.ISSUER_ADDRESS }],
  } as never);

  return submit(client, buyer, {
    TransactionType: 'Payment',
    Account: buyer.classicAddress,
    Destination: buyer.classicAddress,     // to yourself = currency conversion
    Amount: wlbn(targetWlbn),
    SendMax: rlusd(maxRlusd),              // slippage cap
    Paths: (paths.result as { alternatives: { paths_computed: unknown }[] })
      .alternatives[0]?.paths_computed as never,
    Flags: 0x00020000,                     // tfPartialPayment not used
  });
}

/** Query pool state */
export async function getPoolState(client: Client) {
  const res = await client.request({
    command: 'amm_info',
    asset:  { currency: WLBN,  issuer: env.ISSUER_ADDRESS },
    asset2: { currency: RLUSD, issuer: env.ISSUER_ADDRESS },
  } as never);
  return res.result;
}

HTTP/1.1 402 Payment Required
Content-Type: application/json
WWW-Authenticate: x402 realm="kweather-llm", network="xrpl-testnet"

{
  "x402Version": 1,
  "resource": "/api/llm/inference",
  "accepts": [
    {
      "scheme": "xrpl-payment",
      "network": "xrpl-testnet",
      "payTo": "rOperationalWalletAddress...",
      "asset": { "currency": "WLBN", "issuer": "rIssuerAddress...", "value": "0.1" },
      "destinationTag": 402001,
      "maxTimeoutSeconds": 120
    },
    {
      "scheme": "xrpl-payment",
      "network": "xrpl-testnet",
      "payTo": "rOperationalWalletAddress...",
      "asset": { "currency": "RLUSD", "issuer": "rIssuerAddress...", "value": "0.001" },
      "destinationTag": 402001,
      "maxTimeoutSeconds": 120
    }
  ],
  "description": "Kweather Weather LLM inference — per-call pricing"
}

import { getClient } from '../xrpl/client';
import { WLBN, RLUSD } from '../config/currency';
import { env } from '../config/env';

const usedHashes = new Set<string>();     // replace with Redis SETNX + TTL in production

export type VerifyResult =
  | { ok: true; currency: 'WLBN' | 'RLUSD'; value: string }
  | { ok: false; reason: string };

const PRICES = {
  [WLBN]:  { label: 'WLBN'  as const, min: Number(env.X402_PRICE_WLBN)  },
  [RLUSD]: { label: 'RLUSD' as const, min: Number(env.X402_PRICE_RLUSD) },
};

export async function verifyPayment(txHash: string): Promise<VerifyResult> {
  // 0) block reuse — stops unlimited calls with the same hash
  if (usedHashes.has(txHash)) return { ok: false, reason: 'HASH_ALREADY_USED' };

  const client = await getClient();
  let res;
  try {
    res = await client.request({ command: 'tx', transaction: txHash, binary: false });
  } catch {
    return { ok: false, reason: 'TX_NOT_FOUND' };   // may not have propagated yet → prompt a retry
  }

  const tx = res.result.tx_json ?? (res.result as never as Record<string, unknown>);
  const meta = res.result.meta as { TransactionResult: string; delivered_amount?: unknown };

  // 1) ledger finality + success
  if (res.result.validated !== true) return { ok: false, reason: 'NOT_VALIDATED' };
  if (meta.TransactionResult !== 'tesSUCCESS') return { ok: false, reason: meta.TransactionResult };
  if ((tx as { TransactionType: string }).TransactionType !== 'Payment')
    return { ok: false, reason: 'NOT_A_PAYMENT' };

  // 2) recipient matches
  if ((tx as { Destination: string }).Destination !== env.OPERATIONAL_ADDRESS)
    return { ok: false, reason: 'WRONG_DESTINATION' };

  // 3) check actual delivered amount — trust delivered_amount to block PartialPayment bypass
  const delivered = meta.delivered_amount as
    { currency: string; issuer: string; value: string } | string | undefined;
  if (!delivered || typeof delivered === 'string')
    return { ok: false, reason: 'XRP_NOT_ACCEPTED' };

  const price = PRICES[delivered.currency];
  if (!price) return { ok: false, reason: 'UNSUPPORTED_CURRENCY' };
  if (delivered.issuer !== env.ISSUER_ADDRESS) return { ok: false, reason: 'WRONG_ISSUER' };
  if (Number(delivered.value) < price.min) return { ok: false, reason: 'INSUFFICIENT_AMOUNT' };

  usedHashes.add(txHash);
  return { ok: true, currency: price.label, value: delivered.value };
}

import { RequestHandler } from 'express';
import { verifyPayment } from '../services/x402';
import { buildChallenge } from '../services/x402.challenge';

export const x402Gate: RequestHandler = async (req, res, next) => {
  const auth = req.header('authorization');
  const match = auth?.match(/^x402\s+([A-F0-9]{64})$/i);

  if (!match) {
    res.setHeader('WWW-Authenticate', 'x402 realm="kweather-llm", network="xrpl-testnet"');
    return res.status(402).json(buildChallenge(req.path));
  }

  const result = await verifyPayment(match[1]);
  if (!result.ok) {
    // not yet in the ledger → prompt retry; otherwise reissue 402
    const retryable = result.reason === 'TX_NOT_FOUND' || result.reason === 'NOT_VALIDATED';
    if (retryable) { res.setHeader('Retry-After', '3'); return res.status(409).json(result); }
    return res.status(402).json({ ...buildChallenge(req.path), error: result.reason });
  }

  res.setHeader('X-Payment-Response', JSON.stringify({ settled: true, ...result }));
  next();
};

import { getClient } from '../xrpl/client';
import { sendIOU } from '../xrpl/token';
import { agentWallet, env } from '../config/env';
import { toCurrencyHex } from '../config/currency';

const API = 'http://localhost:3000/api/llm/inference';
const body = { query: 'Summarize tomorrow\'s indoor humidity outlook for Seoul Gangnam' };

async function call(headers: Record<string, string> = {}) {
  return fetch(API, {
    method: 'POST',
    headers: { 'content-type': 'application/json', ...headers },
    body: JSON.stringify(body),
  });
}

async function main() {
  // (1) call without payment → receive 402 + payment terms
  const challenge = await call();
  if (challenge.status !== 402) throw new Error(`expected 402, got ${challenge.status}`);
  const terms = await challenge.json();
  const option = terms.accepts.find((a: { asset: { currency: string } }) => a.asset.currency === 'WLBN');
  console.log('[agent] terms received:', option.asset.value, option.asset.currency);

  // (2) pay on-chain — the agent decides and pays on its own
  const client = await getClient();
  const tx = await sendIOU(
    client, agentWallet, option.payTo,
    { currency: toCurrencyHex(option.asset.currency), issuer: option.asset.issuer, value: option.asset.value },
    option.destinationTag,
  );
  const hash = tx.result.hash;
  console.log('[agent] payment settled:', hash);

  // (3) retry with tx_hash attached (retries absorb propagation delay)
  for (let i = 0; i < 5; i++) {
    const res = await call({ authorization: `x402 ${hash}` });
    if (res.status === 200) { console.log('[agent] response:', await res.json()); return; }
    if (res.status !== 409) throw new Error(`failed ${res.status}: ${await res.text()}`);
    await new Promise((r) => setTimeout(r, 3000));
  }
  throw new Error('verification timed out');
}

main().catch((e) => { console.error(e); process.exit(1); });

import { getClient } from '../xrpl/client';
import { sendIOU } from '../xrpl/token';
import { WLBN } from '../config/currency';
import { env, operationalWallet } from '../config/env';

/** Return BURN_RATIO of the WLBN received via x402 this period to the Issuer = burn */
export async function runBurnBatch(periodRevenueWlbn: string) {
  const amount = (Number(periodRevenueWlbn) * Number(env.BURN_RATIO)).toFixed(6);
  if (Number(amount) <= 0) return { burned: '0' };

  const client = await getClient();
  const res = await sendIOU(client, operationalWallet, env.ISSUER_ADDRESS, {
    currency: WLBN, issuer: env.ISSUER_ADDRESS, value: amount,
  });

  console.log(`[burn] ${amount} WLBN → issuer  tx=${res.result.hash}`);
  return { burned: amount, txHash: res.result.hash };
}

revenue   R(n)      = (R_cap / 12) · n² / (n² + N_half²)
budget    B(t, n)   = max( B₀ · 0.5^(t / T_half),  α · R(n) )
reward    r(n, tier) = B · mult[tier] / (n · w̄)      w̄ = Σ share·mult
steady    r(n)      = α · (R_cap/12) · mult · n / (w̄ · (n² + N_half²))   ← single-peaked in n
peak      r_max     = α · (R_cap/12) · mult / (w̄ · 2 · N_half)           @ n = N_half

Sustainable band (maintenance floor): 12,927 ~ 48,347 nodes   peak KRW 1,838 @ 25,000

tier          reward@25k    HW cost   payback   cost for 36mo   subsidy
lite            1,838     55,000    33.6M          58,976       0%
standard        2,941    120,000    43.8M          98,682      18%
pro             4,044    210,000    54.6M         138,388      34%

Coupon outflow = revenue × 30%   (10pp headroom under the 40% cap)

node sim/tokenomics.mjs           # summary report
node sim/tokenomics.mjs --json    # full 36-month time series as JSON