Merge pull request #28 from strategyobject/release/v0.2.0

Release/v0.2.0

Author: kalaninja

.github/workflows/gradle-build.yml

@@ -9,18 +9,18 @@ on:
 jobs:
   build:
 
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     permissions:
       contents: read
       packages: write
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Set up JDK 8
-        uses: actions/setup-java@v2
+        uses: actions/setup-java@v3
         with:
           java-version: '8'
-          distribution: 'adopt'
+          distribution: 'temurin'
 
       - name: Build with Gradle
         run: gradle build

.github/workflows/gradle-publish.yml

@@ -10,18 +10,18 @@ on:
 jobs:
   publish:
 
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     permissions:
       contents: read
       packages: write
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Set up JDK 8
-        uses: actions/setup-java@v2
+        uses: actions/setup-java@v3
         with:
           java-version: '8'
-          distribution: 'adopt'
+          distribution: 'temurin'
 
       - name: Build with Gradle
         run: gradle build

api/build.gradle

@@ -1,19 +1,24 @@
 dependencies {
     implementation project(':common')
+    implementation project(':crypto')
     implementation project(':pallet')
     implementation project(':rpc')
-    implementation project(':rpc:rpc-core')
-    implementation project(':rpc:rpc-sections')
-    implementation project(':rpc:rpc-types')
+    implementation project(':rpc:rpc-api')
     implementation project(':scale')
-    implementation project(':storage')
     implementation project(':transport')
-    implementation project(':types')
+
+    api 'com.google.inject:guice:5.1.0'
+
+    annotationProcessor project(':pallet:pallet-codegen')
+    annotationProcessor project(':rpc:rpc-codegen')
 
     testImplementation project(':tests')
 
-    testImplementation 'org.testcontainers:testcontainers:1.17.1'
-    testImplementation 'org.testcontainers:junit-jupiter:1.17.1'
+    testImplementation 'ch.qos.logback:logback-classic:1.2.11'
+    testImplementation 'org.testcontainers:testcontainers:1.17.3'
+    testImplementation 'org.testcontainers:junit-jupiter:1.17.3'
+    testImplementation 'org.awaitility:awaitility:4.2.0'
+    testImplementation 'org.hamcrest:hamcrest:2.2'
 
     testAnnotationProcessor project(':pallet:pallet-codegen')
-}
+}

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

@@ -1,33 +1,73 @@
 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.google.inject.Module;
+import com.strategyobject.substrateclient.pallet.PalletFactory;
+import com.strategyobject.substrateclient.rpc.RpcSectionFactory;
+import com.strategyobject.substrateclient.rpc.metadata.MetadataProvider;
 import com.strategyobject.substrateclient.transport.ProviderInterface;
-import lombok.val;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Supplier;
 
 /**
  * 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);
+@RequiredArgsConstructor
+public class Api implements AutoCloseable {
+    private final @NonNull RpcSectionFactory rpcSectionFactory;
+    private final @NonNull PalletFactory palletFactory;
+    private final @NonNull MetadataProvider metadataProvider;
+    private final Map<Class<?>, Object> resolvedCache = new ConcurrentHashMap<>();
 
-        return DefaultApi.with(rpc, GeneratedPalletResolver.with(rpc));
-    }
 
     /**
-     * @return the instance that provides a proper API for querying the RPC's methods.
+     * Resolves the instance of a rpc by its definition.
+     *
+     * @param clazz the class of the rpc
+     * @param <T>   the type of the rpc
+     * @return appropriate instance of the rpc
      */
-    Rpc rpc();
+    public <T> T rpc(@NonNull Class<T> clazz) {
+        return clazz.cast(resolvedCache.computeIfAbsent(clazz, rpcSectionFactory::create));
+    }
 
     /**
      * Resolves the instance of a pallet by its definition.
+     *
      * @param clazz the class of the pallet
-     * @param <T> the type of the pallet
+     * @param <T>   the type of the pallet
      * @return appropriate instance of the pallet
      */
-    <T> T pallet(Class<T> clazz);
-}
+    public <T> T pallet(@NonNull Class<T> clazz) {
+        return clazz.cast(resolvedCache.computeIfAbsent(clazz, palletFactory::create));
+    }
+
+    /**
+     * Provides access to current version of metadata in use.
+     *
+     * @return MetadataProvider instance
+     */
+    public MetadataProvider metadata() {
+        return metadataProvider;
+    }
+
+    @Override
+    public void close() throws Exception {
+        if (rpcSectionFactory instanceof AutoCloseable) {
+            ((AutoCloseable) rpcSectionFactory).close();
+        }
+    }
+
+    public static ApiBuilder<DefaultModule> with(@NonNull Supplier<ProviderInterface> providerInterface) {
+        return with(new DefaultModule(providerInterface.get()));
+    }
+
+    public static <M extends Module> ApiBuilder<M> with(@NonNull M module) {
+        return new ApiBuilder<>(module);
+    }
+}

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

@@ -0,0 +1,36 @@
+package com.strategyobject.substrateclient.api;
+
+import com.google.inject.Guice;
+import com.google.inject.Module;
+import com.strategyobject.substrateclient.transport.ProviderInterface;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import lombok.val;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+@RequiredArgsConstructor
+public class ApiBuilder<M extends Module> {
+    private final @NonNull M module;
+
+    public ApiBuilder<M> configure(@NonNull Consumer<M> configuration) {
+        configuration.accept(module);
+        return this;
+    }
+
+    public <N extends Module> ApiBuilder<N> reconfigure(@NonNull Function<M, N> configuration) {
+        return new ApiBuilder<>(configuration.apply(this.module));
+    }
+
+    public CompletableFuture<Api> build() {
+        val injector = Guice.createInjector(new RequireModule(), module);
+        val provider = injector.getInstance(ProviderInterface.class);
+        val result = provider.isConnected() ?
+                CompletableFuture.<Void>completedFuture(null) :
+                provider.connect();
+
+        return result.thenApply(ignored -> injector.getInstance(Api.class));
+    }
+}