@pythnetwork/price-pusher 10.2.0 → 10.3.0

package/dist/evm/evm.cjs

@@ -0,0 +1,287 @@
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */ /* eslint-disable @typescript-eslint/no-unsafe-assignment */ /* eslint-disable @typescript-eslint/no-explicit-any */ /* eslint-disable @typescript-eslint/restrict-template-expressions */ /* eslint-disable @typescript-eslint/require-await */ "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 EvmPriceListener () {
+        return EvmPriceListener;
+    },
+    get EvmPricePusher () {
+        return EvmPricePusher;
+    }
+});
+const _viem = require("viem");
+const _utils = require("../utils.cjs");
+const _interface = require("../interface.cjs");
+class EvmPriceListener extends _interface.ChainPriceListener {
+    pythContract;
+    watchEvents;
+    logger;
+    constructor(pythContract, priceItems, watchEvents, logger, config){
+        super(config.pollingFrequency, priceItems), this.pythContract = pythContract, this.watchEvents = watchEvents, this.logger = logger;
+        this.pythContract = pythContract;
+        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() {
+        if (this.watchEvents) {
+            this.logger.info("Watching target network pyth contract events...");
+            void this.startWatching();
+        } else {
+            this.logger.info("The target network RPC endpoint is not Websocket. " + "Listening for updates only via polling....");
+        }
+        // base class for polling
+        await super.start();
+    }
+    async startWatching() {
+        this.pythContract.watchEvent.PriceFeedUpdate({
+            id: this.priceItems.map((item)=>(0, _utils.addLeading0x)(item.id))
+        }, {
+            strict: true,
+            onLogs: this.onPriceFeedUpdate.bind(this)
+        });
+    }
+    onPriceFeedUpdate(logs) {
+        for (const log of logs){
+            const priceId = (0, _utils.removeLeading0x)((0, _utils.assertDefined)(log.args.id));
+            const priceInfo = {
+                conf: (0, _utils.assertDefined)(log.args.conf).toString(),
+                price: (0, _utils.assertDefined)(log.args.price).toString(),
+                publishTime: Number((0, _utils.assertDefined)(log.args.publishTime))
+            };
+            this.logger.debug({
+                priceInfo
+            }, `Received a new Evm PriceFeedUpdate event for price feed ${this.priceIdToAlias.get(priceId)} (${priceId}).`);
+            this.updateLatestPriceInfo(priceId, priceInfo);
+        }
+    }
+    async getOnChainPriceInfo(priceId) {
+        let priceRaw;
+        try {
+            priceRaw = await this.pythContract.read.getPriceUnsafe([
+                (0, _utils.addLeading0x)(priceId)
+            ]);
+        } catch (error) {
+            this.logger.error(error, `Polling on-chain price for ${priceId} failed.`);
+            return undefined;
+        }
+        this.logger.debug(`Polled an EVM on chain price for feed ${this.priceIdToAlias.get(priceId)} (${priceId}).`);
+        return {
+            conf: priceRaw.conf,
+            price: priceRaw.price,
+            publishTime: Number(priceRaw.publishTime)
+        };
+    }
+}
+class EvmPricePusher {
+    hermesClient;
+    client;
+    pythContract;
+    logger;
+    overrideGasPriceMultiplier;
+    overrideGasPriceMultiplierCap;
+    updateFeeMultiplier;
+    gasLimit;
+    customGasStation;
+    gasPrice;
+    pusherAddress;
+    lastPushAttempt;
+    constructor(hermesClient, client, pythContract, logger, overrideGasPriceMultiplier, overrideGasPriceMultiplierCap, updateFeeMultiplier, gasLimit, customGasStation, gasPrice){
+        this.hermesClient = hermesClient;
+        this.client = client;
+        this.pythContract = pythContract;
+        this.logger = logger;
+        this.overrideGasPriceMultiplier = overrideGasPriceMultiplier;
+        this.overrideGasPriceMultiplierCap = overrideGasPriceMultiplierCap;
+        this.updateFeeMultiplier = updateFeeMultiplier;
+        this.gasLimit = gasLimit;
+        this.customGasStation = customGasStation;
+        this.gasPrice = gasPrice;
+    }
+    // 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 priceFeedUpdateData = await this.getPriceFeedsUpdateData(priceIds);
+        const priceFeedUpdateDataWith0x = priceFeedUpdateData.map((data)=>(0, _utils.addLeading0x)(data));
+        let updateFee;
+        try {
+            updateFee = await this.pythContract.read.getUpdateFee([
+                priceFeedUpdateDataWith0x
+            ]);
+            updateFee = BigInt(Math.round(Number(updateFee) * (this.updateFeeMultiplier || 1)));
+            this.logger.debug(`Update fee: ${updateFee}`);
+        } catch (error) {
+            this.logger.error(error, "An unidentified error has occured when getting the update fee.");
+            throw error;
+        }
+        // Gas price in networks with transaction type eip1559 represents the
+        // addition of baseFee and priorityFee required to land the transaction. We
+        // are using this to remain compatible with the networks that doesn't
+        // support this transaction type.
+        let gasPrice = this.gasPrice ?? Number(await (this.customGasStation?.getCustomGasPrice() ?? this.client.getGasPrice()));
+        // Try to re-use the same nonce and increase the gas if the last tx is not landed yet.
+        this.pusherAddress ??= this.client.account.address;
+        const lastExecutedNonce = await this.client.getTransactionCount({
+            address: this.pusherAddress
+        }) - 1;
+        let gasPriceToOverride = undefined;
+        if (this.lastPushAttempt !== undefined) {
+            if (this.lastPushAttempt.nonce <= lastExecutedNonce) {
+                this.lastPushAttempt = undefined;
+            } else {
+                gasPriceToOverride = this.lastPushAttempt.gasPrice * this.overrideGasPriceMultiplier;
+            }
+        }
+        if (gasPriceToOverride !== undefined && gasPriceToOverride > Number(gasPrice)) {
+            gasPrice = Math.min(gasPriceToOverride, gasPrice * this.overrideGasPriceMultiplierCap);
+        }
+        const txNonce = lastExecutedNonce + 1;
+        this.logger.debug(`Using gas price: ${gasPrice} and nonce: ${txNonce}`);
+        const pubTimesToPushParam = pubTimesToPush.map(BigInt);
+        const priceIdsWith0x = priceIds.map((priceId)=>(0, _utils.addLeading0x)(priceId));
+        // Update lastAttempt
+        this.lastPushAttempt = {
+            nonce: txNonce,
+            gasPrice: gasPrice
+        };
+        try {
+            const { request } = await this.pythContract.simulate.updatePriceFeedsIfNecessary([
+                priceFeedUpdateDataWith0x,
+                priceIdsWith0x,
+                pubTimesToPushParam
+            ], {
+                value: updateFee,
+                gasPrice: BigInt(Math.ceil(gasPrice)),
+                nonce: txNonce,
+                gas: this.gasLimit === undefined ? undefined : BigInt(Math.ceil(this.gasLimit))
+            });
+            this.logger.debug({
+                request
+            }, "Simulated request successfully");
+            const hash = await this.client.writeContract(request);
+            this.logger.info({
+                hash
+            }, "Price update sent");
+            void this.waitForTransactionReceipt(hash);
+        } catch (error) {
+            this.logger.debug({
+                err: error
+            }, "Simulating or sending transactions failed.");
+            if (error instanceof _viem.BaseError) {
+                if (error.walk((e)=>e instanceof _viem.ContractFunctionRevertedError && e.data?.errorName === "NoFreshUpdate")) {
+                    this.logger.info("Simulation reverted because none of the updates are fresh. This is an expected behaviour to save gas. Skipping this push.");
+                    return;
+                }
+                if (error.walk((e)=>e instanceof _viem.InsufficientFundsError)) {
+                    this.logger.error({
+                        err: error
+                    }, "Wallet doesn't have enough balance. In rare cases, there might be issues with gas price " + "calculation in the RPC.");
+                    throw error;
+                }
+                if (error.walk((e)=>e instanceof _viem.FeeCapTooLowError) || error.walk((e)=>e instanceof _viem.InternalRpcError && e.details.includes("replacement transaction underpriced"))) {
+                    this.logger.warn("The gas price of the transaction is too low or there is an existing transaction with higher gas with the same nonce. " + "The price will be increased in the next push. Skipping this push. " + "If this keeps happening or transactions are not landing you need to increase the override gas price " + "multiplier and the cap to increase the likelihood of the transaction landing on-chain.");
+                    return;
+                }
+                if (error.walk((e)=>e instanceof _viem.TransactionExecutionError && (e.details.includes("nonce too low") || e.message.includes("Nonce provided for the transaction")))) {
+                    this.logger.info("The nonce is incorrect. This is an expected behaviour in high frequency or multi-instance setup. Skipping this push.");
+                    return;
+                }
+                // Sometimes the contract function execution fails in simulation and this error is thrown.
+                if (error.walk((e)=>e instanceof _viem.ContractFunctionExecutionError)) {
+                    this.logger.warn({
+                        err: error
+                    }, "The contract function execution failed in simulation. This is an expected behaviour in high frequency or multi-instance setup. " + "Please review this error and file an issue if it is a bug. Skipping this push.");
+                    return;
+                }
+                // We normally crash on unknown failures but we believe that this type of error is safe to skip. The other reason is that
+                // wometimes we see a TransactionExecutionError because of the nonce without any details and it is not catchable.
+                if (error.walk((e)=>e instanceof _viem.TransactionExecutionError)) {
+                    this.logger.error({
+                        err: error
+                    }, "Transaction execution failed. This is an expected behaviour in high frequency or multi-instance setup. " + "Please review this error and file an issue if it is a bug. Skipping this push.");
+                    return;
+                }
+                // The following errors are part of the legacy code and might not work as expected.
+                // We are keeping them in case they help with handling what is not covered above.
+                if (error.message.includes("the tx doesn't have the correct nonce.") || error.message.includes("nonce too low") || error.message.includes("invalid nonce")) {
+                    this.logger.info("The nonce is incorrect (are multiple users using this account?). Skipping this push.");
+                    return;
+                }
+                if (error.message.includes("max fee per gas less than block base fee")) {
+                    // We just have to handle this error and return.
+                    // LastPushAttempt was stored with the class
+                    // Next time the update will be executing, it will check the last attempt
+                    // and increase the gas price accordingly.
+                    this.logger.warn("The transaction failed with error: max fee per gas less than block base fee. " + "The fee will be increased in the next push. Skipping this push.");
+                    return;
+                }
+                if (error.message.includes("sender doesn't have enough funds to send tx.")) {
+                    this.logger.error("Payer is out of balance, please top it up.");
+                    throw new Error("Please top up the wallet");
+                }
+                if (error.message.includes("could not replace existing tx")) {
+                    this.logger.error("A transaction with the same nonce has been mined and this one is no longer needed. Skipping this push.");
+                    return;
+                }
+            }
+            // If the error is not handled, we will crash the process.
+            this.logger.error({
+                err: error
+            }, "The transaction failed with an unhandled error. crashing the process. " + "Please review this error and file an issue if it is a bug.");
+            throw error;
+        }
+    }
+    async waitForTransactionReceipt(hash) {
+        try {
+            const receipt = await this.client.waitForTransactionReceipt({
+                hash: hash
+            });
+            switch(receipt.status){
+                case "success":
+                    {
+                        this.logger.debug({
+                            hash,
+                            receipt
+                        }, "Price update successful");
+                        this.logger.info({
+                            hash
+                        }, "Price update successful");
+                        break;
+                    }
+                default:
+                    {
+                        this.logger.info({
+                            hash,
+                            receipt
+                        }, "Price update did not succeed or its transaction did not land. " + "This is an expected behaviour in high frequency or multi-instance setup.");
+                    }
+            }
+        } catch (error) {
+            this.logger.warn({
+                err: error
+            }, "Failed to get transaction receipt");
+        }
+    }
+    async getPriceFeedsUpdateData(priceIds) {
+        const response = await this.hermesClient.getLatestPriceUpdates(priceIds, {
+            encoding: "hex",
+            ignoreInvalidPriceIds: true
+        });
+        return response.binary.data;
+    }
+}

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

@@ -1,10 +1,12 @@
-import { IPricePusher, PriceInfo, ChainPriceListener, PriceItem } from "../interface";
-import { DurationInSeconds } from "../utils";
-import { Logger } from "pino";
-import { HermesClient, HexString, UnixTimestamp } from "@pythnetwork/hermes-client";
+import type { HexString, UnixTimestamp } from "@pythnetwork/hermes-client";
+import { HermesClient } from "@pythnetwork/hermes-client";
+import type { Logger } from "pino";
+import type { IPricePusher, PriceInfo, PriceItem } from "../interface.js";
+import type { DurationInSeconds } from "../utils.js";
 import { CustomGasStation } from "./custom-gas-station";
-import { PythContract } from "./pyth-contract";
-import { SuperWalletClient } from "./super-wallet";
+import type { PythContract } from "./pyth-contract.js";
+import type { SuperWalletClient } from "./super-wallet.js";
+import { ChainPriceListener } from "../interface.js";
 export declare class EvmPriceListener extends ChainPriceListener {
     private pythContract;
     private watchEvents;
@@ -35,4 +37,3 @@ export declare class EvmPricePusher implements IPricePusher {
     private waitForTransactionReceipt;
     private getPriceFeedsUpdateData;
 }
-//# sourceMappingURL=evm.d.ts.map