org.web3j.abi.datatypes.Type Java Examples

private String getContractTransfer() {
    int tokenDecimals = tokensManager.getTokenByCode(tokenCode).getDecimal();
    BigInteger tokenValue = Converter.toDecimals(new BigDecimal(amountToSend), tokenDecimals).toBigInteger();
    List<Type> inputParams = new ArrayList<>();

    Type address = new Address(walletNumber);
    inputParams.add(address);

    Type value = new Uint(tokenValue);
    inputParams.add(value);

    Function function = new Function(
            "transfer",
            inputParams,
            Collections.<TypeReference<?>>emptyList());

    return FunctionEncoder.encode(function);
}
 

@Deprecated
public static RemoteCall<OnChainPrivacyGroupManagementProxy> deploy(
    Web3j web3j,
    TransactionManager transactionManager,
    BigInteger gasPrice,
    BigInteger gasLimit,
    String _implementation) {
  String encodedConstructor =
      FunctionEncoder.encodeConstructor(
          Arrays.<Type>asList(new org.web3j.abi.datatypes.Address(160, _implementation)));
  return deployRemoteCall(
      OnChainPrivacyGroupManagementProxy.class,
      web3j,
      transactionManager,
      gasPrice,
      gasLimit,
      BINARY,
      encodedConstructor);
}
 

@Test
public void testSimpleFunctionStringResultDecode() {
    Function function =
            new Function(
                    "simple",
                    Arrays.asList(),
                    Collections.singletonList(new TypeReference<Utf8String>() {}));

    List<Type> utf8Strings =
            FunctionReturnDecoder.decode(
                    "0x0000000000000000000000000000000000000000000000000000000000000020"
                            + "000000000000000000000000000000000000000000000000000000000000000d"
                            + "6f6e65206d6f72652074696d6500000000000000000000000000000000000000",
                    function.getOutputParameters());

    assertEquals(utf8Strings.get(0).getValue(), ("one more time"));
}
 

public static EventValues staticExtractEventParameters(
        Event event, Log log) {

    List<String> topics = log.getTopics();
    String encodedEventSignature = EventEncoder.encode(event);
    if (!topics.get(0).equals(encodedEventSignature)) {
        return null;
    }

    List<Type> indexedValues = new ArrayList<>();
    List<Type> nonIndexedValues = FunctionReturnDecoder.decode(
            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), indexedParameters.get(i));
        indexedValues.add(value);
    }
    return new EventValues(indexedValues, nonIndexedValues);
}
 

static <T extends Type> String getTypeName(TypeReference<T> typeReference) {
    try {
        java.lang.reflect.Type reflectedType = typeReference.getType();

        Class<?> type;
        if (reflectedType instanceof ParameterizedType) {
            type = (Class<?>) ((ParameterizedType) reflectedType).getRawType();
            return getParameterizedTypeName(typeReference, type);
        } else {
            type = Class.forName(reflectedType.getTypeName());
            return getSimpleTypeName(type);
        }
    } catch (ClassNotFoundException e) {
        throw new UnsupportedOperationException("Invalid class reference provided", e);
    }
}
 

public RemoteFunctionCall<List> fixedReverse(List<BigInteger> input) {
    final Function function = new Function(FUNC_FIXEDREVERSE, 
            java.util.Arrays.<Type>asList(new org.web3j.abi.datatypes.generated.StaticArray10<org.web3j.abi.datatypes.generated.Uint256>(
                    org.web3j.abi.datatypes.generated.Uint256.class,
                    org.web3j.abi.Utils.typeMap(input, org.web3j.abi.datatypes.generated.Uint256.class))), 
            java.util.Arrays.<TypeReference<?>>asList(new TypeReference<StaticArray10<Uint256>>() {}));
    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> getParticipants(byte[] enclaveKey) {
  final Function function =
      new Function(
          FUNC_GETPARTICIPANTS,
          Arrays.<Type>asList(new org.web3j.abi.datatypes.generated.Bytes32(enclaveKey)),
          Arrays.<TypeReference<?>>asList(new TypeReference<DynamicArray<Bytes32>>() {}));
  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);
        }
      });
}
 

@SuppressWarnings("unchecked")
public <T extends Type> Type decodeEventParameter(
        String rawInput, TypeReference<T> typeReference) {

    String input = Numeric.cleanHexPrefix(rawInput);

    try {
        Class<T> type = typeReference.getClassType();

        if (Bytes.class.isAssignableFrom(type)) {
            Class<Bytes> bytesClass = (Class<Bytes>) Class.forName(type.getName());
            return TypeDecoder.decodeBytes(input, bytesClass);
        } else if (Array.class.isAssignableFrom(type)
                || BytesType.class.isAssignableFrom(type)
                || Utf8String.class.isAssignableFrom(type)) {
            return TypeDecoder.decodeBytes(input, Bytes32.class);
        } else {
            return TypeDecoder.decode(input, type);
        }
    } catch (ClassNotFoundException e) {
        throw new UnsupportedOperationException("Invalid class reference provided", e);
    }
}
 

public RemoteCall<TransactionReceipt> setAddr(byte[] node, String addr) {
    final Function function = new Function(
            FUNC_SETADDR, 
            Arrays.<Type>asList(new org.web3j.abi.datatypes.generated.Bytes32(node), 
            new org.web3j.abi.datatypes.Address(addr)), 
            Collections.<TypeReference<?>>emptyList());
    return executeRemoteCallTransaction(function);
}
 

private List callSmartContractFunctionArray(
        org.web3j.abi.datatypes.Function function, String contractAddress, String address) throws Exception
{
    String encodedFunction = FunctionEncoder.encode(function);
    String value = makeEthCall(
            org.web3j.protocol.core.methods.request.Transaction
                    .createEthCallTransaction(address, contractAddress, encodedFunction));

    List<Type> values = FunctionReturnDecoder.decode(value, function.getOutputParameters());
    if (values.isEmpty()) return null;

    Type T = values.get(0);
    Object o = T.getValue();
    return (List) o;
}
 

@Test
public void testSimpleFunctionDecode() {
    Function function = new Function(
            "test",
            Collections.<Type>emptyList(),
            Collections.singletonList(new TypeReference<Uint>(){})
    );

    assertThat(FunctionReturnDecoder.decode(
            "0x0000000000000000000000000000000000000000000000000000000000000037",
            function.getOutputParameters()),
            equalTo(Collections.singletonList(new Uint(BigInteger.valueOf(55)))));
}
 

private MethodSpec.Builder generateIntTypes(MethodSpec.Builder builder, String packageName) {
    for (int bitSize = 8; bitSize <= Type.MAX_BIT_LENGTH; bitSize += 8) {

        builder = addStatement(builder, packageName,
                Uint.TYPE_NAME + bitSize, Uint.class.getSimpleName() + bitSize);
        builder = addStatement(builder, packageName,
                Int.TYPE_NAME + bitSize, Int.class.getSimpleName() + bitSize);
    }
    return builder;
}
 

public RemoteCall<TransactionReceipt> approveAndCall(String _spender, BigInteger _value, byte[] _extraData) {
    final Function function = new Function(
            FUNC_APPROVEANDCALL, 
            Arrays.<Type>asList(new org.web3j.abi.datatypes.Address(_spender), 
            new org.web3j.abi.datatypes.generated.Uint256(_value), 
            new org.web3j.abi.datatypes.DynamicBytes(_extraData)), 
            Collections.<TypeReference<?>>emptyList());
    return executeRemoteCallTransaction(function);
}
 

public static RemoteCall<HumanStandardToken> deploy(Web3j web3j, Credentials credentials, ContractGasProvider contractGasProvider, 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, credentials, contractGasProvider, BINARY, encodedConstructor);
}
 

@Deprecated
public static RemoteCall<PayWages> deploy(Web3j web3j, Credentials credentials, BigInteger gasPrice, BigInteger gasLimit,
		BigInteger initialWeiValue, String _personnel, String _financer) {
	String encodedConstructor = FunctionEncoder.encodeConstructor(
			Arrays.<Type>asList(new org.web3j.abi.datatypes.Address(_personnel), new org.web3j.abi.datatypes.Address(_financer)));
	return deployRemoteCall(PayWages.class, web3j, credentials, gasPrice, gasLimit, BINARY, encodedConstructor, initialWeiValue);
}
 

public RemoteCall<TransactionReceipt> setTTL(byte[] node, BigInteger ttl) {
    final Function function = new Function(
            FUNC_SETTTL, 
            Arrays.<Type>asList(new org.web3j.abi.datatypes.generated.Bytes32(node), 
            new org.web3j.abi.datatypes.generated.Uint64(ttl)), 
            Collections.<TypeReference<?>>emptyList());
    return executeRemoteCallTransaction(function);
}
 

private static <T extends Type> int getDataOffset(String input, int offset, Class<T> type) {
    if (DynamicBytes.class.isAssignableFrom(type)
            || Utf8String.class.isAssignableFrom(type)
            || DynamicArray.class.isAssignableFrom(type)) {
        return TypeDecoder.decodeUintAsInt(input, offset) << 1;
    } else {
        return offset;
    }
}
 

@SuppressWarnings("unchecked")
public static String encode(Type parameter) {
	if (parameter instanceof IntType) {
		return encodeInt(((IntType) parameter));
	}else if (parameter instanceof Utf8String) {
        return encodeString((Utf8String) parameter);
    }else {
        throw new UnsupportedOperationException(
                "Type cannot be encoded: " + parameter.getClass());
    }
}
 

public RemoteFunctionCall<TransactionReceipt> withdraw() {
    final Function function = new Function(
            FUNC_WITHDRAW, 
            Arrays.<Type>asList(), 
            Collections.<TypeReference<?>>emptyList());
    return executeRemoteCallTransaction(function);
}
 

public RemoteCall<Utf8String> callSingleValue() {
    Function function =
            new Function(
                    "call",
                    Collections.<Type>emptyList(),
                    Collections.<TypeReference<?>>singletonList(
                            new TypeReference<Utf8String>() {}));
    return executeRemoteCallSingleValueReturn(function);
}
 

public RemoteCall<TransactionReceipt> reveal(List<BigInteger> _values, List<Boolean> _fake, List<byte[]> _secret) {
    final Function function = new Function(
            FUNC_REVEAL, 
            Arrays.<Type>asList(new org.web3j.abi.datatypes.DynamicArray<org.web3j.abi.datatypes.generated.Uint256>(
                    org.web3j.abi.datatypes.generated.Uint256.class,
                    org.web3j.abi.Utils.typeMap(_values, org.web3j.abi.datatypes.generated.Uint256.class)), 
            new org.web3j.abi.datatypes.DynamicArray<org.web3j.abi.datatypes.Bool>(
                    org.web3j.abi.datatypes.Bool.class,
                    org.web3j.abi.Utils.typeMap(_fake, org.web3j.abi.datatypes.Bool.class)), 
            new org.web3j.abi.datatypes.DynamicArray<org.web3j.abi.datatypes.generated.Bytes32>(
                    org.web3j.abi.datatypes.generated.Bytes32.class,
                    org.web3j.abi.Utils.typeMap(_secret, org.web3j.abi.datatypes.generated.Bytes32.class))), 
            Collections.<TypeReference<?>>emptyList());
    return executeRemoteCallTransaction(function);
}
 

@SuppressWarnings("unchecked")
protected static <S extends Type, T> 
        List<T> convertToNative(List<S> arr) {
    List<T> out = new ArrayList<T>();
    for (Iterator<S> it = arr.iterator(); it.hasNext(); ) {
        out.add((T)it.next().getValue());
    }
    return out;
}
 

public static RemoteCall<HumanStandardToken> deploy(Web3j web3j, Credentials credentials, GasProvider contractGasProvider,
		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, credentials, contractGasProvider, BINARY, encodedConstructor);
}
 

private <T> T getContractData(String address, org.web3j.abi.datatypes.Function function) throws Exception
{
    String responseValue = callSmartContractFunction(function, address);

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

public RemoteCall<TransactionReceipt> ExampleFunction() {
    final Function function = new Function(
            "ExampleFunction", 
            Arrays.<Type>asList(), 
            Collections.<TypeReference<?>>emptyList());
    return executeRemoteCallTransaction(function);
}
 

@Test
public void testDecodeMultipleStringValues() {
    Function function =
            new Function(
                    "function",
                    Collections.<Type>emptyList(),
                    Arrays.asList(
                            new TypeReference<Utf8String>() {},
                                    new TypeReference<Utf8String>() {},
                            new TypeReference<Utf8String>() {},
                                    new TypeReference<Utf8String>() {}));

    assertEquals(
            FunctionReturnDecoder.decode(
                    "0x0000000000000000000000000000000000000000000000000000000000000080"
                            + "00000000000000000000000000000000000000000000000000000000000000c0"
                            + "0000000000000000000000000000000000000000000000000000000000000100"
                            + "0000000000000000000000000000000000000000000000000000000000000140"
                            + "0000000000000000000000000000000000000000000000000000000000000004"
                            + "6465663100000000000000000000000000000000000000000000000000000000"
                            + "0000000000000000000000000000000000000000000000000000000000000004"
                            + "6768693100000000000000000000000000000000000000000000000000000000"
                            + "0000000000000000000000000000000000000000000000000000000000000004"
                            + "6a6b6c3100000000000000000000000000000000000000000000000000000000"
                            + "0000000000000000000000000000000000000000000000000000000000000004"
                            + "6d6e6f3200000000000000000000000000000000000000000000000000000000",
                    function.getOutputParameters()),
            (Arrays.asList(
                    new Utf8String("def1"), new Utf8String("ghi1"),
                    new Utf8String("jkl1"), new Utf8String("mno2"))));
}
 

private Contract deployContract(TransactionReceipt transactionReceipt)
        throws Exception {

    prepareTransaction(transactionReceipt);

    String encodedConstructor = FunctionEncoder.encodeConstructor(
            Arrays.<Type>asList(new Uint256(BigInteger.TEN)));

    return TestContract.deployRemoteCall(
            TestContract.class, web3j, SampleKeys.CREDENTIALS,
            ManagedTransaction.GAS_PRICE, Contract.GAS_LIMIT,
            "0xcafed00d", encodedConstructor, BigInteger.ZERO).send();
}
 

public RemoteFunctionCall<TransactionReceipt> deployRemote(final String crossAddress) {
  final Function function =
      new Function(
          FUNC_DEPLOYREMOTE,
          Arrays.<Type>asList(new org.web3j.abi.datatypes.Address(160, crossAddress)),
          Collections.<TypeReference<?>>emptyList());
  return executeRemoteCallTransaction(function);
}
 

public RemoteCall<TransactionReceipt> kill() {
    final Function function = new Function(
            FUNC_KILL, 
            Arrays.<Type>asList(), 
            Collections.<TypeReference<?>>emptyList());
    return executeRemoteCallTransaction(function);
}
 

public RemoteCall<TransactionReceipt> transferFrom(String _from, String _to, BigInteger _value) {
    final Function function = new Function(
            FUNC_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);
}