add metadata fetching

packages/api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sora-substrate/api",
-  "version": "1.27.2",
+  "version": "1.27.2-beta.1",
   "license": "Apache-2.0",
   "main": "./build/index.js",
   "typings": "./build/index.d.ts",
@@ -10,6 +10,6 @@
   "dependencies": {
     "@open-web3/orml-api-derive": "1.1.4",
     "@polkadot/api": "9.14.2",
-    "@sora-substrate/types": "1.27.2"
+    "@sora-substrate/types": "1.27.2-beta.1"
   }
 }

packages/connection/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@sora-substrate/connection",
-  "version": "1.27.2",
+  "version": "1.27.2-beta.1",
   "license": "Apache-2.0",
   "main": "./build/index.js",
   "typings": "./build/index.d.ts",
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@sora-substrate/api": "1.27.2"
+    "@sora-substrate/api": "1.27.2-beta.1",
+    "axios": "^0.21.1"
   }
 }

packages/connection/src/connection.ts

@@ -0,0 +1,186 @@
+import { ApiPromise } from '@polkadot/api';
+import { WsProvider } from '@polkadot/rpc-provider';
+import { options } from '@sora-substrate/api';
+
+import { fetchRpc, getRpcEndpoint } from './http';
+
+import type { ApiInterfaceEvents, ApiOptions } from '@polkadot/api/types';
+import type { ProviderInterfaceEmitCb } from '@polkadot/rpc-provider/types';
+import type { HexString } from '@polkadot/util/types';
+
+type ConnectionEventListener = [ApiInterfaceEvents, ProviderInterfaceEmitCb];
+
+export interface ConnectionRunOptions {
+  once?: boolean;
+  timeout?: number;
+  autoConnectMs?: number;
+  eventListeners?: ConnectionEventListener[];
+  getMetadata?: (genesisHash: string, specVersion: number) => Promise<string | null>;
+  setMetadata?: (genesisHash: string, specVersion: number, metadata: string) => Promise<void>;
+}
+
+const disconnectApi = async (api: ApiPromise, eventListeners: ConnectionEventListener[]): Promise<void> => {
+  if (!api) return;
+
+  eventListeners.forEach(([eventName, eventHandler]) => api.off(eventName, eventHandler));
+
+  // close the connection manually
+  if (api.isConnected) {
+    try {
+      await api.disconnect();
+    } catch (error) {
+      console.error(error);
+    }
+  }
+};
+
+const createConnectionTimeout = (timeout: number): Promise<void> => {
+  return new Promise((_resolve, reject) => {
+    setTimeout(() => reject(new Error('Connection Timeout')), timeout);
+  });
+};
+
+export class Connection {
+  public api: ApiPromise | null = null;
+  public endpoint = '';
+  public loading = false;
+
+  private eventListeners: Array<[ApiInterfaceEvents, ProviderInterfaceEmitCb]> = [];
+
+  constructor(private readonly apiOptions: ApiOptions) {}
+
+  private async withLoading<T>(func: () => Promise<T>): Promise<T> {
+    this.loading = true;
+    try {
+      return await func();
+    } finally {
+      this.loading = false;
+    }
+  }
+
+  private async run(endpoint: string, runOptions?: ConnectionRunOptions): Promise<void> {
+    const {
+      once = false,
+      timeout = 0,
+      autoConnectMs = 5000,
+      eventListeners = [],
+      getMetadata,
+      setMetadata,
+    } = runOptions || {};
+
+    const providerAutoConnectMs = once ? false : autoConnectMs;
+    const apiConnectionPromise = once ? 'isReadyOrError' : 'isReady';
+
+    let metadata!: Record<string, HexString>;
+
+    if (getMetadata || setMetadata) {
+      const metadataKeys = await this.fetchMetadataKeys(endpoint);
+
+      if (metadataKeys) {
+        const { genesisHash, specVersion } = metadataKeys;
+        const metadataHex = (await getMetadata?.(genesisHash, specVersion)) ?? (await this.fetchMetadataHex(endpoint));
+
+        if (metadataHex) {
+          const key = this.generateMetadataKey(genesisHash, specVersion);
+          metadata = { [key]: metadataHex as HexString };
+          setMetadata?.(genesisHash, specVersion, metadataHex);
+        }
+      }
+    }
+
+    const provider = new WsProvider(endpoint, providerAutoConnectMs);
+
+    this.api = new ApiPromise({ ...this.apiOptions, provider, noInitWarn: true, metadata });
+    this.endpoint = endpoint;
+
+    const connectionRequests: Array<Promise<any>> = [this.api[apiConnectionPromise]];
+
+    if (timeout) connectionRequests.push(createConnectionTimeout(timeout));
+
+    try {
+      eventListeners.forEach(([eventName, eventHandler]) => {
+        this.addEventListener(eventName, eventHandler);
+      });
+
+      // we should manually call connect fn without autoConnectMs
+      if (!providerAutoConnectMs) {
+        this.api.connect();
+      }
+
+      await Promise.race(connectionRequests);
+    } catch (error) {
+      this.stop();
+      throw error;
+    }
+  }
+
+  private async stop(): Promise<void> {
+    await disconnectApi(this.api!, this.eventListeners);
+    this.api = null;
+    this.endpoint = '';
+    this.eventListeners = [];
+  }
+
+  public addEventListener(eventName: ApiInterfaceEvents, eventHandler: ProviderInterfaceEmitCb) {
+    this.api!.on(eventName, eventHandler);
+    this.eventListeners.push([eventName, eventHandler]);
+  }
+
+  public get opened(): boolean {
+    return !!this.api;
+  }
+
+  /**
+   * Open connection
+   * @param endpoint address of node
+   * @param options
+   */
+  public async open(endpoint?: string, options?: ConnectionRunOptions): Promise<void> {
+    if (!(endpoint || this.endpoint)) throw new Error('You should set endpoint for connection');
+    await this.withLoading(async () => await this.run(endpoint || this.endpoint, options));
+  }
+
+  /**
+   * Close connection
+   */
+  public async close(): Promise<void> {
+    await this.withLoading(async () => await this.stop());
+  }
+
+  // https://github.com/polkadot-js/api/blob/master/packages/api/src/base/Init.ts#L344
+  public generateMetadataKey(genesisHash: string, specVersion: string | number) {
+    return `${genesisHash}-${String(specVersion)}`;
+  }
+
+  public async fetchMetadataKeys(wsEndpoint: string): Promise<{ genesisHash: string; specVersion: number } | null> {
+    try {
+      const rpcEndpoint = getRpcEndpoint(wsEndpoint);
+
+      const [genesisHash, runtimeVersion] = await Promise.all([
+        fetchRpc(rpcEndpoint, 'chain_getBlockHash', [0]),
+        fetchRpc(rpcEndpoint, 'state_getRuntimeVersion', []),
+      ]);
+      const { specVersion } = runtimeVersion;
+
+      return { genesisHash, specVersion: Number(specVersion) };
+    } catch {
+      return null;
+    }
+  }
+
+  public async fetchMetadataHex(wsEndpoint: string): Promise<HexString | null> {
+    try {
+      const rpcEndpoint = getRpcEndpoint(wsEndpoint);
+      const metadataHex = await fetchRpc(rpcEndpoint, 'state_getMetadata', []);
+
+      return metadataHex;
+    } catch {
+      return null;
+    }
+  }
+}
+
+/**
+ * Base SORA connection object
+ */
+export const connection = new Connection(options());

packages/connection/src/http.ts

@@ -0,0 +1,29 @@
+import axios from 'axios';
+
+const throwError = (fnName: string, arg: string) => {
+  throw new Error(`${fnName}: argument ${arg} is required`);
+};
+
+export const axiosInstance = axios.create();
+
+export function getRpcEndpoint(wsEndpoint: string): string {
+  // for soramitsu nodes
+  if (/^wss:\/\/ws\.(?:.+\.)*sora2\.soramitsu\.co\.jp\/?$/.test(wsEndpoint)) {
+    return wsEndpoint.replace(/^wss:\/\/ws/, 'https://rpc');
+  }
+  return wsEndpoint.replace(/^ws(s)?:/, 'http$1:');
+}
+
+export async function fetchRpc(url: string, method: string, params?: any): Promise<any> {
+  if (!url) return throwError(fetchRpc.name, 'url');
+  if (!method) return throwError(fetchRpc.name, 'method');
+
+  const { data } = await axiosInstance.post(url, {
+    id: 1,
+    jsonrpc: '2.0',
+    method,
+    params,
+  });
+
+  return data.result;
+}

packages/connection/src/index.ts

@@ -1,128 +1,2 @@
-import { ApiPromise } from '@polkadot/api';
-import { WsProvider } from '@polkadot/rpc-provider';
-import { options } from '@sora-substrate/api';
-import type { ApiInterfaceEvents, ApiOptions } from '@polkadot/api/types';
-import type { ProviderInterfaceEmitCb } from '@polkadot/rpc-provider/types';
-
-type ConnectionEventListener = [ApiInterfaceEvents, ProviderInterfaceEmitCb];
-
-export interface ConnectionRunOptions {
-  once?: boolean;
-  timeout?: number;
-  autoConnectMs?: number;
-  eventListeners?: ConnectionEventListener[];
-}
-
-const disconnectApi = async (api: ApiPromise, eventListeners: ConnectionEventListener[]): Promise<void> => {
-  if (!api) return;
-
-  eventListeners.forEach(([eventName, eventHandler]) => api.off(eventName, eventHandler));
-
-  // close the connection manually
-  if (api.isConnected) {
-    try {
-      await api.disconnect();
-    } catch (error) {
-      console.error(error);
-    }
-  }
-};
-
-const createConnectionTimeout = (timeout: number): Promise<void> => {
-  return new Promise((_, reject) => {
-    setTimeout(() => reject('Connection Timeout'), timeout);
-  });
-};
-
-class Connection {
-  public api: ApiPromise | null = null;
-  public endpoint = '';
-  public loading = false;
-
-  private eventListeners: Array<[ApiInterfaceEvents, ProviderInterfaceEmitCb]> = [];
-
-  constructor(private readonly apiOptions: ApiOptions) {}
-
-  private async withLoading(func: Function): Promise<any> {
-    this.loading = true;
-    try {
-      return await func();
-    } catch (e) {
-      throw e;
-    } finally {
-      this.loading = false;
-    }
-  }
-
-  private async run(endpoint: string, runOptions?: ConnectionRunOptions): Promise<void> {
-    const { once = false, timeout = 0, autoConnectMs = 5000, eventListeners = [] } = runOptions || {};
-
-    const providerAutoConnectMs = once ? false : autoConnectMs;
-    const apiConnectionPromise = once ? 'isReadyOrError' : 'isReady';
-
-    const provider = new WsProvider(endpoint, providerAutoConnectMs);
-
-    this.api = new ApiPromise({ ...this.apiOptions, provider, noInitWarn: true });
-    this.endpoint = endpoint;
-
-    const connectionRequests: Array<Promise<any>> = [this.api[apiConnectionPromise]];
-
-    if (timeout) connectionRequests.push(createConnectionTimeout(timeout));
-
-    try {
-      eventListeners.forEach(([eventName, eventHandler]) => {
-        this.addEventListener(eventName, eventHandler);
-      });
-
-      // we should manually call connect fn without autoConnectMs
-      if (!providerAutoConnectMs) {
-        this.api.connect();
-      }
-
-      await Promise.race(connectionRequests);
-    } catch (error) {
-      this.stop();
-      throw error;
-    }
-  }
-
-  private async stop(): Promise<void> {
-    await disconnectApi(this.api, this.eventListeners);
-    this.api = null;
-    this.endpoint = '';
-    this.eventListeners = [];
-  }
-
-  public addEventListener(eventName: ApiInterfaceEvents, eventHandler: ProviderInterfaceEmitCb) {
-    this.api.on(eventName, eventHandler);
-    this.eventListeners.push([eventName, eventHandler]);
-  }
-
-  public get opened(): boolean {
-    return !!this.api;
-  }
-
-  /**
-   * Open connection
-   * @param endpoint address of node
-   * @param options
-   */
-  public async open(endpoint?: string, options?: ConnectionRunOptions): Promise<void> {
-    if (!(endpoint || this.endpoint)) throw new Error('You should set endpoint for connection');
-    await this.withLoading(async () => await this.run(endpoint || this.endpoint, options));
-  }
-
-  /**
-   * Close connection
-   */
-  public async close(): Promise<void> {
-    await this.withLoading(async () => await this.stop());
-  }
-}
-
-/**
- * Base SORA connection object
- */
-const connection = new Connection(options());
-
-export { connection, Connection };
+export { connection, Connection } from './connection';
+export { axiosInstance, getRpcEndpoint, fetchRpc } from './http';

packages/liquidity-proxy/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@sora-substrate/liquidity-proxy",
-  "version": "1.27.2",
+  "version": "1.27.2-beta.1",
   "license": "Apache-2.0",
   "main": "./build/index.js",
   "typings": "./build/index.d.ts",
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@sora-substrate/math": "1.27.2"
+    "@sora-substrate/math": "1.27.2-beta.1"
   }
 }