@pythnetwork/price-pusher 10.3.1 → 11.3.0

package/dist/evm/evm.cjs

@@ -17,8 +17,16 @@ _export(exports, {
     }
 });
 const _viem = require("viem");
-const _utils = require("../utils.cjs");
 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;
@@ -44,8 +52,8 @@ class EvmPriceListener extends _interface.ChainPriceListener {
         this.pythContract.watchEvent.PriceFeedUpdate({
             id: this.priceItems.map((item)=>(0, _utils.addLeading0x)(item.id))
         }, {
-            strict: true,
-            onLogs: this.onPriceFeedUpdate.bind(this)
+            onLogs: this.onPriceFeedUpdate.bind(this),
+            strict: true
         });
     }
     onPriceFeedUpdate(logs) {
@@ -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,20 +172,22 @@ 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
         this.lastPushAttempt = {
-            nonce: txNonce,
-            gasPrice: gasPrice
+            gasPrice: gasPrice,
+            nonce: txNonce
         };
         try {
             const { request } = await this.pythContract.simulate.updatePriceFeedsIfNecessary([
@@ -165,26 +195,26 @@ class EvmPricePusher {
                 priceIdsWith0x,
                 pubTimesToPushParam
             ], {
-                value: updateFee,
-                gasPrice: BigInt(Math.ceil(gasPrice)),
+                gas: this.gasLimit === undefined ? undefined : BigInt(Math.ceil(this.gasLimit)),
+                ...(0, _gasprice.gasPriceToTxParams)(gasPrice),
                 nonce: txNonce,
-                gas: this.gasLimit === undefined ? undefined : BigInt(Math.ceil(this.gasLimit))
+                value: updateFee
             });
             this.logger.debug({
                 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

@@ -1,12 +1,11 @@
-import type { HexString, UnixTimestamp } from "@pythnetwork/hermes-client";
-import { HermesClient } from "@pythnetwork/hermes-client";
+import type { HermesClient, HexString, UnixTimestamp } from "@pythnetwork/hermes-client";
 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 { 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";
-import { ChainPriceListener } from "../interface.js";
 export declare class EvmPriceListener extends ChainPriceListener {
     private pythContract;
     private watchEvents;
@@ -27,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;
 }

package/dist/evm/gas-price.cjs

@@ -0,0 +1,114 @@
+"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 describeGasPrice () {
+        return describeGasPrice;
+    },
+    get escalateGasPrice () {
+        return escalateGasPrice;
+    },
+    get gasPriceStrategies () {
+        return gasPriceStrategies;
+    },
+    get gasPriceToTxParams () {
+        return gasPriceToTxParams;
+    },
+    get getGasPrice () {
+        return getGasPrice;
+    },
+    get scaleGasPrice () {
+        return scaleGasPrice;
+    }
+});
+const gasPriceStrategies = [
+    "eip1559",
+    "legacy"
+];
+const getGasPrice = async (client, config, logger)=>{
+    if (config.strategy === "legacy") {
+        const gasPrice = config.gasPrice !== undefined ? BigInt(Math.ceil(config.gasPrice)) : await config.customGasStation?.getCustomGasPrice() || await client.getGasPrice();
+        return {
+            gasPrice,
+            strategy: "legacy"
+        };
+    }
+    // Source the fee from the chain base fee and an estimated priority fee
+    // instead of the deprecated eth_gasPrice RPC (which some RPCs mishandle).
+    // We pad the base fee to leave headroom for increases between blocks and
+    // apply a multiplier to the priority fee, mirroring the gas model in Fortuna.
+    const block = await client.getBlock({
+        blockTag: "latest"
+    });
+    if (block.baseFeePerGas == null) {
+        throw new Error("The chain does not report a base fee per gas, so it does not support " + "eip1559 transactions. Re-run with `--gas-pricing-strategy legacy`.");
+    }
+    const priorityFee = scaleBigInt(await client.estimateMaxPriorityFeePerGas(), config.priorityFeeMultiplier);
+    const maxFeePerGas = scaleBigInt(block.baseFeePerGas, config.baseFeeMultiplier) + priorityFee;
+    logger.debug(`Estimated baseFeePerGas=${block.baseFeePerGas} priorityFee=${priorityFee}`);
+    return {
+        maxFeePerGas,
+        maxPriorityFeePerGas: priorityFee,
+        strategy: "eip1559"
+    };
+};
+const scaleGasPrice = (gasPrice, factor)=>{
+    if (gasPrice.strategy === "legacy") {
+        return {
+            gasPrice: scaleBigInt(gasPrice.gasPrice, factor),
+            strategy: "legacy"
+        };
+    }
+    return {
+        maxFeePerGas: scaleBigInt(gasPrice.maxFeePerGas, factor),
+        maxPriorityFeePerGas: scaleBigInt(gasPrice.maxPriorityFeePerGas, factor),
+        strategy: "eip1559"
+    };
+};
+const escalateGasPrice = (fresh, escalated, cap)=>{
+    // The strategy is fixed for the lifetime of the pusher, so fresh and escalated
+    // always share it. The guards keep the discriminated union narrow.
+    if (fresh.strategy === "legacy" && escalated.strategy === "legacy") {
+        return {
+            gasPrice: capComponent(fresh.gasPrice, escalated.gasPrice, cap),
+            strategy: "legacy"
+        };
+    }
+    if (fresh.strategy === "eip1559" && escalated.strategy === "eip1559") {
+        // Cap the total spend via maxFeePerGas. The priority fee (tip) only needs
+        // to be raised enough to outbid the stuck tx; it is bounded by the capped
+        // maxFeePerGas (the EIP-1559 invariant priority <= maxFee), NOT by the fresh
+        // tip scaled by `cap` — when the market tip drops, that would stop the tip
+        // from escalating and leave the replacement underpriced.
+        const maxFeePerGas = capComponent(fresh.maxFeePerGas, escalated.maxFeePerGas, cap);
+        const bumpedPriority = maxBigInt(escalated.maxPriorityFeePerGas, fresh.maxPriorityFeePerGas);
+        return {
+            maxFeePerGas,
+            maxPriorityFeePerGas: minBigInt(bumpedPriority, maxFeePerGas),
+            strategy: "eip1559"
+        };
+    }
+    return fresh;
+};
+// Raise `fresh` to at least `escalated`, but never above `fresh * cap`.
+const capComponent = (fresh, escalated, cap)=>minBigInt(maxBigInt(escalated, fresh), scaleBigInt(fresh, cap));
+const maxBigInt = (a, b)=>a > b ? a : b;
+const minBigInt = (a, b)=>a < b ? a : b;
+const gasPriceToTxParams = (gasPrice)=>gasPrice.strategy === "legacy" ? {
+        gasPrice: gasPrice.gasPrice
+    } : {
+        maxFeePerGas: gasPrice.maxFeePerGas,
+        maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas
+    };
+const describeGasPrice = (gasPrice)=>gasPrice.strategy === "legacy" ? `gasPrice=${gasPrice.gasPrice}` : `maxFeePerGas=${gasPrice.maxFeePerGas} maxPriorityFeePerGas=${gasPrice.maxPriorityFeePerGas}`;
+// Scale a bigint by a floating point factor using fixed-point arithmetic to
+// avoid precision loss on large wei values.
+const SCALE_PRECISION = 1_000_000_000n;
+const scaleBigInt = (value, factor)=>value * BigInt(Math.round(factor * Number(SCALE_PRECISION))) / SCALE_PRECISION;

package/dist/evm/gas-price.d.ts

@@ -0,0 +1,33 @@
+import type { Logger } from "pino";
+import type { CustomGasStation } from "./custom-gas-station.js";
+import type { SuperWalletClient } from "./super-wallet.js";
+export declare const gasPriceStrategies: readonly ["eip1559", "legacy"];
+export type GasPriceStrategy = (typeof gasPriceStrategies)[number];
+export type GasPrice = {
+    strategy: "legacy";
+    gasPrice: bigint;
+} | {
+    strategy: "eip1559";
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+};
+export type GasPriceConfig = {
+    strategy: GasPriceStrategy;
+    baseFeeMultiplier: number;
+    priorityFeeMultiplier: number;
+    gasPrice?: number | undefined;
+    customGasStation?: CustomGasStation | undefined;
+};
+export declare const getGasPrice: (client: SuperWalletClient, config: GasPriceConfig, logger: Logger) => Promise<GasPrice>;
+export declare const scaleGasPrice: (gasPrice: GasPrice, factor: number) => GasPrice;
+export declare const escalateGasPrice: (fresh: GasPrice, escalated: GasPrice, cap: number) => GasPrice;
+export declare const gasPriceToTxParams: (gasPrice: GasPrice) => {
+    gasPrice: bigint;
+    maxFeePerGas?: never;
+    maxPriorityFeePerGas?: never;
+} | {
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+    gasPrice?: never;
+};
+export declare const describeGasPrice: (gasPrice: GasPrice) => string;

package/dist/evm/pyth-contract.cjs

@@ -11,7 +11,7 @@ Object.defineProperty(exports, "createPythContract", {
 const _viem = require("viem");
 const _pythabi = require("./pyth-abi.cjs");
 const createPythContract = (client, address)=>(0, _viem.getContract)({
-        client,
         abi: _pythabi.PythAbi,
-        address
+        address,
+        client
     });

package/dist/evm/super-wallet.cjs

@@ -56,9 +56,9 @@ function _interop_require_wildcard(obj, nodeInterop) {
 const UNKNOWN_CHAIN_CONFIG = {
     name: "Unknown",
     nativeCurrency: {
+        decimals: 18,
         name: "Unknown",
-        symbol: "Unknown",
-        decimals: 18
+        symbol: "Unknown"
     },
     rpcUrls: {
         default: {
@@ -83,8 +83,8 @@ const createClient = async (endpoint, mnemonic)=>{
         transport
     }).getChainId();
     return (0, _viem.createWalletClient)({
-        transport,
         account: (0, _accounts.mnemonicToAccount)(mnemonic),
-        chain: getChainById(chainId)
+        chain: getChainById(chainId),
+        transport
     }).extend(_viem.publicActions);
 };

package/dist/evm/super-wallet.d.ts

@@ -1,3 +1,3 @@
-import type { Account, Chain, Client, RpcSchema, WalletActions, PublicActions, Transport } from "viem";
+import type { Account, Chain, Client, PublicActions, RpcSchema, Transport, WalletActions } from "viem";
 export type SuperWalletClient = Client<Transport, Chain, Account, RpcSchema, PublicActions<Transport, Chain, Account> & WalletActions<Chain, Account>>;
 export declare const createClient: (endpoint: string, mnemonic: string) => Promise<SuperWalletClient>;

package/dist/fuel/command.cjs

@@ -12,12 +12,12 @@ const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
 const _hermesclient = require("@pythnetwork/hermes-client");
 const _fuels = require("fuels");
 const _pino = /*#__PURE__*/ _interop_require_default(require("pino"));
+const _controller = require("../controller.cjs");
 const _options = /*#__PURE__*/ _interop_require_wildcard(require("../options.cjs"));
 const _priceconfig = require("../price-config.cjs");
 const _pythpricelistener = require("../pyth-price-listener.cjs");
-const _fuel = require("./fuel.cjs");
-const _controller = require("../controller.cjs");
 const _utils = require("../utils.cjs");
+const _fuel = require("./fuel.cjs");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -65,41 +65,44 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 const _default = {
-    command: "fuel",
-    describe: "run price pusher for Fuel",
     builder: {
         endpoint: {
             description: "Fuel RPC API endpoint",
-            type: "string",
-            required: true
+            required: true,
+            type: "string"
         },
         "private-key-file": {
             description: "Path to the private key file",
-            type: "string",
-            required: true
+            required: true,
+            type: "string"
         },
         "pyth-contract-address": {
             description: "Pyth contract address on Fuel",
-            type: "string",
-            required: true
+            required: true,
+            type: "string"
         },
         ..._options.priceConfigFile,
         ..._options.priceServiceEndpoint,
+        ..._options.hermesAccessToken,
         ..._options.pushingFrequency,
         ..._options.pollingFrequency,
         ..._options.logLevel,
         ..._options.controllerLogLevel
     },
+    command: "fuel",
+    describe: "run price pusher for Fuel",
     handler: async function(argv) {
-        const { endpoint, privateKeyFile, pythContractAddress, priceConfigFile, priceServiceEndpoint, pushingFrequency, pollingFrequency, logLevel, controllerLogLevel } = argv;
+        const { endpoint, privateKeyFile, pythContractAddress, priceConfigFile, priceServiceEndpoint, hermesAccessToken, pushingFrequency, pollingFrequency, logLevel, controllerLogLevel } = argv;
         const logger = (0, _pino.default)({
             level: logLevel
         });
         const priceConfigs = (0, _priceconfig.readPriceConfigFile)(priceConfigFile);
-        const hermesClient = new _hermesclient.HermesClient(priceServiceEndpoint);
+        const hermesClient = new _hermesclient.HermesClient(priceServiceEndpoint, {
+            accessToken: hermesAccessToken
+        });
         let priceItems = priceConfigs.map(({ id, alias })=>({
-                id,
-                alias
+                alias,
+                id
             }));
         // Better to filter out invalid price items before creating the pyth listener
         const { existingPriceItems, invalidPriceItems } = await (0, _utils.filterInvalidPriceItems)(hermesClient, priceItems);