@cfxdevkit/executor 0.1.0

package/dist/index.cjs

@@ -0,0 +1,860 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DEFAULT_SAFETY_CONFIG: () => DEFAULT_SAFETY_CONFIG,
+  Executor: () => Executor,
+  KeeperClientImpl: () => KeeperClientImpl,
+  PriceChecker: () => PriceChecker,
+  RetryQueue: () => RetryQueue,
+  SafetyGuard: () => SafetyGuard,
+  noopLogger: () => noopLogger
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/executor.ts
+var import_core = require("@cfxdevkit/core");
+var Executor = class {
+  priceChecker;
+  safetyGuard;
+  retryQueue;
+  keeperClient;
+  jobStore;
+  dryRun;
+  constructor(priceChecker, safetyGuard, retryQueue, keeperClient, jobStore, options = {}) {
+    this.priceChecker = priceChecker;
+    this.safetyGuard = safetyGuard;
+    this.retryQueue = retryQueue;
+    this.keeperClient = keeperClient;
+    this.jobStore = jobStore;
+    this.dryRun = options.dryRun ?? false;
+  }
+  /**
+   * Process a single job tick.
+   */
+  async processTick(job) {
+    if (job.expiresAt !== null && Date.now() >= job.expiresAt) {
+      import_core.logger.info(`[Executor] job ${job.id} expired`);
+      await this.jobStore.markExpired(job.id);
+      return;
+    }
+    try {
+      if (job.status === "pending") {
+        await this.jobStore.markActive(job.id);
+      }
+      if (job.type === "limit_order") {
+        await this._processLimitOrder(job);
+      } else if (job.type === "dca") {
+        await this._processDCA(job);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (message.includes("PriceConditionNotMet")) {
+        import_core.logger.debug(
+          `[Executor] job ${job.id}: price condition no longer met at execution time \u2014 will retry next tick`
+        );
+        return;
+      }
+      if (message.includes("DCAIntervalNotReached")) {
+        import_core.logger.debug(
+          `[Executor] job ${job.id}: DCA interval not yet reached at execution time \u2014 will retry next tick`
+        );
+        return;
+      }
+      if (message.includes("could not be found") || message.includes("TransactionReceiptNotFoundError")) {
+        import_core.logger.debug(
+          `[Executor] job ${job.id}: receipt not yet indexed \u2014 will retry next tick`
+        );
+        return;
+      }
+      if (message.includes("Slippage exceeded")) {
+        import_core.logger.debug(
+          `[Executor] job ${job.id}: slippage exceeded at execution time \u2014 will retry next tick`
+        );
+        await this.jobStore.incrementRetry(job.id);
+        await this.jobStore.updateLastError(job.id, message);
+        return;
+      }
+      if (err instanceof Error && err.cause) {
+        import_core.logger.error(
+          { cause: err.cause },
+          "[Executor] raw error cause"
+        );
+      }
+      if (message.includes("JobNotFound")) {
+        const ocId = job.onChainJobId;
+        import_core.logger.warn(
+          { jobId: job.id, onChainJobId: ocId },
+          "[Executor] JobNotFound \u2014 on_chain_job_id not found on current contract (likely left over from an old deployment) \u2014 marking cancelled"
+        );
+        await this.jobStore.markCancelled(job.id);
+        return;
+      }
+      if (message.includes("JobNotActive")) {
+        const ocId = job.onChainJobId;
+        let onChainStatus = "cancelled";
+        if (ocId) {
+          try {
+            onChainStatus = await this.keeperClient.getOnChainStatus(ocId);
+          } catch (statusErr) {
+            import_core.logger.warn(
+              { jobId: job.id, err: statusErr },
+              "[Executor] could not read on-chain status \u2014 defaulting to cancelled"
+            );
+          }
+        }
+        if (onChainStatus === "executed") {
+          import_core.logger.warn(
+            { jobId: job.id, onChainJobId: ocId },
+            "[Executor] job EXECUTED on-chain but DB was out of sync \u2014 marking executed"
+          );
+          await this.jobStore.markExecuted(job.id, "chain-sync");
+        } else {
+          import_core.logger.warn(
+            { jobId: job.id, onChainJobId: ocId, onChainStatus },
+            "[Executor] job is CANCELLED/EXPIRED on-chain \u2014 marking cancelled in DB"
+          );
+          await this.jobStore.markCancelled(job.id);
+        }
+        return;
+      }
+      import_core.logger.error(`[Executor] job ${job.id} failed: ${message}`);
+      const nextRetries = job.retries + 1;
+      if (job.retries < job.maxRetries) {
+        await this.jobStore.incrementRetry(job.id);
+      }
+      if (nextRetries < job.maxRetries) {
+        this.retryQueue.enqueue({ ...job, retries: nextRetries });
+      }
+      await this.jobStore.markFailed(job.id, message);
+    }
+  }
+  /**
+   * Process all active jobs + due retries in one tick.
+   */
+  async runAllTicks() {
+    const activeJobs = await this.jobStore.getActiveJobs();
+    const retries = this.retryQueue.drainDue();
+    const all = [...activeJobs, ...retries];
+    import_core.logger.info(
+      `[Executor] tick \u2013 ${activeJobs.length} active, ${retries.length} retries`
+    );
+    await Promise.allSettled(all.map((job) => this.processTick(job)));
+  }
+  // ─── Private ────────────────────────────────────────────────────────────────
+  async _processLimitOrder(job) {
+    const priceResult = await this.priceChecker.checkLimitOrder(job);
+    if (!priceResult.conditionMet) {
+      import_core.logger.info(
+        {
+          jobId: job.id,
+          currentPrice: priceResult.currentPrice.toString(),
+          targetPrice: priceResult.targetPrice.toString(),
+          direction: job.params.direction
+        },
+        `[Executor] limit-order ${job.id}: condition not met \u2013 waiting`
+      );
+      return;
+    }
+    const safetyResult = this.safetyGuard.check(job, {
+      swapUsd: priceResult.swapUsd
+    });
+    if (!safetyResult.ok) {
+      import_core.logger.warn(
+        { violation: safetyResult.violation },
+        `[Executor] limit-order ${job.id} blocked by safety guard`
+      );
+      return;
+    }
+    if (this.dryRun) {
+      import_core.logger.info(`[Executor][dryRun] would execute limit-order ${job.id}`);
+      return;
+    }
+    import_core.logger.info(`[Executor] executing limit-order ${job.id}`);
+    const onChainJobId = job.onChainJobId;
+    if (!onChainJobId) {
+      import_core.logger.warn(
+        `[Executor] limit-order ${job.id} has no onChainJobId \u2013 skipping until registered on-chain`
+      );
+      return;
+    }
+    const { txHash, amountOut } = await this.keeperClient.executeLimitOrder(
+      onChainJobId,
+      job.owner,
+      job.params
+    );
+    await this.jobStore.markExecuted(job.id, txHash, amountOut);
+    import_core.logger.info(`[Executor] limit-order ${job.id} executed \u2013 tx ${txHash}`);
+  }
+  async _processDCA(job) {
+    const priceResult = await this.priceChecker.checkDCA(job);
+    if (!priceResult.conditionMet) {
+      import_core.logger.info(
+        {
+          jobId: job.id,
+          nextExecution: job.params.nextExecution,
+          now: Date.now(),
+          secsRemaining: Math.round(
+            (job.params.nextExecution - Date.now()) / 1e3
+          )
+        },
+        `[Executor] DCA ${job.id}: interval not reached`
+      );
+      return;
+    }
+    const safetyResult = this.safetyGuard.check(job, {
+      swapUsd: priceResult.swapUsd
+    });
+    if (!safetyResult.ok) {
+      import_core.logger.warn(
+        { violation: safetyResult.violation },
+        `[Executor] DCA ${job.id} blocked by safety guard`
+      );
+      return;
+    }
+    if (this.dryRun) {
+      import_core.logger.info(`[Executor][dryRun] would execute DCA tick for ${job.id}`);
+      return;
+    }
+    import_core.logger.info(`[Executor] executing DCA tick ${job.id}`);
+    const onChainJobId = job.onChainJobId;
+    if (!onChainJobId) {
+      import_core.logger.warn(
+        `[Executor] DCA job ${job.id} has no onChainJobId \u2013 skipping until registered on-chain`
+      );
+      return;
+    }
+    const { txHash, amountOut, nextExecutionSec } = await this.keeperClient.executeDCATick(
+      onChainJobId,
+      job.owner,
+      job.params
+    );
+    const newSwapsCompleted = job.params.swapsCompleted + 1;
+    const nextExecutionMs = nextExecutionSec * 1e3;
+    await this.jobStore.markDCATick(
+      job.id,
+      txHash,
+      newSwapsCompleted,
+      nextExecutionMs,
+      amountOut
+    );
+    import_core.logger.info(
+      {
+        jobId: job.id,
+        txHash,
+        swapsCompleted: newSwapsCompleted,
+        total: job.params.totalSwaps
+      },
+      `[Executor] DCA tick executed \u2013 ${newSwapsCompleted}/${job.params.totalSwaps}`
+    );
+  }
+};
+
+// src/keeper-client.ts
+var import_core2 = require("@cfxdevkit/core");
+var import_protocol = require("@cfxdevkit/protocol");
+var import_viem = require("viem");
+var import_accounts = require("viem/accounts");
+function decodeAmountOut(logs, owner) {
+  const TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+  const ownerLower = owner.toLowerCase();
+  for (let i = logs.length - 1; i >= 0; i--) {
+    const log = logs[i];
+    if (log.topics[0]?.toLowerCase() === TRANSFER_TOPIC && log.topics[2] && `0x${log.topics[2].slice(26)}`.toLowerCase() === ownerLower) {
+      try {
+        return BigInt(log.data).toString();
+      } catch {
+        return null;
+      }
+    }
+  }
+  return null;
+}
+var KeeperClientImpl = class {
+  walletClient;
+  publicClient;
+  contractAddress;
+  swappiRouter;
+  maxGasPriceGwei;
+  rpcTimeoutMs;
+  account;
+  constructor(config) {
+    this.account = (0, import_accounts.privateKeyToAccount)(config.privateKey);
+    this.contractAddress = config.contractAddress;
+    this.swappiRouter = config.swappiRouter;
+    this.maxGasPriceGwei = config.maxGasPriceGwei ?? 1000n;
+    this.rpcTimeoutMs = config.rpcTimeoutMs ?? 12e4;
+    this.publicClient = (0, import_viem.createPublicClient)({
+      chain: config.chain,
+      transport: (0, import_viem.http)(config.rpcUrl)
+    });
+    this.walletClient = (0, import_viem.createWalletClient)({
+      chain: config.chain,
+      transport: (0, import_viem.http)(config.rpcUrl),
+      account: this.account
+    });
+  }
+  withTimeout(fn, timeoutMs = this.rpcTimeoutMs) {
+    const controller = new AbortController();
+    const id = setTimeout(() => controller.abort(), timeoutMs);
+    return fn(controller.signal).finally(() => clearTimeout(id));
+  }
+  // --------------------------------------------------------------------------
+  // Helpers
+  // --------------------------------------------------------------------------
+  /**
+   * Query the on-chain status of a job.
+   * Returns one of: 'active' | 'executed' | 'cancelled' | 'expired'.
+   * Throws if the contract call fails (e.g. job not found).
+   */
+  async getOnChainStatus(onChainJobId) {
+    const job = await this.withTimeout(
+      (_signal) => this.publicClient.readContract({
+        address: this.contractAddress,
+        abi: import_protocol.AUTOMATION_MANAGER_ABI,
+        functionName: "getJob",
+        args: [onChainJobId]
+      })
+    );
+    switch (job.status) {
+      case 0:
+        return "active";
+      case 1:
+        return "executed";
+      case 2:
+        return "cancelled";
+      case 3:
+        return "expired";
+      default:
+        return "cancelled";
+    }
+  }
+  /** Guard: abort if chain is paused or gas price is too high */
+  async preflightCheck() {
+    const isPaused = await this.withTimeout(
+      (_signal) => this.publicClient.readContract({
+        address: this.contractAddress,
+        abi: import_protocol.AUTOMATION_MANAGER_ABI,
+        functionName: "paused"
+      })
+    );
+    if (isPaused) {
+      throw new Error("AutomationManager is paused on-chain");
+    }
+    const gasPrice = await Promise.race([
+      this.publicClient.getGasPrice(),
+      new Promise(
+        (_, rej) => setTimeout(
+          () => rej(new Error("getGasPrice timeout")),
+          this.rpcTimeoutMs
+        )
+      )
+    ]);
+    const gasPriceGwei = gasPrice / 1000000000n;
+    if (gasPriceGwei > this.maxGasPriceGwei) {
+      throw new Error(
+        `Gas price ${gasPriceGwei} gwei exceeds cap ${this.maxGasPriceGwei} gwei`
+      );
+    }
+  }
+  /**
+   * Build minimal swap calldata for a token-in/token-out pair via Swappi.
+   *
+   * In a production keeper the calldata would be built via a DEX aggregator
+   * (e.g. OKX DEX API) to get optimal routing.  For the MVP we encode the
+   * simplest Swappi path: `swapExactTokensForTokens(amountIn, minOut, path, to, deadline)`.
+   *
+   * NOTE: The AutomationManager does NOT use this calldata for custody;
+   * it only uses it to call the router on behalf of the user's pre-approved allowance.
+   */
+  buildSwapCalldata(tokenIn, tokenOut, amountIn, minAmountOut, recipient) {
+    const selector = "38ed1739";
+    const deadline = BigInt(Math.floor(Date.now() / 1e3) + 1800);
+    const encode256 = (n) => n.toString(16).padStart(64, "0");
+    const encodeAddr = (a) => a.slice(2).toLowerCase().padStart(64, "0");
+    const pathOffset = (5 * 32).toString(16).padStart(64, "0");
+    const pathLength = encode256(2n);
+    const pathData = encodeAddr(tokenIn) + encodeAddr(tokenOut);
+    const calldata = "0x" + selector + encode256(amountIn) + encode256(minAmountOut) + pathOffset + encodeAddr(recipient) + encode256(deadline) + pathLength + pathData;
+    return calldata;
+  }
+  // --------------------------------------------------------------------------
+  // IKeeperClient interface implementation
+  // --------------------------------------------------------------------------
+  async executeLimitOrder(jobId, owner, params) {
+    await this.preflightCheck();
+    const amountIn = BigInt(params.amountIn);
+    const minAmountOut = 0n;
+    const swapCalldata = this.buildSwapCalldata(
+      params.tokenIn,
+      params.tokenOut,
+      amountIn,
+      minAmountOut,
+      owner
+    );
+    import_core2.logger.info(
+      {
+        jobId,
+        tokenIn: params.tokenIn,
+        tokenOut: params.tokenOut,
+        amountIn: params.amountIn
+      },
+      "[KeeperClient] executeLimitOrder"
+    );
+    try {
+      await this.withTimeout(
+        (_signal) => this.publicClient.simulateContract({
+          address: this.contractAddress,
+          abi: import_protocol.AUTOMATION_MANAGER_ABI,
+          functionName: "executeLimitOrder",
+          args: [jobId, this.swappiRouter, swapCalldata],
+          account: this.account.address
+        })
+      );
+    } catch (simErr) {
+      const msg = simErr instanceof Error ? simErr.message : String(simErr);
+      import_core2.logger.error(
+        { jobId, error: msg.slice(0, 500) },
+        "[KeeperClient] executeLimitOrder simulation reverted"
+      );
+      throw simErr;
+    }
+    const hash = await this.withTimeout(
+      (_signal) => this.walletClient.writeContract({
+        address: this.contractAddress,
+        abi: import_protocol.AUTOMATION_MANAGER_ABI,
+        functionName: "executeLimitOrder",
+        args: [jobId, this.swappiRouter, swapCalldata],
+        chain: void 0,
+        account: this.account
+      })
+    );
+    import_core2.logger.info({ jobId, hash }, "[KeeperClient] limitOrder tx submitted");
+    const receipt = await Promise.race([
+      this.publicClient.waitForTransactionReceipt({ hash }),
+      new Promise(
+        (_, rej) => setTimeout(
+          () => rej(new Error("waitForTransactionReceipt timeout")),
+          this.rpcTimeoutMs
+        )
+      )
+    ]);
+    if (receipt.status !== "success") {
+      let reason = hash ?? "unknown";
+      try {
+        await this.withTimeout(
+          (_signal) => this.publicClient.simulateContract({
+            address: this.contractAddress,
+            abi: import_protocol.AUTOMATION_MANAGER_ABI,
+            functionName: "executeLimitOrder",
+            args: [jobId, this.swappiRouter, swapCalldata],
+            account: this.account.address
+          })
+        );
+      } catch (simErr) {
+        if (simErr instanceof Error) reason = simErr.message;
+      }
+      throw new Error(`Limit order tx reverted: ${reason}`);
+    }
+    const amountOut = decodeAmountOut(receipt.logs, owner);
+    import_core2.logger.info(
+      { jobId, hash, blockNumber: receipt.blockNumber.toString(), amountOut },
+      "[KeeperClient] limitOrder confirmed"
+    );
+    return { txHash: hash, amountOut };
+  }
+  async executeDCATick(jobId, owner, params) {
+    await this.preflightCheck();
+    const onChainParams = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: import_protocol.AUTOMATION_MANAGER_ABI,
+      functionName: "getDCAJob",
+      args: [jobId]
+    });
+    const nowSec = BigInt(Math.floor(Date.now() / 1e3));
+    if (nowSec < onChainParams.nextExecution) {
+      throw new Error(
+        `DCAIntervalNotReached(${onChainParams.nextExecution}) \u2014 on-chain interval not reached yet (now=${nowSec}, next=${onChainParams.nextExecution}, remaining=${onChainParams.nextExecution - nowSec}s)`
+      );
+    }
+    const amountPerTick = BigInt(params.amountPerSwap);
+    const minAmountOut = 0n;
+    const swapCalldata = this.buildSwapCalldata(
+      params.tokenIn,
+      params.tokenOut,
+      amountPerTick,
+      minAmountOut,
+      owner
+    );
+    import_core2.logger.info(
+      {
+        jobId,
+        tokenIn: params.tokenIn,
+        tokenOut: params.tokenOut,
+        amountPerTick: params.amountPerSwap
+      },
+      "[KeeperClient] executeDCATick"
+    );
+    try {
+      await this.withTimeout(
+        (_signal) => this.publicClient.simulateContract({
+          address: this.contractAddress,
+          abi: import_protocol.AUTOMATION_MANAGER_ABI,
+          functionName: "executeDCATick",
+          args: [jobId, this.swappiRouter, swapCalldata],
+          account: this.account.address
+        })
+      );
+    } catch (simErr) {
+      const msg = simErr instanceof Error ? simErr.message : String(simErr);
+      import_core2.logger.error(
+        { jobId, error: msg.slice(0, 500) },
+        "[KeeperClient] executeDCATick simulation reverted"
+      );
+      throw simErr;
+    }
+    const hash = await this.withTimeout(
+      (_signal) => this.walletClient.writeContract({
+        address: this.contractAddress,
+        abi: import_protocol.AUTOMATION_MANAGER_ABI,
+        functionName: "executeDCATick",
+        args: [jobId, this.swappiRouter, swapCalldata],
+        chain: void 0,
+        account: this.account
+      })
+    );
+    import_core2.logger.info({ jobId, hash }, "[KeeperClient] dca tx submitted");
+    const receipt = await Promise.race([
+      this.publicClient.waitForTransactionReceipt({ hash }),
+      new Promise(
+        (_, rej) => setTimeout(
+          () => rej(new Error("waitForTransactionReceipt timeout")),
+          this.rpcTimeoutMs
+        )
+      )
+    ]);
+    if (receipt.status !== "success") {
+      let reason = hash ?? "unknown";
+      try {
+        await this.withTimeout(
+          (_signal) => this.publicClient.simulateContract({
+            address: this.contractAddress,
+            abi: import_protocol.AUTOMATION_MANAGER_ABI,
+            functionName: "executeDCATick",
+            args: [jobId, this.swappiRouter, swapCalldata],
+            account: this.account.address
+          })
+        );
+      } catch (simErr) {
+        if (simErr instanceof Error) reason = simErr.message;
+      }
+      throw new Error(`DCA tick tx reverted: ${reason}`);
+    }
+    const amountOut = decodeAmountOut(receipt.logs, owner);
+    const postTickParams = await this.publicClient.readContract({
+      address: this.contractAddress,
+      abi: import_protocol.AUTOMATION_MANAGER_ABI,
+      functionName: "getDCAJob",
+      args: [jobId]
+    });
+    const nextExecutionSec = Number(postTickParams.nextExecution);
+    import_core2.logger.info(
+      {
+        jobId,
+        hash,
+        blockNumber: receipt.blockNumber.toString(),
+        amountOut,
+        nextExecutionSec
+      },
+      "[KeeperClient] dca confirmed"
+    );
+    return { txHash: hash, amountOut, nextExecutionSec };
+  }
+};
+
+// src/logger.ts
+var noopLogger = {
+  info: () => {
+  },
+  warn: () => {
+  },
+  debug: () => {
+  },
+  error: () => {
+  }
+};
+
+// src/price-checker.ts
+var defaultDecimalsResolver = async () => 18;
+var PriceChecker = class {
+  source;
+  tokenPricesUsd;
+  /**
+   * Resolves a token's decimal count.  Called lazily when _estimateUsd needs
+   * to convert raw wei amounts into human-readable values.  The resolver may
+   * query the chain, a static map, or simply return 18.
+   */
+  getDecimals;
+  log;
+  constructor(source, tokenPricesUsd = /* @__PURE__ */ new Map(), logger3 = noopLogger, getDecimals = defaultDecimalsResolver) {
+    this.source = source;
+    this.tokenPricesUsd = tokenPricesUsd;
+    this.getDecimals = getDecimals;
+    this.log = logger3;
+  }
+  async checkLimitOrder(job) {
+    const params = job.params;
+    const currentPrice = await this.source.getPrice(
+      params.tokenIn,
+      params.tokenOut
+    );
+    const targetPrice = BigInt(params.targetPrice);
+    let conditionMet;
+    if (params.direction === "gte") {
+      conditionMet = currentPrice >= targetPrice;
+    } else {
+      conditionMet = currentPrice <= targetPrice;
+    }
+    const swapUsd = await this._estimateUsd(params.tokenIn, params.amountIn);
+    this.log.debug(
+      {
+        jobId: job.id,
+        currentPrice: currentPrice.toString(),
+        targetPrice: targetPrice.toString(),
+        conditionMet,
+        swapUsd
+      },
+      "[PriceChecker] limit-order check"
+    );
+    return { conditionMet, currentPrice, targetPrice, swapUsd };
+  }
+  async checkDCA(job) {
+    const params = job.params;
+    const DCA_EXECUTION_BUFFER_MS = 15e3;
+    const conditionMet = Date.now() >= params.nextExecution + DCA_EXECUTION_BUFFER_MS;
+    const currentPrice = await this.source.getPrice(
+      params.tokenIn,
+      params.tokenOut
+    );
+    const swapUsd = await this._estimateUsd(
+      params.tokenIn,
+      params.amountPerSwap
+    );
+    this.log.debug(
+      {
+        jobId: job.id,
+        nextExecution: params.nextExecution,
+        conditionMet,
+        swapUsd
+      },
+      "[PriceChecker] DCA check"
+    );
+    return { conditionMet, currentPrice, targetPrice: 0n, swapUsd };
+  }
+  updateTokenPrice(token, usdPrice) {
+    this.tokenPricesUsd.set(token.toLowerCase(), usdPrice);
+  }
+  async _estimateUsd(token, amountWei) {
+    const usdPerToken = this.tokenPricesUsd.get(token.toLowerCase()) ?? 0;
+    const decimals = await this.getDecimals(token);
+    const divisor = 10 ** decimals;
+    const amount = Number(BigInt(amountWei)) / divisor;
+    return amount * usdPerToken;
+  }
+};
+
+// src/retry-queue.ts
+var RetryQueue = class {
+  baseDelayMs;
+  maxDelayMs;
+  jitter;
+  log;
+  queue = /* @__PURE__ */ new Map();
+  constructor(options, logger3 = noopLogger) {
+    this.baseDelayMs = options?.baseDelayMs ?? 5e3;
+    this.maxDelayMs = options?.maxDelayMs ?? 3e5;
+    this.jitter = options?.jitter ?? 0.2;
+    this.log = logger3;
+  }
+  /** Enqueue a job for retry after a calculated backoff delay. */
+  enqueue(job) {
+    const existing = this.queue.get(job.id);
+    const attempt = existing ? existing.attempt + 1 : 0;
+    const delay = this._backoffDelay(attempt);
+    const nextRetryAt = Date.now() + delay;
+    this.queue.set(job.id, { job, nextRetryAt, attempt });
+    this.log.info(
+      `[RetryQueue] job ${job.id} enqueued, attempt=${attempt}, delay=${delay}ms`
+    );
+  }
+  /** Remove a job from the queue (e.g. after success or manual cancel). */
+  remove(jobId) {
+    this.queue.delete(jobId);
+  }
+  /** Return all jobs whose retry time has arrived; removes them from the queue. */
+  drainDue(now = Date.now()) {
+    const due = [];
+    for (const [jobId, entry] of this.queue) {
+      if (now >= entry.nextRetryAt) {
+        due.push(entry.job);
+        this.queue.delete(jobId);
+      }
+    }
+    return due;
+  }
+  size() {
+    return this.queue.size;
+  }
+  // ─── Private ──────────────────────────────────────────────────────
+  _backoffDelay(attempt) {
+    const exponential = this.baseDelayMs * 2 ** attempt;
+    const capped = Math.min(exponential, this.maxDelayMs);
+    const withJitter = capped * (1 + this.jitter * Math.random());
+    return Math.floor(withJitter);
+  }
+};
+
+// src/safety-guard.ts
+var DEFAULT_SAFETY_CONFIG = {
+  maxSwapUsd: 1e4,
+  maxSlippageBps: 500,
+  maxRetries: 5,
+  minExecutionIntervalSeconds: 30,
+  globalPause: false
+};
+var SafetyGuard = class {
+  config;
+  violations = [];
+  log;
+  constructor(config = {}, logger3 = noopLogger) {
+    this.config = { ...DEFAULT_SAFETY_CONFIG, ...config };
+    this.log = logger3;
+    this.log.info(
+      {
+        maxSwapUsd: this.config.maxSwapUsd,
+        maxSlippageBps: this.config.maxSlippageBps,
+        maxRetries: this.config.maxRetries,
+        globalPause: this.config.globalPause
+      },
+      "[SafetyGuard] initialized"
+    );
+  }
+  // ─── Core check ───────────────────────────────────────────────────
+  /**
+   * Run all configured safety checks against a job.
+   * Returns `{ ok: true }` if all pass, or `{ ok: false, violation }` on first failure.
+   */
+  check(job, context) {
+    const now = context.currentTime ?? Date.now();
+    if (this.config.globalPause) {
+      return this._fail(
+        job.id,
+        "globalPause",
+        "Global pause is active \u2014 all execution halted"
+      );
+    }
+    if (job.status !== "active" && job.status !== "pending") {
+      return this._fail(
+        job.id,
+        "globalPause",
+        `Job ${job.id} cannot be executed (status: ${job.status})`
+      );
+    }
+    if (job.retries >= job.maxRetries) {
+      return this._fail(
+        job.id,
+        "maxRetries",
+        `Job ${job.id} has exhausted retries (${job.retries}/${job.maxRetries})`
+      );
+    }
+    if (context.swapUsd > this.config.maxSwapUsd) {
+      return this._fail(
+        job.id,
+        "maxSwapUsd",
+        `Swap value $${context.swapUsd.toFixed(2)} exceeds limit $${this.config.maxSwapUsd}`
+      );
+    }
+    if (job.expiresAt !== null && now >= job.expiresAt) {
+      return this._fail(job.id, "globalPause", `Job ${job.id} has expired`);
+    }
+    if (job.type === "dca") {
+      const dcaParams = job.params;
+      if (now < dcaParams.nextExecution) {
+        const waitSec = Math.ceil((dcaParams.nextExecution - now) / 1e3);
+        return this._fail(
+          job.id,
+          "minExecutionIntervalSeconds",
+          `DCA interval not yet reached (${waitSec}s remaining)`
+        );
+      }
+    }
+    return { ok: true };
+  }
+  // ─── Config management ────────────────────────────────────────────
+  updateConfig(patch) {
+    this.config = { ...this.config, ...patch };
+    this.log.info(patch, "[SafetyGuard] config updated");
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  pauseAll() {
+    this.config.globalPause = true;
+    this.log.warn("[SafetyGuard] GLOBAL PAUSE ACTIVATED");
+  }
+  resumeAll() {
+    this.config.globalPause = false;
+    this.log.info("[SafetyGuard] global pause lifted");
+  }
+  isPaused() {
+    return this.config.globalPause;
+  }
+  // ─── Audit log ────────────────────────────────────────────────────
+  getViolations() {
+    return this.violations;
+  }
+  clearViolations() {
+    this.violations = [];
+  }
+  // ─── Private ──────────────────────────────────────────────────────
+  _fail(jobId, rule, detail) {
+    const violation = {
+      jobId,
+      rule,
+      detail,
+      timestamp: Date.now()
+    };
+    this.violations.push(violation);
+    this.log.warn({ jobId, detail }, `[SafetyGuard] violation \u2013 ${rule}`);
+    return { ok: false, violation };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_SAFETY_CONFIG,
+  Executor,
+  KeeperClientImpl,
+  PriceChecker,
+  RetryQueue,
+  SafetyGuard,
+  noopLogger
+});
+//# sourceMappingURL=index.cjs.map