openttt 0.2.7 → 0.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openttt",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "description": "OpenTTT — TLS-grade transaction ordering for DeFi. Time + Logic + Sync.",
   "license": "BSL-1.1",
   "repository": {
@@ -30,7 +30,50 @@
     }
   },
   "files": [
-    "dist",
+    "dist/ct_log.js",
+    "dist/ct_log.d.ts",
+    "dist/dynamic_fee.js",
+    "dist/dynamic_fee.d.ts",
+    "dist/errors.js",
+    "dist/errors.d.ts",
+    "dist/evm_connector.js",
+    "dist/evm_connector.d.ts",
+    "dist/http_client.js",
+    "dist/http_client.d.ts",
+    "dist/index.js",
+    "dist/index.d.ts",
+    "dist/integrity_client.js",
+    "dist/integrity_client.d.ts",
+    "dist/logger.js",
+    "dist/logger.d.ts",
+    "dist/networks.js",
+    "dist/networks.d.ts",
+    "dist/osnma_source.js",
+    "dist/osnma_source.d.ts",
+    "dist/pool_registry.js",
+    "dist/pool_registry.d.ts",
+    "dist/pot_signer.js",
+    "dist/pot_signer.d.ts",
+    "dist/protocol_fee.js",
+    "dist/protocol_fee.d.ts",
+    "dist/revenue_tiers.js",
+    "dist/revenue_tiers.d.ts",
+    "dist/signer.js",
+    "dist/signer.d.ts",
+    "dist/time_synthesis.js",
+    "dist/time_synthesis.d.ts",
+    "dist/trust_store.js",
+    "dist/trust_store.d.ts",
+    "dist/ttt_builder.js",
+    "dist/ttt_builder.d.ts",
+    "dist/ttt_client.js",
+    "dist/ttt_client.d.ts",
+    "dist/types.js",
+    "dist/types.d.ts",
+    "dist/v4_hook.js",
+    "dist/v4_hook.d.ts",
+    "dist/x402_enforcer.js",
+    "dist/x402_enforcer.d.ts",
     "README.md"
   ],
   "scripts": {

package/dist/adaptive_switch.d.ts

@@ -1,59 +0,0 @@
-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) — auditor-requested upgrade */
-export declare const TIER_TOLERANCE_MS: Record<string, number>;
-export declare class AdaptiveSwitch {
-    private windowSize;
-    private threshold;
-    private history;
-    private currentMode;
-    private minBlocks;
-    private penaltyCooldown;
-    private consecutiveFailures;
-    private turboEntryThreshold;
-    private turboMaintainThreshold;
-    private tolerance;
-    constructor(options?: {
-        tolerance?: number;
-    });
-    /**
-     * Core TTT mechanism: switches between Turbo/Full mode based on timestamp ordering match rate.
-     */
-    verifyBlock(block: Block, tttRecord: TTTRecord, chainId: number, poolAddress: string, tier?: string): AdaptiveMode;
-    /**
-     * Return fee discount rate based on current mode.
-     * TURBO: 20% discount (incentivizes profitability).
-     * FULL: No discount.
-     */
-    getFeeDiscount(): number;
-    /**
-     * Get current adaptive mode.
-     */
-    getCurrentMode(): AdaptiveMode;
-    /**
-     * Reset history (for testing).
-     */
-    reset(): void;
-    /**
-     * Serialize internal state to JSON for persistence across restarts.
-     * Allows operators to avoid re-learning over 20 blocks after a restart.
-     */
-    serialize(): string;
-    /**
-     * Reconstruct an AdaptiveSwitch from previously serialized JSON state.
-     */
-    static deserialize(json: string): AdaptiveSwitch;
-    private compareTransactionOrder;
-}

package/dist/adaptive_switch.js

@@ -1,145 +0,0 @@
-"use strict";
-// sdk/src/adaptive_switch.ts — Adaptive Mode Switcher
-// Turbo (50ms) vs Full (127ms)
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AdaptiveSwitch = exports.TIER_TOLERANCE_MS = exports.AdaptiveMode = void 0;
-const grg_inverse_1 = require("./grg_inverse");
-const logger_1 = require("./logger");
-var AdaptiveMode;
-(function (AdaptiveMode) {
-    AdaptiveMode["TURBO"] = "TURBO";
-    AdaptiveMode["FULL"] = "FULL";
-})(AdaptiveMode || (exports.AdaptiveMode = AdaptiveMode = {}));
-// const TOLERANCE = 100; // 100ms tolerance for GEO-sat operator sync (now configurable via constructor)
-/** Tier-based dynamic tolerance (ms) — auditor-requested upgrade */
-exports.TIER_TOLERANCE_MS = {
-    T0_epoch: 2000, // 6.4min tick → 2s tolerance
-    T1_block: 200, // 2s tick → 200ms
-    T2_slot: 500, // 12s tick → 500ms
-    T3_micro: 10, // 100ms tick → 10ms (10%)
-};
-class AdaptiveSwitch {
-    windowSize = 20; // B1-9: Updated from 10 to 20
-    threshold = 0.9; // B1-9: Updated from 0.8 to 0.9
-    history = [];
-    currentMode = AdaptiveMode.FULL;
-    minBlocks = 20; // B1-9: Minimum blocks for TURBO transition
-    penaltyCooldown = 0; // B1-9: Penalty cooldown (P2-1: increased to 20 + exponential backoff)
-    consecutiveFailures = 0; // P2-1: Track consecutive failures for exponential backoff
-    turboEntryThreshold = 0.95; // P2-2: Hysteresis — stricter entry
-    turboMaintainThreshold = 0.85; // P2-2: Hysteresis — relaxed maintenance
-    tolerance;
-    constructor(options) {
-        this.tolerance = options?.tolerance ?? 100;
-    }
-    /**
-     * Core TTT mechanism: switches between Turbo/Full mode based on timestamp ordering match rate.
-     */
-    verifyBlock(block, tttRecord, chainId, poolAddress, tier) {
-        // 1. Check timestamp ordering and time match
-        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;
-        let sequenceOk = orderMatch && timeMatch;
-        // B1-1: Do not skip GrgInverse.verify() in TURBO mode
-        // We check integrity regardless of mode
-        const integrityOk = grg_inverse_1.GrgInverse.verify(block.data, tttRecord.grgPayload, chainId, poolAddress);
-        if (!integrityOk) {
-            logger_1.logger.error(`[AdaptiveSwitch] GRG integrity check FAILED`);
-            sequenceOk = false; // Mark as false if integrity fails
-            if (this.currentMode === AdaptiveMode.TURBO) {
-                logger_1.logger.warn(`[AdaptiveSwitch] TURBO integrity failure: Penalty cooldown applied`);
-                // P2-1: Exponential backoff — 20 * 2^(consecutiveFailures), capped at 320
-                this.consecutiveFailures = Math.min(this.consecutiveFailures + 1, 4);
-                this.penaltyCooldown = 20 * Math.pow(2, this.consecutiveFailures - 1); // 20, 40, 80, 160, 320
-            }
-        }
-        // 2. Update history (Sliding Window)
-        this.history.push(sequenceOk);
-        if (this.history.length > this.windowSize) {
-            this.history.shift();
-        }
-        if (this.penaltyCooldown > 0) {
-            this.penaltyCooldown--;
-        }
-        // 3. Calculate match rate and switch mode
-        const matchCount = this.history.filter(h => h).length;
-        const matchRate = this.history.length > 0 ? matchCount / this.history.length : 0;
-        // P2-2: Hysteresis — different thresholds for entering vs maintaining TURBO
-        const effectiveThreshold = this.currentMode === AdaptiveMode.TURBO
-            ? this.turboMaintainThreshold // 85% to stay in TURBO
-            : this.turboEntryThreshold; // 95% to enter TURBO
-        if (this.history.length >= this.minBlocks && matchRate >= effectiveThreshold && this.penaltyCooldown === 0) {
-            if (this.currentMode === AdaptiveMode.FULL) {
-                logger_1.logger.info(`[AdaptiveSwitch] Switching to TURBO mode (Match rate: ${(matchRate * 100).toFixed(1)}%, Entry threshold: ${(this.turboEntryThreshold * 100).toFixed(0)}%)`);
-            }
-            this.currentMode = AdaptiveMode.TURBO;
-            this.consecutiveFailures = 0; // P2-1: Reset on successful TURBO
-        }
-        else {
-            if (this.currentMode === AdaptiveMode.TURBO) {
-                logger_1.logger.warn(`[AdaptiveSwitch] Switching to FULL mode (Match rate: ${(matchRate * 100).toFixed(1)}%, Maintain threshold: ${(this.turboMaintainThreshold * 100).toFixed(0)}%, Cooldown: ${this.penaltyCooldown})`);
-            }
-            this.currentMode = AdaptiveMode.FULL;
-        }
-        return this.currentMode;
-    }
-    /**
-     * Return fee discount rate based on current mode.
-     * TURBO: 20% discount (incentivizes profitability).
-     * FULL: No discount.
-     */
-    getFeeDiscount() {
-        return this.currentMode === AdaptiveMode.TURBO ? 0.2 : 0.0;
-    }
-    /**
-     * Get current adaptive mode.
-     */
-    getCurrentMode() {
-        return this.currentMode;
-    }
-    /**
-     * Reset history (for testing).
-     */
-    reset() {
-        this.history = [];
-        this.currentMode = AdaptiveMode.FULL;
-        this.penaltyCooldown = 0;
-        this.consecutiveFailures = 0;
-    }
-    /**
-     * Serialize internal state to JSON for persistence across restarts.
-     * Allows operators to avoid re-learning over 20 blocks after a restart.
-     */
-    serialize() {
-        return JSON.stringify({
-            history: this.history,
-            currentMode: this.currentMode,
-            consecutiveFailures: this.consecutiveFailures,
-            penaltyCooldown: this.penaltyCooldown,
-            tolerance: this.tolerance,
-        });
-    }
-    /**
-     * Reconstruct an AdaptiveSwitch from previously serialized JSON state.
-     */
-    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/auto_mint.d.ts

@@ -1,61 +0,0 @@
-import { TimeSynthesis } from "./time_synthesis";
-import { EVMConnector } from "./evm_connector";
-import { AutoMintConfig, MintResult } from "./types";
-/**
- * AutoMintEngine - Automatic TTT minting engine.
- * Combines time synthesis, dynamic fee calculation, and EVM minting into a single loop.
- */
-export declare class AutoMintEngine {
-    private config;
-    private timeSynthesis;
-    private feeEngine;
-    private evmConnector;
-    private feeCollector;
-    private timer;
-    private isRunning;
-    private isProcessing;
-    private onMintCallback?;
-    private onFailureCallback?;
-    private onLatencyCallback?;
-    private cachedSigner;
-    private consecutiveFailures;
-    private maxConsecutiveFailures;
-    private potSigner;
-    /** Monotonic counter appended to tokenId hash to prevent collision when two mints share the same nanosecond timestamp. */
-    private mintNonce;
-    /** Fire the GRG >50ms performance warning at most once per engine session. */
-    private warnedGrgSlow;
-    constructor(config: AutoMintConfig);
-    getEvmConnector(): EVMConnector;
-    getTimeSynthesis(): TimeSynthesis;
-    setOnMint(callback: (result: MintResult) => void): void;
-    setOnFailure(callback: (error: Error) => void): void;
-    setOnLatency(callback: (ms: number) => void): void;
-    /**
-     * Initialize the engine (RPC connection and contract setup).
-     */
-    initialize(): Promise<void>;
-    /**
-     * Start the automatic minting loop.
-     */
-    start(): void;
-    /**
-     * Stop the automatic minting loop.
-     */
-    stop(): void;
-    /**
-     * Resume the minting loop after a circuit breaker trip.
-     * Resets the consecutive failure counter and restarts the loop.
-     */
-    resume(): void;
-    /**
-     * Sleep helper for retry backoff.
-     */
-    private sleep;
-    /**
-     * Execute a single mint tick.
-     * Time synthesis -> tokenId generation -> EVM mint call -> fee calculation/deduction.
-     */
-    mintTick(): Promise<void>;
-    private signFeeMessage;
-}

package/dist/auto_mint.js

@@ -1,330 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AutoMintEngine = void 0;
-const ethers_1 = require("ethers");
-const time_synthesis_1 = require("./time_synthesis");
-const dynamic_fee_1 = require("./dynamic_fee");
-const evm_connector_1 = require("./evm_connector");
-const protocol_fee_1 = require("./protocol_fee");
-const pot_signer_1 = require("./pot_signer");
-const grg_forward_1 = require("./grg_forward");
-const types_1 = require("./types");
-const logger_1 = require("./logger");
-const errors_1 = require("./errors");
-/** Maximum retry attempts for RPC-dependent operations within a single tick */
-const MINT_TICK_MAX_RETRIES = 3;
-/** Backoff durations in ms for each retry attempt (1s, 2s, 4s) */
-const MINT_TICK_BACKOFF_MS = [1000, 2000, 4000];
-/**
- * AutoMintEngine - Automatic TTT minting engine.
- * Combines time synthesis, dynamic fee calculation, and EVM minting into a single loop.
- */
-class AutoMintEngine {
-    config;
-    timeSynthesis;
-    feeEngine;
-    evmConnector;
-    feeCollector = null;
-    timer = null;
-    isRunning = false;
-    isProcessing = false;
-    onMintCallback;
-    onFailureCallback;
-    onLatencyCallback;
-    cachedSigner = null;
-    consecutiveFailures = 0;
-    maxConsecutiveFailures = 5;
-    potSigner = null;
-    /** Monotonic counter appended to tokenId hash to prevent collision when two mints share the same nanosecond timestamp. */
-    mintNonce = BigInt(Date.now());
-    /** Fire the GRG >50ms performance warning at most once per engine session. */
-    warnedGrgSlow = false;
-    constructor(config) {
-        this.config = config;
-        this.timeSynthesis = new time_synthesis_1.TimeSynthesis({ sources: config.timeSources });
-        this.feeEngine = new dynamic_fee_1.DynamicFeeEngine({
-            cacheDurationMs: 5000,
-            fallbackPriceUsd: config.fallbackPriceUsd || 10000n,
-        });
-        this.evmConnector = new evm_connector_1.EVMConnector();
-        if (config.signer) {
-            this.cachedSigner = config.signer;
-        }
-        // Initialize Ed25519 PoT signer for non-repudiation
-        this.potSigner = config.potSignerKeyPath
-            ? pot_signer_1.PotSigner.createOrLoad(config.potSignerKeyPath)
-            : new pot_signer_1.PotSigner();
-    }
-    getEvmConnector() {
-        return this.evmConnector;
-    }
-    getTimeSynthesis() {
-        return this.timeSynthesis;
-    }
-    setOnMint(callback) {
-        this.onMintCallback = callback;
-    }
-    setOnFailure(callback) {
-        this.onFailureCallback = callback;
-    }
-    setOnLatency(callback) {
-        this.onLatencyCallback = callback;
-    }
-    /**
-     * Initialize the engine (RPC connection and contract setup).
-     */
-    async initialize() {
-        try {
-            const signerOrKey = this.config.signer || this.config.privateKey;
-            if (!signerOrKey)
-                throw new errors_1.TTTConfigError(errors_1.ERROR_CODES.CONFIG_MISSING_SIGNER, "[AutoMint] Signer or Private Key is required", "Missing both 'signer' and 'privateKey' in config", "Provide a valid ethers.Signer or a private key string in your configuration.");
-            await this.evmConnector.connect(this.config.rpcUrl, signerOrKey);
-            await this.feeEngine.connect(this.config.rpcUrl);
-            this.cachedSigner = this.evmConnector.getSigner();
-            const tttAbi = [
-                "function mint(address to, uint256 amount, bytes32 grgHash) external returns (bool)",
-                "function burn(uint256 amount, bytes32 grgHash, uint256 tier) external",
-                "function balanceOf(address account, uint256 id) external view returns (uint256)",
-                "event TTTMinted(address indexed to, uint256 indexed tokenId, uint256 amount)",
-                "event TTTBurned(address indexed from, uint256 indexed tokenId, uint256 amount, uint256 tier)",
-                // CT Log equivalent: every PoT is publicly auditable on-chain
-                evm_connector_1.EVMConnector.POT_ANCHORED_EVENT_ABI
-            ];
-            this.evmConnector.attachContract(this.config.contractAddress, tttAbi);
-            if (this.config.feeCollectorAddress) {
-                this.feeCollector = new protocol_fee_1.ProtocolFeeCollector(this.config.chainId, this.config.feeCollectorAddress, this.evmConnector, this.config.protocolFeeRecipient);
-                await this.feeCollector.validateChainId();
-            }
-        }
-        catch (error) {
-            // State rollback: Ensure connections are closed or reset
-            this.evmConnector = new evm_connector_1.EVMConnector();
-            this.cachedSigner = null;
-            this.feeCollector = null;
-            logger_1.logger.error(`[AutoMint] Initialization failed, state rolled back: ${error instanceof Error ? error.message : error}`);
-            throw error;
-        }
-    }
-    /**
-     * Start the automatic minting loop.
-     */
-    start() {
-        if (this.isRunning)
-            return;
-        // Clear existing timer if any
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = null;
-        }
-        const interval = types_1.TierIntervals[this.config.tier];
-        this.isRunning = true;
-        this.timer = setInterval(async () => {
-            if (this.isProcessing)
-                return;
-            this.isProcessing = true;
-            const tickStart = Date.now();
-            try {
-                await this.mintTick();
-                this.consecutiveFailures = 0;
-                // H2: Report latency to TTTClient
-                if (this.onLatencyCallback) {
-                    this.onLatencyCallback(Date.now() - tickStart);
-                }
-            }
-            catch (error) {
-                this.consecutiveFailures++;
-                // H2: Report failure to TTTClient
-                if (this.onFailureCallback) {
-                    this.onFailureCallback(error instanceof Error ? error : new Error(String(error)));
-                }
-                logger_1.logger.error(`[AutoMint] Tick execution failed (${this.consecutiveFailures}/${this.maxConsecutiveFailures}): ${error instanceof Error ? error.message : error}`);
-                if (this.consecutiveFailures >= this.maxConsecutiveFailures) {
-                    logger_1.logger.error(`[AutoMint] Circuit breaker triggered: ${this.consecutiveFailures} consecutive failures. Stopping engine to prevent DoS.`);
-                    this.stop();
-                }
-            }
-            finally {
-                this.isProcessing = false;
-            }
-        }, interval);
-        logger_1.logger.info(`[AutoMint] Loop started for tier ${this.config.tier} (${interval}ms)`);
-    }
-    /**
-     * Stop the automatic minting loop.
-     */
-    stop() {
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = null;
-        }
-        this.isRunning = false;
-        logger_1.logger.info(`[AutoMint] Loop stopped`);
-    }
-    /**
-     * Resume the minting loop after a circuit breaker trip.
-     * Resets the consecutive failure counter and restarts the loop.
-     */
-    resume() {
-        this.consecutiveFailures = 0;
-        logger_1.logger.info(`[AutoMint] Consecutive failures reset, resuming...`);
-        this.start();
-    }
-    /**
-     * Sleep helper for retry backoff.
-     */
-    sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-    /**
-     * Execute a single mint tick.
-     * Time synthesis -> tokenId generation -> EVM mint call -> fee calculation/deduction.
-     */
-    async mintTick() {
-        // 1. Time Synthesis
-        const synthesized = await this.timeSynthesis.synthesize();
-        if (!synthesized) {
-            logger_1.logger.warn(`[AutoMint] Time synthesis returned null/undefined, skipping tick`);
-            return;
-        }
-        // Fix-12: Integrity check
-        if (synthesized.confidence === 0 || synthesized.stratum >= 16) {
-            throw new errors_1.TTTTimeSynthesisError(errors_1.ERROR_CODES.TIME_SYNTHESIS_INTEGRITY_FAILED, `[AutoMint] Synthesis integrity check failed`, `confidence=${synthesized.confidence}, stratum=${synthesized.stratum}`, `Check NTP sources or network connectivity.`);
-        }
-        // 1-1. PoT Generation & Validation (W1-1)
-        const pot = await this.timeSynthesis.generateProofOfTime();
-        if (pot.confidence < 0.5) {
-            throw new errors_1.TTTTimeSynthesisError(errors_1.ERROR_CODES.TIME_SYNTHESIS_INSUFFICIENT_CONFIDENCE, `[PoT] Insufficient confidence`, `Calculated confidence ${pot.confidence} is below required 0.5`, `Ensure more NTP sources are reachable or decrease uncertainty.`);
-        }
-        // Deterministic potHash via ABI.encode — field order is fixed,
-        // independent of JS engine key ordering. External verifiers can
-        // reproduce this hash from the same PoT fields.
-        const nonceHash = ethers_1.ethers.keccak256(ethers_1.ethers.toUtf8Bytes(pot.nonce));
-        const potHash = ethers_1.ethers.keccak256(ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(["uint64", "uint64", "uint8", "uint8", "uint32", "bytes32"], [
-            pot.timestamp,
-            pot.expiresAt,
-            pot.sources,
-            pot.stratum,
-            Math.round(pot.confidence * 1_000_000),
-            nonceHash
-        ]));
-        // 1-2. Ed25519 issuer signature for non-repudiation
-        if (this.potSigner) {
-            pot.issuerSignature = this.potSigner.signPot(potHash);
-            logger_1.logger.info(`[AutoMint] PoT signed by issuer ${this.potSigner.getPubKeyHex().substring(0, 16)}...`);
-        }
-        // 2. Generate tokenId (keccak256)
-        // Unique ID based on chainId, poolAddress, timestamp, and a monotonic nonce
-        // to prevent collision if two mints occur at the same nanosecond timestamp.
-        const nonceSuffix = this.mintNonce;
-        this.mintNonce++;
-        const tokenId = ethers_1.ethers.keccak256(ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(["uint256", "address", "uint64", "uint256"], [BigInt(this.config.chainId), this.config.poolAddress, synthesized.timestamp, nonceSuffix]));
-        // 3. Fee calculation
-        const feeCalculation = await this.feeEngine.calculateMintFee(this.config.tier);
-        // 4. EVM mint call — run GRG integrity pipeline
-        const grgPayload = ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(["bytes32", "bytes32", "uint64", "uint8"], [tokenId, potHash, synthesized.timestamp, pot.sources]);
-        const grgStart = Date.now();
-        const grgShards = grg_forward_1.GrgForward.encode(ethers_1.ethers.getBytes(grgPayload), this.config.chainId, this.config.poolAddress);
-        const grgElapsed = Date.now() - grgStart;
-        logger_1.logger.info(`[AutoMint] GRG pipeline completed in ${grgElapsed}ms`);
-        if (grgElapsed > 50 && !this.warnedGrgSlow) {
-            this.warnedGrgSlow = true;
-            logger_1.logger.warn(`[AutoMint] GRG pipeline took ${grgElapsed}ms (>50ms threshold). Consider offloading to a Worker Thread for T3_micro tiers.`);
-        }
-        // On-chain hash = keccak256 of concatenated GRG-encoded shards
-        const grgHash = ethers_1.ethers.keccak256(ethers_1.ethers.concat(grgShards));
-        // Recipient address (defaults to signer address)
-        if (!this.cachedSigner) {
-            throw new errors_1.TTTSignerError(errors_1.ERROR_CODES.SIGNER_NOT_INITIALIZED, "[AutoMint] Signer not initialized", "cachedSigner is null", "Initialize the engine before calling mintTick().");
-        }
-        const recipient = await this.cachedSigner.getAddress();
-        logger_1.logger.info(`[AutoMint] Executing mint: tokenId=${tokenId.substring(0, 10)}... amount=${feeCalculation.tttAmount}`);
-        // Retry loop for RPC-dependent mint operation (max 3 attempts, backoff 1s/2s/4s)
-        let receipt;
-        let lastError = null;
-        for (let attempt = 0; attempt < MINT_TICK_MAX_RETRIES; attempt++) {
-            try {
-                receipt = await this.evmConnector.mintTTT(recipient, feeCalculation.tttAmount, grgHash, potHash);
-                lastError = null;
-                break;
-            }
-            catch (err) {
-                lastError = err instanceof Error ? err : new Error(String(err));
-                if (attempt < MINT_TICK_MAX_RETRIES - 1) {
-                    const backoff = MINT_TICK_BACKOFF_MS[attempt];
-                    logger_1.logger.warn(`[AutoMint] Mint attempt ${attempt + 1}/${MINT_TICK_MAX_RETRIES} failed, retrying in ${backoff}ms: ${lastError.message}`);
-                    await this.sleep(backoff);
-                }
-            }
-        }
-        if (lastError || !receipt) {
-            throw lastError || new Error("[AutoMint] Mint failed after all retries");
-        }
-        // 5. Fee deduction/recording (handled by contract or tracked at SDK level)
-        // W2-3: Actual ProtocolFeeCollector call
-        let actualFeePaid = feeCalculation.protocolFeeUsd;
-        if (this.feeCollector && this.config.feeCollectorAddress) {
-            try {
-                // NOTE: Single-threaded JS guarantees atomicity between nonce generation,
-                // signing, and collection below. If running multiple AutoMintEngine instances
-                // (e.g., worker_threads or cluster), a separate nonce manager with locking is required.
-                // Sequential nonce: query contract for current nonce, matching ProtocolFee.sol's require(nonces[msg.sender] == nonce)
-                const feeContract = new ethers_1.ethers.Contract(this.config.feeCollectorAddress, ["function getNonce(address) external view returns (uint256)"], this.evmConnector.getProvider());
-                const nonce = BigInt(await feeContract.getNonce(recipient));
-                const deadline = Math.floor(Date.now() / 1000) + 3600; // 1 hour validity
-                const signature = await this.signFeeMessage(feeCalculation, nonce, deadline);
-                const user = recipient;
-                await this.feeCollector.collectMintFee(feeCalculation, signature, user, nonce, deadline);
-            }
-            catch (feeError) {
-                logger_1.logger.error(`[AutoMint] Fee collection failed but mint was successful: ${feeError instanceof Error ? feeError.message : feeError}`);
-                // Reset to 0 so downstream (onMint callback, ledger) does not record a fee that was never collected
-                actualFeePaid = 0n;
-            }
-        }
-        // CT Log equivalent: log PoT anchor info for subgraph indexers
-        logger_1.logger.info(`[AutoMint] PoTAnchored: timestamp=${synthesized.timestamp}, grgHash=${grgHash}, stratum=${synthesized.stratum}, potHash=${potHash}`);
-        logger_1.logger.info(`[AutoMint] Mint success: tx=${receipt.hash}, feePaid=${actualFeePaid} (USDC eq)`);
-        if (this.onMintCallback) {
-            this.onMintCallback({
-                tokenId: tokenId,
-                grgHash: grgHash,
-                timestamp: synthesized.timestamp,
-                txHash: receipt.hash,
-                protocolFeePaid: actualFeePaid,
-                proofOfTime: pot
-            });
-        }
-    }
-    async signFeeMessage(feeCalc, nonce, deadline) {
-        if (!this.cachedSigner) {
-            throw new errors_1.TTTSignerError(errors_1.ERROR_CODES.SIGNER_NOT_INITIALIZED, "[AutoMint] Signer not initialized", "cachedSigner is null", "Ensure initialize() was called successfully.");
-        }
-        // Type casting to handle signTypedData if available on the signer (Wallet supports it)
-        const signer = this.cachedSigner;
-        if (typeof signer.signTypedData !== 'function') {
-            throw new errors_1.TTTSignerError(errors_1.ERROR_CODES.SIGNER_NO_EIP712, "[AutoMint] Provided signer does not support signTypedData (EIP-712)", `Signer type ${signer.constructor.name} missing signTypedData`, "Use a Wallet or a signer that implements EIP-712 signTypedData.");
-        }
-        const domain = {
-            name: "OpenTTT_ProtocolFee",
-            version: "1",
-            chainId: this.config.chainId,
-            verifyingContract: this.config.feeCollectorAddress
-        };
-        const types = {
-            CollectFee: [
-                { name: "token", type: "address" },
-                { name: "amount", type: "uint256" },
-                { name: "nonce", type: "uint256" },
-                { name: "deadline", type: "uint256" }
-            ]
-        };
-        const value = {
-            token: ethers_1.ethers.getAddress(feeCalc.feeTokenAddress),
-            amount: feeCalc.protocolFeeUsd,
-            nonce: nonce,
-            deadline: deadline
-        };
-        return await signer.signTypedData(domain, types, value);
-    }
-}
-exports.AutoMintEngine = AutoMintEngine;

package/dist/golay.d.ts

@@ -1,7 +0,0 @@
-export interface GolayDecodeResult {
-    data: Uint8Array;
-    corrected: number;
-    uncorrectable: boolean;
-}
-export declare function golayEncode(data: Uint8Array): Uint8Array;
-export declare function golayDecode(encoded: Uint8Array): GolayDecodeResult;

package/dist/golay.js

@@ -1,139 +0,0 @@
-"use strict";
-// sdk/src/golay.ts
-// Golay(24,12) Extended Binary Golay Code
-// Corrects up to 3 bit errors, detects 4 bit errors.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.golayEncode = golayEncode;
-exports.golayDecode = golayDecode;
-// Standard Golay Parity Matrix P (12x12) - Systematic Form [I12 | P]
-// Every row has weight 7.
-// Verified: P*P^T = I (mod 2), all rows weight 7.
-const P = [
-    0xC75, 0x49F, 0xD4B, 0x6E3, 0x9B3, 0xB66,
-    0xECC, 0x1ED, 0x3DA, 0x7B4, 0xB1D, 0xE3A
-];
-// P^T (transpose of P) — required for second syndrome computation.
-// P is NOT symmetric, so s2 = s*P^T must use this separate matrix.
-const PT = [
-    0xAE3, 0xF25, 0x16F, 0x2DE, 0x5BC, 0xB78,
-    0x9D5, 0xC8F, 0x63B, 0xC76, 0x7C9, 0xF92
-];
-const UNIT_VECTORS = [
-    0x800, 0x400, 0x200, 0x100, 0x080, 0x040,
-    0x020, 0x010, 0x008, 0x004, 0x002, 0x001
-];
-function weight(n) {
-    let count = 0;
-    let temp = n & 0xFFF;
-    while (temp > 0) {
-        temp &= (temp - 1);
-        count++;
-    }
-    return count;
-}
-function multiplyP(v) {
-    let res = 0;
-    for (let i = 0; i < 12; i++) {
-        if ((v >> (11 - i)) & 1) {
-            res ^= P[i];
-        }
-    }
-    return res & 0xFFF;
-}
-function multiplyPT(v) {
-    let res = 0;
-    for (let i = 0; i < 12; i++) {
-        if ((v >> (11 - i)) & 1) {
-            res ^= PT[i];
-        }
-    }
-    return res & 0xFFF;
-}
-function encodeWord(msg) {
-    const parity = multiplyP(msg & 0xFFF);
-    return ((msg & 0xFFF) << 12) | parity;
-}
-function decodeWord(received) {
-    let r_m = (received >> 12) & 0xFFF;
-    const r_p = received & 0xFFF;
-    const s = multiplyP(r_m) ^ r_p;
-    if (s === 0)
-        return { msg: r_m, corrected: 0, uncorrectable: false };
-    if (weight(s) <= 3) {
-        return { msg: r_m, corrected: weight(s), uncorrectable: false };
-    }
-    for (let i = 0; i < 12; i++) {
-        if (weight(s ^ P[i]) <= 2) {
-            return { msg: r_m ^ UNIT_VECTORS[i], corrected: weight(s ^ P[i]) + 1, uncorrectable: false };
-        }
-    }
-    const s2 = multiplyPT(s);
-    if (weight(s2) <= 3) {
-        return { msg: r_m ^ s2, corrected: weight(s2), uncorrectable: false };
-    }
-    for (let i = 0; i < 12; i++) {
-        if (weight(s2 ^ PT[i]) <= 2) {
-            const error_m = s2 ^ PT[i];
-            return { msg: r_m ^ error_m, corrected: weight(s2 ^ PT[i]) + 1, uncorrectable: false };
-        }
-    }
-    return { msg: r_m, corrected: 0, uncorrectable: true };
-}
-function golayEncode(data) {
-    const out = new Uint8Array(Math.ceil(data.length / 3) * 6);
-    let outIdx = 0;
-    for (let i = 0; i < data.length; i += 3) {
-        const b1 = data[i];
-        const b2 = i + 1 < data.length ? data[i + 1] : 0;
-        const b3 = i + 2 < data.length ? data[i + 2] : 0;
-        const w1 = (b1 << 4) | (b2 >> 4);
-        const c1 = encodeWord(w1);
-        out[outIdx++] = (c1 >> 16) & 0xFF;
-        out[outIdx++] = (c1 >> 8) & 0xFF;
-        out[outIdx++] = c1 & 0xFF;
-        if (i + 1 < data.length) {
-            const w2 = ((b2 & 0x0F) << 8) | b3;
-            const c2 = encodeWord(w2);
-            out[outIdx++] = (c2 >> 16) & 0xFF;
-            out[outIdx++] = (c2 >> 8) & 0xFF;
-            out[outIdx++] = c2 & 0xFF;
-        }
-    }
-    return out;
-}
-function golayDecode(encoded) {
-    if (encoded.length % 6 !== 0) {
-        throw new Error("Invalid Golay encoded data: length must be multiple of 6");
-    }
-    const outLen = Math.floor(encoded.length / 2);
-    const out = new Uint8Array(outLen);
-    let outIdx = 0;
-    let totalCorrected = 0;
-    let anyUncorrectable = false;
-    for (let i = 0; i < encoded.length; i += 6) {
-        const c1 = (encoded[i] << 16) | (encoded[i + 1] << 8) | encoded[i + 2];
-        const res1 = decodeWord(c1);
-        totalCorrected += res1.corrected;
-        if (res1.uncorrectable)
-            anyUncorrectable = true;
-        if (outIdx < outLen)
-            out[outIdx++] = (res1.msg >> 4) & 0xFF;
-        const b2_high = (res1.msg & 0x0F) << 4;
-        if (i + 3 < encoded.length) {
-            const c2 = (encoded[i + 3] << 16) | (encoded[i + 4] << 8) | encoded[i + 5];
-            const res2 = decodeWord(c2);
-            totalCorrected += res2.corrected;
-            if (res2.uncorrectable)
-                anyUncorrectable = true;
-            if (outIdx < outLen)
-                out[outIdx++] = b2_high | (res2.msg >> 8);
-            if (outIdx < outLen)
-                out[outIdx++] = res2.msg & 0xFF;
-        }
-        else {
-            if (outIdx < outLen)
-                out[outIdx++] = b2_high;
-        }
-    }
-    return { data: out, corrected: totalCorrected, uncorrectable: anyUncorrectable };
-}

package/dist/grg_forward.d.ts

@@ -1,7 +0,0 @@
-export declare class GrgForward {
-    static golombEncode(data: Uint8Array, m?: number): Uint8Array;
-    static redstuffEncode(data: Uint8Array, shards?: number, parity?: number): Uint8Array[];
-    static deriveHmacKey(chainId: number, poolAddress: string): Buffer;
-    static golayEncodeWrapper(data: Uint8Array, hmacKey: Buffer): Uint8Array;
-    static encode(data: Uint8Array, chainId: number, poolAddress: string): Uint8Array[];
-}

package/dist/grg_forward.js

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GrgForward = void 0;
-// sdk/src/grg_forward.ts
-const crypto_1 = require("crypto");
-const ethers_1 = require("ethers");
-const golay_1 = require("./golay");
-const reed_solomon_1 = require("./reed_solomon");
-class GrgForward {
-    static golombEncode(data, m = 16) {
-        if (m < 2)
-            throw new Error("[GRG] Golomb parameter m must be >= 2");
-        const k = Math.log2(m);
-        if (!Number.isInteger(k))
-            throw new Error("M must be power of 2");
-        const bits = [];
-        for (const byte of data) {
-            const q = Math.floor(byte / m);
-            const r = byte % m;
-            for (let i = 0; i < q; i++)
-                bits.push(1);
-            bits.push(0);
-            for (let i = k - 1; i >= 0; i--)
-                bits.push((r >> i) & 1);
-        }
-        const out = new Uint8Array(Math.ceil(bits.length / 8));
-        for (let i = 0; i < bits.length; i++) {
-            if (bits[i])
-                out[i >> 3] |= (0x80 >> (i & 7));
-        }
-        return out;
-    }
-    static redstuffEncode(data, shards = 4, parity = 2) {
-        return reed_solomon_1.ReedSolomon.encode(data, shards, parity);
-    }
-    static deriveHmacKey(chainId, poolAddress) {
-        if (chainId === undefined || chainId === null || !poolAddress) {
-            throw new Error("[GRG] chainId and poolAddress are required for HMAC key derivation. No default key is allowed.");
-        }
-        const packed = (0, ethers_1.keccak256)(ethers_1.AbiCoder.defaultAbiCoder().encode(["uint256", "address"], [chainId, poolAddress]));
-        return Buffer.from(packed.slice(2), "hex");
-    }
-    static golayEncodeWrapper(data, hmacKey) {
-        const encoded = (0, golay_1.golayEncode)(data);
-        const mac = (0, crypto_1.createHmac)("sha256", hmacKey).update(Buffer.from(encoded)).digest();
-        const checksum = mac.subarray(0, 8);
-        const final = new Uint8Array(encoded.length + 8);
-        final.set(encoded);
-        final.set(checksum, encoded.length);
-        return final;
-    }
-    static encode(data, chainId, poolAddress) {
-        if (data.length === 0) {
-            throw new Error("[GRG] Cannot encode empty input — roundtrip identity violation");
-        }
-        const compressed = this.golombEncode(data);
-        const withLen = new Uint8Array(4 + compressed.length);
-        withLen[0] = (data.length >> 24) & 0xFF;
-        withLen[1] = (data.length >> 16) & 0xFF;
-        withLen[2] = (data.length >> 8) & 0xFF;
-        withLen[3] = data.length & 0xFF;
-        withLen.set(compressed, 4);
-        const shards = this.redstuffEncode(withLen);
-        const hmacKey = this.deriveHmacKey(chainId, poolAddress);
-        return shards.map(s => this.golayEncodeWrapper(s, hmacKey));
-    }
-}
-exports.GrgForward = GrgForward;

package/dist/grg_inverse.d.ts

@@ -1,7 +0,0 @@
-export declare class GrgInverse {
-    private static readonly MAX_GOLOMB_Q;
-    static golayDecodeWrapper(data: Uint8Array, hmacKey: Buffer): Uint8Array;
-    static redstuffDecode(shards: (Uint8Array | null)[], dataShardCount?: number, parityShardCount?: number): Uint8Array;
-    static golombDecode(data: Uint8Array, m?: number, originalLength?: number): Uint8Array;
-    static verify(data: Uint8Array, originalShards: Uint8Array[], chainId: number, poolAddress: string): boolean;
-}

package/dist/grg_inverse.js

@@ -1,93 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GrgInverse = void 0;
-// sdk/src/grg_inverse.ts
-const crypto_1 = require("crypto");
-const golay_1 = require("./golay");
-const grg_forward_1 = require("./grg_forward");
-const logger_1 = require("./logger");
-const reed_solomon_1 = require("./reed_solomon");
-class GrgInverse {
-    static MAX_GOLOMB_Q = 1000000;
-    static golayDecodeWrapper(data, hmacKey) {
-        if (data.length < 8)
-            throw new Error("GRG shard too short for checksum");
-        const encoded = data.subarray(0, data.length - 8);
-        const checksum = data.subarray(data.length - 8);
-        const mac = (0, crypto_1.createHmac)("sha256", hmacKey).update(Buffer.from(encoded)).digest();
-        const expected = mac.subarray(0, 8);
-        if (!Buffer.from(checksum).equals(Buffer.from(expected))) {
-            throw new Error("GRG tamper detected: HMAC-SHA256 checksum mismatch");
-        }
-        const res = (0, golay_1.golayDecode)(encoded);
-        if (res.uncorrectable) {
-            throw new Error("GRG tamper detected: uncorrectable bit errors in Golay codeword");
-        }
-        return res.data;
-    }
-    static redstuffDecode(shards, dataShardCount = 4, parityShardCount = 2) {
-        return reed_solomon_1.ReedSolomon.decode(shards, dataShardCount, parityShardCount);
-    }
-    static golombDecode(data, m = 16, originalLength) {
-        if (m < 2)
-            throw new Error("[GRG] Golomb parameter m must be >= 2");
-        const k = Math.log2(m);
-        const totalBits = data.length * 8;
-        const readBit = (pos) => (data[pos >> 3] >> (7 - (pos & 7))) & 1;
-        const result = [];
-        let i = 0;
-        while (i < totalBits) {
-            if (originalLength !== undefined && result.length >= originalLength)
-                break;
-            let q = 0;
-            while (i < totalBits && readBit(i) === 1) {
-                q++;
-                i++;
-                if (q > this.MAX_GOLOMB_Q)
-                    throw new Error(`[GRG] Golomb decode: unary run exceeds ${this.MAX_GOLOMB_Q} — malformed or malicious input`);
-            }
-            if (i < totalBits && readBit(i) === 0)
-                i++;
-            if (i + k > totalBits)
-                break;
-            let r = 0;
-            for (let j = 0; j < k; j++)
-                r = (r << 1) | readBit(i + j);
-            result.push(q * m + r);
-            i += k;
-        }
-        return new Uint8Array(result);
-    }
-    static verify(data, originalShards, chainId, poolAddress) {
-        try {
-            const hmacKey = grg_forward_1.GrgForward.deriveHmacKey(chainId, poolAddress);
-            const decodedShards = originalShards.map(s => {
-                try {
-                    return this.golayDecodeWrapper(s, hmacKey);
-                }
-                catch {
-                    return null;
-                }
-            });
-            const withLen = this.redstuffDecode(decodedShards);
-            if (withLen.length < 4)
-                return false;
-            const origLen = (withLen[0] << 24) | (withLen[1] << 16) | (withLen[2] << 8) | withLen[3];
-            const compressed = withLen.subarray(4);
-            const decoded = this.golombDecode(compressed);
-            const final = decoded.subarray(0, origLen);
-            if (final.length !== data.length)
-                return false;
-            for (let i = 0; i < data.length; i++) {
-                if (final[i] !== data[i])
-                    return false;
-            }
-            return true;
-        }
-        catch (e) {
-            logger_1.logger.warn(`[GRG Inverse] Verification failed: ${e}`);
-            return false;
-        }
-    }
-}
-exports.GrgInverse = GrgInverse;

package/dist/grg_pipeline.d.ts

@@ -1,5 +0,0 @@
-export declare class GrgPipeline {
-    static readonly MAX_INPUT_SIZE: number;
-    static processForward(data: Uint8Array, chainId: number, poolAddress: string): Uint8Array[];
-    static processInverse(shards: (Uint8Array | null)[], originalLength: number, chainId: number, poolAddress: string): Uint8Array;
-}

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;