@pythnetwork/price-pusher 10.3.1 → 11.3.0

package/dist/sui/sui.cjs

@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */ /* eslint-disable @typescript-eslint/no-unsafe-argument */ /* eslint-disable @typescript-eslint/no-explicit-any */ /* eslint-disable @typescript-eslint/no-unsafe-return */ /* eslint-disable @typescript-eslint/restrict-template-expressions */ /* eslint-disable @typescript-eslint/no-unsafe-member-access */ /* eslint-disable @typescript-eslint/no-unsafe-assignment */ "use strict";
+/* biome-ignore-all lint/style/noNonNullAssertion: pre-existing; gas-pool code asserts on Sui RPC results */ /* biome-ignore-all lint/suspicious/noExplicitAny: pre-existing; untyped Sui RPC error/result shapes */ /* biome-ignore-all lint/complexity/noForEach: pre-existing */ /* biome-ignore-all lint/suspicious/useAwait: pre-existing */ "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
@@ -14,25 +14,91 @@ _export(exports, {
     },
     get SuiPricePusher () {
         return SuiPricePusher;
+    },
+    get createSuiProvider () {
+        return createSuiProvider;
     }
 });
-const _client = require("@mysten/sui/client");
+const _grpcjs = require("@grpc/grpc-js");
+const _grpc = require("@mysten/sui/grpc");
+const _jsonRpc = require("@mysten/sui/jsonRpc");
 const _transactions = require("@mysten/sui/transactions");
+const _grpctransport = require("@protobuf-ts/grpc-transport");
 const _pythsuijs = require("@pythnetwork/pyth-sui-js");
 const _interface = require("../interface.cjs");
 const GAS_FEE_FOR_SPLIT = 2_000_000_000;
 // TODO: read this from on chain config
 const MAX_NUM_GAS_OBJECTS_IN_PTB = 256;
 const MAX_NUM_OBJECTS_IN_ARGUMENT = 510;
+/**
+ * Turn a gRPC endpoint into a `@grpc/grpc-js` `host:port` plus channel
+ * credentials. Third-party Sui gRPC endpoints (QuikNode `:9000`, Ankr /
+ * BlockVision `:443`) serve **native gRPC over HTTP/2**, so the host must be
+ * a bare `host:port` with no scheme or path. A `http://` prefix selects an
+ * insecure channel (local devnet); anything else uses TLS.
+ */ function parseGrpcEndpoint(url) {
+    let host = url.trim();
+    let insecure = false;
+    if (host.startsWith("https://")) {
+        host = host.slice("https://".length);
+    } else if (host.startsWith("http://")) {
+        host = host.slice("http://".length);
+        insecure = true;
+    }
+    // Drop any path/token segment — native gRPC authenticates via metadata, not URL.
+    host = host.replace(/\/.*$/, "");
+    return {
+        credentials: insecure ? _grpcjs.ChannelCredentials.createInsecure() : _grpcjs.ChannelCredentials.createSsl(),
+        host
+    };
+}
+function createSuiProvider(endpointType, network, url, grpcMetadata) {
+    switch(endpointType){
+        case "grpc":
+            {
+                const { host, credentials } = parseGrpcEndpoint(url);
+                const transport = new _grpctransport.GrpcTransport({
+                    channelCredentials: credentials,
+                    host,
+                    ...grpcMetadata && {
+                        meta: grpcMetadata
+                    }
+                });
+                return new _grpc.SuiGrpcClient({
+                    network,
+                    transport
+                });
+            }
+        case "json-rpc":
+            {
+                return new _jsonRpc.SuiJsonRpcClient({
+                    network,
+                    url
+                });
+            }
+        default:
+            {
+                throw new Error(`Unknown Sui endpoint type: ${endpointType}`);
+            }
+    }
+}
+/** Unwrap the executed transaction from the `.core` execution result union. */ function getExecutedTransaction(result) {
+    return result.$kind === "Transaction" ? result.Transaction : result.FailedTransaction;
+}
+/** Build an owned-object reference from a `.core` effects changed object. */ function changedObjectToRef(obj) {
+    return {
+        digest: obj.outputDigest,
+        objectId: obj.objectId,
+        version: obj.outputVersion
+    };
+}
 class SuiPriceListener extends _interface.ChainPriceListener {
     pythClient;
     provider;
     logger;
-    constructor(pythStateId, wormholeStateId, endpoint, priceItems, logger, config){
+    constructor(pythStateId, wormholeStateId, endpoint, endpointType, network, priceItems, logger, config, grpcMetadata){
         super(config.pollingFrequency, priceItems);
-        this.provider = new _client.SuiClient({
-            url: endpoint
-        });
+        this.provider = createSuiProvider(endpointType, network, endpoint, grpcMetadata);
         this.pythClient = new _pythsuijs.SuiPythClient(this.provider, pythStateId, wormholeStateId);
         this.logger = logger;
     }
@@ -43,24 +109,23 @@ class SuiPriceListener extends _interface.ChainPriceListener {
                 throw new Error("Price not found on chain for price id " + priceId);
             }
             // Fetching the price info object for the above priceInfoObjectId
-            const priceInfoObject = await this.provider.getObject({
-                id: priceInfoObjectId,
-                options: {
-                    showContent: true
-                }
+            const { object } = await this.provider.core.getObject({
+                include: {
+                    json: true
+                },
+                objectId: priceInfoObjectId
             });
-            if (!priceInfoObject.data?.content) throw new Error("Price not found on chain for price id " + priceId);
-            if (priceInfoObject.data.content.dataType !== "moveObject") throw new Error("fetched object datatype should be moveObject");
-            const priceInfo = // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore
-            priceInfoObject.data.content.fields.price_info.fields.price_feed.fields.price.fields;
-            const { magnitude, negative } = priceInfo.price.fields;
-            const conf = priceInfo.conf;
-            const timestamp = priceInfo.timestamp;
+            if (!object.json) throw new Error("Price not found on chain for price id " + priceId);
+            // PriceInfoObject -> price_info -> price_feed -> price (the `Price` struct,
+            // holding the signed `price` magnitude, `conf`, and `timestamp`).
+            const priceFields = (0, _pythsuijs.getStructFields)((0, _pythsuijs.getStructFields)((0, _pythsuijs.getStructFields)(object.json.price_info).price_feed).price);
+            const magnitudeFields = (0, _pythsuijs.getStructFields)(priceFields.price);
+            const magnitude = magnitudeFields.magnitude;
+            const negative = magnitudeFields.negative;
             return {
+                conf: priceFields.conf,
                 price: negative ? `-${magnitude}` : magnitude,
-                conf,
-                publishTime: Number(timestamp)
+                publishTime: Number(priceFields.timestamp)
             };
         } catch (error) {
             this.logger.error(error, `Polling Sui on-chain price for ${priceId} failed.`);
@@ -86,38 +151,13 @@ class SuiPricePusher {
         this.pythClient = pythClient;
     }
     /**
-   * getPackageId returns the latest package id that the object belongs to. Use this to
-   * fetch the latest package id for a given object id and handle package upgrades automatically.
-   * @returns package id
-   */ static async getPackageId(provider, objectId) {
-        const state = await provider.getObject({
-            id: objectId,
-            options: {
-                showContent: true
-            }
-        }).then((result)=>{
-            if (result.data?.content?.dataType == "moveObject") {
-                return result.data.content.fields;
-            }
-            throw new Error("not move object");
-        });
-        if ("upgrade_cap" in state) {
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore
-            return state.upgrade_cap.fields.package;
-        }
-        throw new Error("upgrade_cap not found");
-    }
-    /**
    * Create a price pusher with a pool of `numGasObjects` gas coins that will be used to send transactions.
    * The gas coins of the wallet for the provided keypair will be merged and then evenly split into `numGasObjects`.
-   */ static async createWithAutomaticGasPool(hermesClient, logger, pythStateId, wormholeStateId, endpoint, keypair, gasBudget, numGasObjects, ignoreGasObjects) {
+   */ static async createWithAutomaticGasPool(hermesClient, logger, pythStateId, wormholeStateId, endpoint, endpointType, network, keypair, gasBudget, numGasObjects, ignoreGasObjects, grpcMetadata) {
         if (numGasObjects > MAX_NUM_OBJECTS_IN_ARGUMENT) {
             throw new Error(`numGasObjects cannot be greater than ${MAX_NUM_OBJECTS_IN_ARGUMENT} until we implement split chunking`);
         }
-        const provider = new _client.SuiClient({
-            url: endpoint
-        });
+        const provider = createSuiProvider(endpointType, network, endpoint, grpcMetadata);
         const gasPool = await SuiPricePusher.initializeGasPool(keypair, provider, numGasObjects, ignoreGasObjects, logger);
         const pythClient = new _pythsuijs.SuiPythClient(provider, pythStateId, wormholeStateId);
         return new SuiPricePusher(keypair, provider, logger, hermesClient, gasBudget, gasPool, pythClient);
@@ -166,16 +206,27 @@ class SuiPricePusher {
                 gasObject
             ]);
             tx.setGasBudget(this.gasBudget);
-            const result = await this.provider.signAndExecuteTransaction({
+            const result = await this.provider.core.signAndExecuteTransaction({
+                include: {
+                    effects: true
+                },
                 signer: this.signer,
-                transaction: tx,
-                options: {
-                    showEffects: true
-                }
+                transaction: tx
             });
-            nextGasObject = result.effects?.mutated?.map((obj)=>obj.reference).find((ref)=>ref.objectId === gasObject.objectId);
+            const executed = getExecutedTransaction(result);
+            // The `.core` API returns a `FailedTransaction` for on-chain execution
+            // failures rather than throwing, so check the status explicitly — otherwise
+            // a failed push would emit the success log below and silently miss updates.
+            if (executed.effects.status.error) {
+                throw new Error(`Transaction ${executed.digest} failed on-chain: ${JSON.stringify(executed.effects.status.error)}`);
+            }
+            const gasObjectChange = executed.effects.gasObject;
+            nextGasObject = gasObjectChange && gasObjectChange.objectId === gasObject.objectId ? changedObjectToRef(gasObjectChange) : undefined;
+            // Keep at INFO: the bundled Grafana "Tx Hash" panel scrapes this message
+            // from Loki and extracts {{.hash}}; debug is not emitted under the default
+            // log level, which would hide successful Sui hashes from the dashboard.
             this.logger.info({
-                hash: result.digest
+                hash: executed.digest
             }, "Successfully updated price with transaction digest");
         } catch (error) {
             if (String(error).includes("Balance of gas object") || String(error).includes("GasBalanceTooLow")) {
@@ -204,18 +255,14 @@ class SuiPricePusher {
             }, "Ignoring some gas objects for coin merging");
         }
         const consolidatedCoin = await SuiPricePusher.mergeGasCoinsIntoOne(signer, provider, signerAddress, ignoreGasObjects, logger);
-        const coinResult = await provider.getObject({
-            id: consolidatedCoin.objectId,
-            options: {
-                showContent: true
-            }
+        const { object } = await provider.core.getObject({
+            include: {
+                json: true
+            },
+            objectId: consolidatedCoin.objectId
         });
-        let balance;
-        if (coinResult.data?.content && coinResult.data.content.dataType == "moveObject") {
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore
-            balance = coinResult.data.content.fields.balance;
-        } else throw new Error("Bad coin object");
+        if (!object.json) throw new Error("Bad coin object");
+        const balance = object.json.balance;
         const splitAmount = (BigInt(balance) - BigInt(GAS_FEE_FOR_SPLIT)) / BigInt(numGasObjects);
         const gasPool = await SuiPricePusher.splitGasCoinEqually(signer, provider, signerAddress, Number(splitAmount), numGasObjects, consolidatedCoin);
         logger.info({
@@ -226,40 +273,36 @@ class SuiPricePusher {
     // Attempt to refresh the version of the provided object reference to point to the current version
     // of the object. Throws an error if the object cannot be refreshed.
     static async tryRefreshObjectReference(provider, ref) {
-        const objectResponse = await provider.getObject({
-            id: ref.objectId
+        const { object } = await provider.core.getObject({
+            objectId: ref.objectId
         });
-        if (objectResponse.data === undefined) {
-            throw new Error("Failed to refresh object reference");
-        } else {
-            return {
-                digest: objectResponse.data.digest,
-                objectId: objectResponse.data.objectId,
-                version: objectResponse.data.version
-            };
-        }
+        return {
+            digest: object.digest,
+            objectId: object.objectId,
+            version: object.version
+        };
     }
     static async getAllGasCoins(provider, owner) {
         let hasNextPage = true;
-        let cursor;
+        let cursor = null;
         const coins = new Set([]);
         let numCoins = 0;
         while(hasNextPage){
-            const paginatedCoins = await provider.getCoins({
-                owner,
-                cursor
+            const paginatedCoins = await provider.core.listCoins({
+                cursor,
+                owner
             });
-            numCoins += paginatedCoins.data.length;
-            for (const c of paginatedCoins.data)coins.add(JSON.stringify({
-                objectId: c.coinObjectId,
-                version: c.version,
-                digest: c.digest
+            numCoins += paginatedCoins.objects.length;
+            for (const c of paginatedCoins.objects)coins.add(JSON.stringify({
+                digest: c.digest,
+                objectId: c.objectId,
+                version: c.version
             }));
             hasNextPage = paginatedCoins.hasNextPage;
-            cursor = paginatedCoins.nextCursor;
+            cursor = paginatedCoins.cursor;
         }
         if (numCoins !== coins.size) {
-            throw new Error("Unexpected getCoins result: duplicate coins found");
+            throw new Error("Unexpected listCoins result: duplicate coins found");
         }
         return [
             ...coins
@@ -277,18 +320,18 @@ class SuiPricePusher {
         tx.setGasPayment([
             gasCoin
         ]);
-        const result = await provider.signAndExecuteTransaction({
+        const result = await provider.core.signAndExecuteTransaction({
+            include: {
+                effects: true
+            },
             signer,
-            transaction: tx,
-            options: {
-                showEffects: true
-            }
+            transaction: tx
         });
-        const error = result.effects?.status.error;
-        if (error) {
-            throw new Error(`Failed to initialize gas pool: ${error}. Try re-running the script`);
+        const effects = getExecutedTransaction(result).effects;
+        if (effects.status.error) {
+            throw new Error(`Failed to initialize gas pool: ${JSON.stringify(effects.status.error)}. Try re-running the script`);
         }
-        const newCoins = result.effects.created.map((obj)=>obj.reference);
+        const newCoins = effects.changedObjects.filter((obj)=>obj.idOperation === "Created").map(changedObjectToRef);
         if (newCoins.length !== numGasObjects) {
             throw new Error(`Failed to initialize gas pool. Expected ${numGasObjects}, got: ${JSON.stringify(newCoins)}`);
         }
@@ -317,12 +360,12 @@ class SuiPricePusher {
             mergeTx.setGasPayment(coins);
             let mergeResult;
             try {
-                mergeResult = await provider.signAndExecuteTransaction({
+                mergeResult = await provider.core.signAndExecuteTransaction({
+                    include: {
+                        effects: true
+                    },
                     signer,
-                    transaction: mergeTx,
-                    options: {
-                        showEffects: true
-                    }
+                    transaction: mergeTx
                 });
             } catch (error_) {
                 logger.error(error_, "Merge transaction failed with error");
@@ -340,11 +383,21 @@ class SuiPricePusher {
                 }
                 throw error_;
             }
-            const error = mergeResult.effects?.status.error;
-            if (error) {
-                throw new Error(`Failed to merge coins when initializing gas pool: ${error}. Try re-running the script`);
+            const executed = getExecutedTransaction(mergeResult);
+            const effects = executed.effects;
+            if (effects.status.error) {
+                throw new Error(`Failed to merge coins when initializing gas pool: ${JSON.stringify(effects.status.error)}. Try re-running the script`);
             }
-            finalCoin = mergeResult.effects.mutated.map((obj)=>obj.reference)[0];
+            finalCoin = changedObjectToRef(effects.gasObject);
+            // Block until this merge is observable before the next transaction spends
+            // its output (the next chunk's gas, or the subsequent split). gRPC
+            // endpoints are load-balanced across fullnodes at different checkpoints,
+            // so without this the follow-up tx can be simulated against a backend
+            // that has not yet applied this merge and fail with a version conflict.
+            // The legacy JSON-RPC path got this for free via WaitForLocalExecution.
+            await provider.core.waitForTransaction({
+                digest: executed.digest
+            });
         }
         // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
         return finalCoin;

package/dist/sui/sui.d.ts

@@ -1,20 +1,43 @@
-import type { SuiObjectRef } from "@mysten/sui/client";
-import { SuiClient } from "@mysten/sui/client";
-import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
-import { HermesClient } from "@pythnetwork/hermes-client";
+import type { ClientWithCoreApi } from "@mysten/sui/client";
+import type { SuiObjectRef } from "@mysten/sui/jsonRpc";
+import type { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
+import type { HermesClient } from "@pythnetwork/hermes-client";
 import { SuiPythClient } from "@pythnetwork/pyth-sui-js";
 import type { Logger } from "pino";
 import type { IPricePusher, PriceInfo, PriceItem } from "../interface.js";
 import { ChainPriceListener } from "../interface.js";
 import type { DurationInSeconds } from "../utils.js";
 type ObjectId = string;
+/**
+ * Sui transport selector. `json-rpc` is the legacy default; `grpc` migrates to
+ * the transport Sui Foundation is replacing JSON-RPC with (public JSON-RPC
+ * endpoints are turned off in July 2026, removed entirely by mid-Oct 2026).
+ */
+export type SuiEndpointType = "json-rpc" | "grpc";
+/** Sui network label passed to the `@mysten/sui` v2 clients. */
+export type SuiNetwork = "mainnet" | "testnet" | "devnet" | "localnet";
+/** gRPC request metadata (e.g. `{ "x-token": "<secret>" }`) sent on every call. */
+export type SuiGrpcMetadata = Record<string, string>;
+/**
+ * Both the `@mysten/sui` v2 JSON-RPC client (`SuiJsonRpcClient`) and the
+ * experimental gRPC client (`SuiGrpcClient`) expose the unified `.core` API.
+ * The pusher reads and writes exclusively through `.core` so the same driver
+ * works over either transport.
+ *
+ * `SuiGrpcClient` defaults to a grpc-web (HTTP/1.1) transport, which the Sui
+ * providers' native-gRPC (HTTP/2) endpoints reject; it also drops the `meta`
+ * option on that default path, so credentials never reach the wire. We
+ * therefore build an explicit `@protobuf-ts/grpc-transport` (native gRPC over
+ * `@grpc/grpc-js`) and pass the auth header through its `meta`.
+ */
+export declare function createSuiProvider(endpointType: SuiEndpointType, network: SuiNetwork, url: string, grpcMetadata?: SuiGrpcMetadata): ClientWithCoreApi;
 export declare class SuiPriceListener extends ChainPriceListener {
     private pythClient;
     private provider;
     private logger;
-    constructor(pythStateId: ObjectId, wormholeStateId: ObjectId, endpoint: string, priceItems: PriceItem[], logger: Logger, config: {
+    constructor(pythStateId: ObjectId, wormholeStateId: ObjectId, endpoint: string, endpointType: SuiEndpointType, network: SuiNetwork, priceItems: PriceItem[], logger: Logger, config: {
         pollingFrequency: DurationInSeconds;
-    });
+    }, grpcMetadata?: SuiGrpcMetadata);
     getOnChainPriceInfo(priceId: string): Promise<PriceInfo | undefined>;
 }
 /**
@@ -39,18 +62,12 @@ export declare class SuiPricePusher implements IPricePusher {
     private gasBudget;
     private gasPool;
     private pythClient;
-    constructor(signer: Ed25519Keypair, provider: SuiClient, logger: Logger, hermesClient: HermesClient, gasBudget: number, gasPool: SuiObjectRef[], pythClient: SuiPythClient);
-    /**
-     * getPackageId returns the latest package id that the object belongs to. Use this to
-     * fetch the latest package id for a given object id and handle package upgrades automatically.
-     * @returns package id
-     */
-    static getPackageId(provider: SuiClient, objectId: ObjectId): Promise<ObjectId>;
+    constructor(signer: Ed25519Keypair, provider: ClientWithCoreApi, logger: Logger, hermesClient: HermesClient, gasBudget: number, gasPool: SuiObjectRef[], pythClient: SuiPythClient);
     /**
      * Create a price pusher with a pool of `numGasObjects` gas coins that will be used to send transactions.
      * The gas coins of the wallet for the provided keypair will be merged and then evenly split into `numGasObjects`.
      */
-    static createWithAutomaticGasPool(hermesClient: HermesClient, logger: Logger, pythStateId: string, wormholeStateId: string, endpoint: string, keypair: Ed25519Keypair, gasBudget: number, numGasObjects: number, ignoreGasObjects: string[]): Promise<SuiPricePusher>;
+    static createWithAutomaticGasPool(hermesClient: HermesClient, logger: Logger, pythStateId: string, wormholeStateId: string, endpoint: string, endpointType: SuiEndpointType, network: SuiNetwork, keypair: Ed25519Keypair, gasBudget: number, numGasObjects: number, ignoreGasObjects: string[], grpcMetadata?: SuiGrpcMetadata): Promise<SuiPricePusher>;
     updatePriceFeed(priceIds: string[], pubTimesToPush: number[]): Promise<void>;
     /** Send every transaction in txs in parallel, returning when all transactions have completed. */
     private sendTransactionBlocks;

package/dist/ton/command.cjs

@@ -12,12 +12,12 @@ const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
 const _hermesclient = require("@pythnetwork/hermes-client");
 const _ton = require("@ton/ton");
 const _pino = 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 _ton1 = require("./ton.cjs");
-const _controller = require("../controller.cjs");
 const _utils = require("../utils.cjs");
+const _ton1 = require("./ton.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: "ton",
-    describe: "run price pusher for TON",
     builder: {
         endpoint: {
             description: "TON 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 TON",
-            type: "string",
-            required: true
+            required: true,
+            type: "string"
         },
         ..._options.priceConfigFile,
         ..._options.priceServiceEndpoint,
+        ..._options.hermesAccessToken,
         ..._options.pushingFrequency,
         ..._options.pollingFrequency,
         ..._options.logLevel,
         ..._options.controllerLogLevel
     },
+    command: "ton",
+    describe: "run price pusher for TON",
     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.pino)({
             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);

package/dist/ton/command.d.ts

@@ -1,18 +1,19 @@
 import type { Options } from "yargs";
 declare const _default: {
-    command: string;
-    describe: string;
     builder: {
         "controller-log-level": Options;
         "log-level": Options;
         "polling-frequency": Options;
         "pushing-frequency": Options;
+        "hermes-access-token": Options;
         "price-service-endpoint": Options;
         "price-config-file": Options;
         endpoint: Options;
         "private-key-file": Options;
         "pyth-contract-address": Options;
     };
+    command: string;
+    describe: string;
     handler: (argv: any) => Promise<void>;
 };
 export default _default;

package/dist/ton/ton.d.ts

@@ -1,6 +1,5 @@
-import { HermesClient } from "@pythnetwork/hermes-client";
-import type { ContractProvider } from "@ton/ton";
-import { Address, TonClient } from "@ton/ton";
+import type { HermesClient } from "@pythnetwork/hermes-client";
+import type { Address, ContractProvider, TonClient } from "@ton/ton";
 import type { Logger } from "pino";
 import type { IPricePusher, PriceInfo, PriceItem } from "../interface.js";
 import { ChainPriceListener } from "../interface.js";

package/dist/utils.d.ts

@@ -1,5 +1,4 @@
-import type { HexString } from "@pythnetwork/hermes-client";
-import { HermesClient } from "@pythnetwork/hermes-client";
+import type { HermesClient, HexString } from "@pythnetwork/hermes-client";
 import type { PriceItem } from "./interface.js";
 export type PctNumber = number;
 export type DurationInSeconds = number;