import org.web3j.abi.datatypes.Type; //导入依赖的package包/类
private byte[] callHash(String name, Type...parameters) throws InterruptedException, ExecutionException {

        Function function = new Function(name,
            Arrays.asList(parameters),
            Arrays.asList(new TypeReference<Bytes32>() {})
        );
        String encodedFunction = FunctionEncoder.encode(function);

        TransactionManager transactionManager = cfg.getTransactionManager(cfg.getMainAddress());
        String channelLibraryAddress = contractsProperties.getAddress().get("ChannelLibrary").toString();
        org.web3j.protocol.core.methods.response.EthCall ethCall = web3j.ethCall(
            Transaction.createEthCallTransaction(
                transactionManager.getFromAddress(), channelLibraryAddress, encodedFunction),
            DefaultBlockParameterName.LATEST)
            .sendAsync().get();

        String value = ethCall.getValue();
        List<Type> list = FunctionReturnDecoder.decode(value, function.getOutputParameters());
        return ((Bytes32) list.get(0)).getValue();
    }
 

import org.web3j.abi.datatypes.Type; //导入依赖的package包/类
public static EventValues extractEventParameters(Event event, Log log) throws Exception {
        Hashes topics = log.getTopics();
        if (topics == null || topics.size() == 0) {
//            throw new GethException("topic is empty");
            return null;
        }

        String eventSig = EventEncoder.encode(event);
        String topic = topics.get(0).getHex();
        if (!topic.equals(eventSig)) {
//            throw new GethException("topic is not match. topic signature : " + eventSig + ", log topic : " + topic);
            return null;
        }
        android.util.Log.d(TAG, "======= LOG DATA : " + byteToHex(log.getData()));

        List<Type> indexedValues = new ArrayList<>();
        List<Type> nonIndexedValues = FunctionReturnDecoder.decode(byteToHex(log.getData()), event.getNonIndexedParameters());

        List<TypeReference<Type>> indexedParameters = event.getIndexedParameters();
        for (int i = 0; i < indexedParameters.size(); i++) {
            Type value = FunctionReturnDecoder.decodeIndexedValue(topics.get(i + 1).getHex(), indexedParameters.get(i));
            indexedValues.add(value);
        }
        return new EventValues(indexedValues, nonIndexedValues);
    }
 

import org.web3j.abi.datatypes.Type; //导入依赖的package包/类
private static String json(Type<?> p) {
    if (p == null) return "null";
    if (p instanceof NumericType || p instanceof Bool) {
        return p.getValue().toString();
    } 
    if (p instanceof Array) {
        return "[" + json(((Array<?>) p).getValue()) + "]";
    }
    Object value = p.getValue();
    String str;
    if (value instanceof byte[]) {
        str = Numeric.toHexStringNoPrefix((byte[]) value);
    } else {
        str = value.toString();
    }
    return "\"" + StringEscapeUtils.escapeJava(str) + "\"";
}
 

import org.web3j.abi.datatypes.Type; //导入依赖的package包/类
private Order convertToOrder(List<Type> list) {
  Order order = null;
  if (null != list && list.size() > 0) {
    BigInteger quantity = ((Uint256) list.get(0)).getValue();
    BigInteger price = ((Uint256) list.get(1)).getValue();
    Boolean buy = ((Bool) list.get(2)).getValue();
    String ownerAddress = ((Address) list.get(3)).toString();
    BigInteger dealNr = ((Uint256) list.get(4)).getValue();
    BigInteger extId = ((Uint256) list.get(5)).getValue();
    Order.Type type = Order.Type.BUY;
    if (!buy) {
      type = Order.Type.SELL;
    }
    order = new Order(type, quantity.intValue(), price.doubleValue() / 100, extId.intValue());
    order.setId(dealNr.intValue());
    order.setOwner(ownerAddress);
  }
  return order;
}
 

import org.web3j.abi.datatypes.Type; //导入依赖的package包/类
public Address deployContract(TransactionManager transactionManager, String binary, Map<String, Address> libraries, Type... constructorArgs) throws IOException, InterruptedException, TransactionException {
    ContractLinker linker = new ContractLinker(binary);
    if (libraries != null && !libraries.isEmpty()) {
        libraries.forEach(linker::link);
    }
    linker.assertLinked();
    String encodedConstructor = FunctionEncoder.encodeConstructor(Arrays.<Type>asList(constructorArgs));
    String data = linker.getBinary() + encodedConstructor;

    EthSendTransaction transactionResponse = transactionManager.sendTransaction(
        properties.getGasPrice(), properties.getGasLimit(), null, data, BigInteger.ZERO);

    if (transactionResponse.hasError()) {
        throw new RuntimeException("Error processing transaction request: "
            + transactionResponse.getError().getMessage());
    }

    String transactionHash = transactionResponse.getTransactionHash();

    Optional<TransactionReceipt> receiptOptional =
        sendTransactionReceiptRequest(transactionHash, web3j);

    long millis = properties.getSleep().toMillis();
    int attempts = properties.getAttempts();
    for (int i = 0; i < attempts; i++) {
        if (!receiptOptional.isPresent()) {
            Thread.sleep(millis);
            receiptOptional = sendTransactionReceiptRequest(transactionHash, web3j);
        } else {
            String contractAddress = receiptOptional.get().getContractAddress();
            return new Address(contractAddress);
        }
    }
    throw new TransactionException("Transaction receipt was not generated after " + (millis * attempts / 1000)
        + " seconds for transaction: " + transactionHash);
}
 

import org.web3j.abi.datatypes.Type; //导入依赖的package包/类
public Address deploy(String contractName, String binName, Type... args) throws IOException, TransactionException, InterruptedException {
    System.out.println("Deploying " + contractName + "...");
    Address address = service.deployContract(m, binaryOf(binName), deployed, args);
    deployed.put(contractName,  address);
    System.out.println(contractName + ": " + address);
    return address;
}
 

import org.web3j.abi.datatypes.Type; //导入依赖的package包/类
protected Observable<List<Type>> executeCallMultipleValueReturnObservable(Function function) {
    return executeCall(function)
            .flatMap(types -> {
                if (types == null) {
                    return Observable.error(new GethException("value is null"));
                }
                return Observable.just(types);
            });
}
 

import org.web3j.abi.datatypes.Type; //导入依赖的package包/类
protected <T extends Type> Observable<T> executeCallSingleValueReturnObservable(Function function) {
    return executeCall(function)
            .flatMap(types -> {
                if (types == null || types.isEmpty()) {
                    return Observable.error(new GethException("value is null"));
                }
                return Observable.just((T) types.get(0));
            });
}
 

import org.web3j.abi.datatypes.Type; //导入依赖的package包/类
private BigDecimal getBalance(Wallet wallet, TokenInfo tokenInfo) throws Exception {
    org.web3j.abi.datatypes.Function function = balanceOf(wallet.address);
    String responseValue = callSmartContractFunction(function, tokenInfo.address, wallet);

    List<Type> response = FunctionReturnDecoder.decode(
            responseValue, function.getOutputParameters());
    if (response.size() == 1) {
        return new BigDecimal(((Uint256) response.get(0)).getValue());
    } else {
        return null;
    }
}
 

import org.web3j.abi.datatypes.Type; //导入依赖的package包/类
public RemoteCall<TransactionReceipt> approve(String _spender, BigInteger _value) {
    Function function = new Function(
            "approve", 
            Arrays.<Type>asList(new org.web3j.abi.datatypes.Address(_spender),
            new org.web3j.abi.datatypes.generated.Uint256(_value)),
            Collections.<TypeReference<?>>emptyList());
    return executeRemoteCallTransaction(function);
}
 

import org.web3j.abi.datatypes.Type; //导入依赖的package包/类
public RemoteCall<TransactionReceipt> transferFrom(String _from, String _to, BigInteger _value) {
    Function function = new Function(
            "transferFrom",
            Arrays.<Type>asList(new org.web3j.abi.datatypes.Address(_from),
            new org.web3j.abi.datatypes.Address(_to),
            new org.web3j.abi.datatypes.generated.Uint256(_value)),
            Collections.<TypeReference<?>>emptyList());
    return executeRemoteCallTransaction(function);
}
 

import org.web3j.abi.datatypes.Type; //导入依赖的package包/类
public static RemoteCall<HumanStandardToken> deploy(Web3j web3j, TransactionManager transactionManager, BigInteger gasPrice, BigInteger gasLimit, BigInteger _initialAmount, String _tokenName, BigInteger _decimalUnits, String _tokenSymbol) {
    String encodedConstructor = FunctionEncoder.encodeConstructor(Arrays.<Type>asList(new org.web3j.abi.datatypes.generated.Uint256(_initialAmount),
            new org.web3j.abi.datatypes.Utf8String(_tokenName),
            new org.web3j.abi.datatypes.generated.Uint8(_decimalUnits),
            new org.web3j.abi.datatypes.Utf8String(_tokenSymbol)));
    return deployRemoteCall(HumanStandardToken.class, web3j, transactionManager, gasPrice, gasLimit, BINARY, encodedConstructor);
}
 

import org.web3j.abi.datatypes.Type; //导入依赖的package包/类
public RemoteCall<TransactionReceipt> kill() {
    Function function = new Function(
            "kill", 
            Arrays.<Type>asList(),
            Collections.<TypeReference<?>>emptyList());
    return executeRemoteCallTransaction(function);
}
 

import org.web3j.abi.datatypes.Type; //导入依赖的package包/类
@SuppressWarnings("rawtypes")
P_Order(List<Type> list) {
	quantity = (Uint256) list.get(0);
	price = (Uint256) list.get(1);
	type = (Bool) list.get(2);
	address = (Address) list.get(3);
	id = (Uint256) list.get(4);
}
 

import org.web3j.abi.datatypes.Type; //导入依赖的package包/类
private Order getExecutedOrderAtIndex(int index, OrderBook contract) {
  List<Type> list = null;
  try {
    list = contract.executedOrders(new Uint256(BigInteger.valueOf(index))).get();
  }
  catch (InterruptedException | ExecutionException e) {
    // TODO Auto-generated catch block
    // e.printStackTrace();
  }
  Order order = null;
  if (null != list && list.size() > 0) {
    order = convertToOrder(list);
  }
  return order;
}
 

import org.web3j.abi.datatypes.Type; //导入依赖的package包/类
public Future<Uint256> allowance(Address _owner, Address _spender) {
    Function function = new Function("allowance", 
            Arrays.<Type>asList(_owner, _spender), 
            Arrays.<TypeReference<?>>asList(new TypeReference<Uint256>() {}));
    return executeCallSingleValueReturnAsync(function);
}
 

import org.web3j.abi.datatypes.Type; //导入依赖的package包/类
public Future<TransactionReceipt> approve(Address _spender, Uint256 _value) {
    Function function = new Function("approve", Arrays.<Type>asList(_spender, _value), Collections.<TypeReference<?>>emptyList());
    return executeTransactionAsync(function);
}
 

import org.web3j.abi.datatypes.Type; //导入依赖的package包/类
public Future<Uint256> totalSupply() {
    Function function = new Function("totalSupply", 
            Arrays.<Type>asList(), 
            Arrays.<TypeReference<?>>asList(new TypeReference<Uint256>() {}));
    return executeCallSingleValueReturnAsync(function);
}
 

import org.web3j.abi.datatypes.Type; //导入依赖的package包/类
public Future<Uint8> decimals() {
    Function function = new Function("decimals", 
            Arrays.<Type>asList(), 
            Arrays.<TypeReference<?>>asList(new TypeReference<Uint8>() {}));
    return executeCallSingleValueReturnAsync(function);
}
 

import org.web3j.abi.datatypes.Type; //导入依赖的package包/类
public Future<TransactionReceipt> changeFounder(Address newAddress) {
    Function function = new Function("changeFounder", Arrays.<Type>asList(newAddress), Collections.<TypeReference<?>>emptyList());
    return executeTransactionAsync(function);
}