@decaf-ts/for-fabric 0.5.7 → 0.7.0

package/lib/cjs/client/FabricClientAdapter.cjs

@@ -0,0 +1,1362 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FabricClientAdapter = void 0;
+require("./../shared/overrides/index.cjs");
+const for_couchdb_1 = require("@decaf-ts/for-couchdb");
+const grpc_js_1 = require("@grpc/grpc-js");
+const grpc = __importStar(require("@grpc/grpc-js"));
+const decorator_validation_1 = require("@decaf-ts/decorator-validation");
+const logging_1 = require("@decaf-ts/logging");
+const fabric_gateway_1 = require("@hyperledger/fabric-gateway");
+const fabric_network_1 = require("fabric-network");
+const fabric_fs_1 = require("./fabric-fs.cjs");
+const db_decorators_1 = require("@decaf-ts/db-decorators");
+const core_1 = require("@decaf-ts/core");
+const constants_1 = require("./../shared/constants.cjs");
+const ClientSerializer_1 = require("./../shared/ClientSerializer.cjs");
+const FabricClientStatement_1 = require("./FabricClientStatement.cjs");
+const FabricClientPaginator_1 = require("./FabricClientPaginator.cjs");
+const FabricClientRepository_1 = require("./FabricClientRepository.cjs");
+const errors_1 = require("./../shared/errors.cjs");
+const constants_2 = require("./constants.cjs");
+const fs_1 = __importDefault(require("fs"));
+const crypto_1 = require("./crypto.cjs");
+const id_extraction_1 = require("./ids/id-extraction.cjs");
+/**
+ * @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
+ */
+class FabricClientAdapter extends core_1.Adapter {
+    /**
+     * @description Static text decoder for converting Uint8Array to string
+     */
+    static { this.decoder = new TextDecoder("utf8"); }
+    static { this.serializer = new ClientSerializer_1.ClientSerializer(); }
+    static { this.log = logging_1.Logging.for(FabricClientAdapter); }
+    /**
+     * @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(Object.assign({}, constants_2.DefaultFabricClientFlags, config), constants_1.FabricFlavour, alias);
+        this.serializer = FabricClientAdapter.serializer;
+    }
+    Statement(overrides) {
+        return new FabricClientStatement_1.FabricClientStatement(this, overrides);
+    }
+    Paginator(query, size, clazz) {
+        return new FabricClientPaginator_1.FabricClientPaginator(this, query, size, clazz);
+    }
+    async flags(operation, model, flags, ...args) {
+        const mergedFlags = Object.assign({}, this.config, flags);
+        const f = Object.assign(await super.flags(operation, model, mergedFlags, ...args));
+        return f;
+    }
+    async context(operation, overrides, model, ...args) {
+        const log = this.log.for(this.context);
+        log.silly(`creating new context for ${operation} operation on ${model ? (Array.isArray(model) ? model.map((m) => decorator_validation_1.Model.tableName(m)) : decorator_validation_1.Model.tableName(model)) : "no"} table ${overrides && Object.keys(overrides) ? Object.keys(overrides).length : "no"} with flag overrides`);
+        let ctx = args.pop();
+        if (typeof ctx !== "undefined" && !(ctx instanceof core_1.Context)) {
+            args.push(ctx);
+            ctx = undefined;
+        }
+        overrides = ctx
+            ? Object.assign({}, ctx.toOverrides(), overrides)
+            : overrides;
+        const flags = await this.flags(typeof operation === "string" ? operation : operation.name, model, overrides, ...[...args, ctx].filter(Boolean));
+        if (ctx) {
+            if (!(ctx instanceof this.Context)) {
+                const newCtx = new this.Context().accumulate({
+                    ...ctx["cache"],
+                    ...flags,
+                    parentContext: ctx,
+                });
+                ctx.accumulate({
+                    childContexts: [
+                        ...(ctx.getOrUndefined("childContexts") || []),
+                        newCtx,
+                    ],
+                });
+                return newCtx;
+            }
+            const currentOp = ctx.getOrUndefined("operation");
+            const currentModel = ctx.getOrUndefined("affectedTables");
+            if (!currentOp ||
+                currentOp !== operation ||
+                (model && model !== currentModel)) {
+                const newCtx = new this.Context().accumulate({
+                    ...ctx["cache"],
+                    ...flags,
+                    parentContext: ctx,
+                });
+                ctx.accumulate({
+                    childContexts: [
+                        ...(ctx.getOrUndefined("childContexts") || []),
+                        newCtx,
+                    ],
+                });
+                return newCtx;
+            }
+            return ctx.accumulate(flags);
+        }
+        return new this.Context().accumulate({
+            ...flags,
+        });
+    }
+    /**
+     * @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_1.FabricClientRepository;
+    }
+    createPrefix(clazz, id, model, ...args) {
+        const { ctxArgs } = this.logCtx(args, this.createPrefix);
+        const tableName = decorator_validation_1.Model.tableName(clazz);
+        const record = {};
+        record[for_couchdb_1.CouchDBKeys.TABLE] = tableName;
+        Object.assign(record, model);
+        return [clazz, id, record, ...ctxArgs];
+    }
+    /**
+     * @description Prepares multiple records for creation
+     * @summary Adds necessary CouchDB fields to multiple records before creation
+     * @param {string} tableName - The name of the table
+     * @param {string[]|number[]} ids - The IDs of the records
+     * @param models - The models to prepare
+     * @return A tuple containing the tableName, ids, and prepared records
+     * @throws {InternalError} If ids and models arrays have different lengths
+     */
+    createAllPrefix(clazz, ids, models, ...args) {
+        const tableName = decorator_validation_1.Model.tableName(clazz);
+        if (ids.length !== models.length)
+            throw new db_decorators_1.InternalError("Ids and models must have the same length");
+        const { ctxArgs } = this.logCtx(args, this.createAllPrefix);
+        const records = ids.map((id, count) => {
+            const record = {};
+            record[for_couchdb_1.CouchDBKeys.TABLE] = tableName;
+            Object.assign(record, models[count]);
+            return record;
+        });
+        return [clazz, ids, records, ...ctxArgs];
+    }
+    updateAllPrefix(clazz, ids, models, ...args) {
+        const tableName = decorator_validation_1.Model.tableName(clazz);
+        if (ids.length !== models.length)
+            throw new db_decorators_1.InternalError("Ids and models must have the same length");
+        const { ctxArgs } = this.logCtx(args, this.updateAllPrefix);
+        const records = ids.map(() => {
+            const record = {};
+            record[for_couchdb_1.CouchDBKeys.TABLE] = tableName;
+            return record;
+        });
+        return [clazz, ids, records, ...ctxArgs];
+    }
+    /**
+     * @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(clazz, ids, models, ...args) {
+        if (ids.length !== models.length)
+            throw new db_decorators_1.InternalError("Ids and models must have the same length");
+        //HERE!
+        const ctxArgs = [...args];
+        const transient = ctxArgs.shift();
+        const { log, ctx } = this.logCtx(ctxArgs, this.createAll);
+        const tableName = decorator_validation_1.Model.tableName(clazz);
+        log.info(`adding ${ids.length} entries to ${tableName} table`);
+        log.verbose(`pks: ${ids}`);
+        const hasTransient = transient && Object.keys(transient).length > 0;
+        const needsFullPayload = hasTransient || this.shouldForceGatewayHydration(ctx);
+        const transientPayload = hasTransient ? { [tableName]: transient } : {};
+        const result = await this.submitTransaction(ctx, db_decorators_1.BulkCrudOperationKeys.CREATE_ALL, [
+            JSON.stringify(models.map((m) => this.serializer.serialize(m, clazz.name))),
+        ], transientPayload, this.getEndorsingOrganizations(ctx), clazz.name);
+        let res;
+        try {
+            res = JSON.parse(this.decode(result)).map((r) => JSON.parse(r));
+        }
+        catch (e) {
+            throw new db_decorators_1.SerializationError(e);
+        }
+        if (this.shouldRefreshAfterWrite(clazz, ctx, needsFullPayload, res[0][decorator_validation_1.Model.pk(clazz)] || ids[0])) {
+            return this.readAll(clazz, (0, id_extraction_1.extractIds)(clazz, models.map((m, i) => decorator_validation_1.Model.merge(Object.assign({}, m, transient[i] || {}), res[i])), ids), ctx);
+        }
+        return res;
+    }
+    /**
+     * @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(clazz, ids, ...args) {
+        const { log, ctx } = this.logCtx(args, this.readAll);
+        const tableName = decorator_validation_1.Model.tableName(clazz);
+        log.info(`reading ${ids.length} entries to ${tableName} table`);
+        log.verbose(`pks: ${ids}`);
+        const result = await this.evaluateTransaction(ctx, db_decorators_1.BulkCrudOperationKeys.READ_ALL, [JSON.stringify(ids)], undefined, undefined, clazz.name);
+        try {
+            return JSON.parse(this.decode(result)).map((r) => JSON.parse(r));
+        }
+        catch (e) {
+            throw new db_decorators_1.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(clazz, ids, models, ...args) {
+        if (ids.length !== models.length)
+            throw new db_decorators_1.InternalError("Ids and models must have the same length");
+        const ctxArgs = [...args];
+        const transient = ctxArgs.shift();
+        const { log, ctx } = this.logCtx(ctxArgs, this.updateAll);
+        const tableName = decorator_validation_1.Model.tableName(clazz);
+        log.info(`updating ${ids.length} entries to ${tableName} table`);
+        log.verbose(`pks: ${ids}`);
+        const hasTransient = transient && Object.keys(transient).length > 0;
+        const needsFullPayload = hasTransient || this.shouldForceGatewayHydration(ctx);
+        const transientPayload = hasTransient ? { [tableName]: transient } : {};
+        const result = await this.submitTransaction(ctx, db_decorators_1.BulkCrudOperationKeys.UPDATE_ALL, [
+            JSON.stringify(models.map((m) => this.serializer.serialize(m, clazz.name))),
+        ], transientPayload, this.getEndorsingOrganizations(ctx), clazz.name);
+        let res;
+        try {
+            res = JSON.parse(this.decode(result)).map((r) => JSON.parse(r));
+        }
+        catch (e) {
+            throw new db_decorators_1.SerializationError(e);
+        }
+        if (this.shouldRefreshAfterWrite(clazz, ctx, needsFullPayload, ids[0])) {
+            return this.readAll(clazz, (0, id_extraction_1.extractIds)(clazz, models.map((m, i) => decorator_validation_1.Model.merge(Object.assign({}, m, transient[i] || {}), res[i])), ids), ctx);
+        }
+        return res;
+    }
+    /**
+     * @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(clazz, ids, ...args) {
+        const { log, ctx, ctxArgs } = this.logCtx(args, this.deleteAll);
+        const tableName = decorator_validation_1.Model.tableName(clazz);
+        const needsFullPayload = decorator_validation_1.Model.isTransient(clazz) || this.shouldForceGatewayHydration(ctx);
+        let result;
+        const shouldHydrate = this.shouldRefreshAfterWrite(clazz, ctx, needsFullPayload, ids[0]);
+        if (shouldHydrate) {
+            result = await this.readAll(clazz, ids, ...ctxArgs);
+        }
+        log.info(`deleting ${ids.length} entries to ${tableName} table`);
+        log.verbose(`pks: ${ids}`);
+        const res = await this.submitTransaction(ctx, db_decorators_1.BulkCrudOperationKeys.DELETE_ALL, [JSON.stringify(ids)], undefined, this.getEndorsingOrganizations(ctx), clazz.name);
+        try {
+            return shouldHydrate
+                ? result
+                : JSON.parse(this.decode(res)).map((r) => JSON.parse(r));
+        }
+        catch (e) {
+            throw new db_decorators_1.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, ...args) {
+        const { log, ctx } = this.logCtx(args, this.prepare);
+        const split = decorator_validation_1.Model.segregate(model);
+        if (model[core_1.PersistenceKeys.METADATA]) {
+            log.silly(`Passing along persistence metadata for ${model[core_1.PersistenceKeys.METADATA]}`);
+            Object.defineProperty(split.model, core_1.PersistenceKeys.METADATA, {
+                enumerable: false,
+                writable: false,
+                configurable: true,
+                value: model[core_1.PersistenceKeys.METADATA],
+            });
+        }
+        const mirrorMeta = decorator_validation_1.Model.mirroredAt(model);
+        if (mirrorMeta) {
+            const mirrorMsp = mirrorMeta.mspId;
+            if (!mirrorMsp)
+                throw new db_decorators_1.InternalError(`No mirror MSP could be found`);
+            let msps = this.getEndorsingOrganizations(ctx) || [];
+            msps = Array.isArray(msps) ? msps : [msps];
+            const merged = [...new Set([...msps, mirrorMsp])];
+            ctx.accumulate({
+                endorsingOrgs: merged,
+                endorsingOrganizations: merged,
+                legacy: true,
+            });
+        }
+        return {
+            record: split.model,
+            model: split.model,
+            id: model[decorator_validation_1.Model.pk(model.constructor)],
+            transient: split.transient,
+            privates: split.privates,
+            shared: split.shared,
+        };
+    }
+    revert(obj, clazz, id, transient, ...args) {
+        const { log, ctx } = this.logCtx(args, this.revert);
+        if (transient &&
+            this.shouldRebuildWithTransient(ctx, ctx.getOrUndefined("operation"))) {
+            log.verbose(`re-adding transient properties: ${Object.keys(transient).join(", ")}`);
+            Object.entries(transient)
+                .filter(([, v]) => typeof v !== "undefined")
+                .forEach(([key, val]) => {
+                if (key in obj && obj[key] !== undefined)
+                    log.warn(`overwriting existing ${key}. if this is not a default value, this may pose a problem`);
+                obj[key] = val;
+            });
+        }
+        const result = new clazz(obj);
+        return result;
+    }
+    shouldRebuildWithTransient(ctx, operation) {
+        if (!ctx)
+            return false;
+        if (ctx.getOrUndefined("rebuildWithTransient"))
+            return true;
+        const childRebuild = typeof ctx.getFromChildren === "function"
+            ? ctx.getFromChildren("rebuildWithTransient")
+            : undefined;
+        if (childRebuild)
+            return true;
+        const resolvedOp = this.resolveOperation(ctx, operation);
+        if (!resolvedOp)
+            return false;
+        const op = resolvedOp.toString().toLowerCase();
+        return (op.includes("read") ||
+            op.includes("find") ||
+            op.includes("query") ||
+            op.includes("statement") ||
+            op.includes("page"));
+    }
+    resolveOperation(ctx, operation) {
+        if (operation)
+            return operation;
+        if (typeof ctx.getFromChildren === "function") {
+            return ctx.getFromChildren("operation");
+        }
+        return undefined;
+    }
+    shouldRefreshAfterWrite(clazz, ctx, hasTransient, id) {
+        if (!hasTransient)
+            return false;
+        const pk = decorator_validation_1.Model.pk(clazz);
+        const composed = decorator_validation_1.Model.composed(clazz, pk);
+        const generated = decorator_validation_1.Model.generated(clazz, pk);
+        const hasId = id !== undefined && id !== null;
+        if (!hasId && composed)
+            return true;
+        if (!hasId && generated) {
+            ctx.logger.warn(`Cannot refresh record with private generated primary key`);
+            return false;
+        }
+        return hasId;
+    }
+    getEndorsingOrganizations(ctx) {
+        const direct = ctx.getOrUndefined("endorsingOrgs") ||
+            ctx.getOrUndefined("endorsingOrgs");
+        if (direct && direct.length)
+            return direct;
+        return (ctx.getFromChildren("endorsingOrgs") ||
+            ctx.getFromChildren("endorsingOrgs"));
+    }
+    shouldForceGatewayHydration(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ctx) {
+        return !!this.config.allowGatewayOverride;
+    }
+    /**
+     * @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(clazz, id, model, transient = {}, ...args) {
+        const ctxArgs = [...args];
+        const { log, ctx } = this.logCtx(ctxArgs, this.create);
+        const tableName = decorator_validation_1.Model.tableName(clazz);
+        log.verbose(`adding entry to ${tableName} table`);
+        log.debug(`pk: ${id}`);
+        const hasTransient = transient && Object.keys(transient).length > 0;
+        const needsFullPayload = hasTransient || this.shouldForceGatewayHydration(ctx);
+        const transientPayload = hasTransient ? { [tableName]: transient } : {};
+        const result = await this.submitTransaction(ctx, db_decorators_1.OperationKeys.CREATE, [this.serializer.serialize(model, clazz.name)], transientPayload, this.getEndorsingOrganizations(ctx), clazz.name);
+        const deserialized = this.serializer.deserialize(this.decode(result));
+        if (this.shouldRefreshAfterWrite(clazz, ctx, needsFullPayload, id)) {
+            return this.read(clazz, (0, id_extraction_1.extractIds)(clazz, decorator_validation_1.Model.merge(Object.assign({}, model, transient || {}), deserialized, clazz), id), ctx);
+        }
+        return deserialized;
+    }
+    async healthcheck(clazz, ...args) {
+        const { log, ctx } = this.logCtx(args, this.healthcheck);
+        const tableName = decorator_validation_1.Model.tableName(clazz);
+        log.verbose(`reading entry from ${tableName} table`);
+        const result = await this.evaluateTransaction(ctx, "healthcheck", [], undefined, undefined, clazz.name);
+        return JSON.parse(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(clazz, id, ...args) {
+        const { log, ctx } = this.logCtx(args, this.read);
+        const tableName = decorator_validation_1.Model.tableName(clazz);
+        log.verbose(`reading entry from ${tableName} table`);
+        log.debug(`pk: ${id}`);
+        const result = await this.evaluateTransaction(ctx, db_decorators_1.OperationKeys.READ, [id.toString()], undefined, undefined, clazz.name);
+        return this.serializer.deserialize(this.decode(result));
+    }
+    updatePrefix(clazz, id, model, ...args) {
+        const tableName = decorator_validation_1.Model.tableName(clazz);
+        const { ctxArgs } = this.logCtx(args, this.updatePrefix);
+        const record = {};
+        record[for_couchdb_1.CouchDBKeys.TABLE] = tableName;
+        // record[CouchDBKeys.ID] = this.generateId(tableName, id);
+        Object.assign(record, model);
+        return [clazz, id, record, ...ctxArgs];
+    }
+    /**
+     * @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(clazz, id, model, transient = {}, ...args) {
+        const ctxArgs = [...args];
+        const { log, ctx } = this.logCtx(ctxArgs, this.update);
+        log.info(`CLIENT UPDATE class : ${typeof clazz}`);
+        const tableName = decorator_validation_1.Model.tableName(clazz);
+        log.verbose(`updating entry to ${tableName} table`);
+        log.debug(`pk: ${id}`);
+        const hasTransient = transient && Object.keys(transient).length > 0;
+        const needsFullPayload = hasTransient || this.shouldForceGatewayHydration(ctx);
+        const transientPayload = hasTransient ? { [tableName]: transient } : {};
+        const result = await this.submitTransaction(ctx, db_decorators_1.OperationKeys.UPDATE, [this.serializer.serialize(model, clazz.name || clazz)], // TODO should be receving class but is receiving string
+        transientPayload, this.getEndorsingOrganizations(ctx), clazz.name);
+        const deserialized = this.serializer.deserialize(this.decode(result));
+        if (this.shouldRefreshAfterWrite(clazz, ctx, needsFullPayload, id)) {
+            return this.read(clazz, (0, id_extraction_1.extractIds)(clazz, decorator_validation_1.Model.merge(Object.assign({}, model, transient || {}), deserialized, clazz), id), ctx);
+        }
+        return deserialized;
+    }
+    /**
+     * @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(clazz, id, ...args) {
+        const { log, ctx } = this.logCtx(args, this.delete);
+        const tableName = decorator_validation_1.Model.tableName(clazz);
+        const needsFullPayload = decorator_validation_1.Model.isTransient(clazz) || this.shouldForceGatewayHydration(ctx);
+        let result;
+        const shouldHydrate = this.shouldRefreshAfterWrite(clazz, ctx, needsFullPayload, id);
+        if (shouldHydrate) {
+            result = await this.read(clazz, id, ctx);
+        }
+        log.verbose(`deleting entry from ${tableName} table`);
+        log.debug(`pk: ${id}`);
+        const res = await this.submitTransaction(ctx, db_decorators_1.OperationKeys.DELETE, [id.toString()], undefined, this.getEndorsingOrganizations(ctx), clazz.name);
+        return shouldHydrate
+            ? result
+            : this.serializer.deserialize(this.decode(res));
+    }
+    /**
+     * @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
+     */
+    async raw(rawInput, docsOnly = true, clazz, ...args) {
+        const { log, ctx } = this.logCtx(args, this.raw);
+        const tableName = clazz.name;
+        log.info(`Performing raw statement on table ${decorator_validation_1.Model.tableName(clazz)}`);
+        let transactionResult;
+        try {
+            transactionResult = await this.evaluateTransaction(ctx, "raw", [JSON.stringify(rawInput), docsOnly], undefined, undefined, tableName);
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+        let result;
+        try {
+            result = JSON.parse(this.decode(transactionResult));
+        }
+        catch (e) {
+            throw new db_decorators_1.SerializationError(`Failed to process result: ${e}`);
+        }
+        const parseRecord = (record) => {
+            if (decorator_validation_1.Model.isModel(record))
+                return decorator_validation_1.Model.build(record);
+            return record;
+        };
+        if (Array.isArray(result)) {
+            if (!result.length)
+                return result;
+            const el = result[0];
+            if (decorator_validation_1.Model.isModel(el))
+                // if the first one is a model, all are models
+                return result.map((el) => decorator_validation_1.Model.build(el));
+            return result;
+        }
+        return parseRecord(result);
+    }
+    /**
+     * @description Executes a CouchDB view query against the Fabric chaincode
+     * @summary Evaluates a transaction to query a design document view
+     * @template R - The view response type
+     * @param {string} ddoc - Design document name
+     * @param {string} viewName - View name
+     * @param {Record<string, any>} options - View query options
+     * @param {...ContextualArgs<Context<FabricClientFlags>>} args - Optional contextual arguments
+     * @return {Promise<ViewResponse<R>>} The view response
+     */
+    async view(ddoc, viewName, options, ...args) {
+        const { log, ctx } = this.logCtx(args, this.view);
+        log.info(`Querying view ${ddoc}/${viewName}`);
+        let transactionResult;
+        try {
+            transactionResult = await this.evaluateTransaction(ctx, "view", [ddoc, viewName, JSON.stringify(options)], undefined, undefined, undefined);
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+        let result;
+        try {
+            result = JSON.parse(this.decode(transactionResult));
+        }
+        catch (e) {
+            throw new db_decorators_1.SerializationError(`Failed to process view result: ${e}`);
+        }
+        return 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(ctx) {
+        return FabricClientAdapter.getGateway(ctx, this.config, this.client);
+    }
+    getContractName(className) {
+        if (!className)
+            return undefined;
+        return `${className}Contract`;
+    }
+    /**
+     * @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(ctx, contractName) {
+        return FabricClientAdapter.getContract(await this.Gateway(ctx), this.config, contractName);
+    }
+    /**
+     * @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(ctx, api, submit = true, args, transientData = {}, endorsingOrganizations, className) {
+        const log = this.log.for(this.transaction);
+        const gateway = await this.Gateway(ctx);
+        try {
+            const contract = await this.Contract(ctx, this.getContractName(className));
+            log.verbose(`${submit ? "Submit" : "Evaluate"}ting transaction ${this.getContractName(className) || this.config.contractName}.${api}`);
+            log.debug(`args: ${args?.map((a) => a.toString()).join("\n") || "none"}`);
+            const method = submit ? contract.submit : contract.evaluate;
+            endorsingOrganizations = endorsingOrganizations?.length
+                ? endorsingOrganizations
+                : undefined;
+            const proposalOptions = {
+                arguments: args || [],
+                transientData: Object.entries(transientData).reduce((acc, [key, val]) => {
+                    acc[key] = JSON.stringify(val);
+                    return acc;
+                }, {}),
+                endorsingOrganizations: ctx.getOrUndefined("allowManualEndorsingOrgs")
+                    ? endorsingOrganizations || undefined
+                    : undefined, // mspId list
+            };
+            return await method.call(contract, api, proposalOptions);
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+        finally {
+            this.log.debug(`Closing ${this.config.mspId} gateway connection`);
+            gateway.close();
+        }
+    }
+    shouldUseLegacyGateway(ctx) {
+        return !!ctx.getOrUndefined("legacy") && !!this.config.allowGatewayOverride;
+    }
+    prepareLegacyArgs(args) {
+        return (args || []).map((arg) => typeof arg === "string" ? arg : JSON.stringify(arg));
+    }
+    buildLegacyTransient(transientData) {
+        if (!transientData)
+            return undefined;
+        const entries = Object.entries(transientData);
+        if (!entries.length)
+            return undefined;
+        const map = {};
+        for (const [key, value] of entries) {
+            map[key] = Buffer.from(JSON.stringify(value));
+        }
+        return map;
+    }
+    resolveLegacyMspCount() {
+        const configured = this.config.legacyMspCount ?? 1;
+        const parsed = Number(configured);
+        if (!Number.isFinite(parsed) || parsed < 1)
+            return 1;
+        return Math.floor(parsed);
+    }
+    pickLegacyCandidates(candidates, limit) {
+        if (!candidates.length || limit <= 0)
+            return [];
+        const available = [...candidates];
+        const target = Math.min(limit, available.length);
+        const picked = [];
+        while (picked.length < target && available.length) {
+            const idx = Math.floor(Math.random() * available.length);
+            const [selection] = available.splice(idx, 1);
+            if (selection) {
+                picked.push(selection);
+            }
+        }
+        return picked;
+    }
+    buildLegacyPeerConfigs(ctx) {
+        const peers = [
+            {
+                mspId: this.config.mspId,
+                peerEndpoint: this.config.peerEndpoint,
+                peerHostAlias: this.config.peerHostAlias,
+                tlsCert: this.config.tlsCert,
+            },
+        ];
+        let endorsingOrgs = this.getEndorsingOrganizations(ctx) || [];
+        endorsingOrgs = Array.isArray(endorsingOrgs)
+            ? endorsingOrgs
+            : [endorsingOrgs];
+        const endorsers = endorsingOrgs.filter((org) => Boolean(org)) || [];
+        const extras = endorsers.filter((org) => org !== this.config.mspId);
+        if (!extras.length)
+            return peers;
+        const map = this.config.mspMap;
+        const legacyCount = this.resolveLegacyMspCount();
+        for (const msp of extras) {
+            const candidates = map?.[msp];
+            if (!candidates?.length) {
+                throw new core_1.UnsupportedError(`No peer mapping available for MSP ${msp}. Provide it via config.mspMap`);
+            }
+            const selections = this.pickLegacyCandidates(candidates, legacyCount);
+            if (!selections.length) {
+                throw new core_1.UnsupportedError(`No valid peer mapping available for MSP ${msp}. Provide it via config.mspMap`);
+            }
+            for (const choice of selections) {
+                if (!choice.endpoint) {
+                    throw new core_1.UnsupportedError(`Invalid peer mapping for MSP ${msp}: missing endpoint`);
+                }
+                peers.push({
+                    mspId: msp,
+                    peerEndpoint: choice.endpoint,
+                    peerHostAlias: choice.alias,
+                    tlsCert: choice.tlsCert || this.config.tlsCert,
+                });
+            }
+        }
+        return peers;
+    }
+    async submitLegacyWithExplicitEndorsers(ctx, fcn, args, transientMap, peerConfigs, className) {
+        const log = this.log.for(this.submitLegacyWithExplicitEndorsers);
+        const peers = this.normalizeLegacyPeers(peerConfigs);
+        const identityMaterial = await this.resolveLegacyIdentityMaterial();
+        const wallet = await fabric_network_1.Wallets.newInMemoryWallet();
+        const identityLabel = `${this.config.mspId}-legacy`;
+        await wallet.put(identityLabel, {
+            credentials: {
+                certificate: identityMaterial.certificate,
+                privateKey: identityMaterial.privateKey,
+            },
+            mspId: this.config.mspId,
+            type: "X.509",
+        });
+        const connectionProfile = await this.buildLegacyConnectionProfile(peers);
+        const gateway = new fabric_network_1.Gateway();
+        try {
+            await gateway.connect(connectionProfile, {
+                identity: identityLabel,
+                wallet,
+                discovery: {
+                    enabled: true,
+                    asLocalhost: this.shouldTreatPeersAsLocalhost(peers),
+                },
+                tlsInfo: {
+                    certificate: identityMaterial.certificate,
+                    key: identityMaterial.privateKey,
+                },
+            });
+            const network = await gateway.getNetwork(this.config.channel);
+            const contract = network.getContract(this.config.chaincodeName, this.getContractName(className));
+            const transaction = contract.createTransaction(fcn);
+            if (transientMap) {
+                transaction.setTransient(transientMap);
+            }
+            const endorsers = peers
+                .map((peer) => network.getChannel().getEndorser(peer.name))
+                .filter((endorser) => Boolean(endorser));
+            if (endorsers.length) {
+                transaction.setEndorsingPeers(endorsers);
+            }
+            log.verbose(`Legacy submitting ${this.getContractName(className) || this.config.contractName}.${fcn} via peers ${peers.map((p) => p.peerEndpoint).join(", ")}`);
+            const result = await transaction.submit(...args);
+            return Uint8Array.from(result);
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+        finally {
+            gateway.disconnect();
+        }
+    }
+    normalizeLegacyPeers(peers) {
+        const deduped = new Map();
+        const addPeer = (peer) => {
+            const key = `${peer.peerEndpoint}|${peer.peerHostAlias || ""}`;
+            if (deduped.has(key))
+                return;
+            const name = `peer-${peer.mspId}-${deduped.size}`;
+            deduped.set(key, {
+                ...peer,
+                name,
+            });
+        };
+        peers.forEach(addPeer);
+        addPeer({
+            mspId: this.config.mspId,
+            peerEndpoint: this.config.peerEndpoint,
+            peerHostAlias: this.config.peerHostAlias,
+        });
+        return Array.from(deduped.values());
+    }
+    async resolveLegacyIdentityMaterial() {
+        const certificate = await this.readPemInput(this.config.certCertOrDirectoryPath);
+        const privateKey = await this.readPemInput(this.config.keyCertOrDirectoryPath);
+        return { certificate, privateKey };
+    }
+    async buildLegacyConnectionProfile(peers) {
+        const peerEntries = {};
+        const channelPeers = {};
+        const orgs = {};
+        for (const peer of peers) {
+            const tlsPem = await this.readPemInput(peer.tlsCert || this.config.tlsCert);
+            const hostname = peer.peerHostAlias || this.extractHost(peer.peerEndpoint);
+            peerEntries[peer.name] = {
+                url: this.ensureGrpcUrl(peer.peerEndpoint),
+                tlsCACerts: { pem: tlsPem },
+                grpcOptions: {
+                    "ssl-target-name-override": hostname,
+                    hostnameOverride: hostname,
+                },
+            };
+            channelPeers[peer.name] = {
+                endorsingPeer: true,
+                chaincodeQuery: true,
+                ledgerQuery: true,
+                eventSource: true,
+            };
+            orgs[peer.mspId] = orgs[peer.mspId] || {
+                mspid: peer.mspId,
+                peers: [],
+            };
+            orgs[peer.mspId].peers.push(peer.name);
+        }
+        return {
+            name: "legacy-manual",
+            version: "1.0.0",
+            client: {
+                organization: this.config.mspId,
+            },
+            organizations: orgs,
+            peers: peerEntries,
+            orderers: {},
+            channels: {
+                [this.config.channel]: {
+                    peers: channelPeers,
+                },
+            },
+        };
+    }
+    shouldTreatPeersAsLocalhost(peers) {
+        return peers.every((peer) => this.isLocalEndpoint(peer.peerEndpoint));
+    }
+    isLocalEndpoint(endpoint) {
+        const host = this.extractHost(endpoint).toLowerCase();
+        return host === "localhost" || host === "127.0.0.1";
+    }
+    extractHost(endpoint) {
+        const sanitized = endpoint.replace(/^grpcs?:\/\//, "");
+        return sanitized.split(":")[0];
+    }
+    ensureGrpcUrl(endpoint) {
+        if (/^grpcs?:\/\//i.test(endpoint))
+            return endpoint;
+        return `grpcs://${endpoint}`;
+    }
+    async readPemInput(source) {
+        if (!source)
+            throw new db_decorators_1.InternalError("Missing certificate or key material");
+        if (Buffer.isBuffer(source))
+            return source.toString("utf8");
+        const trimmed = source.trim();
+        if (/-----BEGIN [A-Z ]+-----/.test(trimmed))
+            return trimmed;
+        const stats = await fs_1.default.promises.stat(source).catch(() => undefined);
+        if (stats?.isDirectory()) {
+            return await (0, fabric_fs_1.getFirstDirFileNameContent)(source);
+        }
+        return (await (0, fabric_fs_1.readFile)(source)).toString();
+    }
+    /**
+     * @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) {
+        return FabricClientAdapter.parseError(err);
+    }
+    /**
+     * @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(ctx, api, args, transientData, endorsingOrganizations, className) {
+        if (this.shouldUseLegacyGateway(ctx)) {
+            const legacyArgs = this.prepareLegacyArgs(args);
+            const transientMap = this.buildLegacyTransient(transientData);
+            const peerConfigs = this.buildLegacyPeerConfigs(ctx);
+            return this.submitLegacyWithExplicitEndorsers(ctx, api, legacyArgs, transientMap, peerConfigs, className);
+        }
+        return this.transaction(ctx, api, true, args, transientData, endorsingOrganizations, className);
+    }
+    /**
+     * @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(ctx, api, args, transientData, endorsingOrganizations, className) {
+        return this.transaction(ctx, api, false, args, transientData, endorsingOrganizations, className);
+    }
+    async migrate(reference, ...args) {
+        const { ctxArgs } = (await this.logCtx([args], core_1.PersistenceKeys.MIGRATION, true)).for(this.migrate);
+        return this.submitTransaction(ctxArgs[0], "migrate", [reference, args], undefined, undefined);
+    }
+    /**
+     * @description Shuts down the connection to the Fabric network
+     * @summary Closes the active dispatch (which in turn closes any gateway
+     * event subscription) via the base class, then closes the gRPC client.
+     * Works correctly regardless of whether `syntheticEvents` is enabled.
+     * @return {Promise<void>} Promise that resolves when all connections are closed
+     */
+    async shutdown(...args) {
+        // Base class handles dispatch.close() internally.
+        await super.shutdown(...args);
+        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, contractName) {
+        const log = this.log.for(this.getContract);
+        const network = this.getNetwork(gateway, config.channel);
+        let contract;
+        try {
+            log.debug(`Retrieving chaincode ${config.chaincodeName} contract ${contractName || config.contractName} from network ${config.channel}`);
+            contractName = contractName ? contractName : config.contractName;
+            contract = network.getContract(config.chaincodeName, 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 = logging_1.Logging.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(ctx, config, client) {
+        return (await this.getConnection(client || (await this.getClient(config)), config, ctx));
+    }
+    /**
+     * @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}`);
+        let pathOrCert = config.tlsCert;
+        if (typeof pathOrCert === "string") {
+            if (pathOrCert.match(/-----BEGIN (CERTIFICATE|KEY|PRIVATE KEY)-----.+?-----END \1-----$/gms)) {
+                pathOrCert = Buffer.from(pathOrCert, "utf8");
+            }
+            else {
+                try {
+                    pathOrCert = Buffer.from(fs_1.default.readFileSync(pathOrCert, "utf8"));
+                }
+                catch (e) {
+                    throw new db_decorators_1.InternalError(`Failed to read the tls certificate from ${pathOrCert}: ${e}`);
+                }
+            }
+        }
+        const tlsCredentials = grpc.credentials.createSsl(pathOrCert);
+        log.debug(`generating Gateway Client for url ${config.peerEndpoint}`);
+        return new grpc_js_1.Client(config.peerEndpoint, tlsCredentials, {
+            "grpc.max_receive_message_length": (config.sizeLimit || 15) * 1024 * 1024,
+            "grpc.max_send_message_length": (config.sizeLimit || 15) * 1024 * 1024,
+        });
+    }
+    /**
+     * @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, ctx) {
+        const log = logging_1.Logging.for(this.getConnection);
+        log.debug(`Retrieving Peer Identity for ${config.mspId} under ${config.certCertOrDirectoryPath}`);
+        const identity = await (0, fabric_fs_1.getIdentity)(config.mspId, config.certCertOrDirectoryPath);
+        try {
+            log.debug(`preparing transaction signer for ${crypto_1.CryptoUtils.fabricIdFromCertificate(identity.credentials.toString())}`);
+        }
+        catch (e) {
+            log.error(`Failed to extract Fabric ID from certificate`, e);
+        }
+        let signer;
+        const close = () => { };
+        if (!config.hsm) {
+            signer = await (0, fabric_fs_1.getSigner)(config.keyCertOrDirectoryPath);
+        }
+        else {
+            // const hsm = new HSMSignerFactoryCustom(config.hsm.library);
+            // const identifier = hsm.getSKIFromCertificatePath(
+            //   config.certCertOrDirectoryPath as any
+            // );
+            // const pkcs11Signer = hsm.newSigner({
+            //   label: config.hsm.tokenLabel as string,
+            //   pin: String(config.hsm.pin) as string,
+            //   identifier: identifier,
+            //   // userType: 1 /*CKU_USER */,
+            // });
+            // signer = pkcs11Signer.signer;
+            // close = pkcs11Signer.close;
+            throw new core_1.UnsupportedError("HSM NOT IMPLEMENTED");
+        }
+        const options = {
+            client,
+            identity: identity,
+            signer: signer,
+            // Default timeouts for different gRPC calls
+            evaluateOptions: () => {
+                return { deadline: Date.now() + 1000 * ctx.get("evaluateTimeout") }; // defaults to 5 seconds
+            },
+            endorseOptions: () => {
+                return { deadline: Date.now() + 1000 * ctx.get("endorseTimeout") }; // defaults to 15 seconds
+            },
+            submitOptions: () => {
+                return { deadline: Date.now() + 1000 * ctx.get("submitTimeout") }; // defaults to 5 seconds
+            },
+            commitStatusOptions: () => {
+                return { deadline: Date.now() + 1000 * ctx.get("commitTimeout") }; // defaults to 1 minute
+            },
+        };
+        log.debug(`Connecting to ${config.mspId}`);
+        const gateway = (0, fabric_gateway_1.connect)(options);
+        // TODO: replace?
+        if (config.hsm) {
+            gateway.close = new Proxy(gateway.close, {
+                apply(target, thisArg, argArray) {
+                    Reflect.apply(target, thisArg, argArray);
+                    close();
+                },
+            });
+        }
+        return gateway;
+    }
+    /**
+     * @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 FabricClientAdapter["_baseDispatch"](this.client);
+    }
+    /**
+     * @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) {
+        // if (
+        //   MISSING_PRIVATE_DATA_REGEX.test(
+        //     typeof err === "string" ? err : err.message
+        //   )
+        // )
+        //   return new UnauthorizedPrivateDataAccess(err) as E;
+        let msg = typeof err === "string" ? err : err.message;
+        if (err instanceof fabric_gateway_1.GatewayError && err.details.length && err.code === 10) {
+            msg = `${err.details[0].message}`;
+        }
+        if (err instanceof fabric_gateway_1.EndorseError &&
+            err.details.length &&
+            err.code === 10 &&
+            err.details[0].message?.includes(core_1.UnsupportedError.name)) {
+            msg = `${err.details[0].message}`;
+        }
+        if (msg.includes("MVCC_READ_CONFLICT"))
+            return new errors_1.MvccReadConflictError(err);
+        if (msg.includes("DEADLINE_EXCEEDED"))
+            return new errors_1.TransactionTimeoutError(err);
+        if (msg.includes("ENDORSEMENT_POLICY_FAILURE"))
+            return new errors_1.EndorsementPolicyError(err);
+        if (msg.includes("PHANTOM_READ_CONFLICT"))
+            return new errors_1.PhantomReadConflictError(err);
+        if (err instanceof Error && err.code) {
+            switch (err.code) {
+                case 9:
+                    return new errors_1.EndorsementError(err);
+            }
+        }
+        if (msg.includes(db_decorators_1.ValidationError.name))
+            return new db_decorators_1.ValidationError(err);
+        if (msg.includes(db_decorators_1.NotFoundError.name))
+            return new db_decorators_1.NotFoundError(err);
+        if (msg.includes(db_decorators_1.ConflictError.name))
+            return new db_decorators_1.ConflictError(err);
+        if (msg.includes(db_decorators_1.BadRequestError.name))
+            return new db_decorators_1.BadRequestError(err);
+        if (msg.includes(core_1.QueryError.name))
+            return new core_1.QueryError(err);
+        if (msg.includes(core_1.PagingError.name))
+            return new core_1.PagingError(err);
+        if (msg.includes(core_1.UnsupportedError.name))
+            return new core_1.UnsupportedError(err);
+        if (msg.includes(core_1.MigrationError.name))
+            return new core_1.MigrationError(err);
+        if (msg.includes(core_1.ObserverError.name))
+            return new core_1.ObserverError(err);
+        if (msg.includes(core_1.AuthorizationError.name))
+            return new core_1.AuthorizationError(err);
+        if (msg.includes(core_1.ForbiddenError.name))
+            return new core_1.ForbiddenError(err);
+        if (msg.includes(core_1.ConnectionError.name))
+            return new core_1.ConnectionError(err);
+        if (msg.includes(db_decorators_1.SerializationError.name))
+            return new db_decorators_1.SerializationError(err);
+        return new db_decorators_1.InternalError(err);
+    }
+}
+exports.FabricClientAdapter = FabricClientAdapter;
+__decorate([
+    (0, logging_1.debug)(),
+    (0, logging_1.final)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object, Object, core_1.Context]),
+    __metadata("design:returntype", Promise)
+], FabricClientAdapter.prototype, "create", null);
+__decorate([
+    (0, logging_1.debug)(),
+    (0, logging_1.final)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, core_1.Context]),
+    __metadata("design:returntype", Promise)
+], FabricClientAdapter.prototype, "healthcheck", null);
+__decorate([
+    (0, logging_1.debug)(),
+    (0, logging_1.final)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, core_1.Context]),
+    __metadata("design:returntype", Promise)
+], FabricClientAdapter.prototype, "read", null);
+__decorate([
+    (0, logging_1.debug)(),
+    (0, logging_1.final)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object, Object, core_1.Context]),
+    __metadata("design:returntype", Promise)
+], FabricClientAdapter.prototype, "update", null);
+__decorate([
+    (0, logging_1.debug)(),
+    (0, logging_1.final)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, core_1.Context]),
+    __metadata("design:returntype", Promise)
+], FabricClientAdapter.prototype, "delete", null);
+__decorate([
+    (0, logging_1.debug)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, typeof (_a = typeof D !== "undefined" && D) === "function" ? _a : Object, Object, core_1.Context]),
+    __metadata("design:returntype", Promise)
+], FabricClientAdapter.prototype, "raw", null);
+__decorate([
+    (0, logging_1.debug)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object, core_1.Context]),
+    __metadata("design:returntype", Promise)
+], FabricClientAdapter.prototype, "view", null);
+FabricClientAdapter.decoration();
+core_1.Adapter.setCurrent(constants_1.FabricFlavour);
+//# sourceMappingURL=FabricClientAdapter.js.map