@pezkuwi/api-contract 16.5.5 → 16.5.6

package/src/base/Code.ts

@@ -1,142 +0,0 @@
-// 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, EventRecord } from '@pezkuwi/types/interfaces';
-import type { ISubmittableResult } from '@pezkuwi/types/types';
-import type { Codec } from '@pezkuwi/types-codec/types';
-import type { Abi } from '../Abi/index.js';
-import type { AbiConstructor, BlueprintOptions } from '../types.js';
-import type { MapConstructorExec } from './types.js';
-
-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 type CodeConstructor<ApiType extends ApiTypes> = new(api: ApiBase<ApiType>, abi: string | Record<string, unknown> | Abi, wasm: Uint8Array | string | Buffer | null | undefined) => Code<ApiType>;
-
-export 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) {
-    super(result);
-
-    this.blueprint = blueprint;
-    this.contract = contract;
-  }
-}
-
-// checks to see if the code (or at least the header)
-// is a valid/supported format
-function isValidCode (code: Uint8Array): boolean {
-  return isWasm(code) || isRiscV(code);
-}
-
-export class Code<ApiType extends ApiTypes> extends Base<ApiType> {
-  readonly code: Uint8Array;
-
-  readonly #tx: MapConstructorExec<ApiType> = {};
-
-  constructor (api: ApiBase<ApiType>, abi: string | Record<string, unknown> | Abi, wasm: Uint8Array | string | Buffer | null | undefined, decorateMethod: DecorateMethod<ApiType>) {
-    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): void => {
-      if (isUndefined(this.#tx[c.method])) {
-        this.#tx[c.method] = createBluePrintTx(c, (o, p) => this.#instantiate(c, o, p));
-      }
-    });
-  }
-
-  public get tx (): MapConstructorExec<ApiType> {
-    return this.#tx;
-  }
-
-  #instantiate = (constructorOrId: AbiConstructor | string | number, { gasLimit = BN_ZERO, salt, storageDepositLimit = null, value = BN_ZERO }: BlueprintOptions, params: unknown[]): SubmittableExtrinsic<ApiType, CodeSubmittableResult<ApiType>> => {
-    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: ISubmittableResult) =>
-        new CodeSubmittableResult(
-          result,
-          ...(applyOnEvent(result, ['Instantiated'], (records: EventRecord[]) =>
-            records.reduce<[Blueprint<ApiType> | undefined, Contract<ApiType> | undefined]>(
-              ([blueprint, contract], { event }) =>
-                this.api.events.revive['Instantiated'].is(event)
-                  ? [
-                    blueprint,
-                    new Contract<ApiType>(
-                      this.api,
-                      this.abi,
-                      (event as unknown as { data: [Codec, AccountId] }).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: ISubmittableResult) =>
-      new CodeSubmittableResult(result, ...(applyOnEvent(result, ['CodeStored', 'Instantiated'], (records: EventRecord[]) =>
-        records.reduce<[Blueprint<ApiType> | undefined, Contract<ApiType> | undefined]>(([blueprint, contract], { event }) =>
-          this.api.events.contracts.Instantiated.is(event)
-            ? [blueprint, new Contract<ApiType>(this.api, this.abi, (event as unknown as { data: [Codec, AccountId] }).data[1], this._decorateMethod)]
-            : this.api.events.contracts.CodeStored.is(event)
-              ? [new Blueprint<ApiType>(this.api, this.abi, (event as unknown as { data: [AccountId] }).data[0], this._decorateMethod), contract]
-              : [blueprint, contract],
-        [undefined, undefined]), this._isRevive
-      ) || [undefined, undefined]))
-    );
-  };
-}
-
-export function extendCode <ApiType extends ApiTypes> (type: ApiType, decorateMethod: DecorateMethod<ApiType>): CodeConstructor<ApiType> {
-  return class extends Code<ApiType> {
-    static __CodeType = type;
-
-    constructor (api: ApiBase<ApiType>, abi: string | Record<string, unknown> | Abi, wasm: Uint8Array | string | Buffer | null | undefined) {
-      super(api, abi, wasm, decorateMethod);
-    }
-  };
-}

package/src/base/Contract.ts

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

@@ -1,48 +0,0 @@
-// 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/util.ts

@@ -1,56 +0,0 @@
-// 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/checkTypes.manual.ts

@@ -1,45 +0,0 @@
-// 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

@@ -1,6 +0,0 @@
-// 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

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

package/src/packageInfo.ts

@@ -1,6 +0,0 @@
-// 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

@@ -1,28 +0,0 @@
-// 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/rx/index.ts

@@ -1,28 +0,0 @@
-// 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/test/compare/ink_v0_delegator.test.json

@@ -1,47 +0,0 @@
-[
-  {
-    "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"
-  }
-]