@dedot/contracts 0.0.1-next.cfee875e.21 → 0.0.1-next.d731b849.13

package/Contract.d.ts

@@ -1,13 +1,16 @@
 import { ISubstrateClient } from '@dedot/api';
 import { AccountId32, AccountId32Like } from '@dedot/codecs';
+import { IEventRecord } from '@dedot/types';
 import { TypinkRegistry } from './TypinkRegistry.js';
-import { ContractMetadata, GenericContractApi } from './types/index.js';
+import { ContractEvent, ContractMetadata, GenericContractApi } from './types/index.js';
 export declare class Contract<ContractApi extends GenericContractApi = GenericContractApi> {
     #private;
-    constructor(api: ISubstrateClient, address: AccountId32Like, metadata: ContractMetadata | string);
+    constructor(api: ISubstrateClient, metadata: ContractMetadata | string, address: AccountId32Like);
+    decodeEvent(eventRecord: IEventRecord): ContractEvent;
     get metadata(): ContractMetadata;
     get address(): AccountId32;
     get registry(): TypinkRegistry;
     get query(): ContractApi['query'];
     get tx(): ContractApi['tx'];
+    get events(): ContractApi['events'];
 }

package/Contract.js

@@ -1,19 +1,22 @@
 import { AccountId32 } from '@dedot/codecs';
 import { TypinkRegistry } from './TypinkRegistry.js';
-import { QueryExecutor, TxExecutor } from './executor/index.js';
+import { EventExecutor, QueryExecutor, TxExecutor } from './executor/index.js';
 import { ensureSupportContractsPallet, newProxyChain, parseRawMetadata } from './utils.js';
 export class Contract {
     #api;
     #registry;
     #address;
     #metadata;
-    constructor(api, address, metadata) {
+    constructor(api, metadata, address) {
         ensureSupportContractsPallet(api);
         this.#api = api;
         this.#address = new AccountId32(address);
         this.#metadata = typeof metadata === 'string' ? parseRawMetadata(metadata) : metadata;
         this.#registry = new TypinkRegistry(this.#metadata);
     }
+    decodeEvent(eventRecord) {
+        return this.#registry.decodeEvent(eventRecord);
+    }
     get metadata() {
         return this.#metadata;
     }
@@ -29,4 +32,7 @@ export class Contract {
     get tx() {
         return newProxyChain(new TxExecutor(this.#api, this.#registry, this.#address));
     }
+    get events() {
+        return newProxyChain(new EventExecutor(this.#api, this.#registry, this.#address));
+    }
 }

package/TypinkRegistry.d.ts

@@ -1,7 +1,9 @@
 import { TypeRegistry } from '@dedot/codecs';
-import { ContractMetadata } from './types/index.js';
+import { IEventRecord } from '@dedot/types';
+import { ContractEvent, ContractMetadata } from './types/index.js';
 export declare class TypinkRegistry extends TypeRegistry {
     #private;
     constructor(metadata: ContractMetadata);
     get metadata(): ContractMetadata;
+    decodeEvent(eventRecord: IEventRecord): ContractEvent;
 }

package/TypinkRegistry.js

@@ -1,4 +1,6 @@
 import { TypeRegistry } from '@dedot/codecs';
+import * as $ from '@dedot/shape';
+import { DedotError, assert, hexToU8a, stringCamelCase, stringPascalCase } from '@dedot/utils';
 import { extractContractTypes } from './utils.js';
 export class TypinkRegistry extends TypeRegistry {
     #metadata;
@@ -9,4 +11,61 @@ export class TypinkRegistry extends TypeRegistry {
     get metadata() {
         return this.#metadata;
     }
+    decodeEvent(eventRecord) {
+        const { version } = this.#metadata;
+        switch (version) {
+            case 5:
+                return this.#decodeEventV5(eventRecord);
+            case '4':
+                return this.#decodeEventV4(eventRecord);
+            default:
+                throw new DedotError('Unsupported metadata version!');
+        }
+    }
+    #isContractEmittedEvent(eventRecord) {
+        // @ts-ignore
+        return eventRecord.pallet === 'Contracts' && eventRecord.palletEvent.name === 'ContractEmitted';
+    }
+    #decodeEventV4(eventRecord) {
+        assert(this.#metadata.version === '4', 'Invalid metadata version!');
+        assert(this.#isContractEmittedEvent(eventRecord.event), 'Event Record is not valid!');
+        const data = hexToU8a(eventRecord.event.palletEvent.data.data);
+        const index = data.at(0);
+        assert(index !== undefined, 'Unable to decode event index!');
+        const event = this.#metadata.spec.events[index];
+        assert(event, `Event index not found: ${index.toString()}`);
+        return this.#tryDecodeEvent(event, data.subarray(1));
+    }
+    #decodeEventV5(eventRecord) {
+        assert(this.#metadata.version === 5, 'Invalid metadata version!');
+        assert(this.#isContractEmittedEvent(eventRecord.event), 'Event Record is not valid!');
+        const data = hexToU8a(eventRecord.event.palletEvent.data.data);
+        const signatureTopic = eventRecord.topics.at(0);
+        let eventMeta;
+        if (signatureTopic) {
+            eventMeta = this.#metadata.spec.events.find((one) => one.signature_topic === signatureTopic);
+        }
+        // TODO: Handle multiple anonymous events
+        // If `event` does not exist, it means it's an anonymous event
+        // that does not contain a signature topic in the metadata.
+        if (!eventMeta) {
+            const potentialEvents = this.#metadata.spec.events.filter((one) => !one.signature_topic && one.args.filter((arg) => arg.indexed).length === eventRecord.topics.length);
+            assert(potentialEvents.length === 1, 'Unable to determine event!');
+            eventMeta = potentialEvents[0];
+        }
+        return this.#tryDecodeEvent(eventMeta, data);
+    }
+    #tryDecodeEvent(eventMeta, raw) {
+        const { args, label } = eventMeta;
+        const eventCodecFrame = args.reduce((frame, arg) => {
+            const { label, type: { type }, } = arg;
+            const $codec = this.findCodec(type);
+            Object.assign(frame, { [stringCamelCase(label)]: $codec });
+            return frame;
+        }, {});
+        const $eventCodec = $.Struct(eventCodecFrame);
+        const data = $eventCodec.decode(raw);
+        const name = stringPascalCase(label);
+        return args.length ? { name, data } : { name };
+    }
 }

package/cjs/Contract.js

@@ -10,13 +10,16 @@ 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);
         this.#metadata = typeof metadata === 'string' ? (0, utils_js_1.parseRawMetadata)(metadata) : metadata;
         this.#registry = new TypinkRegistry_js_1.TypinkRegistry(this.#metadata);
     }
+    decodeEvent(eventRecord) {
+        return this.#registry.decodeEvent(eventRecord);
+    }
     get metadata() {
         return this.#metadata;
     }
@@ -32,5 +35,8 @@ class Contract {
     get tx() {
         return (0, utils_js_1.newProxyChain)(new index_js_1.TxExecutor(this.#api, this.#registry, this.#address));
     }
+    get events() {
+        return (0, utils_js_1.newProxyChain)(new index_js_1.EventExecutor(this.#api, this.#registry, this.#address));
+    }
 }
 exports.Contract = Contract;

package/cjs/TypinkRegistry.js

@@ -1,7 +1,32 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypinkRegistry = void 0;
 const codecs_1 = require("@dedot/codecs");
+const $ = __importStar(require("@dedot/shape"));
+const utils_1 = require("@dedot/utils");
 const utils_js_1 = require("./utils.js");
 class TypinkRegistry extends codecs_1.TypeRegistry {
     #metadata;
@@ -12,5 +37,62 @@ class TypinkRegistry extends codecs_1.TypeRegistry {
     get metadata() {
         return this.#metadata;
     }
+    decodeEvent(eventRecord) {
+        const { version } = this.#metadata;
+        switch (version) {
+            case 5:
+                return this.#decodeEventV5(eventRecord);
+            case '4':
+                return this.#decodeEventV4(eventRecord);
+            default:
+                throw new utils_1.DedotError('Unsupported metadata version!');
+        }
+    }
+    #isContractEmittedEvent(eventRecord) {
+        // @ts-ignore
+        return eventRecord.pallet === 'Contracts' && eventRecord.palletEvent.name === 'ContractEmitted';
+    }
+    #decodeEventV4(eventRecord) {
+        (0, utils_1.assert)(this.#metadata.version === '4', 'Invalid metadata version!');
+        (0, utils_1.assert)(this.#isContractEmittedEvent(eventRecord.event), 'Event Record is not valid!');
+        const data = (0, utils_1.hexToU8a)(eventRecord.event.palletEvent.data.data);
+        const index = data.at(0);
+        (0, utils_1.assert)(index !== undefined, 'Unable to decode event index!');
+        const event = this.#metadata.spec.events[index];
+        (0, utils_1.assert)(event, `Event index not found: ${index.toString()}`);
+        return this.#tryDecodeEvent(event, data.subarray(1));
+    }
+    #decodeEventV5(eventRecord) {
+        (0, utils_1.assert)(this.#metadata.version === 5, 'Invalid metadata version!');
+        (0, utils_1.assert)(this.#isContractEmittedEvent(eventRecord.event), 'Event Record is not valid!');
+        const data = (0, utils_1.hexToU8a)(eventRecord.event.palletEvent.data.data);
+        const signatureTopic = eventRecord.topics.at(0);
+        let eventMeta;
+        if (signatureTopic) {
+            eventMeta = this.#metadata.spec.events.find((one) => one.signature_topic === signatureTopic);
+        }
+        // TODO: Handle multiple anonymous events
+        // If `event` does not exist, it means it's an anonymous event
+        // that does not contain a signature topic in the metadata.
+        if (!eventMeta) {
+            const potentialEvents = this.#metadata.spec.events.filter((one) => !one.signature_topic && one.args.filter((arg) => arg.indexed).length === eventRecord.topics.length);
+            (0, utils_1.assert)(potentialEvents.length === 1, 'Unable to determine event!');
+            eventMeta = potentialEvents[0];
+        }
+        return this.#tryDecodeEvent(eventMeta, data);
+    }
+    #tryDecodeEvent(eventMeta, raw) {
+        const { args, label } = eventMeta;
+        const eventCodecFrame = args.reduce((frame, arg) => {
+            const { label, type: { type }, } = arg;
+            const $codec = this.findCodec(type);
+            Object.assign(frame, { [(0, utils_1.stringCamelCase)(label)]: $codec });
+            return frame;
+        }, {});
+        const $eventCodec = $.Struct(eventCodecFrame);
+        const data = $eventCodec.decode(raw);
+        const name = (0, utils_1.stringPascalCase)(label);
+        return args.length ? { name, data } : { name };
+    }
 }
 exports.TypinkRegistry = TypinkRegistry;

package/cjs/errors.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isContractInstantiateLangError = exports.isContractInstantiateDispatchError = exports.isContractInstantiateExecutionError = exports.isContractLangError = exports.isContractDispatchError = exports.isContractExecutionError = exports.ContractLangError = exports.ContractDispatchError = exports.ContractExecutionError = exports.ContractInstantiateLangError = exports.ContractInstantiateDispatchError = exports.ContractInstantiateExecutionError = void 0;
+const utils_1 = require("@dedot/utils");
+class ContractInstantiateExecutionError extends utils_1.DedotError {
+    raw;
+    constructor(raw) {
+        super();
+        this.raw = raw;
+    }
+}
+exports.ContractInstantiateExecutionError = ContractInstantiateExecutionError;
+class ContractInstantiateDispatchError extends ContractInstantiateExecutionError {
+    err;
+    constructor(err, raw) {
+        super(raw);
+        this.err = err;
+    }
+}
+exports.ContractInstantiateDispatchError = ContractInstantiateDispatchError;
+/*
+ * LangError represents an error which comes from the smart contracting language itself
+ * Ref: https://use.ink/faq/migrating-from-ink-3-to-4#:~:text=Add%20support%20for,equivalent%20LangError.
+ */
+class ContractInstantiateLangError extends ContractInstantiateExecutionError {
+    err;
+    constructor(err, raw) {
+        super(raw);
+        this.err = err;
+    }
+}
+exports.ContractInstantiateLangError = ContractInstantiateLangError;
+class ContractExecutionError extends utils_1.DedotError {
+    raw;
+    constructor(raw) {
+        super();
+        this.raw = raw;
+    }
+}
+exports.ContractExecutionError = ContractExecutionError;
+class ContractDispatchError extends ContractExecutionError {
+    err;
+    constructor(err, raw) {
+        super(raw);
+        this.err = err;
+    }
+}
+exports.ContractDispatchError = ContractDispatchError;
+/*
+ * LangError represents an error which comes from the smart contracting language itself
+ * Ref: https://use.ink/faq/migrating-from-ink-3-to-4#:~:text=Add%20support%20for,equivalent%20LangError.
+ */
+class ContractLangError extends ContractExecutionError {
+    err;
+    constructor(err, raw) {
+        super(raw);
+        this.err = err;
+    }
+}
+exports.ContractLangError = ContractLangError;
+function isContractExecutionError(e) {
+    return e instanceof ContractExecutionError;
+}
+exports.isContractExecutionError = isContractExecutionError;
+function isContractDispatchError(e) {
+    return e instanceof ContractDispatchError;
+}
+exports.isContractDispatchError = isContractDispatchError;
+function isContractLangError(e) {
+    return e instanceof ContractLangError;
+}
+exports.isContractLangError = isContractLangError;
+function isContractInstantiateExecutionError(e) {
+    return e instanceof ContractInstantiateExecutionError;
+}
+exports.isContractInstantiateExecutionError = isContractInstantiateExecutionError;
+function isContractInstantiateDispatchError(e) {
+    return e instanceof ContractInstantiateDispatchError;
+}
+exports.isContractInstantiateDispatchError = isContractInstantiateDispatchError;
+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];
@@ -23,10 +24,22 @@ class ConstructorQueryExecutor 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 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);
+            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);
+            }
+            return {
+                raw,
+                data: data.value,
+                address: raw.result.value.accountId,
+            };
         };
         callFn.meta = meta;
         return callFn;

package/cjs/executor/EventExecutor.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventExecutor = void 0;
+const Executor_js_1 = require("./Executor.js");
+const utils_1 = require("@dedot/utils");
+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 is = (event) => {
+            return event.name === eventName;
+        };
+        const as = (event) => {
+            return is(event) ? event : undefined;
+        };
+        return {
+            is,
+            as,
+            meta: eventMeta,
+        };
+    }
+    #findEventMeta(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,17 @@ 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);
+            }
+            return {
+                data: data.value,
+                raw,
+            };
         };
         callFn.meta = meta;
         return callFn;

package/cjs/executor/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./Executor.js"), exports);
 __exportStar(require("./TxExecutor.js"), exports);
 __exportStar(require("./QueryExecutor.js"), exports);
 __exportStar(require("./ConstructorTxExecutor.js"), exports);
+__exportStar(require("./EventExecutor.js"), exports);

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

@@ -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,11 +64,11 @@ 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'];
-const SUPPORTED_VERSIONS = ['5', '4'];
+const SUPPORTED_VERSIONS = [5, '4'];
 const parseRawMetadata = (rawMetadata) => {
     const metadata = JSON.parse(rawMetadata);
     // This is for V1, V2, V3

package/errors.d.ts

@@ -0,0 +1,33 @@
+import { DispatchError } from '@dedot/codecs';
+import { DedotError } from '@dedot/utils';
+import { ContractCallResult, ContractInstantiateResult, GenericContractApi } from './types';
+export declare class ContractInstantiateExecutionError<ContractApi extends GenericContractApi = GenericContractApi> extends DedotError {
+    raw: ContractInstantiateResult<ContractApi['types']['ChainApi']>;
+    constructor(raw: ContractInstantiateResult<ContractApi['types']['ChainApi']>);
+}
+export declare class ContractInstantiateDispatchError<ContractApi extends GenericContractApi = GenericContractApi> extends ContractInstantiateExecutionError<ContractApi> {
+    err: DispatchError;
+    constructor(err: DispatchError, raw: ContractInstantiateResult<ContractApi['types']['ChainApi']>);
+}
+export declare class ContractInstantiateLangError<ContractApi extends GenericContractApi = GenericContractApi> extends ContractInstantiateExecutionError<ContractApi> {
+    err: ContractApi['types']['LangError'];
+    constructor(err: ContractApi['types']['LangError'], raw: ContractInstantiateResult<ContractApi['types']['ChainApi']>);
+}
+export declare class ContractExecutionError<ContractApi extends GenericContractApi = GenericContractApi> extends DedotError {
+    raw: ContractCallResult<ContractApi['types']['ChainApi']>;
+    constructor(raw: ContractCallResult<ContractApi['types']['ChainApi']>);
+}
+export declare class ContractDispatchError<ContractApi extends GenericContractApi = GenericContractApi> extends ContractExecutionError<ContractApi> {
+    err: DispatchError;
+    constructor(err: DispatchError, raw: ContractCallResult<ContractApi['types']['ChainApi']>);
+}
+export declare class ContractLangError<ContractApi extends GenericContractApi = GenericContractApi> extends ContractExecutionError<ContractApi> {
+    err: ContractApi['types']['LangError'];
+    constructor(err: ContractApi['types']['LangError'], raw: ContractCallResult<ContractApi['types']['ChainApi']>);
+}
+export declare function isContractExecutionError<ContractApi extends GenericContractApi = GenericContractApi>(e: Error): e is ContractExecutionError<ContractApi>;
+export declare function isContractDispatchError<ContractApi extends GenericContractApi = GenericContractApi>(e: Error): e is ContractDispatchError<ContractApi>;
+export declare function isContractLangError<ContractApi extends GenericContractApi = GenericContractApi>(e: Error): e is ContractLangError<ContractApi>;
+export declare function isContractInstantiateExecutionError<ContractApi extends GenericContractApi = GenericContractApi>(e: Error): e is ContractInstantiateExecutionError<ContractApi>;
+export declare function isContractInstantiateDispatchError<ContractApi extends GenericContractApi = GenericContractApi>(e: Error): e is ContractInstantiateDispatchError<ContractApi>;
+export declare function isContractInstantiateLangError<ContractApi extends GenericContractApi = GenericContractApi>(e: Error): e is ContractInstantiateLangError<ContractApi>;

package/errors.js

@@ -0,0 +1,69 @@
+import { DedotError } from '@dedot/utils';
+export class ContractInstantiateExecutionError extends DedotError {
+    raw;
+    constructor(raw) {
+        super();
+        this.raw = raw;
+    }
+}
+export class ContractInstantiateDispatchError extends ContractInstantiateExecutionError {
+    err;
+    constructor(err, raw) {
+        super(raw);
+        this.err = err;
+    }
+}
+/*
+ * LangError represents an error which comes from the smart contracting language itself
+ * Ref: https://use.ink/faq/migrating-from-ink-3-to-4#:~:text=Add%20support%20for,equivalent%20LangError.
+ */
+export class ContractInstantiateLangError extends ContractInstantiateExecutionError {
+    err;
+    constructor(err, raw) {
+        super(raw);
+        this.err = err;
+    }
+}
+export class ContractExecutionError extends DedotError {
+    raw;
+    constructor(raw) {
+        super();
+        this.raw = raw;
+    }
+}
+export class ContractDispatchError extends ContractExecutionError {
+    err;
+    constructor(err, raw) {
+        super(raw);
+        this.err = err;
+    }
+}
+/*
+ * LangError represents an error which comes from the smart contracting language itself
+ * Ref: https://use.ink/faq/migrating-from-ink-3-to-4#:~:text=Add%20support%20for,equivalent%20LangError.
+ */
+export class ContractLangError extends ContractExecutionError {
+    err;
+    constructor(err, raw) {
+        super(raw);
+        this.err = err;
+    }
+}
+export function isContractExecutionError(e) {
+    return e instanceof ContractExecutionError;
+}
+export function isContractDispatchError(e) {
+    return e instanceof ContractDispatchError;
+}
+export function isContractLangError(e) {
+    return e instanceof ContractLangError;
+}
+export function isContractInstantiateExecutionError(e) {
+    return e instanceof ContractInstantiateExecutionError;
+}
+export function isContractInstantiateDispatchError(e) {
+    return e instanceof ContractInstantiateDispatchError;
+}
+export function isContractInstantiateLangError(e) {
+    return e instanceof ContractInstantiateLangError;
+}

package/executor/ConstructorQueryExecutor.js

@@ -1,4 +1,5 @@
 import { assert, concatU8a, hexToU8a, isWasm, u8aToHex } from '@dedot/utils';
+import { ContractInstantiateDispatchError, ContractInstantiateLangError } from '../errors.js';
 import { normalizeLabel } from '../utils.js';
 import { Executor } from './Executor.js';
 export class ConstructorQueryExecutor extends Executor {
@@ -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];
@@ -20,10 +21,22 @@ export class ConstructorQueryExecutor extends Executor {
             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);
+            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);
+            }
+            return {
+                raw,
+                data: data.value,
+                address: raw.result.value.accountId,
+            };
         };
         callFn.meta = meta;
         return callFn;

package/executor/EventExecutor.d.ts

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

package/executor/EventExecutor.js

@@ -0,0 +1,22 @@
+import { Executor } from "./Executor.js";
+import { assert, stringPascalCase } from "@dedot/utils";
+export class EventExecutor extends Executor {
+    doExecute(eventName) {
+        const eventMeta = this.#findEventMeta(eventName);
+        assert(eventMeta, "Contract event metadata not found!");
+        const is = (event) => {
+            return event.name === eventName;
+        };
+        const as = (event) => {
+            return is(event) ? event : undefined;
+        };
+        return {
+            is,
+            as,
+            meta: eventMeta,
+        };
+    }
+    #findEventMeta(eventName) {
+        return this.registry.metadata.spec.events.find(one => stringPascalCase(one.label) === eventName);
+    }
+}

package/executor/QueryExecutor.js

@@ -1,4 +1,5 @@
 import { assert, concatU8a, hexToU8a, u8aToHex } from '@dedot/utils';
+import { ContractDispatchError, ContractLangError } from '../errors.js';
 import { normalizeLabel } from '../utils.js';
 import { Executor } from './Executor.js';
 export class QueryExecutor extends Executor {
@@ -14,17 +15,17 @@ 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);
+            }
+            return {
+                data: data.value,
+                raw,
+            };
         };
         callFn.meta = meta;
         return callFn;

package/executor/index.d.ts

@@ -2,3 +2,4 @@ export * from './Executor.js';
 export * from './TxExecutor.js';
 export * from './QueryExecutor.js';
 export * from './ConstructorTxExecutor.js';
+export * from './EventExecutor.js';

package/executor/index.js

@@ -2,3 +2,4 @@ export * from './Executor.js';
 export * from './TxExecutor.js';
 export * from './QueryExecutor.js';
 export * from './ConstructorTxExecutor.js';
+export * from './EventExecutor.js';

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,8 +1,14 @@
 {
   "name": "@dedot/contracts",
-  "version": "0.0.1-next.cfee875e.21+cfee875",
+  "version": "0.0.1-next.d731b849.13+d731b84",
   "description": "Delightful ink! Contract APIs",
   "author": "Tung Vu <tung@coongcrafts.io>",
+  "homepage": "https://github.com/dedotdev/dedot/tree/main/packages/contracts",
+  "repository": {
+    "directory": "packages/contracts",
+    "type": "git",
+    "url": "https://github.com/dedotdev/dedot.git"
+  },
   "main": "./cjs/index.js",
   "sideEffects": false,
   "type": "module",
@@ -12,17 +18,17 @@
     "test": "vitest --watch=false"
   },
   "dependencies": {
-    "@dedot/api": "0.0.1-next.cfee875e.21+cfee875",
-    "@dedot/codecs": "0.0.1-next.cfee875e.21+cfee875",
-    "@dedot/types": "0.0.1-next.cfee875e.21+cfee875",
-    "@dedot/utils": "0.0.1-next.cfee875e.21+cfee875"
+    "@dedot/api": "0.0.1-next.d731b849.13+d731b84",
+    "@dedot/codecs": "0.0.1-next.d731b849.13+d731b84",
+    "@dedot/types": "0.0.1-next.d731b849.13+d731b84",
+    "@dedot/utils": "0.0.1-next.d731b849.13+d731b84"
   },
   "publishConfig": {
     "access": "public",
     "directory": "dist"
   },
   "license": "Apache-2.0",
-  "gitHead": "cfee875eafba07e0fbb8a72556ca549a62ddceff",
+  "gitHead": "d731b849f66c92ca6fa69894e45792c49381d407",
   "module": "./index.js",
   "types": "./index.d.ts",
   "exports": {

package/types/index.d.ts

@@ -1,19 +1,20 @@
 import { SubstrateApi } from '@dedot/api/chaintypes';
-import { AccountId32Like, BytesLike, DispatchError, Weight } from '@dedot/codecs';
+import { AccountId32, AccountId32Like, BytesLike, Weight } from '@dedot/codecs';
 import { AnyFunc, AsyncMethod, GenericSubstrateApi, RpcVersion, VersionedGenericSubstrateApi } from '@dedot/types';
-import { ContractConstructorMessage, ContractMessage } from './shared.js';
-import { ContractMetadataV4 } from './v4.js';
-import { ContractMetadataV5 } from './v5.js';
+import { ContractCallMessage, ContractConstructorMessage } from './shared.js';
+import { ContractEventV4, ContractMetadataV4 } from './v4.js';
+import { ContractEventV5, ContractMetadataV5 } from './v5.js';
 export * from './shared.js';
-export type GenericContractCallResult<DecodedData, ContractResult> = ({
-    isOk: true;
+export type ContractEventMeta = ContractEventV4 | ContractEventV5;
+export type GenericContractCallResult<DecodedData = any, ContractResult = any> = {
     data: DecodedData;
-} | {
-    isOk: false;
-    err: DispatchError;
-}) & {
     raw: ContractResult;
 };
+export type GenericConstructorCallResult<DecodedData = any, ContractResult = any> = {
+    data: DecodedData;
+    raw: 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']>;
@@ -41,12 +42,12 @@ export type ContractTxOptions = CallOptions & {
     gasLimit: Weight;
 };
 export type GenericContractQueryCall<ChainApi extends GenericSubstrateApi, F extends AsyncMethod = (...args: any[]) => Promise<GenericContractCallResult<any, ContractCallResult<ChainApi>>>> = F & {
-    meta: ContractMessage;
+    meta: ContractCallMessage;
 };
 export type GenericContractTxCall<ChainApi extends GenericSubstrateApi, F extends AnyFunc = (...args: any[]) => ContractSubmittableExtrinsic<ChainApi>> = F & {
-    meta: ContractMessage;
+    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 & {
@@ -64,9 +65,29 @@ export interface GenericConstructorQuery<ChainApi extends GenericSubstrateApi> {
 export interface GenericConstructorTx<ChainApi extends GenericSubstrateApi> {
     [method: string]: GenericConstructorTxCall<ChainApi>;
 }
-export interface GenericContractApi<ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> {
-    query: GenericContractQuery<ChainApi[RpcVersion]>;
-    tx: GenericContractTx<ChainApi[RpcVersion]>;
-    constructorQuery: GenericConstructorQuery<ChainApi[RpcVersion]>;
-    constructorTx: GenericConstructorTx<ChainApi[RpcVersion]>;
+export type ContractEvent<EventName extends string = string, Data extends any = any> = Data extends undefined ? {
+    name: EventName;
+} : {
+    name: EventName;
+    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;
+    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/types/shared.d.ts

@@ -28,7 +28,7 @@ export interface ContractTypeInfo {
     displayName: string[];
     type: number;
 }
-export interface Message {
+export interface ContractMessage {
     args: ContractMessageArg[];
     default: boolean;
     docs: string[];
@@ -37,9 +37,9 @@ export interface Message {
     returnType: ContractTypeInfo;
     selector: string;
 }
-export interface ContractConstructorMessage extends Message {
+export interface ContractConstructorMessage extends ContractMessage {
 }
-export interface ContractMessage extends Message {
+export interface ContractCallMessage extends ContractMessage {
     mutates: boolean;
 }
 export interface ContractType {
@@ -98,3 +98,7 @@ export interface ContractStorage {
         root_key: string;
     };
 }
+export interface ContractEventArg extends ContractMessageArg {
+    docs: string[];
+    indexed: boolean;
+}

package/types/v4.d.ts

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

package/types/v5.d.ts

@@ -6,7 +6,7 @@ export interface ContractMetadataV5 {
     spec: ContractSpecV5;
     storage: ContractStorage;
     types: ContractType[];
-    version: '5';
+    version: 5;
 }
 export interface ContractSpecV5 extends ContractSpecV4 {
     environment: ContractEnvironmentV5;
@@ -14,7 +14,7 @@ export interface ContractSpecV5 extends ContractSpecV4 {
 }
 export interface ContractEventV5 extends ContractEventV4 {
     module_path: string;
-    signature_topic: string;
+    signature_topic?: string | null;
 }
 export interface ContractEnvironmentV5 extends ContractEnvironmentV4 {
     staticBufferSize: number;

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,10 +60,10 @@ 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'];
+const SUPPORTED_VERSIONS = [5, '4'];
 export const parseRawMetadata = (rawMetadata) => {
     const metadata = JSON.parse(rawMetadata);
     // This is for V1, V2, V3