@pythnetwork/price-pusher 10.2.0 → 10.3.1

package/dist/solana/command.cjs

@@ -0,0 +1,259 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */ /* eslint-disable @typescript-eslint/no-unsafe-member-access */ /* eslint-disable @typescript-eslint/no-unsafe-call */ /* 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";
+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 default () {
+        return _default;
+    },
+    get onBundleResult () {
+        return onBundleResult;
+    }
+});
+const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
+const _nodewallet = /*#__PURE__*/ _interop_require_default(require("@coral-xyz/anchor/dist/cjs/nodewallet.js"));
+const _hermesclient = require("@pythnetwork/hermes-client");
+const _pythsolanareceiver = require("@pythnetwork/pyth-solana-receiver");
+const _web3 = require("@solana/web3.js");
+const _searcher = require("jito-ts/dist/sdk/block-engine/searcher");
+const _pino = require("pino");
+const _options = /*#__PURE__*/ _interop_require_wildcard(require("../options.cjs"));
+const _priceconfig = require("../price-config.cjs");
+const _pythpricelistener = require("../pyth-price-listener.cjs");
+const _solana = require("./solana.cjs");
+const _controller = require("../controller.cjs");
+const _metrics = require("../metrics.cjs");
+const _utils = require("../utils.cjs");
+const _balancetracker = require("./balance-tracker.cjs");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const _default = {
+    command: "solana",
+    describe: "run price pusher for solana",
+    builder: {
+        endpoint: {
+            description: "Solana RPC API endpoint",
+            type: "string",
+            required: true
+        },
+        "keypair-file": {
+            description: "Path to a keypair file",
+            type: "string",
+            required: true
+        },
+        "shard-id": {
+            description: "Shard ID",
+            type: "number",
+            required: true
+        },
+        "compute-unit-price-micro-lamports": {
+            description: "Priority fee per compute unit",
+            type: "number",
+            default: 50_000
+        },
+        "jito-endpoints": {
+            description: "Jito endpoint(s) - comma-separated list of endpoints",
+            type: "string",
+            optional: true
+        },
+        "jito-keypair-file": {
+            description: "Path to the jito keypair file (need for grpc authentication)",
+            type: "string",
+            optional: true
+        },
+        "jito-tip-lamports": {
+            description: "Lamports to tip the jito builder",
+            type: "number",
+            optional: true
+        },
+        "dynamic-jito-tips": {
+            description: "Use dynamic jito tips",
+            type: "boolean",
+            default: false
+        },
+        "max-jito-tip-lamports": {
+            description: "Maximum jito tip lamports",
+            type: "number",
+            default: _web3.LAMPORTS_PER_SOL / 100
+        },
+        "jito-bundle-size": {
+            description: "Number of transactions in each Jito bundle",
+            type: "number",
+            default: 5
+        },
+        "updates-per-jito-bundle": {
+            description: "Number of price updates in each Jito bundle",
+            type: "number",
+            default: 6
+        },
+        "address-lookup-table-account": {
+            description: "The pubkey of the ALT to use when updating price feeds",
+            type: "string",
+            optional: true
+        },
+        "treasury-id": {
+            description: "The treasuryId to use. Useful when the corresponding treasury account is indexed in the ALT passed to --address-lookup-table-account. This is a tx size optimization and is optional; if not set, a random treasury account will be used.",
+            type: "number",
+            optional: true
+        },
+        ..._options.priceConfigFile,
+        ..._options.priceServiceEndpoint,
+        ..._options.pythContractAddress,
+        ..._options.pollingFrequency,
+        ..._options.pushingFrequency,
+        ..._options.logLevel,
+        ..._options.controllerLogLevel,
+        ..._options.enableMetrics,
+        ..._options.metricsPort
+    },
+    handler: async function(argv) {
+        const { endpoint, keypairFile, shardId, computeUnitPriceMicroLamports, priceConfigFile, priceServiceEndpoint, pythContractAddress, pushingFrequency, pollingFrequency, jitoEndpoints, jitoKeypairFile, jitoTipLamports, dynamicJitoTips, maxJitoTipLamports, updatesPerJitoBundle, addressLookupTableAccount, treasuryId, logLevel, controllerLogLevel, enableMetrics, metricsPort } = argv;
+        const logger = (0, _pino.pino)({
+            level: logLevel
+        });
+        const priceConfigs = (0, _priceconfig.readPriceConfigFile)(priceConfigFile);
+        const hermesClient = new _hermesclient.HermesClient(priceServiceEndpoint);
+        // Initialize metrics if enabled
+        let metrics;
+        if (enableMetrics) {
+            metrics = new _metrics.PricePusherMetrics(logger.child({
+                module: "Metrics"
+            }));
+            metrics.start(metricsPort);
+            logger.info(`Metrics server started on port ${metricsPort}`);
+        }
+        let priceItems = priceConfigs.map(({ id, alias })=>({
+                id,
+                alias
+            }));
+        // Better to filter out invalid price items before creating the pyth listener
+        const { existingPriceItems, invalidPriceItems } = await (0, _utils.filterInvalidPriceItems)(hermesClient, priceItems);
+        if (invalidPriceItems.length > 0) {
+            logger.error(`Invalid price id submitted for: ${invalidPriceItems.map(({ alias })=>alias).join(", ")}`);
+        }
+        priceItems = existingPriceItems;
+        const pythListener = new _pythpricelistener.PythPriceListener(hermesClient, priceItems, logger.child({
+            module: "PythPriceListener"
+        }));
+        const keypair = _web3.Keypair.fromSecretKey(Uint8Array.from(JSON.parse(_nodefs.default.readFileSync(keypairFile, "ascii"))));
+        const wallet = new _nodewallet.default(keypair);
+        const connection = new _web3.Connection(endpoint, "processed");
+        const pythSolanaReceiver = new _pythsolanareceiver.PythSolanaReceiver({
+            connection,
+            wallet,
+            pushOracleProgramId: new _web3.PublicKey(pythContractAddress),
+            treasuryId: treasuryId
+        });
+        // Create and start the balance tracker if metrics are enabled
+        if (metrics) {
+            const balanceTracker = (0, _balancetracker.createSolanaBalanceTracker)({
+                connection,
+                publicKey: keypair.publicKey,
+                network: "solana",
+                updateInterval: 60,
+                metrics,
+                logger
+            });
+            // Start the balance tracker
+            await balanceTracker.start();
+        }
+        // Fetch the account lookup table if provided
+        const lookupTableAccount = addressLookupTableAccount ? await connection.getAddressLookupTable(new _web3.PublicKey(addressLookupTableAccount)).then((result)=>result.value ?? undefined) : undefined;
+        let solanaPricePusher;
+        if (jitoTipLamports) {
+            const jitoKeypair = _web3.Keypair.fromSecretKey(Uint8Array.from(JSON.parse(_nodefs.default.readFileSync(jitoKeypairFile, "ascii"))));
+            const jitoEndpointsList = jitoEndpoints.split(",").map((endpoint)=>endpoint.trim());
+            const jitoClients = jitoEndpointsList.map((endpoint)=>{
+                logger.info(`Constructing Jito searcher client from endpoint ${endpoint}`);
+                return (0, _searcher.searcherClient)(endpoint, jitoKeypair);
+            });
+            solanaPricePusher = new _solana.SolanaPricePusherJito(pythSolanaReceiver, hermesClient, logger.child({
+                module: "SolanaPricePusherJito"
+            }), shardId, jitoTipLamports, dynamicJitoTips, maxJitoTipLamports, jitoClients, updatesPerJitoBundle, // Set max retry time to pushing frequency, since we want to stop retrying before the next push attempt
+            pushingFrequency * 1000, lookupTableAccount);
+            for (const [index, client] of jitoClients.entries()){
+                onBundleResult(client, logger.child({
+                    module: `JitoClient-${index}`
+                }));
+            }
+        } else {
+            solanaPricePusher = new _solana.SolanaPricePusher(pythSolanaReceiver, hermesClient, logger.child({
+                module: "SolanaPricePusher"
+            }), shardId, computeUnitPriceMicroLamports, lookupTableAccount);
+        }
+        const solanaPriceListener = new _solana.SolanaPriceListener(pythSolanaReceiver, shardId, priceItems, logger.child({
+            module: "SolanaPriceListener"
+        }), {
+            pollingFrequency
+        });
+        const controller = new _controller.Controller(priceConfigs, pythListener, solanaPriceListener, solanaPricePusher, logger.child({
+            module: "Controller"
+        }, {
+            level: controllerLogLevel
+        }), {
+            pushingFrequency,
+            metrics: metrics
+        });
+        void controller.start();
+    }
+};
+const onBundleResult = (c, logger)=>{
+    try {
+        c.onBundleResult(// eslint-disable-next-line @typescript-eslint/no-empty-function
+        ()=>{}, (err)=>{
+            logger.error(err, "Error in bundle result");
+        });
+    } catch (error) {
+        logger.error(error, "Exception in bundle result");
+    }
+};

package/{lib → dist}/solana/command.d.ts

@@ -1,6 +1,6 @@
-import { Options } from "yargs";
 import { SearcherClient } from "jito-ts/dist/sdk/block-engine/searcher";
-import { Logger } from "pino";
+import type { Logger } from "pino";
+import type { Options } from "yargs";
 declare const _default: {
     command: string;
     describe: string;
@@ -32,4 +32,3 @@ declare const _default: {
 };
 export default _default;
 export declare const onBundleResult: (c: SearcherClient, logger: Logger) => void;
-//# sourceMappingURL=command.d.ts.map

package/{lib/solana/solana.js → dist/solana/solana.cjs}

@@ -1,20 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolanaPricePusherJito = exports.SolanaPricePusher = exports.SolanaPriceListener = void 0;
-const interface_1 = require("../interface");
-const solana_utils_1 = require("@pythnetwork/solana-utils");
-const price_service_sdk_1 = require("@pythnetwork/price-service-sdk");
-const web3_js_1 = require("@solana/web3.js");
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */ /* eslint-disable @typescript-eslint/no-explicit-any */ "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 SolanaPriceListener () {
+        return SolanaPriceListener;
+    },
+    get SolanaPricePusher () {
+        return SolanaPricePusher;
+    },
+    get SolanaPricePusherJito () {
+        return SolanaPricePusherJito;
+    }
+});
+const _priceservicesdk = require("@pythnetwork/price-service-sdk");
+const _solanautils = require("@pythnetwork/solana-utils");
+const _web3 = require("@solana/web3.js");
+const _interface = require("../interface.cjs");
 const HEALTH_CHECK_TIMEOUT_SECONDS = 60;
-class SolanaPriceListener extends interface_1.ChainPriceListener {
+class SolanaPriceListener extends _interface.ChainPriceListener {
     pythSolanaReceiver;
     shardId;
     logger;
-    constructor(pythSolanaReceiver, shardId, priceItems, logger, config) {
-        super(config.pollingFrequency, priceItems);
-        this.pythSolanaReceiver = pythSolanaReceiver;
-        this.shardId = shardId;
-        this.logger = logger;
+    constructor(pythSolanaReceiver, shardId, priceItems, logger, config){
+        super(config.pollingFrequency, priceItems), this.pythSolanaReceiver = pythSolanaReceiver, this.shardId = shardId, this.logger = logger;
     }
     // Checking the health of the Solana connection by checking the last block time
     // and ensuring it is not older than 30 seconds.
@@ -22,44 +37,38 @@ class SolanaPriceListener extends interface_1.ChainPriceListener {
         const slot = await this.pythSolanaReceiver.connection.getSlot("finalized");
         try {
             const blockTime = await this.pythSolanaReceiver.connection.getBlockTime(slot);
-            if (blockTime === null ||
-                blockTime < Date.now() / 1000 - HEALTH_CHECK_TIMEOUT_SECONDS) {
-                if (blockTime !== null) {
-                    this.logger.info(`Solana connection is behind by ${Date.now() / 1000 - blockTime} seconds`);
-                }
+            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`);
             }
-        }
-        catch (err) {
-            this.logger.error({ err }, "checkHealth failed");
+        } catch (error) {
+            this.logger.error({
+                err: error
+            }, "checkHealth failed");
         }
     }
     async start() {
         // Frequently check the RPC connection to ensure it is healthy
-        setInterval(this.checkHealth.bind(this), 5000);
+        setInterval(()=>void this.checkHealth(), 5000);
         await super.start();
     }
     async getOnChainPriceInfo(priceId) {
         try {
             const priceFeedAccount = await this.pythSolanaReceiver.fetchPriceFeedAccount(this.shardId, Buffer.from(priceId, "hex"));
-            this.logger.debug(`Polled a Solana on chain price for feed ${this.priceIdToAlias.get(priceId)} (${priceId}).`);
-            if (priceFeedAccount) {
-                return {
-                    conf: priceFeedAccount.priceMessage.conf.toString(),
-                    price: priceFeedAccount.priceMessage.price.toString(),
-                    publishTime: priceFeedAccount.priceMessage.publishTime.toNumber(),
-                };
-            }
-            else {
-                return undefined;
-            }
-        }
-        catch (err) {
-            this.logger.error({ err, priceId }, `Polling on-chain price failed.`);
+            this.logger.debug(`Polled a Solana on chain price for feed ${this.priceIdToAlias.get(priceId)?.toString() ?? ""} (${priceId}).`);
+            return priceFeedAccount ? {
+                conf: priceFeedAccount.priceMessage.conf.toString(),
+                price: priceFeedAccount.priceMessage.price.toString(),
+                publishTime: priceFeedAccount.priceMessage.publishTime.toNumber()
+            } : undefined;
+        } catch (error) {
+            this.logger.error({
+                err: error,
+                priceId
+            }, `Polling on-chain price failed.`);
             return undefined;
         }
     }
 }
-exports.SolanaPriceListener = SolanaPriceListener;
 class SolanaPricePusher {
     pythSolanaReceiver;
     hermesClient;
@@ -67,7 +76,7 @@ class SolanaPricePusher {
     shardId;
     computeUnitPriceMicroLamports;
     addressLookupTableAccount;
-    constructor(pythSolanaReceiver, hermesClient, logger, shardId, computeUnitPriceMicroLamports, addressLookupTableAccount) {
+    constructor(pythSolanaReceiver, hermesClient, logger, shardId, computeUnitPriceMicroLamports, addressLookupTableAccount){
         this.pythSolanaReceiver = pythSolanaReceiver;
         this.hermesClient = hermesClient;
         this.logger = logger;
@@ -79,43 +88,42 @@ class SolanaPricePusher {
         if (priceIds.length === 0) {
             return;
         }
-        const shuffledPriceIds = priceIds
-            .map((x) => {
-            return { element: x, key: Math.random() };
-        })
-            .sort((a, b) => a.key - b.key)
-            .map((x) => x.element);
+        const shuffledPriceIds = priceIds.map((x)=>{
+            return {
+                element: x,
+                key: Math.random()
+            };
+        }).sort((a, b)=>a.key - b.key).map((x)=>x.element);
         let priceFeedUpdateData;
         try {
             const response = await this.hermesClient.getLatestPriceUpdates(shuffledPriceIds, {
                 encoding: "base64",
-                ignoreInvalidPriceIds: true,
+                ignoreInvalidPriceIds: true
             });
             priceFeedUpdateData = response.binary.data;
-        }
-        catch (err) {
-            this.logger.error(err, "getPriceFeedsUpdateData failed:");
+        } catch (error) {
+            this.logger.error(error, "getPriceFeedsUpdateData failed:");
             return;
         }
         const transactionBuilder = this.pythSolanaReceiver.newTransactionBuilder({
-            closeUpdateAccounts: true,
+            closeUpdateAccounts: true
         }, this.addressLookupTableAccount);
         await transactionBuilder.addUpdatePriceFeed(priceFeedUpdateData, this.shardId);
         const transactions = await transactionBuilder.buildVersionedTransactions({
             computeUnitPriceMicroLamports: this.computeUnitPriceMicroLamports,
-            tightComputeBudget: true,
+            tightComputeBudget: true
         });
         try {
-            const signatures = await (0, solana_utils_1.sendTransactions)(transactions, this.pythSolanaReceiver.connection, this.pythSolanaReceiver.wallet);
-            this.logger.info({ signatures }, "updatePriceFeed successful");
-        }
-        catch (err) {
-            this.logger.error(err, "updatePriceFeed failed");
+            const signatures = await (0, _solanautils.sendTransactions)(transactions, this.pythSolanaReceiver.connection, this.pythSolanaReceiver.wallet);
+            this.logger.info({
+                signatures
+            }, "updatePriceFeed successful");
+        } catch (error) {
+            this.logger.error(error, "updatePriceFeed failed");
             return;
         }
     }
 }
-exports.SolanaPricePusher = SolanaPricePusher;
 class SolanaPricePusherJito {
     pythSolanaReceiver;
     hermesClient;
@@ -128,7 +136,7 @@ class SolanaPricePusherJito {
     updatesPerJitoBundle;
     maxRetryTimeMs;
     addressLookupTableAccount;
-    constructor(pythSolanaReceiver, hermesClient, logger, shardId, defaultJitoTipLamports, dynamicJitoTips, maxJitoTipLamports, searcherClients, updatesPerJitoBundle, maxRetryTimeMs, addressLookupTableAccount) {
+    constructor(pythSolanaReceiver, hermesClient, logger, shardId, defaultJitoTipLamports, dynamicJitoTips, maxJitoTipLamports, searcherClients, updatesPerJitoBundle, maxRetryTimeMs, addressLookupTableAccount){
         this.pythSolanaReceiver = pythSolanaReceiver;
         this.hermesClient = hermesClient;
         this.logger = logger;
@@ -145,50 +153,54 @@ class SolanaPricePusherJito {
         try {
             const response = await fetch("https://bundles.jito.wtf/api/v1/bundles/tip_floor");
             if (!response.ok) {
-                this.logger.error({ status: response.status, statusText: response.statusText }, "getRecentJitoTips http request failed");
+                this.logger.error({
+                    status: response.status,
+                    statusText: response.statusText
+                }, "getRecentJitoTips http request failed");
                 return undefined;
             }
+            // TODO: fix this type here to be more specific
             const data = await response.json();
-            return Math.floor(Number(data[0].landed_tips_50th_percentile) * web3_js_1.LAMPORTS_PER_SOL);
-        }
-        catch (err) {
-            this.logger.error({ err }, "getRecentJitoTips failed");
+            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({
+                err: error
+            }, "getRecentJitoTips failed");
             return undefined;
         }
     }
     async updatePriceFeed(priceIds) {
         const recentJitoTip = await this.getRecentJitoTipLamports();
-        const jitoTip = this.dynamicJitoTips && recentJitoTip !== undefined
-            ? Math.max(this.defaultJitoTipLamports, recentJitoTip)
-            : this.defaultJitoTipLamports;
+        const jitoTip = this.dynamicJitoTips && recentJitoTip !== undefined ? Math.max(this.defaultJitoTipLamports, recentJitoTip) : this.defaultJitoTipLamports;
         const cappedJitoTip = Math.min(jitoTip, this.maxJitoTipLamports);
-        this.logger.info({ cappedJitoTip }, "using jito tip of");
+        this.logger.info({
+            cappedJitoTip
+        }, "using jito tip of");
         let priceFeedUpdateData;
         try {
             const response = await this.hermesClient.getLatestPriceUpdates(priceIds, {
-                encoding: "base64",
+                encoding: "base64"
             });
             priceFeedUpdateData = response.binary.data;
-        }
-        catch (err) {
-            this.logger.error(err, "getPriceFeedsUpdateData failed");
+        } catch (error) {
+            this.logger.error(error, "getPriceFeedsUpdateData failed");
             return;
         }
-        for (let i = 0; i < priceIds.length; i += this.updatesPerJitoBundle) {
+        for(let i = 0; i < priceIds.length; i += this.updatesPerJitoBundle){
             const transactionBuilder = this.pythSolanaReceiver.newTransactionBuilder({
-                closeUpdateAccounts: true,
+                closeUpdateAccounts: true
             }, this.addressLookupTableAccount);
-            await transactionBuilder.addUpdatePriceFeed(priceFeedUpdateData.map((x) => {
-                return (0, price_service_sdk_1.sliceAccumulatorUpdateData)(Buffer.from(x, "base64"), i, i + this.updatesPerJitoBundle).toString("base64");
+            await transactionBuilder.addUpdatePriceFeed(priceFeedUpdateData.map((x)=>{
+                return (0, _priceservicesdk.sliceAccumulatorUpdateData)(Buffer.from(x, "base64"), i, i + this.updatesPerJitoBundle).toString("base64");
             }), this.shardId);
             const transactions = await transactionBuilder.buildVersionedTransactions({
                 jitoTipLamports: cappedJitoTip,
-                tightComputeBudget: true,
+                tightComputeBudget: true
             });
-            await (0, solana_utils_1.sendTransactionsJito)(transactions, this.searcherClients, this.pythSolanaReceiver.wallet, {
-                maxRetryTimeMs: this.maxRetryTimeMs,
+            await (0, _solanautils.sendTransactionsJito)(transactions, this.searcherClients, this.pythSolanaReceiver.wallet, {
+                maxRetryTimeMs: this.maxRetryTimeMs
             }, this.logger);
         }
     }
 }
-exports.SolanaPricePusherJito = SolanaPricePusherJito;

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

@@ -1,10 +1,11 @@
-import { PythSolanaReceiver } from "@pythnetwork/pyth-solana-receiver";
-import { ChainPriceListener, IPricePusher, PriceInfo, PriceItem } from "../interface";
-import { DurationInSeconds } from "../utils";
 import { HermesClient } from "@pythnetwork/hermes-client";
-import { SearcherClient } from "jito-ts/dist/sdk/block-engine/searcher";
-import { Logger } from "pino";
+import { PythSolanaReceiver } from "@pythnetwork/pyth-solana-receiver";
 import { AddressLookupTableAccount } from "@solana/web3.js";
+import { SearcherClient } from "jito-ts/dist/sdk/block-engine/searcher";
+import type { Logger } from "pino";
+import type { IPricePusher, PriceInfo, PriceItem } from "../interface.js";
+import { ChainPriceListener } from "../interface.js";
+import type { DurationInSeconds } from "../utils.js";
 export declare class SolanaPriceListener extends ChainPriceListener {
     private pythSolanaReceiver;
     private shardId;
@@ -42,4 +43,3 @@ export declare class SolanaPricePusherJito implements IPricePusher {
     getRecentJitoTipLamports(): Promise<number | undefined>;
     updatePriceFeed(priceIds: string[]): Promise<void>;
 }
-//# sourceMappingURL=solana.d.ts.map

package/dist/sui/balance-tracker.cjs

@@ -0,0 +1,58 @@
+"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 SuiBalanceTracker () {
+        return SuiBalanceTracker;
+    },
+    get createSuiBalanceTracker () {
+        return createSuiBalanceTracker;
+    }
+});
+const _interface = require("../interface.cjs");
+class SuiBalanceTracker extends _interface.BaseBalanceTracker {
+    client;
+    constructor(config){
+        super({
+            ...config,
+            logger: config.logger.child({
+                module: "SuiBalanceTracker"
+            })
+        });
+        this.client = config.client;
+    }
+    /**
+   * Sui-specific implementation of balance update
+   */ async updateBalance() {
+        try {
+            const balance = await this.client.getBalance({
+                owner: this.address
+            });
+            // Convert to a normalized number for reporting (SUI has 9 decimals)
+            const normalizedBalance = Number(balance.totalBalance) / 1e9;
+            this.metrics.updateWalletBalance(this.address, this.network, normalizedBalance);
+            this.logger.debug(`Updated Sui wallet balance: ${this.address} = ${normalizedBalance.toString()} SUI`);
+        } catch (error) {
+            this.logger.error({
+                error
+            }, "Error fetching Sui wallet balance for metrics");
+        }
+    }
+}
+function createSuiBalanceTracker(params) {
+    return new SuiBalanceTracker({
+        client: params.client,
+        address: params.address,
+        network: params.network,
+        updateInterval: params.updateInterval,
+        metrics: params.metrics,
+        logger: params.logger
+    });
+}

package/{lib → dist}/sui/balance-tracker.d.ts

@@ -1,15 +1,16 @@
 import { SuiClient } from "@mysten/sui/client";
-import { BaseBalanceTracker, BaseBalanceTrackerConfig, IBalanceTracker } from "../interface";
-import { DurationInSeconds } from "../utils";
-import { PricePusherMetrics } from "../metrics";
-import { Logger } from "pino";
+import type { Logger } from "pino";
+import type { BaseBalanceTrackerConfig, IBalanceTracker } from "../interface.js";
+import { BaseBalanceTracker } from "../interface.js";
+import { PricePusherMetrics } from "../metrics.js";
+import type { DurationInSeconds } from "../utils.js";
 /**
  * Sui-specific configuration for balance tracker
  */
-export interface SuiBalanceTrackerConfig extends BaseBalanceTrackerConfig {
+export type SuiBalanceTrackerConfig = {
     /** Sui client instance */
     client: SuiClient;
-}
+} & BaseBalanceTrackerConfig;
 /**
  * Sui-specific implementation of the balance tracker
  */
@@ -24,16 +25,15 @@ export declare class SuiBalanceTracker extends BaseBalanceTracker {
 /**
  * Parameters for creating a Sui balance tracker
  */
-export interface CreateSuiBalanceTrackerParams {
+export type CreateSuiBalanceTrackerParams = {
     client: SuiClient;
     address: string;
     network: string;
     updateInterval: DurationInSeconds;
     metrics: PricePusherMetrics;
     logger: Logger;
-}
+};
 /**
  * Factory function to create a balance tracker for Sui chain
  */
 export declare function createSuiBalanceTracker(params: CreateSuiBalanceTrackerParams): IBalanceTracker;
-//# sourceMappingURL=balance-tracker.d.ts.map