Java Code Examples for org.fisco.bcos.web3j.abi.datatypes.Bool

The following examples show how to use org.fisco.bcos.web3j.abi.datatypes.Bool. These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
Source Project: web3sdk   Source File: ChainGovernance.java    License: Apache License 2.0 6 votes vote down vote up
public RemoteCall<Tuple2<Boolean, BigInteger>> queryCommitteeMemberWeight(String user) {
    final Function function =
            new Function(
                    FUNC_QUERYCOMMITTEEMEMBERWEIGHT,
                    Arrays.<Type>asList(new org.fisco.bcos.web3j.abi.datatypes.Address(user)),
                    Arrays.<TypeReference<?>>asList(
                            new TypeReference<Bool>() {}, new TypeReference<Int256>() {}));
    return new RemoteCall<Tuple2<Boolean, BigInteger>>(
            new Callable<Tuple2<Boolean, BigInteger>>() {
                @Override
                public Tuple2<Boolean, BigInteger> call() throws Exception {
                    List<Type> results = executeCallMultipleValueReturn(function);
                    return new Tuple2<Boolean, BigInteger>(
                            (Boolean) results.get(0).getValue(),
                            (BigInteger) results.get(1).getValue());
                }
            });
}
 
Example 2
Source Project: web3sdk   Source File: TypeDecoder.java    License: Apache License 2.0 6 votes vote down vote up
@SuppressWarnings("unchecked")
static <T extends Type> T decode(String input, int offset, Class<T> type) {
    if (NumericType.class.isAssignableFrom(type)) {
        return (T) decodeNumeric(input.substring(offset), (Class<NumericType>) type);
    } else if (Address.class.isAssignableFrom(type)) {
        return (T) decodeAddress(input.substring(offset));
    } else if (Bool.class.isAssignableFrom(type)) {
        return (T) decodeBool(input, offset);
    } else if (Bytes.class.isAssignableFrom(type)) {
        return (T) decodeBytes(input, offset, (Class<Bytes>) type);
    } else if (DynamicBytes.class.isAssignableFrom(type)) {
        return (T) decodeDynamicBytes(input, offset);
    } else if (Utf8String.class.isAssignableFrom(type)) {
        return (T) decodeUtf8String(input, offset);
    } else if (Array.class.isAssignableFrom(type)) {
        throw new UnsupportedOperationException(
                "Array types must be wrapped in a TypeReference");
    } else {
        throw new UnsupportedOperationException("Type cannot be encoded: " + type.getClass());
    }
}
 
Example 3
Source Project: web3sdk   Source File: AbiTypesMapperGenerator.java    License: Apache License 2.0 6 votes vote down vote up
private MethodSpec.Builder addTypes(MethodSpec.Builder builder, String packageName) {
    builder =
            addStatement(
                    builder, packageName, Address.TYPE_NAME, Address.class.getSimpleName());

    builder = addStatement(builder, packageName, Bool.TYPE_NAME, Bool.class.getSimpleName());

    builder =
            addStatement(
                    builder,
                    packageName,
                    Utf8String.TYPE_NAME,
                    Utf8String.class.getSimpleName());

    builder =
            addStatement(
                    builder,
                    packageName,
                    DynamicBytes.TYPE_NAME,
                    DynamicBytes.class.getSimpleName());

    // TODO: Fixed array & dynamic array support
    return builder;
}
 
Example 4
Source Project: web3sdk   Source File: ResultEntityTest.java    License: Apache License 2.0 6 votes vote down vote up
@Test
public void typeToObjectTest0() {

    assertThat(ResultEntity.typeToObject(new Uint256(2)), is(new BigInteger("2")));
    assertThat(ResultEntity.typeToObject(new Int256(-1)), is(new BigInteger("-1")));
    assertThat(ResultEntity.typeToObject(new Utf8String("adsfjkl")), is("adsfjkl"));
    assertThat(ResultEntity.typeToObject(new Bool(true)), is(true));
    assertThat(ResultEntity.typeToObject(new DynamicBytes("0x111".getBytes())), is("0x111"));
    assertThat(
            ResultEntity.typeToObject(new Address("0x111")),
            is("0x0000000000000000000000000000000000000111"));
    assertThat(
            ResultEntity.typeToObject(
                    new Bytes32("01234567890123456789012345678912".getBytes())),
            is("01234567890123456789012345678912"));
}
 
Example 5
Source Project: web3sdk   Source File: EventEncoderTest.java    License: Apache License 2.0 6 votes vote down vote up
@Test
public void testEventbuildMethodSignature2() {
    Event event =
            new Event(
                    "f",
                    Arrays.<TypeReference<?>>asList(
                            new TypeReference<DynamicBytes>() {},
                            new TypeReference<Bool>() {},
                            new TypeReference<DynamicArray<Uint256>>() {}));

    assertThat(
            EventEncoder.buildMethodSignature(event.getName(), event.getParameters()),
            is("f(bytes,bool,uint256[])"));

    assertThat(
            EventEncoder.encode(event),
            is("0xa83b3f0112fa8ecc02937d734929bbaa30731fe27b20195418852fb64ac2837d"));

    assertThat(
            EventEncoder.buildEventSignature("f(bytes,bool,uint256[])"),
            is("0xa83b3f0112fa8ecc02937d734929bbaa30731fe27b20195418852fb64ac2837d"));
}
 
Example 6
Source Project: web3sdk   Source File: EventEncoderTest.java    License: Apache License 2.0 6 votes vote down vote up
@Test
public void testEventbuildMethodSignature4() {
    Event event =
            new Event(
                    "test4",
                    Arrays.<TypeReference<?>>asList(
                            new TypeReference<Uint32>() {}, new TypeReference<Bool>() {}));

    assertThat(
            EventEncoder.buildMethodSignature(event.getName(), event.getParameters()),
            is("test4(uint32,bool)"));

    assertThat(
            EventEncoder.encode(event),
            is("0xd7ee7b8ce8fd8944f6c4fc1d3d8f656f855a5b9c130a876af272bdb06b056f9c"));

    assertThat(
            EventEncoder.buildEventSignature("test4(uint32,bool)"),
            is("0xd7ee7b8ce8fd8944f6c4fc1d3d8f656f855a5b9c130a876af272bdb06b056f9c"));
}
 
Example 7
Source Project: web3sdk   Source File: EventEncoderTest.java    License: Apache License 2.0 6 votes vote down vote up
@Test
public void testEventbuildMethodSignature9() {
    Event event =
            new Event(
                    "test9",
                    Arrays.<TypeReference<?>>asList(
                            new TypeReference<Utf8String>() {},
                            new TypeReference<Uint256>() {},
                            new TypeReference<StaticArray6<Uint256>>() {},
                            new TypeReference<DynamicArray<Uint256>>() {},
                            new TypeReference<Bool>() {},
                            new TypeReference<Address>() {}));

    assertThat(
            EventEncoder.buildMethodSignature(event.getName(), event.getParameters()),
            is("test9(string,uint256,uint256[6],uint256[],bool,address)"));

    assertThat(
            EventEncoder.encode(event),
            is("0xa37d8a63087cf5837e0b9ff13d07d756479f8afdfe4b05ea3dfdc98154ef58ed"));

    assertThat(
            EventEncoder.buildEventSignature(
                    "test9(string,uint256,uint256[6],uint256[],bool,address)"),
            is("0xa37d8a63087cf5837e0b9ff13d07d756479f8afdfe4b05ea3dfdc98154ef58ed"));
}
 
Example 8
Source Project: WeBASE-Front   Source File: Evidence.java    License: Apache License 2.0 5 votes vote down vote up
public Tuple1<Boolean> getAddSignaturesOutput(TransactionReceipt transactionReceipt) {
    String data = transactionReceipt.getOutput();
    final Function function = new Function(FUNC_ADDSIGNATURES, 
            Arrays.<Type>asList(), 
            Arrays.<TypeReference<?>>asList(new TypeReference<Bool>() {}));
    List<Type> results = FunctionReturnDecoder.decode(data, function.getOutputParameters());;
    return new Tuple1<Boolean>(

            (Boolean) results.get(0).getValue()
            );
}
 
Example 9
Source Project: WeEvent   Source File: TopicController.java    License: Apache License 2.0 5 votes vote down vote up
public RemoteCall<Tuple8<Boolean, String, BigInteger, BigInteger, BigInteger, BigInteger, BigInteger, String>> getTopicInfo(String topicName) {
    final Function function = new Function(FUNC_GETTOPICINFO, 
            Arrays.<Type>asList(new org.fisco.bcos.web3j.abi.datatypes.Utf8String(topicName)), 
            Arrays.<TypeReference<?>>asList(new TypeReference<Bool>() {},
                new TypeReference<Address>() {},
                new TypeReference<Uint256>() {},
                new TypeReference<Uint256>() {},
                new TypeReference<Uint256>() {},
                new TypeReference<Uint256>() {},
                new TypeReference<Uint256>() {},
                new TypeReference<Address>() {}));
    return new RemoteCall<Tuple8<Boolean, String, BigInteger, BigInteger, BigInteger, BigInteger, BigInteger, String>>(
            new Callable<Tuple8<Boolean, String, BigInteger, BigInteger, BigInteger, BigInteger, BigInteger, String>>() {
                @Override
                public Tuple8<Boolean, String, BigInteger, BigInteger, BigInteger, BigInteger, BigInteger, String> call() throws Exception {
                    List<Type> results = executeCallMultipleValueReturn(function);
                    return new Tuple8<Boolean, String, BigInteger, BigInteger, BigInteger, BigInteger, BigInteger, String>(
                            (Boolean) results.get(0).getValue(), 
                            (String) results.get(1).getValue(), 
                            (BigInteger) results.get(2).getValue(), 
                            (BigInteger) results.get(3).getValue(), 
                            (BigInteger) results.get(4).getValue(), 
                            (BigInteger) results.get(5).getValue(), 
                            (BigInteger) results.get(6).getValue(), 
                            (String) results.get(7).getValue());
                }
            });
}
 
Example 10
Source Project: WeEvent   Source File: TopicController.java    License: Apache License 2.0 5 votes vote down vote up
public Tuple1<Boolean> getAddTopicInfoOutput(TransactionReceipt transactionReceipt) {
    String data = transactionReceipt.getOutput();
    final Function function = new Function(FUNC_ADDTOPICINFO, 
            Arrays.<Type>asList(), 
            Arrays.<TypeReference<?>>asList(new TypeReference<Bool>() {}));
    List<Type> results = FunctionReturnDecoder.decode(data, function.getOutputParameters());;
    return new Tuple1<Boolean>(

            (Boolean) results.get(0).getValue()
            );
}
 
Example 11
Source Project: WeEvent   Source File: Topic.java    License: Apache License 2.0 5 votes vote down vote up
public Tuple1<Boolean> getAddTopicACLOutput(TransactionReceipt transactionReceipt) {
    String data = transactionReceipt.getOutput();
    final Function function = new Function(FUNC_ADDTOPICACL, 
            Arrays.<Type>asList(), 
            Arrays.<TypeReference<?>>asList(new TypeReference<Bool>() {}));
    List<Type> results = FunctionReturnDecoder.decode(data, function.getOutputParameters());;
    return new Tuple1<Boolean>(

            (Boolean) results.get(0).getValue()
            );
}
 
Example 12
public RemoteCall<Boolean> groupSigVerify(
        String signature, String message, String gpkInfo, String paramInfo) {
    final Function function =
            new Function(
                    FUNC_GROUPSIGVERIFY,
                    Arrays.<Type>asList(
                            new org.fisco.bcos.web3j.abi.datatypes.Utf8String(signature),
                            new org.fisco.bcos.web3j.abi.datatypes.Utf8String(message),
                            new org.fisco.bcos.web3j.abi.datatypes.Utf8String(gpkInfo),
                            new org.fisco.bcos.web3j.abi.datatypes.Utf8String(paramInfo)),
                    Arrays.<TypeReference<?>>asList(new TypeReference<Bool>() {}));
    return executeRemoteCallSingleValueReturn(function, Boolean.class);
}
 
Example 13
public RemoteCall<Boolean> get_ring_verify_result() {
    final Function function =
            new Function(
                    FUNC_GET_RING_VERIFY_RESULT,
                    Arrays.<Type>asList(),
                    Arrays.<TypeReference<?>>asList(new TypeReference<Bool>() {}));
    return executeRemoteCallSingleValueReturn(function, Boolean.class);
}
 
Example 14
public Tuple1<Boolean> getVerify_ring_sigOutput(TransactionReceipt transactionReceipt) {
    String data = transactionReceipt.getOutput();
    final Function function =
            new Function(
                    FUNC_VERIFY_RING_SIG,
                    Arrays.<Type>asList(),
                    Arrays.<TypeReference<?>>asList(new TypeReference<Bool>() {}));
    List<Type> results = FunctionReturnDecoder.decode(data, function.getOutputParameters());
    ;
    return new Tuple1<Boolean>((Boolean) results.get(0).getValue());
}
 
Example 15
public Tuple1<Boolean> getVerify_group_sigOutput(TransactionReceipt transactionReceipt) {
    String data = transactionReceipt.getOutput();
    final Function function =
            new Function(
                    FUNC_VERIFY_GROUP_SIG,
                    Arrays.<Type>asList(),
                    Arrays.<TypeReference<?>>asList(new TypeReference<Bool>() {}));
    List<Type> results = FunctionReturnDecoder.decode(data, function.getOutputParameters());
    ;
    return new Tuple1<Boolean>((Boolean) results.get(0).getValue());
}
 
Example 16
public RemoteCall<Boolean> get_group_verify_result() {
    final Function function =
            new Function(
                    FUNC_GET_GROUP_VERIFY_RESULT,
                    Arrays.<Type>asList(),
                    Arrays.<TypeReference<?>>asList(new TypeReference<Bool>() {}));
    return executeRemoteCallSingleValueReturn(function, Boolean.class);
}
 
Example 17
public RemoteCall<Boolean> ringSigVerify(String signature, String message, String paramInfo) {
    final Function function =
            new Function(
                    FUNC_RINGSIGVERIFY,
                    Arrays.<Type>asList(
                            new org.fisco.bcos.web3j.abi.datatypes.Utf8String(signature),
                            new org.fisco.bcos.web3j.abi.datatypes.Utf8String(message),
                            new org.fisco.bcos.web3j.abi.datatypes.Utf8String(paramInfo)),
                    Arrays.<TypeReference<?>>asList(new TypeReference<Bool>() {}));
    return executeRemoteCallSingleValueReturn(function, Boolean.class);
}
 
Example 18
Source Project: web3sdk   Source File: ResultEntity.java    License: Apache License 2.0 5 votes vote down vote up
public static Object typeToObject(Type type) {
    Object obj = null;
    if (type instanceof NumericType) { // uint int
        obj = ((NumericType) type).getValue();
    } else if (type instanceof Bool) { // bool
        obj = ((Bool) type).getValue();
    } else if (type instanceof Address) { // address
        obj = type.toString();
    } else if (type instanceof Bytes) { // bytes32
        obj = new String(((Bytes) type).getValue()).trim();
    } else if (type instanceof DynamicBytes) { // bytes
        obj = new String(((DynamicBytes) type).getValue()).trim();
    } else if (type instanceof Utf8String) { // string
        obj = ((Utf8String) type).getValue();
    } else if (type instanceof Array) { // T[] T[k]
        List<Object> r = new ArrayList<Object>();
        List l = ((Array) type).getValue();
        for (int i = 0; i < l.size(); ++i) {
            r.add(typeToObject((Type) l.get(i)));
        }

        obj = (Object) r;
    } else {
        obj = (Object) obj;
    }

    return obj;
}
 
Example 19
Source Project: web3sdk   Source File: SolidityFunctionWrapper.java    License: Apache License 2.0 5 votes vote down vote up
static TypeName getNativeType(TypeName typeName) {

        if (typeName instanceof ParameterizedTypeName) {
            return getNativeType((ParameterizedTypeName) typeName);
        }

        String simpleName = ((ClassName) typeName).simpleName();

        if (simpleName.startsWith(Address.class.getSimpleName())) {
            return TypeName.get(String.class);
        } else if (simpleName.startsWith("Uint")) {
            return TypeName.get(BigInteger.class);
        } else if (simpleName.startsWith("Int")) {
            return TypeName.get(BigInteger.class);
        } else if (simpleName.startsWith(Utf8String.class.getSimpleName())) {
            return TypeName.get(String.class);
        } else if (simpleName.startsWith("Bytes")) {
            return TypeName.get(byte[].class);
        } else if (simpleName.startsWith(DynamicBytes.class.getSimpleName())) {
            return TypeName.get(byte[].class);
        } else if (simpleName.startsWith(Bool.class.getSimpleName())) {
            return TypeName.get(Boolean.class); // boolean cannot be a parameterized type
        } else {
            throw new UnsupportedOperationException(
                    "Unsupported type: " + typeName + ", no native type mapping exists.");
        }
    }
 
Example 20
Source Project: web3sdk   Source File: ContractTypeUtilTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void getTypeTest() throws BaseException {
    assertThat(ContractTypeUtil.getType("bytes").getName(), is(DynamicBytes.class.getName()));
    assertThat(ContractTypeUtil.getType("address").getName(), is(Address.class.getName()));
    assertThat(ContractTypeUtil.getType("string").getName(), is(Utf8String.class.getName()));
    assertThat(ContractTypeUtil.getType("int").getName(), is(Int256.class.getName()));
    assertThat(ContractTypeUtil.getType("uint").getName(), is(Uint256.class.getName()));
    assertThat(ContractTypeUtil.getType("int256").getName(), is(Int256.class.getName()));
    assertThat(ContractTypeUtil.getType("uint256").getName(), is(Uint256.class.getName()));
    assertThat(ContractTypeUtil.getType("int8").getName(), is(Int8.class.getName()));
    assertThat(ContractTypeUtil.getType("uint8").getName(), is(Uint8.class.getName()));
    assertThat(ContractTypeUtil.getType("bool").getName(), is(Bool.class.getName()));
    assertThat(ContractTypeUtil.getType("bytes1").getName(), is(Bytes1.class.getName()));
    assertThat(ContractTypeUtil.getType("bytes32").getName(), is(Bytes32.class.getName()));
}
 
Example 21
Source Project: WeBASE-Front   Source File: EvidenceSignersData.java    License: Apache License 2.0 4 votes vote down vote up
public RemoteCall<Boolean> verify(String addr) {
    final Function function = new Function(FUNC_VERIFY, 
            Arrays.<Type>asList(new org.fisco.bcos.web3j.abi.datatypes.Address(addr)), 
            Arrays.<TypeReference<?>>asList(new TypeReference<Bool>() {}));
    return executeRemoteCallSingleValueReturn(function, Boolean.class);
}
 
Example 22
Source Project: WeBASE-Front   Source File: Evidence.java    License: Apache License 2.0 4 votes vote down vote up
public RemoteCall<Boolean> CallVerify(String addr) {
    final Function function = new Function(FUNC_CALLVERIFY, 
            Arrays.<Type>asList(new org.fisco.bcos.web3j.abi.datatypes.Address(addr)), 
            Arrays.<TypeReference<?>>asList(new TypeReference<Bool>() {}));
    return executeRemoteCallSingleValueReturn(function, Boolean.class);
}
 
Example 23
Source Project: web3sdk   Source File: DynamicArrayReference.java    License: Apache License 2.0 4 votes vote down vote up
public static TypeReference<?> create(String type, boolean indexed) throws BaseException {

        if (ContractTypeUtil.invalidInt(type)) {
            return new TypeReference<DynamicArray<Int256>>(indexed) {};
        } else if (ContractTypeUtil.invalidUint(type)) {
            return new TypeReference<DynamicArray<Uint256>>(indexed) {};
        }

        switch (type) {
            case "address":
                return new TypeReference<DynamicArray<Address>>(indexed) {};
            case "bool":
                return new TypeReference<DynamicArray<Bool>>(indexed) {};
            case "string":
                return new TypeReference<DynamicArray<Utf8String>>(indexed) {};
            case "bytes":
                return new TypeReference<DynamicArray<DynamicBytes>>(indexed) {};
            case "bytes1":
                return new TypeReference<DynamicArray<Bytes1>>(indexed) {};
            case "bytes2":
                return new TypeReference<DynamicArray<Bytes2>>(indexed) {};
            case "bytes3":
                return new TypeReference<DynamicArray<Bytes3>>(indexed) {};
            case "bytes4":
                return new TypeReference<DynamicArray<Bytes4>>(indexed) {};
            case "bytes5":
                return new TypeReference<DynamicArray<Bytes5>>(indexed) {};
            case "bytes6":
                return new TypeReference<DynamicArray<Bytes6>>(indexed) {};
            case "bytes7":
                return new TypeReference<DynamicArray<Bytes7>>(indexed) {};
            case "bytes8":
                return new TypeReference<DynamicArray<Bytes8>>(indexed) {};
            case "bytes9":
                return new TypeReference<DynamicArray<Bytes9>>(indexed) {};
            case "bytes10":
                return new TypeReference<DynamicArray<Bytes10>>(indexed) {};
            case "bytes11":
                return new TypeReference<DynamicArray<Bytes11>>(indexed) {};
            case "bytes12":
                return new TypeReference<DynamicArray<Bytes12>>(indexed) {};
            case "bytes13":
                return new TypeReference<DynamicArray<Bytes13>>(indexed) {};
            case "bytes14":
                return new TypeReference<DynamicArray<Bytes14>>(indexed) {};
            case "bytes15":
                return new TypeReference<DynamicArray<Bytes15>>(indexed) {};
            case "bytes16":
                return new TypeReference<DynamicArray<Bytes16>>(indexed) {};
            case "bytes17":
                return new TypeReference<DynamicArray<Bytes17>>(indexed) {};
            case "bytes18":
                return new TypeReference<DynamicArray<Bytes18>>(indexed) {};
            case "bytes19":
                return new TypeReference<DynamicArray<Bytes19>>(indexed) {};
            case "bytes20":
                return new TypeReference<DynamicArray<Bytes20>>(indexed) {};
            case "bytes21":
                return new TypeReference<DynamicArray<Bytes21>>(indexed) {};
            case "bytes22":
                return new TypeReference<DynamicArray<Bytes22>>(indexed) {};
            case "bytes23":
                return new TypeReference<DynamicArray<Bytes23>>(indexed) {};
            case "bytes24":
                return new TypeReference<DynamicArray<Bytes24>>(indexed) {};
            case "bytes25":
                return new TypeReference<DynamicArray<Bytes25>>(indexed) {};
            case "bytes26":
                return new TypeReference<DynamicArray<Bytes26>>(indexed) {};
            case "bytes27":
                return new TypeReference<DynamicArray<Bytes27>>(indexed) {};
            case "bytes28":
                return new TypeReference<DynamicArray<Bytes28>>(indexed) {};
            case "bytes29":
                return new TypeReference<DynamicArray<Bytes29>>(indexed) {};
            case "bytes30":
                return new TypeReference<DynamicArray<Bytes30>>(indexed) {};
            case "bytes31":
                return new TypeReference<DynamicArray<Bytes31>>(indexed) {};
            case "bytes32":
                return new TypeReference<DynamicArray<Bytes32>>(indexed) {};
            default:
                throw new BaseException(
                        201201,
                        String.format(" %s[] unsupported encoding dynamic array type ", type));
        }
    }
 
Example 24
Source Project: web3sdk   Source File: StaticArrayReference.java    License: Apache License 2.0 4 votes vote down vote up
private static TypeReference<?> create1(String type, boolean indexed) throws BaseException {

        if (ContractTypeUtil.invalidInt(type)) {
            return new TypeReference<StaticArray1<Int256>>(indexed) {};
        } else if (ContractTypeUtil.invalidUint(type)) {
            return new TypeReference<StaticArray1<Uint256>>(indexed) {};
        }

        switch (type) {
            case "address":
                return new TypeReference<StaticArray1<Address>>(indexed) {};
            case "bool":
                return new TypeReference<StaticArray1<Bool>>(indexed) {};
            case "string":
                return new TypeReference<StaticArray1<Utf8String>>(indexed) {};
            case "bytes":
                return new TypeReference<StaticArray1<DynamicBytes>>(indexed) {};
            case "bytes1":
                return new TypeReference<StaticArray1<Bytes1>>(indexed) {};
            case "bytes2":
                return new TypeReference<StaticArray1<Bytes2>>(indexed) {};
            case "bytes3":
                return new TypeReference<StaticArray1<Bytes3>>(indexed) {};
            case "bytes4":
                return new TypeReference<StaticArray1<Bytes4>>(indexed) {};
            case "bytes5":
                return new TypeReference<StaticArray1<Bytes5>>(indexed) {};
            case "bytes6":
                return new TypeReference<StaticArray1<Bytes6>>(indexed) {};
            case "bytes7":
                return new TypeReference<StaticArray1<Bytes7>>(indexed) {};
            case "bytes8":
                return new TypeReference<StaticArray1<Bytes8>>(indexed) {};
            case "bytes9":
                return new TypeReference<StaticArray1<Bytes9>>(indexed) {};
            case "bytes10":
                return new TypeReference<StaticArray1<Bytes10>>(indexed) {};
            case "bytes11":
                return new TypeReference<StaticArray1<Bytes11>>(indexed) {};
            case "bytes12":
                return new TypeReference<StaticArray1<Bytes12>>(indexed) {};
            case "bytes13":
                return new TypeReference<StaticArray1<Bytes13>>(indexed) {};
            case "bytes14":
                return new TypeReference<StaticArray1<Bytes14>>(indexed) {};
            case "bytes15":
                return new TypeReference<StaticArray1<Bytes15>>(indexed) {};
            case "bytes16":
                return new TypeReference<StaticArray1<Bytes16>>(indexed) {};
            case "bytes17":
                return new TypeReference<StaticArray1<Bytes17>>(indexed) {};
            case "bytes18":
                return new TypeReference<StaticArray1<Bytes18>>(indexed) {};
            case "bytes19":
                return new TypeReference<StaticArray1<Bytes19>>(indexed) {};
            case "bytes20":
                return new TypeReference<StaticArray1<Bytes20>>(indexed) {};
            case "bytes21":
                return new TypeReference<StaticArray1<Bytes21>>(indexed) {};
            case "bytes22":
                return new TypeReference<StaticArray1<Bytes22>>(indexed) {};
            case "bytes23":
                return new TypeReference<StaticArray1<Bytes23>>(indexed) {};
            case "bytes24":
                return new TypeReference<StaticArray1<Bytes24>>(indexed) {};
            case "bytes25":
                return new TypeReference<StaticArray1<Bytes25>>(indexed) {};
            case "bytes26":
                return new TypeReference<StaticArray1<Bytes26>>(indexed) {};
            case "bytes27":
                return new TypeReference<StaticArray1<Bytes27>>(indexed) {};
            case "bytes28":
                return new TypeReference<StaticArray1<Bytes28>>(indexed) {};
            case "bytes29":
                return new TypeReference<StaticArray1<Bytes29>>(indexed) {};
            case "bytes30":
                return new TypeReference<StaticArray1<Bytes30>>(indexed) {};
            case "bytes31":
                return new TypeReference<StaticArray1<Bytes31>>(indexed) {};
            case "bytes32":
                return new TypeReference<StaticArray1<Bytes32>>(indexed) {};
            default:
                throw new BaseException(
                        201201, String.format(" %s[1] unsupported encoding array type ", type));
        }
    }
 
Example 25
Source Project: web3sdk   Source File: StaticArrayReference.java    License: Apache License 2.0 4 votes vote down vote up
private static TypeReference<?> create2(String type, boolean indexed) throws BaseException {

        if (ContractTypeUtil.invalidInt(type)) {
            return new TypeReference<StaticArray2<Int256>>(indexed) {};
        } else if (ContractTypeUtil.invalidUint(type)) {
            return new TypeReference<StaticArray2<Uint256>>(indexed) {};
        }

        switch (type) {
            case "address":
                return new TypeReference<StaticArray2<Address>>(indexed) {};
            case "bool":
                return new TypeReference<StaticArray2<Bool>>(indexed) {};
            case "string":
                return new TypeReference<StaticArray2<Utf8String>>(indexed) {};
            case "bytes":
                return new TypeReference<StaticArray2<DynamicBytes>>(indexed) {};
            case "bytes1":
                return new TypeReference<StaticArray2<Bytes1>>(indexed) {};
            case "bytes2":
                return new TypeReference<StaticArray2<Bytes2>>(indexed) {};
            case "bytes3":
                return new TypeReference<StaticArray2<Bytes3>>(indexed) {};
            case "bytes4":
                return new TypeReference<StaticArray2<Bytes4>>(indexed) {};
            case "bytes5":
                return new TypeReference<StaticArray2<Bytes5>>(indexed) {};
            case "bytes6":
                return new TypeReference<StaticArray2<Bytes6>>(indexed) {};
            case "bytes7":
                return new TypeReference<StaticArray2<Bytes7>>(indexed) {};
            case "bytes8":
                return new TypeReference<StaticArray2<Bytes8>>(indexed) {};
            case "bytes9":
                return new TypeReference<StaticArray2<Bytes9>>(indexed) {};
            case "bytes10":
                return new TypeReference<StaticArray2<Bytes10>>(indexed) {};
            case "bytes11":
                return new TypeReference<StaticArray2<Bytes11>>(indexed) {};
            case "bytes12":
                return new TypeReference<StaticArray2<Bytes12>>(indexed) {};
            case "bytes13":
                return new TypeReference<StaticArray2<Bytes13>>(indexed) {};
            case "bytes14":
                return new TypeReference<StaticArray2<Bytes14>>(indexed) {};
            case "bytes15":
                return new TypeReference<StaticArray2<Bytes15>>(indexed) {};
            case "bytes16":
                return new TypeReference<StaticArray2<Bytes16>>(indexed) {};
            case "bytes17":
                return new TypeReference<StaticArray2<Bytes17>>(indexed) {};
            case "bytes18":
                return new TypeReference<StaticArray2<Bytes18>>(indexed) {};
            case "bytes19":
                return new TypeReference<StaticArray2<Bytes19>>(indexed) {};
            case "bytes20":
                return new TypeReference<StaticArray2<Bytes20>>(indexed) {};
            case "bytes21":
                return new TypeReference<StaticArray2<Bytes21>>(indexed) {};
            case "bytes22":
                return new TypeReference<StaticArray2<Bytes22>>(indexed) {};
            case "bytes23":
                return new TypeReference<StaticArray2<Bytes23>>(indexed) {};
            case "bytes24":
                return new TypeReference<StaticArray2<Bytes24>>(indexed) {};
            case "bytes25":
                return new TypeReference<StaticArray2<Bytes25>>(indexed) {};
            case "bytes26":
                return new TypeReference<StaticArray2<Bytes26>>(indexed) {};
            case "bytes27":
                return new TypeReference<StaticArray2<Bytes27>>(indexed) {};
            case "bytes28":
                return new TypeReference<StaticArray2<Bytes28>>(indexed) {};
            case "bytes29":
                return new TypeReference<StaticArray2<Bytes29>>(indexed) {};
            case "bytes30":
                return new TypeReference<StaticArray2<Bytes30>>(indexed) {};
            case "bytes31":
                return new TypeReference<StaticArray2<Bytes31>>(indexed) {};
            case "bytes32":
                return new TypeReference<StaticArray2<Bytes32>>(indexed) {};
            default:
                throw new BaseException(
                        201201, String.format(" %s[2] unsupported encoding array type ", type));
        }
    }
 
Example 26
Source Project: web3sdk   Source File: StaticArrayReference.java    License: Apache License 2.0 4 votes vote down vote up
private static TypeReference<?> create3(String type, boolean indexed) throws BaseException {

        if (ContractTypeUtil.invalidInt(type)) {
            return new TypeReference<StaticArray3<Int256>>(indexed) {};
        } else if (ContractTypeUtil.invalidUint(type)) {
            return new TypeReference<StaticArray3<Uint256>>(indexed) {};
        }

        switch (type) {
            case "address":
                return new TypeReference<StaticArray3<Address>>(indexed) {};
            case "bool":
                return new TypeReference<StaticArray3<Bool>>(indexed) {};
            case "string":
                return new TypeReference<StaticArray3<Utf8String>>(indexed) {};
            case "bytes":
                return new TypeReference<StaticArray3<DynamicBytes>>(indexed) {};
            case "bytes1":
                return new TypeReference<StaticArray3<Bytes1>>(indexed) {};
            case "bytes2":
                return new TypeReference<StaticArray3<Bytes2>>(indexed) {};
            case "bytes3":
                return new TypeReference<StaticArray3<Bytes3>>(indexed) {};
            case "bytes4":
                return new TypeReference<StaticArray3<Bytes4>>(indexed) {};
            case "bytes5":
                return new TypeReference<StaticArray3<Bytes5>>(indexed) {};
            case "bytes6":
                return new TypeReference<StaticArray3<Bytes6>>(indexed) {};
            case "bytes7":
                return new TypeReference<StaticArray3<Bytes7>>(indexed) {};
            case "bytes8":
                return new TypeReference<StaticArray3<Bytes8>>(indexed) {};
            case "bytes9":
                return new TypeReference<StaticArray3<Bytes9>>(indexed) {};
            case "bytes10":
                return new TypeReference<StaticArray3<Bytes10>>(indexed) {};
            case "bytes11":
                return new TypeReference<StaticArray3<Bytes11>>(indexed) {};
            case "bytes12":
                return new TypeReference<StaticArray3<Bytes12>>(indexed) {};
            case "bytes13":
                return new TypeReference<StaticArray3<Bytes13>>(indexed) {};
            case "bytes14":
                return new TypeReference<StaticArray3<Bytes14>>(indexed) {};
            case "bytes15":
                return new TypeReference<StaticArray3<Bytes15>>(indexed) {};
            case "bytes16":
                return new TypeReference<StaticArray3<Bytes16>>(indexed) {};
            case "bytes17":
                return new TypeReference<StaticArray3<Bytes17>>(indexed) {};
            case "bytes18":
                return new TypeReference<StaticArray3<Bytes18>>(indexed) {};
            case "bytes19":
                return new TypeReference<StaticArray3<Bytes19>>(indexed) {};
            case "bytes20":
                return new TypeReference<StaticArray3<Bytes20>>(indexed) {};
            case "bytes21":
                return new TypeReference<StaticArray3<Bytes21>>(indexed) {};
            case "bytes22":
                return new TypeReference<StaticArray3<Bytes22>>(indexed) {};
            case "bytes23":
                return new TypeReference<StaticArray3<Bytes23>>(indexed) {};
            case "bytes24":
                return new TypeReference<StaticArray3<Bytes24>>(indexed) {};
            case "bytes25":
                return new TypeReference<StaticArray3<Bytes25>>(indexed) {};
            case "bytes26":
                return new TypeReference<StaticArray3<Bytes26>>(indexed) {};
            case "bytes27":
                return new TypeReference<StaticArray3<Bytes27>>(indexed) {};
            case "bytes28":
                return new TypeReference<StaticArray3<Bytes28>>(indexed) {};
            case "bytes29":
                return new TypeReference<StaticArray3<Bytes29>>(indexed) {};
            case "bytes30":
                return new TypeReference<StaticArray3<Bytes30>>(indexed) {};
            case "bytes31":
                return new TypeReference<StaticArray3<Bytes31>>(indexed) {};
            case "bytes32":
                return new TypeReference<StaticArray3<Bytes32>>(indexed) {};
            default:
                throw new BaseException(
                        201201, String.format(" %s[3] unsupported encoding array type ", type));
        }
    }
 
Example 27
Source Project: web3sdk   Source File: StaticArrayReference.java    License: Apache License 2.0 4 votes vote down vote up
private static TypeReference<?> create4(String type, boolean indexed) throws BaseException {

        if (ContractTypeUtil.invalidInt(type)) {
            return new TypeReference<StaticArray4<Int256>>(indexed) {};
        } else if (ContractTypeUtil.invalidUint(type)) {
            return new TypeReference<StaticArray4<Uint256>>(indexed) {};
        }

        switch (type) {
            case "address":
                return new TypeReference<StaticArray4<Address>>(indexed) {};
            case "bool":
                return new TypeReference<StaticArray4<Bool>>(indexed) {};
            case "string":
                return new TypeReference<StaticArray4<Utf8String>>(indexed) {};
            case "bytes":
                return new TypeReference<StaticArray4<DynamicBytes>>(indexed) {};
            case "bytes1":
                return new TypeReference<StaticArray4<Bytes1>>(indexed) {};
            case "bytes2":
                return new TypeReference<StaticArray4<Bytes2>>(indexed) {};
            case "bytes3":
                return new TypeReference<StaticArray4<Bytes3>>(indexed) {};
            case "bytes4":
                return new TypeReference<StaticArray4<Bytes4>>(indexed) {};
            case "bytes5":
                return new TypeReference<StaticArray4<Bytes5>>(indexed) {};
            case "bytes6":
                return new TypeReference<StaticArray4<Bytes6>>(indexed) {};
            case "bytes7":
                return new TypeReference<StaticArray4<Bytes7>>(indexed) {};
            case "bytes8":
                return new TypeReference<StaticArray4<Bytes8>>(indexed) {};
            case "bytes9":
                return new TypeReference<StaticArray4<Bytes9>>(indexed) {};
            case "bytes10":
                return new TypeReference<StaticArray4<Bytes10>>(indexed) {};
            case "bytes11":
                return new TypeReference<StaticArray4<Bytes11>>(indexed) {};
            case "bytes12":
                return new TypeReference<StaticArray4<Bytes12>>(indexed) {};
            case "bytes13":
                return new TypeReference<StaticArray4<Bytes13>>(indexed) {};
            case "bytes14":
                return new TypeReference<StaticArray4<Bytes14>>(indexed) {};
            case "bytes15":
                return new TypeReference<StaticArray4<Bytes15>>(indexed) {};
            case "bytes16":
                return new TypeReference<StaticArray4<Bytes16>>(indexed) {};
            case "bytes17":
                return new TypeReference<StaticArray4<Bytes17>>(indexed) {};
            case "bytes18":
                return new TypeReference<StaticArray4<Bytes18>>(indexed) {};
            case "bytes19":
                return new TypeReference<StaticArray4<Bytes19>>(indexed) {};
            case "bytes20":
                return new TypeReference<StaticArray4<Bytes20>>(indexed) {};
            case "bytes21":
                return new TypeReference<StaticArray4<Bytes21>>(indexed) {};
            case "bytes22":
                return new TypeReference<StaticArray4<Bytes22>>(indexed) {};
            case "bytes23":
                return new TypeReference<StaticArray4<Bytes23>>(indexed) {};
            case "bytes24":
                return new TypeReference<StaticArray4<Bytes24>>(indexed) {};
            case "bytes25":
                return new TypeReference<StaticArray4<Bytes25>>(indexed) {};
            case "bytes26":
                return new TypeReference<StaticArray4<Bytes26>>(indexed) {};
            case "bytes27":
                return new TypeReference<StaticArray4<Bytes27>>(indexed) {};
            case "bytes28":
                return new TypeReference<StaticArray4<Bytes28>>(indexed) {};
            case "bytes29":
                return new TypeReference<StaticArray4<Bytes29>>(indexed) {};
            case "bytes30":
                return new TypeReference<StaticArray4<Bytes30>>(indexed) {};
            case "bytes31":
                return new TypeReference<StaticArray4<Bytes31>>(indexed) {};
            case "bytes32":
                return new TypeReference<StaticArray4<Bytes32>>(indexed) {};
            default:
                throw new BaseException(
                        201201, String.format(" %s[4] unsupported encoding array type ", type));
        }
    }
 
Example 28
Source Project: web3sdk   Source File: StaticArrayReference.java    License: Apache License 2.0 4 votes vote down vote up
private static TypeReference<?> create5(String type, boolean indexed) throws BaseException {

        if (ContractTypeUtil.invalidInt(type)) {
            return new TypeReference<StaticArray5<Int256>>(indexed) {};
        } else if (ContractTypeUtil.invalidUint(type)) {
            return new TypeReference<StaticArray5<Uint256>>(indexed) {};
        }

        switch (type) {
            case "address":
                return new TypeReference<StaticArray5<Address>>(indexed) {};
            case "bool":
                return new TypeReference<StaticArray5<Bool>>(indexed) {};
            case "string":
                return new TypeReference<StaticArray5<Utf8String>>(indexed) {};
            case "bytes":
                return new TypeReference<StaticArray5<DynamicBytes>>(indexed) {};
            case "bytes1":
                return new TypeReference<StaticArray5<Bytes1>>(indexed) {};
            case "bytes2":
                return new TypeReference<StaticArray5<Bytes2>>(indexed) {};
            case "bytes3":
                return new TypeReference<StaticArray5<Bytes3>>(indexed) {};
            case "bytes4":
                return new TypeReference<StaticArray5<Bytes4>>(indexed) {};
            case "bytes5":
                return new TypeReference<StaticArray5<Bytes5>>(indexed) {};
            case "bytes6":
                return new TypeReference<StaticArray5<Bytes6>>(indexed) {};
            case "bytes7":
                return new TypeReference<StaticArray5<Bytes7>>(indexed) {};
            case "bytes8":
                return new TypeReference<StaticArray5<Bytes8>>(indexed) {};
            case "bytes9":
                return new TypeReference<StaticArray5<Bytes9>>(indexed) {};
            case "bytes10":
                return new TypeReference<StaticArray5<Bytes10>>(indexed) {};
            case "bytes11":
                return new TypeReference<StaticArray5<Bytes11>>(indexed) {};
            case "bytes12":
                return new TypeReference<StaticArray5<Bytes12>>(indexed) {};
            case "bytes13":
                return new TypeReference<StaticArray5<Bytes13>>(indexed) {};
            case "bytes14":
                return new TypeReference<StaticArray5<Bytes14>>(indexed) {};
            case "bytes15":
                return new TypeReference<StaticArray5<Bytes15>>(indexed) {};
            case "bytes16":
                return new TypeReference<StaticArray5<Bytes16>>(indexed) {};
            case "bytes17":
                return new TypeReference<StaticArray5<Bytes17>>(indexed) {};
            case "bytes18":
                return new TypeReference<StaticArray5<Bytes18>>(indexed) {};
            case "bytes19":
                return new TypeReference<StaticArray5<Bytes19>>(indexed) {};
            case "bytes20":
                return new TypeReference<StaticArray5<Bytes20>>(indexed) {};
            case "bytes21":
                return new TypeReference<StaticArray5<Bytes21>>(indexed) {};
            case "bytes22":
                return new TypeReference<StaticArray5<Bytes22>>(indexed) {};
            case "bytes23":
                return new TypeReference<StaticArray5<Bytes23>>(indexed) {};
            case "bytes24":
                return new TypeReference<StaticArray5<Bytes24>>(indexed) {};
            case "bytes25":
                return new TypeReference<StaticArray5<Bytes25>>(indexed) {};
            case "bytes26":
                return new TypeReference<StaticArray5<Bytes26>>(indexed) {};
            case "bytes27":
                return new TypeReference<StaticArray5<Bytes27>>(indexed) {};
            case "bytes28":
                return new TypeReference<StaticArray5<Bytes28>>(indexed) {};
            case "bytes29":
                return new TypeReference<StaticArray5<Bytes29>>(indexed) {};
            case "bytes30":
                return new TypeReference<StaticArray5<Bytes30>>(indexed) {};
            case "bytes31":
                return new TypeReference<StaticArray5<Bytes31>>(indexed) {};
            case "bytes32":
                return new TypeReference<StaticArray5<Bytes32>>(indexed) {};
            default:
                throw new BaseException(
                        201201, String.format(" %s[5] unsupported encoding array type ", type));
        }
    }
 
Example 29
Source Project: web3sdk   Source File: StaticArrayReference.java    License: Apache License 2.0 4 votes vote down vote up
private static TypeReference<?> create6(String type, boolean indexed) throws BaseException {

        if (ContractTypeUtil.invalidInt(type)) {
            return new TypeReference<StaticArray6<Int256>>(indexed) {};
        } else if (ContractTypeUtil.invalidUint(type)) {
            return new TypeReference<StaticArray6<Uint256>>(indexed) {};
        }

        switch (type) {
            case "address":
                return new TypeReference<StaticArray6<Address>>(indexed) {};
            case "bool":
                return new TypeReference<StaticArray6<Bool>>(indexed) {};
            case "string":
                return new TypeReference<StaticArray6<Utf8String>>(indexed) {};
            case "bytes":
                return new TypeReference<StaticArray6<DynamicBytes>>(indexed) {};
            case "bytes1":
                return new TypeReference<StaticArray6<Bytes1>>(indexed) {};
            case "bytes2":
                return new TypeReference<StaticArray6<Bytes2>>(indexed) {};
            case "bytes3":
                return new TypeReference<StaticArray6<Bytes3>>(indexed) {};
            case "bytes4":
                return new TypeReference<StaticArray6<Bytes4>>(indexed) {};
            case "bytes5":
                return new TypeReference<StaticArray6<Bytes5>>(indexed) {};
            case "bytes6":
                return new TypeReference<StaticArray6<Bytes6>>(indexed) {};
            case "bytes7":
                return new TypeReference<StaticArray6<Bytes7>>(indexed) {};
            case "bytes8":
                return new TypeReference<StaticArray6<Bytes8>>(indexed) {};
            case "bytes9":
                return new TypeReference<StaticArray6<Bytes9>>(indexed) {};
            case "bytes10":
                return new TypeReference<StaticArray6<Bytes10>>(indexed) {};
            case "bytes11":
                return new TypeReference<StaticArray6<Bytes11>>(indexed) {};
            case "bytes12":
                return new TypeReference<StaticArray6<Bytes12>>(indexed) {};
            case "bytes13":
                return new TypeReference<StaticArray6<Bytes13>>(indexed) {};
            case "bytes14":
                return new TypeReference<StaticArray6<Bytes14>>(indexed) {};
            case "bytes15":
                return new TypeReference<StaticArray6<Bytes15>>(indexed) {};
            case "bytes16":
                return new TypeReference<StaticArray6<Bytes16>>(indexed) {};
            case "bytes17":
                return new TypeReference<StaticArray6<Bytes17>>(indexed) {};
            case "bytes18":
                return new TypeReference<StaticArray6<Bytes18>>(indexed) {};
            case "bytes19":
                return new TypeReference<StaticArray6<Bytes19>>(indexed) {};
            case "bytes20":
                return new TypeReference<StaticArray6<Bytes20>>(indexed) {};
            case "bytes21":
                return new TypeReference<StaticArray6<Bytes21>>(indexed) {};
            case "bytes22":
                return new TypeReference<StaticArray6<Bytes22>>(indexed) {};
            case "bytes23":
                return new TypeReference<StaticArray6<Bytes23>>(indexed) {};
            case "bytes24":
                return new TypeReference<StaticArray6<Bytes24>>(indexed) {};
            case "bytes25":
                return new TypeReference<StaticArray6<Bytes25>>(indexed) {};
            case "bytes26":
                return new TypeReference<StaticArray6<Bytes26>>(indexed) {};
            case "bytes27":
                return new TypeReference<StaticArray6<Bytes27>>(indexed) {};
            case "bytes28":
                return new TypeReference<StaticArray6<Bytes28>>(indexed) {};
            case "bytes29":
                return new TypeReference<StaticArray6<Bytes29>>(indexed) {};
            case "bytes30":
                return new TypeReference<StaticArray6<Bytes30>>(indexed) {};
            case "bytes31":
                return new TypeReference<StaticArray6<Bytes31>>(indexed) {};
            case "bytes32":
                return new TypeReference<StaticArray6<Bytes32>>(indexed) {};
            default:
                throw new BaseException(
                        201201, String.format(" %s[6] unsupported encoding array type ", type));
        }
    }
 
Example 30
Source Project: web3sdk   Source File: StaticArrayReference.java    License: Apache License 2.0 4 votes vote down vote up
private static TypeReference<?> create7(String type, boolean indexed) throws BaseException {

        if (ContractTypeUtil.invalidInt(type)) {
            return new TypeReference<StaticArray7<Int256>>(indexed) {};
        } else if (ContractTypeUtil.invalidUint(type)) {
            return new TypeReference<StaticArray7<Uint256>>(indexed) {};
        }

        switch (type) {
            case "address":
                return new TypeReference<StaticArray7<Address>>(indexed) {};
            case "bool":
                return new TypeReference<StaticArray7<Bool>>(indexed) {};
            case "string":
                return new TypeReference<StaticArray7<Utf8String>>(indexed) {};
            case "bytes":
                return new TypeReference<StaticArray7<DynamicBytes>>(indexed) {};
            case "bytes1":
                return new TypeReference<StaticArray7<Bytes1>>(indexed) {};
            case "bytes2":
                return new TypeReference<StaticArray7<Bytes2>>(indexed) {};
            case "bytes3":
                return new TypeReference<StaticArray7<Bytes3>>(indexed) {};
            case "bytes4":
                return new TypeReference<StaticArray7<Bytes4>>(indexed) {};
            case "bytes5":
                return new TypeReference<StaticArray7<Bytes5>>(indexed) {};
            case "bytes6":
                return new TypeReference<StaticArray7<Bytes6>>(indexed) {};
            case "bytes7":
                return new TypeReference<StaticArray7<Bytes7>>(indexed) {};
            case "bytes8":
                return new TypeReference<StaticArray7<Bytes8>>(indexed) {};
            case "bytes9":
                return new TypeReference<StaticArray7<Bytes9>>(indexed) {};
            case "bytes10":
                return new TypeReference<StaticArray7<Bytes10>>(indexed) {};
            case "bytes11":
                return new TypeReference<StaticArray7<Bytes11>>(indexed) {};
            case "bytes12":
                return new TypeReference<StaticArray7<Bytes12>>(indexed) {};
            case "bytes13":
                return new TypeReference<StaticArray7<Bytes13>>(indexed) {};
            case "bytes14":
                return new TypeReference<StaticArray7<Bytes14>>(indexed) {};
            case "bytes15":
                return new TypeReference<StaticArray7<Bytes15>>(indexed) {};
            case "bytes16":
                return new TypeReference<StaticArray7<Bytes16>>(indexed) {};
            case "bytes17":
                return new TypeReference<StaticArray7<Bytes17>>(indexed) {};
            case "bytes18":
                return new TypeReference<StaticArray7<Bytes18>>(indexed) {};
            case "bytes19":
                return new TypeReference<StaticArray7<Bytes19>>(indexed) {};
            case "bytes20":
                return new TypeReference<StaticArray7<Bytes20>>(indexed) {};
            case "bytes21":
                return new TypeReference<StaticArray7<Bytes21>>(indexed) {};
            case "bytes22":
                return new TypeReference<StaticArray7<Bytes22>>(indexed) {};
            case "bytes23":
                return new TypeReference<StaticArray7<Bytes23>>(indexed) {};
            case "bytes24":
                return new TypeReference<StaticArray7<Bytes24>>(indexed) {};
            case "bytes25":
                return new TypeReference<StaticArray7<Bytes25>>(indexed) {};
            case "bytes26":
                return new TypeReference<StaticArray7<Bytes26>>(indexed) {};
            case "bytes27":
                return new TypeReference<StaticArray7<Bytes27>>(indexed) {};
            case "bytes28":
                return new TypeReference<StaticArray7<Bytes28>>(indexed) {};
            case "bytes29":
                return new TypeReference<StaticArray7<Bytes29>>(indexed) {};
            case "bytes30":
                return new TypeReference<StaticArray7<Bytes30>>(indexed) {};
            case "bytes31":
                return new TypeReference<StaticArray7<Bytes31>>(indexed) {};
            case "bytes32":
                return new TypeReference<StaticArray7<Bytes32>>(indexed) {};
            default:
                throw new BaseException(
                        201201, String.format(" %s[7] unsupported encoding array type ", type));
        }
    }