openttt 0.2.7 → 0.2.9

package/dist/grg_pipeline.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GrgPipeline = void 0;
-// sdk/src/grg_pipeline.ts
-const grg_forward_1 = require("./grg_forward");
-const grg_inverse_1 = require("./grg_inverse");
-const logger_1 = require("./logger");
-class GrgPipeline {
-    static MAX_INPUT_SIZE = 100 * 1024 * 1024; // 100 MB
-    static processForward(data, chainId, poolAddress) {
-        if (data.length > this.MAX_INPUT_SIZE) {
-            throw new Error(`[GRG] Input size ${data.length} exceeds MAX_INPUT_SIZE ${this.MAX_INPUT_SIZE}`);
-        }
-        logger_1.logger.info("Starting GRG forward pipeline...");
-        try {
-            const shards = grg_forward_1.GrgForward.encode(data, chainId, poolAddress);
-            logger_1.logger.info(`GRG forward pipeline complete. Generated ${shards.length} shards.`);
-            return shards;
-        }
-        catch (error) {
-            logger_1.logger.error(`GRG forward pipeline failed: ${error}`);
-            throw error;
-        }
-    }
-    static processInverse(shards, originalLength, chainId, poolAddress) {
-        logger_1.logger.info("Starting GRG inverse pipeline...");
-        try {
-            const hmacKey = grg_forward_1.GrgForward.deriveHmacKey(chainId, poolAddress);
-            const decodedShards = shards.map(s => {
-                try {
-                    return s ? grg_inverse_1.GrgInverse.golayDecodeWrapper(s, hmacKey) : null;
-                }
-                catch (e) {
-                    logger_1.logger.warn(`Golay decode failed for a shard: ${e}`);
-                    return null;
-                }
-            });
-            const withLen = grg_inverse_1.GrgInverse.redstuffDecode(decodedShards);
-            const decodedLength = (withLen[0] << 24) | (withLen[1] << 16) | (withLen[2] << 8) | withLen[3];
-            const compressed = withLen.subarray(4);
-            const decompressed = grg_inverse_1.GrgInverse.golombDecode(compressed);
-            const final = decompressed.subarray(0, decodedLength);
-            if (final.length !== originalLength) {
-                throw new Error(`[GRG] Length mismatch in inverse: expected ${originalLength}, got ${final.length}`);
-            }
-            logger_1.logger.info("GRG inverse pipeline complete.");
-            return final;
-        }
-        catch (error) {
-            logger_1.logger.error(`GRG inverse pipeline failed: ${error}`);
-            throw error;
-        }
-    }
-}
-exports.GrgPipeline = GrgPipeline;

package/dist/reed_solomon.d.ts

@@ -1,13 +0,0 @@
-export declare class ReedSolomon {
-    private static expTable;
-    private static logTable;
-    private static initialized;
-    private static vandermondeCache;
-    static init(): void;
-    static mul(a: number, b: number): number;
-    static div(a: number, b: number): number;
-    static invertMatrix(matrix: number[][]): number[][];
-    static buildVandermonde(rows: number, cols: number): number[][];
-    static encode(data: Uint8Array, dataShards?: number, parityShards?: number): Uint8Array[];
-    static decode(shards: (Uint8Array | null)[], dataShards?: number, parityShards?: number): Uint8Array;
-}

package/dist/reed_solomon.js

@@ -1,170 +0,0 @@
-"use strict";
-// sdk/src/reed_solomon.ts
-// Reed-Solomon GF(2^8) erasure coding
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReedSolomon = void 0;
-class ReedSolomon {
-    static expTable = new Uint8Array(256);
-    static logTable = new Uint8Array(256);
-    static initialized = false;
-    static vandermondeCache = new Map();
-    static init() {
-        if (this.initialized)
-            return;
-        let x = 1;
-        for (let i = 0; i < 255; i++) {
-            this.expTable[i] = x;
-            this.logTable[x] = i;
-            x <<= 1;
-            if (x & 0x100) {
-                x ^= 0x11D; // x^8 + x^4 + x^3 + x^2 + 1
-            }
-        }
-        this.expTable[255] = this.expTable[0];
-        this.logTable[0] = 0;
-        this.initialized = true;
-    }
-    static mul(a, b) {
-        if (a === 0 || b === 0)
-            return 0;
-        return this.expTable[(this.logTable[a] + this.logTable[b]) % 255];
-    }
-    static div(a, b) {
-        if (b === 0)
-            throw new Error("Division by zero");
-        if (a === 0)
-            return 0;
-        return this.expTable[(this.logTable[a] - this.logTable[b] + 255) % 255];
-    }
-    static invertMatrix(matrix) {
-        const n = matrix.length;
-        const aug = [];
-        for (let i = 0; i < n; i++) {
-            aug[i] = [];
-            for (let j = 0; j < n; j++)
-                aug[i][j] = matrix[i][j];
-            for (let j = 0; j < n; j++)
-                aug[i][j + n] = (i === j) ? 1 : 0;
-        }
-        for (let i = 0; i < n; i++) {
-            let pivot = i;
-            while (pivot < n && aug[pivot][i] === 0)
-                pivot++;
-            if (pivot === n)
-                throw new Error("Singular matrix");
-            if (pivot !== i) {
-                const temp = aug[i];
-                aug[i] = aug[pivot];
-                aug[pivot] = temp;
-            }
-            const pivotVal = aug[i][i];
-            if (pivotVal !== 1) {
-                for (let j = i; j < 2 * n; j++)
-                    aug[i][j] = this.div(aug[i][j], pivotVal);
-            }
-            for (let j = 0; j < n; j++) {
-                if (i !== j && aug[j][i] !== 0) {
-                    const factor = aug[j][i];
-                    for (let k = i; k < 2 * n; k++)
-                        aug[j][k] ^= this.mul(factor, aug[i][k]);
-                }
-            }
-        }
-        const inv = [];
-        for (let i = 0; i < n; i++) {
-            inv[i] = [];
-            for (let j = 0; j < n; j++)
-                inv[i][j] = aug[i][j + n];
-        }
-        return inv;
-    }
-    static buildVandermonde(rows, cols) {
-        const cacheKey = `${rows}-${cols}`;
-        const cached = this.vandermondeCache.get(cacheKey);
-        if (cached)
-            return cached;
-        const V = [];
-        for (let r = 0; r < rows; r++) {
-            V[r] = [];
-            const x = r + 1;
-            for (let c = 0; c < cols; c++) {
-                V[r][c] = c === 0 ? 1 : this.mul(V[r][c - 1], x);
-            }
-        }
-        const V_top = [];
-        for (let i = 0; i < cols; i++)
-            V_top.push([...V[i]]);
-        const V_top_inv = this.invertMatrix(V_top);
-        const G = [];
-        for (let r = 0; r < rows; r++) {
-            G[r] = [];
-            for (let c = 0; c < cols; c++) {
-                let val = 0;
-                for (let k = 0; k < cols; k++)
-                    val ^= this.mul(V[r][k], V_top_inv[k][c]);
-                G[r][c] = val;
-            }
-        }
-        this.vandermondeCache.set(cacheKey, G);
-        return G;
-    }
-    static encode(data, dataShards = 4, parityShards = 2) {
-        this.init();
-        const totalShards = dataShards + parityShards;
-        const rawShardSize = Math.ceil(data.length / dataShards);
-        const shardSize = Math.ceil(rawShardSize / 3) * 3;
-        const matrix = this.buildVandermonde(totalShards, dataShards);
-        const shards = [];
-        for (let i = 0; i < totalShards; i++)
-            shards.push(new Uint8Array(shardSize));
-        for (let i = 0; i < dataShards; i++) {
-            shards[i].set(data.subarray(i * shardSize, Math.min((i + 1) * shardSize, data.length)));
-        }
-        for (let c = 0; c < shardSize; c++) {
-            for (let r = dataShards; r < totalShards; r++) {
-                let val = 0;
-                for (let j = 0; j < dataShards; j++)
-                    val ^= this.mul(matrix[r][j], shards[j][c]);
-                shards[r][c] = val;
-            }
-        }
-        return shards;
-    }
-    static decode(shards, dataShards = 4, parityShards = 2) {
-        this.init();
-        const totalShards = dataShards + parityShards;
-        if (shards.length !== totalShards) {
-            throw new Error(`[RS] Expected ${totalShards} shards, got ${shards.length}`);
-        }
-        const presentIndices = [];
-        const presentShards = [];
-        for (let i = 0; i < totalShards; i++) {
-            if (shards[i] !== null && shards[i] !== undefined) {
-                presentIndices.push(i);
-                presentShards.push(shards[i]);
-                if (presentIndices.length === dataShards)
-                    break;
-            }
-        }
-        if (presentIndices.length < dataShards) {
-            throw new Error(`[RS] Not enough shards for recovery: need ${dataShards}, got ${presentIndices.length}`);
-        }
-        const shardSize = presentShards[0].length;
-        const origMatrix = this.buildVandermonde(totalShards, dataShards);
-        const subMatrix = [];
-        for (let i = 0; i < dataShards; i++)
-            subMatrix.push([...origMatrix[presentIndices[i]]]);
-        const invMatrix = this.invertMatrix(subMatrix);
-        const result = new Uint8Array(shardSize * dataShards);
-        for (let c = 0; c < shardSize; c++) {
-            for (let r = 0; r < dataShards; r++) {
-                let val = 0;
-                for (let j = 0; j < dataShards; j++)
-                    val ^= this.mul(invMatrix[r][j], presentShards[j][c]);
-                result[r * shardSize + c] = val;
-            }
-        }
-        return result;
-    }
-}
-exports.ReedSolomon = ReedSolomon;

package/dist/ttt_client.d.ts

@@ -1,131 +0,0 @@
-import { EventEmitter } from "events";
-import { AutoMintConfig, TTTClientConfig, MintResult, HealthStatus } from "./types";
-import { HttpOnlyClient, HttpOnlyClientOptions } from "./http_client";
-export { HealthStatus } from "./types";
-/**
- * Typed event map for TTTClient EventEmitter.
- */
-export interface TTTClientEvents {
-    mint: [result: MintResult];
-    error: [error: Error];
-    alert: [alert: string];
-    latency: [ms: number];
-    modeSwitch: [mode: string];
-}
-/**
- * TTTClient - SDK entry point for DEX operators.
- * Initializes all internal modules and manages the auto-minting process.
- */
-export declare class TTTClient extends EventEmitter {
-    private config;
-    private autoMintEngine;
-    private poolRegistry;
-    private isInitialized;
-    private mintCount;
-    private mintFailures;
-    private totalFeesPaid;
-    private signer;
-    private lastTokenId;
-    private mintLatencies;
-    private maxLatencyHistory;
-    private lastMintAt;
-    private startedAt;
-    private minBalanceWei;
-    constructor(config: AutoMintConfig);
-    /**
-     * Static factory for Base Mainnet
-     */
-    static forBase(config: Omit<TTTClientConfig, 'network'>): Promise<TTTClient>;
-    /**
-     * Static factory for Base Sepolia
-     */
-    static forSepolia(config: Omit<TTTClientConfig, 'network'>): Promise<TTTClient>;
-    /**
-     * Zero-friction sandbox mode — no ETH, no signer, no on-chain interaction.
-     *
-     * Returns an HttpOnlyClient that fetches verified time from NIST, Apple,
-     * Google, and Cloudflare HTTPS endpoints and produces HMAC-signed PoTs.
-     *
-     * @example
-     * // Zero-friction: no wallet, no RPC, no gas
-     * const client = TTTClient.httpOnly();
-     * const pot = await client.generatePoT();
-     * console.log(pot.timestamp, pot.confidence);
-     *
-     * // Verify locally (no on-chain check needed)
-     * const result = client.verifyPoT(pot);
-     * console.log(result.valid); // true
-     */
-    static httpOnly(options?: HttpOnlyClientOptions): HttpOnlyClient;
-    /**
-     * Universal factory to create and initialize a client
-     */
-    static create(config: TTTClientConfig): Promise<TTTClient>;
-    /**
-     * Gracefully shuts down the SDK, stopping all background processes and listeners.
-     */
-    destroy(): Promise<void>;
-    /**
-     * Initialize the SDK: RPC connection, time sources, fee engine wiring.
-     */
-    initialize(): Promise<void>;
-    /**
-     * Start the auto-minting process.
-     */
-    startAutoMint(): void;
-    /**
-     * Stop the auto-minting process.
-     */
-    stopAutoMint(): void;
-    /**
-     * Resume auto-minting after a circuit breaker trip.
-     * Resets consecutive failure count and restarts the engine.
-     */
-    resume(): void;
-    /**
-     * List registered pools.
-     */
-    listPools(): string[];
-    /**
-     * Get stats for a specific pool.
-     */
-    getPoolStats(poolAddress: string): {
-        minted: bigint;
-        burned: bigint;
-    } | null;
-    /**
-     * Set minimum ETH balance threshold for health alerts.
-     */
-    setMinBalance(weiAmount: bigint): void;
-    /**
-     * Register alert callback for real-time notifications.
-     * Backward compatible: delegates to EventEmitter 'alert' event.
-     */
-    onAlert(callback: (alert: string) => void): void;
-    private emitAlert;
-    /**
-     * Record a mint failure (called internally or externally).
-     */
-    recordMintFailure(): void;
-    /**
-     * Record mint latency in ms (called from auto-mint wrapper).
-     */
-    recordMintLatency(ms: number): void;
-    /**
-     * Production health check — liveness + readiness + metrics.
-     * No exceptions: always returns a HealthStatus object.
-     */
-    getHealth(): Promise<HealthStatus>;
-    /**
-     * Return current SDK status and statistics (balance, mint count, fees, etc.)
-     */
-    getStatus(): Promise<{
-        isInitialized: boolean;
-        tier: string;
-        mintCount: number;
-        totalFeesPaid: string;
-        balance: string;
-        tttBalance: string;
-        lastTokenId: string | null;
-    }>;
-}