@dedot/contracts 0.0.1-alpha.33

package/cjs/types/v4.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/types/v5.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/utils.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+    return types.map(({ type, id }) => ({
+        id,
+        type: (0, exports.normalizeContractTypeDef)(type.def),
+        params: [],
+        path: type?.path || [],
+        docs: [],
+    }));
+};
+exports.extractContractTypes = extractContractTypes;
+const normalizeContractTypeDef = (def) => {
+    let tag;
+    let value;
+    if (def.variant) {
+        tag = 'Enum';
+        value = {
+            members: def.variant.variants?.map((variant) => ({
+                fields: variant.fields?.map((fields) => ({ typeId: fields.type, typeName: fields.typeName })) || [],
+                index: variant.index,
+                name: variant.name,
+            })) || [],
+        };
+    }
+    else if (def.tuple) {
+        tag = 'Tuple';
+        value = {
+            fields: def.tuple,
+        };
+    }
+    else if (def.sequence) {
+        tag = 'Sequence';
+        value = {
+            typeParam: def.sequence.type,
+        };
+    }
+    else if (def.composite) {
+        tag = 'Struct';
+        value = {
+            fields: def.composite.fields.map((one) => ({
+                typeId: one.type,
+                name: one.name,
+                typeName: one.typeName,
+            })),
+        };
+    }
+    else if (def.primitive) {
+        tag = 'Primitive';
+        value = {
+            kind: def.primitive,
+        };
+    }
+    else if (def.array) {
+        tag = 'SizedVec';
+        value = {
+            len: def.array.len,
+            typeParam: def.array.type,
+        };
+    }
+    else {
+        throw Error(`Invalid contract type def: ${JSON.stringify(def)}`);
+    }
+    return { tag, value };
+};
+exports.normalizeContractTypeDef = normalizeContractTypeDef;
+const UNSUPPORTED_VERSIONS = ['V3', 'V2', 'V1'];
+const SUPPORTED_VERSIONS = ['5', '4'];
+const parseRawMetadata = (rawMetadata) => {
+    const metadata = JSON.parse(rawMetadata);
+    // This is for V1, V2, V3
+    const unsupportedVersion = UNSUPPORTED_VERSIONS.find((o) => metadata[o]);
+    if (unsupportedVersion) {
+        throw new Error(`Unsupported metadata version: ${unsupportedVersion}`);
+    }
+    // This is for V4, V5
+    if (!SUPPORTED_VERSIONS.includes(metadata.version)) {
+        throw new Error(`Unsupported metadata version: ${metadata.version}`);
+    }
+    return metadata;
+};
+exports.parseRawMetadata = parseRawMetadata;
+function newProxyChain(carrier) {
+    return new Proxy(carrier, {
+        get(target, property) {
+            return target.doExecute(property.toString());
+        },
+    });
+}
+exports.newProxyChain = newProxyChain;
+function ensureSupportContractsPallet(api) {
+    try {
+        !!api.call.contractsApi.call.meta && !!api.tx.contracts.call.meta;
+    }
+    catch {
+        throw new Error('Contracts pallet is not available');
+    }
+}
+exports.ensureSupportContractsPallet = ensureSupportContractsPallet;
+function normalizeLabel(label) {
+    if (!label)
+        return '';
+    return (0, utils_1.stringCamelCase)(label.replaceAll('::', '_'));
+}
+exports.normalizeLabel = normalizeLabel;

package/executor/ConstructorQueryExecutor.d.ts

@@ -0,0 +1,6 @@
+import { GenericSubstrateApi } from '@dedot/types';
+import { GenericConstructorQueryCall } from '../types/index.js';
+import { ConstructorTxExecutor } from './ConstructorTxExecutor.js';
+export declare class ConstructorQueryExecutor<ChainApi extends GenericSubstrateApi> extends ConstructorTxExecutor<ChainApi> {
+    doExecute(constructor: string): GenericConstructorQueryCall<ChainApi>;
+}

package/executor/ConstructorQueryExecutor.js

@@ -0,0 +1,23 @@
+import { assert, concatU8a, hexToU8a, isWasm, u8aToHex } from '@dedot/utils';
+import { ConstructorTxExecutor } from './ConstructorTxExecutor.js';
+export class ConstructorQueryExecutor extends ConstructorTxExecutor {
+    doExecute(constructor) {
+        const meta = this.findConstructorMeta(constructor);
+        assert(meta, `Constructor message not found: ${constructor}`);
+        const callFn = (...params) => {
+            // TODO verify number of arguments/params & call options presence
+            const { args } = meta;
+            const callOptions = params[args.length];
+            const { caller, value = 0n, gasLimit, storageDepositLimit, salt } = callOptions;
+            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',
+                value: this.code,
+            };
+            return this.api.call.contractsApi.instantiate(caller, value, gasLimit, storageDepositLimit, code, bytes, salt);
+        };
+        callFn.meta = meta;
+        return callFn;
+    }
+}

package/executor/ConstructorTxExecutor.d.ts

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

package/executor/ConstructorTxExecutor.js

@@ -0,0 +1,33 @@
+import { assert, concatU8a, hexToU8a, isWasm, u8aToHex } from '@dedot/utils';
+import { normalizeLabel } from '../utils.js';
+import { Executor } from './Executor.js';
+export class ConstructorTxExecutor extends Executor {
+    code;
+    constructor(api, registry, code) {
+        super(api, registry);
+        this.code = code;
+    }
+    doExecute(constructor) {
+        const meta = this.findConstructorMeta(constructor);
+        assert(meta, `Constructor message not found: ${constructor}`);
+        const callFn = (...params) => {
+            // TODO verify number of arguments/params & call options presence
+            const { args } = meta;
+            const txCallOptions = params[args.length];
+            const { value = 0n, gasLimit, storageDepositLimit, salt } = txCallOptions;
+            const formattedInputs = args.map((arg, index) => this.tryEncode(arg, params[index]));
+            const bytes = u8aToHex(concatU8a(hexToU8a(meta.selector), ...formattedInputs));
+            if (isWasm(this.code)) {
+                return this.api.tx.contracts.instantiateWithCode(value, gasLimit, storageDepositLimit, this.code, bytes, salt);
+            }
+            else {
+                return this.api.tx.contracts.instantiate(value, gasLimit, storageDepositLimit, this.code, bytes, salt);
+            }
+        };
+        callFn.meta = meta;
+        return callFn;
+    }
+    findConstructorMeta(constructor) {
+        return this.metadata.spec.constructors.find((one) => normalizeLabel(one.label) === constructor);
+    }
+}

package/executor/Executor.d.ts

@@ -0,0 +1,18 @@
+import { ISubstrateClient } from '@dedot/api';
+import { SubstrateApi } from '@dedot/api/chaintypes';
+import { AccountId32 } from '@dedot/codecs';
+import { GenericSubstrateApi, RpcVersion } from '@dedot/types';
+import { TypinkRegistry } from '../TypinkRegistry.js';
+import { ContractMessageArg, ContractMessage } from '../types/index.js';
+import { ContractMetadata } from '../types/index.js';
+export declare abstract class Executor<ChainApi extends GenericSubstrateApi = SubstrateApi[RpcVersion]> {
+    #private;
+    constructor(api: ISubstrateClient<ChainApi>, registry: TypinkRegistry, address?: AccountId32);
+    get api(): ISubstrateClient<ChainApi>;
+    get metadata(): ContractMetadata;
+    get address(): AccountId32 | undefined;
+    get registry(): TypinkRegistry;
+    abstract doExecute(...paths: string[]): unknown;
+    tryEncode(param: ContractMessageArg, value: any): Uint8Array;
+    tryDecode(meta: ContractMessage, raw: any): unknown;
+}

package/executor/Executor.js

@@ -0,0 +1,35 @@
+import { AccountId32 } from '@dedot/codecs';
+export class Executor {
+    #api;
+    #registry;
+    #address;
+    constructor(api, registry, address) {
+        this.#api = api;
+        this.#registry = registry;
+        if (address) {
+            this.#address = new AccountId32(address);
+        }
+    }
+    get api() {
+        return this.#api;
+    }
+    get metadata() {
+        return this.#registry.metadata;
+    }
+    get address() {
+        return this.#address;
+    }
+    get registry() {
+        return this.#registry;
+    }
+    tryEncode(param, value) {
+        const { type } = param.type;
+        const $codec = this.registry.findCodec(type);
+        return $codec.tryEncode(value);
+    }
+    tryDecode(meta, raw) {
+        const { returnType: { type }, } = meta;
+        const $codec = this.registry.findCodec(type);
+        return $codec.tryDecode(raw);
+    }
+}

package/executor/QueryExecutor.d.ts

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

package/executor/QueryExecutor.js

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

package/executor/TxExecutor.d.ts

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

package/executor/TxExecutor.js

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

package/executor/index.d.ts

@@ -0,0 +1,4 @@
+export * from './Executor.js';
+export * from './TxExecutor.js';
+export * from './QueryExecutor.js';
+export * from './ConstructorTxExecutor.js';

package/executor/index.js

@@ -0,0 +1,4 @@
+export * from './Executor.js';
+export * from './TxExecutor.js';
+export * from './QueryExecutor.js';
+export * from './ConstructorTxExecutor.js';

package/index.d.ts

@@ -0,0 +1,6 @@
+export * from './utils.js';
+export * from './executor/index.js';
+export * from './types/index.js';
+export * from './TypinkRegistry.js';
+export * from './Contract.js';
+export * from './ContractDeployer.js';

package/index.js

@@ -0,0 +1,6 @@
+export * from './utils.js';
+export * from './executor/index.js';
+export * from './types/index.js';
+export * from './TypinkRegistry.js';
+export * from './Contract.js';
+export * from './ContractDeployer.js';

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@dedot/contracts",
+  "version": "0.0.1-alpha.33",
+  "description": "Delightful ink! Contract APIs",
+  "author": "Tung Vu <tung@coongcrafts.io>",
+  "main": "./cjs/index.js",
+  "sideEffects": false,
+  "type": "module",
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json && tsc --project tsconfig.build.cjs.json",
+    "clean": "rm -rf ./dist && rm -rf ./tsconfig.tsbuildinfo ./tsconfig.build.tsbuildinfo",
+    "test": "vitest --watch=false"
+  },
+  "dependencies": {
+    "@dedot/api": "0.0.1-alpha.33",
+    "@dedot/codecs": "0.0.1-alpha.33",
+    "@dedot/types": "0.0.1-alpha.33",
+    "@dedot/utils": "0.0.1-alpha.33"
+  },
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  },
+  "license": "Apache-2.0",
+  "gitHead": "36b30a0cec2d8652915e3660329b78f1c6e4221f",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "require": "./cjs/index.js",
+      "default": "./index.js"
+    }
+  }
+}

package/types/index.d.ts

@@ -0,0 +1,57 @@
+import { SubstrateApi } from '@dedot/api/chaintypes';
+import { AccountId32Like, BytesLike, Weight } from '@dedot/codecs';
+import { AnyFunc, AsyncMethod, GenericSubstrateApi, RpcVersion } from '@dedot/types';
+import { ContractConstructorMessage, ContractMessage } from './shared.js';
+import { ContractMetadataV4 } from './v4.js';
+import { ContractMetadataV5 } from './v5.js';
+export * from './shared.js';
+export type ContractMetadata = ContractMetadataV4 | ContractMetadataV5;
+export type CallOptions = {
+    value?: bigint;
+    gasLimit?: Weight | undefined;
+    storageDepositLimit?: bigint | undefined;
+};
+export type ConstructorCallOptions = CallOptions & {
+    salt: BytesLike;
+    caller: AccountId32Like;
+};
+export type ConstructorTxOptions = CallOptions & {
+    salt: BytesLike;
+    gasLimit: Weight;
+};
+export type ContractCallOptions = CallOptions & {
+    caller: AccountId32Like;
+};
+export type ContractTxOptions = CallOptions & {
+    gasLimit: Weight;
+};
+export type GenericContractQueryCall<_ extends GenericSubstrateApi, F extends AsyncMethod = AsyncMethod> = F & {
+    meta: ContractMessage;
+};
+export type GenericContractTxCall<_ extends GenericSubstrateApi, F extends AnyFunc = AnyFunc> = F & {
+    meta: ContractMessage;
+};
+export type GenericConstructorQueryCall<_ extends GenericSubstrateApi, F extends AsyncMethod = AsyncMethod> = F & {
+    meta: ContractConstructorMessage;
+};
+export type GenericConstructorTxCall<_ extends GenericSubstrateApi, F extends AnyFunc = AnyFunc> = F & {
+    meta: ContractConstructorMessage;
+};
+export interface GenericContractQuery<ChainApi extends GenericSubstrateApi> {
+    [method: string]: GenericContractQueryCall<ChainApi>;
+}
+export interface GenericContractTx<ChainApi extends GenericSubstrateApi> {
+    [method: string]: GenericContractTxCall<ChainApi>;
+}
+export interface GenericConstructorQuery<ChainApi extends GenericSubstrateApi> {
+    [method: string]: GenericConstructorQueryCall<ChainApi>;
+}
+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>;
+}

package/types/index.js

@@ -0,0 +1 @@
+export * from './shared.js';

package/types/shared.d.ts

@@ -0,0 +1,105 @@
+export interface ContractSource {
+    hash: string;
+    wasm?: string;
+    language: string;
+    compiler: string;
+    buildInfo: BuildInfo;
+}
+export interface ContractInformation {
+    name: string;
+    version: string;
+    authors: string[];
+}
+export interface BuildInfo {
+    buildMode: string;
+    cargoContractVersion: string;
+    rustToolchain: string;
+    wasmOptSettings: WasmOptSettings;
+}
+export interface WasmOptSettings {
+    keepDebugSymbols: boolean;
+    optimizationPasses: string;
+}
+export interface ContractMessageArg {
+    label: string;
+    type: ContractTypeInfo;
+}
+export interface ContractTypeInfo {
+    displayName: string[];
+    type: number;
+}
+export interface ContractConstructorMessage {
+    args: ContractMessageArg[];
+    default: boolean;
+    docs: string[];
+    label: string;
+    payable: boolean;
+    returnType: ContractTypeInfo;
+    selector: string;
+}
+export interface ContractMessage {
+    args: ContractMessageArg[];
+    default: boolean;
+    docs: string[];
+    label: string;
+    mutates: boolean;
+    payable: boolean;
+    returnType: ContractTypeInfo;
+    selector: string;
+}
+export interface ContractType {
+    id: number;
+    type: {
+        def: ContractTypeDef;
+        path?: string[];
+        params?: ParamInfo[];
+    };
+}
+export interface ContractTypeDef {
+    composite?: CompositeType;
+    array?: ArrayType;
+    primitive?: string;
+    sequence?: SequenceType;
+    variant?: VariantType;
+    tuple?: number[];
+}
+export interface CompositeType {
+    fields: {
+        type: number;
+        typeName: string;
+        name?: string;
+    }[];
+}
+export interface ArrayType {
+    len: number;
+    type: number;
+}
+export interface SequenceType {
+    type: number;
+}
+export interface VariantType {
+    variants?: {
+        index: number;
+        name: string;
+        fields?: {
+            type: number;
+            typeName?: string;
+            name?: string;
+        }[];
+    }[];
+}
+export interface ParamInfo {
+    name: string;
+    type: number;
+}
+export interface ContractStorage {
+    root: {
+        layout: {
+            struct: {
+                fields: any[];
+                name: string;
+            };
+        };
+        root_key: string;
+    };
+}

package/types/shared.js

@@ -0,0 +1 @@
+export {};

package/types/v4.d.ts

@@ -0,0 +1,31 @@
+import { ContractConstructorMessage, ContractInformation, ContractMessage, ContractSource, ContractStorage, ContractType, ContractTypeInfo } from './shared.js';
+export interface ContractMetadataV4 {
+    source: ContractSource;
+    contract: ContractInformation;
+    spec: ContractSpecV4;
+    storage: ContractStorage;
+    types: ContractType[];
+    version: '4';
+}
+export interface ContractSpecV4 {
+    constructors: ContractConstructorMessage[];
+    docs: string[];
+    environment: ContractEnvironmentV4;
+    events: ContractEventV4[];
+    langError: ContractTypeInfo;
+    messages: ContractMessage[];
+}
+export interface ContractEventV4 {
+    args: unknown[];
+    docs: string[];
+    label: string[];
+}
+export interface ContractEnvironmentV4 {
+    accountId: ContractTypeInfo;
+    balance: ContractTypeInfo;
+    blockNumber: ContractTypeInfo;
+    chainExtension: ContractTypeInfo;
+    hash: ContractTypeInfo;
+    maxEventTopics: number;
+    timestamp: ContractTypeInfo;
+}

package/types/v4.js

@@ -0,0 +1 @@
+export {};

package/types/v5.d.ts

@@ -0,0 +1,21 @@
+import { ContractInformation, ContractSource, ContractStorage, ContractType } from './shared.js';
+import { ContractEnvironmentV4, ContractEventV4, ContractSpecV4 } from './v4.js';
+export interface ContractMetadataV5 {
+    source: ContractSource;
+    contract: ContractInformation;
+    spec: ContractSpecV5;
+    storage: ContractStorage;
+    types: ContractType[];
+    version: '5';
+}
+export interface ContractSpecV5 extends ContractSpecV4 {
+    environment: ContractEnvironmentV5;
+    events: ContractEventV5[];
+}
+export interface ContractEventV5 extends ContractEventV4 {
+    module_path: string;
+    signature_topic: string;
+}
+export interface ContractEnvironmentV5 extends ContractEnvironmentV4 {
+    staticBufferSize: number;
+}

package/types/v5.js

@@ -0,0 +1 @@
+export {};

package/utils.d.ts

@@ -0,0 +1,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';
+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;