openttt 0.2.11 → 0.2.13

package/dist/protocol_fee.js

@@ -1,199 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProtocolFeeCollector = exports.InMemoryReplayCache = void 0;
-const ethers_1 = require("ethers");
-const logger_1 = require("./logger");
-/**
- * Default in-memory replay cache with bounded size and TTL eviction.
- * Suitable for single-process deployments; use a distributed ReplayCache
- * implementation (e.g., Redis) for multi-node setups.
- */
-class InMemoryReplayCache {
-    entries = new Map();
-    maxEntries;
-    defaultTtlMs;
-    lastPruneTime = 0;
-    static PRUNE_INTERVAL_MS = 60000;
-    constructor(maxEntries = 10000, defaultTtlMs = 3600000) {
-        this.maxEntries = maxEntries;
-        this.defaultTtlMs = defaultTtlMs;
-    }
-    async has(key) {
-        this.pruneIfNeeded();
-        const ts = this.entries.get(key);
-        if (ts === undefined)
-            return false;
-        if (Date.now() - ts > this.defaultTtlMs) {
-            this.entries.delete(key);
-            return false;
-        }
-        return true;
-    }
-    async set(key, ttlMs) {
-        this.pruneIfNeeded();
-        this.entries.set(key, Date.now());
-    }
-    pruneIfNeeded() {
-        const now = Date.now();
-        if (now - this.lastPruneTime < InMemoryReplayCache.PRUNE_INTERVAL_MS &&
-            this.entries.size <= this.maxEntries) {
-            return;
-        }
-        this.lastPruneTime = now;
-        for (const [sig, ts] of this.entries) {
-            if (now - ts > this.defaultTtlMs) {
-                this.entries.delete(sig);
-            }
-        }
-        // If still over limit, remove oldest entries
-        if (this.entries.size > this.maxEntries) {
-            const sorted = [...this.entries.entries()].sort((a, b) => a[1] - b[1]);
-            const toRemove = sorted.slice(0, sorted.length - this.maxEntries);
-            for (const [sig] of toRemove) {
-                this.entries.delete(sig);
-            }
-        }
-    }
-}
-exports.InMemoryReplayCache = InMemoryReplayCache;
-/**
- * ProtocolFeeCollector - Handles Helm protocol fee collection and verification.
- * Includes EIP-712 signature verification for x402 compliance.
- */
-class ProtocolFeeCollector {
-    totalCollected = 0n;
-    chainId;
-    verifyingContract;
-    replayCache;
-    evmConnector;
-    protocolFeeRecipient;
-    feeContract = null;
-    constructor(chainId, verifyingContract, evmConnector, protocolFeeRecipient, replayCache) {
-        // R3-P0-2: Validate chainId is a positive integer to prevent cross-chain replay
-        if (!Number.isInteger(chainId) || chainId <= 0) {
-            throw new Error(`[ProtocolFee] Invalid chainId: ${chainId}. Must be a positive integer.`);
-        }
-        this.chainId = chainId;
-        this.verifyingContract = ethers_1.ethers.getAddress(verifyingContract);
-        this.evmConnector = evmConnector;
-        this.protocolFeeRecipient = ethers_1.ethers.getAddress(protocolFeeRecipient);
-        this.replayCache = replayCache ?? new InMemoryReplayCache();
-    }
-    /**
-     * R3-P0-2: Verify chainId matches the actual connected network.
-     * Must be called after EVMConnector.connect() to prevent cross-chain signature replay.
-     */
-    async validateChainId() {
-        const provider = this.evmConnector.getProvider();
-        const network = await provider.getNetwork();
-        if (Number(network.chainId) !== this.chainId) {
-            throw new Error(`[ProtocolFee] Chain ID mismatch: configured ${this.chainId}, network reports ${network.chainId}. Cross-chain replay risk!`);
-        }
-    }
-    getFeeContract() {
-        if (this.feeContract)
-            return this.feeContract;
-        const abi = [
-            "function collectFee(address token, uint256 amount, bytes calldata signature, uint256 nonce, uint256 deadline) external"
-        ];
-        // ProtocolFeeCollector uses verifyingContract as the ProtocolFee.sol address
-        this.feeContract = new ethers_1.ethers.Contract(this.verifyingContract, abi, this.evmConnector.getSigner());
-        return this.feeContract;
-    }
-    /**
-     * Collect minting fee (Stablecoin).
-     * @param feeCalc - Fee calculation result from DynamicFeeEngine.
-     * @param signature - EIP-712 signature (required, for x402 verification).
-     * @param user - Signer address.
-     * @param nonce - Anti-replay nonce.
-     * @param deadline - Signature expiration timestamp.
-     */
-    async collectMintFee(feeCalc, signature, user, nonce, deadline) {
-        try {
-            await this.verifySignature(feeCalc, signature, user, nonce, deadline);
-            // Actual on-chain collection
-            const contract = this.getFeeContract();
-            const tx = await contract.collectFee(ethers_1.ethers.getAddress(feeCalc.feeTokenAddress), feeCalc.protocolFeeUsd, signature, nonce, deadline);
-            await tx.wait();
-            this.totalCollected += feeCalc.protocolFeeUsd;
-            logger_1.logger.info(`[ProtocolFee] Mint fee collected on-chain: ${feeCalc.protocolFeeUsd} ${feeCalc.feeToken}. TX: ${tx.hash}`);
-        }
-        catch (error) {
-            throw new Error(`[ProtocolFee] Mint fee collection failed: ${(error instanceof Error ? error.message : String(error))}`);
-        }
-    }
-    /**
-     * Collect burn fee.
-     * @param feeCalc - Fee calculation result from DynamicFeeEngine.
-     * @param signature - EIP-712 signature (required).
-     * @param user - Signer address.
-     * @param nonce - Anti-replay nonce.
-     * @param deadline - Signature expiration timestamp.
-     */
-    async collectBurnFee(feeCalc, signature, user, nonce, deadline) {
-        try {
-            await this.verifySignature(feeCalc, signature, user, nonce, deadline);
-            // Actual on-chain collection
-            const contract = this.getFeeContract();
-            const tx = await contract.collectFee(ethers_1.ethers.getAddress(feeCalc.feeTokenAddress), feeCalc.protocolFeeUsd, signature, nonce, deadline);
-            await tx.wait();
-            this.totalCollected += feeCalc.protocolFeeUsd;
-            logger_1.logger.info(`[ProtocolFee] Burn fee collected on-chain: ${feeCalc.protocolFeeUsd} ${feeCalc.feeToken}. TX: ${tx.hash}`);
-        }
-        catch (error) {
-            throw new Error(`[ProtocolFee] Burn fee collection failed: ${(error instanceof Error ? error.message : String(error))}`);
-        }
-    }
-    /**
-     * Return total fees collected so far.
-     */
-    async getCollectedFees() {
-        return this.totalCollected;
-    }
-    /**
-     * EIP-712 signature verification (x402 compliance).
-     */
-    async verifySignature(feeCalc, signature, user, nonce, deadline) {
-        // B1-2 + P1-2: Replay protection via pluggable cache
-        if (await this.replayCache.has(signature)) {
-            throw new Error("Signature already used (replay protection)");
-        }
-        // B1-2: Deadline check
-        const now = Math.floor(Date.now() / 1000);
-        if (deadline < now) {
-            throw new Error("Signature deadline expired");
-        }
-        const normalizedUser = ethers_1.ethers.getAddress(user);
-        const domain = {
-            name: "OpenTTT_ProtocolFee",
-            version: "1",
-            chainId: this.chainId,
-            verifyingContract: this.verifyingContract
-        };
-        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
-        };
-        try {
-            const recoveredAddress = ethers_1.ethers.verifyTypedData(domain, types, value, signature);
-            if (ethers_1.ethers.getAddress(recoveredAddress) !== normalizedUser) {
-                throw new Error("Invalid EIP-712 signature: signer mismatch");
-            }
-            await this.replayCache.set(signature, 3600000); // Mark as used with 1h TTL
-        }
-        catch (error) {
-            throw new Error(`[ProtocolFee] Signature verification failed: ${(error instanceof Error ? error.message : String(error))}`);
-        }
-    }
-}
-exports.ProtocolFeeCollector = ProtocolFeeCollector;

package/dist/revenue_tiers.d.ts

@@ -1,36 +0,0 @@
-/**
- * Revenue Tier Configuration
- * Reflects the TTT Labs pricing strategy: Free/Sponsor-backed T0 up to Institutional T3.
- */
-export declare enum RevenueTier {
-    T0_EPOCH = "T0_EPOCH",
-    T1_BLOCK = "T1_BLOCK",
-    T2_SLOT = "T2_SLOT",
-    T3_MICRO = "T3_MICRO"
-}
-export interface TierConfig {
-    tier: RevenueTier;
-    name: string;
-    interval: string;
-    pricePerTick: number;
-    currency: string;
-    model: string;
-    target: string;
-    sponsorEligible: boolean;
-}
-export interface SponsorConfig {
-    sponsor: string;
-    tier: RevenueTier;
-    monthlyBudgetUsd: number;
-    startDate: string;
-    endDate: string;
-}
-export declare const REVENUE_TIERS: Record<RevenueTier, TierConfig>;
-/**
- * Calculate projected monthly cost based on tier and throughput.
- */
-export declare function calculateMonthlyCost(tier: RevenueTier, ticksPerDay: number): number;
-/**
- * Determine the appropriate tier based on a usage description.
- */
-export declare function getTierForUseCase(useCase: string): RevenueTier;

package/dist/revenue_tiers.js

@@ -1,83 +0,0 @@
-"use strict";
-/**
- * Revenue Tier Configuration
- * Reflects the TTT Labs pricing strategy: Free/Sponsor-backed T0 up to Institutional T3.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.REVENUE_TIERS = exports.RevenueTier = void 0;
-exports.calculateMonthlyCost = calculateMonthlyCost;
-exports.getTierForUseCase = getTierForUseCase;
-var RevenueTier;
-(function (RevenueTier) {
-    RevenueTier["T0_EPOCH"] = "T0_EPOCH";
-    RevenueTier["T1_BLOCK"] = "T1_BLOCK";
-    RevenueTier["T2_SLOT"] = "T2_SLOT";
-    RevenueTier["T3_MICRO"] = "T3_MICRO";
-})(RevenueTier || (exports.RevenueTier = RevenueTier = {}));
-exports.REVENUE_TIERS = {
-    [RevenueTier.T0_EPOCH]: {
-        tier: RevenueTier.T0_EPOCH,
-        name: "Standard Epoch",
-        interval: "6.4 min",
-        pricePerTick: 0,
-        currency: "USDC",
-        model: "sponsor", // Let's Encrypt model: free to user, sponsor-backed
-        target: "Standard L1 Swaps / LP Integration",
-        sponsorEligible: true
-    },
-    [RevenueTier.T1_BLOCK]: {
-        tier: RevenueTier.T1_BLOCK,
-        name: "Fast Block",
-        interval: "2 sec",
-        pricePerTick: 0.01,
-        currency: "USDC",
-        model: "sdk_license",
-        target: "L2 Sequencer / Standard DeFi",
-        sponsorEligible: false
-    },
-    [RevenueTier.T2_SLOT]: {
-        tier: RevenueTier.T2_SLOT,
-        name: "High-Frequency Slot",
-        interval: "12 sec",
-        pricePerTick: 0.05,
-        currency: "USDC",
-        model: "sdk_license",
-        target: "Active Traders / Arbitrage",
-        sponsorEligible: false
-    },
-    [RevenueTier.T3_MICRO]: {
-        tier: RevenueTier.T3_MICRO,
-        name: "Institutional Micro-Tick",
-        interval: "100 ms",
-        pricePerTick: 0.10,
-        currency: "USDC",
-        model: "enterprise",
-        target: "Institutional / HFT Pipelines",
-        sponsorEligible: false
-    }
-};
-/**
- * Calculate projected monthly cost based on tier and throughput.
- */
-function calculateMonthlyCost(tier, ticksPerDay) {
-    const config = exports.REVENUE_TIERS[tier];
-    if (config.pricePerTick === 0)
-        return 0;
-    return config.pricePerTick * ticksPerDay * 30;
-}
-/**
- * Determine the appropriate tier based on a usage description.
- */
-function getTierForUseCase(useCase) {
-    const lowerCase = useCase.toLowerCase();
-    if (lowerCase.includes("institutional") || lowerCase.includes("hft") || lowerCase.includes("micro")) {
-        return RevenueTier.T3_MICRO;
-    }
-    if (lowerCase.includes("arbitrage") || lowerCase.includes("trader") || lowerCase.includes("slot")) {
-        return RevenueTier.T2_SLOT;
-    }
-    if (lowerCase.includes("l2") || lowerCase.includes("block") || lowerCase.includes("sequencer")) {
-        return RevenueTier.T1_BLOCK;
-    }
-    return RevenueTier.T0_EPOCH;
-}

package/dist/x402_enforcer.d.ts

@@ -1,44 +0,0 @@
-import { AdaptiveMode } from "./adaptive_switch";
-import { EVMConnector } from "./evm_connector";
-import { ProtocolFeeCollector } from "./protocol_fee";
-import { DynamicFeeEngine, FeeCalculation } from "./dynamic_fee";
-export interface SwapDetails {
-    user: string;
-    tokenIn: string;
-    tokenOut: string;
-    amount: bigint;
-}
-export declare class X402Enforcer {
-    private static getCost;
-    /**
-     * Deducts TTT ticks from the provided balance and determines Adaptive Mode.
-     *
-     * **Important:** By default, the `balance` parameter is an SDK-local value
-     * (tracked in-memory by the caller). It is NOT verified against the on-chain
-     * TTT token balance. This is sufficient for hot-path tick accounting where
-     * on-chain settlement happens separately via `deductOnChain()`.
-     *
-     * @param feeEngine - Dynamic fee engine for cost calculation
-     * @param swap - Swap details (user, tokens, amount)
-     * @param balance - SDK-local TTT balance (not on-chain unless verifyOnChain=true)
-     * @param tier - Stratum tier (0-3)
-     * @param mode - Current adaptive mode (Turbo/Full)
-     * @param verifyOnChain - If true, checks on-chain TTT balance via EVMConnector
-     *   before deducting. Requires `connector` and `tokenId`. Default: false.
-     * @param connector - EVMConnector instance (required when verifyOnChain=true)
-     * @param tokenId - Token ID for on-chain balance lookup (required when verifyOnChain=true)
-     */
-    static deductTick(feeEngine: DynamicFeeEngine, swap: SwapDetails, balance: bigint, tier: number, mode: AdaptiveMode, verifyOnChain?: boolean, connector?: EVMConnector, tokenId?: bigint): Promise<{
-        success: boolean;
-        remaining: bigint;
-        mode: AdaptiveMode;
-    }>;
-    /**
-     * Executes on-chain TTT burn via EVMConnector.
-     */
-    static deductOnChain(connector: EVMConnector, feeEngine: DynamicFeeEngine, swap: SwapDetails, grgHash: string, tier: number, feeCollector?: ProtocolFeeCollector, burnFeeCalc?: FeeCalculation, signature?: string, nonce?: bigint, deadline?: number): Promise<string>;
-    /**
-     * Static validation rule.
-     */
-    static enforcePool(feeEngine: DynamicFeeEngine, swap: SwapDetails, tttBalance: bigint, tier: number): Promise<boolean>;
-}

package/dist/x402_enforcer.js

@@ -1,92 +0,0 @@
-"use strict";
-// sdk/src/x402_enforcer.ts — x402 Micropayment Enforcer (Expanded)
-// Governs TTT tick consumption and on-chain settlement.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.X402Enforcer = void 0;
-const logger_1 = require("./logger");
-const TIER_MAP = {
-    0: "T0_epoch",
-    1: "T1_block",
-    2: "T2_slot",
-    3: "T3_micro"
-};
-class X402Enforcer {
-    static async getCost(feeEngine, tier) {
-        const tierKey = TIER_MAP[tier] || "T0_epoch";
-        const feeCalc = await feeEngine.calculateMintFee(tierKey);
-        return feeCalc.tttAmount;
-    }
-    /**
-     * Deducts TTT ticks from the provided balance and determines Adaptive Mode.
-     *
-     * **Important:** By default, the `balance` parameter is an SDK-local value
-     * (tracked in-memory by the caller). It is NOT verified against the on-chain
-     * TTT token balance. This is sufficient for hot-path tick accounting where
-     * on-chain settlement happens separately via `deductOnChain()`.
-     *
-     * @param feeEngine - Dynamic fee engine for cost calculation
-     * @param swap - Swap details (user, tokens, amount)
-     * @param balance - SDK-local TTT balance (not on-chain unless verifyOnChain=true)
-     * @param tier - Stratum tier (0-3)
-     * @param mode - Current adaptive mode (Turbo/Full)
-     * @param verifyOnChain - If true, checks on-chain TTT balance via EVMConnector
-     *   before deducting. Requires `connector` and `tokenId`. Default: false.
-     * @param connector - EVMConnector instance (required when verifyOnChain=true)
-     * @param tokenId - Token ID for on-chain balance lookup (required when verifyOnChain=true)
-     */
-    static async deductTick(feeEngine, swap, balance, tier, mode, verifyOnChain = false, connector, tokenId) {
-        const cost = await this.getCost(feeEngine, tier);
-        // Optional on-chain balance verification before deducting
-        if (verifyOnChain) {
-            if (!connector || tokenId === undefined) {
-                throw new Error("[x402] verifyOnChain requires both connector and tokenId parameters");
-            }
-            const onChainBalance = await connector.getTTTBalance(swap.user, tokenId);
-            if (onChainBalance < cost) {
-                throw new Error(`[x402] On-chain balance insufficient for user ${swap.user}. Required: ${cost}, On-chain: ${onChainBalance}.`);
-            }
-        }
-        if (balance < cost) {
-            throw new Error(`[x402] Insufficient TTT ticks for user ${swap.user}. Required: ${cost}, Have: ${balance}.`);
-        }
-        const newBalance = balance - cost;
-        logger_1.logger.info(`[x402] Deducted ${cost} ticks for swap. User: ${swap.user}, New Balance: ${newBalance}`);
-        return {
-            success: true,
-            remaining: newBalance,
-            mode
-        };
-    }
-    /**
-     * Executes on-chain TTT burn via EVMConnector.
-     */
-    static async deductOnChain(connector, feeEngine, swap, grgHash, tier, feeCollector, burnFeeCalc, signature, nonce, deadline) {
-        logger_1.logger.info(`[x402] Enforcing on-chain settlement for user ${swap.user}...`);
-        const cost = await this.getCost(feeEngine, tier);
-        try {
-            const receipt = await connector.burnTTT(cost, grgHash, tier);
-            // Collect protocol burn fee if feeCollector and required params are provided
-            if (feeCollector && burnFeeCalc && signature && nonce !== undefined && deadline !== undefined) {
-                try {
-                    await feeCollector.collectBurnFee(burnFeeCalc, signature, swap.user, nonce, deadline);
-                }
-                catch (feeError) {
-                    logger_1.logger.error(`[x402] Burn fee collection failed but burn was successful: ${feeError instanceof Error ? feeError.message : feeError}`);
-                }
-            }
-            return receipt.hash;
-        }
-        catch (error) {
-            logger_1.logger.error(`[x402] On-chain enforcement failed: ${error instanceof Error ? error.message : error}`);
-            throw error;
-        }
-    }
-    /**
-     * Static validation rule.
-     */
-    static async enforcePool(feeEngine, swap, tttBalance, tier) {
-        const cost = await this.getCost(feeEngine, tier);
-        return tttBalance >= cost;
-    }
-}
-exports.X402Enforcer = X402Enforcer;