@pythnetwork/price-pusher 4.1.1

package/lib/evm/evm.js

@@ -0,0 +1,265 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PythContractFactory = exports.EvmPricePusher = exports.EvmPriceListener = void 0;
+const interface_1 = require("../interface");
+const utils_1 = require("../utils");
+const AbstractPyth_json_1 = __importDefault(require("@pythnetwork/pyth-sdk-solidity/abis/AbstractPyth.json"));
+const hdwallet_provider_1 = __importDefault(require("@truffle/hdwallet-provider"));
+const web3_1 = __importDefault(require("web3"));
+const utils_2 = require("../utils");
+class EvmPriceListener extends interface_1.ChainPriceListener {
+    pythContractFactory;
+    pythContract;
+    constructor(pythContractFactory, priceItems, config) {
+        super("Evm", config.pollingFrequency, priceItems);
+        this.pythContractFactory = pythContractFactory;
+        this.pythContract = this.pythContractFactory.createPythContract();
+    }
+    // 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() {
+        if (this.pythContractFactory.hasWebsocketProvider()) {
+            console.log("Subscribing to the target network pyth contract events...");
+            this.startSubscription();
+        }
+        else {
+            console.log("The target network RPC endpoint is not Websocket. " +
+                "Listening for updates only via polling....");
+        }
+        // base class for polling
+        await super.start();
+    }
+    async startSubscription() {
+        for (const { id: priceId } of this.priceItems) {
+            this.pythContract.events.PriceFeedUpdate({
+                filter: {
+                    id: (0, utils_1.addLeading0x)(priceId),
+                    fresh: true,
+                },
+            }, this.onPriceFeedUpdate.bind(this));
+        }
+    }
+    onPriceFeedUpdate(err, event) {
+        if (err !== null) {
+            console.error("PriceFeedUpdate EventEmitter received an error..");
+            throw err;
+        }
+        const priceId = (0, utils_1.removeLeading0x)(event.returnValues.id);
+        console.log(`Received a new Evm PriceFeedUpdate event for price feed ${this.priceIdToAlias.get(priceId)} (${priceId}).`);
+        const priceInfo = {
+            conf: event.returnValues.conf,
+            price: event.returnValues.price,
+            publishTime: Number(event.returnValues.publishTime),
+        };
+        this.updateLatestPriceInfo(priceId, priceInfo);
+    }
+    async getOnChainPriceInfo(priceId) {
+        let priceRaw;
+        try {
+            priceRaw = await this.pythContract.methods
+                .getPriceUnsafe((0, utils_1.addLeading0x)(priceId))
+                .call();
+        }
+        catch (e) {
+            console.error(`Polling on-chain price for ${priceId} failed. Error:`);
+            console.error(e);
+            return undefined;
+        }
+        console.log(`Polled an EVM on chain price for feed ${this.priceIdToAlias.get(priceId)} (${priceId}).`);
+        return {
+            conf: priceRaw.conf,
+            price: priceRaw.price,
+            publishTime: Number(priceRaw.publishTime),
+        };
+    }
+}
+exports.EvmPriceListener = EvmPriceListener;
+class EvmPricePusher {
+    connection;
+    overrideGasPriceMultiplier;
+    customGasStation;
+    pythContract;
+    web3;
+    pusherAddress;
+    lastPushAttempt;
+    constructor(connection, pythContractFactory, overrideGasPriceMultiplier, customGasStation) {
+        this.connection = connection;
+        this.overrideGasPriceMultiplier = overrideGasPriceMultiplier;
+        this.customGasStation = customGasStation;
+        this.pythContract = pythContractFactory.createPythContractWithPayer();
+        this.web3 = new web3_1.default(pythContractFactory.createWeb3PayerProvider());
+    }
+    // The pubTimes are passed here to use the values that triggered the push.
+    // This is an optimization to avoid getting a newer value (as an update comes)
+    // and will help multiple price pushers to have consistent behaviour.
+    // To ensure that we transactions are landing and we are not pushing the prices twice
+    // we will re-use the same nonce (with a higher gas price) if the previous transaction
+    // is not landed yet.
+    async updatePriceFeed(priceIds, pubTimesToPush) {
+        if (priceIds.length === 0) {
+            return;
+        }
+        if (priceIds.length !== pubTimesToPush.length)
+            throw new Error("Invalid arguments");
+        const priceIdsWith0x = priceIds.map((priceId) => (0, utils_1.addLeading0x)(priceId));
+        const priceFeedUpdateData = await this.getPriceFeedsUpdateData(priceIdsWith0x);
+        console.log("Pushing ", priceIdsWith0x);
+        let updateFee;
+        try {
+            updateFee = await this.pythContract.methods
+                .getUpdateFee(priceFeedUpdateData)
+                .call();
+            console.log(`Update fee: ${updateFee}`);
+        }
+        catch (e) {
+            console.error("An unidentified error has occured when getting the update fee:");
+            throw e;
+        }
+        let gasPrice = Number((await this.customGasStation?.getCustomGasPrice()) ||
+            (await this.web3.eth.getGasPrice()));
+        // Try to re-use the same nonce and increase the gas if the last tx is not landed yet.
+        if (this.pusherAddress === undefined) {
+            this.pusherAddress = (await this.web3.eth.getAccounts())[0];
+        }
+        const lastExecutedNonce = (await this.web3.eth.getTransactionCount(this.pusherAddress)) - 1;
+        let gasPriceToOverride = undefined;
+        if (this.lastPushAttempt !== undefined) {
+            if (this.lastPushAttempt.nonce <= lastExecutedNonce) {
+                this.lastPushAttempt = undefined;
+            }
+            else {
+                gasPriceToOverride = Math.ceil(this.lastPushAttempt.gasPrice * this.overrideGasPriceMultiplier);
+            }
+        }
+        if (gasPriceToOverride !== undefined && gasPriceToOverride > gasPrice) {
+            gasPrice = gasPriceToOverride;
+        }
+        const txNonce = lastExecutedNonce + 1;
+        console.log(`Using gas price: ${gasPrice} and nonce: ${txNonce}`);
+        this.pythContract.methods
+            .updatePriceFeedsIfNecessary(priceFeedUpdateData, priceIdsWith0x, pubTimesToPush)
+            .send({ value: updateFee, gasPrice, nonce: txNonce })
+            .on("transactionHash", (hash) => {
+            console.log(`Successful. Tx hash: ${hash}`);
+        })
+            .on("error", (err, receipt) => {
+            if (err.message.includes("revert")) {
+                // Since we are using custom error structs on solidity the rejection
+                // doesn't return any information why the call has reverted. Assuming that
+                // the update data is valid there is no possible rejection cause other than
+                // the target chain price being already updated.
+                console.log("Execution reverted. With high probablity, the target chain price " +
+                    "has already updated, Skipping this push.");
+                return;
+            }
+            if (err.message.includes("the tx doesn't have the correct nonce.") ||
+                err.message.includes("nonce too low")) {
+                console.log("Multiple users are using the same accounts and nonce is incorrect. Skipping this push.");
+                return;
+            }
+            if (err.message.includes("sender doesn't have enough funds to send tx.")) {
+                console.error("Payer is out of balance, please top it up.");
+                throw err;
+            }
+            if (err.message.includes("transaction underpriced")) {
+                console.error("The gas price of the transaction is too low. Skipping this push. " +
+                    "You might want to use a custom gas station or increase the override gas price " +
+                    "multiplier to increase the likelihood of the transaction landing on-chain.");
+                return;
+            }
+            if (err.message.includes("could not replace existing tx")) {
+                console.log("A transaction with the same nonce has been mined and this one is no longer needed.");
+                return;
+            }
+            console.error("An unidentified error has occured:");
+            console.error(receipt);
+            throw err;
+        });
+        // Update lastAttempt
+        this.lastPushAttempt = {
+            nonce: txNonce,
+            gasPrice: gasPrice,
+        };
+    }
+    async getPriceFeedsUpdateData(priceIds) {
+        const latestVaas = await this.connection.getLatestVaas(priceIds);
+        return latestVaas.map((vaa) => "0x" + Buffer.from(vaa, "base64").toString("hex"));
+    }
+}
+exports.EvmPricePusher = EvmPricePusher;
+class PythContractFactory {
+    endpoint;
+    mnemonic;
+    pythContractAddress;
+    constructor(endpoint, mnemonic, pythContractAddress) {
+        this.endpoint = endpoint;
+        this.mnemonic = mnemonic;
+        this.pythContractAddress = pythContractAddress;
+    }
+    /**
+     * This method creates a web3 Pyth contract with payer (based on HDWalletProvider). As this
+     * provider is an HDWalletProvider it does not support subscriptions even if the
+     * endpoint is a websocket endpoint.
+     *
+     * @returns Pyth contract
+     */
+    createPythContractWithPayer() {
+        const provider = this.createWeb3PayerProvider();
+        const web3 = new web3_1.default(provider);
+        return new web3.eth.Contract(AbstractPyth_json_1.default, this.pythContractAddress, {
+            from: provider.getAddress(0),
+        });
+    }
+    /**
+     * This method creates a web3 Pyth contract with the given endpoint as its provider. If
+     * the endpoint is a websocket endpoint the contract will support subscriptions.
+     *
+     * @returns Pyth contract
+     */
+    createPythContract() {
+        const provider = this.createWeb3Provider();
+        const web3 = new web3_1.default(provider);
+        return new web3.eth.Contract(AbstractPyth_json_1.default, this.pythContractAddress);
+    }
+    hasWebsocketProvider() {
+        return (0, utils_2.isWsEndpoint)(this.endpoint);
+    }
+    createWeb3Provider() {
+        if ((0, utils_2.isWsEndpoint)(this.endpoint)) {
+            web3_1.default.providers.WebsocketProvider.prototype.sendAsync =
+                web3_1.default.providers.WebsocketProvider.prototype.send;
+            return new web3_1.default.providers.WebsocketProvider(this.endpoint, {
+                clientConfig: {
+                    keepalive: true,
+                    keepaliveInterval: 30000,
+                },
+                reconnect: {
+                    auto: true,
+                    delay: 1000,
+                    onTimeout: true,
+                },
+                timeout: 30000,
+            });
+        }
+        else {
+            web3_1.default.providers.HttpProvider.prototype.sendAsync =
+                web3_1.default.providers.HttpProvider.prototype.send;
+            return new web3_1.default.providers.HttpProvider(this.endpoint, {
+                keepAlive: true,
+                timeout: 30000,
+            });
+        }
+    }
+    createWeb3PayerProvider() {
+        return new hdwallet_provider_1.default({
+            mnemonic: {
+                phrase: this.mnemonic,
+            },
+            providerOrUrl: this.createWeb3Provider(),
+        });
+    }
+}
+exports.PythContractFactory = PythContractFactory;

package/lib/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// #!/usr/bin/env node
+const yargs_1 = __importDefault(require("yargs"));
+const helpers_1 = require("yargs/helpers");
+const command_1 = __importDefault(require("./injective/command"));
+const command_2 = __importDefault(require("./evm/command"));
+(0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
+    .config("config")
+    .global("config")
+    .command(command_2.default)
+    .command(command_1.default)
+    .help().argv;

package/lib/injective/command.d.ts

@@ -0,0 +1,16 @@
+import { Options } from "yargs";
+declare const _default: {
+    command: string;
+    describe: string;
+    builder: {
+        "pushing-frequency": Options;
+        "polling-frequency": Options;
+        "pyth-contract-address": Options;
+        "mnemonic-file": Options;
+        "price-service-endpoint": Options;
+        "price-config-file": Options;
+        "grpc-endpoint": Options;
+    };
+    handler: (argv: any) => void;
+};
+export default _default;

package/lib/injective/command.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const price_service_client_1 = require("@pythnetwork/price-service-client");
+const options = __importStar(require("../options"));
+const price_config_1 = require("../price-config");
+const fs_1 = __importDefault(require("fs"));
+const injective_1 = require("./injective");
+const pyth_price_listener_1 = require("../pyth-price-listener");
+const controller_1 = require("../controller");
+exports.default = {
+    command: "injective",
+    describe: "run price pusher for injective",
+    builder: {
+        "grpc-endpoint": {
+            description: "gRPC endpoint URL for injective. The pusher will periodically" +
+                "poll for updates. The polling interval is configurable via the " +
+                "`polling-frequency` command-line argument.",
+            type: "string",
+            required: true,
+        },
+        ...options.priceConfigFile,
+        ...options.priceServiceEndpoint,
+        ...options.mnemonicFile,
+        ...options.pythContractAddress,
+        ...options.pollingFrequency,
+        ...options.pushingFrequency,
+    },
+    handler: function (argv) {
+        // FIXME: type checks for this
+        const { grpcEndpoint, priceConfigFile, priceServiceEndpoint, mnemonicFile, pythContractAddress, pushingFrequency, pollingFrequency, } = argv;
+        const priceConfigs = (0, price_config_1.readPriceConfigFile)(priceConfigFile);
+        const priceServiceConnection = new price_service_client_1.PriceServiceConnection(priceServiceEndpoint, {
+            logger: {
+                // Log only warnings and errors from the price service client
+                info: () => undefined,
+                warn: console.warn,
+                error: console.error,
+                debug: () => undefined,
+                trace: () => undefined,
+            },
+        });
+        const mnemonic = fs_1.default.readFileSync(mnemonicFile, "utf-8").trim();
+        const priceItems = priceConfigs.map(({ id, alias }) => ({ id, alias }));
+        const pythListener = new pyth_price_listener_1.PythPriceListener(priceServiceConnection, priceItems);
+        const injectiveListener = new injective_1.InjectivePriceListener(pythContractAddress, grpcEndpoint, priceItems, {
+            pollingFrequency,
+        });
+        const injectivePusher = new injective_1.InjectivePricePusher(priceServiceConnection, pythContractAddress, grpcEndpoint, mnemonic);
+        const controller = new controller_1.Controller(priceConfigs, pythListener, injectiveListener, injectivePusher, { pushingFrequency });
+        controller.start();
+    },
+};

package/lib/injective/injective.d.ts

@@ -0,0 +1,29 @@
+import { HexString, PriceServiceConnection } from "@pythnetwork/price-service-client";
+import { IPricePusher, PriceInfo, ChainPriceListener, PriceItem } from "../interface";
+import { DurationInSeconds } from "../utils";
+export declare class InjectivePriceListener extends ChainPriceListener {
+    private pythContractAddress;
+    private grpcEndpoint;
+    constructor(pythContractAddress: string, grpcEndpoint: string, priceItems: PriceItem[], config: {
+        pollingFrequency: DurationInSeconds;
+    });
+    getOnChainPriceInfo(priceId: HexString): Promise<PriceInfo | undefined>;
+}
+type InjectiveConfig = {
+    chainId: string;
+    gasMultiplier: number;
+    gasPrice: number;
+};
+export declare class InjectivePricePusher implements IPricePusher {
+    private priceServiceConnection;
+    private pythContractAddress;
+    private grpcEndpoint;
+    private wallet;
+    private chainConfig;
+    constructor(priceServiceConnection: PriceServiceConnection, pythContractAddress: string, grpcEndpoint: string, mnemonic: string, chainConfig?: Partial<InjectiveConfig>);
+    private injectiveAddress;
+    private signAndBroadcastMsg;
+    getPriceFeedUpdateObject(priceIds: string[]): Promise<any>;
+    updatePriceFeed(priceIds: string[], pubTimesToPush: number[]): Promise<void>;
+}
+export {};

package/lib/injective/injective.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectivePricePusher = exports.InjectivePriceListener = void 0;
+const interface_1 = require("../interface");
+const sdk_ts_1 = require("@injectivelabs/sdk-ts");
+const utils_1 = require("@injectivelabs/utils");
+// this use price without leading 0x
+class InjectivePriceListener extends interface_1.ChainPriceListener {
+    pythContractAddress;
+    grpcEndpoint;
+    constructor(pythContractAddress, grpcEndpoint, priceItems, config) {
+        super("Injective", config.pollingFrequency, priceItems);
+        this.pythContractAddress = pythContractAddress;
+        this.grpcEndpoint = grpcEndpoint;
+    }
+    async getOnChainPriceInfo(priceId) {
+        let priceQueryResponse;
+        try {
+            const api = new sdk_ts_1.ChainGrpcWasmApi(this.grpcEndpoint);
+            const { data } = await api.fetchSmartContractState(this.pythContractAddress, Buffer.from(`{"price_feed":{"id":"${priceId}"}}`).toString("base64"));
+            const json = Buffer.from(data, "base64").toString();
+            priceQueryResponse = JSON.parse(json);
+        }
+        catch (e) {
+            console.error(`Polling on-chain price for ${priceId} failed. Error:`);
+            console.error(e);
+            return undefined;
+        }
+        console.log(`Polled an Injective on chain price for feed ${this.priceIdToAlias.get(priceId)} (${priceId}).`);
+        return {
+            conf: priceQueryResponse.price_feed.price.conf,
+            price: priceQueryResponse.price_feed.price.price,
+            publishTime: priceQueryResponse.price_feed.price.publish_time,
+        };
+    }
+}
+exports.InjectivePriceListener = InjectivePriceListener;
+class InjectivePricePusher {
+    priceServiceConnection;
+    pythContractAddress;
+    grpcEndpoint;
+    wallet;
+    chainConfig;
+    constructor(priceServiceConnection, pythContractAddress, grpcEndpoint, mnemonic, chainConfig) {
+        this.priceServiceConnection = priceServiceConnection;
+        this.pythContractAddress = pythContractAddress;
+        this.grpcEndpoint = grpcEndpoint;
+        this.wallet = sdk_ts_1.PrivateKey.fromMnemonic(mnemonic);
+        this.chainConfig = {
+            chainId: chainConfig?.chainId ?? "injective-888",
+            gasMultiplier: chainConfig?.gasMultiplier ?? 1.2,
+            gasPrice: chainConfig?.gasPrice ?? utils_1.DEFAULT_GAS_PRICE,
+        };
+    }
+    injectiveAddress() {
+        return this.wallet.toBech32();
+    }
+    async signAndBroadcastMsg(msg) {
+        const chainGrpcAuthApi = new sdk_ts_1.ChainGrpcAuthApi(this.grpcEndpoint);
+        const account = await chainGrpcAuthApi.fetchAccount(this.injectiveAddress());
+        const { txRaw: simulateTxRaw } = (0, sdk_ts_1.createTransactionFromMsg)({
+            sequence: account.baseAccount.sequence,
+            accountNumber: account.baseAccount.accountNumber,
+            message: msg,
+            chainId: this.chainConfig.chainId,
+            pubKey: this.wallet.toPublicKey().toBase64(),
+        });
+        const txService = new sdk_ts_1.TxGrpcClient(this.grpcEndpoint);
+        // simulation
+        const { gasInfo: { gasUsed }, } = await txService.simulate(simulateTxRaw);
+        // simulation returns us the approximate gas used
+        // gas passed with the transaction should be more than that
+        // in order for it to be successfully executed
+        // this multiplier takes care of that
+        const fee = {
+            amount: [
+                {
+                    denom: "inj",
+                    amount: (gasUsed *
+                        this.chainConfig.gasPrice *
+                        this.chainConfig.gasMultiplier).toFixed(),
+                },
+            ],
+            gas: (gasUsed * this.chainConfig.gasMultiplier).toFixed(),
+        };
+        const { signBytes, txRaw } = (0, sdk_ts_1.createTransactionFromMsg)({
+            sequence: account.baseAccount.sequence,
+            accountNumber: account.baseAccount.accountNumber,
+            message: msg,
+            chainId: this.chainConfig.chainId,
+            fee,
+            pubKey: this.wallet.toPublicKey().toBase64(),
+        });
+        const sig = await this.wallet.sign(Buffer.from(signBytes));
+        /** Append Signatures */
+        txRaw.setSignaturesList([sig]);
+        const txResponse = await txService.broadcast(txRaw);
+        return txResponse;
+    }
+    async getPriceFeedUpdateObject(priceIds) {
+        const vaas = await this.priceServiceConnection.getLatestVaas(priceIds);
+        return {
+            update_price_feeds: {
+                data: vaas,
+            },
+        };
+    }
+    async updatePriceFeed(priceIds, pubTimesToPush) {
+        if (priceIds.length === 0) {
+            return;
+        }
+        if (priceIds.length !== pubTimesToPush.length)
+            throw new Error("Invalid arguments");
+        let priceFeedUpdateObject;
+        try {
+            // get the latest VAAs for updatePriceFeed and then push them
+            priceFeedUpdateObject = await this.getPriceFeedUpdateObject(priceIds);
+        }
+        catch (e) {
+            console.error("Error fetching the latest vaas to push");
+            console.error(e);
+            return;
+        }
+        let updateFeeQueryResponse;
+        try {
+            const api = new sdk_ts_1.ChainGrpcWasmApi(this.grpcEndpoint);
+            const { data } = await api.fetchSmartContractState(this.pythContractAddress, Buffer.from(JSON.stringify({
+                get_update_fee: {
+                    vaas: priceFeedUpdateObject.update_price_feeds.data,
+                },
+            })).toString("base64"));
+            const json = Buffer.from(data, "base64").toString();
+            updateFeeQueryResponse = JSON.parse(json);
+        }
+        catch (e) {
+            console.error("Error fetching update fee");
+            console.error(e);
+            return;
+        }
+        try {
+            const executeMsg = sdk_ts_1.MsgExecuteContract.fromJSON({
+                sender: this.injectiveAddress(),
+                contractAddress: this.pythContractAddress,
+                msg: priceFeedUpdateObject,
+                funds: [updateFeeQueryResponse],
+            });
+            const rs = await this.signAndBroadcastMsg(executeMsg);
+            if (rs.code !== 0)
+                throw new Error("Error: transaction failed");
+            console.log("Succesfully broadcasted txHash:", rs.txHash);
+        }
+        catch (e) {
+            if (e.message.match(/account inj[a-zA-Z0-9]+ not found/) !== null) {
+                console.error(e);
+                throw new Error("Please check the mnemonic");
+            }
+            if (e.message.match(/insufficient/) !== null &&
+                e.message.match(/funds/) !== null) {
+                console.error(e);
+                throw new Error("Insufficient funds");
+            }
+            console.error("Error executing messages");
+            console.log(e);
+        }
+    }
+}
+exports.InjectivePricePusher = InjectivePricePusher;

package/lib/interface.d.ts

@@ -0,0 +1,31 @@
+import { HexString, UnixTimestamp } from "@pythnetwork/price-service-client";
+import { DurationInSeconds } from "./utils";
+export type PriceItem = {
+    id: HexString;
+    alias: string;
+};
+export type PriceInfo = {
+    price: string;
+    conf: string;
+    publishTime: UnixTimestamp;
+};
+export interface IPriceListener {
+    start(): Promise<void>;
+    getLatestPriceInfo(priceId: string): PriceInfo | undefined;
+}
+export declare abstract class ChainPriceListener implements IPriceListener {
+    private chain;
+    private pollingFrequency;
+    protected priceItems: PriceItem[];
+    private latestPriceInfo;
+    protected priceIdToAlias: Map<HexString, string>;
+    constructor(chain: string, pollingFrequency: DurationInSeconds, priceItems: PriceItem[]);
+    start(): Promise<void>;
+    private pollPrices;
+    protected updateLatestPriceInfo(priceId: HexString, observedPrice: PriceInfo): void;
+    getLatestPriceInfo(priceId: string): PriceInfo | undefined;
+    abstract getOnChainPriceInfo(priceId: HexString): Promise<PriceInfo | undefined>;
+}
+export interface IPricePusher {
+    updatePriceFeed(priceIds: string[], pubTimesToPush: UnixTimestamp[]): Promise<void>;
+}

package/lib/interface.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainPriceListener = void 0;
+class ChainPriceListener {
+    chain;
+    pollingFrequency;
+    priceItems;
+    latestPriceInfo;
+    priceIdToAlias;
+    constructor(chain, pollingFrequency, priceItems) {
+        this.chain = chain;
+        this.pollingFrequency = pollingFrequency;
+        this.priceItems = priceItems;
+        this.latestPriceInfo = new Map();
+        this.priceIdToAlias = new Map(priceItems.map(({ id, alias }) => [id, alias]));
+    }
+    async start() {
+        console.log(`Polling the prices on ${this.chain} every ${this.pollingFrequency} seconds...`);
+        setInterval(this.pollPrices.bind(this), this.pollingFrequency * 1000);
+        await this.pollPrices();
+    }
+    async pollPrices() {
+        for (const { id: priceId } of this.priceItems) {
+            const currentPriceInfo = await this.getOnChainPriceInfo(priceId);
+            if (currentPriceInfo !== undefined) {
+                this.updateLatestPriceInfo(priceId, currentPriceInfo);
+            }
+        }
+    }
+    updateLatestPriceInfo(priceId, observedPrice) {
+        const cachedLatestPriceInfo = this.getLatestPriceInfo(priceId);
+        // Ignore the observed price if the cache already has newer
+        // price. This could happen because we are using polling and
+        // subscription at the same time.
+        if (cachedLatestPriceInfo !== undefined &&
+            cachedLatestPriceInfo.publishTime > observedPrice.publishTime) {
+            return;
+        }
+        this.latestPriceInfo.set(priceId, observedPrice);
+    }
+    // Should return undefined only when the price does not exist.
+    getLatestPriceInfo(priceId) {
+        return this.latestPriceInfo.get(priceId);
+    }
+}
+exports.ChainPriceListener = ChainPriceListener;

package/lib/options.d.ts

@@ -0,0 +1,19 @@
+import { Options } from "yargs";
+export declare const priceServiceEndpoint: {
+    "price-service-endpoint": Options;
+};
+export declare const pythContractAddress: {
+    "pyth-contract-address": Options;
+};
+export declare const priceConfigFile: {
+    "price-config-file": Options;
+};
+export declare const pollingFrequency: {
+    "polling-frequency": Options;
+};
+export declare const pushingFrequency: {
+    "pushing-frequency": Options;
+};
+export declare const mnemonicFile: {
+    "mnemonic-file": Options;
+};