openttt 0.1.2 → 0.1.3

package/README.md

@@ -27,7 +27,7 @@ Current MEV protection relies on **trust**: builders promise fair ordering, prot
 | **Mechanism** | Social contract (request) | Physical verification (proof) |
 | **Enforcement** | Reputation, exclusion | Economic natural selection |
 | **Bad actors** | Must be identified and removed | Naturally unprofitable, self-selecting out |
-| **Time source** | Block timestamp (miner-controlled) | Multi-source NTP synthesis (NIST, KRISS, Google) |
+| **Time source** | Block timestamp (miner-controlled) | Multi-source NTP synthesis (NIST, Google, Apple) |
 
 **The core insight**: Rollups generate precise timestamps and deliver them to builders with a receipt. The Adaptive GRG pipeline then verifies whether the builder respected that ordering:
 
@@ -95,7 +95,7 @@ const ttt = await TTTClient.create({
   tier: "T1_block",
   contractAddress: "0x...",
   poolAddress: "0x...",
-  timeSources: ["nist", "kriss", "google"],
+  timeSources: ["nist", "google", "cloudflare", "apple"],
   protocolFeeRate: 0.05,
   enableGracefulShutdown: true,
 });
@@ -264,7 +264,7 @@ const ttt = await TTTClient.create({
 ```
 TTTClient (entry point)
 |-- AutoMintEngine         Periodic minting loop
-|   |-- TimeSynthesis      NTP multi-source median synthesis (NIST, KRISS, Google)
+|   |-- TimeSynthesis      NTP multi-source median synthesis (NIST, Google, Apple)
 |   |-- DynamicFeeEngine   Oracle-based pricing
 |   |-- EVMConnector       On-chain mint/burn/events (ethers v6)
 |   '-- ProtocolFee        EIP-712 signed fee collection
@@ -311,7 +311,7 @@ This asymmetry is deliberate: it is hard to earn trust and easy to lose it.
 OpenTTT queries multiple atomic clock-synchronized NTP sources in parallel and produces a median-synthesized timestamp with confidence scoring:
 
 - **NIST** (time.nist.gov) -- US national standard
-- **KRISS** (time.kriss.re.kr) -- Korean national standard
+- **Apple** (time.apple.com) -- Apple global time service
 - **Google** (time.google.com) -- Leap-smeared public NTP
 
 All readings must fall within a stratum-dependent tolerance of the synthesized median (10ms for stratum 1, 25ms for stratum 2, 50ms for stratum 3+), or the Proof of Time is rejected. Single-source operation triggers a degraded-confidence warning.

package/dist/adaptive_switch.d.ts

@@ -12,6 +12,8 @@ export interface Block {
     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;
@@ -22,23 +24,36 @@ export declare class AdaptiveSwitch {
     private consecutiveFailures;
     private turboEntryThreshold;
     private turboMaintainThreshold;
+    private tolerance;
+    constructor(options?: {
+        tolerance?: number;
+    });
     /**
-     * TTT의 핵심 메커니즘: 타임스탬프 순서 일치율에 따른 Turbo/Full 모드 전환
+     * Core TTT mechanism: switches between Turbo/Full mode based on timestamp ordering match rate.
      */
-    verifyBlock(block: Block, tttRecord: TTTRecord): AdaptiveMode;
+    verifyBlock(block: Block, tttRecord: TTTRecord, chainId: number, poolAddress: string, tier?: string): AdaptiveMode;
     /**
-     * 모드에 따른 수수료 할인율 반환
-     * TURBO: 20% 할인 (수익 증가 유도)
-     * FULL: 할인 없음
+     * 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

@@ -2,15 +2,22 @@
 // sdk/src/adaptive_switch.ts — Adaptive Mode Switcher
 // Turbo (50ms) vs Full (127ms)
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AdaptiveSwitch = exports.AdaptiveMode = void 0;
-const grg_inverse_1 = require("./grg_inverse");
+exports.AdaptiveSwitch = exports.TIER_TOLERANCE_MS = exports.AdaptiveMode = void 0;
+const helm_crypto_1 = require("../vendor/helm-crypto");
 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 KTSat sync
+// const TOLERANCE = 100; // 100ms tolerance for KTSat 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
@@ -21,17 +28,22 @@ class AdaptiveSwitch {
     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;
+    }
     /**
-     * TTT의 핵심 메커니즘: 타임스탬프 순서 일치율에 따른 Turbo/Full 모드 전환
+     * Core TTT mechanism: switches between Turbo/Full mode based on timestamp ordering match rate.
      */
-    verifyBlock(block, tttRecord) {
-        // 1. 타임스탬프 순서 및 시간 일치 여부 확인
+    verifyBlock(block, tttRecord, chainId, poolAddress, tier) {
+        // 1. Check timestamp ordering and time match
         const orderMatch = this.compareTransactionOrder(block.txs, tttRecord.txOrder);
-        const timeMatch = Math.abs(block.timestamp - tttRecord.time) < TOLERANCE;
+        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);
+        const integrityOk = helm_crypto_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
@@ -42,7 +54,7 @@ class AdaptiveSwitch {
                 this.penaltyCooldown = 20 * Math.pow(2, this.consecutiveFailures - 1); // 20, 40, 80, 160, 320
             }
         }
-        // 2. 이력 업데이트 (Sliding Window)
+        // 2. Update history (Sliding Window)
         this.history.push(sequenceOk);
         if (this.history.length > this.windowSize) {
             this.history.shift();
@@ -50,7 +62,7 @@ class AdaptiveSwitch {
         if (this.penaltyCooldown > 0) {
             this.penaltyCooldown--;
         }
-        // 3. 일치율 계산 및 모드 전환
+        // 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
@@ -73,21 +85,21 @@ class AdaptiveSwitch {
         return this.currentMode;
     }
     /**
-     * 모드에 따른 수수료 할인율 반환
-     * TURBO: 20% 할인 (수익 증가 유도)
-     * FULL: 할인 없음
+     * 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 = [];
@@ -95,6 +107,31 @@ class AdaptiveSwitch {
         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;

package/dist/auto_mint.d.ts

@@ -1,8 +1,9 @@
+import { TimeSynthesis } from "./time_synthesis";
 import { EVMConnector } from "./evm_connector";
 import { AutoMintConfig, MintResult } from "./types";
 /**
- * AutoMintEngine - TTT 자동 민팅 엔진
- * 시간 합성, 동적 수수료 계산, EVM 민팅을 하나의 루프로 결합
+ * AutoMintEngine - Automatic TTT minting engine.
+ * Combines time synthesis, dynamic fee calculation, and EVM minting into a single loop.
  */
 export declare class AutoMintEngine {
     private config;
@@ -20,26 +21,40 @@ export declare class AutoMintEngine {
     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;
     /**
-     * 엔진 초기화 (RPC 연결 및 컨트랙트 설정)
+     * 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;
     /**
-     * 단일 민트 틱 실행
-     * 시간합성 → tokenId 생성 → EVM mint 호출 → 수수료 계산/차감
+     * 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

@@ -2,18 +2,22 @@
 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 pot_signer_1 = require("./pot_signer");
+const helm_crypto_1 = require("../vendor/helm-crypto");
 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 - TTT 자동 민팅 엔진
- * 시간 합성, 동적 수수료 계산, EVM 민팅을 하나의 루프로 결합
+ * AutoMintEngine - Automatic TTT minting engine.
+ * Combines time synthesis, dynamic fee calculation, and EVM minting into a single loop.
  */
 class AutoMintEngine {
     config;
@@ -31,6 +35,10 @@ class AutoMintEngine {
     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 });
@@ -43,11 +51,16 @@ class AutoMintEngine {
             this.cachedSigner = config.signer;
         }
         // Initialize Ed25519 PoT signer for non-repudiation
-        this.potSigner = new pot_signer_1.PotSigner();
+        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;
     }
@@ -58,13 +71,13 @@ class AutoMintEngine {
         this.onLatencyCallback = callback;
     }
     /**
-     * 엔진 초기화 (RPC 연결 및 컨트랙트 설정)
+     * 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("[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.");
+                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();
@@ -73,7 +86,9 @@ class AutoMintEngine {
                 "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)"
+                "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) {
@@ -91,7 +106,7 @@ class AutoMintEngine {
         }
     }
     /**
-     * 자동 민팅 루프 시작
+     * Start the automatic minting loop.
      */
     start() {
         if (this.isRunning)
@@ -135,7 +150,7 @@ class AutoMintEngine {
         logger_1.logger.info(`[AutoMint] Loop started for tier ${this.config.tier} (${interval}ms)`);
     }
     /**
-     * 자동 민팅 루프 정지
+     * Stop the automatic minting loop.
      */
     stop() {
         if (this.timer) {
@@ -146,11 +161,26 @@ class AutoMintEngine {
         logger_1.logger.info(`[AutoMint] Loop stopped`);
     }
     /**
-     * 단일 민트 틱 실행
-     * 시간합성 → tokenId 생성 → EVM mint 호출 → 수수료 계산/차감
+     * 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)
+        // 1. Time Synthesis
         const synthesized = await this.timeSynthesis.synthesize();
         if (!synthesized) {
             logger_1.logger.warn(`[AutoMint] Time synthesis returned null/undefined, skipping tick`);
@@ -158,35 +188,78 @@ class AutoMintEngine {
         }
         // 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.`);
+            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(`[PoT] Insufficient confidence`, `Calculated confidence ${pot.confidence} is below required 0.5`, `Ensure more NTP sources are reachable or decrease uncertainty.`);
+            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.`);
         }
-        const potHash = ethers_1.ethers.keccak256(ethers_1.ethers.toUtf8Bytes(JSON.stringify(pot, (key, value) => typeof value === 'bigint' ? value.toString() : value)));
+        // 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. 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. 수수료 계산
+        // 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 호출
-        // grgHash는 현재 tokenId를 기반으로 생성 (실제 구현에선 더 복잡한 GRG 페이로드 사용 가능)
-        const grgHash = tokenId;
-        // 수취인 주소 (기본적으로 signer 주소)
+        // 4. EVM mint call — run full GRG pipeline (Golomb → Reed-Solomon → Golay+HMAC)
+        const grgPayload = ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(["bytes32", "bytes32", "uint64", "uint8"], [tokenId, potHash, synthesized.timestamp, pot.sources]);
+        const grgStart = Date.now();
+        const grgShards = helm_crypto_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("[AutoMint] Signer not initialized", "cachedSigner is null", "Initialize the engine before calling mintTick().");
+            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}`);
-        const receipt = await this.evmConnector.mintTTT(recipient, feeCalculation.tttAmount, grgHash, potHash);
-        // 5. 수수료 차감/기록 (실제 컨트랙트에서 처리되거나 SDK 레벨에서 추적)
+        // 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) {
@@ -194,7 +267,9 @@ class AutoMintEngine {
                 // 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
+                // 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;
@@ -206,6 +281,8 @@ class AutoMintEngine {
                 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({
@@ -220,15 +297,15 @@ class AutoMintEngine {
     }
     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.");
+            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("[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.");
+            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: "Helm Protocol",
+            name: "OpenTTT_ProtocolFee",
             version: "1",
             chainId: this.config.chainId,
             verifyingContract: this.config.feeCollectorAddress

package/dist/ct_log.d.ts

@@ -0,0 +1,47 @@
+/**
+ * PoT Certificate Transparency Log Client
+ * Tracks all PoT anchoring events and provides query/audit capabilities.
+ */
+export interface PoTAnchorEntry {
+    id: string;
+    stratum: string;
+    grgHash: string;
+    potHash: string;
+    timestamp: string;
+    blockNumber: string;
+    txHash: string;
+    builderAddress: string;
+}
+export declare class PoTCTLog {
+    private subgraphUrl;
+    constructor(subgraphUrl: string);
+    /**
+     * Query PoT anchors with filters.
+     */
+    queryAnchors(filter: {
+        startTime?: number;
+        endTime?: number;
+        stratum?: string;
+        limit?: number;
+    }): Promise<PoTAnchorEntry[]>;
+    /**
+     * Get audit trail for a specific transaction.
+     */
+    getAuditTrail(txHash: string): Promise<PoTAnchorEntry | null>;
+    /**
+     * Calculate builder performance score.
+     */
+    getBuilderScore(builderAddress: string): Promise<{
+        totalAnchors: number;
+        turboRate: number;
+        avgLatencyMs: number;
+    }>;
+    /**
+     * Get global network statistics.
+     */
+    getNetworkStats(): Promise<{
+        totalAnchors: number;
+        uniqueBuilders: number;
+        avgTurboRate: number;
+    }>;
+}