kontext-sdk 0.9.0 → 0.10.0

package/dist/index.js

@@ -1,8 +1,8 @@
 'use strict';
 
 var crypto$1 = require('crypto');
-var fs4 = require('fs');
-var path4 = require('path');
+var fs5 = require('fs');
+var path5 = require('path');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -22,8 +22,8 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var fs4__namespace = /*#__PURE__*/_interopNamespace(fs4);
-var path4__namespace = /*#__PURE__*/_interopNamespace(path4);
+var fs5__namespace = /*#__PURE__*/_interopNamespace(fs5);
+var path5__namespace = /*#__PURE__*/_interopNamespace(path5);
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -1974,13 +1974,13 @@ var ActionLogger = class {
   }
   flushToFile(actions) {
     const outputDir = this.config.localOutputDir ?? ".kontext";
-    const logDir = path4__namespace.join(outputDir, "logs");
+    const logDir = path5__namespace.join(outputDir, "logs");
     try {
-      fs4__namespace.mkdirSync(logDir, { recursive: true });
+      fs5__namespace.mkdirSync(logDir, { recursive: true });
       const filename = `actions-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.jsonl`;
-      const filePath = path4__namespace.join(logDir, filename);
+      const filePath = path5__namespace.join(logDir, filename);
       const lines = actions.map((a) => JSON.stringify(a)).join("\n") + "\n";
-      fs4__namespace.appendFileSync(filePath, lines, "utf-8");
+      fs5__namespace.appendFileSync(filePath, lines, "utf-8");
     } catch (error) {
       this.emitLog("warn", "Failed to write log file", { error });
     }
@@ -2590,9 +2590,9 @@ var SANCTIONED_SET = new Set(
 function loadCachedSDN() {
   try {
     const dataDir = process.env["KONTEXT_DATA_DIR"] || ".kontext";
-    const cachePath = path4__namespace.join(dataDir, "ofac-sdn-cache.json");
-    if (fs4__namespace.existsSync(cachePath)) {
-      const cache = JSON.parse(fs4__namespace.readFileSync(cachePath, "utf-8"));
+    const cachePath = path5__namespace.join(dataDir, "ofac-sdn-cache.json");
+    if (fs5__namespace.existsSync(cachePath)) {
+      const cache = JSON.parse(fs5__namespace.readFileSync(cachePath, "utf-8"));
       if (Array.isArray(cache.addresses)) {
         for (const addr of cache.addresses) {
           SANCTIONED_SET.add(String(addr).toLowerCase());
@@ -3713,7 +3713,7 @@ var JsonFileExporter = class {
   buffer = [];
   bufferSize;
   constructor(options) {
-    this.outputDir = path4__namespace.resolve(options?.outputDir ?? ".kontext/exports");
+    this.outputDir = path5__namespace.resolve(options?.outputDir ?? ".kontext/exports");
     this.bufferSize = options?.bufferSize ?? 1;
   }
   async export(events) {
@@ -3728,11 +3728,11 @@ var JsonFileExporter = class {
     const toWrite = [...this.buffer];
     this.buffer = [];
     try {
-      fs4__namespace.mkdirSync(this.outputDir, { recursive: true });
+      fs5__namespace.mkdirSync(this.outputDir, { recursive: true });
       const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-      const filePath = path4__namespace.join(this.outputDir, `events-${date}.jsonl`);
+      const filePath = path5__namespace.join(this.outputDir, `events-${date}.jsonl`);
       const lines = toWrite.map((e) => JSON.stringify(e)).join("\n") + "\n";
-      fs4__namespace.appendFileSync(filePath, lines, "utf-8");
+      fs5__namespace.appendFileSync(filePath, lines, "utf-8");
     } catch (error) {
       console.warn("[Kontext JsonFileExporter] Failed to write events:", error);
     }
@@ -3902,6 +3902,218 @@ function extractDocumentId(resourceName) {
   const parts = resourceName.split("/");
   return parts[parts.length - 1] ?? resourceName;
 }
+var CONFIG_FILENAME = "kontext.config.json";
+function loadConfigFile(startDir) {
+  const dir = startDir ?? process.cwd();
+  const filePath = findConfigFile(dir);
+  if (!filePath) return null;
+  try {
+    const raw = fs5__namespace.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.projectId || typeof parsed.projectId !== "string") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function findConfigFile(dir) {
+  let current = path5__namespace.resolve(dir);
+  const root = path5__namespace.parse(current).root;
+  while (true) {
+    const candidate = path5__namespace.join(current, CONFIG_FILENAME);
+    if (fs5__namespace.existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = path5__namespace.dirname(current);
+    if (parent === current || current === root) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+// src/integrations/data/stablecoin-contracts.ts
+var STABLECOIN_CONTRACTS = {
+  // USDC (6 decimals)
+  "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48": { token: "USDC", chain: "ethereum", decimals: 6 },
+  "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913": { token: "USDC", chain: "base", decimals: 6 },
+  "0x3c499c542cef5e3811e1192ce70d8cc03d5c3359": { token: "USDC", chain: "polygon", decimals: 6 },
+  "0xaf88d065e77c8cc2239327c5edb3a432268e5831": { token: "USDC", chain: "arbitrum", decimals: 6 },
+  "0x0b2c639c533813f4aa9d7837caf62653d097ff85": { token: "USDC", chain: "optimism", decimals: 6 },
+  "0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e": { token: "USDC", chain: "avalanche", decimals: 6 },
+  // USDT (6 decimals)
+  "0xdac17f958d2ee523a2206206994597c13d831ec7": { token: "USDT", chain: "ethereum", decimals: 6 },
+  "0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9": { token: "USDT", chain: "arbitrum", decimals: 6 },
+  "0x94b008aa00579c1307b0ef2c499ad98a8ce58e58": { token: "USDT", chain: "optimism", decimals: 6 },
+  "0xc2132d05d31c914a87c6611c10748aeb04b58e8f": { token: "USDT", chain: "polygon", decimals: 6 },
+  // DAI (18 decimals)
+  "0x6b175474e89094c44da98b954eedeac495271d0f": { token: "DAI", chain: "ethereum", decimals: 18 },
+  "0x50c5725949a6f0c72e6c4a641f24049a917db0cb": { token: "DAI", chain: "base", decimals: 18 },
+  // EURC (6 decimals)
+  "0x1abaea1f7c830bd89acc67ec4af516284b1bc33c": { token: "EURC", chain: "ethereum", decimals: 6 },
+  "0x60a3e35cc302bfa44cb288bc5a4f316fdb1adb42": { token: "EURC", chain: "base", decimals: 6 }
+};
+new Set(Object.keys(STABLECOIN_CONTRACTS));
+var CHAIN_ID_MAP = {
+  1: "ethereum",
+  8453: "base",
+  137: "polygon",
+  42161: "arbitrum",
+  10: "optimism",
+  43114: "avalanche"
+};
+var TRANSFER_SELECTOR = "0xa9059cbb";
+var TRANSFER_FROM_SELECTOR = "0x23b872dd";
+var TRANSFER_EVENT_ABI = {
+  type: "event",
+  name: "Transfer",
+  inputs: [
+    { type: "address", name: "from", indexed: true },
+    { type: "address", name: "to", indexed: true },
+    { type: "uint256", name: "value", indexed: false }
+  ]
+};
+
+// src/integrations/wallet-monitor.ts
+var WalletMonitor = class {
+  kontext;
+  config;
+  agentId;
+  tokens;
+  unwatchers = [];
+  running = false;
+  /** Shared dedup set — tracks recently verified txHashes (populated by both layers) */
+  verifiedTxHashes = /* @__PURE__ */ new Set();
+  cleanupTimer = null;
+  txTimestamps = /* @__PURE__ */ new Map();
+  constructor(kontext, config, options) {
+    this.kontext = kontext;
+    this.config = config;
+    this.agentId = options?.agentId ?? "wallet-monitor";
+    this.tokens = options?.tokens ? new Set(options.tokens) : null;
+  }
+  /**
+   * Mark a txHash as already verified (called by the viem interceptor layer).
+   * The monitor will skip this tx if it later sees it on-chain.
+   */
+  markVerified(txHash) {
+    const lower = txHash.toLowerCase();
+    this.verifiedTxHashes.add(lower);
+    this.txTimestamps.set(lower, Date.now());
+  }
+  /**
+   * Start watching all configured chains for stablecoin transfers.
+   * Dynamically imports viem — requires viem as a peer dependency.
+   */
+  async start() {
+    if (this.running) return;
+    let viem;
+    try {
+      viem = await import('viem');
+    } catch {
+      throw new Error(
+        "Wallet monitoring requires viem. Install it: npm install viem"
+      );
+    }
+    const { createPublicClient, http } = viem;
+    const wallets = this.config.wallets.map((w) => w.toLowerCase());
+    const pollingInterval = this.config.pollingIntervalMs ?? 12e3;
+    const contractsByChain = /* @__PURE__ */ new Map();
+    for (const [address, info] of Object.entries(STABLECOIN_CONTRACTS)) {
+      if (this.tokens && !this.tokens.has(info.token)) continue;
+      const existing = contractsByChain.get(info.chain) ?? [];
+      existing.push({ address, info });
+      contractsByChain.set(info.chain, existing);
+    }
+    for (const [chain, contracts] of contractsByChain) {
+      const rpcUrl = this.config.rpcEndpoints[chain];
+      if (!rpcUrl) continue;
+      const client = createPublicClient({
+        transport: http(rpcUrl)
+      });
+      for (const { address, info } of contracts) {
+        const unwatch = client.watchEvent({
+          address,
+          event: TRANSFER_EVENT_ABI,
+          args: { from: wallets.length === 1 ? wallets[0] : wallets },
+          poll: true,
+          pollingInterval,
+          onLogs: (logs) => {
+            for (const log of logs) {
+              this.handleTransferLog(log, info);
+            }
+          }
+        });
+        this.unwatchers.push(unwatch);
+      }
+    }
+    this.cleanupTimer = setInterval(() => {
+      const cutoff = Date.now() - 5 * 60 * 1e3;
+      for (const [hash, ts] of this.txTimestamps) {
+        if (ts < cutoff) {
+          this.verifiedTxHashes.delete(hash);
+          this.txTimestamps.delete(hash);
+        }
+      }
+    }, 6e4);
+    this.running = true;
+  }
+  /** Stop all watchers and cleanup */
+  stop() {
+    for (const unwatch of this.unwatchers) {
+      try {
+        unwatch();
+      } catch {
+      }
+    }
+    this.unwatchers.length = 0;
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+    this.running = false;
+  }
+  isRunning() {
+    return this.running;
+  }
+  handleTransferLog(log, contractInfo) {
+    const txHash = log.transactionHash;
+    if (!txHash) return;
+    const lowerHash = txHash.toLowerCase();
+    if (this.verifiedTxHashes.has(lowerHash)) return;
+    this.markVerified(txHash);
+    const from = log.args?.from?.toLowerCase() ?? "";
+    const to = log.args?.to?.toLowerCase() ?? "";
+    const value = log.args?.value;
+    if (!from || !to || value === void 0) return;
+    const amount = formatTokenAmount(value, contractInfo.decimals);
+    const verifyInput = {
+      txHash,
+      chain: contractInfo.chain,
+      amount,
+      token: contractInfo.token,
+      from,
+      to,
+      agentId: this.agentId,
+      metadata: {
+        source: "wallet-monitor",
+        contractAddress: log.address
+      }
+    };
+    this.kontext.verify(verifyInput).catch(() => {
+    });
+  }
+};
+function formatTokenAmount(amount, decimals) {
+  const divisor = BigInt(10 ** decimals);
+  const whole = amount / divisor;
+  const fraction = amount % divisor;
+  if (fraction === 0n) return whole.toString();
+  const fractionStr = fraction.toString().padStart(decimals, "0").replace(/0+$/, "");
+  return `${whole}.${fractionStr}`;
+}
 var ProvenanceManager = class {
   store;
   logger;
@@ -5436,6 +5648,7 @@ var Kontext = class _Kontext {
   trustScorer;
   anomalyDetector;
   screeningAggregator;
+  walletMonitor = null;
   provenanceManager = null;
   identityRegistry = null;
   walletClusterer = null;
@@ -5486,6 +5699,19 @@ var Kontext = class _Kontext {
         thresholds: config.anomalyThresholds
       });
     }
+    if (config.walletMonitoring && config.walletMonitoring.wallets.length > 0) {
+      const tokens = config.policy?.allowedTokens;
+      this.walletMonitor = new WalletMonitor(
+        this,
+        config.walletMonitoring,
+        { agentId: config.agentId, tokens: tokens ?? void 0 }
+      );
+      this.walletMonitor.start().catch((err) => {
+        if (config.debug) {
+          console.debug(`[Kontext] Wallet monitor failed to start: ${err}`);
+        }
+      });
+    }
   }
   /**
    * Initialize the Kontext SDK.
@@ -5517,6 +5743,29 @@ var Kontext = class _Kontext {
    * ```
    */
   static init(config) {
+    if (!config) {
+      const fileConfig = loadConfigFile();
+      if (!fileConfig) {
+        throw new KontextError(
+          "INITIALIZATION_ERROR" /* INITIALIZATION_ERROR */,
+          "No config provided and no kontext.config.json found. Run `npx kontext init` to create one, or pass config to Kontext.init()."
+        );
+      }
+      const mapped = {
+        projectId: fileConfig.projectId,
+        environment: fileConfig.environment ?? "production",
+        apiKey: fileConfig.apiKey,
+        agentId: fileConfig.agentId,
+        interceptorMode: fileConfig.mode,
+        policy: {
+          allowedTokens: fileConfig.tokens,
+          corridors: fileConfig.corridors?.from ? { blocked: fileConfig.corridors.to ? [{ from: fileConfig.corridors.from, to: fileConfig.corridors.to }] : void 0 } : void 0,
+          thresholds: fileConfig.thresholds ? { edd: fileConfig.thresholds.alertAmount ? Number(fileConfig.thresholds.alertAmount) : void 0 } : void 0
+        },
+        walletMonitoring: fileConfig.wallets && fileConfig.wallets.length > 0 && fileConfig.rpcEndpoints ? { wallets: fileConfig.wallets, rpcEndpoints: fileConfig.rpcEndpoints } : void 0
+      };
+      return _Kontext.init(mapped);
+    }
     if (!config.projectId || config.projectId.trim() === "") {
       throw new KontextError(
         "INITIALIZATION_ERROR" /* INITIALIZATION_ERROR */,
@@ -6697,9 +6946,20 @@ var Kontext = class _Kontext {
   // Lifecycle
   // --------------------------------------------------------------------------
   /**
-   * Gracefully shut down the SDK, flushing any pending data.
+   * Get the wallet monitor instance (or null if not configured).
+   * Used by the viem interceptor for dedup registration.
+   */
+  getWalletMonitor() {
+    return this.walletMonitor;
+  }
+  /**
+   * Gracefully shut down the SDK, flushing any pending data and stopping watchers.
    */
   async destroy() {
+    if (this.walletMonitor) {
+      this.walletMonitor.stop();
+      this.walletMonitor = null;
+    }
     await this.logger.destroy();
     await this.exporter.shutdown();
   }
@@ -6729,20 +6989,20 @@ var MemoryStorage = class {
 var FileStorage = class {
   baseDir;
   constructor(baseDir) {
-    this.baseDir = path4__namespace.resolve(baseDir);
+    this.baseDir = path5__namespace.resolve(baseDir);
   }
   async save(key, data) {
-    fs4__namespace.mkdirSync(this.baseDir, { recursive: true });
+    fs5__namespace.mkdirSync(this.baseDir, { recursive: true });
     const filePath = this.keyToPath(key);
-    const dir = path4__namespace.dirname(filePath);
-    fs4__namespace.mkdirSync(dir, { recursive: true });
-    fs4__namespace.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+    const dir = path5__namespace.dirname(filePath);
+    fs5__namespace.mkdirSync(dir, { recursive: true });
+    fs5__namespace.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
   }
   async load(key) {
     const filePath = this.keyToPath(key);
-    if (!fs4__namespace.existsSync(filePath)) return null;
+    if (!fs5__namespace.existsSync(filePath)) return null;
     try {
-      const raw = fs4__namespace.readFileSync(filePath, "utf-8");
+      const raw = fs5__namespace.readFileSync(filePath, "utf-8");
       return JSON.parse(raw);
     } catch {
       return null;
@@ -6750,12 +7010,12 @@ var FileStorage = class {
   }
   async delete(key) {
     const filePath = this.keyToPath(key);
-    if (fs4__namespace.existsSync(filePath)) {
-      fs4__namespace.unlinkSync(filePath);
+    if (fs5__namespace.existsSync(filePath)) {
+      fs5__namespace.unlinkSync(filePath);
     }
   }
   async list(prefix) {
-    if (!fs4__namespace.existsSync(this.baseDir)) return [];
+    if (!fs5__namespace.existsSync(this.baseDir)) return [];
     return this.listRecursive(this.baseDir, prefix);
   }
   /** Get the base directory path. */
@@ -6767,18 +7027,18 @@ var FileStorage = class {
   // --------------------------------------------------------------------------
   keyToPath(key) {
     const safeName = key.replace(/[<>"|?*]/g, "_");
-    return path4__namespace.join(this.baseDir, `${safeName}.json`);
+    return path5__namespace.join(this.baseDir, `${safeName}.json`);
   }
   pathToKey(filePath) {
-    const relative2 = path4__namespace.relative(this.baseDir, filePath);
+    const relative2 = path5__namespace.relative(this.baseDir, filePath);
     return relative2.replace(/\.json$/, "");
   }
   listRecursive(dir, prefix) {
     const keys = [];
-    if (!fs4__namespace.existsSync(dir)) return keys;
-    const entries = fs4__namespace.readdirSync(dir, { withFileTypes: true });
+    if (!fs5__namespace.existsSync(dir)) return keys;
+    const entries = fs5__namespace.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path4__namespace.join(dir, entry.name);
+      const fullPath = path5__namespace.join(dir, entry.name);
       if (entry.isDirectory()) {
         keys.push(...this.listRecursive(fullPath, prefix));
       } else if (entry.isFile() && entry.name.endsWith(".json")) {
@@ -7140,16 +7400,16 @@ var OpenSanctionsLocalProvider = class {
     this.addressSet.clear();
     this.addressToEntity.clear();
     try {
-      const fs5 = __require("fs");
+      const fs6 = __require("fs");
       const pathMod = __require("path");
       const dataPath = pathMod.resolve(this.dataDir);
-      if (!fs5.existsSync(dataPath)) return;
-      const files = fs5.readdirSync(dataPath).filter(
+      if (!fs6.existsSync(dataPath)) return;
+      const files = fs6.readdirSync(dataPath).filter(
         (f) => f.endsWith(".json")
       );
       for (const file of files) {
         const filePath = pathMod.join(dataPath, file);
-        const content = fs5.readFileSync(filePath, "utf-8");
+        const content = fs6.readFileSync(filePath, "utf-8");
         const lines = content.split("\n").filter((l) => l.trim());
         for (const line of lines) {
           try {
@@ -7500,9 +7760,202 @@ var ChainalysisOracleProvider = class {
   }
 };
 
+// src/integrations/viem-interceptor.ts
+var ViemComplianceError = class extends Error {
+  result;
+  from;
+  to;
+  amount;
+  constructor(message, result, details) {
+    super(message);
+    this.name = "ViemComplianceError";
+    this.result = result;
+    this.from = details.from;
+    this.to = details.to;
+    this.amount = details.amount;
+  }
+};
+function withKontextCompliance(client, kontext, options) {
+  const config = kontext.getConfig();
+  const agentId = options?.agentId ?? config.agentId ?? "viem-agent";
+  const mode = options?.mode ?? config.interceptorMode ?? "post-send";
+  const sessionId = options?.sessionId;
+  const metadata = options?.metadata;
+  const onVerify = options?.onVerify;
+  const onError = options?.onError;
+  const allowedTokens = options?.tokens ? new Set(options.tokens) : config.policy?.allowedTokens ? new Set(config.policy.allowedTokens) : null;
+  const allowedChains = options?.chains ? new Set(options.chains) : null;
+  const allowedContracts = /* @__PURE__ */ new Set();
+  for (const [address, info] of Object.entries(STABLECOIN_CONTRACTS)) {
+    if (allowedTokens && !allowedTokens.has(info.token)) continue;
+    if (allowedChains && !allowedChains.has(info.chain)) continue;
+    allowedContracts.add(address);
+  }
+  const monitor = kontext.getWalletMonitor?.() ?? null;
+  return client.extend((baseClient) => ({
+    async sendTransaction(params) {
+      const target = params.to?.toLowerCase();
+      if (!target || !allowedContracts.has(target)) {
+        return baseClient.sendTransaction(params);
+      }
+      const decoded = params.data ? decodeTransferCalldata(params.data) : null;
+      if (!decoded) {
+        return baseClient.sendTransaction(params);
+      }
+      const contractInfo = STABLECOIN_CONTRACTS[target];
+      const verifyInput = buildVerifyInput(
+        decoded,
+        contractInfo,
+        params,
+        baseClient,
+        agentId,
+        sessionId,
+        metadata
+      );
+      if (mode === "pre-send" || mode === "both") {
+        await runPreSendScreen(kontext, verifyInput);
+      }
+      const txHash = await baseClient.sendTransaction(params);
+      if (mode === "post-send" || mode === "both") {
+        monitor?.markVerified(txHash);
+        runPostSendVerify(kontext, { ...verifyInput, txHash }, txHash, onVerify, onError);
+      }
+      return txHash;
+    },
+    async writeContract(params) {
+      if (!baseClient.writeContract) {
+        throw new Error("writeContract not available on this client");
+      }
+      const target = params.address?.toLowerCase();
+      if (!target || !allowedContracts.has(target)) {
+        return baseClient.writeContract(params);
+      }
+      const fn = params.functionName;
+      if (fn !== "transfer" && fn !== "transferFrom") {
+        return baseClient.writeContract(params);
+      }
+      const decoded = decodeWriteContractArgs(fn, params.args);
+      if (!decoded) {
+        return baseClient.writeContract(params);
+      }
+      const contractInfo = STABLECOIN_CONTRACTS[target];
+      const verifyInput = buildVerifyInput(
+        decoded,
+        contractInfo,
+        params,
+        baseClient,
+        agentId,
+        sessionId,
+        metadata
+      );
+      if (mode === "pre-send" || mode === "both") {
+        await runPreSendScreen(kontext, verifyInput);
+      }
+      const txHash = await baseClient.writeContract(params);
+      if (mode === "post-send" || mode === "both") {
+        monitor?.markVerified(txHash);
+        runPostSendVerify(kontext, { ...verifyInput, txHash }, txHash, onVerify, onError);
+      }
+      return txHash;
+    }
+  }));
+}
+function buildVerifyInput(decoded, contractInfo, params, client, agentId, sessionId, metadata) {
+  const chain = client.chain?.id ? CHAIN_ID_MAP[client.chain.id] ?? contractInfo.chain : contractInfo.chain;
+  const from = (decoded.from ?? params.account?.address ?? client.account?.address ?? params.from ?? "").toLowerCase();
+  return {
+    txHash: "",
+    chain,
+    amount: formatTokenAmount2(decoded.amount, contractInfo.decimals),
+    token: contractInfo.token,
+    from,
+    to: decoded.to.toLowerCase(),
+    agentId,
+    sessionId,
+    metadata: {
+      ...metadata,
+      source: "viem-auto-instrumentation",
+      contractAddress: params.to ?? params.address
+    }
+  };
+}
+function runPostSendVerify(kontext, input, txHash, onVerify, onError) {
+  kontext.verify(input).then(
+    (result) => {
+      if (onVerify) {
+        try {
+          const p = onVerify(result, txHash);
+          if (p && typeof p.catch === "function") {
+            p.catch(() => {
+            });
+          }
+        } catch {
+        }
+      }
+    },
+    (error) => {
+      if (onError) {
+        try {
+          const p = onError(error, txHash);
+          if (p && typeof p.catch === "function") {
+            p.catch(() => {
+            });
+          }
+        } catch {
+        }
+      }
+    }
+  );
+}
+async function runPreSendScreen(kontext, input) {
+  const result = await kontext.verify({ ...input, txHash: "pre-screening" });
+  if (!result.compliant) {
+    throw new ViemComplianceError(
+      `Transaction blocked: ${result.recommendations?.[0] ?? "compliance check failed"}`,
+      result,
+      { from: input.from, to: input.to, amount: input.amount }
+    );
+  }
+}
+function decodeTransferCalldata(data) {
+  if (!data || data.length < 10) return null;
+  const selector = data.slice(0, 10).toLowerCase();
+  if (selector === TRANSFER_SELECTOR && data.length >= 138) {
+    const to = "0x" + data.slice(34, 74);
+    const amount = BigInt("0x" + data.slice(74, 138));
+    return { to, amount };
+  }
+  if (selector === TRANSFER_FROM_SELECTOR && data.length >= 202) {
+    const from = "0x" + data.slice(34, 74);
+    const to = "0x" + data.slice(98, 138);
+    const amount = BigInt("0x" + data.slice(138, 202));
+    return { from, to, amount };
+  }
+  return null;
+}
+function decodeWriteContractArgs(functionName, args) {
+  if (!args || !Array.isArray(args)) return null;
+  if (functionName === "transfer" && args.length >= 2) {
+    return { to: String(args[0]), amount: BigInt(args[1]) };
+  }
+  if (functionName === "transferFrom" && args.length >= 3) {
+    return { from: String(args[0]), to: String(args[1]), amount: BigInt(args[2]) };
+  }
+  return null;
+}
+function formatTokenAmount2(amount, decimals) {
+  const divisor = BigInt(10 ** decimals);
+  const whole = amount / divisor;
+  const fraction = amount % divisor;
+  if (fraction === 0n) return whole.toString();
+  const fractionStr = fraction.toString().padStart(decimals, "0").replace(/0+$/, "");
+  return `${whole}.${fractionStr}`;
+}
+
 exports.AgentIdentityRegistry = AgentIdentityRegistry;
 exports.AnomalyDetector = AnomalyDetector;
 exports.BehavioralFingerprinter = BehavioralFingerprinter;
+exports.CHAIN_ID_MAP = CHAIN_ID_MAP;
 exports.CURRENCY_REQUIRED_LISTS = CURRENCY_REQUIRED_LISTS;
 exports.ChainalysisFreeAPIProvider = ChainalysisFreeAPIProvider;
 exports.ChainalysisOracleProvider = ChainalysisOracleProvider;
@@ -7526,12 +7979,15 @@ exports.PLAN_LIMITS = PLAN_LIMITS;
 exports.PaymentCompliance = PaymentCompliance;
 exports.PlanManager = PlanManager;
 exports.ProvenanceManager = ProvenanceManager;
+exports.STABLECOIN_CONTRACTS = STABLECOIN_CONTRACTS;
 exports.ScreeningAggregator = ScreeningAggregator;
 exports.TOKEN_REQUIRED_LISTS = TOKEN_REQUIRED_LISTS;
 exports.TrustScorer = TrustScorer;
 exports.UKOFSIProvider = UKOFSIProvider;
 exports.UsdcCompliance = UsdcCompliance;
+exports.ViemComplianceError = ViemComplianceError;
 exports.WalletClusterer = WalletClusterer;
+exports.WalletMonitor = WalletMonitor;
 exports.anchorDigest = anchorDigest;
 exports.encodeERC8021Suffix = encodeERC8021Suffix;
 exports.exchangeAttestation = exchangeAttestation;
@@ -7542,10 +7998,12 @@ exports.getRequiredLists = getRequiredLists;
 exports.isBlockchainAddress = isBlockchainAddress;
 exports.isCryptoTransaction = isCryptoTransaction;
 exports.isFeatureAvailable = isFeatureAvailable;
+exports.loadConfigFile = loadConfigFile;
 exports.parseERC8021Suffix = parseERC8021Suffix;
 exports.providerSupportsQuery = providerSupportsQuery;
 exports.requirePlan = requirePlan;
 exports.verifyAnchor = verifyAnchor;
 exports.verifyExportedChain = verifyExportedChain;
+exports.withKontextCompliance = withKontextCompliance;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map