@pezkuwi/api-contract 16.5.6 → 16.5.8

package/build/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/base/types.js

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

package/build/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/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;
+}