@decaf-ts/for-fabric 0.10.0 → 0.12.0

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

@@ -1,71 +0,0 @@
-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";
-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.ts

@@ -1,64 +0,0 @@
-import { AdapterFlags, Condition, Context, MaybeContextualArg, PreparedStatement, Statement, StatementExecutor } from "@decaf-ts/core";
-import { Model } from "@decaf-ts/decorator-validation";
-import { FabricClientAdapter } from "./FabricClientAdapter";
-import { MangoQuery } from "@decaf-ts/for-couchdb";
-import { FabricClientFlags } from "./types";
-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.ts

@@ -1,46 +0,0 @@
-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.ts

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

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

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

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

@@ -1,107 +0,0 @@
-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/erc20/FabricERC20ClientRepository.d.ts

@@ -1,254 +0,0 @@
-import { FabricClientRepository } from "../FabricClientRepository";
-import { ERC20Token, ERC20Wallet } from "../../contracts/erc20/models";
-import { Model, Serializer } from "@decaf-ts/decorator-validation";
-import { FabricClientAdapter } from "../FabricClientAdapter";
-import { ContextOf, ContextualArgs, EventIds, MaybeContextualArg } from "@decaf-ts/core";
-import { BulkCrudOperationKeys, OperationKeys } from "@decaf-ts/db-decorators";
-import { Constructor } from "@decaf-ts/decoration";
-/**
- * Repository for interacting with ERC20 contracts on a Hyperledger Fabric network.
- * Extends the base FabricClientRepository class and utilizes the ClientSerializer for data serialization.
- */
-export declare class FabricERC20ClientRepository<A extends FabricClientAdapter> extends FabricClientRepository<ERC20Wallet, A> {
-    private static serializer;
-    protected readonly serializer: Serializer<any>;
-    private static decoder;
-    /**
-     * @description Notifies all observers of an event.
-     * @summary Updates all registered observers with information about a database event.
-     * @param {string} table - The table name where the event occurred.
-     * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of event that occurred.
-     * @param {EventIds} id - The ID or IDs of the affected records.
-     * @param {...any[]} args - Additional arguments.
-     * @return {Promise<void>} A promise that resolves when all observers have been notified.
-     * @throws {InternalError} If the observer handler is not initialized.
-     */
-    updateObservers<M extends Model>(table: Constructor<M> | string, event: OperationKeys | BulkCrudOperationKeys | string, id: EventIds, ...args: ContextualArgs<ContextOf<A>>): Promise<void>;
-    /**
-     * Decodes a Uint8Array into a string using the TextDecoder.
-     *
-     * @param data - The Uint8Array to decode.
-     * @returns The decoded string.
-     */
-    decode(data: Uint8Array): string;
-    constructor(adapter?: A);
-    /**
-     * Retrieves the name of the ERC20 token.
-     *
-     * @description
-     * This function interacts with the blockchain network to fetch the name of the ERC20 token.
-     * It calls the "TokenName" transaction on the smart contract and decodes the returned data.
-     *
-     * @returns {Promise<string>} A promise that resolves with the name of the ERC20 token.
-     *
-     * @throws {Error} If the transaction fails or the decoding process fails.
-     */
-    tokenName(...args: MaybeContextualArg<ContextOf<A>>): Promise<string>;
-    /**
-     * Retrieves the symbol of the ERC20 token.
-     *
-     * This function interacts with the blockchain network to fetch the symbol of the ERC20 token.
-     * It calls the "Symbol" transaction on the smart contract and decodes the returned data.
-     *
-     * @returns {Promise<string>} A promise that resolves with the symbol of the ERC20 token.
-     *
-     * @throws {Error} If the transaction fails or the decoding process fails.
-     */
-    symbol(...args: MaybeContextualArg<ContextOf<A>>): Promise<string>;
-    /**
-     * Retrieves the number of decimal places for the ERC20 token.
-     *
-     * This function interacts with the blockchain network to fetch the number of decimal places for the ERC20 token.
-     * It calls the "Decimals" transaction on the smart contract and decodes the returned data.
-     *
-     * @returns {Promise<number>} A promise that resolves with the number of decimal places for the ERC20 token.
-     *
-     * @throws {Error} If the transaction fails or the decoding process fails.
-     */
-    decimals(...args: MaybeContextualArg<ContextOf<A>>): Promise<number>;
-    /**
-     * Retrieves the total supply of the ERC20 token.
-     *
-     * This function interacts with the blockchain network to fetch the total supply of the ERC20 token.
-     * It calls the "TotalSupply" transaction on the smart contract and decodes the returned data.
-     *
-     * @returns {Promise<number>} A promise that resolves with the total supply of the ERC20 token.
-     *
-     * @throws {Error} If the transaction fails or the decoding process fails.
-     */
-    totalSupply(...args: MaybeContextualArg<ContextOf<A>>): Promise<number>;
-    /**
-     * Retrieves the balance of the ERC20 token for a specified owner.
-     *
-     * @description
-     * This function interacts with the blockchain network to fetch the balance of the ERC20 token for a given owner.
-     * It calls the "BalanceOf" transaction on the smart contract with the provided owner's address as a parameter.
-     * The returned data is then decoded and converted to a number.
-     *
-     * @param owner - The address of the ERC20 token owner.
-     *
-     * @returns {Promise<number>} A promise that resolves with the balance of the ERC20 token for the specified owner.
-     *
-     * @throws {Error} If the transaction fails or the decoding process fails.
-     */
-    balanceOf(owner: string, ...args: MaybeContextualArg<ContextOf<A>>): Promise<number>;
-    /**
-     * Transfers a specified amount of ERC20 tokens to a recipient.
-     *
-     * @description
-     * This function interacts with the blockchain network to transfer a specified amount of ERC20 tokens to a recipient.
-     * It calls the "Transfer" transaction on the smart contract with the recipient's address and the transfer amount as parameters.
-     * The returned data is then decoded and checked to determine if the transfer was successful.
-     *
-     * @param to - The address of the recipient.
-     * @param value - The amount of ERC20 tokens to transfer.
-     *
-     * @returns {Promise<boolean>} A promise that resolves with `true` if the transfer was successful, and `false` otherwise.
-     *
-     * @throws {Error} If the transaction fails or the decoding process fails.
-     */
-    transfer(to: string, value: number, ...args: MaybeContextualArg<ContextOf<A>>): Promise<boolean>;
-    /**
-     * Transfers a specified amount of ERC20 tokens from one account to another.
-     *
-     * @description
-     * This function interacts with the blockchain network to transfer a specified amount of ERC20 tokens from one account to another.
-     * For this transfer to work the spender ( account that will trigger this function ) need to have the value approved as an allowance by the sender.
-     * It calls the "TransferFrom" transaction on the smart contract with the sender's address, recipient's address, and the transfer amount as parameters.
-     * The returned data is then decoded and checked to determine if the transfer was successful.
-     *
-     * @param from - The address of the sender.
-     * @param to - The address of the recipient.
-     * @param value - The amount of ERC20 tokens to transfer.
-     *
-     * @returns {Promise<boolean>} A promise that resolves with `true` if the transfer was successful, and `false` otherwise.
-     *
-     * @throws {Error} If the transaction fails or the decoding process fails.
-     */
-    transferFrom(from: string, to: string, value: number): Promise<boolean>;
-    /**
-     * Approves a specified amount of ERC20 tokens to be spent by a specified spender.
-     *
-     * This function interacts with the blockchain network to approve a specified amount of ERC20 tokens to be spent by a specified spender.
-     * It calls the "Approve" transaction on the smart contract with the spender's address and the approval amount as parameters.
-     * The returned data is then decoded and checked to determine if the approval was successful.
-     *
-     * @param spender - The address of the spender.
-     * @param value - The amount of ERC20 tokens to approve for the spender.
-     *
-     * @returns {Promise<boolean>} A promise that resolves with `true` if the approval was successful, and `false` otherwise.
-     *
-     * @throws {Error} If the transaction fails or the decoding process fails.
-     */
-    approve(spender: string, value: number): Promise<boolean>;
-    /**
-     * Retrieves the allowance of ERC20 tokens that the specified owner has approved for a spender.
-     *
-     * @description
-     * This function interacts with the blockchain network to fetch the allowance of ERC20 tokens that the specified owner has approved for a spender.
-     * It calls the "Allowance" transaction on the smart contract with the owner's address and the spender's address as parameters.
-     * The returned data is then decoded and converted to a number.
-     *
-     * @param owner - The address of the ERC20 token owner.
-     * @param spender - The address of the spender.
-     *
-     * @returns {Promise<number>} A promise that resolves with the allowance of ERC20 tokens that the specified owner has approved for the spender.
-     *
-     * @throws {Error} If the transaction fails or the decoding process fails.
-     */
-    allowance(owner: string, spender: string): Promise<number>;
-    /**
-     * Initializes the ERC20 contract with the provided token information.
-     *
-     * @description
-     * This function interacts with the blockchain network to initialize the ERC20 contract with the given token information.
-     * It calls the "Initialize" transaction on the smart contract with the serialized token data as a parameter.
-     * The returned data is then decoded and checked to determine if the initialization was successful.
-     *
-     * @param token - The ERC20 token information to initialize the contract with.
-     *
-     * @returns {Promise<boolean>} A promise that resolves with `true` if the initialization was successful, and `false` otherwise.
-     *
-     * @throws {Error} If the transaction fails or the decoding process fails.
-     */
-    initialize(token: ERC20Token): Promise<boolean>;
-    /**
-     * Checks if the ERC20 contract has been initialized.
-     *
-     * This function interacts with the blockchain network to verify if the ERC20 contract has been initialized.
-     * It calls the "CheckInitialized" transaction on the smart contract, which does not require any parameters.
-     *
-     * @returns {Promise<void>} A promise that resolves when the initialization check is completed.
-     *
-     * @throws {Error} If the transaction fails.
-     */
-    checkInitialized(): Promise<void>;
-    /**
-     * Mints a specified amount of ERC20 tokens.
-     *
-     * @description
-     * This function interacts with the blockchain network to mint a specified amount of ERC20 tokens.
-     * It calls the "Mint" transaction on the smart contract with the minting amount as a parameter.
-     * The function does not return any value, but it updates the minter's number of tokens.
-     *
-     * @param amount - The amount of ERC20 tokens to mint.
-     *
-     * @returns {Promise<void>} A promise that resolves when the minting process is completed.
-     *
-     * @throws {Error} If the transaction fails.
-     */
-    mint(amount: number): Promise<void>;
-    /**
-     * Burns a specified amount of ERC20 tokens from the minter's account.
-     *
-     * This function interacts with the blockchain network to burn a specified amount of ERC20 tokens.
-     * It calls the "Burn" transaction on the smart contract with the burning amount as a parameter.
-     * The function does not return any value, but it decreases the minter's number of tokens.
-     *
-     * @param amount - The amount of ERC20 tokens to burn.
-     *
-     * @returns {Promise<void>} A promise that resolves when the burning process is completed.
-     *
-     * @throws {Error} If the transaction fails.
-     */
-    burn(amount: number): Promise<void>;
-    /**
-     * Burns a specified amount of ERC20 tokens from a specified account.
-     *
-     * This function interacts with the blockchain network to burn a specified amount of ERC20 tokens from a given account.
-     * It calls the "BurnFrom" transaction on the smart contract with the account's address and the burning amount as parameters.
-     * The function does not return any value, but it decreases the specified account's number of tokens.
-     *
-     * @param account - The address of the account from which to burn the ERC20 tokens.
-     * @param amount - The amount of ERC20 tokens to burn.
-     *
-     * @returns {Promise<void>} A promise that resolves when the burning process is completed.
-     *
-     * @throws {Error} If the transaction fails.
-     */
-    burnFrom(account: string, amount: number): Promise<void>;
-    /**
-     * Retrieves the balance of ERC20 tokens associated with the client's account.
-     *
-     * This function interacts with the blockchain network to fetch the balance of ERC20 tokens associated with the client's account.
-     * It calls the "ClientAccountBalance" transaction on the smart contract, which does not require any parameters.
-     * The returned data is then decoded and converted to a number.
-     *
-     * @returns {Promise<number>} A promise that resolves with the balance of ERC20 tokens associated with the client's account.
-     *
-     * @throws {Error} If the transaction fails or the decoding process fails.
-     */
-    clientAccountBalance(): Promise<number>;
-    /**
-     * Retrieves the client's account ID from the blockchain network.
-     *
-     * This function interacts with the blockchain network to fetch the client's account ID.
-     * It calls the "ClientAccountID" transaction on the smart contract, which does not require any parameters.
-     * The returned data is then decoded and returned as a string.
-     *
-     * @returns {Promise<string>} A promise that resolves with the client's account ID.
-     *
-     * @throws {Error} If the transaction fails or the decoding process fails.
-     */
-    clientAccountID(): Promise<string>;
-}

package/lib/types/client/erc20/index.d.ts

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

package/lib/types/client/fabric-fs.d.ts

@@ -1,92 +0,0 @@
-import { User } from "fabric-common";
-import { Identity, Signer } from "@hyperledger/fabric-gateway";
-/**
- * @description Loads content from a file or returns the content if already loaded
- * @summary Determines if the input is already content or a path to a file, and loads the file if needed
- * @param {string | Uint8Array} contentOrPath - The content or path to load
- * @param {Function} fileReader - Function to read the file if contentOrPath is a path
- * @return {Promise<string | Uint8Array | Buffer>} The content
- * @function contentOfLoadFile
- * @memberOf module:for-fabric.client
- */
-export declare function contentOfLoadFile(contentOrPath: string | Uint8Array, fileReader: (path: string) => Promise<string | Uint8Array | Buffer>): Promise<string | Uint8Array<ArrayBufferLike> | Buffer<ArrayBufferLike>>;
-/**
- * @description Reads a file from the file system
- * @summary Loads a file using the Node.js file system module
- * @param {string | Buffer} contentOrPath - The content or path to load
- * @return {Promise<Buffer>} The file content as a Buffer
- * @function readFile
- * @memberOf module:for-fabric.client
- */
-export declare function readFile(contentOrPath: string | Buffer): Promise<Buffer<ArrayBufferLike>>;
-/**
- * @description Creates a Certificate Authority user
- * @summary Initializes a user with the given credentials for interacting with a Fabric CA
- * @param {string} userName - The user name
- * @param {string} privateKey - The private key as a string
- * @param {string} certificate - The certificate as a string
- * @param {string} mspId - The Membership Service Provider ID
- * @return {Promise<User>} Promise resolving to the created user
- * @function getCAUser
- * @memberOf module:for-fabric.client
- */
-export declare function getCAUser(userName: string, privateKey: string, certificate: string, mspId: string): Promise<User>;
-/**
- * @description Gets an identity from a certificate directory
- * @summary Loads a certificate from a directory and creates an Identity object
- * @param {string} mspId - The Membership Service Provider ID
- * @param {string} certDirectoryPath - Path to the directory containing the certificate
- * @return {Promise<Identity>} Promise resolving to the identity
- * @function getIdentity
- * @memberOf module:for-fabric.client
- */
-export declare function getIdentity(mspId: string, certDirectoryPath: string): Promise<Identity>;
-/**
- * @description Gets the full path of the first file in a directory
- * @summary Reads a directory and returns the path to the first file found
- * @param {string} dirPath - Path to the directory
- * @return {Promise<string>} Promise resolving to the full path of the first file
- * @function getFirstDirFileName
- * @memberOf module:for-fabric.client
- */
-export declare function getFirstDirFileName(dirPath: string): Promise<string>;
-/**
- * @description Gets the content of the first file in a directory
- * @summary Reads a directory, finds the first file, and returns its content as a string
- * @param {string} dirPath - Path to the directory
- * @return {Promise<string>} Promise resolving to the content of the first file
- * @function getFirstDirFileNameContent
- * @memberOf module:for-fabric.client
- */
-export declare function getFirstDirFileNameContent(dirPath: string): Promise<string>;
-/**
- * @description Gets a signer from a key directory
- * @summary Loads a private key from a directory and creates a Signer for Fabric transactions
- * @param {string} keyDirectoryPath - Path to the directory containing the private key
- * @return {Promise<Signer>} Promise resolving to the signer
- * @function getSigner
- * @memberOf module:for-fabric.client
- */
-export declare function getSigner(keyDirectoryPath: string): Promise<Signer>;
-/**
- * @description Extracts a private key from a PEM buffer
- * @summary Converts a PEM-encoded private key to a CryptoKey object
- * @param {Buffer} pem - The PEM-encoded private key
- * @return {Promise<CryptoKey>} Promise resolving to the CryptoKey
- * @function extractPrivateKey
- * @memberOf module:for-fabric.client
- * @mermaid
- * sequenceDiagram
- *   participant Caller
- *   participant ExtractPrivateKey
- *   participant SubtleCrypto
- *
- *   Caller->>ExtractPrivateKey: extractPrivateKey(pem)
- *   ExtractPrivateKey->>ExtractPrivateKey: Get SubtleCrypto implementation
- *   ExtractPrivateKey->>ExtractPrivateKey: Parse PEM format
- *   ExtractPrivateKey->>ExtractPrivateKey: Convert to binary DER
- *   ExtractPrivateKey->>SubtleCrypto: importKey(pkcs8, binaryDer, options)
- *   SubtleCrypto-->>ExtractPrivateKey: CryptoKey
- *   ExtractPrivateKey-->>Caller: CryptoKey
- */
-export declare function extractPrivateKey(pem: Buffer): Promise<any>;