dedot 0.0.1-alpha.22

package/executor/Executor.d.ts

@@ -0,0 +1,150 @@
+import type { SubstrateApi } from '@dedot/chaintypes';
+import { BlockHash, PalletDefLatest } from '@dedot/codecs';
+import { GenericSubstrateApi } from '@dedot/types';
+import { Dedot } from '../client';
+/**
+ * @name Executor
+ * @description Execution abstraction for a specific action
+ */
+export declare abstract class Executor<ChainApi extends GenericSubstrateApi = SubstrateApi> {
+    #private;
+    constructor(api: Dedot<ChainApi>, atBlockHash?: BlockHash);
+    get api(): Dedot<ChainApi>;
+    get atBlockHash(): `0x${string}` | undefined;
+    get provider(): import("@polkadot/rpc-provider/types").ProviderInterface;
+    get registry(): import("@dedot/codecs").CodecRegistry;
+    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}`;
+            }>;
+        };
+    };
+    getPallet(name: string, throwErr?: boolean): PalletDefLatest;
+    abstract execute(...paths: string[]): unknown;
+}

package/executor/Executor.js

@@ -0,0 +1,35 @@
+import { stringCamelCase } from '@polkadot/util';
+/**
+ * @name Executor
+ * @description Execution abstraction for a specific action
+ */
+export class Executor {
+    #api;
+    #atBlockHash;
+    constructor(api, atBlockHash) {
+        this.#api = api;
+        this.#atBlockHash = atBlockHash;
+    }
+    get api() {
+        return this.#api;
+    }
+    get atBlockHash() {
+        return this.#atBlockHash;
+    }
+    get provider() {
+        return this.api.provider;
+    }
+    get registry() {
+        return this.api.registry;
+    }
+    get metadata() {
+        return this.api.metadataLatest;
+    }
+    getPallet(name, throwErr = true) {
+        const targetPallet = this.metadata.pallets.find((p) => stringCamelCase(p.name) === name);
+        if (!targetPallet && throwErr) {
+            throw new Error(`Pallet not found: ${name}`);
+        }
+        return targetPallet;
+    }
+}

package/executor/RpcExecutor.d.ts

@@ -0,0 +1,14 @@
+import type { SubstrateApi } from '@dedot/chaintypes';
+import { GenericSubstrateApi, RpcCallSpec, RpcParamSpec, GenericRpcCall } from '@dedot/types';
+import { Executor } from './Executor';
+/**
+ * @name RpcExecutor
+ * @description Execute a rpc based from an RPC spec,
+ * if a spec is not found we execute an arbitrary rpc method
+ */
+export declare class RpcExecutor<ChainApi extends GenericSubstrateApi = SubstrateApi> extends Executor<ChainApi> {
+    execute(section: string, method: string): GenericRpcCall;
+    tryDecode(callSpec: RpcCallSpec, raw: any): any;
+    tryEncode(paramSpec: RpcParamSpec, value: any): any;
+    checkRpcInputs(callSpec: RpcCallSpec, actualArgs: any[]): void;
+}

package/executor/RpcExecutor.js

@@ -0,0 +1,105 @@
+import { isFunction, u8aToHex } from '@polkadot/util';
+import { findAliasRpcSpec, findRpcSpec } from '@dedot/specs';
+import { assert, isNativeType } from '@dedot/utils';
+import { Executor } from './Executor';
+const isOptionalParam = (param) => {
+    return param.isOptional || param.name.startsWith('Option<');
+};
+/**
+ * @name RpcExecutor
+ * @description Execute a rpc based from an RPC spec,
+ * if a spec is not found we execute an arbitrary rpc method
+ */
+export class RpcExecutor extends Executor {
+    execute(section, method) {
+        const maybeRpcName = `${section}_${method}`;
+        const callSpec = findRpcSpec(maybeRpcName) || findAliasRpcSpec(maybeRpcName);
+        const rpcName = callSpec?.name || `${section}_${method}`;
+        const isSubscription = !!callSpec?.pubsub;
+        const fnRpc = async (...args) => {
+            assert(callSpec, 'Rpc spec not found');
+            this.checkRpcInputs(callSpec, args);
+            const { params } = callSpec;
+            const formattedInputs = args.map((input, index) => this.tryEncode(params[index], input));
+            const result = await this.provider.send(rpcName, formattedInputs);
+            return this.tryDecode(callSpec, result);
+        };
+        const fnSubRpc = async (...args) => {
+            assert(callSpec, 'Rpc spec not found');
+            const inArgs = args.slice();
+            const callback = inArgs.pop();
+            assert(isFunction(callback), 'A callback is required for subscription');
+            this.checkRpcInputs(callSpec, inArgs);
+            const onNewMessage = (error, result) => {
+                if (error) {
+                    console.error(error);
+                    return;
+                }
+                callback(this.tryDecode(callSpec, result));
+            };
+            const { params, pubsub } = callSpec;
+            const formattedInputs = inArgs.map((input, index) => this.tryEncode(params[index], input));
+            const [subname, subscribe, unsubcribe] = pubsub;
+            const subscription = this.provider.subscribe(subname, subscribe, formattedInputs, onNewMessage);
+            return async () => {
+                return subscription
+                    .then((subscriptionId) => this.provider.unsubscribe(subname, unsubcribe, subscriptionId))
+                    .catch((err) => {
+                    console.error(err);
+                    return false;
+                });
+            };
+        };
+        if (!callSpec) {
+            // Call arbitrary rpc method
+            return async (...args) => {
+                return await this.provider.send(rpcName, args);
+            };
+        }
+        const oneFnRpc = isSubscription ? fnSubRpc : fnRpc;
+        oneFnRpc.meta = callSpec;
+        return oneFnRpc;
+    }
+    tryDecode(callSpec, raw) {
+        if (raw === null) {
+            // We use `undefined` to represent Option::None in the client
+            return undefined;
+        }
+        const { type, isScale } = callSpec;
+        if (isScale) {
+            return this.registry.findCodec(type).tryDecode(raw);
+        }
+        if (isNativeType(type)) {
+            return raw;
+        }
+        return raw;
+    }
+    tryEncode(paramSpec, value) {
+        const { type, isScale, isOptional } = paramSpec;
+        if (isScale) {
+            if (isOptional && (value === undefined || value === null)) {
+                return null;
+            }
+            const $codec = this.registry.findCodec(type);
+            return u8aToHex($codec.tryEncode(value));
+        }
+        // TODO generalize this!
+        if (value && value['toJSON']) {
+            return value.toJSON();
+        }
+        return value;
+    }
+    checkRpcInputs(callSpec, actualArgs) {
+        const params = callSpec.params;
+        if (params.length === actualArgs.length) {
+            return;
+        }
+        params.forEach((param, idx) => {
+            const isRequiredParam = !isOptionalParam(param);
+            if (isRequiredParam && actualArgs[idx] === undefined) {
+                const requiredParamCount = params.filter((p) => !isOptionalParam(p)).length;
+                throw new Error(`Miss match RPC params, required ${requiredParamCount} params, current inputs length: ${actualArgs.length}`);
+            }
+        });
+    }
+}

package/executor/RuntimeApiExecutor.d.ts

@@ -0,0 +1,9 @@
+import { Executor } from './Executor';
+import { GenericRuntimeApiMethod, GenericSubstrateApi, RuntimeApiMethodParamSpec, RuntimeApiMethodSpec } from '@dedot/types';
+export declare const FallbackRuntimeApis: (string | number)[][];
+export declare class RuntimeApiExecutor<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> extends Executor<ChainApi> {
+    #private;
+    execute(runtimeApi: string, method: string): GenericRuntimeApiMethod;
+    tryDecode(callSpec: RuntimeApiMethodSpec, raw: any): unknown;
+    tryEncode(paramSpec: RuntimeApiMethodParamSpec, value: any): Uint8Array;
+}

package/executor/RuntimeApiExecutor.js

@@ -0,0 +1,89 @@
+import { Executor } from './Executor';
+import { assert, calculateRuntimeApiHash, stringSnakeCase } from '@dedot/utils';
+import { isNumber, stringPascalCase, u8aConcat, u8aToHex } from '@polkadot/util';
+import { findRuntimeApiMethodSpec } from '@dedot/specs';
+export const FallbackRuntimeApis = [
+    ['0x37e397fc7c91f5e4', 2], // Metadata Api v2
+];
+export class RuntimeApiExecutor extends Executor {
+    execute(runtimeApi, method) {
+        runtimeApi = stringPascalCase(runtimeApi);
+        method = stringSnakeCase(method);
+        const callName = `${runtimeApi}_${method}`;
+        const callSpec = this.#findRuntimeApiMethodSpec(runtimeApi, method);
+        assert(callSpec, `Runtime Api not found: ${callName}`);
+        const callFn = async (...args) => {
+            const { params } = callSpec;
+            const formattedInputs = params.map((param, index) => this.tryEncode(param, args[index]));
+            const bytes = u8aToHex(u8aConcat(...formattedInputs));
+            const callArgs = [callName, bytes];
+            if (this.atBlockHash) {
+                callArgs.push(this.atBlockHash);
+            }
+            const result = await this.api.rpc.state.call(...callArgs);
+            return this.tryDecode(callSpec, result);
+        };
+        callFn.meta = callSpec;
+        return callFn;
+    }
+    tryDecode(callSpec, raw) {
+        const { type, typeId } = callSpec;
+        if (isNumber(typeId)) {
+            return this.registry.findPortableCodec(typeId).tryDecode(raw);
+        }
+        return this.registry.findCodec(type).tryDecode(raw);
+    }
+    tryEncode(paramSpec, value) {
+        const { type, typeId } = paramSpec;
+        const $codec = isNumber(typeId) ? this.registry.findPortableCodec(typeId) : this.registry.findCodec(type);
+        return $codec.tryEncode(value);
+    }
+    #findRuntimeApiMethodSpec(runtimeApi, method) {
+        const methodDef = this.#findRuntimeApiMethodDef(runtimeApi, method);
+        if (methodDef) {
+            return this.#toMethodSpec(runtimeApi, methodDef);
+        }
+        return this.#findRuntimeApiMethodExternalSpec(runtimeApi, method);
+    }
+    #findRuntimeApiMethodDef(runtimeApi, method) {
+        try {
+            for (const api of this.metadata.apis) {
+                if (api.name !== runtimeApi)
+                    continue;
+                for (const apiMethod of api.methods) {
+                    if (apiMethod.name === method)
+                        return apiMethod;
+                }
+            }
+        }
+        catch { }
+    }
+    #toMethodSpec(runtimeApi, methodDef) {
+        if (!methodDef)
+            return undefined;
+        const { name, inputs, output, docs } = methodDef;
+        return {
+            docs,
+            runtimeApiName: runtimeApi,
+            methodName: name,
+            type: '', // TODO generate type name
+            typeId: output,
+            params: inputs.map(({ name, typeId }) => ({
+                name,
+                type: '', // TODO generate type name
+                typeId,
+            })),
+        };
+    }
+    #findRuntimeApiMethodExternalSpec(runtimeApi, method) {
+        const targetRuntimeApiHash = calculateRuntimeApiHash(runtimeApi);
+        const runtimeApiVersions = this.api.runtimeVersion?.apis || FallbackRuntimeApis;
+        const targetRuntimeApiVersion = runtimeApiVersions
+            .find(([supportedRuntimeApiHash]) => targetRuntimeApiHash === supportedRuntimeApiHash)
+            ?.at(1);
+        if (!isNumber(targetRuntimeApiVersion)) {
+            return undefined;
+        }
+        return findRuntimeApiMethodSpec(`${runtimeApi}_${method}`, targetRuntimeApiVersion);
+    }
+}

package/executor/StorageQueryExecutor.d.ts

@@ -0,0 +1,10 @@
+import type { SubstrateApi } from '@dedot/chaintypes';
+import { GenericSubstrateApi } from '@dedot/types';
+import { Executor } from './Executor';
+/**
+ * @name StorageQueryExecutor
+ * @description Execute a query to on-chain storage
+ */
+export declare class StorageQueryExecutor<ChainApi extends GenericSubstrateApi = SubstrateApi> extends Executor<ChainApi> {
+    execute(pallet: string, storage: string): (...args: any[]) => Promise<any>;
+}

package/executor/StorageQueryExecutor.js

@@ -0,0 +1,29 @@
+import { Executor } from './Executor';
+import { QueryableStorage } from '../storage/QueryableStorage';
+import { isFunction } from '@polkadot/util';
+/**
+ * @name StorageQueryExecutor
+ * @description Execute a query to on-chain storage
+ */
+export class StorageQueryExecutor extends Executor {
+    execute(pallet, storage) {
+        return async (...args) => {
+            const entry = new QueryableStorage(this.registry, pallet, storage);
+            const inArgs = args.slice();
+            const lastArg = args.at(-1);
+            const callback = isFunction(lastArg) ? inArgs.pop() : undefined;
+            const encodedKey = entry.encodeKey(inArgs.at(0));
+            // if a callback is passed, make a storage subscription and return an unsub function
+            if (callback) {
+                return await this.api.rpc.state.subscribeStorage([encodedKey], (changeSet) => {
+                    const targetChange = changeSet.changes.find((change) => change[0] === encodedKey);
+                    targetChange && callback(entry.decodeValue(targetChange[1]));
+                });
+            }
+            else {
+                const result = await this.api.rpc.state.getStorage(encodedKey, this.atBlockHash);
+                return entry.decodeValue(result);
+            }
+        };
+    }
+}

package/executor/TxExecutor.d.ts

@@ -0,0 +1,47 @@
+import { Executor } from './Executor';
+import { AddressOrPair, Callback, DryRunResult, GenericSubstrateApi, GenericTxCall, IRuntimeTxCall, ISubmittableResult, SignerOptions, Unsub } from '@dedot/types';
+import { SubstrateApi } from '@dedot/chaintypes';
+import { HexString } from '@dedot/utils';
+import { BlockHash, Hash } from '@dedot/codecs';
+import { IKeyringPair } from '@polkadot/types/types';
+import { SignOptions } from '@polkadot/keyring/types';
+export declare function isKeyringPair(account: AddressOrPair): account is IKeyringPair;
+/**
+ * Sign a raw message
+ * @param signerPair
+ * @param raw
+ * @param options
+ */
+export declare function signRaw(signerPair: IKeyringPair, raw: HexString, options?: SignOptions): Uint8Array;
+/**
+ * @name TxExecutor
+ * @description Execute a transaction instruction, returns a submittable extrinsic
+ */
+export declare class TxExecutor<ChainApi extends GenericSubstrateApi = SubstrateApi> extends Executor<ChainApi> {
+    execute(pallet: string, functionName: string): GenericTxCall;
+    createExtrinsic(call: IRuntimeTxCall): {
+        sign(fromAccount: AddressOrPair, options?: Partial<SignerOptions>): Promise<any>;
+        signAndSend(account: AddressOrPair, options?: Partial<SignerOptions>): Promise<Hash>;
+        signAndSend(account: AddressOrPair, callback: Callback<ISubmittableResult>): Promise<Unsub>;
+        signAndSend(account: AddressOrPair, options: Partial<SignerOptions>, callback?: Callback<ISubmittableResult>): Promise<Unsub>;
+        "__#51@#normalizeOptions"(partialOptions?: Partial<SignerOptions> | Callback<ISubmittableResult>, callback?: Callback<ISubmittableResult>): [Partial<SignerOptions>, Callback<ISubmittableResult> | undefined];
+        dryRun(account: AddressOrPair, optionsOrHash?: Partial<SignerOptions> | BlockHash): Promise<DryRunResult>;
+        send(): Promise<Hash>;
+        send(callback: Callback<ISubmittableResult>): Promise<Unsub>;
+        "__#10@#private": any;
+        registry: import("@dedot/codecs").CodecRegistry;
+        readonly signed: boolean;
+        readonly version: number;
+        readonly signature: import("@dedot/codecs").ExtrinsicSignatureV4<any, any, any> | undefined;
+        readonly call: any;
+        readonly callU8a: Uint8Array;
+        readonly callHex: `0x${string}`;
+        readonly callLength: number;
+        attachSignature(signature: import("@dedot/codecs").ExtrinsicSignatureV4<any, any, any>): void;
+        readonly $Codec: import("subshape").Shape<unknown, unknown>;
+        toU8a(): Uint8Array;
+        toHex(): `0x${string}`;
+        readonly length: number;
+        readonly hash: `0x${string}`;
+    };
+}

package/executor/TxExecutor.js

@@ -0,0 +1,147 @@
+import { Executor } from './Executor';
+import { assert } from '@dedot/utils';
+import { hexToU8a, isFunction, isHex, objectSpread, stringCamelCase, stringPascalCase, u8aToHex } from '@polkadot/util';
+import { Extrinsic } from '@dedot/codecs';
+import { ExtraSignedExtension, SubmittableResult } from '../extrinsic';
+import { blake2AsHex, blake2AsU8a } from '@polkadot/util-crypto';
+export function isKeyringPair(account) {
+    return isFunction(account.sign);
+}
+/**
+ * Sign a raw message
+ * @param signerPair
+ * @param raw
+ * @param options
+ */
+export function signRaw(signerPair, raw, options) {
+    const u8a = hexToU8a(raw);
+    // Ref: https://github.com/paritytech/polkadot-sdk/blob/943697fa693a4da6ef481ef93df522accb7d0583/substrate/primitives/runtime/src/generic/unchecked_extrinsic.rs#L234-L238
+    const toSignRaw = u8a.length > 256 ? blake2AsU8a(u8a, 256) : u8a;
+    return signerPair.sign(toSignRaw, options);
+}
+/**
+ * @name TxExecutor
+ * @description Execute a transaction instruction, returns a submittable extrinsic
+ */
+export class TxExecutor extends Executor {
+    execute(pallet, functionName) {
+        const targetPallet = this.getPallet(pallet);
+        assert(targetPallet.calls, 'Tx call type not found');
+        const txType = this.metadata.types[targetPallet.calls];
+        assert(txType.type.tag === 'Enum', 'Tx type should be enum');
+        const isFlatEnum = txType.type.value.members.every((m) => m.fields.length === 0);
+        const txCallDef = txType.type.value.members.find((m) => stringCamelCase(m.name) === functionName);
+        assert(txCallDef, 'Tx call not found');
+        const txCallFn = (...args) => {
+            let call;
+            if (isFlatEnum) {
+                call = {
+                    pallet: stringPascalCase(targetPallet.name),
+                    palletCall: stringPascalCase(txCallDef.name),
+                };
+            }
+            else {
+                const callParams = txCallDef.fields.reduce((o, { name }, idx) => {
+                    o[stringCamelCase(name)] = args[idx];
+                    return o;
+                }, {});
+                call = {
+                    pallet: stringPascalCase(targetPallet.name),
+                    palletCall: {
+                        name: stringPascalCase(txCallDef.name),
+                        params: callParams,
+                    },
+                };
+            }
+            return this.createExtrinsic(call);
+        };
+        txCallFn.meta = {
+            ...txCallDef,
+            fieldCodecs: txCallDef.fields.map(({ typeId }) => this.registry.findPortableCodec(typeId)),
+            pallet: targetPallet.name,
+            palletIndex: targetPallet.index,
+        };
+        return txCallFn;
+    }
+    createExtrinsic(call) {
+        const api = this.api;
+        class SubmittableExtrinsic extends Extrinsic {
+            async sign(fromAccount, options) {
+                const address = isKeyringPair(fromAccount) ? fromAccount.address : fromAccount.toString();
+                const extra = new ExtraSignedExtension(api, {
+                    signerAddress: address,
+                    payloadOptions: options,
+                });
+                await extra.init();
+                const { signer } = options || {};
+                let signature;
+                if (isKeyringPair(fromAccount)) {
+                    signature = u8aToHex(signRaw(fromAccount, extra.toRawPayload(this.callHex).data, { withType: true }));
+                }
+                else if (signer?.signPayload) {
+                    const result = await signer.signPayload(extra.toPayload(this.callHex));
+                    signature = result.signature;
+                }
+                else {
+                    throw new Error('Signer not found. Cannot sign the extrinsic!');
+                }
+                const { signatureTypeId } = this.registry.metadata.extrinsic;
+                const $Signature = this.registry.findPortableCodec(signatureTypeId);
+                this.attachSignature({
+                    address: address,
+                    signature: $Signature.tryDecode(signature),
+                    extra: extra.data,
+                });
+                return this;
+            }
+            async signAndSend(fromAccount, partialOptions, maybeCallback) {
+                const [options, callback] = this.#normalizeOptions(partialOptions, maybeCallback);
+                await this.sign(fromAccount, options);
+                return this.send(callback);
+            }
+            #normalizeOptions(partialOptions, callback) {
+                if (isFunction(partialOptions)) {
+                    return [{}, partialOptions];
+                }
+                else {
+                    return [objectSpread({}, partialOptions), callback];
+                }
+            }
+            async dryRun(account, optionsOrHash) {
+                const dryRunFn = api.rpc.system.dryRun;
+                assert(dryRunFn.meta, 'system_dryRun RPC does not supported!');
+                if (isHex(optionsOrHash)) {
+                    return dryRunFn(this.toHex(), optionsOrHash);
+                }
+                await this.sign(account, optionsOrHash);
+                return dryRunFn(this.toHex());
+            }
+            async send(callback) {
+                const isSubscription = !!callback;
+                const txHash = this.hash;
+                if (isSubscription) {
+                    return api.rpc.author.submitAndWatchExtrinsic(this.toHex(), async (status) => {
+                        if (status.tag === 'InBlock' || status.tag === 'Finalized') {
+                            const blockHash = status.value;
+                            const [signedBlock, blockEvents] = await Promise.all([
+                                api.rpc.chain.getBlock(blockHash),
+                                api.queryAt(blockHash).system.events(),
+                            ]);
+                            const txIndex = signedBlock.block.extrinsics.findIndex((tx) => blake2AsHex(hexToU8a(tx)) === txHash);
+                            assert(txIndex >= 0, 'Extrinsic not found!');
+                            const events = blockEvents.filter(({ phase }) => phase.tag === 'ApplyExtrinsic' && phase.value === txIndex);
+                            return callback(new SubmittableResult({ status, txHash, events, txIndex }));
+                        }
+                        else {
+                            return callback(new SubmittableResult({ status, txHash }));
+                        }
+                    });
+                }
+                else {
+                    return api.rpc.author.submitExtrinsic(this.toHex());
+                }
+            }
+        }
+        return new SubmittableExtrinsic(api.registry, call);
+    }
+}

package/executor/index.d.ts

@@ -0,0 +1,8 @@
+export * from './Executor';
+export * from './RpcExecutor';
+export * from './ConstantExecutor';
+export * from './StorageQueryExecutor';
+export * from './ErrorExecutor';
+export * from './EventExecutor';
+export * from './RuntimeApiExecutor';
+export * from './TxExecutor';

package/executor/index.js

@@ -0,0 +1,8 @@
+export * from './Executor';
+export * from './RpcExecutor';
+export * from './ConstantExecutor';
+export * from './StorageQueryExecutor';
+export * from './ErrorExecutor';
+export * from './EventExecutor';
+export * from './RuntimeApiExecutor';
+export * from './TxExecutor';