@dedot/contracts 0.1.1 → 0.3.0

package/Contract.d.ts

@@ -7,6 +7,7 @@ export declare class Contract<ContractApi extends GenericContractApi = GenericCo
     #private;
     constructor(api: ISubstrateClient, metadata: ContractMetadata | string, address: AccountId32Like);
     decodeEvent(eventRecord: IEventRecord): ContractEvent;
+    decodeEvents(eventRecords: IEventRecord[]): ContractEvent[];
     get metadata(): ContractMetadata;
     get address(): AccountId32;
     get registry(): TypinkRegistry;

package/Contract.js

@@ -17,6 +17,9 @@ export class Contract {
     decodeEvent(eventRecord) {
         return this.#registry.decodeEvent(eventRecord);
     }
+    decodeEvents(eventRecords) {
+        return this.#registry.decodeEvents(eventRecords);
+    }
     get metadata() {
         return this.#metadata;
     }

package/TypinkRegistry.d.ts

@@ -5,5 +5,6 @@ export declare class TypinkRegistry extends TypeRegistry {
     #private;
     constructor(metadata: ContractMetadata);
     get metadata(): ContractMetadata;
+    decodeEvents(records: IEventRecord[]): ContractEvent[];
     decodeEvent(eventRecord: IEventRecord): ContractEvent;
 }

package/TypinkRegistry.js

@@ -11,6 +11,11 @@ export class TypinkRegistry extends TypeRegistry {
     get metadata() {
         return this.#metadata;
     }
+    decodeEvents(records) {
+        return records
+            .filter(({ event }) => this.#isContractEmittedEvent(event)) // prettier-end-here
+            .map((record) => this.decodeEvent(record));
+    }
     decodeEvent(eventRecord) {
         const { version } = this.#metadata;
         switch (version) {
@@ -22,9 +27,9 @@ export class TypinkRegistry extends TypeRegistry {
                 throw new DedotError('Unsupported metadata version!');
         }
     }
-    #isContractEmittedEvent(eventRecord) {
+    #isContractEmittedEvent(event) {
         // @ts-ignore
-        return eventRecord.pallet === 'Contracts' && eventRecord.palletEvent.name === 'ContractEmitted';
+        return event.pallet === 'Contracts' && event.palletEvent.name === 'ContractEmitted';
     }
     #decodeEventV4(eventRecord) {
         assert(this.#metadata.version === '4', 'Invalid metadata version!');

package/cjs/Contract.js

@@ -20,6 +20,9 @@ class Contract {
     decodeEvent(eventRecord) {
         return this.#registry.decodeEvent(eventRecord);
     }
+    decodeEvents(eventRecords) {
+        return this.#registry.decodeEvents(eventRecords);
+    }
     get metadata() {
         return this.#metadata;
     }

package/cjs/TypinkRegistry.js

@@ -37,6 +37,11 @@ class TypinkRegistry extends codecs_1.TypeRegistry {
     get metadata() {
         return this.#metadata;
     }
+    decodeEvents(records) {
+        return records
+            .filter(({ event }) => this.#isContractEmittedEvent(event)) // prettier-end-here
+            .map((record) => this.decodeEvent(record));
+    }
     decodeEvent(eventRecord) {
         const { version } = this.#metadata;
         switch (version) {
@@ -48,9 +53,9 @@ class TypinkRegistry extends codecs_1.TypeRegistry {
                 throw new utils_1.DedotError('Unsupported metadata version!');
         }
     }
-    #isContractEmittedEvent(eventRecord) {
+    #isContractEmittedEvent(event) {
         // @ts-ignore
-        return eventRecord.pallet === 'Contracts' && eventRecord.palletEvent.name === 'ContractEmitted';
+        return event.pallet === 'Contracts' && event.palletEvent.name === 'ContractEmitted';
     }
     #decodeEventV4(eventRecord) {
         (0, utils_1.assert)(this.#metadata.version === '4', 'Invalid metadata version!');

package/cjs/errors.js

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isContractInstantiateLangError = exports.isContractInstantiateDispatchError = exports.isContractInstantiateError = exports.isContractLangError = exports.isContractDispatchError = exports.isContractExecutionError = exports.ContractLangError = exports.ContractDispatchError = exports.ContractExecutionError = exports.ContractInstantiateLangError = exports.ContractInstantiateDispatchError = exports.ContractInstantiateError = void 0;
+const utils_1 = require("@dedot/utils");
+const utils_js_1 = require("./utils.js");
+/**
+ * Represents an error that occurred during the instantiation of a smart contract.
+ * This class extends the base `DedotError` and includes a `raw` property of type `ContractInstantiateResult`.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @extends DedotError
+ */
+class ContractInstantiateError extends utils_1.DedotError {
+    /**
+     * The raw result of the contract instantiation.
+     */
+    raw;
+    /**
+     * Constructs a new `ContractInstantiateError` instance.
+     *
+     * @param raw - The raw result of the contract instantiation.
+     */
+    constructor(raw) {
+        super();
+        this.raw = raw;
+    }
+}
+exports.ContractInstantiateError = ContractInstantiateError;
+/**
+ * Represents an error that occurred during the dispatch phase of contract instantiation.
+ * This class extends `ContractInstantiateError` and includes a `DispatchError` property.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @extends ContractInstantiateError
+ */
+class ContractInstantiateDispatchError extends ContractInstantiateError {
+    /**
+     * The error that occurred during the dispatch phase.
+     */
+    dispatchError;
+    /**
+     * Constructs a new `ContractInstantiateDispatchError` instance.
+     *
+     * @param err - The `DispatchError` that occurred during the dispatch phase.
+     * @param raw - The raw result of the contract instantiation.
+     */
+    constructor(err, raw) {
+        super(raw);
+        this.dispatchError = err;
+    }
+}
+exports.ContractInstantiateDispatchError = ContractInstantiateDispatchError;
+/**
+ * Represents an error that occurred during the instantiation of a smart contract due to a language-specific error.
+ * This class extends `ContractInstantiateError` and includes a `LangError` property.
+ *
+ * Ref: https://use.ink/faq/migrating-from-ink-3-to-4#:~:text=Add%20support%20for,equivalent%20LangError.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @extends ContractInstantiateError
+ */
+class ContractInstantiateLangError extends ContractInstantiateError {
+    /**
+     * The language-specific error that occurred during the instantiation.
+     */
+    langError;
+    /**
+     * Decoded `ReturnFlags` from contract call result.
+     */
+    flags;
+    /**
+     * Constructs a new `ContractInstantiateLangError` instance.
+     *
+     * @param err - The `LangError` that occurred during the instantiation phase.
+     * @param raw - The raw result of the contract instantiation.
+     */
+    constructor(err, raw) {
+        (0, utils_1.assert)(raw.result.isOk, 'Should not throw DispatchError!');
+        super(raw);
+        this.langError = err;
+        this.flags = (0, utils_js_1.toReturnFlags)(raw.result.value.result.flags.bits);
+    }
+}
+exports.ContractInstantiateLangError = ContractInstantiateLangError;
+/**
+ * Represents an error that occurred during the execution of a smart contract call.
+ * This class extends the base `DedotError` and includes a `raw` property of type `ContractCallResult`.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @extends DedotError
+ */
+class ContractExecutionError extends utils_1.DedotError {
+    /**
+     * The raw result of the contract call.
+     */
+    raw;
+    /**
+     * Constructs a new `ContractExecutionError` instance.
+     *
+     * @param raw - The raw result of the contract call.
+     */
+    constructor(raw) {
+        super();
+        this.raw = raw;
+    }
+}
+exports.ContractExecutionError = ContractExecutionError;
+/**
+ * Represents an error that occurred during the execution of a smart contract call due to a dispatch error.
+ * This class extends `ContractExecutionError` and includes a `DispatchError` property.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @extends ContractExecutionError
+ */
+class ContractDispatchError extends ContractExecutionError {
+    /**
+     * The error that occurred during the dispatch phase.
+     */
+    dispatchError;
+    /**
+     * Constructs a new `ContractDispatchError` instance.
+     *
+     * @param err - The `DispatchError` that occurred during the dispatch phase.
+     * @param raw - The raw result of the contract call.
+     */
+    constructor(err, raw) {
+        super(raw);
+        this.dispatchError = err;
+    }
+}
+exports.ContractDispatchError = ContractDispatchError;
+/**
+ * Represents an error that occurred during the execution of a smart contract call due to a language-specific error.
+ * This class extends `ContractExecutionError` and includes a `LangError` property.
+ *
+ * Ref: https://use.ink/faq/migrating-from-ink-3-to-4#:~:text=Add%20support%20for,equivalent%20LangError.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @extends ContractExecutionError
+ */
+class ContractLangError extends ContractExecutionError {
+    /**
+     * The language-specific error that occurred during the execution.
+     */
+    langError;
+    /**
+     * Decoded `ReturnFlags` from contract call result.
+     */
+    flags;
+    /**
+     * Constructs a new `ContractLangError` instance.
+     *
+     * @param err - The `LangError` that occurred during the execution phase.
+     * @param raw - The raw result of the contract call.
+     */
+    constructor(err, raw) {
+        (0, utils_1.assert)(raw.result.isOk, 'Should not throw DispatchError!');
+        super(raw);
+        this.langError = err;
+        this.flags = (0, utils_js_1.toReturnFlags)(raw.result.value.flags.bits);
+    }
+}
+exports.ContractLangError = ContractLangError;
+/**
+ * Checks if the provided error is an instance of `ContractExecutionError`.
+ *
+ * This function is used to determine if a given error is a result of an execution error during a smart contract call.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @param e - The error to be checked.
+ *
+ * @returns `true` if the error is an instance of `ContractExecutionError`, `false` otherwise.
+ */
+function isContractExecutionError(e) {
+    return e instanceof ContractExecutionError;
+}
+exports.isContractExecutionError = isContractExecutionError;
+/**
+ * Checks if the provided error is an instance of `ContractDispatchError`.
+ *
+ * This function is used to determine if a given error is a result of a dispatch error during a smart contract call.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @param e - The error to be checked. This should be an instance of `Error`.
+ *
+ * @returns `true` if the error is an instance of `ContractDispatchError`, `false` otherwise.
+ *          This function returns a boolean value indicating whether the provided error is of type `ContractDispatchError`.
+ */
+function isContractDispatchError(e) {
+    return e instanceof ContractDispatchError;
+}
+exports.isContractDispatchError = isContractDispatchError;
+/**
+ * Checks if the provided error is an instance of `ContractLangError`.
+ *
+ * This function is used to determine if a given error is a result of a language-specific error during a smart contract call.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @param e - The error to be checked. This should be an instance of `Error`.
+ *
+ * @returns `true` if the error is an instance of `ContractLangError`, `false` otherwise.
+ *          This function returns a boolean value indicating whether the provided error is of type `ContractLangError`.
+ */
+function isContractLangError(e) {
+    return e instanceof ContractLangError;
+}
+exports.isContractLangError = isContractLangError;
+/**
+ * Checks if the provided error is an instance of `ContractInstantiateError`.
+ *
+ * This function is used to determine if a given error is a result of an execution error during the instantiation of a smart contract.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @param e - The error to be checked. This should be an instance of `Error`.
+ *
+ * @returns `true` if the error is an instance of `ContractInstantiateError`, `false` otherwise.
+ *          This function returns a boolean value indicating whether the provided error is of type `ContractInstantiateError`.
+ */
+function isContractInstantiateError(e) {
+    return e instanceof ContractInstantiateError;
+}
+exports.isContractInstantiateError = isContractInstantiateError;
+/**
+ * Checks if the provided error is an instance of `ContractInstantiateDispatchError`.
+ *
+ * This function is used to determine if a given error is a result of a dispatch error during the instantiation of a smart contract.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @param e - The error to be checked. This should be an instance of `Error`.
+ *
+ * @returns `true` if the error is an instance of `ContractInstantiateDispatchError`, `false` otherwise.
+ *          This function returns a boolean value indicating whether the provided error is of type `ContractInstantiateDispatchError`.
+ */
+function isContractInstantiateDispatchError(e) {
+    return e instanceof ContractInstantiateDispatchError;
+}
+exports.isContractInstantiateDispatchError = isContractInstantiateDispatchError;
+/**
+ * Checks if the provided error is an instance of `ContractInstantiateLangError`.
+ *
+ * This function is used to determine if a given error is a result of a language-specific error during the instantiation of a smart contract.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @param e - The error to be checked. This should be an instance of `Error`.
+ *
+ * @returns `true` if the error is an instance of `ContractInstantiateLangError`, `false` otherwise.
+ *          This function returns a boolean value indicating whether the provided error is of type `ContractInstantiateLangError`.
+ */
+function isContractInstantiateLangError(e) {
+    return e instanceof ContractInstantiateLangError;
+}
+exports.isContractInstantiateLangError = isContractInstantiateLangError;

package/cjs/executor/ConstructorQueryExecutor.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConstructorQueryExecutor = void 0;
 const utils_1 = require("@dedot/utils");
+const errors_js_1 = require("../errors.js");
 const utils_js_1 = require("../utils.js");
 const Executor_js_1 = require("./Executor.js");
 class ConstructorQueryExecutor extends Executor_js_1.Executor {
@@ -13,7 +14,7 @@ class ConstructorQueryExecutor extends Executor_js_1.Executor {
     doExecute(constructor) {
         const meta = this.#findConstructorMeta(constructor);
         (0, utils_1.assert)(meta, `Constructor message not found: ${constructor}`);
-        const callFn = (...params) => {
+        const callFn = async (...params) => {
             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];
@@ -26,7 +27,21 @@ class ConstructorQueryExecutor extends Executor_js_1.Executor {
                 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);
+            const raw = await this.api.call.contractsApi.instantiate(caller, value, gasLimit, storageDepositLimit, code, bytes, salt);
+            if (raw.result.isErr) {
+                throw new errors_js_1.ContractInstantiateDispatchError(raw.result.err, raw);
+            }
+            const data = this.tryDecode(meta, raw.result.value.result.data);
+            if (data.isErr) {
+                throw new errors_js_1.ContractInstantiateLangError(data.err, raw);
+            }
+            const bits = raw.result.value.result.flags.bits;
+            return {
+                data: data.value,
+                raw,
+                address: raw.result.value.accountId,
+                flags: (0, utils_js_1.toReturnFlags)(bits),
+            };
         };
         callFn.meta = meta;
         return callFn;

package/cjs/executor/EventExecutor.js

@@ -1,26 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventExecutor = void 0;
-const Executor_js_1 = require("./Executor.js");
+const api_1 = require("@dedot/api");
 const utils_1 = require("@dedot/utils");
+const Executor_js_1 = require("./Executor.js");
 class EventExecutor extends Executor_js_1.Executor {
     doExecute(eventName) {
-        const eventMeta = this.#findEventMeta(eventName);
-        (0, utils_1.assert)(eventMeta, "Contract event metadata not found!");
+        const meta = this.#findEventMeta(eventName);
+        (0, utils_1.assert)(meta, 'Contract event metadata not found!');
         const is = (event) => {
+            if ((0, api_1.isEventRecord)(event)) {
+                try {
+                    event = this.registry.decodeEvent(event);
+                }
+                catch {
+                    return false;
+                }
+            }
             return event.name === eventName;
         };
-        const as = (event) => {
-            return is(event) ? event : undefined;
+        const find = (events) => {
+            if (!events || events.length === 0)
+                return undefined;
+            if ((0, api_1.isEventRecord)(events[0])) {
+                return this.registry.decodeEvents(events).find(is);
+            }
+            else {
+                return events.find(is);
+            }
+        };
+        const filter = (events) => {
+            if ((0, api_1.isEventRecord)(events[0])) {
+                return this.registry.decodeEvents(events).filter(is);
+            }
+            else {
+                return events.filter(is);
+            }
         };
         return {
             is,
-            as,
-            meta: eventMeta,
+            find,
+            filter,
+            meta,
         };
     }
     #findEventMeta(eventName) {
-        return this.registry.metadata.spec.events.find(one => (0, utils_1.stringPascalCase)(one.label) === eventName);
+        return this.registry.metadata.spec.events.find((one) => (0, utils_1.stringPascalCase)(one.label) === eventName);
     }
 }
 exports.EventExecutor = EventExecutor;

package/cjs/executor/QueryExecutor.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryExecutor = void 0;
 const utils_1 = require("@dedot/utils");
+const errors_js_1 = require("../errors.js");
 const utils_js_1 = require("../utils.js");
 const Executor_js_1 = require("./Executor.js");
 class QueryExecutor extends Executor_js_1.Executor {
@@ -17,17 +18,19 @@ class QueryExecutor extends Executor_js_1.Executor {
             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 raw = await this.api.call.contractsApi.call(caller, this.address, value, gasLimit, storageDepositLimit, bytes);
-            return (raw.result.isOk
-                ? {
-                    isOk: true,
-                    data: this.tryDecode(meta, raw.result.value.data),
-                    raw,
-                }
-                : {
-                    isOk: false,
-                    err: raw.result.err,
-                    raw,
-                });
+            if (raw.result.isErr) {
+                throw new errors_js_1.ContractDispatchError(raw.result.err, raw);
+            }
+            const data = this.tryDecode(meta, raw.result.value.data);
+            if (data.isErr) {
+                throw new errors_js_1.ContractLangError(data.err, raw);
+            }
+            const bits = raw.result.value.flags.bits;
+            return {
+                data: data.value,
+                raw,
+                flags: (0, utils_js_1.toReturnFlags)(bits),
+            };
         };
         callFn.meta = meta;
         return callFn;

package/cjs/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./utils.js"), exports);
+__exportStar(require("./errors.js"), exports);
 __exportStar(require("./executor/index.js"), exports);
 __exportStar(require("./types/index.js"), exports);
 __exportStar(require("./TypinkRegistry.js"), exports);

package/cjs/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeLabel = exports.ensureSupportContractsPallet = exports.newProxyChain = exports.parseRawMetadata = exports.normalizeContractTypeDef = exports.extractContractTypes = void 0;
+exports.toReturnFlags = exports.normalizeLabel = exports.ensureSupportContractsPallet = exports.newProxyChain = exports.parseRawMetadata = exports.normalizeContractTypeDef = exports.extractContractTypes = void 0;
 const utils_1 = require("@dedot/utils");
 const extractContractTypes = (contractMetadata) => {
     const { types } = contractMetadata;
@@ -106,3 +106,12 @@ function normalizeLabel(label) {
     return (0, utils_1.stringCamelCase)(label.replaceAll('::', '_'));
 }
 exports.normalizeLabel = normalizeLabel;
+// https://github.com/paritytech/polkadot-sdk/blob/d2fd53645654d3b8e12cbf735b67b93078d70113/substrate/frame/contracts/uapi/src/flags.rs#L23-L26
+const REVERT_FLAG = 1;
+function toReturnFlags(bits) {
+    return {
+        bits,
+        revert: bits === REVERT_FLAG,
+    };
+}
+exports.toReturnFlags = toReturnFlags;

package/errors.d.ts

@@ -0,0 +1,216 @@
+import { DispatchError } from '@dedot/codecs';
+import { DedotError } from '@dedot/utils';
+import { ContractCallResult, ContractInstantiateResult, GenericContractApi, ReturnFlags } from './types/index.js';
+/**
+ * Represents an error that occurred during the instantiation of a smart contract.
+ * This class extends the base `DedotError` and includes a `raw` property of type `ContractInstantiateResult`.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @extends DedotError
+ */
+export declare class ContractInstantiateError<ContractApi extends GenericContractApi = GenericContractApi> extends DedotError {
+    /**
+     * The raw result of the contract instantiation.
+     */
+    raw: ContractInstantiateResult<ContractApi['types']['ChainApi']>;
+    /**
+     * Constructs a new `ContractInstantiateError` instance.
+     *
+     * @param raw - The raw result of the contract instantiation.
+     */
+    constructor(raw: ContractInstantiateResult<ContractApi['types']['ChainApi']>);
+}
+/**
+ * Represents an error that occurred during the dispatch phase of contract instantiation.
+ * This class extends `ContractInstantiateError` and includes a `DispatchError` property.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @extends ContractInstantiateError
+ */
+export declare class ContractInstantiateDispatchError<ContractApi extends GenericContractApi = GenericContractApi> extends ContractInstantiateError<ContractApi> {
+    /**
+     * The error that occurred during the dispatch phase.
+     */
+    dispatchError: DispatchError;
+    /**
+     * Constructs a new `ContractInstantiateDispatchError` instance.
+     *
+     * @param err - The `DispatchError` that occurred during the dispatch phase.
+     * @param raw - The raw result of the contract instantiation.
+     */
+    constructor(err: DispatchError, raw: ContractInstantiateResult<ContractApi['types']['ChainApi']>);
+}
+/**
+ * Represents an error that occurred during the instantiation of a smart contract due to a language-specific error.
+ * This class extends `ContractInstantiateError` and includes a `LangError` property.
+ *
+ * Ref: https://use.ink/faq/migrating-from-ink-3-to-4#:~:text=Add%20support%20for,equivalent%20LangError.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @extends ContractInstantiateError
+ */
+export declare class ContractInstantiateLangError<ContractApi extends GenericContractApi = GenericContractApi> extends ContractInstantiateError<ContractApi> {
+    /**
+     * The language-specific error that occurred during the instantiation.
+     */
+    langError: ContractApi['types']['LangError'];
+    /**
+     * Decoded `ReturnFlags` from contract call result.
+     */
+    flags: ReturnFlags;
+    /**
+     * Constructs a new `ContractInstantiateLangError` instance.
+     *
+     * @param err - The `LangError` that occurred during the instantiation phase.
+     * @param raw - The raw result of the contract instantiation.
+     */
+    constructor(err: ContractApi['types']['LangError'], raw: ContractInstantiateResult<ContractApi['types']['ChainApi']>);
+}
+/**
+ * Represents an error that occurred during the execution of a smart contract call.
+ * This class extends the base `DedotError` and includes a `raw` property of type `ContractCallResult`.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @extends DedotError
+ */
+export declare class ContractExecutionError<ContractApi extends GenericContractApi = GenericContractApi> extends DedotError {
+    /**
+     * The raw result of the contract call.
+     */
+    raw: ContractCallResult<ContractApi['types']['ChainApi']>;
+    /**
+     * Constructs a new `ContractExecutionError` instance.
+     *
+     * @param raw - The raw result of the contract call.
+     */
+    constructor(raw: ContractCallResult<ContractApi['types']['ChainApi']>);
+}
+/**
+ * Represents an error that occurred during the execution of a smart contract call due to a dispatch error.
+ * This class extends `ContractExecutionError` and includes a `DispatchError` property.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @extends ContractExecutionError
+ */
+export declare class ContractDispatchError<ContractApi extends GenericContractApi = GenericContractApi> extends ContractExecutionError<ContractApi> {
+    /**
+     * The error that occurred during the dispatch phase.
+     */
+    dispatchError: DispatchError;
+    /**
+     * Constructs a new `ContractDispatchError` instance.
+     *
+     * @param err - The `DispatchError` that occurred during the dispatch phase.
+     * @param raw - The raw result of the contract call.
+     */
+    constructor(err: DispatchError, raw: ContractCallResult<ContractApi['types']['ChainApi']>);
+}
+/**
+ * Represents an error that occurred during the execution of a smart contract call due to a language-specific error.
+ * This class extends `ContractExecutionError` and includes a `LangError` property.
+ *
+ * Ref: https://use.ink/faq/migrating-from-ink-3-to-4#:~:text=Add%20support%20for,equivalent%20LangError.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @extends ContractExecutionError
+ */
+export declare class ContractLangError<ContractApi extends GenericContractApi = GenericContractApi> extends ContractExecutionError<ContractApi> {
+    /**
+     * The language-specific error that occurred during the execution.
+     */
+    langError: ContractApi['types']['LangError'];
+    /**
+     * Decoded `ReturnFlags` from contract call result.
+     */
+    flags: ReturnFlags;
+    /**
+     * Constructs a new `ContractLangError` instance.
+     *
+     * @param err - The `LangError` that occurred during the execution phase.
+     * @param raw - The raw result of the contract call.
+     */
+    constructor(err: ContractApi['types']['LangError'], raw: ContractCallResult<ContractApi['types']['ChainApi']>);
+}
+/**
+ * Checks if the provided error is an instance of `ContractExecutionError`.
+ *
+ * This function is used to determine if a given error is a result of an execution error during a smart contract call.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @param e - The error to be checked.
+ *
+ * @returns `true` if the error is an instance of `ContractExecutionError`, `false` otherwise.
+ */
+export declare function isContractExecutionError<ContractApi extends GenericContractApi = GenericContractApi>(e: Error): e is ContractExecutionError<ContractApi>;
+/**
+ * Checks if the provided error is an instance of `ContractDispatchError`.
+ *
+ * This function is used to determine if a given error is a result of a dispatch error during a smart contract call.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @param e - The error to be checked. This should be an instance of `Error`.
+ *
+ * @returns `true` if the error is an instance of `ContractDispatchError`, `false` otherwise.
+ *          This function returns a boolean value indicating whether the provided error is of type `ContractDispatchError`.
+ */
+export declare function isContractDispatchError<ContractApi extends GenericContractApi = GenericContractApi>(e: Error): e is ContractDispatchError<ContractApi>;
+/**
+ * Checks if the provided error is an instance of `ContractLangError`.
+ *
+ * This function is used to determine if a given error is a result of a language-specific error during a smart contract call.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @param e - The error to be checked. This should be an instance of `Error`.
+ *
+ * @returns `true` if the error is an instance of `ContractLangError`, `false` otherwise.
+ *          This function returns a boolean value indicating whether the provided error is of type `ContractLangError`.
+ */
+export declare function isContractLangError<ContractApi extends GenericContractApi = GenericContractApi>(e: Error): e is ContractLangError<ContractApi>;
+/**
+ * Checks if the provided error is an instance of `ContractInstantiateError`.
+ *
+ * This function is used to determine if a given error is a result of an execution error during the instantiation of a smart contract.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @param e - The error to be checked. This should be an instance of `Error`.
+ *
+ * @returns `true` if the error is an instance of `ContractInstantiateError`, `false` otherwise.
+ *          This function returns a boolean value indicating whether the provided error is of type `ContractInstantiateError`.
+ */
+export declare function isContractInstantiateError<ContractApi extends GenericContractApi = GenericContractApi>(e: Error): e is ContractInstantiateError<ContractApi>;
+/**
+ * Checks if the provided error is an instance of `ContractInstantiateDispatchError`.
+ *
+ * This function is used to determine if a given error is a result of a dispatch error during the instantiation of a smart contract.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @param e - The error to be checked. This should be an instance of `Error`.
+ *
+ * @returns `true` if the error is an instance of `ContractInstantiateDispatchError`, `false` otherwise.
+ *          This function returns a boolean value indicating whether the provided error is of type `ContractInstantiateDispatchError`.
+ */
+export declare function isContractInstantiateDispatchError<ContractApi extends GenericContractApi = GenericContractApi>(e: Error): e is ContractInstantiateDispatchError<ContractApi>;
+/**
+ * Checks if the provided error is an instance of `ContractInstantiateLangError`.
+ *
+ * This function is used to determine if a given error is a result of a language-specific error during the instantiation of a smart contract.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @param e - The error to be checked. This should be an instance of `Error`.
+ *
+ * @returns `true` if the error is an instance of `ContractInstantiateLangError`, `false` otherwise.
+ *          This function returns a boolean value indicating whether the provided error is of type `ContractInstantiateLangError`.
+ */
+export declare function isContractInstantiateLangError<ContractApi extends GenericContractApi = GenericContractApi>(e: Error): e is ContractInstantiateLangError<ContractApi>;

package/errors.js

@@ -0,0 +1,249 @@
+import { DedotError, assert } from '@dedot/utils';
+import { toReturnFlags } from './utils.js';
+/**
+ * Represents an error that occurred during the instantiation of a smart contract.
+ * This class extends the base `DedotError` and includes a `raw` property of type `ContractInstantiateResult`.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @extends DedotError
+ */
+export class ContractInstantiateError extends DedotError {
+    /**
+     * The raw result of the contract instantiation.
+     */
+    raw;
+    /**
+     * Constructs a new `ContractInstantiateError` instance.
+     *
+     * @param raw - The raw result of the contract instantiation.
+     */
+    constructor(raw) {
+        super();
+        this.raw = raw;
+    }
+}
+/**
+ * Represents an error that occurred during the dispatch phase of contract instantiation.
+ * This class extends `ContractInstantiateError` and includes a `DispatchError` property.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @extends ContractInstantiateError
+ */
+export class ContractInstantiateDispatchError extends ContractInstantiateError {
+    /**
+     * The error that occurred during the dispatch phase.
+     */
+    dispatchError;
+    /**
+     * Constructs a new `ContractInstantiateDispatchError` instance.
+     *
+     * @param err - The `DispatchError` that occurred during the dispatch phase.
+     * @param raw - The raw result of the contract instantiation.
+     */
+    constructor(err, raw) {
+        super(raw);
+        this.dispatchError = err;
+    }
+}
+/**
+ * Represents an error that occurred during the instantiation of a smart contract due to a language-specific error.
+ * This class extends `ContractInstantiateError` and includes a `LangError` property.
+ *
+ * Ref: https://use.ink/faq/migrating-from-ink-3-to-4#:~:text=Add%20support%20for,equivalent%20LangError.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @extends ContractInstantiateError
+ */
+export class ContractInstantiateLangError extends ContractInstantiateError {
+    /**
+     * The language-specific error that occurred during the instantiation.
+     */
+    langError;
+    /**
+     * Decoded `ReturnFlags` from contract call result.
+     */
+    flags;
+    /**
+     * Constructs a new `ContractInstantiateLangError` instance.
+     *
+     * @param err - The `LangError` that occurred during the instantiation phase.
+     * @param raw - The raw result of the contract instantiation.
+     */
+    constructor(err, raw) {
+        assert(raw.result.isOk, 'Should not throw DispatchError!');
+        super(raw);
+        this.langError = err;
+        this.flags = toReturnFlags(raw.result.value.result.flags.bits);
+    }
+}
+/**
+ * Represents an error that occurred during the execution of a smart contract call.
+ * This class extends the base `DedotError` and includes a `raw` property of type `ContractCallResult`.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @extends DedotError
+ */
+export class ContractExecutionError extends DedotError {
+    /**
+     * The raw result of the contract call.
+     */
+    raw;
+    /**
+     * Constructs a new `ContractExecutionError` instance.
+     *
+     * @param raw - The raw result of the contract call.
+     */
+    constructor(raw) {
+        super();
+        this.raw = raw;
+    }
+}
+/**
+ * Represents an error that occurred during the execution of a smart contract call due to a dispatch error.
+ * This class extends `ContractExecutionError` and includes a `DispatchError` property.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @extends ContractExecutionError
+ */
+export class ContractDispatchError extends ContractExecutionError {
+    /**
+     * The error that occurred during the dispatch phase.
+     */
+    dispatchError;
+    /**
+     * Constructs a new `ContractDispatchError` instance.
+     *
+     * @param err - The `DispatchError` that occurred during the dispatch phase.
+     * @param raw - The raw result of the contract call.
+     */
+    constructor(err, raw) {
+        super(raw);
+        this.dispatchError = err;
+    }
+}
+/**
+ * Represents an error that occurred during the execution of a smart contract call due to a language-specific error.
+ * This class extends `ContractExecutionError` and includes a `LangError` property.
+ *
+ * Ref: https://use.ink/faq/migrating-from-ink-3-to-4#:~:text=Add%20support%20for,equivalent%20LangError.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @extends ContractExecutionError
+ */
+export class ContractLangError extends ContractExecutionError {
+    /**
+     * The language-specific error that occurred during the execution.
+     */
+    langError;
+    /**
+     * Decoded `ReturnFlags` from contract call result.
+     */
+    flags;
+    /**
+     * Constructs a new `ContractLangError` instance.
+     *
+     * @param err - The `LangError` that occurred during the execution phase.
+     * @param raw - The raw result of the contract call.
+     */
+    constructor(err, raw) {
+        assert(raw.result.isOk, 'Should not throw DispatchError!');
+        super(raw);
+        this.langError = err;
+        this.flags = toReturnFlags(raw.result.value.flags.bits);
+    }
+}
+/**
+ * Checks if the provided error is an instance of `ContractExecutionError`.
+ *
+ * This function is used to determine if a given error is a result of an execution error during a smart contract call.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @param e - The error to be checked.
+ *
+ * @returns `true` if the error is an instance of `ContractExecutionError`, `false` otherwise.
+ */
+export function isContractExecutionError(e) {
+    return e instanceof ContractExecutionError;
+}
+/**
+ * Checks if the provided error is an instance of `ContractDispatchError`.
+ *
+ * This function is used to determine if a given error is a result of a dispatch error during a smart contract call.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @param e - The error to be checked. This should be an instance of `Error`.
+ *
+ * @returns `true` if the error is an instance of `ContractDispatchError`, `false` otherwise.
+ *          This function returns a boolean value indicating whether the provided error is of type `ContractDispatchError`.
+ */
+export function isContractDispatchError(e) {
+    return e instanceof ContractDispatchError;
+}
+/**
+ * Checks if the provided error is an instance of `ContractLangError`.
+ *
+ * This function is used to determine if a given error is a result of a language-specific error during a smart contract call.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @param e - The error to be checked. This should be an instance of `Error`.
+ *
+ * @returns `true` if the error is an instance of `ContractLangError`, `false` otherwise.
+ *          This function returns a boolean value indicating whether the provided error is of type `ContractLangError`.
+ */
+export function isContractLangError(e) {
+    return e instanceof ContractLangError;
+}
+/**
+ * Checks if the provided error is an instance of `ContractInstantiateError`.
+ *
+ * This function is used to determine if a given error is a result of an execution error during the instantiation of a smart contract.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @param e - The error to be checked. This should be an instance of `Error`.
+ *
+ * @returns `true` if the error is an instance of `ContractInstantiateError`, `false` otherwise.
+ *          This function returns a boolean value indicating whether the provided error is of type `ContractInstantiateError`.
+ */
+export function isContractInstantiateError(e) {
+    return e instanceof ContractInstantiateError;
+}
+/**
+ * Checks if the provided error is an instance of `ContractInstantiateDispatchError`.
+ *
+ * This function is used to determine if a given error is a result of a dispatch error during the instantiation of a smart contract.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @param e - The error to be checked. This should be an instance of `Error`.
+ *
+ * @returns `true` if the error is an instance of `ContractInstantiateDispatchError`, `false` otherwise.
+ *          This function returns a boolean value indicating whether the provided error is of type `ContractInstantiateDispatchError`.
+ */
+export function isContractInstantiateDispatchError(e) {
+    return e instanceof ContractInstantiateDispatchError;
+}
+/**
+ * Checks if the provided error is an instance of `ContractInstantiateLangError`.
+ *
+ * This function is used to determine if a given error is a result of a language-specific error during the instantiation of a smart contract.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `GenericContractApi`.
+ *
+ * @param e - The error to be checked. This should be an instance of `Error`.
+ *
+ * @returns `true` if the error is an instance of `ContractInstantiateLangError`, `false` otherwise.
+ *          This function returns a boolean value indicating whether the provided error is of type `ContractInstantiateLangError`.
+ */
+export function isContractInstantiateLangError(e) {
+    return e instanceof ContractInstantiateLangError;
+}

package/executor/ConstructorQueryExecutor.js

@@ -1,5 +1,6 @@
 import { assert, concatU8a, hexToU8a, isWasm, u8aToHex } from '@dedot/utils';
-import { normalizeLabel } from '../utils.js';
+import { ContractInstantiateDispatchError, ContractInstantiateLangError } from '../errors.js';
+import { normalizeLabel, toReturnFlags } from '../utils.js';
 import { Executor } from './Executor.js';
 export class ConstructorQueryExecutor extends Executor {
     code;
@@ -10,7 +11,7 @@ export class ConstructorQueryExecutor extends Executor {
     doExecute(constructor) {
         const meta = this.#findConstructorMeta(constructor);
         assert(meta, `Constructor message not found: ${constructor}`);
-        const callFn = (...params) => {
+        const callFn = async (...params) => {
             const { args } = meta;
             assert(params.length === args.length + 1, `Expected ${args.length + 1} arguments, got ${params.length}`);
             const callOptions = params[args.length];
@@ -23,7 +24,21 @@ export class ConstructorQueryExecutor extends Executor {
                 type: isWasm(this.code) ? 'Upload' : 'Existing',
                 value: this.code,
             };
-            return this.api.call.contractsApi.instantiate(caller, value, gasLimit, storageDepositLimit, code, bytes, salt);
+            const raw = await this.api.call.contractsApi.instantiate(caller, value, gasLimit, storageDepositLimit, code, bytes, salt);
+            if (raw.result.isErr) {
+                throw new ContractInstantiateDispatchError(raw.result.err, raw);
+            }
+            const data = this.tryDecode(meta, raw.result.value.result.data);
+            if (data.isErr) {
+                throw new ContractInstantiateLangError(data.err, raw);
+            }
+            const bits = raw.result.value.result.flags.bits;
+            return {
+                data: data.value,
+                raw,
+                address: raw.result.value.accountId,
+                flags: toReturnFlags(bits),
+            };
         };
         callFn.meta = meta;
         return callFn;

package/executor/EventExecutor.d.ts

@@ -1,6 +1,6 @@
-import { GenericSubstrateApi } from "@dedot/types";
-import { Executor } from "./Executor.js";
-import { GenericContractEvent } from "../types/index.js";
+import { GenericSubstrateApi } from '@dedot/types';
+import { GenericContractEvent } from '../types/index.js';
+import { Executor } from './Executor.js';
 export declare class EventExecutor<ChainApi extends GenericSubstrateApi> extends Executor<ChainApi> {
     #private;
     doExecute(eventName: string): GenericContractEvent;

package/executor/EventExecutor.js

@@ -1,22 +1,47 @@
-import { Executor } from "./Executor.js";
-import { assert, stringPascalCase } from "@dedot/utils";
+import { isEventRecord } from '@dedot/api';
+import { assert, stringPascalCase } from '@dedot/utils';
+import { Executor } from './Executor.js';
 export class EventExecutor extends Executor {
     doExecute(eventName) {
-        const eventMeta = this.#findEventMeta(eventName);
-        assert(eventMeta, "Contract event metadata not found!");
+        const meta = this.#findEventMeta(eventName);
+        assert(meta, 'Contract event metadata not found!');
         const is = (event) => {
+            if (isEventRecord(event)) {
+                try {
+                    event = this.registry.decodeEvent(event);
+                }
+                catch {
+                    return false;
+                }
+            }
             return event.name === eventName;
         };
-        const as = (event) => {
-            return is(event) ? event : undefined;
+        const find = (events) => {
+            if (!events || events.length === 0)
+                return undefined;
+            if (isEventRecord(events[0])) {
+                return this.registry.decodeEvents(events).find(is);
+            }
+            else {
+                return events.find(is);
+            }
+        };
+        const filter = (events) => {
+            if (isEventRecord(events[0])) {
+                return this.registry.decodeEvents(events).filter(is);
+            }
+            else {
+                return events.filter(is);
+            }
         };
         return {
             is,
-            as,
-            meta: eventMeta,
+            find,
+            filter,
+            meta,
         };
     }
     #findEventMeta(eventName) {
-        return this.registry.metadata.spec.events.find(one => stringPascalCase(one.label) === eventName);
+        return this.registry.metadata.spec.events.find((one) => stringPascalCase(one.label) === eventName);
     }
 }

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, ContractCallMessage } from '../types/index.js';
+import { ContractMessageArg, ContractMessage } 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: ContractCallMessage, raw: any): unknown;
+    tryDecode(meta: ContractMessage, raw: any): unknown;
 }

package/executor/QueryExecutor.js

@@ -1,5 +1,6 @@
 import { assert, concatU8a, hexToU8a, u8aToHex } from '@dedot/utils';
-import { normalizeLabel } from '../utils.js';
+import { ContractDispatchError, ContractLangError } from '../errors.js';
+import { normalizeLabel, toReturnFlags } from '../utils.js';
 import { Executor } from './Executor.js';
 export class QueryExecutor extends Executor {
     doExecute(message) {
@@ -14,17 +15,19 @@ export class QueryExecutor extends Executor {
             const formattedInputs = args.map((arg, index) => this.tryEncode(arg, params[index]));
             const bytes = u8aToHex(concatU8a(hexToU8a(meta.selector), ...formattedInputs));
             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, raw.result.value.data),
-                    raw,
-                }
-                : {
-                    isOk: false,
-                    err: raw.result.err,
-                    raw,
-                });
+            if (raw.result.isErr) {
+                throw new ContractDispatchError(raw.result.err, raw);
+            }
+            const data = this.tryDecode(meta, raw.result.value.data);
+            if (data.isErr) {
+                throw new ContractLangError(data.err, raw);
+            }
+            const bits = raw.result.value.flags.bits;
+            return {
+                data: data.value,
+                raw,
+                flags: toReturnFlags(bits),
+            };
         };
         callFn.meta = meta;
         return callFn;

package/index.d.ts

@@ -1,4 +1,5 @@
 export * from './utils.js';
+export * from './errors.js';
 export * from './executor/index.js';
 export * from './types/index.js';
 export * from './TypinkRegistry.js';

package/index.js

@@ -1,4 +1,5 @@
 export * from './utils.js';
+export * from './errors.js';
 export * from './executor/index.js';
 export * from './types/index.js';
 export * from './TypinkRegistry.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/contracts",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Delightful ink! Contract APIs",
   "author": "Tung Vu <tung@coongcrafts.io>",
   "homepage": "https://github.com/dedotdev/dedot/tree/main/packages/contracts",
@@ -18,17 +18,17 @@
     "test": "vitest --watch=false"
   },
   "dependencies": {
-    "@dedot/api": "0.1.1",
-    "@dedot/codecs": "0.1.1",
-    "@dedot/types": "0.1.1",
-    "@dedot/utils": "0.1.1"
+    "@dedot/api": "0.3.0",
+    "@dedot/codecs": "0.3.0",
+    "@dedot/types": "0.3.0",
+    "@dedot/utils": "0.3.0"
   },
   "publishConfig": {
     "access": "public",
     "directory": "dist"
   },
   "license": "Apache-2.0",
-  "gitHead": "ea6d1e7ba00a5931b86a7946afba820101a06fc2",
+  "gitHead": "40d0f3c7eee292b7615649e6a5d54887bee75fe2",
   "module": "./index.js",
   "types": "./index.d.ts",
   "exports": {

package/types/index.d.ts

@@ -1,20 +1,27 @@
 import { SubstrateApi } from '@dedot/api/chaintypes';
-import { AccountId32Like, BytesLike, DispatchError, Weight } from '@dedot/codecs';
-import { AnyFunc, AsyncMethod, GenericSubstrateApi, RpcVersion, VersionedGenericSubstrateApi } from '@dedot/types';
+import { AccountId32, AccountId32Like, BytesLike, Weight } from '@dedot/codecs';
+import { AnyFunc, AsyncMethod, GenericSubstrateApi, IEventRecord, RpcVersion, VersionedGenericSubstrateApi } from '@dedot/types';
 import { ContractCallMessage, ContractConstructorMessage } from './shared.js';
 import { ContractEventV4, ContractMetadataV4 } from './v4.js';
 import { ContractEventV5, ContractMetadataV5 } from './v5.js';
 export * from './shared.js';
 export type ContractEventMeta = ContractEventV4 | ContractEventV5;
-export type GenericContractCallResult<DecodedData, ContractResult> = ({
-    isOk: true;
+/**
+ * Flags used by a contract to customize exit behaviour.
+ * Ref: https://github.com/paritytech/polkadot-sdk/blob/d2fd53645654d3b8e12cbf735b67b93078d70113/substrate/frame/contracts/uapi/src/flags.rs#L23-L26
+ */
+export type ReturnFlags = {
+    bits: number;
+    revert: boolean;
+};
+export interface GenericContractCallResult<DecodedData = any, ContractResult = any> {
     data: DecodedData;
-} | {
-    isOk: false;
-    err: DispatchError;
-}) & {
     raw: ContractResult;
-};
+    flags: ReturnFlags;
+}
+export interface GenericConstructorCallResult<DecodedData = any, ContractResult = any> extends GenericContractCallResult<DecodedData, ContractResult> {
+    address: AccountId32;
+}
 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']>;
@@ -47,7 +54,7 @@ export type GenericContractQueryCall<ChainApi extends GenericSubstrateApi, F ext
 export type GenericContractTxCall<ChainApi extends GenericSubstrateApi, F extends AnyFunc = (...args: any[]) => ContractSubmittableExtrinsic<ChainApi>> = F & {
     meta: ContractCallMessage;
 };
-export type GenericConstructorQueryCall<ChainApi extends GenericSubstrateApi, F extends AsyncMethod = (...args: any[]) => Promise<ContractInstantiateResult<ChainApi>>> = F & {
+export type GenericConstructorQueryCall<ChainApi extends GenericSubstrateApi, F extends AsyncMethod = (...args: any[]) => Promise<GenericConstructorCallResult<any, ContractInstantiateResult<ChainApi>>>> = F & {
     meta: ContractConstructorMessage;
 };
 export type GenericConstructorTxCall<ChainApi extends GenericSubstrateApi, F extends AnyFunc = (...args: any[]) => GenericInstantiateSubmittableExtrinsic<ChainApi>> = F & {
@@ -72,17 +79,23 @@ export type ContractEvent<EventName extends string = string, Data extends any =
     data: Data;
 };
 export interface GenericContractEvent<EventName extends string = string, Data extends any = any> {
-    is: (event: ContractEvent) => event is ContractEvent<EventName, Data>;
-    as: (event: ContractEvent) => ContractEvent<EventName, Data> | undefined;
+    is: (event: IEventRecord | ContractEvent) => event is ContractEvent<EventName, Data>;
+    find: (events: IEventRecord[] | ContractEvent[]) => ContractEvent<EventName, Data> | undefined;
+    filter: (events: IEventRecord[] | ContractEvent[]) => ContractEvent<EventName, Data>[];
     meta: ContractEventMeta;
 }
 export interface GenericContractEvents<_ extends GenericSubstrateApi> {
     [event: string]: GenericContractEvent;
 }
+export type GenericInkLangError = 'CouldNotReadInput' | any;
 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]>;
     events: GenericContractEvents<ChainApi[Rv]>;
+    types: {
+        LangError: GenericInkLangError;
+        ChainApi: ChainApi[Rv];
+    };
 }

package/utils.d.ts

@@ -2,10 +2,11 @@ import { ISubstrateClient } from '@dedot/api';
 import { PortableType, TypeDef } from '@dedot/codecs';
 import { GenericSubstrateApi } from '@dedot/types';
 import { Executor } from './executor/index.js';
-import { ContractMetadata, ContractTypeDef } from './types/index.js';
+import { ContractMetadata, ContractTypeDef, ReturnFlags } from './types/index.js';
 export declare const extractContractTypes: (contractMetadata: ContractMetadata) => PortableType[];
 export declare const normalizeContractTypeDef: (def: ContractTypeDef) => TypeDef;
 export declare const parseRawMetadata: (rawMetadata: string) => ContractMetadata;
 export declare function newProxyChain<ChainApi extends GenericSubstrateApi>(carrier: Executor<ChainApi>): unknown;
 export declare function ensureSupportContractsPallet<ChainApi extends GenericSubstrateApi>(api: ISubstrateClient<ChainApi>): void;
 export declare function normalizeLabel(label?: string): string;
+export declare function toReturnFlags(bits: number): ReturnFlags;

package/utils.js

@@ -97,3 +97,11 @@ export function normalizeLabel(label) {
         return '';
     return stringCamelCase(label.replaceAll('::', '_'));
 }
+// https://github.com/paritytech/polkadot-sdk/blob/d2fd53645654d3b8e12cbf735b67b93078d70113/substrate/frame/contracts/uapi/src/flags.rs#L23-L26
+const REVERT_FLAG = 1;
+export function toReturnFlags(bits) {
+    return {
+        bits,
+        revert: bits === REVERT_FLAG,
+    };
+}