@dedot/contracts 0.0.1-alpha.34 → 0.0.1-alpha.35

package/Contract.d.ts

@@ -1,12 +1,10 @@
 import { ISubstrateClient } from '@dedot/api';
-import { SubstrateApi } from '@dedot/api/chaintypes';
 import { AccountId32, AccountId32Like } from '@dedot/codecs';
-import { GenericSubstrateApi, RpcVersion } from '@dedot/types';
 import { TypinkRegistry } from './TypinkRegistry.js';
 import { ContractMetadata, GenericContractApi } from './types/index.js';
-export declare class Contract<ContractApi extends GenericContractApi = GenericContractApi, ChainApi extends GenericSubstrateApi = SubstrateApi[RpcVersion]> {
+export declare class Contract<ContractApi extends GenericContractApi = GenericContractApi> {
     #private;
-    constructor(api: ISubstrateClient<ChainApi>, address: AccountId32Like, metadata: ContractMetadata | string);
+    constructor(api: ISubstrateClient, metadata: ContractMetadata | string, address: AccountId32Like);
     get metadata(): ContractMetadata;
     get address(): AccountId32;
     get registry(): TypinkRegistry;

package/Contract.js

@@ -7,7 +7,7 @@ export class Contract {
     #registry;
     #address;
     #metadata;
-    constructor(api, address, metadata) {
+    constructor(api, metadata, address) {
         ensureSupportContractsPallet(api);
         this.#api = api;
         this.#address = new AccountId32(address);

package/ContractDeployer.d.ts

@@ -1,12 +1,10 @@
 import { ISubstrateClient } from '@dedot/api';
-import { SubstrateApi } from '@dedot/api/chaintypes';
 import { Hash } from '@dedot/codecs';
-import { GenericSubstrateApi, RpcVersion } from '@dedot/types';
 import { TypinkRegistry } from './TypinkRegistry.js';
 import { ContractMetadata, GenericContractApi } from './types/index.js';
-export declare class ContractDeployer<ContractApi extends GenericContractApi = GenericContractApi, ChainApi extends GenericSubstrateApi = SubstrateApi[RpcVersion]> {
+export declare class ContractDeployer<ContractApi extends GenericContractApi = GenericContractApi> {
     #private;
-    constructor(api: ISubstrateClient<ChainApi>, metadata: ContractMetadata | string, codeHashOrWasm: Hash | Uint8Array | string);
+    constructor(api: ISubstrateClient, metadata: ContractMetadata | string, codeHashOrWasm: Hash | Uint8Array | string);
     get metadata(): ContractMetadata;
     get registry(): TypinkRegistry;
     get tx(): ContractApi['constructorTx'];

package/ContractDeployer.js

@@ -1,8 +1,7 @@
 import { TypinkRegistry } from './TypinkRegistry.js';
 import { ConstructorQueryExecutor } from './executor/ConstructorQueryExecutor.js';
 import { ConstructorTxExecutor } from './executor/index.js';
-import { newProxyChain, ensureSupportContractsPallet } from './utils.js';
-import { parseRawMetadata } from './utils.js';
+import { ensureSupportContractsPallet, newProxyChain, parseRawMetadata } from './utils.js';
 export class ContractDeployer {
     #api;
     #metadata;

package/cjs/Contract.js

@@ -10,7 +10,7 @@ class Contract {
     #registry;
     #address;
     #metadata;
-    constructor(api, address, metadata) {
+    constructor(api, metadata, address) {
         (0, utils_js_1.ensureSupportContractsPallet)(api);
         this.#api = api;
         this.#address = new codecs_1.AccountId32(address);

package/cjs/ContractDeployer.js

@@ -5,7 +5,6 @@ const TypinkRegistry_js_1 = require("./TypinkRegistry.js");
 const ConstructorQueryExecutor_js_1 = require("./executor/ConstructorQueryExecutor.js");
 const index_js_1 = require("./executor/index.js");
 const utils_js_1 = require("./utils.js");
-const utils_js_2 = require("./utils.js");
 class ContractDeployer {
     #api;
     #metadata;
@@ -14,7 +13,7 @@ class ContractDeployer {
     constructor(api, metadata, codeHashOrWasm) {
         (0, utils_js_1.ensureSupportContractsPallet)(api);
         this.#api = api;
-        this.#metadata = typeof metadata === 'string' ? (0, utils_js_2.parseRawMetadata)(metadata) : metadata;
+        this.#metadata = typeof metadata === 'string' ? (0, utils_js_1.parseRawMetadata)(metadata) : metadata;
         this.#registry = new TypinkRegistry_js_1.TypinkRegistry(this.#metadata);
         this.#code = codeHashOrWasm;
     }

package/cjs/executor/ConstructorQueryExecutor.js

@@ -2,20 +2,28 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConstructorQueryExecutor = void 0;
 const utils_1 = require("@dedot/utils");
-const ConstructorTxExecutor_js_1 = require("./ConstructorTxExecutor.js");
-class ConstructorQueryExecutor extends ConstructorTxExecutor_js_1.ConstructorTxExecutor {
+const utils_js_1 = require("../utils.js");
+const Executor_js_1 = require("./Executor.js");
+class ConstructorQueryExecutor extends Executor_js_1.Executor {
+    code;
+    constructor(api, registry, code) {
+        super(api, registry);
+        this.code = code;
+    }
     doExecute(constructor) {
-        const meta = this.findConstructorMeta(constructor);
+        const meta = this.#findConstructorMeta(constructor);
         (0, utils_1.assert)(meta, `Constructor message not found: ${constructor}`);
         const callFn = (...params) => {
-            // TODO verify number of arguments/params & call options presence
             const { args } = meta;
+            (0, utils_1.assert)(params.length === args.length + 1, `Expected ${args.length + 1} arguments, got ${params.length}`);
             const callOptions = params[args.length];
             const { caller, value = 0n, gasLimit, storageDepositLimit, salt } = callOptions;
+            (0, utils_1.assert)(caller, 'Expected a valid caller address in ConstructorCallOptions');
+            (0, utils_1.assert)(salt, 'Expected a salt in ConstructorCallOptions');
             const formattedInputs = args.map((arg, index) => this.tryEncode(arg, params[index]));
             const bytes = (0, utils_1.u8aToHex)((0, utils_1.concatU8a)((0, utils_1.hexToU8a)(meta.selector), ...formattedInputs));
             const code = {
-                tag: (0, utils_1.isWasm)(this.code) ? 'Upload' : 'Existing',
+                type: (0, utils_1.isWasm)(this.code) ? 'Upload' : 'Existing',
                 value: this.code,
             };
             return this.api.call.contractsApi.instantiate(caller, value, gasLimit, storageDepositLimit, code, bytes, salt);
@@ -23,5 +31,8 @@ class ConstructorQueryExecutor extends ConstructorTxExecutor_js_1.ConstructorTxE
         callFn.meta = meta;
         return callFn;
     }
+    #findConstructorMeta(constructor) {
+        return this.metadata.spec.constructors.find((one) => (0, utils_js_1.normalizeLabel)(one.label) === constructor);
+    }
 }
 exports.ConstructorQueryExecutor = ConstructorQueryExecutor;

package/cjs/executor/ConstructorTxExecutor.js

@@ -11,13 +11,15 @@ class ConstructorTxExecutor extends Executor_js_1.Executor {
         this.code = code;
     }
     doExecute(constructor) {
-        const meta = this.findConstructorMeta(constructor);
+        const meta = this.#findConstructorMeta(constructor);
         (0, utils_1.assert)(meta, `Constructor message not found: ${constructor}`);
         const callFn = (...params) => {
-            // TODO verify number of arguments/params & call options presence
             const { args } = meta;
+            (0, utils_1.assert)(params.length === args.length + 1, `Expected ${args.length + 1} arguments, got ${params.length}`);
             const txCallOptions = params[args.length];
             const { value = 0n, gasLimit, storageDepositLimit, salt } = txCallOptions;
+            (0, utils_1.assert)(gasLimit, 'Expected a gas limit in ConstructorTxOptions');
+            (0, utils_1.assert)(salt, 'Expected a salt in ConstructorTxOptions');
             const formattedInputs = args.map((arg, index) => this.tryEncode(arg, params[index]));
             const bytes = (0, utils_1.u8aToHex)((0, utils_1.concatU8a)((0, utils_1.hexToU8a)(meta.selector), ...formattedInputs));
             if ((0, utils_1.isWasm)(this.code)) {
@@ -30,7 +32,7 @@ class ConstructorTxExecutor extends Executor_js_1.Executor {
         callFn.meta = meta;
         return callFn;
     }
-    findConstructorMeta(constructor) {
+    #findConstructorMeta(constructor) {
         return this.metadata.spec.constructors.find((one) => (0, utils_js_1.normalizeLabel)(one.label) === constructor);
     }
 }

package/cjs/executor/QueryExecutor.js

@@ -6,32 +6,33 @@ const utils_js_1 = require("../utils.js");
 const Executor_js_1 = require("./Executor.js");
 class QueryExecutor extends Executor_js_1.Executor {
     doExecute(message) {
-        const meta = this.findMessage(message);
+        const meta = this.#findMessage(message);
         (0, utils_1.assert)(meta, `Query message not found: ${message}`);
         const callFn = async (...params) => {
-            // TODO verify number of arguments/params & call options presence
             const { args } = meta;
+            (0, utils_1.assert)(params.length === args.length + 1, `Expected ${args.length + 1} arguments, got ${params.length}`);
             const callOptions = params[args.length];
             const { caller, value = 0n, gasLimit, storageDepositLimit } = callOptions;
+            (0, utils_1.assert)(caller, 'Expected a valid caller address in ContractCallOptions');
             const formattedInputs = args.map((arg, index) => this.tryEncode(arg, params[index]));
             const bytes = (0, utils_1.u8aToHex)((0, utils_1.concatU8a)((0, utils_1.hexToU8a)(meta.selector), ...formattedInputs));
-            const contractResult = await this.api.call.contractsApi.call(caller, this.address, value, gasLimit, storageDepositLimit, bytes);
-            if (contractResult.result.isOk) {
-                return {
+            const raw = await this.api.call.contractsApi.call(caller, this.address, value, gasLimit, storageDepositLimit, bytes);
+            return (raw.result.isOk
+                ? {
                     isOk: true,
-                    data: this.tryDecode(meta, contractResult.result.value.data),
-                    contractResult: contractResult,
-                };
-            }
-            return {
-                isOk: false,
-                contractResult: contractResult,
-            };
+                    data: this.tryDecode(meta, raw.result.value.data),
+                    raw,
+                }
+                : {
+                    isOk: false,
+                    err: raw.result.err,
+                    raw,
+                });
         };
         callFn.meta = meta;
         return callFn;
     }
-    findMessage(message) {
+    #findMessage(message) {
         return this.metadata.spec.messages.find((one) => (0, utils_js_1.normalizeLabel)(one.label) === message);
     }
 }

package/cjs/executor/TxExecutor.js

@@ -6,13 +6,14 @@ const utils_js_1 = require("../utils.js");
 const Executor_js_1 = require("./Executor.js");
 class TxExecutor extends Executor_js_1.Executor {
     doExecute(message) {
-        const meta = this.findTxMessage(message);
+        const meta = this.#findTxMessage(message);
         (0, utils_1.assert)(meta, `Tx message not found: ${message}`);
         const callFn = (...params) => {
-            // TODO verify number of arguments/params & call options presence
             const { args } = meta;
+            (0, utils_1.assert)(params.length === args.length + 1, `Expected ${args.length + 1} arguments, got ${params.length}`);
             const txCallOptions = params[args.length];
             const { value = 0n, gasLimit, storageDepositLimit } = txCallOptions;
+            (0, utils_1.assert)(gasLimit, 'Expected a gas limit in ContractTxOptions');
             const formattedInputs = args.map((arg, index) => this.tryEncode(arg, params[index]));
             const bytes = (0, utils_1.u8aToHex)((0, utils_1.concatU8a)((0, utils_1.hexToU8a)(meta.selector), ...formattedInputs));
             return this.api.tx.contracts.call(this.address, value, gasLimit, storageDepositLimit, bytes);
@@ -20,7 +21,7 @@ class TxExecutor extends Executor_js_1.Executor {
         callFn.meta = meta;
         return callFn;
     }
-    findTxMessage(message) {
+    #findTxMessage(message) {
         return this.metadata.spec.messages.find((one) => one.mutates && (0, utils_js_1.normalizeLabel)(one.label) === message);
     }
 }

package/cjs/utils.js

@@ -6,7 +6,7 @@ const extractContractTypes = (contractMetadata) => {
     const { types } = contractMetadata;
     return types.map(({ type, id }) => ({
         id,
-        type: (0, exports.normalizeContractTypeDef)(type.def),
+        typeDef: (0, exports.normalizeContractTypeDef)(type.def),
         params: [],
         path: type?.path || [],
         docs: [],
@@ -14,10 +14,10 @@ const extractContractTypes = (contractMetadata) => {
 };
 exports.extractContractTypes = extractContractTypes;
 const normalizeContractTypeDef = (def) => {
-    let tag;
+    let type;
     let value;
     if (def.variant) {
-        tag = 'Enum';
+        type = 'Enum';
         value = {
             members: def.variant.variants?.map((variant) => ({
                 fields: variant.fields?.map((fields) => ({ typeId: fields.type, typeName: fields.typeName })) || [],
@@ -27,19 +27,19 @@ const normalizeContractTypeDef = (def) => {
         };
     }
     else if (def.tuple) {
-        tag = 'Tuple';
+        type = 'Tuple';
         value = {
             fields: def.tuple,
         };
     }
     else if (def.sequence) {
-        tag = 'Sequence';
+        type = 'Sequence';
         value = {
             typeParam: def.sequence.type,
         };
     }
     else if (def.composite) {
-        tag = 'Struct';
+        type = 'Struct';
         value = {
             fields: def.composite.fields.map((one) => ({
                 typeId: one.type,
@@ -49,13 +49,13 @@ const normalizeContractTypeDef = (def) => {
         };
     }
     else if (def.primitive) {
-        tag = 'Primitive';
+        type = 'Primitive';
         value = {
             kind: def.primitive,
         };
     }
     else if (def.array) {
-        tag = 'SizedVec';
+        type = 'SizedVec';
         value = {
             len: def.array.len,
             typeParam: def.array.type,
@@ -64,7 +64,7 @@ const normalizeContractTypeDef = (def) => {
     else {
         throw Error(`Invalid contract type def: ${JSON.stringify(def)}`);
     }
-    return { tag, value };
+    return { type, value };
 };
 exports.normalizeContractTypeDef = normalizeContractTypeDef;
 const UNSUPPORTED_VERSIONS = ['V3', 'V2', 'V1'];

package/executor/ConstructorQueryExecutor.d.ts

@@ -1,6 +1,13 @@
+import { ISubstrateClient } from '@dedot/api';
+import { Hash } from '@dedot/codecs';
 import { GenericSubstrateApi } from '@dedot/types';
+import { HexString } from '@dedot/utils';
+import { TypinkRegistry } from '../TypinkRegistry.js';
 import { GenericConstructorQueryCall } from '../types/index.js';
-import { ConstructorTxExecutor } from './ConstructorTxExecutor.js';
-export declare class ConstructorQueryExecutor<ChainApi extends GenericSubstrateApi> extends ConstructorTxExecutor<ChainApi> {
+import { Executor } from './Executor.js';
+export declare class ConstructorQueryExecutor<ChainApi extends GenericSubstrateApi> extends Executor<ChainApi> {
+    #private;
+    protected readonly code: Hash | Uint8Array | HexString | string;
+    constructor(api: ISubstrateClient<ChainApi>, registry: TypinkRegistry, code: Hash | Uint8Array | string);
     doExecute(constructor: string): GenericConstructorQueryCall<ChainApi>;
 }

package/executor/ConstructorQueryExecutor.js

@@ -1,18 +1,26 @@
 import { assert, concatU8a, hexToU8a, isWasm, u8aToHex } from '@dedot/utils';
-import { ConstructorTxExecutor } from './ConstructorTxExecutor.js';
-export class ConstructorQueryExecutor extends ConstructorTxExecutor {
+import { normalizeLabel } from '../utils.js';
+import { Executor } from './Executor.js';
+export class ConstructorQueryExecutor extends Executor {
+    code;
+    constructor(api, registry, code) {
+        super(api, registry);
+        this.code = code;
+    }
     doExecute(constructor) {
-        const meta = this.findConstructorMeta(constructor);
+        const meta = this.#findConstructorMeta(constructor);
         assert(meta, `Constructor message not found: ${constructor}`);
         const callFn = (...params) => {
-            // TODO verify number of arguments/params & call options presence
             const { args } = meta;
+            assert(params.length === args.length + 1, `Expected ${args.length + 1} arguments, got ${params.length}`);
             const callOptions = params[args.length];
             const { caller, value = 0n, gasLimit, storageDepositLimit, salt } = callOptions;
+            assert(caller, 'Expected a valid caller address in ConstructorCallOptions');
+            assert(salt, 'Expected a salt in ConstructorCallOptions');
             const formattedInputs = args.map((arg, index) => this.tryEncode(arg, params[index]));
             const bytes = u8aToHex(concatU8a(hexToU8a(meta.selector), ...formattedInputs));
             const code = {
-                tag: isWasm(this.code) ? 'Upload' : 'Existing',
+                type: isWasm(this.code) ? 'Upload' : 'Existing',
                 value: this.code,
             };
             return this.api.call.contractsApi.instantiate(caller, value, gasLimit, storageDepositLimit, code, bytes, salt);
@@ -20,4 +28,7 @@ export class ConstructorQueryExecutor extends ConstructorTxExecutor {
         callFn.meta = meta;
         return callFn;
     }
+    #findConstructorMeta(constructor) {
+        return this.metadata.spec.constructors.find((one) => normalizeLabel(one.label) === constructor);
+    }
 }

package/executor/ConstructorTxExecutor.d.ts

@@ -3,11 +3,11 @@ import { Hash } from '@dedot/codecs';
 import { GenericSubstrateApi } from '@dedot/types';
 import { HexString } from '@dedot/utils';
 import { TypinkRegistry } from '../TypinkRegistry.js';
-import { ContractConstructorMessage, GenericConstructorTxCall } from '../types/index.js';
+import { GenericConstructorTxCall } from '../types/index.js';
 import { Executor } from './Executor.js';
 export declare class ConstructorTxExecutor<ChainApi extends GenericSubstrateApi> extends Executor<ChainApi> {
+    #private;
     protected readonly code: Hash | Uint8Array | HexString | string;
     constructor(api: ISubstrateClient<ChainApi>, registry: TypinkRegistry, code: Hash | Uint8Array | string);
     doExecute(constructor: string): GenericConstructorTxCall<ChainApi>;
-    protected findConstructorMeta(constructor: string): ContractConstructorMessage | undefined;
 }

package/executor/ConstructorTxExecutor.js

@@ -8,13 +8,15 @@ export class ConstructorTxExecutor extends Executor {
         this.code = code;
     }
     doExecute(constructor) {
-        const meta = this.findConstructorMeta(constructor);
+        const meta = this.#findConstructorMeta(constructor);
         assert(meta, `Constructor message not found: ${constructor}`);
         const callFn = (...params) => {
-            // TODO verify number of arguments/params & call options presence
             const { args } = meta;
+            assert(params.length === args.length + 1, `Expected ${args.length + 1} arguments, got ${params.length}`);
             const txCallOptions = params[args.length];
             const { value = 0n, gasLimit, storageDepositLimit, salt } = txCallOptions;
+            assert(gasLimit, 'Expected a gas limit in ConstructorTxOptions');
+            assert(salt, 'Expected a salt in ConstructorTxOptions');
             const formattedInputs = args.map((arg, index) => this.tryEncode(arg, params[index]));
             const bytes = u8aToHex(concatU8a(hexToU8a(meta.selector), ...formattedInputs));
             if (isWasm(this.code)) {
@@ -27,7 +29,7 @@ export class ConstructorTxExecutor extends Executor {
         callFn.meta = meta;
         return callFn;
     }
-    findConstructorMeta(constructor) {
+    #findConstructorMeta(constructor) {
         return this.metadata.spec.constructors.find((one) => normalizeLabel(one.label) === constructor);
     }
 }

package/executor/Executor.d.ts

@@ -3,7 +3,7 @@ import { SubstrateApi } from '@dedot/api/chaintypes';
 import { AccountId32 } from '@dedot/codecs';
 import { GenericSubstrateApi, RpcVersion } from '@dedot/types';
 import { TypinkRegistry } from '../TypinkRegistry.js';
-import { ContractMessageArg, ContractMessage } from '../types/index.js';
+import { ContractMessageArg, ContractCallMessage } from '../types/index.js';
 import { ContractMetadata } from '../types/index.js';
 export declare abstract class Executor<ChainApi extends GenericSubstrateApi = SubstrateApi[RpcVersion]> {
     #private;
@@ -14,5 +14,5 @@ export declare abstract class Executor<ChainApi extends GenericSubstrateApi = Su
     get registry(): TypinkRegistry;
     abstract doExecute(...paths: string[]): unknown;
     tryEncode(param: ContractMessageArg, value: any): Uint8Array;
-    tryDecode(meta: ContractMessage, raw: any): unknown;
+    tryDecode(meta: ContractCallMessage, raw: any): unknown;
 }

package/executor/QueryExecutor.d.ts

@@ -1,7 +1,7 @@
 import { GenericSubstrateApi } from '@dedot/types';
-import { ContractMessage, GenericContractQueryCall } from '../types/index.js';
+import { GenericContractQueryCall } from '../types/index.js';
 import { Executor } from './Executor.js';
 export declare class QueryExecutor<ChainApi extends GenericSubstrateApi> extends Executor<ChainApi> {
+    #private;
     doExecute(message: string): GenericContractQueryCall<ChainApi>;
-    protected findMessage(message: string): ContractMessage | undefined;
 }

package/executor/QueryExecutor.js

@@ -3,32 +3,33 @@ import { normalizeLabel } from '../utils.js';
 import { Executor } from './Executor.js';
 export class QueryExecutor extends Executor {
     doExecute(message) {
-        const meta = this.findMessage(message);
+        const meta = this.#findMessage(message);
         assert(meta, `Query message not found: ${message}`);
         const callFn = async (...params) => {
-            // TODO verify number of arguments/params & call options presence
             const { args } = meta;
+            assert(params.length === args.length + 1, `Expected ${args.length + 1} arguments, got ${params.length}`);
             const callOptions = params[args.length];
             const { caller, value = 0n, gasLimit, storageDepositLimit } = callOptions;
+            assert(caller, 'Expected a valid caller address in ContractCallOptions');
             const formattedInputs = args.map((arg, index) => this.tryEncode(arg, params[index]));
             const bytes = u8aToHex(concatU8a(hexToU8a(meta.selector), ...formattedInputs));
-            const contractResult = await this.api.call.contractsApi.call(caller, this.address, value, gasLimit, storageDepositLimit, bytes);
-            if (contractResult.result.isOk) {
-                return {
+            const raw = await this.api.call.contractsApi.call(caller, this.address, value, gasLimit, storageDepositLimit, bytes);
+            return (raw.result.isOk
+                ? {
                     isOk: true,
-                    data: this.tryDecode(meta, contractResult.result.value.data),
-                    contractResult: contractResult,
-                };
-            }
-            return {
-                isOk: false,
-                contractResult: contractResult,
-            };
+                    data: this.tryDecode(meta, raw.result.value.data),
+                    raw,
+                }
+                : {
+                    isOk: false,
+                    err: raw.result.err,
+                    raw,
+                });
         };
         callFn.meta = meta;
         return callFn;
     }
-    findMessage(message) {
+    #findMessage(message) {
         return this.metadata.spec.messages.find((one) => normalizeLabel(one.label) === message);
     }
 }

package/executor/TxExecutor.d.ts

@@ -1,7 +1,7 @@
 import { GenericSubstrateApi } from '@dedot/types';
-import { ContractMessage, GenericContractTxCall } from '../types/index.js';
+import { GenericContractTxCall } from '../types/index.js';
 import { Executor } from './Executor.js';
 export declare class TxExecutor<ChainApi extends GenericSubstrateApi> extends Executor<ChainApi> {
+    #private;
     doExecute(message: string): GenericContractTxCall<ChainApi>;
-    protected findTxMessage(message: string): ContractMessage | undefined;
 }

package/executor/TxExecutor.js

@@ -3,13 +3,14 @@ import { normalizeLabel } from '../utils.js';
 import { Executor } from './Executor.js';
 export class TxExecutor extends Executor {
     doExecute(message) {
-        const meta = this.findTxMessage(message);
+        const meta = this.#findTxMessage(message);
         assert(meta, `Tx message not found: ${message}`);
         const callFn = (...params) => {
-            // TODO verify number of arguments/params & call options presence
             const { args } = meta;
+            assert(params.length === args.length + 1, `Expected ${args.length + 1} arguments, got ${params.length}`);
             const txCallOptions = params[args.length];
             const { value = 0n, gasLimit, storageDepositLimit } = txCallOptions;
+            assert(gasLimit, 'Expected a gas limit in ContractTxOptions');
             const formattedInputs = args.map((arg, index) => this.tryEncode(arg, params[index]));
             const bytes = u8aToHex(concatU8a(hexToU8a(meta.selector), ...formattedInputs));
             return this.api.tx.contracts.call(this.address, value, gasLimit, storageDepositLimit, bytes);
@@ -17,7 +18,7 @@ export class TxExecutor extends Executor {
         callFn.meta = meta;
         return callFn;
     }
-    findTxMessage(message) {
+    #findTxMessage(message) {
         return this.metadata.spec.messages.find((one) => one.mutates && normalizeLabel(one.label) === message);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/contracts",
-  "version": "0.0.1-alpha.34",
+  "version": "0.0.1-alpha.35",
   "description": "Delightful ink! Contract APIs",
   "author": "Tung Vu <tung@coongcrafts.io>",
   "main": "./cjs/index.js",
@@ -12,17 +12,17 @@
     "test": "vitest --watch=false"
   },
   "dependencies": {
-    "@dedot/api": "0.0.1-alpha.34",
-    "@dedot/codecs": "0.0.1-alpha.34",
-    "@dedot/types": "0.0.1-alpha.34",
-    "@dedot/utils": "0.0.1-alpha.34"
+    "@dedot/api": "0.0.1-alpha.35",
+    "@dedot/codecs": "0.0.1-alpha.35",
+    "@dedot/types": "0.0.1-alpha.35",
+    "@dedot/utils": "0.0.1-alpha.35"
   },
   "publishConfig": {
     "access": "public",
     "directory": "dist"
   },
   "license": "Apache-2.0",
-  "gitHead": "053078f3aed79a3044314421967325b9fe0e6f57",
+  "gitHead": "bf954b82ac4c8a8e1d989c0c708a099269eb4262",
   "module": "./index.js",
   "types": "./index.d.ts",
   "exports": {

package/types/index.d.ts

@@ -1,10 +1,25 @@
 import { SubstrateApi } from '@dedot/api/chaintypes';
-import { AccountId32Like, BytesLike, Weight } from '@dedot/codecs';
-import { AnyFunc, AsyncMethod, GenericSubstrateApi, RpcVersion } from '@dedot/types';
-import { ContractConstructorMessage, ContractMessage } from './shared.js';
+import { AccountId32Like, BytesLike, DispatchError, Weight } from '@dedot/codecs';
+import { AnyFunc, AsyncMethod, GenericSubstrateApi, RpcVersion, VersionedGenericSubstrateApi } from '@dedot/types';
+import { ContractCallMessage, ContractConstructorMessage } from './shared.js';
 import { ContractMetadataV4 } from './v4.js';
 import { ContractMetadataV5 } from './v5.js';
 export * from './shared.js';
+export type GenericContractCallResult<DecodedData, ContractResult> = ({
+    isOk: true;
+    data: DecodedData;
+} | {
+    isOk: false;
+    err: DispatchError;
+}) & {
+    raw: ContractResult;
+};
+export type ContractCallResult<ChainApi extends GenericSubstrateApi> = Awaited<ReturnType<ChainApi['call']['contractsApi']['call']>>;
+export type ContractInstantiateResult<ChainApi extends GenericSubstrateApi> = Awaited<ReturnType<ChainApi['call']['contractsApi']['instantiate']>>;
+export type ContractSubmittableExtrinsic<ChainApi extends GenericSubstrateApi> = ReturnType<ChainApi['tx']['contracts']['call']>;
+export type InstantiateWithCodeSubmittableExtrinsic<ChainApi extends GenericSubstrateApi> = ReturnType<ChainApi['tx']['contracts']['instantiateWithCode']>;
+export type InstantiateSubmittableExtrinsic<ChainApi extends GenericSubstrateApi> = ReturnType<ChainApi['tx']['contracts']['instantiate']>;
+export type GenericInstantiateSubmittableExtrinsic<ChainApi extends GenericSubstrateApi> = InstantiateSubmittableExtrinsic<ChainApi> | InstantiateWithCodeSubmittableExtrinsic<ChainApi>;
 export type ContractMetadata = ContractMetadataV4 | ContractMetadataV5;
 export type CallOptions = {
     value?: bigint;
@@ -25,16 +40,16 @@ export type ContractCallOptions = CallOptions & {
 export type ContractTxOptions = CallOptions & {
     gasLimit: Weight;
 };
-export type GenericContractQueryCall<_ extends GenericSubstrateApi, F extends AsyncMethod = AsyncMethod> = F & {
-    meta: ContractMessage;
+export type GenericContractQueryCall<ChainApi extends GenericSubstrateApi, F extends AsyncMethod = (...args: any[]) => Promise<GenericContractCallResult<any, ContractCallResult<ChainApi>>>> = F & {
+    meta: ContractCallMessage;
 };
-export type GenericContractTxCall<_ extends GenericSubstrateApi, F extends AnyFunc = AnyFunc> = F & {
-    meta: ContractMessage;
+export type GenericContractTxCall<ChainApi extends GenericSubstrateApi, F extends AnyFunc = (...args: any[]) => ContractSubmittableExtrinsic<ChainApi>> = F & {
+    meta: ContractCallMessage;
 };
-export type GenericConstructorQueryCall<_ extends GenericSubstrateApi, F extends AsyncMethod = AsyncMethod> = F & {
+export type GenericConstructorQueryCall<ChainApi extends GenericSubstrateApi, F extends AsyncMethod = (...args: any[]) => Promise<ContractInstantiateResult<ChainApi>>> = F & {
     meta: ContractConstructorMessage;
 };
-export type GenericConstructorTxCall<_ extends GenericSubstrateApi, F extends AnyFunc = AnyFunc> = F & {
+export type GenericConstructorTxCall<ChainApi extends GenericSubstrateApi, F extends AnyFunc = (...args: any[]) => GenericInstantiateSubmittableExtrinsic<ChainApi>> = F & {
     meta: ContractConstructorMessage;
 };
 export interface GenericContractQuery<ChainApi extends GenericSubstrateApi> {
@@ -49,9 +64,9 @@ export interface GenericConstructorQuery<ChainApi extends GenericSubstrateApi> {
 export interface GenericConstructorTx<ChainApi extends GenericSubstrateApi> {
     [method: string]: GenericConstructorTxCall<ChainApi>;
 }
-export interface GenericContractApi<ChainApi extends GenericSubstrateApi = SubstrateApi[RpcVersion]> {
-    query: GenericContractQuery<ChainApi>;
-    tx: GenericContractTx<ChainApi>;
-    constructorQuery: GenericConstructorQuery<ChainApi>;
-    constructorTx: GenericConstructorTx<ChainApi>;
+export interface GenericContractApi<Rv extends RpcVersion = RpcVersion, ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> {
+    query: GenericContractQuery<ChainApi[Rv]>;
+    tx: GenericContractTx<ChainApi[Rv]>;
+    constructorQuery: GenericConstructorQuery<ChainApi[Rv]>;
+    constructorTx: GenericConstructorTx<ChainApi[Rv]>;
 }

package/types/shared.d.ts

@@ -3,7 +3,7 @@ export interface ContractSource {
     wasm?: string;
     language: string;
     compiler: string;
-    buildInfo: BuildInfo;
+    build_info: BuildInfo;
 }
 export interface ContractInformation {
     name: string;
@@ -11,14 +11,14 @@ export interface ContractInformation {
     authors: string[];
 }
 export interface BuildInfo {
-    buildMode: string;
-    cargoContractVersion: string;
-    rustToolchain: string;
-    wasmOptSettings: WasmOptSettings;
+    build_mode: string;
+    cargo_contract_version: string;
+    rust_toolchain: string;
+    wasm_opt_settings: WasmOptSettings;
 }
 export interface WasmOptSettings {
-    keepDebugSymbols: boolean;
-    optimizationPasses: string;
+    keep_debug_symbols: boolean;
+    optimization_passes: string;
 }
 export interface ContractMessageArg {
     label: string;
@@ -28,7 +28,7 @@ export interface ContractTypeInfo {
     displayName: string[];
     type: number;
 }
-export interface ContractConstructorMessage {
+export interface ContractMessage {
     args: ContractMessageArg[];
     default: boolean;
     docs: string[];
@@ -37,15 +37,10 @@ export interface ContractConstructorMessage {
     returnType: ContractTypeInfo;
     selector: string;
 }
-export interface ContractMessage {
-    args: ContractMessageArg[];
-    default: boolean;
-    docs: string[];
-    label: string;
+export interface ContractConstructorMessage extends ContractMessage {
+}
+export interface ContractCallMessage extends ContractMessage {
     mutates: boolean;
-    payable: boolean;
-    returnType: ContractTypeInfo;
-    selector: string;
 }
 export interface ContractType {
     id: number;

package/types/v4.d.ts

@@ -1,4 +1,4 @@
-import { ContractConstructorMessage, ContractInformation, ContractMessage, ContractSource, ContractStorage, ContractType, ContractTypeInfo } from './shared.js';
+import { ContractConstructorMessage, ContractInformation, ContractCallMessage, ContractSource, ContractStorage, ContractType, ContractTypeInfo } from './shared.js';
 export interface ContractMetadataV4 {
     source: ContractSource;
     contract: ContractInformation;
@@ -12,8 +12,8 @@ export interface ContractSpecV4 {
     docs: string[];
     environment: ContractEnvironmentV4;
     events: ContractEventV4[];
-    langError: ContractTypeInfo;
-    messages: ContractMessage[];
+    lang_error: ContractTypeInfo;
+    messages: ContractCallMessage[];
 }
 export interface ContractEventV4 {
     args: unknown[];

package/utils.js

@@ -3,17 +3,17 @@ export const extractContractTypes = (contractMetadata) => {
     const { types } = contractMetadata;
     return types.map(({ type, id }) => ({
         id,
-        type: normalizeContractTypeDef(type.def),
+        typeDef: normalizeContractTypeDef(type.def),
         params: [],
         path: type?.path || [],
         docs: [],
     }));
 };
 export const normalizeContractTypeDef = (def) => {
-    let tag;
+    let type;
     let value;
     if (def.variant) {
-        tag = 'Enum';
+        type = 'Enum';
         value = {
             members: def.variant.variants?.map((variant) => ({
                 fields: variant.fields?.map((fields) => ({ typeId: fields.type, typeName: fields.typeName })) || [],
@@ -23,19 +23,19 @@ export const normalizeContractTypeDef = (def) => {
         };
     }
     else if (def.tuple) {
-        tag = 'Tuple';
+        type = 'Tuple';
         value = {
             fields: def.tuple,
         };
     }
     else if (def.sequence) {
-        tag = 'Sequence';
+        type = 'Sequence';
         value = {
             typeParam: def.sequence.type,
         };
     }
     else if (def.composite) {
-        tag = 'Struct';
+        type = 'Struct';
         value = {
             fields: def.composite.fields.map((one) => ({
                 typeId: one.type,
@@ -45,13 +45,13 @@ export const normalizeContractTypeDef = (def) => {
         };
     }
     else if (def.primitive) {
-        tag = 'Primitive';
+        type = 'Primitive';
         value = {
             kind: def.primitive,
         };
     }
     else if (def.array) {
-        tag = 'SizedVec';
+        type = 'SizedVec';
         value = {
             len: def.array.len,
             typeParam: def.array.type,
@@ -60,7 +60,7 @@ export const normalizeContractTypeDef = (def) => {
     else {
         throw Error(`Invalid contract type def: ${JSON.stringify(def)}`);
     }
-    return { tag, value };
+    return { type, value };
 };
 const UNSUPPORTED_VERSIONS = ['V3', 'V2', 'V1'];
 const SUPPORTED_VERSIONS = ['5', '4'];