@pythnetwork/price-pusher 10.2.0 → 10.3.1

package/{lib/controller.js → dist/controller.cjs}

@@ -1,8 +1,15 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Controller = void 0;
-const utils_1 = require("./utils");
-const price_config_1 = require("./price-config");
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Controller", {
+    enumerable: true,
+    get: function() {
+        return Controller;
+    }
+});
+const _priceconfig = require("./price-config.cjs");
+const _utils = require("./utils.cjs");
 class Controller {
     priceConfigs;
     sourcePriceListener;
@@ -11,7 +18,7 @@ class Controller {
     logger;
     pushingFrequency;
     metrics;
-    constructor(priceConfigs, sourcePriceListener, targetPriceListener, targetChainPricePusher, logger, config) {
+    constructor(priceConfigs, sourcePriceListener, targetPriceListener, targetChainPricePusher, logger, config){
         this.priceConfigs = priceConfigs;
         this.sourcePriceListener = sourcePriceListener;
         this.targetPriceListener = targetPriceListener;
@@ -29,14 +36,14 @@ class Controller {
         // wait for the listeners to get updated. There could be a restart
         // before this run and we need to respect the cooldown duration as
         // their might be a message sent before.
-        await (0, utils_1.sleep)(this.pushingFrequency * 1000);
-        for (;;) {
+        await (0, _utils.sleep)(this.pushingFrequency * 1000);
+        for(;;){
             // We will push all prices whose update condition is YES or EARLY as long as there is
             // at least one YES.
             let pushThresholdMet = false;
             const pricesToPush = [];
             const pubTimesToPush = [];
-            for (const priceConfig of this.priceConfigs) {
+            for (const priceConfig of this.priceConfigs){
                 const priceId = priceConfig.id;
                 const alias = priceConfig.alias;
                 const targetLatestPrice = this.targetPriceListener.getLatestPriceInfo(priceId);
@@ -45,59 +52,54 @@ class Controller {
                     this.metrics.updateTimestamps(priceId, alias, targetLatestPrice.publishTime, sourceLatestPrice.publishTime, priceConfig.timeDifference);
                     this.metrics.updatePriceValues(priceId, alias, sourceLatestPrice.price, targetLatestPrice.price);
                 }
-                const priceShouldUpdate = (0, price_config_1.shouldUpdate)(priceConfig, sourceLatestPrice, targetLatestPrice, this.logger);
+                const priceShouldUpdate = (0, _priceconfig.shouldUpdate)(priceConfig, sourceLatestPrice, targetLatestPrice, this.logger);
                 // Record update condition in metrics
                 if (this.metrics) {
                     this.metrics.recordUpdateCondition(priceId, alias, priceShouldUpdate);
                 }
-                if (priceShouldUpdate == price_config_1.UpdateCondition.YES) {
+                if (priceShouldUpdate == _priceconfig.UpdateCondition.YES) {
                     pushThresholdMet = true;
                 }
-                if (priceShouldUpdate == price_config_1.UpdateCondition.YES ||
-                    priceShouldUpdate == price_config_1.UpdateCondition.EARLY) {
+                if (priceShouldUpdate == _priceconfig.UpdateCondition.YES || priceShouldUpdate == _priceconfig.UpdateCondition.EARLY) {
                     pricesToPush.push(priceConfig);
-                    pubTimesToPush.push((targetLatestPrice?.publishTime || 0) + 1);
+                    pubTimesToPush.push((targetLatestPrice?.publishTime ?? 0) + 1);
                 }
             }
             if (pushThresholdMet) {
                 this.logger.info({
-                    priceIds: pricesToPush.map((priceConfig) => ({
-                        id: priceConfig.id,
-                        alias: priceConfig.alias,
-                    })),
+                    priceIds: pricesToPush.map((priceConfig)=>({
+                            id: priceConfig.id,
+                            alias: priceConfig.alias
+                        }))
                 }, "Some of the checks triggered pushing update. Will push the updates for some feeds.");
                 // note that the priceIds are without leading "0x"
-                const priceIds = pricesToPush.map((priceConfig) => priceConfig.id);
+                const priceIds = pricesToPush.map((priceConfig)=>priceConfig.id);
                 try {
                     await this.targetChainPricePusher.updatePriceFeed(priceIds, pubTimesToPush);
                     // Record successful updates
                     if (this.metrics) {
-                        for (const config of pricesToPush) {
-                            const triggerValue = (0, price_config_1.shouldUpdate)(config, this.sourcePriceListener.getLatestPriceInfo(config.id), this.targetPriceListener.getLatestPriceInfo(config.id), this.logger) === price_config_1.UpdateCondition.YES
-                                ? "yes"
-                                : "early";
+                        for (const config of pricesToPush){
+                            const triggerValue = (0, _priceconfig.shouldUpdate)(config, this.sourcePriceListener.getLatestPriceInfo(config.id), this.targetPriceListener.getLatestPriceInfo(config.id), this.logger) === _priceconfig.UpdateCondition.YES ? "yes" : "early";
                             this.metrics.recordPriceUpdate(config.id, config.alias, triggerValue);
                         }
                     }
-                }
-                catch (error) {
-                    this.logger.error({ error, priceIds }, "Error pushing price updates to chain");
+                } catch (error) {
+                    this.logger.error({
+                        error,
+                        priceIds
+                    }, "Error pushing price updates to chain");
                     // Record errors in metrics
                     if (this.metrics) {
-                        for (const config of pricesToPush) {
-                            const triggerValue = (0, price_config_1.shouldUpdate)(config, this.sourcePriceListener.getLatestPriceInfo(config.id), this.targetPriceListener.getLatestPriceInfo(config.id), this.logger) === price_config_1.UpdateCondition.YES
-                                ? "yes"
-                                : "early";
+                        for (const config of pricesToPush){
+                            const triggerValue = (0, _priceconfig.shouldUpdate)(config, this.sourcePriceListener.getLatestPriceInfo(config.id), this.targetPriceListener.getLatestPriceInfo(config.id), this.logger) === _priceconfig.UpdateCondition.YES ? "yes" : "early";
                             this.metrics.recordPriceUpdateError(config.id, config.alias, triggerValue);
                         }
                     }
                 }
-            }
-            else {
+            } else {
                 this.logger.info("None of the checks were triggered. No push needed.");
             }
-            await (0, utils_1.sleep)(this.pushingFrequency * 1000);
+            await (0, _utils.sleep)(this.pushingFrequency * 1000);
         }
     }
 }
-exports.Controller = Controller;

package/{lib → dist}/controller.d.ts

@@ -1,8 +1,8 @@
-import { DurationInSeconds } from "./utils";
-import { IPriceListener, IPricePusher } from "./interface";
-import { PriceConfig } from "./price-config";
-import { Logger } from "pino";
-import { PricePusherMetrics } from "./metrics";
+import type { Logger } from "pino";
+import type { IPriceListener, IPricePusher } from "./interface.js";
+import { PricePusherMetrics } from "./metrics.js";
+import type { PriceConfig } from "./price-config.js";
+import type { DurationInSeconds } from "./utils.js";
 export declare class Controller {
     private priceConfigs;
     private sourcePriceListener;
@@ -17,4 +17,3 @@ export declare class Controller {
     });
     start(): Promise<void>;
 }
-//# sourceMappingURL=controller.d.ts.map

package/dist/evm/balance-tracker.cjs

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get EvmBalanceTracker () {
+        return EvmBalanceTracker;
+    },
+    get createEvmBalanceTracker () {
+        return createEvmBalanceTracker;
+    }
+});
+const _interface = require("../interface.cjs");
+class EvmBalanceTracker extends _interface.BaseBalanceTracker {
+    client;
+    evmAddress;
+    constructor(config){
+        super({
+            ...config,
+            logger: config.logger.child({
+                module: "EvmBalanceTracker"
+            })
+        });
+        this.client = config.client;
+        this.evmAddress = config.address;
+    }
+    /**
+   * EVM-specific implementation of balance update
+   */ async updateBalance() {
+        try {
+            const balance = await this.client.getBalance({
+                address: this.evmAddress
+            });
+            this.metrics.updateWalletBalance(this.address, this.network, balance);
+            this.logger.debug(`Updated EVM wallet balance: ${this.address} = ${balance.toString()}`);
+        } catch (error) {
+            this.logger.error({
+                error
+            }, "Error fetching EVM wallet balance for metrics");
+        }
+    }
+}
+function createEvmBalanceTracker(params) {
+    return new EvmBalanceTracker({
+        client: params.client,
+        address: params.address,
+        network: params.network,
+        updateInterval: params.updateInterval,
+        metrics: params.metrics,
+        logger: params.logger
+    });
+}

package/{lib → dist}/evm/balance-tracker.d.ts

@@ -1,17 +1,18 @@
-import { SuperWalletClient } from "./super-wallet";
-import { BaseBalanceTracker, BaseBalanceTrackerConfig, IBalanceTracker } from "../interface";
-import { DurationInSeconds } from "../utils";
-import { PricePusherMetrics } from "../metrics";
-import { Logger } from "pino";
+import type { Logger } from "pino";
+import type { SuperWalletClient } from "./super-wallet.js";
+import type { BaseBalanceTrackerConfig, IBalanceTracker } from "../interface.js";
+import { BaseBalanceTracker } from "../interface.js";
+import { PricePusherMetrics } from "../metrics.js";
+import type { DurationInSeconds } from "../utils.js";
 /**
  * EVM-specific configuration for balance tracker
  */
-export interface EvmBalanceTrackerConfig extends BaseBalanceTrackerConfig {
+export type EvmBalanceTrackerConfig = {
     /** EVM wallet client */
     client: SuperWalletClient;
     /** EVM address with 0x prefix */
     address: `0x${string}`;
-}
+} & BaseBalanceTrackerConfig;
 /**
  * EVM-specific implementation of the balance tracker
  */
@@ -27,16 +28,15 @@ export declare class EvmBalanceTracker extends BaseBalanceTracker {
 /**
  * Parameters for creating an EVM balance tracker
  */
-export interface CreateEvmBalanceTrackerParams {
+export type CreateEvmBalanceTrackerParams = {
     client: SuperWalletClient;
     address: `0x${string}`;
     network: string;
     updateInterval: DurationInSeconds;
     metrics: PricePusherMetrics;
     logger: Logger;
-}
+};
 /**
  * Factory function to create a balance tracker for EVM chains
  */
 export declare function createEvmBalanceTracker(params: CreateEvmBalanceTrackerParams): IBalanceTracker;
-//# sourceMappingURL=balance-tracker.d.ts.map

package/dist/evm/command.cjs

@@ -0,0 +1,205 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */ /* eslint-disable @typescript-eslint/restrict-template-expressions */ /* eslint-disable @typescript-eslint/no-unsafe-argument */ /* eslint-disable @typescript-eslint/no-unsafe-assignment */ /* eslint-disable @typescript-eslint/no-explicit-any */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
+const _hermesclient = require("@pythnetwork/hermes-client");
+const _pino = /*#__PURE__*/ _interop_require_default(require("pino"));
+const _controller = require("../controller.cjs");
+const _options = /*#__PURE__*/ _interop_require_wildcard(require("../options.cjs"));
+const _priceconfig = require("../price-config.cjs");
+const _pythpricelistener = require("../pyth-price-listener.cjs");
+const _customgasstation = require("./custom-gas-station.cjs");
+const _evm = require("./evm.cjs");
+const _pythcontract = require("./pyth-contract.cjs");
+const _superwallet = require("./super-wallet.cjs");
+const _metrics = require("../metrics.cjs");
+const _utils = require("../utils.cjs");
+const _balancetracker = require("./balance-tracker.cjs");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const _default = {
+    command: "evm",
+    describe: "run price pusher for evm",
+    builder: {
+        endpoint: {
+            description: "RPC endpoint URL for evm network. If you provide a normal HTTP endpoint, the pusher " + "will periodically poll for updates. The polling interval is configurable via the " + "`polling-frequency` command-line argument. If you provide a websocket RPC " + "endpoint (`ws[s]://...`), the price pusher will use event subscriptions to read " + "the current EVM price in addition to polling. ",
+            type: "string",
+            required: true
+        },
+        "custom-gas-station": {
+            description: "If using a custom gas station, chainId of custom gas station to use",
+            type: "number",
+            required: false
+        },
+        "tx-speed": {
+            description: "txSpeed for custom gas station. choose between 'slow'|'standard'|'fast'",
+            choices: [
+                "slow",
+                "standard",
+                "fast"
+            ],
+            required: false
+        },
+        "override-gas-price-multiplier": {
+            description: "Multiply the previous gas price by this number if the transaction is not landing to override. " + "Please note that the gas price can grow exponentially on consecutive failures; " + "to set a cap on the multiplier, use the `override-gas-price-multiplier-cap` option." + "Default to 1.1",
+            type: "number",
+            required: false,
+            default: 1.1
+        },
+        "override-gas-price-multiplier-cap": {
+            description: "Maximum gas price multiplier to use in override compared to the RPC returned " + "gas price. Default to 5",
+            type: "number",
+            required: false,
+            default: 5
+        },
+        "gas-limit": {
+            description: "Gas limit for the transaction",
+            type: "number",
+            required: false
+        },
+        "gas-price": {
+            description: "Override the gas price that would be received from the RPC",
+            type: "number",
+            required: false
+        },
+        "update-fee-multiplier": {
+            description: "Multiplier for the fee to update the price. It is useful in networks " + "such as Hedera where setting on-chain getUpdateFee as the transaction value " + "won't work. Default to 1",
+            type: "number",
+            required: false,
+            default: 1
+        },
+        ..._options.priceConfigFile,
+        ..._options.priceServiceEndpoint,
+        ..._options.mnemonicFile,
+        ..._options.pythContractAddress,
+        ..._options.pollingFrequency,
+        ..._options.pushingFrequency,
+        ..._options.logLevel,
+        ..._options.controllerLogLevel,
+        ..._options.enableMetrics,
+        ..._options.metricsPort
+    },
+    handler: async function(argv) {
+        // FIXME: type checks for this
+        const { endpoint, priceConfigFile, priceServiceEndpoint, mnemonicFile, pythContractAddress, pushingFrequency, pollingFrequency, customGasStation, txSpeed, overrideGasPriceMultiplier, overrideGasPriceMultiplierCap, gasLimit, gasPrice, updateFeeMultiplier, logLevel, controllerLogLevel, enableMetrics, metricsPort } = argv;
+        const logger = (0, _pino.default)({
+            level: logLevel
+        });
+        const priceConfigs = (0, _priceconfig.readPriceConfigFile)(priceConfigFile);
+        const hermesClient = new _hermesclient.HermesClient(priceServiceEndpoint);
+        const mnemonic = _nodefs.default.readFileSync(mnemonicFile, "utf8").trim();
+        let priceItems = priceConfigs.map(({ id, alias })=>({
+                id,
+                alias
+            }));
+        // Better to filter out invalid price items before creating the pyth listener
+        const { existingPriceItems, invalidPriceItems } = await (0, _utils.filterInvalidPriceItems)(hermesClient, priceItems);
+        if (invalidPriceItems.length > 0) {
+            logger.error(`Invalid price id submitted for: ${invalidPriceItems.map(({ alias })=>alias).join(", ")}`);
+        }
+        priceItems = existingPriceItems;
+        // Initialize metrics if enabled
+        let metrics;
+        if (enableMetrics) {
+            metrics = new _metrics.PricePusherMetrics(logger.child({
+                module: "Metrics"
+            }));
+            metrics.start(metricsPort);
+            logger.info(`Metrics server started on port ${metricsPort}`);
+        }
+        const pythListener = new _pythpricelistener.PythPriceListener(hermesClient, priceItems, logger.child({
+            module: "PythPriceListener"
+        }));
+        const client = await (0, _superwallet.createClient)(endpoint, mnemonic);
+        const pythContract = (0, _pythcontract.createPythContract)(client, pythContractAddress);
+        logger.info(`Pushing updates from wallet address: ${client.account.address}`);
+        // It is possible to watch the events in the non-ws endpoints, either by getFilter
+        // or by getLogs, but it is very expensive and our polling mechanism does it
+        // in a more efficient way. So we only do it with ws endpoints.
+        const watchEvents = (0, _utils.isWsEndpoint)(endpoint);
+        const evmListener = new _evm.EvmPriceListener(pythContract, priceItems, watchEvents, logger.child({
+            module: "EvmPriceListener"
+        }), {
+            pollingFrequency
+        });
+        const gasStation = (0, _customgasstation.getCustomGasStation)(logger.child({
+            module: "CustomGasStation"
+        }), customGasStation, txSpeed);
+        const evmPusher = new _evm.EvmPricePusher(hermesClient, client, pythContract, logger.child({
+            module: "EvmPricePusher"
+        }), overrideGasPriceMultiplier, overrideGasPriceMultiplierCap, updateFeeMultiplier, gasLimit, gasStation, gasPrice);
+        const controller = new _controller.Controller(priceConfigs, pythListener, evmListener, evmPusher, logger.child({
+            module: "Controller"
+        }, {
+            level: controllerLogLevel
+        }), {
+            pushingFrequency,
+            metrics: metrics
+        });
+        // Create and start the balance tracker if metrics are enabled
+        if (metrics) {
+            const balanceTracker = (0, _balancetracker.createEvmBalanceTracker)({
+                client,
+                address: client.account.address,
+                network: await client.getChainId().then((id)=>id.toString()),
+                updateInterval: pushingFrequency,
+                metrics,
+                logger
+            });
+            // Start the balance tracker
+            await balanceTracker.start();
+        }
+        void controller.start();
+    }
+};

package/{lib → dist}/evm/command.d.ts

@@ -1,4 +1,4 @@
-import { Options } from "yargs";
+import type { Options } from "yargs";
 declare const _default: {
     command: string;
     describe: string;
@@ -25,4 +25,3 @@ declare const _default: {
     handler: (argv: any) => Promise<void>;
 };
 export default _default;
-//# sourceMappingURL=command.d.ts.map

package/dist/evm/custom-gas-station.cjs

@@ -0,0 +1,54 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */ /* eslint-disable @typescript-eslint/no-unsafe-call */ /* eslint-disable @typescript-eslint/no-unsafe-argument */ /* eslint-disable @typescript-eslint/no-unsafe-member-access */ /* eslint-disable @typescript-eslint/no-unsafe-assignment */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get CustomGasStation () {
+        return CustomGasStation;
+    },
+    get getCustomGasStation () {
+        return getCustomGasStation;
+    }
+});
+const _viem = require("viem");
+const _utils = require("../utils.cjs");
+class CustomGasStation {
+    chain;
+    speed;
+    chainMethods = {
+        137: this.fetchMaticMainnetGasPrice.bind(this)
+    };
+    logger;
+    constructor(logger, chain, speed){
+        this.logger = logger;
+        this.speed = (0, _utils.verifyValidOption)(speed, _utils.txSpeeds);
+        this.chain = (0, _utils.verifyValidOption)(chain, _utils.customGasChainIds);
+    }
+    async getCustomGasPrice() {
+        return this.chainMethods[this.chain]();
+    }
+    async fetchMaticMainnetGasPrice() {
+        try {
+            const res = await fetch("https://gasstation.polygon.technology/v2");
+            // TODO: improve the typing specificity here
+            const jsonRes = await res.json();
+            const gasPrice = jsonRes[this.speed].maxFee;
+            return (0, _viem.parseGwei)(gasPrice.toFixed(2));
+        } catch (error) {
+            this.logger.error(error, "Failed to fetch gas price from Matic mainnet. Returning undefined");
+            return;
+        }
+    }
+}
+function getCustomGasStation(logger, customGasStation, txSpeed) {
+    if (customGasStation && txSpeed) {
+        return new CustomGasStation(logger, customGasStation, txSpeed);
+    }
+    return;
+}

package/{lib → dist}/evm/custom-gas-station.d.ts

@@ -1,4 +1,4 @@
-import { Logger } from "pino";
+import type { Logger } from "pino";
 export declare class CustomGasStation {
     private chain;
     private speed;
@@ -9,4 +9,3 @@ export declare class CustomGasStation {
     private fetchMaticMainnetGasPrice;
 }
 export declare function getCustomGasStation(logger: Logger, customGasStation?: number, txSpeed?: string): CustomGasStation | undefined;
-//# sourceMappingURL=custom-gas-station.d.ts.map