openttt 0.2.11 → 0.2.13

package/dist/tls_binding.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * tls_binding.ts — RFC 5705 TLS Exporter binding for TTTPS
+ *
+ * Implements Section 7.1 of draft-helmprotocol-tttps-02:
+ *   binding_key = TLS-Exporter("EXPORTER-tttps-pot-binding",
+ *                               pot_record_without_sig, 32)
+ *
+ * Both client and server derive the same 32-byte key from the
+ * shared TLS session master secret. A PoT frame generated in
+ * session A cannot be replayed into session B.
+ *
+ * Node.js API: tls.TLSSocket.exportKeyingMaterial()
+ * Available since Node.js 13.x (LTS 14+)
+ * RFC 5705 compliant.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TLSBindingError = exports.TTTPS_BINDING_KEY_LENGTH = exports.TTTPS_EXPORTER_LABEL = void 0;
+exports.computeBindingKey = computeBindingKey;
+exports.verifyBindingKey = verifyBindingKey;
+/** Label defined in draft-helmprotocol-tttps-02 Section 7.1 */
+exports.TTTPS_EXPORTER_LABEL = "EXPORTER-tttps-pot-binding";
+exports.TTTPS_BINDING_KEY_LENGTH = 32; // octets per RFC 5705
+class TLSBindingError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TLSBindingError";
+    }
+}
+exports.TLSBindingError = TLSBindingError;
+/**
+ * Derive the 32-byte binding key from a TLS session and a PoT record.
+ *
+ * @param socket          - Active TLS socket (must be in CONNECTED state)
+ * @param potWithoutSig   - PoT record bytes WITHOUT the Ed25519 signature
+ *                          (first 79 bytes of the 143-byte record:
+ *                           Version[1] + Tier[1] + Reserved[1] +
+ *                           Timestamp[8] + Confidence[4] +
+ *                           Nonce[32] + GRGCommit[32])
+ * @returns 32-byte binding key
+ */
+function computeBindingKey(socket, potWithoutSig) {
+    if (!socket.encrypted) {
+        throw new TLSBindingError("Socket is not a TLS socket");
+    }
+    // exportKeyingMaterial(length, label, context, useContextFlag?)
+    // context = pot_record_without_sig per RFC 5705 Section 4
+    const bindingKey = socket.exportKeyingMaterial(exports.TTTPS_BINDING_KEY_LENGTH, exports.TTTPS_EXPORTER_LABEL, potWithoutSig // context bound to this specific PoT record
+    );
+    const sessionId = socket.getSession?.()?.toString("hex").slice(0, 16) ?? "unknown";
+    return {
+        bindingKey: Buffer.from(bindingKey),
+        sessionId,
+    };
+}
+/**
+ * Verify that a received binding_key matches the expected value
+ * for this TLS session and PoT record.
+ *
+ * This is the normative check from draft-helmprotocol-tttps-02 Section 7.1:
+ *   "The verifier MUST recompute expected_key via TLS-Exporter
+ *    and verify it matches the binding_key in the PoT frame header."
+ *
+ * @param socket            - Active TLS socket (same session as sender)
+ * @param potWithoutSig     - PoT record bytes WITHOUT signature (79 bytes)
+ * @param receivedBindingKey - 32-byte binding_key from the received PoT frame
+ * @returns true if binding is valid, false if cross-session replay detected
+ */
+function verifyBindingKey(socket, potWithoutSig, receivedBindingKey) {
+    if (receivedBindingKey.length !== exports.TTTPS_BINDING_KEY_LENGTH) {
+        return false;
+    }
+    const { bindingKey: expected } = computeBindingKey(socket, potWithoutSig);
+    // Constant-time comparison (prevents timing attacks)
+    return timingSafeEqual(expected, receivedBindingKey);
+}
+/**
+ * Constant-time Buffer comparison.
+ * Node.js crypto.timingSafeEqual requires equal-length buffers.
+ */
+function timingSafeEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    const { timingSafeEqual } = require("crypto");
+    return timingSafeEqual(a, b);
+}

package/dist/v4_hook.d.ts

@@ -1,7 +1,12 @@
 import { EVMConnector } from "./evm_connector";
-import { ProtocolFeeCollector } from "./protocol_fee";
-import { FeeCalculation } from "./dynamic_fee";
 import { BeforeSwapParams, AfterSwapParams } from "./types";
+export interface FeeCalculation {
+    feeAmount: bigint;
+    tier: string;
+}
+export interface ProtocolFeeCollector {
+    collectBurnFee(fee: FeeCalculation, signature: string, sender: string, nonce: bigint, deadline: number): Promise<void>;
+}
 /**
  * UniswapV4Hook - TTT-based Uniswap V4 Hook Simulation (SDK-side)
  *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "openttt",
-  "version": "0.2.11",
-  "description": "OpenTTT \u2014 TLS-grade transaction ordering for DeFi. Time + Logic + Sync.",
+  "version": "0.2.13",
+  "description": "OpenTTT — TLS-grade transaction ordering for DeFi. Time + Logic + Sync.",
   "license": "BSL-1.1",
   "repository": {
     "type": "git",
@@ -29,10 +29,10 @@
     }
   },
   "files": [
+    "dist/adaptive_switch.js",
+    "dist/adaptive_switch.d.ts",
     "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",
@@ -51,24 +51,24 @@
     "dist/osnma_source.d.ts",
     "dist/pool_registry.js",
     "dist/pool_registry.d.ts",
+    "dist/pot_frame.js",
+    "dist/pot_frame.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/pot_verifier.js",
+    "dist/pot_verifier.d.ts",
     "dist/signer.js",
     "dist/signer.d.ts",
     "dist/time_synthesis.js",
     "dist/time_synthesis.d.ts",
+    "dist/tls_binding.js",
+    "dist/tls_binding.d.ts",
     "dist/trust_store.js",
     "dist/trust_store.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": {
@@ -104,5 +104,11 @@
     "ts-jest": "^29.1.2",
     "typescript": "^5.3.3"
   },
-  "mcpName": "io.github.Helm-Protocol/openttt-pot"
+  "mcpName": "io.github.Helm-Protocol/openttt-pot",
+  "overrides": {
+    "defu": ">=6.1.4",
+    "picomatch": ">=4.0.2",
+    "handlebars": ">=4.7.9",
+    "ws": ">=8.21.0"
+  }
 }

package/dist/dynamic_fee.d.ts

@@ -1,75 +0,0 @@
-export declare const TIER_USD_MICRO: Record<string, bigint>;
-export declare const FEE_TIERS: {
-    BOOTSTRAP: {
-        mintFee: bigint;
-        burnFee: bigint;
-        threshold: bigint;
-    };
-    GROWTH: {
-        mintFee: bigint;
-        burnFee: bigint;
-        threshold: bigint;
-    };
-    MATURE: {
-        mintFee: bigint;
-        burnFee: bigint;
-        threshold: bigint;
-    };
-    PREMIUM: {
-        mintFee: bigint;
-        burnFee: bigint;
-        threshold: bigint;
-    };
-};
-export interface FeeCalculation {
-    tttAmount: bigint;
-    protocolFeeUsd: bigint;
-    feeToken: string;
-    feeTokenAddress: string;
-    clientNet: bigint;
-    tttPriceUsd: bigint;
-    usdCost: bigint;
-    feeRateMint: bigint;
-    feeRateBurn: bigint;
-    tier: string;
-}
-export interface PriceOracleConfig {
-    poolAddress?: string;
-    chainlinkFeed?: string;
-    cacheDurationMs: number;
-    fallbackPriceUsd: bigint;
-}
-export declare class DynamicFeeEngine {
-    private priceCache;
-    private provider;
-    private rpcUrls;
-    private config;
-    private warnedSpotPrice;
-    private static readonly RECOMMENDED_MAX_CACHE_MS;
-    constructor(config: PriceOracleConfig);
-    /**
-     * Connect to an RPC provider. Accepts a single URL or an array of URLs
-     * for multi-RPC fallback. On connection failure, the next URL is tried.
-     */
-    connect(rpcUrl: string | string[]): Promise<void>;
-    /**
-     * Iterate through stored RPC URLs and connect to the first one that succeeds.
-     * Throws if all URLs fail.
-     */
-    private connectToNext;
-    getTTTPriceUsd(): Promise<bigint>;
-    /**
-     * Force-invalidate price cache -- call when immediate price refresh is needed.
-     */
-    invalidateCache(): void;
-    private fetchUniswapPrice;
-    private fetchChainlinkPrice;
-    getFeeRate(tttPriceUsd: bigint): {
-        mintFee: bigint;
-        burnFee: bigint;
-        phase: string;
-    };
-    calculateMintFee(tier: string, tickCount?: number, feeToken?: string, feeTokenAddress?: string): Promise<FeeCalculation>;
-    calculateBurnFee(tier: string, tickCount?: number, feeToken?: string, feeTokenAddress?: string): Promise<FeeCalculation>;
-    calculateEmergencyMintFee(tier: string, tickCount?: number): Promise<FeeCalculation>;
-}

package/dist/dynamic_fee.js

@@ -1,254 +0,0 @@
-"use strict";
-// sdk/src/dynamic_fee.ts — Dynamic Fee Engine
-// Automatically adjusts tick cost based on TTT market price
-// DEX operators only set tier; the SDK handles the rest automatically
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DynamicFeeEngine = exports.FEE_TIERS = exports.TIER_USD_MICRO = void 0;
-const ethers_1 = require("ethers");
-const logger_1 = require("./logger");
-// Target USD cost per tier (Scale: 1e6)
-//
-// PRICING (2026-03-14 감사 수정):
-//   T2/T3 가격 하향 — 감사 결과 "트랜잭션당 1틱 소비" 구조에서
-//   매 틱 판매 가정은 비현실적. 볼륨 기반 수익 구조로 전환.
-//   T2: $0.24 → $0.05 (4.8x 하향)
-//   T3: $12.00 → $0.10 (120x 하향)
-//
-// YP discrepancies (code is authoritative in all cases):
-//   YP5: TURBO entry threshold — YP says 90%, code uses 95% (more conservative).
-//   YP6: BOOTSTRAP mintFee — YP says 3%, code uses 5% (500 basis points).
-//   YP7: PoT min confidence — YP says 0.7, code uses 0.5 (auto_mint.ts).
-exports.TIER_USD_MICRO = {
-    T0_epoch: 1000n, // $0.001 * 1e6
-    T1_block: 10000n, // $0.01 * 1e6
-    T2_slot: 50000n, // $0.05 * 1e6 — 감사 수정: 볼륨 기반 수익 구조
-    T3_micro: 100000n, // $0.10 * 1e6 — 감사 수정: 트랜잭션당 1틱 소비 기준
-};
-// Helm protocol fee tiers (Scale: 1e4, e.g., 500 = 5%)
-exports.FEE_TIERS = {
-    BOOTSTRAP: { mintFee: 500n, burnFee: 200n, threshold: 5000n }, // threshold: $0.005 * 1e6
-    GROWTH: { mintFee: 1000n, burnFee: 300n, threshold: 50000n }, // threshold: $0.05 * 1e6
-    MATURE: { mintFee: 1000n, burnFee: 500n, threshold: 500000n }, // threshold: $0.50 * 1e6
-    PREMIUM: { mintFee: 800n, burnFee: 500n, threshold: -1n }, // Infinity replacement
-};
-class DynamicFeeEngine {
-    priceCache = null;
-    provider = null;
-    rpcUrls = [];
-    config;
-    warnedSpotPrice = false;
-    // P2-3: Recommended max cache duration for DEX price freshness
-    static RECOMMENDED_MAX_CACHE_MS = 5000;
-    constructor(config) {
-        // R3-P0-1: Prevent division by zero in all fee calculations
-        if (config.fallbackPriceUsd <= 0n) {
-            throw new Error(`[DynamicFee] fallbackPriceUsd must be > 0, got: ${config.fallbackPriceUsd}`);
-        }
-        this.config = config;
-        // P2-3: Warn if cache duration is too long for DEX pricing
-        if (config.cacheDurationMs > DynamicFeeEngine.RECOMMENDED_MAX_CACHE_MS) {
-            logger_1.logger.warn(`[DynamicFee] cacheDurationMs=${config.cacheDurationMs}ms exceeds recommended ${DynamicFeeEngine.RECOMMENDED_MAX_CACHE_MS}ms for DEX pricing accuracy`);
-        }
-    }
-    /**
-     * Connect to an RPC provider. Accepts a single URL or an array of URLs
-     * for multi-RPC fallback. On connection failure, the next URL is tried.
-     */
-    async connect(rpcUrl) {
-        const urls = Array.isArray(rpcUrl) ? rpcUrl : [rpcUrl];
-        if (urls.length === 0 || urls.every(u => !u)) {
-            throw new Error("[DynamicFee] At least one valid RPC URL is required");
-        }
-        this.rpcUrls = urls.filter(u => !!u);
-        await this.connectToNext();
-    }
-    /**
-     * Iterate through stored RPC URLs and connect to the first one that succeeds.
-     * Throws if all URLs fail.
-     */
-    async connectToNext() {
-        let lastError = null;
-        for (const url of this.rpcUrls) {
-            try {
-                const provider = new ethers_1.JsonRpcProvider(url);
-                // Verify connectivity by requesting the network
-                await provider.getNetwork();
-                this.provider = provider;
-                logger_1.logger.info(`[DynamicFee] Connected to RPC: ${url}`);
-                return;
-            }
-            catch (err) {
-                lastError = err instanceof Error ? err : new Error(String(err));
-                logger_1.logger.warn(`[DynamicFee] RPC connection failed for ${url}: ${lastError.message}`);
-            }
-        }
-        // If all URLs failed, fall back to the first URL without connectivity check
-        // so that subsequent calls can still attempt requests
-        this.provider = new ethers_1.JsonRpcProvider(this.rpcUrls[0]);
-        logger_1.logger.warn(`[DynamicFee] All RPC URLs failed connectivity check, using first URL as fallback`);
-    }
-    async getTTTPriceUsd() {
-        const now = Date.now();
-        if (this.priceCache && (now - this.priceCache.timestamp) < this.config.cacheDurationMs) {
-            return this.priceCache.price;
-        }
-        try {
-            let price;
-            // R4-P1-2: Chainlink FIRST (resistant to flash loan), Uniswap spot as fallback only
-            if (this.config.chainlinkFeed && this.provider) {
-                price = await this.fetchChainlinkPrice();
-            }
-            else if (this.config.poolAddress && this.provider) {
-                // To suppress this warning, set `chainlinkFeed` in PriceOracleConfig to a
-                // Chainlink AggregatorV3 address (e.g. the TTT/USD feed on your target chain).
-                // Chainlink TWAP prices are resistant to single-block flash loan manipulation.
-                if (!this.warnedSpotPrice) {
-                    logger_1.logger.warn("[DynamicFee] Using Uniswap spot price — vulnerable to flash loan manipulation. Configure chainlinkFeed for production.");
-                    this.warnedSpotPrice = true;
-                }
-                price = await this.fetchUniswapPrice();
-            }
-            else {
-                price = this.config.fallbackPriceUsd;
-            }
-            if (price <= 0n) {
-                logger_1.logger.warn(`[DynamicFee] Invalid price ${price}, using fallback ${this.config.fallbackPriceUsd}`);
-                price = this.config.fallbackPriceUsd;
-                // R3-P0-1: Double-guard — fallback validated in constructor but belt-and-suspenders
-                if (price <= 0n)
-                    throw new Error("[DynamicFee] FATAL: fallbackPriceUsd is zero — cannot calculate fees");
-            }
-            this.priceCache = { price, timestamp: now };
-            return price;
-        }
-        catch (error) {
-            logger_1.logger.warn(`[DynamicFee] Price fetch failed, using fallback`);
-            return this.config.fallbackPriceUsd;
-        }
-    }
-    /**
-     * Force-invalidate price cache -- call when immediate price refresh is needed.
-     */
-    invalidateCache() {
-        this.priceCache = null;
-        logger_1.logger.info(`[DynamicFee] Price cache invalidated`);
-    }
-    async fetchUniswapPrice() {
-        if (!this.provider || !this.config.poolAddress)
-            return this.config.fallbackPriceUsd;
-        const stateViewAbi = ["function getSlot0(bytes32 poolId) external view returns (uint160 sqrtPriceX96, int24 tick, uint24 protocolFee, uint24 lpFee)"];
-        try {
-            const contract = new ethers_1.Contract(this.config.poolAddress, stateViewAbi, this.provider);
-            const poolId = ethers_1.ethers.keccak256(ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(["address"], [this.config.poolAddress]));
-            const [sqrtPriceX96] = await contract.getSlot0(poolId);
-            // B1-7: Unified Uniswap price scaling
-            const priceScaled = (BigInt(sqrtPriceX96) * BigInt(sqrtPriceX96) * 1000000n) >> 192n;
-            return priceScaled;
-        }
-        catch (error) {
-            logger_1.logger.warn(`[DynamicFee] Uniswap price fetch failed, using fallback: ${error instanceof Error ? error.message : error}`);
-            return this.config.fallbackPriceUsd;
-        }
-    }
-    async fetchChainlinkPrice() {
-        if (!this.provider || !this.config.chainlinkFeed)
-            return this.config.fallbackPriceUsd;
-        const feedAbi = ["function latestRoundData() external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)"];
-        const MAX_PRICE = 10n ** 12n; // B1-8: Max price 10^12n
-        try {
-            const contract = new ethers_1.Contract(this.config.chainlinkFeed, feedAbi, this.provider);
-            const [, answer, , updatedAt] = await contract.latestRoundData();
-            // B1-8: Check updatedAt (within 1 hour) and price <= MAX_PRICE
-            const now = BigInt(Math.floor(Date.now() / 1000));
-            // P2-4: Tightened staleness check from 3600s to 1800s (30 min)
-            if (now - BigInt(updatedAt) > 1800n) {
-                throw new Error("Chainlink price stale (>30min)");
-            }
-            const price = BigInt(answer) / 100n; // 8 decimals -> 6 decimals
-            if (price > MAX_PRICE) {
-                throw new Error("Chainlink price exceeds MAX_PRICE");
-            }
-            return price;
-        }
-        catch (error) {
-            logger_1.logger.warn(`[DynamicFee] Chainlink price fetch failed, using fallback: ${error instanceof Error ? error.message : error}`);
-            return this.config.fallbackPriceUsd;
-        }
-    }
-    getFeeRate(tttPriceUsd) {
-        if (tttPriceUsd < exports.FEE_TIERS.BOOTSTRAP.threshold) {
-            return { ...exports.FEE_TIERS.BOOTSTRAP, phase: "BOOTSTRAP" };
-        }
-        else if (tttPriceUsd < exports.FEE_TIERS.GROWTH.threshold) {
-            return { ...exports.FEE_TIERS.GROWTH, phase: "GROWTH" };
-        }
-        else if (tttPriceUsd < exports.FEE_TIERS.MATURE.threshold) {
-            return { ...exports.FEE_TIERS.MATURE, phase: "MATURE" };
-        }
-        else {
-            return { ...exports.FEE_TIERS.PREMIUM, phase: "PREMIUM" };
-        }
-    }
-    async calculateMintFee(tier, tickCount = 1, feeToken = "USDC", feeTokenAddress = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913") {
-        // B1-4: Throw if tickCount <= 0
-        if (tickCount <= 0)
-            throw new Error("[DynamicFee] tickCount must be positive");
-        if (!exports.TIER_USD_MICRO[tier])
-            throw new Error(`[DynamicFee] Invalid tier: ${tier}`);
-        const tttPriceUsd = await this.getTTTPriceUsd(); // 6 decimals
-        const usdTarget = exports.TIER_USD_MICRO[tier]; // 6 decimals
-        const feeRate = this.getFeeRate(tttPriceUsd);
-        const totalUsdCost = usdTarget * BigInt(tickCount); // 6 decimals
-        // tttAmount = (totalUsdCost / tttPriceUsd) * 1e18
-        const tttAmount = (totalUsdCost * (10n ** 18n)) / tttPriceUsd;
-        // protocolFeeUsd = totalUsdCost * feeRate / 10000
-        const protocolFeeUsd = (totalUsdCost * feeRate.mintFee) / 10000n;
-        return {
-            tttAmount,
-            protocolFeeUsd,
-            feeToken,
-            feeTokenAddress,
-            clientNet: tttAmount,
-            tttPriceUsd,
-            usdCost: totalUsdCost + protocolFeeUsd,
-            feeRateMint: feeRate.mintFee,
-            feeRateBurn: feeRate.burnFee,
-            tier,
-        };
-    }
-    async calculateBurnFee(tier, tickCount = 1, feeToken = "USDC", feeTokenAddress = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913") {
-        // B1-4: Throw if tickCount <= 0
-        if (tickCount <= 0)
-            throw new Error("[DynamicFee] tickCount must be positive");
-        if (!exports.TIER_USD_MICRO[tier])
-            throw new Error(`[DynamicFee] Invalid tier: ${tier}`);
-        const tttPriceUsd = await this.getTTTPriceUsd();
-        const usdTarget = exports.TIER_USD_MICRO[tier];
-        const feeRate = this.getFeeRate(tttPriceUsd);
-        const totalUsdCost = usdTarget * BigInt(tickCount);
-        const tttAmount = (totalUsdCost * (10n ** 18n)) / tttPriceUsd;
-        const protocolFeeUsd = (totalUsdCost * feeRate.burnFee) / 10000n;
-        return {
-            tttAmount,
-            protocolFeeUsd,
-            feeToken,
-            feeTokenAddress,
-            clientNet: tttAmount,
-            tttPriceUsd,
-            usdCost: totalUsdCost + protocolFeeUsd,
-            feeRateMint: feeRate.mintFee,
-            feeRateBurn: feeRate.burnFee,
-            tier,
-        };
-    }
-    async calculateEmergencyMintFee(tier, tickCount = 1) {
-        const base = await this.calculateMintFee(tier, tickCount);
-        const emergencyFeeUsd = (base.protocolFeeUsd * 150n) / 100n;
-        return {
-            ...base,
-            protocolFeeUsd: emergencyFeeUsd,
-            usdCost: (base.usdCost * 150n) / 100n,
-        };
-    }
-}
-exports.DynamicFeeEngine = DynamicFeeEngine;

package/dist/protocol_fee.d.ts

@@ -1,72 +0,0 @@
-import { FeeCalculation } from "./dynamic_fee";
-import { EVMConnector } from "./evm_connector";
-/**
- * Pluggable replay cache interface for signature deduplication.
- * Implement this to use Redis, database, or other external stores.
- */
-export interface ReplayCache {
-    has(key: string): Promise<boolean>;
-    set(key: string, ttlMs: number): Promise<void>;
-}
-/**
- * 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.
- */
-export declare class InMemoryReplayCache implements ReplayCache {
-    private entries;
-    private readonly maxEntries;
-    private readonly defaultTtlMs;
-    private lastPruneTime;
-    private static readonly PRUNE_INTERVAL_MS;
-    constructor(maxEntries?: number, defaultTtlMs?: number);
-    has(key: string): Promise<boolean>;
-    set(key: string, ttlMs: number): Promise<void>;
-    private pruneIfNeeded;
-}
-/**
- * ProtocolFeeCollector - Handles Helm protocol fee collection and verification.
- * Includes EIP-712 signature verification for x402 compliance.
- */
-export declare class ProtocolFeeCollector {
-    private totalCollected;
-    private chainId;
-    private verifyingContract;
-    private replayCache;
-    private evmConnector;
-    private protocolFeeRecipient;
-    private feeContract;
-    constructor(chainId: number, verifyingContract: string, evmConnector: EVMConnector, protocolFeeRecipient: string, replayCache?: ReplayCache);
-    /**
-     * R3-P0-2: Verify chainId matches the actual connected network.
-     * Must be called after EVMConnector.connect() to prevent cross-chain signature replay.
-     */
-    validateChainId(): Promise<void>;
-    private getFeeContract;
-    /**
-     * 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.
-     */
-    collectMintFee(feeCalc: FeeCalculation, signature: string, user: string, nonce: bigint, deadline: number): Promise<void>;
-    /**
-     * 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.
-     */
-    collectBurnFee(feeCalc: FeeCalculation, signature: string, user: string, nonce: bigint, deadline: number): Promise<void>;
-    /**
-     * Return total fees collected so far.
-     */
-    getCollectedFees(): Promise<bigint>;
-    /**
-     * EIP-712 signature verification (x402 compliance).
-     */
-    private verifySignature;
-}