@pezkuwi/api-contract 16.5.5 → 16.5.8

package/build-deno/mod.ts

@@ -0,0 +1,2 @@
+
+export * from './index.ts';

package/build-deno/packageDetect.ts

@@ -0,0 +1,9 @@
+
+
+import { packageInfo as apiInfo } from 'https://deno.land/x/pezkuwi/api/packageInfo.ts';
+import { packageInfo as typesInfo } from 'https://deno.land/x/pezkuwi/types/packageInfo.ts';
+import { detectPackage } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { packageInfo } from './packageInfo.ts';
+
+detectPackage(packageInfo, null, [apiInfo, typesInfo]);

package/build-deno/packageInfo.ts

@@ -0,0 +1,3 @@
+
+
+export const packageInfo = { name: '@pezkuwi/api-contract', path: new URL(import.meta.url).pathname, type: 'deno', version: '16.5.8' };

package/build-deno/promise/index.ts

@@ -0,0 +1,28 @@
+import { Buffer } from 'node:buffer';
+
+
+import type { ApiPromise } from 'https://deno.land/x/pezkuwi/api/mod.ts';
+import type { AccountId, AccountId20, Hash } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { Abi } from '../Abi/index.ts';
+
+import { toPromiseMethod } from 'https://deno.land/x/pezkuwi/api/mod.ts';
+
+import { Blueprint, Code, Contract } from '../base/index.ts';
+
+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/build-deno/promise/types.ts

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

package/build-deno/rx/index.ts

@@ -0,0 +1,28 @@
+import { Buffer } from 'node:buffer';
+
+
+import type { ApiRx } from 'https://deno.land/x/pezkuwi/api/mod.ts';
+import type { AccountId, Hash } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { Abi } from '../Abi/index.ts';
+
+import { toRxMethod } from 'https://deno.land/x/pezkuwi/api/mod.ts';
+
+import { Blueprint, Code, Contract } from '../base/index.ts';
+
+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/build-deno/rx/types.ts

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

package/build-deno/test/contracts/index.ts

@@ -0,0 +1,18 @@
+
+import ink from './ink/index.ts';
+import solang from './solang/index.ts';
+import user from './user/index.ts';
+
+const all: Record<string, Record<string, unknown>> = {};
+
+Object
+  .entries({ ink, solang, user })
+  .forEach(([type, abis]) =>
+    Object
+      .entries(abis)
+      .forEach(([name, abi]): void => {
+        all[`${type}_${name}`] = abi;
+      })
+  );
+
+export default all;

package/build-deno/test/contracts/ink/index.ts

@@ -0,0 +1,11 @@
+
+import { createVersionedExport } from '../util.ts';
+import * as v0 from './v0/index.ts';
+import * as v1 from './v1/index.ts';
+import * as v2 from './v2/index.ts';
+import * as v3 from './v3/index.ts';
+import * as v4 from './v4/index.ts';
+import * as v5 from './v5/index.ts';
+import * as v6 from './v6/index.ts';
+
+export default createVersionedExport({ v0, v1, v2, v3, v4, v5, v6 });

package/build-deno/test/contracts/ink/v0/index.ts

@@ -0,0 +1,9 @@
+
+export { default as delegator } from './delegator.json' assert { type: 'json' };
+export { default as dns } from './dns.json' assert { type: 'json' };
+export { default as erc20 } from './erc20.json' assert { type: 'json' };
+export { default as erc721 } from './erc721.json' assert { type: 'json' };
+export { default as flipperBundle } from './flipper.contract.json' assert { type: 'json' };
+export { default as flipper } from './flipper.json' assert { type: 'json' };
+export { default as incrementer } from './incrementer.json' assert { type: 'json' };
+export { default as multisigPlain } from './multisig_plain.json' assert { type: 'json' };

package/build-deno/test/contracts/ink/v1/index.ts

@@ -0,0 +1,3 @@
+
+export { default as flipper } from './flipper.contract.json' assert { type: 'json' };
+export { default as psp22 } from './psp22_minter_pauser.contract.json' assert { type: 'json' };

package/build-deno/test/contracts/ink/v2/index.ts

@@ -0,0 +1,3 @@
+
+export { default as erc20 } from './erc20.contract.json' assert { type: 'json' };
+export { default as flipper } from './flipper.contract.json' assert { type: 'json' };

package/build-deno/test/contracts/ink/v3/index.ts

@@ -0,0 +1,3 @@
+
+export { default as flipper } from './flipper.contract.json' assert { type: 'json' };
+export { default as traitErc20 } from './trait_erc20.contract.json' assert { type: 'json' };

package/build-deno/test/contracts/ink/v4/index.ts

@@ -0,0 +1,5 @@
+
+export { default as erc20Contract } from './erc20.contract.json' assert { type: 'json' };
+export { default as erc20Metadata } from './erc20.json' assert { type: 'json' };
+export { default as flipperContract } from './flipper.contract.json' assert { type: 'json' };
+export { default as flipperMetadata } from './flipper.json' assert { type: 'json' };

package/build-deno/test/contracts/ink/v5/index.ts

@@ -0,0 +1,6 @@
+
+export { default as erc20Contract } from './erc20.contract.json' assert { type: 'json' };
+export { default as erc20Metadata } from './erc20.json' assert { type: 'json' };
+export { default as erc20AnonymousTransferMetadata } from './erc20_anonymous_transfer.json' assert { type: 'json' };
+export { default as flipperContract } from './flipper.contract.json' assert { type: 'json' };
+export { default as flipperMetadata } from './flipper.json' assert { type: 'json' };

package/build-deno/test/contracts/ink/v6/index.ts

@@ -0,0 +1,3 @@
+
+export { default as erc20Contract } from './erc20.contract.json' assert { type: 'json' };
+export { default as erc20Metadata } from './erc20.json' assert { type: 'json' };

package/build-deno/test/contracts/solang/index.ts

@@ -0,0 +1,5 @@
+
+import { createVersionedExport } from '../util.ts';
+import * as v0 from './v0/index.ts';
+
+export default createVersionedExport({ v0 });

package/build-deno/test/contracts/solang/v0/index.ts

@@ -0,0 +1,2 @@
+
+export { default as ints256 } from './ints256.json' assert { type: 'json' };

package/build-deno/test/contracts/solang/v0/ints256.sol

@@ -0,0 +1,13 @@
+/// @title Test 256 bits types
+/// @author Sean Young <sean@mess.org>
+contract ints256 {
+	/// Multiply two 256 bit values
+	function multiply(uint256 a, uint256 b) public pure returns (uint256) {
+		return a * b;
+	}
+
+	/// Add two 256 bit values
+	function add(uint256 a, uint256 b) public pure returns (uint256) {
+		return a + b;
+	}
+}

package/build-deno/test/contracts/user/index.ts

@@ -0,0 +1,7 @@
+
+import { createVersionedExport } from '../util.ts';
+import * as v0 from './v0/index.ts';
+import * as v3 from './v3/index.ts';
+import * as v4 from './v4/index.ts';
+
+export default createVersionedExport({ v0, v3, v4 });

package/build-deno/test/contracts/user/v0/index.ts

@@ -0,0 +1,5 @@
+
+export { default as assetTransfer } from './assetTransfer.json' assert { type: 'json' };
+export { default as enumExample } from './enumExample.json' assert { type: 'json' };
+export { default as recursive } from './recursive.contract.json' assert { type: 'json' };
+export { default as withString } from './withString.json' assert { type: 'json' };

package/build-deno/test/contracts/user/v3/index.ts

@@ -0,0 +1,2 @@
+
+export { default as ask } from './ask.json' assert { type: 'json' };

package/build-deno/test/contracts/user/v4/index.ts

@@ -0,0 +1,2 @@
+
+export { default as events } from './events.contract.json' assert { type: 'json' };

package/build-deno/test/contracts/util.ts

@@ -0,0 +1,12 @@
+
+export function createVersionedExport (versioned: Record<string, Record<string, unknown>>): Record<string, Record<string, unknown>> {
+  const result: Record<string, Record<string, unknown>> = {};
+
+  Object.entries(versioned).forEach(([version, contracts]) =>
+    Object.entries(contracts).forEach(([name, contract]): void => {
+      result[`${version}_${name}`] = contract as Record<string, unknown>;
+    })
+  );
+
+  return result;
+}

package/build-deno/types.ts

@@ -0,0 +1,95 @@
+
+import type { ApiBase } from 'https://deno.land/x/pezkuwi/api/base/index.ts';
+import type { ApiTypes } from 'https://deno.land/x/pezkuwi/api/types/index.ts';
+import type { Text } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+import type { ContractExecResultResult, ContractSelector, StorageDeposit, Weight, WeightV2 } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { Codec, TypeDef } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+import type { BN } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+import type { HexString } from 'https://deno.land/x/pezkuwi/util/types.ts';
+import type { Abi } from './index.ts';
+
+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-deno/util.ts

@@ -0,0 +1,18 @@
+
+import type { SubmittableResult } from 'https://deno.land/x/pezkuwi/api/mod.ts';
+import type { EventRecord } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+
+type ContractEvents = 'CodeStored' | 'ContractEmitted' | 'ContractExecution' | 'Instantiated';
+
+export function applyOnEvent <T> (result: SubmittableResult, types: ContractEvents[], fn: (records: EventRecord[]) => T, isRevive: boolean): T | undefined {
+  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/build-tsc/Abi/index.d.ts

@@ -0,0 +1,31 @@
+import type { ChainProperties, ContractMetadataV4, ContractMetadataV5, ContractMetadataV6, ContractProjectInfo, EventRecord } from '@pezkuwi/types/interfaces';
+import type { Codec, Registry, TypeDef } from '@pezkuwi/types/types';
+import type { AbiConstructor, AbiEvent, AbiMessage, DecodedEvent, DecodedMessage } from '../types.js';
+export type ContractMetadataSupported = ContractMetadataV4 | ContractMetadataV5 | ContractMetadataV6;
+export declare class Abi {
+    #private;
+    readonly events: AbiEvent[];
+    readonly constructors: AbiConstructor[];
+    readonly info: ContractProjectInfo;
+    readonly json: Record<string, unknown>;
+    readonly messages: AbiMessage[];
+    readonly metadata: ContractMetadataSupported;
+    readonly registry: Registry;
+    readonly environment: Map<string, TypeDef | Codec>;
+    readonly isRevive: boolean;
+    constructor(abiJson: Record<string, unknown> | string, chainProperties?: ChainProperties);
+    /**
+     * Warning: Unstable API, bound to change
+     */
+    decodeEvent(record: EventRecord): DecodedEvent;
+    /**
+     * Warning: Unstable API, bound to change
+     */
+    decodeConstructor(data: Uint8Array): DecodedMessage;
+    /**
+     * Warning: Unstable API, bound to change
+     */
+    decodeMessage(data: Uint8Array): DecodedMessage;
+    findConstructor(constructorOrId: AbiConstructor | string | number): AbiConstructor;
+    findMessage(messageOrId: AbiMessage | string | number): AbiMessage;
+}

package/build-tsc/Abi/toLatestCompatible.d.ts

@@ -0,0 +1,15 @@
+import type { ContractMetadataV4, ContractMetadataV5, ContractMetadataV6 } from '@pezkuwi/types/interfaces';
+import type { Registry } from '@pezkuwi/types/types';
+import type { ContractMetadataSupported } from './index.js';
+export declare const enumVersions: readonly ["V6", "V5", "V4", "V3", "V2", "V1"];
+type Versions = typeof enumVersions[number] | 'V0';
+type Converter = (registry: Registry, vx: any) => ContractMetadataSupported;
+export declare function v6ToLatestCompatible(_registry: Registry, v6: ContractMetadataV6): ContractMetadataV6;
+export declare function v5ToLatestCompatible(_registry: Registry, v5: ContractMetadataV5): ContractMetadataV5;
+export declare function v4ToLatestCompatible(_registry: Registry, v4: ContractMetadataV4): ContractMetadataV4;
+export declare const v3ToLatestCompatible: (registry: Registry, input: import("@pezkuwi/types/interfaces").ContractMetadataV3) => ContractMetadataSupported;
+export declare const v2ToLatestCompatible: (registry: Registry, input: import("@pezkuwi/types/interfaces").ContractMetadataV2) => ContractMetadataSupported;
+export declare const v1ToLatestCompatible: (registry: Registry, input: import("@pezkuwi/types/interfaces").ContractMetadataV1) => ContractMetadataSupported;
+export declare const v0ToLatestCompatible: (registry: Registry, input: import("@pezkuwi/types/interfaces").ContractMetadataV0) => ContractMetadataSupported;
+export declare const convertVersions: [Versions, Converter][];
+export {};

package/build-tsc/Abi/toV1.d.ts

@@ -0,0 +1,3 @@
+import type { ContractMetadataV0, ContractMetadataV1 } from '@pezkuwi/types/interfaces';
+import type { Registry } from '@pezkuwi/types/types';
+export declare function v0ToV1(registry: Registry, v0: ContractMetadataV0): ContractMetadataV1;

package/build-tsc/Abi/toV2.d.ts

@@ -0,0 +1,3 @@
+import type { ContractMetadataV1, ContractMetadataV2 } from '@pezkuwi/types/interfaces';
+import type { Registry } from '@pezkuwi/types/types';
+export declare function v1ToV2(registry: Registry, v1: ContractMetadataV1): ContractMetadataV2;

package/build-tsc/Abi/toV3.d.ts

@@ -0,0 +1,3 @@
+import type { ContractMetadataV2, ContractMetadataV3 } from '@pezkuwi/types/interfaces';
+import type { Registry } from '@pezkuwi/types/types';
+export declare function v2ToV3(registry: Registry, v2: ContractMetadataV2): ContractMetadataV3;

package/build-tsc/Abi/toV4.d.ts

@@ -0,0 +1,3 @@
+import type { ContractMetadataV3, ContractMetadataV4 } from '@pezkuwi/types/interfaces';
+import type { Registry } from '@pezkuwi/types/types';
+export declare function v3ToV4(registry: Registry, v3: ContractMetadataV3): ContractMetadataV4;

package/build-tsc/augment.d.ts

@@ -0,0 +1 @@
+import '@pezkuwi/api-augment';

package/build-tsc/base/Base.d.ts

@@ -0,0 +1,13 @@
+import type { ApiBase } from '@pezkuwi/api/base';
+import type { ApiTypes, DecorateMethod } from '@pezkuwi/api/types';
+import type { Registry } from '@pezkuwi/types/types';
+import { Abi } from '../Abi/index.js';
+export declare abstract class Base<ApiType extends ApiTypes> {
+    readonly abi: Abi;
+    readonly api: ApiBase<ApiType>;
+    protected readonly _decorateMethod: DecorateMethod<ApiType>;
+    protected readonly _isWeightV1: boolean;
+    protected readonly _isRevive: boolean;
+    constructor(api: ApiBase<ApiType>, abi: string | Record<string, unknown> | Abi, decorateMethod: DecorateMethod<ApiType>);
+    get registry(): Registry;
+}

package/build-tsc/base/Blueprint.d.ts

@@ -0,0 +1,24 @@
+import type { ApiBase } from '@pezkuwi/api/base';
+import type { ApiTypes, DecorateMethod } from '@pezkuwi/api/types';
+import type { Hash } from '@pezkuwi/types/interfaces';
+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 { Contract } from './Contract.js';
+export type BlueprintConstructor<ApiType extends ApiTypes> = new (api: ApiBase<ApiType>, abi: string | Record<string, unknown> | Abi, codeHash: string | Hash | Uint8Array) => Blueprint<ApiType>;
+export declare class BlueprintSubmittableResult<ApiType extends ApiTypes> extends SubmittableResult {
+    readonly contract?: Contract<ApiType> | undefined;
+    constructor(result: ISubmittableResult, contract?: Contract<ApiType>);
+}
+export declare class Blueprint<ApiType extends ApiTypes> extends Base<ApiType> {
+    #private;
+    /**
+     * @description The on-chain code hash for this blueprint
+     */
+    readonly codeHash: Hash;
+    constructor(api: ApiBase<ApiType>, abi: string | Record<string, unknown> | Abi, codeHash: string | Hash | Uint8Array, decorateMethod: DecorateMethod<ApiType>);
+    get tx(): MapConstructorExec<ApiType>;
+}
+export declare function extendBlueprint<ApiType extends ApiTypes>(type: ApiType, decorateMethod: DecorateMethod<ApiType>): BlueprintConstructor<ApiType>;

package/build-tsc/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/build-tsc/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/build-tsc/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/build-tsc/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/build-tsc/base/types.d.ts

@@ -0,0 +1,25 @@
+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/build-tsc/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/build-tsc/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';