@pythnetwork/price-pusher 10.4.0 → 11.3.0

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/metrics.cjs

@@ -30,6 +30,11 @@ class PricePusherMetrics {
     targetPriceValue;
     // Wallet metrics
     walletBalance;
+    // Liveness heartbeat
+    loopIterations;
+    // Liveness state for the /live endpoint (threshold set by the controller)
+    lastLoopIterationAt;
+    livenessThresholdMs = 60_000;
     constructor(logger){
         this.logger = logger;
         this.registry = new _promclient.Registry();
@@ -42,7 +47,6 @@ class PricePusherMetrics {
         this.lastPublishedTime = new _promclient.Gauge({
             help: "The last published time of a price feed in unix timestamp",
             labelNames: [
-                "price_id",
                 "alias"
             ],
             name: "pyth_price_last_published_time",
@@ -53,7 +57,6 @@ class PricePusherMetrics {
         this.priceUpdateAttempts = new _promclient.Counter({
             help: "Total number of price update attempts with their trigger condition and status",
             labelNames: [
-                "price_id",
                 "alias",
                 "trigger",
                 "status"
@@ -73,7 +76,6 @@ class PricePusherMetrics {
         this.sourceTimestamp = new _promclient.Gauge({
             help: "Latest source chain price publish timestamp",
             labelNames: [
-                "price_id",
                 "alias"
             ],
             name: "pyth_source_timestamp",
@@ -84,7 +86,6 @@ class PricePusherMetrics {
         this.configuredTimeDifference = new _promclient.Gauge({
             help: "Configured time difference threshold between source and target chains",
             labelNames: [
-                "price_id",
                 "alias"
             ],
             name: "pyth_configured_time_difference",
@@ -95,7 +96,6 @@ class PricePusherMetrics {
         this.sourcePriceValue = new _promclient.Gauge({
             help: "Latest price value from Pyth source",
             labelNames: [
-                "price_id",
                 "alias"
             ],
             name: "pyth_source_price",
@@ -106,7 +106,6 @@ class PricePusherMetrics {
         this.targetPriceValue = new _promclient.Gauge({
             help: "Latest price value from target chain",
             labelNames: [
-                "price_id",
                 "alias"
             ],
             name: "pyth_target_price",
@@ -126,11 +125,32 @@ class PricePusherMetrics {
                 this.registry
             ]
         });
+        // Liveness heartbeat: increments once per controller loop iteration so a
+        // hung (but not crashed) process is detectable via the metric going flat.
+        this.loopIterations = new _promclient.Counter({
+            help: "Total number of controller loop iterations completed (liveness heartbeat)",
+            name: "pyth_pusher_loop_iterations_total",
+            registers: [
+                this.registry
+            ]
+        });
         // Setup the metrics endpoint
         this.server.get("/metrics", async (_, res)=>{
             res.set("Content-Type", this.registry.contentType);
             res.end(await this.registry.metrics());
         });
+        // Liveness endpoint for the k8s livenessProbe: 200 while the control loop is
+        // progressing, 503 once no iteration has completed within the threshold (hung),
+        // so Kubernetes restarts a hung-but-not-crashed pod.
+        this.server.get("/live", (_, res)=>{
+            const last = this.lastLoopIterationAt;
+            const healthy = last !== undefined && Date.now() - last <= this.livenessThresholdMs;
+            res.status(healthy ? 200 : 503).json({
+                lastLoopIterationAt: last ?? null,
+                status: healthy ? "ok" : "stale",
+                thresholdMs: this.livenessThresholdMs
+            });
+        });
     }
     // Start the metrics server
     start(port) {
@@ -139,22 +159,20 @@ class PricePusherMetrics {
         });
     }
     // Record a successful price update
-    recordPriceUpdate(priceId, alias, trigger = "yes") {
+    recordPriceUpdate(alias, trigger = "yes") {
         this.priceUpdateAttempts.inc({
             alias,
-            price_id: priceId,
             status: "success",
             trigger: trigger.toLowerCase()
         });
     }
     // Record update condition status (YES/NO/EARLY)
-    recordUpdateCondition(priceId, alias, condition) {
+    recordUpdateCondition(alias, condition) {
         const triggerLabel = _priceconfig.UpdateCondition[condition].toLowerCase();
         // Only record as 'skipped' when the condition is NO
         if (condition === _priceconfig.UpdateCondition.NO) {
             this.priceUpdateAttempts.inc({
                 alias,
-                price_id: priceId,
                 status: "skipped",
                 trigger: triggerLabel
             });
@@ -163,10 +181,9 @@ class PricePusherMetrics {
     // when recordPriceUpdate or recordPriceUpdateError is called
     }
     // Record a price update error
-    recordPriceUpdateError(priceId, alias, trigger = "yes") {
+    recordPriceUpdateError(alias, trigger = "yes") {
         this.priceUpdateAttempts.inc({
             alias,
-            price_id: priceId,
             status: "error",
             trigger: trigger.toLowerCase()
         });
@@ -175,33 +192,38 @@ class PricePusherMetrics {
     setPriceFeedsTotal(count) {
         this.priceFeedsTotal.set(count);
     }
+    // Record a completed controller loop iteration (liveness heartbeat)
+    recordLoopIteration() {
+        this.lastLoopIterationAt = Date.now();
+        this.loopIterations.inc();
+    }
+    // Configure how long without a completed loop iteration before /live reports
+    // unhealthy (used by the k8s livenessProbe to restart a hung pod).
+    setLivenessThresholdSeconds(seconds) {
+        this.livenessThresholdMs = seconds * 1000;
+    }
     // Update source, target and configured time difference timestamps
-    updateTimestamps(priceId, alias, targetLatestPricePublishTime, sourceLatestPricePublishTime, priceConfigTimeDifference) {
+    updateTimestamps(alias, targetLatestPricePublishTime, sourceLatestPricePublishTime, priceConfigTimeDifference) {
         this.sourceTimestamp.set({
-            alias,
-            price_id: priceId
+            alias
         }, sourceLatestPricePublishTime);
         this.lastPublishedTime.set({
-            alias,
-            price_id: priceId
+            alias
         }, targetLatestPricePublishTime);
         this.configuredTimeDifference.set({
-            alias,
-            price_id: priceId
+            alias
         }, priceConfigTimeDifference);
     }
     // Update price values
-    updatePriceValues(priceId, alias, sourcePrice, targetPrice) {
+    updatePriceValues(alias, sourcePrice, targetPrice) {
         if (sourcePrice !== undefined) {
             this.sourcePriceValue.set({
-                alias,
-                price_id: priceId
+                alias
             }, Number(sourcePrice));
         }
         if (targetPrice !== undefined) {
             this.targetPriceValue.set({
-                alias,
-                price_id: priceId
+                alias
             }, Number(targetPrice));
         }
     }

package/dist/metrics.d.ts

@@ -13,13 +13,18 @@ export declare class PricePusherMetrics {
     sourcePriceValue: Gauge;
     targetPriceValue: Gauge;
     walletBalance: Gauge;
+    loopIterations: Counter;
+    private lastLoopIterationAt;
+    private livenessThresholdMs;
     constructor(logger: Logger);
     start(port: number): void;
-    recordPriceUpdate(priceId: string, alias: string, trigger?: string): void;
-    recordUpdateCondition(priceId: string, alias: string, condition: UpdateCondition): void;
-    recordPriceUpdateError(priceId: string, alias: string, trigger?: string): void;
+    recordPriceUpdate(alias: string, trigger?: string): void;
+    recordUpdateCondition(alias: string, condition: UpdateCondition): void;
+    recordPriceUpdateError(alias: string, trigger?: string): void;
     setPriceFeedsTotal(count: number): void;
-    updateTimestamps(priceId: string, alias: string, targetLatestPricePublishTime: number, sourceLatestPricePublishTime: number, priceConfigTimeDifference: number): void;
-    updatePriceValues(priceId: string, alias: string, sourcePrice: string | undefined, targetPrice: string | undefined): void;
+    recordLoopIteration(): void;
+    setLivenessThresholdSeconds(seconds: number): void;
+    updateTimestamps(alias: string, targetLatestPricePublishTime: number, sourceLatestPricePublishTime: number, priceConfigTimeDifference: number): void;
+    updatePriceValues(alias: string, sourcePrice: string | undefined, targetPrice: string | undefined): void;
     updateWalletBalance(walletAddress: string, network: string, balance: bigint | number): void;
 }

package/dist/price-config.cjs

@@ -74,12 +74,12 @@ function shouldUpdate(priceConfig, sourceLatestPrice, targetLatestPrice, logger)
     const priceId = priceConfig.id;
     // There is no price to update the target with. So we should not update it.
     if (sourceLatestPrice === undefined) {
-        logger.info(`${priceConfig.alias} (${priceId}) is not available on the source network. Ignoring it.`);
+        logger.warn(`${priceConfig.alias} (${priceId}) is not available on the source network. Ignoring it.`);
         return 2;
     }
     // It means that price never existed there. So we should push the latest price feed.
     if (targetLatestPrice === undefined) {
-        logger.info(`${priceConfig.alias} (${priceId}) is not available on the target network. Pushing the price.`);
+        logger.debug(`${priceConfig.alias} (${priceId}) is not available on the target network. Pushing the price.`);
         return 0;
     }
     // The current price is not newer than the price onchain

package/dist/pyth-price-listener.cjs

@@ -64,7 +64,9 @@ class PythPriceListener {
             }
         };
         eventSource.onerror = async (error)=>{
-            console.error("Error receiving updates from Hermes:", error);
+            this.logger.error({
+                err: error
+            }, "Error receiving updates from Hermes");
             eventSource.close();
             await (0, _utils.sleep)(5000); // Wait a bit before trying to reconnect
             void this.startListening(); // Attempt to restart the listener

package/dist/solana/solana.cjs

@@ -38,7 +38,7 @@ class SolanaPriceListener extends _interface.ChainPriceListener {
         try {
             const blockTime = await this.pythSolanaReceiver.connection.getBlockTime(slot);
             if ((blockTime === null || blockTime < Date.now() / 1000 - HEALTH_CHECK_TIMEOUT_SECONDS) && blockTime !== null) {
-                this.logger.info(`Solana connection is behind by ${(Date.now() / 1000 - blockTime).toString()} seconds`);
+                this.logger.warn(`Solana connection is behind by ${(Date.now() / 1000 - blockTime).toString()} seconds`);
             }
         } catch (error) {
             this.logger.error({
@@ -115,7 +115,7 @@ class SolanaPricePusher {
         });
         try {
             const signatures = await (0, _solanautils.sendTransactions)(transactions, this.pythSolanaReceiver.connection, this.pythSolanaReceiver.wallet);
-            this.logger.info({
+            this.logger.debug({
                 signatures
             }, "updatePriceFeed successful");
         } catch (error) {
@@ -153,7 +153,7 @@ class SolanaPricePusherJito {
         try {
             const response = await fetch("https://bundles.jito.wtf/api/v1/bundles/tip_floor");
             if (!response.ok) {
-                this.logger.error({
+                this.logger.warn({
                     status: response.status,
                     statusText: response.statusText
                 }, "getRecentJitoTips http request failed");
@@ -164,7 +164,7 @@ class SolanaPricePusherJito {
             return Math.floor(Number(data[0].landed_tips_50th_percentile) * _web3.LAMPORTS_PER_SOL);
         } catch (error) {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            this.logger.error({
+            this.logger.warn({
                 err: error
             }, "getRecentJitoTips failed");
             return undefined;
@@ -174,7 +174,7 @@ class SolanaPricePusherJito {
         const recentJitoTip = await this.getRecentJitoTipLamports();
         const jitoTip = this.dynamicJitoTips && recentJitoTip !== undefined ? Math.max(this.defaultJitoTipLamports, recentJitoTip) : this.defaultJitoTipLamports;
         const cappedJitoTip = Math.min(jitoTip, this.maxJitoTipLamports);
-        this.logger.info({
+        this.logger.debug({
             cappedJitoTip
         }, "using jito tip of");
         let priceFeedUpdateData;

package/dist/sui/balance-tracker.cjs

@@ -32,11 +32,11 @@ class SuiBalanceTracker extends _interface.BaseBalanceTracker {
    * Sui-specific implementation of balance update
    */ async updateBalance() {
         try {
-            const balance = await this.client.getBalance({
+            const { balance } = await this.client.core.getBalance({
                 owner: this.address
             });
             // Convert to a normalized number for reporting (SUI has 9 decimals)
-            const normalizedBalance = Number(balance.totalBalance) / 1e9;
+            const normalizedBalance = Number(balance.balance) / 1e9;
             this.metrics.updateWalletBalance(this.address, this.network, normalizedBalance);
             this.logger.debug(`Updated Sui wallet balance: ${this.address} = ${normalizedBalance.toString()} SUI`);
         } catch (error) {

package/dist/sui/balance-tracker.d.ts

@@ -1,4 +1,4 @@
-import type { SuiClient } from "@mysten/sui/client";
+import type { ClientWithCoreApi } from "@mysten/sui/client";
 import type { Logger } from "pino";
 import type { BaseBalanceTrackerConfig, IBalanceTracker } from "../interface.js";
 import { BaseBalanceTracker } from "../interface.js";
@@ -8,8 +8,8 @@ import type { DurationInSeconds } from "../utils.js";
  * Sui-specific configuration for balance tracker
  */
 export type SuiBalanceTrackerConfig = {
-    /** Sui client instance */
-    client: SuiClient;
+    /** Sui client instance (JSON-RPC or gRPC) */
+    client: ClientWithCoreApi;
 } & BaseBalanceTrackerConfig;
 /**
  * Sui-specific implementation of the balance tracker
@@ -26,7 +26,7 @@ export declare class SuiBalanceTracker extends BaseBalanceTracker {
  * Parameters for creating a Sui balance tracker
  */
 export type CreateSuiBalanceTrackerParams = {
-    client: SuiClient;
+    client: ClientWithCoreApi;
     address: string;
     network: string;
     updateInterval: DurationInSeconds;

package/dist/sui/command.cjs

@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */ /* eslint-disable @typescript-eslint/restrict-template-expressions */ /* eslint-disable @typescript-eslint/no-unsafe-argument */ /* eslint-disable @typescript-eslint/no-unsafe-assignment */ /* eslint-disable @typescript-eslint/no-explicit-any */ "use strict";
+/* biome-ignore-all lint/style/noNonNullAssertion: pre-existing; metrics wiring asserts on optional config */ /* biome-ignore-all lint/suspicious/noExplicitAny: pre-existing; yargs argv is untyped */ "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
@@ -9,7 +9,6 @@ Object.defineProperty(exports, "default", {
     }
 });
 const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
-const _client = require("@mysten/sui/client");
 const _ed25519 = require("@mysten/sui/keypairs/ed25519");
 const _hermesclient = require("@pythnetwork/hermes-client");
 const _pino = /*#__PURE__*/ _interop_require_default(require("pino"));
@@ -76,22 +75,49 @@ const _default = {
             type: "number"
         },
         endpoint: {
-            description: "RPC endpoint URL for sui. The pusher will periodically" + "poll for updates. The polling interval is configurable via the " + "`polling-frequency` command-line argument.",
+            description: "RPC endpoint URL for sui. The pusher will periodically" + "poll for updates. The polling interval is configurable via the " + "`polling-frequency` command-line argument. For `--endpoint-type grpc` " + "this is the gRPC-web base URL.",
             required: true,
             type: "string"
         },
+        "endpoint-type": {
+            choices: [
+                "json-rpc",
+                "grpc"
+            ],
+            default: "json-rpc",
+            description: "Transport to use for the Sui RPC endpoint. Sui Foundation is deprecating " + "JSON-RPC (public endpoints off July 2026, removed by mid-Oct 2026); use " + "`grpc` to migrate. `grpc` relies on @mysten/sui's experimental SuiGrpcClient.",
+            required: false,
+            type: "string"
+        },
         "gas-budget": {
             default: 500_000_000,
             description: "Gas budget for each price update",
             required: true,
             type: "number"
         },
+        "grpc-metadata": {
+            default: [],
+            description: "Metadata header(s) sent with every gRPC request, formatted as " + "`key=value`. Repeat for multiple headers. Use this to authenticate " + "native-gRPC providers: `x-token=<secret>` for QuikNode/Ankr, " + "`x-api-key=<secret>` for BlockVision. Only used with `--endpoint-type grpc`.",
+            required: false,
+            type: "array"
+        },
         "ignore-gas-objects": {
             default: [],
             description: "Gas objects to ignore when merging gas objects on startup -- use this for locked objects.",
             required: false,
             type: "array"
         },
+        network: {
+            choices: [
+                "mainnet",
+                "testnet",
+                "devnet",
+                "localnet"
+            ],
+            description: "Sui network label for the RPC client. This selects the network the " + "endpoint serves; it does not change which `--endpoint` URL is used.",
+            required: true,
+            type: "string"
+        },
         "num-gas-objects": {
             default: 30,
             description: "Number of gas objects in the pool.",
@@ -122,10 +148,20 @@ const _default = {
     command: "sui",
     describe: "Run price pusher for sui. Most of the arguments below are" + "network specific, so there's one set of values for mainnet and" + " another for testnet. See config.sui.mainnet.sample.json for the " + "appropriate values for your network. ",
     handler: async function(argv) {
-        const { endpoint, priceConfigFile, priceServiceEndpoint, hermesAccessToken, mnemonicFile, pushingFrequency, pollingFrequency, pythStateId, wormholeStateId, numGasObjects, ignoreGasObjects, gasBudget, accountIndex, logLevel, controllerLogLevel, enableMetrics, metricsPort } = argv;
+        const { endpoint, endpointType, network, priceConfigFile, priceServiceEndpoint, hermesAccessToken, mnemonicFile, pushingFrequency, pollingFrequency, pythStateId, wormholeStateId, numGasObjects, ignoreGasObjects, gasBudget, accountIndex, grpcMetadata: grpcMetadataArgs, logLevel, controllerLogLevel, enableMetrics, metricsPort } = argv;
         const logger = (0, _pino.default)({
             level: logLevel
         });
+        // Parse `--grpc-metadata key=value` pairs into the metadata map forwarded
+        // to the gRPC transport (e.g. the `x-token` auth header).
+        const grpcMetadata = {};
+        for (const entry of grpcMetadataArgs){
+            const eq = entry.indexOf("=");
+            if (eq === -1) {
+                throw new Error(`Invalid --grpc-metadata "${entry}": expected key=value`);
+            }
+            grpcMetadata[entry.slice(0, eq)] = entry.slice(eq + 1);
+        }
         const priceConfigs = (0, _priceconfig.readPriceConfigFile)(priceConfigFile);
         const hermesClient = new _hermesclient.HermesClient(priceServiceEndpoint, {
             accessToken: hermesAccessToken
@@ -156,17 +192,15 @@ const _default = {
         const pythListener = new _pythpricelistener.PythPriceListener(hermesClient, priceItems, logger.child({
             module: "PythPriceListener"
         }));
-        const suiClient = new _client.SuiClient({
-            url: endpoint
-        });
-        const suiListener = new _sui.SuiPriceListener(pythStateId, wormholeStateId, endpoint, priceItems, logger.child({
+        const suiClient = (0, _sui.createSuiProvider)(endpointType, network, endpoint, grpcMetadata);
+        const suiListener = new _sui.SuiPriceListener(pythStateId, wormholeStateId, endpoint, endpointType, network, priceItems, logger.child({
             module: "SuiPriceListener"
         }), {
             pollingFrequency
-        });
+        }, grpcMetadata);
         const suiPusher = await _sui.SuiPricePusher.createWithAutomaticGasPool(hermesClient, logger.child({
             module: "SuiPricePusher"
-        }), pythStateId, wormholeStateId, endpoint, keypair, gasBudget, numGasObjects, ignoreGasObjects);
+        }), pythStateId, wormholeStateId, endpoint, endpointType, network, keypair, gasBudget, numGasObjects, ignoreGasObjects, grpcMetadata);
         const controller = new _controller.Controller(priceConfigs, pythListener, suiListener, suiPusher, logger.child({
             module: "Controller"
         }, {

package/dist/sui/command.d.ts

@@ -13,8 +13,11 @@ declare const _default: {
         "price-config-file": Options;
         "account-index": Options;
         endpoint: Options;
+        "endpoint-type": Options;
         "gas-budget": Options;
+        "grpc-metadata": Options;
         "ignore-gas-objects": Options;
+        network: Options;
         "num-gas-objects": Options;
         "pyth-state-id": Options;
         "wormhole-state-id": Options;