@suzaku-network/suzaku-cli 1.0.2

package/dist/kiteStaking.js

@@ -0,0 +1,731 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateStakingConfig = updateStakingConfig;
+exports.initiateValidatorRegistration = initiateValidatorRegistration;
+exports.initiateDelegatorRegistration = initiateDelegatorRegistration;
+exports.initiateDelegatorRemoval = initiateDelegatorRemoval;
+exports.initiateValidatorRemoval = initiateValidatorRemoval;
+exports.completeDelegatorRegistration = completeDelegatorRegistration;
+exports.completeDelegatorRemoval = completeDelegatorRemoval;
+exports.completeValidatorRegistration = completeValidatorRegistration;
+exports.completeValidatorRemoval = completeValidatorRemoval;
+exports.submitUptimeProof = submitUptimeProof;
+exports.getKiteStakingManagerInfo = getKiteStakingManagerInfo;
+exports.getValidatorFullInfo = getValidatorFullInfo;
+exports.getDelegatorFullInfo = getDelegatorFullInfo;
+const viem_1 = require("viem");
+const config_1 = require("./config");
+const utils_1 = require("./lib/utils");
+const logger_1 = require("./lib/logger");
+const console_log_colors_1 = require("console-log-colors");
+const warpUtils_1 = require("./lib/warpUtils");
+const pChainUtils_1 = require("./lib/pChainUtils");
+const ts_belt_1 = require("@mobily/ts-belt");
+const justification_1 = require("./lib/justification");
+const avalanchejs_1 = require("@avalabs/avalanchejs");
+const uptime_1 = require("./uptime");
+async function updateStakingConfig(kiteStakingManager, minimumStakeAmount, maximumStakeAmount, minimumStakeDuration, minimumDelegationFeeBips, maximumStakeMultiplier) {
+    logger_1.logger.log("Updating staking config...");
+    const hash = await kiteStakingManager.safeWrite.updateStakingConfig([
+        minimumStakeAmount,
+        maximumStakeAmount,
+        minimumStakeDuration,
+        minimumDelegationFeeBips,
+        maximumStakeMultiplier
+    ]);
+    logger_1.logger.log("updateStakingConfig executed successfully, tx hash:", hash);
+    return hash;
+}
+async function initiateValidatorRegistration(kiteStakingManager, nodeId, blsKey, remainingBalanceOwner, disableOwner, delegationFeeBips, minStakeDuration, rewardRecipient, initialStake) {
+    logger_1.logger.log("Initiating validator registration...");
+    // Parse NodeID to bytes32 format
+    const nodeIdHex32 = (0, utils_1.parseNodeID)(nodeId, false);
+    const hash = await kiteStakingManager.safeWrite.initiateValidatorRegistration([
+        nodeIdHex32,
+        blsKey,
+        { threshold: remainingBalanceOwner[0], addresses: remainingBalanceOwner[1] },
+        { threshold: disableOwner[0], addresses: disableOwner[1] },
+        delegationFeeBips,
+        minStakeDuration,
+        rewardRecipient
+    ], {
+        value: initialStake,
+        chain: null
+    });
+    logger_1.logger.log("initiateValidatorRegistration executed successfully, tx hash:", hash);
+    return hash;
+}
+async function initiateDelegatorRegistration(kiteStakingManager, config, nodeId, rewardRecipient, stakeAmount) {
+    logger_1.logger.log("Initiating delegator registration...");
+    // Get ValidatorManager from settings
+    const settings = await kiteStakingManager.read.getStakingManagerSettings();
+    const validatorManager = await config.contracts.ValidatorManager(settings.manager);
+    // Parse NodeID to bytes format (20 bytes, no padding)
+    const nodeIdBytes = (0, utils_1.parseNodeID)(nodeId, false);
+    // Get validationID from ValidatorManager
+    const validationID = await validatorManager.read.getNodeValidationID([nodeIdBytes]);
+    const txHash = await kiteStakingManager.safeWrite.initiateDelegatorRegistration([
+        validationID,
+        rewardRecipient
+    ], {
+        value: stakeAmount,
+        chain: null
+    });
+    logger_1.logger.log("initiateDelegatorRegistration executed successfully, tx hash:", txHash);
+    return txHash;
+}
+async function initiateDelegatorRemoval(kiteStakingManager, config, delegationID, includeUptimeProof, rpcUrl) {
+    logger_1.logger.log("Initiating delegator removal...");
+    const client = config.client;
+    // messageIndex is always 0 for KiteStakingManager
+    const messageIndex = 0;
+    // If uptime proof is required, fetch and pack it into access list
+    let accessList = undefined;
+    if (includeUptimeProof) {
+        if (!rpcUrl) {
+            logger_1.logger.error(console_log_colors_1.color.red("RPC URL is required when includeUptimeProof is true."));
+            process.exit(1);
+        }
+        // Get ValidatorManager from settings
+        const settings = await kiteStakingManager.read.getStakingManagerSettings();
+        const validatorManager = await config.contracts.ValidatorManager(settings.manager);
+        // Get delegator info to get validationID
+        const delegatorInfo = await kiteStakingManager.read.getDelegatorInfo([delegationID]);
+        const validationID = delegatorInfo.validationID;
+        // Get the validator info to get nodeID
+        const validator = await validatorManager.read.getValidator([validationID]);
+        const nodeId = (0, utils_1.encodeNodeID)(validator.nodeID);
+        // Get the uptime message
+        const warpNetworkID = client.network === 'fuji' ? 5 : 1;
+        const sourceChainID = avalanchejs_1.utils.base58check.encode((0, viem_1.hexToBytes)(settings.uptimeBlockchainID));
+        logger_1.logger.log("\nGetting validation uptime message...");
+        const signedUptimeMessage = await (0, uptime_1.getValidationUptimeMessage)(client, rpcUrl, nodeId, warpNetworkID, sourceChainID);
+        // Ensure signedUptimeMessage has 0x prefix
+        const signedUptimeMessageHex = signedUptimeMessage.startsWith('0x') ? signedUptimeMessage : `0x${signedUptimeMessage}`;
+        // Pack uptime message into access list
+        const signedUptimeMessageBytes = (0, viem_1.hexToBytes)(signedUptimeMessageHex);
+        const uptimeAccessList = (0, warpUtils_1.packWarpIntoAccessList)(signedUptimeMessageBytes);
+        accessList = [uptimeAccessList[0]];
+    }
+    const hash = await kiteStakingManager.safeWrite.initiateDelegatorRemoval([delegationID, includeUptimeProof, messageIndex], accessList ? {
+        account: client.account,
+        chain: null,
+        accessList
+    } : undefined);
+    logger_1.logger.log("initiateDelegatorRemoval executed successfully, tx hash:", hash);
+    return hash;
+}
+async function initiateValidatorRemoval(kiteStakingManager, config, nodeId, includeUptimeProof) {
+    logger_1.logger.log("Initiating validator removal...");
+    // Get ValidatorManager from settings
+    const settings = await kiteStakingManager.read.getStakingManagerSettings();
+    const validatorManager = await config.contracts.ValidatorManager(settings.manager);
+    // Parse NodeID to bytes format (20 bytes, no padding)
+    const nodeIdBytes = (0, utils_1.parseNodeID)(nodeId, false);
+    // Get validationID from ValidatorManager
+    const validationID = await validatorManager.read.getNodeValidationID([nodeIdBytes]);
+    // messageIndex is always 0 for KiteStakingManager
+    const messageIndex = 0;
+    const hash = await kiteStakingManager.safeWrite.initiateValidatorRemoval([
+        validationID,
+        includeUptimeProof,
+        messageIndex
+    ]);
+    logger_1.logger.log("initiateValidatorRemoval executed successfully, tx hash:", hash);
+    return hash;
+}
+async function completeDelegatorRegistration(pchainClient, kiteStakingManager, config, initiateTxHash, rpcUrl) {
+    logger_1.logger.log("Completing delegator registration...");
+    const client = config.client;
+    // Wait for the initiate delegator registration transaction to be confirmed
+    const receipt = await client.waitForTransactionReceipt({ hash: initiateTxHash, confirmations: 1 });
+    if (receipt.status === 'reverted')
+        throw new Error(`Transaction ${initiateTxHash} reverted, pls resend the initiate delegator registration transaction`);
+    // Get ValidatorManager from settings
+    const settings = await kiteStakingManager.read.getStakingManagerSettings();
+    const validatorManager = await config.contracts.ValidatorManager(settings.manager);
+    // Parse InitiatedDelegatorRegistration event from KiteStakingManager
+    const initiatedDelegatorRegistration = (0, viem_1.parseEventLogs)({
+        abi: kiteStakingManager.abi,
+        logs: receipt.logs,
+        eventName: 'InitiatedDelegatorRegistration'
+    })[0];
+    if (!initiatedDelegatorRegistration) {
+        logger_1.logger.error(console_log_colors_1.color.red("No InitiatedDelegatorRegistration event found in the transaction logs, verify the transaction hash."));
+        process.exit(1);
+    }
+    const delegationID = initiatedDelegatorRegistration.args.delegationID;
+    const validationID = initiatedDelegatorRegistration.args.validationID;
+    const validatorWeight = initiatedDelegatorRegistration.args.validatorWeight;
+    const nonce = initiatedDelegatorRegistration.args.nonce;
+    const setWeightMessageID = initiatedDelegatorRegistration.args.setWeightMessageID;
+    // Get the validator info to get nodeID
+    const validator = await validatorManager.read.getValidator([validationID]);
+    const nodeId = (0, utils_1.encodeNodeID)(validator.nodeID);
+    // Get warp logs to find the weight message
+    const warpLogs = (0, viem_1.parseEventLogs)({
+        abi: config.abis.IWarpMessenger,
+        logs: receipt.logs,
+    });
+    const signingSubnetId = await (0, warpUtils_1.getSigningSubnetIdFromWarpMessage)(client, warpLogs[0].args.message);
+    const weightWarpLog = warpLogs.find((w) => w.args.messageID === setWeightMessageID);
+    if (!weightWarpLog) {
+        logger_1.logger.error(console_log_colors_1.color.red("No matching warp message found for setWeightMessageID, verify the transaction hash."));
+        process.exit(1);
+    }
+    // Get the unsigned L1ValidatorWeightMessage
+    const unsignedL1ValidatorWeightMessage = weightWarpLog.args.message;
+    // Aggregate signatures from validators for the weight message
+    logger_1.logger.log("\nCollecting signatures for the L1ValidatorWeightMessage from the Validator Manager chain...");
+    const signedL1ValidatorWeightMessage = await (0, warpUtils_1.collectSignatures)({ network: client.network, message: unsignedL1ValidatorWeightMessage, signingSubnetId });
+    logger_1.logger.log("Aggregated signatures for the L1ValidatorWeightMessage from the Validator Manager chain");
+    // Call setValidatorWeight on the P-Chain with the signed L1ValidatorWeightMessage
+    logger_1.logger.log("\nSetting validator weight on P-Chain...");
+    (0, ts_belt_1.pipe)(await (0, pChainUtils_1.setValidatorWeight)({
+        client: pchainClient,
+        validationID: validationID,
+        message: signedL1ValidatorWeightMessage
+    }), ts_belt_1.R.tap(pChainSetWeightTxId => logger_1.logger.log("SetL1ValidatorWeightTx executed on P-Chain:", pChainSetWeightTxId)), ts_belt_1.R.tapError(err => {
+        if (!err.includes('warp message contains stale nonce')) {
+            logger_1.logger.error(err);
+            process.exit(1);
+        }
+        logger_1.logger.warn(console_log_colors_1.color.yellow(`Warning: Skipping SetL1ValidatorWeightTx for validationID ${validationID} due to stale nonce (already issued)`));
+    }));
+    // Pack and sign the P-Chain warp message for weight update
+    const validationIDBytes = (0, viem_1.hexToBytes)(validationID);
+    const unsignedPChainWeightWarpMsg = (0, warpUtils_1.packL1ValidatorWeightMessage)(validationIDBytes, BigInt(nonce), BigInt(validatorWeight), client.network === 'fuji' ? 5 : 1, config_1.pChainChainID);
+    const unsignedPChainWeightWarpMsgHex = (0, viem_1.bytesToHex)(unsignedPChainWeightWarpMsg);
+    // Aggregate signatures from validators for the P-Chain weight message
+    logger_1.logger.log("\nAggregating signatures for the L1ValidatorWeightMessage from the P-Chain...");
+    const signedPChainWeightMessage = await (0, warpUtils_1.collectSignatures)({ network: client.network, message: unsignedPChainWeightWarpMsgHex, signingSubnetId });
+    logger_1.logger.log("Aggregated signatures for the L1ValidatorWeightMessage from the P-Chain");
+    // Get the uptime message
+    const warpNetworkID = client.network === 'fuji' ? 5 : 1;
+    const sourceChainID = avalanchejs_1.utils.base58check.encode((0, viem_1.hexToBytes)(settings.uptimeBlockchainID));
+    logger_1.logger.log("\nGetting validation uptime message...");
+    const signedUptimeMessage = await (0, uptime_1.getValidationUptimeMessage)(client, rpcUrl, nodeId, warpNetworkID, sourceChainID);
+    // Ensure signedUptimeMessage has 0x prefix
+    const signedUptimeMessageHex = signedUptimeMessage.startsWith('0x') ? signedUptimeMessage : `0x${signedUptimeMessage}`;
+    // Pack both messages into access list
+    // Convert both signed messages to bytes
+    const signedPChainWeightWarpMsgBytes = (0, viem_1.hexToBytes)(`0x${signedPChainWeightMessage}`);
+    const signedUptimeMessageBytes = (0, viem_1.hexToBytes)(signedUptimeMessageHex);
+    // Pack both messages into separate access list objects
+    const weightAccessList = (0, warpUtils_1.packWarpIntoAccessList)(signedPChainWeightWarpMsgBytes);
+    const uptimeAccessList = (0, warpUtils_1.packWarpIntoAccessList)(signedUptimeMessageBytes);
+    // Combine access lists as two separate objects in the array
+    const combinedAccessList = [
+        weightAccessList[0],
+        uptimeAccessList[0]
+    ];
+    // messageIndex is always 0 for KiteStakingManager
+    const messageIndex = 0;
+    const uptimeMessageIndex = 1;
+    logger_1.logger.log("\nCalling function completeDelegatorRegistration...");
+    const hash = await kiteStakingManager.safeWrite.completeDelegatorRegistration([delegationID, messageIndex, uptimeMessageIndex], {
+        account: client.account,
+        chain: null,
+        accessList: combinedAccessList
+    });
+    logger_1.logger.log("completeDelegatorRegistration executed successfully, tx hash:", hash);
+    return hash;
+}
+async function completeDelegatorRemoval(pchainClient, kiteStakingManager, config, initiateRemovalTxHash, rpcUrl, waitValidatorVisible, delegationIDs, initiateTxHash) {
+    logger_1.logger.log("Completing delegator removal...");
+    const client = config.client;
+    // Wait for the initiate removal transaction to be confirmed
+    const receipt = await client.waitForTransactionReceipt({ hash: initiateRemovalTxHash, confirmations: 1 });
+    if (receipt.status === 'reverted')
+        throw new Error(`Transaction ${initiateRemovalTxHash} reverted, pls resend the removal transaction`);
+    // Get ValidatorManager from settings
+    const settings = await kiteStakingManager.read.getStakingManagerSettings();
+    const validatorManager = await config.contracts.ValidatorManager(settings.manager);
+    // Parse InitiatedDelegatorRemoval events from KiteStakingManager
+    const initiatedDelegatorRemovals = (0, viem_1.parseEventLogs)({
+        abi: kiteStakingManager.abi,
+        logs: receipt.logs,
+        eventName: 'InitiatedDelegatorRemoval'
+    });
+    if (initiatedDelegatorRemovals.length === 0) {
+        logger_1.logger.error(console_log_colors_1.color.red("No InitiatedDelegatorRemoval event found in the transaction logs, verify the transaction hash."));
+        process.exit(1);
+    }
+    // Filter by delegationIDs if provided
+    const filteredRemovals = delegationIDs
+        ? initiatedDelegatorRemovals.filter((e) => {
+            const delegationID = e.args.delegationID;
+            return delegationIDs.includes(delegationID);
+        })
+        : initiatedDelegatorRemovals;
+    if (filteredRemovals.length === 0) {
+        logger_1.logger.error(console_log_colors_1.color.red("No matching InitiatedDelegatorRemoval event found for the provided delegationIDs, verify the transaction hash and delegationIDs."));
+        process.exit(1);
+    }
+    // Get warp logs
+    const warpLogs = (0, viem_1.parseEventLogs)({
+        abi: config.abis.IWarpMessenger,
+        logs: receipt.logs,
+    });
+    let lastHash;
+    for (const event of filteredRemovals) {
+        const delegationID = event.args.delegationID;
+        const validationID = event.args.validationID;
+        // Get the validator info to get nodeID
+        const validator = await validatorManager.read.getValidator([validationID]);
+        const nodeID = (0, utils_1.encodeNodeID)(validator.nodeID);
+        logger_1.logger.log(`Processing removal for delegation ${delegationID}, node ${nodeID}`);
+        // Get delegator info to find the registration block number
+        const delegatorInfo = await kiteStakingManager.read.getDelegatorInfo([delegationID]);
+        let addNodeBlockNumber = receipt.blockNumber;
+        if (initiateTxHash) {
+            const addNodeReceipt = await client.waitForTransactionReceipt({ hash: initiateTxHash, confirmations: 0 });
+            if (addNodeReceipt.status === 'reverted')
+                throw new Error(`Transaction ${initiateTxHash} reverted, pls use another initiate tx`);
+            // Check if this delegationID is in the registration event
+            const registrationEvents = (0, viem_1.parseEventLogs)({
+                abi: kiteStakingManager.abi,
+                logs: addNodeReceipt.logs,
+                eventName: 'InitiatedDelegatorRegistration'
+            });
+            if (registrationEvents.some((e) => e.args.delegationID === delegationID)) {
+                addNodeBlockNumber = addNodeReceipt.blockNumber;
+            }
+        }
+        // Look for InitiatedValidatorWeightUpdate events from ValidatorManager (similar to completeWeightUpdate)
+        const initiatedValidatorWeightUpdates = (0, viem_1.parseEventLogs)({
+            abi: validatorManager.abi,
+            logs: receipt.logs,
+            eventName: 'InitiatedValidatorWeightUpdate'
+        }).filter((e) => e.args.validationID === validationID);
+        if (initiatedValidatorWeightUpdates.length === 0) {
+            logger_1.logger.error(console_log_colors_1.color.red(`No InitiatedValidatorWeightUpdate event found for validationID ${validationID}`));
+            continue;
+        }
+        const weightUpdateEvent = initiatedValidatorWeightUpdates[0];
+        const warpLog = warpLogs.find((w) => w.args.messageID === weightUpdateEvent.args.weightUpdateMessageID);
+        if (!warpLog) {
+            logger_1.logger.error(console_log_colors_1.color.red(`No matching warp log found for weightUpdateMessageID ${weightUpdateEvent.args.weightUpdateMessageID}`));
+            continue;
+        }
+        const unsignedL1ValidatorWeightMessage = warpLog.args.message;
+        const weight = weightUpdateEvent.args.weight;
+        const nonce = weightUpdateEvent.args.nonce;
+        const signingSubnetId = await (0, warpUtils_1.getSigningSubnetIdFromWarpMessage)(client, unsignedL1ValidatorWeightMessage);
+        // Aggregate signatures from validators for the weight message
+        logger_1.logger.log("\nCollecting signatures for the L1ValidatorWeightMessage from the Validator Manager chain...");
+        const signedL1ValidatorWeightMessage = await (0, warpUtils_1.collectSignatures)({ network: client.network, message: unsignedL1ValidatorWeightMessage, signingSubnetId });
+        logger_1.logger.log("Aggregated signatures for the L1ValidatorWeightMessage from the Validator Manager chain");
+        // Call setValidatorWeight on the P-Chain with the signed L1ValidatorWeightMessage
+        logger_1.logger.log("\nSetting validator weight on P-Chain...");
+        (0, ts_belt_1.pipe)(await (0, pChainUtils_1.setValidatorWeight)({
+            client: pchainClient,
+            validationID: validationID,
+            message: signedL1ValidatorWeightMessage
+        }), ts_belt_1.R.tap(pChainSetWeightTxId => logger_1.logger.log("SetL1ValidatorWeightTx executed on P-Chain:", pChainSetWeightTxId)), ts_belt_1.R.tapError(err => {
+            if (!err.includes('warp message contains stale nonce')) {
+                logger_1.logger.error(err);
+                process.exit(1);
+            }
+            logger_1.logger.warn(console_log_colors_1.color.yellow(`Warning: Skipping SetL1ValidatorWeightTx for validationID ${validationID} due to stale nonce (already issued)`));
+        }));
+        // Pack and sign the P-Chain warp message for weight update
+        const validationIDBytes = (0, viem_1.hexToBytes)(validationID);
+        const unsignedPChainWarpMsg = (0, warpUtils_1.packL1ValidatorWeightMessage)(validationIDBytes, BigInt(nonce), BigInt(weight), client.network === 'fuji' ? 5 : 1, config_1.pChainChainID);
+        const unsignedPChainWarpMsgHex = (0, viem_1.bytesToHex)(unsignedPChainWarpMsg);
+        // Aggregate signatures from validators for the P-Chain weight message
+        logger_1.logger.log("\nAggregating signatures for the L1ValidatorWeightMessage from the P-Chain...");
+        const signedPChainMessage = await (0, warpUtils_1.collectSignatures)({ network: client.network, message: unsignedPChainWarpMsgHex, signingSubnetId });
+        logger_1.logger.log("Aggregated signatures for the L1ValidatorWeightMessage from the P-Chain");
+        // Convert the signed warp message to bytes and pack into access list
+        const signedPChainWarpMsgBytes = (0, viem_1.hexToBytes)(`0x${signedPChainMessage}`);
+        const accessList = (0, warpUtils_1.packWarpIntoAccessList)(signedPChainWarpMsgBytes);
+        // messageIndex is always 0 for KiteStakingManager
+        const messageIndex = 0;
+        logger_1.logger.log("\nCalling function completeDelegatorRemoval...");
+        const hash = await kiteStakingManager.safeWrite.completeDelegatorRemoval([delegationID, messageIndex], {
+            account: client.account,
+            chain: null,
+            accessList
+        });
+        if (waitValidatorVisible) {
+            const subnetIDHex = await validatorManager.read.subnetID();
+            logger_1.logger.log("Waiting for the validator to be removed from the P-Chain (may take a while)...");
+            await (0, utils_1.retryWhileError)(async () => (await (0, pChainUtils_1.getCurrentValidators)(client, avalanchejs_1.utils.base58check.encode((0, viem_1.hexToBytes)(subnetIDHex)))).some((v) => v.nodeID === nodeID), 5000, 180000, (res) => res === false);
+        }
+        logger_1.logger.log("completeDelegatorRemoval executed successfully, tx hash:", hash);
+        lastHash = hash;
+    }
+    if (!lastHash) {
+        throw new Error("No delegator removals processed");
+    }
+    return lastHash;
+}
+async function completeValidatorRegistration(pchainClient, kiteStakingManager, config, blsProofOfPossession, initiateTxHash, initialBalance, waitValidatorVisible) {
+    logger_1.logger.log("Completing validator registration...");
+    const client = config.client;
+    // Wait for transaction receipt to extract warp message and validation ID
+    const receipt = await client.waitForTransactionReceipt({ hash: initiateTxHash });
+    // Parse InitiatedStakingValidatorRegistration event from KiteStakingManager
+    const initiatedStakingRegistration = (0, viem_1.parseEventLogs)({
+        abi: kiteStakingManager.abi,
+        logs: receipt.logs,
+        eventName: 'InitiatedStakingValidatorRegistration'
+    })[0];
+    if (!initiatedStakingRegistration) {
+        logger_1.logger.error(console_log_colors_1.color.red("No InitiatedStakingValidatorRegistration event found in the transaction logs, verify the transaction hash."));
+        process.exit(1);
+    }
+    // Get ValidatorManager from settings
+    const settings = await kiteStakingManager.read.getStakingManagerSettings();
+    const validatorManager = await config.contracts.ValidatorManager(settings.manager);
+    // Parse InitiatedValidatorRegistration event from ValidatorManager
+    const initiatedValidatorRegistration = (0, viem_1.parseEventLogs)({
+        abi: validatorManager.abi,
+        logs: receipt.logs,
+        eventName: 'InitiatedValidatorRegistration'
+    })[0];
+    if (!initiatedValidatorRegistration) {
+        logger_1.logger.error(console_log_colors_1.color.red("No InitiatedValidatorRegistration event found in the transaction logs, verify the transaction hash."));
+        process.exit(1);
+    }
+    // messageIndex is always 0 for KiteStakingManager
+    const messageIndex = 0;
+    const warpLogs = (0, viem_1.parseEventLogs)({
+        abi: config.abis.IWarpMessenger,
+        logs: receipt.logs,
+    })[0];
+    if (!warpLogs) {
+        logger_1.logger.error(console_log_colors_1.color.red("No IWarpMessenger event found in the transaction logs."));
+        process.exit(1);
+    }
+    const signingSubnetId = await (0, warpUtils_1.getSigningSubnetIdFromWarpMessage)(client, warpLogs.args.message);
+    const validationIDHex = initiatedValidatorRegistration.args.validationID;
+    const nodeId = (0, utils_1.encodeNodeID)(initiatedValidatorRegistration.args.nodeID); // Convert bytes20 to NodeID format
+    // Check if the node is still registered as a validator on the P-Chain
+    const subnetIDHex = await validatorManager.read.subnetID();
+    const subnetID = avalanchejs_1.utils.base58check.encode((0, viem_1.hexToBytes)(subnetIDHex));
+    const isValidator = (await (0, pChainUtils_1.getCurrentValidators)(client, subnetID)).some((v) => v.nodeID === nodeId);
+    if (isValidator) {
+        logger_1.logger.log(console_log_colors_1.color.yellow("Node is already registered as a validator on the P-Chain, skipping registerL1Validator call."));
+    }
+    else {
+        // Get the unsigned warp message from the receipt
+        const RegisterL1ValidatorUnsignedWarpMsg = warpLogs.args.message;
+        // Collect signatures for the warp message
+        logger_1.logger.log("\nCollecting signatures for the L1ValidatorRegistrationMessage from the Validator Manager chain...");
+        const signedMessage = await (0, warpUtils_1.collectSignatures)({ network: client.network, message: RegisterL1ValidatorUnsignedWarpMsg, signingSubnetId });
+        // Register validator on P-Chain
+        logger_1.logger.log("\nRegistering validator on P-Chain...");
+        (0, ts_belt_1.pipe)(await (0, pChainUtils_1.registerL1Validator)({
+            client: pchainClient,
+            blsProofOfPossession: blsProofOfPossession,
+            signedMessage,
+            initialBalance: initialBalance
+        }), ts_belt_1.R.tap(pChainTxId => logger_1.logger.log("RegisterL1ValidatorTx executed on P-Chain:", pChainTxId)), ts_belt_1.R.tapError(err => { logger_1.logger.error(err); process.exit(1); }));
+    }
+    // Pack and sign the P-Chain warp message
+    const validationIDBytes = (0, viem_1.hexToBytes)(validationIDHex);
+    const unsignedPChainWarpMsg = (0, warpUtils_1.packL1ValidatorRegistration)(validationIDBytes, true, client.network === 'fuji' ? 5 : 1, config_1.pChainChainID);
+    const unsignedPChainWarpMsgHex = (0, viem_1.bytesToHex)(unsignedPChainWarpMsg);
+    // Aggregate signatures from validators
+    logger_1.logger.log("\nAggregating signatures for the L1ValidatorRegistrationMessage from the P-Chain...");
+    const signedPChainMessage = await (0, warpUtils_1.collectSignatures)({ network: client.network, message: unsignedPChainWarpMsgHex, signingSubnetId });
+    // Convert the signed warp message to bytes and pack into access list
+    const signedPChainWarpMsgBytes = (0, viem_1.hexToBytes)(`0x${signedPChainMessage}`);
+    const accessList = (0, warpUtils_1.packWarpIntoAccessList)(signedPChainWarpMsgBytes);
+    logger_1.logger.log("\nCalling function completeValidatorRegistration...");
+    const hash = await kiteStakingManager.safeWrite.completeValidatorRegistration([messageIndex], {
+        account: client.account,
+        chain: null,
+        accessList
+    });
+    // Wait until the validator is visible on the P-Chain
+    if (waitValidatorVisible) {
+        logger_1.logger.log("Waiting for the validator to be visible on the P-Chain (may take a while)...");
+        await (0, utils_1.retryWhileError)(async () => (await (0, pChainUtils_1.getCurrentValidators)(client, avalanchejs_1.utils.base58check.encode((0, viem_1.hexToBytes)(subnetIDHex)))).some((v) => v.nodeID === nodeId), 5000, 180000, (res) => res === true);
+    }
+    logger_1.logger.log("completeValidatorRegistration executed successfully, tx hash:", hash);
+    return hash;
+}
+async function completeValidatorRemoval(pchainClient, kiteStakingManager, config, initiateRemovalTxHash, waitValidatorVisible, nodeIDs, initiateTxHash) {
+    logger_1.logger.log("Completing validator removal...");
+    const client = config.client;
+    // Wait for the initiate removal transaction to be confirmed
+    const receipt = await client.waitForTransactionReceipt({ hash: initiateRemovalTxHash, confirmations: 1 });
+    if (receipt.status === 'reverted')
+        throw new Error(`Transaction ${initiateRemovalTxHash} reverted, pls resend the removal transaction`);
+    // Get ValidatorManager from settings
+    const settings = await kiteStakingManager.read.getStakingManagerSettings();
+    const validatorManager = await config.contracts.ValidatorManager(settings.manager);
+    // Parse InitiatedValidatorRemoval events from ValidatorManager
+    const initiatedValidatorRemovals = (0, viem_1.parseEventLogs)({
+        abi: validatorManager.abi,
+        logs: receipt.logs,
+        eventName: 'InitiatedValidatorRemoval'
+    });
+    if (initiatedValidatorRemovals.length === 0) {
+        logger_1.logger.error(console_log_colors_1.color.red("No InitiatedValidatorRemoval event found in the transaction logs, verify the transaction hash."));
+        process.exit(1);
+    }
+    // Filter by nodeIDs if provided
+    // Note: InitiatedValidatorRemoval event doesn't include nodeID, so we need to get it from the validator
+    const filteredRemovals = nodeIDs
+        ? (await Promise.all(initiatedValidatorRemovals.map(async (e) => {
+            const validator = await validatorManager.read.getValidator([e.args.validationID]);
+            const nodeId = (0, utils_1.encodeNodeID)(validator.nodeID);
+            return { event: e, nodeId };
+        }))).filter(({ nodeId }) => nodeIDs.includes(nodeId)).map(({ event }) => event)
+        : initiatedValidatorRemovals;
+    if (filteredRemovals.length === 0) {
+        logger_1.logger.error(console_log_colors_1.color.red("No matching InitiatedValidatorRemoval event found for the provided NodeIDs, verify the transaction hash and NodeIDs."));
+        process.exit(1);
+    }
+    const warpLogs = (0, viem_1.parseEventLogs)({
+        abi: config.abis.IWarpMessenger,
+        logs: receipt.logs,
+    });
+    const subnetIDHex = await validatorManager.read.subnetID();
+    const subnetID = avalanchejs_1.utils.base58check.encode((0, viem_1.hexToBytes)(subnetIDHex));
+    const currentValidators = await (0, pChainUtils_1.getCurrentValidators)(client, subnetID);
+    for (const event of filteredRemovals) {
+        const eventIndex = filteredRemovals.indexOf(event);
+        const validationID = event.args.validationID;
+        // Get nodeID from validator - ValidatorManager InitiatedValidatorRemoval doesn't include nodeID
+        const validator = await validatorManager.read.getValidator([validationID]);
+        const nodeID = (0, utils_1.encodeNodeID)(validator.nodeID);
+        logger_1.logger.log(`Processing removal for node ${nodeID}`);
+        // Find the corresponding warp log
+        // ValidatorManager InitiatedValidatorRemoval event has validatorWeightMessageID field
+        const warpLog = warpLogs.find((w) => {
+            // Match by messageID - ValidatorManager event has validatorWeightMessageID
+            return w.args.messageID === event.args.validatorWeightMessageID;
+        });
+        if (!warpLog) {
+            logger_1.logger.error(console_log_colors_1.color.red(`No matching warp log found for validationID ${validationID}`));
+            continue;
+        }
+        const signingSubnetId = await (0, warpUtils_1.getSigningSubnetIdFromWarpMessage)(client, warpLog.args.message);
+        let addNodeBlockNumber = receipt.blockNumber;
+        if (initiateTxHash && initiateTxHash.length > eventIndex) {
+            const addNodeReceipt = await client.waitForTransactionReceipt({ hash: initiateTxHash[eventIndex], confirmations: 0 });
+            if (addNodeReceipt.status === 'reverted')
+                throw new Error(`Transaction ${initiateTxHash[eventIndex]} reverted, pls use another initiate tx`);
+            addNodeBlockNumber = addNodeReceipt.blockNumber;
+        }
+        // Check if the node is still registered as a validator on the P-Chain
+        const isValidator = currentValidators.some((v) => v.nodeID === nodeID);
+        if (!isValidator) {
+            logger_1.logger.log(console_log_colors_1.color.yellow("Node is not registered as a validator on the P-Chain."));
+        }
+        else {
+            // Get the unsigned L1ValidatorWeightMessage with weight=0 generated by the ValidatorManager from the receipt
+            const unsignedL1ValidatorWeightMessage = warpLog.args.message;
+            // Aggregate signatures from validators
+            const signedL1ValidatorWeightMessage = await (0, warpUtils_1.collectSignatures)({ network: client.network, message: unsignedL1ValidatorWeightMessage, signingSubnetId });
+            logger_1.logger.log("Aggregated signatures for the L1ValidatorWeightMessage from the Validator Manager chain");
+            // Call setValidatorWeight on the P-Chain with the signed L1ValidatorWeightMessage
+            (0, ts_belt_1.pipe)(await (0, pChainUtils_1.setValidatorWeight)({
+                client: pchainClient,
+                validationID: validationID,
+                message: signedL1ValidatorWeightMessage
+            }), ts_belt_1.R.tapError((error) => {
+                throw new Error("SetL1ValidatorWeightTx failed on P-Chain: " + error + '\n');
+            }), ts_belt_1.R.tap((txId) => {
+                logger_1.logger.log("SetL1ValidatorWeightTx executed on P-Chain: " + txId);
+            }));
+        }
+        // Get justification for original register validator tx
+        const justification = await (0, justification_1.GetRegistrationJustification)(nodeID, validationID, subnetID, client, addNodeBlockNumber);
+        if (!justification) {
+            throw new Error("Justification not found for validator removal");
+        }
+        // Pack and sign the P-Chain warp message
+        const validationIDBytes = (0, viem_1.hexToBytes)(validationID);
+        const unsignedPChainWarpMsg = (0, warpUtils_1.packL1ValidatorRegistration)(validationIDBytes, false, client.network === 'fuji' ? 5 : 1, config_1.pChainChainID);
+        const unsignedPChainWarpMsgHex = (0, viem_1.bytesToHex)(unsignedPChainWarpMsg);
+        // Aggregate signatures from validators
+        const signedPChainMessage = await (0, warpUtils_1.collectSignatures)({ network: client.network, message: unsignedPChainWarpMsgHex, justification: (0, viem_1.bytesToHex)(justification), signingSubnetId });
+        logger_1.logger.log("Aggregated signatures for the L1ValidatorRegistrationMessage from the P-Chain");
+        // Convert the signed warp message to bytes and pack into access list
+        const signedPChainWarpMsgBytes = (0, viem_1.hexToBytes)(`0x${signedPChainMessage}`);
+        const accessList = (0, warpUtils_1.packWarpIntoAccessList)(signedPChainWarpMsgBytes);
+        // messageIndex is always 0 for KiteStakingManager
+        const messageIndex = 0;
+        // Execute completeValidatorRemoval transaction
+        logger_1.logger.log("Executing completeValidatorRemoval transaction...");
+        // Checking if the node was only in the vmc or also in the stakingManager
+        const completeHash = await kiteStakingManager.safeWrite.completeValidatorRemoval([messageIndex], {
+            account: client.account,
+            chain: null,
+            accessList
+        });
+        if (waitValidatorVisible) {
+            logger_1.logger.log("Waiting for the validator to be removed from the P-Chain (may take a while)...");
+            await (0, utils_1.retryWhileError)(async () => (await (0, pChainUtils_1.getCurrentValidators)(client, avalanchejs_1.utils.base58check.encode((0, viem_1.hexToBytes)(subnetIDHex)))).some((v) => v.nodeID === nodeID), 5000, 180000, (res) => res === false);
+        }
+        logger_1.logger.log("completeValidatorRemoval executed successfully, tx hash:", completeHash);
+    }
+}
+async function submitUptimeProof(config, kiteStakingManager, rpcUrl, nodeId) {
+    const client = config.client;
+    const [uptimeBlockchainID, manager] = await kiteStakingManager.read.getStakingManagerSettings().then((settings) => [settings.uptimeBlockchainID, settings.manager]);
+    const warpNetworkID = client.network === 'fuji' ? 5 : 1;
+    const sourceChainID = avalanchejs_1.utils.base58check.encode((0, viem_1.hexToBytes)(uptimeBlockchainID));
+    logger_1.logger.log("\nGetting validation uptime message...");
+    const signedUptimeMessage = await (0, uptime_1.getValidationUptimeMessage)(client, rpcUrl, nodeId, warpNetworkID, sourceChainID);
+    // Ensure signedUptimeMessage has 0x prefix
+    const signedUptimeMessageHex = signedUptimeMessage.startsWith('0x') ? signedUptimeMessage : `0x${signedUptimeMessage}`;
+    // Pack both messages into separate access list objects
+    const uptimeAccessList = (0, warpUtils_1.packWarpIntoAccessList)((0, viem_1.hexToBytes)(signedUptimeMessageHex));
+    const validators = await (0, uptime_1.getCurrentValidatorsFromNode)(rpcUrl);
+    const validator = validators.find(v => v.nodeID === nodeId);
+    if (!validator)
+        throw new Error(`Validator with nodeID ${nodeId} not found in the current validator set`);
+    const txHash = await kiteStakingManager.write.submitUptimeProof([(0, utils_1.cb58ToHex)(validator.validationID), 0], { accessList: uptimeAccessList, chain: null });
+    logger_1.logger.log("submitUptimeProof done, tx hash:", txHash);
+    return txHash;
+}
+// ─── Info Aggregators ────────────────────────────────────────────────────────
+const NANOS_PER_AVAX = 1000000000n;
+function formatAvax(wei) {
+    const whole = wei / NANOS_PER_AVAX;
+    const frac = wei % NANOS_PER_AVAX;
+    return frac === 0n
+        ? `${whole} AVAX`
+        : `${whole}.${frac.toString().padStart(9, '0').replace(/0+$/, '')} AVAX`;
+}
+function formatDuration(seconds) {
+    const s = Number(seconds);
+    if (s < 60)
+        return `${s}s`;
+    if (s < 3600)
+        return `${Math.floor(s / 60)}m ${s % 60}s`;
+    if (s < 86400)
+        return `${Math.floor(s / 3600)}h ${Math.floor((s % 3600) / 60)}m`;
+    return `${Math.floor(s / 86400)}d ${Math.floor((s % 86400) / 3600)}h`;
+}
+function formatTimestamp(ts) {
+    if (ts === 0n)
+        return 'never';
+    return new Date(Number(ts) * 1000).toISOString();
+}
+/** Aggregate all global-level information from KiteStakingManager */
+async function getKiteStakingManagerInfo(kiteStakingManager) {
+    const [config, settings, rewardCalculator, rewardVault, owner, pendingOwner, bipsFactor, maxDelegationFeeBips, maxStakeMultiplierLimit,] = await Promise.all([
+        kiteStakingManager.read.getStakingConfig(),
+        kiteStakingManager.read.getStakingManagerSettings(),
+        kiteStakingManager.read.getRewardCalculator(),
+        kiteStakingManager.read.getRewardVault(),
+        kiteStakingManager.read.owner(),
+        kiteStakingManager.read.pendingOwner(),
+        kiteStakingManager.read.BIPS_CONVERSION_FACTOR(),
+        kiteStakingManager.read.MAXIMUM_DELEGATION_FEE_BIPS(),
+        kiteStakingManager.read.MAXIMUM_STAKE_MULTIPLIER_LIMIT(),
+    ]);
+    return {
+        // Staking config
+        minimumStakeAmount: config[0].toString(),
+        maximumStakeAmount: config[1].toString(),
+        minimumStakeDuration: config[2].toString(),
+        minimumDelegationFeeBips: config[3].toString(),
+        maximumStakeMultiplier: config[4].toString(),
+        weightToValueFactor: config[5].toString(),
+        // Addresses
+        validatorManager: settings.manager,
+        rewardCalculator,
+        rewardVault,
+        uptimeBlockchainID: settings.uptimeBlockchainID,
+        // Ownership
+        owner,
+        pendingOwner,
+        // Protocol constants
+        BIPS_CONVERSION_FACTOR: bipsFactor,
+        MAXIMUM_DELEGATION_FEE_BIPS: maxDelegationFeeBips,
+        MAXIMUM_STAKE_MULTIPLIER_LIMIT: maxStakeMultiplierLimit,
+        // Human-readable summaries
+        formatted: {
+            minimumStakeAmount: formatAvax(config[0]),
+            maximumStakeAmount: formatAvax(config[1]),
+            minimumStakeDuration: formatDuration(config[2]),
+            minimumDelegationFeeBips: `${config[3] / 100}%`,
+            maximumStakeMultiplier: `${config[4]}x`,
+        },
+    };
+}
+/** Aggregate all information for a specific validator by validationID */
+async function getValidatorFullInfo(kiteStakingManager, validationID) {
+    const [validator, pendingRewards, rewardInfo] = await Promise.all([
+        kiteStakingManager.read.getStakingValidator([validationID]),
+        kiteStakingManager.read.getValidatorPendingRewards([validationID]),
+        kiteStakingManager.read.getValidatorRewardInfo([validationID]),
+    ]);
+    const [rewardRecipient, accruedRewards] = rewardInfo;
+    return {
+        validationID,
+        // PoS validator info
+        owner: validator.owner,
+        delegationFeeBips: validator.delegationFeeBips,
+        minStakeDuration: validator.minStakeDuration.toString(),
+        uptimeSeconds: validator.uptimeSeconds.toString(),
+        lastRewardClaimTime: validator.lastRewardClaimTime.toString(),
+        lastClaimUptimeSeconds: validator.lastClaimUptimeSeconds.toString(),
+        // Pending rewards
+        stakingReward: pendingRewards[0].toString(),
+        delegationFees: pendingRewards[1].toString(),
+        totalPendingReward: pendingRewards[2].toString(),
+        // Reward accounting
+        rewardRecipient,
+        accruedRewards: accruedRewards.toString(),
+        // Human-readable
+        formatted: {
+            delegationFeeBips: `${validator.delegationFeeBips / 100}%`,
+            minStakeDuration: formatDuration(validator.minStakeDuration),
+            uptime: formatDuration(validator.uptimeSeconds),
+            lastRewardClaimTime: formatTimestamp(validator.lastRewardClaimTime),
+            stakingReward: formatAvax(pendingRewards[0]),
+            delegationFees: formatAvax(pendingRewards[1]),
+            totalPendingReward: formatAvax(pendingRewards[2]),
+            accruedRewards: formatAvax(accruedRewards),
+        },
+    };
+}
+/** Aggregate all information for a specific delegator by delegationID */
+async function getDelegatorFullInfo(kiteStakingManager, delegationID) {
+    const [delegator, pendingRewards, rewardInfo] = await Promise.all([
+        kiteStakingManager.read.getDelegatorInfo([delegationID]),
+        kiteStakingManager.read.getDelegatorPendingRewards([delegationID]),
+        kiteStakingManager.read.getDelegatorRewardInfo([delegationID]),
+    ]);
+    const [rewardRecipient, accruedRewards] = rewardInfo;
+    return {
+        delegationID,
+        // Delegator info
+        status: delegator.status,
+        owner: delegator.owner,
+        validationID: delegator.validationID,
+        weight: delegator.weight.toString(),
+        startTime: delegator.startTime.toString(),
+        startingNonce: delegator.startingNonce.toString(),
+        endingNonce: delegator.endingNonce.toString(),
+        lastRewardClaimTime: delegator.lastRewardClaimTime.toString(),
+        lastClaimUptimeSeconds: delegator.lastClaimUptimeSeconds.toString(),
+        // Pending rewards
+        grossReward: pendingRewards[0].toString(),
+        validatorFee: pendingRewards[1].toString(),
+        netPendingReward: pendingRewards[2].toString(),
+        // Reward accounting
+        rewardRecipient,
+        accruedRewards: accruedRewards.toString(),
+        // Human-readable
+        formatted: {
+            startTime: formatTimestamp(delegator.startTime),
+            lastRewardClaimTime: formatTimestamp(delegator.lastRewardClaimTime),
+            grossReward: formatAvax(pendingRewards[0]),
+            validatorFee: formatAvax(pendingRewards[1]),
+            netPendingReward: formatAvax(pendingRewards[2]),
+            accruedRewards: formatAvax(accruedRewards),
+        },
+    };
+}
+//# sourceMappingURL=kiteStaking.js.map