openttt 0.1.0

package/dist/auto_mint.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoMintEngine = void 0;
+const ethers_1 = require("ethers");
+const crypto_1 = require("crypto");
+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 types_1 = require("./types");
+const logger_1 = require("./logger");
+const errors_1 = require("./errors");
+/**
+ * AutoMintEngine - TTT 자동 민팅 엔진
+ * 시간 합성, 동적 수수료 계산, EVM 민팅을 하나의 루프로 결합
+ */
+class AutoMintEngine {
+    config;
+    timeSynthesis;
+    feeEngine;
+    evmConnector;
+    feeCollector = null;
+    timer = null;
+    isRunning = false;
+    isProcessing = false;
+    onMintCallback;
+    onFailureCallback;
+    onLatencyCallback;
+    cachedSigner = null;
+    consecutiveFailures = 0;
+    maxConsecutiveFailures = 5;
+    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;
+        }
+    }
+    getEvmConnector() {
+        return this.evmConnector;
+    }
+    setOnMint(callback) {
+        this.onMintCallback = callback;
+    }
+    setOnFailure(callback) {
+        this.onFailureCallback = callback;
+    }
+    setOnLatency(callback) {
+        this.onLatencyCallback = callback;
+    }
+    /**
+     * 엔진 초기화 (RPC 연결 및 컨트랙트 설정)
+     */
+    async initialize() {
+        try {
+            const signerOrKey = this.config.signer || this.config.privateKey;
+            if (!signerOrKey)
+                throw new errors_1.TTTConfigError("[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)"
+            ];
+            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() {
+        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() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        this.isRunning = false;
+        logger_1.logger.info(`[AutoMint] Loop stopped`);
+    }
+    /**
+     * 단일 민트 틱 실행
+     * 시간합성 → tokenId 생성 → EVM mint 호출 → 수수료 계산/차감
+     */
+    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(`[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(`[PoT] Insufficient confidence`, `Calculated confidence ${pot.confidence} is below required 0.5`, `Ensure more NTP sources are reachable or decrease uncertainty.`);
+        }
+        const potHash = ethers_1.ethers.keccak256(ethers_1.ethers.toUtf8Bytes(JSON.stringify(pot, (key, value) => typeof value === 'bigint' ? value.toString() : value)));
+        // 2. tokenId 생성 (keccak256)
+        // chainId, poolAddress, timestamp 기반 유니크 ID
+        const tokenId = ethers_1.ethers.keccak256(ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(["uint256", "address", "uint64"], [BigInt(this.config.chainId), this.config.poolAddress, synthesized.timestamp]));
+        // 3. 수수료 계산
+        const feeCalculation = await this.feeEngine.calculateMintFee(this.config.tier);
+        // 4. EVM mint 호출
+        // grgHash는 현재 tokenId를 기반으로 생성 (실제 구현에선 더 복잡한 GRG 페이로드 사용 가능)
+        const grgHash = tokenId;
+        // 수취인 주소 (기본적으로 signer 주소)
+        if (!this.cachedSigner) {
+            throw new errors_1.TTTSignerError("[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}`);
+        const receipt = await this.evmConnector.mintTTT(recipient, feeCalculation.tttAmount, grgHash, potHash);
+        // 5. 수수료 차감/기록 (실제 컨트랙트에서 처리되거나 SDK 레벨에서 추적)
+        // 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.
+                const nonce = BigInt("0x" + (0, crypto_1.randomBytes)(8).toString("hex")); // Cryptographic nonce
+                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;
+            }
+        }
+        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("[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("[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: "Helm Protocol",
+            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/dynamic_fee.d.ts

@@ -0,0 +1,64 @@
+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 config;
+    private static readonly RECOMMENDED_MAX_CACHE_MS;
+    constructor(config: PriceOracleConfig);
+    connect(rpcUrl: string): Promise<void>;
+    getTTTPriceUsd(): Promise<bigint>;
+    /**
+     * 캐시 강제 무효화 — 외부에서 즉시 가격 갱신이 필요할 때 호출
+     */
+    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

@@ -0,0 +1,203 @@
+"use strict";
+// sdk/src/dynamic_fee.ts — Dynamic Fee Engine
+// TTT 시장가에 연동되어 자동으로 tick 비용 조정
+// DEX 운영자는 tier만 설정 → 나머지 SDK가 자동 처리
+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");
+// Tier별 USD 목표 비용 (Scale: 1e6)
+exports.TIER_USD_MICRO = {
+    T0_epoch: 1000n, // $0.001 * 1e6
+    T1_block: 10000n, // $0.01 * 1e6
+    T2_slot: 240000n, // $0.24 * 1e6
+    T3_micro: 12000000n, // $12 * 1e6
+};
+// Helm 프로토콜 수수료 구간 (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;
+    config;
+    // 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`);
+        }
+    }
+    async connect(rpcUrl) {
+        if (!rpcUrl)
+            throw new Error("[DynamicFee] RPC URL is required");
+        this.provider = new ethers_1.JsonRpcProvider(rpcUrl);
+    }
+    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) {
+                logger_1.logger.warn("[DynamicFee] Using Uniswap spot price — vulnerable to flash loan manipulation. Configure chainlinkFeed for production.");
+                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;
+        }
+    }
+    /**
+     * 캐시 강제 무효화 — 외부에서 즉시 가격 갱신이 필요할 때 호출
+     */
+    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/errors.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Base error class for TTT SDK errors with storytelling capabilities.
+ */
+export declare class TTTBaseError extends Error {
+    readonly message: string;
+    readonly reason: string;
+    readonly fix: string;
+    constructor(message: string, reason: string, fix: string);
+}
+/**
+ * Errors related to SDK or Engine configuration.
+ */
+export declare class TTTConfigError extends TTTBaseError {
+    constructor(message: string, reason: string, fix: string);
+}
+/**
+ * Errors related to Signer (PrivateKey, Turnkey, Privy, KMS) acquisition or usage.
+ */
+export declare class TTTSignerError extends TTTBaseError {
+    constructor(message: string, reason: string, fix: string);
+}
+/**
+ * Errors related to Network (RPC, ChainID, Connectivity).
+ */
+export declare class TTTNetworkError extends TTTBaseError {
+    constructor(message: string, reason: string, fix: string);
+}
+/**
+ * Errors related to Smart Contract interaction (TTT.sol, ProtocolFee.sol).
+ */
+export declare class TTTContractError extends TTTBaseError {
+    constructor(message: string, reason: string, fix: string);
+}
+/**
+ * Errors related to NTP/KTSat Time Synthesis.
+ */
+export declare class TTTTimeSynthesisError extends TTTBaseError {
+    constructor(message: string, reason: string, fix: string);
+}
+/**
+ * Errors related to Dynamic Fee Engine or Protocol Fee collection.
+ */
+export declare class TTTFeeError extends TTTBaseError {
+    constructor(message: string, reason: string, fix: string);
+}

package/dist/errors.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TTTFeeError = exports.TTTTimeSynthesisError = exports.TTTContractError = exports.TTTNetworkError = exports.TTTSignerError = exports.TTTConfigError = exports.TTTBaseError = void 0;
+/**
+ * Base error class for TTT SDK errors with storytelling capabilities.
+ */
+class TTTBaseError extends Error {
+    message;
+    reason;
+    fix;
+    constructor(message, reason, fix) {
+        super(`${message} (Reason: ${reason}. Fix: ${fix})`);
+        this.message = message;
+        this.reason = reason;
+        this.fix = fix;
+        this.name = this.constructor.name;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.TTTBaseError = TTTBaseError;
+/**
+ * Errors related to SDK or Engine configuration.
+ */
+class TTTConfigError extends TTTBaseError {
+    constructor(message, reason, fix) {
+        super(message, reason, fix);
+    }
+}
+exports.TTTConfigError = TTTConfigError;
+/**
+ * Errors related to Signer (PrivateKey, Turnkey, Privy, KMS) acquisition or usage.
+ */
+class TTTSignerError extends TTTBaseError {
+    constructor(message, reason, fix) {
+        super(message, reason, fix);
+    }
+}
+exports.TTTSignerError = TTTSignerError;
+/**
+ * Errors related to Network (RPC, ChainID, Connectivity).
+ */
+class TTTNetworkError extends TTTBaseError {
+    constructor(message, reason, fix) {
+        super(message, reason, fix);
+    }
+}
+exports.TTTNetworkError = TTTNetworkError;
+/**
+ * Errors related to Smart Contract interaction (TTT.sol, ProtocolFee.sol).
+ */
+class TTTContractError extends TTTBaseError {
+    constructor(message, reason, fix) {
+        super(message, reason, fix);
+    }
+}
+exports.TTTContractError = TTTContractError;
+/**
+ * Errors related to NTP/KTSat Time Synthesis.
+ */
+class TTTTimeSynthesisError extends TTTBaseError {
+    constructor(message, reason, fix) {
+        super(message, reason, fix);
+    }
+}
+exports.TTTTimeSynthesisError = TTTTimeSynthesisError;
+/**
+ * Errors related to Dynamic Fee Engine or Protocol Fee collection.
+ */
+class TTTFeeError extends TTTBaseError {
+    constructor(message, reason, fix) {
+        super(message, reason, fix);
+    }
+}
+exports.TTTFeeError = TTTFeeError;