@dedot/contracts 0.0.1-next.9c1d51fe.10 → 0.0.1-next.cb041b89.17

package/Contract.d.ts

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

package/ContractDeployer.d.ts

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

package/ContractDeployer.js

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

package/cjs/ContractDeployer.js

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

package/cjs/executor/QueryExecutor.js

@@ -16,17 +16,18 @@ class QueryExecutor extends Executor_js_1.Executor {
             (0, utils_1.assert)(caller, 'Expected a valid caller address in ContractCallOptions');
             const formattedInputs = args.map((arg, index) => this.tryEncode(arg, params[index]));
             const bytes = (0, utils_1.u8aToHex)((0, utils_1.concatU8a)((0, utils_1.hexToU8a)(meta.selector), ...formattedInputs));
-            const contractResult = await this.api.call.contractsApi.call(caller, this.address, value, gasLimit, storageDepositLimit, bytes);
-            return contractResult.result.isOk
+            const raw = await this.api.call.contractsApi.call(caller, this.address, value, gasLimit, storageDepositLimit, bytes);
+            return (raw.result.isOk
                 ? {
                     isOk: true,
-                    data: this.tryDecode(meta, contractResult.result.value.data),
-                    rawResult: contractResult,
+                    data: this.tryDecode(meta, raw.result.value.data),
+                    raw,
                 }
                 : {
                     isOk: false,
-                    rawResult: contractResult,
-                };
+                    err: raw.result.err,
+                    raw,
+                });
         };
         callFn.meta = meta;
         return callFn;

package/executor/QueryExecutor.js

@@ -13,17 +13,18 @@ export class QueryExecutor extends Executor {
             assert(caller, 'Expected a valid caller address in ContractCallOptions');
             const formattedInputs = args.map((arg, index) => this.tryEncode(arg, params[index]));
             const bytes = u8aToHex(concatU8a(hexToU8a(meta.selector), ...formattedInputs));
-            const contractResult = await this.api.call.contractsApi.call(caller, this.address, value, gasLimit, storageDepositLimit, bytes);
-            return contractResult.result.isOk
+            const raw = await this.api.call.contractsApi.call(caller, this.address, value, gasLimit, storageDepositLimit, bytes);
+            return (raw.result.isOk
                 ? {
                     isOk: true,
-                    data: this.tryDecode(meta, contractResult.result.value.data),
-                    rawResult: contractResult,
+                    data: this.tryDecode(meta, raw.result.value.data),
+                    raw,
                 }
                 : {
                     isOk: false,
-                    rawResult: contractResult,
-                };
+                    err: raw.result.err,
+                    raw,
+                });
         };
         callFn.meta = meta;
         return callFn;

package/package.json

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

package/types/index.d.ts

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