@dedot/codegen 0.0.1-alpha.11

package/cjs/templates/rpc.hbs

@@ -0,0 +1,7 @@
+// Generated by @dedot/codegen
+
+{{{ importTypes }}}
+
+export interface RpcCalls extends GenericRpcCalls {
+  {{{rpcCallsOut}}}
+}

package/cjs/templates/runtime.hbs

@@ -0,0 +1,8 @@
+// Generated by @dedot/codegen
+
+{{{ importTypes }}}
+
+export interface RuntimeApis extends GenericRuntimeApis {
+{{{ runtimeCallsOut }}}
+}
+

package/cjs/templates/tx.hbs

@@ -0,0 +1,9 @@
+// Generated by @dedot/codegen
+
+{{{ importTypes }}}
+
+{{{ defTypes }}}
+
+export interface ChainTx extends GenericChainTx<TxCall> {
+  {{{ txDefsOut }}}
+}

package/cjs/templates/types.hbs

@@ -0,0 +1,5 @@
+// Generated by @dedot/codegen
+
+{{{ importTypes }}}
+
+{{{ defTypeOut }}}

package/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/genSupportedChainTypes.d.ts

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

package/genSupportedChainTypes.js

@@ -0,0 +1,74 @@
+import { generateTypes, generateTypesFromChain } from './index';
+import { rpc } from '@polkadot/types-support/metadata/static-substrate';
+import staticSubstrate from '@polkadot/types-support/metadata/v15/substrate-hex';
+import { $Metadata, CodecRegistry } from '@dedot/codecs';
+import { ConstantExecutor } from 'dedot';
+const NETWORKS = [
+    {
+        chain: 'substrate',
+        metadataHex: staticSubstrate,
+        rpcMethods: rpc.methods,
+    },
+    {
+        chain: 'polkadot',
+        endpoint: 'wss://rpc.polkadot.io',
+    },
+    {
+        chain: 'kusama',
+        endpoint: 'wss://kusama-rpc.polkadot.io',
+    },
+    {
+        chain: 'astar',
+        endpoint: 'wss://rpc.astar.network',
+    },
+    {
+        chain: 'moonbeam',
+        endpoint: 'wss://moonbeam.api.onfinality.io/public-ws',
+    },
+    {
+        chain: 'polkadotAssetHub',
+        endpoint: 'wss://polkadot-asset-hub-rpc.polkadot.io/',
+    },
+    {
+        chain: 'kusamaAssetHub',
+        endpoint: 'wss://kusama-asset-hub-rpc.polkadot.io/',
+    },
+    {
+        chain: 'rococoAssetHub',
+        endpoint: 'wss://rococo-asset-hub-rpc.polkadot.io/',
+    },
+    {
+        chain: 'aleph',
+        endpoint: 'wss://aleph-zero.api.onfinality.io/public-ws',
+    },
+    {
+        chain: 'westendAssetHub',
+        endpoint: 'wss://westend-asset-hub-rpc.polkadot.io',
+    },
+];
+const OUT_DIR = 'packages/chaintypes/src';
+async function run() {
+    for (const network of NETWORKS) {
+        const { chain, endpoint, metadataHex, rpcMethods } = network;
+        if (endpoint) {
+            console.log(`Generate types for ${chain} via endpoint ${endpoint}`);
+            await generateTypesFromChain(network, endpoint, OUT_DIR);
+        }
+        else if (metadataHex && rpcMethods) {
+            console.log(`Generate types for ${chain} via raw data`);
+            const metadata = $Metadata.tryDecode(metadataHex);
+            const runtimeVersion = getRuntimeVersion(metadata);
+            await generateTypes(network, metadata.latest, rpcMethods, runtimeVersion.apis, OUT_DIR);
+        }
+    }
+    console.log('DONE!');
+}
+const getRuntimeVersion = (metadata) => {
+    const registry = new CodecRegistry(metadata.latest);
+    const executor = new ConstantExecutor({
+        registry,
+        metadataLatest: metadata.latest,
+    });
+    return executor.execute('system', 'version');
+};
+run().catch(console.log);

package/generator/ApiGen.d.ts

@@ -0,0 +1,138 @@
+import { TypesGen } from '../generator';
+export declare abstract class ApiGen {
+    readonly typesGen: TypesGen;
+    constructor(typesGen: TypesGen);
+    get metadata(): {
+        types: {
+            id: number;
+            path: string[];
+            params: {
+                name: string;
+                typeId: number | undefined;
+            }[];
+            type: {
+                tag: "Struct";
+                value: {
+                    fields: import("@dedot/codecs").Field[];
+                };
+            } | {
+                tag: "Enum";
+                value: {
+                    members: {
+                        name: string;
+                        fields: import("@dedot/codecs").Field[];
+                        index: number;
+                        docs: string[];
+                    }[];
+                };
+            } | {
+                tag: "Sequence";
+                value: {
+                    typeParam: number;
+                };
+            } | {
+                tag: "SizedVec";
+                value: {
+                    len: number;
+                    typeParam: number;
+                };
+            } | {
+                tag: "Tuple";
+                value: {
+                    fields: number[];
+                };
+            } | {
+                tag: "Primitive";
+                value: {
+                    kind: "bool" | "char" | "str" | "u8" | "u16" | "u32" | "u64" | "u128" | "u256" | "i8" | "i16" | "i32" | "i64" | "i128" | "i256";
+                };
+            } | {
+                tag: "Compact";
+                value: {
+                    typeParam: number;
+                };
+            } | {
+                tag: "BitSequence";
+                value: {
+                    bitOrderType: number;
+                    bitStoreType: number;
+                };
+            };
+            docs: string[];
+        }[];
+        pallets: {
+            name: string;
+            storage: {
+                prefix: string;
+                entries: {
+                    name: string;
+                    modifier: string;
+                    type: {
+                        tag: "Plain";
+                        value: {
+                            valueTypeId: number;
+                        };
+                    } | {
+                        tag: "Map";
+                        value: {
+                            hashers: ("identity" | "blake2_128" | "blake2_256" | "blake2_128Concat" | "twox128" | "twox256" | "twox64Concat")[];
+                            keyTypeId: number;
+                            valueTypeId: number;
+                        };
+                    };
+                    default: `0x${string}`;
+                    docs: string[];
+                }[];
+            } | undefined;
+            calls: number | undefined;
+            event: number | undefined;
+            constants: {
+                name: string;
+                typeId: number;
+                value: `0x${string}`;
+                docs: string[];
+            }[];
+            error: number | undefined;
+            index: number;
+            docs: string[];
+        }[];
+        extrinsic: {
+            version: number;
+            addressTypeId: number;
+            callTypeId: number;
+            signatureTypeId: number;
+            extraTypeId: number;
+            signedExtensions: {
+                ident: string;
+                typeId: number;
+                additionalSigned: number;
+            }[];
+        };
+        runtimeType: number;
+        apis: {
+            name: string;
+            methods: {
+                name: string;
+                inputs: {
+                    name: string;
+                    typeId: number;
+                }[];
+                output: number;
+                docs: string[];
+            }[];
+            docs: string[];
+        }[];
+        outerEnums: {
+            callEnumTypeId: number;
+            eventEnumTypeId: number;
+            errorEnumTypeId: number;
+        };
+        custom: {
+            map: ReadonlyMap<string, {
+                typeId: number;
+                value: `0x${string}`;
+            }>;
+        };
+    };
+    get registry(): import("@dedot/codecs").CodecRegistry;
+}

package/generator/ApiGen.js

@@ -0,0 +1,12 @@
+export class ApiGen {
+    typesGen;
+    constructor(typesGen) {
+        this.typesGen = typesGen;
+    }
+    get metadata() {
+        return this.typesGen.metadata;
+    }
+    get registry() {
+        return this.typesGen.registry;
+    }
+}

package/generator/ConstsGen.d.ts

@@ -0,0 +1,4 @@
+import { ApiGen } from '../generator';
+export declare class ConstsGen extends ApiGen {
+    generate(): Promise<string>;
+}

package/generator/ConstsGen.js

@@ -0,0 +1,28 @@
+import { stringLowerFirst } from '@polkadot/util';
+import { normalizeName } from '@dedot/utils';
+import { ApiGen } from '../generator';
+import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
+export class ConstsGen extends ApiGen {
+    generate() {
+        const { pallets } = this.metadata;
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericChainConsts');
+        let defTypeOut = '';
+        for (let pallet of pallets) {
+            const typedConstants = pallet.constants.map((one) => ({
+                name: normalizeName(one.name),
+                type: this.typesGen.generateType(one.typeId, 1, true),
+                docs: one.docs,
+            }));
+            defTypeOut += commentBlock(`Pallet \`${pallet.name}\`'s constants`);
+            defTypeOut += `${stringLowerFirst(pallet.name)}: {
+        ${typedConstants.map(({ name, type, docs }) => `${commentBlock(docs)}${name}: ${type}`).join(',\n')}
+          
+        ${commentBlock('Generic pallet constant')}[name: string]: any,
+      },`;
+        }
+        const importTypes = this.typesGen.typeImports.toImports();
+        const template = compileTemplate('consts.hbs');
+        return beautifySourceCode(template({ importTypes, defTypeOut }));
+    }
+}

package/generator/ErrorsGen.d.ts

@@ -0,0 +1,5 @@
+import { ApiGen } from './ApiGen';
+export declare class ErrorsGen extends ApiGen {
+    #private;
+    generate(): Promise<string>;
+}

package/generator/ErrorsGen.js

@@ -0,0 +1,37 @@
+import { ApiGen } from './ApiGen';
+import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
+import { stringCamelCase, stringPascalCase } from '@polkadot/util';
+import { assert } from '@dedot/utils';
+export class ErrorsGen extends ApiGen {
+    generate() {
+        const { pallets } = this.metadata;
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericChainErrors', 'GenericPalletError');
+        let defTypeOut = '';
+        for (let pallet of pallets) {
+            const errorTypeId = pallet.error;
+            if (!errorTypeId) {
+                continue;
+            }
+            const errorDefs = this.#getErrorDefs(errorTypeId);
+            defTypeOut += commentBlock(`Pallet \`${pallet.name}\`'s errors`);
+            defTypeOut += `${stringCamelCase(pallet.name)}: {
+        ${errorDefs
+                .map(({ name, docs }) => `${commentBlock(docs)}${stringPascalCase(name)}: GenericPalletError`)
+                .join(',\n')}
+          
+        ${commentBlock('Generic pallet error')}[error: string]: GenericPalletError,
+      },`;
+        }
+        const importTypes = this.typesGen.typeImports.toImports();
+        const template = compileTemplate('errors.hbs');
+        return beautifySourceCode(template({ importTypes, defTypeOut }));
+    }
+    #getErrorDefs(errorTypeId) {
+        const def = this.metadata.types[errorTypeId];
+        assert(def, `Error def not found for id ${errorTypeId}`);
+        const { tag, value } = def.type;
+        assert(tag === 'Enum', `Invalid pallet error type!`);
+        return value.members;
+    }
+}

package/generator/EventsGen.d.ts

@@ -0,0 +1,5 @@
+import { ApiGen } from './ApiGen';
+export declare class EventsGen extends ApiGen {
+    #private;
+    generate(): Promise<string>;
+}

package/generator/EventsGen.js

@@ -0,0 +1,64 @@
+import { ApiGen } from './ApiGen';
+import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
+import { stringCamelCase, stringPascalCase } from '@polkadot/util';
+import { assert } from '@dedot/utils';
+export class EventsGen extends ApiGen {
+    generate() {
+        const { pallets } = this.metadata;
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericChainEvents', 'GenericPalletEvent');
+        let defTypeOut = '';
+        for (let pallet of pallets) {
+            const eventTypeId = pallet.event;
+            if (!eventTypeId) {
+                continue;
+            }
+            const eventDefs = this.#getEventDefs(eventTypeId);
+            const flatMembers = eventDefs.every((d) => d.fields.length === 0);
+            defTypeOut += commentBlock(`Pallet \`${pallet.name}\`'s events`);
+            defTypeOut += `${stringCamelCase(pallet.name)}: {
+        ${eventDefs
+                .map((def) => {
+                const genericParts = [`'${pallet.name}'`, `'${def.name}'`];
+                const eventDataPart = this.#generateMemberDefType(def.fields);
+                if (eventDataPart) {
+                    genericParts.push(eventDataPart);
+                }
+                else {
+                    genericParts.push(flatMembers ? 'undefined' : 'null');
+                }
+                return { ...def, genericParts };
+            })
+                .map(({ name, docs, fields, genericParts }) => `${commentBlock(docs)}${stringPascalCase(name)}: GenericPalletEvent<${genericParts.join(', ')}>`)
+                .join(',\n')}
+          
+        ${commentBlock('Generic pallet event')}[prop: string]: GenericPalletEvent,
+      },`;
+        }
+        const importTypes = this.typesGen.typeImports.toImports();
+        const template = compileTemplate('events.hbs');
+        return beautifySourceCode(template({ importTypes, defTypeOut }));
+    }
+    #getEventDefs(typeId) {
+        const def = this.metadata.types[typeId];
+        assert(def, `Event def not found for id ${typeId}`);
+        const { tag, value } = def.type;
+        assert(tag === 'Enum', 'Invalid pallet event type!');
+        return value.members;
+    }
+    #generateMemberDefType(fields) {
+        if (fields.length === 0) {
+            return null;
+        }
+        else if (fields[0].name === undefined) {
+            return fields.length === 1
+                ? this.typesGen.generateType(fields[0].typeId, 1, true)
+                : `[${fields
+                    .map(({ typeId, docs }) => `${commentBlock(docs)}${this.typesGen.generateType(typeId, 1, true)}`)
+                    .join(', ')}]`;
+        }
+        else {
+            return this.typesGen.generateObjectType(fields, 1, true);
+        }
+    }
+}

package/generator/IndexGen.d.ts

@@ -0,0 +1,6 @@
+import { NetworkInfo } from '../types';
+export declare class IndexGen {
+    readonly networkInfo: NetworkInfo;
+    constructor(networkInfo: NetworkInfo);
+    generate(): Promise<string>;
+}

package/generator/IndexGen.js

@@ -0,0 +1,14 @@
+import { beautifySourceCode, compileTemplate } from './utils';
+import { stringPascalCase } from '@polkadot/util';
+export class IndexGen {
+    networkInfo;
+    constructor(networkInfo) {
+        this.networkInfo = networkInfo;
+    }
+    async generate() {
+        const { chain } = this.networkInfo;
+        const interfaceName = stringPascalCase(chain);
+        const template = compileTemplate('index.hbs');
+        return beautifySourceCode(template({ interfaceName }));
+    }
+}

package/generator/QueryGen.d.ts

@@ -0,0 +1,5 @@
+import { ApiGen } from '../generator';
+export declare class QueryGen extends ApiGen {
+    #private;
+    generate(): Promise<string>;
+}

package/generator/QueryGen.js

@@ -0,0 +1,55 @@
+import { stringLowerFirst } from '@polkadot/util';
+import { normalizeName } from '@dedot/utils';
+import { ApiGen } from '../generator';
+import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
+export class QueryGen extends ApiGen {
+    generate() {
+        const { pallets } = this.metadata;
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericChainStorage', 'GenericStorageQuery', 'Callback');
+        let defTypeOut = '';
+        for (let pallet of pallets) {
+            const storage = pallet.storage;
+            if (!storage)
+                continue;
+            const queries = storage.entries.map((one) => this.#generateEntry(one));
+            const queryDefs = queries.map(({ name, valueType, keyType, docs }) => `${commentBlock(docs)}${name}: GenericStorageQuery<(${keyType}) => ${valueType}>`);
+            defTypeOut += commentBlock(`Pallet \`${pallet.name}\`'s storage queries`);
+            defTypeOut += `${stringLowerFirst(pallet.name)}: {
+        ${queryDefs.join(',\n')}
+        
+        ${commentBlock('Generic pallet storage query')}[storage: string]: GenericStorageQuery;
+      },`;
+        }
+        const importTypes = this.typesGen.typeImports.toImports();
+        const template = compileTemplate('query.hbs');
+        return beautifySourceCode(template({ importTypes, defTypeOut }));
+    }
+    #generateEntry(entry) {
+        const { name, type, docs, modifier } = entry;
+        let valueType, keyType;
+        if (type.tag === 'Plain') {
+            valueType = this.typesGen.generateType(type.value.valueTypeId, 1, true);
+        }
+        else if (type.tag === 'Map') {
+            valueType = this.typesGen.generateType(type.value.valueTypeId, 1, true);
+            keyType = this.typesGen.generateType(type.value.keyTypeId, 1);
+        }
+        else {
+            throw Error('Invalid entry type!');
+        }
+        const isOptional = modifier === 'Optional';
+        valueType = `${valueType}${isOptional ? ' | undefined' : ''}`;
+        docs.push('\n');
+        if (keyType) {
+            docs.push(`@param {${keyType}} arg`);
+        }
+        docs.push(`@param {Callback<${valueType}> =} callback`);
+        return {
+            name: normalizeName(name),
+            valueType,
+            keyType: keyType ? `arg: ${keyType}` : '',
+            docs,
+        };
+    }
+}

package/generator/RpcGen.d.ts

@@ -0,0 +1,10 @@
+import { ApiGen, TypesGen } from '../generator';
+export declare class RpcGen extends ApiGen {
+    #private;
+    readonly typesGen: TypesGen;
+    readonly rpcMethods: string[];
+    constructor(typesGen: TypesGen, rpcMethods: string[]);
+    generate(): Promise<string>;
+    addTypeImport(type: string | string[], toTypeIn?: boolean): void;
+    getGeneratedTypeName(type: string, toTypeIn?: boolean): string;
+}