dedot 0.0.1-alpha.11

package/cjs/executor/RpcExecutor.js

@@ -0,0 +1,109 @@
+"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 } = callSpec;
+        if (isScale) {
+            return this.registry.findCodec(type).tryDecode(raw);
+        }
+        if ((0, utils_1.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 (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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeApiExecutor = 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
+];
+class RuntimeApiExecutor extends Executor_1.Executor {
+    execute(runtimeApi, method) {
+        runtimeApi = (0, util_1.stringPascalCase)(runtimeApi);
+        method = (0, utils_1.stringSnakeCase)(method);
+        const callName = `${runtimeApi}_${method}`;
+        const callSpec = this.#findRuntimeApiMethodSpec(runtimeApi, method);
+        (0, utils_1.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 = (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 { type, typeId } = callSpec;
+        if ((0, util_1.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 = (0, util_1.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 = (0, utils_1.calculateRuntimeApiHash)(runtimeApi);
+        const runtimeApiVersions = this.api.runtimeVersion?.apis || exports.FallbackRuntimeApis;
+        const targetRuntimeApiVersion = runtimeApiVersions
+            .find(([supportedRuntimeApiHash]) => targetRuntimeApiHash === supportedRuntimeApiHash)
+            ?.at(1);
+        if (!(0, util_1.isNumber)(targetRuntimeApiVersion)) {
+            return undefined;
+        }
+        return (0, specs_1.findRuntimeApiMethodSpec)(`${runtimeApi}_${method}`, targetRuntimeApiVersion);
+    }
+}
+exports.RuntimeApiExecutor = RuntimeApiExecutor;

package/cjs/executor/StorageQueryExecutor.js

@@ -0,0 +1,33 @@
+"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

@@ -0,0 +1,153 @@
+"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 util_crypto_1 = require("@polkadot/util-crypto");
+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, util_crypto_1.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 call type not found');
+        const txType = this.metadata.types[targetPallet.calls];
+        (0, utils_1.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) => (0, util_1.stringCamelCase)(m.name) === functionName);
+        (0, utils_1.assert)(txCallDef, 'Tx call not found');
+        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.findPortableCodec(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.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 ((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, util_crypto_1.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/executor/index.js

@@ -0,0 +1,24 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Executor"), exports);
+__exportStar(require("./RpcExecutor"), exports);
+__exportStar(require("./ConstantExecutor"), exports);
+__exportStar(require("./StorageQueryExecutor"), exports);
+__exportStar(require("./ErrorExecutor"), exports);
+__exportStar(require("./EventExecutor"), exports);
+__exportStar(require("./RuntimeApiExecutor"), exports);
+__exportStar(require("./TxExecutor"), exports);

package/cjs/extrinsic/SubmittableResult.js

@@ -0,0 +1,33 @@
+"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

@@ -0,0 +1,88 @@
+"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.api.metadataLatest.extrinsic;
+        return (0, utils_1.ensurePresence)(this.registry.findPortableCodec(extraTypeId));
+    }
+    get additionalSignedCodec() {
+        const $AdditionalSignedCodecs = this.#signedExtensionDefs.map((se) => this.registry.findPortableCodec(se.additionalSigned));
+        return $.Tuple(...$AdditionalSignedCodecs);
+    }
+    get payloadCodec() {
+        const { callTypeId } = this.api.metadataLatest.extrinsic;
+        const $Call = this.registry.findPortableCodec(callTypeId);
+        return $.Tuple($Call, this.dataCodec, this.additionalSignedCodec);
+    }
+    get #signedExtensionDefs() {
+        return this.api.metadataLatest.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.api.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;

package/cjs/extrinsic/extensions/SignedExtension.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignedExtension = void 0;
+const utils_1 = require("@dedot/utils");
+class SignedExtension {
+    api;
+    options;
+    data;
+    additionalSigned;
+    constructor(api, options) {
+        this.api = api;
+        this.options = options;
+        this.data = {};
+        this.additionalSigned = [];
+    }
+    async init() {
+        // TODO implement this method
+    }
+    get identifier() {
+        return this.signedExtensionDef.ident;
+    }
+    get dataCodec() {
+        return (0, utils_1.ensurePresence)(this.api.registry.findPortableCodec(this.signedExtensionDef.typeId));
+    }
+    get additionalSignedCodec() {
+        return (0, utils_1.ensurePresence)(this.api.registry.findPortableCodec(this.signedExtensionDef.additionalSigned));
+    }
+    get registry() {
+        return this.api.registry;
+    }
+    get signedExtensionDef() {
+        return (0, utils_1.ensurePresence)(this.options.def);
+    }
+    get payloadOptions() {
+        return this.options?.payloadOptions || {};
+    }
+    toPayload(...args) {
+        return {};
+    }
+}
+exports.SignedExtension = SignedExtension;

package/cjs/extrinsic/extensions/index.js

@@ -0,0 +1,19 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./SignedExtension"), exports);
+__exportStar(require("./known"), exports);
+__exportStar(require("./ExtraSignedExtension"), exports);

package/cjs/extrinsic/extensions/known/ChargeAssetTxPayment.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChargeAssetTxPayment = void 0;
+const SignedExtension_1 = require("../SignedExtension");
+const util_1 = require("@polkadot/util");
+const utils_1 = require("@dedot/utils");
+/**
+ * @name ChargeAssetTxPayment
+ */
+class ChargeAssetTxPayment extends SignedExtension_1.SignedExtension {
+    async init() {
+        const { tip, assetId } = this.payloadOptions;
+        this.data = {
+            tip: tip || 0n,
+            assetId,
+        };
+    }
+    toPayload() {
+        const { tip, assetId } = this.data;
+        return {
+            tip: (0, util_1.bnToHex)(tip, { isLe: false }),
+            // @ts-ignore
+            assetId: this.#encodeAssetId(assetId),
+        };
+    }
+    #encodeAssetId(assetId) {
+        if (assetId === null || assetId === undefined) {
+            return undefined;
+        }
+        return (0, util_1.u8aToHex)(this.$AssetId().tryEncode(assetId));
+    }
+    $AssetId() {
+        const extensionTypeDef = this.registry.findPortableType(this.signedExtensionDef.typeId);
+        (0, utils_1.assert)(extensionTypeDef.type.tag === 'Struct');
+        const assetIdTypeDef = extensionTypeDef.type.value.fields.find((f) => f.name === 'asset_id');
+        const $codec = this.registry.findPortableCodec(assetIdTypeDef.typeId);
+        const codecMetadata = $codec.metadata[0];
+        if (codecMetadata.name === '$.option') {
+            return codecMetadata.args[0]; // inner shape
+        }
+        return $codec;
+    }
+}
+exports.ChargeAssetTxPayment = ChargeAssetTxPayment;

package/cjs/extrinsic/extensions/known/ChargeTransactionPayment.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChargeTransactionPayment = void 0;
+const SignedExtension_1 = require("../SignedExtension");
+const util_1 = require("@polkadot/util");
+class ChargeTransactionPayment extends SignedExtension_1.SignedExtension {
+    async init() {
+        this.data = this.payloadOptions.tip || 0n;
+    }
+    toPayload() {
+        return {
+            tip: (0, util_1.bnToHex)(this.data, { isLe: false }),
+        };
+    }
+}
+exports.ChargeTransactionPayment = ChargeTransactionPayment;