@pezkuwi/api-contract 16.5.5 → 16.5.8

package/build-tsc/index.d.ts

@@ -0,0 +1,2 @@
+import './packageDetect.js';
+export * from './bundle.js';

package/build-tsc/packageDetect.d.ts

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

package/build-tsc/packageInfo.d.ts

@@ -0,0 +1,6 @@
+export declare const packageInfo: {
+    name: string;
+    path: string;
+    type: string;
+    version: string;
+};

package/build-tsc/promise/index.d.ts

@@ -0,0 +1,13 @@
+import type { ApiPromise } from '@pezkuwi/api';
+import type { AccountId, AccountId20, Hash } from '@pezkuwi/types/interfaces';
+import type { Abi } from '../Abi/index.js';
+import { Blueprint, Code, Contract } from '../base/index.js';
+export declare class BlueprintPromise extends Blueprint<'promise'> {
+    constructor(api: ApiPromise, abi: string | Record<string, unknown> | Abi, codeHash: string | Hash);
+}
+export declare class CodePromise extends Code<'promise'> {
+    constructor(api: ApiPromise, abi: string | Record<string, unknown> | Abi, wasm: Uint8Array | string | Buffer | null | undefined);
+}
+export declare class ContractPromise extends Contract<'promise'> {
+    constructor(api: ApiPromise, abi: string | Record<string, unknown> | Abi, address: string | AccountId | AccountId20);
+}

package/build-tsc/promise/types.d.ts

@@ -0,0 +1,3 @@
+import type { BlueprintSubmittableResult as BaseBlueprintSubmittableResult, CodeSubmittableResult as BaseCodeSubmittableResult } from '../base/index.js';
+export type BlueprintSubmittableResult = BaseBlueprintSubmittableResult<'promise'>;
+export type CodeSubmittableResult = BaseCodeSubmittableResult<'promise'>;

package/build-tsc/rx/index.d.ts

@@ -0,0 +1,13 @@
+import type { ApiRx } from '@pezkuwi/api';
+import type { AccountId, Hash } from '@pezkuwi/types/interfaces';
+import type { Abi } from '../Abi/index.js';
+import { Blueprint, Code, Contract } from '../base/index.js';
+export declare class BlueprintRx extends Blueprint<'rxjs'> {
+    constructor(api: ApiRx, abi: string | Record<string, unknown> | Abi, codeHash: string | Hash);
+}
+export declare class CodeRx extends Code<'rxjs'> {
+    constructor(api: ApiRx, abi: string | Record<string, unknown> | Abi, wasm: Uint8Array | string | Buffer | null | undefined);
+}
+export declare class ContractRx extends Contract<'rxjs'> {
+    constructor(api: ApiRx, abi: string | Record<string, unknown> | Abi, address: string | AccountId);
+}

package/build-tsc/rx/types.d.ts

@@ -0,0 +1,3 @@
+import type { BlueprintSubmittableResult as BaseBlueprintSubmittableResult, CodeSubmittableResult as BaseCodeSubmittableResult } from '../base/index.js';
+export type BlueprintSubmittableResult = BaseBlueprintSubmittableResult<'promise'>;
+export type CodeSubmittableResult = BaseCodeSubmittableResult<'promise'>;

package/build-tsc/types.d.ts

@@ -0,0 +1,79 @@
+import type { ApiBase } from '@pezkuwi/api/base';
+import type { ApiTypes } from '@pezkuwi/api/types';
+import type { Text } from '@pezkuwi/types';
+import type { ContractExecResultResult, ContractSelector, StorageDeposit, Weight, WeightV2 } from '@pezkuwi/types/interfaces';
+import type { Codec, TypeDef } from '@pezkuwi/types/types';
+import type { BN } from '@pezkuwi/util';
+import type { HexString } from '@pezkuwi/util/types';
+import type { Abi } from './index.js';
+export interface ContractBase<ApiType extends ApiTypes> {
+    readonly abi: Abi;
+    readonly api: ApiBase<ApiType>;
+    getMessage: (name: string) => AbiMessage;
+    messages: AbiMessage[];
+}
+export interface AbiParam {
+    name: string;
+    type: TypeDef;
+}
+export type AbiMessageParam = AbiParam;
+export interface AbiEventParam extends AbiParam {
+    indexed: boolean;
+}
+export interface AbiEvent {
+    args: AbiEventParam[];
+    docs: string[];
+    fromU8a: (data: Uint8Array) => DecodedEvent;
+    identifier: string;
+    index: number;
+    signatureTopic?: HexString | null;
+}
+export interface AbiMessage {
+    args: AbiMessageParam[];
+    docs: string[];
+    fromU8a: (data: Uint8Array) => DecodedMessage;
+    identifier: string;
+    index: number;
+    isConstructor?: boolean;
+    isDefault?: boolean;
+    isMutating?: boolean;
+    isPayable?: boolean;
+    method: string;
+    path: string[];
+    returnType?: TypeDef | null;
+    selector: ContractSelector;
+    toU8a: (params: unknown[]) => Uint8Array;
+}
+export type AbiConstructor = AbiMessage;
+export type InterfaceContractCalls = Record<string, Function>;
+export interface ContractCallOutcome {
+    debugMessage: Text;
+    gasConsumed: Weight;
+    gasRequired: Weight;
+    output: Codec | null;
+    result: ContractExecResultResult;
+    storageDeposit: StorageDeposit;
+}
+export interface DecodedEvent {
+    args: Codec[];
+    event: AbiEvent;
+}
+export interface DecodedMessage {
+    args: Codec[];
+    message: AbiMessage;
+}
+export interface ContractOptions {
+    gasLimit?: bigint | string | number | BN | WeightV2;
+    storageDepositLimit?: bigint | string | number | BN | null;
+    value?: bigint | BN | string | number;
+}
+export interface BlueprintOptions extends ContractOptions {
+    salt?: Uint8Array | string | null;
+}
+export interface WeightAll {
+    v1Weight: BN;
+    v2Weight: {
+        refTime: BN;
+        proofSize?: BN | undefined;
+    };
+}

package/build-tsc/util.d.ts

@@ -0,0 +1,5 @@
+import type { SubmittableResult } from '@pezkuwi/api';
+import type { EventRecord } from '@pezkuwi/types/interfaces';
+type ContractEvents = 'CodeStored' | 'ContractEmitted' | 'ContractExecution' | 'Instantiated';
+export declare function applyOnEvent<T>(result: SubmittableResult, types: ContractEvents[], fn: (records: EventRecord[]) => T, isRevive: boolean): T | undefined;
+export {};

package/build-tsc-cjs/Abi/index.js

@@ -0,0 +1,363 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Abi = void 0;
+const types_1 = require("@pezkuwi/types");
+const types_create_1 = require("@pezkuwi/types-create");
+const util_1 = require("@pezkuwi/util");
+const toLatestCompatible_js_1 = require("./toLatestCompatible.js");
+const l = (0, util_1.logger)('Abi');
+const PRIMITIVE_ALWAYS = ['AccountId', 'AccountId20', 'AccountIndex', 'Address', 'Balance'];
+function findMessage(list, messageOrId) {
+    const message = (0, util_1.isNumber)(messageOrId)
+        ? list[messageOrId]
+        : (0, util_1.isString)(messageOrId)
+            ? list.find(({ identifier }) => [identifier, (0, util_1.stringCamelCase)(identifier)].includes(messageOrId.toString()))
+            : messageOrId;
+    return (0, util_1.assertReturn)(message, () => `Attempted to call an invalid contract interface, ${(0, util_1.stringify)(messageOrId)}`);
+}
+function getMetadata(registry, json) {
+    // this is for V1, V2, V3
+    const vx = toLatestCompatible_js_1.enumVersions.find((v) => (0, util_1.isObject)(json[v]));
+    // this was added in V4
+    const jsonVersion = json.version;
+    if (!vx && jsonVersion && !toLatestCompatible_js_1.enumVersions.find((v) => v === `V${jsonVersion}`)) {
+        throw new Error(`Unable to handle version ${jsonVersion}`);
+    }
+    const metadata = registry.createType('ContractMetadata', vx
+        ? { [vx]: json[vx] }
+        : jsonVersion
+            ? { [`V${jsonVersion}`]: json }
+            : { V0: json });
+    const converter = toLatestCompatible_js_1.convertVersions.find(([v]) => metadata[`is${v}`]);
+    if (!converter) {
+        throw new Error(`Unable to convert ABI with version ${metadata.type} to a supported version`);
+    }
+    const upgradedMetadata = converter[1](registry, metadata[`as${converter[0]}`]);
+    return upgradedMetadata;
+}
+function isRevive(json) {
+    const source = json['source'];
+    const version = json['version'];
+    const hasContractBinary = typeof source === 'object' &&
+        source !== null &&
+        'contract_binary' in source;
+    const hasVersion = typeof version === 'number' && version >= 6;
+    return hasContractBinary || hasVersion;
+}
+function parseJson(json, chainProperties) {
+    const registry = new types_1.TypeRegistry();
+    const revive = isRevive(json);
+    const typeName = revive ? 'ContractReviveProjectInfo' : 'ContractProjectInfo';
+    const info = registry.createType(typeName, json);
+    const metadata = getMetadata(registry, json);
+    const lookup = registry.createType('PortableRegistry', { types: metadata.types }, true);
+    // attach the lookup to the registry - now the types are known
+    registry.setLookup(lookup);
+    if (chainProperties) {
+        registry.setChainProperties(chainProperties);
+    }
+    // warm-up the actual type, pre-use
+    lookup.types.forEach(({ id }) => lookup.getTypeDef(id));
+    return [json, registry, metadata, info, revive];
+}
+/**
+ * @internal
+ * Determines if the given input value is a ContractTypeSpec
+ */
+function isTypeSpec(value) {
+    return !!value && value instanceof Map && !(0, util_1.isUndefined)(value.type) && !(0, util_1.isUndefined)(value.displayName);
+}
+/**
+ * @internal
+ * Determines if the given input value is an Option
+ */
+function isOption(value) {
+    return !!value && value instanceof types_1.Option;
+}
+class Abi {
+    events;
+    constructors;
+    info;
+    json;
+    messages;
+    metadata;
+    registry;
+    environment = new Map();
+    isRevive;
+    constructor(abiJson, chainProperties) {
+        [this.json, this.registry, this.metadata, this.info, this.isRevive] = parseJson((0, util_1.isString)(abiJson)
+            ? JSON.parse(abiJson)
+            : abiJson, chainProperties);
+        this.constructors = this.metadata.spec.constructors.map((spec, index) => this.#createMessage(spec, index, {
+            isConstructor: true,
+            isDefault: spec.default.isTrue,
+            isPayable: spec.payable.isTrue,
+            returnType: spec.returnType.isSome
+                ? this.registry.lookup.getTypeDef(spec.returnType.unwrap().type)
+                : null
+        }));
+        this.events = this.metadata.spec.events.map((_, index) => this.#createEvent(index));
+        this.messages = this.metadata.spec.messages.map((spec, index) => this.#createMessage(spec, index, {
+            isDefault: spec.default.isTrue,
+            isMutating: spec.mutates.isTrue,
+            isPayable: spec.payable.isTrue,
+            returnType: spec.returnType.isSome
+                ? this.registry.lookup.getTypeDef(spec.returnType.unwrap().type)
+                : null
+        }));
+        // NOTE See the rationale for having Option<...> values in the actual
+        // ContractEnvironmentV4 structure definition in interfaces/contractsAbi
+        // (Due to conversions, the fields may not exist)
+        for (const [key, opt] of this.metadata.spec.environment.entries()) {
+            if (isOption(opt)) {
+                if (opt.isSome) {
+                    const value = opt.unwrap();
+                    if ((0, util_1.isBn)(value)) {
+                        this.environment.set(key, value);
+                    }
+                    else if (isTypeSpec(value)) {
+                        this.environment.set(key, this.registry.lookup.getTypeDef(value.type));
+                    }
+                    else {
+                        throw new Error(`Invalid environment definition for ${key}:: Expected either Number or ContractTypeSpec`);
+                    }
+                }
+            }
+            else {
+                throw new Error(`Expected Option<*> definition for ${key} in ContractEnvironment`);
+            }
+        }
+    }
+    /**
+     * Warning: Unstable API, bound to change
+     */
+    decodeEvent(record) {
+        switch (this.metadata.version.toString()) {
+            // earlier version are hoisted to v4
+            case '4':
+                return this.#decodeEventV4(record);
+            case '5':
+                return this.#decodeEventV5(record);
+            // Latest
+            default:
+                return this.#decodeEventV6(record);
+        }
+    }
+    #decodeEventV6 = (record) => {
+        const topics = record.event.data[2];
+        // Try to match by signature topic (first topic)
+        const signatureTopic = topics[0];
+        const data = record.event.data[1];
+        if (signatureTopic) {
+            const event = this.events.find((e) => e.signatureTopic !== undefined && e.signatureTopic !== null && e.signatureTopic === signatureTopic.toHex());
+            // Early return if event found by signature topic
+            if (event) {
+                return event.fromU8a(data);
+            }
+        }
+        // If no event returned yet, it might be anonymous
+        const amountOfTopics = topics.length;
+        const potentialEvents = this.events.filter((e) => {
+            // event can't have a signature topic
+            if (e.signatureTopic !== null && e.signatureTopic !== undefined) {
+                return false;
+            }
+            // event should have same amount of indexed fields as emitted topics
+            const amountIndexed = e.args.filter((a) => a.indexed).length;
+            if (amountIndexed !== amountOfTopics) {
+                return false;
+            }
+            // If all conditions met, it's a potential event
+            return true;
+        });
+        if (potentialEvents.length === 1) {
+            return potentialEvents[0].fromU8a(data);
+        }
+        throw new Error('Unable to determine event');
+    };
+    #decodeEventV5 = (record) => {
+        // Find event by first topic, which potentially is the signature_topic
+        const signatureTopic = record.topics[0];
+        const data = record.event.data[1];
+        if (signatureTopic) {
+            const event = this.events.find((e) => e.signatureTopic !== undefined && e.signatureTopic !== null && e.signatureTopic === signatureTopic.toHex());
+            // Early return if event found by signature topic
+            if (event) {
+                return event.fromU8a(data);
+            }
+        }
+        // If no event returned yet, it might be anonymous
+        const amountOfTopics = record.topics.length;
+        const potentialEvents = this.events.filter((e) => {
+            // event can't have a signature topic
+            if (e.signatureTopic !== null && e.signatureTopic !== undefined) {
+                return false;
+            }
+            // event should have same amount of indexed fields as emitted topics
+            const amountIndexed = e.args.filter((a) => a.indexed).length;
+            if (amountIndexed !== amountOfTopics) {
+                return false;
+            }
+            // If all conditions met, it's a potential event
+            return true;
+        });
+        if (potentialEvents.length === 1) {
+            return potentialEvents[0].fromU8a(data);
+        }
+        throw new Error('Unable to determine event');
+    };
+    #decodeEventV4 = (record) => {
+        const data = record.event.data[1];
+        const index = data[0];
+        const event = this.events[index];
+        if (!event) {
+            throw new Error(`Unable to find event with index ${index}`);
+        }
+        return event.fromU8a(data.subarray(1));
+    };
+    /**
+     * Warning: Unstable API, bound to change
+     */
+    decodeConstructor(data) {
+        return this.#decodeMessage('message', this.constructors, data);
+    }
+    /**
+     * Warning: Unstable API, bound to change
+     */
+    decodeMessage(data) {
+        return this.#decodeMessage('message', this.messages, data);
+    }
+    findConstructor(constructorOrId) {
+        return findMessage(this.constructors, constructorOrId);
+    }
+    findMessage(messageOrId) {
+        return findMessage(this.messages, messageOrId);
+    }
+    #createArgs = (args, spec) => {
+        return args.map(({ label, type }, index) => {
+            try {
+                if (!(0, util_1.isObject)(type)) {
+                    throw new Error('Invalid type definition found');
+                }
+                const displayName = type.displayName.length
+                    ? type.displayName[type.displayName.length - 1].toString()
+                    : undefined;
+                const camelName = (0, util_1.stringCamelCase)(label);
+                if (displayName && PRIMITIVE_ALWAYS.includes(displayName)) {
+                    return {
+                        name: camelName,
+                        type: {
+                            info: types_create_1.TypeDefInfo.Plain,
+                            type: displayName
+                        }
+                    };
+                }
+                const typeDef = this.registry.lookup.getTypeDef(type.type);
+                return {
+                    name: camelName,
+                    type: displayName && !typeDef.type.startsWith(displayName)
+                        ? { displayName, ...typeDef }
+                        : typeDef
+                };
+            }
+            catch (error) {
+                l.error(`Error expanding argument ${index} in ${(0, util_1.stringify)(spec)}`);
+                throw error;
+            }
+        });
+    };
+    #createMessageParams = (args, spec) => {
+        return this.#createArgs(args, spec);
+    };
+    #createEventParams = (args, spec) => {
+        const params = this.#createArgs(args, spec);
+        return params.map((p, index) => ({ ...p, indexed: args[index].indexed.toPrimitive() }));
+    };
+    #createEvent = (index) => {
+        // TODO TypeScript would narrow this type to the correct version,
+        // but version is `Text` so I need to call `toString()` here,
+        // which breaks the type inference.
+        switch (this.metadata.version.toString()) {
+            case '4':
+                return this.#createEventV4(this.metadata.spec.events[index], index);
+            default:
+                return this.#createEventV5(this.metadata.spec.events[index], index);
+        }
+    };
+    #createEventV5 = (spec, index) => {
+        const args = this.#createEventParams(spec.args, spec);
+        const event = {
+            args,
+            docs: spec.docs.map((d) => d.toString()),
+            fromU8a: (data) => ({
+                args: this.#decodeArgs(args, data),
+                event
+            }),
+            identifier: [spec.module_path, spec.label].join('::'),
+            index,
+            signatureTopic: spec.signature_topic.isSome ? spec.signature_topic.unwrap().toHex() : null
+        };
+        return event;
+    };
+    #createEventV4 = (spec, index) => {
+        const args = this.#createEventParams(spec.args, spec);
+        const event = {
+            args,
+            docs: spec.docs.map((d) => d.toString()),
+            fromU8a: (data) => ({
+                args: this.#decodeArgs(args, data),
+                event
+            }),
+            identifier: spec.label.toString(),
+            index
+        };
+        return event;
+    };
+    #createMessage = (spec, index, add = {}) => {
+        const args = this.#createMessageParams(spec.args, spec);
+        const identifier = spec.label.toString();
+        const message = {
+            ...add,
+            args,
+            docs: spec.docs.map((d) => d.toString()),
+            fromU8a: (data) => ({
+                args: this.#decodeArgs(args, data),
+                message
+            }),
+            identifier,
+            index,
+            isDefault: spec.default.isTrue,
+            method: (0, util_1.stringCamelCase)(identifier),
+            path: identifier.split('::').map((s) => (0, util_1.stringCamelCase)(s)),
+            selector: spec.selector,
+            toU8a: (params) => this.#encodeMessageArgs(spec, args, params)
+        };
+        return message;
+    };
+    #decodeArgs = (args, data) => {
+        // for decoding we expect the input to be just the arg data, no selectors
+        // no length added (this allows use with events as well)
+        let offset = 0;
+        return args.map(({ type: { lookupName, type } }) => {
+            const value = this.registry.createType(lookupName || type, data.subarray(offset));
+            offset += value.encodedLength;
+            return value;
+        });
+    };
+    #decodeMessage = (type, list, data) => {
+        const [, trimmed] = (0, util_1.compactStripLength)(data);
+        const selector = trimmed.subarray(0, 4);
+        const message = list.find((m) => m.selector.eq(selector));
+        if (!message) {
+            throw new Error(`Unable to find ${type} with selector ${(0, util_1.u8aToHex)(selector)}`);
+        }
+        return message.fromU8a(trimmed.subarray(4));
+    };
+    #encodeMessageArgs = ({ label, selector }, args, data) => {
+        if (data.length !== args.length) {
+            throw new Error(`Expected ${args.length} arguments to contract message '${label.toString()}', found ${data.length}`);
+        }
+        return (0, util_1.compactAddLength)((0, util_1.u8aConcat)(this.registry.createType('ContractSelector', selector).toU8a(), ...args.map(({ type: { lookupName, type } }, index) => this.registry.createType(lookupName || type, data[index]).toU8a())));
+    };
+}
+exports.Abi = Abi;

package/build-tsc-cjs/Abi/toLatestCompatible.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertVersions = exports.v0ToLatestCompatible = exports.v1ToLatestCompatible = exports.v2ToLatestCompatible = exports.v3ToLatestCompatible = exports.enumVersions = void 0;
+exports.v6ToLatestCompatible = v6ToLatestCompatible;
+exports.v5ToLatestCompatible = v5ToLatestCompatible;
+exports.v4ToLatestCompatible = v4ToLatestCompatible;
+const toV1_js_1 = require("./toV1.js");
+const toV2_js_1 = require("./toV2.js");
+const toV3_js_1 = require("./toV3.js");
+const toV4_js_1 = require("./toV4.js");
+exports.enumVersions = ['V6', 'V5', 'V4', 'V3', 'V2', 'V1'];
+function createConverter(next, step) {
+    return (registry, input) => next(registry, step(registry, input));
+}
+function v6ToLatestCompatible(_registry, v6) {
+    return v6;
+}
+function v5ToLatestCompatible(_registry, v5) {
+    return v5;
+}
+function v4ToLatestCompatible(_registry, v4) {
+    return v4;
+}
+exports.v3ToLatestCompatible = createConverter(v4ToLatestCompatible, toV4_js_1.v3ToV4);
+exports.v2ToLatestCompatible = createConverter(exports.v3ToLatestCompatible, toV3_js_1.v2ToV3);
+exports.v1ToLatestCompatible = createConverter(exports.v2ToLatestCompatible, toV2_js_1.v1ToV2);
+exports.v0ToLatestCompatible = createConverter(exports.v1ToLatestCompatible, toV1_js_1.v0ToV1);
+exports.convertVersions = [
+    ['V6', v6ToLatestCompatible],
+    ['V5', v5ToLatestCompatible],
+    ['V4', v4ToLatestCompatible],
+    ['V3', exports.v3ToLatestCompatible],
+    ['V2', exports.v2ToLatestCompatible],
+    ['V1', exports.v1ToLatestCompatible],
+    ['V0', exports.v0ToLatestCompatible]
+];

package/build-tsc-cjs/Abi/toV1.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v0ToV1 = v0ToV1;
+const types_1 = require("@pezkuwi/types");
+const util_1 = require("@pezkuwi/util");
+function v0ToV1Names(all) {
+    return all.map((e) => (0, util_1.objectSpread)({}, e, {
+        name: Array.isArray(e.name)
+            ? e.name
+            : [e.name]
+    }));
+}
+function v0ToV1(registry, v0) {
+    if (!v0.metadataVersion.length) {
+        throw new Error('Invalid format for V0 (detected) contract metadata');
+    }
+    return registry.createType('ContractMetadataV1', (0, util_1.objectSpread)({}, v0, {
+        spec: (0, util_1.objectSpread)({}, v0.spec, {
+            constructors: v0ToV1Names(v0.spec.constructors),
+            messages: v0ToV1Names(v0.spec.messages)
+        }),
+        types: (0, types_1.convertSiV0toV1)(registry, v0.types)
+    }));
+}

package/build-tsc-cjs/Abi/toV2.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v1ToV2 = v1ToV2;
+const util_1 = require("@pezkuwi/util");
+const ARG_TYPES = {
+    ContractConstructorSpec: 'ContractMessageParamSpecV2',
+    ContractEventSpec: 'ContractEventParamSpecV2',
+    ContractMessageSpec: 'ContractMessageParamSpecV2'
+};
+function v1ToV2Label(entry) {
+    return (0, util_1.objectSpread)({}, entry, {
+        label: Array.isArray(entry.name)
+            ? entry.name.join('::')
+            : entry.name
+    });
+}
+function v1ToV2Labels(registry, outType, all) {
+    return all.map((e) => registry.createType(`${outType}V2`, (0, util_1.objectSpread)(v1ToV2Label(e), {
+        args: e.args.map((a) => registry.createType(ARG_TYPES[outType], v1ToV2Label(a)))
+    })));
+}
+function v1ToV2(registry, v1) {
+    return registry.createType('ContractMetadataV2', (0, util_1.objectSpread)({}, v1, {
+        spec: (0, util_1.objectSpread)({}, v1.spec, {
+            constructors: v1ToV2Labels(registry, 'ContractConstructorSpec', v1.spec.constructors),
+            events: v1ToV2Labels(registry, 'ContractEventSpec', v1.spec.events),
+            messages: v1ToV2Labels(registry, 'ContractMessageSpec', v1.spec.messages)
+        })
+    }));
+}

package/build-tsc-cjs/Abi/toV3.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v2ToV3 = v2ToV3;
+const util_1 = require("@pezkuwi/util");
+function v2ToV3(registry, v2) {
+    return registry.createType('ContractMetadataV3', (0, util_1.objectSpread)({}, v2, {
+        spec: (0, util_1.objectSpread)({}, v2.spec, {
+            constructors: v2.spec.constructors.map((c) => 
+            // V3 introduces the payable flag on constructors, for <V3, it is always true
+            registry.createType('ContractConstructorSpecV3', (0, util_1.objectSpread)({}, c, { payable: true })))
+        })
+    }));
+}

package/build-tsc-cjs/Abi/toV4.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v3ToV4 = v3ToV4;
+const util_1 = require("@pezkuwi/util");
+function v3ToV4(registry, v3) {
+    return registry.createType('ContractMetadataV4', (0, util_1.objectSpread)({}, v3, {
+        spec: (0, util_1.objectSpread)({}, v3.spec, {
+            constructors: v3.spec.constructors.map((c) => registry.createType('ContractConstructorSpecV4', (0, util_1.objectSpread)({}, c))),
+            messages: v3.spec.messages.map((m) => registry.createType('ContractMessageSpecV3', (0, util_1.objectSpread)({}, m)))
+        }),
+        version: registry.createType('Text', '4')
+    }));
+}

package/build-tsc-cjs/augment.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("@pezkuwi/api-augment");

package/build-tsc-cjs/base/Base.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Base = void 0;
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../Abi/index.js");
+class Base {
+    abi;
+    api;
+    _decorateMethod;
+    _isWeightV1;
+    _isRevive;
+    constructor(api, abi, decorateMethod) {
+        if (!api || !api.isConnected || !api.tx) {
+            throw new Error('Your API has not been initialized correctly and is not connected to a chain');
+        }
+        this.abi = abi instanceof index_js_1.Abi
+            ? abi
+            : new index_js_1.Abi(abi, api.registry.getChainProperties());
+        this.api = api;
+        this._decorateMethod = decorateMethod;
+        this._isWeightV1 = !api.registry.createType('Weight').proofSize;
+        this._isRevive = this.abi.isRevive;
+        if (this._isRevive) {
+            if (!api.tx.revive || !(0, util_1.isFunction)(api.tx.revive.instantiateWithCode) || api.tx.revive.instantiateWithCode.meta.args.length !== 6) {
+                throw new Error('The runtime does not expose api.tx.revive.instantiateWithCode with storageDepositLimit');
+            }
+            else if (!api.call.reviveApi || !(0, util_1.isFunction)(api.call.reviveApi.call)) {
+                throw new Error('Your runtime does not expose the api.call.reviveApi.call runtime interfaces');
+            }
+        }
+        else {
+            if (!api.tx.contracts || !(0, util_1.isFunction)(api.tx.contracts.instantiateWithCode) || api.tx.contracts.instantiateWithCode.meta.args.length !== 6) {
+                throw new Error('The runtime does not expose api.tx.contracts.instantiateWithCode with storageDepositLimit');
+            }
+            else if (!api.call.contractsApi || !(0, util_1.isFunction)(api.call.contractsApi.call)) {
+                throw new Error('Your runtime does not expose the api.call.contractsApi.call runtime interfaces');
+            }
+        }
+    }
+    get registry() {
+        return this.api.registry;
+    }
+}
+exports.Base = Base;