Wie greife ich auf Ethereum Smart Contract (bereits bereitgestellt) in einer Java-Anwendung über seine Adresse mit web3j zu?

Verwenden Sie die ERC20-Klasse von Java und laden Sie dann Ihren Vertrag, nachdem Sie ihn von der Remix-IDE in einem beliebigen Netzwerk bereitgestellt haben. Hier ist ein kleiner Ausschnitt meines Codes:

public class TokenAPI {
@Path("/erc")
@GET
@Produces(MediaType.APPLICATION_JSON)
public Erc20Controller getErcTokenInfo() throws Exception{
    Web3j web3 = Web3j.build(new HttpService("HTTP:YourNetwrok"));
    Credentials creds = Credentials.create("b1427aa43d62f7592feff8874d20fa42d9dbc96005d2a1c8a5cfdd55ebbfca62");
    String contractAddress = "0x82b575F93bEffea73C3C3bb776C82F8D67cb064e"; // The deployed contract address, taken

    ERC20 javaToken = ERC20.load(contractAddress, web3, creds, new DefaultGasProvider());

    Erc20Controller erc=new Erc20Controller();
    erc.setTotalSupply(javaToken.totalSupply().send());
    erc.setTokenSymbol(javaToken.symbol().send());
    erc.setTotalDecimal(javaToken.decimals().send());
    erc.setTokenName(javaToken.name().send());
    erc.setTotalBalanceOnDeployedAccount(javaToken.balanceOf("0x82b575F93bEffea73C3C3bb776C82F8D67cb064e").send());
    return erc;
}

Sie können das tun, siehe die Dokumentation von web3j hier https://docs.web3j.io/transactions.html

Im Transaktionsbereich unten auf der Seite

1- Erstellung eines Smart Contracts.

2- Transaktionen mit einem Smart Contract.

3- Abfragen des Zustands eines Smart Contracts.

Bei 1 & 2 vergessen Sie nicht, die Transaktion zu unterschreiben. hier ein einfaches beispiel:

EthGetTransactionCount ethGetTransactionCount = web3j
                .ethGetTransactionCount("account-address", DefaultBlockParameterName.LATEST).send();
BigInteger nonce = ethGetTransactionCount.getTransactionCount();

// Encode the function
final Function function = new Function(
                "method-name example transfer",
                Arrays.<Type>asList(new org.web3j.abi.datatypes.Address("first parameter example fromAddress"),
                new org.web3j.abi.datatypes.Address("example toAddress"),
                new org.web3j.abi.datatypes.generated.Int256("example value")),
                Collections.<TypeReference<?>>emptyList());
String encodedFunction = FunctionEncoder
                .encode(contractFunctionProvider.getFunction(function);

// Create new Transaction
RawTransaction rawTransaction = RawTransaction.createTransaction(nonce, GASPRICE, GASLIMIT, "contract address", BigInteger.ZERO, encodedFunction);

// Sign the Transaction
byte[] signedMessage = TransactionEncoder.signMessage(rawTransaction, credentials);
String hexValue = Numeric.toHexString(signedMessage);

// Send the Transaction
 org.web3j.protocol.core.methods.response.EthSendTransaction transactionResponse = web3j
                .ethSendRawTransaction(hexValue).sendAsync().get();

Ich habe dies kürzlich nach einer Android-Anwendung untersucht, um mit beliebigen ERC20-Token-Verträgen zu interagieren. Sie können dies anhand der Adresse und des Behälters des Vertrags tun.

Mein Prozess dafür bestand darin, die Wrapper-Klasse für einen verwandten Vertrag zu erstellen, die Funktionen darin zu finden, die ich brauchte (sowie die „Lade“-Funktionen), und diese dann in eine neu erstellte „generische“ Wrapper-Klasse zu kopieren, die es könnte mit jedem beliebigen Vertrag arbeiten, anstatt nur an einen gebunden zu sein, der einen vorgenerierten Wrapper hat. Solange Sie die Funktionen, die Sie verwenden werden, in den generischen Wrapper geschrieben haben, wird es gut funktionieren. Dies funktioniert am besten, wenn Sie so etwas wie die Interaktion mit ERC20-Token-Verträgen tun, da diese Standardfunktionen (Transfer, TotalSupply usw.) haben. Hier ist ein Ausschnitt meines Codes aus dem Wrapper, der mit jedem ERC20-Token funktionieren würde, wenn Bin, Adresse, Wallet-Anmeldeinformationen und einige andere Dinge abgerufen wurden:

public RemoteCall<TransactionReceipt> transfer(String to, BigInteger tokens) {
    Function function = new Function(
            "transfer", 
            Arrays.<Type>asList(new org.web3j.abi.datatypes.Address(to), 
            new org.web3j.abi.datatypes.generated.Uint256(tokens)), 
            Collections.<TypeReference<?>>emptyList());
    return executeRemoteCallTransaction(function);
}

//...

public static Web3jWrapper load(String contractAddress, Web3j web3j, Credentials credentials, BigInteger gasPrice, BigInteger gasLimit, String binary) {
    BINARY = binary;
        return Web3jWrapper(contractAddress, web3j, credentials, gasPrice, gasLimit);
}

Der Rest der schweren Arbeit wird hinter den Kulissen mit web3j erledigt, Sie müssen nur die Ladefunktion so ändern, dass sie die Binärdatei zusammen mit den anderen Parametern übernimmt und Sie sie laden können mit:

GenericSmartContract contract = GenericSmartContract.load(
    "0x<address>|<ensName>", web3j, credentials, GAS_PRICE, GAS_LIMIT, binary);

und rufen Sie von dort aus Ihre Funktionen auf:

TransactionReceipt receipt = contract.transfer("0x1234567890123456",100000).send();

Dies ist so etwas wie der Standard für die Interaktion mit einem Smart Contract über web3.js und die Verknüpfung mit Ihrem Frontend

<script>

    if (typeof web3 !== 'undefined') {
       web3 = new Web3(web3.currentProvider);
   } else {
       web3 = new Web3(new Web3.providers.HttpProvider("http://localhost:8545"));
   }
   var contractAddress = 'youContractAddress';

   web3.eth.defaultAccount = web3.eth.accounts[0];

   var MyContract = web3.eth.contract();

   var MySiteContract = MyContract.at(contractAddress);

</script>