@pythnetwork/price-pusher 10.4.0 → 11.3.0

package/README.md

@@ -104,8 +104,19 @@ pnpm run start evm --endpoint wss://example-rpc.com \
     [--override-gas-price-multiplier 1.1] \
     [--override-gas-price-multiplier-cap 5] \
     [--gas-limit 1000000] \
+    [--gas-pricing-strategy eip1559] \
+    [--base-fee-multiplier 1.2] \
+    [--priority-fee-multiplier 1] \
     [--gas-price 160000000]
 
+# The EVM pusher prices transactions with the `eip1559` strategy by default. It
+# computes `maxFeePerGas` from the chain base fee (padded by `--base-fee-multiplier`
+# to leave headroom for the base fee growing between blocks) plus an estimated
+# priority fee (scaled by `--priority-fee-multiplier`). This avoids the deprecated
+# `eth_gasPrice` RPC, which some RPCs mishandle. For chains that do not support
+# EIP-1559 transactions, pass `--gas-pricing-strategy legacy`, which falls back to
+# the single `gasPrice` model and where `--gas-price` / `--custom-gas-station` apply.
+
 # For Injective
 pnpm run start injective --grpc-endpoint https://grpc-endpoint.com \
     --pyth-contract-address inj1z60tg0... --price-service-endpoint "https://example-hermes-rpc.com" \
@@ -129,19 +140,27 @@ pnpm run start aptos --endpoint https://fullnode.testnet.aptoslabs.com/v1 \
 
 # For Sui
 pnpm run start sui \
-  --endpoint https://sui-testnet-rpc.allthatnode.com \
-  --pyth-package-id 0x975e063f398f720af4f33ec06a927f14ea76ca24f7f8dd544aa62ab9d5d15f44 \
-  --pyth-state-id 0xd8afde3a48b4ff7212bd6829a150f43f59043221200d63504d981f62bff2e27a \
-  --wormhole-package-id 0xcc029e2810f17f9f43f52262f40026a71fbdca40ed3803ad2884994361910b7e \
-  --wormhole-state-id 0xebba4cc4d614f7a7cdbe883acc76d1cc767922bc96778e7b68be0d15fce27c02 \
-  --price-feed-to-price-info-object-table-id 0xf8929174008c662266a1adde78e1e8e33016eb7ad37d379481e860b911e40ed5 \
+  --endpoint https://fullnode.testnet.sui.io:443 \
+  --network testnet \
+  --pyth-package-id 0xabf837e98c26087cba0883c0a7a28326b1fa3c5e1e2c5abdb486f9e8f594c837 \
+  --pyth-state-id 0x243759059f4c3111179da5878c12f68d612c21a8d54d85edc86164bb18be1c7c \
+  --wormhole-package-id 0x21473617f3565d704aa67be73ea41243e9e34a42d434c31f8182c67ba01ccf49 \
+  --wormhole-state-id 0x31358d198147da50db32eda2562951d53973a0c0ad5ed738e9b17d88b213d790 \
+  --price-feed-to-price-info-object-table-id 0xcb858b77d8068c6c8c0d8a4ddfba95053268e4a31f8ecc49adccc4ec1570d3a7 \
   --price-service-endpoint https://example-hermes-rpc.com \
   --mnemonic-file ./mnemonic \
   --price-config-file ./price-config.beta.sample.yaml \
+  [--endpoint-type json-rpc] \
   [--pushing-frequency 10] \
   [--polling-frequency 5] \
   [--num-gas-objects 30]
 
+# `--endpoint-type` selects the Sui RPC transport: `json-rpc` (default) or `grpc`.
+# Sui Foundation is deprecating JSON-RPC (public endpoints off July 2026, removed
+# from full nodes by mid-Oct 2026), so set `--endpoint-type grpc` and point
+# `--endpoint` at a gRPC-web base URL to migrate. `grpc` uses @mysten/sui's
+# experimental SuiGrpcClient.
+
 # For Near
 pnpm run start near \
   --node-url https://rpc.testnet.near.org \

package/dist/common.cjs

@@ -1,4 +1 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});

package/dist/common.d.ts

@@ -1,4 +0,0 @@
-export type PushAttempt = {
-    nonce: number;
-    gasPrice: number;
-};

package/dist/controller.cjs

@@ -28,6 +28,9 @@ class Controller {
         this.metrics = config.metrics;
         // Set the number of price feeds if metrics are enabled
         this.metrics?.setPriceFeedsTotal(this.priceConfigs.length);
+        // Report unhealthy on /live if no loop iteration completes within a few
+        // pushing cycles (min 60s), so the k8s livenessProbe restarts a hung pod.
+        this.metrics?.setLivenessThresholdSeconds(Math.max(this.pushingFrequency * 5, 60));
     }
     async start() {
         // start the listeners
@@ -49,13 +52,13 @@ class Controller {
                 const targetLatestPrice = this.targetPriceListener.getLatestPriceInfo(priceId);
                 const sourceLatestPrice = this.sourcePriceListener.getLatestPriceInfo(priceId);
                 if (this.metrics && targetLatestPrice && sourceLatestPrice) {
-                    this.metrics.updateTimestamps(priceId, alias, targetLatestPrice.publishTime, sourceLatestPrice.publishTime, priceConfig.timeDifference);
-                    this.metrics.updatePriceValues(priceId, alias, sourceLatestPrice.price, targetLatestPrice.price);
+                    this.metrics.updateTimestamps(alias, targetLatestPrice.publishTime, sourceLatestPrice.publishTime, priceConfig.timeDifference);
+                    this.metrics.updatePriceValues(alias, sourceLatestPrice.price, targetLatestPrice.price);
                 }
                 const priceShouldUpdate = (0, _priceconfig.shouldUpdate)(priceConfig, sourceLatestPrice, targetLatestPrice, this.logger);
                 // Record update condition in metrics
                 if (this.metrics) {
-                    this.metrics.recordUpdateCondition(priceId, alias, priceShouldUpdate);
+                    this.metrics.recordUpdateCondition(alias, priceShouldUpdate);
                 }
                 if (priceShouldUpdate == _priceconfig.UpdateCondition.YES) {
                     pushThresholdMet = true;
@@ -80,7 +83,7 @@ class Controller {
                     if (this.metrics) {
                         for (const config of pricesToPush){
                             const triggerValue = (0, _priceconfig.shouldUpdate)(config, this.sourcePriceListener.getLatestPriceInfo(config.id), this.targetPriceListener.getLatestPriceInfo(config.id), this.logger) === _priceconfig.UpdateCondition.YES ? "yes" : "early";
-                            this.metrics.recordPriceUpdate(config.id, config.alias, triggerValue);
+                            this.metrics.recordPriceUpdate(config.alias, triggerValue);
                         }
                     }
                 } catch (error) {
@@ -92,13 +95,15 @@ class Controller {
                     if (this.metrics) {
                         for (const config of pricesToPush){
                             const triggerValue = (0, _priceconfig.shouldUpdate)(config, this.sourcePriceListener.getLatestPriceInfo(config.id), this.targetPriceListener.getLatestPriceInfo(config.id), this.logger) === _priceconfig.UpdateCondition.YES ? "yes" : "early";
-                            this.metrics.recordPriceUpdateError(config.id, config.alias, triggerValue);
+                            this.metrics.recordPriceUpdateError(config.alias, triggerValue);
                         }
                     }
                 }
             } else {
                 this.logger.info("None of the checks were triggered. No push needed.");
             }
+            // Liveness heartbeat: mark this loop iteration as completed.
+            this.metrics?.recordLoopIteration();
             await (0, _utils.sleep)(this.pushingFrequency * 1000);
         }
     }

package/dist/evm/command.cjs

@@ -70,6 +70,12 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 const _default = {
     builder: {
+        "base-fee-multiplier": {
+            default: 1.2,
+            description: "[eip1559 strategy only] Multiplier applied to the chain base fee when computing " + "maxFeePerGas. Values above 1 leave headroom for the base fee to grow between blocks. " + "Default to 1.2",
+            required: false,
+            type: "number"
+        },
         "custom-gas-station": {
             description: "If using a custom gas station, chainId of custom gas station to use",
             required: false,
@@ -86,10 +92,19 @@ const _default = {
             type: "number"
         },
         "gas-price": {
-            description: "Override the gas price that would be received from the RPC",
+            description: "[legacy strategy only] Override the gas price (in wei) that would be received from the RPC",
             required: false,
             type: "number"
         },
+        "gas-pricing-strategy": {
+            choices: [
+                "eip1559",
+                "legacy"
+            ],
+            default: "eip1559",
+            description: "How to price transactions. 'eip1559' (default and recommended) sources the " + "gas from the chain base fee and a priority fee, which is more robust as it " + "avoids the deprecated eth_gasPrice RPC. Use 'legacy' for chains that do not " + "support eip1559 transactions.",
+            required: false
+        },
         "override-gas-price-multiplier": {
             default: 1.1,
             description: "Multiply the previous gas price by this number if the transaction is not landing to override. " + "Please note that the gas price can grow exponentially on consecutive failures; " + "to set a cap on the multiplier, use the `override-gas-price-multiplier-cap` option." + "Default to 1.1",
@@ -102,6 +117,24 @@ const _default = {
             required: false,
             type: "number"
         },
+        "priority-fee-multiplier": {
+            default: 1,
+            description: "[eip1559 strategy only] Multiplier applied to the priority fee (tip) estimated from " + "the RPC. Default to 1",
+            required: false,
+            type: "number"
+        },
+        "receipt-poll-interval": {
+            default: 2,
+            description: "How often (in seconds) to poll for a sent transaction's receipt while waiting for " + "it to land. Default to 2",
+            required: false,
+            type: "number"
+        },
+        "receipt-wait-timeout": {
+            default: 60,
+            description: "Maximum time (in seconds) to poll for a sent transaction's receipt before giving " + "up. Bounds the wait so a transaction that never lands cannot be polled forever. " + "Default to 60",
+            required: false,
+            type: "number"
+        },
         "tx-speed": {
             choices: [
                 "slow",
@@ -133,7 +166,7 @@ const _default = {
     describe: "run price pusher for evm",
     handler: async function(argv) {
         // FIXME: type checks for this
-        const { endpoint, priceConfigFile, priceServiceEndpoint, hermesAccessToken, mnemonicFile, pythContractAddress, pushingFrequency, pollingFrequency, customGasStation, txSpeed, overrideGasPriceMultiplier, overrideGasPriceMultiplierCap, gasLimit, gasPrice, updateFeeMultiplier, logLevel, controllerLogLevel, enableMetrics, metricsPort } = argv;
+        const { endpoint, priceConfigFile, priceServiceEndpoint, hermesAccessToken, mnemonicFile, pythContractAddress, pushingFrequency, pollingFrequency, customGasStation, txSpeed, overrideGasPriceMultiplier, overrideGasPriceMultiplierCap, gasLimit, gasPricingStrategy, gasPrice, baseFeeMultiplier, priorityFeeMultiplier, updateFeeMultiplier, receiptPollInterval, receiptWaitTimeout, logLevel, controllerLogLevel, enableMetrics, metricsPort } = argv;
         const logger = (0, _pino.default)({
             level: logLevel
         });
@@ -179,9 +212,22 @@ const _default = {
         const gasStation = (0, _customgasstation.getCustomGasStation)(logger.child({
             module: "CustomGasStation"
         }), customGasStation, txSpeed);
+        if (gasPricingStrategy === "eip1559" && (gasStation || gasPrice)) {
+            logger.warn("`--custom-gas-station`/`--tx-speed` and `--gas-price` only apply to the 'legacy' " + "gas pricing strategy and will be ignored. Use `--base-fee-multiplier` and " + "`--priority-fee-multiplier` to tune the 'eip1559' strategy.");
+        }
+        const gasPriceConfig = {
+            baseFeeMultiplier,
+            customGasStation: gasStation,
+            gasPrice,
+            priorityFeeMultiplier,
+            strategy: gasPricingStrategy
+        };
         const evmPusher = new _evm.EvmPricePusher(hermesClient, client, pythContract, logger.child({
             module: "EvmPricePusher"
-        }), overrideGasPriceMultiplier, overrideGasPriceMultiplierCap, updateFeeMultiplier, gasLimit, gasStation, gasPrice);
+        }), overrideGasPriceMultiplier, overrideGasPriceMultiplierCap, updateFeeMultiplier, gasPriceConfig, gasLimit, // CLI values are in seconds; the pusher expects milliseconds. Defaults
+        // (60s / 2s) reproduce the pre-flag behaviour, so existing deployments
+        // that don't set these flags are unaffected.
+        receiptWaitTimeout * 1000, receiptPollInterval * 1000);
         const controller = new _controller.Controller(priceConfigs, pythListener, evmListener, evmPusher, logger.child({
             module: "Controller"
         }, {

package/dist/evm/command.d.ts

@@ -12,12 +12,17 @@ declare const _default: {
         "hermes-access-token": Options;
         "price-service-endpoint": Options;
         "price-config-file": Options;
+        "base-fee-multiplier": Options;
         "custom-gas-station": Options;
         endpoint: Options;
         "gas-limit": Options;
         "gas-price": Options;
+        "gas-pricing-strategy": Options;
         "override-gas-price-multiplier": Options;
         "override-gas-price-multiplier-cap": Options;
+        "priority-fee-multiplier": Options;
+        "receipt-poll-interval": Options;
+        "receipt-wait-timeout": Options;
         "tx-speed": Options;
         "update-fee-multiplier": Options;
     };

package/dist/evm/evm.cjs

@@ -19,6 +19,14 @@ _export(exports, {
 const _viem = require("viem");
 const _interface = require("../interface.cjs");
 const _utils = require("../utils.cjs");
+const _gasprice = require("./gas-price.cjs");
+// Some RPC providers surface the same underlying failure through different viem
+// error classes. For example "replacement transaction underpriced" comes back as
+// an `InternalRpcError` (code -32000) on most chains, but Soneium/Alchemy returns
+// it as an `InvalidInputRpcError` (code -32602, "Missing or invalid parameters").
+// Matching on the error text across the whole cause chain (rather than on a
+// specific class) keeps the detection robust across providers.
+const errorChainIncludes = (error, needle)=>error.walk((e)=>e instanceof _viem.BaseError && e.details.includes(needle) || e instanceof Error && e.message.includes(needle)) !== null;
 class EvmPriceListener extends _interface.ChainPriceListener {
     pythContract;
     watchEvents;
@@ -88,12 +96,31 @@ class EvmPricePusher {
     overrideGasPriceMultiplier;
     overrideGasPriceMultiplierCap;
     updateFeeMultiplier;
+    gasPriceConfig;
     gasLimit;
-    customGasStation;
-    gasPrice;
+    receiptWaitTimeoutMs;
+    receiptPollIntervalMs;
     pusherAddress;
     lastPushAttempt;
-    constructor(hermesClient, client, pythContract, logger, overrideGasPriceMultiplier, overrideGasPriceMultiplierCap, updateFeeMultiplier, gasLimit, customGasStation, gasPrice){
+    // Bounded, per-nonce receipt trackers. Each poll self-terminates on landing or
+    // at `receiptWaitTimeoutMs`. Same-nonce gas escalations ADD a tracker rather
+    // than replacing the previous one: the original and the repriced tx compete
+    // for the nonce and EITHER can land (a miner may include the old tx over the
+    // replacement), so all competing hashes stay watched and whichever lands is
+    // logged. A nonce advance means the previous nonce already resolved, so its
+    // now-doomed stragglers are aborted. This replaces viem's
+    // `waitForTransactionReceipt`, whose timeout (on the pinned version) rejects
+    // without tearing down its internal `eth_getTransactionByHash` / block-number
+    // poll — so a fire-and-forget wait for a tx that never becomes findable leaked
+    // a detached poller that ran for the pod's whole lifetime, one per push. Here
+    // the count is bounded: at most one nonce is tracked at a time, and each of
+    // its trackers self-terminates at the deadline.
+    receiptTrackers = new Set();
+    trackedNonce;
+    constructor(hermesClient, client, pythContract, logger, overrideGasPriceMultiplier, overrideGasPriceMultiplierCap, updateFeeMultiplier, gasPriceConfig, gasLimit, // Upper bound on how long to poll for a tx receipt before giving up. Keeps a
+    // tx that never lands from polling forever. Defaults to ~2 push cycles.
+    receiptWaitTimeoutMs = 60_000, // How often to poll `eth_getTransactionReceipt` while waiting.
+    receiptPollIntervalMs = 2000){
         this.hermesClient = hermesClient;
         this.client = client;
         this.pythContract = pythContract;
@@ -101,9 +128,10 @@ class EvmPricePusher {
         this.overrideGasPriceMultiplier = overrideGasPriceMultiplier;
         this.overrideGasPriceMultiplierCap = overrideGasPriceMultiplierCap;
         this.updateFeeMultiplier = updateFeeMultiplier;
+        this.gasPriceConfig = gasPriceConfig;
         this.gasLimit = gasLimit;
-        this.customGasStation = customGasStation;
-        this.gasPrice = gasPrice;
+        this.receiptWaitTimeoutMs = receiptWaitTimeoutMs;
+        this.receiptPollIntervalMs = receiptPollIntervalMs;
     }
     // 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)
@@ -129,11 +157,11 @@ class EvmPricePusher {
             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()));
+        // Fetch a fresh gas price. With the eip1559 strategy this is sourced from
+        // the chain base fee and priority fee (avoiding the deprecated eth_gasPrice
+        // RPC); with the legacy strategy it falls back to the single gasPrice model
+        // for chains that don't support eip1559 transactions.
+        let gasPrice = await (0, _gasprice.getGasPrice)(this.client, this.gasPriceConfig, this.logger);
         // 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({
@@ -144,14 +172,16 @@ class EvmPricePusher {
             if (this.lastPushAttempt.nonce <= lastExecutedNonce) {
                 this.lastPushAttempt = undefined;
             } else {
-                gasPriceToOverride = this.lastPushAttempt.gasPrice * this.overrideGasPriceMultiplier;
+                gasPriceToOverride = (0, _gasprice.scaleGasPrice)(this.lastPushAttempt.gasPrice, this.overrideGasPriceMultiplier);
             }
         }
-        if (gasPriceToOverride !== undefined && gasPriceToOverride > Number(gasPrice)) {
-            gasPrice = Math.min(gasPriceToOverride, gasPrice * this.overrideGasPriceMultiplierCap);
+        if (gasPriceToOverride !== undefined) {
+            // Bump every fee component to override the stuck transaction, capping the
+            // bump relative to the fresh gas price returned by the RPC.
+            gasPrice = (0, _gasprice.escalateGasPrice)(gasPrice, gasPriceToOverride, this.overrideGasPriceMultiplierCap);
         }
         const txNonce = lastExecutedNonce + 1;
-        this.logger.debug(`Using gas price: ${gasPrice} and nonce: ${txNonce}`);
+        this.logger.debug(`Using ${(0, _gasprice.describeGasPrice)(gasPrice)} and nonce: ${txNonce}`);
         const pubTimesToPushParam = pubTimesToPush.map(BigInt);
         const priceIdsWith0x = priceIds.map((priceId)=>(0, _utils.addLeading0x)(priceId));
         // Update lastAttempt
@@ -166,7 +196,7 @@ class EvmPricePusher {
                 pubTimesToPushParam
             ], {
                 gas: this.gasLimit === undefined ? undefined : BigInt(Math.ceil(this.gasLimit)),
-                gasPrice: BigInt(Math.ceil(gasPrice)),
+                ...(0, _gasprice.gasPriceToTxParams)(gasPrice),
                 nonce: txNonce,
                 value: updateFee
             });
@@ -174,17 +204,17 @@ class EvmPricePusher {
                 request
             }, "Simulated request successfully");
             const hash = await this.client.writeContract(request);
-            this.logger.info({
+            this.logger.debug({
                 hash
             }, "Price update sent");
-            void this.waitForTransactionReceipt(hash);
+            this.trackTransactionReceipt(hash, txNonce);
         } 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.");
+                    this.logger.debug("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)) {
@@ -193,12 +223,12 @@ class EvmPricePusher {
                     }, "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"))) {
+                if (error.walk((e)=>e instanceof _viem.FeeCapTooLowError) || errorChainIncludes(error, "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.");
+                    this.logger.debug("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.
@@ -211,7 +241,7 @@ class EvmPricePusher {
                 // 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({
+                    this.logger.warn({
                         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;
@@ -219,7 +249,7 @@ class EvmPricePusher {
                 // 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.");
+                    this.logger.debug("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")) {
@@ -235,7 +265,7 @@ class EvmPricePusher {
                     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.");
+                    this.logger.debug("A transaction with the same nonce has been mined and this one is no longer needed. Skipping this push.");
                     return;
                 }
             }
@@ -246,37 +276,111 @@ class EvmPricePusher {
             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.");
-                    }
+    // Stop all in-flight receipt trackers (graceful shutdown / tests). Safe to
+    // call at any time; leaves no pending poll behind.
+    dispose() {
+        for (const controller of this.receiptTrackers){
+            controller.abort();
+        }
+        this.receiptTrackers.clear();
+        this.trackedNonce = undefined;
+    }
+    // Start a receipt tracker for a freshly-sent tx. Fire-and-forget by design —
+    // the receipt is observational (it only produces the "Price update successful"
+    // log the Grafana Tx-Hash panel scrapes); the controller never blocks on it,
+    // and the re-send/nonce/gas decision is driven by a fresh `getTransactionCount`
+    // each cycle, not by the receipt.
+    trackTransactionReceipt(hash, nonce) {
+        // A new nonce means the previous nonce already resolved (a tx for it landed,
+        // advancing the on-chain count), so abort the stragglers still polling the
+        // old nonce's hashes. They each do one final lookup on abort, so the hash
+        // that actually landed is still logged before they stop. Same-nonce
+        // escalations fall through and ADD a tracker so every competing hash for the
+        // live nonce stays watched.
+        if (this.trackedNonce !== undefined && nonce !== this.trackedNonce) {
+            for (const controller of this.receiptTrackers){
+                controller.abort();
             }
-        } catch (error) {
-            this.logger.warn({
-                err: error
-            }, "Failed to get transaction receipt");
+            this.receiptTrackers.clear();
+        }
+        this.trackedNonce = nonce;
+        const controller = new AbortController();
+        this.receiptTrackers.add(controller);
+        void this.pollTransactionReceipt(hash, controller).finally(()=>{
+            this.receiptTrackers.delete(controller);
+        });
+    }
+    // Poll `eth_getTransactionReceipt` (one call per interval) until the tx lands,
+    // the tracker is superseded, or the deadline elapses. Unlike viem's
+    // `waitForTransactionReceipt` this issues no `eth_getTransactionByHash` and no
+    // per-block full-block fetch, and its teardown is guaranteed by the bound +
+    // AbortController — so an un-landing tx cannot leak a poller.
+    async pollTransactionReceipt(hash, controller) {
+        const deadline = Date.now() + this.receiptWaitTimeoutMs;
+        for(;;){
+            let receipt;
+            try {
+                receipt = await this.client.getTransactionReceipt({
+                    hash
+                });
+            } catch  {
+                // viem throws TransactionReceiptNotFoundError while the tx is unmined.
+                // Treat any lookup failure as "not landed yet" and keep polling.
+                receipt = undefined;
+            }
+            // A fetched receipt means the tx actually landed — it is never stale, so
+            // log it even if this tracker was superseded (otherwise the Grafana panel
+            // would miss the hash of a tx that landed just as the next push started).
+            if (receipt !== undefined) {
+                if (receipt.status === "success") {
+                    // Keep one non-debug hash line per landed tx: the bundled Grafana
+                    // "Tx Hash" panel scrapes this message from Loki and extracts {{.hash}}.
+                    this.logger.info({
+                        hash
+                    }, "Price update successful");
+                } else {
+                    this.logger.debug({
+                        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.");
+                }
+                return;
+            }
+            // Not landed yet: stop if this tracker was superseded, or if we ran out
+            // of time (only these bounded paths end the loop, so it cannot leak).
+            if (controller.signal.aborted) {
+                return;
+            }
+            if (Date.now() >= deadline) {
+                this.logger.debug({
+                    hash
+                }, "Gave up waiting for the transaction receipt within the timeout. " + "This is expected when a tx does not land; the next push re-derives " + "the nonce from the chain and replaces it if needed.");
+                return;
+            }
+            await this.interruptibleSleep(this.receiptPollIntervalMs, controller.signal);
         }
     }
+    // Sleep that resolves early if the signal aborts, so a superseded tracker
+    // stops promptly instead of waiting out its poll interval.
+    interruptibleSleep(ms, signal) {
+        return new Promise((resolve)=>{
+            if (signal.aborted) {
+                resolve();
+                return;
+            }
+            const onAbort = ()=>{
+                clearTimeout(timer);
+                resolve();
+            };
+            const timer = setTimeout(()=>{
+                signal.removeEventListener("abort", onAbort);
+                resolve();
+            }, ms);
+            signal.addEventListener("abort", onAbort, {
+                once: true
+            });
+        });
+    }
     async getPriceFeedsUpdateData(priceIds) {
         const response = await this.hermesClient.getLatestPriceUpdates(priceIds, {
             encoding: "hex",

package/dist/evm/evm.d.ts

@@ -3,7 +3,7 @@ import type { Logger } from "pino";
 import type { IPricePusher, PriceInfo, PriceItem } from "../interface.js";
 import { ChainPriceListener } from "../interface.js";
 import type { DurationInSeconds } from "../utils.js";
-import type { CustomGasStation } from "./custom-gas-station";
+import type { GasPriceConfig } from "./gas-price.js";
 import type { PythContract } from "./pyth-contract.js";
 import type { SuperWalletClient } from "./super-wallet.js";
 export declare class EvmPriceListener extends ChainPriceListener {
@@ -26,13 +26,19 @@ export declare class EvmPricePusher implements IPricePusher {
     private overrideGasPriceMultiplier;
     private overrideGasPriceMultiplierCap;
     private updateFeeMultiplier;
+    private gasPriceConfig;
     private gasLimit?;
-    private customGasStation?;
-    private gasPrice?;
+    private receiptWaitTimeoutMs;
+    private receiptPollIntervalMs;
     private pusherAddress;
     private lastPushAttempt;
-    constructor(hermesClient: HermesClient, client: SuperWalletClient, pythContract: PythContract, logger: Logger, overrideGasPriceMultiplier: number, overrideGasPriceMultiplierCap: number, updateFeeMultiplier: number, gasLimit?: number | undefined, customGasStation?: CustomGasStation | undefined, gasPrice?: number | undefined);
+    private receiptTrackers;
+    private trackedNonce;
+    constructor(hermesClient: HermesClient, client: SuperWalletClient, pythContract: PythContract, logger: Logger, overrideGasPriceMultiplier: number, overrideGasPriceMultiplierCap: number, updateFeeMultiplier: number, gasPriceConfig: GasPriceConfig, gasLimit?: number | undefined, receiptWaitTimeoutMs?: number, receiptPollIntervalMs?: number);
     updatePriceFeed(priceIds: string[], pubTimesToPush: UnixTimestamp[]): Promise<void>;
-    private waitForTransactionReceipt;
+    dispose(): void;
+    private trackTransactionReceipt;
+    private pollTransactionReceipt;
+    private interruptibleSleep;
     private getPriceFeedsUpdateData;
 }