@decaf-ts/for-fabric 0.0.2

package/lib/esm/client/FabricClientAdapter.js

@@ -0,0 +1,723 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { CouchDBAdapter } from "@decaf-ts/for-couchdb";
+import { Client } from "@grpc/grpc-js";
+import * as grpc from "@grpc/grpc-js";
+import { Model, } from "@decaf-ts/decorator-validation";
+import { debug, Logging } from "@decaf-ts/logging";
+import { connect, } from "@hyperledger/fabric-gateway";
+import { getIdentity, getSigner } from "./fabric-fs.js";
+import { InternalError, OperationKeys, SerializationError, BulkCrudOperationKeys, modelToTransient, } from "@decaf-ts/db-decorators";
+import { Adapter, final, PersistenceKeys, } from "@decaf-ts/core";
+import { FabricClientRepository } from "./FabricClientRepository.js";
+import { FabricFlavour } from "./../shared/constants.js";
+import { ClientSerializer } from "./../shared/ClientSerializer.js";
+import { FabricClientDispatch } from "./FabricClientDispatch.js";
+/**
+ * @description Adapter for interacting with Hyperledger Fabric networks
+ * @summary The FabricAdapter extends CouchDBAdapter to provide a seamless interface for interacting with Hyperledger Fabric networks.
+ * It handles connection management, transaction submission, and CRUD operations against Fabric chaincode.
+ * @template PeerConfig - Configuration type for connecting to a Fabric peer
+ * @template FabricFlags - Flags specific to Fabric operations
+ * @template Context<FabricFlags> - Context type containing Fabric-specific flags
+ * @param config - Configuration for connecting to a Fabric peer
+ * @param alias - Optional alias for the adapter instance
+ * @class FabricClientAdapter
+ * @example
+ * ```typescript
+ * // Create a new FabricAdapter instance
+ * const config: PeerConfig = {
+ *   mspId: 'Org1MSP',
+ *   peerEndpoint: 'localhost:7051',
+ *   channelName: 'mychannel',
+ *   chaincodeName: 'mycc',
+ *   contractName: 'mycontract',
+ *   tlsCertPath: '/path/to/tls/cert',
+ *   certDirectoryPath: '/path/to/cert/dir',
+ *   keyDirectoryPath: '/path/to/key/dir'
+ * };
+ *
+ * const adapter = new FabricAdapter(config, 'org1-adapter');
+ *
+ * // Use the adapter to interact with the Fabric network
+ * const result = await adapter.read('users', 'user1', mySerializer);
+ * ```
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant FabricAdapter
+ *   participant Gateway
+ *   participant Network
+ *   participant Contract
+ *   participant Chaincode
+ *
+ *   Client->>FabricAdapter: create(tableName, id, model, transient, serializer)
+ *   FabricAdapter->>FabricAdapter: submitTransaction(OperationKeys.CREATE, [serializedModel], transient)
+ *   FabricAdapter->>Gateway: connect()
+ *   Gateway->>Network: getNetwork(channelName)
+ *   Network->>Contract: getContract(chaincodeName, contractName)
+ *   FabricAdapter->>Contract: submit(api, proposalOptions)
+ *   Contract->>Chaincode: invoke
+ *   Chaincode-->>Contract: response
+ *   Contract-->>FabricAdapter: result
+ *   FabricAdapter->>FabricAdapter: decode(result)
+ *   FabricAdapter->>FabricAdapter: serializer.deserialize(decodedResult)
+ *   FabricAdapter-->>Client: deserializedResult
+ */
+export class FabricClientAdapter extends CouchDBAdapter {
+    /**
+     * @description Static text decoder for converting Uint8Array to string
+     */
+    static { this.decoder = new TextDecoder("utf8"); }
+    static { this.serializer = new ClientSerializer(); }
+    /**
+     * @description Static logger instance for the FabricAdapter class
+     */
+    static { this.log = Logging.for(FabricClientAdapter); }
+    /**
+     * @description Gets the logger instance for this adapter
+     * @summary Returns the static logger instance for the FabricAdapter class
+     * @return {Logger} The logger instance
+     */
+    get log() {
+        return FabricClientAdapter.log;
+    }
+    /**
+     * @description Creates a new FabricAdapter instance
+     * @summary Initializes a new adapter for interacting with a Hyperledger Fabric network
+     * @param {PeerConfig} config - Configuration for connecting to a Fabric peer
+     * @param {string} [alias] - Optional alias for the adapter instance
+     */
+    constructor(config, alias) {
+        super(config, FabricFlavour, alias);
+        this.serializer = FabricClientAdapter.serializer;
+    }
+    /**
+     * @description Decodes a Uint8Array to a string
+     * @summary Converts binary data received from Fabric to a string using UTF-8 encoding
+     * @param {Uint8Array} data - The binary data to decode
+     * @return {string} The decoded string
+     */
+    decode(data) {
+        return FabricClientAdapter.decoder.decode(data);
+    }
+    repository() {
+        return FabricClientRepository;
+    }
+    /**
+     * @description Creates multiple records in a single transaction
+     * @summary Submits a transaction to create multiple records in the Fabric ledger
+     * @param {string} tableName - The name of the table/collection
+     * @param {string[] | number[]} ids - Array of record identifiers
+     * @param {Array<Record<string, any>>} models - Array of record data
+     * @param {Record<string, any>} transient - Transient data for the transaction
+     * @return {Promise<Array<Record<string, any>>>} Promise resolving to the created records
+     */
+    async createAll(tableName, ids, models, transient) {
+        const log = this.log.for(this.createAll);
+        if (ids.length !== models.length)
+            throw new InternalError(`Ids and models must have the same length: ${ids.length} != ${models.length}`);
+        log.info(`adding ${ids.length} entries to ${tableName} table`);
+        log.verbose(`pks: ${ids}`);
+        const result = await this.submitTransaction(BulkCrudOperationKeys.CREATE_ALL, [ids, models.map((m) => this.serializer.serialize(m, tableName))], transient);
+        try {
+            return JSON.parse(this.decode(result)).map((r) => JSON.parse(r));
+        }
+        catch (e) {
+            throw new SerializationError(e);
+        }
+    }
+    /**
+     * @description Reads multiple records in a single transaction
+     * @summary Submits a transaction to read multiple records from the Fabric ledger
+     * @param {string} tableName - The name of the table/collection
+     * @param {string[] | number[]} ids - Array of record identifiers to read
+     * @return {Promise<Array<Record<string, any>>>} Promise resolving to the retrieved records
+     */
+    async readAll(tableName, ids) {
+        const log = this.log.for(this.readAll);
+        log.info(`reading ${ids.length} entries to ${tableName} table`);
+        log.verbose(`pks: ${ids}`);
+        const result = await this.submitTransaction(BulkCrudOperationKeys.READ_ALL, [ids]);
+        try {
+            return JSON.parse(this.decode(result)).map((r) => JSON.parse(r));
+        }
+        catch (e) {
+            throw new SerializationError(e);
+        }
+    }
+    /**
+     * @description Updates multiple records in a single transaction
+     * @summary Submits a transaction to update multiple records in the Fabric ledger
+     * @param {string} tableName - The name of the table/collection
+     * @param {string[] | number[]} ids - Array of record identifiers
+     * @param {Array<Record<string, any>>} models - Array of updated record data
+     * @param {Record<string, any>} transient - Transient data for the transaction
+     * @return {Promise<Array<Record<string, any>>>} Promise resolving to the updated records
+     */
+    async updateAll(tableName, ids, models, transient) {
+        const log = this.log.for(this.updateAll);
+        if (ids.length !== models.length)
+            throw new InternalError(`Ids and models must have the same length: ${ids.length} != ${models.length}`);
+        log.info(`updating ${ids.length} entries to ${tableName} table`);
+        log.verbose(`pks: ${ids}`);
+        const result = await this.submitTransaction(BulkCrudOperationKeys.UPDATE_ALL, [ids, models.map((m) => this.serializer.serialize(m, tableName))], transient);
+        try {
+            return JSON.parse(this.decode(result)).map((r) => JSON.parse(r));
+        }
+        catch (e) {
+            throw new SerializationError(e);
+        }
+    }
+    /**
+     * @description Deletes multiple records in a single transaction
+     * @summary Submits a transaction to delete multiple records from the Fabric ledger
+     * @param {string} tableName - The name of the table/collection
+     * @param {Array<string | number | bigint>} ids - Array of record identifiers to delete
+     * @param {Serializer<any>} serializer - Serializer for the model data
+     * @return {Promise<Array<Record<string, any>>>} Promise resolving to the deleted records
+     */
+    async deleteAll(tableName, ids) {
+        const log = this.log.for(this.deleteAll);
+        log.info(`deleting ${ids.length} entries to ${tableName} table`);
+        log.verbose(`pks: ${ids}`);
+        const result = await this.submitTransaction(BulkCrudOperationKeys.DELETE_ALL, [ids]);
+        try {
+            return JSON.parse(this.decode(result)).map((r) => JSON.parse(r));
+        }
+        catch (e) {
+            throw new SerializationError(e);
+        }
+    }
+    /**
+     * @description Prepares a model for persistence
+     * @summary Converts a model instance into a format suitable for database storage,
+     * handling column mapping and separating transient properties
+     * @template M - The model type
+     * @param {M} model - The model instance to prepare
+     * @param pk - The primary key property name
+     * @return The prepared data
+     */
+    prepare(model, pk) {
+        const log = this.log.for(this.prepare);
+        const split = modelToTransient(model);
+        if (model[PersistenceKeys.METADATA]) {
+            log.silly(`Passing along persistence metadata for ${model[PersistenceKeys.METADATA]}`);
+            Object.defineProperty(split.model, PersistenceKeys.METADATA, {
+                enumerable: false,
+                writable: false,
+                configurable: true,
+                value: model[PersistenceKeys.METADATA],
+            });
+        }
+        return {
+            record: split.model,
+            id: model[pk],
+            transient: split.transient,
+        };
+    }
+    /**
+     * @description Converts database data back into a model instance
+     * @summary Reconstructs a model instance from database data, handling column mapping
+     * and reattaching transient properties
+     * @template M - The model type
+     * @param obj - The database record
+     * @param {string|Constructor<M>} clazz - The model class or name
+     * @param pk - The primary key property name
+     * @param {string|number|bigint} id - The primary key value
+     * @param [transient] - Transient properties to reattach
+     * @return {M} The reconstructed model instance
+     */
+    revert(obj, clazz, pk, id, transient) {
+        const log = this.log.for(this.revert);
+        const ob = {};
+        ob[pk] = id;
+        const m = (typeof clazz === "string" ? Model.build(ob, clazz) : new clazz(ob));
+        log.silly(`Rebuilding model ${m.constructor.name} id ${id}`);
+        const metadata = obj[PersistenceKeys.METADATA];
+        const result = Object.keys(m).reduce((accum, key) => {
+            accum[key] = obj[key];
+            return accum;
+        }, m);
+        if (transient) {
+            log.verbose(`re-adding transient properties: ${Object.keys(transient).join(", ")}`);
+            Object.entries(transient).forEach(([key, val]) => {
+                if (key in result && result[key] !== undefined)
+                    throw new InternalError(`Transient property ${key} already exists on model ${m.constructor.name}. should be impossible`);
+                result[key] = val;
+            });
+        }
+        if (metadata) {
+            log.silly(`Passing along ${this.flavour} persistence metadata for ${m.constructor.name} id ${id}: ${metadata}`);
+            Object.defineProperty(result, PersistenceKeys.METADATA, {
+                enumerable: false,
+                configurable: false,
+                writable: false,
+                value: metadata,
+            });
+        }
+        return result;
+    }
+    /**
+     * @description Creates an index for a model
+     * @summary This method is not implemented for Fabric and will throw an error
+     * @template M - Type extending Model
+     * @param {Constructor<M>} models - The model constructor
+     * @return {Promise<void>} Promise that will throw an error
+     */
+    index(models) {
+        throw new Error();
+    }
+    /**
+     * @description Creates a single record
+     * @summary Submits a transaction to create a record in the Fabric ledger
+     * @param {string} tableName - The name of the table/collection
+     * @param {string | number} id - The record identifier
+     * @param {Record<string, any>} model - The record data
+     * @param {Record<string, any>} transient - Transient data for the transaction
+     * @return {Promise<Record<string, any>>} Promise resolving to the created record
+     */
+    async create(tableName, id, model, transient) {
+        const log = this.log.for(this.create);
+        log.verbose(`adding entry to ${tableName} table`);
+        log.debug(`pk: ${id}`);
+        const result = await this.submitTransaction(OperationKeys.CREATE, [this.serializer.serialize(model, tableName)], transient);
+        return this.serializer.deserialize(this.decode(result));
+    }
+    /**
+     * @description Reads a single record
+     * @summary Evaluates a transaction to read a record from the Fabric ledger
+     * @param {string} tableName - The name of the table/collection
+     * @param {string | number} id - The record identifier
+     * @return {Promise<Record<string, any>>} Promise resolving to the retrieved record
+     */
+    async read(tableName, id) {
+        const log = this.log.for(this.read);
+        log.verbose(`reading entry from ${tableName} table`);
+        log.debug(`pk: ${id}`);
+        const result = await this.evaluateTransaction(OperationKeys.READ, [
+            id.toString(),
+        ]);
+        return this.serializer.deserialize(this.decode(result));
+    }
+    /**
+     * @description Updates a single record
+     * @summary Submits a transaction to update a record in the Fabric ledger
+     * @param {string} tableName - The name of the table/collection
+     * @param {string | number} id - The record identifier
+     * @param {Record<string, any>} model - The updated record data
+     * @param {Record<string, any>} transient - Transient data for the transaction
+     * @return {Promise<Record<string, any>>} Promise resolving to the updated record
+     */
+    async update(tableName, id, model, transient) {
+        const log = this.log.for(this.update);
+        log.verbose(`updating entry to ${tableName} table`);
+        log.debug(`pk: ${id}`);
+        const result = await this.submitTransaction(OperationKeys.UPDATE, [this.serializer.serialize(model, tableName)], transient);
+        return this.serializer.deserialize(this.decode(result));
+    }
+    /**
+     * @description Deletes a single record
+     * @summary Submits a transaction to delete a record from the Fabric ledger
+     * @param {string} tableName - The name of the table/collection
+     * @param {string | number} id - The record identifier to delete
+     * @return {Promise<Record<string, any>>} Promise resolving to the deleted record
+     */
+    async delete(tableName, id) {
+        const log = this.log.for(this.delete);
+        log.verbose(`deleting entry from ${tableName} table`);
+        log.debug(`pk: ${id}`);
+        const result = await this.submitTransaction(OperationKeys.DELETE, [
+            tableName,
+            id,
+        ]);
+        return this.serializer.deserialize(this.decode(result));
+    }
+    /**
+     * @description Executes a raw query against the Fabric ledger
+     * @summary Evaluates a transaction to perform a query using Mango Query syntax
+     * @template V - The return type
+     * @param {MangoQuery} rawInput - The Mango Query to execute
+     * @param {boolean} process - Whether to process the result
+     * @return {Promise<V>} Promise resolving to the query result
+     * @mermaid
+     * sequenceDiagram
+     *   participant Client
+     *   participant FabricAdapter
+     *   participant Contract
+     *   participant Chaincode
+     *
+     *   Client->>FabricAdapter: raw(rawInput, process)
+     *   FabricAdapter->>FabricAdapter: JSON.stringify(rawInput)
+     *   FabricAdapter->>FabricAdapter: evaluateTransaction("query", [input])
+     *   FabricAdapter->>Contract: evaluate("query", proposalOptions)
+     *   Contract->>Chaincode: invoke
+     *   Chaincode-->>Contract: response
+     *   Contract-->>FabricAdapter: result
+     *   FabricAdapter->>FabricAdapter: JSON.parse(decode(result))
+     *   FabricAdapter->>FabricAdapter: Process result based on type
+     *   FabricAdapter-->>Client: processed result
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async raw(rawInput, process) {
+        const log = this.log.for(this.raw);
+        log.info(`Performing raw  query on table`);
+        log.debug(`processing raw input for query: ${JSON.stringify(rawInput)}`);
+        let input;
+        try {
+            input = JSON.stringify(rawInput);
+        }
+        catch (e) {
+            throw new SerializationError(`Failed to process raw input for query: ${e}`);
+        }
+        let transactionResult;
+        try {
+            transactionResult = await this.evaluateTransaction("query", [input]);
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+        let result;
+        try {
+            result = JSON.parse(this.decode(transactionResult));
+        }
+        catch (e) {
+            throw new SerializationError(`Failed to process result: ${e}`);
+        }
+        const parseRecord = (record) => {
+            if (Model.isModel(record))
+                return Model.build(record);
+            return record;
+        };
+        if (Array.isArray(result)) {
+            if (!result.length)
+                return result;
+            const el = result[0];
+            if (Model.isModel(el))
+                // if the first one is a model, all are models
+                return result.map((el) => Model.build(el));
+            return result;
+        }
+        return parseRecord(result);
+    }
+    /**
+     * @description Gets or creates a gRPC client for the Fabric peer
+     * @summary Returns a cached client or creates a new one if none exists
+     * @return {Promise<Client>} Promise resolving to the gRPC client
+     */
+    getClient() {
+        if (!this._client)
+            this._client = FabricClientAdapter.getClient(this.config);
+        return this._client;
+    }
+    /**
+     * @description Gets a Gateway instance for the Fabric network
+     * @summary Creates a new Gateway instance using the current client
+     * @return {Promise<Gateway>} Promise resolving to the Gateway instance
+     */
+    async Gateway() {
+        return FabricClientAdapter.getGateway(this.config, this.client);
+    }
+    /**
+     * @description Gets a Contract instance for the Fabric chaincode
+     * @summary Creates a new Contract instance using the current Gateway
+     * @return {Promise<Contrakt>} Promise resolving to the Contract instance
+     */
+    async Contract() {
+        return FabricClientAdapter.getContract(await this.Gateway(), this.config);
+    }
+    /**
+     * @description Executes a transaction on the Fabric network
+     * @summary Submits or evaluates a transaction on the Fabric chaincode
+     * @param {string} api - The chaincode function to call
+     * @param {boolean} submit - Whether to submit (true) or evaluate (false) the transaction
+     * @param {any[]} [args] - Arguments to pass to the chaincode function
+     * @param {Record<string, string>} [transientData] - Transient data for the transaction
+     * @param {Array<string>} [endorsingOrganizations] - Organizations that must endorse the transaction
+     * @return {Promise<Uint8Array>} Promise resolving to the transaction result
+     * @mermaid
+     * sequenceDiagram
+     *   participant FabricAdapter
+     *   participant Gateway
+     *   participant Contract
+     *   participant Chaincode
+     *
+     *   FabricAdapter->>Gateway: connect()
+     *   FabricAdapter->>Contract: getContract()
+     *   alt submit transaction
+     *     FabricAdapter->>Contract: submit(api, proposalOptions)
+     *   else evaluate transaction
+     *     FabricAdapter->>Contract: evaluate(api, proposalOptions)
+     *   end
+     *   Contract->>Chaincode: invoke
+     *   Chaincode-->>Contract: response
+     *   Contract-->>FabricAdapter: result
+     *   FabricAdapter->>Gateway: close()
+     */
+    async transaction(api, submit = true, args, transientData, endorsingOrganizations) {
+        const log = this.log.for(this.transaction);
+        const gateway = await this.Gateway();
+        try {
+            const contract = await this.Contract();
+            log.verbose(`${submit ? "Submit" : "Evaluate"}ting transaction ${this.config.contractName}.${api}`);
+            log.debug(`args: ${args?.map((a) => a.toString()).join("\n") || "none"}`);
+            const method = submit ? contract.submit : contract.evaluate;
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            endorsingOrganizations = endorsingOrganizations?.length
+                ? endorsingOrganizations
+                : undefined;
+            const proposalOptions = {
+                arguments: args || [],
+                transientData: transientData,
+                // ...(endorsingOrganizations && { endorsingOrganizations }) // mspId list
+            };
+            return await method.call(contract, api, proposalOptions);
+        }
+        catch (e) {
+            if (e.code === 10) {
+                throw new Error(`${e.details[0].message}`);
+            }
+            throw this.parseError(e);
+        }
+        finally {
+            this.log.debug(`Closing ${this.config.mspId} gateway connection`);
+            gateway.close();
+        }
+    }
+    /**
+     * @description Parses an error into a BaseError
+     * @summary Converts any error into a standardized BaseError
+     * @param {Error | string} err - The error to parse
+     * @param {string} [reason] - Optional reason for the error
+     * @return {BaseError} The parsed error
+     */
+    parseError(err, reason) {
+        return FabricClientAdapter.parseError(err, reason);
+    }
+    /**
+     * @description Submits a transaction to the Fabric network
+     * @summary Executes a transaction that modifies the ledger state
+     * @param {string} api - The chaincode function to call
+     * @param {any[]} [args] - Arguments to pass to the chaincode function
+     * @param {Record<string, string>} [transientData] - Transient data for the transaction
+     * @param {Array<string>} [endorsingOrganizations] - Organizations that must endorse the transaction
+     * @return {Promise<Uint8Array>} Promise resolving to the transaction result
+     */
+    async submitTransaction(api, args, transientData, endorsingOrganizations) {
+        return this.transaction(api, true, args, transientData, endorsingOrganizations);
+    }
+    /**
+     * @description Evaluates a transaction on the Fabric network
+     * @summary Executes a transaction that does not modify the ledger state
+     * @param {string} api - The chaincode function to call
+     * @param {any[]} [args] - Arguments to pass to the chaincode function
+     * @param {Record<string, string>} [transientData] - Transient data for the transaction
+     * @param {Array<string>} [endorsingOrganizations] - Organizations that must endorse the transaction
+     * @return {Promise<Uint8Array>} Promise resolving to the transaction result
+     */
+    async evaluateTransaction(api, args, transientData, endorsingOrganizations) {
+        return this.transaction(api, false, args, transientData, endorsingOrganizations);
+    }
+    /**
+     * @description Closes the connection to the Fabric network
+     * @summary Closes the gRPC client if it exists
+     * @return {Promise<void>} Promise that resolves when the client is closed
+     */
+    async close() {
+        if (this.client) {
+            this.log.verbose(`Closing ${this.config.mspId} gateway client`);
+            this.client.close();
+        }
+    }
+    /**
+     * @description Gets a Contract instance from a Gateway
+     * @summary Retrieves a chaincode contract from the specified network
+     * @param {Gateway} gateway - The Gateway instance
+     * @param {PeerConfig} config - The peer configuration
+     * @return {Contrakt} The Contract instance
+     */
+    static getContract(gateway, config) {
+        const log = this.log.for(this.getContract);
+        const network = this.getNetwork(gateway, config.channel);
+        let contract;
+        try {
+            log.debug(`Retrieving chaincode ${config.chaincodeName} contract ${config.contractName} from network ${config.channel}`);
+            contract = network.getContract(config.chaincodeName, config.contractName);
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+        return contract;
+    }
+    /**
+     * @description Gets a Network instance from a Gateway
+     * @summary Connects to a specific channel on the Fabric network
+     * @param {Gateway} gateway - The Gateway instance
+     * @param {string} channelName - The name of the channel to connect to
+     * @return {Network} The Network instance
+     */
+    static getNetwork(gateway, channelName) {
+        const log = this.log.for(this.getNetwork);
+        let network;
+        try {
+            log.debug(`Connecting to channel ${channelName}`);
+            network = gateway.getNetwork(channelName);
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+        return network;
+    }
+    /**
+     * @description Gets a Gateway instance for connecting to the Fabric network
+     * @summary Creates a Gateway using the provided configuration and client
+     * @param {PeerConfig} config - The peer configuration
+     * @param {Client} [client] - Optional gRPC client, will be created if not provided
+     * @return {Promise<Gateway>} Promise resolving to the Gateway instance
+     */
+    static async getGateway(config, client) {
+        return (await this.getConnection(client || (await this.getClient(config)), config));
+    }
+    /**
+     * @description Creates a gRPC client for connecting to a Fabric peer
+     * @summary Initializes a client with TLS credentials for secure communication
+     * @param {PeerConfig} config - The peer configuration
+     * @return {Client} Promise resolving to the gRPC client
+     */
+    static getClient(config) {
+        const log = this.log.for(this.getClient);
+        log.debug(`generating TLS credentials for msp ${config.mspId}`);
+        const tlsCredentials = grpc.credentials.createSsl(typeof config.tlsCert === "string"
+            ? Buffer.from(config.tlsCert)
+            : config.tlsCert);
+        log.debug(`generating Gateway Client for url ${config.peerEndpoint}`);
+        return new Client(config.peerEndpoint, tlsCredentials);
+    }
+    /**
+     * @description Establishes a connection to the Fabric network
+     * @summary Creates a Gateway connection with identity and signer
+     * @param {Client} client - The gRPC client
+     * @param {PeerConfig} config - The peer configuration
+     * @return {Promise<Gateway>} Promise resolving to the connected Gateway
+     * @mermaid
+     * sequenceDiagram
+     *   participant Caller
+     *   participant FabricAdapter
+     *   participant Identity
+     *   participant Signer
+     *   participant Gateway
+     *
+     *   Caller->>FabricAdapter: getConnection(client, config)
+     *   FabricAdapter->>Identity: getIdentity(mspId, certDirectoryPath)
+     *   Identity-->>FabricAdapter: identity
+     *   FabricAdapter->>Signer: getSigner(keyDirectoryPath)
+     *   Signer-->>FabricAdapter: signer
+     *   FabricAdapter->>FabricAdapter: Create ConnectOptions
+     *   FabricAdapter->>Gateway: connect(options)
+     *   Gateway-->>FabricAdapter: gateway
+     *   FabricAdapter-->>Caller: gateway
+     */
+    static async getConnection(client, config) {
+        const log = this.log.for(this.getConnection);
+        log.debug(`Retrieving Peer Identity for ${config.mspId} under ${config.certCertOrDirectoryPath}`);
+        const identity = await getIdentity(config.mspId, config.certCertOrDirectoryPath);
+        log.debug(`Retrieving signer key from ${config.keyCertOrDirectoryPath}`);
+        const signer = await getSigner(config.keyCertOrDirectoryPath);
+        const options = {
+            client,
+            identity: identity,
+            signer: signer,
+            // Default timeouts for different gRPC calls
+            evaluateOptions: () => {
+                return { deadline: Date.now() + 5000 }; // 5 seconds
+            },
+            endorseOptions: () => {
+                return { deadline: Date.now() + 15000 }; // 15 seconds
+            },
+            submitOptions: () => {
+                return { deadline: Date.now() + 5000 }; // 5 seconds
+            },
+            commitStatusOptions: () => {
+                return { deadline: Date.now() + 60000 }; // 1 minute
+            },
+        };
+        log.debug(`Connecting to ${config.mspId}`);
+        return connect(options);
+    }
+    /**
+     * @description Creates a new Dispatch instance for the Fabric client.
+     * @summary This function is responsible for creating a new FabricClientDispatch instance that can be used to interact with the Fabric network.
+     * @returns {Dispatch} A new Dispatch instance configured for the Fabric client.
+     * @remarks The Dispatch instance is used to encapsulate the logic for interacting with the Fabric network, such as submitting transactions or querying data.
+     * @example
+     * const fabricDispatch = fabricClientAdapter.Dispatch();
+     * fabricDispatch.submitTransaction('createProduct', { name: 'Product A', price: 100 });
+     */
+    Dispatch() {
+        return new FabricClientDispatch(this.getClient());
+    }
+    /**
+     * @description Parses an error into a BaseError
+     * @summary Converts any error into a standardized BaseError using the parent class implementation
+     * @param {Error | string} err - The error to parse
+     * @param {string} [reason] - Optional reason for the error
+     * @return {BaseError} The parsed error
+     */
+    static parseError(err, reason) {
+        return super.parseError(err, reason);
+    }
+}
+__decorate([
+    debug(true)
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], FabricClientAdapter.prototype, "index", null);
+__decorate([
+    debug(true),
+    final(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], FabricClientAdapter.prototype, "create", null);
+__decorate([
+    debug(true),
+    final(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], FabricClientAdapter.prototype, "read", null);
+__decorate([
+    debug(true),
+    final(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], FabricClientAdapter.prototype, "update", null);
+__decorate([
+    debug(true),
+    final(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], FabricClientAdapter.prototype, "delete", null);
+__decorate([
+    debug(true)
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Boolean]),
+    __metadata("design:returntype", Promise)
+], FabricClientAdapter.prototype, "raw", null);
+FabricClientAdapter.decoration();
+Adapter.setCurrent(FabricFlavour);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FabricClientAdapter.js","sourceRoot":"","sources":["../../../src/client/FabricClientAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["import { CouchDBAdapter, type MangoQuery } from \"@decaf-ts/for-couchdb\";\nimport { Client } from \"@grpc/grpc-js\";\nimport * as grpc from \"@grpc/grpc-js\";\n\nimport {\n  type Constructor,\n  Model,\n  type Serializer,\n} from \"@decaf-ts/decorator-validation\";\nimport { debug, Logger, Logging } from \"@decaf-ts/logging\";\nimport { FabricFlags, PeerConfig } from \"../shared/types\";\nimport {\n  connect,\n  ConnectOptions,\n  Gateway,\n  Network,\n  ProposalOptions,\n  Contract as Contrakt,\n} from \"@hyperledger/fabric-gateway\";\nimport { getIdentity, getSigner } from \"./fabric-fs\";\nimport {\n  BaseError,\n  Context,\n  InternalError,\n  OperationKeys,\n  SerializationError,\n  BulkCrudOperationKeys,\n  modelToTransient,\n} from \"@decaf-ts/db-decorators\";\nimport {\n  Adapter,\n  Dispatch,\n  final,\n  PersistenceKeys,\n  Repository,\n} from \"@decaf-ts/core\";\nimport { FabricClientRepository } from \"./FabricClientRepository\";\nimport { FabricFlavour } from \"../shared/constants\";\nimport { ClientSerializer } from \"../shared/ClientSerializer\";\nimport { FabricClientDispatch } from \"./FabricClientDispatch\";\n\n/**\n * @description Adapter for interacting with Hyperledger Fabric networks\n * @summary The FabricAdapter extends CouchDBAdapter to provide a seamless interface for interacting with Hyperledger Fabric networks.\n * It handles connection management, transaction submission, and CRUD operations against Fabric chaincode.\n * @template PeerConfig - Configuration type for connecting to a Fabric peer\n * @template FabricFlags - Flags specific to Fabric operations\n * @template Context<FabricFlags> - Context type containing Fabric-specific flags\n * @param config - Configuration for connecting to a Fabric peer\n * @param alias - Optional alias for the adapter instance\n * @class FabricClientAdapter\n * @example\n * ```typescript\n * // Create a new FabricAdapter instance\n * const config: PeerConfig = {\n *   mspId: 'Org1MSP',\n *   peerEndpoint: 'localhost:7051',\n *   channelName: 'mychannel',\n *   chaincodeName: 'mycc',\n *   contractName: 'mycontract',\n *   tlsCertPath: '/path/to/tls/cert',\n *   certDirectoryPath: '/path/to/cert/dir',\n *   keyDirectoryPath: '/path/to/key/dir'\n * };\n *\n * const adapter = new FabricAdapter(config, 'org1-adapter');\n *\n * // Use the adapter to interact with the Fabric network\n * const result = await adapter.read('users', 'user1', mySerializer);\n * ```\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant FabricAdapter\n *   participant Gateway\n *   participant Network\n *   participant Contract\n *   participant Chaincode\n *\n *   Client->>FabricAdapter: create(tableName, id, model, transient, serializer)\n *   FabricAdapter->>FabricAdapter: submitTransaction(OperationKeys.CREATE, [serializedModel], transient)\n *   FabricAdapter->>Gateway: connect()\n *   Gateway->>Network: getNetwork(channelName)\n *   Network->>Contract: getContract(chaincodeName, contractName)\n *   FabricAdapter->>Contract: submit(api, proposalOptions)\n *   Contract->>Chaincode: invoke\n *   Chaincode-->>Contract: response\n *   Contract-->>FabricAdapter: result\n *   FabricAdapter->>FabricAdapter: decode(result)\n *   FabricAdapter->>FabricAdapter: serializer.deserialize(decodedResult)\n *   FabricAdapter-->>Client: deserializedResult\n */\nexport class FabricClientAdapter extends CouchDBAdapter<\n  PeerConfig,\n  Client,\n  FabricFlags,\n  Context<FabricFlags>\n> {\n  /**\n   * @description Static text decoder for converting Uint8Array to string\n   */\n  private static decoder = new TextDecoder(\"utf8\");\n\n  private static serializer = new ClientSerializer();\n\n  /**\n   * @description Static logger instance for the FabricAdapter class\n   */\n  private static log: Logger = Logging.for(FabricClientAdapter);\n\n  /**\n   * @description Gets the logger instance for this adapter\n   * @summary Returns the static logger instance for the FabricAdapter class\n   * @return {Logger} The logger instance\n   */\n  protected override get log(): Logger {\n    return FabricClientAdapter.log;\n  }\n\n  protected readonly serializer: Serializer<any> =\n    FabricClientAdapter.serializer;\n\n  /**\n   * @description Creates a new FabricAdapter instance\n   * @summary Initializes a new adapter for interacting with a Hyperledger Fabric network\n   * @param {PeerConfig} config - Configuration for connecting to a Fabric peer\n   * @param {string} [alias] - Optional alias for the adapter instance\n   */\n  constructor(config: PeerConfig, alias?: string) {\n    super(config, FabricFlavour, alias);\n  }\n\n  /**\n   * @description Decodes a Uint8Array to a string\n   * @summary Converts binary data received from Fabric to a string using UTF-8 encoding\n   * @param {Uint8Array} data - The binary data to decode\n   * @return {string} The decoded string\n   */\n  decode(data: Uint8Array): string {\n    return FabricClientAdapter.decoder.decode(data);\n  }\n\n  override repository<M extends Model<true | false>>(): Constructor<\n    Repository<\n      M,\n      MangoQuery,\n      Adapter<\n        PeerConfig,\n        Client,\n        MangoQuery,\n        FabricFlags,\n        Context<FabricFlags>\n      >,\n      FabricFlags,\n      Context<FabricFlags>\n    >\n  > {\n    return FabricClientRepository;\n  }\n\n  /**\n   * @description Creates multiple records in a single transaction\n   * @summary Submits a transaction to create multiple records in the Fabric ledger\n   * @param {string} tableName - The name of the table/collection\n   * @param {string[] | number[]} ids - Array of record identifiers\n   * @param {Array<Record<string, any>>} models - Array of record data\n   * @param {Record<string, any>} transient - Transient data for the transaction\n   * @return {Promise<Array<Record<string, any>>>} Promise resolving to the created records\n   */\n  override async createAll(\n    tableName: string,\n    ids: string[] | number[],\n    models: Record<string, any>[],\n    transient: Record<string, any>\n  ): Promise<Record<string, any>[]> {\n    const log = this.log.for(this.createAll);\n    if (ids.length !== models.length)\n      throw new InternalError(\n        `Ids and models must have the same length: ${ids.length} != ${models.length}`\n      );\n    log.info(`adding ${ids.length} entries to ${tableName} table`);\n    log.verbose(`pks: ${ids}`);\n    const result = await this.submitTransaction(\n      BulkCrudOperationKeys.CREATE_ALL,\n      [ids, models.map((m) => this.serializer.serialize(m, tableName))],\n      transient\n    );\n    try {\n      return JSON.parse(this.decode(result)).map((r: any) => JSON.parse(r));\n    } catch (e: unknown) {\n      throw new SerializationError(e as Error);\n    }\n  }\n\n  /**\n   * @description Reads multiple records in a single transaction\n   * @summary Submits a transaction to read multiple records from the Fabric ledger\n   * @param {string} tableName - The name of the table/collection\n   * @param {string[] | number[]} ids - Array of record identifiers to read\n   * @return {Promise<Array<Record<string, any>>>} Promise resolving to the retrieved records\n   */\n  override async readAll(\n    tableName: string,\n    ids: string[] | number[]\n  ): Promise<Record<string, any>[]> {\n    const log = this.log.for(this.readAll);\n    log.info(`reading ${ids.length} entries to ${tableName} table`);\n    log.verbose(`pks: ${ids}`);\n    const result = await this.submitTransaction(\n      BulkCrudOperationKeys.READ_ALL,\n      [ids]\n    );\n    try {\n      return JSON.parse(this.decode(result)).map((r: any) => JSON.parse(r));\n    } catch (e: unknown) {\n      throw new SerializationError(e as Error);\n    }\n  }\n\n  /**\n   * @description Updates multiple records in a single transaction\n   * @summary Submits a transaction to update multiple records in the Fabric ledger\n   * @param {string} tableName - The name of the table/collection\n   * @param {string[] | number[]} ids - Array of record identifiers\n   * @param {Array<Record<string, any>>} models - Array of updated record data\n   * @param {Record<string, any>} transient - Transient data for the transaction\n   * @return {Promise<Array<Record<string, any>>>} Promise resolving to the updated records\n   */\n  override async updateAll(\n    tableName: string,\n    ids: string[] | number[],\n    models: Record<string, any>[],\n    transient: Record<string, any>\n  ): Promise<Record<string, any>[]> {\n    const log = this.log.for(this.updateAll);\n    if (ids.length !== models.length)\n      throw new InternalError(\n        `Ids and models must have the same length: ${ids.length} != ${models.length}`\n      );\n    log.info(`updating ${ids.length} entries to ${tableName} table`);\n    log.verbose(`pks: ${ids}`);\n    const result = await this.submitTransaction(\n      BulkCrudOperationKeys.UPDATE_ALL,\n      [ids, models.map((m) => this.serializer.serialize(m, tableName))],\n      transient\n    );\n    try {\n      return JSON.parse(this.decode(result)).map((r: any) => JSON.parse(r));\n    } catch (e: unknown) {\n      throw new SerializationError(e as Error);\n    }\n  }\n\n  /**\n   * @description Deletes multiple records in a single transaction\n   * @summary Submits a transaction to delete multiple records from the Fabric ledger\n   * @param {string} tableName - The name of the table/collection\n   * @param {Array<string | number | bigint>} ids - Array of record identifiers to delete\n   * @param {Serializer<any>} serializer - Serializer for the model data\n   * @return {Promise<Array<Record<string, any>>>} Promise resolving to the deleted records\n   */\n  override async deleteAll(\n    tableName: string,\n    ids: (string | number | bigint)[]\n  ): Promise<Record<string, any>[]> {\n    const log = this.log.for(this.deleteAll);\n    log.info(`deleting ${ids.length} entries to ${tableName} table`);\n    log.verbose(`pks: ${ids}`);\n    const result = await this.submitTransaction(\n      BulkCrudOperationKeys.DELETE_ALL,\n      [ids]\n    );\n    try {\n      return JSON.parse(this.decode(result)).map((r: any) => JSON.parse(r));\n    } catch (e: unknown) {\n      throw new SerializationError(e as Error);\n    }\n  }\n\n  /**\n   * @description Prepares a model for persistence\n   * @summary Converts a model instance into a format suitable for database storage,\n   * handling column mapping and separating transient properties\n   * @template M - The model type\n   * @param {M} model - The model instance to prepare\n   * @param pk - The primary key property name\n   * @return The prepared data\n   */\n  override prepare<M extends Model>(\n    model: M,\n    pk: keyof M\n  ): {\n    record: Record<string, any>;\n    id: string;\n    transient?: Record<string, any>;\n  } {\n    const log = this.log.for(this.prepare);\n    const split = modelToTransient(model);\n    if ((model as any)[PersistenceKeys.METADATA]) {\n      log.silly(\n        `Passing along persistence metadata for ${(model as any)[PersistenceKeys.METADATA]}`\n      );\n      Object.defineProperty(split.model, PersistenceKeys.METADATA, {\n        enumerable: false,\n        writable: false,\n        configurable: true,\n        value: (model as any)[PersistenceKeys.METADATA],\n      });\n    }\n\n    return {\n      record: split.model,\n      id: model[pk] as string,\n      transient: split.transient,\n    };\n  }\n\n  /**\n   * @description Converts database data back into a model instance\n   * @summary Reconstructs a model instance from database data, handling column mapping\n   * and reattaching transient properties\n   * @template M - The model type\n   * @param obj - The database record\n   * @param {string|Constructor<M>} clazz - The model class or name\n   * @param pk - The primary key property name\n   * @param {string|number|bigint} id - The primary key value\n   * @param [transient] - Transient properties to reattach\n   * @return {M} The reconstructed model instance\n   */\n  override revert<M extends Model>(\n    obj: Record<string, any>,\n    clazz: string | Constructor<M>,\n    pk: keyof M,\n    id: string | number | bigint,\n    transient?: Record<string, any>\n  ): M {\n    const log = this.log.for(this.revert);\n    const ob: Record<string, any> = {};\n    ob[pk as string] = id;\n    const m = (\n      typeof clazz === \"string\" ? Model.build(ob, clazz) : new clazz(ob)\n    ) as M;\n    log.silly(`Rebuilding model ${m.constructor.name} id ${id}`);\n    const metadata = obj[PersistenceKeys.METADATA];\n    const result = Object.keys(m).reduce((accum: M, key) => {\n      (accum as Record<string, any>)[key] = obj[key];\n      return accum;\n    }, m);\n\n    if (transient) {\n      log.verbose(\n        `re-adding transient properties: ${Object.keys(transient).join(\", \")}`\n      );\n      Object.entries(transient).forEach(([key, val]) => {\n        if (key in result && (result as any)[key] !== undefined)\n          throw new InternalError(\n            `Transient property ${key} already exists on model ${m.constructor.name}. should be impossible`\n          );\n        result[key as keyof M] = val;\n      });\n    }\n\n    if (metadata) {\n      log.silly(\n        `Passing along ${this.flavour} persistence metadata for ${m.constructor.name} id ${id}: ${metadata}`\n      );\n      Object.defineProperty(result, PersistenceKeys.METADATA, {\n        enumerable: false,\n        configurable: false,\n        writable: false,\n        value: metadata,\n      });\n    }\n\n    return result;\n  }\n\n  /**\n   * @description Creates an index for a model\n   * @summary This method is not implemented for Fabric and will throw an error\n   * @template M - Type extending Model\n   * @param {Constructor<M>} models - The model constructor\n   * @return {Promise<void>} Promise that will throw an error\n   */\n  @debug(true)\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  protected index<M>(models: Constructor<M>): Promise<void> {\n    throw new Error();\n  }\n\n  /**\n   * @description Creates a single record\n   * @summary Submits a transaction to create a record in the Fabric ledger\n   * @param {string} tableName - The name of the table/collection\n   * @param {string | number} id - The record identifier\n   * @param {Record<string, any>} model - The record data\n   * @param {Record<string, any>} transient - Transient data for the transaction\n   * @return {Promise<Record<string, any>>} Promise resolving to the created record\n   */\n  @debug(true)\n  @final()\n  override async create(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>,\n    transient: Record<string, any>\n  ): Promise<Record<string, any>> {\n    const log = this.log.for(this.create);\n    log.verbose(`adding entry to ${tableName} table`);\n    log.debug(`pk: ${id}`);\n    const result = await this.submitTransaction(\n      OperationKeys.CREATE,\n      [this.serializer.serialize(model, tableName)],\n      transient\n    );\n    return this.serializer.deserialize(this.decode(result));\n  }\n\n  /**\n   * @description Reads a single record\n   * @summary Evaluates a transaction to read a record from the Fabric ledger\n   * @param {string} tableName - The name of the table/collection\n   * @param {string | number} id - The record identifier\n   * @return {Promise<Record<string, any>>} Promise resolving to the retrieved record\n   */\n  @debug(true)\n  @final()\n  async read(\n    tableName: string,\n    id: string | number\n  ): Promise<Record<string, any>> {\n    const log = this.log.for(this.read);\n    log.verbose(`reading entry from ${tableName} table`);\n    log.debug(`pk: ${id}`);\n    const result = await this.evaluateTransaction(OperationKeys.READ, [\n      id.toString(),\n    ]);\n    return this.serializer.deserialize(this.decode(result));\n  }\n\n  /**\n   * @description Updates a single record\n   * @summary Submits a transaction to update a record in the Fabric ledger\n   * @param {string} tableName - The name of the table/collection\n   * @param {string | number} id - The record identifier\n   * @param {Record<string, any>} model - The updated record data\n   * @param {Record<string, any>} transient - Transient data for the transaction\n   * @return {Promise<Record<string, any>>} Promise resolving to the updated record\n   */\n  @debug(true)\n  @final()\n  async update(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>,\n    transient: Record<string, any>\n  ): Promise<Record<string, any>> {\n    const log = this.log.for(this.update);\n    log.verbose(`updating entry to ${tableName} table`);\n    log.debug(`pk: ${id}`);\n    const result = await this.submitTransaction(\n      OperationKeys.UPDATE,\n      [this.serializer.serialize(model, tableName)],\n      transient\n    );\n    return this.serializer.deserialize(this.decode(result));\n  }\n\n  /**\n   * @description Deletes a single record\n   * @summary Submits a transaction to delete a record from the Fabric ledger\n   * @param {string} tableName - The name of the table/collection\n   * @param {string | number} id - The record identifier to delete\n   * @return {Promise<Record<string, any>>} Promise resolving to the deleted record\n   */\n  @debug(true)\n  @final()\n  async delete(\n    tableName: string,\n    id: string | number\n  ): Promise<Record<string, any>> {\n    const log = this.log.for(this.delete);\n    log.verbose(`deleting entry from ${tableName} table`);\n    log.debug(`pk: ${id}`);\n    const result = await this.submitTransaction(OperationKeys.DELETE, [\n      tableName,\n      id,\n    ]);\n    return this.serializer.deserialize(this.decode(result));\n  }\n\n  /**\n   * @description Executes a raw query against the Fabric ledger\n   * @summary Evaluates a transaction to perform a query using Mango Query syntax\n   * @template V - The return type\n   * @param {MangoQuery} rawInput - The Mango Query to execute\n   * @param {boolean} process - Whether to process the result\n   * @return {Promise<V>} Promise resolving to the query result\n   * @mermaid\n   * sequenceDiagram\n   *   participant Client\n   *   participant FabricAdapter\n   *   participant Contract\n   *   participant Chaincode\n   *\n   *   Client->>FabricAdapter: raw(rawInput, process)\n   *   FabricAdapter->>FabricAdapter: JSON.stringify(rawInput)\n   *   FabricAdapter->>FabricAdapter: evaluateTransaction(\"query\", [input])\n   *   FabricAdapter->>Contract: evaluate(\"query\", proposalOptions)\n   *   Contract->>Chaincode: invoke\n   *   Chaincode-->>Contract: response\n   *   Contract-->>FabricAdapter: result\n   *   FabricAdapter->>FabricAdapter: JSON.parse(decode(result))\n   *   FabricAdapter->>FabricAdapter: Process result based on type\n   *   FabricAdapter-->>Client: processed result\n   */\n  @debug(true)\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  async raw<V>(rawInput: MangoQuery, process: boolean): Promise<V> {\n    const log = this.log.for(this.raw);\n    log.info(`Performing raw  query on table`);\n    log.debug(`processing raw input for query: ${JSON.stringify(rawInput)}`);\n    let input: string;\n    try {\n      input = JSON.stringify(rawInput);\n    } catch (e: any) {\n      throw new SerializationError(\n        `Failed to process raw input for query: ${e}`\n      );\n    }\n    let transactionResult: any;\n    try {\n      transactionResult = await this.evaluateTransaction(\"query\", [input]);\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n    let result: any;\n    try {\n      result = JSON.parse(this.decode(transactionResult));\n    } catch (e: any) {\n      throw new SerializationError(`Failed to process result: ${e}`);\n    }\n\n    const parseRecord = (record: Record<any, any>) => {\n      if (Model.isModel(record)) return Model.build(record);\n      return record;\n    };\n\n    if (Array.isArray(result)) {\n      if (!result.length) return result as V;\n      const el = result[0];\n      if (Model.isModel(el))\n        // if the first one is a model, all are models\n        return result.map((el) => Model.build(el)) as V;\n      return result as V;\n    }\n\n    return parseRecord(result as any) as V;\n  }\n\n  /**\n   * @description Gets or creates a gRPC client for the Fabric peer\n   * @summary Returns a cached client or creates a new one if none exists\n   * @return {Promise<Client>} Promise resolving to the gRPC client\n   */\n  override getClient(): Client {\n    if (!this._client)\n      this._client = FabricClientAdapter.getClient(this.config);\n    return this._client;\n  }\n\n  /**\n   * @description Gets a Gateway instance for the Fabric network\n   * @summary Creates a new Gateway instance using the current client\n   * @return {Promise<Gateway>} Promise resolving to the Gateway instance\n   */\n  protected async Gateway(): Promise<Gateway> {\n    return FabricClientAdapter.getGateway(this.config, this.client);\n  }\n\n  /**\n   * @description Gets a Contract instance for the Fabric chaincode\n   * @summary Creates a new Contract instance using the current Gateway\n   * @return {Promise<Contrakt>} Promise resolving to the Contract instance\n   */\n  protected async Contract(): Promise<Contrakt> {\n    return FabricClientAdapter.getContract(await this.Gateway(), this.config);\n  }\n\n  /**\n   * @description Executes a transaction on the Fabric network\n   * @summary Submits or evaluates a transaction on the Fabric chaincode\n   * @param {string} api - The chaincode function to call\n   * @param {boolean} submit - Whether to submit (true) or evaluate (false) the transaction\n   * @param {any[]} [args] - Arguments to pass to the chaincode function\n   * @param {Record<string, string>} [transientData] - Transient data for the transaction\n   * @param {Array<string>} [endorsingOrganizations] - Organizations that must endorse the transaction\n   * @return {Promise<Uint8Array>} Promise resolving to the transaction result\n   * @mermaid\n   * sequenceDiagram\n   *   participant FabricAdapter\n   *   participant Gateway\n   *   participant Contract\n   *   participant Chaincode\n   *\n   *   FabricAdapter->>Gateway: connect()\n   *   FabricAdapter->>Contract: getContract()\n   *   alt submit transaction\n   *     FabricAdapter->>Contract: submit(api, proposalOptions)\n   *   else evaluate transaction\n   *     FabricAdapter->>Contract: evaluate(api, proposalOptions)\n   *   end\n   *   Contract->>Chaincode: invoke\n   *   Chaincode-->>Contract: response\n   *   Contract-->>FabricAdapter: result\n   *   FabricAdapter->>Gateway: close()\n   */\n  protected async transaction(\n    api: string,\n    submit = true,\n    args?: any[],\n    transientData?: Record<string, string>,\n    endorsingOrganizations?: Array<string>\n  ): Promise<Uint8Array> {\n    const log = this.log.for(this.transaction);\n    const gateway = await this.Gateway();\n    try {\n      const contract = await this.Contract();\n      log.verbose(\n        `${submit ? \"Submit\" : \"Evaluate\"}ting transaction ${this.config.contractName}.${api}`\n      );\n      log.debug(`args: ${args?.map((a) => a.toString()).join(\"\\n\") || \"none\"}`);\n      const method = submit ? contract.submit : contract.evaluate;\n\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      endorsingOrganizations = endorsingOrganizations?.length\n        ? endorsingOrganizations\n        : undefined;\n      const proposalOptions: ProposalOptions = {\n        arguments: args || [],\n        transientData: transientData,\n        // ...(endorsingOrganizations && { endorsingOrganizations }) // mspId list\n      };\n\n      return await method.call(contract, api, proposalOptions);\n    } catch (e: any) {\n      if (e.code === 10) {\n        throw new Error(`${e.details[0].message}`);\n      }\n      throw this.parseError(e);\n    } finally {\n      this.log.debug(`Closing ${this.config.mspId} gateway connection`);\n      gateway.close();\n    }\n  }\n\n  /**\n   * @description Parses an error into a BaseError\n   * @summary Converts any error into a standardized BaseError\n   * @param {Error | string} err - The error to parse\n   * @param {string} [reason] - Optional reason for the error\n   * @return {BaseError} The parsed error\n   */\n  override parseError(err: Error | string, reason?: string): BaseError {\n    return FabricClientAdapter.parseError(err, reason);\n  }\n\n  /**\n   * @description Submits a transaction to the Fabric network\n   * @summary Executes a transaction that modifies the ledger state\n   * @param {string} api - The chaincode function to call\n   * @param {any[]} [args] - Arguments to pass to the chaincode function\n   * @param {Record<string, string>} [transientData] - Transient data for the transaction\n   * @param {Array<string>} [endorsingOrganizations] - Organizations that must endorse the transaction\n   * @return {Promise<Uint8Array>} Promise resolving to the transaction result\n   */\n  async submitTransaction(\n    api: string,\n    args?: any[],\n    transientData?: Record<string, string>,\n    endorsingOrganizations?: Array<string>\n  ): Promise<Uint8Array> {\n    return this.transaction(\n      api,\n      true,\n      args,\n      transientData,\n      endorsingOrganizations\n    );\n  }\n\n  /**\n   * @description Evaluates a transaction on the Fabric network\n   * @summary Executes a transaction that does not modify the ledger state\n   * @param {string} api - The chaincode function to call\n   * @param {any[]} [args] - Arguments to pass to the chaincode function\n   * @param {Record<string, string>} [transientData] - Transient data for the transaction\n   * @param {Array<string>} [endorsingOrganizations] - Organizations that must endorse the transaction\n   * @return {Promise<Uint8Array>} Promise resolving to the transaction result\n   */\n  async evaluateTransaction(\n    api: string,\n    args?: any[],\n    transientData?: Record<string, string>,\n    endorsingOrganizations?: Array<string>\n  ): Promise<Uint8Array> {\n    return this.transaction(\n      api,\n      false,\n      args,\n      transientData,\n      endorsingOrganizations\n    );\n  }\n\n  /**\n   * @description Closes the connection to the Fabric network\n   * @summary Closes the gRPC client if it exists\n   * @return {Promise<void>} Promise that resolves when the client is closed\n   */\n  async close(): Promise<void> {\n    if (this.client) {\n      this.log.verbose(`Closing ${this.config.mspId} gateway client`);\n      this.client.close();\n    }\n  }\n\n  /**\n   * @description Gets a Contract instance from a Gateway\n   * @summary Retrieves a chaincode contract from the specified network\n   * @param {Gateway} gateway - The Gateway instance\n   * @param {PeerConfig} config - The peer configuration\n   * @return {Contrakt} The Contract instance\n   */\n  static getContract(gateway: Gateway, config: PeerConfig): Contrakt {\n    const log = this.log.for(this.getContract);\n    const network = this.getNetwork(gateway, config.channel);\n    let contract: Contrakt;\n    try {\n      log.debug(\n        `Retrieving chaincode ${config.chaincodeName} contract ${config.contractName} from network ${config.channel}`\n      );\n      contract = network.getContract(config.chaincodeName, config.contractName);\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n    return contract;\n  }\n\n  /**\n   * @description Gets a Network instance from a Gateway\n   * @summary Connects to a specific channel on the Fabric network\n   * @param {Gateway} gateway - The Gateway instance\n   * @param {string} channelName - The name of the channel to connect to\n   * @return {Network} The Network instance\n   */\n  static getNetwork(gateway: Gateway, channelName: string): Network {\n    const log = this.log.for(this.getNetwork);\n    let network: Network;\n    try {\n      log.debug(`Connecting to channel ${channelName}`);\n      network = gateway.getNetwork(channelName);\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n\n    return network;\n  }\n\n  /**\n   * @description Gets a Gateway instance for connecting to the Fabric network\n   * @summary Creates a Gateway using the provided configuration and client\n   * @param {PeerConfig} config - The peer configuration\n   * @param {Client} [client] - Optional gRPC client, will be created if not provided\n   * @return {Promise<Gateway>} Promise resolving to the Gateway instance\n   */\n  static async getGateway(config: PeerConfig, client?: Client) {\n    return (await this.getConnection(\n      client || (await this.getClient(config)),\n      config\n    )) as Gateway;\n  }\n\n  /**\n   * @description Creates a gRPC client for connecting to a Fabric peer\n   * @summary Initializes a client with TLS credentials for secure communication\n   * @param {PeerConfig} config - The peer configuration\n   * @return {Client} Promise resolving to the gRPC client\n   */\n  static getClient(config: PeerConfig): Client {\n    const log = this.log.for(this.getClient);\n    log.debug(`generating TLS credentials for msp ${config.mspId}`);\n    const tlsCredentials = grpc.credentials.createSsl(\n      typeof config.tlsCert === \"string\"\n        ? Buffer.from(config.tlsCert)\n        : config.tlsCert\n    );\n    log.debug(`generating Gateway Client for url ${config.peerEndpoint}`);\n    return new Client(config.peerEndpoint, tlsCredentials);\n  }\n\n  /**\n   * @description Establishes a connection to the Fabric network\n   * @summary Creates a Gateway connection with identity and signer\n   * @param {Client} client - The gRPC client\n   * @param {PeerConfig} config - The peer configuration\n   * @return {Promise<Gateway>} Promise resolving to the connected Gateway\n   * @mermaid\n   * sequenceDiagram\n   *   participant Caller\n   *   participant FabricAdapter\n   *   participant Identity\n   *   participant Signer\n   *   participant Gateway\n   *\n   *   Caller->>FabricAdapter: getConnection(client, config)\n   *   FabricAdapter->>Identity: getIdentity(mspId, certDirectoryPath)\n   *   Identity-->>FabricAdapter: identity\n   *   FabricAdapter->>Signer: getSigner(keyDirectoryPath)\n   *   Signer-->>FabricAdapter: signer\n   *   FabricAdapter->>FabricAdapter: Create ConnectOptions\n   *   FabricAdapter->>Gateway: connect(options)\n   *   Gateway-->>FabricAdapter: gateway\n   *   FabricAdapter-->>Caller: gateway\n   */\n  static async getConnection(client: Client, config: PeerConfig) {\n    const log = this.log.for(this.getConnection);\n    log.debug(\n      `Retrieving Peer Identity for ${config.mspId} under ${config.certCertOrDirectoryPath}`\n    );\n    const identity = await getIdentity(\n      config.mspId,\n      config.certCertOrDirectoryPath\n    );\n    log.debug(`Retrieving signer key from ${config.keyCertOrDirectoryPath}`);\n\n    const signer = await getSigner(config.keyCertOrDirectoryPath);\n\n    const options = {\n      client,\n      identity: identity,\n      signer: signer,\n      // Default timeouts for different gRPC calls\n      evaluateOptions: () => {\n        return { deadline: Date.now() + 5000 }; // 5 seconds\n      },\n      endorseOptions: () => {\n        return { deadline: Date.now() + 15000 }; // 15 seconds\n      },\n      submitOptions: () => {\n        return { deadline: Date.now() + 5000 }; // 5 seconds\n      },\n      commitStatusOptions: () => {\n        return { deadline: Date.now() + 60000 }; // 1 minute\n      },\n    } as ConnectOptions;\n\n    log.debug(`Connecting to ${config.mspId}`);\n    return connect(options);\n  }\n\n  /**\n   * @description Creates a new Dispatch instance for the Fabric client.\n   * @summary This function is responsible for creating a new FabricClientDispatch instance that can be used to interact with the Fabric network.\n   * @returns {Dispatch} A new Dispatch instance configured for the Fabric client.\n   * @remarks The Dispatch instance is used to encapsulate the logic for interacting with the Fabric network, such as submitting transactions or querying data.\n   * @example\n   * const fabricDispatch = fabricClientAdapter.Dispatch();\n   * fabricDispatch.submitTransaction('createProduct', { name: 'Product A', price: 100 });\n   */\n  override Dispatch(): Dispatch {\n    return new FabricClientDispatch(this.getClient());\n  }\n\n  /**\n   * @description Parses an error into a BaseError\n   * @summary Converts any error into a standardized BaseError using the parent class implementation\n   * @param {Error | string} err - The error to parse\n   * @param {string} [reason] - Optional reason for the error\n   * @return {BaseError} The parsed error\n   */\n  protected static override parseError(\n    err: Error | string,\n    reason?: string\n  ): BaseError {\n    return super.parseError(err, reason);\n  }\n}\n\nFabricClientAdapter.decoration();\nAdapter.setCurrent(FabricFlavour);\n"]}