@pythnetwork/price-pusher 10.2.0 → 10.3.0

package/dist/sui/command.cjs

@@ -0,0 +1,190 @@
+/* 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";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _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"));
+const _controller = require("../controller.cjs");
+const _metrics = require("../metrics.cjs");
+const _options = /*#__PURE__*/ _interop_require_wildcard(require("../options.cjs"));
+const _priceconfig = require("../price-config.cjs");
+const _pythpricelistener = require("../pyth-price-listener.cjs");
+const _balancetracker = require("./balance-tracker.cjs");
+const _sui = require("./sui.cjs");
+const _utils = require("../utils.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: "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. ",
+    builder: {
+        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.",
+            type: "string",
+            required: true
+        },
+        "pyth-state-id": {
+            description: "Pyth State Id. Can be found here" + "https://docs.pyth.network/documentation/pythnet-price-feeds/sui",
+            type: "string",
+            required: true
+        },
+        "wormhole-state-id": {
+            description: "Wormhole State Id. Can be found here" + "https://docs.pyth.network/documentation/pythnet-price-feeds/sui",
+            type: "string",
+            required: true
+        },
+        "num-gas-objects": {
+            description: "Number of gas objects in the pool.",
+            type: "number",
+            required: true,
+            default: 30
+        },
+        "ignore-gas-objects": {
+            description: "Gas objects to ignore when merging gas objects on startup -- use this for locked objects.",
+            type: "array",
+            required: false,
+            default: []
+        },
+        "gas-budget": {
+            description: "Gas budget for each price update",
+            type: "number",
+            required: true,
+            default: 500_000_000
+        },
+        "account-index": {
+            description: "Index of the account to use derived by the mnemonic",
+            type: "number",
+            required: true,
+            default: 0
+        },
+        ..._options.priceConfigFile,
+        ..._options.priceServiceEndpoint,
+        ..._options.mnemonicFile,
+        ..._options.pollingFrequency,
+        ..._options.pushingFrequency,
+        ..._options.logLevel,
+        ..._options.controllerLogLevel,
+        ..._options.enableMetrics,
+        ..._options.metricsPort
+    },
+    handler: async function(argv) {
+        const { endpoint, priceConfigFile, priceServiceEndpoint, mnemonicFile, pushingFrequency, pollingFrequency, pythStateId, wormholeStateId, numGasObjects, ignoreGasObjects, gasBudget, accountIndex, logLevel, controllerLogLevel, enableMetrics, metricsPort } = argv;
+        const logger = (0, _pino.default)({
+            level: logLevel
+        });
+        const priceConfigs = (0, _priceconfig.readPriceConfigFile)(priceConfigFile);
+        const hermesClient = new _hermesclient.HermesClient(priceServiceEndpoint);
+        const mnemonic = _nodefs.default.readFileSync(mnemonicFile, "utf8").trim();
+        const keypair = _ed25519.Ed25519Keypair.deriveKeypair(mnemonic, `m/44'/784'/${accountIndex}'/0'/0'`);
+        const suiAddress = keypair.getPublicKey().toSuiAddress();
+        logger.info(`Pushing updates from wallet address: ${suiAddress}`);
+        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;
+        // 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}`);
+        }
+        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({
+            module: "SuiPriceListener"
+        }), {
+            pollingFrequency
+        });
+        const suiPusher = await _sui.SuiPricePusher.createWithAutomaticGasPool(hermesClient, logger.child({
+            module: "SuiPricePusher"
+        }), pythStateId, wormholeStateId, endpoint, keypair, gasBudget, numGasObjects, ignoreGasObjects);
+        const controller = new _controller.Controller(priceConfigs, pythListener, suiListener, suiPusher, logger.child({
+            module: "Controller"
+        }, {
+            level: controllerLogLevel
+        }), {
+            pushingFrequency,
+            metrics: metrics
+        });
+        // Create and start the balance tracker if metrics are enabled
+        if (metrics) {
+            const balanceTracker = (0, _balancetracker.createSuiBalanceTracker)({
+                client: suiClient,
+                address: suiAddress,
+                network: "sui",
+                updateInterval: pushingFrequency,
+                metrics,
+                logger
+            });
+            // Start the balance tracker
+            await balanceTracker.start();
+        }
+        void controller.start();
+    }
+};

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

@@ -1,4 +1,4 @@
-import { Options } from "yargs";
+import type { Options } from "yargs";
 declare const _default: {
     command: string;
     describe: string;
@@ -23,4 +23,3 @@ declare const _default: {
     handler: (argv: any) => Promise<void>;
 };
 export default _default;
-//# sourceMappingURL=command.d.ts.map

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

@@ -1,22 +1,39 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SuiPricePusher = exports.SuiPriceListener = void 0;
-const interface_1 = require("../interface");
-const pyth_sui_js_1 = require("@pythnetwork/pyth-sui-js");
-const transactions_1 = require("@mysten/sui/transactions");
-const client_1 = require("@mysten/sui/client");
+/* 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";
+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 SuiPriceListener () {
+        return SuiPriceListener;
+    },
+    get SuiPricePusher () {
+        return SuiPricePusher;
+    }
+});
+const _client = require("@mysten/sui/client");
+const _transactions = require("@mysten/sui/transactions");
+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;
-class SuiPriceListener extends interface_1.ChainPriceListener {
+class SuiPriceListener extends _interface.ChainPriceListener {
     pythClient;
     provider;
     logger;
-    constructor(pythStateId, wormholeStateId, endpoint, priceItems, logger, config) {
+    constructor(pythStateId, wormholeStateId, endpoint, priceItems, logger, config){
         super(config.pollingFrequency, priceItems);
-        this.provider = new client_1.SuiClient({ url: endpoint });
-        this.pythClient = new pyth_sui_js_1.SuiPythClient(this.provider, pythStateId, wormholeStateId);
+        this.provider = new _client.SuiClient({
+            url: endpoint
+        });
+        this.pythClient = new _pythsuijs.SuiPythClient(this.provider, pythStateId, wormholeStateId);
         this.logger = logger;
     }
     async getOnChainPriceInfo(priceId) {
@@ -28,47 +45,29 @@ class SuiPriceListener extends interface_1.ChainPriceListener {
             // Fetching the price info object for the above priceInfoObjectId
             const priceInfoObject = await this.provider.getObject({
                 id: priceInfoObjectId,
-                options: { showContent: true },
+                options: {
+                    showContent: true
+                }
             });
-            if (!priceInfoObject.data || !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
+            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;
+            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;
             return {
-                price: negative ? "-" + magnitude : magnitude,
+                price: negative ? `-${magnitude}` : magnitude,
                 conf,
-                publishTime: Number(timestamp),
+                publishTime: Number(timestamp)
             };
-        }
-        catch (err) {
-            this.logger.error(err, `Polling Sui on-chain price for ${priceId} failed.`);
+        } catch (error) {
+            this.logger.error(error, `Polling Sui on-chain price for ${priceId} failed.`);
             return undefined;
         }
     }
 }
-exports.SuiPriceListener = SuiPriceListener;
-/**
- * The `SuiPricePusher` is designed for high-throughput of price updates.
- * Achieving this property requires sacrificing some nice-to-have features of other
- * pusher implementations that can reduce cost when running multiple pushers. It also requires
- * jumping through some Sui-specific hoops in order to maximize parallelism.
- *
- * The two main design features are:
- * 1. This implementation does not use `update_price_feeds_if_necssary` and simulate the transaction
- *    before submission. If multiple instances of this pusher are running in parallel, all of them will
- *    land all of their pushed updates on-chain.
- * 2. The pusher will split the Coin balance in the provided account into a pool of different Coin objects.
- *    Each transaction will be allocated a Coin object from this pool as needed. This process enables the
- *    transactions to avoid referencing the same owned objects, which allows them to be processed in parallel.
- */
 class SuiPricePusher {
     signer;
     provider;
@@ -77,7 +76,7 @@ class SuiPricePusher {
     gasBudget;
     gasPool;
     pythClient;
-    constructor(signer, provider, logger, hermesClient, gasBudget, gasPool, pythClient) {
+    constructor(signer, provider, logger, hermesClient, gasBudget, gasPool, pythClient){
         this.signer = signer;
         this.provider = provider;
         this.logger = logger;
@@ -87,21 +86,16 @@ 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.
-     * @param provider
-     * @param objectId
-     * @returns package id
-     */
-    static async getPackageId(provider, objectId) {
-        const state = await provider
-            .getObject({
+   * 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) => {
+                showContent: true
+            }
+        }).then((result)=>{
             if (result.data?.content?.dataType == "moveObject") {
                 return result.data.content.fields;
             }
@@ -115,24 +109,24 @@ class SuiPricePusher {
         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) {
+   * 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) {
         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_1.SuiClient({ url: endpoint });
+        const provider = new _client.SuiClient({
+            url: endpoint
+        });
         const gasPool = await SuiPricePusher.initializeGasPool(keypair, provider, numGasObjects, ignoreGasObjects, logger);
-        const pythClient = new pyth_sui_js_1.SuiPythClient(provider, pythStateId, wormholeStateId);
+        const pythClient = new _pythsuijs.SuiPythClient(provider, pythStateId, wormholeStateId);
         return new SuiPricePusher(keypair, provider, logger, hermesClient, gasBudget, gasPool, pythClient);
     }
     async updatePriceFeed(priceIds, pubTimesToPush) {
         if (priceIds.length === 0) {
             return;
         }
-        if (priceIds.length !== pubTimesToPush.length)
-            throw new Error("Invalid arguments");
+        if (priceIds.length !== pubTimesToPush.length) throw new Error("Invalid arguments");
         if (this.gasPool.length === 0) {
             this.logger.warn("Skipping update: no available gas coin.");
             return;
@@ -140,27 +134,27 @@ class SuiPricePusher {
         // 3 price feeds per transaction is the optimal number for gas cost.
         const priceIdChunks = chunkArray(priceIds, 3);
         const txBlocks = [];
-        await Promise.all(priceIdChunks.map(async (priceIdChunk) => {
+        await Promise.all(priceIdChunks.map(async (priceIdChunk)=>{
             const response = await this.hermesClient.getLatestPriceUpdates(priceIdChunk, {
                 encoding: "base64",
-                ignoreInvalidPriceIds: true,
+                ignoreInvalidPriceIds: true
             });
             if (response.binary.data.length !== 1) {
                 throw new Error(`Expected a single VAA for all priceIds ${priceIdChunk} but received ${response.binary.data.length} VAAs: ${response.binary.data}`);
             }
             const vaa = response.binary.data[0];
-            const tx = new transactions_1.Transaction();
-            await this.pythClient.updatePriceFeeds(tx, [Buffer.from(vaa, "base64")], priceIdChunk);
+            const tx = new _transactions.Transaction();
+            await this.pythClient.updatePriceFeeds(tx, [
+                Buffer.from(vaa ?? "", "base64")
+            ], priceIdChunk);
             txBlocks.push(tx);
         }));
         await this.sendTransactionBlocks(txBlocks);
     }
-    /** Send every transaction in txs in parallel, returning when all transactions have completed. */
-    async sendTransactionBlocks(txs) {
-        return Promise.all(txs.map((tx) => this.sendTransactionBlock(tx)));
+    /** Send every transaction in txs in parallel, returning when all transactions have completed. */ async sendTransactionBlocks(txs) {
+        return Promise.all(txs.map((tx)=>this.sendTransactionBlock(tx)));
     }
-    /** Send a single transaction block using a gas coin from the pool. */
-    async sendTransactionBlock(tx) {
+    /** Send a single transaction block using a gas coin from the pool. */ async sendTransactionBlock(tx) {
         const gasObject = this.gasPool.shift();
         if (gasObject === undefined) {
             this.logger.warn("No available gas coin. Skipping push.");
@@ -168,29 +162,28 @@ class SuiPricePusher {
         }
         let nextGasObject = undefined;
         try {
-            tx.setGasPayment([gasObject]);
+            tx.setGasPayment([
+                gasObject
+            ]);
             tx.setGasBudget(this.gasBudget);
             const result = await this.provider.signAndExecuteTransaction({
                 signer: this.signer,
                 transaction: tx,
                 options: {
-                    showEffects: true,
-                },
+                    showEffects: true
+                }
             });
-            nextGasObject = result.effects?.mutated
-                ?.map((obj) => obj.reference)
-                .find((ref) => ref.objectId === gasObject.objectId);
-            this.logger.info({ hash: result.digest }, "Successfully updated price with transaction digest");
-        }
-        catch (err) {
-            if (String(err).includes("Balance of gas object") ||
-                String(err).includes("GasBalanceTooLow")) {
-                this.logger.error(err, "Insufficient gas balance");
+            nextGasObject = result.effects?.mutated?.map((obj)=>obj.reference).find((ref)=>ref.objectId === gasObject.objectId);
+            this.logger.info({
+                hash: result.digest
+            }, "Successfully updated price with transaction digest");
+        } catch (error) {
+            if (String(error).includes("Balance of gas object") || String(error).includes("GasBalanceTooLow")) {
+                this.logger.error(error, "Insufficient gas balance");
                 // If the error is caused by insufficient gas, we should panic
-                throw err;
-            }
-            else {
-                this.logger.error(err, "Failed to update price. Trying to refresh gas object references.");
+                throw error;
+            } else {
+                this.logger.error(error, "Failed to update price. Trying to refresh gas object references.");
                 // Refresh the coin object here in case the error is caused by an object version mismatch.
                 nextGasObject = await SuiPricePusher.tryRefreshObjectReference(this.provider, gasObject);
             }
@@ -206,85 +199,98 @@ class SuiPricePusher {
     static async initializeGasPool(signer, provider, numGasObjects, ignoreGasObjects, logger) {
         const signerAddress = signer.toSuiAddress();
         if (ignoreGasObjects.length > 0) {
-            logger.info({ ignoreGasObjects }, "Ignoring some gas objects for coin merging");
+            logger.info({
+                ignoreGasObjects
+            }, "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 },
+            options: {
+                showContent: true
+            }
         });
         let balance;
-        if (coinResult.data &&
-            coinResult.data.content &&
-            coinResult.data.content.dataType == "moveObject") {
+        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");
+        } else throw new Error("Bad coin object");
         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({ gasPool }, "Gas pool is filled with coins");
+        logger.info({
+            gasPool
+        }, "Gas pool is filled with coins");
         return gasPool;
     }
     // 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 });
-        if (objectResponse.data !== undefined) {
+        const objectResponse = await provider.getObject({
+            id: 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,
+                version: objectResponse.data.version
             };
         }
-        else {
-            throw new Error("Failed to refresh object reference");
-        }
     }
     static async getAllGasCoins(provider, owner) {
         let hasNextPage = true;
         let cursor;
         const coins = new Set([]);
         let numCoins = 0;
-        while (hasNextPage) {
+        while(hasNextPage){
             const paginatedCoins = await provider.getCoins({
                 owner,
-                cursor,
+                cursor
             });
             numCoins += paginatedCoins.data.length;
-            paginatedCoins.data.forEach((c) => coins.add(JSON.stringify({
+            for (const c of paginatedCoins.data)coins.add(JSON.stringify({
                 objectId: c.coinObjectId,
                 version: c.version,
-                digest: c.digest,
-            })));
+                digest: c.digest
+            }));
             hasNextPage = paginatedCoins.hasNextPage;
             cursor = paginatedCoins.nextCursor;
         }
         if (numCoins !== coins.size) {
             throw new Error("Unexpected getCoins result: duplicate coins found");
         }
-        return [...coins].map((item) => JSON.parse(item));
+        return [
+            ...coins
+        ].map((item)=>JSON.parse(item));
     }
     static async splitGasCoinEqually(signer, provider, signerAddress, splitAmount, numGasObjects, gasCoin) {
         // TODO: implement chunking if numGasObjects exceeds MAX_NUM_CREATED_OBJECTS
-        const tx = new transactions_1.Transaction();
-        const coins = tx.splitCoins(tx.gas, Array.from({ length: numGasObjects }, () => tx.pure.u64(splitAmount)));
-        tx.transferObjects(Array.from({ length: numGasObjects }, (_, i) => coins[i]), tx.pure.address(signerAddress));
-        tx.setGasPayment([gasCoin]);
+        const tx = new _transactions.Transaction();
+        const coins = tx.splitCoins(tx.gas, Array.from({
+            length: numGasObjects
+        }, ()=>tx.pure.u64(splitAmount)));
+        tx.transferObjects(Array.from({
+            length: numGasObjects
+        }, (_, i)=>coins[i]), tx.pure.address(signerAddress));
+        tx.setGasPayment([
+            gasCoin
+        ]);
         const result = await provider.signAndExecuteTransaction({
             signer,
             transaction: tx,
-            options: { showEffects: true },
+            options: {
+                showEffects: true
+            }
         });
-        const error = result?.effects?.status.error;
+        const error = result.effects?.status.error;
         if (error) {
             throw new Error(`Failed to initialize gas pool: ${error}. Try re-running the script`);
         }
-        const newCoins = result.effects.created.map((obj) => obj.reference);
+        const newCoins = result.effects.created.map((obj)=>obj.reference);
         if (newCoins.length !== numGasObjects) {
-            throw new Error(`Failed to initialize gas pool. Expected ${numGasObjects}, got: ${newCoins}`);
+            throw new Error(`Failed to initialize gas pool. Expected ${numGasObjects}, got: ${JSON.stringify(newCoins)}`);
         }
         return newCoins;
     }
@@ -297,13 +303,16 @@ class SuiPricePusher {
         const gasCoinsChunks = chunkArray(gasCoins, MAX_NUM_GAS_OBJECTS_IN_PTB - 2);
         let finalCoin;
         const lockedAddresses = new Set();
-        initialLockedAddresses.forEach((value) => lockedAddresses.add(value));
-        for (let i = 0; i < gasCoinsChunks.length; i++) {
-            const mergeTx = new transactions_1.Transaction();
+        for (const value of initialLockedAddresses)lockedAddresses.add(value);
+        for(let i = 0; i < gasCoinsChunks.length; i++){
+            const mergeTx = new _transactions.Transaction();
             let coins = gasCoinsChunks[i];
-            coins = coins.filter((coin) => !lockedAddresses.has(coin.objectId));
+            coins = coins?.filter((coin)=>!lockedAddresses.has(coin.objectId)) ?? [];
             if (finalCoin) {
-                coins = [finalCoin, ...coins];
+                coins = [
+                    finalCoin,
+                    ...coins
+                ];
             }
             mergeTx.setGasPayment(coins);
             let mergeResult;
@@ -311,14 +320,17 @@ class SuiPricePusher {
                 mergeResult = await provider.signAndExecuteTransaction({
                     signer,
                     transaction: mergeTx,
-                    options: { showEffects: true },
+                    options: {
+                        showEffects: true
+                    }
                 });
-            }
-            catch (err) {
-                logger.error(err, "Merge transaction failed with error");
-                if (String(err).includes("quorum of validators because of locked objects. Retried a conflicting transaction")) {
-                    Object.values(err.data).forEach((lockedObjects) => {
-                        lockedObjects.forEach((lockedObject) => {
+            } catch (error_) {
+                logger.error(error_, "Merge transaction failed with error");
+                if (String(error_).includes("quorum of validators because of locked objects. Retried a conflicting transaction")) {
+                    // eslint-disable-next-line unicorn/no-array-for-each
+                    Object.values(error_.data).forEach((lockedObjects)=>{
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, unicorn/no-array-for-each
+                        lockedObjects.forEach((lockedObject)=>{
                             lockedAddresses.add(lockedObject[0]);
                         });
                     });
@@ -326,22 +338,22 @@ class SuiPricePusher {
                     i--;
                     continue;
                 }
-                throw err;
+                throw error_;
             }
-            const error = mergeResult?.effects?.status.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`);
             }
-            finalCoin = mergeResult.effects.mutated.map((obj) => obj.reference)[0];
+            finalCoin = mergeResult.effects.mutated.map((obj)=>obj.reference)[0];
         }
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
         return finalCoin;
     }
 }
-exports.SuiPricePusher = SuiPricePusher;
 function chunkArray(array, size) {
     const chunked = [];
     let index = 0;
-    while (index < array.length) {
+    while(index < array.length){
         chunked.push(array.slice(index, size + index));
         index += size;
     }