@pythnetwork/price-pusher 10.2.0 → 10.3.1

package/lib/evm/evm.js

@@ -1,270 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EvmPricePusher = exports.EvmPriceListener = void 0;
-const interface_1 = require("../interface");
-const utils_1 = require("../utils");
-const viem_1 = require("viem");
-class EvmPriceListener extends interface_1.ChainPriceListener {
-    pythContract;
-    watchEvents;
-    logger;
-    constructor(pythContract, priceItems, watchEvents, logger, config) {
-        super(config.pollingFrequency, priceItems);
-        this.pythContract = pythContract;
-        this.watchEvents = watchEvents;
-        this.logger = logger;
-        this.pythContract = pythContract;
-        this.logger = logger;
-    }
-    // This method should be awaited on and once it finishes it has the latest value
-    // for the given price feeds (if they exist).
-    async start() {
-        if (this.watchEvents) {
-            this.logger.info("Watching target network pyth contract events...");
-            this.startWatching();
-        }
-        else {
-            this.logger.info("The target network RPC endpoint is not Websocket. " +
-                "Listening for updates only via polling....");
-        }
-        // base class for polling
-        await super.start();
-    }
-    async startWatching() {
-        this.pythContract.watchEvent.PriceFeedUpdate({ id: this.priceItems.map((item) => (0, utils_1.addLeading0x)(item.id)) }, { strict: true, onLogs: this.onPriceFeedUpdate.bind(this) });
-    }
-    onPriceFeedUpdate(logs) {
-        for (const log of logs) {
-            const priceId = (0, utils_1.removeLeading0x)((0, utils_1.assertDefined)(log.args.id));
-            const priceInfo = {
-                conf: (0, utils_1.assertDefined)(log.args.conf).toString(),
-                price: (0, utils_1.assertDefined)(log.args.price).toString(),
-                publishTime: Number((0, utils_1.assertDefined)(log.args.publishTime)),
-            };
-            this.logger.debug({ priceInfo }, `Received a new Evm PriceFeedUpdate event for price feed ${this.priceIdToAlias.get(priceId)} (${priceId}).`);
-            this.updateLatestPriceInfo(priceId, priceInfo);
-        }
-    }
-    async getOnChainPriceInfo(priceId) {
-        let priceRaw;
-        try {
-            priceRaw = await this.pythContract.read.getPriceUnsafe([
-                (0, utils_1.addLeading0x)(priceId),
-            ]);
-        }
-        catch (err) {
-            this.logger.error(err, `Polling on-chain price for ${priceId} failed.`);
-            return undefined;
-        }
-        this.logger.debug(`Polled an EVM on chain price for feed ${this.priceIdToAlias.get(priceId)} (${priceId}).`);
-        return {
-            conf: priceRaw.conf,
-            price: priceRaw.price,
-            publishTime: Number(priceRaw.publishTime),
-        };
-    }
-}
-exports.EvmPriceListener = EvmPriceListener;
-class EvmPricePusher {
-    hermesClient;
-    client;
-    pythContract;
-    logger;
-    overrideGasPriceMultiplier;
-    overrideGasPriceMultiplierCap;
-    updateFeeMultiplier;
-    gasLimit;
-    customGasStation;
-    gasPrice;
-    pusherAddress;
-    lastPushAttempt;
-    constructor(hermesClient, client, pythContract, logger, overrideGasPriceMultiplier, overrideGasPriceMultiplierCap, updateFeeMultiplier, gasLimit, customGasStation, gasPrice) {
-        this.hermesClient = hermesClient;
-        this.client = client;
-        this.pythContract = pythContract;
-        this.logger = logger;
-        this.overrideGasPriceMultiplier = overrideGasPriceMultiplier;
-        this.overrideGasPriceMultiplierCap = overrideGasPriceMultiplierCap;
-        this.updateFeeMultiplier = updateFeeMultiplier;
-        this.gasLimit = gasLimit;
-        this.customGasStation = customGasStation;
-        this.gasPrice = gasPrice;
-    }
-    // The pubTimes are passed here to use the values that triggered the push.
-    // This is an optimization to avoid getting a newer value (as an update comes)
-    // and will help multiple price pushers to have consistent behaviour.
-    // To ensure that we transactions are landing and we are not pushing the prices twice
-    // we will re-use the same nonce (with a higher gas price) if the previous transaction
-    // is not landed yet.
-    async updatePriceFeed(priceIds, pubTimesToPush) {
-        if (priceIds.length === 0) {
-            return;
-        }
-        if (priceIds.length !== pubTimesToPush.length)
-            throw new Error("Invalid arguments");
-        const priceFeedUpdateData = (await this.getPriceFeedsUpdateData(priceIds));
-        const priceFeedUpdateDataWith0x = priceFeedUpdateData.map((data) => (0, utils_1.addLeading0x)(data));
-        let updateFee;
-        try {
-            updateFee = await this.pythContract.read.getUpdateFee([
-                priceFeedUpdateDataWith0x,
-            ]);
-            updateFee = BigInt(Math.round(Number(updateFee) * (this.updateFeeMultiplier || 1)));
-            this.logger.debug(`Update fee: ${updateFee}`);
-        }
-        catch (e) {
-            this.logger.error(e, "An unidentified error has occured when getting the update fee.");
-            throw e;
-        }
-        // Gas price in networks with transaction type eip1559 represents the
-        // addition of baseFee and priorityFee required to land the transaction. We
-        // are using this to remain compatible with the networks that doesn't
-        // support this transaction type.
-        let gasPrice = this.gasPrice ??
-            Number(await (this.customGasStation?.getCustomGasPrice() ??
-                this.client.getGasPrice()));
-        // Try to re-use the same nonce and increase the gas if the last tx is not landed yet.
-        if (this.pusherAddress === undefined) {
-            this.pusherAddress = this.client.account.address;
-        }
-        const lastExecutedNonce = (await this.client.getTransactionCount({
-            address: this.pusherAddress,
-        })) - 1;
-        let gasPriceToOverride = undefined;
-        if (this.lastPushAttempt !== undefined) {
-            if (this.lastPushAttempt.nonce <= lastExecutedNonce) {
-                this.lastPushAttempt = undefined;
-            }
-            else {
-                gasPriceToOverride =
-                    this.lastPushAttempt.gasPrice * this.overrideGasPriceMultiplier;
-            }
-        }
-        if (gasPriceToOverride !== undefined &&
-            gasPriceToOverride > Number(gasPrice)) {
-            gasPrice = Math.min(gasPriceToOverride, gasPrice * this.overrideGasPriceMultiplierCap);
-        }
-        const txNonce = lastExecutedNonce + 1;
-        this.logger.debug(`Using gas price: ${gasPrice} and nonce: ${txNonce}`);
-        const pubTimesToPushParam = pubTimesToPush.map((pubTime) => BigInt(pubTime));
-        const priceIdsWith0x = priceIds.map((priceId) => (0, utils_1.addLeading0x)(priceId));
-        // Update lastAttempt
-        this.lastPushAttempt = {
-            nonce: txNonce,
-            gasPrice: gasPrice,
-        };
-        try {
-            const { request } = await this.pythContract.simulate.updatePriceFeedsIfNecessary([priceFeedUpdateDataWith0x, priceIdsWith0x, pubTimesToPushParam], {
-                value: updateFee,
-                gasPrice: BigInt(Math.ceil(gasPrice)),
-                nonce: txNonce,
-                gas: this.gasLimit !== undefined
-                    ? BigInt(Math.ceil(this.gasLimit))
-                    : undefined,
-            });
-            this.logger.debug({ request }, "Simulated request successfully");
-            const hash = await this.client.writeContract(request);
-            this.logger.info({ hash }, "Price update sent");
-            this.waitForTransactionReceipt(hash);
-        }
-        catch (err) {
-            this.logger.debug({ err }, "Simulating or sending transactions failed.");
-            if (err instanceof viem_1.BaseError) {
-                if (err.walk((e) => e instanceof viem_1.ContractFunctionRevertedError &&
-                    e.data?.errorName === "NoFreshUpdate")) {
-                    this.logger.info("Simulation reverted because none of the updates are fresh. This is an expected behaviour to save gas. Skipping this push.");
-                    return;
-                }
-                if (err.walk((e) => e instanceof viem_1.InsufficientFundsError)) {
-                    this.logger.error({ err }, "Wallet doesn't have enough balance. In rare cases, there might be issues with gas price " +
-                        "calculation in the RPC.");
-                    throw err;
-                }
-                if (err.walk((e) => e instanceof viem_1.FeeCapTooLowError) ||
-                    err.walk((e) => e instanceof viem_1.InternalRpcError &&
-                        e.details.includes("replacement transaction underpriced"))) {
-                    this.logger.warn("The gas price of the transaction is too low or there is an existing transaction with higher gas with the same nonce. " +
-                        "The price will be increased in the next push. Skipping this push. " +
-                        "If this keeps happening or transactions are not landing you need to increase the override gas price " +
-                        "multiplier and the cap to increase the likelihood of the transaction landing on-chain.");
-                    return;
-                }
-                if (err.walk((e) => e instanceof viem_1.TransactionExecutionError &&
-                    (e.details.includes("nonce too low") ||
-                        e.message.includes("Nonce provided for the transaction")))) {
-                    this.logger.info("The nonce is incorrect. This is an expected behaviour in high frequency or multi-instance setup. Skipping this push.");
-                    return;
-                }
-                // Sometimes the contract function execution fails in simulation and this error is thrown.
-                if (err.walk((e) => e instanceof viem_1.ContractFunctionExecutionError)) {
-                    this.logger.warn({ err }, "The contract function execution failed in simulation. This is an expected behaviour in high frequency or multi-instance setup. " +
-                        "Please review this error and file an issue if it is a bug. Skipping this push.");
-                    return;
-                }
-                // We normally crash on unknown failures but we believe that this type of error is safe to skip. The other reason is that
-                // wometimes we see a TransactionExecutionError because of the nonce without any details and it is not catchable.
-                if (err.walk((e) => e instanceof viem_1.TransactionExecutionError)) {
-                    this.logger.error({ err }, "Transaction execution failed. This is an expected behaviour in high frequency or multi-instance setup. " +
-                        "Please review this error and file an issue if it is a bug. Skipping this push.");
-                    return;
-                }
-                // The following errors are part of the legacy code and might not work as expected.
-                // We are keeping them in case they help with handling what is not covered above.
-                if (err.message.includes("the tx doesn't have the correct nonce.") ||
-                    err.message.includes("nonce too low") ||
-                    err.message.includes("invalid nonce")) {
-                    this.logger.info("The nonce is incorrect (are multiple users using this account?). Skipping this push.");
-                    return;
-                }
-                if (err.message.includes("max fee per gas less than block base fee")) {
-                    // We just have to handle this error and return.
-                    // LastPushAttempt was stored with the class
-                    // Next time the update will be executing, it will check the last attempt
-                    // and increase the gas price accordingly.
-                    this.logger.warn("The transaction failed with error: max fee per gas less than block base fee. " +
-                        "The fee will be increased in the next push. Skipping this push.");
-                    return;
-                }
-                if (err.message.includes("sender doesn't have enough funds to send tx.")) {
-                    this.logger.error("Payer is out of balance, please top it up.");
-                    throw new Error("Please top up the wallet");
-                }
-                if (err.message.includes("could not replace existing tx")) {
-                    this.logger.error("A transaction with the same nonce has been mined and this one is no longer needed. Skipping this push.");
-                    return;
-                }
-            }
-            // If the error is not handled, we will crash the process.
-            this.logger.error({ err }, "The transaction failed with an unhandled error. crashing the process. " +
-                "Please review this error and file an issue if it is a bug.");
-            throw err;
-        }
-    }
-    async waitForTransactionReceipt(hash) {
-        try {
-            const receipt = await this.client.waitForTransactionReceipt({
-                hash: hash,
-            });
-            switch (receipt.status) {
-                case "success":
-                    this.logger.debug({ hash, receipt }, "Price update successful");
-                    this.logger.info({ hash }, "Price update successful");
-                    break;
-                default:
-                    this.logger.info({ hash, receipt }, "Price update did not succeed or its transaction did not land. " +
-                        "This is an expected behaviour in high frequency or multi-instance setup.");
-            }
-        }
-        catch (err) {
-            this.logger.warn({ err }, "Failed to get transaction receipt");
-        }
-    }
-    async getPriceFeedsUpdateData(priceIds) {
-        const response = await this.hermesClient.getLatestPriceUpdates(priceIds, {
-            encoding: "hex",
-            ignoreInvalidPriceIds: true,
-        });
-        return response.binary.data;
-    }
-}
-exports.EvmPricePusher = EvmPricePusher;

package/lib/evm/pyth-abi.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pyth-abi.d.ts","sourceRoot":"","sources":["../../src/evm/pyth-abi.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkiBX,CAAC;AAEX,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;EAgCjB,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuEhB,CAAC;AAEX,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIV,CAAC"}

package/lib/evm/pyth-contract.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pyth-contract.d.ts","sourceRoot":"","sources":["../../src/evm/pyth-contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,OAAO,EAAE,qBAAqB,EAAE,MAAM,MAAM,CAAC;AACnE,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAEnD,MAAM,MAAM,YAAY,GAAG,qBAAqB,CAC9C,OAAO,OAAO,EACd,iBAAiB,CAClB,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,iBAAiB,EACzB,SAAS,OAAO,KACf,YAKC,CAAC"}

package/lib/evm/pyth-contract.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPythContract = void 0;
-const viem_1 = require("viem");
-const pyth_abi_1 = require("./pyth-abi");
-const createPythContract = (client, address) => (0, viem_1.getContract)({
-    client,
-    abi: pyth_abi_1.PythAbi,
-    address,
-});
-exports.createPythContract = createPythContract;

package/lib/evm/super-wallet.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"super-wallet.d.ts","sourceRoot":"","sources":["../../src/evm/super-wallet.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,OAAO,EACP,KAAK,EAEL,MAAM,EACN,SAAS,EACT,aAAa,EACb,aAAa,EAGb,SAAS,EACV,MAAM,MAAM,CAAC;AAmBd,MAAM,MAAM,iBAAiB,GAAG,MAAM,CACpC,SAAS,EACT,KAAK,EACL,OAAO,EACP,SAAS,EACT,aAAa,CAAC,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,GAAG,aAAa,CAAC,KAAK,EAAE,OAAO,CAAC,CACzE,CAAC;AAcF,eAAO,MAAM,YAAY,GACvB,UAAU,MAAM,EAChB,UAAU,MAAM,KACf,OAAO,CAAC,iBAAiB,CAY3B,CAAC"}

package/lib/evm/super-wallet.js

@@ -1,73 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createClient = void 0;
-const viem_1 = require("viem");
-const accounts_1 = require("viem/accounts");
-const chains = __importStar(require("viem/chains"));
-const utils_1 = require("../utils");
-const UNKNOWN_CHAIN_CONFIG = {
-    name: "Unknown",
-    nativeCurrency: {
-        name: "Unknown",
-        symbol: "Unknown",
-        decimals: 18,
-    },
-    rpcUrls: {
-        default: {
-            http: [],
-        },
-    },
-};
-// Get the transport based on the endpoint
-const getTransport = (endpoint) => (0, utils_1.isWsEndpoint)(endpoint) ? (0, viem_1.webSocket)(endpoint) : (0, viem_1.http)(endpoint);
-// Get the chain corresponding to the chainId. If the chain is not found, it will return
-// an unknown chain which should work fine in most of the cases. We might need to update
-// the viem package to support new chains if they don't work as expected with the unknown
-// chain.
-const getChainById = (chainId) => Object.values(chains).find((chain) => chain.id === chainId) ||
-    (0, viem_1.defineChain)({ id: chainId, ...UNKNOWN_CHAIN_CONFIG });
-const createClient = async (endpoint, mnemonic) => {
-    const transport = getTransport(endpoint);
-    const chainId = await (0, viem_1.createPublicClient)({
-        transport,
-    }).getChainId();
-    return (0, viem_1.createWalletClient)({
-        transport,
-        account: (0, accounts_1.mnemonicToAccount)(mnemonic),
-        chain: getChainById(chainId),
-    }).extend(viem_1.publicActions);
-};
-exports.createClient = createClient;

package/lib/fuel/command.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../src/fuel/command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;;;;;;;;;;;kBAmBvB,OAAO;4BAKP,OAAO;iCAKP,OAAO;;oBAQiB,GAAG;;AA1BpC,wBAiGE"}

package/lib/fuel/command.js

@@ -1,98 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const options = __importStar(require("../options"));
-const price_config_1 = require("../price-config");
-const hermes_client_1 = require("@pythnetwork/hermes-client");
-const pyth_price_listener_1 = require("../pyth-price-listener");
-const fuel_1 = require("./fuel");
-const controller_1 = require("../controller");
-const fuels_1 = require("fuels");
-const fs_1 = __importDefault(require("fs"));
-const pino_1 = __importDefault(require("pino"));
-const utils_1 = require("../utils");
-exports.default = {
-    command: "fuel",
-    describe: "run price pusher for Fuel",
-    builder: {
-        endpoint: {
-            description: "Fuel RPC API endpoint",
-            type: "string",
-            required: true,
-        },
-        "private-key-file": {
-            description: "Path to the private key file",
-            type: "string",
-            required: true,
-        },
-        "pyth-contract-address": {
-            description: "Pyth contract address on Fuel",
-            type: "string",
-            required: true,
-        },
-        ...options.priceConfigFile,
-        ...options.priceServiceEndpoint,
-        ...options.pushingFrequency,
-        ...options.pollingFrequency,
-        ...options.logLevel,
-        ...options.controllerLogLevel,
-    },
-    handler: async function (argv) {
-        const { endpoint, privateKeyFile, pythContractAddress, priceConfigFile, priceServiceEndpoint, pushingFrequency, pollingFrequency, logLevel, controllerLogLevel, } = argv;
-        const logger = (0, pino_1.default)({ level: logLevel });
-        const priceConfigs = (0, price_config_1.readPriceConfigFile)(priceConfigFile);
-        const hermesClient = new hermes_client_1.HermesClient(priceServiceEndpoint);
-        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_1.filterInvalidPriceItems)(hermesClient, priceItems);
-        if (invalidPriceItems.length > 0) {
-            logger.error(`Invalid price id submitted for: ${invalidPriceItems
-                .map(({ alias }) => alias)
-                .join(", ")}`);
-        }
-        priceItems = existingPriceItems;
-        const pythListener = new pyth_price_listener_1.PythPriceListener(hermesClient, priceItems, logger.child({ module: "PythPriceListener" }));
-        const provider = await fuels_1.Provider.create(endpoint);
-        const privateKey = fs_1.default.readFileSync(privateKeyFile, "utf8").trim();
-        const wallet = fuels_1.Wallet.fromPrivateKey(privateKey, provider);
-        const fuelPriceListener = new fuel_1.FuelPriceListener(provider, pythContractAddress, priceItems, logger.child({ module: "FuelPriceListener" }), { pollingFrequency });
-        const fuelPricePusher = new fuel_1.FuelPricePusher(wallet, pythContractAddress, hermesClient, logger.child({ module: "FuelPricePusher" }));
-        const controller = new controller_1.Controller(priceConfigs, pythListener, fuelPriceListener, fuelPricePusher, logger.child({ module: "Controller" }, { level: controllerLogLevel }), { pushingFrequency });
-        await controller.start();
-    },
-};

package/lib/fuel/fuel.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fuel.d.ts","sourceRoot":"","sources":["../../src/fuel/fuel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EACL,kBAAkB,EAClB,YAAY,EACZ,SAAS,EACT,SAAS,EACV,MAAM,cAAc,CAAC;AACtB,OAAO,EAAgB,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC3D,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAC9B,OAAO,EAAE,QAAQ,EAA+B,MAAM,EAAM,MAAM,OAAO,CAAC;AAc1E,qBAAa,iBAAkB,SAAQ,kBAAkB;IAIrD,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,cAAc;IAEtB,OAAO,CAAC,MAAM;IANhB,OAAO,CAAC,QAAQ,CAAW;gBAGjB,QAAQ,EAAE,QAAQ,EAClB,cAAc,EAAE,MAAM,EAC9B,UAAU,EAAE,SAAS,EAAE,EACf,MAAM,EAAE,MAAM,EACtB,MAAM,EAAE;QACN,gBAAgB,EAAE,iBAAiB,CAAC;KACrC;IAUG,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;CA6B3E;AAED,qBAAa,eAAgB,YAAW,YAAY;IAIhD,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,MAAM;IANhB,OAAO,CAAC,QAAQ,CAAW;gBAGjB,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,MAAM,EACtB,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,MAAM;IASlB,eAAe,CACnB,QAAQ,EAAE,MAAM,EAAE,EAElB,cAAc,EAAE,MAAM,EAAE,GACvB,OAAO,CAAC,IAAI,CAAC;CAuCjB"}

package/lib/fuel/fuel.js

@@ -1,101 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FuelPricePusher = exports.FuelPriceListener = void 0;
-const interface_1 = require("../interface");
-const utils_1 = require("../utils");
-const fuels_1 = require("fuels");
-const pyth_fuel_js_1 = require("@pythnetwork/pyth-fuel-js");
-// Convert TAI64 timestamp to Unix timestamp
-function tai64ToUnix(tai64) {
-    // TAI64 is 2^62 seconds ahead of Unix epoch (1970-01-01)
-    // Additional 10-second offset accounts for TAI being ahead of UTC at Unix epoch
-    const result = BigInt(tai64.toString()) - BigInt(2n ** 62n) - 10n;
-    return Number(result);
-}
-class FuelPriceListener extends interface_1.ChainPriceListener {
-    provider;
-    pythContractId;
-    logger;
-    contract;
-    constructor(provider, pythContractId, priceItems, logger, config) {
-        super(config.pollingFrequency, priceItems);
-        this.provider = provider;
-        this.pythContractId = pythContractId;
-        this.logger = logger;
-        this.contract = new fuels_1.Contract(this.pythContractId, pyth_fuel_js_1.PYTH_CONTRACT_ABI, this.provider);
-    }
-    async getOnChainPriceInfo(priceId) {
-        try {
-            const formattedPriceId = (0, utils_1.addLeading0x)(priceId);
-            const priceInfo = await this.contract.functions
-                .price_unsafe(formattedPriceId)
-                .get();
-            console.log({
-                conf: priceInfo.value.confidence.toString(),
-                price: priceInfo.value.price.toString(),
-                publishTime: tai64ToUnix(priceInfo.value.publish_time),
-            });
-            this.logger.debug(`Polled a Fuel on chain price for feed ${this.priceIdToAlias.get(priceId)} (${priceId}).`);
-            return {
-                conf: priceInfo.value.confidence.toString(),
-                price: priceInfo.value.price.toString(),
-                publishTime: tai64ToUnix(priceInfo.value.publish_time),
-            };
-        }
-        catch (err) {
-            this.logger.error({ err, priceId }, `Polling on-chain price failed.`);
-            return undefined;
-        }
-    }
-}
-exports.FuelPriceListener = FuelPriceListener;
-class FuelPricePusher {
-    wallet;
-    pythContractId;
-    hermesClient;
-    logger;
-    contract;
-    constructor(wallet, pythContractId, hermesClient, logger) {
-        this.wallet = wallet;
-        this.pythContractId = pythContractId;
-        this.hermesClient = hermesClient;
-        this.logger = logger;
-        this.contract = new fuels_1.Contract(this.pythContractId, pyth_fuel_js_1.PYTH_CONTRACT_ABI, this.wallet);
-    }
-    async updatePriceFeed(priceIds, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    pubTimesToPush) {
-        if (priceIds.length === 0) {
-            return;
-        }
-        let priceFeedUpdateData;
-        try {
-            const response = await this.hermesClient.getLatestPriceUpdates(priceIds, {
-                encoding: "base64",
-                ignoreInvalidPriceIds: true,
-            });
-            priceFeedUpdateData = response.binary.data;
-        }
-        catch (err) {
-            this.logger.error(err, "getPriceFeedsUpdateData failed");
-            return;
-        }
-        const updateData = priceFeedUpdateData.map((data) => (0, fuels_1.arrayify)(data));
-        try {
-            const updateFee = await this.contract.functions
-                .update_fee(updateData)
-                .get();
-            const result = await this.contract.functions
-                .update_price_feeds(updateData)
-                .callParams({
-                forward: [updateFee.value, (0, fuels_1.hexlify)(pyth_fuel_js_1.FUEL_ETH_ASSET_ID)],
-            })
-                .call();
-            this.logger.info({ transactionId: result.transactionId }, "updatePriceFeed successful");
-        }
-        catch (err) {
-            this.logger.error(err, "updatePriceFeed failed");
-        }
-    }
-}
-exports.FuelPricePusher = FuelPricePusher;

package/lib/index.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/lib/index.js

@@ -1,34 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const yargs_1 = __importDefault(require("yargs"));
-const helpers_1 = require("yargs/helpers");
-const command_1 = __importDefault(require("./injective/command"));
-const command_2 = __importDefault(require("./evm/command"));
-const command_3 = __importDefault(require("./aptos/command"));
-const command_4 = __importDefault(require("./sui/command"));
-const command_5 = __importDefault(require("./near/command"));
-const command_6 = __importDefault(require("./solana/command"));
-const command_7 = __importDefault(require("./fuel/command"));
-const command_8 = __importDefault(require("./ton/command"));
-const options_1 = require("./options");
-(0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
-    .parserConfiguration({
-    "parse-numbers": false,
-})
-    .config("config")
-    .global("config")
-    .option("enable-metrics", options_1.enableMetrics["enable-metrics"])
-    .option("metrics-port", options_1.metricsPort["metrics-port"])
-    .command(command_2.default)
-    .command(command_7.default)
-    .command(command_1.default)
-    .command(command_3.default)
-    .command(command_4.default)
-    .command(command_5.default)
-    .command(command_6.default)
-    .command(command_8.default)
-    .help().argv;

package/lib/injective/command.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../src/injective/command.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;;;;;;;;;;;;;yBAevB,OAAO;iBAKP,OAAO;qBAIP,OAAO;0BAIP,OAAO;wCAMP,OAAO;;oBAUiB,GAAG;;AAxCpC,wBA4HE"}