Senden Sie benutzerdefinierte ERC20-Token von einer Adresse an eine andere

Ich gehe davon aus, dass Sie Web3j und einen bereitgestellten Smart Contract verwenden, der die ERC20-Schnittstelle implementiert, wobei die Übertragungsmethode wie folgt aussieht:

function transfer(address _to, uint256 _value) public returns (bool success) {
    require(balances[msg.sender] >= _value && _value > 0);
    balances[msg.sender] -= _value;
    balances[_to] += _value;
    return true;
}

Sie können den web3j-Wrapper für Ihren Vertrag verwenden, um Vertragsmethoden auf einem Blockahain aufzurufen. Angenommen, Ihr Contract-Dateiname lautet MyContract.sol, dann benötigen Sie den Solc- Compiler und das Web3j- Tool und tun Folgendes in Ihrer Konsole:

$ solc {contract}.sol --bin --abi --optimize -o {output-dir}/

Dadurch werden .abiund .binDateien generiert, aus denen Sie eine Java-Wrapper-Klasse generieren:

$ web3j solidity generate /path/to/<smart-contract>.bin /path/to/<smart-contract>.abi -o /path/to/src/main/java -p com.your.organisation.name

Dadurch wird eine Java-Wrapper-Klasse für Ihren Vertrag erstellt, MyContract.javain der Sie alle im Smart-Vertrag verfügbaren Methoden aufrufen können:

import static org.web3j.tx.Contract.GAS_LIMIT;
import static org.web3j.tx.ManagedTransaction.GAS_PRICE;

//web3j initialization code goes here

//Load the deployed contract:
MyContract contract = MyContract.load(contractAddress, web3j, credentials,     GAS_PRICE, GAS_LIMIT);

//Call methods on the contract:
Future<> result = contract.transfer(_to, _value);

Weitere Informationen zur Arbeit mit Smart Contracts Wrappern finden Sie hier . Ich hoffe, das hilft.

bearbeiten. abiund binfür diesen speziellen Vertrag können Sie von etherscan.io erhalten werden. Sie können Token übertragen, auch wenn Sie nicht der Eigentümer des Vertrags sind. Sie können jedoch nur verfügbare Token auf Ihr eigenes Konto übertragen, wie im Vertrag angegeben:

 function transfer(address _to, uint256 _amount) returns (bool success) {
     if (balances[msg.sender] >= _amount 
        && _amount > 0
         && balances[_to] + _amount > balances[_to]) {
         balances[msg.sender] -= _amount;
         balances[_to] += _amount;
         Transfer(msg.sender, _to, _amount);
        return true;
     } else {
         return false;
     }
 }

Inspiriert von @ITisha habe ich ein detaillierteres Beispiel wie unten.

Angenommen, wir wollen als Vertragseigentümer einige „Hundemünzen“ an eine andere Adresse senden .

Arbeit vorbereiten:

1. MeinVertrag.bin
2. DogCoin.abi

Schritte:

1. Generieren Sie eine Java-Wrapper-Datei über die Befehlszeile. Beachten Sie, dass macOS und Linux Unterschiede verursachen können. Linux wird empfohlen:

 web3j solidity generate /path/to/MyContract.bin /path/to/DogCoin.abi -o /path/to/src/main/DogCoin.java -p com.your.organisation.name

2.Dann ist unsere Kernfunktion zum Übertragen von Münzen:

public class EthereumTest {


     public static void transferCoins (String toAccount, int coinAmount){


         // if testing, use https://ropsten.etherscan.io/address/[Your contract address]
         Web3j web3 = Web3j.build(new HttpService("https://mainnet.infura.io/[your contract]"));  
         try{

                Web3ClientVersion web3ClientVersion = web3.web3ClientVersion().send();
                String clientVersion = web3ClientVersion.getWeb3ClientVersion();
                System.out.println("clientVersion " + clientVersion);

                String privateKey = "[ contract owner privateKey ]";
                BigInteger key = new BigInteger(privateKey,16); 
                ECKeyPair ecKeyPair = ECKeyPair.create(key.toByteArray()); 
                Credentials credentials = Credentials.create(ecKeyPair); 


                TransactionReceiptProcessor transactionReceiptProcessor = new NoOpProcessor(web3);
                TransactionManager transactionManager = new RawTransactionManager(
                        web3, credentials, ChainId.MAINNET, transactionReceiptProcessor);
                //if testing, use ChainId.ROPSTEN

                // need to use the java wrapper filed generated before
                DogCoin mycontract = DogCoin.load("[Your contract address]", web3, transactionManager, GAS_PRICE, GAS_LIMIT);


                BigInteger _value = BigInteger.valueOf((long) (coinAmount *Math.pow(10, 8)) );


                 try {

                    TransactionReceipt  mReceipt = mycontract.transfer(toAccount, _value).sendAsync().get();

                    String sTransHash = mReceipt.getTransactionHash();


                    System.out.println("toAccount: " + toAccount + " coinAmount: " + coinAmount + " transactionhash: " + sTransHash)

                    // You can view the transaction record on https://etherscan.io/tx/[transaction hash]
                    // if testing , on https://ropsten.etherscan.io/tx/[transaction hash]
                } catch (Exception e) {
                    System.out.println("Ethereum Exception " + e.getMessage());

                }

            }catch(IOException e){
                System.out.println("Ethereum IOException " + e.getMessage());

            }
     }


    public static void main(String[] args) { // unit testing

        String toAccount = "0x1xxxyyyzzz...";

        int coinAmount = 1; // e.g 1 dog coin

        transferCoins(toAccount, coinAmount); 

    }
}

Ein paar Kommentare:

a. Wir verwenden den Transaktionsmanager auf niedriger Ebene, um eine ASYC-Lösung zu erreichen, sodass wir Transaktionshash sofort erhalten können, wenn die Transaktion aussteht.

b. Wir können unseren eigenen GAS_PRICE und GAS_LIMIT definieren, hier verwenden wir den Standardwert der Bibliothek

c. mycontract.transfer() ist eine Methode aus dem Java-Wrapper-Code, der mit dem Vertrag generiert wurde