@decaf-ts/for-fabric 0.8.0 → 0.10.0

package/lib/types/client/FabricClientPaginator.d.cts

@@ -0,0 +1,12 @@
+import { MaybeContextualArg, Paginator, PreparedStatement, SerializedPage } from "@decaf-ts/core";
+import { Model } from "@decaf-ts/decorator-validation";
+import { Constructor } from "@decaf-ts/decoration";
+import { FabricClientAdapter } from "./FabricClientAdapter.cjs";
+import { MangoQuery } from "@decaf-ts/for-couchdb";
+export declare class FabricClientPaginator<M extends Model> extends Paginator<M, M[], MangoQuery> {
+    bookmark?: string;
+    constructor(adapter: FabricClientAdapter, query: MangoQuery | PreparedStatement<any>, size: number, clazz: Constructor<M>);
+    protected prepare(rawStatement: MangoQuery): MangoQuery;
+    page(page?: number, ...args: MaybeContextualArg<any>): Promise<M[]>;
+    static isSerializedPage(obj: SerializedPage<any> | any): any;
+}

package/lib/types/client/FabricClientPaginator.d.mts

@@ -0,0 +1,12 @@
+import { MaybeContextualArg, Paginator, PreparedStatement, SerializedPage } from "@decaf-ts/core";
+import { Model } from "@decaf-ts/decorator-validation";
+import { Constructor } from "@decaf-ts/decoration";
+import { FabricClientAdapter } from "./FabricClientAdapter.js";
+import { MangoQuery } from "@decaf-ts/for-couchdb";
+export declare class FabricClientPaginator<M extends Model> extends Paginator<M, M[], MangoQuery> {
+    bookmark?: string;
+    constructor(adapter: FabricClientAdapter, query: MangoQuery | PreparedStatement<any>, size: number, clazz: Constructor<M>);
+    protected prepare(rawStatement: MangoQuery): MangoQuery;
+    page(page?: number, ...args: MaybeContextualArg<any>): Promise<M[]>;
+    static isSerializedPage(obj: SerializedPage<any> | any): any;
+}

package/lib/types/client/FabricClientRepository.d.cts

@@ -0,0 +1,71 @@
+import type { MaybeContextualArg } from "@decaf-ts/core";
+import { ContextOf, DirectionLimitOffset, FlagsOf, ObserverHandler, OrderDirection, Repository, SerializedPage } from "@decaf-ts/core";
+import { Model } from "@decaf-ts/decorator-validation";
+import { Constructor } from "@decaf-ts/decoration";
+import { type FabricClientAdapter } from "./FabricClientAdapter.cjs";
+import { PrimaryKeyType } from "@decaf-ts/db-decorators";
+/**
+ * @description Repository implementation for Fabric client operations
+ * @summary Extends the generic Repository to prepare context and arguments for CRUD operations executed via a Fabric client Adapter, wiring RepositoryFlags and Fabric-specific overrides.
+ * @template M extends Model - The model type handled by this repository
+ * @param {Adapter<any, MangoQuery, FabricFlags, Context<FabricFlags>>} [adapter] - Optional adapter instance used to execute operations
+ * @param {Constructor<M>} [clazz] - Optional model constructor used by the repository
+ * @return {void}
+ * @class FabricClientRepository
+ * @example
+ * import { Repository } from "@decaf-ts/core";
+ * import { FabricClientRepository } from "@decaf-ts/for-fabric";
+ *
+ * class User extends Model { id!: string; name!: string; }
+ * const repo = new FabricClientRepository<User>();
+ * const created = await repo.create(new User({ id: "1", name: "Alice" }));
+ * const loaded = await repo.read("1");
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant App
+ *   participant Repo as FabricClientRepository
+ *   participant Adapter
+ *   App->>Repo: create(model)
+ *   Repo->>Repo: createPrefix(model, ...args)
+ *   Repo->>Adapter: create(table, id, model, flags)
+ *   Adapter-->>Repo: result
+ *   Repo-->>App: model
+ */
+export declare class FabricClientRepository<M extends Model, A extends FabricClientAdapter = FabricClientAdapter> extends Repository<M, A> {
+    protected _overrides: Partial<FlagsOf<ContextOf<A>>> & {
+        ignoreValidation: boolean;
+        ignoreHandlers: boolean;
+        allowRawStatements: boolean;
+        forcePrepareSimpleQueries: boolean;
+        forcePrepareComplexQueries: boolean;
+        allowGenerationOverride: boolean;
+        rebuildWithTransient: boolean;
+    };
+    constructor(adapter?: A, clazz?: Constructor<M>, force?: boolean);
+    override(flags: Partial<FlagsOf<ContextOf<A>>>): this;
+    protected ObserverHandler(): ObserverHandler;
+    paginateBy(key: keyof M, order: OrderDirection, ref?: Omit<DirectionLimitOffset, "direction">, ...args: MaybeContextualArg<ContextOf<A>>): Promise<SerializedPage<M>>;
+    listBy(key: keyof M, order: OrderDirection, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
+    findBy(key: keyof M, value: any, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
+    findOneBy(key: keyof M, value: any, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M>;
+    find(value: string, order?: OrderDirection, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
+    page(value: string, direction?: OrderDirection, ref?: Omit<DirectionLimitOffset, "direction">, ...args: MaybeContextualArg<ContextOf<A>>): Promise<SerializedPage<M>>;
+    statement(name: string, ...args: MaybeContextualArg<ContextOf<A>>): Promise<any>;
+    private applyAfterRead;
+    countOf(key?: keyof M, ...args: MaybeContextualArg<ContextOf<A>>): Promise<number>;
+    maxOf<K extends keyof M>(key: K, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[K]>;
+    minOf<K extends keyof M>(key: K, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[K]>;
+    avgOf<K extends keyof M>(key: K, ...args: MaybeContextualArg<ContextOf<A>>): Promise<number>;
+    sumOf<K extends keyof M>(key: K, ...args: MaybeContextualArg<ContextOf<A>>): Promise<number>;
+    distinctOf<K extends keyof M>(key: K, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[K][]>;
+    groupOf<K extends keyof M>(key: K, ...args: MaybeContextualArg<ContextOf<A>>): Promise<Record<string, M[]>>;
+    healthcheck(...args: MaybeContextualArg<ContextOf<A>>): Promise<Record<string, any>>;
+    create(model: M, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M>;
+    update(model: M, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M>;
+    protected createAllPrefix(models: M[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<[M[], ...any[], ContextOf<A>]>;
+    createAll(models: M[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
+    readAll(keys: PrimaryKeyType[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
+    updateAll(models: M[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
+    private ensureLegacyMirrorFlag;
+}

package/lib/types/client/FabricClientRepository.d.mts

@@ -0,0 +1,71 @@
+import type { MaybeContextualArg } from "@decaf-ts/core";
+import { ContextOf, DirectionLimitOffset, FlagsOf, ObserverHandler, OrderDirection, Repository, SerializedPage } from "@decaf-ts/core";
+import { Model } from "@decaf-ts/decorator-validation";
+import { Constructor } from "@decaf-ts/decoration";
+import { type FabricClientAdapter } from "./FabricClientAdapter.js";
+import { PrimaryKeyType } from "@decaf-ts/db-decorators";
+/**
+ * @description Repository implementation for Fabric client operations
+ * @summary Extends the generic Repository to prepare context and arguments for CRUD operations executed via a Fabric client Adapter, wiring RepositoryFlags and Fabric-specific overrides.
+ * @template M extends Model - The model type handled by this repository
+ * @param {Adapter<any, MangoQuery, FabricFlags, Context<FabricFlags>>} [adapter] - Optional adapter instance used to execute operations
+ * @param {Constructor<M>} [clazz] - Optional model constructor used by the repository
+ * @return {void}
+ * @class FabricClientRepository
+ * @example
+ * import { Repository } from "@decaf-ts/core";
+ * import { FabricClientRepository } from "@decaf-ts/for-fabric";
+ *
+ * class User extends Model { id!: string; name!: string; }
+ * const repo = new FabricClientRepository<User>();
+ * const created = await repo.create(new User({ id: "1", name: "Alice" }));
+ * const loaded = await repo.read("1");
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant App
+ *   participant Repo as FabricClientRepository
+ *   participant Adapter
+ *   App->>Repo: create(model)
+ *   Repo->>Repo: createPrefix(model, ...args)
+ *   Repo->>Adapter: create(table, id, model, flags)
+ *   Adapter-->>Repo: result
+ *   Repo-->>App: model
+ */
+export declare class FabricClientRepository<M extends Model, A extends FabricClientAdapter = FabricClientAdapter> extends Repository<M, A> {
+    protected _overrides: Partial<FlagsOf<ContextOf<A>>> & {
+        ignoreValidation: boolean;
+        ignoreHandlers: boolean;
+        allowRawStatements: boolean;
+        forcePrepareSimpleQueries: boolean;
+        forcePrepareComplexQueries: boolean;
+        allowGenerationOverride: boolean;
+        rebuildWithTransient: boolean;
+    };
+    constructor(adapter?: A, clazz?: Constructor<M>, force?: boolean);
+    override(flags: Partial<FlagsOf<ContextOf<A>>>): this;
+    protected ObserverHandler(): ObserverHandler;
+    paginateBy(key: keyof M, order: OrderDirection, ref?: Omit<DirectionLimitOffset, "direction">, ...args: MaybeContextualArg<ContextOf<A>>): Promise<SerializedPage<M>>;
+    listBy(key: keyof M, order: OrderDirection, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
+    findBy(key: keyof M, value: any, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
+    findOneBy(key: keyof M, value: any, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M>;
+    find(value: string, order?: OrderDirection, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
+    page(value: string, direction?: OrderDirection, ref?: Omit<DirectionLimitOffset, "direction">, ...args: MaybeContextualArg<ContextOf<A>>): Promise<SerializedPage<M>>;
+    statement(name: string, ...args: MaybeContextualArg<ContextOf<A>>): Promise<any>;
+    private applyAfterRead;
+    countOf(key?: keyof M, ...args: MaybeContextualArg<ContextOf<A>>): Promise<number>;
+    maxOf<K extends keyof M>(key: K, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[K]>;
+    minOf<K extends keyof M>(key: K, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[K]>;
+    avgOf<K extends keyof M>(key: K, ...args: MaybeContextualArg<ContextOf<A>>): Promise<number>;
+    sumOf<K extends keyof M>(key: K, ...args: MaybeContextualArg<ContextOf<A>>): Promise<number>;
+    distinctOf<K extends keyof M>(key: K, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[K][]>;
+    groupOf<K extends keyof M>(key: K, ...args: MaybeContextualArg<ContextOf<A>>): Promise<Record<string, M[]>>;
+    healthcheck(...args: MaybeContextualArg<ContextOf<A>>): Promise<Record<string, any>>;
+    create(model: M, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M>;
+    update(model: M, ...args: MaybeContextualArg<ContextOf<A>>): Promise<M>;
+    protected createAllPrefix(models: M[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<[M[], ...any[], ContextOf<A>]>;
+    createAll(models: M[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
+    readAll(keys: PrimaryKeyType[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
+    updateAll(models: M[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<M[]>;
+    private ensureLegacyMirrorFlag;
+}

package/lib/types/client/FabricClientStatement.d.cts

@@ -0,0 +1,64 @@
+import { AdapterFlags, Condition, Context, MaybeContextualArg, PreparedStatement, Statement, StatementExecutor } from "@decaf-ts/core";
+import { Model } from "@decaf-ts/decorator-validation";
+import { FabricClientAdapter } from "./FabricClientAdapter.cjs";
+import { MangoQuery } from "@decaf-ts/for-couchdb";
+import { FabricClientFlags } from "./types.cjs";
+export declare class FabricClientStatement<M extends Model, R> extends Statement<M, FabricClientAdapter, R, MangoQuery> {
+    constructor(adapter: FabricClientAdapter, overrides?: Partial<AdapterFlags>);
+    protected squash(ctx: Context<FabricClientFlags>): PreparedStatement<any> | undefined;
+    protected executePrepared(...argz: MaybeContextualArg<Context<FabricClientFlags>>): Promise<R>;
+    prepare(ctx?: Context<FabricClientFlags>): Promise<StatementExecutor<M, R>>;
+    /**
+     * @description Processes a record from CouchDB/Fabric
+     * @summary Extracts the ID from a CouchDB document and reverts it to a model instance
+     */
+    protected processRecord(record: any, ctx: Context<FabricClientFlags>): M;
+    /**
+     * @description Executes a raw Mango query
+     * @summary Sends a raw Mango query to Fabric and processes the results
+     */
+    raw<R>(rawInput: MangoQuery, ...args: any[]): Promise<R>;
+    /**
+     * @description Builds a CouchDB Mango query from the statement
+     * @summary Converts the statement's conditions, selectors, and options into a CouchDB Mango query
+     */
+    protected build(): MangoQuery;
+    /**
+     * @description Parses a condition into a CouchDB Mango query selector
+     * @summary Converts a Condition object into a CouchDB Mango query selector structure
+     */
+    protected parseCondition(condition: Condition<M>): MangoQuery;
+    /**
+     * @description Builds an aggregate query if aggregation is requested
+     * @summary Checks for aggregate operations and returns a special MangoQuery for them
+     */
+    private buildAggregateQuery;
+    /**
+     * @description Creates an aggregate descriptor for a view-based aggregation
+     */
+    private createAggregateDescriptor;
+    /**
+     * @description Creates the special aggregate MangoQuery marker
+     */
+    private createAggregateQuery;
+    /**
+     * @description Gets the adapter cast to FabricClientAdapter for view access
+     */
+    private getFabricAdapter;
+    /**
+     * @description Executes an aggregate query via adapter's view method
+     */
+    private executeAggregate;
+    /**
+     * @description Handles average calculation from sum and count views
+     */
+    private handleAverage;
+    /**
+     * @description Processes the view response based on aggregate kind
+     */
+    private processViewResponse;
+    /**
+     * @description Type guard to check if info is a view-based aggregate
+     */
+    private isViewAggregate;
+}

package/lib/types/client/FabricClientStatement.d.mts

@@ -0,0 +1,64 @@
+import { AdapterFlags, Condition, Context, MaybeContextualArg, PreparedStatement, Statement, StatementExecutor } from "@decaf-ts/core";
+import { Model } from "@decaf-ts/decorator-validation";
+import { FabricClientAdapter } from "./FabricClientAdapter.js";
+import { MangoQuery } from "@decaf-ts/for-couchdb";
+import { FabricClientFlags } from "./types.js";
+export declare class FabricClientStatement<M extends Model, R> extends Statement<M, FabricClientAdapter, R, MangoQuery> {
+    constructor(adapter: FabricClientAdapter, overrides?: Partial<AdapterFlags>);
+    protected squash(ctx: Context<FabricClientFlags>): PreparedStatement<any> | undefined;
+    protected executePrepared(...argz: MaybeContextualArg<Context<FabricClientFlags>>): Promise<R>;
+    prepare(ctx?: Context<FabricClientFlags>): Promise<StatementExecutor<M, R>>;
+    /**
+     * @description Processes a record from CouchDB/Fabric
+     * @summary Extracts the ID from a CouchDB document and reverts it to a model instance
+     */
+    protected processRecord(record: any, ctx: Context<FabricClientFlags>): M;
+    /**
+     * @description Executes a raw Mango query
+     * @summary Sends a raw Mango query to Fabric and processes the results
+     */
+    raw<R>(rawInput: MangoQuery, ...args: any[]): Promise<R>;
+    /**
+     * @description Builds a CouchDB Mango query from the statement
+     * @summary Converts the statement's conditions, selectors, and options into a CouchDB Mango query
+     */
+    protected build(): MangoQuery;
+    /**
+     * @description Parses a condition into a CouchDB Mango query selector
+     * @summary Converts a Condition object into a CouchDB Mango query selector structure
+     */
+    protected parseCondition(condition: Condition<M>): MangoQuery;
+    /**
+     * @description Builds an aggregate query if aggregation is requested
+     * @summary Checks for aggregate operations and returns a special MangoQuery for them
+     */
+    private buildAggregateQuery;
+    /**
+     * @description Creates an aggregate descriptor for a view-based aggregation
+     */
+    private createAggregateDescriptor;
+    /**
+     * @description Creates the special aggregate MangoQuery marker
+     */
+    private createAggregateQuery;
+    /**
+     * @description Gets the adapter cast to FabricClientAdapter for view access
+     */
+    private getFabricAdapter;
+    /**
+     * @description Executes an aggregate query via adapter's view method
+     */
+    private executeAggregate;
+    /**
+     * @description Handles average calculation from sum and count views
+     */
+    private handleAverage;
+    /**
+     * @description Processes the view response based on aggregate kind
+     */
+    private processViewResponse;
+    /**
+     * @description Type guard to check if info is a view-based aggregate
+     */
+    private isViewAggregate;
+}

package/lib/types/client/collections/generation.d.cts

@@ -0,0 +1,46 @@
+import { Constructor } from "@decaf-ts/decoration";
+import { CouchDBDesignDoc } from "@decaf-ts/for-couchdb";
+import { Model } from "@decaf-ts/decorator-validation";
+export type FabricPolicyIdentity = {
+    role: {
+        name: string;
+        mspId: string;
+    };
+};
+export type FabricCollection = {
+    name: string;
+    policy: string;
+    requiredPeerCount: number;
+    maxPeerCount: number;
+    blockToLive: number;
+    memberOnlyRead: boolean;
+    memberOnlyWrite: boolean;
+    endorsementPolicy: {
+        identities: FabricPolicyIdentity[];
+        rule: string;
+    };
+};
+export type PrivateCollection = {
+    name: string;
+    policy: string;
+    requiredPeerCount: number;
+    maxPeerCount: number;
+    blockToLive: number;
+    memberOnlyRead: boolean;
+    memberOnlyWrite: boolean;
+    endorsementPolicy?: {
+        signaturePolicy: string;
+    };
+};
+export declare function collectionFor(collectionName: string, policy: string, requiredPeerCount: number, maxPeerCount: number, blockToLive: number, memberOnlyRead: boolean, memberOnlyWrite: boolean): PrivateCollection;
+export declare function privateCollectionFor(mspId: string, collectionName?: string, requiredPeerCount?: number, maxPeerCount?: number, blockToLive?: number, memberOnlyRead?: boolean, memberOnlyWrite?: boolean): PrivateCollection;
+export declare function sharedCollectionFor(mspIds: string[], collectionName: string, requiredPeerCount?: number, maxPeerCount?: number, blockToLive?: number, memberOnlyRead?: boolean, memberOnlyWrite?: boolean): PrivateCollection;
+export declare function extractCollections<M extends Model>(m: Constructor<M>, mspIds: string[], overrides?: {
+    privateCols?: Partial<PrivateCollection>;
+    sharedCols?: Partial<PrivateCollection>;
+}, mirror?: boolean): Promise<{
+    privates: PrivateCollection[];
+    shared: PrivateCollection[];
+}>;
+export declare function writeCollections(cols: PrivateCollection[], p?: string, fileName?: string): void;
+export declare function writeCollectionDesignDocs(docs: CouchDBDesignDoc[], p?: string, collection?: string): void;

package/lib/types/client/collections/generation.d.mts

@@ -0,0 +1,46 @@
+import { Constructor } from "@decaf-ts/decoration";
+import { CouchDBDesignDoc } from "@decaf-ts/for-couchdb";
+import { Model } from "@decaf-ts/decorator-validation";
+export type FabricPolicyIdentity = {
+    role: {
+        name: string;
+        mspId: string;
+    };
+};
+export type FabricCollection = {
+    name: string;
+    policy: string;
+    requiredPeerCount: number;
+    maxPeerCount: number;
+    blockToLive: number;
+    memberOnlyRead: boolean;
+    memberOnlyWrite: boolean;
+    endorsementPolicy: {
+        identities: FabricPolicyIdentity[];
+        rule: string;
+    };
+};
+export type PrivateCollection = {
+    name: string;
+    policy: string;
+    requiredPeerCount: number;
+    maxPeerCount: number;
+    blockToLive: number;
+    memberOnlyRead: boolean;
+    memberOnlyWrite: boolean;
+    endorsementPolicy?: {
+        signaturePolicy: string;
+    };
+};
+export declare function collectionFor(collectionName: string, policy: string, requiredPeerCount: number, maxPeerCount: number, blockToLive: number, memberOnlyRead: boolean, memberOnlyWrite: boolean): PrivateCollection;
+export declare function privateCollectionFor(mspId: string, collectionName?: string, requiredPeerCount?: number, maxPeerCount?: number, blockToLive?: number, memberOnlyRead?: boolean, memberOnlyWrite?: boolean): PrivateCollection;
+export declare function sharedCollectionFor(mspIds: string[], collectionName: string, requiredPeerCount?: number, maxPeerCount?: number, blockToLive?: number, memberOnlyRead?: boolean, memberOnlyWrite?: boolean): PrivateCollection;
+export declare function extractCollections<M extends Model>(m: Constructor<M>, mspIds: string[], overrides?: {
+    privateCols?: Partial<PrivateCollection>;
+    sharedCols?: Partial<PrivateCollection>;
+}, mirror?: boolean): Promise<{
+    privates: PrivateCollection[];
+    shared: PrivateCollection[];
+}>;
+export declare function writeCollections(cols: PrivateCollection[], p?: string, fileName?: string): void;
+export declare function writeCollectionDesignDocs(docs: CouchDBDesignDoc[], p?: string, collection?: string): void;

package/lib/types/client/collections/index.d.cts

@@ -0,0 +1 @@
+export * from "./generation.cjs";

package/lib/types/client/collections/index.d.mts

@@ -0,0 +1 @@
+export * from "./generation.js";

package/lib/types/client/constants.d.cts

@@ -0,0 +1,2 @@
+import { FabricClientFlags } from "./types.cjs";
+export declare const DefaultFabricClientFlags: FabricClientFlags;

package/lib/types/client/constants.d.mts

@@ -0,0 +1,2 @@
+import { FabricClientFlags } from "./types.js";
+export declare const DefaultFabricClientFlags: FabricClientFlags;

package/lib/types/client/crypto.d.cts

@@ -0,0 +1,107 @@
+import { CryptoKey } from "@peculiar/webcrypto";
+export declare enum BASE_ALPHABET {
+    BASE2 = "01",
+    BASE8 = "01234567",
+    BASE11 = "0123456789a",
+    BASE16 = "0123456789abcdef",
+    BASE32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ",
+    BASE32_Z = "ybndrfg8ejkmcpqxot1uwisza345h769",
+    BASE36 = "0123456789abcdefghijklmnopqrstuvwxyz",
+    BASE58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz",
+    BASE62 = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
+    BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
+    BASE67 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.!~"
+}
+export type keyObject = {
+    iv: ArrayBuffer;
+    key: CryptoKey;
+};
+export declare enum CRYPTO {
+    HASH = "SHA-256",
+    ITERATIONS = 1000,
+    KEYLENGTH = 48,
+    DERIVED_IV_LENGTH = 16,
+    DERIVED_KEY_LENGTH = 32,// Because SHA-256 used has a native size of 32 bytes
+    ALGORYTHM = "AES-GCM",
+    KEY_ALGORYTHM = "PBKDF2"
+}
+export declare class BaseEncoder {
+    private alphabet;
+    private readonly baseMap;
+    private readonly base;
+    private readonly leader;
+    private readonly factor;
+    private readonly iFactor;
+    constructor(alphabet: BASE_ALPHABET);
+    encode(source: Uint8Array | DataView | any[] | string): string;
+    private decodeUnsafe;
+    decode(source: string): Uint8Array<ArrayBufferLike>;
+}
+export declare class CryptoUtils {
+    private static readonly b58encoder;
+    private static readonly logger;
+    private constructor();
+    static fabricIdFromCertificate(certificate: string): string;
+    static encode(str: string): string;
+    static decode(str: string): string;
+    static stringToArrayBuffer(str: string): ArrayBuffer;
+    private static extractKey;
+    static extractPrivateKey(pem: Buffer | string, usages?: any[]): Promise<import("node:crypto").webcrypto.CryptoKey>;
+    static extractPublicKey(pem: Buffer | string, usages?: any[]): Promise<import("node:crypto").webcrypto.CryptoKey>;
+    static sign(privateKey: string, data: Buffer): Promise<string>;
+    static verify(certificate: string, signature: Buffer | string, data: Buffer | string): Promise<boolean>;
+    static encrypt(certificate: string, data: string | Buffer): Promise<string>;
+    private static getSubtleCrypto;
+    static decrypt(privateKey: string, data: string | Buffer): Promise<any>;
+    /**
+     * @summary Util function to get a random master key
+     *
+     * @description If data is not passed, a random ArrayBuffer will be generated
+     *
+     * @param {ArrayBuffer} data encrytion data
+     *
+     * @function getMaster
+     */
+    static getMaster(data?: ArrayBuffer): Promise<keyObject>;
+    /**
+     * @summary Util function to derive a key from another key
+     *
+     * @param {string} salt
+     * @param {CryptoKey} key Original key
+     *
+     * @function getDerivationKey
+     */
+    static getDerivationKey(salt: string, key: CryptoKey): Promise<{
+        key: any;
+        iv: ArrayBuffer;
+    }>;
+    /**
+     * @summary Util function to get the key and IV from the CrytoKey array
+     *
+     * @param {ArrayBuffer} derivation
+     *
+     * @function getKey
+     */
+    static getKey(derivation: ArrayBuffer): Promise<{
+        key: any;
+        iv: ArrayBuffer;
+    }>;
+    /**
+     * @summary Util function to decrypt data
+     *
+     * @param {string} text
+     * @param {keyObject} keyObject
+     *
+     * @function encrypt
+     */
+    static encryptPin(text: string, keyObject: keyObject): Promise<ArrayBuffer>;
+    /**
+     * @summary Util function to decrypt data
+     *
+     * @param {BufferSource} encryptedText
+     * @param {keyObject} keyObject
+     *
+     * @function decrypt
+     */
+    static decryptPin(encryptedText: ArrayBuffer, keyObject: keyObject): Promise<string>;
+}

package/lib/types/client/crypto.d.mts

@@ -0,0 +1,107 @@
+import { CryptoKey } from "@peculiar/webcrypto";
+export declare enum BASE_ALPHABET {
+    BASE2 = "01",
+    BASE8 = "01234567",
+    BASE11 = "0123456789a",
+    BASE16 = "0123456789abcdef",
+    BASE32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ",
+    BASE32_Z = "ybndrfg8ejkmcpqxot1uwisza345h769",
+    BASE36 = "0123456789abcdefghijklmnopqrstuvwxyz",
+    BASE58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz",
+    BASE62 = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
+    BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
+    BASE67 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.!~"
+}
+export type keyObject = {
+    iv: ArrayBuffer;
+    key: CryptoKey;
+};
+export declare enum CRYPTO {
+    HASH = "SHA-256",
+    ITERATIONS = 1000,
+    KEYLENGTH = 48,
+    DERIVED_IV_LENGTH = 16,
+    DERIVED_KEY_LENGTH = 32,// Because SHA-256 used has a native size of 32 bytes
+    ALGORYTHM = "AES-GCM",
+    KEY_ALGORYTHM = "PBKDF2"
+}
+export declare class BaseEncoder {
+    private alphabet;
+    private readonly baseMap;
+    private readonly base;
+    private readonly leader;
+    private readonly factor;
+    private readonly iFactor;
+    constructor(alphabet: BASE_ALPHABET);
+    encode(source: Uint8Array | DataView | any[] | string): string;
+    private decodeUnsafe;
+    decode(source: string): Uint8Array<ArrayBufferLike>;
+}
+export declare class CryptoUtils {
+    private static readonly b58encoder;
+    private static readonly logger;
+    private constructor();
+    static fabricIdFromCertificate(certificate: string): string;
+    static encode(str: string): string;
+    static decode(str: string): string;
+    static stringToArrayBuffer(str: string): ArrayBuffer;
+    private static extractKey;
+    static extractPrivateKey(pem: Buffer | string, usages?: any[]): Promise<import("node:crypto").webcrypto.CryptoKey>;
+    static extractPublicKey(pem: Buffer | string, usages?: any[]): Promise<import("node:crypto").webcrypto.CryptoKey>;
+    static sign(privateKey: string, data: Buffer): Promise<string>;
+    static verify(certificate: string, signature: Buffer | string, data: Buffer | string): Promise<boolean>;
+    static encrypt(certificate: string, data: string | Buffer): Promise<string>;
+    private static getSubtleCrypto;
+    static decrypt(privateKey: string, data: string | Buffer): Promise<any>;
+    /**
+     * @summary Util function to get a random master key
+     *
+     * @description If data is not passed, a random ArrayBuffer will be generated
+     *
+     * @param {ArrayBuffer} data encrytion data
+     *
+     * @function getMaster
+     */
+    static getMaster(data?: ArrayBuffer): Promise<keyObject>;
+    /**
+     * @summary Util function to derive a key from another key
+     *
+     * @param {string} salt
+     * @param {CryptoKey} key Original key
+     *
+     * @function getDerivationKey
+     */
+    static getDerivationKey(salt: string, key: CryptoKey): Promise<{
+        key: any;
+        iv: ArrayBuffer;
+    }>;
+    /**
+     * @summary Util function to get the key and IV from the CrytoKey array
+     *
+     * @param {ArrayBuffer} derivation
+     *
+     * @function getKey
+     */
+    static getKey(derivation: ArrayBuffer): Promise<{
+        key: any;
+        iv: ArrayBuffer;
+    }>;
+    /**
+     * @summary Util function to decrypt data
+     *
+     * @param {string} text
+     * @param {keyObject} keyObject
+     *
+     * @function encrypt
+     */
+    static encryptPin(text: string, keyObject: keyObject): Promise<ArrayBuffer>;
+    /**
+     * @summary Util function to decrypt data
+     *
+     * @param {BufferSource} encryptedText
+     * @param {keyObject} keyObject
+     *
+     * @function decrypt
+     */
+    static decryptPin(encryptedText: ArrayBuffer, keyObject: keyObject): Promise<string>;
+}