@general-liquidity/gordon-cli 0.75.12 → 0.75.13

package/dist/index.js

@@ -2783910,6 +2783910,3136 @@ var init_defillama_yields = __esm(() => {
   };
 });
 
+// src/infra/chainlink/types.ts
+function getRpcUrl(chainName) {
+  const envKey = `CHAINLINK_RPC_${chainName.toUpperCase()}`;
+  const envUrl = process.env[envKey];
+  if (envUrl)
+    return envUrl;
+  const defaultUrl = CHAIN_RPCS[chainName];
+  if (!defaultUrl) {
+    throw new Error(`Unknown chain "${chainName}". Supported: ${Object.keys(CHAIN_RPCS).join(", ")}`);
+  }
+  return defaultUrl;
+}
+var CHAINLINK_ENV_KEYS, STREAMS_BASE_URL = "https://api.dataengine.chain.link", STREAMS_FEED_IDS, FEED_SELECTORS, CHAIN_RPCS, FEED_DIRECTORY, CCIP_CHAINS, ERC20_APPROVE_ABI, CCIP_ROUTER_ABI;
+var init_types53 = __esm(() => {
+  CHAINLINK_ENV_KEYS = {
+    API_KEY: "CHAINLINK_API_KEY",
+    API_SECRET: "CHAINLINK_API_SECRET",
+    EVM_PRIVATE_KEY: "EVM_PRIVATE_KEY"
+  };
+  STREAMS_FEED_IDS = {
+    "BTC/USD": "0x00027bbaff688c906a3e20a34fe951715d1018d262a5b66e38eda027a674cd1b",
+    "ETH/USD": "0x000359843a543ee2fe414dc14c7e7920ef10f4372990b79d6361cdc0dd1ba782",
+    "SOL/USD": "0x000346b313b6252ed2b79e0ba23bbfa04bace3de5dec995baab3c0a8756e1e47",
+    "LINK/USD": "0x000322e3155c32334a8af4ec4f3ad6f2e0ee3b8fc9b5bba459f2c2f9e2ace1a3",
+    "AVAX/USD": "0x0003ee5a13ec8c58f795e4c71e0c63c62b0c71b946c58d9afda4d5c0fbc34a07",
+    "DOGE/USD": "0x00036bbf92e81b12a1f3fb2e70b79aebc413adb9590e80cd75ada6a8b476a8c5",
+    "MATIC/USD": "0x0003ec8e24da58f00c3a14f36a76e556b3a4c2b6f7a2461b64c0e73f8a2a5c0e",
+    "ARB/USD": "0x00034cb3de9cebd64f06eb6ae978a5fb78bfe2e90d8a4d20a5c6fe34be3e4c89",
+    "OP/USD": "0x0003ccb8cf41e5749e2e3f1b6ea1f0e76e0f2079f9ce7cc3b3e3d2e3e4f08b6a",
+    "DOT/USD": "0x0003b413f4a7c94e7ecb1c6c6fcfc94e36a17ef5a3f1e1e6e5b8b0d5c8e1a2b3"
+  };
+  FEED_SELECTORS = {
+    latestRoundData: "0xfeaf968c",
+    decimals: "0x313ce567"
+  };
+  CHAIN_RPCS = {
+    ethereum: "https://eth.llamarpc.com",
+    arbitrum: "https://arb1.arbitrum.io/rpc",
+    optimism: "https://mainnet.optimism.io",
+    polygon: "https://polygon-rpc.com",
+    base: "https://mainnet.base.org",
+    avalanche: "https://api.avax.network/ext/bc/C/rpc",
+    bnb: "https://bsc-dataseed.binance.org"
+  };
+  FEED_DIRECTORY = {
+    "ethereum:BTC/USD": "0xF4030086522a5bEEa4988F8cA5B36dbC97BeE88c",
+    "ethereum:ETH/USD": "0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419",
+    "ethereum:LINK/USD": "0x2c1d072e956AFFC0D435Cb7AC38EF18d24d9127c",
+    "ethereum:SOL/USD": "0x4ffC43a60e009B551865A93d232E33Fce9f01507",
+    "ethereum:AVAX/USD": "0xFF3EEb22B5E3dE6e705b44749C2559d704923FD7",
+    "ethereum:DOGE/USD": "0x2465CefD3b488BE410b941b1d4b2767088e2A028",
+    "ethereum:DOT/USD": "0x1C07AFb8E2B827c5A4739C6d59Ae3A5035f28734",
+    "ethereum:USDC/USD": "0x8fFfFfd4AfB6115b954Bd326cbe7B4BA576818f6",
+    "ethereum:USDT/USD": "0x3E7d1eAB13ad0104d2750B8863b489D65364e32D",
+    "arbitrum:BTC/USD": "0x6ce185860a4963106506C203335A2910413708e9",
+    "arbitrum:ETH/USD": "0x639Fe6ab55C921f74e7fac1ee960C0B6293ba612",
+    "arbitrum:LINK/USD": "0x86E53CF1B870786351Da77A57575e79CB55812CB",
+    "arbitrum:ARB/USD": "0xb2A824043730FE05F3DA2efaFa1CBbe83fa548D6",
+    "arbitrum:SOL/USD": "0x24ceA4b8ce57cdA5058b924B9B9987992450590c",
+    "base:ETH/USD": "0x71041dddad3595F9CEd3DcCFBe3D1F4b0a16Bb70",
+    "base:USDC/USD": "0x7e860098F58bBFC8648a4311b374B1D669a2bc6B",
+    "polygon:BTC/USD": "0xc907E116054Ad103354f2D350FD2514433D57F6f",
+    "polygon:ETH/USD": "0xF9680D99D6C9589e2a93a78A04A279e509205945",
+    "polygon:LINK/USD": "0xd9FFdb71EbE7496cC440152d43986Aae0AB76665",
+    "polygon:MATIC/USD": "0xAB594600376Ec9fD91F8e8dC9E0950EfEf8a3c20"
+  };
+  CCIP_CHAINS = {
+    ethereum: {
+      selector: "5009297550715157269",
+      router: "0x80226fc0Ee2b096224EeAc085Bb9a8cba1146f7D",
+      linkToken: "0x514910771AF9Ca656af840dff83E8264EcF986CA",
+      supportedTokens: {
+        WETH: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+        USDC: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        USDT: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+        LINK: "0x514910771AF9Ca656af840dff83E8264EcF986CA"
+      },
+      rpcKey: "ethereum"
+    },
+    arbitrum: {
+      selector: "4949039107694359620",
+      router: "0x141fa059441E0ca23ce184B6A78bafD2A517DdE8",
+      linkToken: "0xf97f4df75117a78c1A5a0DBb814Af92458539FB4",
+      supportedTokens: {
+        WETH: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+        USDC: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+        USDT: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+        LINK: "0xf97f4df75117a78c1A5a0DBb814Af92458539FB4"
+      },
+      rpcKey: "arbitrum"
+    },
+    optimism: {
+      selector: "3734403246176062136",
+      router: "0x3206695CaE725f44B28e86ede0805bAD662Ce783",
+      linkToken: "0x350a791Bfc2C21F9Ed5d10980Dad2e2638ffa7f6",
+      supportedTokens: {
+        WETH: "0x4200000000000000000000000000000000000006",
+        USDC: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+        LINK: "0x350a791Bfc2C21F9Ed5d10980Dad2e2638ffa7f6"
+      },
+      rpcKey: "optimism"
+    },
+    base: {
+      selector: "15971525489660198786",
+      router: "0x881e3A65B4d4a04dD529061dd0071cf975F58bCD",
+      linkToken: "0x88Fb150BDc53A65fe94Dea0c9BA0a6dAf8C6e196",
+      supportedTokens: {
+        WETH: "0x4200000000000000000000000000000000000006",
+        USDC: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+        LINK: "0x88Fb150BDc53A65fe94Dea0c9BA0a6dAf8C6e196"
+      },
+      rpcKey: "base"
+    },
+    polygon: {
+      selector: "4051577828743386545",
+      router: "0x849c5ED5a80F5B408Dd4969b78c2C8fdf0565Bfe",
+      linkToken: "0xb0897686c545045aFc77CF20eC7A532E3120E0F1",
+      supportedTokens: {
+        WMATIC: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
+        USDC: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+        USDT: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F",
+        LINK: "0xb0897686c545045aFc77CF20eC7A532E3120E0F1"
+      },
+      rpcKey: "polygon"
+    },
+    avalanche: {
+      selector: "6433500567565415381",
+      router: "0xF4c7E640EdA248ef95972845a62bdC74237805dB",
+      linkToken: "0x5947BB275c521040051D82396192181b413227A3",
+      supportedTokens: {
+        WAVAX: "0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7",
+        USDC: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+        LINK: "0x5947BB275c521040051D82396192181b413227A3"
+      },
+      rpcKey: "avalanche"
+    },
+    bnb: {
+      selector: "11344663589394136015",
+      router: "0x34B03Cb9086d7D758AC55af71584F81A598759FE",
+      linkToken: "0x404460C6A5EdE2D891e8297795264fDe62ADBB75",
+      supportedTokens: {
+        WBNB: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
+        USDC: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d",
+        USDT: "0x55d398326f99059fF775485246999027B3197955",
+        LINK: "0x404460C6A5EdE2D891e8297795264fDe62ADBB75"
+      },
+      rpcKey: "bnb"
+    }
+  };
+  ERC20_APPROVE_ABI = [
+    "function approve(address spender, uint256 amount) returns (bool)",
+    "function allowance(address owner, address spender) view returns (uint256)"
+  ];
+  CCIP_ROUTER_ABI = [
+    "function getFee(uint64 destinationChainSelector, tuple(bytes receiver, bytes data, tuple(address token, uint256 amount)[] tokenAmounts, address feeToken, bytes extraArgs) message) view returns (uint256)",
+    "function ccipSend(uint64 destinationChainSelector, tuple(bytes receiver, bytes data, tuple(address token, uint256 amount)[] tokenAmounts, address feeToken, bytes extraArgs) message) payable returns (bytes32)"
+  ];
+});
+
+// node_modules/@chainlink/data-streams-sdk/dist/src/utils/constants.js
+var require_constants79 = __commonJS((exports6) => {
+  Object.defineProperty(exports6, "__esModule", { value: true });
+  exports6.X_CLL_ORIGIN_HEADER = exports6.X_CLL_AVAILABLE_ORIGINS_HEADER = exports6.DEFAULT_RETRY_ATTEMPTS = exports6.DEFAULT_RETRY_DELAY = exports6.DEFAULT_TIMEOUT = exports6.VALIDATION_REGEX = exports6.WS_CONSTANTS = undefined;
+  exports6.WS_CONSTANTS = {
+    CONNECT_TIMEOUT: 5000,
+    PING_INTERVAL: 30000,
+    PONG_TIMEOUT: 5000,
+    MAX_RECONNECTS: 5,
+    RECONNECT_DELAY: 1000,
+    MAX_RECONNECT_INTERVAL: 1e4
+  };
+  exports6.VALIDATION_REGEX = {
+    FEED_ID: /^0x[0-9a-fA-F]{64}$/,
+    SCHEMA_VERSION: /^0x000([2-9]|a|b|c|d)$/
+  };
+  exports6.DEFAULT_TIMEOUT = 30000;
+  exports6.DEFAULT_RETRY_DELAY = 1000;
+  exports6.DEFAULT_RETRY_ATTEMPTS = 1;
+  exports6.X_CLL_AVAILABLE_ORIGINS_HEADER = "X-Cll-Available-Origins";
+  exports6.X_CLL_ORIGIN_HEADER = "X-Cll-Origin";
+});
+
+// node_modules/@chainlink/data-streams-sdk/dist/src/types/errors.js
+var require_errors56 = __commonJS((exports6) => {
+  Object.defineProperty(exports6, "__esModule", { value: true });
+  exports6.InsufficientConnectionsError = exports6.PartialConnectionFailureError = exports6.MultiConnectionError = exports6.OriginDiscoveryError = exports6.APIError = exports6.WebSocketError = exports6.ReportDecodingError = exports6.AuthenticationError = exports6.ValidationError = exports6.DataStreamsError = undefined;
+
+  class DataStreamsError extends Error {
+    constructor(message5) {
+      super(message5);
+      this.name = "DataStreamsError";
+      Object.setPrototypeOf(this, DataStreamsError.prototype);
+    }
+  }
+  exports6.DataStreamsError = DataStreamsError;
+
+  class ValidationError3 extends DataStreamsError {
+    constructor(message5) {
+      super(message5);
+      this.name = "ValidationError";
+      Object.setPrototypeOf(this, ValidationError3.prototype);
+    }
+  }
+  exports6.ValidationError = ValidationError3;
+
+  class AuthenticationError3 extends DataStreamsError {
+    constructor(message5) {
+      super(message5);
+      this.name = "AuthenticationError";
+      Object.setPrototypeOf(this, AuthenticationError3.prototype);
+    }
+  }
+  exports6.AuthenticationError = AuthenticationError3;
+
+  class ReportDecodingError extends DataStreamsError {
+    constructor(message5) {
+      super(message5);
+      this.name = "ReportDecodingError";
+      Object.setPrototypeOf(this, ReportDecodingError.prototype);
+    }
+  }
+  exports6.ReportDecodingError = ReportDecodingError;
+
+  class WebSocketError2 extends DataStreamsError {
+    constructor(message5) {
+      super(message5);
+      this.name = "WebSocketError";
+      Object.setPrototypeOf(this, WebSocketError2.prototype);
+    }
+  }
+  exports6.WebSocketError = WebSocketError2;
+
+  class APIError2 extends DataStreamsError {
+    constructor(message5, statusCode) {
+      super(message5);
+      this.statusCode = statusCode;
+      this.name = "APIError";
+      Object.setPrototypeOf(this, APIError2.prototype);
+    }
+  }
+  exports6.APIError = APIError2;
+
+  class OriginDiscoveryError extends DataStreamsError {
+    constructor(message5, cause) {
+      super(message5);
+      this.cause = cause;
+      this.name = "OriginDiscoveryError";
+      Object.setPrototypeOf(this, OriginDiscoveryError.prototype);
+    }
+  }
+  exports6.OriginDiscoveryError = OriginDiscoveryError;
+
+  class MultiConnectionError extends DataStreamsError {
+    constructor(message5) {
+      super(message5);
+      this.name = "MultiConnectionError";
+      Object.setPrototypeOf(this, MultiConnectionError.prototype);
+    }
+  }
+  exports6.MultiConnectionError = MultiConnectionError;
+
+  class PartialConnectionFailureError extends DataStreamsError {
+    constructor(message5, failedConnections, totalConnections) {
+      super(message5);
+      this.failedConnections = failedConnections;
+      this.totalConnections = totalConnections;
+      this.name = "PartialConnectionFailureError";
+      Object.setPrototypeOf(this, PartialConnectionFailureError.prototype);
+    }
+  }
+  exports6.PartialConnectionFailureError = PartialConnectionFailureError;
+
+  class InsufficientConnectionsError extends DataStreamsError {
+    constructor(message5, availableConnections, requiredConnections) {
+      super(message5);
+      this.availableConnections = availableConnections;
+      this.requiredConnections = requiredConnections;
+      this.name = "InsufficientConnectionsError";
+      Object.setPrototypeOf(this, InsufficientConnectionsError.prototype);
+    }
+  }
+  exports6.InsufficientConnectionsError = InsufficientConnectionsError;
+});
+
+// node_modules/@chainlink/data-streams-sdk/dist/src/types/logger.js
+var require_logger16 = __commonJS((exports6) => {
+  Object.defineProperty(exports6, "__esModule", { value: true });
+  exports6.LogLevel = undefined;
+  var LogLevel3;
+  (function(LogLevel4) {
+    LogLevel4[LogLevel4["DEBUG"] = 0] = "DEBUG";
+    LogLevel4[LogLevel4["INFO"] = 1] = "INFO";
+    LogLevel4[LogLevel4["WARN"] = 2] = "WARN";
+    LogLevel4[LogLevel4["ERROR"] = 3] = "ERROR";
+  })(LogLevel3 || (exports6.LogLevel = LogLevel3 = {}));
+});
+
+// node_modules/@chainlink/data-streams-sdk/dist/src/utils/auth.js
+var require_auth2 = __commonJS((exports6) => {
+  Object.defineProperty(exports6, "__esModule", { value: true });
+  exports6.generateAuthHeaders = generateAuthHeaders;
+  var crypto_1 = __require("crypto");
+  function generateAuthHeaders(apiKey, userSecret, method2, url3, body, timestamp2) {
+    const ts2 = timestamp2 || Date.now();
+    const pathWithQuery = new URL(url3).pathname + new URL(url3).search;
+    const bodyHash = (0, crypto_1.createHash)("sha256").update(body || "").digest("hex");
+    const hmacBaseString = `${method2} ${pathWithQuery} ${bodyHash} ${apiKey} ${ts2}`;
+    const hmac14 = (0, crypto_1.createHmac)("sha256", userSecret);
+    const signature5 = hmac14.update(hmacBaseString).digest("hex");
+    return {
+      Authorization: apiKey,
+      "X-Authorization-Timestamp": ts2.toString(),
+      "X-Authorization-Signature-SHA256": signature5
+    };
+  }
+});
+
+// node_modules/@chainlink/data-streams-sdk/dist/src/utils/logger.js
+var require_logger17 = __commonJS((exports6) => {
+  Object.defineProperty(exports6, "__esModule", { value: true });
+  exports6.SDKLogger = undefined;
+  var logger_1 = require_logger16();
+
+  class SDKLogger {
+    constructor(config9 = {}) {
+      this.config = config9;
+    }
+    debug(message5, ...args2) {
+      this.log(logger_1.LogLevel.DEBUG, message5, ...args2);
+    }
+    info(message5, ...args2) {
+      this.log(logger_1.LogLevel.INFO, message5, ...args2);
+    }
+    warn(message5, ...args2) {
+      this.log(logger_1.LogLevel.WARN, message5, ...args2);
+    }
+    error(message5, ...args2) {
+      this.log(logger_1.LogLevel.ERROR, message5, ...args2);
+    }
+    connectionDebug(message5, ...args2) {
+      if (this.config.enableConnectionDebug) {
+        this.debug(`[Connection] ${message5}`, ...args2);
+      }
+    }
+    log(level, message5, ...args2) {
+      if (!this.config.logger) {
+        return;
+      }
+      const minLevel = this.config.logLevel ?? logger_1.LogLevel.INFO;
+      if (level < minLevel) {
+        return;
+      }
+      const timestamp2 = new Date().toISOString();
+      const formattedMessage = `[${timestamp2}] [DataStreams] ${message5}`;
+      try {
+        switch (level) {
+          case logger_1.LogLevel.DEBUG:
+            this.config.logger.debug?.(formattedMessage, ...args2);
+            break;
+          case logger_1.LogLevel.INFO:
+            this.config.logger.info?.(formattedMessage, ...args2);
+            break;
+          case logger_1.LogLevel.WARN:
+            this.config.logger.warn?.(formattedMessage, ...args2);
+            break;
+          case logger_1.LogLevel.ERROR:
+            this.config.logger.error?.(formattedMessage, ...args2);
+            break;
+        }
+      } catch {}
+    }
+  }
+  exports6.SDKLogger = SDKLogger;
+});
+
+// node_modules/@chainlink/data-streams-sdk/dist/src/client/base.js
+var require_base26 = __commonJS((exports6) => {
+  Object.defineProperty(exports6, "__esModule", { value: true });
+  exports6.BaseClient = undefined;
+  var constants_1 = require_constants79();
+  var errors_1 = require_errors56();
+  var logger_1 = require_logger16();
+  var auth_1 = require_auth2();
+  var logger_2 = require_logger17();
+
+  class BaseClient {
+    constructor(config9) {
+      this.config = config9;
+      this.logger = new logger_2.SDKLogger(config9.logging);
+      this.validateConfig(config9);
+    }
+    validateConfig(config9) {
+      this.logger.debug("Starting configuration validation");
+      if (!config9 || typeof config9 !== "object") {
+        throw new errors_1.ValidationError("Configuration object is required");
+      }
+      this.validateRequiredString(config9.apiKey, "apiKey");
+      this.validateRequiredString(config9.userSecret, "userSecret");
+      this.validateRequiredString(config9.endpoint, "endpoint");
+      this.validateRequiredString(config9.wsEndpoint, "wsEndpoint");
+      this.validateUrl(config9.endpoint, "endpoint", ["http:", "https:"]);
+      this.validateWebSocketUrls(config9.wsEndpoint);
+      if (config9.timeout !== undefined) {
+        this.validatePositiveNumber(config9.timeout, "timeout");
+      }
+      if (config9.retryAttempts !== undefined) {
+        this.validateNonNegativeNumber(config9.retryAttempts, "retryAttempts");
+      }
+      if (config9.retryDelay !== undefined) {
+        this.validateNonNegativeNumber(config9.retryDelay, "retryDelay");
+      }
+      if (config9.haConnectionTimeout !== undefined) {
+        this.validatePositiveNumber(config9.haConnectionTimeout, "haConnectionTimeout");
+      }
+      if (config9.haMode !== undefined && typeof config9.haMode !== "boolean") {
+        throw new errors_1.ValidationError("haMode must be a boolean");
+      }
+      if (config9.connectionStatusCallback !== undefined && typeof config9.connectionStatusCallback !== "function") {
+        throw new errors_1.ValidationError("connectionStatusCallback must be a function");
+      }
+      this.validateLoggingConfig(config9.logging);
+      this.logger.debug("Configuration validation completed successfully");
+    }
+    validateRequiredString(value2, fieldName) {
+      if (value2 === undefined || value2 === null) {
+        throw new errors_1.ValidationError(`${fieldName} is required`);
+      }
+      if (typeof value2 !== "string") {
+        throw new errors_1.ValidationError(`${fieldName} must be a string`);
+      }
+      if (value2.trim() === "") {
+        throw new errors_1.ValidationError(`${fieldName} cannot be empty`);
+      }
+    }
+    validateUrl(value2, fieldName, allowedProtocols) {
+      try {
+        const url3 = new URL(value2);
+        if (!allowedProtocols.includes(url3.protocol)) {
+          throw new errors_1.ValidationError(`${fieldName} must use one of these protocols: ${allowedProtocols.join(", ")}`);
+        }
+      } catch (error56) {
+        if (error56 instanceof errors_1.ValidationError) {
+          throw error56;
+        }
+        throw new errors_1.ValidationError(`${fieldName} must be a valid URL`);
+      }
+    }
+    validateWebSocketUrls(wsEndpoint) {
+      const urls = wsEndpoint.split(",").map((url3) => url3.trim()).filter((url3) => url3.length > 0);
+      if (urls.length === 0) {
+        throw new errors_1.ValidationError("wsEndpoint cannot be empty");
+      }
+      for (const url3 of urls) {
+        this.validateUrl(url3, "wsEndpoint", ["ws:", "wss:"]);
+      }
+    }
+    validatePositiveNumber(value2, fieldName) {
+      if (typeof value2 !== "number" || isNaN(value2)) {
+        throw new errors_1.ValidationError(`${fieldName} must be a number`);
+      }
+      if (value2 <= 0) {
+        throw new errors_1.ValidationError(`${fieldName} must be positive`);
+      }
+    }
+    validateNonNegativeNumber(value2, fieldName) {
+      if (typeof value2 !== "number" || isNaN(value2)) {
+        throw new errors_1.ValidationError(`${fieldName} must be a number`);
+      }
+      if (value2 < 0) {
+        throw new errors_1.ValidationError(`${fieldName} cannot be negative`);
+      }
+    }
+    validateLoggingConfig(logging2) {
+      if (!logging2) {
+        return;
+      }
+      if (logging2.logLevel !== undefined) {
+        if (!Object.values(logger_1.LogLevel).includes(logging2.logLevel)) {
+          throw new errors_1.ValidationError(`Invalid logLevel: ${logging2.logLevel}. Must be one of: ${Object.values(logger_1.LogLevel).join(", ")}`);
+        }
+      }
+      if (logging2.logger) {
+        const logger106 = logging2.logger;
+        const validLevels = ["debug", "info", "warn", "error"];
+        validLevels.forEach((level) => {
+          if (logger106[level] && typeof logger106[level] !== "function") {
+            throw new errors_1.ValidationError(`Logger.${level} must be a function, got ${typeof logger106[level]}`);
+          }
+        });
+      }
+      if (logging2.enableConnectionDebug !== undefined && typeof logging2.enableConnectionDebug !== "boolean") {
+        throw new errors_1.ValidationError("enableConnectionDebug must be a boolean");
+      }
+    }
+    async makeRequest(path7, options4 = {}) {
+      const url3 = new URL(path7, this.config.endpoint);
+      const method2 = options4.method || "GET";
+      const body = typeof options4.body === "string" ? options4.body : undefined;
+      this.logger.debug(`Making ${method2} request to ${url3}`);
+      const authHeaders = (0, auth_1.generateAuthHeaders)(this.config.apiKey, this.config.userSecret, method2, url3.toString(), body);
+      const headers = new Headers(options4.headers);
+      headers.set("Content-Type", "application/json");
+      Object.entries(authHeaders).forEach(([key5, value2]) => {
+        headers.set(key5, value2);
+      });
+      const response = await fetch(url3.toString(), {
+        ...options4,
+        headers,
+        signal: AbortSignal.timeout(this.config.timeout ?? constants_1.DEFAULT_TIMEOUT)
+      });
+      if (!response.ok) {
+        let errorMessage;
+        try {
+          const errorData = await response.json();
+          errorMessage = errorData.message || response.statusText;
+        } catch {
+          errorMessage = response.statusText;
+        }
+        this.logger.error(`Request failed: ${method2} ${url3} - ${response.status} ${errorMessage}`);
+        throw new errors_1.APIError(errorMessage, response.status);
+      }
+      this.logger.info(`Request successful: ${method2} ${url3} - ${response.status}`);
+      return response.json();
+    }
+    async withRetry(fn3) {
+      const maxAttempts = this.config.retryAttempts ?? constants_1.DEFAULT_RETRY_ATTEMPTS;
+      const baseDelay = this.config.retryDelay ?? constants_1.DEFAULT_RETRY_DELAY;
+      this.logger.debug(`Starting retry logic: max ${maxAttempts} attempts`);
+      let lastError;
+      for (let attempt = 0;attempt <= maxAttempts; attempt++) {
+        try {
+          return await fn3();
+        } catch (error56) {
+          lastError = error56;
+          if (attempt === maxAttempts) {
+            this.logger.error(`All retry attempts failed (${maxAttempts}/${maxAttempts}):`, lastError);
+            break;
+          }
+          if (error56 instanceof errors_1.APIError && (error56.statusCode === 400 || error56.statusCode === 401)) {
+            this.logger.warn(`Not retrying client error ${error56.statusCode}: ${error56.message}`);
+            throw error56;
+          }
+          const delay8 = baseDelay * Math.pow(2, attempt) * (0.5 + Math.random() * 0.5);
+          this.logger.warn(`Retry attempt ${attempt}/${maxAttempts} failed, retrying in ${Math.round(delay8)}ms:`, error56);
+          await new Promise((resolve7) => setTimeout(resolve7, delay8));
+        }
+      }
+      throw lastError;
+    }
+  }
+  exports6.BaseClient = BaseClient;
+});
+
+// node_modules/@chainlink/data-streams-sdk/dist/src/utils/validation.js
+var require_validation3 = __commonJS((exports6) => {
+  Object.defineProperty(exports6, "__esModule", { value: true });
+  exports6.validateFeedId = validateFeedId;
+  exports6.validateTimestamp = validateTimestamp;
+  exports6.validateFeedIds = validateFeedIds;
+  exports6.validateHexString = validateHexString;
+  exports6.validateEnvironment = validateEnvironment;
+  var errors_1 = require_errors56();
+  var constants_1 = require_constants79();
+  function validateFeedId(feedId) {
+    if (!feedId) {
+      throw new errors_1.ValidationError("Feed ID is required");
+    }
+    if (!constants_1.VALIDATION_REGEX.FEED_ID.test(feedId)) {
+      throw new errors_1.ValidationError("Invalid feed ID format. Must be 0x followed by 64 hex characters");
+    }
+    const version18 = feedId.slice(2, 6);
+    if (!constants_1.VALIDATION_REGEX.SCHEMA_VERSION.test(`0x${version18}`)) {
+      throw new errors_1.ValidationError("Invalid feed ID version. Must start with 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c or 0x000d");
+    }
+  }
+  function validateTimestamp(timestamp2) {
+    if (!Number.isInteger(timestamp2)) {
+      throw new errors_1.ValidationError("Timestamp must be an integer");
+    }
+    if (timestamp2 < 0) {
+      throw new errors_1.ValidationError("Timestamp cannot be negative");
+    }
+  }
+  function validateFeedIds(feedIds) {
+    if (!Array.isArray(feedIds)) {
+      throw new errors_1.ValidationError("Feed IDs must be an array");
+    }
+    if (feedIds.length === 0) {
+      throw new errors_1.ValidationError("At least one feed ID is required");
+    }
+    feedIds.forEach(validateFeedId);
+  }
+  function validateHexString(hexString, fieldName = "hex string") {
+    if (!hexString) {
+      throw new errors_1.ValidationError(`${fieldName} is required`);
+    }
+    if (typeof hexString !== "string") {
+      throw new errors_1.ValidationError(`${fieldName} must be a string`);
+    }
+    if (!hexString.startsWith("0x")) {
+      throw new errors_1.ValidationError(`${fieldName} must start with 0x`);
+    }
+    if (!/^0x[0-9a-fA-F]+$/.test(hexString)) {
+      throw new errors_1.ValidationError(`${fieldName} contains invalid hex characters`);
+    }
+    if (hexString.length < 3) {
+      throw new errors_1.ValidationError(`${fieldName} must contain at least one hex character after 0x`);
+    }
+  }
+  function validateEnvironment() {
+    if (!process.env.API_KEY) {
+      throw new errors_1.ValidationError("API_KEY environment variable is required");
+    }
+    if (!process.env.USER_SECRET) {
+      throw new errors_1.ValidationError("USER_SECRET environment variable is required");
+    }
+  }
+});
+
+// node_modules/@chainlink/data-streams-sdk/dist/src/types/metrics.js
+var require_metrics4 = __commonJS((exports6) => {
+  Object.defineProperty(exports6, "__esModule", { value: true });
+  exports6.ConnectionStatus = undefined;
+  var ConnectionStatus;
+  (function(ConnectionStatus2) {
+    ConnectionStatus2["DISCONNECTED"] = "disconnected";
+    ConnectionStatus2["CONNECTING"] = "connecting";
+    ConnectionStatus2["CONNECTED"] = "connected";
+    ConnectionStatus2["RECONNECTING"] = "reconnecting";
+    ConnectionStatus2["FAILED"] = "failed";
+  })(ConnectionStatus || (exports6.ConnectionStatus = ConnectionStatus = {}));
+});
+
+// node_modules/@chainlink/data-streams-sdk/dist/src/stream/stats.js
+var require_stats = __commonJS((exports6) => {
+  Object.defineProperty(exports6, "__esModule", { value: true });
+  exports6.StreamStats = undefined;
+  var metrics_1 = require_metrics4();
+
+  class StreamStats {
+    constructor(configuredConnections = 1) {
+      this._accepted = 0;
+      this._deduplicated = 0;
+      this._partialReconnects = 0;
+      this._fullReconnects = 0;
+      this._configuredConnections = 0;
+      this._activeConnections = 0;
+      this._originStatus = {};
+      this._totalReceived = 0;
+      this._configuredConnections = configuredConnections;
+    }
+    incrementAccepted() {
+      this._accepted++;
+      this._totalReceived++;
+    }
+    incrementDeduplicated() {
+      this._deduplicated++;
+      this._totalReceived++;
+    }
+    incrementPartialReconnects() {
+      this._partialReconnects++;
+    }
+    incrementFullReconnects() {
+      this._fullReconnects++;
+    }
+    setActiveConnections(count3) {
+      this._activeConnections = count3;
+    }
+    setConfiguredConnections(count3) {
+      this._configuredConnections = count3;
+    }
+    setOriginStatus(origin2, status) {
+      this._originStatus[origin2] = status;
+    }
+    removeOriginStatus(origin2) {
+      delete this._originStatus[origin2];
+    }
+    getOriginStatus(origin2) {
+      return this._originStatus[origin2] || metrics_1.ConnectionStatus.DISCONNECTED;
+    }
+    getAllOriginStatuses() {
+      return { ...this._originStatus };
+    }
+    updateOriginStatuses(originStatus) {
+      this._originStatus = { ...originStatus };
+    }
+    reset() {
+      this._accepted = 0;
+      this._deduplicated = 0;
+      this._partialReconnects = 0;
+      this._fullReconnects = 0;
+      this._totalReceived = 0;
+      this._activeConnections = 0;
+      this._originStatus = {};
+    }
+    getStats() {
+      return {
+        accepted: this._accepted,
+        deduplicated: this._deduplicated,
+        partialReconnects: this._partialReconnects,
+        fullReconnects: this._fullReconnects,
+        configuredConnections: this._configuredConnections,
+        activeConnections: this._activeConnections,
+        totalReceived: this._totalReceived,
+        originStatus: Object.freeze({ ...this._originStatus })
+      };
+    }
+  }
+  exports6.StreamStats = StreamStats;
+});
+
+// node_modules/@chainlink/data-streams-sdk/dist/src/utils/origin-discovery.js
+var require_origin_discovery = __commonJS((exports6) => {
+  Object.defineProperty(exports6, "__esModule", { value: true });
+  exports6.parseCommaSeparatedUrls = parseCommaSeparatedUrls;
+  exports6.convertWebSocketToHttpScheme = convertWebSocketToHttpScheme;
+  exports6.parseOriginsHeader = parseOriginsHeader;
+  exports6.discoverOrigins = discoverOrigins;
+  exports6.getAvailableOrigins = getAvailableOrigins;
+  var constants_1 = require_constants79();
+  var auth_1 = require_auth2();
+  var errors_1 = require_errors56();
+  function parseCommaSeparatedUrls(wsUrl) {
+    return wsUrl.split(",").map((url3) => url3.trim()).filter((url3) => url3.length > 0);
+  }
+  function convertWebSocketToHttpScheme(wsUrl) {
+    if (wsUrl.startsWith("wss://")) {
+      return wsUrl.replace("wss://", "https://");
+    } else if (wsUrl.startsWith("ws://")) {
+      return wsUrl.replace("ws://", "http://");
+    }
+    return wsUrl;
+  }
+  function parseOriginsHeader(headerValue) {
+    if (!headerValue) {
+      return [];
+    }
+    let cleaned = headerValue.trim();
+    if (cleaned.startsWith("{")) {
+      cleaned = cleaned.slice(1);
+    }
+    if (cleaned.endsWith("}")) {
+      cleaned = cleaned.slice(0, -1);
+    }
+    return cleaned.split(",").map((origin2) => origin2.trim()).filter((origin2) => origin2.length > 0);
+  }
+  async function discoverOrigins(baseUrl, apiKey, userSecret, timeout = constants_1.WS_CONSTANTS.CONNECT_TIMEOUT, logger106) {
+    logger106?.debug(`Starting origin discovery for ${baseUrl}`);
+    try {
+      const httpUrl2 = convertWebSocketToHttpScheme(baseUrl);
+      logger106?.debug(`Converted WebSocket URL to HTTP: ${httpUrl2}`);
+      const url3 = new URL("/", httpUrl2);
+      const headers = (0, auth_1.generateAuthHeaders)(apiKey, userSecret, "HEAD", url3.toString());
+      const controller = new AbortController;
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      try {
+        const response = await fetch(url3.toString(), {
+          method: "HEAD",
+          headers,
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const originsHeader = response.headers.get(constants_1.X_CLL_AVAILABLE_ORIGINS_HEADER);
+        if (!originsHeader) {
+          logger106?.info("No origins header found in response");
+          return [];
+        }
+        const origins = parseOriginsHeader(originsHeader);
+        logger106?.info(`Origin discovery successful: found ${origins.length} origins`);
+        return origins;
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    } catch (error56) {
+      logger106?.error(`Origin discovery failed for ${baseUrl}:`, error56);
+      if (error56 instanceof Error) {
+        if (error56.name === "AbortError") {
+          throw new errors_1.OriginDiscoveryError(`Origin discovery timed out after ${timeout}ms`, error56);
+        }
+        throw new errors_1.OriginDiscoveryError(`Failed to discover origins: ${error56.message}`, error56);
+      }
+      throw new errors_1.OriginDiscoveryError("Unknown error during origin discovery");
+    }
+  }
+  async function getAvailableOrigins(wsUrl, apiKey, userSecret, haEnabled = true, timeout = constants_1.WS_CONSTANTS.CONNECT_TIMEOUT, logger106) {
+    logger106?.debug(`Getting available origins for ${wsUrl}, dynamic discovery: ${haEnabled}`);
+    const staticOrigins = parseCommaSeparatedUrls(wsUrl);
+    logger106?.debug(`Found ${staticOrigins.length} static origins`);
+    if (!haEnabled || staticOrigins.length > 1) {
+      logger106?.info(`Using static origins: ${staticOrigins.join(", ")}`);
+      return staticOrigins;
+    }
+    try {
+      const dynamicOrigins = await discoverOrigins(staticOrigins[0], apiKey, userSecret, timeout, logger106);
+      let finalOrigins = dynamicOrigins.length > 0 ? dynamicOrigins : staticOrigins;
+      if (dynamicOrigins.length > 0 && !dynamicOrigins[0].startsWith("ws")) {
+        const baseUrl = staticOrigins[0];
+        finalOrigins = dynamicOrigins.map((originId) => `${baseUrl}#${originId}`);
+      }
+      if (finalOrigins.length === 0) {
+        throw new errors_1.InsufficientConnectionsError("No origins available for connection", 0, 1);
+      }
+      logger106?.info(`Dynamic discovery completed: ${finalOrigins.length} origins available`);
+      return finalOrigins;
+    } catch (error56) {
+      logger106?.warn(`Dynamic discovery failed, falling back to static origins:`, error56);
+      if (staticOrigins.length === 0) {
+        throw new errors_1.InsufficientConnectionsError("No origins available for connection after discovery failure", 0, 1);
+      }
+      return staticOrigins;
+    }
+  }
+});
+
+// node_modules/@chainlink/data-streams-sdk/dist/src/stream/connection-manager.js
+var require_connection_manager = __commonJS((exports6) => {
+  var __importDefault = exports6 && exports6.__importDefault || function(mod11) {
+    return mod11 && mod11.__esModule ? mod11 : { default: mod11 };
+  };
+  Object.defineProperty(exports6, "__esModule", { value: true });
+  exports6.ConnectionManager = exports6.ConnectionState = undefined;
+  var ws_1 = __importDefault(__require("ws"));
+  var events_1 = __require("events");
+  var auth_1 = require_auth2();
+  var origin_discovery_1 = require_origin_discovery();
+  var constants_1 = require_constants79();
+  var errors_1 = require_errors56();
+  var logger_1 = require_logger17();
+  var metrics_1 = require_metrics4();
+  var ConnectionState;
+  (function(ConnectionState2) {
+    ConnectionState2["DISCONNECTED"] = "disconnected";
+    ConnectionState2["CONNECTING"] = "connecting";
+    ConnectionState2["CONNECTED"] = "connected";
+    ConnectionState2["RECONNECTING"] = "reconnecting";
+    ConnectionState2["FAILED"] = "failed";
+  })(ConnectionState || (exports6.ConnectionState = ConnectionState = {}));
+
+  class ConnectionManager extends events_1.EventEmitter {
+    constructor(config9, managerConfig) {
+      super();
+      this.connections = new Map;
+      this.isShuttingDown = false;
+      this.reconnectTimeouts = new Map;
+      this.streamStats = null;
+      this.config = config9;
+      this.managerConfig = managerConfig;
+      this.logger = new logger_1.SDKLogger(config9.logging);
+    }
+    setStreamStats(streamStats) {
+      this.streamStats = streamStats;
+    }
+    async initialize() {
+      try {
+        const origins = await (0, origin_discovery_1.getAvailableOrigins)(this.config.wsEndpoint, this.config.apiKey, this.config.userSecret, this.managerConfig.haMode, this.managerConfig.haConnectionTimeout);
+        const useHAMode = this.managerConfig.haMode && origins.length > 1;
+        const originsToUse = useHAMode ? origins : [origins[0]];
+        if (useHAMode) {
+          this.logger.info(`Initializing in HA mode with ${origins.length} origins`, {
+            origins: origins.map((o4) => new URL(o4).host)
+          });
+        } else {
+          if (this.managerConfig.haMode) {
+            this.logger.warn(`HA mode requested but only ${origins.length} origin available, falling back to single connection`, {
+              origin: new URL(origins[0]).host
+            });
+          } else {
+            this.logger.info(`Initializing in single connection mode`, { origin: new URL(origins[0]).host });
+          }
+        }
+        if (!useHAMode && this.managerConfig.haMode) {
+          this.emit("ha-fallback-warning", {
+            message: "HA mode requested but only one origin available, falling back to single connection",
+            requestedOrigins: origins.length,
+            actualMode: "single"
+          });
+        }
+        const connectionPromises = originsToUse.map((origin2, index4) => this.createConnection(origin2, index4));
+        const results = await Promise.allSettled(connectionPromises);
+        const successfulConnections = results.filter((r2) => r2.status === "fulfilled").length;
+        const failedConnections = results.length - successfulConnections;
+        if (successfulConnections === 0) {
+          throw new errors_1.InsufficientConnectionsError("Failed to establish any WebSocket connections", 0, 1);
+        } else if (failedConnections > 0 && useHAMode) {
+          this.emit("partial-failure", failedConnections, results.length);
+        }
+      } catch (error56) {
+        throw new errors_1.MultiConnectionError(`Failed to initialize connections: ${error56 instanceof Error ? error56.message : error56}`);
+      }
+    }
+    updateConnectionState(connection, newState, reason) {
+      const oldState = connection.state;
+      connection.state = newState;
+      if (oldState !== newState) {
+        const logData = {
+          connectionId: connection.id,
+          host: connection.host,
+          oldState,
+          newState,
+          reason
+        };
+        switch (newState) {
+          case ConnectionState.CONNECTING:
+            this.logger.connectionDebug(`Connection ${connection.id} transitioning to CONNECTING`, logData);
+            break;
+          case ConnectionState.CONNECTED:
+            this.logger.info(`Connection ${connection.id} established to ${connection.host}`, logData);
+            break;
+          case ConnectionState.RECONNECTING:
+            this.logger.warn(`Connection ${connection.id} reconnecting to ${connection.host}: ${reason || "Unknown reason"}`, logData);
+            break;
+          case ConnectionState.FAILED:
+            this.logger.error(`Connection ${connection.id} failed to ${connection.host}: ${reason || "Unknown reason"}`, logData);
+            break;
+          case ConnectionState.DISCONNECTED:
+            if (oldState === ConnectionState.CONNECTED) {
+              this.logger.warn(`Connection ${connection.id} lost to ${connection.host}: ${reason || "Unknown reason"}`, logData);
+            } else {
+              this.logger.connectionDebug(`Connection ${connection.id} disconnected from ${connection.host}`, logData);
+            }
+            break;
+        }
+      }
+    }
+    cleanupWebSocket(connection) {
+      if (!connection.ws) {
+        return;
+      }
+      this.logger.connectionDebug(`Cleaning up WebSocket for ${connection.id} (readyState: ${connection.ws.readyState})`);
+      const ws4 = connection.ws;
+      ws4.once("error", (error56) => {
+        this.logger.connectionDebug(`Error during WebSocket cleanup for ${connection.id}:`, error56);
+      });
+      ws4.removeAllListeners("open");
+      ws4.removeAllListeners("close");
+      ws4.removeAllListeners("message");
+      ws4.removeAllListeners("ping");
+      ws4.removeAllListeners("pong");
+      ws4.removeAllListeners("unexpected-response");
+      if (ws4.readyState === ws_1.default.OPEN || ws4.readyState === ws_1.default.CONNECTING) {
+        try {
+          ws4.terminate();
+        } catch (error56) {
+          this.logger.connectionDebug(`Synchronous error terminating WebSocket for ${connection.id}:`, error56);
+        }
+      }
+      connection.ws = null;
+      this.stopHealthMonitoring(connection);
+    }
+    async createConnection(origin2, index4) {
+      const connectionId = `conn-${index4}`;
+      const url3 = new URL(origin2);
+      const connection = {
+        id: connectionId,
+        origin: origin2,
+        host: url3.host,
+        ws: null,
+        state: ConnectionState.DISCONNECTED,
+        reconnectAttempts: 0
+      };
+      this.connections.set(connectionId, connection);
+      try {
+        await this.establishConnection(connection);
+        return connection;
+      } catch (error56) {
+        this.updateConnectionState(connection, ConnectionState.FAILED, `Connection setup failed: ${error56 instanceof Error ? error56.message : error56}`);
+        connection.lastError = error56 instanceof Error ? error56 : new Error(String(error56));
+        throw error56;
+      }
+    }
+    async establishConnection(connection) {
+      return new Promise((resolve7, reject) => {
+        try {
+          const hadExistingConnection = !!connection.ws;
+          if (hadExistingConnection) {
+            this.logger.connectionDebug(`Cleaning up existing WebSocket for ${connection.id} before reconnection`);
+            this.cleanupWebSocket(connection);
+          }
+          this.updateConnectionState(connection, ConnectionState.CONNECTING, "WebSocket connection initiated");
+          this.logger.connectionDebug(`Creating new WebSocket for ${connection.id} to ${connection.origin} (cleaned up old: ${hadExistingConnection})`);
+          const feedIdsParam = this.managerConfig.feedIds.join(",");
+          let baseUrl = connection.origin;
+          let originId = "";
+          if (connection.origin.includes("#")) {
+            [baseUrl, originId] = connection.origin.split("#");
+          } else if (!connection.origin.startsWith("ws")) {
+            baseUrl = this.config.wsEndpoint.split(",")[0];
+            originId = connection.origin;
+          }
+          const wsUrl = `${baseUrl}/api/v1/ws?feedIDs=${feedIdsParam}`;
+          const headers = (0, auth_1.generateAuthHeaders)(this.config.apiKey, this.config.userSecret, "GET", wsUrl);
+          if (originId) {
+            headers[constants_1.X_CLL_ORIGIN_HEADER] = originId;
+          }
+          const connectTimeout = setTimeout(() => {
+            if (connection.ws) {
+              connection.ws.terminate();
+            }
+            reject(new errors_1.WebSocketError(`Connection timeout after ${this.managerConfig.connectTimeout}ms`));
+          }, this.managerConfig.connectTimeout);
+          connection.ws = new ws_1.default(wsUrl, { headers });
+          connection.ws.once("unexpected-response", (_req, res) => {
+            clearTimeout(connectTimeout);
+            const status = res?.statusCode;
+            if (status === 401 || status === 403) {
+              reject(new errors_1.WebSocketError(`Authentication failed during WebSocket handshake (${status}). Check API key/secret.`));
+            } else {
+              reject(new errors_1.WebSocketError(`Unexpected WebSocket handshake response: ${String(status)}`));
+            }
+          });
+          connection.ws.on("open", () => {
+            clearTimeout(connectTimeout);
+            this.updateConnectionState(connection, ConnectionState.CONNECTED, "WebSocket connection established");
+            connection.connectedAt = Date.now();
+            connection.reconnectAttempts = 0;
+            this.startHealthMonitoring(connection);
+            if (this.managerConfig.statusCallback) {
+              this.managerConfig.statusCallback(true, connection.host, connection.origin);
+            }
+            this.emit("connection-established", connection);
+            resolve7();
+          });
+          connection.ws.on("message", (data7) => {
+            this.emit("message", data7, connection);
+          });
+          connection.ws.on("close", () => {
+            clearTimeout(connectTimeout);
+            this.handleConnectionLoss(connection);
+          });
+          connection.ws.on("error", (error56) => {
+            clearTimeout(connectTimeout);
+            connection.lastError = error56;
+            if (connection.state === ConnectionState.CONNECTING) {
+              const message5 = /401|403/.test(error56.message) ? `Authentication failed during WebSocket handshake. Check API key/secret. (${error56.message})` : `Failed to connect to ${connection.origin}: ${error56.message}`;
+              reject(new errors_1.WebSocketError(message5));
+            } else {
+              this.handleConnectionLoss(connection, error56);
+            }
+          });
+          connection.ws.on("ping", (data7) => {
+            this.logger.connectionDebug(`Received ping from ${connection.origin}`);
+            if (connection.ws && connection.ws.readyState === ws_1.default.OPEN) {
+              try {
+                this.logger.connectionDebug(`Responding with pong to ${connection.origin}`);
+                connection.ws.pong(data7);
+              } catch {}
+            }
+          });
+          connection.ws.on("pong", () => {
+            this.handlePongReceived(connection);
+          });
+        } catch (error56) {
+          reject(error56);
+        }
+      });
+    }
+    handleConnectionLoss(connection, error56) {
+      if (this.isShuttingDown) {
+        return;
+      }
+      const wasConnected = connection.state === ConnectionState.CONNECTED;
+      this.updateConnectionState(connection, ConnectionState.DISCONNECTED, error56 ? `Connection lost: ${error56.message}` : "Connection closed");
+      connection.lastError = error56;
+      this.stopHealthMonitoring(connection);
+      if (this.managerConfig.statusCallback && wasConnected) {
+        this.managerConfig.statusCallback(false, connection.host, connection.origin);
+      }
+      this.emit("connection-lost", connection, error56);
+      const activeConnections = this.getActiveConnectionCount();
+      if (activeConnections === 0) {
+        this.emit("all-connections-lost");
+      }
+      this.scheduleReconnection(connection);
+    }
+    scheduleReconnection(connection) {
+      if (this.isShuttingDown) {
+        return;
+      }
+      connection.reconnectAttempts++;
+      this.updateConnectionState(connection, ConnectionState.RECONNECTING, `Reconnect attempt ${connection.reconnectAttempts}/${this.managerConfig.maxReconnectAttempts}`);
+      connection.lastReconnectAt = Date.now();
+      const activeConnections = this.getActiveConnectionCount();
+      if (activeConnections === 0) {
+        if (this.streamStats) {
+          this.streamStats.incrementFullReconnects();
+        }
+        this.logger.debug(`Full reconnection attempt (no active connections)`);
+      } else {
+        if (this.streamStats) {
+          this.streamStats.incrementPartialReconnects();
+        }
+        this.logger.debug(`Partial reconnection attempt (${activeConnections} active connections remaining)`);
+      }
+      const baseDelay = this.managerConfig.reconnectInterval || constants_1.WS_CONSTANTS.RECONNECT_DELAY;
+      const delay8 = Math.min(baseDelay * Math.pow(2, connection.reconnectAttempts - 1), constants_1.WS_CONSTANTS.MAX_RECONNECT_INTERVAL);
+      this.logger.debug(`Scheduling reconnection for ${connection.id} in ${delay8}ms (attempt ${connection.reconnectAttempts})`);
+      this.emit("reconnecting", {
+        attempt: connection.reconnectAttempts,
+        delayMs: delay8,
+        origin: connection.origin,
+        host: connection.host
+      }, connection);
+      const timeout = setTimeout(async () => {
+        this.reconnectTimeouts.delete(connection.id);
+        if (this.isShuttingDown) {
+          return;
+        }
+        const activeConnections2 = this.getActiveConnectionCount();
+        if (connection.reconnectAttempts >= this.managerConfig.maxReconnectAttempts && activeConnections2 === 0) {
+          this.updateConnectionState(connection, ConnectionState.FAILED, `Max reconnection attempts (${this.managerConfig.maxReconnectAttempts}) reached with no active connections`);
+          this.emit("max-reconnect-attempts-reached", {
+            origin: connection.origin,
+            attempts: connection.reconnectAttempts,
+            activeConnections: activeConnections2,
+            message: `Max reconnection attempts reached for ${connection.origin} with no active connections`
+          });
+          this.emit("all-connections-lost");
+          return;
+        }
+        try {
+          await this.establishConnection(connection);
+          this.emit("connection-restored", connection);
+        } catch {
+          this.scheduleReconnection(connection);
+        }
+      }, delay8);
+      timeout.unref();
+      this.reconnectTimeouts.set(connection.id, timeout);
+    }
+    getActiveConnectionCount() {
+      return Array.from(this.connections.values()).filter((conn) => conn.state === ConnectionState.CONNECTED).length;
+    }
+    getConfiguredConnectionCount() {
+      return this.connections.size;
+    }
+    getConnectionStates() {
+      const states = {};
+      for (const [id4, conn] of this.connections) {
+        states[id4] = conn.state;
+      }
+      return states;
+    }
+    getConnectionDetails() {
+      return Array.from(this.connections.values()).map((conn) => ({
+        ...conn,
+        ws: null
+      }));
+    }
+    startHealthMonitoring(connection) {
+      connection.pingInterval = setInterval(() => {
+        this.sendPing(connection);
+      }, constants_1.WS_CONSTANTS.PING_INTERVAL);
+      connection.pingInterval.unref();
+    }
+    sendPing(connection) {
+      if (!connection.ws || connection.ws.readyState !== ws_1.default.OPEN) {
+        return;
+      }
+      try {
+        this.logger.connectionDebug(`Sending ping to ${connection.origin}`);
+        connection.ws.ping();
+        connection.pongTimeout = setTimeout(() => {
+          this.logger.warn(`Pong timeout for ${connection.origin} - terminating connection`);
+          if (connection.ws) {
+            connection.ws.terminate();
+          }
+        }, constants_1.WS_CONSTANTS.PONG_TIMEOUT);
+        connection.pongTimeout.unref();
+      } catch (error56) {
+        this.logger.error(`Ping failed for ${connection.origin}:`, error56);
+        if (connection.ws) {
+          connection.ws.terminate();
+        }
+      }
+    }
+    handlePongReceived(connection) {
+      this.logger.connectionDebug(`Received pong from ${connection.origin}`);
+      if (connection.pongTimeout) {
+        clearTimeout(connection.pongTimeout);
+        connection.pongTimeout = undefined;
+      }
+    }
+    stopHealthMonitoring(connection) {
+      if (connection.pingInterval) {
+        clearInterval(connection.pingInterval);
+        connection.pingInterval = undefined;
+      }
+      if (connection.pongTimeout) {
+        clearTimeout(connection.pongTimeout);
+        connection.pongTimeout = undefined;
+      }
+    }
+    async shutdown() {
+      this.isShuttingDown = true;
+      for (const timeout of this.reconnectTimeouts.values()) {
+        clearTimeout(timeout);
+      }
+      this.reconnectTimeouts.clear();
+      const closePromises = Array.from(this.connections.values()).map((connection) => this.closeConnection(connection));
+      await Promise.allSettled(closePromises);
+      this.connections.clear();
+    }
+    async closeConnection(connection) {
+      return new Promise((resolve7) => {
+        if (!connection.ws) {
+          resolve7();
+          return;
+        }
+        const ws4 = connection.ws;
+        this.updateConnectionState(connection, ConnectionState.DISCONNECTED, "Graceful shutdown initiated");
+        this.stopHealthMonitoring(connection);
+        if (ws4.readyState === ws_1.default.OPEN || ws4.readyState === ws_1.default.CONNECTING) {
+          const timeout = setTimeout(() => {
+            this.cleanupWebSocket(connection);
+            resolve7();
+          }, 1000);
+          ws4.once("close", () => {
+            clearTimeout(timeout);
+            this.cleanupWebSocket(connection);
+            resolve7();
+          });
+          try {
+            ws4.close();
+          } catch (error56) {
+            this.logger.connectionDebug(`Error closing WebSocket for ${connection.id}:`, error56);
+            this.cleanupWebSocket(connection);
+            clearTimeout(timeout);
+            resolve7();
+          }
+        } else {
+          this.cleanupWebSocket(connection);
+          resolve7();
+        }
+      });
+    }
+    getOriginStatusMap() {
+      const originStatus = {};
+      for (const connection of this.connections.values()) {
+        let status;
+        switch (connection.state) {
+          case ConnectionState.CONNECTED:
+            status = metrics_1.ConnectionStatus.CONNECTED;
+            break;
+          case ConnectionState.CONNECTING:
+            status = metrics_1.ConnectionStatus.CONNECTING;
+            break;
+          case ConnectionState.RECONNECTING:
+            status = metrics_1.ConnectionStatus.RECONNECTING;
+            break;
+          case ConnectionState.FAILED:
+            status = metrics_1.ConnectionStatus.FAILED;
+            break;
+          case ConnectionState.DISCONNECTED:
+          default:
+            status = metrics_1.ConnectionStatus.DISCONNECTED;
+            break;
+        }
+        originStatus[connection.origin] = status;
+      }
+      return Object.freeze(originStatus);
+    }
+  }
+  exports6.ConnectionManager = ConnectionManager;
+});
+
+// node_modules/@chainlink/data-streams-sdk/dist/src/stream/deduplication.js
+var require_deduplication = __commonJS((exports6) => {
+  Object.defineProperty(exports6, "__esModule", { value: true });
+  exports6.ReportDeduplicator = undefined;
+
+  class ReportDeduplicator {
+    constructor(options4 = {}) {
+      this.waterMark = new Map;
+      this.acceptedCount = 0;
+      this.deduplicatedCount = 0;
+      this.cleanupInterval = null;
+      this.maxWatermarkAge = options4.maxWatermarkAge ?? 60 * 60 * 1000;
+      this.cleanupIntervalMs = options4.cleanupIntervalMs ?? 5 * 60 * 1000;
+      this.startCleanup();
+    }
+    processReport(report) {
+      const feedId = report.feedID;
+      const observationsTimestamp = report.observationsTimestamp;
+      const currentWatermark = this.waterMark.get(feedId);
+      if (currentWatermark !== undefined && currentWatermark >= observationsTimestamp) {
+        this.deduplicatedCount++;
+        return {
+          isAccepted: false,
+          isDuplicate: true,
+          reason: `Report timestamp ${observationsTimestamp} <= watermark ${currentWatermark} for feed ${feedId}`
+        };
+      }
+      this.waterMark.set(feedId, observationsTimestamp);
+      this.acceptedCount++;
+      return {
+        isAccepted: true,
+        isDuplicate: false
+      };
+    }
+    getStats() {
+      return {
+        accepted: this.acceptedCount,
+        deduplicated: this.deduplicatedCount,
+        totalReceived: this.acceptedCount + this.deduplicatedCount,
+        watermarkCount: this.waterMark.size
+      };
+    }
+    getWatermark(feedId) {
+      return this.waterMark.get(feedId);
+    }
+    getAllWatermarks() {
+      const watermarks = {};
+      for (const [feedId, timestamp2] of this.waterMark) {
+        watermarks[feedId] = timestamp2;
+      }
+      return watermarks;
+    }
+    setWatermark(feedId, timestamp2) {
+      this.waterMark.set(feedId, timestamp2);
+    }
+    clearWatermark(feedId) {
+      return this.waterMark.delete(feedId);
+    }
+    clearAllWatermarks() {
+      this.waterMark.clear();
+    }
+    reset() {
+      this.acceptedCount = 0;
+      this.deduplicatedCount = 0;
+      this.waterMark.clear();
+    }
+    startCleanup() {
+      this.cleanupInterval = setInterval(() => {
+        this.cleanupOldWatermarks();
+      }, this.cleanupIntervalMs);
+    }
+    cleanupOldWatermarks() {
+      const now4 = Date.now();
+      const cutoffTime = now4 - this.maxWatermarkAge;
+      const cutoffTimestamp = Math.floor(cutoffTime / 1000);
+      let _removedCount = 0;
+      for (const [feedId, timestamp2] of this.waterMark) {
+        if (timestamp2 < cutoffTimestamp) {
+          this.waterMark.delete(feedId);
+          _removedCount++;
+        }
+      }
+    }
+    stop() {
+      if (this.cleanupInterval) {
+        clearInterval(this.cleanupInterval);
+        this.cleanupInterval = null;
+      }
+    }
+    getMemoryInfo() {
+      const watermarkCount = this.waterMark.size;
+      const estimatedMemoryBytes = watermarkCount * (64 + 8 + 32);
+      return {
+        watermarkCount,
+        estimatedMemoryBytes
+      };
+    }
+    exportWatermarks() {
+      return Array.from(this.waterMark.entries()).map(([feedId, timestamp2]) => ({
+        feedId,
+        timestamp: timestamp2
+      }));
+    }
+    importWatermarks(watermarks) {
+      for (const { feedId, timestamp: timestamp2 } of watermarks) {
+        this.waterMark.set(feedId, timestamp2);
+      }
+    }
+  }
+  exports6.ReportDeduplicator = ReportDeduplicator;
+});
+
+// node_modules/@chainlink/data-streams-sdk/dist/src/stream/index.js
+var require_stream = __commonJS((exports6) => {
+  Object.defineProperty(exports6, "__esModule", { value: true });
+  exports6.Stream = exports6.ConnectionType = undefined;
+  var events_1 = __require("events");
+  var stats_1 = require_stats();
+  var metrics_1 = require_metrics4();
+  var constants_1 = require_constants79();
+  var connection_manager_1 = require_connection_manager();
+  var deduplication_1 = require_deduplication();
+  var errors_1 = require_errors56();
+  var logger_1 = require_logger17();
+  var ConnectionType;
+  (function(ConnectionType2) {
+    ConnectionType2["Single"] = "single";
+    ConnectionType2["Multiple"] = "multiple";
+  })(ConnectionType || (exports6.ConnectionType = ConnectionType = {}));
+
+  class Stream4 extends events_1.EventEmitter {
+    constructor(config9, feedIds, options4 = {}) {
+      super();
+      this.isClosing = false;
+      this.origins = [];
+      this.config = config9;
+      this.feedIds = feedIds;
+      this.logger = new logger_1.SDKLogger(config9.logging);
+      this.options = {
+        reconnectInterval: options4.reconnectInterval || constants_1.WS_CONSTANTS.RECONNECT_DELAY,
+        maxReconnectAttempts: options4.maxReconnectAttempts || constants_1.WS_CONSTANTS.MAX_RECONNECTS
+      };
+      this.logger.debug(`Creating stream for feeds: ${feedIds.join(", ")}`);
+      this.logger.debug(`Stream options: reconnectInterval=${this.options.reconnectInterval}ms, maxReconnectAttempts=${this.options.maxReconnectAttempts}`);
+      const useHAMode = config9.haMode && this.parseOrigins().length > 1;
+      this.connectionType = useHAMode ? ConnectionType.Multiple : ConnectionType.Single;
+      this.logger.info(`Initializing stream in ${this.connectionType} mode`);
+      const expectedConnections = useHAMode ? this.parseOrigins().length : 1;
+      this.stats = new stats_1.StreamStats(expectedConnections);
+      this.logger.debug(`Expected connections: ${expectedConnections}`);
+      const managerConfig = {
+        feedIds: this.feedIds,
+        maxReconnectAttempts: this.options.maxReconnectAttempts,
+        reconnectInterval: this.options.reconnectInterval,
+        connectTimeout: config9.haConnectionTimeout || constants_1.WS_CONSTANTS.CONNECT_TIMEOUT,
+        haMode: config9.haMode || false,
+        haConnectionTimeout: config9.haConnectionTimeout || constants_1.WS_CONSTANTS.CONNECT_TIMEOUT,
+        statusCallback: config9.connectionStatusCallback
+      };
+      this.connectionManager = new connection_manager_1.ConnectionManager(config9, managerConfig);
+      this.deduplicator = new deduplication_1.ReportDeduplicator;
+      this.connectionManager.setStreamStats(this.stats);
+      this.setupConnectionManagerEvents();
+    }
+    parseOrigins() {
+      if (!this.config.wsEndpoint) {
+        return [];
+      }
+      return this.config.wsEndpoint.split(",").map((url3) => url3.trim()).filter((url3) => url3.length > 0);
+    }
+    setupConnectionManagerEvents() {
+      this.connectionManager.on("connection-established", (connection) => {
+        this.stats.setOriginStatus(connection.origin, metrics_1.ConnectionStatus.CONNECTED);
+      });
+      this.connectionManager.on("connection-lost", (connection, error56) => {
+        this.stats.setOriginStatus(connection.origin, metrics_1.ConnectionStatus.DISCONNECTED);
+        this.emit("connection-lost", connection, error56);
+      });
+      this.connectionManager.on("message", (data7, connection) => {
+        try {
+          const message5 = JSON.parse(data7.toString());
+          if (message5 && message5.report) {
+            const report = {
+              feedID: message5.report.feedID,
+              fullReport: message5.report.fullReport,
+              validFromTimestamp: message5.report.validFromTimestamp,
+              observationsTimestamp: message5.report.observationsTimestamp
+            };
+            this.logger.debug(`Received report for feed ${report.feedID} from ${connection.origin}`);
+            this.handleReport(report, connection.origin);
+          } else {
+            this.logger.warn(`Invalid message format received from ${connection.origin}`);
+            this.emit("error", new Error("Invalid message format"));
+          }
+        } catch (error56) {
+          this.logger.error(`Failed to parse WebSocket message from ${connection.origin}:`, error56);
+          this.emit("error", new Error("Failed to parse WebSocket message"));
+        }
+      });
+      this.connectionManager.on("reconnecting", (info11) => {
+        this.emit("reconnecting", info11);
+      });
+      this.connectionManager.on("all-connections-lost", () => {
+        this.logger.error("All connections lost - stream disconnected");
+        this.emit("disconnected");
+        this.emit("all-connections-lost");
+      });
+      this.connectionManager.on("partial-failure", (failedCount, totalCount) => {
+        this.logger.warn(`Partial connection failure: ${failedCount}/${totalCount} connections failed`);
+      });
+      this.connectionManager.on("connection-restored", (connection) => {
+        this.stats.setOriginStatus(connection.origin, metrics_1.ConnectionStatus.CONNECTED);
+        this.emit("connection-restored", connection);
+      });
+    }
+    handleReport(report, origin2) {
+      const result = this.deduplicator.processReport({
+        feedID: report.feedID,
+        observationsTimestamp: report.observationsTimestamp,
+        validFromTimestamp: report.validFromTimestamp,
+        fullReport: report.fullReport
+      });
+      const originInfo = origin2 ? ` from ${new URL(origin2).host}` : "";
+      if (result.isAccepted) {
+        this.stats.incrementAccepted();
+        this.logger.debug(`Report accepted for feed ${report.feedID}${originInfo} (timestamp: ${report.observationsTimestamp})`);
+        this.emit("report", report);
+      } else {
+        this.stats.incrementDeduplicated();
+        this.logger.debug(`Report deduplicated for feed ${report.feedID}${originInfo} (timestamp: ${report.observationsTimestamp})`);
+      }
+    }
+    async connect() {
+      this.logger.info(`Connecting stream in ${this.connectionType} mode`);
+      try {
+        await this.connectionManager.initialize();
+        const connectionDetails = this.connectionManager.getConnectionDetails();
+        this.origins = connectionDetails.map((conn) => conn.origin);
+        if (this.origins.length === 0) {
+          this.logger.error("No origins available for connection");
+          throw new errors_1.InsufficientConnectionsError("No origins available for connection", 0, 1);
+        }
+        this.connectionType = this.origins.length > 1 && this.config.haMode ? ConnectionType.Multiple : ConnectionType.Single;
+        this.stats.setConfiguredConnections(this.origins.length);
+        this.stats.setActiveConnections(this.connectionManager.getActiveConnectionCount());
+        this.logger.info(`Stream connected successfully with ${this.origins.length} origins: ${this.origins.join(", ")}`);
+      } catch (error56) {
+        if (error56 instanceof errors_1.OriginDiscoveryError) {
+          this.logger.warn("Origin discovery failed, falling back to single connection mode");
+          this.connectionType = ConnectionType.Single;
+          this.origins = this.parseOrigins().slice(0, 1);
+          this.stats.setConfiguredConnections(1);
+          this.stats.setActiveConnections(this.connectionManager.getActiveConnectionCount());
+          this.logger.info(`Fallback connection established to: ${this.origins[0]}`);
+        } else {
+          this.logger.error("Failed to connect stream:", error56);
+          throw error56;
+        }
+      }
+    }
+    async close() {
+      this.logger.info("Closing stream and shutting down connections");
+      this.isClosing = true;
+      await this.connectionManager.shutdown();
+      this.deduplicator.stop();
+      this.stats.setActiveConnections(0);
+      this.logger.info("Stream closed successfully");
+    }
+    async read() {
+      return new Promise((resolve7, reject) => {
+        const onReport = (report) => {
+          cleanup();
+          resolve7(report);
+        };
+        const onError = (error56) => {
+          cleanup();
+          reject(error56);
+        };
+        const cleanup = () => {
+          this.removeListener("report", onReport);
+          this.removeListener("error", onError);
+        };
+        this.once("report", onReport);
+        this.once("error", onError);
+      });
+    }
+    getMetrics() {
+      this.stats.setActiveConnections(this.connectionManager.getActiveConnectionCount());
+      this.stats.updateOriginStatuses(this.connectionManager.getOriginStatusMap());
+      return this.stats.getStats();
+    }
+    getConnectionType() {
+      return this.connectionType;
+    }
+    getOrigins() {
+      return [...this.origins];
+    }
+    getConnectionDetails() {
+      return this.connectionManager.getConnectionDetails();
+    }
+    getConnectionStates() {
+      return this.connectionManager.getConnectionStates();
+    }
+  }
+  exports6.Stream = Stream4;
+});
+
+// node_modules/@chainlink/data-streams-sdk/dist/src/client/implementation.js
+var require_implementation2 = __commonJS((exports6) => {
+  Object.defineProperty(exports6, "__esModule", { value: true });
+  exports6.DataStreamsClientImpl = undefined;
+  var base_1 = require_base26();
+  var validation_1 = require_validation3();
+  var stream_1 = require_stream();
+
+  class DataStreamsClientImpl extends base_1.BaseClient {
+    constructor(config9) {
+      super(config9);
+      this.validateHAConfiguration(config9);
+      this.logger.info("Data Streams client initialized");
+    }
+    validateHAConfiguration(config9) {
+      if (config9.haMode) {
+        const origins = this.parseOrigins(config9.wsEndpoint);
+        if (origins.length === 0) {
+          throw new Error("HA mode enabled but no WebSocket endpoints provided");
+        }
+      }
+      if (config9.wsEndpoint) {
+        const origins = this.parseOrigins(config9.wsEndpoint);
+        for (const origin2 of origins) {
+          if (!origin2.startsWith("ws://") && !origin2.startsWith("wss://")) {
+            throw new Error(`Invalid WebSocket URL format: ${origin2}. Must start with ws:// or wss://`);
+          }
+        }
+      }
+    }
+    parseOrigins(wsEndpoint) {
+      if (!wsEndpoint) {
+        return [];
+      }
+      return wsEndpoint.split(",").map((url3) => url3.trim()).filter((url3) => url3.length > 0);
+    }
+    async listFeeds() {
+      this.logger.debug("Fetching available feeds");
+      const response = await this.withRetry(() => this.makeRequest("/api/v1/feeds"));
+      this.logger.debug(`Retrieved ${response.feeds.length} feeds`);
+      return response.feeds;
+    }
+    async getLatestReport(feedId) {
+      (0, validation_1.validateFeedId)(feedId);
+      this.logger.debug(`Fetching latest report for feed ${feedId}`);
+      const response = await this.withRetry(() => this.makeRequest(`/api/v1/reports/latest?feedID=${feedId}`));
+      this.logger.debug(`Retrieved latest report for feed ${feedId} (timestamp: ${response.report.observationsTimestamp})`);
+      return response.report;
+    }
+    async getReportByTimestamp(feedId, timestamp2) {
+      (0, validation_1.validateFeedId)(feedId);
+      (0, validation_1.validateTimestamp)(timestamp2);
+      this.logger.debug(`Fetching report for feed ${feedId} at timestamp ${timestamp2}`);
+      const response = await this.withRetry(() => this.makeRequest(`/api/v1/reports?feedID=${feedId}&timestamp=${timestamp2}`));
+      this.logger.debug(`Retrieved report for feed ${feedId} at timestamp ${timestamp2}`);
+      return response.report;
+    }
+    async getReportsPage(feedId, startTime, limit2 = 10) {
+      (0, validation_1.validateFeedId)(feedId);
+      (0, validation_1.validateTimestamp)(startTime);
+      this.logger.debug(`Fetching ${limit2} reports for feed ${feedId} starting from timestamp ${startTime}`);
+      const response = await this.withRetry(() => this.makeRequest(`/api/v1/reports/page?feedID=${feedId}&startTimestamp=${startTime}&limit=${limit2}`));
+      this.logger.info(`Retrieved ${response.reports.length} reports for feed ${feedId} (requested: ${limit2})`);
+      return response.reports;
+    }
+    async getReportsBulk(feedIds, timestamp2) {
+      (0, validation_1.validateFeedIds)(feedIds);
+      (0, validation_1.validateTimestamp)(timestamp2);
+      this.logger.debug(`Fetching bulk reports for ${feedIds.length} feeds at timestamp ${timestamp2}`);
+      const response = await this.withRetry(() => this.makeRequest(`/api/v1/reports/bulk?feedIDs=${feedIds.join(",")}&timestamp=${timestamp2}`));
+      this.logger.info(`Retrieved ${response.reports.length} bulk reports for timestamp ${timestamp2}`);
+      return response.reports;
+    }
+    createStream(feedIds, options4) {
+      const feedIdArray = Array.isArray(feedIds) ? feedIds : [feedIds];
+      feedIdArray.forEach(validation_1.validateFeedId);
+      this.logger.debug(`Creating stream for ${feedIdArray.length} feeds: ${feedIdArray.join(", ")}`);
+      const streamOptions = options4 ? {
+        reconnectInterval: options4.reconnectInterval,
+        maxReconnectAttempts: options4.maxReconnectAttempts
+      } : {};
+      const stream4 = new stream_1.Stream(this.config, feedIdArray, streamOptions);
+      this.logger.info(`Stream created successfully for ${feedIdArray.length} feed(s)`);
+      return stream4;
+    }
+  }
+  exports6.DataStreamsClientImpl = DataStreamsClientImpl;
+});
+
+// node_modules/@chainlink/data-streams-sdk/dist/src/client/index.js
+var require_client18 = __commonJS((exports6) => {
+  Object.defineProperty(exports6, "__esModule", { value: true });
+  exports6.DataStreamsClientImpl = undefined;
+  exports6.createClient = createClient8;
+  var implementation_1 = require_implementation2();
+  Object.defineProperty(exports6, "DataStreamsClientImpl", { enumerable: true, get: function() {
+    return implementation_1.DataStreamsClientImpl;
+  } });
+  function createClient8(config9) {
+    return new implementation_1.DataStreamsClientImpl(config9);
+  }
+});
+
+// node_modules/@chainlink/data-streams-sdk/dist/src/types/report.js
+var require_report = __commonJS((exports6) => {
+  Object.defineProperty(exports6, "__esModule", { value: true });
+  exports6.Ripcord = exports6.MarketStatus = undefined;
+  var MarketStatus;
+  (function(MarketStatus2) {
+    MarketStatus2[MarketStatus2["UNKNOWN"] = 0] = "UNKNOWN";
+    MarketStatus2[MarketStatus2["INACTIVE"] = 1] = "INACTIVE";
+    MarketStatus2[MarketStatus2["ACTIVE"] = 2] = "ACTIVE";
+  })(MarketStatus || (exports6.MarketStatus = MarketStatus = {}));
+  var Ripcord;
+  (function(Ripcord2) {
+    Ripcord2[Ripcord2["NORMAL"] = 0] = "NORMAL";
+    Ripcord2[Ripcord2["PAUSED"] = 1] = "PAUSED";
+  })(Ripcord || (exports6.Ripcord = Ripcord = {}));
+});
+
+// node_modules/@chainlink/data-streams-sdk/dist/src/types/client.js
+var require_client19 = __commonJS((exports6) => {
+  Object.defineProperty(exports6, "__esModule", { value: true });
+});
+
+// node_modules/@chainlink/data-streams-sdk/dist/src/types/index.js
+var require_types102 = __commonJS((exports6) => {
+  var __createBinding = exports6 && exports6.__createBinding || (Object.create ? function(o4, m2, k2, k22) {
+    if (k22 === undefined)
+      k22 = k2;
+    var desc = Object.getOwnPropertyDescriptor(m2, k2);
+    if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m2[k2];
+      } };
+    }
+    Object.defineProperty(o4, k22, desc);
+  } : function(o4, m2, k2, k22) {
+    if (k22 === undefined)
+      k22 = k2;
+    o4[k22] = m2[k2];
+  });
+  var __exportStar = exports6 && exports6.__exportStar || function(m2, exports7) {
+    for (var p in m2)
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports7, p))
+        __createBinding(exports7, m2, p);
+  };
+  Object.defineProperty(exports6, "__esModule", { value: true });
+  __exportStar(require_report(), exports6);
+  __exportStar(require_errors56(), exports6);
+  __exportStar(require_client19(), exports6);
+});
+
+// node_modules/@chainlink/data-streams-sdk/dist/src/decoder/implementation.js
+var require_implementation3 = __commonJS((exports6) => {
+  Object.defineProperty(exports6, "__esModule", { value: true });
+  exports6.decodeReport = decodeReport;
+  var ethers_1 = require_lib6();
+  var errors_1 = require_errors56();
+  var types_1 = require_types102();
+  var globalAbiCoder = new ethers_1.AbiCoder;
+  var outerReportAbiCoder = new ethers_1.AbiCoder;
+  var reportSchemaV2 = [
+    { type: "bytes32", name: "feedId" },
+    { type: "uint32", name: "validFromTimestamp" },
+    { type: "uint32", name: "observationsTimestamp" },
+    { type: "uint192", name: "nativeFee" },
+    { type: "uint192", name: "linkFee" },
+    { type: "uint32", name: "expiresAt" },
+    { type: "int192", name: "price" }
+  ];
+  var reportSchemaV3 = [
+    { type: "bytes32", name: "feedId" },
+    { type: "uint32", name: "validFromTimestamp" },
+    { type: "uint32", name: "observationsTimestamp" },
+    { type: "uint192", name: "nativeFee" },
+    { type: "uint192", name: "linkFee" },
+    { type: "uint32", name: "expiresAt" },
+    { type: "int192", name: "price" },
+    { type: "int192", name: "bid" },
+    { type: "int192", name: "ask" }
+  ];
+  var reportSchemaV4 = [
+    { type: "bytes32", name: "feedId" },
+    { type: "uint32", name: "validFromTimestamp" },
+    { type: "uint32", name: "observationsTimestamp" },
+    { type: "uint192", name: "nativeFee" },
+    { type: "uint192", name: "linkFee" },
+    { type: "uint32", name: "expiresAt" },
+    { type: "int192", name: "price" },
+    { type: "uint8", name: "marketStatus" }
+  ];
+  var reportSchemaV5 = [
+    { type: "bytes32", name: "feedId" },
+    { type: "uint32", name: "validFromTimestamp" },
+    { type: "uint32", name: "observationsTimestamp" },
+    { type: "uint192", name: "nativeFee" },
+    { type: "uint192", name: "linkFee" },
+    { type: "uint32", name: "expiresAt" },
+    { type: "int192", name: "rate" },
+    { type: "uint32", name: "timestamp" },
+    { type: "uint32", name: "duration" }
+  ];
+  var reportSchemaV6 = [
+    { type: "bytes32", name: "feedId" },
+    { type: "uint32", name: "validFromTimestamp" },
+    { type: "uint32", name: "observationsTimestamp" },
+    { type: "uint192", name: "nativeFee" },
+    { type: "uint192", name: "linkFee" },
+    { type: "uint32", name: "expiresAt" },
+    { type: "int192", name: "price" },
+    { type: "int192", name: "price2" },
+    { type: "int192", name: "price3" },
+    { type: "int192", name: "price4" },
+    { type: "int192", name: "price5" }
+  ];
+  var reportSchemaV7 = [
+    { type: "bytes32", name: "feedId" },
+    { type: "uint32", name: "validFromTimestamp" },
+    { type: "uint32", name: "observationsTimestamp" },
+    { type: "uint192", name: "nativeFee" },
+    { type: "uint192", name: "linkFee" },
+    { type: "uint32", name: "expiresAt" },
+    { type: "int192", name: "exchangeRate" }
+  ];
+  var reportSchemaV8 = [
+    { type: "bytes32", name: "feedId" },
+    { type: "uint32", name: "validFromTimestamp" },
+    { type: "uint32", name: "observationsTimestamp" },
+    { type: "uint192", name: "nativeFee" },
+    { type: "uint192", name: "linkFee" },
+    { type: "uint32", name: "expiresAt" },
+    { type: "uint64", name: "lastUpdateTimestamp" },
+    { type: "int192", name: "midPrice" },
+    { type: "uint32", name: "marketStatus" }
+  ];
+  var reportSchemaV9 = [
+    { type: "bytes32", name: "feedId" },
+    { type: "uint32", name: "validFromTimestamp" },
+    { type: "uint32", name: "observationsTimestamp" },
+    { type: "uint192", name: "nativeFee" },
+    { type: "uint192", name: "linkFee" },
+    { type: "uint32", name: "expiresAt" },
+    { type: "int192", name: "navPerShare" },
+    { type: "uint64", name: "navDate" },
+    { type: "int192", name: "aum" },
+    { type: "uint32", name: "ripcord" }
+  ];
+  var reportSchemaV10 = [
+    { type: "bytes32", name: "feedId" },
+    { type: "uint32", name: "validFromTimestamp" },
+    { type: "uint32", name: "observationsTimestamp" },
+    { type: "uint192", name: "nativeFee" },
+    { type: "uint192", name: "linkFee" },
+    { type: "uint32", name: "expiresAt" },
+    { type: "uint64", name: "lastUpdateTimestamp" },
+    { type: "int192", name: "price" },
+    { type: "uint32", name: "marketStatus" },
+    { type: "int192", name: "currentMultiplier" },
+    { type: "int192", name: "newMultiplier" },
+    { type: "uint32", name: "activationDateTime" },
+    { type: "int192", name: "tokenizedPrice" }
+  ];
+  var reportSchemaV11 = [
+    { type: "bytes32", name: "feedId" },
+    { type: "uint32", name: "validFromTimestamp" },
+    { type: "uint32", name: "observationsTimestamp" },
+    { type: "uint192", name: "nativeFee" },
+    { type: "uint192", name: "linkFee" },
+    { type: "uint32", name: "expiresAt" },
+    { type: "int192", name: "mid" },
+    { type: "uint64", name: "lastSeenTimestampNs" },
+    { type: "int192", name: "bid" },
+    { type: "int192", name: "bidVolume" },
+    { type: "int192", name: "ask" },
+    { type: "int192", name: "askVolume" },
+    { type: "int192", name: "lastTradedPrice" },
+    { type: "uint32", name: "marketStatus" }
+  ];
+  var reportSchemaV12 = [
+    { type: "bytes32", name: "feedId" },
+    { type: "uint32", name: "validFromTimestamp" },
+    { type: "uint32", name: "observationsTimestamp" },
+    { type: "uint192", name: "nativeFee" },
+    { type: "uint192", name: "linkFee" },
+    { type: "uint32", name: "expiresAt" },
+    { type: "int192", name: "navPerShare" },
+    { type: "int192", name: "nextNavPerShare" },
+    { type: "uint64", name: "navDate" },
+    { type: "uint32", name: "ripcord" }
+  ];
+  var reportSchemaV13 = [
+    { type: "bytes32", name: "feedId" },
+    { type: "uint32", name: "validFromTimestamp" },
+    { type: "uint32", name: "observationsTimestamp" },
+    { type: "uint192", name: "nativeFee" },
+    { type: "uint192", name: "linkFee" },
+    { type: "uint32", name: "expiresAt" },
+    { type: "int192", name: "bestAsk" },
+    { type: "int192", name: "bestBid" },
+    { type: "uint64", name: "askVolume" },
+    { type: "uint64", name: "bidVolume" },
+    { type: "int192", name: "lastTradedPrice" }
+  ];
+  function decodeReport(reportHex, feedId, logger106) {
+    logger106?.debug(`Decoding report for feed ${feedId}`);
+    try {
+      if (!(0, ethers_1.isHexString)(reportHex)) {
+        throw new errors_1.ReportDecodingError("Report hex string must start with 0x");
+      }
+      const version18 = feedId.slice(2, 6);
+      logger106?.debug(`Detected report version: V${version18.slice(2)}`);
+      const fullReportAbi = [
+        { type: "bytes32[3]", name: "reportContext" },
+        { type: "bytes", name: "reportBlob" },
+        { type: "bytes32[]", name: "rawRs" },
+        { type: "bytes32[]", name: "rawSs" },
+        { type: "bytes32", name: "rawVs" }
+      ];
+      const decodedFullReport = outerReportAbiCoder.decode(fullReportAbi.map((item) => item.type), reportHex);
+      const reportBlob = decodedFullReport[1];
+      switch (version18) {
+        case "0002":
+          return decodeV2Report(reportBlob);
+        case "0003":
+          return decodeV3Report(reportBlob);
+        case "0004":
+          return decodeV4Report(reportBlob);
+        case "0005":
+          return decodeV5Report(reportBlob);
+        case "0006":
+          return decodeV6Report(reportBlob);
+        case "0007":
+          return decodeV7Report(reportBlob);
+        case "0008":
+          return decodeV8Report(reportBlob);
+        case "0009":
+          return decodeV9Report(reportBlob);
+        case "000a":
+          return decodeV10Report(reportBlob);
+        case "000b":
+          return decodeV11Report(reportBlob);
+        case "000c":
+          return decodeV12Report(reportBlob);
+        case "000d":
+          return decodeV13Report(reportBlob);
+        default:
+          throw new errors_1.ReportDecodingError(`Unknown report version: 0x${version18}`);
+      }
+    } catch (error56) {
+      if (error56 instanceof errors_1.ReportDecodingError) {
+        throw error56;
+      }
+      throw new errors_1.ReportDecodingError(`Failed to decode report: ${error56 instanceof Error ? error56.message : String(error56)}`);
+    }
+  }
+  function decodeV2Report(reportBlob) {
+    try {
+      const decoded = globalAbiCoder.decode(reportSchemaV2.map((item) => item.type), (0, ethers_1.getBytes)(reportBlob));
+      return {
+        version: "V2",
+        nativeFee: decoded[3],
+        linkFee: decoded[4],
+        expiresAt: Number(decoded[5]),
+        price: decoded[6]
+      };
+    } catch (error56) {
+      throw new errors_1.ReportDecodingError(`Failed to decode V2 report: ${error56 instanceof Error ? error56.message : String(error56)}`);
+    }
+  }
+  function decodeV3Report(reportBlob) {
+    try {
+      const decoded = globalAbiCoder.decode(reportSchemaV3.map((item) => item.type), (0, ethers_1.getBytes)(reportBlob));
+      return {
+        version: "V3",
+        nativeFee: decoded[3],
+        linkFee: decoded[4],
+        expiresAt: Number(decoded[5]),
+        price: decoded[6],
+        bid: decoded[7],
+        ask: decoded[8]
+      };
+    } catch (error56) {
+      throw new errors_1.ReportDecodingError(`Failed to decode V3 report: ${error56 instanceof Error ? error56.message : String(error56)}`);
+    }
+  }
+  function decodeV4Report(reportBlob) {
+    try {
+      const decoded = globalAbiCoder.decode(reportSchemaV4.map((item) => item.type), (0, ethers_1.getBytes)(reportBlob));
+      const marketStatus = Number(decoded[7]);
+      if (marketStatus !== types_1.MarketStatus.UNKNOWN && marketStatus !== types_1.MarketStatus.INACTIVE && marketStatus !== types_1.MarketStatus.ACTIVE) {
+        throw new errors_1.ReportDecodingError(`Invalid market status: ${marketStatus}`);
+      }
+      return {
+        version: "V4",
+        nativeFee: decoded[3],
+        linkFee: decoded[4],
+        expiresAt: Number(decoded[5]),
+        price: decoded[6],
+        marketStatus
+      };
+    } catch (error56) {
+      throw new errors_1.ReportDecodingError(`Failed to decode V4 report: ${error56 instanceof Error ? error56.message : String(error56)}`);
+    }
+  }
+  function decodeV5Report(reportBlob) {
+    try {
+      const decoded = globalAbiCoder.decode(reportSchemaV5.map((item) => item.type), (0, ethers_1.getBytes)(reportBlob));
+      return {
+        version: "V5",
+        nativeFee: decoded[3],
+        linkFee: decoded[4],
+        expiresAt: Number(decoded[5]),
+        rate: decoded[6],
+        timestamp: Number(decoded[7]),
+        duration: Number(decoded[8])
+      };
+    } catch (error56) {
+      throw new errors_1.ReportDecodingError(`Failed to decode V5 report: ${error56 instanceof Error ? error56.message : String(error56)}`);
+    }
+  }
+  function decodeV6Report(reportBlob) {
+    try {
+      const decoded = globalAbiCoder.decode(reportSchemaV6.map((item) => item.type), (0, ethers_1.getBytes)(reportBlob));
+      return {
+        version: "V6",
+        nativeFee: decoded[3],
+        linkFee: decoded[4],
+        expiresAt: Number(decoded[5]),
+        price: decoded[6],
+        price2: decoded[7],
+        price3: decoded[8],
+        price4: decoded[9],
+        price5: decoded[10]
+      };
+    } catch (error56) {
+      throw new errors_1.ReportDecodingError(`Failed to decode V6 report: ${error56 instanceof Error ? error56.message : String(error56)}`);
+    }
+  }
+  function decodeV7Report(reportBlob) {
+    try {
+      const decoded = globalAbiCoder.decode(reportSchemaV7.map((item) => item.type), (0, ethers_1.getBytes)(reportBlob));
+      return {
+        version: "V7",
+        nativeFee: decoded[3],
+        linkFee: decoded[4],
+        expiresAt: Number(decoded[5]),
+        exchangeRate: decoded[6]
+      };
+    } catch (error56) {
+      throw new errors_1.ReportDecodingError(`Failed to decode V7 report: ${error56 instanceof Error ? error56.message : String(error56)}`);
+    }
+  }
+  function decodeV8Report(reportBlob) {
+    try {
+      const decoded = globalAbiCoder.decode(reportSchemaV8.map((item) => item.type), (0, ethers_1.getBytes)(reportBlob));
+      const marketStatus = Number(decoded[8]);
+      if (marketStatus !== types_1.MarketStatus.UNKNOWN && marketStatus !== types_1.MarketStatus.INACTIVE && marketStatus !== types_1.MarketStatus.ACTIVE) {
+        throw new errors_1.ReportDecodingError(`Invalid market status: ${marketStatus}`);
+      }
+      return {
+        version: "V8",
+        nativeFee: decoded[3],
+        linkFee: decoded[4],
+        expiresAt: Number(decoded[5]),
+        lastUpdateTimestamp: Number(decoded[6]),
+        midPrice: decoded[7],
+        marketStatus
+      };
+    } catch (error56) {
+      throw new errors_1.ReportDecodingError(`Failed to decode V8 report: ${error56 instanceof Error ? error56.message : String(error56)}`);
+    }
+  }
+  function decodeV9Report(reportBlob) {
+    try {
+      const decoded = globalAbiCoder.decode(reportSchemaV9.map((item) => item.type), (0, ethers_1.getBytes)(reportBlob));
+      const ripcord = Number(decoded[9]);
+      if (ripcord !== types_1.Ripcord.NORMAL && ripcord !== types_1.Ripcord.PAUSED) {
+        throw new errors_1.ReportDecodingError(`Invalid ripcord value: ${ripcord}. Must be 0 (normal) or 1 (paused)`);
+      }
+      return {
+        version: "V9",
+        nativeFee: decoded[3],
+        linkFee: decoded[4],
+        expiresAt: Number(decoded[5]),
+        navPerShare: decoded[6],
+        navDate: Number(decoded[7]),
+        aum: decoded[8],
+        ripcord
+      };
+    } catch (error56) {
+      throw new errors_1.ReportDecodingError(`Failed to decode V9 report: ${error56 instanceof Error ? error56.message : String(error56)}`);
+    }
+  }
+  function decodeV10Report(reportBlob) {
+    try {
+      const decoded = globalAbiCoder.decode(reportSchemaV10.map((item) => item.type), (0, ethers_1.getBytes)(reportBlob));
+      const marketStatus = Number(decoded[8]);
+      if (marketStatus !== types_1.MarketStatus.UNKNOWN && marketStatus !== types_1.MarketStatus.INACTIVE && marketStatus !== types_1.MarketStatus.ACTIVE) {
+        throw new errors_1.ReportDecodingError(`Invalid market status: ${marketStatus}`);
+      }
+      return {
+        version: "V10",
+        nativeFee: decoded[3],
+        linkFee: decoded[4],
+        expiresAt: Number(decoded[5]),
+        lastUpdateTimestamp: Number(decoded[6]),
+        price: decoded[7],
+        marketStatus,
+        currentMultiplier: decoded[9],
+        newMultiplier: decoded[10],
+        activationDateTime: Number(decoded[11]),
+        tokenizedPrice: decoded[12]
+      };
+    } catch (error56) {
+      throw new errors_1.ReportDecodingError(`Failed to decode V10 report: ${error56 instanceof Error ? error56.message : String(error56)}`);
+    }
+  }
+  function decodeV11Report(reportBlob) {
+    try {
+      const decoded = globalAbiCoder.decode(reportSchemaV11.map((item) => item.type), (0, ethers_1.getBytes)(reportBlob));
+      return {
+        version: "V11",
+        nativeFee: decoded[3],
+        linkFee: decoded[4],
+        expiresAt: Number(decoded[5]),
+        mid: decoded[6],
+        lastSeenTimestampNs: decoded[7],
+        bid: decoded[8],
+        bidVolume: decoded[9],
+        ask: decoded[10],
+        askVolume: decoded[11],
+        lastTradedPrice: decoded[12],
+        marketStatus: Number(decoded[13])
+      };
+    } catch (error56) {
+      throw new errors_1.ReportDecodingError(`Failed to decode V11 report: ${error56 instanceof Error ? error56.message : String(error56)}`);
+    }
+  }
+  function decodeV12Report(reportBlob) {
+    try {
+      const decoded = globalAbiCoder.decode(reportSchemaV12.map((item) => item.type), (0, ethers_1.getBytes)(reportBlob));
+      const ripcord = Number(decoded[9]);
+      if (ripcord !== types_1.Ripcord.NORMAL && ripcord !== types_1.Ripcord.PAUSED) {
+        throw new errors_1.ReportDecodingError(`Invalid ripcord value: ${ripcord}. Must be 0 (normal) or 1 (paused)`);
+      }
+      return {
+        version: "V12",
+        nativeFee: decoded[3],
+        linkFee: decoded[4],
+        expiresAt: Number(decoded[5]),
+        navPerShare: decoded[6],
+        nextNavPerShare: decoded[7],
+        navDate: Number(decoded[8]),
+        ripcord
+      };
+    } catch (error56) {
+      throw new errors_1.ReportDecodingError(`Failed to decode V12 report: ${error56 instanceof Error ? error56.message : String(error56)}`);
+    }
+  }
+  function decodeV13Report(reportBlob) {
+    try {
+      const decoded = globalAbiCoder.decode(reportSchemaV13.map((item) => item.type), (0, ethers_1.getBytes)(reportBlob));
+      return {
+        version: "V13",
+        nativeFee: decoded[3],
+        linkFee: decoded[4],
+        expiresAt: Number(decoded[5]),
+        bestAsk: decoded[6],
+        bestBid: decoded[7],
+        askVolume: Number(decoded[8]),
+        bidVolume: Number(decoded[9]),
+        lastTradedPrice: decoded[10]
+      };
+    } catch (error56) {
+      throw new errors_1.ReportDecodingError(`Failed to decode V13 report: ${error56 instanceof Error ? error56.message : String(error56)}`);
+    }
+  }
+});
+
+// node_modules/@chainlink/data-streams-sdk/dist/src/decoder/index.js
+var require_decoder12 = __commonJS((exports6) => {
+  Object.defineProperty(exports6, "__esModule", { value: true });
+  exports6.decodeReport = undefined;
+  var implementation_1 = require_implementation3();
+  Object.defineProperty(exports6, "decodeReport", { enumerable: true, get: function() {
+    return implementation_1.decodeReport;
+  } });
+});
+
+// node_modules/@chainlink/data-streams-sdk/dist/src/utils/time.js
+var require_time5 = __commonJS((exports6) => {
+  Object.defineProperty(exports6, "__esModule", { value: true });
+  exports6.getCurrentTimestamp = getCurrentTimestamp;
+  exports6.getThirtyDaysAgoTimestamp = getThirtyDaysAgoTimestamp;
+  exports6.isTimestampWithinLast30Days = isTimestampWithinLast30Days;
+  exports6.validateTimestampWithin30Days = validateTimestampWithin30Days;
+  var errors_1 = require_errors56();
+  function getCurrentTimestamp() {
+    return Math.floor(Date.now() / 1000);
+  }
+  function getThirtyDaysAgoTimestamp() {
+    return getCurrentTimestamp() - 30 * 24 * 60 * 60;
+  }
+  function isTimestampWithinLast30Days(timestamp2) {
+    return timestamp2 >= getThirtyDaysAgoTimestamp();
+  }
+  function validateTimestampWithin30Days(timestamp2) {
+    if (!isTimestampWithinLast30Days(timestamp2)) {
+      throw new errors_1.ValidationError(`Timestamp ${timestamp2} is not within the last 30 days. ` + `Earliest allowed timestamp is ${getThirtyDaysAgoTimestamp()}`);
+    }
+  }
+});
+
+// node_modules/@chainlink/data-streams-sdk/dist/src/utils/report.js
+var require_report2 = __commonJS((exports6) => {
+  Object.defineProperty(exports6, "__esModule", { value: true });
+  exports6.getReportVersion = getReportVersion;
+  exports6.formatReport = formatReport;
+  var types_1 = require_types102();
+  function getReportVersion(feedId) {
+    const schemaVersion = feedId.slice(2, 6);
+    switch (schemaVersion) {
+      case "0002":
+        return "V2";
+      case "0003":
+        return "V3";
+      case "0004":
+        return "V4";
+      case "0005":
+        return "V5";
+      case "0006":
+        return "V6";
+      case "0007":
+        return "V7";
+      case "0008":
+        return "V8";
+      case "0009":
+        return "V9";
+      case "000a":
+        return "V10";
+      case "000b":
+        return "V11";
+      case "000c":
+        return "V12";
+      case "000d":
+        return "V13";
+      default:
+        throw new Error(`Unknown schema version: 0x${schemaVersion}`);
+    }
+  }
+  function formatReport(report, version18) {
+    let output4 = "";
+    output4 += `
+Report Metadata:
+`;
+    output4 += `Feed ID: ${report.feedID}
+`;
+    output4 += `Valid From: ${report.validFromTimestamp}
+`;
+    output4 += `Observations: ${report.observationsTimestamp}
+`;
+    output4 += `
+Decoded Data:
+`;
+    output4 += `Native Fee: ${report.nativeFee.toString()}
+`;
+    output4 += `LINK Fee: ${report.linkFee.toString()}
+`;
+    output4 += `Expires At: ${report.expiresAt}
+`;
+    switch (version18) {
+      case "V2": {
+        const r2 = report;
+        output4 += `Price: ${r2.price.toString()}
+`;
+        break;
+      }
+      case "V3": {
+        const r2 = report;
+        output4 += `Price: ${r2.price.toString()}
+`;
+        output4 += `Bid Price: ${r2.bid.toString()}
+`;
+        output4 += `Ask Price: ${r2.ask.toString()}
+`;
+        break;
+      }
+      case "V4": {
+        const r2 = report;
+        output4 += `Price: ${r2.price.toString()}
+`;
+        output4 += `Market Status: ${types_1.MarketStatus[r2.marketStatus]} (${r2.marketStatus})
+`;
+        break;
+      }
+      case "V5": {
+        const r2 = report;
+        output4 += `Rate: ${r2.rate.toString()}
+`;
+        output4 += `Rate Timestamp: ${r2.timestamp}
+`;
+        output4 += `Duration: ${r2.duration}
+`;
+        break;
+      }
+      case "V6": {
+        const r2 = report;
+        output4 += `Price: ${r2.price.toString()}
+`;
+        output4 += `Price2: ${r2.price2.toString()}
+`;
+        output4 += `Price3: ${r2.price3.toString()}
+`;
+        output4 += `Price4: ${r2.price4.toString()}
+`;
+        output4 += `Price5: ${r2.price5.toString()}
+`;
+        break;
+      }
+      case "V7": {
+        const r2 = report;
+        output4 += `Exchange Rate: ${r2.exchangeRate.toString()}
+`;
+        break;
+      }
+      case "V8": {
+        const r2 = report;
+        output4 += `Mid Price: ${r2.midPrice.toString()}
+`;
+        output4 += `Last Update: ${r2.lastUpdateTimestamp}
+`;
+        output4 += `Market Status: ${types_1.MarketStatus[r2.marketStatus]} (${r2.marketStatus})
+`;
+        break;
+      }
+      case "V9": {
+        const r2 = report;
+        output4 += `NAV per Share: ${r2.navPerShare.toString()}
+`;
+        output4 += `NAV Date: ${r2.navDate}
+`;
+        output4 += `AUM: ${r2.aum.toString()}
+`;
+        output4 += `Ripcord: ${r2.ripcord === 0 ? `Normal (${r2.ripcord})` : `PAUSED - DO NOT CONSUME (${r2.ripcord})`}
+`;
+        break;
+      }
+      case "V10": {
+        const r2 = report;
+        output4 += `Price: ${r2.price.toString()}
+`;
+        output4 += `Last Update: ${r2.lastUpdateTimestamp}
+`;
+        output4 += `Market Status: ${types_1.MarketStatus[r2.marketStatus]} (${r2.marketStatus})
+`;
+        output4 += `Current Multiplier: ${r2.currentMultiplier.toString()}
+`;
+        output4 += `New Multiplier: ${r2.newMultiplier.toString()}
+`;
+        output4 += `Activation Date: ${r2.activationDateTime}
+`;
+        output4 += `Tokenized Price: ${r2.tokenizedPrice.toString()}
+`;
+        break;
+      }
+      case "V11": {
+        const r2 = report;
+        output4 += `Mid: ${r2.mid.toString()}
+`;
+        output4 += `Last Seen Timestamp Nanos: ${r2.lastSeenTimestampNs.toString()}
+`;
+        output4 += `Bid: ${r2.bid.toString()}
+`;
+        output4 += `Bid Volume: ${r2.bidVolume.toString()}
+`;
+        output4 += `Ask: ${r2.ask.toString()}
+`;
+        output4 += `Ask Volume: ${r2.askVolume.toString()}
+`;
+        output4 += `Last Traded Price: ${r2.lastTradedPrice.toString()}
+`;
+        output4 += `Market Status: ${r2.marketStatus.toString()}
+`;
+        break;
+      }
+      case "V12": {
+        const r2 = report;
+        output4 += `NAV per Share: ${r2.navPerShare.toString()}
+`;
+        output4 += `Next NAV per Share: ${r2.nextNavPerShare.toString()}
+`;
+        output4 += `NAV Date: ${r2.navDate}
+`;
+        output4 += `Ripcord: ${r2.ripcord === 0 ? `Normal (${r2.ripcord})` : `PAUSED - DO NOT CONSUME (${r2.ripcord})`}
+`;
+        break;
+      }
+      case "V13": {
+        const r2 = report;
+        output4 += `Best Ask: ${r2.bestAsk.toString()}
+`;
+        output4 += `Best Bid: ${r2.bestBid.toString()}
+`;
+        output4 += `Ask Volume: ${r2.askVolume.toString()}
+`;
+        output4 += `Bid Volume: ${r2.bidVolume.toString()}
+`;
+        output4 += `Last Traded Price: ${r2.lastTradedPrice.toString()}
+`;
+        break;
+      }
+    }
+    output4 += "-".repeat(50);
+    return output4;
+  }
+});
+
+// node_modules/@chainlink/data-streams-sdk/dist/src/utils/index.js
+var require_utils193 = __commonJS((exports6) => {
+  var __createBinding = exports6 && exports6.__createBinding || (Object.create ? function(o4, m2, k2, k22) {
+    if (k22 === undefined)
+      k22 = k2;
+    var desc = Object.getOwnPropertyDescriptor(m2, k2);
+    if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m2[k2];
+      } };
+    }
+    Object.defineProperty(o4, k22, desc);
+  } : function(o4, m2, k2, k22) {
+    if (k22 === undefined)
+      k22 = k2;
+    o4[k22] = m2[k2];
+  });
+  var __exportStar = exports6 && exports6.__exportStar || function(m2, exports7) {
+    for (var p in m2)
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports7, p))
+        __createBinding(exports7, m2, p);
+  };
+  Object.defineProperty(exports6, "__esModule", { value: true });
+  __exportStar(require_constants79(), exports6);
+  __exportStar(require_time5(), exports6);
+  __exportStar(require_auth2(), exports6);
+  __exportStar(require_logger17(), exports6);
+  __exportStar(require_report2(), exports6);
+  __exportStar(require_origin_discovery(), exports6);
+  __exportStar(require_validation3(), exports6);
+});
+
+// node_modules/@chainlink/data-streams-sdk/dist/src/defaultConfig.js
+var require_defaultConfig = __commonJS((exports6) => {
+  Object.defineProperty(exports6, "__esModule", { value: true });
+  exports6.DEFAULT_CONFIG = undefined;
+  var constants_1 = require_constants79();
+  exports6.DEFAULT_CONFIG = {
+    endpoint: "https://api.testnet-dataengine.chain.link",
+    wsEndpoint: "wss://ws.testnet-dataengine.chain.link",
+    retryAttempts: constants_1.DEFAULT_RETRY_ATTEMPTS,
+    retryDelay: constants_1.DEFAULT_RETRY_DELAY,
+    timeout: constants_1.DEFAULT_TIMEOUT,
+    haMode: false,
+    haConnectionTimeout: constants_1.WS_CONSTANTS.CONNECT_TIMEOUT,
+    logging: undefined
+  };
+});
+
+// node_modules/@chainlink/data-streams-sdk/dist/src/index.js
+var require_src41 = __commonJS((exports6) => {
+  var __createBinding = exports6 && exports6.__createBinding || (Object.create ? function(o4, m2, k2, k22) {
+    if (k22 === undefined)
+      k22 = k2;
+    var desc = Object.getOwnPropertyDescriptor(m2, k2);
+    if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m2[k2];
+      } };
+    }
+    Object.defineProperty(o4, k22, desc);
+  } : function(o4, m2, k2, k22) {
+    if (k22 === undefined)
+      k22 = k2;
+    o4[k22] = m2[k2];
+  });
+  var __exportStar = exports6 && exports6.__exportStar || function(m2, exports7) {
+    for (var p in m2)
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports7, p))
+        __createBinding(exports7, m2, p);
+  };
+  Object.defineProperty(exports6, "__esModule", { value: true });
+  exports6.DEFAULT_RETRY_DELAY = exports6.DEFAULT_RETRY_ATTEMPTS = exports6.DEFAULT_TIMEOUT = exports6.DEFAULT_CONFIG = exports6.generateAuthHeaders = exports6.getCurrentTimestamp = exports6.formatReport = exports6.getReportVersion = exports6.ConnectionStatus = exports6.LogLevel = exports6.Stream = exports6.decodeReport = exports6.createClient = undefined;
+  var client_1 = require_client18();
+  Object.defineProperty(exports6, "createClient", { enumerable: true, get: function() {
+    return client_1.createClient;
+  } });
+  var decoder_1 = require_decoder12();
+  Object.defineProperty(exports6, "decodeReport", { enumerable: true, get: function() {
+    return decoder_1.decodeReport;
+  } });
+  var stream_1 = require_stream();
+  Object.defineProperty(exports6, "Stream", { enumerable: true, get: function() {
+    return stream_1.Stream;
+  } });
+  var logger_1 = require_logger16();
+  Object.defineProperty(exports6, "LogLevel", { enumerable: true, get: function() {
+    return logger_1.LogLevel;
+  } });
+  var metrics_1 = require_metrics4();
+  Object.defineProperty(exports6, "ConnectionStatus", { enumerable: true, get: function() {
+    return metrics_1.ConnectionStatus;
+  } });
+  __exportStar(require_errors56(), exports6);
+  var utils_1 = require_utils193();
+  Object.defineProperty(exports6, "getReportVersion", { enumerable: true, get: function() {
+    return utils_1.getReportVersion;
+  } });
+  Object.defineProperty(exports6, "formatReport", { enumerable: true, get: function() {
+    return utils_1.formatReport;
+  } });
+  Object.defineProperty(exports6, "getCurrentTimestamp", { enumerable: true, get: function() {
+    return utils_1.getCurrentTimestamp;
+  } });
+  Object.defineProperty(exports6, "generateAuthHeaders", { enumerable: true, get: function() {
+    return utils_1.generateAuthHeaders;
+  } });
+  var defaultConfig_1 = require_defaultConfig();
+  Object.defineProperty(exports6, "DEFAULT_CONFIG", { enumerable: true, get: function() {
+    return defaultConfig_1.DEFAULT_CONFIG;
+  } });
+  var constants_1 = require_constants79();
+  Object.defineProperty(exports6, "DEFAULT_TIMEOUT", { enumerable: true, get: function() {
+    return constants_1.DEFAULT_TIMEOUT;
+  } });
+  Object.defineProperty(exports6, "DEFAULT_RETRY_ATTEMPTS", { enumerable: true, get: function() {
+    return constants_1.DEFAULT_RETRY_ATTEMPTS;
+  } });
+  Object.defineProperty(exports6, "DEFAULT_RETRY_DELAY", { enumerable: true, get: function() {
+    return constants_1.DEFAULT_RETRY_DELAY;
+  } });
+});
+
+// src/infra/chainlink/streams.ts
+function isStreamsConfigured() {
+  return Boolean(process.env[CHAINLINK_ENV_KEYS.API_KEY] && process.env[CHAINLINK_ENV_KEYS.API_SECRET]);
+}
+function getClient4() {
+  if (_client)
+    return _client;
+  if (!isStreamsConfigured()) {
+    throw new Error("Chainlink Data Streams not configured. Set CHAINLINK_API_KEY and CHAINLINK_API_SECRET environment variables.");
+  }
+  _client = import_data_streams_sdk.createClient({
+    apiKey: process.env[CHAINLINK_ENV_KEYS.API_KEY],
+    userSecret: process.env[CHAINLINK_ENV_KEYS.API_SECRET],
+    endpoint: STREAMS_BASE_URL,
+    wsEndpoint: STREAMS_BASE_URL.replace("https://", "wss://").replace("api.", "ws.")
+  });
+  return _client;
+}
+function resolveFeedId(pairOrFeedId) {
+  if (pairOrFeedId.startsWith("0x"))
+    return pairOrFeedId;
+  const normalized = pairOrFeedId.toUpperCase().replace("-", "/");
+  const pair = normalized.includes("/") ? normalized : `${normalized}/USD`;
+  const feedId = STREAMS_FEED_IDS[pair];
+  if (!feedId) {
+    throw new Error(`Unknown feed pair "${pair}". Available: ${Object.keys(STREAMS_FEED_IDS).join(", ")}. ` + `You can also provide a raw feed ID (0x...).`);
+  }
+  return feedId;
+}
+function feedIdToPair(feedId) {
+  for (const [pair, id4] of Object.entries(STREAMS_FEED_IDS)) {
+    if (id4.toLowerCase() === feedId.toLowerCase())
+      return pair;
+  }
+  return feedId;
+}
+function toStreamsReport(rawReport, feedId) {
+  const decoded = import_data_streams_sdk.decodeReport(rawReport.fullReport, rawReport.feedID);
+  const price = toNumber9(decoded.price ?? decoded.benchmarkPrice ?? 0n, decoded.decimals);
+  const bid = toNumber9(decoded.bid ?? price, decoded.decimals);
+  const ask = toNumber9(decoded.ask ?? price, decoded.decimals);
+  const timestamp2 = Number(decoded.observationsTimestamp ?? rawReport.observationsTimestamp ?? 0);
+  const validFrom = Number(decoded.validFromTimestamp ?? rawReport.validFromTimestamp ?? timestamp2);
+  const expiresAt = Number(decoded.expiresAt ?? 0);
+  return {
+    feedId,
+    pair: feedIdToPair(feedId),
+    price: typeof price === "number" ? price : Number(price),
+    bid: typeof bid === "number" ? bid : Number(bid),
+    ask: typeof ask === "number" ? ask : Number(ask),
+    timestamp: timestamp2,
+    validFromTimestamp: validFrom,
+    expiresAt
+  };
+}
+function toNumber9(value2, decimals) {
+  if (typeof value2 === "number")
+    return value2;
+  if (typeof value2 === "bigint") {
+    const dec2 = typeof decimals === "number" ? decimals : typeof decimals === "bigint" ? Number(decimals) : 18;
+    return Number(value2) / Math.pow(10, dec2);
+  }
+  return parseFloat(String(value2)) || 0;
+}
+async function getLatestReport(pairOrFeedId) {
+  const feedId = resolveFeedId(pairOrFeedId);
+  const client4 = getClient4();
+  const report = await client4.getLatestReport(feedId);
+  return toStreamsReport(report, feedId);
+}
+async function getReportAtTimestamp(pairOrFeedId, timestamp2) {
+  const feedId = resolveFeedId(pairOrFeedId);
+  const client4 = getClient4();
+  const report = await client4.getReportByTimestamp(feedId, timestamp2);
+  return toStreamsReport(report, feedId);
+}
+async function getBulkReports(pairsOrFeedIds) {
+  const feedIds = pairsOrFeedIds.map(resolveFeedId);
+  const client4 = getClient4();
+  const now4 = Math.floor(Date.now() / 1000);
+  const reports = await client4.getReportsBulk(feedIds, now4);
+  const results = Array.isArray(reports) ? reports : [reports];
+  return results.map((raw, i2) => toStreamsReport(raw, feedIds[i2] ?? "unknown"));
+}
+function listAvailableFeeds() {
+  return Object.entries(STREAMS_FEED_IDS).map(([pair, feedId]) => ({
+    pair,
+    feedId
+  }));
+}
+var import_data_streams_sdk, _client = null;
+var init_streams = __esm(() => {
+  init_types53();
+  import_data_streams_sdk = __toESM(require_src41(), 1);
+});
+
+// src/infra/chainlink/feeds.ts
+async function ethCall(rpcUrl, to3, data7) {
+  const response = await fetch(rpcUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "eth_call",
+      params: [{ to: to3, data: data7 }, "latest"]
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`RPC request failed: ${response.status} ${response.statusText}`);
+  }
+  const json8 = await response.json();
+  if (json8.error) {
+    throw new Error(`eth_call error: ${json8.error.message}`);
+  }
+  if (!json8.result || json8.result === "0x") {
+    throw new Error("eth_call returned empty result \u2014 contract may not exist at this address");
+  }
+  return json8.result;
+}
+function decodeLatestRoundData(hex29) {
+  const data7 = hex29.startsWith("0x") ? hex29.slice(2) : hex29;
+  const roundId = BigInt("0x" + data7.slice(0, 64)).toString();
+  const answer = BigInt("0x" + data7.slice(64, 128));
+  const updatedAt = Number(BigInt("0x" + data7.slice(192, 256)));
+  return { roundId, answer, updatedAt };
+}
+function decodeDecimals(hex29) {
+  const data7 = hex29.startsWith("0x") ? hex29.slice(2) : hex29;
+  return Number(BigInt("0x" + data7));
+}
+async function readFeed(chainName, aggregatorAddress, pair) {
+  const rpcUrl = getRpcUrl(chainName);
+  const [roundDataHex, decimalsHex] = await Promise.all([
+    ethCall(rpcUrl, aggregatorAddress, FEED_SELECTORS.latestRoundData),
+    ethCall(rpcUrl, aggregatorAddress, FEED_SELECTORS.decimals)
+  ]);
+  const { roundId, answer, updatedAt } = decodeLatestRoundData(roundDataHex);
+  const decimals = decodeDecimals(decimalsHex);
+  const price = Number(answer) / Math.pow(10, decimals);
+  return {
+    chain: chainName,
+    pair: pair || "UNKNOWN",
+    price,
+    decimals,
+    roundId,
+    updatedAt,
+    aggregatorAddress
+  };
+}
+async function readFeedByPair(chainName, pair) {
+  const normalized = pair.toUpperCase().replace("-", "/");
+  const key5 = `${chainName}:${normalized}`;
+  const aggregatorAddress = FEED_DIRECTORY[key5];
+  if (!aggregatorAddress) {
+    const available = Object.keys(FEED_DIRECTORY).filter((k2) => k2.startsWith(`${chainName}:`)).map((k2) => k2.split(":")[1]);
+    if (available.length === 0) {
+      throw new Error(`No Data Feeds available for chain "${chainName}". ` + `Supported chains: ${[...new Set(Object.keys(FEED_DIRECTORY).map((k2) => k2.split(":")[0]))].join(", ")}`);
+    }
+    throw new Error(`Data Feed "${normalized}" not found on ${chainName}. ` + `Available: ${available.join(", ")}. ` + `Or provide a custom aggregator address.`);
+  }
+  return readFeed(chainName, aggregatorAddress, normalized);
+}
+async function comparePrices(pair, chainName = "ethereum", streamPrice) {
+  const feedResult = await readFeedByPair(chainName, pair);
+  let streamsPrice = streamPrice ?? null;
+  if (streamsPrice === null && isStreamsConfigured()) {
+    try {
+      const report = await getLatestReport(pair);
+      streamsPrice = report.price;
+    } catch {
+      streamsPrice = null;
+    }
+  }
+  const deltaPercent = streamsPrice !== null ? (feedResult.price - streamsPrice) / streamsPrice * 100 : null;
+  return {
+    pair: feedResult.pair,
+    onChainPrice: feedResult.price,
+    streamsPrice,
+    deltaPercent,
+    onChainUpdatedAt: feedResult.updatedAt,
+    chain: chainName
+  };
+}
+var init_feeds = __esm(() => {
+  init_types53();
+  init_streams();
+});
+
+// src/infra/chainlink/ccip.ts
+function isCCIPConfigured() {
+  return Boolean(process.env[CHAINLINK_ENV_KEYS.EVM_PRIVATE_KEY]);
+}
+function getWallet(chainName) {
+  const privateKey = process.env[CHAINLINK_ENV_KEYS.EVM_PRIVATE_KEY];
+  if (!privateKey) {
+    throw new Error("CCIP not configured. Set EVM_PRIVATE_KEY environment variable.");
+  }
+  const rpcUrl = getRpcUrl(chainName);
+  const provider = new JsonRpcProvider(rpcUrl);
+  const key5 = privateKey.startsWith("0x") ? privateKey : `0x${privateKey}`;
+  return new Wallet(key5, provider);
+}
+function getChainConfig3(chainName) {
+  const config9 = CCIP_CHAINS[chainName.toLowerCase()];
+  if (!config9) {
+    throw new Error(`Chain "${chainName}" not supported for CCIP. ` + `Supported: ${Object.keys(CCIP_CHAINS).join(", ")}`);
+  }
+  return config9;
+}
+function buildCCIPMessage(recipient, tokenAddress, amount, feeToken) {
+  const abiCoder = AbiCoder.defaultAbiCoder();
+  const receiver = abiCoder.encode(["address"], [recipient]);
+  const extraArgs = "0x97a657c9" + abiCoder.encode(["uint256"], [200000n]).slice(2);
+  return {
+    receiver,
+    data: "0x",
+    tokenAmounts: [{ token: tokenAddress, amount }],
+    feeToken,
+    extraArgs
+  };
+}
+function getSupportedChains3() {
+  return Object.entries(CCIP_CHAINS).map(([chain5, config9]) => ({
+    chain: chain5,
+    selector: config9.selector,
+    tokens: Object.keys(config9.supportedTokens)
+  }));
+}
+async function getCCIPFee(sourceChain, destChain, tokenSymbol, amount, recipient, decimals = 18) {
+  const sourceConfig = getChainConfig3(sourceChain);
+  const destConfig = getChainConfig3(destChain);
+  const tokenAddress = sourceConfig.supportedTokens[tokenSymbol.toUpperCase()];
+  if (!tokenAddress) {
+    throw new Error(`Token "${tokenSymbol}" not supported on ${sourceChain} for CCIP. ` + `Available: ${Object.keys(sourceConfig.supportedTokens).join(", ")}`);
+  }
+  const wallet3 = getWallet(sourceChain);
+  const router = new Contract(sourceConfig.router, CCIP_ROUTER_ABI, wallet3);
+  const amountWei = parseUnits(amount, decimals);
+  const linkFeeMessage = buildCCIPMessage(recipient, tokenAddress, amountWei, sourceConfig.linkToken);
+  const nativeFeeMessage = buildCCIPMessage(recipient, tokenAddress, amountWei, "0x0000000000000000000000000000000000000000");
+  const getFee2 = router.getFunction("getFee");
+  const [feeInLink, feeInNative] = await Promise.all([
+    getFee2(destConfig.selector, linkFeeMessage),
+    getFee2(destConfig.selector, nativeFeeMessage)
+  ]);
+  return {
+    sourceChain,
+    destChain,
+    token: tokenSymbol,
+    amount,
+    feeInLink: formatUnits(feeInLink, 18),
+    feeInNative: formatUnits(feeInNative, 18)
+  };
+}
+async function executeCCIPTransfer(sourceChain, destChain, tokenSymbol, amount, recipient, payFeesInLink = false, decimals = 18) {
+  if (!isCCIPConfigured()) {
+    throw new Error("CCIP not configured. Set EVM_PRIVATE_KEY environment variable.");
+  }
+  const sourceConfig = getChainConfig3(sourceChain);
+  const destConfig = getChainConfig3(destChain);
+  const tokenAddress = sourceConfig.supportedTokens[tokenSymbol.toUpperCase()];
+  if (!tokenAddress) {
+    throw new Error(`Token "${tokenSymbol}" not supported on ${sourceChain} for CCIP. ` + `Available: ${Object.keys(sourceConfig.supportedTokens).join(", ")}`);
+  }
+  const wallet3 = getWallet(sourceChain);
+  const amountWei = parseUnits(amount, decimals);
+  const tokenContract = new Contract(tokenAddress, ERC20_APPROVE_ABI, wallet3);
+  const tokenApprove = tokenContract.getFunction("approve");
+  const approveTx = await tokenApprove(sourceConfig.router, amountWei);
+  await approveTx.wait();
+  const feeToken = payFeesInLink ? sourceConfig.linkToken : "0x0000000000000000000000000000000000000000";
+  const message5 = buildCCIPMessage(recipient, tokenAddress, amountWei, feeToken);
+  const router = new Contract(sourceConfig.router, CCIP_ROUTER_ABI, wallet3);
+  const routerGetFee = router.getFunction("getFee");
+  const fee3 = await routerGetFee(destConfig.selector, message5);
+  if (payFeesInLink) {
+    const linkContract = new Contract(sourceConfig.linkToken, ERC20_APPROVE_ABI, wallet3);
+    const linkApprove = linkContract.getFunction("approve");
+    const linkApproveTx = await linkApprove(sourceConfig.router, fee3);
+    await linkApproveTx.wait();
+  }
+  const ccipSend = router.getFunction("ccipSend");
+  const tx = await ccipSend(destConfig.selector, message5, {
+    value: payFeesInLink ? 0n : fee3
+  });
+  const receipt = await tx.wait();
+  const messageId = receipt?.logs?.[receipt.logs.length - 1]?.topics?.[1] ?? "unknown";
+  return {
+    txHash: receipt?.hash ?? tx.hash,
+    messageId,
+    sourceChain,
+    destChain,
+    token: tokenSymbol,
+    amount,
+    recipient
+  };
+}
+async function getCCIPStatus(messageId) {
+  const url3 = `https://ccip.chain.link/api/h/atlas/message/${messageId}`;
+  const response = await fetch(url3, {
+    headers: { Accept: "application/json" }
+  });
+  if (!response.ok) {
+    if (response.status === 404) {
+      return {
+        messageId,
+        status: "pending",
+        sourceChain: "unknown",
+        destChain: "unknown",
+        timestamp: null
+      };
+    }
+    throw new Error(`CCIP Explorer error ${response.status}: ${await response.text()}`);
+  }
+  const data7 = await response.json();
+  return {
+    messageId,
+    status: String(data7.state || data7.status || "unknown"),
+    sourceChain: String(data7.sourceChainName || data7.sourceNetwork || "unknown"),
+    destChain: String(data7.destChainName || data7.destNetwork || "unknown"),
+    timestamp: data7.timestamp ? Number(data7.timestamp) : null
+  };
+}
+var init_ccip7 = __esm(() => {
+  init_lib2();
+  init_types53();
+});
+
+// src/infra/chainlink/index.ts
+var init_chainlink = __esm(() => {
+  init_types53();
+  init_streams();
+  init_feeds();
+  init_ccip7();
+});
+
+// src/infra/agents/tools/chainlink-streams.ts
+var chainlinkGetPriceTool, chainlinkGetPriceAtTool, chainlinkBulkPricesTool, chainlinkListFeedsTool, chainlinkStreamsTools;
+var init_chainlink_streams = __esm(() => {
+  init_tools();
+  init_zod();
+  init_chainlink();
+  chainlinkGetPriceTool = createTool({
+    id: "chainlink_get_price",
+    description: "Get the latest institutional-grade price for a crypto pair from Chainlink Data Streams. " + "Returns price, bid, ask, and timestamp. Supports BTC/USD, ETH/USD, SOL/USD, LINK/USD, and more. " + "Requires CHAINLINK_API_KEY and CHAINLINK_API_SECRET.",
+    inputSchema: exports_external.object({
+      pair: exports_external.string().describe('Price pair (e.g., "BTC/USD", "ETH/USD") or raw Chainlink feed ID (0x...)')
+    }),
+    outputSchema: exports_external.object({
+      success: exports_external.boolean(),
+      data: exports_external.unknown().optional(),
+      error: exports_external.string().optional()
+    }),
+    execute: async ({ pair }) => {
+      if (!isStreamsConfigured()) {
+        return {
+          success: false,
+          error: "Chainlink Data Streams not configured. Set CHAINLINK_API_KEY and CHAINLINK_API_SECRET."
+        };
+      }
+      try {
+        const report = await getLatestReport(pair);
+        return { success: true, data: report };
+      } catch (error56) {
+        return { success: false, error: error56.message };
+      }
+    }
+  });
+  chainlinkGetPriceAtTool = createTool({
+    id: "chainlink_get_price_at",
+    description: "Get a historical Chainlink Data Streams price at a specific timestamp. " + "Useful for checking what the price was at a particular moment in time.",
+    inputSchema: exports_external.object({
+      pair: exports_external.string().describe('Price pair (e.g., "BTC/USD") or raw feed ID (0x...)'),
+      timestamp: exports_external.number().describe("Unix timestamp in seconds to query the price at")
+    }),
+    outputSchema: exports_external.object({
+      success: exports_external.boolean(),
+      data: exports_external.unknown().optional(),
+      error: exports_external.string().optional()
+    }),
+    execute: async ({ pair, timestamp: timestamp2 }) => {
+      if (!isStreamsConfigured()) {
+        return {
+          success: false,
+          error: "Chainlink Data Streams not configured. Set CHAINLINK_API_KEY and CHAINLINK_API_SECRET."
+        };
+      }
+      try {
+        const report = await getReportAtTimestamp(pair, timestamp2);
+        return { success: true, data: report };
+      } catch (error56) {
+        return { success: false, error: error56.message };
+      }
+    }
+  });
+  chainlinkBulkPricesTool = createTool({
+    id: "chainlink_bulk_prices",
+    description: "Get latest prices for multiple crypto pairs in a single Chainlink Data Streams API call. " + "More efficient than calling chainlink_get_price multiple times.",
+    inputSchema: exports_external.object({
+      pairs: exports_external.array(exports_external.string()).min(1).max(20).describe('Array of price pairs (e.g., ["BTC/USD", "ETH/USD", "SOL/USD"])')
+    }),
+    outputSchema: exports_external.object({
+      success: exports_external.boolean(),
+      data: exports_external.unknown().optional(),
+      error: exports_external.string().optional()
+    }),
+    execute: async ({ pairs: pairs2 }) => {
+      if (!isStreamsConfigured()) {
+        return {
+          success: false,
+          error: "Chainlink Data Streams not configured. Set CHAINLINK_API_KEY and CHAINLINK_API_SECRET."
+        };
+      }
+      try {
+        const reports = await getBulkReports(pairs2);
+        return { success: true, data: reports };
+      } catch (error56) {
+        return { success: false, error: error56.message };
+      }
+    }
+  });
+  chainlinkListFeedsTool = createTool({
+    id: "chainlink_list_feeds",
+    description: "List all available Chainlink Data Streams feed IDs and their corresponding pairs. " + "Use this to discover which crypto pairs are available for price queries.",
+    inputSchema: exports_external.object({}),
+    outputSchema: exports_external.object({
+      success: exports_external.boolean(),
+      data: exports_external.unknown().optional()
+    }),
+    execute: async () => {
+      const feeds = listAvailableFeeds();
+      return { success: true, data: feeds };
+    }
+  });
+  chainlinkStreamsTools = {
+    chainlink_get_price: chainlinkGetPriceTool,
+    chainlink_get_price_at: chainlinkGetPriceAtTool,
+    chainlink_bulk_prices: chainlinkBulkPricesTool,
+    chainlink_list_feeds: chainlinkListFeedsTool
+  };
+});
+
+// src/infra/agents/tools/chainlink-feeds.ts
+var chainlinkReadFeedTool, chainlinkComparePricesTool, chainlinkFeedsTools;
+var init_chainlink_feeds = __esm(() => {
+  init_tools();
+  init_zod();
+  init_chainlink();
+  chainlinkReadFeedTool = createTool({
+    id: "chainlink_read_feed",
+    description: "Read the latest price from a Chainlink on-chain Data Feed (aggregator contract). " + "Free \u2014 no API key needed. Reads directly from the blockchain via eth_call. " + "Supports multiple EVM chains: ethereum, arbitrum, base, polygon, optimism, avalanche, bnb. " + "You can specify a pair (e.g., ETH/USD) or a custom aggregator address.",
+    inputSchema: exports_external.object({
+      chain: exports_external.string().default("ethereum").describe('EVM chain name (e.g., "ethereum", "arbitrum", "base", "polygon")'),
+      pair: exports_external.string().optional().describe('Price pair (e.g., "ETH/USD", "BTC/USD"). Use this OR aggregatorAddress.'),
+      aggregatorAddress: exports_external.string().optional().describe("Custom aggregator proxy contract address (0x...). Use this OR pair.")
+    }),
+    outputSchema: exports_external.object({
+      success: exports_external.boolean(),
+      data: exports_external.unknown().optional(),
+      error: exports_external.string().optional()
+    }),
+    execute: async ({ chain: chain5, pair, aggregatorAddress }) => {
+      try {
+        if (aggregatorAddress) {
+          const result = await readFeed(chain5, aggregatorAddress, pair);
+          return { success: true, data: result };
+        }
+        if (pair) {
+          const result = await readFeedByPair(chain5, pair);
+          return { success: true, data: result };
+        }
+        return { success: false, error: "Provide either 'pair' or 'aggregatorAddress'." };
+      } catch (error56) {
+        return { success: false, error: error56.message };
+      }
+    }
+  });
+  chainlinkComparePricesTool = createTool({
+    id: "chainlink_compare_prices",
+    description: "Compare a Chainlink on-chain Data Feed price with the Chainlink Data Streams price for the same pair. " + "Shows the delta percentage between the two sources. Useful for detecting price manipulation or confirming fair value. " + "Data Streams requires API keys; on-chain feed is free.",
+    inputSchema: exports_external.object({
+      pair: exports_external.string().describe('Price pair to compare (e.g., "ETH/USD", "BTC/USD")'),
+      chain: exports_external.string().default("ethereum").describe('Chain to read on-chain feed from (default: "ethereum")')
+    }),
+    outputSchema: exports_external.object({
+      success: exports_external.boolean(),
+      data: exports_external.unknown().optional(),
+      error: exports_external.string().optional()
+    }),
+    execute: async ({ pair, chain: chain5 }) => {
+      try {
+        const result = await comparePrices(pair, chain5);
+        return { success: true, data: result };
+      } catch (error56) {
+        return { success: false, error: error56.message };
+      }
+    }
+  });
+  chainlinkFeedsTools = {
+    chainlink_read_feed: chainlinkReadFeedTool,
+    chainlink_compare_prices: chainlinkComparePricesTool
+  };
+});
+
+// src/infra/agents/tools/chainlink-ccip.ts
+var chainlinkCCIPSupportedChainsTool, chainlinkCCIPGetFeeTool, chainlinkCCIPTransferTool, chainlinkCCIPStatusTool, chainlinkCCIPTools;
+var init_chainlink_ccip = __esm(() => {
+  init_tools();
+  init_zod();
+  init_chainlink();
+  chainlinkCCIPSupportedChainsTool = createTool({
+    id: "chainlink_ccip_supported_chains",
+    description: "List all chains and tokens supported by Chainlink CCIP for cross-chain transfers. " + "Shows which EVM chains can send/receive tokens and what tokens are available on each.",
+    inputSchema: exports_external.object({}),
+    outputSchema: exports_external.object({
+      success: exports_external.boolean(),
+      data: exports_external.unknown().optional()
+    }),
+    execute: async () => {
+      const chains5 = getSupportedChains3();
+      return { success: true, data: chains5 };
+    }
+  });
+  chainlinkCCIPGetFeeTool = createTool({
+    id: "chainlink_ccip_get_fee",
+    description: "Estimate the fee for a Chainlink CCIP cross-chain token transfer. " + "Returns fee in both LINK and native token. Does NOT execute the transfer. " + "Requires EVM_PRIVATE_KEY to query the router contract.",
+    inputSchema: exports_external.object({
+      sourceChain: exports_external.string().describe('Source chain (e.g., "ethereum", "arbitrum", "base")'),
+      destChain: exports_external.string().describe('Destination chain (e.g., "arbitrum", "optimism", "polygon")'),
+      token: exports_external.string().describe('Token symbol to transfer (e.g., "USDC", "LINK", "WETH")'),
+      amount: exports_external.string().describe('Amount to transfer in human-readable format (e.g., "100.5")'),
+      recipient: exports_external.string().describe("Recipient address on the destination chain (0x...)"),
+      decimals: exports_external.number().default(18).describe("Token decimals (default 18, USDC=6)")
+    }),
+    outputSchema: exports_external.object({
+      success: exports_external.boolean(),
+      data: exports_external.unknown().optional(),
+      error: exports_external.string().optional()
+    }),
+    execute: async ({ sourceChain, destChain, token: token2, amount, recipient, decimals }) => {
+      if (!isCCIPConfigured()) {
+        return {
+          success: false,
+          error: "CCIP not configured. Set EVM_PRIVATE_KEY environment variable."
+        };
+      }
+      try {
+        const fee3 = await getCCIPFee(sourceChain, destChain, token2, amount, recipient, decimals);
+        return { success: true, data: fee3 };
+      } catch (error56) {
+        return { success: false, error: error56.message };
+      }
+    }
+  });
+  chainlinkCCIPTransferTool = createTool({
+    id: "chainlink_ccip_transfer",
+    description: "Execute a cross-chain token transfer using Chainlink CCIP. " + "Transfers tokens between EVM chains (e.g., Ethereum -> Arbitrum). " + "REQUIRES ARMED MODE. Confirm transfer details with user before executing. " + "Flow: approve -> estimate fee -> ccipSend. Requires EVM_PRIVATE_KEY.",
+    inputSchema: exports_external.object({
+      sourceChain: exports_external.string().describe('Source chain (e.g., "ethereum", "arbitrum")'),
+      destChain: exports_external.string().describe('Destination chain (e.g., "arbitrum", "base")'),
+      token: exports_external.string().describe('Token symbol (e.g., "USDC", "LINK", "WETH")'),
+      amount: exports_external.string().describe('Amount to transfer (e.g., "100.5")'),
+      recipient: exports_external.string().describe("Recipient address on destination chain (0x...)"),
+      payFeesInLink: exports_external.boolean().default(false).describe("Pay fees in LINK (true) or native token (false, default)"),
+      decimals: exports_external.number().default(18).describe("Token decimals (default 18, USDC=6)")
+    }),
+    outputSchema: exports_external.object({
+      success: exports_external.boolean(),
+      data: exports_external.unknown().optional(),
+      error: exports_external.string().optional()
+    }),
+    execute: async ({ sourceChain, destChain, token: token2, amount, recipient, payFeesInLink, decimals }) => {
+      if (!isCCIPConfigured()) {
+        return {
+          success: false,
+          error: "CCIP not configured. Set EVM_PRIVATE_KEY environment variable."
+        };
+      }
+      try {
+        const result = await executeCCIPTransfer(sourceChain, destChain, token2, amount, recipient, payFeesInLink, decimals);
+        return { success: true, data: result };
+      } catch (error56) {
+        return { success: false, error: error56.message };
+      }
+    }
+  });
+  chainlinkCCIPStatusTool = createTool({
+    id: "chainlink_ccip_status",
+    description: "Check the status of a Chainlink CCIP cross-chain transfer by its message ID. " + "Returns the transfer state (pending, in-flight, success, failed).",
+    inputSchema: exports_external.object({
+      messageId: exports_external.string().describe("The CCIP message ID returned from chainlink_ccip_transfer")
+    }),
+    outputSchema: exports_external.object({
+      success: exports_external.boolean(),
+      data: exports_external.unknown().optional(),
+      error: exports_external.string().optional()
+    }),
+    execute: async ({ messageId }) => {
+      try {
+        const status = await getCCIPStatus(messageId);
+        return { success: true, data: status };
+      } catch (error56) {
+        return { success: false, error: error56.message };
+      }
+    }
+  });
+  chainlinkCCIPTools = {
+    chainlink_ccip_supported_chains: chainlinkCCIPSupportedChainsTool,
+    chainlink_ccip_get_fee: chainlinkCCIPGetFeeTool,
+    chainlink_ccip_transfer: chainlinkCCIPTransferTool,
+    chainlink_ccip_status: chainlinkCCIPStatusTool
+  };
+});
+
 // src/infra/agents/tools/position-tracking.ts
 async function getManager() {
   return getPositionManager(getEventBus());
@@ -2785318,7 +2788448,7 @@ var init_runtime_tools = __esm(() => {
 
 // src/core/regime/types.ts
 var MarketRegimeSchema, RegimeMetricsSchema, RegimeSignalSchema, RegimeSpanSchema, RegimeHistorySchema, MultiTimeframeRegimeSchema;
-var init_types53 = __esm(() => {
+var init_types54 = __esm(() => {
   init_zod();
   MarketRegimeSchema = exports_external.enum([
     "trending_up",
@@ -2785546,7 +2788676,7 @@ var init_watcher = __esm(() => {
 
 // src/core/regime/index.ts
 var init_regime = __esm(() => {
-  init_types53();
+  init_types54();
   init_classifier();
   init_detector();
   init_watcher();
@@ -2785558,7 +2788688,7 @@ var init_regime_tools = __esm(() => {
   init_tools();
   init_zod();
   init_regime();
-  init_types53();
+  init_types54();
   init_types9();
   init_logger2();
   logger112 = createModuleLogger("regime-tools");
@@ -2786235,7 +2789365,7 @@ var init_advanced_tools = __esm(() => {
 
 // src/core/genome/types.ts
 var MutationSchema2, GenomeSchema, ExperimentSchema, MutationSuggestionSchema;
-var init_types54 = __esm(() => {
+var init_types55 = __esm(() => {
   init_zod();
   MutationSchema2 = exports_external.object({
     mutation_id: exports_external.string().uuid(),
@@ -2786762,7 +2789892,7 @@ __export(exports_genome, {
   EvolutionLoop: () => EvolutionLoop
 });
 var init_genome = __esm(() => {
-  init_types54();
+  init_types55();
   init_manager3();
   init_mutator();
   init_fitness();
@@ -2790281,6 +2793411,9 @@ var init_tools7 = __esm(async () => {
   init_uniswap_data();
   init_dex_search();
   init_defillama_yields();
+  init_chainlink_streams();
+  init_chainlink_feeds();
+  init_chainlink_ccip();
   init_position_tracking();
   init_risk_gate();
   init_memory_tools();
@@ -2790344,6 +2793477,9 @@ var init_tools7 = __esm(async () => {
   init_uniswap_data();
   init_dex_search();
   init_defillama_yields();
+  init_chainlink_streams();
+  init_chainlink_feeds();
+  init_chainlink_ccip();
   init_position_tracking();
   init_risk_gate();
   init_memory_tools();
@@ -2790411,6 +2793547,9 @@ var init_tools7 = __esm(async () => {
     ...uniswapDataTools,
     ...dexSearchTools,
     ...defillamaYieldTools,
+    ...chainlinkStreamsTools,
+    ...chainlinkFeedsTools,
+    ...chainlinkCCIPTools,
     ...multiModalChartTools,
     ...evalTools,
     ...positionTrackingTools,
@@ -2790469,6 +2793608,9 @@ var init_tools7 = __esm(async () => {
     uniswapData: Object.keys(uniswapDataTools).length,
     dexSearch: Object.keys(dexSearchTools).length,
     defillamaYields: Object.keys(defillamaYieldTools).length,
+    chainlinkStreams: Object.keys(chainlinkStreamsTools).length,
+    chainlinkFeeds: Object.keys(chainlinkFeedsTools).length,
+    chainlinkCCIP: Object.keys(chainlinkCCIPTools).length,
     multiModalCharts: Object.keys(multiModalChartTools).length,
     evals: Object.keys(evalTools).length,
     positionTracking: Object.keys(positionTrackingTools).length,
@@ -2790869,7 +2794011,7 @@ var require_url5 = __commonJS((exports6) => {
 });
 
 // node_modules/@apidevtools/json-schema-ref-parser/dist/lib/util/errors.js
-var require_errors56 = __commonJS((exports6) => {
+var require_errors57 = __commonJS((exports6) => {
   Object.defineProperty(exports6, "__esModule", { value: true });
   exports6.InvalidPointerError = exports6.TimeoutError = exports6.MissingPointerError = exports6.UnmatchedResolverError = exports6.ResolverError = exports6.UnmatchedParserError = exports6.ParserError = exports6.JSONParserErrorGroup = exports6.JSONParserError = undefined;
   exports6.toJSON = toJSON;
@@ -2791090,7 +2794232,7 @@ var require_pointer = __commonJS((exports6) => {
   exports6.nullSymbol = undefined;
   var ref_js_1 = __importDefault(require_ref3());
   var url3 = __importStar(require_url5());
-  var errors_js_1 = require_errors56();
+  var errors_js_1 = require_errors57();
   exports6.nullSymbol = Symbol("null");
   var slashes = /\//g;
   var tildes = /~/g;
@@ -2791307,7 +2794449,7 @@ var require_ref3 = __commonJS((exports6) => {
   }();
   Object.defineProperty(exports6, "__esModule", { value: true });
   var pointer_js_1 = __importStar(require_pointer());
-  var errors_js_1 = require_errors56();
+  var errors_js_1 = require_errors57();
   var url_js_1 = require_url5();
 
   class $Ref {
@@ -2791693,7 +2794835,7 @@ var require_parse21 = __commonJS((exports6) => {
   Object.defineProperty(exports6, "__esModule", { value: true });
   var url3 = __importStar(require_url5());
   var plugins = __importStar(require_plugins2());
-  var errors_js_1 = require_errors56();
+  var errors_js_1 = require_errors57();
   async function parse26(path8, $refs, options4) {
     const hashIndex = path8.indexOf("#");
     let hash12 = "";
@@ -2791776,7 +2794918,7 @@ Parsed value is empty`);
 // node_modules/@apidevtools/json-schema-ref-parser/dist/lib/parsers/json.js
 var require_json12 = __commonJS((exports6) => {
   Object.defineProperty(exports6, "__esModule", { value: true });
-  var errors_js_1 = require_errors56();
+  var errors_js_1 = require_errors57();
   exports6.default = {
     order: 100,
     allowEmpty: true,
@@ -2791819,7 +2794961,7 @@ var require_yaml = __commonJS((exports6) => {
     return mod11 && mod11.__esModule ? mod11 : { default: mod11 };
   };
   Object.defineProperty(exports6, "__esModule", { value: true });
-  var errors_js_1 = require_errors56();
+  var errors_js_1 = require_errors57();
   var js_yaml_1 = __importDefault(require_js_yaml3());
   var js_yaml_2 = require_js_yaml3();
   exports6.default = {
@@ -2791851,7 +2794993,7 @@ var require_yaml = __commonJS((exports6) => {
 // node_modules/@apidevtools/json-schema-ref-parser/dist/lib/parsers/text.js
 var require_text = __commonJS((exports6) => {
   Object.defineProperty(exports6, "__esModule", { value: true });
-  var errors_js_1 = require_errors56();
+  var errors_js_1 = require_errors57();
   var TEXT_REGEXP = /\.(txt|htm|html|md|xml|js|min|map|css|scss|less|svg)$/i;
   exports6.default = {
     order: 300,
@@ -2791944,7 +2795086,7 @@ var require_file = __commonJS((exports6) => {
   Object.defineProperty(exports6, "__esModule", { value: true });
   var fs_1 = __importDefault(__require("fs"));
   var url3 = __importStar(require_url5());
-  var errors_js_1 = require_errors56();
+  var errors_js_1 = require_errors57();
   exports6.default = {
     order: 100,
     canRead(file2) {
@@ -2792021,7 +2795163,7 @@ var require_http17 = __commonJS((exports6) => {
   }();
   Object.defineProperty(exports6, "__esModule", { value: true });
   var url3 = __importStar(require_url5());
-  var errors_js_1 = require_errors56();
+  var errors_js_1 = require_errors57();
   exports6.default = {
     order: 200,
     headers: null,
@@ -2792268,7 +2795410,7 @@ var require_resolve_external = __commonJS((exports6) => {
   var pointer_js_1 = __importDefault(require_pointer());
   var parse_js_1 = __importDefault(require_parse21());
   var url3 = __importStar(require_url5());
-  var errors_js_1 = require_errors56();
+  var errors_js_1 = require_errors57();
   function resolveExternal(parser, options4) {
     if (!options4.resolve?.external) {
       return Promise.resolve();
@@ -2792567,7 +2795709,7 @@ var require_dereference = __commonJS((exports6) => {
   var ref_js_1 = __importDefault(require_ref3());
   var pointer_js_1 = __importDefault(require_pointer());
   var url3 = __importStar(require_url5());
-  var errors_1 = require_errors56();
+  var errors_1 = require_errors57();
   exports6.default = dereference3;
   function dereference3(parser, options4) {
     const start3 = Date.now();
@@ -2792830,7 +2795972,7 @@ var require_lib321 = __commonJS((exports6) => {
   var dereference_js_1 = __importDefault(require_dereference());
   exports6.dereferenceInternal = dereference_js_1.default;
   var url3 = __importStar(require_url5());
-  var errors_js_1 = require_errors56();
+  var errors_js_1 = require_errors57();
   Object.defineProperty(exports6, "JSONParserError", { enumerable: true, get: function() {
     return errors_js_1.JSONParserError;
   } });
@@ -2793084,7 +2796226,7 @@ var init_zod_compat = __esm(() => {
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
 var LATEST_PROTOCOL_VERSION = "2025-11-25", SUPPORTED_PROTOCOL_VERSIONS, RELATED_TASK_META_KEY = "io.modelcontextprotocol/related-task", JSONRPC_VERSION4 = "2.0", AssertObjectSchema, ProgressTokenSchema, CursorSchema, TaskCreationParamsSchema, TaskMetadataSchema, RelatedTaskMetadataSchema, RequestMetaSchema, BaseRequestParamsSchema, TaskAugmentedRequestParamsSchema, isTaskAugmentedRequestParams = (value2) => TaskAugmentedRequestParamsSchema.safeParse(value2).success, RequestSchema4, NotificationsParamsSchema, NotificationSchema, ResultSchema4, RequestIdSchema, JSONRPCRequestSchema4, isJSONRPCRequest = (value2) => JSONRPCRequestSchema4.safeParse(value2).success, JSONRPCNotificationSchema4, isJSONRPCNotification = (value2) => JSONRPCNotificationSchema4.safeParse(value2).success, JSONRPCResultResponseSchema, isJSONRPCResultResponse = (value2) => JSONRPCResultResponseSchema.safeParse(value2).success, ErrorCode, JSONRPCErrorResponseSchema, isJSONRPCErrorResponse = (value2) => JSONRPCErrorResponseSchema.safeParse(value2).success, JSONRPCMessageSchema, JSONRPCResponseSchema4, EmptyResultSchema, CancelledNotificationParamsSchema, CancelledNotificationSchema, IconSchema, IconsSchema, BaseMetadataSchema, ImplementationSchema, FormElicitationCapabilitySchema, ElicitationCapabilitySchema, ClientTasksCapabilitySchema, ServerTasksCapabilitySchema, ClientCapabilitiesSchema, InitializeRequestParamsSchema, InitializeRequestSchema, ServerCapabilitiesSchema4, InitializeResultSchema, InitializedNotificationSchema, isInitializedNotification = (value2) => InitializedNotificationSchema.safeParse(value2).success, PingRequestSchema, ProgressSchema, ProgressNotificationParamsSchema, ProgressNotificationSchema, PaginatedRequestParamsSchema, PaginatedRequestSchema, PaginatedResultSchema4, TaskStatusSchema, TaskSchema, CreateTaskResultSchema, TaskStatusNotificationParamsSchema, TaskStatusNotificationSchema, GetTaskRequestSchema, GetTaskResultSchema, GetTaskPayloadRequestSchema, GetTaskPayloadResultSchema, ListTasksRequestSchema, ListTasksResultSchema, CancelTaskRequestSchema, CancelTaskResultSchema, ResourceContentsSchema4, TextResourceContentsSchema4, Base64Schema, BlobResourceContentsSchema4, RoleSchema, AnnotationsSchema, ResourceSchema, ResourceTemplateSchema, ListResourcesRequestSchema, ListResourcesResultSchema, ListResourceTemplatesRequestSchema, ListResourceTemplatesResultSchema, ResourceRequestParamsSchema, ReadResourceRequestParamsSchema, ReadResourceRequestSchema, ReadResourceResultSchema, ResourceListChangedNotificationSchema, SubscribeRequestParamsSchema, SubscribeRequestSchema, UnsubscribeRequestParamsSchema, UnsubscribeRequestSchema, ResourceUpdatedNotificationParamsSchema, ResourceUpdatedNotificationSchema, PromptArgumentSchema, PromptSchema, ListPromptsRequestSchema, ListPromptsResultSchema, GetPromptRequestParamsSchema, GetPromptRequestSchema, TextContentSchema4, ImageContentSchema4, AudioContentSchema, ToolUseContentSchema, EmbeddedResourceSchema4, ResourceLinkSchema, ContentBlockSchema, PromptMessageSchema, GetPromptResultSchema, PromptListChangedNotificationSchema, ToolAnnotationsSchema, ToolExecutionSchema, ToolSchema4, ListToolsRequestSchema, ListToolsResultSchema, CallToolResultSchema, CompatibilityCallToolResultSchema, CallToolRequestParamsSchema, CallToolRequestSchema, ToolListChangedNotificationSchema, ListChangedOptionsBaseSchema, LoggingLevelSchema, SetLevelRequestParamsSchema, SetLevelRequestSchema, LoggingMessageNotificationParamsSchema, LoggingMessageNotificationSchema, ModelHintSchema, ModelPreferencesSchema, ToolChoiceSchema, ToolResultContentSchema, SamplingContentSchema, SamplingMessageContentBlockSchema, SamplingMessageSchema, CreateMessageRequestParamsSchema, CreateMessageRequestSchema, CreateMessageResultSchema, CreateMessageResultWithToolsSchema, BooleanSchemaSchema, StringSchemaSchema, NumberSchemaSchema, UntitledSingleSelectEnumSchemaSchema, TitledSingleSelectEnumSchemaSchema, LegacyTitledEnumSchemaSchema, SingleSelectEnumSchemaSchema, UntitledMultiSelectEnumSchemaSchema, TitledMultiSelectEnumSchemaSchema, MultiSelectEnumSchemaSchema, EnumSchemaSchema, PrimitiveSchemaDefinitionSchema, ElicitRequestFormParamsSchema, ElicitRequestURLParamsSchema, ElicitRequestParamsSchema, ElicitRequestSchema, ElicitationCompleteNotificationParamsSchema, ElicitationCompleteNotificationSchema, ElicitResultSchema, ResourceTemplateReferenceSchema, PromptReferenceSchema, CompleteRequestParamsSchema, CompleteRequestSchema, CompleteResultSchema, RootSchema, ListRootsRequestSchema, ListRootsResultSchema, RootsListChangedNotificationSchema, ClientRequestSchema, ClientNotificationSchema, ClientResultSchema, ServerRequestSchema, ServerNotificationSchema, ServerResultSchema, McpError, UrlElicitationRequiredError;
-var init_types55 = __esm(() => {
+var init_types56 = __esm(() => {
   init_v42();
   SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05", "2024-10-07"];
   AssertObjectSchema = custom((v18) => v18 !== null && (typeof v18 === "object" || typeof v18 === "function"));
@@ -2794760,7 +2797902,7 @@ function mergeCapabilities(base10, additional) {
 var DEFAULT_REQUEST_TIMEOUT_MSEC = 60000;
 var init_protocol4 = __esm(() => {
   init_zod_compat();
-  init_types55();
+  init_types56();
   init_zod_json_schema_compat();
 });
 
@@ -2795964,7 +2799106,7 @@ var require_names2 = __commonJS((exports6) => {
 });
 
 // node_modules/ajv/dist/compile/errors.js
-var require_errors57 = __commonJS((exports6) => {
+var require_errors58 = __commonJS((exports6) => {
   Object.defineProperty(exports6, "__esModule", { value: true });
   exports6.extendErrors = exports6.resetErrorsCount = exports6.reportExtraError = exports6.reportError = exports6.keyword$DataError = exports6.keywordError = undefined;
   var codegen_1 = require_codegen3();
@@ -2796085,7 +2799227,7 @@ var require_errors57 = __commonJS((exports6) => {
 var require_boolSchema2 = __commonJS((exports6) => {
   Object.defineProperty(exports6, "__esModule", { value: true });
   exports6.boolOrEmptySchema = exports6.topBoolOrEmptySchema = undefined;
-  var errors_1 = require_errors57();
+  var errors_1 = require_errors58();
   var codegen_1 = require_codegen3();
   var names_1 = require_names2();
   var boolError = {
@@ -2796183,7 +2799325,7 @@ var require_dataType2 = __commonJS((exports6) => {
   exports6.reportTypeError = exports6.checkDataTypes = exports6.checkDataType = exports6.coerceAndCheckDataType = exports6.getJSONTypes = exports6.getSchemaTypes = exports6.DataType = undefined;
   var rules_1 = require_rules2();
   var applicability_1 = require_applicability2();
-  var errors_1 = require_errors57();
+  var errors_1 = require_errors58();
   var codegen_1 = require_codegen3();
   var util_1 = require_util76();
   var DataType;
@@ -2796528,7 +2799670,7 @@ var require_keyword2 = __commonJS((exports6) => {
   var codegen_1 = require_codegen3();
   var names_1 = require_names2();
   var code_1 = require_code5();
-  var errors_1 = require_errors57();
+  var errors_1 = require_errors58();
   function macroKeywordCode(cxt, def2) {
     const { gen: gen10, keyword, schema, parentSchema, it: it2 } = cxt;
     const macroSchema = def2.macro.call(it2.self, schema, parentSchema, it2);
@@ -2797009,7 +2800151,7 @@ var require_validate28 = __commonJS((exports6) => {
   var names_1 = require_names2();
   var resolve_1 = require_resolve3();
   var util_1 = require_util76();
-  var errors_1 = require_errors57();
+  var errors_1 = require_errors58();
   function validateFunctionCode(it2) {
     if (isSchemaObj(it2)) {
       checkKeywords(it2);
@@ -2797767,7 +2800909,7 @@ var require_data11 = __commonJS((exports6, module) => {
 });
 
 // node_modules/fast-uri/lib/utils.js
-var require_utils193 = __commonJS((exports6, module) => {
+var require_utils194 = __commonJS((exports6, module) => {
   var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
   var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
   function stringArrayToHexStripped(input) {
@@ -2798023,7 +2801165,7 @@ var require_utils193 = __commonJS((exports6, module) => {
 
 // node_modules/fast-uri/lib/schemes.js
 var require_schemes2 = __commonJS((exports6, module) => {
-  var { isUUID } = require_utils193();
+  var { isUUID } = require_utils194();
   var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
   var supportedSchemeNames = [
     "http",
@@ -2798197,7 +2801339,7 @@ var require_schemes2 = __commonJS((exports6, module) => {
 
 // node_modules/fast-uri/index.js
 var require_fast_uri2 = __commonJS((exports6, module) => {
-  var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils193();
+  var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils194();
   var { SCHEMES, getSchemeHandler } = require_schemes2();
   function normalize6(uri2, options4) {
     if (typeof uri2 === "string") {
@@ -2799603,7 +2802745,7 @@ var require_enum4 = __commonJS((exports6) => {
 });
 
 // node_modules/ajv/dist/vocabularies/validation/index.js
-var require_validation3 = __commonJS((exports6) => {
+var require_validation4 = __commonJS((exports6) => {
   Object.defineProperty(exports6, "__esModule", { value: true });
   var limitNumber_1 = require_limitNumber2();
   var multipleOf_1 = require_multipleOf2();
@@ -2800591,7 +2803733,7 @@ var require_metadata6 = __commonJS((exports6) => {
 var require_draft72 = __commonJS((exports6) => {
   Object.defineProperty(exports6, "__esModule", { value: true });
   var core_1 = require_core9();
-  var validation_1 = require_validation3();
+  var validation_1 = require_validation4();
   var applicator_1 = require_applicator2();
   var format_1 = require_format26();
   var metadata_1 = require_metadata6();
@@ -2800607,7 +2803749,7 @@ var require_draft72 = __commonJS((exports6) => {
 });
 
 // node_modules/ajv/dist/vocabularies/discriminator/types.js
-var require_types102 = __commonJS((exports6) => {
+var require_types103 = __commonJS((exports6) => {
   Object.defineProperty(exports6, "__esModule", { value: true });
   exports6.DiscrError = undefined;
   var DiscrError;
@@ -2800621,7 +2803763,7 @@ var require_types102 = __commonJS((exports6) => {
 var require_discriminator6 = __commonJS((exports6) => {
   Object.defineProperty(exports6, "__esModule", { value: true });
   var codegen_1 = require_codegen3();
-  var types_1 = require_types102();
+  var types_1 = require_types103();
   var compile_1 = require_compile2();
   var ref_error_1 = require_ref_error2();
   var util_1 = require_util76();
@@ -2801272,8 +2804414,8 @@ var init_ajv_provider = __esm(() => {
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/client.js
 class ExperimentalClientTasks {
-  constructor(_client) {
-    this._client = _client;
+  constructor(_client2) {
+    this._client = _client2;
   }
   async* callToolStream(params2, resultSchema = CallToolResultSchema, options4) {
     const clientInternal = this._client;
@@ -2801336,7 +2804478,7 @@ class ExperimentalClientTasks {
   }
 }
 var init_client17 = __esm(() => {
-  init_types55();
+  init_types56();
 });
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
@@ -2801419,7 +2804561,7 @@ function getSupportedElicitationModes(capabilities) {
 var Client3;
 var init_client18 = __esm(() => {
   init_protocol4();
-  init_types55();
+  init_types56();
   init_ajv_provider();
   init_zod_compat();
   init_client17();
@@ -2802666,7 +2805808,7 @@ async function registerClient(authorizationServerUrl, { metadata: metadata4, cli
 var UnauthorizedError2, AUTHORIZATION_CODE_RESPONSE_TYPE = "code", AUTHORIZATION_CODE_CHALLENGE_METHOD = "S256";
 var init_auth2 = __esm(() => {
   init_index_node10();
-  init_types55();
+  init_types56();
   init_auth();
   init_auth();
   init_errors43();
@@ -2802859,7 +2806001,7 @@ class SSEClientTransport {
 var SseError;
 var init_sse = __esm(() => {
   init_dist43();
-  init_types55();
+  init_types56();
   init_auth2();
   SseError = class SseError extends Error {
     constructor(code, message5, event9) {
@@ -2803356,7 +2806498,7 @@ function serializeMessage2(message5) {
 `;
 }
 var init_stdio = __esm(() => {
-  init_types55();
+  init_types56();
 });
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/client/stdio.js
@@ -2803865,7 +2807007,7 @@ class StreamableHTTPClientTransport {
 }
 var DEFAULT_STREAMABLE_HTTP_RECONNECTION_OPTIONS, StreamableHTTPError;
 var init_streamableHttp = __esm(() => {
-  init_types55();
+  init_types56();
   init_auth2();
   init_stream();
   DEFAULT_STREAMABLE_HTTP_RECONNECTION_OPTIONS = {
@@ -2804014,7 +2807156,7 @@ var init_exit_hook = __esm(() => {
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
 var init_server = __esm(() => {
   init_protocol4();
-  init_types55();
+  init_types56();
   init_ajv_provider();
   init_zod_compat();
 });
@@ -2808767,7 +2811909,7 @@ var require_content_type = __commonJS((exports6) => {
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/sse.js
 var import_raw_body, import_content_type;
 var init_sse2 = __esm(() => {
-  init_types55();
+  init_types56();
   import_raw_body = __toESM(require_raw_body(), 1);
   import_content_type = __toESM(require_content_type(), 1);
 });
@@ -2808979,7 +2812121,7 @@ var init_dist47 = __esm(() => {
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/webStandardStreamableHttp.js
 var init_webStandardStreamableHttp = __esm(() => {
-  init_types55();
+  init_types56();
 });
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/streamableHttp.js
@@ -2809138,7 +2812280,7 @@ var init_dist48 = __esm(() => {
   init_stdio2();
   init_streamableHttp();
   init_protocol4();
-  init_types55();
+  init_types56();
   init_exit_hook();
   init_zod();
   init_dist6();
@@ -2810977,6 +2814119,8 @@ function getScannerAgent() {
         ...instrumentedRegimeTools,
         solana_get_token_data: instrumentedSolanaKitWalletTools.solana_get_token_data,
         solana_rugcheck: instrumentedSolanaKitWalletTools.solana_rugcheck,
+        chainlink_bulk_prices: instrumentedChainlinkStreamsTools.chainlink_bulk_prices,
+        chainlink_list_feeds: instrumentedChainlinkStreamsTools.chainlink_list_feeds,
         ...getRoutingToolsForAgent("Scanner")
       },
       memory: createSubAgentMemory(),
@@ -2811063,6 +2814207,12 @@ function getAnalystAgent() {
         solana_debridge_status: instrumentedSolanaKitDefiBridgeTools.solana_debridge_status,
         solana_okx_quote: instrumentedSolanaKitDefiBridgeTools.solana_okx_quote,
         solana_okx_tokens: instrumentedSolanaKitDefiBridgeTools.solana_okx_tokens,
+        chainlink_get_price: instrumentedChainlinkStreamsTools.chainlink_get_price,
+        chainlink_get_price_at: instrumentedChainlinkStreamsTools.chainlink_get_price_at,
+        chainlink_read_feed: instrumentedChainlinkFeedsTools.chainlink_read_feed,
+        chainlink_compare_prices: instrumentedChainlinkFeedsTools.chainlink_compare_prices,
+        chainlink_ccip_supported_chains: instrumentedChainlinkCCIPTools.chainlink_ccip_supported_chains,
+        chainlink_ccip_get_fee: instrumentedChainlinkCCIPTools.chainlink_ccip_get_fee,
         ...getRoutingToolsForAgent("Analyst")
       },
       memory: createSubAgentMemory(),
@@ -2811222,6 +2814372,7 @@ function getExecutorAgent() {
         solana_debridge_create_order: instrumentedSolanaKitDefiBridgeTools.solana_debridge_create_order,
         solana_debridge_execute: instrumentedSolanaKitDefiBridgeTools.solana_debridge_execute,
         solana_okx_swap: instrumentedSolanaKitDefiBridgeTools.solana_okx_swap,
+        chainlink_ccip_transfer: instrumentedChainlinkCCIPTools.chainlink_ccip_transfer,
         ...getRoutingToolsForAgent("Executor")
       },
       memory: createSubAgentMemory(),
@@ -2811285,6 +2814436,7 @@ function getMonitorAgent() {
         solana_orca_fetch_positions: instrumentedSolanaKitDefiPoolsTools.solana_orca_fetch_positions,
         solana_sanctum_owned_lst: instrumentedSolanaKitDefiLendingTools.solana_sanctum_owned_lst,
         solana_voltr_positions: instrumentedSolanaKitDefiLendingTools.solana_voltr_positions,
+        chainlink_ccip_status: instrumentedChainlinkCCIPTools.chainlink_ccip_status,
         ...getRoutingToolsForAgent("Monitor")
       },
       memory: createSubAgentMemory(),
@@ -2811395,7 +2814547,7 @@ function resetAgents() {
   _agents = {};
   _subAgentMemory = null;
 }
-var gordonInputGuard, gordonOutputSanitizer, DEFAULT_MEMORY_CONFIG, _memoryConfig, instrumentedIndicatorTools, instrumentedExplainTools, instrumentedMarketTools, instrumentedPositionTools, instrumentedSchedulerTools, instrumentedSystemTools, instrumentedEarnTools, instrumentedChartTools, instrumentedOrderbookTools, instrumentedWalletTools, instrumentedDiscoveryTools, instrumentedHistoryTools, instrumentedAccountTools, instrumentedTradingTools, instrumentedMarketAnalysisTools, instrumentedLiquidationIntelligenceTools, instrumentedRiskManagementTools, instrumentedStrategyTools, instrumentedMetricsTools, instrumentedCompositionTools, instrumentedBacktestTools, instrumentedSharedContextTools, instrumentedParallelAnalysisTools, instrumentedStrategyGenerationTools, instrumentedMultiModalChartTools, instrumentedMarketDataTools, instrumentedPairAnalysisTools, instrumentedAutonomousTools, instrumentedBaseOnchainTools, instrumentedAgentKitOnchainTools, instrumentedAgentKitDefiTools, instrumentedPolkadotKitAssetTools, instrumentedPolkadotKitStakingTools, instrumentedPolkadotKitDefiTools, instrumentedSolanaKitWalletTools, instrumentedSolanaKitTradingTools, instrumentedSolanaKitDefiPerpsTools, instrumentedSolanaKitDefiLendingTools, instrumentedSolanaKitDefiPoolsTools, instrumentedSolanaKitDefiBridgeTools, instrumentedBaseSignalTools, instrumentedBaseIndexerTools, instrumentedUniswapDataTools, instrumentedDexSearchTools, instrumentedDefillamaYieldTools, instrumentedEvalTools, instrumentedPositionTrackingTools, instrumentedMemoryTools, instrumentedPlaybookTools, instrumentedPlaybookBacktestTools, instrumentedAuditTools, instrumentedProtocolTools, instrumentedRegimeTools, instrumentedRuntimeTools, instrumentedAdvancedTools, instrumentedCheckRiskTool, WORKING_MEMORY_TEMPLATE = `
+var gordonInputGuard, gordonOutputSanitizer, DEFAULT_MEMORY_CONFIG, _memoryConfig, instrumentedIndicatorTools, instrumentedExplainTools, instrumentedMarketTools, instrumentedPositionTools, instrumentedSchedulerTools, instrumentedSystemTools, instrumentedEarnTools, instrumentedChartTools, instrumentedOrderbookTools, instrumentedWalletTools, instrumentedDiscoveryTools, instrumentedHistoryTools, instrumentedAccountTools, instrumentedTradingTools, instrumentedMarketAnalysisTools, instrumentedLiquidationIntelligenceTools, instrumentedRiskManagementTools, instrumentedStrategyTools, instrumentedMetricsTools, instrumentedCompositionTools, instrumentedBacktestTools, instrumentedSharedContextTools, instrumentedParallelAnalysisTools, instrumentedStrategyGenerationTools, instrumentedMultiModalChartTools, instrumentedMarketDataTools, instrumentedPairAnalysisTools, instrumentedAutonomousTools, instrumentedBaseOnchainTools, instrumentedAgentKitOnchainTools, instrumentedAgentKitDefiTools, instrumentedPolkadotKitAssetTools, instrumentedPolkadotKitStakingTools, instrumentedPolkadotKitDefiTools, instrumentedSolanaKitWalletTools, instrumentedSolanaKitTradingTools, instrumentedSolanaKitDefiPerpsTools, instrumentedSolanaKitDefiLendingTools, instrumentedSolanaKitDefiPoolsTools, instrumentedSolanaKitDefiBridgeTools, instrumentedChainlinkStreamsTools, instrumentedChainlinkFeedsTools, instrumentedChainlinkCCIPTools, instrumentedBaseSignalTools, instrumentedBaseIndexerTools, instrumentedUniswapDataTools, instrumentedDexSearchTools, instrumentedDefillamaYieldTools, instrumentedEvalTools, instrumentedPositionTrackingTools, instrumentedMemoryTools, instrumentedPlaybookTools, instrumentedPlaybookBacktestTools, instrumentedAuditTools, instrumentedProtocolTools, instrumentedRegimeTools, instrumentedRuntimeTools, instrumentedAdvancedTools, instrumentedCheckRiskTool, WORKING_MEMORY_TEMPLATE = `
 # Trader Profile
 
 ## Personal Info
@@ -2811984,6 +2815136,10 @@ When the user asks for analysis, scanning, planning, backtesting, or execution \
 - Polkadot: DOT/KSM balance checks across 12+ chains -> Monitor (when POLKADOT_PRIVATE_KEY is set)
 - Polkadot: native transfers, XCM cross-chain transfers, nomination pool staking, Hydration DEX swaps, Bifrost vDOT liquid staking, identity registration -> Executor (when POLKADOT_PRIVATE_KEY is set)
 - Polkadot: nomination pool info, chain initialization -> Analyst (when POLKADOT_PRIVATE_KEY is set)
+- Chainlink Data Streams: real-time institutional prices (BTC, ETH, SOL, LINK, etc.), bulk price queries, historical prices -> Analyst and Scanner (when CHAINLINK_API_KEY is set)
+- Chainlink Data Feeds: free on-chain price oracles on Ethereum, Arbitrum, Base, Polygon, price comparison/verification -> Analyst
+- Chainlink CCIP: cross-chain EVM token transfers (USDC, LINK, WETH across Ethereum, Arbitrum, Base, Optimism, Polygon, Avalanche, BNB), fee estimation -> Executor for transfers, Analyst for fees/info (when EVM_PRIVATE_KEY is set)
+- Chainlink CCIP transfer status tracking -> Monitor
 - Educational explanations -> Teacher
 - Position lifecycle tracking (setup \u2192 analysis \u2192 plan \u2192 execute \u2192 monitor \u2192 review) -> tracked automatically across agents
 - Risk pre-checks on all orders -> Planner and Executor (automatic)
@@ -2812066,6 +2815222,9 @@ var init_agents = __esm(async () => {
   instrumentedSolanaKitDefiLendingTools = withToolsMetrics(solanaKitDefiLendingTools);
   instrumentedSolanaKitDefiPoolsTools = withToolsMetrics(solanaKitDefiPoolsTools);
   instrumentedSolanaKitDefiBridgeTools = withToolsMetrics(solanaKitDefiBridgeTools);
+  instrumentedChainlinkStreamsTools = withToolsMetrics(chainlinkStreamsTools);
+  instrumentedChainlinkFeedsTools = withToolsMetrics(chainlinkFeedsTools);
+  instrumentedChainlinkCCIPTools = withToolsMetrics(chainlinkCCIPTools);
   instrumentedBaseSignalTools = withToolsMetrics(baseSignalTools);
   instrumentedBaseIndexerTools = withToolsMetrics(baseIndexerTools);
   instrumentedUniswapDataTools = withToolsMetrics(uniswapDataTools);
@@ -2813949,7 +2817108,17 @@ var init_orchestrator = __esm(async () => {
     get_portfolio_state: "Monitor",
     rebalance_portfolio: "Planner",
     check_portfolio_health: "Monitor",
-    approve_strategy_trade: "Executor"
+    approve_strategy_trade: "Executor",
+    chainlink_get_price: "Analyst",
+    chainlink_get_price_at: "Analyst",
+    chainlink_bulk_prices: "Scanner",
+    chainlink_list_feeds: "Scanner",
+    chainlink_read_feed: "Analyst",
+    chainlink_compare_prices: "Analyst",
+    chainlink_ccip_supported_chains: "Analyst",
+    chainlink_ccip_get_fee: "Analyst",
+    chainlink_ccip_transfer: "Executor",
+    chainlink_ccip_status: "Monitor"
   };
   handoffHistory = [];
   VALID_HANDOFF_RULES = {
@@ -2823942,7 +2827111,7 @@ var import_react64 = __toESM(require_react(), 1);
 // package.json
 var package_default2 = {
   name: "@general-liquidity/gordon-cli",
-  version: "0.75.12",
+  version: "0.75.13",
   description: "The Frontier Trading Agent",
   author: "General Liquidity, Inc.",
   license: "MIT",
@@ -2824000,6 +2827169,7 @@ var package_default2 = {
     "@ai-sdk/anthropic": "^1.0.0",
     "@ai-sdk/google": "^1.0.0",
     "@ai-sdk/openai": "^1.0.0",
+    "@chainlink/data-streams-sdk": "^1.2.1",
     "@coinbase/agentkit": "^0.10.4",
     "@galacticcouncil/api-augment": "^0.9.0",
     "@inkjs/ui": "^2.0.0",