¿Cómo acceder al contrato inteligente de ethereum (ya implementado) en una aplicación Java a través de su dirección usando web3j?

use ERC20 Class of java, luego cargue su contrato después de implementarlo desde remix ide a cualquier red aquí hay un pequeño fragmento de mi código:

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;
}

Puede hacerlo, consulte la documentación de web3j aquí https://docs.web3j.io/transactions.html

En la sección Transacción en la página

1- Creación de un contrato inteligente.

2- Transacciones con un contrato inteligente.

3- Consultar el estado de un contrato inteligente.

Por 1 y 2 no olvide firmar la Transacción. aquí un ejemplo sencillo:

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();

Estuve explorando esto recientemente para que una aplicación de Android interactúe con contratos de token ERC20 arbitrarios. Puedes hacerlo utilizando la dirección y bin del contrato.

Mi proceso para hacerlo fue crear la clase contenedora para un contrato relacionado, encontrar las funciones que necesitaba (así como las funciones de "carga"), luego copiarlas en una clase contenedora "genérica" ​​recién creada que podría trabajar con cualquier contrato arbitrario en lugar de tener que estar vinculado a uno solo que tenga un envoltorio pregenerado. Siempre que haya escrito las funciones que usará en el contenedor genérico, funcionará bien. Esto funciona mejor si está haciendo algo como interactuar con contratos de token ERC20, ya que tienen funciones estándar (transferencia, totalSupply, etc.). Aquí hay un fragmento de mi código del contenedor que funcionaría con cualquier token ERC20 dado el contenedor, la dirección, las credenciales de la billetera y algunas otras cosas que se han recuperado:

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);
}

El resto del trabajo pesado se hace detrás de escena con web3j, solo tiene que cambiar la función de carga para que tome el binario junto con los otros parámetros y pueda cargarlo con:

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

y desde allí llama a tus funciones:

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

Este es de alguna manera el estándar para interactuar con un contrato inteligente a través de web3.js y vincularlo en su interfaz

<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>