VTWithMemo.java

package com.klaytn.example.caver;


import com.klaytn.caver.Caver;
import com.klaytn.caver.crpyto.KlayCredentials;
import com.klaytn.caver.fee.FeePayerManager;
import com.klaytn.caver.methods.response.KlayTransactionReceipt;
import com.klaytn.caver.tx.gas.DefaultGasProvider;
import com.klaytn.caver.tx.manager.PollingTransactionReceiptProcessor;
import com.klaytn.caver.tx.model.ValueTransferTransaction;
import com.klaytn.caver.tx.type.TxType;
import com.klaytn.caver.utils.ChainId;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.web3j.protocol.core.DefaultBlockParameter;
import org.web3j.protocol.core.DefaultBlockParameterName;

import java.io.IOException;
import java.math.BigInteger;

public class FeeDelegatedVTWithMemo {
    private static final Logger logger = LoggerFactory.getLogger(FeeDelegatedTxExample.class.getSimpleName());
    private static final BigInteger GAS_LIMIT = new DefaultGasProvider().getGasLimit();

    private static DefaultBlockParameter BLK_PARAM = DefaultBlockParameterName.LATEST;

    private static int CHAIN_ID;

    private static Caver caver;

    private static KlayCredentials senderCredential;
    private static KlayCredentials payerCredential;
    private static KlayCredentials recipientCredential;

    @BeforeClass
    public static void setup() {
        CHAIN_ID = ChainId.BAOBAB_TESTNET;
        caver = Caver.build("https://api.baobab.klaytn.net:8651/");

        // arbitrary accounts
        senderCredential = KlayCredentials.create("key1");
        payerCredential = KlayCredentials.create("key2");
        recipientCredential = KlayCredentials.create("key3");
    }

    @Test
    public void VTWithMemoTest() throws IOException {
        BigInteger senderBalance = caver.klay().getBalance(senderCredential.getAddress(), BLK_PARAM).send().getValue();
        BigInteger payerBalance = caver.klay().getBalance(payerCredential.getAddress(), BLK_PARAM).send().getValue();
        BigInteger recipientBalance = caver.klay().getBalance(recipientCredential.getAddress(), BLK_PARAM).send().getValue();

        logger.info("sender.balance\t=\t{}", senderBalance);
        logger.info("payer.balance\t=\t{}", payerBalance);
        logger.info("recipient.balance\t=\t{}", recipientBalance);

        System.out.println(">>> Sender:\t" + senderCredential.getAddress());
        System.out.println(">>> Payer:\t" + payerCredential.getAddress());

        BigInteger nonce = caver.klay().getTransactionCount(senderCredential.getAddress(), BLK_PARAM).send().getValue();
        TxType tx = ValueTransferTransaction
                .create(senderCredential.getAddress(), recipientCredential.getAddress(), BigInteger.ONE, GAS_LIMIT)
                .nonce(nonce)
                .memo("Hello, memo")
                .buildFeeDelegated();
        String rawTx = tx.sign(senderCredential, CHAIN_ID).getValueAsString();

        FeePayerManager feePayerManager = new FeePayerManager.Builder(caver, payerCredential)
                .setTransactionReceiptProcessor(new PollingTransactionReceiptProcessor(caver, 1000, 10))
                .setChainId(CHAIN_ID)
                .build();

        System.out.println(">>> Sending TX");

        KlayTransactionReceipt.TransactionReceipt transactionReceipt = feePayerManager.executeTransaction(rawTx);
        Assert.assertEquals(1, Integer.decode(transactionReceipt.getStatus()).intValue()); // status should be 0x1 if succeeded

        BigInteger senderBalance2 = caver.klay().getBalance(senderCredential.getAddress(), BLK_PARAM).send().getValue();
        BigInteger payerBalance2 = caver.klay().getBalance(payerCredential.getAddress(), BLK_PARAM).send().getValue();
        BigInteger recipientBalance2 = caver.klay().getBalance(recipientCredential.getAddress(), BLK_PARAM).send().getValue();

        logger.info("sender.balance\t=\t{}", senderBalance2);
        logger.info("payer.balance\t=\t{}", payerBalance2);
        logger.info("recipient.balance\t=\t{}", recipientBalance2);

        Assert.assertEquals(-1, senderBalance2.subtract(senderBalance).intValue());
        Assert.assertEquals(1, recipientBalance2.subtract(recipientBalance).intValue());
    }
}