@gvnrdao/dh-sdk 0.0.293 → 0.0.294

package/dist/index.js

@@ -3744,7 +3744,7 @@ var require_abstract_coder = __commonJS({
     function toObject2(names2, items, deep) {
       if (names2.indexOf(null) >= 0) {
         return items.map((item, index) => {
-          if (item instanceof Result10) {
+          if (item instanceof Result11) {
             return toObject2(getNames2(item), item, deep);
           }
           return item;
@@ -3753,7 +3753,7 @@ var require_abstract_coder = __commonJS({
       return names2.reduce((accum, name, index) => {
         let item = items.getValue(name);
         if (!(name in accum)) {
-          if (deep && item instanceof Result10) {
+          if (deep && item instanceof Result11) {
             item = toObject2(getNames2(item), item, deep);
           }
           accum[name] = item;
@@ -3761,7 +3761,7 @@ var require_abstract_coder = __commonJS({
         return accum;
       }, {});
     }
-    var Result10 = class _Result extends Array {
+    var Result11 = class _Result extends Array {
       // No longer used; but cannot be removed as it will remove the
       // #private field from the .d.ts which may break backwards
       // compatibility
@@ -3965,7 +3965,7 @@ var require_abstract_coder = __commonJS({
         return new _Result(_guard5, items, keys);
       }
     };
-    exports2.Result = Result10;
+    exports2.Result = Result11;
     function checkResultErrors2(result) {
       const errors2 = [];
       const checkErrors = function(path2, object2) {
@@ -32403,8 +32403,8 @@ ${errorReport}`);
     var UTXO_QUERY_MAX_RETRIES = 3;
     var UTXO_QUERY_RETRY_DELAY_MS = 500;
     var QUANTUM_WINDOW_SECONDS2 = 60;
-    var DEAD_ZONE_SECONDS = 16;
-    var SAFE_EXECUTION_WINDOW_SECONDS = QUANTUM_WINDOW_SECONDS2 - DEAD_ZONE_SECONDS;
+    var DEAD_ZONE_SECONDS2 = 16;
+    var SAFE_EXECUTION_WINDOW_SECONDS = QUANTUM_WINDOW_SECONDS2 - DEAD_ZONE_SECONDS2;
     var SECONDS_PER_DAY = 86400;
     var DAYS_PER_MONTH = 30;
     var LIT_ACTION_ETH_RPC_TIMEOUT_MS = 8e3;
@@ -34943,8 +34943,8 @@ function getMainnetConfig() {
       bitcoinWithdrawalAddressRegistry: MAINNET_CONTRACTS.BitcoinWithdrawalAddressRegistry || ""
     },
     subgraphs: {
-      diamondHandsUrl: "https://api.studio.thegraph.com/query/1755201/diamond-hands/v1.0.0-mainnet"
-      // Mainnet subgraph (keyless studio endpoint, browser-queryable)
+      diamondHandsUrl: "https://gateway-arbitrum.network.thegraph.com/api/subgraphs/id/CCTPsdYqco2jChDLLBQTbdJWwoukVoMt1cXeR9ti6r9A"
+      // Published Sepolia subgraph on Arbitrum One
     },
     litNetwork: "chipotle",
     debug: false
@@ -90299,7 +90299,7 @@ __export(src_exports, {
   ErrorSeverity: () => ErrorSeverity,
   EventHelpers: () => EventHelpers,
   LOCALHOST_CONTRACTS: () => LOCALHOST_CONTRACTS,
-  LRUCache: () => Cache,
+  LRUCache: () => LRUCache,
   LoanCreator: () => LoanCreator,
   LoanQuery: () => LoanQuery,
   LoanStatus: () => LoanStatus,
@@ -108186,6 +108186,9 @@ function validateSDKConfig(config) {
 
 // src/utils/quantum-timing.ts
 var QUANTUM_WINDOW_SECONDS = 60;
+var DEAD_ZONE_SECONDS = 8;
+var INCLUSION_LATENCY_BUDGET = 16;
+var POST_BOUNDARY_SKEW_MARGIN = 3;
 function calculateNextQuantumTimestamp() {
   const now = Math.floor(Date.now() / 1e3);
   const currentQuantum = Math.floor(now / QUANTUM_WINDOW_SECONDS) * QUANTUM_WINDOW_SECONDS;
@@ -108214,6 +108217,27 @@ function validateQuantumTiming(signedTimestamp, _bufferSeconds = 30) {
   console.log("  Current quantum:", currentQuantum);
   console.log("  Valid window: PAST/CURRENT/NEXT (180s total)");
 }
+async function awaitSafeSubmissionWindow(quantumTimestamp, opts = {}) {
+  const now = opts.now ?? (() => Math.floor(Date.now() / 1e3));
+  const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const nowSec = now();
+  const signatureQuantum = Math.floor(quantumTimestamp / QUANTUM_WINDOW_SECONDS) * QUANTUM_WINDOW_SECONDS;
+  const currentQuantum = Math.floor(nowSec / QUANTUM_WINDOW_SECONDS) * QUANTUM_WINDOW_SECONDS;
+  const secsToBoundary = QUANTUM_WINDOW_SECONDS - nowSec % QUANTUM_WINDOW_SECONDS;
+  const isNextQuantumSig = signatureQuantum === currentQuantum + QUANTUM_WINDOW_SECONDS;
+  if (isNextQuantumSig && secsToBoundary <= DEAD_ZONE_SECONDS + INCLUSION_LATENCY_BUDGET) {
+    const target = currentQuantum + QUANTUM_WINDOW_SECONDS + POST_BOUNDARY_SKEW_MARGIN;
+    const waitSeconds = target - nowSec;
+    if (waitSeconds > 0) {
+      console.log(
+        `[Quantum Timing] \u23F3 Deferring send ${waitSeconds}s to clear the quantum dead zone (sig quantum ${signatureQuantum}, current ${currentQuantum}, ${secsToBoundary}s to boundary)`
+      );
+      await sleep(waitSeconds * 1e3);
+      return { waited: true, waitedSeconds: waitSeconds };
+    }
+  }
+  return { waited: false, waitedSeconds: 0 };
+}
 
 // src/utils/mint-authorization.utils.ts
 var PKP_NFT_ABI = [
@@ -109823,106 +109847,365 @@ function createContractManager(config) {
 }
 
 // src/modules/cache/cache-manager.module.ts
-var Cache = class {
-  cache = /* @__PURE__ */ new Map();
+var LRUCache = class {
+  cache;
+  /**
+   * Audit M-J: singleflight registry for `getOrCompute` / `getOrComputeResult`.
+   * Concurrent cache-miss callers for the same key share one inflight promise
+   * instead of each running `compute()` independently — important when the
+   * compute spends a paid LIT capacity credit or hits a rate-limited upstream.
+   */
+  inflight = /* @__PURE__ */ new Map();
+  inflightResult = /* @__PURE__ */ new Map();
   maxSize;
   ttlMs;
-  constructor(config) {
-    this.maxSize = config.maxSize;
-    this.ttlMs = config.ttlMs;
+  debug;
+  name;
+  // Statistics
+  stats = {
+    hits: 0,
+    misses: 0,
+    evictions: 0
+  };
+  constructor(config = {}) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = config.maxSize || 1e3;
+    this.ttlMs = config.ttlMs || 6e4;
+    this.debug = config.debug || false;
+    this.name = config.name || "Cache";
+    if (this.debug) {
+      console.log(
+        `\u{1F4BE} [${this.name}] Initialized: maxSize=${this.maxSize}, ttl=${this.ttlMs}ms`
+      );
+    }
   }
   /**
    * Get value from cache
+   *
+   * Returns null if:
+   * - Key not found
+   * - Entry has expired
+   *
+   * @param key - Cache key
+   * @returns Cached value or null
    */
   get(key) {
     const entry = this.cache.get(key);
     if (!entry) {
-      return void 0;
+      this.stats.misses++;
+      if (this.debug) {
+        console.log(`\u274C [${this.name}] Cache MISS: ${String(key)}`);
+      }
+      return null;
     }
-    const now = Date.now();
-    if (now - entry.timestamp > entry.ttl) {
+    if (this.isExpired(entry)) {
       this.cache.delete(key);
-      return void 0;
+      this.stats.misses++;
+      if (this.debug) {
+        const age = Date.now() - entry.timestamp;
+        console.log(`\u23F0 [${this.name}] Cache EXPIRED: ${String(key)} (age: ${age}ms)`);
+      }
+      return null;
+    }
+    entry.hits++;
+    entry.lastAccessed = Date.now();
+    this.cache.set(key, entry);
+    this.stats.hits++;
+    if (this.debug) {
+      const age = Date.now() - entry.timestamp;
+      console.log(
+        `\u2705 [${this.name}] Cache HIT: ${String(key)} (age: ${age}ms, hits: ${entry.hits})`
+      );
     }
     return entry.value;
   }
+  /**
+   * Get value from cache with Result wrapper
+   *
+   * Useful when you want to distinguish between "not found" and "expired"
+   */
+  getResult(key) {
+    const value = this.get(key);
+    if (value === null) {
+      return failure(
+        new SDKError({
+          message: `Cache miss for key: ${String(key)}`,
+          category: "CACHE" /* CACHE */,
+          severity: "LOW" /* LOW */,
+          originalError: new Error("Cache miss")
+        })
+      );
+    }
+    return success(value);
+  }
   /**
    * Set value in cache
+   *
+   * If cache is full, evicts the least recently used entry
+   *
+   * @param key - Cache key
+   * @param value - Value to cache
+   * @param ttl - Optional custom TTL for this entry (ms)
    */
   set(key, value, ttl) {
     if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
-      const firstKey = this.cache.keys().next().value;
-      if (firstKey) {
-        this.cache.delete(firstKey);
-      }
+      this.evictLRU();
     }
-    this.cache.set(key, {
+    const entry = {
       value,
       timestamp: Date.now(),
-      ttl: ttl || this.ttlMs
-    });
+      hits: 0,
+      lastAccessed: Date.now()
+    };
+    this.cache.set(key, entry);
+    if (this.debug) {
+      const effectiveTtl = ttl || this.ttlMs;
+      console.log(
+        `\u{1F4BE} [${this.name}] Cache SET: ${String(key)} (ttl: ${effectiveTtl}ms, size: ${this.cache.size}/${this.maxSize})`
+      );
+    }
   }
   /**
-   * Check if key exists in cache
+   * Set value in cache with Result wrapper
+   */
+  setResult(key, value, ttl) {
+    try {
+      this.set(key, value, ttl);
+      return success(void 0);
+    } catch (error2) {
+      return failure(
+        new SDKError({
+          message: `Failed to set cache value for key: ${String(key)}`,
+          category: "CACHE" /* CACHE */,
+          severity: "MEDIUM" /* MEDIUM */,
+          originalError: error2 instanceof Error ? error2 : new Error(String(error2))
+        })
+      );
+    }
+  }
+  /**
+   * Check if key exists in cache (without affecting stats)
    */
   has(key) {
-    return this.get(key) !== void 0;
+    const entry = this.cache.get(key);
+    return entry !== void 0 && !this.isExpired(entry);
   }
   /**
-   * Delete key from cache
+   * Delete specific key from cache
    */
   delete(key) {
-    return this.cache.delete(key);
+    const deleted = this.cache.delete(key);
+    if (deleted && this.debug) {
+      console.log(`\u{1F5D1}\uFE0F  [${this.name}] Cache DELETE: ${String(key)}`);
+    }
+    return deleted;
   }
   /**
-   * Clear all cache entries
+   * Clear entire cache
    */
   clear() {
+    const previousSize = this.cache.size;
     this.cache.clear();
+    this.stats = {
+      hits: 0,
+      misses: 0,
+      evictions: 0
+    };
+    if (this.debug) {
+      console.log(`\u{1F9F9} [${this.name}] Cache CLEARED: removed ${previousSize} entries`);
+    }
   }
   /**
-   * Clean expired entries
+   * Get current cache size
+   */
+  size() {
+    return this.cache.size;
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    const entries = Array.from(this.cache.values());
+    const timestamps = entries.map((e) => e.timestamp);
+    const total = this.stats.hits + this.stats.misses;
+    const hitRate = total === 0 ? 0 : this.stats.hits / total * 100;
+    return {
+      size: this.cache.size,
+      hits: this.stats.hits,
+      misses: this.stats.misses,
+      evictions: this.stats.evictions,
+      oldestEntry: timestamps.length > 0 ? Math.min(...timestamps) : 0,
+      newestEntry: timestamps.length > 0 ? Math.max(...timestamps) : 0,
+      hitRate
+    };
+  }
+  /**
+   * Get hit rate percentage
+   */
+  getHitRate() {
+    const total = this.stats.hits + this.stats.misses;
+    return total === 0 ? 0 : this.stats.hits / total * 100;
+  }
+  /**
+   * Get all cached keys (for debugging)
+   */
+  getKeys() {
+    return Array.from(this.cache.keys());
+  }
+  /**
+   * Get all cached values (for debugging)
+   */
+  getValues() {
+    return Array.from(this.cache.values()).map((entry) => entry.value);
+  }
+  /**
+   * Get all cache entries with metadata (for debugging)
+   */
+  getEntries() {
+    return Array.from(this.cache.entries()).map(([key, entry]) => ({
+      key,
+      value: entry.value,
+      metadata: {
+        timestamp: entry.timestamp,
+        hits: entry.hits,
+        lastAccessed: entry.lastAccessed
+      }
+    }));
+  }
+  /**
+   * Clean up expired entries
+   *
+   * Useful for periodic maintenance
+   *
+   * @returns Number of entries cleaned
    */
   cleanExpired() {
     const now = Date.now();
-    let cleaned = 0;
+    let cleanedCount = 0;
     for (const [key, entry] of this.cache.entries()) {
-      if (now - entry.timestamp > entry.ttl) {
+      if (now - entry.timestamp > this.ttlMs) {
         this.cache.delete(key);
-        cleaned++;
+        cleanedCount++;
       }
     }
-    return cleaned;
+    if (cleanedCount > 0 && this.debug) {
+      console.log(`\u{1F9F9} [${this.name}] Cleaned ${cleanedCount} expired entries`);
+    }
+    return cleanedCount;
   }
   /**
-   * Get cache statistics
+   * Check if cache entry is expired
    */
-  getStats() {
-    return {
-      size: this.cache.size,
-      maxSize: this.maxSize,
-      ttlMs: this.ttlMs
-    };
+  isExpired(entry) {
+    return Date.now() - entry.timestamp > this.ttlMs;
+  }
+  /**
+   * Evict least recently used entry
+   */
+  evictLRU() {
+    let oldestKey = null;
+    let oldestAccess = Infinity;
+    for (const [key, entry] of this.cache.entries()) {
+      if (entry.lastAccessed < oldestAccess) {
+        oldestAccess = entry.lastAccessed;
+        oldestKey = key;
+      }
+    }
+    if (oldestKey !== null) {
+      this.cache.delete(oldestKey);
+      this.stats.evictions++;
+      if (this.debug) {
+        const timeSinceAccess = Date.now() - oldestAccess;
+        console.log(
+          `\u267B\uFE0F  [${this.name}] Cache EVICT (LRU): ${String(oldestKey)} (last accessed: ${timeSinceAccess}ms ago)`
+        );
+      }
+    }
+  }
+  /**
+   * Get or compute value
+   *
+   * If key exists in cache, returns cached value.
+   * Otherwise, computes value using provided function and caches it.
+   *
+   * @param key - Cache key
+   * @param compute - Function to compute value if not in cache
+   * @param ttl - Optional custom TTL for this entry
+   * @returns Cached or computed value
+   */
+  async getOrCompute(key, compute, ttl) {
+    const cached = this.get(key);
+    if (cached !== null) {
+      return cached;
+    }
+    const existing = this.inflight.get(key);
+    if (existing) {
+      return existing;
+    }
+    const computePromise = (async () => {
+      try {
+        const value = await compute();
+        this.set(key, value, ttl);
+        return value;
+      } finally {
+        this.inflight.delete(key);
+      }
+    })();
+    this.inflight.set(key, computePromise);
+    return computePromise;
+  }
+  /**
+   * Get or compute value with Result wrapper
+   */
+  async getOrComputeResult(key, compute, ttl) {
+    const cached = this.get(key);
+    if (cached !== null) {
+      return success(cached);
+    }
+    const existing = this.inflightResult.get(key);
+    if (existing) {
+      return existing;
+    }
+    const computePromise = (async () => {
+      try {
+        return await compute();
+      } finally {
+        this.inflightResult.delete(key);
+      }
+    })();
+    this.inflightResult.set(key, computePromise);
+    const result = await computePromise;
+    if (result.success) {
+      this.set(key, result.value, ttl);
+    }
+    return result;
   }
 };
 var CacheManager = class {
   caches = /* @__PURE__ */ new Map();
-  debug;
-  constructor(config = {}) {
-    this.debug = config.debug || false;
+  globalConfig;
+  constructor(globalConfig = {}) {
+    this.globalConfig = globalConfig;
   }
   /**
-   * Get or create a cache instance
+   * Create or get a named cache
+   *
+   * @param name - Unique cache name
+   * @param config - Optional cache-specific configuration
+   * @returns LRU cache instance
    */
   getCache(name, config) {
-    if (this.caches.has(name)) {
-      return this.caches.get(name);
+    const existingCache = this.caches.get(name);
+    if (existingCache) {
+      return existingCache;
     }
-    const cache = new Cache(config);
+    const mergedConfig = {
+      ...this.globalConfig,
+      ...config,
+      name
+    };
+    const cache = new LRUCache(mergedConfig);
     this.caches.set(name, cache);
-    if (this.debug) {
-      console.log(`[CacheManager] Created cache: ${name}`, config);
-    }
     return cache;
   }
   /**
@@ -109937,11 +110220,11 @@ var CacheManager = class {
    * Clean expired entries from all caches
    */
   cleanAllExpired() {
-    let total = 0;
+    let totalCleaned = 0;
     for (const cache of this.caches.values()) {
-      total += cache.cleanExpired();
+      totalCleaned += cache.cleanExpired();
     }
-    return total;
+    return totalCleaned;
   }
   /**
    * Get statistics for all caches
@@ -109954,11 +110237,16 @@ var CacheManager = class {
     return stats;
   }
   /**
-   * Destroy cache manager
+   * Get list of all cache names
    */
-  destroy() {
-    this.clearAll();
-    this.caches.clear();
+  getCacheNames() {
+    return Array.from(this.caches.keys());
+  }
+  /**
+   * Delete a named cache
+   */
+  deleteCache(name) {
+    return this.caches.delete(name);
   }
 };
 function createCacheManager(config) {
@@ -118451,12 +118739,11 @@ var DiamondHandsSDK = class _DiamondHandsSDK {
             {}
           );
         }
-        try {
-          return await this._requestMintUCDAttempt(request);
-        } catch (error2) {
-          const errorMsg = error2.message || String(error2);
+        const result = await this._requestMintUCDAttempt(request);
+        if (!result.success && fullRetry < MAX_FULL_RETRIES) {
+          const errorMsg = result.error || "";
           const isStaleTimestamp = errorMsg.includes("quantumTimestamp too old") || errorMsg.includes("Timestamp staleness") || errorMsg.includes("MAX_SKEW") || errorMsg.includes("Quantum window expired") || errorMsg.includes("Too close to quantum boundary") || errorMsg.includes("QuantumOutsideWindow") || errorMsg.includes("Quantum window remaining too low");
-          if (isStaleTimestamp && fullRetry < MAX_FULL_RETRIES) {
+          if (isStaleTimestamp) {
             if (this.config.debug) {
               log.warn(
                 `\u26A0\uFE0F  Timestamp became stale during mint process. Retrying from beginning...`,
@@ -118466,8 +118753,8 @@ var DiamondHandsSDK = class _DiamondHandsSDK {
             await new Promise((resolve) => setTimeout(resolve, 2e3));
             continue;
           }
-          throw error2;
         }
+        return result;
       }
       return {
         success: false,
@@ -119089,6 +119376,7 @@ Context: Quantum timestamp=${validationResponse.timestamp}, Position=${request.p
             "0x131d9a21": "QuantumExpired()",
             "0x52ce5d58": "QuantumAlreadyUsed()",
             "0x137f3b70": "InDeadZone()",
+            "0xbe4b82c1": "DeadZoneViolation()",
             "0x3e76a3c9": "QuantumOutsideWindow()",
             "0x62278171": "InvalidValidatorSignature()",
             "0xb9d419a7": "DebtUpdateVerificationFailed()",
@@ -119109,7 +119397,7 @@ Mint/debt diagnostics (LoanOperationsManager mint path \u2192 increaseDebtFromMi
   Contract expects UCD supply increase to match mintAmount+mintFee and debt update to newDebt.
 ` : "";
           let quantumContext = "";
-          if (selector === "0x131d9a21" || selector === "0x52ce5d58" || selector === "0x137f3b70" || selector === "0x3e76a3c9") {
+          if (selector === "0x131d9a21" || selector === "0x52ce5d58" || selector === "0x137f3b70" || selector === "0xbe4b82c1" || selector === "0x3e76a3c9") {
             const currentTime2 = Math.floor(Date.now() / 1e3);
             const currentQuantum = Math.floor(currentTime2 / 60) * 60;
             const sigQuantum2 = Math.floor(validationResponse.timestamp / 60) * 60;
@@ -119371,6 +119659,7 @@ Position: ${request.positionId}`
         validationResponse.timestamp,
         signatureHexMint
       ]);
+      await awaitSafeSubmissionWindow(Number(validationResponse.timestamp));
       const fromAddress = await signer.getAddress();
       const estimatedGas = await estimateContractCallGasWithMargin(
         signerProvider,
@@ -119429,6 +119718,7 @@ Position: ${request.positionId}`
               "0x131d9a21": "QuantumExpired()",
               "0x52ce5d58": "QuantumAlreadyUsed()",
               "0x137f3b70": "InDeadZone()",
+              "0xbe4b82c1": "DeadZoneViolation()",
               "0x3e76a3c9": "QuantumOutsideWindow()",
               "0x62278171": "InvalidValidatorSignature()",
               "0xb9d419a7": "DebtUpdateVerificationFailed()",
@@ -119608,6 +119898,7 @@ Error data: ${errorData || "none"}`
           "0x131d9a21": "QuantumExpired() - Signature quantum window has closed",
           "0x52ce5d58": "QuantumAlreadyUsed() - This quantum was already used for this position",
           "0x137f3b70": "InDeadZone() - Timestamp in dead zone (near quantum boundary)",
+          "0xbe4b82c1": "DeadZoneViolation() - Non-current-quantum signature mined in the last 8s of the current quantum",
           "0x3e76a3c9": "QuantumOutsideWindow() - Timestamp not in past/current/next quantum window"
         };
         const errorName = knownErrors[selector] || `Unknown error ${selector}`;
@@ -120676,6 +120967,7 @@ Error data: ${errorData || "none"}`
       );
     }
     const positionManager = positionManagerResult.value;
+    await awaitSafeSubmissionWindow(Number(quantumTimestamp));
     const tx = await positionManager["extendPosition"](
       positionIdBytes32,
       BigInt(_selectedTerm),
@@ -121108,6 +121400,57 @@ Error data: ${errorData || "none"}`
       if (!pauseCheck.ok) {
         return { success: false, error: pauseCheck.error };
       }
+      const MAX_FULL_RETRIES = 3;
+      for (let fullRetry = 1; fullRetry <= MAX_FULL_RETRIES; fullRetry++) {
+        if (fullRetry > 1 && this.config.debug) {
+          log.info(
+            `\u{1F504} Full payment retry ${fullRetry}/${MAX_FULL_RETRIES} due to quantum-timing failure...`,
+            {}
+          );
+        }
+        const result = await this._makePaymentAttempt(request);
+        if (fullRetry < MAX_FULL_RETRIES && this.isRetryablePaymentQuantumFailure(result)) {
+          await new Promise((resolve) => setTimeout(resolve, 2e3));
+          continue;
+        }
+        return result;
+      }
+      return {
+        success: false,
+        error: "Max retries exceeded for payment operation"
+      };
+    } finally {
+      this.invalidateCachesForPosition(request.positionId);
+      this.releaseWriteLock(request.positionId);
+    }
+  }
+  /**
+   * Whether a failed payment attempt is a quantum-timing failure that a fresh
+   * re-sign can fix (safe to retry), versus a terminal failure.
+   *
+   * Retryable: pre-send simulation quantum errors, or an atomic mined revert
+   * (status 0) — no funds moved and the quantum was not recorded on-chain, so a
+   * fresh signature + resubmit is safe.
+   *
+   * NOT retryable: a confirmation timeout — the original tx may still be pending, so
+   * a resubmit could double-pay. It is surfaced (with its tx hash) instead.
+   */
+  isRetryablePaymentQuantumFailure(result) {
+    if (result.success || !result.error)
+      return false;
+    const e = result.error;
+    if (e.includes("Transaction timeout"))
+      return false;
+    return e.includes("DeadZoneViolation") || e.includes("QuantumOutsideWindow") || e.includes("QuantumAlreadyUsed") || e.includes("QuantumExpired") || e === "Transaction reverted";
+  }
+  /**
+   * One payment attempt: user auth → Lit Action authorization → dead-zone gate →
+   * pre-send simulation → broadcast → confirmation. Always resolves to a
+   * PartialPaymentResult (never throws to the caller); the makePayment wrapper owns
+   * the write lock, the pause pre-check, and the bounded re-sign retry loop.
+   */
+  async _makePaymentAttempt(request) {
+    try {
       if (this.config.debug) {
         log.info(`\u{1F4B3} Making payment...`, {});
         log.info(`   Request object:`, { request });
@@ -121368,7 +121711,6 @@ Error data: ${errorData || "none"}`
           error: `Failed to get PositionManager: ${positionManagerResult.error.message}`
         };
       }
-      const positionManager = positionManagerResult.value;
       if (this.config.debug) {
         log.info(
           `   About to call toBytes32 with: ${request.positionId} (type: ${typeof request.positionId})`
@@ -121428,9 +121770,6 @@ Error data: ${errorData || "none"}`
           currentQuantum
         });
       }
-      if (this.config.debug) {
-        log.info("\u23ED\uFE0F  Skipping dead zone check to isolate BigNumber issue", {});
-      }
       if (this.config.debug) {
         log.info("\u{1F50D} Final timestamp validation:", {
           litActionTimestamp: litActionResult.timestamp,
@@ -121497,108 +121836,100 @@ Error data: ${errorData || "none"}`
           quantumTimestamp: quantumTimestamp.toString()
         });
       }
-      let tx;
-      try {
-        if (this.config.debug) {
-          log.info("\u{1F50D} Attempting contract interface call to makePayment");
-        }
-        if (this.config.debug) {
-          log.info("\u{1F50D} Contract call parameters:", {
-            positionIdBytes32,
-            paymentAmountWei: paymentAmountWei.toString(),
-            quantumTimestamp: quantumTimestamp.toString(),
-            btcPrice: btcPrice.toString(),
-            signatureLength: signature.length
-          });
-        }
-        if (typeof quantumTimestamp !== "bigint") {
-          throw new Error(
-            `quantumTimestamp is not a BigInt: ${typeof quantumTimestamp}, value: ${quantumTimestamp}`
-          );
-        }
-        if (typeof btcPrice !== "bigint") {
-          throw new Error(
-            `btcPrice is not a BigInt: ${typeof btcPrice}, value: ${btcPrice}`
-          );
-        }
-        if (typeof paymentAmountWei !== "bigint") {
-          throw new Error(
-            `paymentAmountWei is not a BigNumber: ${typeof paymentAmountWei}, value: ${paymentAmountWei}`
-          );
-        }
-        const paymentAmountStr = paymentAmountWei.toString();
-        const quantumTimestampStr = quantumTimestamp.toString();
-        const btcPriceStr = btcPrice.toString();
-        if (this.config.debug) {
-          log.info("\u{1F50D} About to call contract makePayment with:", {
-            positionIdBytes32: positionIdBytes32.substring(0, 20) + "...",
-            paymentAmountWei: paymentAmountStr,
-            quantumTimestamp: quantumTimestampStr,
-            btcPrice: btcPriceStr,
-            signature: signature.substring(0, 20) + "..."
-          });
-        }
-        if (typeof paymentAmountStr !== "string" || paymentAmountStr === "[object Object]") {
-          throw new Error(`Invalid paymentAmount: ${paymentAmountStr}`);
-        }
-        if (typeof quantumTimestampStr !== "string" || quantumTimestampStr === "[object Object]") {
-          throw new Error(`Invalid quantumTimestamp: ${quantumTimestampStr}`);
-        }
-        if (typeof btcPriceStr !== "string" || btcPriceStr === "[object Object]") {
-          throw new Error(`Invalid btcPrice: ${btcPriceStr}`);
-        }
-        if (this.config.debug) {
-          log.info("\u{1F50D} Final parameter validation before contract call:", {
-            positionIdBytes32: typeof positionIdBytes32,
-            paymentAmountStr: typeof paymentAmountStr + " = " + paymentAmountStr.substring(0, 20),
-            quantumTimestampStr: typeof quantumTimestampStr + " = " + quantumTimestampStr.substring(0, 20),
-            btcPriceStr: typeof btcPriceStr + " = " + btcPriceStr.substring(0, 20),
-            signature: typeof signature + " = " + signature.substring(0, 20)
+      await awaitSafeSubmissionWindow(Number(quantumTimestamp));
+      const paymentAmountStr = paymentAmountWei.toString();
+      const quantumTimestampStr = quantumTimestamp.toString();
+      const btcPriceStr = btcPrice.toString();
+      const paymentContractAddress = this.getContractAddressesOrThrow().positionManager;
+      const paymentSigner = this.getSignerOrThrow();
+      const paymentFrom = await paymentSigner.getAddress();
+      const paymentProvider = contractManager.getProvider();
+      const paymentIface = new Interface([
+        "function makePayment(bytes32 positionId, uint256 paymentAmount, uint256 quantumTimestamp, uint256 btcPrice, bytes calldata paymentValidatorSignature) external returns (bool)"
+      ]);
+      const paymentCalldata = paymentIface.encodeFunctionData("makePayment", [
+        positionIdBytes32,
+        paymentAmountStr,
+        quantumTimestampStr,
+        btcPriceStr,
+        signature
+      ]);
+      const decodePaymentRevert = (e) => {
+        const raw = e?.data ?? e?.info?.error?.data ?? e?.error?.data?.data ?? e?.error?.data;
+        const data = typeof raw === "string" ? raw : void 0;
+        if (!data || !data.startsWith("0x") || data.length < 10)
+          return null;
+        const selector = data.slice(0, 10);
+        const map3 = {
+          "0xbe4b82c1": "DeadZoneViolation()",
+          "0x137f3b70": "InDeadZone()",
+          "0x52ce5d58": "QuantumAlreadyUsed()",
+          "0x3e76a3c9": "QuantumOutsideWindow()",
+          "0x131d9a21": "QuantumExpired()",
+          "0x8baa579f": "InvalidSignature()",
+          "0x62278171": "InvalidValidatorSignature()",
+          "0x3ee5aeb5": "OperationNotAuthorized()",
+          "0x48f5c3ed": "Unauthorized()"
+        };
+        return map3[selector] ?? `Unknown error ${selector}`;
+      };
+      const MAX_DEADZONE_RESIMULATIONS = 3;
+      for (let sim = 1; ; sim++) {
+        try {
+          await paymentProvider.call({
+            to: paymentContractAddress,
+            from: paymentFrom,
+            data: paymentCalldata
           });
-        }
-        tx = await positionManager["makePayment"](
-          positionIdBytes32,
-          paymentAmountStr,
-          quantumTimestampStr,
-          btcPriceStr,
-          signature
-        );
-        if (this.config.debug) {
-          log.info("\u2705 Contract call succeeded", { txHash: tx.hash });
-        }
-      } catch (contractError) {
-        if (this.config.debug) {
-          log.warn(
-            "\u26A0\uFE0F  Contract interface failed, falling back to raw transaction",
-            {
-              error: contractError instanceof Error ? contractError.message : String(contractError)
+          break;
+        } catch (simError) {
+          const decoded = decodePaymentRevert(simError);
+          if (decoded === "DeadZoneViolation()" && sim <= MAX_DEADZONE_RESIMULATIONS) {
+            const nowSec = Math.floor(Date.now() / 1e3);
+            const sigQuantum = Math.floor(Number(quantumTimestamp) / 60) * 60;
+            const realCurrentQuantum = Math.floor(nowSec / 60) * 60;
+            if (sigQuantum === realCurrentQuantum) {
+              if (this.config.debug) {
+                log.info(
+                  "\u21AA\uFE0F  Simulated DeadZoneViolation is a stale-latest-block artifact (signature is the current quantum) \u2014 proceeding to broadcast",
+                  {}
+                );
+              }
+              break;
             }
-          );
-        }
-        const contractAddress = this.getContractAddressesOrThrow().positionManager;
-        const iface = new Interface([
-          "function makePayment(bytes32 positionId, uint256 paymentAmount, uint256 quantumTimestamp, uint256 btcPrice, bytes calldata paymentValidatorSignature) external returns (bool)"
-        ]);
-        const calldata = iface.encodeFunctionData("makePayment", [
-          positionIdBytes32,
-          paymentAmountWei.toString(),
-          quantumTimestamp.toString(),
-          btcPrice.toString(),
-          signature
-        ]);
-        const signer2 = this.getSignerOrThrow();
-        tx = await signer2.sendTransaction({
-          to: contractAddress,
-          data: calldata,
-          value: "0x0",
-          gasLimit: 5e5
-        });
-        if (this.config.debug) {
-          log.info("\u2705 Raw transaction fallback succeeded", {
-            txHash: tx.hash
-          });
+            const gate = await awaitSafeSubmissionWindow(Number(quantumTimestamp));
+            if (gate.waited) {
+              if (this.config.debug) {
+                log.info(
+                  `\u{1F501} Re-simulating makePayment after crossing the quantum boundary (attempt ${sim}/${MAX_DEADZONE_RESIMULATIONS})`,
+                  {}
+                );
+              }
+              continue;
+            }
+          }
+          const label = decoded ?? simError?.reason ?? simError?.shortMessage ?? (simError instanceof Error ? simError.message : String(simError));
+          if (this.config.debug) {
+            log.error("\u274C makePayment pre-send simulation reverted", { error: label });
+          }
+          return {
+            success: false,
+            error: `Payment would revert (pre-send simulation): ${label}`,
+            positionId: request.positionId,
+            paymentAmountUCD: request.paymentAmount
+          };
         }
       }
+      const MAKE_PAYMENT_GAS_CEILING = 500000n;
+      const tx = await sendEip1559Transaction({
+        signer: paymentSigner,
+        to: paymentContractAddress,
+        data: paymentCalldata,
+        gasLimit: MAKE_PAYMENT_GAS_CEILING
+      });
+      if (this.config.debug) {
+        log.info("\u2705 makePayment broadcast", { txHash: tx.hash });
+      }
       if (this.config.debug) {
         log.info(`\u{1F4E4} Transaction sent: ${tx.hash}`);
         log.info("\u23F3 Waiting for transaction confirmation...");
@@ -121742,9 +122073,6 @@ Error data: ${errorData || "none"}`
         result.effectiveGasPrice = receipt.effectiveGasPrice?.toString() || receipt.gasPrice?.toString();
       }
       return result;
-    } finally {
-      this.invalidateCachesForPosition(request.positionId);
-      this.releaseWriteLock(request.positionId);
     }
   }
   /**
@@ -122306,6 +122634,7 @@ Error data: ${errorData || "none"}`
           utxoVout: withdrawalParams.utxoVout
         });
       }
+      await awaitSafeSubmissionWindow(Number(withdrawalParams.quantumTimestamp));
       let tx;
       try {
         tx = await positionManagerContract["withdrawBTC"](