실내외 날씨 데이터 생태계와
온체인 데이터 거래 인프라

// 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://xrplcluster.com
XRPL_NETWORK=mainnet

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

# Hot — API server runtime
HOT_SEED=sEd..............................
HOT_WALLET_ADDRESS=r..............................

# Counterparties
TREASURY_ADDRESS=rPZFY2yLgqjmBrxtxWHXnB1doBt7gu7xin
RLUSD_ISSUER_ADDRESS=rMxCKbEDwqr76QuheSUMdEGf4B9xJ8m5De

# Pricing policy (RLUSD)
X402_PRICE_AGGREGATE_RLUSD=0.002
X402_PRICE_COHORT_RLUSD=0.05
X402_PRICE_REPORT_RLUSD=0.5
X402_DEST_TAG=402001

# Reward policy
REWARD_BASE_DAILY_WLBN=7
PHASE_DECAY=0.78
EXCELLENT_BONUS_WLBN=1.4
NODE_DAILY_CAP_WLBN=10.5
BUDGET_PER_NODE_WLBN=7.14
CLAIM_HOLD_HOURS=24
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": "wellbian-iaq-telemetry/v1",
  "deviceAddress": "rDeviceWalletAddress...",
  "signature": "3045022100...",
  "batch": [
    {
      "ts": 1786195200,
      "pm25": 11.4, "pm10": 15.8,
      "co2": 812, "tvoc": 143,
      "tempC": 23.4, "rh": 58.1, "feelsLikeC": 24.1
    },
    {
      "ts": 1786195260,
      "pm25": 11.1, "pm10": 15.2,
      "co2": 845, "tvoc": 139,
      "tempC": 23.4, "rh": 58.4, "feelsLikeC": 24.2
    }
  ]
}

{
  "schema": "wellbian-iaq-device/v1",
  "name": "Wellbian IAQ Node #10427",
  "description": "Indoor Air Quality license",
  "device": {
    "serial": "KW-IAQ-10427",
    "model": "ARC-600DA",
    "sensors": ["pm25", "pm10", "co2", "tvoc", "temp", "rh"],
    "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-standard", "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)
  calibrationAgeDays: 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);
  if (uptime < 0.2) return 0;                            // 가동률 20% 미만이면 점수 0
  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.calibrationAgeDays / 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 BASE_DAILY      = 7;      // 정상 등급 1차 지급 (수량 · 시세 무관)
export const EXCELLENT_DAILY = 8.4;    // 품질 상위 10% (+1.4)
export const NODE_CAP        = 10.5;   // 재분배 후 지점당 상한 — 초과분 소각
export const BUDGET_PER_NODE = 7.14;   // 에폭 예산 = 활성 지점 × 7.14 × 단계 계수
export const PHASE_DECAY     = 0.78;   // 단계마다 22% 체감

export type Grade = 0 | 1 | 1.2;
export interface NodeEpochStats { address: string; quality: QualityInputs; txRate: number; licenseHeld: boolean; }

/** 전송률 게이트 → 품질 점수 상위 10% 우수. 게이트 미달은 0 */
export function grade(n: NodeEpochStats, top10Cut: number): Grade {
  if (n.txRate < 0.8) return 0;
  return qualityScore(n.quality) >= top10Cut ? 1.2 : 1;
}

/** 에폭 정산: 총 지급 + 소각 = 예산 (항상 성립) */
export function distribute(nodes: NodeEpochStats[], phase: number) {
  const factor = Math.pow(PHASE_DECAY, phase - 1);
  const active = nodes.filter((n) => n.licenseHeld);
  const budget = active.length * BUDGET_PER_NODE * factor;
  const cut = percentile(active.map((n) => qualityScore(n.quality)), 0.9);

  // 1) 1차 지급 — 정상 7 · 우수 8.4 · 미달 0 (80~95% 전송률은 선형 감액)
  const paid = active.map((n) => {
    const g = grade(n, cut);
    const ramp = n.txRate >= 0.95 ? 1 : n.txRate < 0.8 ? 0 : (n.txRate - 0.8) / 0.15;
    return { address: n.address, g, amount: BASE_DAILY * g * ramp * factor };
  });
  const unpaid = budget - paid.reduce((s, p) => s + p.amount, 0);

  // 2) 미지급분 재분배 — 가중치 비례, 지점당 상한 10.5 × factor, 초과분 소각
  const w = paid.reduce((s, p) => s + p.g, 0);
  let burn = 0;
  for (const p of paid) {
    if (p.g === 0 || w === 0) continue;
    const target = Math.min(p.amount + unpaid * (p.g / w), NODE_CAP * factor);
    burn += p.amount + unpaid * (p.g / w) - target;
    p.amount = target;
  }
  return { paid, burn, budget };   // Σ paid.amount + burn === budget
}

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-08-01", "to": "2026-08-31" },
  "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/data/aggregates",
  "accepts": [
    {
      "scheme": "xrpl-payment",
      "network": "xrpl-mainnet",
      "payTo": "rhTTtx8YyKzcmPDsoroYXuHdGMThrnweb1",
      "asset": { "currency": "RLUSD", "issuer": "rMxCKbEDwqr76QuheSUMdEGf4B9xJ8m5De", "value": "0.002" },
      "destinationTag": 402010,
      "maxTimeoutSeconds": 120
    },
    {
      "scheme": "xrpl-credit",
      "network": "xrpl-mainnet",
      "payTo": "rhTTtx8YyKzcmPDsoroYXuHdGMThrnweb1",
      "topUpMinimum": { "currency": "RLUSD", "issuer": "rMxCKbEDwqr76QuheSUMdEGf4B9xJ8m5De", "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 ]  Enterprise    → Hot           RLUSD / KRW  (aggregate credit · cohort · report · dataset)
[IN ]  AI agent      → Hot           RLUSD / WLBN (per-call x402 payment)
[OUT]  Hot           → points        WLBN   7 × 0.78^(phase−1) × grade   ← quantity, never value
[BURN] Hot           → Issuer        WLBN   quality shortfall (redistribution excess)
[BURN] Treasury      → Issuer        WLBN   scheduled 2.5B in 4 tranches · buyback from revenue (2.465B)
[LP  ] Treasury      → AMM           WLBN/RLUSD   20% of participation fees on sale

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 { Wallet } from 'xrpl';
import { getClient, closeClient } from '../xrpl/client';
import { env } from '../config/env';

const ROLES = ['ISSUER', 'HOT', 'TREASURY'] as const;
const MIN_RESERVE_XRP = 5;
// ISSUER(cold) rDJz8WJhsKgydqJzSZXMpsJot3eRmSkR5
// HOT          rhTTtx8YyKzcmPDsoroYXuHdGMThrnweb1
// TREASURY     rPZFY2yLgqjmBrxtxWHXnB1doBt7gu7xin

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

  for (const role of ROLES) {
    // Mainnet: 시드로 로드하고 잔액을 확인한다 (Faucet 없음)
    const wallet = Wallet.fromSeed(env[`${role}_SEED`]);
    const info = await client.request({
      command: 'account_info', account: wallet.classicAddress, ledger_index: 'validated',
    });
    const balance = Number(info.result.account_data.Balance) / 1_000_000;
    if (balance < MIN_RESERVE_XRP) throw new Error(`${role} underfunded: ${balance} XRP`);
    console.log(`\n# ${role}`);
    // 시드는 출력하지 않는다 — .env에서만 관리한다
    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('wellbian.io').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 = {
  OBS_GENESIS: 1001, OBS_REGION: 1002, OBS_BIZ: 1003,          // 관측소 NFT (계정당 1개)
  VOUCHER: 1010,                                               // 사전예약 바우처 (테스트 900010)
  OAQ: 2026, IAQ: 3026, AI: 4026, RADAR: 5026, SAT: 6026,      // 스테이션 NFT (기기당 1개)
} as const;

/** Mint a license NFT → returns the NFTokenID */
export async function mintLicense(
  client: Client, hot: Wallet, metadataUri: string, taxon: number = TAXON.IAQ,
) {
  // 서명자는 Hot 지갑, 발행 주체(Issuer)는 콜드 지갑 — NFTokenMinter로 위임
  const res = await submit(client, hot, {
    TransactionType: 'NFTokenMint',
    Account: hot.classicAddress,
    Issuer: env.ISSUER_ADDRESS,
    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, hot: Wallet, nftokenId: string, destination: string,
) {
  const res = await submit(client, hot, {
    TransactionType: 'NFTokenCreateOffer',
    Account: hot.classicAddress,
    NFTokenID: nftokenId,
    Amount: '0',
    Destination: destination,                  // 리딤으로 확인된 사용자 계정만 수락 가능
    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;
}

/** User wallet accepts the offer → ownership transfers.
 *  D'CENT 펜딩 오퍼 폴백은 설정 플래그 allowPendingOffer(기본 false)로 제어한다. */
export async function acceptLicense(client: Client, user: Wallet, offerId: string) {
  return submit(client, user, {
    TransactionType: 'NFTokenAcceptOffer',
    Account: user.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": "wellbian-oaq-device/v1",
  "name": "Wellbian OAQ Node #0042",
  "description": "Outdoor Air Quality station license",
  "device": {
    "serial": "KW-OAQ-0042",
    "model": "TBD",
    "sensors": ["pm25", "pm10", "o3", "no2", "temp", "rh"],
    "installed_at": "2026-03-11"
  },
  "context": { "geohash5": "wydm9", "space_type": "outdoor" },
  "license": { "tier": "oaq-standard", "valid_until": "2029-03-11" }
}

import { getClient } from '../xrpl/client';
import { verifyDeviceLicense } from '../xrpl/nft';
import { env } from '../config/env';

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

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

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

const lastSeen = new Map<string, number>();
const MIN_INTERVAL_MS = 4 * 60_000;      // 1-minute transmit cadence; floor keeps 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) accrual only — the daily epoch settles accruals; payout happens on claim
  await accrueForEpoch(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.RLUSD_ISSUER_ADDRESS, value });

/** AMM pool deposit 100,000 WLBN : 1,000 RLUSD — 예시 값. 예치 비율은 스왑 교환비 산정용일 뿐
 *  WLBN의 가치·법정화폐 환산을 의미하지 않는다. */
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.RLUSD_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.RLUSD_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: 0,                              // tfPartialPayment 미사용
  });
}

/** 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.RLUSD_ISSUER_ADDRESS },
  } as never);
  return res.result;
}

HTTP/1.1 402 Payment Required
Content-Type: application/json
WWW-Authenticate: x402 realm="wellbian-data", network="xrpl-mainnet"

{
  "x402Version": 1,
  "resource": "/api/data/aggregates",
  "accepts": [
    {
      "scheme": "xrpl-payment",
      "network": "xrpl-mainnet",
      "payTo": "rhTTtx8YyKzcmPDsoroYXuHdGMThrnweb1",
      "asset": { "currency": "WLBN", "issuer": "rDJz8WJhsKgydqJzSZXMpsJot3eRmSkR5", "value": "<수량>" },   // 수량 기준 단가 · RLUSD/법정화폐 환산 아님
      "destinationTag": 402001,
      "maxTimeoutSeconds": 120
    },
    {
      "scheme": "xrpl-payment",
      "network": "xrpl-mainnet",
      "payTo": "rhTTtx8YyKzcmPDsoroYXuHdGMThrnweb1",
      "asset": { "currency": "RLUSD", "issuer": "rMxCKbEDwqr76QuheSUMdEGf4B9xJ8m5De", "value": "0.002" },
      "destinationTag": 402001,
      "maxTimeoutSeconds": 120
    }
  ],
  "description": "Wellbian IAQ 집계 데이터 — 호출당 과금"
}

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.HOT_WALLET_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' };
  const EXPECTED_ISSUER = { [WLBN]: env.ISSUER_ADDRESS, [RLUSD]: env.RLUSD_ISSUER_ADDRESS };
  if (delivered.issuer !== EXPECTED_ISSUER[delivered.currency])
    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 payTx = req.header('x-payment-tx');            // 선불 크레딧은 x-api-key 경로로 별도 처리
  const match = payTx?.match(/^([A-F0-9]{64})$/i);

  if (!match) {
    res.setHeader('WWW-Authenticate', 'x402 realm="wellbian-data", network="xrpl-mainnet"');
    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 = 'https://wellbian.io/api/data/aggregates';
const query = new URLSearchParams({ taxon: 'IAQ', geohash: 'wydm6', from: '2026-08-31T00:00:00+09:00', to: '2026-09-01T00:00:00+09:00' });

async function call(headers: Record<string, string> = {}) {
  return fetch(`${API}?${query}`, { method: 'GET', headers });
}

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({ 'x-payment-tx': 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, hotWallet, treasuryWallet } from '../config/env';

export type BurnReason = 'scheduled' | 'buyback' | 'quality-shortfall' | 'round2-unopened';

/** Return WLBN to the Issuer = burn. Quantity and tx hash are published; buyback timing/price are not. */
export async function burn(amountWlbn: string, reason: BurnReason) {
  if (Number(amountWlbn) <= 0) return { burned: '0' };
  const from = reason === 'quality-shortfall' ? hotWallet : treasuryWallet;
  const client = await getClient();
  const res = await sendIOU(client, from, env.ISSUER_ADDRESS, {
    currency: WLBN, issuer: env.ISSUER_ADDRESS, value: amountWlbn,
  });
  await publishBurn({ reason, amount: amountWlbn, tx: res.result.hash });   // 수량·tx만 공표
  return { burned: amountWlbn, txHash: res.result.hash };
}

daily reward  = base 7 × 0.78^(phase − 1) × quality grade (0 ~ 1.2)
epoch budget  = active points × 7.14 WLBN × phase factor

first pass     normal 7 · excellent 8.4 · failing 0
redistribute   unpaid share pro rata by weight · cap 10.5 per point · excess burned

reward(p, g)   = 7 × 0.78^(p − 1) × g               g ∈ { 0, 1.0, 1.2 }
budget(p, n)   = n_active × 7.14 × 0.78^(p − 1)       fixed per epoch
redistribute   = unpaid × w_i / Σw                     cap 10.5 per point · excess → burn
emission(p)    = Σ_epochs budget(p, n) − burn(p)
Σ p=1..10      = 2.665B  ≤  2.8B (round-1 reward bucket)