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

@Test
public void typeToObjectArrayTest() throws JsonProcessingException {
    ResultEntity r0 = new ResultEntity("string", "string", new Utf8String("章鱼丸子"));
    assertThat(r0.toJson(), is("{\"name\":\"string\",\"type\":\"string\",\"data\":\"章鱼丸子\"}"));
    ResultEntity r1 = new ResultEntity("uint256", "uint256", new Uint256(247809787));
    assertThat(
            r1.toJson(), is("{\"name\":\"uint256\",\"type\":\"uint256\",\"data\":247809787}"));
    ResultEntity r2 = new ResultEntity("int256", "int256", new Int256(-247809787));
    assertThat(
            r2.toJson(), is("{\"name\":\"int256\",\"type\":\"int256\",\"data\":-247809787}"));
    ResultEntity r3 = new ResultEntity("bool", "bool", new Bool(true));
    assertThat(r3.toJson(), is("{\"name\":\"bool\",\"type\":\"bool\",\"data\":true}"));
    ResultEntity r4 =
            new ResultEntity("bytes", "bytes", new DynamicBytes("dasfjl;kljadfkl".getBytes()));
    assertThat(
            r4.toJson(),
            is("{\"name\":\"bytes\",\"type\":\"bytes\",\"data\":\"dasfjl;kljadfkl\"}"));

    ResultEntity r5 =
            new ResultEntity(
                    "StaticArray1", "StaticArray1", new StaticArray1<Uint256>(new Uint256(22)));
    assertThat(
            r5.toJson(),
            is("{\"name\":\"StaticArray1\",\"type\":\"StaticArray1\",\"data\":[22]}"));
    ResultEntity r6 =
            new ResultEntity(
                    "StaticArray3",
                    "StaticArray3",
                    new StaticArray3<Uint256>(new Uint256(1), new Uint256(2), new Uint256(3)));
    assertThat(
            r6.toJson(),
            is("{\"name\":\"StaticArray3\",\"type\":\"StaticArray3\",\"data\":[1,2,3]}"));
    ResultEntity r7 =
            new ResultEntity(
                    "DynamicArray",
                    "DynamicArray",
                    new DynamicArray<Bool>(new Bool(true), new Bool(false), new Bool(true)));
    assertThat(
            r7.toJson(),
            is(
                    "{\"name\":\"DynamicArray\",\"type\":\"DynamicArray\",\"data\":[true,false,true]}"));
    ResultEntity r8 =
            new ResultEntity(
                    "DynamicArray",
                    "DynamicArray",
                    new DynamicArray<Bytes7>(
                            new Bytes7("sdafljk".getBytes()),
                            new Bytes7("sdafljk".getBytes()),
                            new Bytes7("sdafljk".getBytes())));
    assertThat(
            r8.toJson(),
            is(
                    "{\"name\":\"DynamicArray\",\"type\":\"DynamicArray\",\"data\":[\"sdafljk\",\"sdafljk\",\"sdafljk\"]}"));
}