@dedot/cli 0.4.1 → 0.4.2-next.5d9d02c1.7

package/commands/{chaintypes.d.ts → chaintypes/index.d.ts}

@@ -5,6 +5,8 @@ type Args = {
     chain?: string;
     dts?: boolean;
     subpath?: boolean;
+    wasm?: string;
+    metadata?: string;
 };
 export declare const chaintypes: CommandModule<Args, Args>;
 export {};

package/commands/chaintypes/index.js

@@ -0,0 +1,118 @@
+import { generateTypes, generateTypesFromEndpoint } from '@dedot/codegen';
+import { stringCamelCase, stringPascalCase } from '@dedot/utils';
+import ora from 'ora';
+import * as path from 'path';
+import { parseMetadataFromRaw, parseMetadataFromWasm, parseStaticSubstrate } from './utils.js';
+export const chaintypes = {
+    command: 'chaintypes',
+    describe: 'Generate Types & APIs for Substrate-based chains',
+    handler: async (yargs) => {
+        const { wsUrl, wasm, metadata, output = '', chain = '', dts = true, subpath = true } = yargs;
+        const outDir = path.resolve(output);
+        const extension = dts ? 'd.ts' : 'ts';
+        const spinner = ora().start();
+        const shouldGenerateGenericTypes = wsUrl === 'substrate';
+        let generatedResult;
+        let parsedResult;
+        try {
+            if (metadata) {
+                spinner.text = `Parsing metadata file ${metadata}...`;
+                parsedResult = await parseMetadataFromRaw(metadata);
+                spinner.succeed(`Parsed metadata file ${metadata}`);
+            }
+            else if (wasm) {
+                spinner.text = `Parsing runtime wasm file ${wasm}`;
+                parsedResult = await parseMetadataFromWasm(wasm);
+                spinner.succeed(`Parsed runtime wasm file ${wasm}`);
+            }
+            else if (shouldGenerateGenericTypes) {
+                spinner.text = 'Parsing static substrate generic chaintypes...';
+                parsedResult = await parseStaticSubstrate();
+                spinner.succeed(`Parsed static substrate generic chaintypes`);
+            }
+            if (parsedResult) {
+                const { metadata, runtimeVersion, runtimeApis, rpcMethods } = parsedResult;
+                const chainName = chain || stringCamelCase(runtimeVersion.specName) || (shouldGenerateGenericTypes ? 'substrate' : 'local');
+                spinner.text = `Generating ${stringPascalCase(chainName)} generic chaintypes`;
+                generatedResult = await generateTypes(chainName, metadata.latest, rpcMethods, runtimeApis, outDir, extension, subpath);
+                spinner.succeed(`Generated ${stringPascalCase(chainName)} generic chaintypes`);
+            }
+            else {
+                spinner.text = `Generating chaintypes via endpoint: ${wsUrl}`;
+                generatedResult = await generateTypesFromEndpoint(chain, wsUrl, outDir, extension, subpath);
+                spinner.succeed(`Generated chaintypes via endpoint: ${wsUrl}`);
+            }
+            const { interfaceName, outputFolder } = generatedResult;
+            console.log(`  ➡ Output directory: file://${outputFolder}`);
+            console.log(`  ➡ ChainApi interface: ${interfaceName}`);
+            console.log('🌈 Done!');
+        }
+        catch (e) {
+            if (shouldGenerateGenericTypes) {
+                spinner.fail(`Failed to generate Substrate generic chaintypes`);
+            }
+            else if (wasm) {
+                spinner.fail(`Failed to generate chaintypes via runtime wasm file: ${wasm}`);
+            }
+            else if (metadata) {
+                spinner.fail(`Failed to generate chaintypes via metadata file: ${metadata}`);
+            }
+            else {
+                spinner.fail(`Failed to generate chaintypes via endpoint: ${wsUrl}`);
+            }
+            console.error(e);
+        }
+        spinner.stop();
+    },
+    builder: (yargs) => {
+        return yargs
+            .option('wsUrl', {
+            type: 'string',
+            describe: 'Websocket URL to fetch metadata',
+            alias: 'w',
+        })
+            .option('wasm', {
+            type: 'string',
+            describe: 'Runtime wasm file to fetch metadata (.wasm)',
+            alias: 'r',
+        })
+            .option('metadata', {
+            type: 'string',
+            describe: 'Raw encoded metadata file (.scale)',
+            alias: 'm',
+        })
+            .option('output', {
+            type: 'string',
+            describe: 'Output folder to put generated files',
+            alias: 'o',
+        })
+            .option('chain', {
+            type: 'string',
+            describe: 'Custom chain name',
+            alias: 'c',
+        })
+            .option('dts', {
+            type: 'boolean',
+            describe: 'Generate d.ts files',
+            alias: 'd',
+            default: true,
+        })
+            .option('subpath', {
+            type: 'boolean',
+            describe: 'Using subpath for shared packages (e.g: dedot/types)',
+            alias: 's',
+            default: true,
+        })
+            .check((argv) => {
+            const inputs = ['wsUrl', 'wasm', 'metadata'];
+            const providedInputs = inputs.filter((input) => argv[input]);
+            if (providedInputs.length > 1) {
+                throw new Error(`Please provide only one of the following options: ${inputs.join(', ')}`);
+            }
+            if (providedInputs.length === 0) {
+                throw new Error(`Please provide one of the following options: ${inputs.join(', ')}`);
+            }
+            return true;
+        });
+    },
+};

package/commands/chaintypes/types.d.ts

@@ -0,0 +1,9 @@
+import { Metadata, RuntimeVersion } from '@dedot/codecs';
+export interface ParsedResult extends DecodedMetadataInfo {
+    rpcMethods: string[];
+}
+export interface DecodedMetadataInfo {
+    metadata: Metadata;
+    runtimeVersion: RuntimeVersion;
+    runtimeApis: Record<string, number>;
+}

package/commands/chaintypes/types.js

@@ -0,0 +1 @@
+export {};

package/commands/chaintypes/utils.d.ts

@@ -0,0 +1,8 @@
+import { Metadata, RuntimeVersion } from '@dedot/codecs';
+import { HexString } from '@dedot/utils';
+import { DecodedMetadataInfo, ParsedResult } from './types.js';
+export declare const getRuntimeVersion: (metadata: Metadata) => RuntimeVersion;
+export declare const decodeMetadata: (metadataHex: HexString) => DecodedMetadataInfo;
+export declare const parseMetadataFromRaw: (metadataFile: string) => Promise<ParsedResult>;
+export declare const parseMetadataFromWasm: (runtimeFile: string) => Promise<ParsedResult>;
+export declare const parseStaticSubstrate: () => Promise<ParsedResult>;

package/commands/chaintypes/utils.js

@@ -0,0 +1,62 @@
+import { rpc } from '@polkadot/types-support/metadata/static-substrate';
+import staticSubstrate from '@polkadot/types-support/metadata/v15/substrate-hex';
+import { ConstantExecutor } from '@dedot/api';
+import { $Metadata, PortableRegistry } from '@dedot/codecs';
+import * as $ from '@dedot/shape';
+import { hexToU8a, u8aToHex } from '@dedot/utils';
+import { getMetadataFromRuntime } from '@polkadot-api/wasm-executor';
+import * as fs from 'fs';
+export const getRuntimeVersion = (metadata) => {
+    const registry = new PortableRegistry(metadata.latest);
+    const executor = new ConstantExecutor({
+        registry,
+        metadata,
+    });
+    return executor.execute('system', 'version');
+};
+export const decodeMetadata = (metadataHex) => {
+    const metadata = $Metadata.tryDecode(metadataHex);
+    const runtimeVersion = getRuntimeVersion(metadata);
+    const runtimeApis = runtimeVersion.apis.reduce((acc, [name, version]) => {
+        acc[name] = version;
+        return acc;
+    }, {});
+    return {
+        metadata,
+        runtimeVersion,
+        runtimeApis,
+    };
+};
+export const parseMetadataFromRaw = async (metadataFile) => {
+    const metadataHex = fs.readFileSync(metadataFile, 'utf-8').trim();
+    const { metadata, runtimeVersion, runtimeApis } = decodeMetadata(metadataHex);
+    return {
+        metadata,
+        runtimeVersion,
+        runtimeApis,
+        rpcMethods: [],
+    };
+};
+export const parseMetadataFromWasm = async (runtimeFile) => {
+    const u8aMetadata = hexToU8a(getMetadataFromRuntime(('0x' + fs.readFileSync(runtimeFile).toString('hex'))));
+    // Because this u8aMetadata has compactInt prefixed for it length, we need to get rid of it.
+    const length = $.compactU32.tryDecode(u8aMetadata);
+    const offset = $.compactU32.tryEncode(length).length;
+    const metadataHex = u8aToHex(u8aMetadata.subarray(offset));
+    const { metadata, runtimeVersion, runtimeApis } = decodeMetadata(metadataHex);
+    return {
+        metadata,
+        runtimeVersion,
+        runtimeApis,
+        rpcMethods: [],
+    };
+};
+export const parseStaticSubstrate = async () => {
+    const { runtimeVersion, metadata, runtimeApis } = decodeMetadata(staticSubstrate);
+    return {
+        metadata,
+        runtimeVersion,
+        runtimeApis,
+        rpcMethods: rpc.methods,
+    };
+};

package/commands/index.d.ts

@@ -1,2 +1,2 @@
-export * from './chaintypes.js';
+export * from './chaintypes/index.js';
 export * from './typink.js';

package/commands/index.js

@@ -1,2 +1,2 @@
-export * from './chaintypes.js';
+export * from './chaintypes/index.js';
 export * from './typink.js';

package/commands/typink.js

@@ -19,9 +19,9 @@ export const typink = {
             const contractMetadata = parseRawMetadata(fs.readFileSync(metadataFile, 'utf-8'));
             spinner.succeed(`Parsed contract metadata file: ${metadata}`);
             spinner.text = 'Generating contract Types & APIs';
-            const { interfaceName } = await generateContractTypes(contractMetadata, contract, outDir, extension, subpath);
+            const { interfaceName, outputFolder } = await generateContractTypes(contractMetadata, contract, outDir, extension, subpath);
             spinner.succeed('Generated contract Types & APIs');
-            console.log(`  ➡ Output directory: file://${outDir}`);
+            console.log(`  ➡ Output directory: file://${outputFolder}`);
             console.log(`  ➡ ContractApi interface: ${interfaceName}`);
             console.log('🌈 Done!');
             spinner.stop();

package/dedot.js

@@ -7,6 +7,7 @@ export const dedot = () => {
         .showHelpOnFail(true)
         .command(chaintypes)
         .command(typink)
+        .version(false)
         .help('help', 'Show help instructions')
         .alias('h', 'help')
         .alias('v', 'version')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/cli",
-  "version": "0.4.1",
+  "version": "0.4.2-next.5d9d02c1.7+5d9d02c",
   "author": "Thang X. Vu <thang@coongcrafts.io>",
   "homepage": "https://github.com/dedotdev/dedot/tree/main/packages/cli",
   "repository": {
@@ -21,22 +21,23 @@
     "start": "ts-node src/index.ts"
   },
   "dependencies": {
-    "@dedot/api": "0.4.1",
-    "@dedot/codecs": "0.4.1",
-    "@dedot/codegen": "0.4.1",
-    "@polkadot/types-support": "^12.2.3",
+    "@dedot/api": "0.4.2-next.5d9d02c1.7+5d9d02c",
+    "@dedot/codecs": "0.4.2-next.5d9d02c1.7+5d9d02c",
+    "@dedot/codegen": "0.4.2-next.5d9d02c1.7+5d9d02c",
+    "@polkadot-api/wasm-executor": "^0.1.1",
+    "@polkadot/types-support": "^12.3.1",
     "ora": "^8.0.1",
     "yargs": "^17.7.2"
   },
   "devDependencies": {
-    "@types/yargs": "^17.0.32"
+    "@types/yargs": "^17.0.33"
   },
   "publishConfig": {
     "access": "public",
     "directory": "dist"
   },
   "license": "Apache-2.0",
-  "gitHead": "05b2a88dd2c78b17d68f0dd211e50be79e79852e",
+  "gitHead": "5d9d02c17067074674ae588eb266a46f36742cb4",
   "module": "./index.js",
   "types": "./index.d.ts"
 }

package/commands/chaintypes.js

@@ -1,91 +0,0 @@
-import { rpc } from '@polkadot/types-support/metadata/static-substrate';
-import staticSubstrate from '@polkadot/types-support/metadata/v15/substrate-hex';
-import { ConstantExecutor } from '@dedot/api';
-import { $Metadata, PortableRegistry } from '@dedot/codecs';
-import { generateTypes, generateTypesFromEndpoint } from '@dedot/codegen';
-import ora from 'ora';
-import * as path from 'path';
-export const chaintypes = {
-    command: 'chaintypes',
-    describe: 'Generate Types & APIs for Substrate-based chains',
-    handler: async (yargs) => {
-        const { wsUrl, output = '', chain = '', dts = true, subpath = true } = yargs;
-        const outDir = path.resolve(output);
-        const extension = dts ? 'd.ts' : 'ts';
-        const spinner = ora().start();
-        const shouldGenerateGenericTypes = wsUrl === 'substrate';
-        try {
-            let generatedResult;
-            if (shouldGenerateGenericTypes) {
-                spinner.text = 'Generating Substrate generic chaintypes';
-                const metadataHex = staticSubstrate;
-                const rpcMethods = rpc.methods;
-                const metadata = $Metadata.tryDecode(metadataHex);
-                const runtimeVersion = getRuntimeVersion(metadata);
-                const runtimeApis = runtimeVersion.apis.reduce((acc, [name, version]) => {
-                    acc[name] = version;
-                    return acc;
-                }, {});
-                generatedResult = await generateTypes(chain || 'substrate', metadata.latest, rpcMethods, runtimeApis, outDir, extension, subpath);
-                spinner.succeed('Generated Substrate generic chaintypes');
-            }
-            else {
-                spinner.text = `Generating chaintypes via endpoint: ${wsUrl}`;
-                generatedResult = await generateTypesFromEndpoint(chain, wsUrl, outDir, extension, subpath);
-                spinner.succeed(`Generated chaintypes via endpoint: ${wsUrl}`);
-            }
-            console.log(`  ➡ Output directory: file://${outDir}`);
-            console.log(`  ➡ ChainApi interface: ${generatedResult.interfaceName}`);
-            console.log('🌈 Done!');
-        }
-        catch (e) {
-            if (shouldGenerateGenericTypes) {
-                spinner.fail(`Failed to generate Substrate generic chaintypes`);
-            }
-            else {
-                spinner.fail(`Failed to generate chaintypes via endpoint: ${wsUrl}`);
-            }
-            console.error(e);
-        }
-        spinner.stop();
-    },
-    builder: (yargs) => {
-        return yargs
-            .option('wsUrl', {
-            type: 'string',
-            describe: 'Websocket URL to fetch metadata',
-            alias: 'w',
-            default: 'ws://127.0.0.1:9944',
-        })
-            .option('output', {
-            type: 'string',
-            describe: 'Output folder to put generated files',
-            alias: 'o',
-        })
-            .option('chain', {
-            type: 'string',
-            describe: 'Custom chain name',
-            alias: 'c',
-        })
-            .option('dts', {
-            type: 'boolean',
-            describe: 'Generate d.ts files',
-            alias: 'd',
-            default: true,
-        })
-            .option('subpath', {
-            type: 'boolean',
-            describe: 'Using subpath for shared packages (e.g: dedot/types)',
-            alias: 's',
-            default: true,
-        }); // TODO check to verify inputs
-    },
-};
-const getRuntimeVersion = (metadata) => {
-    const registry = new PortableRegistry(metadata.latest);
-    const executor = new ConstantExecutor({
-        registry,
-        metadata,
-    });
-    return executor.execute('system', 'version');
-};