@dedot/codegen 0.0.1-next.020a0293.9 → 0.0.1-next.16e37feb.8

package/generator/known-codecs.js

@@ -0,0 +1,120 @@
+import * as $ from '@dedot/shape';
+import * as Codecs from '@dedot/codecs';
+import { $AccountId20, $AccountId32, $Bytes, $ConsensusEngineId, $Era, $EthereumAddress, $MultiAddress, $OpaqueExtrinsic, $PrefixedStorageKey, $RawBytes, $StorageData, $StorageKey, $UncheckedExtrinsic, } from '@dedot/codecs';
+import { assert } from '@dedot/utils';
+export const normalizeCodecName = (name) => {
+    return name.startsWith('$') ? name : `$${name}`;
+};
+// Known paths for codecs (primitives) that are shared between
+// different substrate-based blockchains
+const KNOWN_PATHS = [
+    'sp_core::crypto::AccountId32',
+    'sp_runtime::generic::era::Era',
+    'sp_runtime::multiaddress::MultiAddress',
+    /^sp_runtime::DispatchError$/,
+    'sp_runtime::ModuleError',
+    'sp_runtime::TokenError',
+    'sp_arithmetic::ArithmeticError',
+    'sp_runtime::TransactionalError',
+    'frame_support::dispatch::DispatchInfo',
+    'frame_system::Phase',
+    'sp_version::RuntimeVersion',
+    'fp_account::AccountId20',
+    'account::AccountId20',
+    'polkadot_runtime_common::claims::EthereumAddress',
+    'pallet_identity::types::Data',
+    'sp_runtime::generic::digest::Digest',
+    'sp_runtime::generic::digest::DigestItem',
+    'sp_runtime::generic::header::Header',
+    'sp_runtime::generic::unchecked_extrinsic::UncheckedExtrinsic',
+    /^primitive_types::\w+$/,
+    /^sp_arithmetic::per_things::\w+$/,
+    /^sp_arithmetic::fixed_point::\w+$/,
+];
+const WRAPPER_TYPE_REGEX = /^(\w+)<(.*)>$/;
+const TUPLE_TYPE_REGEX = /^\[(.*)]$/;
+const KNOWN_WRAPPER_TYPES = ['Option', 'Vec', 'Result', 'Array'];
+/**
+ * Collection of codec types with loose input types
+ *
+ * Loose codecs are codecs with different typeIn & typeOut,
+ * E.g: Codec `$AccountId32`, we have its typeIn is `AccountId32Like` & typeOut is `AccountId32`
+ *
+ * This registry keep track the list of codecs which follow this convention
+ */
+export const looseTypeCodecs = {
+    $AccountId20,
+    $EthereumAddress,
+    $AccountId32,
+    $ConsensusEngineId,
+    $StorageKey,
+    $StorageData,
+    $PrefixedStorageKey,
+    $Bytes,
+    $RawBytes,
+    $MultiAddress,
+    $OpaqueExtrinsic,
+    $UncheckedExtrinsic,
+    $Era,
+};
+export function findKnownCodecType(name) {
+    const normalizedName = normalizeCodecName(name);
+    const $knownCodec = looseTypeCodecs[normalizedName];
+    if ($knownCodec) {
+        return {
+            name: normalizedName,
+            $codec: $knownCodec,
+            typeIn: `${name}Like`,
+            typeOut: name,
+        };
+    }
+    const $codec = findKnownCodec(name);
+    if ($codec.nativeType && $[name]) {
+        return {
+            name: normalizedName,
+            $codec,
+            typeIn: $codec.nativeType,
+            typeOut: $codec.nativeType,
+        };
+    }
+    return {
+        name: normalizedName,
+        $codec,
+        typeIn: name,
+        typeOut: name,
+    };
+}
+export function findKnownCodec(typeName) {
+    // @ts-ignore
+    const $codec = findKnownWrapperCodec(typeName) || Codecs[normalizeCodecName(typeName)] || $[typeName];
+    assert($codec, `Known codec not found - ${typeName}`);
+    return $codec;
+}
+export function findKnownWrapperCodec(typeName) {
+    const matchNames = typeName.match(WRAPPER_TYPE_REGEX);
+    if (matchNames) {
+        const [_, wrapper, inner] = matchNames;
+        if (KNOWN_WRAPPER_TYPES.includes(wrapper)) {
+            // @ts-ignore
+            const $Wrapper = $[wrapper];
+            if (inner.match(TUPLE_TYPE_REGEX) || inner.match(WRAPPER_TYPE_REGEX)) {
+                return $Wrapper(findKnownWrapperCodec(inner));
+            }
+            const $inners = inner.split(',').map((one) => findKnownCodec(one.trim()));
+            return $Wrapper(...$inners);
+        }
+        throw new Error(`Unknown wrapper type ${wrapper} from ${typeName}`);
+    }
+    else if (typeName.match(TUPLE_TYPE_REGEX)) {
+        const $inner = typeName
+            .slice(1, -1)
+            .split(',')
+            .filter((x) => x)
+            .map((one) => findKnownCodec(one.trim()));
+        return $.Tuple(...$inner);
+    }
+}
+export function isKnownCodecType(path) {
+    const joinedPath = Array.isArray(path) ? path.join('::') : path;
+    return KNOWN_PATHS.some((one) => joinedPath.match(one));
+}

package/generator/known-types.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Known type names registered in @dedot/types
+ * Since TS interfaces are trim-off when compiling,
+ * So we need to register them explicitly here for RPC codegen process
+ */
+export declare const knownTypes: string[];

package/generator/known-types.js

@@ -0,0 +1,30 @@
+/**
+ * Known type names registered in @dedot/types
+ * Since TS interfaces are trim-off when compiling,
+ * So we need to register them explicitly here for RPC codegen process
+ */
+export const knownTypes = [
+    'ExtrinsicOrHash',
+    'EpochAuthorship',
+    'BlockStats',
+    'Prevotes',
+    'Precommits',
+    'RoundState',
+    'ReportedRoundStates',
+    'JustificationNotification',
+    'EncodedFinalityProofs',
+    'LeavesProof',
+    'StorageKind',
+    'RpcMethods',
+    'ReadProof',
+    'StorageChangeSet',
+    'TraceBlockResponse',
+    'MigrationStatusResult',
+    'ChainType',
+    'ChainProperties',
+    'Health',
+    'SyncState',
+    'PeerInfo',
+    'NodeRole',
+    'NetworkState',
+];

package/index.d.ts

@@ -1,4 +1,4 @@
 import { MetadataLatest } from '@dedot/codecs';
-import { NetworkInfo } from './types';
+import { NetworkInfo } from './types.js';
 export declare function generateTypesFromChain(network: NetworkInfo, endpoint: string, outDir: string): Promise<void>;
 export declare function generateTypes(network: NetworkInfo, metadata: MetadataLatest, rpcMethods: string[], runtimeApis: any[], outDir?: string): Promise<void>;

package/index.js

@@ -1,7 +1,7 @@
 import { Dedot } from 'dedot';
 import * as fs from 'fs';
 import * as path from 'path';
-import { ConstsGen, ErrorsGen, EventsGen, IndexGen, QueryGen, RpcGen, RuntimeApisGen, TxGen, TypesGen, } from './generator';
+import { ConstsGen, ErrorsGen, EventsGen, IndexGen, QueryGen, RpcGen, RuntimeApisGen, TxGen, TypesGen, } from './generator/index.js';
 import { stringCamelCase } from '@polkadot/util';
 export async function generateTypesFromChain(network, endpoint, outDir) {
     const api = await Dedot.create(endpoint);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/codegen",
-  "version": "0.0.1-next.020a0293.9+020a029",
+  "version": "0.0.1-next.16e37feb.8+16e37fe",
   "description": "Generate types",
   "author": "Thang X. Vu <thang@coongcrafts.io>",
   "homepage": "https://github.com/dedotdev/dedot/tree/main/packages/codegen",
@@ -18,12 +18,12 @@
     "copy": "cp -R ./src/templates ./dist && cp -R ./src/templates ./dist/cjs"
   },
   "dependencies": {
-    "@dedot/codecs": "0.0.1-next.020a0293.9+020a029",
-    "@dedot/shape": "0.0.1-next.020a0293.9+020a029",
-    "@dedot/specs": "0.0.1-next.020a0293.9+020a029",
-    "@dedot/utils": "0.0.1-next.020a0293.9+020a029",
+    "@dedot/codecs": "0.0.1-next.16e37feb.8+16e37fe",
+    "@dedot/shape": "0.0.1-next.16e37feb.8+16e37fe",
+    "@dedot/specs": "0.0.1-next.16e37feb.8+16e37fe",
+    "@dedot/utils": "0.0.1-next.16e37feb.8+16e37fe",
     "@polkadot/util": "^12.6.2",
-    "dedot": "0.0.1-next.020a0293.9+020a029",
+    "dedot": "0.0.1-next.16e37feb.8+16e37fe",
     "handlebars": "^4.7.8",
     "prettier": "^3.0.3"
   },
@@ -32,7 +32,7 @@
     "directory": "dist"
   },
   "license": "Apache-2.0",
-  "gitHead": "020a029329c3dec2201144962454658c443953ca",
+  "gitHead": "16e37feb35200c80b3ffcba5791154050da36443",
   "module": "./index.js",
   "types": "./index.d.ts",
   "exports": {

package/packageInfo.js

@@ -1,2 +1,2 @@
 // THIS FILE IS AUTO-GENERATED, DO NOT EDIT!
-export const packageInfo = { name: '@dedot/codegen', version: '0.0.1-alpha.26' };
+export const packageInfo = { name: '@dedot/codegen', version: '0.0.1-alpha.28' };