@broxus/js-bridge-essentials/dist/cjs/models/evm-ton-event-alien/EvmTonEventAlienUtils.js

Bridge JavaScript Essentials library

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.EvmTonEventAlienUtils = void 0;
const js_core_1 = require("@broxus/js-core");
const contracts_1 = require("../../models/evm-ton-event-alien/contracts");
class EvmTonEventAlienUtils {
    static async approveLimit(provider, eventAddress, args) {
        return (0, contracts_1.evmTonEventAlienContract)(provider, eventAddress)
            .methods.approveLimit()
            .sendDelayed({ bounce: true, ...args });
    }
    static async cancel(provider, eventAddress, params, args) {
        return (0, contracts_1.evmTonEventAlienContract)(provider, eventAddress)
            .methods.cancel({
            _callback: {
                payload: params.callback.payload,
                recipient: params.callback.recipient,
                strict: params.callback.strict,
            },
            _expectedGasReceiver: (0, js_core_1.resolveTvmAddress)(params.expectedGasReceiver),
            _newRecipient: params.newRecipient,
            _remainingGasTo: (0, js_core_1.resolveTvmAddress)(params.remainingGasTo),
        })
            .sendDelayed({ bounce: true, ...args });
    }
    static async rejectLimit(provider, eventAddress, expectedGasReceiver, args) {
        return (0, contracts_1.evmTonEventAlienContract)(provider, eventAddress)
            .methods.rejectLimit({
            _expectedGasReceiver: (0, js_core_1.resolveTvmAddress)(expectedGasReceiver),
        })
            .sendDelayed({ bounce: true, ...args });
    }
    static async retry(provider, eventAddress, args) {
        return (0, contracts_1.evmTonEventAlienContract)(provider, eventAddress)
            .methods.retry()
            .sendDelayed({ bounce: true, ...args });
    }
    static async getDecodedData(connection, eventAddress, cachedState) {
        const state = cachedState ?? await (0, js_core_1.getFullContractState)(connection, eventAddress);
        const result = await (0, contracts_1.evmTonEventAlienContract)(connection, eventAddress)
            .methods.getDecodedData({ answerId: 0 })
            .call({ cachedState: state, responsible: true });
        return {
            amount: result.amount_,
            baseChainId: result.base_chainId_,
            baseToken: result.base_token_,
            decimals: Number(result.decimals_),
            expectedGas: result.expected_gas_,
            name: result.name_,
            payload: result.payload_,
            proxyAddress: result.proxy_,
            recipientAddress: result.recipient_,
            symbol: result.symbol_,
            tokenAddress: result.token_,
            value: result.value_,
        };
    }
    static async getDetails(connection, eventAddress, cachedState) {
        const state = cachedState ?? await (0, js_core_1.getFullContractState)(connection, eventAddress);
        const result = await (0, contracts_1.evmTonEventAlienContract)(connection, eventAddress)
            .methods.getDetails({ answerId: 0 })
            .call({ cachedState: state, responsible: true });
        return {
            balance: result.balance,
            confirms: result._confirms,
            empty: result.empty,
            eventInitData: {
                chainId: result._eventInitData.chainId,
                configuration: result._eventInitData.configuration,
                roundDeployer: result._eventInitData.roundDeployer,
                voteData: {
                    eventBlock: Number(result._eventInitData.voteData.eventBlock),
                    eventBlockNumber: Number(result._eventInitData.voteData.eventBlockNumber),
                    eventData: result._eventInitData.voteData.eventData,
                    eventIndex: Number(result._eventInitData.voteData.eventIndex),
                    eventTransaction: result._eventInitData.voteData.eventTransaction,
                },
            },
            initializer: result._initializer,
            meta: result._meta,
            rejects: result._rejects,
            requiredVotes: Number(result._requiredVotes),
            status: result._status,
        };
    }
    static async getEventInitData(connection, eventAddress, cachedState) {
        const state = cachedState ?? await (0, js_core_1.getFullContractState)(connection, eventAddress);
        const result = await (0, contracts_1.evmTonEventAlienContract)(connection, eventAddress)
            .methods.getEventInitData({ answerId: 0 })
            .call({ cachedState: state, responsible: true });
        return {
            chainId: result.value0.chainId,
            configuration: result.value0.configuration,
            roundDeployer: result.value0.roundDeployer,
            voteData: {
                eventBlock: Number(result.value0.voteData.eventBlock),
                eventBlockNumber: Number(result.value0.voteData.eventBlockNumber),
                eventData: result.value0.voteData.eventData,
                eventIndex: Number(result.value0.voteData.eventIndex),
                eventTransaction: result.value0.voteData.eventTransaction,
            },
        };
    }
    static async getTransitionalData(connection, eventAddress, cachedState) {
        const state = cachedState ?? await (0, js_core_1.getFullContractState)(connection, eventAddress);
        const result = await (0, contracts_1.evmTonEventAlienContract)(connection, eventAddress)
            .methods.getTransitionalData()
            .call({ cachedState: state });
        return {
            canonicalAddress: result.value0.canon,
            poolAddress: result.value0.pool,
            proxyAddress: result.value0.proxy,
            routerAddress: result.value0.router,
            targetAmount: result.value0.target_amount,
            targetTokenAddress: result.value0.target_token,
            tokenAddress: result.value0.token,
        };
    }
    static async limitApprover(connection, eventAddress, cachedState) {
        const state = cachedState ?? await (0, js_core_1.getFullContractState)(connection, eventAddress);
        const result = await (0, contracts_1.evmTonEventAlienContract)(connection, eventAddress)
            .methods.limitApprover()
            .call({ cachedState: state });
        return result.limitApprover;
    }
    static async nonce(connection, eventAddress, cachedState) {
        const state = cachedState ?? await (0, js_core_1.getFullContractState)(connection, eventAddress);
        const result = await (0, contracts_1.evmTonEventAlienContract)(connection, eventAddress)
            .methods.nonce()
            .call({ cachedState: state });
        return result.nonce;
    }
    static async relayRound(connection, eventAddress, cachedState) {
        const state = cachedState ?? await (0, js_core_1.getFullContractState)(connection, eventAddress);
        const result = await (0, contracts_1.evmTonEventAlienContract)(connection, eventAddress)
            .methods.relay_round()
            .call({ cachedState: state });
        return result.relay_round;
    }
    static async roundNumber(connection, eventAddress, cachedState) {
        const state = cachedState ?? await (0, js_core_1.getFullContractState)(connection, eventAddress);
        const result = await (0, contracts_1.evmTonEventAlienContract)(connection, eventAddress)
            .methods.round_number()
            .call({ cachedState: state });
        return Number(result.round_number);
    }
    static decodeEvent(connection, eventAddress, args) {
        return (0, contracts_1.evmTonEventAlienContract)(connection, eventAddress).decodeEvent(args);
    }
    static decodeTransaction(connection, eventAddress, args) {
        return (0, contracts_1.evmTonEventAlienContract)(connection, eventAddress).decodeTransaction(args);
    }
    static decodeTransactionEvents(connection, eventAddress, transaction) {
        return (0, contracts_1.evmTonEventAlienContract)(connection, eventAddress).decodeTransactionEvents({ transaction });
    }
}
exports.EvmTonEventAlienUtils = EvmTonEventAlienUtils;