@starship-ci/client/verifiers/chain.js

Starship CI Client

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.chainVerifiers = exports.verifyEthereumRpc = exports.verifyEthereumRest = exports.verifyChainExposer = exports.verifyChainFaucet = exports.verifyChainRpc = exports.verifyChainRest = void 0;
const axios_1 = __importDefault(require("axios"));
const utils_1 = require("../utils");
const verifyChainRest = async (chain) => {
    const port = chain.ports?.rest;
    const result = {
        service: `chain-${chain.id}`,
        endpoint: 'rest',
        status: 'failure'
    };
    if (!port) {
        result.status = 'skipped';
        result.error = 'Port not found';
        return result;
    }
    try {
        const response = await axios_1.default.get(`http://localhost:${port}/cosmos/bank/v1beta1/supply`);
        result.details = response.data;
        if (response.status !== 200) {
            result.error = 'Failed to get chain supply';
            return result;
        }
        if (response.data.supply[0].amount > 0) {
            result.status = 'success';
            result.message = 'Chain supply is greater than 0';
            return result;
        }
        result.status = 'failure';
        result.error = 'Chain supply not confirmed';
        result.details = response.data;
        return result;
    }
    catch (error) {
        result.error = (0, utils_1.handleAxiosError)(error);
        return result;
    }
};
exports.verifyChainRest = verifyChainRest;
const verifyChainRpc = async (chain) => {
    const port = chain.ports?.rpc;
    const result = {
        service: `chain-${chain.id}`,
        endpoint: 'rpc',
        status: 'failure'
    };
    if (!port) {
        result.status = 'skipped';
        result.error = 'Port not found';
        return result;
    }
    try {
        const response = await axios_1.default.get(`http://localhost:${port}/status`);
        result.details = response.data;
        if (response.status !== 200) {
            result.error = 'Failed to get chain node info';
            return result;
        }
        const blockHeight = Number(response.data.result?.sync_info?.latest_block_height ||
            response.data.result?.SyncInfo?.latest_block_height);
        if (blockHeight > 0) {
            result.status = 'success';
            result.message = 'Chain is synced';
            return result;
        }
        result.status = 'failure';
        result.error = 'Block height is 0';
        result.details = response.data;
        return result;
    }
    catch (error) {
        result.error = (0, utils_1.handleAxiosError)(error);
        return result;
    }
};
exports.verifyChainRpc = verifyChainRpc;
const verifyChainFaucet = async (chain) => {
    const port = chain.ports?.faucet;
    const result = {
        service: `chain-${chain.id}`,
        endpoint: 'faucet',
        status: 'failure'
    };
    if (!port) {
        result.status = 'skipped';
        result.error = 'Port not found';
        return result;
    }
    try {
        const response = await axios_1.default.get(`http://localhost:${port}/status`);
        if (response.status !== 200) {
            result.error = 'Failed to get chain node info';
            return result;
        }
        if (!response.data.chainId) {
            result.error = 'Invalid response: chainId not found';
            result.details = response.data;
            return result;
        }
        if (response.data.chainId === chain.id) {
            result.status = 'success';
            result.message = 'Chain faucet is working';
            return result;
        }
        result.status = 'failure';
        result.error = `Chain ID mismatch: expected ${chain.id}, got ${response.data.chainId}`;
        result.details = response.data;
        return result;
    }
    catch (error) {
        result.error = (0, utils_1.handleAxiosError)(error);
        return result;
    }
};
exports.verifyChainFaucet = verifyChainFaucet;
const verifyChainExposer = async (chain) => {
    const port = chain.ports?.exposer;
    const result = {
        service: `chain-${chain.id}`,
        endpoint: 'exposer',
        status: 'failure'
    };
    if (!port) {
        result.status = 'skipped';
        result.error = 'Port not found';
        return result;
    }
    try {
        const response = await axios_1.default.get(`http://localhost:${port}/node_id`);
        result.details = response.data;
        if (response.status !== 200) {
            result.error = 'Failed to get chain node id';
            return result;
        }
        if (response.data && response.data.node_id) {
            result.status = 'success';
            result.message = 'Chain exposer is working';
            return result;
        }
        result.status = 'failure';
        result.error = 'Invalid node_id response';
        result.details = response.data;
        return result;
    }
    catch (error) {
        if (axios_1.default.isAxiosError(error)) {
            if (error.code === 'ECONNREFUSED') {
                result.error = 'Exposer service is not running';
            }
            else {
                result.error = (0, utils_1.handleAxiosError)(error);
            }
        }
        else {
            result.error = 'Unknown error occurred';
        }
        return result;
    }
};
exports.verifyChainExposer = verifyChainExposer;
// Ethereum specific verifiers
const verifyEthereumRest = async (chain) => {
    const port = chain.ports?.rest;
    const result = {
        service: `chain-${chain.id}`,
        endpoint: 'rest',
        status: 'failure'
    };
    if (!port) {
        result.status = 'skipped';
        result.error = 'Port not found';
        return result;
    }
    try {
        const response = await axios_1.default.post(`http://localhost:${port}`, {
            jsonrpc: '2.0',
            method: 'eth_blockNumber',
            params: [],
            id: 1
        });
        result.details = response.data;
        if (response.status !== 200) {
            result.error = 'Failed to get block number';
            return result;
        }
        if (response.data.result) {
            result.status = 'success';
            result.message = 'Ethereum node is responding';
            return result;
        }
        result.status = 'failure';
        result.error = 'Invalid response from Ethereum node';
        result.details = response.data;
        return result;
    }
    catch (error) {
        result.error = (0, utils_1.handleAxiosError)(error);
        return result;
    }
};
exports.verifyEthereumRest = verifyEthereumRest;
const verifyEthereumRpc = async (chain) => {
    const port = chain.ports?.rpc;
    const result = {
        service: `chain-${chain.id}`,
        endpoint: 'rpc',
        status: 'failure'
    };
    if (!port) {
        result.status = 'skipped';
        result.error = 'Port not found';
        return result;
    }
    try {
        const response = await axios_1.default.post(`http://localhost:${port}`, {
            jsonrpc: '2.0',
            method: 'eth_syncing',
            params: [],
            id: 1
        });
        result.details = response.data;
        if (response.status !== 200) {
            result.error = 'Failed to get sync status';
            return result;
        }
        if (typeof response.data.result === 'boolean' ||
            response.data.result === false) {
            result.status = 'success';
            result.message = 'Ethereum node is synced';
            return result;
        }
        result.status = 'failure';
        result.error = 'Ethereum node is still syncing';
        result.details = response.data;
        return result;
    }
    catch (error) {
        result.error = (0, utils_1.handleAxiosError)(error);
        return result;
    }
};
exports.verifyEthereumRpc = verifyEthereumRpc;
exports.chainVerifiers = {
    default: {
        rest: exports.verifyChainRest,
        rpc: exports.verifyChainRpc,
        faucet: exports.verifyChainFaucet,
        exposer: exports.verifyChainExposer
    },
    ethereum: {
        rest: exports.verifyEthereumRest,
        rpc: exports.verifyEthereumRpc
    }
};