@pezkuwi/api-contract 16.5.5

package/src/base/Contract.ts

@@ -0,0 +1,197 @@
+// Copyright 2017-2025 @polkadot/api-contract authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ApiBase } from '@pezkuwi/api/base';
+import type { SubmittableExtrinsic } from '@pezkuwi/api/submittable/types';
+import type { ApiTypes, DecorateMethod } from '@pezkuwi/api/types';
+import type { AccountId, AccountId20, ContractExecResult, EventRecord, Weight, WeightV2 } from '@pezkuwi/types/interfaces';
+import type { ISubmittableResult } from '@pezkuwi/types/types';
+import type { Abi } from '../Abi/index.js';
+import type { AbiMessage, ContractCallOutcome, ContractOptions, DecodedEvent, WeightAll } from '../types.js';
+import type { ContractCallResult, ContractCallSend, ContractQuery, ContractTx, MapMessageQuery, MapMessageTx } from './types.js';
+
+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';
+
+export type ContractConstructor<ApiType extends ApiTypes> = new(api: ApiBase<ApiType>, abi: string | Record<string, unknown> | Abi, address: string | AccountId) => Contract<ApiType>;
+
+// As per Rust, 5 * GAS_PER_SEC
+const MAX_CALL_GAS = new BN(5_000_000_000_000).isub(BN_ONE);
+
+const l = logger('Contract');
+
+function createQuery <ApiType extends ApiTypes> (meta: AbiMessage, fn: (origin: string | AccountId | Uint8Array, options: ContractOptions, params: unknown[]) => ContractCallResult<ApiType, ContractCallOutcome>): ContractQuery<ApiType> {
+  return withMeta(meta, (origin: string | AccountId | Uint8Array, options: ContractOptions, ...params: unknown[]): ContractCallResult<ApiType, ContractCallOutcome> =>
+    fn(origin, options, params)
+  );
+}
+
+function createTx <ApiType extends ApiTypes> (meta: AbiMessage, fn: (options: ContractOptions, params: unknown[]) => SubmittableExtrinsic<ApiType>): ContractTx<ApiType> {
+  return withMeta(meta, (options: ContractOptions, ...params: unknown[]): SubmittableExtrinsic<ApiType> =>
+    fn(options, params)
+  );
+}
+
+export class ContractSubmittableResult extends SubmittableResult {
+  readonly contractEvents?: DecodedEvent[] | undefined;
+
+  constructor (result: ISubmittableResult, contractEvents?: DecodedEvent[]) {
+    super(result);
+
+    this.contractEvents = contractEvents;
+  }
+}
+
+export class Contract<ApiType extends ApiTypes> extends Base<ApiType> {
+  /**
+   * @description The on-chain address for this contract
+   */
+  readonly address: AccountId | AccountId20;
+
+  readonly #query: MapMessageQuery<ApiType> = {};
+  readonly #tx: MapMessageTx<ApiType> = {};
+
+  constructor (api: ApiBase<ApiType>, abi: string | Record<string, unknown> | Abi, address: string | AccountId | AccountId20, decorateMethod: DecorateMethod<ApiType>) {
+    super(api, abi, decorateMethod);
+
+    this.address = this.registry.createType(this._isRevive ? 'AccountId20' : 'AccountId', address);
+
+    this.abi.messages.forEach((m): void => {
+      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));
+      }
+    });
+  }
+
+  public get query (): MapMessageQuery<ApiType> {
+    return this.#query;
+  }
+
+  public get tx (): MapMessageTx<ApiType> {
+    return this.#tx;
+  }
+
+  #getGas = (_gasLimit: bigint | BN | string | number | WeightV2, isCall = false): WeightAll => {
+    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 as unknown as { maxBlock: WeightV2 }).maxBlock
+            : this.api.consts.system['maximumBlockWeight'] as Weight
+        ).v1Weight.muln(64).div(BN_HUNDRED)
+    );
+  };
+
+  #exec = (messageOrId: AbiMessage | string | number, { gasLimit = BN_ZERO, storageDepositLimit = null, value = BN_ZERO }: ContractOptions, params: unknown[]): SubmittableExtrinsic<ApiType> => {
+    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: ISubmittableResult) =>
+      // ContractEmitted is the current generation, ContractExecution is the previous generation
+      new ContractSubmittableResult(result, applyOnEvent(result, ['ContractEmitted', 'ContractExecution'], (records: EventRecord[]) =>
+        records
+          // Filter to only decode events emitted by this specific contract instance.
+          .filter((record): boolean => {
+            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 as Error).message}`);
+
+              return false;
+            }
+          })
+          .map((record): DecodedEvent | null => {
+            try {
+              return this.abi.decodeEvent(record);
+            } catch (error) {
+              l.error(`Unable to decode contract event: ${(error as Error).message}`);
+
+              return null;
+            }
+          })
+          .filter((decoded): decoded is DecodedEvent => !!decoded), this._isRevive
+      ))
+    );
+  };
+
+  #read = (messageOrId: AbiMessage | string | number, { gasLimit = BN_ZERO, storageDepositLimit = null, value = BN_ZERO }: ContractOptions, params: unknown[]): ContractCallSend<ApiType> => {
+    const message = this.abi.findMessage(messageOrId);
+
+    return {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      send: this._decorateMethod((origin: string | AccountId | Uint8Array) =>
+        (this._isRevive
+          ? this.api.rx.call.reviveApi.call
+          : this.api.rx.call.contractsApi.call)<ContractExecResult>(
+          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 }): ContractCallOutcome => ({
+            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 <ApiType extends ApiTypes> (type: ApiType, decorateMethod: DecorateMethod<ApiType>): ContractConstructor<ApiType> {
+  return class extends Contract<ApiType> {
+    static __ContractType = type;
+
+    constructor (api: ApiBase<ApiType>, abi: string | Record<string, unknown> | Abi, address: string | AccountId) {
+      super(api, abi, address, decorateMethod);
+    }
+  };
+}

package/src/base/index.ts

@@ -0,0 +1,6 @@
+// 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/src/base/mock.ts

@@ -0,0 +1,48 @@
+// Copyright 2017-2025 @polkadot/api-contract authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ApiBase } from '@pezkuwi/api/base';
+
+import { TypeRegistry } from '@pezkuwi/types';
+
+const registry = new TypeRegistry();
+
+const instantiateWithCode = (): never => {
+  throw new Error('mock');
+};
+
+instantiateWithCode.meta = { args: new Array(6) };
+
+export const mockApi = {
+  call: {
+    contractsApi: {
+      call: (): never => {
+        throw new Error('mock');
+      }
+    }
+  },
+  isConnected: true,
+  registry,
+  tx: {
+    contracts: {
+      instantiateWithCode
+    }
+  }
+} as unknown as ApiBase<'promise'>;
+
+export const mockReviveApi = {
+  call: {
+    reviveApi: {
+      call: (): never => {
+        throw new Error('mock');
+      }
+    }
+  },
+  isConnected: true,
+  registry,
+  tx: {
+    revive: {
+      instantiateWithCode
+    }
+  }
+} as unknown as ApiBase<'promise'>;

package/src/base/types.ts

@@ -0,0 +1,40 @@
+// 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;
+}
+
+export interface BlueprintDeploy<ApiType extends ApiTypes> extends MessageMeta {
+  (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>;
+}
+
+export interface ContractTx<ApiType extends ApiTypes> extends MessageMeta {
+  (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 interface ContractCallSend<ApiType extends ApiTypes> {
+  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/src/base/util.ts

@@ -0,0 +1,56 @@
+// Copyright 2017-2025 @polkadot/api-contract authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+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';
+
+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 <T extends { meta: AbiMessage }> (meta: AbiMessage, creator: Omit<T, 'meta'>): T {
+  (creator as T).meta = meta;
+
+  return creator as T;
+}
+
+export function createBluePrintTx <ApiType extends ApiTypes, R extends SubmittableResult> (meta: AbiMessage, fn: (options: BlueprintOptions, params: unknown[]) => SubmittableExtrinsic<ApiType, R>): BlueprintDeploy<ApiType> {
+  return withMeta(meta, (options: BlueprintOptions, ...params: unknown[]): SubmittableExtrinsic<ApiType, R> =>
+    fn(options, params)
+  );
+}
+
+export function createBluePrintWithId <T> (fn: (constructorOrId: AbiConstructor | string | number, options: BlueprintOptions, params: unknown[]) => T): ContractGeneric<BlueprintOptions, T> {
+  return (constructorOrId: AbiConstructor | string | number, options: BlueprintOptions, ...params: unknown[]): T =>
+    fn(constructorOrId, options, params);
+}
+
+export function encodeSalt (salt: Uint8Array | string | null = randomAsU8a()): Uint8Array {
+  return salt instanceof Bytes
+    ? salt
+    : salt?.length
+      ? compactAddLength(u8aToU8a(salt))
+      : EMPTY_SALT;
+}
+
+export function convertWeight (weight: WeightV1 | WeightV2 | bigint | string | number | BN): WeightAll {
+  const [refTime, proofSize] = isWeightV2(weight)
+    ? [weight.refTime.toBn(), weight.proofSize.toBn()]
+    : [bnToBn(weight), undefined];
+
+  return {
+    v1Weight: refTime,
+    v2Weight: { proofSize, refTime }
+  };
+}
+
+export function isWeightV2 (weight: WeightV1 | WeightV2 | bigint | string | number | BN): weight is WeightV2 {
+  return !!(weight as WeightV2).proofSize;
+}

package/src/bundle.ts

@@ -0,0 +1,10 @@
+// Copyright 2017-2025 @polkadot/api-contract authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// all named
+export { Abi } from './Abi/index.js';
+export { packageInfo } from './packageInfo.js';
+
+// all starred
+export * from './promise/index.js';
+export * from './rx/index.js';

package/src/checkTypes.manual.ts

@@ -0,0 +1,45 @@
+// Copyright 2017-2025 @polkadot/api-contract authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Simple non-runnable checks to test type definitions in the editor itself
+
+import '@pezkuwi/api-augment';
+
+import type { TestKeyringMapSubstrate } from '@pezkuwi/keyring/testingPairs';
+
+import { ApiPromise } from '@pezkuwi/api';
+import { BlueprintPromise, ContractPromise } from '@pezkuwi/api-contract';
+import { createTestPairs } from '@pezkuwi/keyring/testingPairs';
+
+import abiIncrementer from './test/contracts/ink/v0/incrementer.json' assert { type: 'json' };
+
+async function checkBlueprint (api: ApiPromise, pairs: TestKeyringMapSubstrate): Promise<void> {
+  const blueprint = new BlueprintPromise(api, abiIncrementer as Record<string, unknown>, '0x1234');
+
+  await blueprint.tx['new']({ gasLimit: 456, salt: '0x1234', value: 123 }, 42).signAndSend(pairs.bob);
+  await blueprint.tx['new']({ gasLimit: 456, value: 123 }, 42).signAndSend(pairs.bob);
+}
+
+async function checkContract (api: ApiPromise, pairs: TestKeyringMapSubstrate): Promise<void> {
+  const contract = new ContractPromise(api, abiIncrementer as Record<string, unknown>, '0x1234');
+
+  // queries
+  await contract.query['get'](pairs.alice.address, {});
+
+  // execute
+  await contract.tx['inc']({ gasLimit: 1234 }, 123).signAndSend(pairs.eve);
+}
+
+async function main (): Promise<void> {
+  const api = await ApiPromise.create({
+    hasher: (data: Uint8Array): Uint8Array => data
+  });
+  const pairs = createTestPairs();
+
+  await Promise.all([
+    checkBlueprint(api, pairs),
+    checkContract(api, pairs)
+  ]);
+}
+
+main().catch(console.error);

package/src/index.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2025 @polkadot/api-contract authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import './packageDetect.js';
+
+export * from './bundle.js';

package/src/mod.ts

@@ -0,0 +1,4 @@
+// Copyright 2017-2025 @polkadot/api-contract authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './index.js';

package/src/packageDetect.ts

@@ -0,0 +1,13 @@
+// Copyright 2017-2025 @polkadot/api-contract authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Do not edit, auto-generated by @polkadot/dev
+// (packageInfo imports will be kept as-is, user-editable)
+
+import { packageInfo as apiInfo } from '@pezkuwi/api/packageInfo';
+import { packageInfo as typesInfo } from '@pezkuwi/types/packageInfo';
+import { detectPackage } from '@pezkuwi/util';
+
+import { packageInfo } from './packageInfo.js';
+
+detectPackage(packageInfo, null, [apiInfo, typesInfo]);

package/src/packageInfo.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2025 @polkadot/api-contract authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Do not edit, auto-generated by @polkadot/dev
+
+export const packageInfo = { name: '@pezkuwi/api-contract', path: 'auto', type: 'auto', version: '16.5.5' };

package/src/promise/index.ts

@@ -0,0 +1,28 @@
+// Copyright 2017-2025 @polkadot/api-contract authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ApiPromise } from '@pezkuwi/api';
+import type { AccountId, AccountId20, Hash } from '@pezkuwi/types/interfaces';
+import type { Abi } from '../Abi/index.js';
+
+import { toPromiseMethod } from '@pezkuwi/api';
+
+import { Blueprint, Code, Contract } from '../base/index.js';
+
+export class BlueprintPromise extends Blueprint<'promise'> {
+  constructor (api: ApiPromise, abi: string | Record<string, unknown> | Abi, codeHash: string | Hash) {
+    super(api, abi, codeHash, toPromiseMethod);
+  }
+}
+
+export class CodePromise extends Code<'promise'> {
+  constructor (api: ApiPromise, abi: string | Record<string, unknown> | Abi, wasm: Uint8Array | string | Buffer | null | undefined) {
+    super(api, abi, wasm, toPromiseMethod);
+  }
+}
+
+export class ContractPromise extends Contract<'promise'> {
+  constructor (api: ApiPromise, abi: string | Record<string, unknown> | Abi, address: string | AccountId | AccountId20) {
+    super(api, abi, address, toPromiseMethod);
+  }
+}

package/src/promise/types.ts

@@ -0,0 +1,7 @@
+// Copyright 2017-2025 @polkadot/api-contract authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { BlueprintSubmittableResult as BaseBlueprintSubmittableResult, CodeSubmittableResult as BaseCodeSubmittableResult } from '../base/index.js';
+
+export type BlueprintSubmittableResult = BaseBlueprintSubmittableResult<'promise'>;
+export type CodeSubmittableResult = BaseCodeSubmittableResult<'promise'>;

package/src/rx/index.ts

@@ -0,0 +1,28 @@
+// Copyright 2017-2025 @polkadot/api-contract authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ApiRx } from '@pezkuwi/api';
+import type { AccountId, Hash } from '@pezkuwi/types/interfaces';
+import type { Abi } from '../Abi/index.js';
+
+import { toRxMethod } from '@pezkuwi/api';
+
+import { Blueprint, Code, Contract } from '../base/index.js';
+
+export class BlueprintRx extends Blueprint<'rxjs'> {
+  constructor (api: ApiRx, abi: string | Record<string, unknown> | Abi, codeHash: string | Hash) {
+    super(api, abi, codeHash, toRxMethod);
+  }
+}
+
+export class CodeRx extends Code<'rxjs'> {
+  constructor (api: ApiRx, abi: string | Record<string, unknown> | Abi, wasm: Uint8Array | string | Buffer | null | undefined) {
+    super(api, abi, wasm, toRxMethod);
+  }
+}
+
+export class ContractRx extends Contract<'rxjs'> {
+  constructor (api: ApiRx, abi: string | Record<string, unknown> | Abi, address: string | AccountId) {
+    super(api, abi, address, toRxMethod);
+  }
+}

package/src/rx/types.ts

@@ -0,0 +1,7 @@
+// Copyright 2017-2025 @polkadot/api-contract authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { BlueprintSubmittableResult as BaseBlueprintSubmittableResult, CodeSubmittableResult as BaseCodeSubmittableResult } from '../base/index.js';
+
+export type BlueprintSubmittableResult = BaseBlueprintSubmittableResult<'promise'>;
+export type CodeSubmittableResult = BaseCodeSubmittableResult<'promise'>;

package/src/test/compare/ink_v0_delegator.test.json

@@ -0,0 +1,47 @@
+[
+  {
+    "info": "Plain",
+    "lookupIndex": 1,
+    "type": "AccountId",
+    "docs": [],
+    "namespace": "ink_env::types::AccountId",
+    "lookupNameRoot": "InkEnvAccountId"
+  },
+  {
+    "info": "VecFixed",
+    "lookupIndex": 2,
+    "type": "[u8;32]",
+    "docs": [],
+    "namespace": "",
+    "length": 32,
+    "sub": {
+      "info": "Plain",
+      "lookupIndex": 3,
+      "type": "u8",
+      "docs": [],
+      "namespace": ""
+    }
+  },
+  {
+    "info": "Plain",
+    "lookupIndex": 3,
+    "type": "u8",
+    "docs": [],
+    "namespace": ""
+  },
+  {
+    "info": "Plain",
+    "lookupIndex": 4,
+    "type": "i32",
+    "docs": [],
+    "namespace": ""
+  },
+  {
+    "info": "Plain",
+    "lookupIndex": 5,
+    "type": "Hash",
+    "docs": [],
+    "namespace": "ink_env::types::Hash",
+    "lookupNameRoot": "InkEnvHash"
+  }
+]