software.crldev.elrondspringbootstarterreactive.interactor.transaction.ErdTransactionInteractorImpl Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of elrond-spring-boot-starter-reactive Show documentation
A SpringBoot Starter solution designed to ensure easy and efficient integration with the Elrond Network using a Reactive API layer.
The newest version!
package software.crldev.elrondspringbootstarterreactive.interactor.transaction;

import reactor.core.publisher.Mono;
import software.crldev.elrondspringbootstarterreactive.api.ApiResourceURI;
import software.crldev.elrondspringbootstarterreactive.api.model.*;
import software.crldev.elrondspringbootstarterreactive.client.ErdProxyClient;
import software.crldev.elrondspringbootstarterreactive.domain.account.Address;
import software.crldev.elrondspringbootstarterreactive.domain.common.Nonce;
import software.crldev.elrondspringbootstarterreactive.domain.transaction.Transaction;
import software.crldev.elrondspringbootstarterreactive.domain.wallet.Wallet;
import software.crldev.elrondspringbootstarterreactive.error.exception.InvalidSentTransactionsException;
import software.crldev.elrondspringbootstarterreactive.error.exception.MissingTransactionRequestException;
import software.crldev.elrondspringbootstarterreactive.error.exception.ProxyRequestException;
import software.crldev.elrondspringbootstarterreactive.interactor.WrappedResponses;
import software.crldev.elrondspringbootstarterreactive.interactor.account.ErdAccountInteractor;
import java.util.ArrayList;
import java.util.List;
import static java.lang.String.format;

public class ErdTransactionInteractorImpl implements ErdTransactionInteractor {
    private final ErdProxyClient client;
    private final ErdAccountInteractor accountInteractor;

    @Override
    public Mono sendTransaction(Transaction.Sendable payload) {
        return client.post(ApiResourceURI.SEND_TRANSACTION.getURI(), payload, TransactionHash.class);
    }

    @Override
    public Mono sendTransaction(Wallet wallet, TransactionRequest request) {
        return assignNonce(wallet).map(nonce -> buildSendableFromRequest(wallet, request, nonce, false)).flatMap(this::sendTransaction);
    }

    @Override
    public Mono sendMultipleTransactions(List payloads) {
        return client.post(ApiResourceURI.SEND_MULTIPLE_TRANSACTIONS.getURI(), payloads.toArray(), TransactionsSentResult.class).map(this::processSendTransactions);
    }

    @Override
    public Mono sendMultipleTransactions(Wallet wallet, List request) {
        request.stream().findFirst().orElseThrow(MissingTransactionRequestException::new);
        return assignNonce(wallet).map(n -> {
            var listOfSendables = new ArrayList();
            for (long i = 0, nonce = n; i < request.size() && nonce <= nonce + request.size(); i++, nonce++) listOfSendables.add(buildSendableFromRequest(wallet, request.get((int) i), nonce, false));
            return listOfSendables;
        }).flatMap(this::sendMultipleTransactions);
    }

    @Override
    public Mono simulateTransaction(Transaction.Sendable payload) {
        return client.post(ApiResourceURI.SIMULATE_TRANSACTION.getURI(), payload, WrappedResponses.SimulateTransactionResponse.class).map(WrappedResponses.SimulateTransactionResponse::getResult);
    }

    @Override
    public Mono simulateTransaction(Wallet wallet, TransactionRequest request) {
        return assignNonce(wallet).map(nonce -> buildSendableFromRequest(wallet, request, nonce, false)).flatMap(this::simulateTransaction);
    }

    @Override
    public Mono estimateTransactionCost(Transaction.Sendable payload) {
        return client.post(ApiResourceURI.ESTIMATE_TRANSACTION_COST.getURI(), payload, TransactionCostEstimation.class).map(this::processCostEstimation);
    }

    @Override
    public Mono estimateTransactionCost(Wallet wallet, TransactionRequest request) {
        return assignNonce(wallet).map(nonce -> buildSendableFromRequest(wallet, request, nonce, true)).flatMap(this::estimateTransactionCost);
    }

    @Override
    public Mono queryTransactionInfo(String transactionHash, boolean withResults) {
        return client.get(format(ApiResourceURI.TRANSACTION_ON_NETWORK.getURI(), transactionHash, withResults), WrappedResponses.QueryTransactionResponse.class).map(WrappedResponses.QueryTransactionResponse::getTransaction);
    }

    @Override
    public Mono queryTransactionStatus(String transactionHash) {
        return client.get(format(ApiResourceURI.TRANSACTION_STATUS.getURI(), transactionHash), TransactionStatus.class);
    }

    private TransactionCostEstimation processCostEstimation(TransactionCostEstimation estimation) {
        if (estimation.getTransactionGasUnits().equals("0")) throw new ProxyRequestException(estimation.getReturnMessage());
        return estimation;
    }

    private TransactionsSentResult processSendTransactions(TransactionsSentResult result) {
        if (result.getNumberOfSentTransactions() == 0) throw new InvalidSentTransactionsException();
        return result;
    }

    private Transaction.Sendable buildSendableFromRequest(Wallet wallet, TransactionRequest request, Long nonceValue, boolean isEstimationRequest) {
        var transaction = new Transaction();
        transaction.setValue(request.getValue());
        transaction.setNonce(Nonce.fromLong(nonceValue));
        transaction.setReceiver(request.getReceiverAddress());
        transaction.setSender(Address.fromHex(wallet.getPublicKeyHex()));
        transaction.setPayloadData(request.getData());
        transaction.setIsEstimation(isEstimationRequest);
        if (!request.getGasLimit().isZero()) transaction.setGasLimit(request.getGasLimit());
        wallet.sign(transaction);
        return transaction.toSendable();
    }

    private Mono assignNonce(Wallet wallet) {
        return accountInteractor.getNonce(Address.fromHex(wallet.getPublicKeyHex())).map(AccountNonce::getNonce);
    }

    public ErdTransactionInteractorImpl(final ErdProxyClient client, final ErdAccountInteractor accountInteractor) {
        this.client = client;
        this.accountInteractor = accountInteractor;
    }
}