@pythnetwork/price-pusher 10.0.0 → 10.3.0

package/dist/metrics.cjs

@@ -0,0 +1,218 @@
+/* eslint-disable @typescript-eslint/restrict-template-expressions */ /* eslint-disable @typescript-eslint/no-misused-promises */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "PricePusherMetrics", {
+    enumerable: true,
+    get: function() {
+        return PricePusherMetrics;
+    }
+});
+const _express = /*#__PURE__*/ _interop_require_default(require("express"));
+const _promclient = require("prom-client");
+const _priceconfig = require("./price-config.cjs");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class PricePusherMetrics {
+    registry;
+    server;
+    logger;
+    // Metrics for price feed updates
+    lastPublishedTime;
+    priceUpdateAttempts;
+    priceFeedsTotal;
+    sourceTimestamp;
+    configuredTimeDifference;
+    sourcePriceValue;
+    targetPriceValue;
+    // Wallet metrics
+    walletBalance;
+    constructor(logger){
+        this.logger = logger;
+        this.registry = new _promclient.Registry();
+        this.server = (0, _express.default)();
+        // Register the default metrics (memory, CPU, etc.)
+        this.registry.setDefaultLabels({
+            app: "price_pusher"
+        });
+        // Create metrics
+        this.lastPublishedTime = new _promclient.Gauge({
+            name: "pyth_price_last_published_time",
+            help: "The last published time of a price feed in unix timestamp",
+            labelNames: [
+                "price_id",
+                "alias"
+            ],
+            registers: [
+                this.registry
+            ]
+        });
+        this.priceUpdateAttempts = new _promclient.Counter({
+            name: "pyth_price_update_attempts_total",
+            help: "Total number of price update attempts with their trigger condition and status",
+            labelNames: [
+                "price_id",
+                "alias",
+                "trigger",
+                "status"
+            ],
+            registers: [
+                this.registry
+            ]
+        });
+        this.priceFeedsTotal = new _promclient.Gauge({
+            name: "pyth_price_feeds_total",
+            help: "Total number of price feeds being monitored",
+            registers: [
+                this.registry
+            ]
+        });
+        this.sourceTimestamp = new _promclient.Gauge({
+            name: "pyth_source_timestamp",
+            help: "Latest source chain price publish timestamp",
+            labelNames: [
+                "price_id",
+                "alias"
+            ],
+            registers: [
+                this.registry
+            ]
+        });
+        this.configuredTimeDifference = new _promclient.Gauge({
+            name: "pyth_configured_time_difference",
+            help: "Configured time difference threshold between source and target chains",
+            labelNames: [
+                "price_id",
+                "alias"
+            ],
+            registers: [
+                this.registry
+            ]
+        });
+        this.sourcePriceValue = new _promclient.Gauge({
+            name: "pyth_source_price",
+            help: "Latest price value from Pyth source",
+            labelNames: [
+                "price_id",
+                "alias"
+            ],
+            registers: [
+                this.registry
+            ]
+        });
+        this.targetPriceValue = new _promclient.Gauge({
+            name: "pyth_target_price",
+            help: "Latest price value from target chain",
+            labelNames: [
+                "price_id",
+                "alias"
+            ],
+            registers: [
+                this.registry
+            ]
+        });
+        // Wallet balance metric
+        this.walletBalance = new _promclient.Gauge({
+            name: "pyth_wallet_balance",
+            help: "Current wallet balance of the price pusher in native token units",
+            labelNames: [
+                "wallet_address",
+                "network"
+            ],
+            registers: [
+                this.registry
+            ]
+        });
+        // Setup the metrics endpoint
+        this.server.get("/metrics", async (_, res)=>{
+            res.set("Content-Type", this.registry.contentType);
+            res.end(await this.registry.metrics());
+        });
+    }
+    // Start the metrics server
+    start(port) {
+        this.server.listen(port, ()=>{
+            this.logger.info(`Metrics server started on port ${port}`);
+        });
+    }
+    // Record a successful price update
+    recordPriceUpdate(priceId, alias, trigger = "yes") {
+        this.priceUpdateAttempts.inc({
+            price_id: priceId,
+            alias,
+            trigger: trigger.toLowerCase(),
+            status: "success"
+        });
+    }
+    // Record update condition status (YES/NO/EARLY)
+    recordUpdateCondition(priceId, alias, condition) {
+        const triggerLabel = _priceconfig.UpdateCondition[condition].toLowerCase();
+        // Only record as 'skipped' when the condition is NO
+        if (condition === _priceconfig.UpdateCondition.NO) {
+            this.priceUpdateAttempts.inc({
+                price_id: priceId,
+                alias,
+                trigger: triggerLabel,
+                status: "skipped"
+            });
+        }
+    // YES and EARLY don't increment the counter here - they'll be counted
+    // when recordPriceUpdate or recordPriceUpdateError is called
+    }
+    // Record a price update error
+    recordPriceUpdateError(priceId, alias, trigger = "yes") {
+        this.priceUpdateAttempts.inc({
+            price_id: priceId,
+            alias,
+            trigger: trigger.toLowerCase(),
+            status: "error"
+        });
+    }
+    // Set the number of price feeds
+    setPriceFeedsTotal(count) {
+        this.priceFeedsTotal.set(count);
+    }
+    // Update source, target and configured time difference timestamps
+    updateTimestamps(priceId, alias, targetLatestPricePublishTime, sourceLatestPricePublishTime, priceConfigTimeDifference) {
+        this.sourceTimestamp.set({
+            price_id: priceId,
+            alias
+        }, sourceLatestPricePublishTime);
+        this.lastPublishedTime.set({
+            price_id: priceId,
+            alias
+        }, targetLatestPricePublishTime);
+        this.configuredTimeDifference.set({
+            price_id: priceId,
+            alias
+        }, priceConfigTimeDifference);
+    }
+    // Update price values
+    updatePriceValues(priceId, alias, sourcePrice, targetPrice) {
+        if (sourcePrice !== undefined) {
+            this.sourcePriceValue.set({
+                price_id: priceId,
+                alias
+            }, Number(sourcePrice));
+        }
+        if (targetPrice !== undefined) {
+            this.targetPriceValue.set({
+                price_id: priceId,
+                alias
+            }, Number(targetPrice));
+        }
+    }
+    // Update wallet balance
+    updateWalletBalance(walletAddress, network, balance) {
+        // Convert to number for compatibility with prometheus
+        const balanceNum = typeof balance === "bigint" ? Number(balance) / 1e18 : balance;
+        this.walletBalance.set({
+            wallet_address: walletAddress,
+            network
+        }, balanceNum);
+        this.logger.debug(`Updated wallet balance metric: ${walletAddress} = ${balanceNum}`);
+    }
+}

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

@@ -1,16 +1,18 @@
+import type { Logger } from "pino";
 import { Counter, Gauge } from "prom-client";
-import { Logger } from "pino";
-import { UpdateCondition } from "./price-config";
+import { UpdateCondition } from "./price-config.js";
 export declare class PricePusherMetrics {
     private registry;
     private server;
     private logger;
-    lastPublishedTime: Gauge<string>;
-    priceUpdateAttempts: Counter<string>;
-    priceFeedsTotal: Gauge<string>;
-    sourceTimestamp: Gauge<string>;
-    configuredTimeDifference: Gauge<string>;
-    walletBalance: Gauge<string>;
+    lastPublishedTime: Gauge;
+    priceUpdateAttempts: Counter;
+    priceFeedsTotal: Gauge;
+    sourceTimestamp: Gauge;
+    configuredTimeDifference: Gauge;
+    sourcePriceValue: Gauge;
+    targetPriceValue: Gauge;
+    walletBalance: Gauge;
     constructor(logger: Logger);
     start(port: number): void;
     recordPriceUpdate(priceId: string, alias: string, trigger?: string): void;
@@ -18,6 +20,6 @@ export declare class PricePusherMetrics {
     recordPriceUpdateError(priceId: string, alias: string, trigger?: string): void;
     setPriceFeedsTotal(count: number): void;
     updateTimestamps(priceId: string, alias: string, targetLatestPricePublishTime: number, sourceLatestPricePublishTime: number, priceConfigTimeDifference: number): void;
+    updatePriceValues(priceId: string, alias: string, sourcePrice: string | undefined, targetPrice: string | undefined): void;
     updateWalletBalance(walletAddress: string, network: string, balance: bigint | number): void;
 }
-//# sourceMappingURL=metrics.d.ts.map

package/dist/near/command.cjs

@@ -0,0 +1,129 @@
+/* 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 _hermesclient = require("@pythnetwork/hermes-client");
+const _pino = 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 _near = require("./near.cjs");
+const _utils = require("../utils.cjs");
+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: "near",
+    describe: "run price pusher for near",
+    builder: {
+        "node-url": {
+            description: "NEAR RPC API url. used to make JSON RPC calls to interact with NEAR.",
+            type: "string",
+            required: true
+        },
+        network: {
+            description: "testnet or mainnet.",
+            type: "string",
+            required: true
+        },
+        "account-id": {
+            description: "payer account identifier.",
+            type: "string",
+            required: true
+        },
+        "private-key-path": {
+            description: "path to payer private key file.",
+            type: "string",
+            required: false
+        },
+        ..._options.priceConfigFile,
+        ..._options.priceServiceEndpoint,
+        ..._options.pythContractAddress,
+        ..._options.pollingFrequency,
+        ..._options.pushingFrequency,
+        ..._options.logLevel,
+        ..._options.controllerLogLevel
+    },
+    handler: async function(argv) {
+        // FIXME: type checks for this
+        const { nodeUrl, network, accountId, privateKeyPath, priceConfigFile, priceServiceEndpoint, pythContractAddress, pushingFrequency, pollingFrequency, logLevel, controllerLogLevel } = argv;
+        const logger = (0, _pino.pino)({
+            level: logLevel
+        });
+        const priceConfigs = (0, _priceconfig.readPriceConfigFile)(priceConfigFile);
+        const hermesClient = new _hermesclient.HermesClient(priceServiceEndpoint);
+        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;
+        const pythListener = new _pythpricelistener.PythPriceListener(hermesClient, priceItems, logger);
+        const nearAccount = new _near.NearAccount(network, accountId, nodeUrl, privateKeyPath, pythContractAddress);
+        const nearListener = new _near.NearPriceListener(nearAccount, priceItems, logger.child({
+            module: "NearPriceListener"
+        }), {
+            pollingFrequency
+        });
+        const nearPusher = new _near.NearPricePusher(nearAccount, hermesClient, logger.child({
+            module: "NearPricePusher"
+        }));
+        const controller = new _controller.Controller(priceConfigs, pythListener, nearListener, nearPusher, logger.child({
+            module: "Controller"
+        }, {
+            level: controllerLogLevel
+        }), {
+            pushingFrequency
+        });
+        void controller.start();
+    }
+};

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

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

package/dist/near/near.cjs

@@ -0,0 +1,183 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */ /* eslint-disable unicorn/no-array-reduce */ /* eslint-disable @typescript-eslint/no-explicit-any */ /* eslint-disable @typescript-eslint/no-unsafe-member-access */ /* eslint-disable @typescript-eslint/restrict-template-expressions */ /* 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 NearAccount () {
+        return NearAccount;
+    },
+    get NearPriceListener () {
+        return NearPriceListener;
+    },
+    get NearPricePusher () {
+        return NearPricePusher;
+    }
+});
+const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
+const _nodeos = /*#__PURE__*/ _interop_require_default(require("node:os"));
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _nearapijs = require("near-api-js");
+const _key_stores = require("near-api-js/lib/key_stores");
+const _interface = require("../interface.cjs");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class NearPriceListener extends _interface.ChainPriceListener {
+    account;
+    logger;
+    constructor(account, priceItems, logger, config){
+        super(config.pollingFrequency, priceItems), this.account = account, this.logger = logger;
+    }
+    async getOnChainPriceInfo(priceId) {
+        try {
+            const priceRaw = await this.account.getPriceUnsafe(priceId);
+            this.logger.debug(`Polled a NEAR on chain price for feed ${this.priceIdToAlias.get(priceId)} (${priceId}) ${JSON.stringify(priceRaw)}.`);
+            return priceRaw ? {
+                conf: priceRaw.conf,
+                price: priceRaw.price,
+                publishTime: priceRaw.publish_time
+            } : undefined;
+        } catch (error) {
+            this.logger.error(error, `Polling on-chain price for ${priceId} failed.:`);
+            return undefined;
+        }
+    }
+}
+class NearPricePusher {
+    account;
+    hermesClient;
+    logger;
+    constructor(account, hermesClient, logger){
+        this.account = account;
+        this.hermesClient = hermesClient;
+        this.logger = logger;
+    }
+    async updatePriceFeed(priceIds, pubTimesToPush) {
+        if (priceIds.length === 0) {
+            return;
+        }
+        if (priceIds.length !== pubTimesToPush.length) throw new Error("Invalid arguments");
+        let priceFeedUpdateData;
+        try {
+            priceFeedUpdateData = await this.getPriceFeedsUpdateData(priceIds);
+        } catch (error) {
+            this.logger.error(error, "getPriceFeedsUpdateData failed");
+            return;
+        }
+        for (const data of priceFeedUpdateData){
+            let updateFee;
+            try {
+                updateFee = await this.account.getUpdateFeeEstimate(data);
+                this.logger.debug(`Update fee: ${updateFee}`);
+            } catch (error) {
+                this.logger.error(error, "getUpdateFeeEstimate failed");
+                continue;
+            }
+            try {
+                const outcome = await this.account.updatePriceFeeds(data, updateFee);
+                const failureMessages = [];
+                const is_success = Object.values(outcome.receipts_outcome).reduce((is_success, receipt)=>{
+                    if (Object.prototype.hasOwnProperty.call(receipt.outcome.status, "Failure")) {
+                        failureMessages.push(receipt.outcome.status);
+                        return false;
+                    }
+                    return is_success;
+                }, true);
+                if (is_success) {
+                    this.logger.info({
+                        hash: outcome.transaction.hash
+                    }, "updatePriceFeeds successful.");
+                } else {
+                    this.logger.error({
+                        failureMessages
+                    }, "updatePriceFeeds failed");
+                }
+            } catch (error) {
+                this.logger.error(error, "updatePriceFeeds failed");
+            }
+        }
+    }
+    async getPriceFeedsUpdateData(priceIds) {
+        const response = await this.hermesClient.getLatestPriceUpdates(priceIds, {
+            encoding: "base64",
+            ignoreInvalidPriceIds: true
+        });
+        return response.binary.data;
+    }
+}
+class NearAccount {
+    pythAccountId;
+    account;
+    constructor(network, accountId, nodeUrl, privateKeyPath, pythAccountId){
+        this.pythAccountId = pythAccountId;
+        const connection = this.getConnection(network, accountId, nodeUrl, privateKeyPath);
+        this.account = new _nearapijs.Account(connection, accountId);
+    }
+    async getPriceUnsafe(priceId) {
+        return await this.account.viewFunction({
+            contractId: this.pythAccountId,
+            methodName: "get_price_unsafe",
+            args: {
+                price_identifier: priceId
+            }
+        });
+    }
+    async getUpdateFeeEstimate(data) {
+        return await this.account.viewFunction({
+            contractId: this.pythAccountId,
+            methodName: "get_update_fee_estimate",
+            args: {
+                data
+            }
+        });
+    }
+    async updatePriceFeeds(data, updateFee) {
+        return await this.account.functionCall({
+            contractId: this.pythAccountId,
+            methodName: "update_price_feeds",
+            args: {
+                data
+            },
+            gas: "300000000000000",
+            attachedDeposit: updateFee
+        });
+    }
+    getConnection(network, accountId, nodeUrl, privateKeyPath) {
+        const content = _nodefs.default.readFileSync(// eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+        privateKeyPath || _nodepath.default.join(_nodeos.default.homedir(), ".near-credentials", network, accountId + ".json"));
+        const accountInfo = JSON.parse(content.toString());
+        let privateKey = accountInfo.private_key;
+        if (!privateKey && accountInfo.secret_key) {
+            privateKey = accountInfo.secret_key;
+        }
+        if (accountInfo.account_id && privateKey) {
+            const keyPair = _nearapijs.KeyPair.fromString(privateKey);
+            const keyStore = new _key_stores.InMemoryKeyStore();
+            void keyStore.setKey(network, accountInfo.account_id, keyPair);
+            return _nearapijs.Connection.fromConfig({
+                networkId: network,
+                provider: {
+                    type: "JsonRpcProvider",
+                    args: {
+                        url: nodeUrl
+                    }
+                },
+                signer: {
+                    type: "InMemorySigner",
+                    keyStore
+                },
+                jsvmAccountId: `jsvm.${network}`
+            });
+        } else {
+            throw new Error("Invalid key file!");
+        }
+    }
+}

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

@@ -1,8 +1,9 @@
-import { IPricePusher, PriceInfo, ChainPriceListener, PriceItem } from "../interface";
 import { HermesClient } from "@pythnetwork/hermes-client";
-import { DurationInSeconds } from "../utils";
-import { FinalExecutionOutcome } from "near-api-js/lib/providers/provider";
-import { Logger } from "pino";
+import type { FinalExecutionOutcome } from "near-api-js/lib/providers/provider";
+import type { Logger } from "pino";
+import type { IPricePusher, PriceInfo, PriceItem } from "../interface.js";
+import { ChainPriceListener } from "../interface.js";
+import type { DurationInSeconds } from "../utils.js";
 export declare class NearPriceListener extends ChainPriceListener {
     private account;
     private logger;
@@ -28,4 +29,3 @@ export declare class NearAccount {
     updatePriceFeeds(data: string, updateFee: any): Promise<FinalExecutionOutcome>;
     private getConnection;
 }
-//# sourceMappingURL=near.d.ts.map