openttt 0.2.12 → 0.2.13

package/README.md

@@ -231,9 +231,29 @@ try {
 
 ---
 
+## Pricing
+
+| Tier | Price | Quota | Use Case |
+|---|---|---|---|
+| **FREE** | $0 | 100 calls/day | Non-commercial, research, personal bots (revenue < $10K/yr) |
+| **BOT** | $199/mo | 5M calls · 1K req/s | MEV bots, arbitrage bots |
+| **DEX/LP** | $499/mo | 20M calls + overage | DEX protocols, liquidity providers |
+| **FUND** | $2,000+/mo | Unlimited + MiFIR Art.22c audit log | Hedge funds, OTC desks, prop trading |
+
+API key & commercial licensing: heime.jorgen@proton.me
+
+---
+
 ## License
 
-[Business Source License 1.1](LICENSE) — Copyright 2026 Helm Protocol.
+BSL-1.1 — free for non-commercial use.
+
+**Commercial use** (production bots, hedge funds, prop desks) requires a license.  
+→ [Pricing](https://github.com/Helm-Protocol/openttt-mcp#pricing)
+
+Change Date: 2029-05-28 → Apache 2.0
+
+Full license text: [LICENSE](LICENSE) — Copyright 2026 Helm Protocol.
 
 ---
 

package/dist/adaptive_switch.d.ts

@@ -0,0 +1,41 @@
+export declare enum AdaptiveMode {
+    TURBO = "TURBO",// 50ms — Valid sequence, low latency
+    FULL = "FULL"
+}
+export interface TTTRecord {
+    time: number;
+    txOrder: string[];
+    grgPayload: Uint8Array[];
+}
+export interface Block {
+    timestamp: number;
+    txs: string[];
+    data: Uint8Array;
+}
+/** Tier-based dynamic tolerance (ms) */
+export declare const TIER_TOLERANCE_MS: Record<string, number>;
+export declare class AdaptiveSwitch {
+    private windowSize;
+    private turboEntryThreshold;
+    private turboMaintainThreshold;
+    private history;
+    private currentMode;
+    private minBlocks;
+    private penaltyCooldown;
+    private consecutiveFailures;
+    private tolerance;
+    constructor(options?: {
+        tolerance?: number;
+    });
+    /**
+     * Client-side TTT check: timestamp ordering + time delta only.
+     * GRG integrity verification is delegated to the server (IntegrityClient).
+     */
+    verifyBlock(block: Block, tttRecord: TTTRecord, _chainId: number, _poolAddress: string, tier?: string): AdaptiveMode;
+    getFeeDiscount(): number;
+    getCurrentMode(): AdaptiveMode;
+    reset(): void;
+    serialize(): string;
+    static deserialize(json: string): AdaptiveSwitch;
+    private compareTransactionOrder;
+}

package/dist/adaptive_switch.js

@@ -0,0 +1,108 @@
+"use strict";
+// sdk/src/adaptive_switch.ts — Adaptive Mode Switcher (public SDK stub)
+// GRG integrity check runs server-side (helm private repo).
+// This module exports types, enums, and the client-side AdaptiveSwitch
+// (timestamp + ordering check only; integrity check delegated to server).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdaptiveSwitch = exports.TIER_TOLERANCE_MS = exports.AdaptiveMode = void 0;
+const logger_1 = require("./logger");
+var AdaptiveMode;
+(function (AdaptiveMode) {
+    AdaptiveMode["TURBO"] = "TURBO";
+    AdaptiveMode["FULL"] = "FULL";
+})(AdaptiveMode || (exports.AdaptiveMode = AdaptiveMode = {}));
+/** Tier-based dynamic tolerance (ms) */
+exports.TIER_TOLERANCE_MS = {
+    T0_epoch: 2000,
+    T1_block: 200,
+    T2_slot: 500,
+    T3_micro: 10,
+};
+class AdaptiveSwitch {
+    windowSize = 20;
+    turboEntryThreshold = 0.95;
+    turboMaintainThreshold = 0.85;
+    history = [];
+    currentMode = AdaptiveMode.FULL;
+    minBlocks = 20;
+    penaltyCooldown = 0;
+    consecutiveFailures = 0;
+    tolerance;
+    constructor(options) {
+        this.tolerance = options?.tolerance ?? 100;
+    }
+    /**
+     * Client-side TTT check: timestamp ordering + time delta only.
+     * GRG integrity verification is delegated to the server (IntegrityClient).
+     */
+    verifyBlock(block, tttRecord, _chainId, _poolAddress, tier) {
+        const orderMatch = this.compareTransactionOrder(block.txs, tttRecord.txOrder);
+        const tolerance = tier ? (exports.TIER_TOLERANCE_MS[tier] ?? this.tolerance) : this.tolerance;
+        const timeMatch = Math.abs(block.timestamp - tttRecord.time) < tolerance;
+        const sequenceOk = orderMatch && timeMatch;
+        this.history.push(sequenceOk);
+        if (this.history.length > this.windowSize)
+            this.history.shift();
+        if (this.penaltyCooldown > 0)
+            this.penaltyCooldown--;
+        const matchCount = this.history.filter(h => h).length;
+        const matchRate = this.history.length > 0 ? matchCount / this.history.length : 0;
+        const effectiveThreshold = this.currentMode === AdaptiveMode.TURBO
+            ? this.turboMaintainThreshold
+            : this.turboEntryThreshold;
+        if (this.history.length >= this.minBlocks && matchRate >= effectiveThreshold && this.penaltyCooldown === 0) {
+            if (this.currentMode === AdaptiveMode.FULL) {
+                logger_1.logger.info(`[AdaptiveSwitch] Switching to TURBO (rate: ${(matchRate * 100).toFixed(1)}%)`);
+            }
+            this.currentMode = AdaptiveMode.TURBO;
+            this.consecutiveFailures = 0;
+        }
+        else {
+            if (this.currentMode === AdaptiveMode.TURBO) {
+                logger_1.logger.warn(`[AdaptiveSwitch] Switching to FULL (rate: ${(matchRate * 100).toFixed(1)}%)`);
+            }
+            this.currentMode = AdaptiveMode.FULL;
+        }
+        return this.currentMode;
+    }
+    getFeeDiscount() {
+        return this.currentMode === AdaptiveMode.TURBO ? 0.2 : 0.0;
+    }
+    getCurrentMode() {
+        return this.currentMode;
+    }
+    reset() {
+        this.history = [];
+        this.currentMode = AdaptiveMode.FULL;
+        this.penaltyCooldown = 0;
+        this.consecutiveFailures = 0;
+    }
+    serialize() {
+        return JSON.stringify({
+            history: this.history,
+            currentMode: this.currentMode,
+            consecutiveFailures: this.consecutiveFailures,
+            penaltyCooldown: this.penaltyCooldown,
+            tolerance: this.tolerance,
+        });
+    }
+    static deserialize(json) {
+        const data = JSON.parse(json);
+        const instance = new AdaptiveSwitch({ tolerance: data.tolerance ?? 100 });
+        instance.history = data.history;
+        instance.currentMode = data.currentMode;
+        instance.consecutiveFailures = data.consecutiveFailures;
+        instance.penaltyCooldown = data.penaltyCooldown;
+        return instance;
+    }
+    compareTransactionOrder(blockTxs, expectedOrder) {
+        if (blockTxs.length !== expectedOrder.length)
+            return false;
+        for (let i = 0; i < blockTxs.length; i++) {
+            if (blockTxs[i] !== expectedOrder[i])
+                return false;
+        }
+        return true;
+    }
+}
+exports.AdaptiveSwitch = AdaptiveSwitch;

package/dist/http_client.d.ts

@@ -0,0 +1,98 @@
+/**
+ * TTTClient.httpOnly() — Zero-friction Proof of Time
+ * No ETH, no signer, no on-chain. Just verified time.
+ *
+ * Usage:
+ *   const client = TTTClient.httpOnly();
+ *   const pot = await client.generatePoT();
+ *   console.log(pot.timestamp, pot.confidence);
+ *
+ * Time sources: NIST, Apple, Google, Cloudflare HTTPS Date headers.
+ * HMAC-SHA256 signature — no ethers.js dependency required.
+ */
+import { ProofOfTime } from "./types";
+export interface HttpPoT {
+    /** Synthesized timestamp in Unix nanoseconds (bigint). */
+    timestamp: bigint;
+    /** Fraction of configured sources that responded (0.0–1.0). */
+    confidence: number;
+    /** Lowest NTP stratum observed across sources (2 for HTTPS Date headers). */
+    stratum: number;
+    /** Number of sources that successfully responded. */
+    sources: number;
+    /** Per-source readings used to compute the median. */
+    sourceReadings: {
+        source: string;
+        timestamp: bigint;
+        uncertainty: number;
+        stratum?: number;
+    }[];
+    /** Replay-protection nonce (hex). */
+    nonce: string;
+    /** Expiry timestamp in Unix milliseconds (bigint). */
+    expiresAt: bigint;
+    /** HMAC-SHA256 over canonical fields, hex-encoded. */
+    hmac: string;
+}
+export interface HttpPoTVerifyResult {
+    valid: boolean;
+    reason?: string;
+}
+export interface HttpOnlyClientOptions {
+    /**
+     * Override HMAC secret for non-sandbox usage.
+     * Defaults to a fixed sandbox key — sufficient for local verification only.
+     */
+    hmacSecret?: string;
+    /**
+     * Per-source request timeout in ms. Default: 3000.
+     */
+    timeoutMs?: number;
+    /**
+     * PoT validity window in seconds. Default: 60.
+     */
+    expirySeconds?: number;
+    /**
+     * Maximum divergence allowed between sources in nanoseconds.
+     * Default: 2_000_000_000n (2 seconds — lenient for HTTPS Date 1s resolution).
+     */
+    toleranceNs?: bigint;
+}
+/**
+ * HttpOnlyClient — zero-dependency Proof of Time over HTTPS.
+ *
+ * Fetches time from NIST, Apple, Google, and Cloudflare HTTPS endpoints,
+ * computes the median, and returns a PoT with HMAC integrity protection.
+ *
+ * No ETH, no signer, no on-chain interaction required.
+ */
+export declare class HttpOnlyClient {
+    private readonly hmacSecret;
+    private readonly timeoutMs;
+    private readonly expirySeconds;
+    private readonly toleranceNs;
+    private readonly usedNonces;
+    private readonly NONCE_TTL_MS;
+    private readonly MAX_NONCE_CACHE;
+    constructor(options?: HttpOnlyClientOptions);
+    /**
+     * Fetch time from all four HTTPS sources, compute median, return PoT.
+     * Requires at least 1 source to succeed.
+     */
+    generatePoT(): Promise<HttpPoT>;
+    /**
+     * Verify an HttpPoT:
+     * - HMAC integrity check
+     * - Expiry check
+     * - Nonce replay protection
+     * - Source divergence tolerance check
+     *
+     * No on-chain interaction. Pure local verification.
+     */
+    verifyPoT(pot: HttpPoT): HttpPoTVerifyResult;
+    /**
+     * Convert HttpPoT to the standard ProofOfTime shape used by the rest of the SDK.
+     * The issuerSignature field is omitted (no on-chain signer in httpOnly mode).
+     */
+    static toProofOfTime(pot: HttpPoT): ProofOfTime;
+}

package/dist/http_client.js

@@ -0,0 +1,257 @@
+"use strict";
+/**
+ * TTTClient.httpOnly() — Zero-friction Proof of Time
+ * No ETH, no signer, no on-chain. Just verified time.
+ *
+ * Usage:
+ *   const client = TTTClient.httpOnly();
+ *   const pot = await client.generatePoT();
+ *   console.log(pot.timestamp, pot.confidence);
+ *
+ * Time sources: NIST, Apple, Google, Cloudflare HTTPS Date headers.
+ * HMAC-SHA256 signature — no ethers.js dependency required.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpOnlyClient = void 0;
+const crypto = __importStar(require("crypto"));
+const https = __importStar(require("https"));
+const SOURCES = [
+    { name: "nist", url: "https://time.nist.gov/" },
+    { name: "apple", url: "https://time.apple.com/" },
+    { name: "google", url: "https://time.google.com/" },
+    { name: "cloudflare", url: "https://time.cloudflare.com/" },
+];
+function fetchHttpsDate(name, url, timeoutMs = 3000) {
+    return new Promise((resolve, reject) => {
+        const t1 = BigInt(Date.now()) * 1000000n;
+        const timer = setTimeout(() => {
+            req.destroy();
+            reject(new Error(`[httpOnly] Timeout: ${name} (${timeoutMs}ms)`));
+        }, timeoutMs);
+        const req = https.request(url, { method: "HEAD" }, (res) => {
+            clearTimeout(timer);
+            res.resume(); // drain so socket is freed
+            const t4 = BigInt(Date.now()) * 1000000n;
+            const dateHeader = res.headers["date"];
+            if (!dateHeader) {
+                reject(new Error(`[httpOnly] No Date header from ${name}`));
+                return;
+            }
+            const parsed = new Date(dateHeader).getTime();
+            if (isNaN(parsed)) {
+                reject(new Error(`[httpOnly] Invalid Date header from ${name}: ${dateHeader}`));
+                return;
+            }
+            const serverNs = BigInt(parsed) * 1000000n;
+            const rttNs = t4 - t1;
+            // Offset-corrected: server time + half RTT
+            const corrected = serverNs + rttNs / 2n;
+            const rttMs = Number(rttNs) / 1_000_000;
+            resolve({
+                source: name,
+                timestamp: corrected,
+                uncertainty: rttMs / 2 + 500, // 500ms base — HTTP Date has 1s resolution
+                stratum: 2,
+            });
+        });
+        req.on("error", (err) => {
+            clearTimeout(timer);
+            reject(new Error(`[httpOnly] Request error for ${name}: ${err.message}`));
+        });
+        req.end();
+    });
+}
+// ---------------------------------------------------------------------------
+// HMAC helpers — default sandbox key derived from fixed chain+address strings
+// HMAC key is public by design — context binding, not secrecy.
+// The sandbox key below is a fixed string for local-only verification.
+// In production, the HMAC key is derived from (chainId, poolAddress) and
+// is deterministically recomputable by any party. The security property is
+// tamper detection (integrity), not confidentiality.
+// ---------------------------------------------------------------------------
+const SANDBOX_HMAC_SECRET = "openttt-sandbox:chainId=0:address=0x0000000000000000000000000000000000000000";
+function computeHmac(timestamp, nonce, expiresAt, sources, secret = SANDBOX_HMAC_SECRET) {
+    // Canonical message: deterministic field concatenation
+    const msg = `${timestamp.toString()}:${nonce}:${expiresAt.toString()}:${sources}`;
+    return crypto.createHmac("sha256", secret).update(msg).digest("hex");
+}
+/**
+ * HttpOnlyClient — zero-dependency Proof of Time over HTTPS.
+ *
+ * Fetches time from NIST, Apple, Google, and Cloudflare HTTPS endpoints,
+ * computes the median, and returns a PoT with HMAC integrity protection.
+ *
+ * No ETH, no signer, no on-chain interaction required.
+ */
+class HttpOnlyClient {
+    hmacSecret;
+    timeoutMs;
+    expirySeconds;
+    toleranceNs;
+    usedNonces = new Map();
+    NONCE_TTL_MS = 300_000; // 5 min
+    MAX_NONCE_CACHE = 10_000;
+    constructor(options = {}) {
+        this.hmacSecret = options.hmacSecret ?? SANDBOX_HMAC_SECRET;
+        this.timeoutMs = options.timeoutMs ?? 3000;
+        this.expirySeconds = options.expirySeconds ?? 60;
+        this.toleranceNs = options.toleranceNs ?? 2000000000n; // 2 s
+    }
+    /**
+     * Fetch time from all four HTTPS sources, compute median, return PoT.
+     * Requires at least 1 source to succeed.
+     */
+    async generatePoT() {
+        const results = await Promise.allSettled(SOURCES.map((s) => fetchHttpsDate(s.name, s.url, this.timeoutMs)));
+        const readings = [];
+        for (const r of results) {
+            if (r.status === "fulfilled")
+                readings.push(r.value);
+        }
+        if (readings.length === 0) {
+            throw new Error("[httpOnly] All HTTPS time sources failed. Check network connectivity.");
+        }
+        // Sort by timestamp for median selection
+        readings.sort((a, b) => (a.timestamp < b.timestamp ? -1 : a.timestamp > b.timestamp ? 1 : 0));
+        let finalTs;
+        let finalUnc;
+        let finalStratum;
+        if (readings.length === 1) {
+            finalTs = readings[0].timestamp;
+            finalUnc = readings[0].uncertainty;
+            finalStratum = readings[0].stratum;
+        }
+        else if (readings.length === 2) {
+            finalTs = (readings[0].timestamp + readings[1].timestamp) / 2n;
+            finalUnc = (readings[0].uncertainty + readings[1].uncertainty) / 2;
+            finalStratum = Math.min(readings[0].stratum, readings[1].stratum);
+        }
+        else {
+            const mid = Math.floor(readings.length / 2);
+            finalTs = readings[mid].timestamp;
+            finalUnc = readings[mid].uncertainty;
+            finalStratum = readings[mid].stratum;
+        }
+        const nonce = crypto.randomBytes(16).toString("hex");
+        const expiresAt = BigInt(Date.now()) + BigInt(this.expirySeconds * 1000);
+        const sourceReadings = readings.map((r) => ({
+            source: r.source,
+            timestamp: r.timestamp,
+            uncertainty: r.uncertainty,
+            stratum: r.stratum,
+        }));
+        const hmac = computeHmac(finalTs, nonce, expiresAt, readings.length, this.hmacSecret);
+        return {
+            timestamp: finalTs,
+            confidence: readings.length / SOURCES.length,
+            stratum: finalStratum,
+            sources: readings.length,
+            sourceReadings,
+            nonce,
+            expiresAt,
+            hmac,
+        };
+    }
+    /**
+     * Verify an HttpPoT:
+     * - HMAC integrity check
+     * - Expiry check
+     * - Nonce replay protection
+     * - Source divergence tolerance check
+     *
+     * No on-chain interaction. Pure local verification.
+     */
+    verifyPoT(pot) {
+        // 1. Expiry
+        if (BigInt(Date.now()) > pot.expiresAt) {
+            return { valid: false, reason: "PoT expired" };
+        }
+        // 2. HMAC integrity
+        const expected = computeHmac(pot.timestamp, pot.nonce, pot.expiresAt, pot.sources, this.hmacSecret);
+        if (!crypto.timingSafeEqual(Buffer.from(expected, "hex"), Buffer.from(pot.hmac, "hex"))) {
+            return { valid: false, reason: "HMAC mismatch — PoT may have been tampered" };
+        }
+        // 3. Nonce replay (bounded cache + TTL)
+        const now = Date.now();
+        if (this.usedNonces.size > this.MAX_NONCE_CACHE / 2) {
+            for (const [k, ts] of this.usedNonces) {
+                if (now - ts > this.NONCE_TTL_MS)
+                    this.usedNonces.delete(k);
+            }
+        }
+        if (this.usedNonces.has(pot.nonce)) {
+            return { valid: false, reason: "Duplicate nonce — replay detected" };
+        }
+        if (this.usedNonces.size >= this.MAX_NONCE_CACHE) {
+            const oldest = this.usedNonces.keys().next().value;
+            if (oldest !== undefined)
+                this.usedNonces.delete(oldest);
+        }
+        this.usedNonces.set(pot.nonce, now);
+        // 4. Source divergence
+        for (const reading of pot.sourceReadings) {
+            const diff = reading.timestamp > pot.timestamp
+                ? reading.timestamp - pot.timestamp
+                : pot.timestamp - reading.timestamp;
+            if (diff > this.toleranceNs) {
+                return {
+                    valid: false,
+                    reason: `Source ${reading.source} diverges by ${diff}ns (tolerance: ${this.toleranceNs}ns)`,
+                };
+            }
+        }
+        return { valid: true };
+    }
+    /**
+     * Convert HttpPoT to the standard ProofOfTime shape used by the rest of the SDK.
+     * The issuerSignature field is omitted (no on-chain signer in httpOnly mode).
+     */
+    static toProofOfTime(pot) {
+        return {
+            timestamp: pot.timestamp,
+            uncertainty: pot.sourceReadings.length > 0
+                ? pot.sourceReadings.reduce((sum, r) => sum + r.uncertainty, 0) / pot.sourceReadings.length
+                : 500,
+            sources: pot.sources,
+            stratum: pot.stratum,
+            confidence: pot.confidence,
+            sourceReadings: pot.sourceReadings,
+            nonce: pot.nonce,
+            expiresAt: pot.expiresAt,
+        };
+    }
+}
+exports.HttpOnlyClient = HttpOnlyClient;

package/dist/index.d.ts

@@ -1,20 +1,19 @@
 export * from "./evm_connector";
-export * from "./x402_enforcer";
 export * from "./adaptive_switch";
-export * from "./protocol_fee";
 export * from "./pool_registry";
 export * from "./v4_hook";
 export * from "./logger";
 export * from "./types";
 export * from "./http_client";
 export * from "./time_synthesis";
-export * from "./dynamic_fee";
 export * from "./signer";
 export * from "./networks";
 export * from "./errors";
 export * from "./pot_signer";
 export * from "./ct_log";
 export * from "./trust_store";
-export * from "./revenue_tiers";
 export * from "./integrity_client";
 export * from "./osnma_source";
+export * from "./tls_binding";
+export * from "./pot_frame";
+export * from "./pot_verifier";

package/dist/index.js

@@ -19,11 +19,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 //   grg_forward, grg_inverse, grg_pipeline, golay, reed_solomon
 //   auto_mint (GRG 의존)
 // 위 모듈은 서버 코드에서 직접 경로로 import할 것.
+// 유료화 모듈 (private helm repo로 이동):
+//   protocol_fee, revenue_tiers, dynamic_fee, x402_enforcer
 __exportStar(require("./evm_connector"), exports);
-__exportStar(require("./x402_enforcer"), exports);
 __exportStar(require("./adaptive_switch"), exports);
 // ttt_builder omitted — server-internal only
-__exportStar(require("./protocol_fee"), exports);
 __exportStar(require("./pool_registry"), exports);
 __exportStar(require("./v4_hook"), exports);
 __exportStar(require("./logger"), exports);
@@ -31,13 +31,15 @@ __exportStar(require("./types"), exports);
 // ttt_client omitted — requires auto_mint (server-internal, not in public SDK)
 __exportStar(require("./http_client"), exports);
 __exportStar(require("./time_synthesis"), exports);
-__exportStar(require("./dynamic_fee"), exports);
 __exportStar(require("./signer"), exports);
 __exportStar(require("./networks"), exports);
 __exportStar(require("./errors"), exports);
 __exportStar(require("./pot_signer"), exports);
 __exportStar(require("./ct_log"), exports);
 __exportStar(require("./trust_store"), exports);
-__exportStar(require("./revenue_tiers"), exports);
 __exportStar(require("./integrity_client"), exports);
 __exportStar(require("./osnma_source"), exports);
+// TTTPS -02: TLS binding_key implementation (draft-helmprotocol-tttps-02 Section 7.1)
+__exportStar(require("./tls_binding"), exports);
+__exportStar(require("./pot_frame"), exports);
+__exportStar(require("./pot_verifier"), exports);

package/dist/integrity_client.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Integrity Client — replaces local integrity computation with server-side API call.
+ * Core pipeline source code stays in Helm private repo. Only API calls go through npm SDK.
+ *
+ * Drop-in replacement interface for local encode() and verify() operations.
+ */
+export interface IntegrityEncodeResult {
+    /** Hex-encoded serialized shards (joined as JSON array of hex strings) */
+    shards: string[];
+}
+export interface IntegrityVerifyResult {
+    valid: boolean;
+}
+export declare class IntegrityClient {
+    private baseUrl;
+    private timeoutMs;
+    private apiKey;
+    constructor(baseUrl?: string, options?: {
+        timeoutMs?: number;
+        apiKey?: string;
+    });
+    /**
+     * Forward pass: encode data through integrity pipeline (server-side).
+     *
+     * @returns Array of Uint8Array shards
+     */
+    encode(data: Uint8Array, chainId: number, poolAddress: string): Promise<Uint8Array[]>;
+    /**
+     * Verify: check data integrity (server-side).
+     *
+     * @returns boolean — true if data matches the original shards
+     */
+    verify(data: Uint8Array, originalShards: Uint8Array[], chainId: number, poolAddress: string): Promise<boolean>;
+    /**
+     * Health check — ping the integrity API server.
+     * Returns true if reachable within timeoutMs.
+     */
+    isReachable(): Promise<boolean>;
+}
+export declare function getDefaultIntegrityClient(): IntegrityClient;
+export declare function setDefaultIntegrityClient(client: IntegrityClient): void;