Merge pull request #13 from strategyobject/feature/pallet-query-api

Annotations for pallets and their storages

Author: vnabiev

api/build.gradle

@@ -1,3 +1,18 @@
 dependencies {
     implementation project(':rpc')
+    implementation project(':rpc:rpc-core')
+    implementation project(':rpc:rpc-sections')
+    implementation project(':transport')
+    implementation project(':pallet')
+    implementation project(':scale')
+    implementation project(':types')
+    implementation project(':rpc:rpc-types')
+    implementation project(':storage')
+
+    testImplementation project(':tests')
+
+    testImplementation 'org.testcontainers:testcontainers:1.16.3'
+    testImplementation 'org.testcontainers:junit-jupiter:1.16.3'
+
+    testAnnotationProcessor project(':pallet:pallet-codegen')
 }

api/src/main/java/com/strategyobject/substrateclient/api/Api.java

@@ -1,7 +1,33 @@
 package com.strategyobject.substrateclient.api;
 
+import com.strategyobject.substrateclient.pallet.GeneratedPalletResolver;
 import com.strategyobject.substrateclient.rpc.Rpc;
+import com.strategyobject.substrateclient.rpc.RpcImpl;
+import com.strategyobject.substrateclient.transport.ProviderInterface;
+import lombok.val;
 
+/**
+ * Provides the ability to query a node and interact with the Polkadot or Substrate chains.
+ * It allows interacting with blockchain in various ways: using RPC's queries directly or
+ * accessing Pallets and its APIs, such as storages, transactions, etc.
+ */
 public interface Api {
+    static DefaultApi with(ProviderInterface provider) {
+        val rpc = RpcImpl.with(provider);
+
+        return DefaultApi.with(rpc, GeneratedPalletResolver.with(rpc));
+    }
+
+    /**
+     * @return the instance that provides a proper API for querying the RPC's methods.
+     */
     Rpc rpc();
+
+    /**
+     * Resolves the instance of a pallet by its definition.
+     * @param clazz the class of the pallet
+     * @param <T> the type of the pallet
+     * @return appropriate instance of the pallet
+     */
+    <T> T pallet(Class<T> clazz);
 }

api/src/main/java/com/strategyobject/substrateclient/api/DefaultApi.java

@@ -0,0 +1,34 @@
+package com.strategyobject.substrateclient.api;
+
+import com.strategyobject.substrateclient.pallet.PalletResolver;
+import com.strategyobject.substrateclient.rpc.Rpc;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+@RequiredArgsConstructor(staticName = "with")
+public class DefaultApi implements Api, AutoCloseable {
+    private final @NonNull Rpc rpc;
+    private final @NonNull PalletResolver palletResolver;
+    private final Map<Class<?>, Object> palletCache = new ConcurrentHashMap<>();
+
+    @Override
+    public Rpc rpc() {
+        return rpc;
+    }
+
+    @Override
+    public <T> T pallet(@NonNull Class<T> clazz) {
+        return clazz.cast(palletCache
+                .computeIfAbsent(clazz, palletResolver::resolve));
+    }
+
+    @Override
+    public void close() throws Exception {
+        if (rpc instanceof AutoCloseable) {
+            ((AutoCloseable) rpc).close();
+        }
+    }
+}

api/src/test/java/com/strategyobject/substrateclient/api/ApiTests.java

@@ -0,0 +1,42 @@
+package com.strategyobject.substrateclient.api;
+
+import com.strategyobject.substrateclient.tests.containers.SubstrateVersion;
+import com.strategyobject.substrateclient.tests.containers.TestSubstrateContainer;
+import com.strategyobject.substrateclient.transport.ws.WsProvider;
+import lombok.val;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.math.BigInteger;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+@Testcontainers
+public class ApiTests {
+    private static final int WAIT_TIMEOUT = 1000;
+
+    @Container
+    private final TestSubstrateContainer substrate = new TestSubstrateContainer(SubstrateVersion.V3_0_0);
+
+    @Test
+    public void getSystemPalletAndCall() throws Exception { // TODO move the test out of the project
+        val wsProvider = WsProvider.builder()
+                .setEndpoint(substrate.getWsAddress())
+                .build();
+        wsProvider.connect().get(WAIT_TIMEOUT, TimeUnit.SECONDS);
+
+        try (val api = Api.with(wsProvider)) {
+            val systemPallet = api.pallet(SystemPallet.class);
+            val blockHash = systemPallet
+                    .blockHash()
+                    .get(0)
+                    .get(WAIT_TIMEOUT, TimeUnit.SECONDS);
+
+            assertNotNull(blockHash);
+            assertNotEquals(BigInteger.ZERO, new BigInteger(blockHash.getData()));
+        }
+    }
+}

api/src/test/java/com/strategyobject/substrateclient/api/SystemPallet.java

@@ -0,0 +1,22 @@
+package com.strategyobject.substrateclient.api;
+
+import com.strategyobject.substrateclient.pallet.annotations.Pallet;
+import com.strategyobject.substrateclient.pallet.annotations.Storage;
+import com.strategyobject.substrateclient.pallet.annotations.StorageHasher;
+import com.strategyobject.substrateclient.pallet.annotations.StorageKey;
+import com.strategyobject.substrateclient.rpc.types.BlockHash;
+import com.strategyobject.substrateclient.scale.annotations.Scale;
+import com.strategyobject.substrateclient.storage.StorageNMap;
+
+@Pallet("System")
+public interface SystemPallet {
+    @Storage(
+            value = "BlockHash",
+            keys = {
+                    @StorageKey(
+                            type = @Scale(Integer.class),
+                            hasher = StorageHasher.TwoX64Concat
+                    )
+            })
+    StorageNMap<BlockHash> blockHash();
+}

build.gradle

@@ -5,7 +5,7 @@ plugins {
 
 allprojects {
     group = 'com.strategyobject.substrateclient'
-    version = '0.0.4-SNAPSHOT'
+    version = '0.1.0-SNAPSHOT'
 
     repositories {
         mavenLocal()

common/src/main/java/com/strategyobject/substrateclient/common/codegen/ProcessorContext.java

@@ -26,9 +26,13 @@ public String getPackageName(@NonNull TypeElement classElement) {
         return elementUtils.getPackageOf(classElement).getQualifiedName().toString();
     }
 
-    public boolean isSubtypeOf(@NonNull TypeMirror candidate, @NonNull TypeMirror supertype) {
+    public boolean isAssignable(@NonNull TypeMirror candidate, @NonNull TypeMirror supertype) {
         return typeUtils.isAssignable(candidate, supertype);
     }
+
+    public boolean isSubtype(@NonNull TypeMirror candidate, @NonNull TypeMirror supertype) {
+        return typeUtils.isSubtype(candidate, supertype);
+    }
 
     public boolean isGeneric(@NonNull TypeMirror type) {
         return ((TypeElement) typeUtils.asElement(type))

common/src/main/java/com/strategyobject/substrateclient/common/codegen/TypeTraverser.java

@@ -101,6 +101,29 @@ public T traverse(@NonNull TypeMirror type, @NonNull TypeTraverser.TypeTreeNode
                         .toArray(x -> (T[]) Array.newInstance(clazz, typeArguments.size())));
     }
 
+    @SuppressWarnings({"unchecked"})
+    public T traverse(@NonNull TypeTraverser.TypeTreeNode typeOverride) {
+        if (typeOverride.type.getKind().isPrimitive()) {
+            return whenPrimitiveType((PrimitiveType) typeOverride.type, typeOverride.type);
+        }
+
+        if (!(typeOverride.type instanceof DeclaredType)) {
+            throw new IllegalArgumentException("Type is not supported: " + typeOverride.type);
+        }
+
+        val declaredType = (DeclaredType) typeOverride.type;
+        if (typeOverride.children.size() == 0) {
+            return whenNonGenericType(declaredType, typeOverride.type);
+        }
+
+        return whenGenericType(
+                declaredType,
+                typeOverride.type,
+                typeOverride.children.stream()
+                        .map(this::traverse)
+                        .toArray(x -> (T[]) Array.newInstance(clazz, typeOverride.children.size())));
+    }
+
     private List<? extends TypeMirror> getTypeArgumentsOrDefault(DeclaredType declaredType, TypeMirror override) {
         return (doTraverseArguments(declaredType, override) ?
                 declaredType.getTypeArguments() :
@@ -125,6 +148,7 @@ private boolean typeIsOverriddenByNonGeneric(int typeOverrideSize) {
 
 
     public static class TypeTreeNode {
+        @Getter
         private final TypeMirror type;
         private final List<TypeTreeNode> children;
 

pallet/build.gradle

@@ -0,0 +1,4 @@
+dependencies {
+    implementation project(':scale')
+    implementation project(':rpc')
+}

pallet/pallet-codegen/build.gradle

@@ -0,0 +1,16 @@
+dependencies {
+    implementation project(':common')
+    implementation project(':rpc')
+    implementation project(':types')
+    implementation project(':scale')
+    implementation project(':scale:scale-codegen')
+    implementation project(':storage')
+    implementation project(':pallet')
+
+    implementation 'com.squareup:javapoet:1.13.0'
+
+    compileOnly 'com.google.auto.service:auto-service-annotations:1.0.1'
+    annotationProcessor 'com.google.auto.service:auto-service:1.0.1'
+
+    testImplementation 'com.google.testing.compile:compile-testing:0.19'
+}