dedot 0.0.1-next.f5bf4fc2.1 → 0.1.0

package/cjs/executor/ErrorExecutor.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrorExecutor = void 0;
-const Executor_1 = require("./Executor");
-const utils_1 = require("@dedot/utils");
-const util_1 = require("@polkadot/util");
-/**
- * @name ErrorExecutor
- * @description Find pallet error information from metadata
- */
-class ErrorExecutor extends Executor_1.Executor {
-    execute(pallet, errorName) {
-        const targetPallet = this.getPallet(pallet);
-        const errorTypeId = targetPallet.error;
-        (0, utils_1.assert)(errorTypeId, `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 ((0, util_1.isObject)(errorInfo) && errorInfo.tag === 'Module') {
-                    errorInfo = errorInfo.value;
-                }
-                if ((0, util_1.isObject)(errorInfo) && (0, util_1.isNumber)(errorInfo.index) && (0, util_1.isHex)(errorInfo.error)) {
-                    return errorInfo.index === targetPallet.index && (0, util_1.hexToU8a)(errorInfo.error)[0] === errorDef.index;
-                }
-                return false;
-            },
-        };
-    }
-    #getErrorDef(errorTypeId, errorName) {
-        const def = this.metadata.types[errorTypeId];
-        (0, utils_1.assert)(def, `Error def not found for id ${errorTypeId}`);
-        const { tag, value } = def.type;
-        (0, utils_1.assert)(tag === 'Enum', `Error type should be an enum, found: ${tag}`);
-        const errorDef = value.members.find(({ name }) => (0, util_1.stringPascalCase)(name) === errorName);
-        (0, utils_1.assert)(errorDef, `Error def not found for ${errorName}`);
-        return {
-            ...errorDef,
-            fieldCodecs: errorDef.fields.map(({ typeId }) => this.registry.findCodec(typeId)),
-        };
-    }
-}
-exports.ErrorExecutor = ErrorExecutor;

package/cjs/executor/EventExecutor.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventExecutor = void 0;
-const Executor_1 = require("./Executor");
-const util_1 = require("@polkadot/util");
-const utils_1 = require("@dedot/utils");
-/**
- * @name EventExecutor
- * @description Find pallet event information from metadata
- */
-class EventExecutor extends Executor_1.Executor {
-    execute(pallet, errorName) {
-        const targetPallet = this.getPallet(pallet);
-        const eventTypeId = targetPallet.event;
-        (0, utils_1.assert)(eventTypeId, `Not found event with id ${eventTypeId} in pallet ${pallet}`);
-        const eventDef = this.#getEventDef(eventTypeId, errorName);
-        const is = (event) => {
-            const palletCheck = (0, util_1.stringCamelCase)(event.pallet) === pallet;
-            if (typeof event.palletEvent === 'string') {
-                return palletCheck && (0, util_1.stringPascalCase)(event.palletEvent) === errorName;
-            }
-            else if (typeof event.palletEvent === 'object') {
-                return palletCheck && (0, util_1.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];
-        (0, utils_1.assert)(def, `Event def not found for id ${eventTypeId}`);
-        const { tag, value } = def.type;
-        (0, utils_1.assert)(tag === 'Enum', `Event type should be an enum, found: ${tag}`);
-        const eventDef = value.members.find(({ name }) => (0, util_1.stringPascalCase)(name) === errorName);
-        (0, utils_1.assert)(eventDef, `Event def not found for ${errorName}`);
-        return {
-            ...eventDef,
-            fieldCodecs: eventDef.fields.map(({ typeId }) => this.registry.findCodec(typeId)),
-        };
-    }
-}
-exports.EventExecutor = EventExecutor;

package/cjs/executor/Executor.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Executor = void 0;
-const util_1 = require("@polkadot/util");
-/**
- * @name Executor
- * @description Execution abstraction for a specific action
- */
-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) => (0, util_1.stringCamelCase)(p.name) === name);
-        if (!targetPallet && throwErr) {
-            throw new Error(`Pallet not found: ${name}`);
-        }
-        return targetPallet;
-    }
-}
-exports.Executor = Executor;

package/cjs/executor/RpcExecutor.js

@@ -1,110 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RpcExecutor = void 0;
-const util_1 = require("@polkadot/util");
-const specs_1 = require("@dedot/specs");
-const utils_1 = require("@dedot/utils");
-const Executor_1 = require("./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
- */
-class RpcExecutor extends Executor_1.Executor {
-    execute(section, method) {
-        const maybeRpcName = `${section}_${method}`;
-        const callSpec = (0, specs_1.findRpcSpec)(maybeRpcName) || (0, specs_1.findAliasRpcSpec)(maybeRpcName);
-        const rpcName = callSpec?.name || `${section}_${method}`;
-        const isSubscription = !!callSpec?.pubsub;
-        const fnRpc = async (...args) => {
-            (0, utils_1.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) => {
-            (0, utils_1.assert)(callSpec, 'Rpc spec not found');
-            const inArgs = args.slice();
-            const callback = inArgs.pop();
-            (0, utils_1.assert)((0, util_1.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, codec } = callSpec;
-        if (isScale) {
-            (0, utils_1.assert)(codec, 'Codec not found to decode response');
-            return codec.tryDecode(raw);
-        }
-        if ((0, utils_1.isNativeType)(type)) {
-            return raw;
-        }
-        return raw;
-    }
-    tryEncode(paramSpec, value) {
-        const { isScale, codec, isOptional } = paramSpec;
-        if (isScale) {
-            if (isOptional && (value === undefined || value === null)) {
-                return null;
-            }
-            (0, utils_1.assert)(codec, 'Codec not found to encode params');
-            return (0, util_1.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}`);
-            }
-        });
-    }
-}
-exports.RpcExecutor = RpcExecutor;

package/cjs/executor/RuntimeApiExecutor.js

@@ -1,108 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RuntimeApiExecutor = exports.FallbackRuntimeApiSpecs = exports.FallbackRuntimeApis = void 0;
-const Executor_1 = require("./Executor");
-const utils_1 = require("@dedot/utils");
-const util_1 = require("@polkadot/util");
-const specs_1 = require("@dedot/specs");
-exports.FallbackRuntimeApis = [
-    ['0x37e397fc7c91f5e4', 2], // Metadata Api v2
-];
-exports.FallbackRuntimeApiSpecs = { Metadata: specs_1.Metadata };
-class RuntimeApiExecutor extends Executor_1.Executor {
-    execute(runtimeApi, method) {
-        const runtimeApiName = (0, util_1.stringPascalCase)(runtimeApi);
-        const methodName = (0, utils_1.stringSnakeCase)(method);
-        const callName = this.#callName({ runtimeApiName, methodName });
-        const callSpec = this.#findRuntimeApiMethodSpec(runtimeApiName, methodName);
-        (0, utils_1.assert)(callSpec, `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 = (0, util_1.u8aToHex)((0, util_1.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 $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 ((0, util_1.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 (!(0, util_1.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(exports.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 = (0, utils_1.calculateRuntimeApiHash)(runtimeApi);
-        const runtimeApiVersions = this.api.runtimeVersion?.apis || exports.FallbackRuntimeApis;
-        const foundVersion = runtimeApiVersions
-            .find(([supportedRuntimeApiHash]) => runtimeApiHash === supportedRuntimeApiHash)
-            ?.at(1);
-        return foundVersion;
-    }
-    #findDefinedSpec(specs, runtimeApi, method, runtimeApiVersion) {
-        if (!specs)
-            return undefined;
-        const methodSpecs = (0, specs_1.toRuntimeApiSpecs)(specs).map(specs_1.toRuntimeApiMethods).flat();
-        return methodSpecs.find(({ runtimeApiName, methodName, version }) => `${(0, util_1.stringPascalCase)(runtimeApiName)}_${(0, utils_1.stringSnakeCase)(methodName)}` === `${runtimeApi}_${method}` &&
-            runtimeApiVersion === version);
-    }
-}
-exports.RuntimeApiExecutor = RuntimeApiExecutor;

package/cjs/executor/StorageQueryExecutor.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StorageQueryExecutor = void 0;
-const Executor_1 = require("./Executor");
-const QueryableStorage_1 = require("../storage/QueryableStorage");
-const util_1 = require("@polkadot/util");
-/**
- * @name StorageQueryExecutor
- * @description Execute a query to on-chain storage
- */
-class StorageQueryExecutor extends Executor_1.Executor {
-    execute(pallet, storage) {
-        return async (...args) => {
-            const entry = new QueryableStorage_1.QueryableStorage(this.registry, pallet, storage);
-            const inArgs = args.slice();
-            const lastArg = args.at(-1);
-            const callback = (0, util_1.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);
-            }
-        };
-    }
-}
-exports.StorageQueryExecutor = StorageQueryExecutor;

package/cjs/executor/TxExecutor.js

@@ -1,153 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TxExecutor = exports.signRaw = exports.isKeyringPair = void 0;
-const Executor_1 = require("./Executor");
-const utils_1 = require("@dedot/utils");
-const util_1 = require("@polkadot/util");
-const codecs_1 = require("@dedot/codecs");
-const extrinsic_1 = require("../extrinsic");
-const utils_2 = require("@dedot/utils");
-function isKeyringPair(account) {
-    return (0, util_1.isFunction)(account.sign);
-}
-exports.isKeyringPair = isKeyringPair;
-/**
- * Sign a raw message
- * @param signerPair
- * @param raw
- * @param options
- */
-function signRaw(signerPair, raw, options) {
-    const u8a = (0, util_1.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 ? (0, utils_2.blake2AsU8a)(u8a, 256) : u8a;
-    return signerPair.sign(toSignRaw, options);
-}
-exports.signRaw = signRaw;
-/**
- * @name TxExecutor
- * @description Execute a transaction instruction, returns a submittable extrinsic
- */
-class TxExecutor extends Executor_1.Executor {
-    execute(pallet, functionName) {
-        const targetPallet = this.getPallet(pallet);
-        (0, utils_1.assert)(targetPallet.calls, `Tx calls are not available for pallet ${targetPallet.name}`);
-        const txType = this.metadata.types[targetPallet.calls];
-        (0, utils_1.assert)(txType.type.tag === 'Enum', 'Tx type defs should be enum');
-        const isFlatEnum = txType.type.value.members.every((m) => m.fields.length === 0);
-        const txCallDef = txType.type.value.members.find((m) => (0, util_1.stringCamelCase)(m.name) === functionName);
-        (0, utils_1.assert)(txCallDef, `Tx call spec not found for ${pallet}.${functionName}`);
-        const txCallFn = (...args) => {
-            let call;
-            if (isFlatEnum) {
-                call = {
-                    pallet: (0, util_1.stringPascalCase)(targetPallet.name),
-                    palletCall: (0, util_1.stringPascalCase)(txCallDef.name),
-                };
-            }
-            else {
-                const callParams = txCallDef.fields.reduce((o, { name }, idx) => {
-                    o[(0, util_1.stringCamelCase)(name)] = args[idx];
-                    return o;
-                }, {});
-                call = {
-                    pallet: (0, util_1.stringPascalCase)(targetPallet.name),
-                    palletCall: {
-                        name: (0, util_1.stringPascalCase)(txCallDef.name),
-                        params: callParams,
-                    },
-                };
-            }
-            return this.createExtrinsic(call);
-        };
-        txCallFn.meta = {
-            ...txCallDef,
-            fieldCodecs: txCallDef.fields.map(({ typeId }) => this.registry.findCodec(typeId)),
-            pallet: targetPallet.name,
-            palletIndex: targetPallet.index,
-        };
-        return txCallFn;
-    }
-    createExtrinsic(call) {
-        const api = this.api;
-        class SubmittableExtrinsic extends codecs_1.Extrinsic {
-            async sign(fromAccount, options) {
-                const address = isKeyringPair(fromAccount) ? fromAccount.address : fromAccount.toString();
-                const extra = new extrinsic_1.ExtraSignedExtension(api, {
-                    signerAddress: address,
-                    payloadOptions: options,
-                });
-                await extra.init();
-                const { signer } = options || {};
-                let signature;
-                if (isKeyringPair(fromAccount)) {
-                    signature = (0, util_1.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.findCodec(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 ((0, util_1.isFunction)(partialOptions)) {
-                    return [{}, partialOptions];
-                }
-                else {
-                    return [(0, util_1.objectSpread)({}, partialOptions), callback];
-                }
-            }
-            async dryRun(account, optionsOrHash) {
-                const dryRunFn = api.rpc.system.dryRun;
-                (0, utils_1.assert)(dryRunFn.meta, 'system_dryRun RPC does not supported!');
-                if ((0, util_1.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) => (0, utils_2.blake2AsHex)((0, util_1.hexToU8a)(tx)) === txHash);
-                            (0, utils_1.assert)(txIndex >= 0, 'Extrinsic not found!');
-                            const events = blockEvents.filter(({ phase }) => phase.tag === 'ApplyExtrinsic' && phase.value === txIndex);
-                            return callback(new extrinsic_1.SubmittableResult({ status, txHash, events, txIndex }));
-                        }
-                        else {
-                            return callback(new extrinsic_1.SubmittableResult({ status, txHash }));
-                        }
-                    });
-                }
-                else {
-                    return api.rpc.author.submitExtrinsic(this.toHex());
-                }
-            }
-        }
-        return new SubmittableExtrinsic(api.registry, call);
-    }
-}
-exports.TxExecutor = TxExecutor;

package/cjs/extrinsic/SubmittableResult.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SubmittableResult = void 0;
-class SubmittableResult {
-    dispatchInfo;
-    dispatchError;
-    events;
-    status;
-    txHash;
-    txIndex;
-    constructor({ events, status, txHash, txIndex }) {
-        this.events = events || [];
-        this.status = status;
-        this.txHash = txHash;
-        this.txIndex = txIndex;
-        [this.dispatchInfo, this.dispatchError] = this.#extractInfo();
-    }
-    #extractInfo() {
-        for (const { event } of this.events) {
-            const { pallet, palletEvent } = event;
-            if (pallet === 'System' && palletEvent.name === 'ExtrinsicFailed') {
-                const { dispatchInfo, dispatchError } = palletEvent.data;
-                return [dispatchInfo, dispatchError];
-            }
-            else if (pallet === 'System' && palletEvent.name === 'ExtrinsicSuccess') {
-                const { dispatchInfo } = palletEvent.data;
-                return [dispatchInfo, undefined];
-            }
-        }
-        return [undefined, undefined];
-    }
-}
-exports.SubmittableResult = SubmittableResult;

package/cjs/extrinsic/extensions/ExtraSignedExtension.js

@@ -1,88 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExtraSignedExtension = void 0;
-const SignedExtension_1 = require("./SignedExtension");
-const utils_1 = require("@dedot/utils");
-const $ = __importStar(require("@dedot/shape"));
-const known_1 = require("./known");
-const util_1 = require("@polkadot/util");
-class ExtraSignedExtension extends SignedExtension_1.SignedExtension {
-    #signedExtensions;
-    async init() {
-        this.#signedExtensions = this.#getSignedExtensions();
-        await Promise.all(this.#signedExtensions.map((se) => se.init()));
-        this.data = this.#signedExtensions.map((se) => se.data);
-        this.additionalSigned = this.#signedExtensions.map((se) => se.additionalSigned);
-    }
-    get identifier() {
-        return 'ExtraSignedExtension';
-    }
-    get dataCodec() {
-        const { extraTypeId } = this.registry.metadata.extrinsic;
-        return (0, utils_1.ensurePresence)(this.registry.findCodec(extraTypeId));
-    }
-    get additionalSignedCodec() {
-        const $AdditionalSignedCodecs = this.#signedExtensionDefs.map((se) => this.registry.findCodec(se.additionalSigned));
-        return $.Tuple(...$AdditionalSignedCodecs);
-    }
-    get payloadCodec() {
-        const { callTypeId } = this.registry.metadata.extrinsic;
-        const $Call = this.registry.findCodec(callTypeId);
-        return $.Tuple($Call, this.dataCodec, this.additionalSignedCodec);
-    }
-    get #signedExtensionDefs() {
-        return this.registry.metadata.extrinsic.signedExtensions;
-    }
-    #getSignedExtensions() {
-        return this.#signedExtensionDefs.map((extDef) => {
-            const { signedExtensions: userSignedExtensions = {} } = this.api.options;
-            const Extension = userSignedExtensions[extDef.ident] ||
-                known_1.knownSignedExtensions[extDef.ident];
-            (0, utils_1.assert)(Extension, `SignedExtension for ${extDef.ident} not found`);
-            return new Extension(this.api, {
-                ...(0, utils_1.ensurePresence)(this.options),
-                def: extDef,
-            });
-        });
-    }
-    toPayload(call = '0x') {
-        const signedExtensions = this.#signedExtensions.map((se) => se.identifier);
-        const { version } = this.registry.metadata.extrinsic;
-        return (0, util_1.objectSpread)({ address: this.options.signerAddress, signedExtensions, version, method: call }, ...this.#signedExtensions.map((se) => se.toPayload()));
-    }
-    toRawPayload(call = '0x') {
-        const payload = this.toPayload(call);
-        const $ToSignPayload = $.Tuple($.RawHex, this.dataCodec, this.additionalSignedCodec);
-        const toSignPayload = [call, this.data, this.additionalSigned];
-        const rawPayload = $ToSignPayload.tryEncode(toSignPayload);
-        return {
-            address: payload.address,
-            data: (0, util_1.u8aToHex)(rawPayload),
-            type: 'payload',
-        };
-    }
-}
-exports.ExtraSignedExtension = ExtraSignedExtension;