rubic-sdk-next/lib/features/on-chain/calculation-manager/common/on-chain-trade/tron-on-chain-trade/tron-on-chain-trade.js

Simplify dApp creation

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.TronOnChainTrade = void 0;
const errors_1 = require("../../../../../../common/errors");
const errors_2 = require("../../../../../../common/utils/errors");
const injector_1 = require("../../../../../../core/injector/injector");
const on_chain_trade_1 = require("../on-chain-trade");
class TronOnChainTrade extends on_chain_trade_1.OnChainTrade {
    get web3Public() {
        return injector_1.Injector.web3PublicService.getWeb3Public(this.from.blockchain);
    }
    get web3Private() {
        return injector_1.Injector.web3PrivateService.getWeb3PrivateByBlockchain(this.from.blockchain);
    }
    constructor(integratorAddress, apiQuote, apiResponse) {
        super(integratorAddress);
        this.lastTransactionConfig = null;
        this.apiQuote = apiQuote || null;
        this.apiResponse = apiResponse || null;
    }
    async approve(options, checkNeedApprove = true, amount = 'infinity') {
        if (checkNeedApprove) {
            const needApprove = await this.needApprove();
            if (!needApprove) {
                throw new errors_1.UnnecessaryApproveError();
            }
        }
        this.checkWalletConnected();
        await this.checkBlockchainCorrect();
        return this.web3Private.approveTokens(this.from.address, this.spenderAddress, amount, options);
    }
    async checkAllowanceAndApprove(options) {
        const needApprove = await this.needApprove();
        if (!needApprove) {
            return;
        }
        const approveOptions = {
            onTransactionHash: options?.onApprove,
            feeLimit: options?.approveFeeLimit
        };
        await this.approve(approveOptions, false);
    }
    async swap(options = {}) {
        await this.checkWalletState(options?.testMode);
        await this.checkAllowanceAndApprove(options);
        const { onConfirm } = options;
        let transactionHash;
        const onTransactionHash = (hash) => {
            if (onConfirm) {
                onConfirm(hash);
            }
            transactionHash = hash;
        };
        const fromAddress = this.walletAddress;
        const transactionData = await this.encode({
            ...options,
            fromAddress
        });
        const method = options?.testMode ? 'sendTransaction' : 'trySendTransaction';
        try {
            await this.web3Private[method](transactionData.to, transactionData.signature, transactionData.arguments, {
                onTransactionHash,
                ...(transactionData?.feeLimit && { feeLimit: transactionData.feeLimit }),
                ...(transactionData.callValue && { callValue: transactionData.callValue }),
                ...(transactionData.rawParameter && {
                    rawParameter: transactionData.rawParameter
                })
            });
            return transactionHash;
        }
        catch (err) {
            if (err instanceof errors_1.FailedToCheckForTransactionReceiptError) {
                return transactionHash;
            }
            throw (0, errors_2.parseError)(err);
        }
    }
    async encode(options) {
        await this.checkFromAddress(options.fromAddress, true);
        await this.checkReceiverAddress(options.receiverAddress);
        return this.setTransactionConfig(options);
    }
    async setTransactionConfig(options) {
        if (this.lastTransactionConfig && options.useCacheData) {
            return this.lastTransactionConfig;
        }
        const { tx, toAmount } = await this.getTransactionConfigAndAmount(options.receiverAddress);
        this.lastTransactionConfig = tx;
        setTimeout(() => {
            this.lastTransactionConfig = null;
        }, 15000);
        if (!options.skipAmountCheck) {
            this.checkAmountChange(toAmount, this.to.stringWeiAmount);
        }
        return tx;
    }
    async getTransactionConfigAndAmount(receiverAddress) {
        if (!this.apiResponse || !this.apiQuote) {
            throw new Error('Failed to load api response');
        }
        const swapRequestData = {
            ...this.apiQuote,
            fromAddress: this.walletAddress,
            receiver: receiverAddress || this.walletAddress,
            id: this.apiResponse.id
        };
        const { transaction, estimate } = await this.fetchSwapData(swapRequestData);
        const amount = estimate.destinationWeiAmount;
        return { tx: transaction, toAmount: amount };
    }
    async encodeApprove(tokenAddress, spenderAddress, value, options = {}) {
        return this.web3Private.encodeApprove(tokenAddress, spenderAddress, value, options);
    }
}
exports.TronOnChainTrade = TronOnChainTrade;
//# sourceMappingURL=tron-on-chain-trade.js.map