@pezkuwi/api-contract 16.5.5 → 16.5.6

package/base/Base.js

@@ -0,0 +1,40 @@
+import { isFunction } from '@pezkuwi/util';
+import { Abi } from '../Abi/index.js';
+export 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 Abi
+            ? abi
+            : new 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 || !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 || !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 || !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 || !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;
+    }
+}

package/base/Blueprint.js

@@ -0,0 +1,51 @@
+import { SubmittableResult } from '@pezkuwi/api';
+import { BN_ZERO, isUndefined } from '@pezkuwi/util';
+import { applyOnEvent } from '../util.js';
+import { Base } from './Base.js';
+import { Contract } from './Contract.js';
+import { convertWeight, createBluePrintTx, encodeSalt } from './util.js';
+export class BlueprintSubmittableResult extends SubmittableResult {
+    contract;
+    constructor(result, contract) {
+        super(result);
+        this.contract = contract;
+    }
+}
+export class Blueprint extends 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 (isUndefined(this.#tx[c.method])) {
+                this.#tx[c.method] = createBluePrintTx(c, (o, p) => this.#deploy(c, o, p));
+            }
+        });
+    }
+    get tx() {
+        return this.#tx;
+    }
+    #deploy = (constructorOrId, { gasLimit = BN_ZERO, salt, storageDepositLimit = null, value = 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
+            ? convertWeight(gasLimit).v1Weight
+            : convertWeight(gasLimit).v2Weight, storageDepositLimit, this.codeHash, this.abi.findConstructor(constructorOrId).toU8a(params), encodeSalt(salt)).withResultTransform((result) => new BlueprintSubmittableResult(result, applyOnEvent(result, ['Instantiated'], ([record]) => new Contract(this.api, this.abi, record.event.data[1], this._decorateMethod), this._isRevive)));
+    };
+}
+export function extendBlueprint(type, decorateMethod) {
+    return class extends Blueprint {
+        static __BlueprintType = type;
+        constructor(api, abi, codeHash) {
+            super(api, abi, codeHash, decorateMethod);
+        }
+    };
+}

package/base/Code.js

@@ -0,0 +1,74 @@
+import { SubmittableResult } from '@pezkuwi/api';
+import { BN_ZERO, compactAddLength, isRiscV, isUndefined, isWasm, u8aToU8a } from '@pezkuwi/util';
+import { applyOnEvent } from '../util.js';
+import { Base } from './Base.js';
+import { Blueprint } from './Blueprint.js';
+import { Contract } from './Contract.js';
+import { convertWeight, createBluePrintTx, encodeSalt } from './util.js';
+export class CodeSubmittableResult extends SubmittableResult {
+    blueprint;
+    contract;
+    constructor(result, blueprint, contract) {
+        super(result);
+        this.blueprint = blueprint;
+        this.contract = contract;
+    }
+}
+function isValidCode(code) {
+    return isWasm(code) || isRiscV(code);
+}
+export class Code extends 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
+            : u8aToU8a(wasm);
+        if (!isValidCode(this.code)) {
+            throw new Error('Invalid code provided');
+        }
+        this.abi.constructors.forEach((c) => {
+            if (isUndefined(this.#tx[c.method])) {
+                this.#tx[c.method] = createBluePrintTx(c, (o, p) => this.#instantiate(c, o, p));
+            }
+        });
+    }
+    get tx() {
+        return this.#tx;
+    }
+    #instantiate = (constructorOrId, { gasLimit = BN_ZERO, salt, storageDepositLimit = null, value = 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
+                ? convertWeight(gasLimit).v1Weight
+                : convertWeight(gasLimit).v2Weight, storageDepositLimit, compactAddLength(this.code), this.abi.findConstructor(constructorOrId).toU8a(params), encodeSalt(salt)).withResultTransform((result) => new CodeSubmittableResult(result, ...(applyOnEvent(result, ['Instantiated'], (records) => records.reduce(([blueprint, contract], { event }) => this.api.events.revive['Instantiated'].is(event)
+                ? [
+                    blueprint,
+                    new 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
+            ? convertWeight(gasLimit).v1Weight
+            : convertWeight(gasLimit).v2Weight, storageDepositLimit, compactAddLength(this.code), this.abi.findConstructor(constructorOrId).toU8a(params), encodeSalt(salt)).withResultTransform((result) => new CodeSubmittableResult(result, ...(applyOnEvent(result, ['CodeStored', 'Instantiated'], (records) => records.reduce(([blueprint, contract], { event }) => this.api.events.contracts.Instantiated.is(event)
+            ? [blueprint, new Contract(this.api, this.abi, event.data[1], this._decorateMethod)]
+            : this.api.events.contracts.CodeStored.is(event)
+                ? [new Blueprint(this.api, this.abi, event.data[0], this._decorateMethod), contract]
+                : [blueprint, contract], [undefined, undefined]), this._isRevive) || [undefined, undefined])));
+    };
+}
+export function extendCode(type, decorateMethod) {
+    return class extends Code {
+        static __CodeType = type;
+        constructor(api, abi, wasm) {
+            super(api, abi, wasm, decorateMethod);
+        }
+    };
+}

package/base/Contract.js

@@ -0,0 +1,127 @@
+import { map } from 'rxjs';
+import { SubmittableResult } from '@pezkuwi/api';
+import { BN, BN_HUNDRED, BN_ONE, BN_ZERO, isUndefined, logger } from '@pezkuwi/util';
+import { applyOnEvent } from '../util.js';
+import { Base } from './Base.js';
+import { convertWeight, withMeta } from './util.js';
+const MAX_CALL_GAS = new BN(5_000_000_000_000).isub(BN_ONE);
+const l = logger('Contract');
+function createQuery(meta, fn) {
+    return withMeta(meta, (origin, options, ...params) => fn(origin, options, params));
+}
+function createTx(meta, fn) {
+    return withMeta(meta, (options, ...params) => fn(options, params));
+}
+export class ContractSubmittableResult extends SubmittableResult {
+    contractEvents;
+    constructor(result, contractEvents) {
+        super(result);
+        this.contractEvents = contractEvents;
+    }
+}
+export class Contract extends 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 (isUndefined(this.#tx[m.method])) {
+                this.#tx[m.method] = createTx(m, (o, p) => this.#exec(m, o, p));
+            }
+            if (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 = convertWeight(_gasLimit);
+        if (weight.v1Weight.gt(BN_ZERO)) {
+            return weight;
+        }
+        return convertWeight(isCall
+            ? MAX_CALL_GAS
+            : convertWeight(this.api.consts.system.blockWeights
+                ? this.api.consts.system.blockWeights.maxBlock
+                : this.api.consts.system['maximumBlockWeight']).v1Weight.muln(64).div(BN_HUNDRED));
+    };
+    #exec = (messageOrId, { gasLimit = BN_ZERO, storageDepositLimit = null, value = 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
+            ? convertWeight(gasLimit).v1Weight
+            : 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, 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 = BN_ZERO, storageDepositLimit = null, value = 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(map(({ debugMessage, gasConsumed, gasRequired, result, storageDeposit }) => ({
+                debugMessage,
+                gasConsumed,
+                gasRequired: gasRequired && !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
+            }))))
+        };
+    };
+}
+export function extendContract(type, decorateMethod) {
+    return class extends Contract {
+        static __ContractType = type;
+        constructor(api, abi, address) {
+            super(api, abi, address, decorateMethod);
+        }
+    };
+}

package/{src/base/index.ts → base/index.js}

@@ -1,6 +1,3 @@
-// Copyright 2017-2025 @polkadot/api authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 export { Blueprint, BlueprintSubmittableResult, extendBlueprint } from './Blueprint.js';
 export { Code, CodeSubmittableResult, extendCode } from './Code.js';
 export { Contract, extendContract } from './Contract.js';

package/base/mock.js

@@ -0,0 +1,38 @@
+import { TypeRegistry } from '@pezkuwi/types';
+const registry = new TypeRegistry();
+const instantiateWithCode = () => {
+    throw new Error('mock');
+};
+instantiateWithCode.meta = { args: new Array(6) };
+export const mockApi = {
+    call: {
+        contractsApi: {
+            call: () => {
+                throw new Error('mock');
+            }
+        }
+    },
+    isConnected: true,
+    registry,
+    tx: {
+        contracts: {
+            instantiateWithCode
+        }
+    }
+};
+export const mockReviveApi = {
+    call: {
+        reviveApi: {
+            call: () => {
+                throw new Error('mock');
+            }
+        }
+    },
+    isConnected: true,
+    registry,
+    tx: {
+        revive: {
+            instantiateWithCode
+        }
+    }
+};

package/{build/base → base}/util.d.ts

@@ -5,7 +5,7 @@ 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<ArrayBuffer>;
+export declare const EMPTY_SALT: Uint8Array;
 export declare function withMeta<T extends {
     meta: AbiMessage;
 }>(meta: AbiMessage, creator: Omit<T, 'meta'>): T;

package/base/util.js

@@ -0,0 +1,33 @@
+import { Bytes } from '@pezkuwi/types';
+import { bnToBn, compactAddLength, u8aToU8a } from '@pezkuwi/util';
+import { randomAsU8a } from '@pezkuwi/util-crypto';
+export const EMPTY_SALT = new Uint8Array();
+export function withMeta(meta, creator) {
+    creator.meta = meta;
+    return creator;
+}
+export function createBluePrintTx(meta, fn) {
+    return withMeta(meta, (options, ...params) => fn(options, params));
+}
+export function createBluePrintWithId(fn) {
+    return (constructorOrId, options, ...params) => fn(constructorOrId, options, params);
+}
+export function encodeSalt(salt = randomAsU8a()) {
+    return salt instanceof Bytes
+        ? salt
+        : salt?.length
+            ? compactAddLength(u8aToU8a(salt))
+            : EMPTY_SALT;
+}
+export function convertWeight(weight) {
+    const [refTime, proofSize] = isWeightV2(weight)
+        ? [weight.refTime.toBn(), weight.proofSize.toBn()]
+        : [bnToBn(weight), undefined];
+    return {
+        v1Weight: refTime,
+        v2Weight: { proofSize, refTime }
+    };
+}
+export function isWeightV2(weight) {
+    return !!weight.proofSize;
+}