@pezkuwi/api-contract 16.5.5 → 16.5.6

package/cjs/base/Blueprint.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Blueprint = exports.BlueprintSubmittableResult = void 0;
+exports.extendBlueprint = extendBlueprint;
+const api_1 = require("@pezkuwi/api");
+const util_1 = require("@pezkuwi/util");
+const util_js_1 = require("../util.js");
+const Base_js_1 = require("./Base.js");
+const Contract_js_1 = require("./Contract.js");
+const util_js_2 = require("./util.js");
+class BlueprintSubmittableResult extends api_1.SubmittableResult {
+    contract;
+    constructor(result, contract) {
+        super(result);
+        this.contract = contract;
+    }
+}
+exports.BlueprintSubmittableResult = BlueprintSubmittableResult;
+class Blueprint extends Base_js_1.Base {
+    /**
+     * @description The on-chain code hash for this blueprint
+     */
+    codeHash;
+    #tx = {};
+    constructor(api, abi, codeHash, decorateMethod) {
+        super(api, abi, decorateMethod);
+        this.codeHash = this.registry.createType('Hash', codeHash);
+        this.abi.constructors.forEach((c) => {
+            if ((0, util_1.isUndefined)(this.#tx[c.method])) {
+                this.#tx[c.method] = (0, util_js_2.createBluePrintTx)(c, (o, p) => this.#deploy(c, o, p));
+            }
+        });
+    }
+    get tx() {
+        return this.#tx;
+    }
+    #deploy = (constructorOrId, { gasLimit = util_1.BN_ZERO, salt, storageDepositLimit = null, value = util_1.BN_ZERO }, params) => {
+        const palletTx = this._isRevive
+            ? this.api.tx.revive
+            : this.api.tx.contracts;
+        return palletTx.instantiate(value, 
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore jiggle v1 weights, metadata points to latest
+        this._isWeightV1
+            ? (0, util_js_2.convertWeight)(gasLimit).v1Weight
+            : (0, util_js_2.convertWeight)(gasLimit).v2Weight, storageDepositLimit, this.codeHash, this.abi.findConstructor(constructorOrId).toU8a(params), (0, util_js_2.encodeSalt)(salt)).withResultTransform((result) => new BlueprintSubmittableResult(result, (0, util_js_1.applyOnEvent)(result, ['Instantiated'], ([record]) => new Contract_js_1.Contract(this.api, this.abi, record.event.data[1], this._decorateMethod), this._isRevive)));
+    };
+}
+exports.Blueprint = Blueprint;
+function extendBlueprint(type, decorateMethod) {
+    return class extends Blueprint {
+        static __BlueprintType = type;
+        constructor(api, abi, codeHash) {
+            super(api, abi, codeHash, decorateMethod);
+        }
+    };
+}

package/cjs/base/Code.d.ts

@@ -0,0 +1,22 @@
+import type { ApiBase } from '@pezkuwi/api/base';
+import type { ApiTypes, DecorateMethod } from '@pezkuwi/api/types';
+import type { ISubmittableResult } from '@pezkuwi/types/types';
+import type { Abi } from '../Abi/index.js';
+import type { MapConstructorExec } from './types.js';
+import { SubmittableResult } from '@pezkuwi/api';
+import { Base } from './Base.js';
+import { Blueprint } from './Blueprint.js';
+import { Contract } from './Contract.js';
+export type CodeConstructor<ApiType extends ApiTypes> = new (api: ApiBase<ApiType>, abi: string | Record<string, unknown> | Abi, wasm: Uint8Array | string | Buffer | null | undefined) => Code<ApiType>;
+export declare class CodeSubmittableResult<ApiType extends ApiTypes> extends SubmittableResult {
+    readonly blueprint?: Blueprint<ApiType> | undefined;
+    readonly contract?: Contract<ApiType> | undefined;
+    constructor(result: ISubmittableResult, blueprint?: Blueprint<ApiType> | undefined, contract?: Contract<ApiType> | undefined);
+}
+export declare class Code<ApiType extends ApiTypes> extends Base<ApiType> {
+    #private;
+    readonly code: Uint8Array;
+    constructor(api: ApiBase<ApiType>, abi: string | Record<string, unknown> | Abi, wasm: Uint8Array | string | Buffer | null | undefined, decorateMethod: DecorateMethod<ApiType>);
+    get tx(): MapConstructorExec<ApiType>;
+}
+export declare function extendCode<ApiType extends ApiTypes>(type: ApiType, decorateMethod: DecorateMethod<ApiType>): CodeConstructor<ApiType>;

package/cjs/base/Code.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Code = exports.CodeSubmittableResult = void 0;
+exports.extendCode = extendCode;
+const api_1 = require("@pezkuwi/api");
+const util_1 = require("@pezkuwi/util");
+const util_js_1 = require("../util.js");
+const Base_js_1 = require("./Base.js");
+const Blueprint_js_1 = require("./Blueprint.js");
+const Contract_js_1 = require("./Contract.js");
+const util_js_2 = require("./util.js");
+class CodeSubmittableResult extends api_1.SubmittableResult {
+    blueprint;
+    contract;
+    constructor(result, blueprint, contract) {
+        super(result);
+        this.blueprint = blueprint;
+        this.contract = contract;
+    }
+}
+exports.CodeSubmittableResult = CodeSubmittableResult;
+function isValidCode(code) {
+    return (0, util_1.isWasm)(code) || (0, util_1.isRiscV)(code);
+}
+class Code extends Base_js_1.Base {
+    code;
+    #tx = {};
+    constructor(api, abi, wasm, decorateMethod) {
+        super(api, abi, decorateMethod);
+        this.code = isValidCode(this.abi.info.source.wasm)
+            ? this.abi.info.source.wasm
+            : (0, util_1.u8aToU8a)(wasm);
+        if (!isValidCode(this.code)) {
+            throw new Error('Invalid code provided');
+        }
+        this.abi.constructors.forEach((c) => {
+            if ((0, util_1.isUndefined)(this.#tx[c.method])) {
+                this.#tx[c.method] = (0, util_js_2.createBluePrintTx)(c, (o, p) => this.#instantiate(c, o, p));
+            }
+        });
+    }
+    get tx() {
+        return this.#tx;
+    }
+    #instantiate = (constructorOrId, { gasLimit = util_1.BN_ZERO, salt, storageDepositLimit = null, value = util_1.BN_ZERO }, params) => {
+        const palletTx = this._isRevive ? this.api.tx.revive : this.api.tx.contracts;
+        if (this._isRevive) {
+            return palletTx.instantiateWithCode(value, 
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore jiggle v1 weights, metadata points to latest
+            this._isWeightV1
+                ? (0, util_js_2.convertWeight)(gasLimit).v1Weight
+                : (0, util_js_2.convertWeight)(gasLimit).v2Weight, storageDepositLimit, (0, util_1.compactAddLength)(this.code), this.abi.findConstructor(constructorOrId).toU8a(params), (0, util_js_2.encodeSalt)(salt)).withResultTransform((result) => new CodeSubmittableResult(result, ...((0, util_js_1.applyOnEvent)(result, ['Instantiated'], (records) => records.reduce(([blueprint, contract], { event }) => this.api.events.revive['Instantiated'].is(event)
+                ? [
+                    blueprint,
+                    new Contract_js_1.Contract(this.api, this.abi, event.data[1], this._decorateMethod)
+                ]
+                : [blueprint, contract], [undefined, undefined]), this._isRevive) || [undefined, undefined])));
+        }
+        return palletTx.instantiateWithCode(value, 
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore jiggle v1 weights, metadata points to latest
+        this._isWeightV1
+            ? (0, util_js_2.convertWeight)(gasLimit).v1Weight
+            : (0, util_js_2.convertWeight)(gasLimit).v2Weight, storageDepositLimit, (0, util_1.compactAddLength)(this.code), this.abi.findConstructor(constructorOrId).toU8a(params), (0, util_js_2.encodeSalt)(salt)).withResultTransform((result) => new CodeSubmittableResult(result, ...((0, util_js_1.applyOnEvent)(result, ['CodeStored', 'Instantiated'], (records) => records.reduce(([blueprint, contract], { event }) => this.api.events.contracts.Instantiated.is(event)
+            ? [blueprint, new Contract_js_1.Contract(this.api, this.abi, event.data[1], this._decorateMethod)]
+            : this.api.events.contracts.CodeStored.is(event)
+                ? [new Blueprint_js_1.Blueprint(this.api, this.abi, event.data[0], this._decorateMethod), contract]
+                : [blueprint, contract], [undefined, undefined]), this._isRevive) || [undefined, undefined])));
+    };
+}
+exports.Code = Code;
+function extendCode(type, decorateMethod) {
+    return class extends Code {
+        static __CodeType = type;
+        constructor(api, abi, wasm) {
+            super(api, abi, wasm, decorateMethod);
+        }
+    };
+}

package/cjs/base/Contract.d.ts

@@ -0,0 +1,25 @@
+import type { ApiBase } from '@pezkuwi/api/base';
+import type { ApiTypes, DecorateMethod } from '@pezkuwi/api/types';
+import type { AccountId, AccountId20 } from '@pezkuwi/types/interfaces';
+import type { ISubmittableResult } from '@pezkuwi/types/types';
+import type { Abi } from '../Abi/index.js';
+import type { DecodedEvent } from '../types.js';
+import type { MapMessageQuery, MapMessageTx } from './types.js';
+import { SubmittableResult } from '@pezkuwi/api';
+import { Base } from './Base.js';
+export type ContractConstructor<ApiType extends ApiTypes> = new (api: ApiBase<ApiType>, abi: string | Record<string, unknown> | Abi, address: string | AccountId) => Contract<ApiType>;
+export declare class ContractSubmittableResult extends SubmittableResult {
+    readonly contractEvents?: DecodedEvent[] | undefined;
+    constructor(result: ISubmittableResult, contractEvents?: DecodedEvent[]);
+}
+export declare class Contract<ApiType extends ApiTypes> extends Base<ApiType> {
+    #private;
+    /**
+     * @description The on-chain address for this contract
+     */
+    readonly address: AccountId | AccountId20;
+    constructor(api: ApiBase<ApiType>, abi: string | Record<string, unknown> | Abi, address: string | AccountId | AccountId20, decorateMethod: DecorateMethod<ApiType>);
+    get query(): MapMessageQuery<ApiType>;
+    get tx(): MapMessageTx<ApiType>;
+}
+export declare function extendContract<ApiType extends ApiTypes>(type: ApiType, decorateMethod: DecorateMethod<ApiType>): ContractConstructor<ApiType>;

package/cjs/base/Contract.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Contract = exports.ContractSubmittableResult = void 0;
+exports.extendContract = extendContract;
+const rxjs_1 = require("rxjs");
+const api_1 = require("@pezkuwi/api");
+const util_1 = require("@pezkuwi/util");
+const util_js_1 = require("../util.js");
+const Base_js_1 = require("./Base.js");
+const util_js_2 = require("./util.js");
+const MAX_CALL_GAS = new util_1.BN(5_000_000_000_000).isub(util_1.BN_ONE);
+const l = (0, util_1.logger)('Contract');
+function createQuery(meta, fn) {
+    return (0, util_js_2.withMeta)(meta, (origin, options, ...params) => fn(origin, options, params));
+}
+function createTx(meta, fn) {
+    return (0, util_js_2.withMeta)(meta, (options, ...params) => fn(options, params));
+}
+class ContractSubmittableResult extends api_1.SubmittableResult {
+    contractEvents;
+    constructor(result, contractEvents) {
+        super(result);
+        this.contractEvents = contractEvents;
+    }
+}
+exports.ContractSubmittableResult = ContractSubmittableResult;
+class Contract extends Base_js_1.Base {
+    /**
+     * @description The on-chain address for this contract
+     */
+    address;
+    #query = {};
+    #tx = {};
+    constructor(api, abi, address, decorateMethod) {
+        super(api, abi, decorateMethod);
+        this.address = this.registry.createType(this._isRevive ? 'AccountId20' : 'AccountId', address);
+        this.abi.messages.forEach((m) => {
+            if ((0, util_1.isUndefined)(this.#tx[m.method])) {
+                this.#tx[m.method] = createTx(m, (o, p) => this.#exec(m, o, p));
+            }
+            if ((0, util_1.isUndefined)(this.#query[m.method])) {
+                this.#query[m.method] = createQuery(m, (f, o, p) => this.#read(m, o, p).send(f));
+            }
+        });
+    }
+    get query() {
+        return this.#query;
+    }
+    get tx() {
+        return this.#tx;
+    }
+    #getGas = (_gasLimit, isCall = false) => {
+        const weight = (0, util_js_2.convertWeight)(_gasLimit);
+        if (weight.v1Weight.gt(util_1.BN_ZERO)) {
+            return weight;
+        }
+        return (0, util_js_2.convertWeight)(isCall
+            ? MAX_CALL_GAS
+            : (0, util_js_2.convertWeight)(this.api.consts.system.blockWeights
+                ? this.api.consts.system.blockWeights.maxBlock
+                : this.api.consts.system['maximumBlockWeight']).v1Weight.muln(64).div(util_1.BN_HUNDRED));
+    };
+    #exec = (messageOrId, { gasLimit = util_1.BN_ZERO, storageDepositLimit = null, value = util_1.BN_ZERO }, params) => {
+        const palletTx = this._isRevive ? this.api.tx.revive : this.api.tx.contracts;
+        return palletTx.call(this.address, value, 
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore jiggle v1 weights, metadata points to latest
+        this._isWeightV1
+            ? (0, util_js_2.convertWeight)(gasLimit).v1Weight
+            : (0, util_js_2.convertWeight)(gasLimit).v2Weight, storageDepositLimit, this.abi.findMessage(messageOrId).toU8a(params)).withResultTransform((result) => 
+        // ContractEmitted is the current generation, ContractExecution is the previous generation
+        new ContractSubmittableResult(result, (0, util_js_1.applyOnEvent)(result, ['ContractEmitted', 'ContractExecution'], (records) => records
+            // Filter to only decode events emitted by this specific contract instance.
+            .filter((record) => {
+            try {
+                const contractAddress = record.event.data[0];
+                if (this.address.eq(contractAddress)) {
+                    return true;
+                }
+                l.debug(`Skipping event from different contract ${contractAddress.toString()} (this contract: ${this.address.toString()})`);
+                return false;
+            }
+            catch (error) {
+                l.warn(`Unable to extract contract address from event: ${error.message}`);
+                return false;
+            }
+        })
+            .map((record) => {
+            try {
+                return this.abi.decodeEvent(record);
+            }
+            catch (error) {
+                l.error(`Unable to decode contract event: ${error.message}`);
+                return null;
+            }
+        })
+            .filter((decoded) => !!decoded), this._isRevive)));
+    };
+    #read = (messageOrId, { gasLimit = util_1.BN_ZERO, storageDepositLimit = null, value = util_1.BN_ZERO }, params) => {
+        const message = this.abi.findMessage(messageOrId);
+        return {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            send: this._decorateMethod((origin) => (this._isRevive
+                ? this.api.rx.call.reviveApi.call
+                : this.api.rx.call.contractsApi.call)(origin, this.address, value, 
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore jiggle v1 weights, metadata points to latest
+            this._isWeightV1
+                ? this.#getGas(gasLimit, true).v1Weight
+                : this.#getGas(gasLimit, true).v2Weight, storageDepositLimit, message.toU8a(params)).pipe((0, rxjs_1.map)(({ debugMessage, gasConsumed, gasRequired, result, storageDeposit }) => ({
+                debugMessage,
+                gasConsumed,
+                gasRequired: gasRequired && !(0, util_js_2.convertWeight)(gasRequired).v1Weight.isZero()
+                    ? gasRequired
+                    : gasConsumed,
+                output: result.isOk && message.returnType
+                    ? this.abi.registry.createTypeUnsafe(message.returnType.lookupName || message.returnType.type, [result.asOk.data.toU8a(true)], { isPedantic: true })
+                    : null,
+                result,
+                storageDeposit
+            }))))
+        };
+    };
+}
+exports.Contract = Contract;
+function extendContract(type, decorateMethod) {
+    return class extends Contract {
+        static __ContractType = type;
+        constructor(api, abi, address) {
+            super(api, abi, address, decorateMethod);
+        }
+    };
+}

package/cjs/base/index.d.ts

@@ -0,0 +1,3 @@
+export { Blueprint, BlueprintSubmittableResult, extendBlueprint } from './Blueprint.js';
+export { Code, CodeSubmittableResult, extendCode } from './Code.js';
+export { Contract, extendContract } from './Contract.js';

package/cjs/base/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendContract = exports.Contract = exports.extendCode = exports.CodeSubmittableResult = exports.Code = exports.extendBlueprint = exports.BlueprintSubmittableResult = exports.Blueprint = void 0;
+var Blueprint_js_1 = require("./Blueprint.js");
+Object.defineProperty(exports, "Blueprint", { enumerable: true, get: function () { return Blueprint_js_1.Blueprint; } });
+Object.defineProperty(exports, "BlueprintSubmittableResult", { enumerable: true, get: function () { return Blueprint_js_1.BlueprintSubmittableResult; } });
+Object.defineProperty(exports, "extendBlueprint", { enumerable: true, get: function () { return Blueprint_js_1.extendBlueprint; } });
+var Code_js_1 = require("./Code.js");
+Object.defineProperty(exports, "Code", { enumerable: true, get: function () { return Code_js_1.Code; } });
+Object.defineProperty(exports, "CodeSubmittableResult", { enumerable: true, get: function () { return Code_js_1.CodeSubmittableResult; } });
+Object.defineProperty(exports, "extendCode", { enumerable: true, get: function () { return Code_js_1.extendCode; } });
+var Contract_js_1 = require("./Contract.js");
+Object.defineProperty(exports, "Contract", { enumerable: true, get: function () { return Contract_js_1.Contract; } });
+Object.defineProperty(exports, "extendContract", { enumerable: true, get: function () { return Contract_js_1.extendContract; } });

package/cjs/base/mock.d.ts

@@ -0,0 +1,3 @@
+import type { ApiBase } from '@pezkuwi/api/base';
+export declare const mockApi: ApiBase<"promise">;
+export declare const mockReviveApi: ApiBase<"promise">;

package/cjs/base/mock.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockReviveApi = exports.mockApi = void 0;
+const types_1 = require("@pezkuwi/types");
+const registry = new types_1.TypeRegistry();
+const instantiateWithCode = () => {
+    throw new Error('mock');
+};
+instantiateWithCode.meta = { args: new Array(6) };
+exports.mockApi = {
+    call: {
+        contractsApi: {
+            call: () => {
+                throw new Error('mock');
+            }
+        }
+    },
+    isConnected: true,
+    registry,
+    tx: {
+        contracts: {
+            instantiateWithCode
+        }
+    }
+};
+exports.mockReviveApi = {
+    call: {
+        reviveApi: {
+            call: () => {
+                throw new Error('mock');
+            }
+        }
+    },
+    isConnected: true,
+    registry,
+    tx: {
+        revive: {
+            instantiateWithCode
+        }
+    }
+};

package/{src/base/types.ts → cjs/base/types.d.ts}

@@ -1,40 +1,25 @@
-// Copyright 2017-2025 @polkadot/api-contract authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import type { Observable } from 'rxjs';
 import type { SubmittableExtrinsic } from '@pezkuwi/api/submittable/types';
 import type { ApiTypes, ObsInnerType } from '@pezkuwi/api/types';
 import type { AccountId } from '@pezkuwi/types/interfaces';
 import type { AbiMessage, BlueprintOptions, ContractCallOutcome, ContractOptions } from '../types.js';
-
 export interface MessageMeta {
-  readonly meta: AbiMessage;
+    readonly meta: AbiMessage;
 }
-
 export interface BlueprintDeploy<ApiType extends ApiTypes> extends MessageMeta {
-  (options: BlueprintOptions, ...params: unknown[]): SubmittableExtrinsic<ApiType>;
+    (options: BlueprintOptions, ...params: unknown[]): SubmittableExtrinsic<ApiType>;
 }
-
 export interface ContractQuery<ApiType extends ApiTypes> extends MessageMeta {
-  (origin: AccountId | string | Uint8Array, options: ContractOptions, ...params: unknown[]): ContractCallResult<ApiType, ContractCallOutcome>;
+    (origin: AccountId | string | Uint8Array, options: ContractOptions, ...params: unknown[]): ContractCallResult<ApiType, ContractCallOutcome>;
 }
-
 export interface ContractTx<ApiType extends ApiTypes> extends MessageMeta {
-  (options: ContractOptions, ...params: unknown[]): SubmittableExtrinsic<ApiType>;
+    (options: ContractOptions, ...params: unknown[]): SubmittableExtrinsic<ApiType>;
 }
-
 export type ContractGeneric<O, T> = (messageOrId: AbiMessage | string | number, options: O, ...params: unknown[]) => T;
-
-export type ContractCallResult<ApiType extends ApiTypes, T> = ApiType extends 'rxjs'
-  ? Observable<T>
-  : Promise<ObsInnerType<Observable<T>>>;
-
+export type ContractCallResult<ApiType extends ApiTypes, T> = ApiType extends 'rxjs' ? Observable<T> : Promise<ObsInnerType<Observable<T>>>;
 export interface ContractCallSend<ApiType extends ApiTypes> {
-  send (account: string | AccountId | Uint8Array): ContractCallResult<ApiType, ContractCallOutcome>;
+    send(account: string | AccountId | Uint8Array): ContractCallResult<ApiType, ContractCallOutcome>;
 }
-
 export type MapConstructorExec<ApiType extends ApiTypes> = Record<string, BlueprintDeploy<ApiType>>;
-
 export type MapMessageTx<ApiType extends ApiTypes> = Record<string, ContractTx<ApiType>>;
-
 export type MapMessageQuery<ApiType extends ApiTypes> = Record<string, ContractQuery<ApiType>>;

package/cjs/base/types.js

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

package/cjs/base/util.d.ts

@@ -0,0 +1,16 @@
+import type { SubmittableResult } from '@pezkuwi/api';
+import type { SubmittableExtrinsic } from '@pezkuwi/api/submittable/types';
+import type { ApiTypes } from '@pezkuwi/api/types';
+import type { WeightV1, WeightV2 } from '@pezkuwi/types/interfaces';
+import type { BN } from '@pezkuwi/util';
+import type { AbiConstructor, AbiMessage, BlueprintOptions, WeightAll } from '../types.js';
+import type { BlueprintDeploy, ContractGeneric } from './types.js';
+export declare const EMPTY_SALT: Uint8Array;
+export declare function withMeta<T extends {
+    meta: AbiMessage;
+}>(meta: AbiMessage, creator: Omit<T, 'meta'>): T;
+export declare function createBluePrintTx<ApiType extends ApiTypes, R extends SubmittableResult>(meta: AbiMessage, fn: (options: BlueprintOptions, params: unknown[]) => SubmittableExtrinsic<ApiType, R>): BlueprintDeploy<ApiType>;
+export declare function createBluePrintWithId<T>(fn: (constructorOrId: AbiConstructor | string | number, options: BlueprintOptions, params: unknown[]) => T): ContractGeneric<BlueprintOptions, T>;
+export declare function encodeSalt(salt?: Uint8Array | string | null): Uint8Array;
+export declare function convertWeight(weight: WeightV1 | WeightV2 | bigint | string | number | BN): WeightAll;
+export declare function isWeightV2(weight: WeightV1 | WeightV2 | bigint | string | number | BN): weight is WeightV2;

package/cjs/base/util.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMPTY_SALT = void 0;
+exports.withMeta = withMeta;
+exports.createBluePrintTx = createBluePrintTx;
+exports.createBluePrintWithId = createBluePrintWithId;
+exports.encodeSalt = encodeSalt;
+exports.convertWeight = convertWeight;
+exports.isWeightV2 = isWeightV2;
+const types_1 = require("@pezkuwi/types");
+const util_1 = require("@pezkuwi/util");
+const util_crypto_1 = require("@pezkuwi/util-crypto");
+exports.EMPTY_SALT = new Uint8Array();
+function withMeta(meta, creator) {
+    creator.meta = meta;
+    return creator;
+}
+function createBluePrintTx(meta, fn) {
+    return withMeta(meta, (options, ...params) => fn(options, params));
+}
+function createBluePrintWithId(fn) {
+    return (constructorOrId, options, ...params) => fn(constructorOrId, options, params);
+}
+function encodeSalt(salt = (0, util_crypto_1.randomAsU8a)()) {
+    return salt instanceof types_1.Bytes
+        ? salt
+        : salt?.length
+            ? (0, util_1.compactAddLength)((0, util_1.u8aToU8a)(salt))
+            : exports.EMPTY_SALT;
+}
+function convertWeight(weight) {
+    const [refTime, proofSize] = isWeightV2(weight)
+        ? [weight.refTime.toBn(), weight.proofSize.toBn()]
+        : [(0, util_1.bnToBn)(weight), undefined];
+    return {
+        v1Weight: refTime,
+        v2Weight: { proofSize, refTime }
+    };
+}
+function isWeightV2(weight) {
+    return !!weight.proofSize;
+}

package/cjs/bundle.d.ts

@@ -0,0 +1,4 @@
+export { Abi } from './Abi/index.js';
+export { packageInfo } from './packageInfo.js';
+export * from './promise/index.js';
+export * from './rx/index.js';

package/cjs/bundle.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageInfo = exports.Abi = void 0;
+const tslib_1 = require("tslib");
+var index_js_1 = require("./Abi/index.js");
+Object.defineProperty(exports, "Abi", { enumerable: true, get: function () { return index_js_1.Abi; } });
+var packageInfo_js_1 = require("./packageInfo.js");
+Object.defineProperty(exports, "packageInfo", { enumerable: true, get: function () { return packageInfo_js_1.packageInfo; } });
+tslib_1.__exportStar(require("./promise/index.js"), exports);
+tslib_1.__exportStar(require("./rx/index.js"), exports);

package/cjs/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+require("./packageDetect.js");
+tslib_1.__exportStar(require("./bundle.js"), exports);

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/packageDetect.d.ts

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

package/cjs/packageDetect.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const packageInfo_1 = require("@pezkuwi/api/cjs/packageInfo");
+const packageInfo_2 = require("@pezkuwi/types/cjs/packageInfo");
+const util_1 = require("@pezkuwi/util");
+const packageInfo_js_1 = require("./packageInfo.js");
+(0, util_1.detectPackage)(packageInfo_js_1.packageInfo, null, [packageInfo_1.packageInfo, packageInfo_2.packageInfo]);

package/cjs/packageInfo.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageInfo = void 0;
+exports.packageInfo = { name: '@pezkuwi/api-contract', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '16.5.4' };

package/cjs/promise/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractPromise = exports.CodePromise = exports.BlueprintPromise = void 0;
+const api_1 = require("@pezkuwi/api");
+const index_js_1 = require("../base/index.js");
+class BlueprintPromise extends index_js_1.Blueprint {
+    constructor(api, abi, codeHash) {
+        super(api, abi, codeHash, api_1.toPromiseMethod);
+    }
+}
+exports.BlueprintPromise = BlueprintPromise;
+class CodePromise extends index_js_1.Code {
+    constructor(api, abi, wasm) {
+        super(api, abi, wasm, api_1.toPromiseMethod);
+    }
+}
+exports.CodePromise = CodePromise;
+class ContractPromise extends index_js_1.Contract {
+    constructor(api, abi, address) {
+        super(api, abi, address, api_1.toPromiseMethod);
+    }
+}
+exports.ContractPromise = ContractPromise;

package/cjs/promise/types.js

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

package/cjs/rx/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractRx = exports.CodeRx = exports.BlueprintRx = void 0;
+const api_1 = require("@pezkuwi/api");
+const index_js_1 = require("../base/index.js");
+class BlueprintRx extends index_js_1.Blueprint {
+    constructor(api, abi, codeHash) {
+        super(api, abi, codeHash, api_1.toRxMethod);
+    }
+}
+exports.BlueprintRx = BlueprintRx;
+class CodeRx extends index_js_1.Code {
+    constructor(api, abi, wasm) {
+        super(api, abi, wasm, api_1.toRxMethod);
+    }
+}
+exports.CodeRx = CodeRx;
+class ContractRx extends index_js_1.Contract {
+    constructor(api, abi, address) {
+        super(api, abi, address, api_1.toRxMethod);
+    }
+}
+exports.ContractRx = ContractRx;

package/cjs/rx/types.js

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

package/cjs/types.js

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

package/cjs/util.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyOnEvent = applyOnEvent;
+function applyOnEvent(result, types, fn, isRevive) {
+    if (result.isInBlock || result.isFinalized) {
+        const section = isRevive ? 'revive' : 'contracts';
+        const records = result.filterRecords(section, types);
+        if (records.length) {
+            return fn(records);
+        }
+    }
+    return undefined;
+}

package/index.d.ts

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

package/index.js

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