chaingate/dist/cjs/Currencies/CurrencyUtils/abstract/EvmCurrencyUtils.js

A complete TypeScript library for connecting to and making transactions on different blockchains

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.EvmCurrencyUtils = void 0;
const CurrencyUtils_1 = require("../CurrencyUtils");
const Client_1 = require("../../../Client");
const Utils_1 = require("../../../InternalUtils/Utils");
const NumberLike_1 = require("../../../InternalUtils/NumberLike");
const ethers_1 = require("ethers");
class EvmCurrencyUtils extends CurrencyUtils_1.CurrencyUtils {
    network;
    constructor(context, currencyInfo, network) {
        super(context, currencyInfo);
        this.network = network;
    }
    async addressBalance(address) {
        const result = await (0, Client_1.evmAddressBalance)({
            client: this.context.client,
            path: { network: this.network },
            query: { address },
        });
        return {
            confirmed: this.buildAmount(result.data.confirmed),
            unconfirmed: this.buildAmount(result.data.unconfirmed),
        };
    }
    async addressTransactionCount(address) {
        const result = await (0, Client_1.evmAddressTransactionCount)({
            client: this.context.client,
            path: { network: this.network },
            query: { address },
        });
        return Number(result.data);
    }
    async callSmartContractRaw(smartContractAddress, data) {
        const result = await (0, Client_1.evmCallSmartContractFunction)({
            client: this.context.client,
            path: { network: this.network },
            body: { contract: smartContractAddress, data },
        });
        return result.data.result;
    }
    async estimateGas(addressFrom, addressTo, amount, nonce, data) {
        const result = await (0, Client_1.evmEstimateGas)({
            client: this.context.client,
            path: { network: this.network },
            query: {
                addressFrom,
                addressTo,
                amount: amount.baseAmount.toString(),
                nonce: (0, NumberLike_1.toDecimal)(nonce).toString(),
                data: data.toString(),
            },
        });
        return Number(result.data);
    }
    async broadcastTransaction(transactionRaw) {
        const result = await (0, Client_1.evmBroadcastTransaction)({
            client: this.context.client,
            path: { network: this.network },
            body: {
                transactionRaw: transactionRaw instanceof Uint8Array
                    ? (0, Utils_1.bytesToHex)(transactionRaw, false)
                    : transactionRaw,
            },
        });
        return { transactionId: result.data.txId };
    }
    async transactionDetails(transactionId) {
        const result = await (0, Client_1.evmTransactionDetails)({
            client: this.context.client,
            path: { network: this.network },
            query: { transactionId },
        });
        return {
            amount: this.buildAmount(result.data.amount),
            blockHeight: result.data.blockHeight ?? null,
            addressFrom: result.data.from,
            addressTo: result.data.to,
            gas: (0, NumberLike_1.toDecimal)(result.data.gas),
            gasPrice: this.buildAmount(result.data.gasPrice),
            maxFeePerGas: this.buildAmount(result.data.maxFeePerGas),
            maxPriorityFeePerGas: this.buildAmount(result.data.maxPriorityFeePerGas),
            transfers: result.data.transfers.map((transfer) => ({
                amount: this.buildAmount(transfer.amount),
                addressFrom: transfer.from,
                addressTo: transfer.to,
            })),
        };
    }
    async getFeeRate() {
        const result = await (0, Client_1.evmFeeRate)({
            client: this.context.client,
            path: { network: this.network },
        });
        return result.data;
    }
    async networkStatus() {
        const result = await (0, Client_1.evmNetworkStatus)({
            client: this.context.client,
            path: { network: this.network },
        });
        return result.data;
    }
    publicKeyToAddress(publicKey) {
        return ethers_1.ethers.computeAddress((0, Utils_1.bytesToHex)(publicKey.raw, true));
    }
    async signMessage(message, privateKey) {
        const signer = new ethers_1.ethers.Wallet(new ethers_1.SigningKey(privateKey.raw));
        return await signer.signMessage(message);
    }
    async verifySignedMessage(message, signature, address) {
        try {
            const recoveredAddress = (0, ethers_1.verifyMessage)(message, signature);
            return recoveredAddress == address;
        }
        catch (_ex) {
            return false;
        }
    }
    async latestBlock() {
        const result = await (0, Client_1.evmLatestBlock)({
            client: this.context.client,
            path: { network: this.network },
        });
        return result.data;
    }
    async blockByHeight(blockHeight) {
        const result = await (0, Client_1.evmBlockByHeight)({
            client: this.context.client,
            path: { network: this.network },
            query: { blockHeight },
        });
        return result.data;
    }
    async blockByHash(blockHash) {
        const result = await (0, Client_1.evmBlockByHash)({
            client: this.context.client,
            path: { network: this.network },
            query: { blockHash },
        });
        return result.data;
    }
}
exports.EvmCurrencyUtils = EvmCurrencyUtils;
//# sourceMappingURL=EvmCurrencyUtils.js.map