dedot 0.0.1-next.fecbe32d.13 → 0.1.0

package/executor/ConstantExecutor.d.ts

@@ -1,11 +0,0 @@
-import { GenericSubstrateApi } from '@dedot/types';
-import type { SubstrateApi } from '../chaintypes/index.js';
-import { Executor } from './Executor.js';
-/**
- * @name ConstantExecutor
- *
- * Find & decode the constant value from metadata
- */
-export declare class ConstantExecutor<ChainApi extends GenericSubstrateApi = SubstrateApi> extends Executor<ChainApi> {
-    doExecute(pallet: string, constantName: string): unknown;
-}

package/executor/ConstantExecutor.js

@@ -1,16 +0,0 @@
-import { assert, UnknownApiError, stringCamelCase } from '@dedot/utils';
-import { Executor } from './Executor.js';
-/**
- * @name ConstantExecutor
- *
- * Find & decode the constant value from metadata
- */
-export class ConstantExecutor extends Executor {
-    doExecute(pallet, constantName) {
-        const targetPallet = this.getPallet(pallet);
-        const constantDef = targetPallet.constants.find((one) => stringCamelCase(one.name) === constantName);
-        assert(constantDef, new UnknownApiError(`Constant ${constantName} not found in pallet ${pallet}`));
-        const $codec = this.registry.findCodec(constantDef.typeId);
-        return $codec.tryDecode(constantDef.value);
-    }
-}

package/executor/ErrorExecutor.d.ts

@@ -1,11 +0,0 @@
-import type { GenericPalletError, GenericSubstrateApi } from '@dedot/types';
-import type { SubstrateApi } from '../chaintypes/index.js';
-import { Executor } from './Executor.js';
-/**
- * @name ErrorExecutor
- * @description Find pallet error information from metadata
- */
-export declare class ErrorExecutor<ChainApi extends GenericSubstrateApi = SubstrateApi> extends Executor<ChainApi> {
-    #private;
-    doExecute(pallet: string, errorName: string): GenericPalletError;
-}

package/executor/ErrorExecutor.js

@@ -1,42 +0,0 @@
-import { assert, hexToU8a, isHex, isNumber, isObject, stringPascalCase, UnknownApiError } from '@dedot/utils';
-import { Executor } from './Executor.js';
-/**
- * @name ErrorExecutor
- * @description Find pallet error information from metadata
- */
-export class ErrorExecutor extends Executor {
-    doExecute(pallet, errorName) {
-        const targetPallet = this.getPallet(pallet);
-        const errorTypeId = targetPallet.error;
-        assert(errorTypeId, new UnknownApiError(`Not found error with id ${errorTypeId} in pallet ${pallet}`));
-        const errorDef = this.#getErrorDef(errorTypeId, errorName);
-        return {
-            meta: {
-                ...errorDef,
-                pallet: targetPallet.name,
-                palletIndex: targetPallet.index,
-            },
-            is: (errorInfo) => {
-                if (isObject(errorInfo) && errorInfo.tag === 'Module') {
-                    errorInfo = errorInfo.value;
-                }
-                if (isObject(errorInfo) && isNumber(errorInfo.index) && isHex(errorInfo.error)) {
-                    return errorInfo.index === targetPallet.index && hexToU8a(errorInfo.error)[0] === errorDef.index;
-                }
-                return false;
-            },
-        };
-    }
-    #getErrorDef(errorTypeId, errorName) {
-        const def = this.metadata.types[errorTypeId];
-        assert(def, new UnknownApiError(`Error def not found for id ${errorTypeId}`));
-        const { tag, value } = def.type;
-        assert(tag === 'Enum', new UnknownApiError(`Error type should be an enum, found: ${tag}`));
-        const errorDef = value.members.find(({ name }) => stringPascalCase(name) === errorName);
-        assert(errorDef, new UnknownApiError(`Error def not found for ${errorName}`));
-        return {
-            ...errorDef,
-            fieldCodecs: errorDef.fields.map(({ typeId }) => this.registry.findCodec(typeId)),
-        };
-    }
-}

package/executor/EventExecutor.d.ts

@@ -1,11 +0,0 @@
-import type { GenericPalletEvent, GenericSubstrateApi } from '@dedot/types';
-import type { SubstrateApi } from '../chaintypes/index.js';
-import { Executor } from './Executor.js';
-/**
- * @name EventExecutor
- * @description Find pallet event information from metadata
- */
-export declare class EventExecutor<ChainApi extends GenericSubstrateApi = SubstrateApi> extends Executor<ChainApi> {
-    #private;
-    doExecute(pallet: string, errorName: string): GenericPalletEvent<string, string>;
-}

package/executor/EventExecutor.js

@@ -1,48 +0,0 @@
-import { assert, UnknownApiError, stringCamelCase, stringPascalCase } from '@dedot/utils';
-import { Executor } from './Executor.js';
-/**
- * @name EventExecutor
- * @description Find pallet event information from metadata
- */
-export class EventExecutor extends Executor {
-    doExecute(pallet, errorName) {
-        const targetPallet = this.getPallet(pallet);
-        const eventTypeId = targetPallet.event;
-        assert(eventTypeId, new UnknownApiError(`Not found event with id ${eventTypeId} in pallet ${pallet}`));
-        const eventDef = this.#getEventDef(eventTypeId, errorName);
-        const is = (event) => {
-            const palletCheck = stringCamelCase(event.pallet) === pallet;
-            if (typeof event.palletEvent === 'string') {
-                return palletCheck && stringPascalCase(event.palletEvent) === errorName;
-            }
-            else if (typeof event.palletEvent === 'object') {
-                return palletCheck && stringPascalCase(event.palletEvent.name) === errorName;
-            }
-            return false;
-        };
-        const as = (event) => {
-            return is(event) ? event : undefined;
-        };
-        return {
-            is,
-            as,
-            meta: {
-                ...eventDef,
-                pallet: targetPallet.name,
-                palletIndex: targetPallet.index,
-            },
-        };
-    }
-    #getEventDef(eventTypeId, errorName) {
-        const def = this.metadata.types[eventTypeId];
-        assert(def, new UnknownApiError(`Event def not found for id ${eventTypeId}`));
-        const { tag, value } = def.type;
-        assert(tag === 'Enum', new UnknownApiError(`Event type should be an enum, found: ${tag}`));
-        const eventDef = value.members.find(({ name }) => stringPascalCase(name) === errorName);
-        assert(eventDef, new UnknownApiError(`Event def not found for ${errorName}`));
-        return {
-            ...eventDef,
-            fieldCodecs: eventDef.fields.map(({ typeId }) => this.registry.findCodec(typeId)),
-        };
-    }
-}

package/executor/Executor.d.ts

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

package/executor/Executor.js

@@ -1,41 +0,0 @@
-import { assert, stringCamelCase, UnknownApiError } from '@dedot/utils';
-/**
- * @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 || this.api.atBlockHash;
-    }
-    get registry() {
-        return this.api.registry;
-    }
-    get metadata() {
-        return this.api.metadata.latest;
-    }
-    getPallet(name) {
-        const targetPallet = this.metadata.pallets.find((p) => stringCamelCase(p.name) === name);
-        assert(targetPallet, new UnknownApiError(`Pallet not found: ${name}`));
-        return targetPallet;
-    }
-    execute(...paths) {
-        try {
-            return this.doExecute(...paths);
-        }
-        catch (e) {
-            if (!this.api.options?.throwOnUnknownApi && e instanceof UnknownApiError) {
-                return undefined;
-            }
-            throw e;
-        }
-    }
-}

package/executor/RuntimeApiExecutor.d.ts

@@ -1,19 +0,0 @@
-import type { GenericRuntimeApiMethod, GenericSubstrateApi, RuntimeApiMethodParamSpec, RuntimeApiMethodSpec, RuntimeApiSpec } from '@dedot/types';
-import { Executor } from './Executor.js';
-export declare const FallbackRuntimeApis: Record<string, number>;
-export declare const FallbackRuntimeApiSpecs: {
-    Metadata: RuntimeApiSpec[];
-};
-/**
- * @name RuntimeApiExecutor
- * @description Execute a runtime api call,
- * runtime api definitions/specs are either from Metadata V15
- * or defined externally when initializing `Dedot` instance
- * via `ApiOptions.runtimeApis` option.
- */
-export declare class RuntimeApiExecutor<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> extends Executor<ChainApi> {
-    #private;
-    doExecute(runtimeApi: string, method: string): GenericRuntimeApiMethod;
-    tryDecode(callSpec: RuntimeApiMethodSpec, raw: any): unknown;
-    tryEncode(paramSpec: RuntimeApiMethodParamSpec, value: any): Uint8Array;
-}

package/executor/RuntimeApiExecutor.js

@@ -1,109 +0,0 @@
-import { Metadata, toRuntimeApiMethods, toRuntimeApiSpecs } from '@dedot/specs';
-import { assert, calcRuntimeApiHash, isNumber, stringPascalCase, stringSnakeCase, concatU8a, u8aToHex, UnknownApiError, } from '@dedot/utils';
-import { Executor } from './Executor.js';
-export const FallbackRuntimeApis = { '0x37e397fc7c91f5e4': 2 };
-export const FallbackRuntimeApiSpecs = { Metadata };
-/**
- * @name RuntimeApiExecutor
- * @description Execute a runtime api call,
- * runtime api definitions/specs are either from Metadata V15
- * or defined externally when initializing `Dedot` instance
- * via `ApiOptions.runtimeApis` option.
- */
-export class RuntimeApiExecutor extends Executor {
-    doExecute(runtimeApi, method) {
-        const runtimeApiName = stringPascalCase(runtimeApi);
-        const methodName = stringSnakeCase(method);
-        const callName = this.#callName({ runtimeApiName, methodName });
-        const callSpec = this.#findRuntimeApiMethodSpec(runtimeApiName, methodName);
-        assert(callSpec, new UnknownApiError(`Runtime api spec not found for ${callName}`));
-        const callFn = async (...args) => {
-            const { params } = callSpec;
-            const formattedInputs = params.map((param, index) => this.tryEncode(param, args[index]));
-            const bytes = u8aToHex(concatU8a(...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 $codec = this.#findCodec(callSpec, `Codec not found to decode respond data for ${this.#callName(callSpec)}`);
-        return $codec.tryDecode(raw);
-    }
-    tryEncode(paramSpec, value) {
-        const $codec = this.#findCodec(paramSpec, `Codec not found to encode input for param ${paramSpec.name}`);
-        return $codec.tryEncode(value);
-    }
-    #findCodec(spec, error) {
-        const { codec, typeId, type } = spec;
-        if (codec)
-            return codec;
-        if (isNumber(typeId)) {
-            return this.registry.findCodec(typeId);
-        }
-        throw new Error(error || 'Codec not found');
-    }
-    #callName({ runtimeApiName, methodName }) {
-        return `${runtimeApiName}_${methodName}`;
-    }
-    #findRuntimeApiMethodSpec(runtimeApi, method) {
-        const targetVersion = this.#findTargetRuntimeApiVersion(runtimeApi);
-        if (!isNumber(targetVersion))
-            return undefined;
-        const userDefinedSpec = this.#findDefinedSpec(this.api.options.runtimeApis, runtimeApi, method, targetVersion);
-        if (userDefinedSpec)
-            return userDefinedSpec;
-        const methodDef = this.#findRuntimeApiMethodDef(runtimeApi, method);
-        if (methodDef) {
-            return this.#toMethodSpec(runtimeApi, methodDef);
-        }
-        return this.#findDefinedSpec(FallbackRuntimeApiSpecs, runtimeApi, method, targetVersion);
-    }
-    #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) {
-        const { name, inputs, output, docs } = methodDef;
-        return {
-            docs,
-            runtimeApiName: runtimeApi,
-            methodName: name,
-            typeId: output,
-            params: inputs.map(({ name, typeId }) => ({
-                name,
-                typeId,
-            })),
-        };
-    }
-    #findTargetRuntimeApiVersion(runtimeApi) {
-        const runtimeApiHash = calcRuntimeApiHash(runtimeApi);
-        try {
-            return this.api.runtimeVersion.apis[runtimeApiHash] || FallbackRuntimeApis[runtimeApiHash];
-        }
-        catch {
-            return FallbackRuntimeApis[runtimeApiHash];
-        }
-    }
-    #findDefinedSpec(specs, runtimeApi, method, runtimeApiVersion) {
-        if (!specs)
-            return undefined;
-        const methodSpecs = toRuntimeApiSpecs(specs).map(toRuntimeApiMethods).flat();
-        return methodSpecs.find(({ runtimeApiName, methodName, version }) => `${stringPascalCase(runtimeApiName)}_${stringSnakeCase(methodName)}` === `${runtimeApi}_${method}` &&
-            runtimeApiVersion === version);
-    }
-}

package/executor/StorageQueryExecutor.d.ts

@@ -1,13 +0,0 @@
-import { BlockHash, StorageData, StorageKey } from '@dedot/codecs';
-import type { Callback, GenericStorageQuery, GenericSubstrateApi, Unsub } from '@dedot/types';
-import type { SubstrateApi } from '../chaintypes/index.js';
-import { Executor } from './Executor.js';
-/**
- * @name StorageQueryExecutor
- * @description Execute a query to on-chain storage
- */
-export declare class StorageQueryExecutor<ChainApi extends GenericSubstrateApi = SubstrateApi> extends Executor<ChainApi> {
-    doExecute(pallet: string, storage: string): GenericStorageQuery;
-    protected getStorage(key: StorageKey, at?: BlockHash): Promise<StorageData | undefined>;
-    protected subscribeStorage(keys: StorageKey[], callback: Callback<Array<StorageData | undefined>>): Promise<Unsub>;
-}

package/executor/StorageQueryExecutor.js

@@ -1,105 +0,0 @@
-import { assert, isFunction } from '@dedot/utils';
-import { QueryableStorage } from '../storage/QueryableStorage.js';
-import { Executor } from './Executor.js';
-const DEFAULT_KEYS_PAGE_SIZE = 1000;
-const DEFAULT_ENTRIES_PAGE_SIZE = 250;
-/**
- * @name StorageQueryExecutor
- * @description Execute a query to on-chain storage
- */
-export class StorageQueryExecutor extends Executor {
-    doExecute(pallet, storage) {
-        const entry = new QueryableStorage(this.registry, pallet, storage);
-        const extractArgs = (args) => {
-            const inArgs = args.slice();
-            const lastArg = args.at(-1);
-            const callback = isFunction(lastArg) ? inArgs.pop() : undefined;
-            return [inArgs, callback];
-        };
-        const getStorageKey = (...args) => {
-            const [inArgs] = extractArgs(args);
-            return entry.encodeKey(inArgs.at(0));
-        };
-        const getStorage = async (key) => {
-            const raw = await this.getStorage(key, this.atBlockHash);
-            return entry.decodeValue(raw);
-        };
-        const queryFn = async (...args) => {
-            const [inArgs, callback] = extractArgs(args);
-            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.subscribeStorage([encodedKey], (changes) => {
-                    if (changes.length === 0)
-                        return;
-                    callback(entry.decodeValue(changes[0]));
-                });
-            }
-            else {
-                return getStorage(encodedKey);
-            }
-        };
-        const queryMultiFn = async (...args) => {
-            const [inArgs, callback] = extractArgs(args);
-            const multiArgs = inArgs.at(0);
-            assert(Array.isArray(multiArgs), 'First param for multi query should be an array');
-            const encodedKeys = multiArgs.map((arg) => entry.encodeKey(arg));
-            // if a callback is passed, make a storage subscription and return an unsub function
-            if (callback) {
-                return await this.subscribeStorage(encodedKeys, (changes) => {
-                    callback(changes.map((change) => entry.decodeValue(change)));
-                });
-            }
-            else {
-                return await Promise.all(encodedKeys.map(getStorage));
-            }
-        };
-        queryFn.rawKey = getStorageKey;
-        queryFn.meta = {
-            pallet: entry.pallet.name,
-            palletIndex: entry.pallet.index,
-            ...entry.storageEntry,
-        };
-        queryFn.multi = queryMultiFn;
-        const isMap = entry.storageEntry.type.tag === 'Map';
-        if (isMap) {
-            const rawKeys = async (pagination) => {
-                const pageSize = pagination?.pageSize || DEFAULT_KEYS_PAGE_SIZE;
-                const startKey = pagination?.startKey || entry.prefixKey;
-                return await this.api.rpc.state_getKeysPaged(entry.prefixKey, pageSize, startKey, this.atBlockHash);
-            };
-            const keys = async (pagination) => {
-                const storageKeys = await rawKeys({ pageSize: DEFAULT_KEYS_PAGE_SIZE, ...pagination });
-                return storageKeys.map((key) => entry.decodeKey(key));
-            };
-            const entries = async (pagination) => {
-                const storageKeys = await rawKeys({ pageSize: DEFAULT_ENTRIES_PAGE_SIZE, ...pagination });
-                const changeSets = await this.api.rpc.state_queryStorageAt(storageKeys, this.atBlockHash);
-                const changes = changeSets[0].changes.reduce((o, [key, value]) => {
-                    o[key] = value;
-                    return o;
-                }, {});
-                return storageKeys.map((key) => [entry.decodeKey(key), entry.decodeValue(changes[key])]);
-            };
-            // @ts-ignore
-            queryFn.keys = keys;
-            // @ts-ignore
-            queryFn.entries = entries;
-        }
-        return queryFn;
-    }
-    getStorage(key, at) {
-        return this.api.rpc.state_getStorage(key, at);
-    }
-    subscribeStorage(keys, callback) {
-        const lastChanges = {};
-        return this.api.rpc.state_subscribeStorage(keys, (changeSet) => {
-            changeSet.changes.forEach(([key, value]) => {
-                if (lastChanges[key] !== value) {
-                    lastChanges[key] = value ?? undefined;
-                }
-            });
-            return callback(keys.map((key) => lastChanges[key]));
-        });
-    }
-}

package/executor/TxExecutor.d.ts

@@ -1,48 +0,0 @@
-import { SignOptions } from '@polkadot/keyring/types';
-import { IKeyringPair } from '@polkadot/types/types';
-import { BlockHash, Extrinsic, Hash } from '@dedot/codecs';
-import type { AddressOrPair, Callback, DryRunResult, GenericSubstrateApi, GenericTxCall, IRuntimeTxCall, ISubmittableResult, SignerOptions, Unsub } from '@dedot/types';
-import { HexString } from '@dedot/utils';
-import type { SubstrateApi } from '../chaintypes/index.js';
-import { Executor } from './Executor.js';
-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> {
-    #private;
-    doExecute(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>;
-        "__#42@#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>;
-        "__#6@#private": any;
-        registry: import("@dedot/codecs").PortableRegistry;
-        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<Extrinsic<any, any, any, any>, Extrinsic<any, any, any, any>>;
-        toU8a(): Uint8Array;
-        toHex(): `0x${string}`;
-        readonly length: number;
-        readonly hash: `0x${string}`;
-    };
-}