@pythnetwork/price-pusher 10.2.0 → 10.3.1

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

@@ -1,45 +1,54 @@
-"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");
-const DEFAULT_GAS_PRICE = 160000000;
+/* eslint-disable @typescript-eslint/no-unsafe-call */ /* eslint-disable @typescript-eslint/no-unsafe-member-access */ /* eslint-disable @typescript-eslint/no-explicit-any */ /* eslint-disable @typescript-eslint/no-unnecessary-condition */ /* 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 InjectivePriceListener () {
+        return InjectivePriceListener;
+    },
+    get InjectivePricePusher () {
+        return InjectivePricePusher;
+    }
+});
+const _sdkts = require("@injectivelabs/sdk-ts");
+const _utils = require("@injectivelabs/utils");
+const _interface = require("../interface.cjs");
+const DEFAULT_GAS_PRICE = 160_000_000;
 const DEFAULT_GAS_MULTIPLIER = 1.05;
 const DEFAULT_PRICE_IDS_PROCESS_CHUNK_SIZE = -1;
 const INJECTIVE_TESTNET_CHAIN_ID = "injective-888";
-// this use price without leading 0x
-class InjectivePriceListener extends interface_1.ChainPriceListener {
+class InjectivePriceListener extends _interface.ChainPriceListener {
     pythContractAddress;
     grpcEndpoint;
     logger;
-    constructor(pythContractAddress, grpcEndpoint, priceItems, logger, config) {
-        super(config.pollingFrequency, priceItems);
-        this.pythContractAddress = pythContractAddress;
-        this.grpcEndpoint = grpcEndpoint;
-        this.logger = logger;
+    constructor(pythContractAddress, grpcEndpoint, priceItems, logger, config){
+        super(config.pollingFrequency, priceItems), this.pythContractAddress = pythContractAddress, this.grpcEndpoint = grpcEndpoint, this.logger = logger;
     }
     async getOnChainPriceInfo(priceId) {
         let priceQueryResponse;
         try {
-            const api = new sdk_ts_1.ChainGrpcWasmApi(this.grpcEndpoint);
+            const api = new _sdkts.ChainGrpcWasmApi(this.grpcEndpoint);
             const { data } = await api.fetchSmartContractState(this.pythContractAddress, Buffer.from(`{"price_feed":{"id":"${priceId}"}}`).toString("base64"));
             const json = Buffer.from(data).toString();
             priceQueryResponse = JSON.parse(json);
-        }
-        catch (err) {
-            this.logger.error(err, `Polling on-chain price for ${priceId} failed.`);
+        } catch (error) {
+            this.logger.error(error, `Polling on-chain price for ${priceId} failed.`);
             return undefined;
         }
         this.logger.debug(`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,
+            publishTime: priceQueryResponse.price_feed.price.publish_time
         };
     }
 }
-exports.InjectivePriceListener = InjectivePriceListener;
 class InjectivePricePusher {
     hermesClient;
     pythContractAddress;
@@ -47,8 +56,8 @@ class InjectivePricePusher {
     logger;
     mnemonic;
     chainConfig;
-    accounts = {}; /** { address: Account } */
-    constructor(hermesClient, pythContractAddress, grpcEndpoint, logger, mnemonic, chainConfig) {
+    accounts = {};
+    constructor(hermesClient, pythContractAddress, grpcEndpoint, logger, mnemonic, chainConfig){
         this.hermesClient = hermesClient;
         this.pythContractAddress = pythContractAddress;
         this.grpcEndpoint = grpcEndpoint;
@@ -58,170 +67,163 @@ class InjectivePricePusher {
             chainId: chainConfig?.chainId ?? INJECTIVE_TESTNET_CHAIN_ID,
             gasMultiplier: chainConfig?.gasMultiplier ?? DEFAULT_GAS_MULTIPLIER,
             gasPrice: chainConfig?.gasPrice ?? DEFAULT_GAS_PRICE,
-            priceIdsProcessChunkSize: chainConfig?.priceIdsProcessChunkSize ??
-                DEFAULT_PRICE_IDS_PROCESS_CHUNK_SIZE,
+            priceIdsProcessChunkSize: chainConfig?.priceIdsProcessChunkSize ?? DEFAULT_PRICE_IDS_PROCESS_CHUNK_SIZE
         };
     }
     getWallet(index) {
-        if (this.chainConfig.priceIdsProcessChunkSize === -1 ||
-            this.chainConfig.priceIdsProcessChunkSize === undefined) {
-            return sdk_ts_1.PrivateKey.fromMnemonic(this.mnemonic);
+        if (this.chainConfig.priceIdsProcessChunkSize === -1 || this.chainConfig.priceIdsProcessChunkSize === undefined) {
+            return _sdkts.PrivateKey.fromMnemonic(this.mnemonic);
         }
-        return sdk_ts_1.PrivateKey.fromMnemonic(this.mnemonic, `m/44'/60'/0'/0/${index}`);
+        return _sdkts.PrivateKey.fromMnemonic(this.mnemonic, `m/44'/60'/0'/0/${index}`);
     }
     async signAndBroadcastMsg(msg, index) {
-        const chainGrpcAuthApi = new sdk_ts_1.ChainGrpcAuthApi(this.grpcEndpoint);
+        const chainGrpcAuthApi = new _sdkts.ChainGrpcAuthApi(this.grpcEndpoint);
         const wallet = this.getWallet(index);
         const injectiveAddress = wallet.toAddress().toBech32();
         // Fetch the latest account details only if it's not stored.
-        this.accounts[injectiveAddress] ??=
-            await chainGrpcAuthApi.fetchAccount(injectiveAddress);
+        this.accounts[injectiveAddress] ??= await chainGrpcAuthApi.fetchAccount(injectiveAddress);
         const account = this.accounts[injectiveAddress];
         try {
-            const { signBytes, txRaw } = (0, sdk_ts_1.createTransactionFromMsg)({
+            const { signBytes, txRaw } = (0, _sdkts.createTransactionFromMsg)({
                 sequence: account.baseAccount.sequence,
                 accountNumber: account.baseAccount.accountNumber,
                 message: msg,
                 chainId: this.chainConfig.chainId,
                 fee: await this.getStdFee(msg, index),
-                pubKey: wallet.toPublicKey().toBase64(),
+                pubKey: wallet.toPublicKey().toBase64()
             });
+            // eslint-disable-next-line @typescript-eslint/await-thenable
             const sig = await wallet.sign(Buffer.from(signBytes));
-            /** Append Signatures */
-            txRaw.signatures = [sig];
+            /** Append Signatures */ txRaw.signatures = [
+                sig
+            ];
             // this takes approx 5 seconds
-            const txResponse = await new sdk_ts_1.TxGrpcApi(this.grpcEndpoint).broadcast(txRaw);
+            const txResponse = await new _sdkts.TxGrpcApi(this.grpcEndpoint).broadcast(txRaw);
             account.baseAccount.sequence++;
             return txResponse;
-        }
-        catch (e) {
+        } catch (error) {
             // The sequence number was invalid and hence we will have to fetch it again
-            if (JSON.stringify(e).match(/account sequence mismatch/) !== null) {
+            if (/account sequence mismatch/.exec(JSON.stringify(error)) !== null) {
                 this.accounts[injectiveAddress] = undefined;
             }
-            throw e;
+            throw error;
         }
     }
     async updatePriceFeed(priceIds, pubTimesToPush) {
         if (priceIds.length === 0) {
             return;
         }
-        if (priceIds.length !== pubTimesToPush.length)
-            throw new Error("Invalid arguments");
-        const priceIdChunks = this.chainConfig.priceIdsProcessChunkSize === -1
-            ? [priceIds]
-            : (0, utils_1.splitArrayToChunks)({
-                array: priceIds,
-                chunkSize: Number(this.chainConfig.priceIdsProcessChunkSize),
-            });
-        await Promise.all(priceIdChunks.map((priceIdChunk, chunkIndex) => this.updatePriceFeedChunk(priceIdChunk, chunkIndex)));
+        if (priceIds.length !== pubTimesToPush.length) throw new Error("Invalid arguments");
+        const priceIdChunks = this.chainConfig.priceIdsProcessChunkSize === -1 ? [
+            priceIds
+        ] : (0, _utils.splitArrayToChunks)({
+            array: priceIds,
+            chunkSize: Number(this.chainConfig.priceIdsProcessChunkSize)
+        });
+        await Promise.all(priceIdChunks.map((priceIdChunk, chunkIndex)=>this.updatePriceFeedChunk(priceIdChunk, chunkIndex)));
     }
     async updatePriceFeedChunk(priceIds, chunkIndex) {
         try {
             const priceFeedUpdateObject = await this.getPriceFeedUpdateObject(priceIds);
             const updateFeeQueryResponse = await this.getUpdateFee(priceFeedUpdateObject.update_price_feeds.data);
             const wallet = this.getWallet(chunkIndex);
-            const msg = sdk_ts_1.MsgExecuteContract.fromJSON({
+            const msg = _sdkts.MsgExecuteContract.fromJSON({
                 sender: wallet.toAddress().toBech32(),
                 contractAddress: this.pythContractAddress,
                 msg: priceFeedUpdateObject,
-                funds: [updateFeeQueryResponse],
+                funds: [
+                    updateFeeQueryResponse
+                ]
             });
             const rs = await this.signAndBroadcastMsg(msg, chunkIndex);
-            this.logger.info({ hash: rs.txHash }, `Successfully broadcasted txHash for chunk ${chunkIndex}`);
-        }
-        catch (err) {
-            if (err.message.match(/account inj[a-zA-Z0-9]+ not found/) !== null) {
-                this.logger.error(err, `Account not found for chunk ${chunkIndex}`);
+            this.logger.info({
+                hash: rs.txHash
+            }, `Successfully broadcasted txHash for chunk ${chunkIndex}`);
+        } catch (error) {
+            if (error.message.match(/account inj[a-zA-Z0-9]+ not found/) !== null) {
+                this.logger.error(error, `Account not found for chunk ${chunkIndex}`);
                 throw new Error("Please check the mnemonic");
             }
-            if (err.message.match(/insufficient/) !== null &&
-                err.message.match(/funds/) !== null) {
-                this.logger.error(err, `Insufficient funds for chunk ${chunkIndex}`);
+            if (error.message.match(/insufficient/) !== null && error.message.match(/funds/) !== null) {
+                this.logger.error(error, `Insufficient funds for chunk ${chunkIndex}`);
                 throw new Error("Insufficient funds");
             }
-            this.logger.error(err, `Error executing messages for chunk ${chunkIndex}`);
+            this.logger.error(error, `Error executing messages for chunk ${chunkIndex}`);
         }
     }
     /**
-     * Get the fee for the transaction (using simulation).
-     *
-     * We also apply a multiplier to the gas used to apply a small
-     * buffer to the gas that'll be used.
-     */
-    async getStdFee(msg, index) {
+   * Get the fee for the transaction (using simulation).
+   *
+   * We also apply a multiplier to the gas used to apply a small
+   * buffer to the gas that'll be used.
+   */ async getStdFee(msg, index) {
         const wallet = this.getWallet(index);
         const injectiveAddress = wallet.toAddress().toBech32();
         const account = this.accounts[injectiveAddress];
         if (!account) {
             throw new Error("Account not found");
         }
-        const { txRaw: simulateTxRaw } = (0, sdk_ts_1.createTransactionFromMsg)({
+        const { txRaw: simulateTxRaw } = (0, _sdkts.createTransactionFromMsg)({
             sequence: account.baseAccount.sequence,
             accountNumber: account.baseAccount.accountNumber,
             message: msg,
             chainId: this.chainConfig.chainId,
-            pubKey: wallet.toPublicKey().toBase64(),
+            pubKey: wallet.toPublicKey().toBase64()
         });
         try {
-            const result = await new sdk_ts_1.TxGrpcApi(this.grpcEndpoint).simulate(simulateTxRaw);
-            const gas = (result.gasInfo.gasUsed * this.chainConfig.gasMultiplier).toFixed();
+            const result = await new _sdkts.TxGrpcApi(this.grpcEndpoint).simulate(simulateTxRaw);
+            const gas = (result.gasInfo.gasUsed * this.chainConfig.gasMultiplier).toFixed(0);
             const fee = {
                 amount: [
                     {
                         denom: "inj",
-                        amount: (Number(gas) * this.chainConfig.gasPrice).toFixed(),
-                    },
+                        amount: (Number(gas) * this.chainConfig.gasPrice).toFixed(0)
+                    }
                 ],
-                gas,
+                gas
             };
             return fee;
-        }
-        catch (err) {
-            this.logger.error(err, `Error getting std fee`);
-            throw err;
+        } catch (error) {
+            this.logger.error(error, `Error getting std fee`);
+            throw error;
         }
     }
     /**
-     * Get the latest VAAs for updatePriceFeed and then push them
-     */
-    async getPriceFeedUpdateObject(priceIds) {
+   * Get the latest VAAs for updatePriceFeed and then push them
+   */ async getPriceFeedUpdateObject(priceIds) {
         try {
             const response = await this.hermesClient.getLatestPriceUpdates(priceIds, {
                 encoding: "base64",
-                ignoreInvalidPriceIds: true,
+                ignoreInvalidPriceIds: true
             });
             const vaas = response.binary.data;
             return {
                 update_price_feeds: {
-                    data: vaas,
-                },
+                    data: vaas
+                }
             };
-        }
-        catch (err) {
-            this.logger.error(err, `Error fetching the latest vaas to push`);
-            throw err;
+        } catch (error) {
+            this.logger.error(error, `Error fetching the latest vaas to push`);
+            throw error;
         }
     }
     /**
-     * Get the update fee for the given VAAs (i.e the fee that is paid to the pyth contract)
-     */
-    async getUpdateFee(vaas) {
+   * Get the update fee for the given VAAs (i.e the fee that is paid to the pyth contract)
+   */ async getUpdateFee(vaas) {
         try {
-            const api = new sdk_ts_1.ChainGrpcWasmApi(this.grpcEndpoint);
+            const api = new _sdkts.ChainGrpcWasmApi(this.grpcEndpoint);
             const { data } = await api.fetchSmartContractState(this.pythContractAddress, Buffer.from(JSON.stringify({
                 get_update_fee: {
-                    vaas,
-                },
+                    vaas
+                }
             })).toString("base64"));
             const json = Buffer.from(data).toString();
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             return JSON.parse(json);
-        }
-        catch (err) {
-            this.logger.error(err, `Error fetching update fee.`);
+        } catch (error) {
+            this.logger.error(error, `Error fetching update fee.`);
             // Throwing an error because it is likely an RPC issue
-            throw err;
+            throw error;
         }
     }
 }
-exports.InjectivePricePusher = InjectivePricePusher;

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

@@ -1,7 +1,9 @@
-import { HexString, HermesClient } from "@pythnetwork/hermes-client";
-import { PriceItem, PriceInfo, IPricePusher, ChainPriceListener } from "../interface";
-import { DurationInSeconds } from "../utils";
-import { Logger } from "pino";
+import type { HexString } from "@pythnetwork/hermes-client";
+import { HermesClient } from "@pythnetwork/hermes-client";
+import type { Logger } from "pino";
+import type { PriceItem, PriceInfo, IPricePusher } from "../interface.js";
+import { ChainPriceListener } from "../interface.js";
+import type { DurationInSeconds } from "../utils.js";
 type InjectiveConfig = {
     chainId: string;
     gasMultiplier: number;
@@ -24,7 +26,7 @@ export declare class InjectivePricePusher implements IPricePusher {
     private logger;
     private mnemonic;
     private chainConfig;
-    private accounts; /** { address: Account } */
+    private accounts;
     constructor(hermesClient: HermesClient, pythContractAddress: string, grpcEndpoint: string, logger: Logger, mnemonic: string, chainConfig?: Partial<InjectiveConfig>);
     private getWallet;
     private signAndBroadcastMsg;
@@ -47,4 +49,3 @@ export declare class InjectivePricePusher implements IPricePusher {
     private getUpdateFee;
 }
 export {};
-//# sourceMappingURL=injective.d.ts.map

package/dist/interface.cjs

@@ -0,0 +1,142 @@
+"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 BaseBalanceTracker () {
+        return BaseBalanceTracker;
+    },
+    get ChainPriceListener () {
+        return ChainPriceListener;
+    }
+});
+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;
+}
+class ChainPriceListener {
+    pollingFrequency;
+    priceItems;
+    latestPriceInfo;
+    priceIdToAlias;
+    constructor(pollingFrequency, priceItems){
+        this.pollingFrequency = pollingFrequency;
+        this.priceItems = priceItems;
+        this.latestPriceInfo = new Map();
+        this.priceIdToAlias = new Map(priceItems.map(({ id, alias })=>[
+                id,
+                alias
+            ]));
+    }
+    async start() {
+        setInterval(()=>void this.pollPrices(), 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);
+    }
+}
+class BaseBalanceTracker {
+    address;
+    network;
+    updateInterval;
+    metrics;
+    logger;
+    isRunning = false;
+    constructor(config){
+        this.address = config.address;
+        this.network = config.network;
+        this.updateInterval = config.updateInterval;
+        this.metrics = config.metrics;
+        this.logger = config.logger;
+    }
+    async start() {
+        if (this.isRunning) {
+            return;
+        }
+        this.isRunning = true;
+        // Initial balance update
+        await this.updateBalance();
+        // Start the update loop
+        void this.startUpdateLoop();
+    }
+    async startUpdateLoop() {
+        // We're using dynamic import to avoid circular dependencies
+        const { sleep } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./utils.cjs")));
+        // Run in a loop to regularly update the balance
+        for(;;){
+            // Wait first, since we already did the initial update in start()
+            await sleep(this.updateInterval * 1000);
+            // Only continue if we're still running
+            if (!this.isRunning) {
+                break;
+            }
+            await this.updateBalance();
+        }
+    }
+    stop() {
+        this.isRunning = false;
+    }
+}

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

@@ -1,7 +1,7 @@
-import { HexString, UnixTimestamp } from "@pythnetwork/hermes-client";
-import { DurationInSeconds } from "./utils";
-import { Logger } from "pino";
-import { PricePusherMetrics } from "./metrics";
+import type { HexString, UnixTimestamp } from "@pythnetwork/hermes-client";
+import type { Logger } from "pino";
+import { PricePusherMetrics } from "./metrics.js";
+import type { DurationInSeconds } from "./utils.js";
 export type PriceItem = {
     id: HexString;
     alias: string;
@@ -11,10 +11,10 @@ export type PriceInfo = {
     conf: string;
     publishTime: UnixTimestamp;
 };
-export interface IPriceListener {
+export type IPriceListener = {
     start(): Promise<void>;
     getLatestPriceInfo(priceId: string): PriceInfo | undefined;
-}
+};
 export declare abstract class ChainPriceListener implements IPriceListener {
     private pollingFrequency;
     protected priceItems: PriceItem[];
@@ -27,13 +27,13 @@ export declare abstract class ChainPriceListener implements IPriceListener {
     getLatestPriceInfo(priceId: string): PriceInfo | undefined;
     abstract getOnChainPriceInfo(priceId: HexString): Promise<PriceInfo | undefined>;
 }
-export interface IPricePusher {
+export type IPricePusher = {
     updatePriceFeed(priceIds: string[], pubTimesToPush: UnixTimestamp[]): Promise<void>;
-}
+};
 /**
  * Common configuration properties for all balance trackers
  */
-export interface BaseBalanceTrackerConfig {
+export type BaseBalanceTrackerConfig = {
     /** Address of the wallet to track */
     address: string;
     /** Name/ID of the network/chain */
@@ -44,12 +44,12 @@ export interface BaseBalanceTrackerConfig {
     metrics: PricePusherMetrics;
     /** Logger instance */
     logger: Logger;
-}
+};
 /**
  * Interface for all balance trackers to implement
  * Each chain will have its own implementation of this interface
  */
-export interface IBalanceTracker {
+export type IBalanceTracker = {
     /**
      * Start tracking the wallet balance
      */
@@ -58,7 +58,7 @@ export interface IBalanceTracker {
      * Stop tracking the wallet balance
      */
     stop(): void;
-}
+};
 /**
  * Abstract base class that implements common functionality for all balance trackers
  */
@@ -79,4 +79,3 @@ export declare abstract class BaseBalanceTracker implements IBalanceTracker {
     protected abstract updateBalance(): Promise<void>;
     stop(): void;
 }
-//# sourceMappingURL=interface.d.ts.map