@dedot/api 0.18.8 → 1.0.0

package/cjs/executor/v2/StorageQueryExecutorV2.js

@@ -28,7 +28,13 @@ class StorageQueryExecutorV2 extends StorageQueryExecutor_js_1.StorageQueryExecu
                 entry.decodeValue(value),
             ]);
         };
-        return { entries };
+        const pagedKeys = () => {
+            throw new utils_1.DedotError('The pagedKeys method is not yet available via the new JSON-RPC (v2) specification. Please use the legacy client instead.');
+        };
+        const pagedEntries = () => {
+            throw new utils_1.DedotError('The pagedEntries method is not yet available via the new JSON-RPC (v2) specification. Please use the legacy client instead.');
+        };
+        return { entries, pagedKeys, pagedEntries };
     }
     getStorageQuery() {
         // @ts-ignore little trick to make querying data client.at instance works here,

package/cjs/executor/validation-helpers.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCompatibilityError = exports.padArgsForOptionalParams = exports.isOptionalParam = exports.isOptionCodec = void 0;
+const utils_1 = require("@dedot/utils");
+/**
+ * Check if a codec is an Option type
+ */
+function isOptionCodec(codec) {
+    try {
+        const metadata = codec?.metadata?.[0];
+        return metadata?.name === '$.option';
+    }
+    catch {
+        return false;
+    }
+}
+exports.isOptionCodec = isOptionCodec;
+/**
+ * Check if a parameter is optional (wrapped in Option)
+ */
+function isOptionalParam(param, registry) {
+    // Check direct codec first
+    if (param.codec) {
+        return isOptionCodec(param.codec);
+    }
+    // Check via typeId using registry
+    if ((0, utils_1.isNumber)(param.typeId)) {
+        try {
+            const type = registry.findType(param.typeId);
+            return type.typeDef.type === 'Enum' && type.path.join('::') === 'Option';
+        }
+        catch {
+            // ignore
+        }
+    }
+    return false;
+}
+exports.isOptionalParam = isOptionalParam;
+/**
+ * Pad args array with undefined for missing trailing optional parameters.
+ * This allows users to omit optional parameters at the end of the parameter list.
+ */
+function padArgsForOptionalParams(args, params, registry) {
+    // If args already match params length, no padding needed
+    if (args.length === params.length) {
+        return args;
+    }
+    // If more args than params, validation will fail later
+    if (args.length > params.length) {
+        return args;
+    }
+    // Check that all missing parameters are optional
+    for (let i = args.length; i < params.length; i++) {
+        const param = params[i];
+        if (!isOptionalParam(param, registry)) {
+            // Required parameter is missing, let the validation fail naturally
+            return args;
+        }
+    }
+    // All missing parameters are optional, pad with undefined
+    return [...args, ...Array(params.length - args.length).fill(undefined)];
+}
+exports.padArgsForOptionalParams = padArgsForOptionalParams;
+/**
+ * Format a value for display in error messages
+ * Stringifies and truncates to 20 characters max
+ */
+function formatValue(value) {
+    try {
+        let str;
+        if (typeof value === 'string') {
+            str = JSON.stringify(value);
+        }
+        else if (typeof value === 'undefined') {
+            str = 'undefined';
+        }
+        else if (value === null) {
+            str = 'null';
+        }
+        else if (typeof value === 'bigint') {
+            str = `${value}n`;
+        }
+        else if (typeof value === 'object') {
+            // For objects/arrays, use JSON.stringify
+            str = JSON.stringify(value);
+        }
+        else {
+            str = String(value);
+        }
+        // Truncate to 20 characters
+        if (str.length > 20) {
+            return str.slice(0, 20) + '...';
+        }
+        return str;
+    }
+    catch {
+        return '[complex value]';
+    }
+}
+/**
+ * Build a comprehensive API compatibility error with detailed information
+ */
+function buildCompatibilityError(originalError, params, args, context) {
+    const lines = [];
+    // Header
+    if (context.itemIndex !== undefined) {
+        lines.push(`API Compatibility Error: ${context.apiName} (item ${context.itemIndex})`);
+    }
+    else {
+        lines.push(`API Compatibility Error: ${context.apiName}`);
+    }
+    lines.push('');
+    // Check parameter count mismatch
+    if (args.length !== params.length) {
+        lines.push(`Expected ${params.length} parameter${params.length !== 1 ? 's' : ''} but received ${args.length}`);
+        lines.push('');
+    }
+    // Validate each parameter and report errors
+    const paramErrors = [];
+    const maxParams = Math.max(args.length, params.length);
+    for (let i = 0; i < maxParams; i++) {
+        const param = params[i];
+        const value = args[i];
+        if (!param) {
+            // Extra argument provided
+            paramErrors.push(`  [${i}] (unexpected) - value: ${formatValue(value)}`);
+            continue;
+        }
+        if (value === undefined && i >= args.length) {
+            // Missing argument - check if it's actually optional
+            const isOptional = isOptionalParam(param, context.registry);
+            if (isOptional) {
+                paramErrors.push(`  [${i}] ${param.name}: omitted (optional)`);
+            }
+            else {
+                paramErrors.push(`  [${i}] ${param.name}: ✗ required parameter missing - value: undefined`);
+            }
+            continue;
+        }
+        // Try to validate the parameter
+        try {
+            const $codec = findCodec(param, context.registry);
+            if ($codec) {
+                $codec.assert?.(value);
+                // Valid parameter
+                paramErrors.push(`  [${i}] ${param.name}: ✓ valid`);
+            }
+        }
+        catch (error) {
+            // Invalid parameter
+            paramErrors.push(`  [${i}] ${param.name}: ✗ invalid input type - value: ${formatValue(value)}`);
+        }
+    }
+    if (paramErrors.length > 0) {
+        lines.push('Parameters:');
+        lines.push(...paramErrors);
+        lines.push('');
+    }
+    // Add suggestion
+    lines.push('This may indicate your chaintypes definitions are outdated.');
+    lines.push('Consider regenerating chaintypes with:');
+    lines.push('  npx dedot chaintypes -w <your-chain-endpoint>');
+    return new utils_1.ApiCompatibilityError(lines.join('\n'));
+}
+exports.buildCompatibilityError = buildCompatibilityError;
+/**
+ * Find codec for a parameter (internal helper)
+ */
+function findCodec(param, registry) {
+    if (param.codec)
+        return param.codec;
+    if ((0, utils_1.isNumber)(param.typeId)) {
+        try {
+            return registry.findCodec(param.typeId);
+        }
+        catch {
+            // ignore
+        }
+    }
+    return undefined;
+}

package/cjs/extrinsic/submittable/BaseSubmittableExtrinsic.js

@@ -1,8 +1,33 @@
 "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.BaseSubmittableExtrinsic = void 0;
 const codecs_1 = require("@dedot/codecs");
+const $ = __importStar(require("@dedot/shape"));
 const utils_1 = require("@dedot/utils");
+const validation_helpers_js_1 = require("../../executor/validation-helpers.js");
 const index_js_1 = require("../extensions/index.js");
 const fakeSigner_js_1 = require("./fakeSigner.js");
 const utils_js_1 = require("./utils.js");
@@ -10,8 +35,8 @@ class BaseSubmittableExtrinsic extends codecs_1.Extrinsic {
     client;
     #alterTx;
     #hooks;
-    constructor(client, call) {
-        super(client.registry, call);
+    constructor(client, call, preamble) {
+        super(client.registry, call, preamble);
         this.client = client;
     }
     withHooks(hooks) {
@@ -118,10 +143,69 @@ class BaseSubmittableExtrinsic extends codecs_1.Extrinsic {
         const atApi = (await this.client.at(hash));
         return await atApi.query.system.events();
     }
+    /**
+     * Override callU8a to add transaction parameter validation before encoding
+     */
+    get callU8a() {
+        // Validate transaction parameters first
+        this.#validateTxParams();
+        // Then call parent implementation which does $RuntimeCall.assert and encoding
+        return super.callU8a;
+    }
+    /**
+     * Validate transaction parameters against their type definitions
+     * @private
+     */
+    #validateTxParams() {
+        // Skip if palletCall is a string (flat enum, no params)
+        if (typeof this.call.palletCall === 'string')
+            return;
+        if (!this.call.palletCall?.name)
+            return;
+        // 1. Find pallet metadata
+        const palletName = this.call.pallet;
+        const pallet = this.registry.metadata.pallets.find((p) => (0, utils_1.stringCamelCase)(p.name) === (0, utils_1.stringCamelCase)(palletName));
+        if (!pallet?.calls)
+            return;
+        // 2. Get calls enum type definition
+        const callsType = this.registry.metadata.types[pallet.calls.typeId];
+        if (callsType.typeDef.type !== 'Enum')
+            return;
+        // 3. Find specific call definition
+        const callName = this.call.palletCall.name;
+        const callDef = callsType.typeDef.value.members.find((m) => (0, utils_1.stringCamelCase)(m.name) === (0, utils_1.stringCamelCase)(callName));
+        if (!callDef)
+            return;
+        // 4. Build param specs from field definitions
+        const paramSpecs = callDef.fields.map((f) => ({
+            name: (0, utils_1.stringCamelCase)(f.name || ''),
+            typeId: f.typeId,
+        }));
+        // 5. Extract args in field order from params object
+        const params = this.call.palletCall.params || {};
+        const args = paramSpecs.map((spec) => params[spec.name]);
+        // 6. Validate with tuple codec
+        const $ParamsTuple = $.Tuple(...paramSpecs.map((spec) => this.registry.findCodec(spec.typeId)));
+        try {
+            $ParamsTuple.assert?.(args);
+        }
+        catch (error) {
+            if (error instanceof $.ShapeAssertError) {
+                throw (0, validation_helpers_js_1.buildCompatibilityError)(error, // --
+                paramSpecs, args, {
+                    apiName: `${(0, utils_1.stringCamelCase)(pallet.name)}.${(0, utils_1.stringCamelCase)(callDef.name)}`,
+                    registry: this.registry,
+                });
+            }
+            throw error;
+        }
+    }
     toU8a() {
         if (this.#alterTx) {
             return (0, utils_1.hexToU8a)(this.#alterTx);
         }
+        // Validate transaction parameters before encoding
+        this.#validateTxParams();
         return super.toU8a();
     }
     toHex() {

package/cjs/extrinsic/submittable/SubmittableExtrinsic.js

@@ -10,6 +10,16 @@ const utils_js_1 = require("./utils.js");
  * @description A wrapper around an Extrinsic that exposes methods to sign, send, and other utility around Extrinsic.
  */
 class SubmittableExtrinsic extends BaseSubmittableExtrinsic_js_1.BaseSubmittableExtrinsic {
+    static fromTx(client, tx) {
+        let extrinsic;
+        if ((0, utils_1.isHex)(tx)) {
+            extrinsic = client.registry.$Extrinsic.tryDecode(tx);
+        }
+        else {
+            extrinsic = tx;
+        }
+        return new SubmittableExtrinsic(client, extrinsic.call, extrinsic.preamble);
+    }
     async dryRun(account, optionsOrHash) {
         const dryRunFn = this.client.rpc.system_dryRun;
         if ((0, utils_1.isHex)(optionsOrHash)) {
@@ -23,7 +33,11 @@ class SubmittableExtrinsic extends BaseSubmittableExtrinsic_js_1.BaseSubmittable
         const txHex = this.toHex();
         const txHash = this.hash;
         const { deferTx, onTxProgress } = (0, utils_js_1.txDefer)();
-        const unsub = this.client.rpc.author_submitAndWatchExtrinsic(txHex, async (txStatus) => {
+        let unsub;
+        this.client.rpc
+            .author_submitAndWatchExtrinsic(txHex, async (txStatus) => {
+            let status;
+            let result;
             if (txStatus.type === 'InBlock' || txStatus.type === 'Finalized') {
                 const blockHash = txStatus.value;
                 const [signedBlock, blockEvents] = await Promise.all([
@@ -34,25 +48,33 @@ class SubmittableExtrinsic extends BaseSubmittableExtrinsic_js_1.BaseSubmittable
                 (0, utils_1.assert)(txIndex >= 0, 'Extrinsic not found!');
                 const events = blockEvents.filter(({ phase }) => phase.type === 'ApplyExtrinsic' && phase.value === txIndex);
                 const blockNumber = signedBlock.block.header.number;
-                const status = (0, utils_js_1.toTxStatus)(txStatus, { txIndex, blockNumber });
-                const result = this.transformTxResult(new SubmittableResult_js_1.SubmittableResult({ status, txHash, events, txIndex }));
-                onTxProgress(result);
-                !isSubscription && deferTx.resolve(txHash);
-                return callback?.(result);
+                status = (0, utils_js_1.toTxStatus)(txStatus, { txIndex, blockNumber });
+                result = this.transformTxResult(new SubmittableResult_js_1.SubmittableResult({ status, txHash, events, txIndex }));
             }
             else {
-                const status = (0, utils_js_1.toTxStatus)(txStatus);
-                const result = this.transformTxResult(new SubmittableResult_js_1.SubmittableResult({ status, txHash }));
-                onTxProgress(result);
-                !isSubscription && deferTx.resolve(txHash);
-                return callback?.(result);
+                status = (0, utils_js_1.toTxStatus)(txStatus);
+                result = this.transformTxResult(new SubmittableResult_js_1.SubmittableResult({ status, txHash }));
             }
-        });
-        if (isSubscription) {
-            unsub.then((x) => {
+            onTxProgress(result);
+            if (isSubscription) {
+                callback?.(result);
+            }
+            else {
+                deferTx.resolve(txHash);
+            }
+            if (status.type === 'Finalized' || // --
+                status.type === 'Invalid' ||
+                status.type === 'Drop') {
+                unsub?.().catch(utils_1.noop);
+            }
+        })
+            .then((x) => {
+            unsub = x;
+            if (isSubscription) {
                 deferTx.resolve(x);
-            });
-        }
+            }
+        })
+            .catch(deferTx.reject);
         return deferTx.promise;
     }
 }

package/cjs/extrinsic/submittable/SubmittableExtrinsicV2.js

@@ -12,10 +12,20 @@ const utils_js_1 = require("./utils.js");
  */
 class SubmittableExtrinsicV2 extends BaseSubmittableExtrinsic_js_1.BaseSubmittableExtrinsic {
     client;
-    constructor(client, call) {
-        super(client, call);
+    constructor(client, call, preamble) {
+        super(client, call, preamble);
         this.client = client;
     }
+    static fromTx(client, tx) {
+        let extrinsic;
+        if ((0, utils_1.isHex)(tx)) {
+            extrinsic = client.registry.$Extrinsic.tryDecode(tx);
+        }
+        else {
+            extrinsic = tx;
+        }
+        return new SubmittableExtrinsicV2(client, extrinsic.call, extrinsic.preamble);
+    }
     async #send(callback) {
         const api = this.client;
         const txHex = this.toHex();