@pythnetwork/price-pusher 10.0.0 → 10.3.0

package/dist/options.cjs

@@ -0,0 +1,132 @@
+"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 controllerLogLevel () {
+        return controllerLogLevel;
+    },
+    get enableMetrics () {
+        return enableMetrics;
+    },
+    get logLevel () {
+        return logLevel;
+    },
+    get metricsPort () {
+        return metricsPort;
+    },
+    get mnemonicFile () {
+        return mnemonicFile;
+    },
+    get pollingFrequency () {
+        return pollingFrequency;
+    },
+    get priceConfigFile () {
+        return priceConfigFile;
+    },
+    get priceServiceEndpoint () {
+        return priceServiceEndpoint;
+    },
+    get pushingFrequency () {
+        return pushingFrequency;
+    },
+    get pythContractAddress () {
+        return pythContractAddress;
+    }
+});
+const priceServiceEndpoint = {
+    "price-service-endpoint": {
+        description: "Endpoint URL for the hermes client. e.g: https://endpoint/example",
+        type: "string",
+        required: true
+    }
+};
+const pythContractAddress = {
+    "pyth-contract-address": {
+        description: "Pyth contract address. Provide the network name on which Pyth is deployed " + "or the Pyth contract address if you use a local network.",
+        type: "string",
+        required: true
+    }
+};
+const priceConfigFile = {
+    "price-config-file": {
+        description: "Path to price configuration YAML file.",
+        type: "string",
+        required: true
+    }
+};
+const pollingFrequency = {
+    "polling-frequency": {
+        description: "The frequency to poll price info data from the network if the RPC is not a websocket.",
+        type: "number",
+        required: false,
+        default: 5
+    }
+};
+const pushingFrequency = {
+    "pushing-frequency": {
+        description: "The frequency to push prices to the RPC. " + "It is better that the value be greater than the block time of the network, so this program confirms " + "it is updated and does not push it twice.",
+        type: "number",
+        required: false,
+        default: 10
+    }
+};
+const mnemonicFile = {
+    "mnemonic-file": {
+        description: "Path to payer mnemonic (private key) file.",
+        type: "string",
+        required: true
+    }
+};
+const logLevel = {
+    "log-level": {
+        description: "Log level",
+        type: "string",
+        required: false,
+        default: "info",
+        choices: [
+            "trace",
+            "debug",
+            "info",
+            "warn",
+            "error"
+        ]
+    }
+};
+const controllerLogLevel = {
+    "controller-log-level": {
+        description: "Log level for the controller.",
+        type: "string",
+        required: false,
+        default: "info",
+        choices: [
+            "trace",
+            "debug",
+            "info",
+            "warn",
+            "error"
+        ]
+    }
+};
+const enableMetrics = {
+    "enable-metrics": {
+        description: "Enable Prometheus metrics server",
+        type: "boolean",
+        required: false,
+        default: true
+    }
+};
+const metricsPort = {
+    "metrics-port": {
+        description: "Port for the Prometheus metrics server",
+        type: "number",
+        required: false,
+        default: 9090
+    }
+};

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

@@ -1,4 +1,4 @@
-import { Options } from "yargs";
+import type { Options } from "yargs";
 export declare const priceServiceEndpoint: {
     "price-service-endpoint": Options;
 };
@@ -29,4 +29,3 @@ export declare const enableMetrics: {
 export declare const metricsPort: {
     "metrics-port": Options;
 };
-//# sourceMappingURL=options.d.ts.map

package/dist/package.json

@@ -0,0 +1 @@
+{ "type": "commonjs" }

package/dist/price-config.cjs

@@ -0,0 +1,104 @@
+/* eslint-disable @typescript-eslint/restrict-template-expressions */ /* eslint-disable @typescript-eslint/no-explicit-any */ /* 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 UpdateCondition () {
+        return UpdateCondition;
+    },
+    get readPriceConfigFile () {
+        return readPriceConfigFile;
+    },
+    get shouldUpdate () {
+        return shouldUpdate;
+    }
+});
+const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
+const _joi = /*#__PURE__*/ _interop_require_default(require("joi"));
+const _yaml = /*#__PURE__*/ _interop_require_default(require("yaml"));
+const _utils = require("./utils.cjs");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const PriceConfigFileSchema = _joi.default.array().items(_joi.default.object({
+    alias: _joi.default.string().required(),
+    id: _joi.default.string().regex(/^(0x)?[a-f0-9]{64}$/).required(),
+    time_difference: _joi.default.number().required(),
+    price_deviation: _joi.default.number().required(),
+    confidence_ratio: _joi.default.number().required(),
+    early_update: _joi.default.object({
+        time_difference: _joi.default.number().optional(),
+        price_deviation: _joi.default.number().optional(),
+        confidence_ratio: _joi.default.number().optional()
+    }).optional()
+})).unique("id").unique("alias").required();
+function readPriceConfigFile(path) {
+    const priceConfigs = _yaml.default.parse(_nodefs.default.readFileSync(path, "utf8"));
+    const validationResult = PriceConfigFileSchema.validate(priceConfigs);
+    if (validationResult.error !== undefined) {
+        throw validationResult.error;
+    }
+    return priceConfigs.map((priceConfigRaw)=>{
+        const priceConfig = {
+            alias: priceConfigRaw.alias,
+            id: (0, _utils.removeLeading0x)(priceConfigRaw.id),
+            timeDifference: priceConfigRaw.time_difference,
+            priceDeviation: priceConfigRaw.price_deviation,
+            confidenceRatio: priceConfigRaw.confidence_ratio,
+            customEarlyUpdate: priceConfigRaw.early_update !== undefined,
+            earlyUpdateTimeDifference: priceConfigRaw.early_update?.time_difference,
+            earlyUpdatePriceDeviation: priceConfigRaw.early_update?.price_deviation,
+            earlyUpdateConfidenceRatio: priceConfigRaw.early_update?.confidence_ratio
+        };
+        return priceConfig;
+    });
+}
+var UpdateCondition = /*#__PURE__*/ function(UpdateCondition) {
+    // This price feed must be updated
+    UpdateCondition[UpdateCondition["YES"] = 0] = "YES";
+    // This price feed may be updated as part of a larger batch
+    UpdateCondition[UpdateCondition["EARLY"] = 1] = "EARLY";
+    // This price feed shouldn't be updated
+    UpdateCondition[UpdateCondition["NO"] = 2] = "NO";
+    return UpdateCondition;
+}({});
+function shouldUpdate(priceConfig, sourceLatestPrice, targetLatestPrice, logger) {
+    const priceId = priceConfig.id;
+    // There is no price to update the target with. So we should not update it.
+    if (sourceLatestPrice === undefined) {
+        logger.info(`${priceConfig.alias} (${priceId}) is not available on the source network. Ignoring it.`);
+        return 2;
+    }
+    // It means that price never existed there. So we should push the latest price feed.
+    if (targetLatestPrice === undefined) {
+        logger.info(`${priceConfig.alias} (${priceId}) is not available on the target network. Pushing the price.`);
+        return 0;
+    }
+    // The current price is not newer than the price onchain
+    if (sourceLatestPrice.publishTime < targetLatestPrice.publishTime) {
+        return 2;
+    }
+    const timeDifference = sourceLatestPrice.publishTime - targetLatestPrice.publishTime;
+    const priceDeviationPct = Math.abs(Number(sourceLatestPrice.price) - Number(targetLatestPrice.price)) / Number(targetLatestPrice.price) * 100;
+    const confidenceRatioPct = Math.abs(Number(sourceLatestPrice.conf) / Number(sourceLatestPrice.price) * 100);
+    logger.info({
+        sourcePrice: sourceLatestPrice,
+        targetPrice: targetLatestPrice,
+        symbol: priceConfig.alias
+    }, `Analyzing price ${priceConfig.alias} (${priceId}). ` + `Time difference: ${timeDifference} (< ${priceConfig.timeDifference}? / early: < ${priceConfig.earlyUpdateTimeDifference}) OR ` + `Price deviation: ${priceDeviationPct.toFixed(5)}% (< ${priceConfig.priceDeviation}%? / early: < ${priceConfig.earlyUpdatePriceDeviation}%?) OR ` + `Confidence ratio: ${confidenceRatioPct.toFixed(5)}% (< ${priceConfig.confidenceRatio}%? / early: < ${priceConfig.earlyUpdateConfidenceRatio}%?)`);
+    if (timeDifference >= priceConfig.timeDifference || priceDeviationPct >= priceConfig.priceDeviation || confidenceRatioPct >= priceConfig.confidenceRatio) {
+        return 0;
+    } else if (priceConfig.customEarlyUpdate === undefined || !priceConfig.customEarlyUpdate || priceConfig.earlyUpdateTimeDifference !== undefined && timeDifference >= priceConfig.earlyUpdateTimeDifference || priceConfig.earlyUpdatePriceDeviation !== undefined && priceDeviationPct >= priceConfig.earlyUpdatePriceDeviation || priceConfig.earlyUpdateConfidenceRatio !== undefined && confidenceRatioPct >= priceConfig.earlyUpdateConfidenceRatio) {
+        return 1;
+    } else {
+        return 2;
+    }
+}

package/{lib → dist}/price-config.d.ts

@@ -1,7 +1,7 @@
-import { HexString } from "@pythnetwork/hermes-client";
-import { Logger } from "pino";
-import { DurationInSeconds, PctNumber } from "./utils";
-import { PriceInfo } from "./interface";
+import type { HexString } from "@pythnetwork/hermes-client";
+import type { Logger } from "pino";
+import type { PriceInfo } from "./interface.js";
+import type { DurationInSeconds, PctNumber } from "./utils.js";
 export type PriceConfig = {
     alias: string;
     id: HexString;
@@ -22,8 +22,7 @@ export declare enum UpdateCondition {
 /**
  * Checks whether on-chain price needs to be updated with the latest pyth price information.
  *
- * @param priceConfig Config of the price feed to check
+ * @param priceConfig - Config of the price feed to check
  * @returns True if the on-chain price needs to be updated.
  */
 export declare function shouldUpdate(priceConfig: PriceConfig, sourceLatestPrice: PriceInfo | undefined, targetLatestPrice: PriceInfo | undefined, logger: Logger): UpdateCondition;
-//# sourceMappingURL=price-config.d.ts.map

package/{lib/pyth-price-listener.js → dist/pyth-price-listener.cjs}

@@ -1,7 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PythPriceListener = void 0;
-const utils_1 = require("./utils");
+/* eslint-disable no-console */ /* eslint-disable @typescript-eslint/no-unsafe-argument */ /* eslint-disable unicorn/prefer-add-event-listener */ /* eslint-disable @typescript-eslint/restrict-template-expressions */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "PythPriceListener", {
+    enumerable: true,
+    get: function() {
+        return PythPriceListener;
+    }
+});
+const _utils = require("./utils.cjs");
 class PythPriceListener {
     hermesClient;
     priceIds;
@@ -10,21 +17,23 @@ class PythPriceListener {
     logger;
     lastUpdated;
     healthCheckInterval;
-    constructor(hermesClient, priceItems, logger) {
+    constructor(hermesClient, priceItems, logger){
         this.hermesClient = hermesClient;
-        this.priceIds = priceItems.map((priceItem) => priceItem.id);
-        this.priceIdToAlias = new Map(priceItems.map((priceItem) => [priceItem.id, priceItem.alias]));
+        this.priceIds = priceItems.map((priceItem)=>priceItem.id);
+        this.priceIdToAlias = new Map(priceItems.map((priceItem)=>[
+                priceItem.id,
+                priceItem.alias
+            ]));
         this.latestPriceInfo = new Map();
         this.logger = logger;
     }
     // This method should be awaited on and once it finishes it has the latest value
     // for the given price feeds (if they exist).
     async start() {
-        this.startListening();
+        await this.startListening();
         // Store health check interval reference
-        this.healthCheckInterval = setInterval(() => {
-            if (this.lastUpdated === undefined ||
-                this.lastUpdated < Date.now() - 30 * 1000) {
+        this.healthCheckInterval = setInterval(()=>{
+            if (this.lastUpdated === undefined || this.lastUpdated < Date.now() - 30 * 1000) {
                 throw new Error("Hermes Price feeds are not updating.");
             }
         }, 5000);
@@ -33,34 +42,32 @@ class PythPriceListener {
         this.logger.info(`Starting to listen for price updates from Hermes for ${this.priceIds.length} price feeds.`);
         const eventSource = await this.hermesClient.getPriceUpdatesStream(this.priceIds, {
             parsed: true,
-            ignoreInvalidPriceIds: true,
+            ignoreInvalidPriceIds: true
         });
-        eventSource.onmessage = (event) => {
+        eventSource.onmessage = (event)=>{
             const priceUpdates = JSON.parse(event.data);
-            priceUpdates.parsed?.forEach((priceUpdate) => {
+            if (priceUpdates.parsed) for (const priceUpdate of priceUpdates.parsed){
                 this.logger.debug(`Received new price feed update from Pyth price service: ${this.priceIdToAlias.get(priceUpdate.id)} ${priceUpdate.id}`);
                 // Consider price to be currently available if it is not older than 60s
-                const currentPrice = Date.now() / 1000 - priceUpdate.price.publish_time > 60
-                    ? undefined
-                    : priceUpdate.price;
+                const currentPrice = Date.now() / 1000 - priceUpdate.price.publish_time > 60 ? undefined : priceUpdate.price;
                 if (currentPrice === undefined) {
                     this.logger.debug("Price is older than 60s, skipping");
-                    return;
+                    continue;
                 }
                 const priceInfo = {
                     conf: currentPrice.conf,
                     price: currentPrice.price,
-                    publishTime: currentPrice.publish_time,
+                    publishTime: currentPrice.publish_time
                 };
                 this.latestPriceInfo.set(priceUpdate.id, priceInfo);
                 this.lastUpdated = Date.now();
-            });
+            }
         };
-        eventSource.onerror = async (error) => {
+        eventSource.onerror = async (error)=>{
             console.error("Error receiving updates from Hermes:", error);
             eventSource.close();
-            await (0, utils_1.sleep)(5000); // Wait a bit before trying to reconnect
-            this.startListening(); // Attempt to restart the listener
+            await (0, _utils.sleep)(5000); // Wait a bit before trying to reconnect
+            void this.startListening(); // Attempt to restart the listener
         };
     }
     getLatestPriceInfo(priceId) {
@@ -72,4 +79,3 @@ class PythPriceListener {
         }
     }
 }
-exports.PythPriceListener = PythPriceListener;

package/{lib → dist}/pyth-price-listener.d.ts

@@ -1,6 +1,7 @@
-import { HexString, HermesClient } from "@pythnetwork/hermes-client";
-import { PriceInfo, IPriceListener, PriceItem } from "./interface";
-import { Logger } from "pino";
+import type { HexString } from "@pythnetwork/hermes-client";
+import { HermesClient } from "@pythnetwork/hermes-client";
+import type { Logger } from "pino";
+import type { PriceInfo, IPriceListener, PriceItem } from "./interface.js";
 export declare class PythPriceListener implements IPriceListener {
     private hermesClient;
     private priceIds;
@@ -15,4 +16,3 @@ export declare class PythPriceListener implements IPriceListener {
     getLatestPriceInfo(priceId: HexString): PriceInfo | undefined;
     cleanup(): void;
 }
-//# sourceMappingURL=pyth-price-listener.d.ts.map

package/dist/solana/balance-tracker.cjs

@@ -0,0 +1,60 @@
+"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 SolanaBalanceTracker () {
+        return SolanaBalanceTracker;
+    },
+    get createSolanaBalanceTracker () {
+        return createSolanaBalanceTracker;
+    }
+});
+const _web3 = require("@solana/web3.js");
+const _interface = require("../interface.cjs");
+class SolanaBalanceTracker extends _interface.BaseBalanceTracker {
+    connection;
+    publicKey;
+    constructor(config){
+        super({
+            ...config,
+            logger: config.logger.child({
+                module: "SolanaBalanceTracker"
+            })
+        });
+        this.connection = config.connection;
+        this.publicKey = config.publicKey;
+    }
+    /**
+   * Solana-specific implementation of balance update
+   */ async updateBalance() {
+        try {
+            const balanceInLamports = await this.connection.getBalance(this.publicKey);
+            // Convert from lamports to SOL
+            const balanceInSol = balanceInLamports / _web3.LAMPORTS_PER_SOL;
+            this.metrics.updateWalletBalance(this.address, this.network, balanceInSol);
+            this.logger.debug(`Updated Solana wallet balance: ${this.address} = ${balanceInSol.toString()} SOL (${balanceInLamports.toString()} lamports)`);
+        } catch (error) {
+            this.logger.error({
+                error
+            }, "Error fetching Solana wallet balance for metrics");
+        }
+    }
+}
+function createSolanaBalanceTracker(params) {
+    return new SolanaBalanceTracker({
+        connection: params.connection,
+        publicKey: params.publicKey,
+        address: params.publicKey.toString(),
+        network: params.network,
+        updateInterval: params.updateInterval,
+        metrics: params.metrics,
+        logger: params.logger
+    });
+}

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

@@ -1,17 +1,18 @@
 import { Connection, PublicKey } from "@solana/web3.js";
-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 { BaseBalanceTrackerConfig, IBalanceTracker } from "../interface.js";
+import { BaseBalanceTracker } from "../interface.js";
+import { PricePusherMetrics } from "../metrics.js";
+import type { DurationInSeconds } from "../utils.js";
 /**
  * Solana-specific configuration for balance tracker
  */
-export interface SolanaBalanceTrackerConfig extends BaseBalanceTrackerConfig {
+export type SolanaBalanceTrackerConfig = {
     /** Solana connection instance */
     connection: Connection;
     /** Solana public key */
     publicKey: PublicKey;
-}
+} & BaseBalanceTrackerConfig;
 /**
  * Solana-specific implementation of the balance tracker
  */
@@ -27,16 +28,15 @@ export declare class SolanaBalanceTracker extends BaseBalanceTracker {
 /**
  * Parameters for creating a Solana balance tracker
  */
-export interface CreateSolanaBalanceTrackerParams {
+export type CreateSolanaBalanceTrackerParams = {
     connection: Connection;
     publicKey: PublicKey;
     network: string;
     updateInterval: DurationInSeconds;
     metrics: PricePusherMetrics;
     logger: Logger;
-}
+};
 /**
  * Factory function to create a balance tracker for Solana
  */
 export declare function createSolanaBalanceTracker(params: CreateSolanaBalanceTrackerParams): IBalanceTracker;
-//# sourceMappingURL=balance-tracker.d.ts.map