@pythnetwork/price-pusher 4.1.1

package/lib/options.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mnemonicFile = exports.pushingFrequency = exports.pollingFrequency = exports.priceConfigFile = exports.pythContractAddress = exports.priceServiceEndpoint = void 0;
+exports.priceServiceEndpoint = {
+    "price-service-endpoint": {
+        description: "Endpoint URL for the price service. e.g: https://endpoint/example",
+        type: "string",
+        required: true,
+    },
+};
+exports.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,
+    },
+};
+exports.priceConfigFile = {
+    "price-config-file": {
+        description: "Path to price configuration YAML file.",
+        type: "string",
+        required: true,
+    },
+};
+exports.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,
+    },
+};
+exports.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,
+    },
+};
+exports.mnemonicFile = {
+    "mnemonic-file": {
+        description: "Path to payer mnemonic (private key) file.",
+        type: "string",
+        required: true,
+    },
+};

package/lib/price-config.d.ts

@@ -0,0 +1,18 @@
+import { HexString } from "@pythnetwork/price-service-client";
+import { DurationInSeconds, PctNumber } from "./utils";
+import { PriceInfo } from "./interface";
+export type PriceConfig = {
+    alias: string;
+    id: HexString;
+    timeDifference: DurationInSeconds;
+    priceDeviation: PctNumber;
+    confidenceRatio: PctNumber;
+};
+export declare function readPriceConfigFile(path: string): PriceConfig[];
+/**
+ * Checks whether on-chain price needs to be updated with the latest pyth price information.
+ *
+ * @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): boolean;

package/lib/price-config.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldUpdate = exports.readPriceConfigFile = void 0;
+const joi_1 = __importDefault(require("joi"));
+const yaml_1 = __importDefault(require("yaml"));
+const fs_1 = __importDefault(require("fs"));
+const utils_1 = require("./utils");
+const PriceConfigFileSchema = joi_1.default.array()
+    .items(joi_1.default.object({
+    alias: joi_1.default.string().required(),
+    id: joi_1.default.string()
+        .regex(/^(0x)?[a-f0-9]{64}$/)
+        .required(),
+    time_difference: joi_1.default.number().required(),
+    price_deviation: joi_1.default.number().required(),
+    confidence_ratio: joi_1.default.number().required(),
+}))
+    .unique("id")
+    .unique("alias")
+    .required();
+function readPriceConfigFile(path) {
+    const priceConfigs = yaml_1.default.parse(fs_1.default.readFileSync(path, "utf-8"));
+    const validationResult = PriceConfigFileSchema.validate(priceConfigs);
+    if (validationResult.error !== undefined) {
+        throw validationResult.error;
+    }
+    return priceConfigs.map((priceConfigRaw) => {
+        const priceConfig = {
+            alias: priceConfigRaw.alias,
+            id: (0, utils_1.removeLeading0x)(priceConfigRaw.id),
+            timeDifference: priceConfigRaw.time_difference,
+            priceDeviation: priceConfigRaw.price_deviation,
+            confidenceRatio: priceConfigRaw.confidence_ratio,
+        };
+        return priceConfig;
+    });
+}
+exports.readPriceConfigFile = readPriceConfigFile;
+/**
+ * Checks whether on-chain price needs to be updated with the latest pyth price information.
+ *
+ * @param priceConfig Config of the price feed to check
+ * @returns True if the on-chain price needs to be updated.
+ */
+function shouldUpdate(priceConfig, sourceLatestPrice, targetLatestPrice) {
+    const priceId = priceConfig.id;
+    // There is no price to update the target with.
+    if (sourceLatestPrice === undefined) {
+        return false;
+    }
+    // It means that price never existed there. So we should push the latest price feed.
+    if (targetLatestPrice === undefined) {
+        console.log(`${priceConfig.alias} (${priceId}) is not available on the target network. Pushing the price.`);
+        return true;
+    }
+    // The current price is not newer than the price onchain
+    if (sourceLatestPrice.publishTime < targetLatestPrice.publishTime) {
+        return false;
+    }
+    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);
+    console.log(`Analyzing price ${priceConfig.alias} (${priceId})`);
+    console.log("Source latest price: ", sourceLatestPrice);
+    console.log("Target latest price: ", targetLatestPrice);
+    console.log(`Time difference: ${timeDifference} (< ${priceConfig.timeDifference}?) OR ` +
+        `Price deviation: ${priceDeviationPct.toFixed(5)}% (< ${priceConfig.priceDeviation}%?) OR ` +
+        `Confidence ratio: ${confidenceRatioPct.toFixed(5)}% (< ${priceConfig.confidenceRatio}%?)`);
+    const result = timeDifference >= priceConfig.timeDifference ||
+        priceDeviationPct >= priceConfig.priceDeviation ||
+        confidenceRatioPct >= priceConfig.confidenceRatio;
+    return result;
+}
+exports.shouldUpdate = shouldUpdate;

package/lib/pyth-price-listener.d.ts

@@ -0,0 +1,12 @@
+import { PriceServiceConnection } from "@pythnetwork/price-service-client";
+import { PriceInfo, IPriceListener, PriceItem } from "./interface";
+export declare class PythPriceListener implements IPriceListener {
+    private connection;
+    private priceIds;
+    private priceIdToAlias;
+    private latestPriceInfo;
+    constructor(connection: PriceServiceConnection, priceItems: PriceItem[]);
+    start(): Promise<void>;
+    private onNewPriceFeed;
+    getLatestPriceInfo(priceId: string): PriceInfo | undefined;
+}

package/lib/pyth-price-listener.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PythPriceListener = void 0;
+class PythPriceListener {
+    connection;
+    priceIds;
+    priceIdToAlias;
+    latestPriceInfo;
+    constructor(connection, priceItems) {
+        this.connection = connection;
+        this.priceIds = priceItems.map((priceItem) => priceItem.id);
+        this.priceIdToAlias = new Map(priceItems.map((priceItem) => [priceItem.id, priceItem.alias]));
+        this.latestPriceInfo = new Map();
+    }
+    // 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.connection.subscribePriceFeedUpdates(this.priceIds, this.onNewPriceFeed.bind(this));
+        const priceFeeds = await this.connection.getLatestPriceFeeds(this.priceIds);
+        priceFeeds?.forEach((priceFeed) => {
+            // Getting unchecked because although it might be old
+            // but might not be there on the target chain.
+            const latestAvailablePrice = priceFeed.getPriceUnchecked();
+            this.latestPriceInfo.set(priceFeed.id, {
+                price: latestAvailablePrice.price,
+                conf: latestAvailablePrice.conf,
+                publishTime: latestAvailablePrice.publishTime,
+            });
+        });
+    }
+    onNewPriceFeed(priceFeed) {
+        console.log(`Received new price feed update from Pyth price service: ${this.priceIdToAlias.get(priceFeed.id)} ${priceFeed.id}`);
+        // Consider price to be currently available if it is not older than 60s
+        const currentPrice = priceFeed.getPriceNoOlderThan(60);
+        if (currentPrice === undefined) {
+            return;
+        }
+        const priceInfo = {
+            conf: currentPrice.conf,
+            price: currentPrice.price,
+            publishTime: currentPrice.publishTime,
+        };
+        this.latestPriceInfo.set(priceFeed.id, priceInfo);
+    }
+    getLatestPriceInfo(priceId) {
+        return this.latestPriceInfo.get(priceId);
+    }
+}
+exports.PythPriceListener = PythPriceListener;

package/lib/utils.d.ts

@@ -0,0 +1,12 @@
+import { HexString } from "@pythnetwork/price-service-client";
+export type PctNumber = number;
+export type DurationInSeconds = number;
+export declare const txSpeeds: readonly ["slow", "standard", "fast"];
+export type TxSpeed = typeof txSpeeds[number];
+export declare const customGasChainIds: readonly [137];
+export type CustomGasChainId = typeof customGasChainIds[number];
+export declare function sleep(ms: number): Promise<void>;
+export declare function removeLeading0x(id: HexString): HexString;
+export declare function addLeading0x(id: HexString): HexString;
+export declare function isWsEndpoint(endpoint: string): boolean;
+export declare function verifyValidOption<options extends Readonly<Array<any>>, validOption extends options[number]>(option: any, validOptions: options): validOption;

package/lib/utils.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyValidOption = exports.isWsEndpoint = exports.addLeading0x = exports.removeLeading0x = exports.sleep = exports.customGasChainIds = exports.txSpeeds = void 0;
+exports.txSpeeds = ["slow", "standard", "fast"];
+exports.customGasChainIds = [137];
+async function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+exports.sleep = sleep;
+function removeLeading0x(id) {
+    if (id.startsWith("0x")) {
+        return id.substring(2);
+    }
+    return id;
+}
+exports.removeLeading0x = removeLeading0x;
+function addLeading0x(id) {
+    if (id.startsWith("0x")) {
+        return id;
+    }
+    return "0x" + id;
+}
+exports.addLeading0x = addLeading0x;
+function isWsEndpoint(endpoint) {
+    const url = new URL(endpoint);
+    const protocol = url.protocol;
+    if (protocol === "ws:" || protocol == "wss:") {
+        return true;
+    }
+    return false;
+}
+exports.isWsEndpoint = isWsEndpoint;
+function verifyValidOption(option, validOptions) {
+    if (validOptions.includes(option)) {
+        return option;
+    }
+    const errorString = option + " is not a valid option. Please choose between " + validOptions;
+    throw new Error(errorString);
+}
+exports.verifyValidOption = verifyValidOption;

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@pythnetwork/price-pusher",
+  "version": "4.1.1",
+  "description": "Pyth Price Pusher",
+  "homepage": "https://pyth.network",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib/**/*"
+  ],
+  "bin": {
+    "pyth-price-pusher": "./lib/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pyth-network/pyth-crosschain",
+    "directory": "price_pusher"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "jest src/ --passWithNoTests",
+    "build": "tsc",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "lint": "eslint src/",
+    "start": "node lib/index.js",
+    "dev": "ts-node src/index.ts",
+    "prepublishOnly": "npm run build && npm test && npm run lint",
+    "preversion": "npm run lint",
+    "version": "npm run format && git add -A src"
+  },
+  "keywords": [
+    "pyth",
+    "oracle",
+    "evm",
+    "ethereum",
+    "injective"
+  ],
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@types/ethereum-protocol": "^1.0.2",
+    "@types/jest": "^27.4.1",
+    "@types/yargs": "^17.0.10",
+    "@typescript-eslint/eslint-plugin": "^5.20.0",
+    "@typescript-eslint/parser": "^5.20.0",
+    "eslint": "^8.13.0",
+    "jest": "^27.5.1",
+    "prettier": "^2.6.2",
+    "ts-jest": "^27.1.4",
+    "typescript": "^4.6.3"
+  },
+  "dependencies": {
+    "@injectivelabs/sdk-ts": "^1.0.484",
+    "@pythnetwork/price-service-client": "*",
+    "@pythnetwork/pyth-sdk-solidity": "*",
+    "@truffle/hdwallet-provider": "^2.1.3",
+    "joi": "^17.6.0",
+    "web3": "^1.8.1",
+    "web3-eth-contract": "^1.8.1",
+    "yaml": "^2.1.1",
+    "yargs": "^17.5.1"
+  },
+  "gitHead": "94f38fdd745ba4211e4aee0b361b2f6d82522f8c"
+}