我对生成的 web3j 文件 .java 有问题

Question

我在移动应用程序和区块链中有项目，我创建了我在项目 uinf Solidity 中很好使用的所有智能合约，这是我将使用的第一个：

// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;

contract UserRegistrationContract {
    // Enumération pour représenter le profil de l'utilisateur
    enum UserProfile { Requester, Worker }

    // Structure pour représenter un utilisateur
    struct User {
        UserProfile profile; // Profil de l'utilisateur (Requester ou Worker)
        uint256 points; // Point de l'utilisateur
    }

    // Mapping pour associer une adresse Ethereum à un utilisateur
    mapping(address => User) public users;

    // Ensembles pour stocker les adresses des Requesters et Workers
    address[] public requesterPool;
    address[] public workerPool;

    // Événements pour signaler l'enregistrement d'un utilisateur
    event UserRegistered(address indexed user, UserProfile profile, uint256 points);
    // Événements pour signaler l'ajout d'un utilisateur au pool
    event RequesterAdded(address indexed requester); //ajput de requester
    event WorkerAdded(address indexed worker); //ajout de worker

    // Fonction d'enregistrement d'un nouvel utilisateur
    function addUser(UserProfile profile, uint256 points) public returns (bool) {

        // Vérifiez si l'adresse n'est pas déjà dans l'ensemble des workers et requester
        require(profile != UserProfile.Worker || !isAddressInArray(msg.sender, workerPool), "Worker already registered");
        require(profile != UserProfile.Requester || !isAddressInArray(msg.sender, requesterPool), "Requester already registered");

        // Initialiser l'utilisateur avec ses données
        users[msg.sender] = User({
            profile: profile,
            points: points
        });

        // Émettre un événement pour signaler l'enregistrement de l'utilisateur
        emit UserRegistered(msg.sender, profile, points);

        // Ajouter l'adresse de l'utilisateur au pool approprié
        if (profile == UserProfile.Requester) { // si le profil est requester
            requesterPool.push(msg.sender);
            emit RequesterAdded(msg.sender);
        } else if (profile == UserProfile.Worker) { //si le profil est worker
            workerPool.push(msg.sender);
            emit WorkerAdded(msg.sender);
        }

        // Retourner vrai pour indiquer un enregistrement réussi
        return true;
    }

    // Fonction pour vérifier si une adresse existe dans un ensemble
    function isAddressInArray(address _address, address[] storage _array) internal view returns (bool) {
        for (uint256 i = 0; i < _array.length; i++) {
            if (_array[i] == _address) {
                return true;
            }
        }
        return false;
    }

    // Fonctions pour récupérer les adresses des Requesters et Workers
    function getRequesters() public view returns (address[] memory) {
        return requesterPool;
    }
    function getWorkers() public view returns (address[] memory) {
        return workerPool;
    }

    //Fonction pour verifier si l'address donnée est selle de requester
    function isRequesterRegistered(address requesterAddress) public view returns (bool) {
    return users[requesterAddress].profile == UserProfile.Requester;
    }

    //Fonction pour recuperer les points d'un utilisateur 
    function getPoints(address userAddress) public view returns (uint256) {
    return users[userAddress].points;}

    //Fonction pour ajouter des points au points d un utilisateur
    function addPoints(address userAddress, uint256 pointsToAdd) public {
    users[userAddress].points += pointsToAdd;
    }

    //Fonction pour retirer des poitns au points d un utilisateur
    function subtructPoints(address userAddress, uint256 pointsTosubtract) public {
    users[userAddress].points -= pointsTosubtract;
    }

}

这是生成的文件

@SuppressWarnings("rawtypes")
public class UserRegistrationContract extends Contract {
    public static final String BINARY = "3";

    public static final String FUNC_ADDPOINTS = "addPoints";

    public static final String FUNC_ADDUSER = "addUser";

    public static final String FUNC_GETPOINTS = "getPoints";

    public static final String FUNC_GETREQUESTERS = "getRequesters";

    public static final String FUNC_GETWORKERS = "getWorkers";

    public static final String FUNC_ISREQUESTERREGISTERED = "isRequesterRegistered";

    public static final String FUNC_REQUESTERPOOL = "requesterPool";

    public static final String FUNC_SUBTRUCTPOINTS = "subtructPoints";

    public static final String FUNC_USERS = "users";

    public static final String FUNC_WORKERPOOL = "workerPool";

    public static final Event REQUESTERADDED_EVENT = new Event("RequesterAdded", 
            Arrays.<TypeReference<?>>asList(new TypeReference<Address>(true) {}));
    ;

    public static final Event USERREGISTERED_EVENT = new Event("UserRegistered", 
            Arrays.<TypeReference<?>>asList(new TypeReference<Address>(true) {}, new TypeReference<Uint8>() {}, new TypeReference<Uint256>() {}));
    ;

    public static final Event WORKERADDED_EVENT = new Event("WorkerAdded", 
            Arrays.<TypeReference<?>>asList(new TypeReference<Address>(true) {}));
    ;

    @Deprecated
    protected UserRegistrationContract(String contractAddress, Web3j web3j, Credentials credentials, BigInteger gasPrice, BigInteger gasLimit) {
        super(BINARY, contractAddress, web3j, credentials, gasPrice, gasLimit);
    }

    protected UserRegistrationContract(String contractAddress, Web3j web3j, Credentials credentials, ContractGasProvider contractGasProvider) {
        super(BINARY, contractAddress, web3j, credentials, contractGasProvider);
    }

    @Deprecated
    protected UserRegistrationContract(String contractAddress, Web3j web3j, TransactionManager transactionManager, BigInteger gasPrice, BigInteger gasLimit) {
        super(BINARY, contractAddress, web3j, transactionManager, gasPrice, gasLimit);
    }

    protected UserRegistrationContract(String contractAddress, Web3j web3j, TransactionManager transactionManager, ContractGasProvider contractGasProvider) {
        super(BINARY, contractAddress, web3j, transactionManager, contractGasProvider);
    }

    public static List<RequesterAddedEventResponse> getRequesterAddedEvents(TransactionReceipt transactionReceipt) {
        List<Contract.EventValuesWithLog> valueList = staticExtractEventParametersWithLog(REQUESTERADDED_EVENT, transactionReceipt);
        ArrayList<RequesterAddedEventResponse> responses = new ArrayList<RequesterAddedEventResponse>(valueList.size());
        for (Contract.EventValuesWithLog eventValues : valueList) {
            RequesterAddedEventResponse typedResponse = new RequesterAddedEventResponse();
            typedResponse.log = eventValues.getLog();
            typedResponse.requester = (String) eventValues.getIndexedValues().get(0).getValue();
            responses.add(typedResponse);
        }
        return responses;
    }

    public static RequesterAddedEventResponse getRequesterAddedEventFromLog(Log log) {
        Contract.EventValuesWithLog eventValues = staticExtractEventParametersWithLog(REQUESTERADDED_EVENT, log);
        RequesterAddedEventResponse typedResponse = new RequesterAddedEventResponse();
        typedResponse.log = log;
        typedResponse.requester = (String) eventValues.getIndexedValues().get(0).getValue();
        return typedResponse;
    }

    public Flowable<RequesterAddedEventResponse> requesterAddedEventFlowable(EthFilter filter) {
        return web3j.ethLogFlowable(filter).map(log -> getRequesterAddedEventFromLog(log));
    }

    public Flowable<RequesterAddedEventResponse> requesterAddedEventFlowable(DefaultBlockParameter startBlock, DefaultBlockParameter endBlock) {
        EthFilter filter = new EthFilter(startBlock, endBlock, getContractAddress());
        filter.addSingleTopic(EventEncoder.encode(REQUESTERADDED_EVENT));
        return requesterAddedEventFlowable(filter);
    }

    public static List<UserRegisteredEventResponse> getUserRegisteredEvents(TransactionReceipt transactionReceipt) {
        List<Contract.EventValuesWithLog> valueList = staticExtractEventParametersWithLog(USERREGISTERED_EVENT, transactionReceipt);
        ArrayList<UserRegisteredEventResponse> responses = new ArrayList<UserRegisteredEventResponse>(valueList.size());
        for (Contract.EventValuesWithLog eventValues : valueList) {
            UserRegisteredEventResponse typedResponse = new UserRegisteredEventResponse();
            typedResponse.log = eventValues.getLog();
            typedResponse.user = (String) eventValues.getIndexedValues().get(0).getValue();
            typedResponse.profile = (BigInteger) eventValues.getNonIndexedValues().get(0).getValue();
            typedResponse.points = (BigInteger) eventValues.getNonIndexedValues().get(1).getValue();
            responses.add(typedResponse);
        }
        return responses;
    }

    public static UserRegisteredEventResponse getUserRegisteredEventFromLog(Log log) {
        Contract.EventValuesWithLog eventValues = staticExtractEventParametersWithLog(USERREGISTERED_EVENT, log);
        UserRegisteredEventResponse typedResponse = new UserRegisteredEventResponse();
        typedResponse.log = log;
        typedResponse.user = (String) eventValues.getIndexedValues().get(0).getValue();
        typedResponse.profile = (BigInteger) eventValues.getNonIndexedValues().get(0).getValue();
        typedResponse.points = (BigInteger) eventValues.getNonIndexedValues().get(1).getValue();
        return typedResponse;
    }

    public Flowable<UserRegisteredEventResponse> userRegisteredEventFlowable(EthFilter filter) {
        return web3j.ethLogFlowable(filter).map(log -> getUserRegisteredEventFromLog(log));
    }

    public Flowable<UserRegisteredEventResponse> userRegisteredEventFlowable(DefaultBlockParameter startBlock, DefaultBlockParameter endBlock) {
        EthFilter filter = new EthFilter(startBlock, endBlock, getContractAddress());
        filter.addSingleTopic(EventEncoder.encode(USERREGISTERED_EVENT));
        return userRegisteredEventFlowable(filter);
    }

    public static List<WorkerAddedEventResponse> getWorkerAddedEvents(TransactionReceipt transactionReceipt) {
        List<Contract.EventValuesWithLog> valueList = staticExtractEventParametersWithLog(WORKERADDED_EVENT, transactionReceipt);
        ArrayList<WorkerAddedEventResponse> responses = new ArrayList<WorkerAddedEventResponse>(valueList.size());
        for (Contract.EventValuesWithLog eventValues : valueList) {
            WorkerAddedEventResponse typedResponse = new WorkerAddedEventResponse();
            typedResponse.log = eventValues.getLog();
            typedResponse.worker = (String) eventValues.getIndexedValues().get(0).getValue();
            responses.add(typedResponse);
        }
        return responses;
    }

    public static WorkerAddedEventResponse getWorkerAddedEventFromLog(Log log) {
        Contract.EventValuesWithLog eventValues = staticExtractEventParametersWithLog(WORKERADDED_EVENT, log);
        WorkerAddedEventResponse typedResponse = new WorkerAddedEventResponse();
        typedResponse.log = log;
        typedResponse.worker = (String) eventValues.getIndexedValues().get(0).getValue();
        return typedResponse;
    }

    public Flowable<WorkerAddedEventResponse> workerAddedEventFlowable(EthFilter filter) {
        return web3j.ethLogFlowable(filter).map(log -> getWorkerAddedEventFromLog(log));
    }

    public Flowable<WorkerAddedEventResponse> workerAddedEventFlowable(DefaultBlockParameter startBlock, DefaultBlockParameter endBlock) {
        EthFilter filter = new EthFilter(startBlock, endBlock, getContractAddress());
        filter.addSingleTopic(EventEncoder.encode(WORKERADDED_EVENT));
        return workerAddedEventFlowable(filter);
    }

    public RemoteFunctionCall<TransactionReceipt> addPoints(String userAddress, BigInteger pointsToAdd) {
        final Function function = new Function(
                FUNC_ADDPOINTS, 
                Arrays.<Type>asList(new org.web3j.abi.datatypes.Address(160, userAddress), 
                new org.web3j.abi.datatypes.generated.Uint256(pointsToAdd)), 
                Collections.<TypeReference<?>>emptyList());
        return executeRemoteCallTransaction(function);
    }

    public RemoteFunctionCall<TransactionReceipt> addUser(BigInteger profile, BigInteger points) {
        final Function function = new Function(
                FUNC_ADDUSER, 
                Arrays.<Type>asList(new org.web3j.abi.datatypes.generated.Uint8(profile), 
                new org.web3j.abi.datatypes.generated.Uint256(points)), 
                Collections.<TypeReference<?>>emptyList());
        return executeRemoteCallTransaction(function);
    }

    public RemoteFunctionCall<BigInteger> getPoints(String userAddress) {
        final Function function = new Function(FUNC_GETPOINTS, 
                Arrays.<Type>asList(new org.web3j.abi.datatypes.Address(160, userAddress)), 
                Arrays.<TypeReference<?>>asList(new TypeReference<Uint256>() {}));
        return executeRemoteCallSingleValueReturn(function, BigInteger.class);
    }

    public RemoteFunctionCall<List> getRequesters() {
        final Function function = new Function(FUNC_GETREQUESTERS, 
                Arrays.<Type>asList(), 
                Arrays.<TypeReference<?>>asList(new TypeReference<DynamicArray<Address>>() {}));
        return new RemoteFunctionCall<List>(function,
                new Callable<List>() {
                    @Override
                    @SuppressWarnings("unchecked")
                    public List call() throws Exception {
                        List<Type> result = (List<Type>) executeCallSingleValueReturn(function, List.class);
                        return convertToNative(result);
                    }
                });
    }

    public RemoteFunctionCall<List> getWorkers() {
        final Function function = new Function(FUNC_GETWORKERS, 
                Arrays.<Type>asList(), 
                Arrays.<TypeReference<?>>asList(new TypeReference<DynamicArray<Address>>() {}));
        return new RemoteFunctionCall<List>(function,
                new Callable<List>() {
                    @Override
                    @SuppressWarnings("unchecked")
                    public List call() throws Exception {
                        List<Type> result = (List<Type>) executeCallSingleValueReturn(function, List.class);
                        return convertToNative(result);
                    }
                });
    }

    public RemoteFunctionCall<Boolean> isRequesterRegistered(String requesterAddress) {
        final Function function = new Function(FUNC_ISREQUESTERREGISTERED, 
                Arrays.<Type>asList(new org.web3j.abi.datatypes.Address(160, requesterAddress)), 
                Arrays.<TypeReference<?>>asList(new TypeReference<Bool>() {}));
        return executeRemoteCallSingleValueReturn(function, Boolean.class);
    }

    public RemoteFunctionCall<String> requesterPool(BigInteger param0) {
        final Function function = new Function(FUNC_REQUESTERPOOL, 
                Arrays.<Type>asList(new org.web3j.abi.datatypes.generated.Uint256(param0)), 
                Arrays.<TypeReference<?>>asList(new TypeReference<Address>() {}));
        return executeRemoteCallSingleValueReturn(function, String.class);
    }

    public RemoteFunctionCall<TransactionReceipt> subtructPoints(String userAddress, BigInteger pointsTosubtract) {
        final Function function = new Function(
                FUNC_SUBTRUCTPOINTS, 
                Arrays.<Type>asList(new org.web3j.abi.datatypes.Address(160, userAddress), 
                new org.web3j.abi.datatypes.generated.Uint256(pointsTosubtract)), 
                Collections.<TypeReference<?>>emptyList());
        return executeRemoteCallTransaction(function);
    }

    public RemoteFunctionCall<Tuple2<BigInteger, BigInteger>> users(String param0) {
        final Function function = new Function(FUNC_USERS, 
                Arrays.<Type>asList(new org.web3j.abi.datatypes.Address(160, param0)), 
                Arrays.<TypeReference<?>>asList(new TypeReference<Uint8>() {}, new TypeReference<Uint256>() {}));
        return new RemoteFunctionCall<Tuple2<BigInteger, BigInteger>>(function,
                new Callable<Tuple2<BigInteger, BigInteger>>() {
                    @Override
                    public Tuple2<BigInteger, BigInteger> call() throws Exception {
                        List<Type> results = executeCallMultipleValueReturn(function);
                        return new Tuple2<BigInteger, BigInteger>(
                                (BigInteger) results.get(0).getValue(), 
                                (BigInteger) results.get(1).getValue());
                    }
                });
    }

    public RemoteFunctionCall<String> workerPool(BigInteger param0) {
        final Function function = new Function(FUNC_WORKERPOOL, 
                Arrays.<Type>asList(new org.web3j.abi.datatypes.generated.Uint256(param0)), 
                Arrays.<TypeReference<?>>asList(new TypeReference<Address>() {}));
        return executeRemoteCallSingleValueReturn(function, String.class);
    }

    @Deprecated
    public static UserRegistrationContract load(String contractAddress, Web3j web3j, Credentials credentials, BigInteger gasPrice, BigInteger gasLimit) {
        return new UserRegistrationContract(contractAddress, web3j, credentials, gasPrice, gasLimit);
    }

    @Deprecated
    public static UserRegistrationContract load(String contractAddress, Web3j web3j, TransactionManager transactionManager, BigInteger gasPrice, BigInteger gasLimit) {
        return new UserRegistrationContract(contractAddress, web3j, transactionManager, gasPrice, gasLimit);
    }

    public static UserRegistrationContract load(String contractAddress, Web3j web3j, Credentials credentials, ContractGasProvider contractGasProvider) {
        return new UserRegistrationContract(contractAddress, web3j, credentials, contractGasProvider);
    }

    public static UserRegistrationContract load(String contractAddress, Web3j web3j, TransactionManager transactionManager, ContractGasProvider contractGasProvider) {
        return new UserRegistrationContract(contractAddress, web3j, transactionManager, contractGasProvider);
    }

    public static RemoteCall<UserRegistrationContract> deploy(Web3j web3j, Credentials credentials, ContractGasProvider contractGasProvider) {
        return deployRemoteCall(UserRegistrationContract.class, web3j, credentials, contractGasProvider, BINARY, "");
    }

    @Deprecated
    public static RemoteCall<UserRegistrationContract> deploy(Web3j web3j, Credentials credentials, BigInteger gasPrice, BigInteger gasLimit) {
        return deployRemoteCall(UserRegistrationContract.class, web3j, credentials, gasPrice, gasLimit, BINARY, "");
    }

    public static RemoteCall<UserRegistrationContract> deploy(Web3j web3j, TransactionManager transactionManager, ContractGasProvider contractGasProvider) {
        return deployRemoteCall(UserRegistrationContract.class, web3j, transactionManager, contractGasProvider, BINARY, "");
    }

    @Deprecated
    public static RemoteCall<UserRegistrationContract> deploy(Web3j web3j, TransactionManager transactionManager, BigInteger gasPrice, BigInteger gasLimit) {
        return deployRemoteCall(UserRegistrationContract.class, web3j, transactionManager, gasPrice, gasLimit, BINARY, "");
    }

    public static class RequesterAddedEventResponse extends BaseEventResponse {
        public String requester;
    }

    public static class UserRegisteredEventResponse extends BaseEventResponse {
        public String user;

        public BigInteger profile;

        public BigInteger points;
    }

    public static class WorkerAddedEventResponse extends BaseEventResponse {
        public String worker;
    }
}

我不断收到此错误，不知道为什么：

'staticExtractEventParametersWithLog(org.web3j.abi.datatypes.Event, org.web3j.protocol.core.methods.response.Log)' in 'org.web3j.tx.Contract' cannot be applied to '(org.web3j.abi.datatypes.Event, org.web3j.protocol.core.methods.response.TransactionReceipt)'

它位于 transactionReceipt 变量中。

不知道我是否需要更改代码或什么？

Answer 1

我遇到了同样的问题，作为解决方法，我更改了生成的代码，如下所示：

// Original generated code
    public static List<NewUserEventResponse> getNewUserEvents(TransactionReceipt transactionReceipt) {
        List<Contract.EventValuesWithLog> valueList = staticExtractEventParametersWithLog(NEWUSER_EVENT, transactionReceipt);
        ArrayList<NewUserEventResponse> responses = new ArrayList<NewUserEventResponse>(valueList.size());
        for (Contract.EventValuesWithLog eventValues : valueList) {
            NewUserEventResponse typedResponse = new NewUserEventResponse();
            typedResponse.log = eventValues.getLog();
            typedResponse.user = (String) eventValues.getNonIndexedValues().get(0).getValue();
            typedResponse.nickname = (String) eventValues.getNonIndexedValues().get(1).getValue();
            responses.add(typedResponse);
        }
        return responses;
    }

更改是迭代 TransactionReceipt 日志：

// Workaround
    public static List<NewUserEventResponse> getNewUserEvents(TransactionReceipt transactionReceipt) {
        ArrayList<NewUserEventResponse> responses = new ArrayList<NewUserEventResponse>();

        for (Log log : transactionReceipt.getLogs()) {
            NewUserEventResponse typedResponse = new NewUserEventResponse();
            Contract.EventValuesWithLog eventValue = staticExtractEventParametersWithLog(NEWUSER_EVENT, log);
            typedResponse.log = eventValue.getLog();
            typedResponse.user = (String) eventValue.getNonIndexedValues().get(0).getValue();
            typedResponse.nickname = (String) eventValue.getNonIndexedValues().get(1).getValue();
            responses.add(typedResponse);
        }

        return responses;
    }

所以，如果我没记错的话，你的代码应该如下所示：

    public static List<WorkerAddedEventResponse> getWorkerAddedEvents(TransactionReceipt transactionReceipt) {
        ArrayList<WorkerAddedEventResponse> responses = new ArrayList<WorkerAddedEventResponse>();
        
        for (Log log : transactionReceipt.getLogs()) {
            Contract.EventValuesWithLog eventValue = staticExtractEventParametersWithLog(WORKERADDED_EVENT, log);

            WorkerAddedEventResponse typedResponse = new WorkerAddedEventResponse();
            typedResponse.log = eventValue.getLog();
            typedResponse.worker = (String) eventValue.getIndexedValues().get(0).getValue();
            responses.add(typedResponse);
        }
        
        return responses;
    }