@decaf-ts/for-fabric 0.4.7 → 0.4.8-hotfix.1

package/dist/for-fabric.js

@@ -2519,21 +2519,21 @@ async function getSigner(keyDirectoryPath) {
         return await promises.readFile(keyPath);
     };
     const privateKeyPem = await contentOfLoadFile(keyDirectoryPath, signerFileReader);
-    const privateKey = await extractPrivateKey(privateKeyPem);
-    const keys = Object.getOwnPropertySymbols(privateKey);
-    const k = privateKey[keys[0]];
+    let k;
+    if (isBrowser()) {
+        const privateKey = await extractPrivateKey(privateKeyPem);
+        const keys = Object.getOwnPropertySymbols(privateKey);
+        k = privateKey[keys[0]];
+    } else {
+        const {createPrivateKey: createPrivateKey} = await import("crypto");
+        k = createPrivateKey(privateKeyPem);
+    }
     return signers.newPrivateKeySigner(k);
 }
 
 async function extractPrivateKey(pem) {
-    const libName = "crypto";
     let subtle;
-    if (isBrowser()) {
-        subtle = globalThis.crypto.subtle;
-    } else {
-        const lib = await normalizeImport(import(libName));
-        subtle = lib.subtle || lib.webcrypto.subtle;
-    }
+    subtle = globalThis.crypto.subtle;
     if (!subtle) throw new Error("Could not load SubtleCrypto module");
     function str2ab(str) {
         const buf = new ArrayBuffer(str.length);
@@ -3871,11 +3871,11 @@ class FabricClientDispatch extends Dispatch {
 
 if (FabricClientAdapter) FabricClientAdapter["_baseDispatch"] = FabricClientDispatch;
 
-const VERSION = "0.4.7";
+const VERSION = "0.4.8";
 
 const PACKAGE_NAME = "@decaf-ts/for-fabric";
 
 Metadata.registerLibrary(PACKAGE_NAME, VERSION);
 
 export { AllowanceError, BASE_ALPHABET, BalanceError, BaseEncoder, CA_ROLE, CRYPTO, ClientSerializer, CoreUtils, CryptoUtils, DefaultFabricClientFlags, DeterministicSerializer, ERC20Events, EndorsementError, EndorsementPolicyError, FabricBaseModel, FabricClientAdapter, FabricClientDispatch, FabricClientRepository, FabricERC20ClientRepository, FabricEnrollmentService, FabricFlavour, FabricIdentifiedBaseModel, FabricIdentityService, FabricModelKeys, HFCAIdentityAttributes, HFCAIdentityType, Identity, IdentityCredentials, IdentityType, ImplicitPrivateCollection, MissingContextError, MissingPKCSS11Lib, ModelCollection, MvccReadConflictError, NamespaceCollection, NotInitializedError, OverflowError, Owner, PACKAGE_NAME, PhantomReadConflictError, RegistrationError, RegistrationRequestBuilder, SEGREGATED_COLLECTION_EXTRACTION_PRIORITY, SimpleDeterministicSerializer, TransactionBufferSizeError, TransactionLimitsError, TransactionTimeoutError, UnauthorizedPrivateDataAccess, VERSION, add, applyMirrorFlags, applySegregationFlags, collectionFor, contentOfLoadFile, createMirrorHandler, deleteMirrorHandler, evalMirrorMetadata, extractCollections, extractIds, extractMspId, extractPrivateKey, extractSegregatedCollections, generateFabricEventName, generateModelDesignDocs, generateModelIndexes, getAkiAndSerialFromCert, getCAUser, getFirstDirFileName, getFirstDirFileNameContent, getIdentity, getSigner, mirror, mirrorWriteGuard, ownedBy, ownedByOnCreate, parseEventName, privateCollectionFor, privateData, readFile, readMirrorHandler, readModelFile, readModelFolders, safeParseInt, segregatedDataOnCreate, segregatedDataOnDelete, segregatedDataOnRead, segregatedDataOnUpdate, sharedCollectionFor, sharedData, sortKeysOnlyRecursive, sub, transactionId, transactionIdOnCreate, updateMirrorHandler, writeCollectionDesignDocs, writeCollections, writeDesignDocs, writeIndexes };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"for-fabric.js","sources":["../src/client/indexes/generation.ts","../src/client/collections/generation.ts","../src/client/FabricClientPaginator.ts","../src/client/FabricClientRepository.ts","../src/contracts/erc20/models.ts","../src/shared/ClientSerializer.ts","../src/client/erc20/FabricERC20ClientRepository.ts","../src/client/ids/id-extraction.ts","../src/shared/model/IdentityCredentials.ts","../src/shared/constants.ts","../src/shared/model/Identity.ts","../src/client/utils.ts","../src/client/crypto.ts","../src/shared/errors.ts","../src/client/services/FabricEnrollmentService.ts","../src/client/services/RegistrationRequestBuilder.ts","../src/shared/erc20/erc20-constants.ts","../src/shared/model/FabricBaseModel.ts","../src/shared/model/FabricIdentifiedBaseModel.ts","../src/shared/overrides/overrides.ts","../src/shared/decorators.ts","../src/shared/DeterministicSerializer.ts","../src/shared/events.ts","../src/shared/math.ts","../src/shared/SimpleDeterministicSerializer.ts","../src/client/services/FabricIdentityService.ts","../src/client/services/constants.ts","../src/client/constants.ts","../src/client/fabric-fs.ts","../src/client/FabricClientStatement.ts","../src/client/FabricClientAdapter.ts","../src/client/FabricClientDispatch.ts","../src/version.ts"],"sourcesContent":["import { Constructor } from \"@decaf-ts/decoration\";\nimport {\n  CreateIndexRequest,\n  CouchDBDesignDoc,\n  generateIndexes,\n  generateViews,\n} from \"@decaf-ts/for-couchdb\";\nimport { Model, ModelConstructor } from \"@decaf-ts/decorator-validation\";\n\nexport type Index = CreateIndexRequest;\n\nfunction ensureDirectoryExistence(filePath: string) {\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const fs = require(\"fs\");\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const path = require(\"path\");\n  const dirname: string = path.dirname(filePath);\n  if (fs.existsSync(dirname)) {\n    return true;\n  }\n  ensureDirectoryExistence(dirname);\n  fs.mkdirSync(dirname);\n}\n\nexport function generateModelIndexes<M extends Model>(\n  m: Constructor<M>\n): Index[] {\n  return generateIndexes([m]);\n}\n\nexport function generateModelDesignDocs<M extends Model>(\n  m: Constructor<M>,\n  accum?: Record<string, CouchDBDesignDoc>\n): CouchDBDesignDoc[] {\n  const views = generateViews([m]);\n  const storage: Record<string, CouchDBDesignDoc> = accum || {};\n  views.forEach((doc) => {\n    storage[doc._id] = doc;\n  });\n  return views;\n}\n\nexport function readModelFile(file: any) {\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const path = require(\"path\");\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const exports = require(path.join(process.cwd(), file.parentPath, file.name));\n\n  const values = Object.values(exports).filter((e) => {\n    try {\n      const m = new (e as Constructor)();\n      return m instanceof Model;\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (e: unknown) {\n      return false;\n    }\n  }) as ModelConstructor<any>[];\n  return values;\n}\n\nexport async function readModelFolders(\n  ...folders: string[]\n): Promise<ModelConstructor<any>[]> {\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const fs = require(\"fs\");\n\n  const result: ModelConstructor<any>[] = [];\n\n  for (const folder of folders) {\n    const files = fs\n      .readdirSync(folder, {\n        withFileTypes: true,\n        recursive: true,\n      })\n      .filter((f: any) => f.isFile() && f.name.endsWith(\"js\"));\n    for (const file of files) {\n      result.push(...readModelFile(file));\n    }\n  }\n  return result;\n}\n\nexport function writeIndexes(\n  indexes: Index[],\n  p: string = process.cwd(),\n  collection?: string\n) {\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const fs = require(\"fs\");\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const path = require(\"path\");\n\n  indexes.forEach((index) => {\n    const file = path.resolve(\n      path.join(\n        p,\n        `./META-INF/statedb/couchdb/${collection ? `collections/${collection}/` : \"\"}indexes/${index.name}.json`\n      )\n    );\n    ensureDirectoryExistence(file);\n    fs.writeFileSync(file, JSON.stringify(index, undefined, 2));\n  });\n}\n\nexport function writeDesignDocs(\n  designDocs: CouchDBDesignDoc[],\n  p: string = process.cwd(),\n  collection?: string\n) {\n  if (!designDocs.length) return;\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const fs = require(\"fs\");\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const path = require(\"path\");\n\n  designDocs.forEach((doc) => {\n    const docId = doc._id.replace(/^_design\\//, \"\");\n    const file = path.resolve(\n      path.join(\n        p,\n        `./META-INF/statedb/couchdb/${collection ? `collections/${collection}/` : \"\"}design_docs/${docId}.json`\n      )\n    );\n    ensureDirectoryExistence(file);\n    const payload = { ...doc };\n    delete payload._rev;\n    fs.writeFileSync(file, JSON.stringify(payload, undefined, 2));\n  });\n}\n","import { Constructor } from \"@decaf-ts/decoration\";\nimport { CouchDBDesignDoc } from \"@decaf-ts/for-couchdb\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\nimport { CollectionResolver } from \"../../shared/index\";\nimport { writeDesignDocs } from \"../indexes/generation\";\n\n//\n// export type FabricCollection = {\n//   name: \"collectionMarbles\";\n//   policy: \"OR('Org1MSP.member', 'Org2MSP.member')\";\n//   requiredPeerCount: 0;\n//   maxPeerCount: 3;\n//   blockToLive: 0;\n//   memberOnlyRead: true;\n//   memberOnlyWrite: true;\n//   endorsementPolicy: {\n//     identities: [\n//       { role: { name: \"member\"; mspId: \"Org1MSP\" } },\n//       { role: { name: \"member\"; mspId: \"Org2MSP\" } },\n//     ];\n//     rule: \"OR('Org1MSP.member', 'Org2MSP.member')\";\n//   };\n// };\n\nexport type FabricPolicyIdentity = {\n  role: {\n    name: string;\n    mspId: string;\n  };\n};\n\nexport type FabricCollection = {\n  name: string;\n  policy: string;\n  requiredPeerCount: number;\n  maxPeerCount: number;\n  blockToLive: number;\n  memberOnlyRead: boolean;\n  memberOnlyWrite: boolean;\n  endorsementPolicy: {\n    identities: FabricPolicyIdentity[];\n    rule: string;\n  };\n};\n\nexport type PrivateCollection = {\n  name: string;\n  policy: string;\n  requiredPeerCount: number;\n  maxPeerCount: number;\n  blockToLive: number;\n  memberOnlyRead: boolean;\n  memberOnlyWrite: boolean;\n  endorsementPolicy?: {\n    signaturePolicy: string;\n  };\n};\n\nexport function collectionFor(\n  collectionName: string,\n  policy: string,\n  requiredPeerCount: number,\n  maxPeerCount: number,\n  blockToLive: number,\n  memberOnlyRead: boolean,\n  memberOnlyWrite: boolean\n): PrivateCollection {\n  return {\n    name: collectionName,\n    policy: policy,\n    requiredPeerCount,\n    maxPeerCount,\n    blockToLive,\n    memberOnlyRead,\n    memberOnlyWrite,\n  };\n}\n\nexport function privateCollectionFor(\n  mspId: string,\n  collectionName: string = `${mspId}Private`,\n  requiredPeerCount: number = 0,\n  maxPeerCount: number = 0,\n  blockToLive: number = 0,\n  memberOnlyRead: boolean = true,\n  memberOnlyWrite: boolean = true\n): PrivateCollection {\n  const c = collectionFor(\n    collectionName,\n    `OR('${mspId}.member')`,\n    requiredPeerCount,\n    maxPeerCount,\n    blockToLive,\n    memberOnlyRead,\n    memberOnlyWrite\n  );\n\n  c.endorsementPolicy = {\n    signaturePolicy: `OR('${mspId}.peer')`,\n  };\n  return c;\n}\n\nexport function sharedCollectionFor(\n  mspIds: string[],\n  collectionName: string,\n  requiredPeerCount: number = 1,\n  maxPeerCount: number = 2,\n  blockToLive: number = 0,\n  memberOnlyRead: boolean = true,\n  memberOnlyWrite: boolean = true\n): PrivateCollection {\n  const c = collectionFor(\n    collectionName,\n    `OR(${mspIds.map((m) => `'${m}.member'`).join(\",\")})`,\n    requiredPeerCount,\n    maxPeerCount,\n    blockToLive,\n    memberOnlyRead,\n    memberOnlyWrite\n  );\n  c.endorsementPolicy = {\n    signaturePolicy: `AND(${mspIds.map((m) => `'${m}.peer'`).join(\",\")})`,\n  };\n  return c;\n}\n\nexport async function extractCollections<M extends Model>(\n  m: Constructor<M>,\n  mspIds: string[],\n  overrides: {\n    privateCols?: Partial<PrivateCollection>;\n    sharedCols?: Partial<PrivateCollection>;\n  } = {},\n  mirror: boolean = false\n) {\n  let { privateCols, sharedCols } = Model.collectionsFor(m);\n\n  function resolveCollection(arg: string | CollectionResolver): string {\n    try {\n      if (typeof arg === \"string\") return arg;\n      return arg(m, mspIds[0]) as string;\n    } catch (e: unknown) {\n      throw new InternalError(e as Error);\n    }\n  }\n\n  privateCols = privateCols.map(resolveCollection);\n  sharedCols = sharedCols.map(resolveCollection);\n\n  const privateDefaults = Object.assign(\n    {},\n    {\n      requiredPeerCount: 0,\n      maxPeerCount: 0,\n      blockToLive: 0,\n      memberOnlyRead: true,\n      memberOnlyWrite: true,\n    },\n    overrides?.privateCols || {}\n  );\n  const sharedDefaults = Object.assign(\n    {},\n    {\n      requiredPeerCount: 1,\n      maxPeerCount: 2,\n      blockToLive: 0,\n      memberOnlyRead: true,\n      memberOnlyWrite: true,\n    },\n    overrides?.sharedCols || {}\n  );\n\n  const mirrorMeta = mirror ? Model.mirroredAt(m) : undefined;\n\n  const privates = mspIds\n    .map((mspId) =>\n      (privateCols as string[]).map((p) => {\n        const { requiredPeerCount, maxPeerCount, blockToLive, memberOnlyRead } =\n          privateDefaults;\n        return privateCollectionFor(\n          mspId,\n          p,\n          requiredPeerCount,\n          maxPeerCount,\n          blockToLive,\n          memberOnlyRead,\n          false\n        );\n      })\n    )\n    .flat();\n\n  if (mirrorMeta && mirrorMeta.mspId) {\n    const resolved =\n      typeof mirrorMeta.resolver === \"string\"\n        ? mirrorMeta.resolver\n        : mirrorMeta.resolver(m, mirrorMeta.mspId);\n    if (\n      resolved &&\n      !privates.some(\n        (p) => p.name === resolved && p.policy.includes(mirrorMeta.mspId)\n      )\n    ) {\n      const { requiredPeerCount, maxPeerCount, blockToLive, memberOnlyRead } =\n        privateDefaults;\n      privates.push(\n        privateCollectionFor(\n          mirrorMeta.mspId,\n          resolved,\n          requiredPeerCount,\n          maxPeerCount,\n          blockToLive,\n          memberOnlyRead,\n          false\n        )\n      );\n    }\n  }\n\n  const shared = (sharedCols as string[]).map((p) => {\n    const {\n      requiredPeerCount,\n      maxPeerCount,\n      blockToLive,\n      memberOnlyRead,\n      memberOnlyWrite,\n    } = sharedDefaults;\n    return sharedCollectionFor(\n      mspIds,\n      p,\n      requiredPeerCount,\n      maxPeerCount,\n      blockToLive,\n      memberOnlyRead,\n      memberOnlyWrite\n    );\n  });\n\n  return {\n    privates,\n    shared,\n  };\n}\n\nexport function writeCollections(\n  cols: PrivateCollection[],\n  p: string = process.cwd(),\n  fileName = \"collections_config\"\n) {\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const fs = require(\"fs\");\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const path = require(\"path\");\n\n  function ensureDirectoryExistence(filePath: string) {\n    const dirname: string = path.dirname(filePath) as string;\n    if (fs.existsSync(dirname)) {\n      return true;\n    }\n    ensureDirectoryExistence(dirname);\n    fs.mkdirSync(dirname);\n  }\n\n  const file = path.resolve(path.join(p, `./META-INF/${fileName}.json`));\n  ensureDirectoryExistence(file);\n  fs.writeFileSync(file, JSON.stringify(cols, undefined, 2));\n}\n\nexport function writeCollectionDesignDocs(\n  docs: CouchDBDesignDoc[],\n  p: string = process.cwd(),\n  collection?: string\n) {\n  if (!docs?.length) return;\n  writeDesignDocs(docs, p, collection);\n}\n","import {\n  MaybeContextualArg,\n  Paginator,\n  PreparedStatement,\n  SerializedPage,\n  UnsupportedError,\n} from \"@decaf-ts/core\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { Constructor } from \"@decaf-ts/decoration\";\nimport { FabricClientAdapter } from \"./FabricClientAdapter\";\nimport { MangoQuery } from \"@decaf-ts/for-couchdb\";\n\nexport class FabricClientPaginator<M extends Model> extends Paginator<\n  M,\n  M[],\n  MangoQuery\n> {\n  bookmark?: string;\n\n  constructor(\n    adapter: FabricClientAdapter,\n    query: MangoQuery | PreparedStatement<any>,\n    size: number,\n    clazz: Constructor<M>\n  ) {\n    super(adapter, query, size, clazz);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  protected prepare(rawStatement: MangoQuery): MangoQuery {\n    throw new UnsupportedError(\n      `Raw query access must be implemented by a subclass. only prepared statements are natively available`\n    );\n  }\n\n  override page(\n    page: number = 1,\n    ...args: MaybeContextualArg<any>\n  ): Promise<M[]> {\n    return super.page(page, ...args); // this will fail for non-prepared statements\n  }\n\n  static override isSerializedPage(obj: SerializedPage<any> | any) {\n    return obj && typeof obj === \"object\" && Array.isArray(obj.data);\n  }\n}\n","import type { MaybeContextualArg } from \"@decaf-ts/core\";\nimport {\n  ContextOf,\n  DirectionLimitOffset,\n  FlagsOf,\n  ObserverHandler,\n  OrderDirection,\n  Paginator,\n  PersistenceKeys,\n  PreparedStatementKeys,\n  Repository,\n  SerializedPage,\n} from \"@decaf-ts/core\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { Constructor } from \"@decaf-ts/decoration\";\nimport { type FabricClientAdapter } from \"./FabricClientAdapter\";\nimport {\n  BulkCrudOperationKeys,\n  enforceDBDecorators,\n  OperationKeys,\n  PrimaryKeyType,\n  reduceErrorsToPrint,\n  ValidationError,\n} from \"@decaf-ts/db-decorators\";\nimport { CouchDBKeys } from \"@decaf-ts/for-couchdb\";\nimport { FabricClientPaginator } from \"./FabricClientPaginator\";\n\n/**\n * @description Repository implementation for Fabric client operations\n * @summary Extends the generic Repository to prepare context and arguments for CRUD operations executed via a Fabric client Adapter, wiring RepositoryFlags and Fabric-specific overrides.\n * @template M extends Model - The model type handled by this repository\n * @param {Adapter<any, MangoQuery, FabricFlags, Context<FabricFlags>>} [adapter] - Optional adapter instance used to execute operations\n * @param {Constructor<M>} [clazz] - Optional model constructor used by the repository\n * @return {void}\n * @class FabricClientRepository\n * @example\n * import { Repository } from \"@decaf-ts/core\";\n * import { FabricClientRepository } from \"@decaf-ts/for-fabric\";\n *\n * class User extends Model { id!: string; name!: string; }\n * const repo = new FabricClientRepository<User>();\n * const created = await repo.create(new User({ id: \"1\", name: \"Alice\" }));\n * const loaded = await repo.read(\"1\");\n *\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant Repo as FabricClientRepository\n *   participant Adapter\n *   App->>Repo: create(model)\n *   Repo->>Repo: createPrefix(model, ...args)\n *   Repo->>Adapter: create(table, id, model, flags)\n *   Adapter-->>Repo: result\n *   Repo-->>App: model\n */\nexport class FabricClientRepository<\n  M extends Model,\n  A extends FabricClientAdapter = FabricClientAdapter,\n> extends Repository<M, A> {\n  protected override _overrides = Object.assign({}, super[\"_overrides\"], {\n    ignoreValidation: true,\n    ignoreHandlers: true,\n    allowRawStatements: false,\n    forcePrepareSimpleQueries: true,\n    forcePrepareComplexQueries: true,\n    allowGenerationOverride: false,\n    rebuildWithTransient: false,\n  });\n\n  constructor(adapter?: A, clazz?: Constructor<M>, force: boolean = false) {\n    super(adapter, clazz, force);\n  }\n\n  override override(flags: Partial<FlagsOf<ContextOf<A>>>): this {\n    return super\n      .override(Object.assign({}, flags, this._overrides))\n      .for(flags as any);\n  }\n\n  protected override ObserverHandler(): ObserverHandler {\n    return super.ObserverHandler();\n  }\n\n  override async paginateBy(\n    key: keyof M,\n    order: OrderDirection,\n    ref: Omit<DirectionLimitOffset, \"direction\"> = {\n      offset: 1,\n      limit: 10,\n    },\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<SerializedPage<M>> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.PAGE_BY, true)\n    ).for(this.paginateBy);\n    log.verbose(\n      `paginating ${Model.tableName(this.class)} with page size ${ref.limit}`\n    );\n    return this.statement(\n      this.paginateBy.name,\n      key,\n      order,\n      { limit: ref.limit, offset: ref.offset, bookmark: ref.bookmark },\n      ...ctxArgs\n    );\n  }\n\n  override async listBy(\n    key: keyof M,\n    order: OrderDirection,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<M[]> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.LIST_BY, true)\n    ).for(this.listBy);\n    log.verbose(\n      `listing ${Model.tableName(this.class)} by ${key as string} ${order}`\n    );\n    return (await this.statement(\n      this.listBy.name,\n      key,\n      order,\n      ...ctxArgs\n    )) as any;\n  }\n\n  override async findBy(\n    key: keyof M,\n    value: any,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<M[]> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.FIND_BY, true)\n    ).for(this.findBy);\n    log.verbose(\n      `finding all ${Model.tableName(this.class)} with ${key as string} ${value}`\n    );\n    return (await this.statement(\n      this.findBy.name,\n      key,\n      value,\n      ...ctxArgs\n    )) as any;\n  }\n\n  override async findOneBy(\n    key: keyof M,\n    value: any,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<M> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.FIND_ONE_BY, true)\n    ).for(this.findOneBy);\n    log.verbose(\n      `finding One ${Model.tableName(this.class)} with ${key as string} ${value}`\n    );\n    return (await this.statement(\n      this.findOneBy.name,\n      key,\n      value,\n      ...ctxArgs\n    )) as any;\n  }\n\n  override async find(\n    value: string,\n    order: OrderDirection = OrderDirection.ASC,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<M[]> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.FIND, true)\n    ).for(this.find);\n    log.verbose(\n      `finding ${Model.tableName(this.class)} by default query attributes`\n    );\n    return (await this.statement(\n      this.find.name,\n      value,\n      order,\n      ...ctxArgs\n    )) as any;\n  }\n\n  override async page(\n    value: string,\n    direction: OrderDirection = OrderDirection.ASC,\n    ref: Omit<DirectionLimitOffset, \"direction\"> = {\n      offset: 1,\n      limit: 10,\n    },\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<SerializedPage<M>> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.PAGE, true)\n    ).for(this.page);\n    log.verbose(\n      `paging ${Model.tableName(this.class)} by default query attributes`\n    );\n    return (await this.statement(\n      this.page.name,\n      value,\n      direction,\n      ref,\n      ...ctxArgs\n    )) as any;\n  }\n\n  override async statement(\n    name: string,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<any> {\n    const { log, ctx, ctxArgs } = (\n      await this.logCtx(args, PersistenceKeys.STATEMENT, true)\n    ).for(this.statement);\n    log.verbose(`Executing prepared statement ${name}`);\n    const callArgs = ctxArgs.slice(0, -1);\n    const result = JSON.parse(\n      this.adapter.decode(\n        await this.adapter.evaluateTransaction(\n          ctx,\n          PersistenceKeys.STATEMENT,\n          [name, JSON.stringify(callArgs)],\n          undefined,\n          undefined,\n          this.class.name\n        )\n      )\n    );\n\n    let hydrated: any;\n    if (Array.isArray(result)) {\n      hydrated = result.map((r: any) =>\n        (r as any)[CouchDBKeys.TABLE] &&\n        (r as any)[CouchDBKeys.TABLE] === Model.tableName(this.class)\n          ? (new this.class(r) as M)\n          : r\n      );\n    } else if (\n      (result as any)[CouchDBKeys.TABLE] &&\n      (result as any)[CouchDBKeys.TABLE] === Model.tableName(this.class)\n    ) {\n      hydrated = new this.class(result) as M;\n    } else if (FabricClientPaginator.isSerializedPage(result)) {\n      hydrated = Object.assign(result, {\n        data: result.data.map((d: any) => new this.class(d) as M),\n      });\n    } else {\n      hydrated = result;\n    }\n\n    return this.applyAfterRead(hydrated, ctx);\n  }\n\n  private async applyAfterRead(value: any, ctx: ContextOf<A>): Promise<any> {\n    if (!ctx.getOrUndefined(\"afterQueryHandlers\")) return value;\n    if (value instanceof Model) {\n      await enforceDBDecorators<M, Repository<M, A>, any>(\n        this,\n        ctx,\n        value as M,\n        OperationKeys.READ,\n        OperationKeys.AFTER\n      );\n      return value;\n    }\n    if (Array.isArray(value)) {\n      await Promise.all(value.map((entry) => this.applyAfterRead(entry, ctx)));\n      return value;\n    }\n    if (FabricClientPaginator.isSerializedPage(value)) {\n      await this.applyAfterRead(value.data, ctx);\n      return value;\n    }\n    return value;\n  }\n\n  override async countOf(\n    key?: keyof M,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<number> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.COUNT_OF, true)\n    ).for(this.countOf);\n    log.verbose(\n      `counting ${Model.tableName(this.class)}${key ? ` by ${key as string}` : \"\"}`\n    );\n    const stmtArgs = key ? [key, ...ctxArgs] : ctxArgs;\n    return this.statement(PreparedStatementKeys.COUNT_OF, ...stmtArgs);\n  }\n\n  override async maxOf<K extends keyof M>(\n    key: K,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<M[K]> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.MAX_OF, true)\n    ).for(this.maxOf);\n    log.verbose(\n      `finding max of ${key as string} in ${Model.tableName(this.class)}`\n    );\n    return this.statement(PreparedStatementKeys.MAX_OF, key, ...ctxArgs);\n  }\n\n  override async minOf<K extends keyof M>(\n    key: K,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<M[K]> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.MIN_OF, true)\n    ).for(this.minOf);\n    log.verbose(\n      `finding min of ${key as string} in ${Model.tableName(this.class)}`\n    );\n    return this.statement(PreparedStatementKeys.MIN_OF, key, ...ctxArgs);\n  }\n\n  override async avgOf<K extends keyof M>(\n    key: K,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<number> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.AVG_OF, true)\n    ).for(this.avgOf);\n    log.verbose(\n      `calculating avg of ${key as string} in ${Model.tableName(this.class)}`\n    );\n    return this.statement(PreparedStatementKeys.AVG_OF, key, ...ctxArgs);\n  }\n\n  override async sumOf<K extends keyof M>(\n    key: K,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<number> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.SUM_OF, true)\n    ).for(this.sumOf);\n    log.verbose(\n      `calculating sum of ${key as string} in ${Model.tableName(this.class)}`\n    );\n    return this.statement(PreparedStatementKeys.SUM_OF, key, ...ctxArgs);\n  }\n\n  override async distinctOf<K extends keyof M>(\n    key: K,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<M[K][]> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.DISTINCT_OF, true)\n    ).for(this.distinctOf);\n    log.verbose(\n      `finding distinct values of ${key as string} in ${Model.tableName(this.class)}`\n    );\n    return this.statement(PreparedStatementKeys.DISTINCT_OF, key, ...ctxArgs);\n  }\n\n  override async groupOf<K extends keyof M>(\n    key: K,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<Record<string, M[]>> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.GROUP_OF, true)\n    ).for(this.groupOf);\n    log.verbose(`grouping ${Model.tableName(this.class)} by ${key as string}`);\n    return this.statement(PreparedStatementKeys.GROUP_OF, key, ...ctxArgs);\n  }\n\n  async healthcheck(...args: MaybeContextualArg<ContextOf<A>>) {\n    const { ctxArgs } = this.logCtx(args, this.healthcheck);\n\n    const result = await this.adapter.healthcheck(this.class, ...ctxArgs);\n\n    return result;\n  }\n\n  override async create(\n    model: M,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<M> {\n    const { ctx, log, ctxArgs } = this.logCtx(args, this.create);\n    log.debug(\n      `Creating new ${this.class.name} in table ${Model.tableName(this.class)}`\n    );\n    this.ensureLegacyMirrorFlag(ctx, model);\n    const prepared = this.adapter.prepare(model, ctx);\n    const { record, id, transient } = prepared;\n    const result = await this.adapter.create(\n      this.class,\n      id,\n      record,\n      transient,\n      ...ctxArgs\n    );\n    return this.adapter.revert<M>(result, this.class, id, transient, ctx);\n  }\n\n  override async update(\n    model: M,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<M> {\n    const { ctxArgs, log, ctx } = this.logCtx(args, this.update);\n    this.ensureLegacyMirrorFlag(ctx, model);\n    const prepared = this.adapter.prepare(model, ctx);\n    const { id, transient } = prepared;\n    let record = prepared.record;\n    log.debug(\n      `updating ${this.class.name} in table ${Model.tableName(this.class)} with id ${id}`\n    );\n    record = await this.adapter.update(\n      this.class,\n      id,\n      record,\n      transient,\n      ...ctxArgs\n    );\n    return this.adapter.revert<M>(record, this.class, id, transient, ctx);\n  }\n\n  protected override async createAllPrefix(\n    models: M[],\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<[M[], ...any[], ContextOf<A>]> {\n    const { ctx, ctxArgs } = (\n      await this.logCtx(args, OperationKeys.CREATE, true)\n    ).for(this.createAllPrefix);\n    const ignoreHandlers = ctx.get(\"ignoreHandlers\");\n    const ignoreValidate = ctx.get(\"ignoreValidation\");\n    if (!models.length) return [models, ...ctxArgs] as any;\n\n    models = await Promise.all(\n      models.map(async (m) => {\n        m = new this.class(m);\n        if (!ignoreHandlers)\n          await enforceDBDecorators<M, Repository<M, A>, any>(\n            this,\n            ctx,\n            m,\n            OperationKeys.CREATE,\n            OperationKeys.ON\n          );\n        return m;\n      })\n    );\n\n    if (!ignoreValidate) {\n      const ignoredProps = ctx.get(\"ignoredValidationProperties\") || [];\n\n      const errors = await Promise.all(\n        models.map((m) => Promise.resolve(m.hasErrors(...ignoredProps)))\n      );\n\n      const errorMessages = reduceErrorsToPrint(errors);\n\n      if (errorMessages) throw new ValidationError(errorMessages);\n    }\n    return [models, ...ctxArgs] as any;\n  }\n\n  override async createAll(\n    models: M[],\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<M[]> {\n    if (!models.length) return models;\n    const { ctx, log, ctxArgs } = this.logCtx(args, this.createAll);\n    log.debug(\n      `Creating ${models.length} new ${this.class.name} in table ${Model.tableName(this.class)}`\n    );\n\n    models.forEach((model) => this.ensureLegacyMirrorFlag(ctx, model));\n    const prepared = models.map((m) => this.adapter.prepare(m, ctx));\n    const ids = prepared.map((p) => p.id);\n    const payloads = prepared.map((p) => p.record);\n    const transients = prepared.map((p) => p.transient);\n    const created = await this.adapter.createAll(\n      this.class,\n      ids as PrimaryKeyType[],\n      payloads,\n      transients,\n      ...ctxArgs\n    );\n    return Promise.all(\n      created.map(async (r, i) => {\n        const id = ids[i];\n        return this.adapter.revert<M>(r, this.class, id, transients[i], ctx);\n      })\n    );\n  }\n\n  override async readAll(\n    keys: PrimaryKeyType[],\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ) {\n    const { ctx, log, ctxArgs } = this.logCtx(args, this.readAll);\n    log.debug(\n      `reading ${keys.length} ${this.class.name} in table ${Model.tableName(this.class)}`\n    );\n    const records = await this.adapter.readAll(this.class, keys, ...ctxArgs);\n    return records.map((r, i) =>\n      this.adapter.revert(r, this.class, keys[i], {}, ctx)\n    );\n  }\n\n  override async updateAll(\n    models: M[],\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<M[]> {\n    const { ctx, log, ctxArgs } = this.logCtx(args, this.updateAll);\n    log.debug(\n      `Updating ${models.length} new ${this.class.name} in table ${Model.tableName(this.class)}`\n    );\n\n    models.forEach((model) => this.ensureLegacyMirrorFlag(ctx, model));\n    const prepared = models.map((m) => this.adapter.prepare(m, ctx));\n    const ids = prepared.map((p) => p.id);\n    const updated = await this.adapter.updateAll(\n      this.class,\n      ids as PrimaryKeyType[],\n      prepared.map((r) => r.record),\n      prepared.map((r) => r.transient),\n      ...ctxArgs\n    );\n    return Promise.all(\n      updated.map(async (u, i) => {\n        const id = ids[i];\n        return this.adapter.revert<M>(\n          u,\n          this.class,\n          id,\n          prepared[i].transient,\n          ctx\n        );\n      })\n    );\n  }\n\n  private ensureLegacyMirrorFlag(ctx: ContextOf<A>, model: M): void {\n    if (Model.mirroredAt(model)) {\n      ctx.accumulate({ legacy: true });\n    }\n  }\n}\n","import { BaseModel, column, pk, table } from \"@decaf-ts/core\";\nimport { model, type ModelArg, required } from \"@decaf-ts/decorator-validation\";\n\n/**\n * @description ERC20 token metadata model\n * @summary Represents an ERC20 token definition within the Fabric ERC20 sample, including name, symbol, decimals, and the owning identity. Used to define the unique token managed by the contract.\n * @param {ModelArg<ERC20Token>} [m] - Optional partial data or another instance to initialize the model\n * @return {void}\n * @class ERC20Token\n * @example\n * const token = new ERC20Token({ name: \"MyToken\", symbol: \"MTK\", decimals: 18, owner: \"x509::...\" });\n * // Persist through a repository: await repo.create(token, ctx)\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant Repo\n *   participant Adapter\n *   App->>Repo: create(new ERC20Token({...}), ctx)\n *   Repo->>Adapter: create(table, id=name, record, flags)\n *   Adapter-->>Repo: stored\n *   Repo-->>App: model\n */\n@table(\"erc20_tokens\")\n@model()\nexport class ERC20Token extends BaseModel {\n  @pk({ type: String })\n  /**\n   * @description Token unique name\n   * @summary Serves as the primary key for the ERC20 token definition; typically a human-readable identifier\n   */\n  name!: string;\n\n  @column()\n  @required()\n  /**\n   * @description Owning identity of the token\n   * @summary X.509 subject or MSP identity string that denotes who owns/controls the token definition\n   */\n  owner!: string;\n  @column()\n  @required()\n  /**\n   * @description Token symbol\n   * @summary Short ticker-like symbol used to represent the token (e.g., MTK)\n   */\n  symbol!: string;\n  @column()\n  @required()\n  /**\n   * @description Decimal precision for token amounts\n   * @summary Number of digits after the decimal separator used when formatting token balances\n   */\n  decimals!: number;\n\n  constructor(m?: ModelArg<ERC20Wallet>) {\n    super(m);\n  }\n}\n\n/**\n * @description ERC20 wallet model\n * @summary Represents a holder account for an ERC20 token within the Fabric network, tracking balance and token association.\n * @param {ModelArg<ERC20Wallet>} [m] - Optional partial data or another instance to initialize the model\n * @return {void}\n * @class ERC20Wallet\n * @example\n * const wallet = new ERC20Wallet({ id: \"acct1\", token: \"MyToken\", balance: 1000 });\n * // Update balance via repository: await repo.update(wallet, ctx)\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant Repo\n *   App->>Repo: read(\"acct1\", ctx)\n *   Repo-->>App: ERC20Wallet\n */\n@table(\"erc20_wallets\")\n@model()\nexport class ERC20Wallet extends BaseModel {\n  @pk({ type: String })\n  /**\n   * @description Wallet unique identifier\n   * @summary Primary key for the wallet; commonly references an account or identity\n   */\n  id!: string;\n\n  @column()\n  @required()\n  /**\n   * @description Associated token name\n   * @summary References the ERC20Token this wallet holds; maintained as a relationship for cascading updates/deletes\n   */\n  token!: string;\n\n  @column()\n  @required()\n  /**\n   * @description Token balance for this wallet\n   * @summary Current amount of the associated token held by this wallet\n   */\n  balance!: number;\n\n  @column()\n  /**\n   * @description Captive flag or identifier\n   * @summary Optional field used by some flows to mark non-transferable funds or managed custody\n   */\n  captive!: string;\n\n  constructor(m?: ModelArg<ERC20Wallet>) {\n    super(m);\n  }\n}\n\n/**\n * @description ERC20 allowance model\n * @summary Captures an approval relationship where an owner allows a spender to transfer up to a certain value from the owner's wallet.\n * @param {ModelArg<Allowance>} [m] - Optional partial data or another instance to initialize the model\n * @return {void}\n * @class Allowance\n * @example\n * const allowance = new Allowance({ owner: \"acct1\", spender: \"acct2\", value: 50 });\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   App->>App: new Allowance({ owner, spender, value })\n */\n@table(\"erc20_allowances\")\n@model()\nexport class Allowance extends BaseModel {\n  @pk({ type: String })\n  /**\n   * @description Allowance unique identifier\n   * @summary Primary key for the allowance; typically a unique identifier for the approval relationship\n   */\n  @column()\n  @required()\n  /**\n   * @description Owner wallet identifier\n   * @summary Wallet that authorizes the allowance\n   */\n  owner!: string;\n\n  @column()\n  @required()\n  /**\n   * @description Spender wallet identifier\n   * @summary Wallet allowed to spend up to the approved value from the owner\n   */\n  spender!: string;\n\n  @column()\n  @required()\n  /**\n   * @description Approved value\n   * @summary Maximum token amount the spender may transfer on behalf of the owner\n   */\n  value!: number;\n\n  constructor(m?: ModelArg<Allowance>) {\n    super(m);\n  }\n}\n","import {\n  JSONSerializer,\n  Model,\n  ModelKeys,\n} from \"@decaf-ts/decorator-validation\";\nimport { SerializationError } from \"@decaf-ts/db-decorators\";\nimport { Constructor, Metadata } from \"@decaf-ts/decoration\";\n\n/**\n * @description Client-side JSON serializer for Decaf models targeting Hyperledger Fabric\n * @summary Extends the base JSONSerializer to embed model metadata (anchor) required to reconstruct instances on the client, and to safely serialize/deserialize Fabric-bound models.\n * @template M extends Model - The Decaf model type handled by this serializer\n * @param {void} [constructor] No public constructor arguments; provided for documentation completeness\n * @return {void}\n * @class ClientSerializer\n * @example\n * const serializer = new ClientSerializer<User>();\n * const json = serializer.serialize(new User({ id: \"1\", name: \"Alice\" }));\n * const user = serializer.deserialize(json);\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant Serializer as ClientSerializer\n *   participant Model\n *   App->>Serializer: serialize(model)\n *   Serializer->>Serializer: preSerialize(model)\n *   Serializer-->>App: JSON string\n *   App->>Serializer: deserialize(json)\n *   Serializer->>Serializer: JSON.parse(json)\n *   Serializer->>Model: Model.build(parsed, anchor)\n *   Model-->>App: instance\n */\nexport class ClientSerializer<M extends Model> extends JSONSerializer<M> {\n  constructor() {\n    super();\n  }\n  /**\n   * @description Prepare a model for JSON serialization embedding class anchor\n   * @summary Clones the model and injects the class metadata anchor so it can be reconstructed during deserialization. Falls back to provided table name if metadata is not available.\n   * @template M - Model type handled by this serializer\n   * @param {M} model - The model instance to serialize\n   * @param {string} [modelName] - Optional table name to use when metadata cannot be derived\n   * @return {Record<string, any>} A plain object ready to be JSON.stringify'd\n   */\n  protected override preSerialize(model: M, modelName?: string) {\n    // TODO: nested preserialization (so increase performance when deserializing)\n    const toSerialize: Record<string, any> = Object.assign({}, model);\n    let metadata = Metadata.modelName(model.constructor as Constructor<M>);\n\n    if (!metadata || metadata === \"Object\")\n      if (modelName) metadata = modelName;\n      else\n        throw new SerializationError(\n          `Could not find metadata for ${model.constructor.name}`\n        );\n    toSerialize[ModelKeys.ANCHOR] = metadata;\n    return toSerialize;\n  }\n\n  /**\n   * @description Rebuilds a model from its JSON serialization\n   * @summary Parses the JSON string, retrieves the embedded model anchor, and uses Model.build to reconstruct the original instance\n   * @param {string} str - The JSON string previously produced by serialize\n   * @return {M} The reconstructed model instance\n   */\n  override deserialize(str: string): M {\n    const deserialization = JSON.parse(str);\n    const className = deserialization[ModelKeys.ANCHOR];\n    if (!className)\n      throw new Error(\"Could not find class reference in serialized model\");\n    const model: M = Model.build(deserialization, className) as unknown as M;\n    return model;\n  }\n\n  /**\n   * @description Serializes a model to a JSON string\n   * @summary Prepares the model via preSerialize, embedding metadata needed for reconstruction, and returns a JSON string representation\n   * @param {M} model - The model instance to serialize\n   * @param {string} [table] - Optional table name to include as anchor when metadata is unavailable\n   * @return {string} A JSON string containing the serialized model with anchor metadata\n   */\n  override serialize(model: M, modelName?: string): string {\n    return JSON.stringify(this.preSerialize(model, modelName));\n  }\n}\n","import { FabricClientRepository } from \"../FabricClientRepository\";\nimport { ERC20Token, ERC20Wallet } from \"../../contracts/erc20/models\";\nimport { Model, Serializer } from \"@decaf-ts/decorator-validation\";\nimport { FabricClientAdapter } from \"../FabricClientAdapter\";\nimport { ClientSerializer } from \"../../shared/ClientSerializer\";\nimport {\n  Context,\n  ContextOf,\n  ContextualArgs,\n  EventIds,\n  MaybeContextualArg,\n  Sequence,\n} from \"@decaf-ts/core\";\nimport {\n  BulkCrudOperationKeys,\n  InternalError,\n  OperationKeys,\n} from \"@decaf-ts/db-decorators\";\nimport { Constructor } from \"@decaf-ts/decoration\";\n/**\n * Repository for interacting with ERC20 contracts on a Hyperledger Fabric network.\n * Extends the base FabricClientRepository class and utilizes the ClientSerializer for data serialization.\n */\nexport class FabricERC20ClientRepository<\n  A extends FabricClientAdapter,\n> extends FabricClientRepository<ERC20Wallet, A> {\n  private static serializer = new ClientSerializer();\n\n  protected readonly serializer: Serializer<any> =\n    FabricERC20ClientRepository.serializer;\n\n  private static decoder = new TextDecoder(\"utf8\");\n\n  /**\n   * @description Notifies all observers of an event.\n   * @summary Updates all registered observers with information about a database event.\n   * @param {string} table - The table name where the event occurred.\n   * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of event that occurred.\n   * @param {EventIds} id - The ID or IDs of the affected records.\n   * @param {...any[]} args - Additional arguments.\n   * @return {Promise<void>} A promise that resolves when all observers have been notified.\n   * @throws {InternalError} If the observer handler is not initialized.\n   */\n  override async updateObservers<M extends Model>(\n    table: Constructor<M> | string,\n    event: OperationKeys | BulkCrudOperationKeys | string,\n    id: EventIds,\n    ...args: ContextualArgs<ContextOf<A>>\n  ): Promise<void> {\n    if (!this.observerHandler)\n      throw new InternalError(\n        \"ObserverHandler not initialized. Did you register any observables?\"\n      );\n    const { log, ctxArgs } = this.logCtx(args, this.updateObservers);\n    log.verbose(\n      `Updating ${this.observerHandler.count()} observers for ${this}`\n    );\n\n    table = (\n      typeof table === \"string\" ? Model.get(table) : table\n    ) as Constructor<M>;\n    let parsedId: string | string[] | undefined;\n\n    if (id === undefined) {\n      parsedId = undefined;\n    } else if (Array.isArray(id)) {\n      parsedId = id.map(\n        (i) => Sequence.parseValue(Model.sequenceFor(table).type, i) as string\n      );\n    } else {\n      parsedId = Sequence.parseValue(\n        Model.sequenceFor(table).type,\n        id\n      ) as string;\n    }\n    await this.observerHandler.updateObservers(\n      table,\n      event,\n      parsedId!,\n      ...ctxArgs\n    );\n  }\n\n  /**\n   * Decodes a Uint8Array into a string using the TextDecoder.\n   *\n   * @param data - The Uint8Array to decode.\n   * @returns The decoded string.\n   */\n  decode(data: Uint8Array): string {\n    return FabricERC20ClientRepository.decoder.decode(data);\n  }\n\n  constructor(adapter?: A) {\n    super(adapter, ERC20Wallet);\n  }\n\n  /**\n   * Retrieves the name of the ERC20 token.\n   *\n   * @description\n   * This function interacts with the blockchain network to fetch the name of the ERC20 token.\n   * It calls the \"TokenName\" transaction on the smart contract and decodes the returned data.\n   *\n   * @returns {Promise<string>} A promise that resolves with the name of the ERC20 token.\n   *\n   * @throws {Error} If the transaction fails or the decoding process fails.\n   */\n  async tokenName(...args: MaybeContextualArg<ContextOf<A>>): Promise<string> {\n    const { ctx } = (await this.logCtx(args, \"tokenName\", true)).for(\n      this.tokenName\n    );\n    const name = await this.adapter.evaluateTransaction(ctx, \"TokenName\");\n    return this.decode(name);\n  }\n\n  /**\n   * Retrieves the symbol of the ERC20 token.\n   *\n   * This function interacts with the blockchain network to fetch the symbol of the ERC20 token.\n   * It calls the \"Symbol\" transaction on the smart contract and decodes the returned data.\n   *\n   * @returns {Promise<string>} A promise that resolves with the symbol of the ERC20 token.\n   *\n   * @throws {Error} If the transaction fails or the decoding process fails.\n   */\n  async symbol(...args: MaybeContextualArg<ContextOf<A>>): Promise<string> {\n    const { ctx } = (await this.logCtx(args, \"symbol\", true)).for(this.symbol);\n    const symbol = await this.adapter.evaluateTransaction(ctx, \"Symbol\");\n    return this.decode(symbol);\n  }\n\n  /**\n   * Retrieves the number of decimal places for the ERC20 token.\n   *\n   * This function interacts with the blockchain network to fetch the number of decimal places for the ERC20 token.\n   * It calls the \"Decimals\" transaction on the smart contract and decodes the returned data.\n   *\n   * @returns {Promise<number>} A promise that resolves with the number of decimal places for the ERC20 token.\n   *\n   * @throws {Error} If the transaction fails or the decoding process fails.\n   */\n  async decimals(...args: MaybeContextualArg<ContextOf<A>>): Promise<number> {\n    const { ctx } = (await this.logCtx(args, \"decimals\", true)).for(\n      this.decimals\n    );\n    const decimals = await this.adapter.evaluateTransaction(ctx, \"Decimals\");\n    return Number(this.decode(decimals));\n  }\n\n  /**\n   * Retrieves the total supply of the ERC20 token.\n   *\n   * This function interacts with the blockchain network to fetch the total supply of the ERC20 token.\n   * It calls the \"TotalSupply\" transaction on the smart contract and decodes the returned data.\n   *\n   * @returns {Promise<number>} A promise that resolves with the total supply of the ERC20 token.\n   *\n   * @throws {Error} If the transaction fails or the decoding process fails.\n   */\n  async totalSupply(\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<number> {\n    const { ctx } = (await this.logCtx(args, \"totalSupply\", true)).for(\n      this.totalSupply\n    );\n    const total = await this.adapter.evaluateTransaction(ctx, \"TotalSupply\");\n    return Number(this.decode(total));\n  }\n\n  /**\n   * Retrieves the balance of the ERC20 token for a specified owner.\n   *\n   * @description\n   * This function interacts with the blockchain network to fetch the balance of the ERC20 token for a given owner.\n   * It calls the \"BalanceOf\" transaction on the smart contract with the provided owner's address as a parameter.\n   * The returned data is then decoded and converted to a number.\n   *\n   * @param owner - The address of the ERC20 token owner.\n   *\n   * @returns {Promise<number>} A promise that resolves with the balance of the ERC20 token for the specified owner.\n   *\n   * @throws {Error} If the transaction fails or the decoding process fails.\n   */\n  async balanceOf(\n    owner: string,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<number> {\n    const { ctx } = (await this.logCtx(args, \"balance\", true)).for(\n      this.balanceOf\n    );\n    const balance = await this.adapter.evaluateTransaction(ctx, \"BalanceOf\", [\n      owner,\n    ]);\n    return Number(this.decode(balance));\n  }\n\n  /**\n   * Transfers a specified amount of ERC20 tokens to a recipient.\n   *\n   * @description\n   * This function interacts with the blockchain network to transfer a specified amount of ERC20 tokens to a recipient.\n   * It calls the \"Transfer\" transaction on the smart contract with the recipient's address and the transfer amount as parameters.\n   * The returned data is then decoded and checked to determine if the transfer was successful.\n   *\n   * @param to - The address of the recipient.\n   * @param value - The amount of ERC20 tokens to transfer.\n   *\n   * @returns {Promise<boolean>} A promise that resolves with `true` if the transfer was successful, and `false` otherwise.\n   *\n   * @throws {Error} If the transaction fails or the decoding process fails.\n   */\n  async transfer(\n    to: string,\n    value: number,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<boolean> {\n    const { ctx } = (await this.logCtx(args, \"transfer\", true)).for(\n      this.transfer\n    );\n    const transferred = await this.adapter.submitTransaction(ctx, \"Transfer\", [\n      to,\n      value.toString(),\n    ]);\n    return this.decode(transferred) === \"true\" ? true : false;\n  }\n\n  /**\n   * Transfers a specified amount of ERC20 tokens from one account to another.\n   *\n   * @description\n   * This function interacts with the blockchain network to transfer a specified amount of ERC20 tokens from one account to another.\n   * For this transfer to work the spender ( account that will trigger this function ) need to have the value approved as an allowance by the sender.\n   * It calls the \"TransferFrom\" transaction on the smart contract with the sender's address, recipient's address, and the transfer amount as parameters.\n   * The returned data is then decoded and checked to determine if the transfer was successful.\n   *\n   * @param from - The address of the sender.\n   * @param to - The address of the recipient.\n   * @param value - The amount of ERC20 tokens to transfer.\n   *\n   * @returns {Promise<boolean>} A promise that resolves with `true` if the transfer was successful, and `false` otherwise.\n   *\n   * @throws {Error} If the transaction fails or the decoding process fails.\n   */\n  async transferFrom(\n    from: string,\n    to: string,\n    value: number\n  ): Promise<boolean> {\n    const contextArgs = await Context.args(\n      \"transferFrom\",\n      this.class,\n      [],\n      this.adapter,\n      this._overrides || {}\n    );\n    const { ctx } = this.logCtx(contextArgs.args, this.transferFrom);\n    const transferred = await this.adapter.submitTransaction(\n      ctx,\n      \"TransferFrom\",\n      [from, to, value.toString()]\n    );\n\n    return this.decode(transferred) === \"true\" ? true : false;\n  }\n\n  /**\n   * Approves a specified amount of ERC20 tokens to be spent by a specified spender.\n   *\n   * This function interacts with the blockchain network to approve a specified amount of ERC20 tokens to be spent by a specified spender.\n   * It calls the \"Approve\" transaction on the smart contract with the spender's address and the approval amount as parameters.\n   * The returned data is then decoded and checked to determine if the approval was successful.\n   *\n   * @param spender - The address of the spender.\n   * @param value - The amount of ERC20 tokens to approve for the spender.\n   *\n   * @returns {Promise<boolean>} A promise that resolves with `true` if the approval was successful, and `false` otherwise.\n   *\n   * @throws {Error} If the transaction fails or the decoding process fails.\n   */\n  async approve(spender: string, value: number): Promise<boolean> {\n    const contextArgs = await Context.args(\n      \"approve\",\n      this.class,\n      [],\n      this.adapter,\n      this._overrides || {}\n    );\n    const { ctx } = this.logCtx(contextArgs.args, this.approve);\n    const approved = await this.adapter.submitTransaction(ctx, \"Approve\", [\n      spender,\n      value.toString(),\n    ]);\n    return this.decode(approved) === \"true\" ? true : false;\n  }\n\n  /**\n   * Retrieves the allowance of ERC20 tokens that the specified owner has approved for a spender.\n   *\n   * @description\n   * This function interacts with the blockchain network to fetch the allowance of ERC20 tokens that the specified owner has approved for a spender.\n   * It calls the \"Allowance\" transaction on the smart contract with the owner's address and the spender's address as parameters.\n   * The returned data is then decoded and converted to a number.\n   *\n   * @param owner - The address of the ERC20 token owner.\n   * @param spender - The address of the spender.\n   *\n   * @returns {Promise<number>} A promise that resolves with the allowance of ERC20 tokens that the specified owner has approved for the spender.\n   *\n   * @throws {Error} If the transaction fails or the decoding process fails.\n   */\n  async allowance(owner: string, spender: string): Promise<number> {\n    const contextArgs = await Context.args(\n      \"allowance\",\n      this.class,\n      [],\n      this.adapter,\n      this._overrides || {}\n    );\n    const { ctx } = this.logCtx(contextArgs.args, this.allowance);\n    const allowance = await this.adapter.submitTransaction(ctx, \"Allowance\", [\n      owner,\n      spender,\n    ]);\n    return Number(this.decode(allowance));\n  }\n\n  /**\n   * Initializes the ERC20 contract with the provided token information.\n   *\n   * @description\n   * This function interacts with the blockchain network to initialize the ERC20 contract with the given token information.\n   * It calls the \"Initialize\" transaction on the smart contract with the serialized token data as a parameter.\n   * The returned data is then decoded and checked to determine if the initialization was successful.\n   *\n   * @param token - The ERC20 token information to initialize the contract with.\n   *\n   * @returns {Promise<boolean>} A promise that resolves with `true` if the initialization was successful, and `false` otherwise.\n   *\n   * @throws {Error} If the transaction fails or the decoding process fails.\n   */\n  async initialize(token: ERC20Token): Promise<boolean> {\n    const contextArgs = await Context.args(\n      \"initialize\",\n      this.class,\n      [],\n      this.adapter,\n      this._overrides || {}\n    );\n    const { ctx } = this.logCtx(contextArgs.args, this.initialize);\n    const initiliazed = await this.adapter.submitTransaction(\n      ctx,\n      \"Initialize\",\n      [FabricERC20ClientRepository.serializer.serialize(token)]\n    );\n\n    return this.decode(initiliazed) === \"true\" ? true : false;\n  }\n\n  /**\n   * Checks if the ERC20 contract has been initialized.\n   *\n   * This function interacts with the blockchain network to verify if the ERC20 contract has been initialized.\n   * It calls the \"CheckInitialized\" transaction on the smart contract, which does not require any parameters.\n   *\n   * @returns {Promise<void>} A promise that resolves when the initialization check is completed.\n   *\n   * @throws {Error} If the transaction fails.\n   */\n  async checkInitialized(): Promise<void> {\n    const contextArgs = await Context.args(\n      \"checkInitialized\",\n      this.class,\n      [],\n      this.adapter,\n      this._overrides || {}\n    );\n    const { ctx } = this.logCtx(contextArgs.args, this.checkInitialized);\n    await this.adapter.evaluateTransaction(ctx, \"CheckInitialized\");\n  }\n\n  /**\n   * Mints a specified amount of ERC20 tokens.\n   *\n   * @description\n   * This function interacts with the blockchain network to mint a specified amount of ERC20 tokens.\n   * It calls the \"Mint\" transaction on the smart contract with the minting amount as a parameter.\n   * The function does not return any value, but it updates the minter's number of tokens.\n   *\n   * @param amount - The amount of ERC20 tokens to mint.\n   *\n   * @returns {Promise<void>} A promise that resolves when the minting process is completed.\n   *\n   * @throws {Error} If the transaction fails.\n   */\n  async mint(amount: number): Promise<void> {\n    const contextArgs = await Context.args(\n      \"mint\",\n      this.class,\n      [],\n      this.adapter,\n      this._overrides || {}\n    );\n    const { ctx } = this.logCtx(contextArgs.args, this.mint);\n    await this.adapter.submitTransaction(ctx, \"Mint\", [amount.toString()]);\n  }\n\n  /**\n   * Burns a specified amount of ERC20 tokens from the minter's account.\n   *\n   * This function interacts with the blockchain network to burn a specified amount of ERC20 tokens.\n   * It calls the \"Burn\" transaction on the smart contract with the burning amount as a parameter.\n   * The function does not return any value, but it decreases the minter's number of tokens.\n   *\n   * @param amount - The amount of ERC20 tokens to burn.\n   *\n   * @returns {Promise<void>} A promise that resolves when the burning process is completed.\n   *\n   * @throws {Error} If the transaction fails.\n   */\n  async burn(amount: number): Promise<void> {\n    const contextArgs = await Context.args(\n      \"burn\",\n      this.class,\n      [],\n      this.adapter,\n      this._overrides || {}\n    );\n    const { ctx } = this.logCtx(contextArgs.args, this.burn);\n    await this.adapter.submitTransaction(ctx, \"Burn\", [amount.toString()]);\n  }\n\n  /**\n   * Burns a specified amount of ERC20 tokens from a specified account.\n   *\n   * This function interacts with the blockchain network to burn a specified amount of ERC20 tokens from a given account.\n   * It calls the \"BurnFrom\" transaction on the smart contract with the account's address and the burning amount as parameters.\n   * The function does not return any value, but it decreases the specified account's number of tokens.\n   *\n   * @param account - The address of the account from which to burn the ERC20 tokens.\n   * @param amount - The amount of ERC20 tokens to burn.\n   *\n   * @returns {Promise<void>} A promise that resolves when the burning process is completed.\n   *\n   * @throws {Error} If the transaction fails.\n   */\n  async burnFrom(account: string, amount: number): Promise<void> {\n    const contextArgs = await Context.args(\n      \"burnFrom\",\n      this.class,\n      [],\n      this.adapter,\n      this._overrides || {}\n    );\n    const { ctx } = this.logCtx(contextArgs.args, this.burnFrom);\n    await this.adapter.submitTransaction(ctx, \"BurnFrom\", [\n      account,\n      amount.toString(),\n    ]);\n  }\n\n  /**\n   * Retrieves the balance of ERC20 tokens associated with the client's account.\n   *\n   * This function interacts with the blockchain network to fetch the balance of ERC20 tokens associated with the client's account.\n   * It calls the \"ClientAccountBalance\" transaction on the smart contract, which does not require any parameters.\n   * The returned data is then decoded and converted to a number.\n   *\n   * @returns {Promise<number>} A promise that resolves with the balance of ERC20 tokens associated with the client's account.\n   *\n   * @throws {Error} If the transaction fails or the decoding process fails.\n   */\n  async clientAccountBalance(): Promise<number> {\n    const contextArgs = await Context.args(\n      \"accountBalance\",\n      this.class,\n      [],\n      this.adapter,\n      this._overrides || {}\n    );\n    const { ctx } = this.logCtx(contextArgs.args, this.clientAccountBalance);\n    const serializedAccountBalance = await this.adapter.evaluateTransaction(\n      ctx,\n      \"ClientAccountBalance\"\n    );\n\n    return Number(this.decode(serializedAccountBalance));\n  }\n\n  /**\n   * Retrieves the client's account ID from the blockchain network.\n   *\n   * This function interacts with the blockchain network to fetch the client's account ID.\n   * It calls the \"ClientAccountID\" transaction on the smart contract, which does not require any parameters.\n   * The returned data is then decoded and returned as a string.\n   *\n   * @returns {Promise<string>} A promise that resolves with the client's account ID.\n   *\n   * @throws {Error} If the transaction fails or the decoding process fails.\n   */\n  async clientAccountID(): Promise<string> {\n    const contextArgs = await Context.args(\n      \"accountId\",\n      this.class,\n      [],\n      this.adapter,\n      this._overrides || {}\n    );\n    const { ctx } = this.logCtx(contextArgs.args, this.clientAccountID);\n    const clientAccountID = await this.adapter.evaluateTransaction(\n      ctx,\n      \"ClientAccountID\"\n    );\n\n    return this.decode(clientAccountID);\n  }\n}\n","import { Model } from \"@decaf-ts/decorator-validation\";\nimport { InternalError, PrimaryKeyType } from \"@decaf-ts/db-decorators\";\nimport { Constructor } from \"@decaf-ts/decoration\";\nimport { SequenceOptions } from \"@decaf-ts/core\";\nimport { composeAttributeValue } from \"@decaf-ts/db-decorators\";\n\nexport function extractIds<M extends Model>(\n  clazz: Constructor<M>,\n  models: M | M[] | Record<string, any> | Record<string, any>[],\n  ids: PrimaryKeyType | PrimaryKeyType[]\n) {\n  let pk: keyof M;\n  let composed: any;\n  let pkProps: SequenceOptions;\n\n  function extractId(m: M | Record<string, any>, ids: PrimaryKeyType) {\n    pk = pk || Model.pk(clazz);\n    pkProps = pkProps || Model.sequenceFor(clazz);\n    composed = composed || Model.composed(clazz, pk);\n\n    if (composed) {\n      return composeAttributeValue(m as any, composed);\n    }\n\n    const id = (m as any)[pk] || ids;\n    if (typeof id === \"undefined\")\n      throw new InternalError(`could not rebuild id for ${m.constructor.name}`);\n    return id;\n  }\n\n  if (Array.isArray(models)) {\n    if (!Array.isArray(ids) || ids.length !== models.length)\n      throw new InternalError(\n        \"inconsistent parameters. both must be arrays of equal length\"\n      );\n    return models.map((m, i) => extractId(m, ids[i]));\n  }\n  return extractId(models, ids as PrimaryKeyType);\n}\n","import { BaseModel, column, pk } from \"@decaf-ts/core\";\nimport { model, type ModelArg, required } from \"@decaf-ts/decorator-validation\";\nimport { description } from \"@decaf-ts/decoration\";\n\n/**\n * @description Identity credential model storing cryptographic materials\n * @summary Holds certificate chain and private key information for a Fabric identity, managed as a separate entity linked from Identity\n * @param {ModelArg<IdentityCredentials>} [arg] - Optional initialization object used to populate model fields\n * @class IdentityCredentials\n * @example\n * // Create credentials entry\n * const creds = new IdentityCredentials({ id: \"creds1\", certificate: \"...\", rootCertificate: \"...\", privateKey: \"...\" });\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant Model as IdentityCredentials\n *   App->>Model: new IdentityCredentials({ id, certificate, rootCertificate, privateKey })\n *   Model-->>App: instance\n * @see model\n */\n@model()\nexport class IdentityCredentials extends BaseModel {\n  /**\n   * @description Unique identifier of the credentials record\n   * @summary Primary key for referencing this credentials entry\n   */\n  @description(\"Unique identifier of the credentials record\")\n  @column()\n  @pk()\n  id!: string;\n\n  /**\n   * @description PEM-encoded X.509 certificate for the identity\n   * @summary Leaf certificate associated with the identity\n   */\n  @description(\"PEM-encoded X.509 certificate for the identity\")\n  @column()\n  @required()\n  certificate!: string;\n\n  /**\n   * @description PEM-encoded root or intermediate certificate\n   * @summary Root of trust used to validate the leaf certificate\n   */\n  @description(\"PEM-encoded root or intermediate certificate\")\n  @column()\n  @required()\n  rootCertificate!: string;\n\n  /**\n   * @description PEM-encoded private key material\n   * @summary Private key corresponding to the identity certificate\n   */\n  @description(\"PEM-encoded private key\")\n  @column()\n  @required()\n  privateKey!: string;\n\n  constructor(arg?: ModelArg<IdentityCredentials>) {\n    super(arg);\n  }\n}\n","/**\n * @description Keys used to mark Fabric-specific model metadata\n * @summary Enumeration of special keys used by the serialization layer to persist Fabric-related flags on models\n * @enum {string}\n * @readonly\n * @memberOf module:for-fabric.shared\n */\nexport enum FabricModelKeys {\n  /** Private data marker used to tag properties or models for Fabric private collections */\n  PRIVATE = \"private\",\n  SHARED = \"shared\",\n  /** Namespace prefix used for Fabric-specific metadata keys */\n  FABRIC = \"fabric\",\n  OWNED_BY = \"owned-by\",\n  TRANSACTION_ID = \"transaction-id\",\n  MIRROR = \"mirror\",\n}\n/**\n * @description Supported identity types for Fabric credentials\n * @summary Enumeration of identity formats recognized by this library\n * @enum {string}\n * @readonly\n * @memberOf module:for-fabric.shared\n */\nexport enum IdentityType {\n  /** Standard X.509 identity format used by Hyperledger Fabric */\n  X509 = \"X.509\",\n}\n\n/**\n * @description String identifier for the Fabric adapter flavour\n * @summary Used to tag adapters/repositories that operate against Hyperledger Fabric\n * @const FabricFlavour\n * @memberOf module:for-fabric.shared\n */\nexport const FabricFlavour = \"hlf-fabric\";\n","import {\n  BaseModel,\n  Cascade,\n  column,\n  index,\n  oneToOne,\n  pk,\n} from \"@decaf-ts/core\";\nimport { model, type ModelArg, required } from \"@decaf-ts/decorator-validation\";\nimport { IdentityCredentials } from \"./IdentityCredentials\";\nimport { IdentityType } from \"../constants\";\nimport { description } from \"@decaf-ts/decoration\";\n\n/**\n * @description Identity model representing a Fabric wallet entry\n * @summary Encapsulates an identity stored in a Fabric wallet, including its MSP identifier, credential linkage, and type information. Built on BaseModel for integration with Decaf validation and persistence.\n * @param {ModelArg<Identity>} [arg] - Optional initialization object used to populate model fields\n * @class Identity\n * @example\n * // Create a new identity referencing existing credentials\n * const id = new Identity({ id: \"user1\", mspId: \"Org1MSP\", type: IdentityType.X509 });\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant Model as Identity\n *   App->>Model: new Identity({ id, mspId, type })\n *   Model-->>App: instance\n */\n@model()\nexport class Identity extends BaseModel {\n  /**\n   * @description Unique identifier of the identity in the wallet\n   * @summary Primary key used to reference this identity record\n   */\n  @description(\"Unique identifier of the identity\")\n  @pk()\n  id!: string;\n\n  /**\n   * @description Link to the identity credentials stored separately\n   * @summary One-to-one relationship to the credentials entity; cascades on update and delete\n   */\n  @oneToOne(IdentityCredentials, {\n    update: Cascade.CASCADE,\n    delete: Cascade.CASCADE,\n  })\n  credentials!: IdentityCredentials;\n\n  /**\n   * @description Membership Service Provider identifier\n   * @summary The MSP ID corresponding to the organization that issued this identity\n   */\n  @column()\n  @required()\n  @index()\n  mspId!: string;\n\n  /**\n   * @description Type of identity\n   * @summary Indicates the identity encoding/format; defaults to X.509\n   */\n  @column()\n  @required()\n  type: IdentityType = IdentityType.X509;\n\n  constructor(arg: ModelArg<Identity>) {\n    super(arg);\n  }\n}\n","import { stringFormat } from \"@decaf-ts/decorator-validation\";\nimport { Logger, MiniLogger } from \"@decaf-ts/logging\";\nimport { Identity, Signer, signers } from \"@hyperledger/fabric-gateway\";\nimport { CryptoSetting, ICryptoSuite, User } from \"fabric-common\";\nimport { HSMOptions } from \"../shared/types\";\nimport { normalizeImport } from \"@decaf-ts/core\";\nimport crypto, { X509Certificate } from \"crypto\";\nimport { X509Certificate as X509Cert } from \"@peculiar/x509\";\n\n/**\n * @description Core utilities for interacting with files, crypto identities, and Fabric SDK helpers\n * @summary Provides static helper methods to read credentials and keys from disk or raw content, construct Fabric gateway Identities and Signers, and perform common filesystem operations used by the Fabric client tooling.\n * @class CoreUtils\n * @example\n * // Read an identity and signer from directories\n * const identity = await CoreUtils.getIdentity('Org1MSP', '/msp/signcerts');\n * const signer = await CoreUtils.getSigner('/msp/keystore');\n * // Build a CA user\n * const user = await CoreUtils.getCAUser('appUser', pemKey, pemCert, 'Org1MSP');\n */\nexport class CoreUtils {\n  private static logger: Logger = new MiniLogger(CoreUtils.name);\n\n  private static cryptoSuite: ICryptoSuite;\n\n  private constructor() {}\n\n  /**\n   * @description Resolve file content from a path or return provided raw content\n   * @summary If the input is a Uint8Array or PEM content, returns it as-is; otherwise uses a provided async fileReader to load the content from disk.\n   * @param {string|Uint8Array} contentOrPath - Either a raw content buffer/string or a filesystem path\n   * @param {function(string): Promise<string|Uint8Array|Buffer>} fileReader - Async function to read file content when a path is provided\n   * @return {Promise<string|Uint8Array|Buffer>} The content to be used downstream\n   */\n  private static async contentOfLoadFile(\n    contentOrPath: string | Uint8Array,\n    fileReader: (path: string) => Promise<string | Uint8Array | Buffer>\n  ) {\n    if (contentOrPath instanceof Uint8Array) return contentOrPath;\n    if (\n      contentOrPath.match(\n        /-----BEGIN (CERTIFICATE|KEY|PRIVATE KEY)-----.+?-----END \\1-----$/gms\n      )\n    )\n      return contentOrPath;\n    return await fileReader(contentOrPath);\n  }\n\n  /**\n   * @description Read file content from a path or return provided Buffer\n   * @summary Convenience wrapper that loads a file using fs.promises when a path string is provided; otherwise returns the given Buffer directly.\n   * @param {string|Buffer} contentOrPath - Path to a file on disk or an already-loaded Buffer\n   * @return {Promise<string|Uint8Array|Buffer>} The file content as a Buffer/string depending on reader\n   */\n  static async readFile(contentOrPath: string | Buffer) {\n    if (typeof contentOrPath !== \"string\") return contentOrPath;\n\n    const fileReader = async (path: string) => {\n      const { promises } = await normalizeImport(import(\"fs\"));\n      return await promises.readFile(path);\n    };\n\n    return await fileReader(contentOrPath);\n  }\n\n  /**\n   * @description Create a Fabric CA User object with enrollment\n   * @summary Constructs a fabric-common User, sets a crypto suite, imports the provided private key, and sets enrollment with certificate and MSP ID.\n   * @param {string} userName - The user name for the CA user\n   * @param {string} privateKey - PEM-encoded private key\n   * @param {string} certificate - PEM-encoded X.509 certificate\n   * @param {string} mspId - Membership Service Provider identifier\n   * @return {Promise<User>} The enrolled Fabric User instance\n   */\n  static async getCAUser(\n    userName: string,\n    privateKey: string | undefined,\n    certificate: string,\n    mspId: string,\n    options?: { hsm?: HSMOptions }\n  ): Promise<User> {\n    this.logger.debug(\n      stringFormat(\n        \"Creating CA {0} user {1} with certificate {2}\",\n        mspId,\n        userName,\n        certificate\n      )\n    );\n    const user = new User(userName);\n    const config = options?.hsm\n      ? {\n          software: false,\n          lib: options.hsm.library,\n          slot: options.hsm.slot,\n          label: options.hsm.tokenLabel,\n          pin: String(options.hsm.pin),\n        }\n      : undefined;\n    const cryptoSuite = this.getCryptoSuite(config);\n\n    user.setCryptoSuite(cryptoSuite);\n    const enrollmentKey = options?.hsm\n      ? await this.getHSMEnrollmentKey(cryptoSuite, certificate, options.hsm)\n      : this.getSoftwareEnrollmentKey(cryptoSuite, privateKey);\n    await user.setEnrollment(enrollmentKey, certificate, mspId);\n    return user;\n  }\n\n  static getCryptoSuite(options?: CryptoSetting): ICryptoSuite {\n    if (!options) return User.newCryptoSuite();\n    if (CoreUtils.cryptoSuite) return CoreUtils.cryptoSuite;\n\n    CoreUtils.cryptoSuite = User.newCryptoSuite(options);\n    return CoreUtils.cryptoSuite;\n  }\n\n  private static getSoftwareEnrollmentKey(\n    cryptoSuite: any,\n    privateKey?: string\n  ) {\n    if (!privateKey) {\n      throw new Error(\n        \"Private key must be provided when HSM configuration is not supplied\"\n      );\n    }\n    return cryptoSuite.createKeyFromRaw(privateKey);\n  }\n\n  private static async getHSMEnrollmentKey(\n    cryptoSuite: any,\n    certificate: string,\n    hsm: HSMOptions\n  ) {\n    const ski =\n      hsm.keyIdHex && hsm.keyIdHex.trim().length > 0\n        ? Buffer.from(hsm.keyIdHex, \"hex\")\n        : await this.getCertificateSKI(certificate);\n    const key = await cryptoSuite.getKey(ski);\n    if (!key || (typeof key.isPrivate === \"function\" && !key.isPrivate())) {\n      throw new Error(\"Unable to resolve private key from HSM\");\n    }\n    return key;\n  }\n\n  static async getCertificateSKI(certificate: string): Promise<Buffer> {\n    const x509 = new X509Certificate(certificate);\n    const jwk = x509.publicKey.export({ format: \"jwk\" });\n    const prefix = Buffer.from([0x04]);\n    const x = Buffer.from(jwk.x || \"\", \"base64url\");\n    const y = Buffer.from(jwk.y || \"\", \"base64url\");\n    return crypto\n      .createHash(\"sha256\")\n      .update(Buffer.concat([prefix, x, y]))\n      .digest();\n  }\n\n  /**\n   * @description Build a Fabric Gateway Identity from an MSP ID and certificate\n   * @summary Reads a certificate from a directory path or accepts raw content and returns an Identity object suitable for the Fabric Gateway.\n   * @param {string} mspId - Membership Service Provider ID\n   * @param {string} certDirectoryPath - Path to a directory containing the certificate file, or PEM content\n   * @return {Promise<Identity>} The identity containing mspId and certificate credentials\n   */\n  static async getIdentity(\n    mspId: string,\n    certDirectoryPath: string\n  ): Promise<Identity> {\n    const identityFileReader = async (path: string) => {\n      const { promises } = await normalizeImport(import(\"fs\"));\n      const certPath = await this.getFirstDirFileName(path);\n      const credentials = await promises.readFile(certPath);\n      return credentials;\n    };\n\n    const credentials: Uint8Array = (await this.contentOfLoadFile(\n      certDirectoryPath,\n      identityFileReader\n    )) as Uint8Array;\n\n    return { mspId, credentials };\n  }\n\n  static async getFirstDirFileName(dirPath: string): Promise<string> {\n    const { promises } = await normalizeImport(import(\"fs\"));\n    const { join } = await normalizeImport(import(\"path\"));\n    const files = await promises.readdir(dirPath);\n    return join(dirPath, files[0]);\n  }\n\n  static async getFirstDirFileNameContent(dirPath: string): Promise<string> {\n    const { promises } = await normalizeImport(import(\"fs\"));\n    const { join } = await normalizeImport(import(\"path\"));\n    const files = await promises.readdir(dirPath);\n    return (await promises.readFile(join(dirPath, files[0]))).toString();\n  }\n\n  static async getFileContent(filePath: string): Promise<string> {\n    const { promises } = await normalizeImport(import(\"fs\"));\n    return (await promises.readFile(filePath)).toString();\n  }\n\n  static async getSigner(keyDirectoryPath: string): Promise<Signer> {\n    const signerFileReader = async (path: string) => {\n      const { promises } = await normalizeImport(import(\"fs\"));\n      const keyPath = await this.getFirstDirFileName(path);\n      return await promises.readFile(keyPath);\n    };\n\n    const privateKeyPem = (await this.contentOfLoadFile(\n      keyDirectoryPath,\n      signerFileReader\n    )) as Buffer;\n    const privateKey = await this.extractPrivateKey(privateKeyPem);\n    const keys = Object.getOwnPropertySymbols(privateKey);\n    const k = (privateKey as any)[keys[0]];\n    // --\n\n    return signers.newPrivateKeySigner(k as any);\n  }\n\n  private static async extractPrivateKey(pem: Buffer) {\n    const libName = \"crypto\";\n    let subtle: any;\n    if (\n      (globalThis as any).window &&\n      ((globalThis as any).window as { Crypto: any }).Crypto\n    ) {\n      subtle = ((globalThis as any).Crypto as any).subtle;\n    } else {\n      const lib = (await normalizeImport(import(libName))) as any;\n      subtle = lib.subtle || lib.webcrypto.subtle;\n    }\n\n    if (!subtle) throw new Error(\"Could not load SubtleCrypto module\");\n\n    function str2ab(str: string) {\n      const buf = new ArrayBuffer(str.length);\n      const bufView = new Uint8Array(buf);\n      for (let i = 0, strLen = str.length; i < strLen; i++) {\n        bufView[i] = str.charCodeAt(i);\n      }\n      return buf;\n    }\n\n    const str = pem\n      .toString(\"utf8\")\n      .replace(\"-----BEGIN PRIVATE KEY-----\", \"\")\n      .replaceAll(\"\\n\", \"\")\n      .replace(\"-----END PRIVATE KEY-----\", \"\");\n    const decoded = Buffer.from(str, \"base64\").toString(\"binary\");\n    const binaryDer = str2ab(decoded);\n    const key = await subtle.importKey(\n      \"pkcs8\",\n      binaryDer,\n      {\n        name: \"ECDSA\",\n        namedCurve: \"P-256\",\n      },\n      true,\n      [\"sign\"]\n    );\n\n    return key;\n  }\n}\n\n/**\n * Extracts the certificate Serial Number and the AKI (Authority Key Identifier)\n * in the format Fabric CA expects (plain hex, no colons).\n */\nexport function getAkiAndSerialFromCert(cert: string): {\n  aki: string;\n  serial: string;\n} {\n  const x509Certificate = new X509Cert(cert);\n\n  // Find the AKI (Authority Key Identifier) extension by its OID: 2.5.29.35\n  const akiExt = x509Certificate.extensions?.find(\n    (e) => e.type === \"2.5.29.35\"\n  );\n  if (!akiExt) {\n    throw new Error(\n      \"Authority Key Identifier (AKI) extension not found in certificate.\"\n    );\n  }\n\n  // akiExt.value is the extension content in DER bytes. Convert it to a hex string.\n  let aki = Buffer.from(new Uint8Array(akiExt.value))\n    .toString(\"hex\")\n    .toUpperCase();\n\n  /**\n   * Common case:\n   * The DER-encoded AKI extension often starts with:\n   *   30 16 80 14 <20-byte keyIdentifier>\n   * In hex, that's \"30168014\" + 40 hex chars (20 bytes).\n   *\n   * Fabric CA expects ONLY the 20-byte keyIdentifier (40 hex chars),\n   * so we strip the \"30168014\" prefix when present.\n   */\n  if (aki.startsWith(\"30168014\") && aki.length >= 8 + 40)\n    aki = aki.slice(8, 8 + 40);\n\n  return { aki, serial: x509Certificate.serialNumber };\n}\n","import * as x509 from \"@peculiar/x509\";\nimport { Crypto, CryptoKey } from \"@peculiar/webcrypto\";\nimport { stringFormat } from \"@decaf-ts/decorator-validation\";\nimport { isBrowser, MiniLogger } from \"@decaf-ts/logging\";\n\nconst crypto = new Crypto();\nx509.cryptoProvider.set(crypto);\n\nexport enum BASE_ALPHABET {\n  BASE2 = \"01\",\n  BASE8 = \"01234567\",\n  BASE11 = \"0123456789a\",\n  BASE16 = \"0123456789abcdef\",\n  BASE32 = \"0123456789ABCDEFGHJKMNPQRSTVWXYZ\",\n  BASE32_Z = \"ybndrfg8ejkmcpqxot1uwisza345h769\",\n  BASE36 = \"0123456789abcdefghijklmnopqrstuvwxyz\",\n  BASE58 = \"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz\",\n  BASE62 = \"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\",\n  BASE64 = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\",\n  BASE67 = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.!~\",\n}\n\nexport type keyObject = {\n  iv: ArrayBuffer;\n  key: CryptoKey;\n};\n\nexport enum CRYPTO {\n  HASH = \"SHA-256\",\n  ITERATIONS = 1000,\n  KEYLENGTH = 48,\n  DERIVED_IV_LENGTH = 16,\n  DERIVED_KEY_LENGTH = 32, // Because SHA-256 used has a native size of 32 bytes\n  ALGORYTHM = \"AES-GCM\",\n  KEY_ALGORYTHM = \"PBKDF2\",\n}\n\nexport class BaseEncoder {\n  private readonly baseMap: Uint8Array = new Uint8Array(256);\n  private readonly base: number;\n  private readonly leader: string;\n  private readonly factor: number;\n  private readonly iFactor: number;\n\n  constructor(private alphabet: BASE_ALPHABET) {\n    if (this.alphabet.length >= 255) throw new Error(\"Alphabet too long\");\n\n    for (let j = 0; j < this.baseMap.length; j++) this.baseMap[j] = 255;\n\n    for (let i = 0; i < alphabet.length; i++) {\n      const x = alphabet.charAt(i);\n      const xc = x.charCodeAt(0);\n      if (this.baseMap[xc] !== 255) throw new Error(x + \" is ambiguous\");\n\n      this.baseMap[xc] = i;\n    }\n\n    this.base = this.alphabet.length;\n    this.leader = this.alphabet.charAt(0);\n    this.factor = Math.log(this.base) / Math.log(256); // log(BASE) / log(256), rounded up\n    this.iFactor = Math.log(256) / Math.log(this.base); // log(256) / log(BASE), rounded up\n  }\n\n  encode(source: Uint8Array | DataView | any[] | string) {\n    if (typeof source === \"string\") {\n      source = Buffer.from(source);\n    } else if (ArrayBuffer.isView(source)) {\n      source = new Uint8Array(\n        source.buffer,\n        source.byteOffset,\n        source.byteLength\n      );\n    } else if (Array.isArray(source)) {\n      source = Uint8Array.from(source);\n    }\n\n    if (source.length === 0) return \"\";\n\n    // Skip & count leading zeroes.\n    let zeroes = 0;\n    let length = 0;\n    let pbegin = 0;\n    const pend = source.length;\n    while (pbegin !== pend && source[pbegin] === 0) {\n      pbegin++;\n      zeroes++;\n    }\n    // Allocate enough space in big-endian base58 representation.\n    const size = ((pend - pbegin) * this.iFactor + 1) >>> 0;\n    const b58 = new Uint8Array(size);\n    // Process the bytes.\n    while (pbegin !== pend) {\n      let carry = source[pbegin];\n      // Apply \"b58 = b58 * 256 + ch\".\n      let i = 0;\n      for (\n        let it1 = size - 1;\n        (carry !== 0 || i < length) && it1 !== -1;\n        it1--, i++\n      ) {\n        carry += (256 * b58[it1]) >>> 0;\n        b58[it1] = carry % this.base >>> 0;\n        carry = (carry / this.base) >>> 0;\n      }\n      if (carry !== 0) throw new Error(\"Non-zero carry\");\n\n      length = i;\n      pbegin++;\n    }\n    // Skip leading zeroes in base58 result.\n    let it2 = size - length;\n    while (it2 !== size && b58[it2] === 0) it2++;\n\n    // Translate the result into a string.\n    let str = this.leader.repeat(zeroes);\n    for (; it2 < size; ++it2) {\n      str += this.alphabet.charAt(b58[it2]);\n    }\n    return str;\n  }\n\n  private decodeUnsafe(source: string): Uint8Array | undefined {\n    if (source.length === 0) return new Uint8Array(0);\n\n    let psz = 0;\n    // Skip and count leading '1's.\n    let zeroes = 0;\n    let length = 0;\n    while (source[psz] === this.leader) {\n      zeroes++;\n      psz++;\n    }\n    // Allocate enough space in big-endian base256 representation.\n    const size = ((source.length - psz) * this.factor + 1) >>> 0; // log(58) / log(256), rounded up.\n    const b256 = new Uint8Array(size);\n    // Process the characters.\n    while (source[psz]) {\n      // Decode character\n      let carry = this.baseMap[source.charCodeAt(psz)];\n      // Invalid character\n      if (carry === 255) return;\n\n      let i = 0;\n      for (\n        let it3 = size - 1;\n        (carry !== 0 || i < length) && it3 !== -1;\n        it3--, i++\n      ) {\n        carry += (this.base * b256[it3]) >>> 0;\n        b256[it3] = carry % 256 >>> 0;\n        carry = (carry / 256) >>> 0;\n      }\n      if (carry !== 0) throw new Error(\"Non-zero carry\");\n\n      length = i;\n      psz++;\n    }\n    // Skip leading zeroes in b256.\n    let it4 = size - length;\n    while (it4 !== size && b256[it4] === 0) it4++;\n\n    const vch = new Uint8Array(zeroes + (size - it4));\n    let j = zeroes;\n    while (it4 !== size) vch[j++] = b256[it4++];\n\n    return vch;\n  }\n\n  decode(source: string) {\n    const buffer = this.decodeUnsafe(source);\n    if (buffer) return buffer;\n    throw new Error(\"Non-base\" + this.base + \" character\");\n  }\n}\n\nexport class CryptoUtils {\n  private static readonly b58encoder = new BaseEncoder(BASE_ALPHABET.BASE58);\n  private static readonly logger = new MiniLogger(CryptoUtils.name);\n  private constructor() {}\n\n  static fabricIdFromCertificate(certificate: string) {\n    this.logger.debug(stringFormat(\"Parsing certificate: {0}\", certificate));\n    const cert = new x509.X509Certificate(certificate);\n    const { subject, issuer } = cert;\n    this.logger.debug(\n      stringFormat(\n        \"Certificate parsed with subject {0} and issuer {1}\",\n        subject,\n        issuer\n      )\n    );\n    return `x509::/${subject.replaceAll(\", \", \"/\")}::/${issuer.replaceAll(\", \", \"/\")}`;\n  }\n\n  static encode(str: string): string {\n    return this.b58encoder.encode(str);\n  }\n  static decode(str: string): string {\n    const decoded = this.b58encoder.decode(str);\n    const result = new TextDecoder().decode(decoded);\n    return result;\n  }\n\n  static stringToArrayBuffer(str: string) {\n    const buf = new ArrayBuffer(str.length);\n    const bufView = new Uint8Array(buf);\n    for (let i = 0, strLen = str.length; i < strLen; i++) {\n      bufView[i] = str.charCodeAt(i);\n    }\n    return buf;\n  }\n\n  private static async extractKey(\n    type: \"private\" | \"public\",\n    pem: Buffer | string,\n    usages?: any[]\n  ) {\n    const subtle = crypto.subtle;\n\n    const str = pem\n      .toString(\"utf8\")\n      .replace(\n        new RegExp(`-----BEGIN (${type.toUpperCase()} KEY|CERTIFICATE)-----`),\n        \"\"\n      )\n      .replaceAll(\"\\n\", \"\")\n      .replace(\n        new RegExp(`-----END (${type.toUpperCase()} KEY|CERTIFICATE)-----`),\n        \"\"\n      );\n    const decoded = Buffer.from(str, \"base64\").toString(\"binary\");\n    const binaryDer = this.stringToArrayBuffer(decoded);\n    const key = await subtle.importKey(\n      \"pkcs8\",\n      binaryDer,\n      {\n        name: \"ECDSA\",\n        namedCurve: \"P-256\",\n      },\n      true,\n      usages ? usages : [\"sign\"]\n    );\n\n    return key;\n  }\n\n  static async extractPrivateKey(pem: Buffer | string, usages?: any[]) {\n    return this.extractKey(\"private\", pem, usages);\n  }\n\n  static async extractPublicKey(pem: Buffer | string, usages?: any[]) {\n    return this.extractKey(\"public\", pem, usages);\n  }\n\n  static async sign(privateKey: string, data: Buffer): Promise<string> {\n    const key = await this.extractPrivateKey(privateKey);\n    const buff = (await crypto.subtle.sign(\n      {\n        name: \"ECDSA\",\n        hash: \"SHA-256\",\n      },\n      key,\n      data as any\n    )) as ArrayBuffer;\n\n    return Array.from(new Uint8Array(buff))\n      .map((b) => b.toString(16).padStart(2, \"0\"))\n      .join(\"\");\n  }\n\n  static async verify(\n    certificate: string,\n    signature: Buffer | string,\n    data: Buffer | string\n  ): Promise<boolean> {\n    const cert = new x509.X509Certificate(certificate);\n    const key = await cert.publicKey.export();\n    signature = (\n      typeof signature === \"string\" ? Buffer.from(signature, \"hex\") : signature\n    ) as Buffer;\n    data = (typeof data === \"string\" ? Buffer.from(data) : data) as Buffer;\n    return crypto.subtle.verify(\n      {\n        name: \"ECDSA\",\n        hash: \"SHA-256\",\n      },\n      key,\n      signature as any,\n      data as any\n    );\n  }\n\n  static async encrypt(certificate: string, data: string | Buffer) {\n    const cert = new x509.X509Certificate(certificate);\n    const key = await cert.publicKey.export();\n    data = (typeof data === \"string\" ? Buffer.from(data) : data) as Buffer;\n    const buff = await this.getSubtleCrypto().encrypt(\n      {\n        name: \"ECDSA\",\n      },\n      key,\n      data\n    );\n\n    return Array.from(new Uint8Array(buff))\n      .map((b) => b.toString(16).padStart(2, \"0\"))\n      .join(\"\");\n  }\n\n  private static getSubtleCrypto() {\n    return isBrowser()\n      ? (globalThis as any).window.crypto.subtle\n      : crypto.subtle;\n  }\n\n  static async decrypt(privateKey: string, data: string | Buffer) {\n    const key = await this.extractPrivateKey(privateKey);\n    data = (\n      typeof data === \"string\" ? Buffer.from(data, \"hex\") : data\n    ) as Buffer;\n    return this.getSubtleCrypto().decrypt(\n      {\n        name: \"ECDSA\",\n      },\n      key,\n      data\n    );\n  }\n\n  /**\n   * @summary Util function to get a random master key\n   *\n   * @description If data is not passed, a random ArrayBuffer will be generated\n   *\n   * @param {ArrayBuffer} data encrytion data\n   *\n   * @function getMaster\n   */\n  static async getMaster(data?: ArrayBuffer): Promise<keyObject> {\n    const textEncoder = new TextEncoder();\n    if (data === undefined) {\n      const genGenesis = crypto.randomUUID();\n      data = textEncoder.encode(genGenesis).buffer;\n    }\n\n    const importedKey = await this.getSubtleCrypto().importKey(\n      \"raw\",\n      data,\n      CRYPTO.KEY_ALGORYTHM as string,\n      false,\n      [\"deriveBits\"]\n    );\n\n    return {\n      key: importedKey,\n      iv: data!,\n    };\n  }\n\n  /**\n   * @summary Util function to derive a key from another key\n   *\n   * @param {string} salt\n   * @param {CryptoKey} key Original key\n   *\n   * @function getDerivationKey\n   */\n  static async getDerivationKey(salt: string, key: CryptoKey) {\n    const textEncoder = new TextEncoder();\n    const saltBuffer = textEncoder.encode(salt);\n    const saltHashed = await this.getSubtleCrypto().digest(\n      \"SHA-256\",\n      saltBuffer\n    );\n    const params = {\n      name: CRYPTO.KEY_ALGORYTHM as string,\n      hash: CRYPTO.HASH,\n      salt: saltHashed,\n      iterations: CRYPTO.ITERATIONS,\n    };\n    const derivation = await this.getSubtleCrypto().deriveBits(\n      params,\n      key,\n      CRYPTO.KEYLENGTH * 8\n    );\n    return this.getKey(derivation);\n  }\n\n  /**\n   * @summary Util function to get the key and IV from the CrytoKey array\n   *\n   * @param {ArrayBuffer} derivation\n   *\n   * @function getKey\n   */\n  static async getKey(derivation: ArrayBuffer) {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    const ivlen = 16;\n    const keylen = 32;\n    const derivedKey = derivation.slice(0, keylen);\n    const iv = derivation.slice(keylen);\n    const importedEncryptionKey = await this.getSubtleCrypto().importKey(\n      \"raw\",\n      derivedKey,\n      { name: CRYPTO.ALGORYTHM as string },\n      false,\n      [\"encrypt\", \"decrypt\"]\n    );\n    return {\n      key: importedEncryptionKey,\n      iv: iv,\n    };\n  }\n\n  /**\n   * @summary Util function to decrypt data\n   *\n   * @param {string} text\n   * @param {keyObject} keyObject\n   *\n   * @function encrypt\n   */\n  static async encryptPin(\n    text: string,\n    keyObject: keyObject\n  ): Promise<ArrayBuffer> {\n    const textEncoder = new TextEncoder();\n    const textBuffer = textEncoder.encode(text);\n    const encryptedText = await this.getSubtleCrypto().encrypt(\n      { name: CRYPTO.ALGORYTHM as string, iv: keyObject.iv },\n      keyObject.key,\n      textBuffer\n    );\n    return encryptedText;\n  }\n\n  /**\n   * @summary Util function to decrypt data\n   *\n   * @param {BufferSource} encryptedText\n   * @param {keyObject} keyObject\n   *\n   * @function decrypt\n   */\n  static async decryptPin(\n    encryptedText: ArrayBuffer,\n    keyObject: keyObject\n  ): Promise<string> {\n    const textDecoder = new TextDecoder();\n    const decryptedText = await this.getSubtleCrypto().decrypt(\n      { name: CRYPTO.ALGORYTHM as string, iv: keyObject.iv },\n      keyObject.key,\n      encryptedText\n    );\n    return textDecoder.decode(decryptedText);\n  }\n}\n","import { BaseError, InternalError } from \"@decaf-ts/db-decorators\";\nimport { AuthorizationError } from \"@decaf-ts/core\";\n// import { MISSING_PRIVATE_DATA_ERROR_MESSAGE } from \"../contracts/private-data\";\n/**\n * @summary Represents an overflow error in arithmetic operations in Smart Contracts\n *\n * @param {string} msg the error message\n *\n * @class OverflowError\n * @extends InternalError\n *\n * @category Errors\n */\nexport class OverflowError extends InternalError {\n  constructor(msg: string | Error) {\n    super(msg, OverflowError.name);\n  }\n}\n\n/**\n * @summary Represents a failure in balance to perform a transaction in Smart Contracts\n *\n * @param {string} msg the error message\n *\n * @class BalanceError\n * @extends InternalError\n *\n * @category Errors\n */\nexport class BalanceError extends InternalError {\n  constructor(msg: string | Error) {\n    super(msg, BalanceError.name);\n  }\n}\n\n/**\n * @summary Represents a failure in balance to perform a transaction in Smart Contracts\n *\n * @param {string} msg the error message\n *\n * @class BalanceError\n * @extends InternalError\n *\n * @category Errors\n */\nexport class AllowanceError extends InternalError {\n  constructor(msg: string | Error) {\n    super(msg, AllowanceError.name);\n  }\n}\n\n/**\n * @summary Represents a failure registrating new entities\n *\n * @param {string} msg the error message\n *\n * @class RegistrationError\n *\n * @categort Errors\n */\nexport class RegistrationError extends AuthorizationError {\n  constructor(msg: string | Error) {\n    super(msg, RegistrationError.name);\n  }\n}\n\n/**\n * @description Error thrown when an unsupported operation is attempted\n * @summary This error is thrown when an operation is requested that is not supported by the current\n * persistence adapter or configuration. It extends the BaseError class and sets a 500 status code.\n * @param {string|Error} msg - The error message or an Error object to wrap\n * @class UnsupportedError\n * @example\n * ```typescript\n * // Throwing an UnsupportedError\n * if (!adapter.supportsTransactions()) {\n *   throw new UnsupportedError('Transactions are not supported by this adapter');\n * }\n *\n * // Catching an UnsupportedError\n * try {\n *   await adapter.beginTransaction();\n * } catch (error) {\n *   if (error instanceof UnsupportedError) {\n *     console.error('Operation not supported:', error.message);\n *   }\n * }\n * ```\n *\n * @category Errors\n */\nexport class MissingContextError extends InternalError {\n  constructor(msg: string | Error) {\n    super(msg, MissingContextError.name, 500);\n  }\n}\n\nexport class UnauthorizedPrivateDataAccess extends BaseError {\n  constructor(msg: string | Error = \"MISSING_PRIVATE_DATA_ERROR_MESSAGE\") {\n    super(UnauthorizedPrivateDataAccess.name, msg, 403);\n  }\n}\n\n/**\n * Represents an error that occurs when a required initialization step is not performed.\n *\n * @class NotInitializedError\n * @extends BaseError\n *\n * @category Errors\n *\n * @param {string | Error} msg - The error message or an Error object to wrap.\n *\n * @throws {NotInitializedError} - Throws an error when a required initialization step is not performed.\n *\n * @example\n * ```typescript\n * // Initialize the application\n * if (!isInitialized) {\n *   throw new NotInitializedError('Application is not initialized');\n * }\n *\n * // Catching an NotInitializedError\n * try {\n *   // Perform operations that require initialization\n * } catch (error) {\n *   if (error instanceof NotInitializedError) {\n *     console.error('Initialization error:', error.message);\n *   }\n * }\n * ```\n */\nexport class NotInitializedError extends BaseError {\n  constructor(msg: string | Error) {\n    super(NotInitializedError.name, msg, 409);\n  }\n}\n\nexport class MissingPKCSS11Lib extends InternalError {\n  constructor(msg: string | Error) {\n    super(msg, MissingPKCSS11Lib.name, 500);\n  }\n}\n\nexport class EndorsementError extends InternalError {\n  constructor(message: string | Error) {\n    super(message, EndorsementError.name, 500);\n  }\n}\n\nexport class MvccReadConflictError extends InternalError {\n  constructor(message: string | Error) {\n    super(message, MvccReadConflictError.name, 500);\n  }\n}\n\nexport class PhantomReadConflictError extends InternalError {\n  constructor(message: string | Error) {\n    super(message, PhantomReadConflictError.name, 500);\n  }\n}\n\nexport class EndorsementPolicyError extends InternalError {\n  constructor(message: string | Error) {\n    super(message, EndorsementPolicyError.name, 500);\n  }\n}\n\nexport class TransactionLimitsError extends InternalError {\n  constructor(\n    message: string | Error,\n    name: string = TransactionLimitsError.name,\n    code = 590\n  ) {\n    super(message, name, code);\n  }\n}\n\nexport class TransactionTimeoutError extends InternalError {\n  constructor(message: string | Error) {\n    super(message, TransactionTimeoutError.name, 591);\n  }\n}\n\nexport class TransactionBufferSizeError extends InternalError {\n  constructor(message: string | Error) {\n    super(message, TransactionBufferSizeError.name, 592);\n  }\n}\n","import FabricCAServices from \"fabric-ca-client\";\nimport {\n  AffiliationService,\n  IdentityService,\n  IEnrollResponse,\n  IRegisterRequest,\n  IServiceResponse,\n  TLSOptions,\n} from \"fabric-ca-client\";\nimport { User } from \"fabric-common\";\nimport { CAConfig, Credentials } from \"../../shared/types\";\nimport { Identity } from \"../../shared/model/Identity\";\nimport { AuthorizationError } from \"@decaf-ts/core\";\nimport {\n  ConflictError,\n  InternalError,\n  NotFoundError,\n} from \"@decaf-ts/db-decorators\";\nimport { CoreUtils } from \"../utils\";\nimport { CA_ROLE } from \"./constants\";\nimport { CryptoUtils } from \"../crypto\";\nimport {\n  CertificateResponse,\n  FabricIdentity,\n  GetCertificatesRequest,\n  IdentityResponse,\n} from \"../../shared/fabric-types\";\nimport { RegistrationError } from \"../../shared/errors\";\nimport { LoggedClass, Logging } from \"@decaf-ts/logging\";\n\n/**\n * @description Hyperledger Fabric CA identity types.\n * @summary Enumerates the supported identity types recognized by Fabric CA for registration and identity management.\n * @enum {string}\n * @readonly\n * @memberOf module:for-fabric.client\n */\nexport enum HFCAIdentityType {\n  PEER = \"peer\",\n  ORDERER = \"orderer\",\n  CLIENT = \"client\",\n  USER = \"user\",\n  ADMIN = \"admin\",\n}\n/**\n * @description Key/value attribute used during CA registration.\n * @summary Represents an attribute entry that can be attached to a Fabric CA identity during registration, optionally marking it for inclusion in ecert.\n * @interface IKeyValueAttribute\n * @template T\n * @param {string} name - Attribute name.\n * @param {string} value - Attribute value.\n * @param {boolean} [ecert] - Whether the attribute should be included in the enrollment certificate (ECert).\n * @memberOf module:for-fabric.client\n */\nexport interface IKeyValueAttribute {\n  name: string;\n  value: string;\n  ecert?: boolean;\n}\n\n/**\n * @description Standard Fabric CA identity attribute keys.\n * @summary Enumerates well-known Fabric CA attribute keys that can be assigned to identities for delegations and permissions.\n * @enum {string}\n * @readonly\n * @memberOf module:for-fabric.client\n */\nexport enum HFCAIdentityAttributes {\n  HFREGISTRARROLES = \"hf.Registrar.Roles\",\n  HFREGISTRARDELEGATEROLES = \"hf.Registrar.DelegateRoles\",\n  HFREGISTRARATTRIBUTES = \"hf.Registrar.Attributes\",\n  HFINTERMEDIATECA = \"hf.IntermediateCA\",\n  HFREVOKER = \"hf.Revoker\",\n  HFAFFILIATIONMGR = \"hf.AffiliationMgr\",\n  HFGENCRL = \"hf.GenCRL\",\n}\n\n/**\n * @description Service wrapper for interacting with a Fabric CA.\n * @summary Provides high-level operations for managing identities against a Hyperledger Fabric Certificate Authority, including registration, enrollment, revocation, and administrative queries. Encapsulates lower-level Fabric CA client calls with consistent logging and error mapping.\n * @param {CAConfig} caConfig - Connection and TLS configuration for the target CA.\n * @class FabricEnrollmentService\n * @example\n * // Register and enroll a new user\n * const svc = new FabricEnrollmentService({\n *   url: 'https://localhost:7054',\n *   caName: 'Org1CA',\n *   tls: { trustedRoots: ['/path/to/ca.pem'], verify: false },\n *   caCert: '/path/to/admin/certDir',\n *   caKey: '/path/to/admin/keyDir'\n * });\n * await svc.register({ userName: 'alice', password: 's3cr3t' }, false, 'org1.department1', CA_ROLE.USER);\n * const id = await svc.enroll('alice', 's3cr3t');\n * @mermaid\n * sequenceDiagram\n *   autonumber\n *   participant App\n *   participant Svc as FabricEnrollmentService\n *   participant CA as Fabric CA\n *   App->>Svc: register(credentials, ...)\n *   Svc->>CA: register(request, adminUser)\n *   CA-->>Svc: enrollmentSecret\n *   Svc-->>App: secret\n *   App->>Svc: enroll(enrollmentId, secret)\n *   Svc->>CA: enroll({enrollmentID, secret})\n *   CA-->>Svc: certificates\n *   Svc-->>App: Identity\n */\nexport class FabricEnrollmentService extends LoggedClass {\n  private ca?: FabricCAServices;\n\n  private certificateService?: any;\n\n  private affiliationService?: AffiliationService;\n\n  private identityService?: IdentityService;\n\n  private client?: any;\n\n  private user?: User;\n\n  constructor(private caConfig: CAConfig) {\n    CoreUtils.getCryptoSuite(\n      caConfig.hsm\n        ? {\n            software: false,\n            lib: caConfig.hsm.library,\n            slot: caConfig.hsm.slot,\n            label: caConfig.hsm.tokenLabel,\n            pin: String(caConfig.hsm.pin),\n          }\n        : undefined\n    );\n    super();\n  }\n\n  protected async User(): Promise<User> {\n    if (this.user) return this.user;\n    const { caName, caCert, caKey, url, hsm } = this.caConfig;\n    const log = this.log.for(this.User);\n    log.debug(`Creating CA user for ${caName} at ${url}`);\n    log.debug(`Retrieving CA certificate from ${caCert}`);\n    const certificate = await CoreUtils.getFirstDirFileNameContent(caCert);\n    let key: string | undefined;\n    if (!hsm) {\n      if (!caKey) {\n        throw new InternalError(\n          `Missing caKey configuration for CA ${caName}. Provide a key directory or configure HSM support.`\n        );\n      }\n      log.debug(`Retrieving CA key from ${caKey}`);\n      key = await CoreUtils.getFirstDirFileNameContent(caKey);\n    } else {\n      log.debug(\n        `Using HSM configuration for CA ${caName} with library ${hsm.library}`\n      );\n    }\n    log.debug(`Loading Admin user for ca ${caName}`);\n    this.user = await CoreUtils.getCAUser(\"admin\", key, certificate, caName, {\n      hsm,\n    });\n    return this.user;\n  }\n\n  protected async CA(): Promise<FabricCAServices> {\n    if (this.ca) return this.ca;\n    const log = this.log.for(this.CA);\n    const { url, tls, caName } = this.caConfig;\n\n    // FOR Some Reason the verification fails need to investigate this works for now\n    // eslint-disable-next-line prefer-const\n    let { trustedRoots, verify } = tls as TLSOptions;\n\n    const root = (trustedRoots as string[])[0] as string;\n    log.debug(`Retrieving CA certificate from ${root}. cwd: ${process.cwd()}`);\n\n    const certificate = await CoreUtils.getFileContent(root);\n    log.debug(`Creating CA Client for CA ${caName} under ${url}`);\n    this.ca = new FabricCAServices(\n      url,\n      {\n        trustedRoots: Buffer.from(certificate),\n        verify,\n      } as TLSOptions,\n      caName\n    );\n    return this.ca;\n  }\n\n  protected async Client(): Promise<{ newCertificateService: any }> {\n    if (this.client) return this.client;\n    const ca = await this.CA();\n    this.client = (ca as any)[\"_FabricCAServices\"];\n    return this.client;\n  }\n\n  protected async Certificate() {\n    if (!this.certificateService)\n      this.certificateService = (await this.Client()).newCertificateService();\n    return this.certificateService;\n  }\n\n  protected async Affiliations() {\n    if (!this.affiliationService)\n      this.affiliationService = (await this.CA()).newAffiliationService();\n    return this.affiliationService;\n  }\n\n  protected async Identities() {\n    if (!this.identityService)\n      this.identityService = (await this.CA()).newIdentityService();\n    return this.identityService;\n  }\n\n  /**\n   * @description Retrieve certificates from the CA.\n   * @summary Calls the CA certificate service to list certificates, optionally mapping to PEM strings only.\n   * @param {GetCertificatesRequest} [request] - Optional filter request for certificate lookup.\n   * @param {boolean} [doMap=true] - When true, returns array of PEM strings; otherwise returns full response object.\n   * @return {Promise<string[] | CertificateResponse>} Array of PEM strings or the full certificate response.\n   */\n  async getCertificates(\n    request?: GetCertificatesRequest,\n    doMap = true\n  ): Promise<string[] | CertificateResponse> {\n    const certificateService = await this.Certificate();\n    const user = await this.User();\n    const log = this.log.for(this.getCertificates);\n    log.debug(\n      `Retrieving certificates${request ? ` for ${request.id}` : \"\"} for CA ${this.caConfig.caName}`\n    );\n    const response: CertificateResponse = (\n      await certificateService.getCertificates(request || {}, user)\n    ).result;\n    log.debug(\n      `Found ${response.certs.length} certificates: ${JSON.stringify(response)}`\n    );\n    return doMap ? response.certs.map((c) => c.PEM) : response;\n  }\n\n  /**\n   * @description List identities registered in the CA.\n   * @summary Queries the CA identity service to fetch all identities and returns the list as FabricIdentity objects.\n   * @return {Promise<FabricIdentity[]>} The list of identities registered in the CA.\n   */\n  async getIdentities(): Promise<FabricIdentity[]> {\n    const identitiesService = await this.Identities();\n    const log = this.log.for(this.getIdentities);\n    log.debug(`Retrieving Identities under CA ${this.caConfig.caName}`);\n    const response: IdentityResponse = (\n      await identitiesService.getAll(await this.User())\n    ).result;\n    log.debug(\n      `Found ${response.identities.length} Identities: ${JSON.stringify(response)}`\n    );\n    return response.identities;\n  }\n\n  protected parseError(e: Error) {\n    const regexp = /.*code:\\s(\\d+).*?message:\\s[\"'](.+)[\"']/gs;\n    const match = regexp.exec(e.message);\n    if (!match) return new RegistrationError(e);\n    const [, code, message] = match;\n    switch (code) {\n      case \"74\":\n      case \"71\":\n        return new ConflictError(message);\n      case \"20\":\n        return new AuthorizationError(message);\n      default:\n        return new RegistrationError(message);\n    }\n  }\n\n  /**\n   * @description Retrieve affiliations from the CA.\n   * @summary Queries the CA for the list of affiliations available under the configured CA.\n   * @return {string} The affiliations result payload.\n   */\n  async getAffiliations() {\n    const affiliationService = await this.Affiliations();\n    const log = this.log.for(this.getAffiliations);\n    log.debug(`Retrieving Affiliations under CA ${this.caConfig.caName}`);\n    const response = (await affiliationService.getAll(await this.User()))\n      .result;\n    log.debug(\n      `Found ${response.a.length} Affiliations: ${JSON.stringify(response)}`\n    );\n    return response;\n  }\n\n  /**\n   * @description Read identity details from the CA by enrollment ID.\n   * @summary Retrieves and validates a single identity, throwing NotFoundError when missing.\n   * @param {string} enrollmentId - Enrollment ID to lookup.\n   * @return {Promise<FabricIdentity>} The identity details stored in the CA.\n   */\n  async read(enrollmentId: string) {\n    const ca = await this.CA();\n    const user = await this.User();\n    let result: IServiceResponse;\n    try {\n      result = await ca.newIdentityService().getOne(enrollmentId, user);\n    } catch (e: any) {\n      throw new NotFoundError(\n        `Couldn't find enrollment with id ${enrollmentId}: ${e}`\n      );\n    }\n\n    if (!result.success)\n      throw new NotFoundError(\n        `Couldn't find enrollment with id ${enrollmentId}: ${result.errors.join(\"\\n\")}`\n      );\n\n    return result.result as FabricIdentity;\n  }\n\n  /**\n   * @description Register a new identity with the CA.\n   * @summary Submits a registration request for a new enrollment ID, returning the enrollment secret upon success.\n   * @param {Credentials} model - Credentials containing userName and password for the new identity.\n   * @param {boolean} [isSuperUser=false] - Whether to register the identity as a super user.\n   * @param {string} [affiliation=\"\"] - Affiliation string (e.g., org1.department1).\n   * @param {CA_ROLE | string} [userRole] - Role to assign to the identity.\n   * @param {IKeyValueAttribute} [attrs] - Optional attributes to attach to the identity.\n   * @param {number} [maxEnrollments] - Maximum number of enrollments allowed for the identity.\n   * @return {Promise<string>} The enrollment secret for the registered identity.\n   */\n  async register(\n    model: Credentials,\n    isSuperUser: boolean = false,\n    affiliation: string = \"\",\n    userRole?: CA_ROLE | string,\n    attrs?: IKeyValueAttribute,\n    maxEnrollments?: number\n  ): Promise<string> {\n    let registration: string;\n    const log = this.log.for(this.register);\n    try {\n      const { userName, password } = model;\n      const ca = await this.CA();\n      const user = await this.User();\n      const props = {\n        enrollmentID: userName as string,\n        enrollmentSecret: password,\n        affiliation: affiliation,\n        userRole: userRole,\n        attrs: attrs,\n        maxEnrollments: maxEnrollments,\n      } as IRegisterRequest;\n      registration = await ca.register(props, user);\n      log.info(\n        `Registration for ${userName} created with user type ${userRole ?? \"Undefined Role\"} ${isSuperUser ? \"as super user\" : \"\"}`\n      );\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n    return registration;\n  }\n\n  protected static identityFromEnrollment(\n    enrollment: IEnrollResponse,\n    mspId: string\n  ): Identity {\n    const { certificate, key, rootCertificate } = enrollment;\n    const log = Logging.for(FabricEnrollmentService, {}).for(\n      this.identityFromEnrollment\n    );\n    log.debug(\n      `Generating Identity from certificate ${certificate} in msp ${mspId}`\n    );\n    const clientId = CryptoUtils.fabricIdFromCertificate(certificate);\n    const id = CryptoUtils.encode(clientId);\n    log.debug(`Identity ${clientId} and encodedId ${id}`);\n    const now = new Date();\n    return new Identity({\n      id: id,\n      credentials: {\n        id: id,\n        certificate: certificate,\n        privateKey: key.toBytes(),\n        rootCertificate: rootCertificate,\n        createdOn: now,\n        updatedOn: now,\n      },\n      mspId: mspId,\n      createdOn: now,\n      updatedOn: now,\n    });\n  }\n\n  /**\n   * @description Enroll an identity with the CA using a registration secret.\n   * @summary Exchanges the enrollment ID and secret for certificates, returning a constructed Identity model.\n   * @param {string} enrollmentId - Enrollment ID to enroll.\n   * @param {string} registration - Enrollment secret returned at registration time.\n   * @return {Promise<Identity>} The enrolled identity object with credentials.\n   */\n  async enroll(enrollmentId: string, registration: string) {\n    let identity: Identity;\n    const log = this.log.for(this.enroll);\n    try {\n      const ca = await this.CA();\n      log.debug(`Enrolling ${enrollmentId}`);\n      const enrollment: IEnrollResponse = await ca.enroll({\n        enrollmentID: enrollmentId,\n        enrollmentSecret: registration,\n      });\n      identity = FabricEnrollmentService.identityFromEnrollment(\n        enrollment,\n        this.caConfig.caName\n      );\n      log.info(\n        `Successfully enrolled ${enrollmentId} under ${this.caConfig.caName} as ${identity.id}`\n      );\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n    return identity;\n  }\n\n  /**\n   * @description Register and enroll a new identity in one step.\n   * @summary Registers a new enrollment ID with the CA and immediately exchanges the secret to enroll, returning the created Identity.\n   * @param {Credentials} model - Credentials for the new identity containing userName and password.\n   * @param {boolean} [isSuperUser=false] - Whether to register the identity as a super user.\n   * @param {string} [affiliation=\"\"] - Affiliation string (e.g., org1.department1).\n   * @param {CA_ROLE | string} [userRole] - Role to assign to the identity.\n   * @param {IKeyValueAttribute} [attrs] - Optional attributes to attach to the identity.\n   * @param {number} [maxEnrollments] - Maximum number of enrollments allowed for the identity.\n   * @return {Promise<Identity>} The enrolled identity.\n   */\n  async registerAndEnroll(\n    model: Credentials,\n    isSuperUser: boolean = false,\n    affiliation: string = \"\",\n    userRole?: CA_ROLE | string,\n    attrs?: IKeyValueAttribute,\n    maxEnrollments?: number\n  ): Promise<Identity> {\n    const registration = await this.register(\n      model,\n      isSuperUser,\n      affiliation,\n      userRole,\n      attrs,\n      maxEnrollments\n    );\n    const { userName } = model;\n    return this.enroll(userName as string, registration);\n  }\n\n  /**\n   * Revokes the enrollment of an identity with the specified enrollment ID.\n   *\n   * @param enrollmentId - The enrollment ID of the identity to be revoked.\n   *\n   * @returns A Promise that resolves to the result of the revocation operation.\n   *\n   * @throws {NotFoundError} If the enrollment with the specified ID does not exist.\n   * @throws {InternalError} If there is an error during the revocation process.\n   */\n  async revoke(enrollmentId: string) {\n    const ca = await this.CA();\n    const user = await this.User();\n    const identity = await this.read(enrollmentId);\n    if (!identity)\n      throw new NotFoundError(\n        `Could not find enrollment with id ${enrollmentId}`\n      );\n    let result: IServiceResponse;\n    try {\n      result = await ca.revoke(\n        { enrollmentID: identity.id, reason: \"User Deletation\" },\n        user\n      );\n    } catch (e: unknown) {\n      throw new InternalError(\n        `Could not revoke enrollment with id ${enrollmentId}: ${e}`\n      );\n    }\n    if (!result.success)\n      throw new InternalError(\n        `Could not revoke enrollment with id ${enrollmentId}: ${result.errors.join(\"\\n\")}`\n      );\n    return result;\n  }\n}\n","import { IRegisterRequest, IKeyValueAttribute } from \"fabric-ca-client\";\nimport { CA_ROLE } from \"./constants\";\nimport {\n  min,\n  minlength,\n  Model,\n  required,\n} from \"@decaf-ts/decorator-validation\";\nimport { ValidationError } from \"@decaf-ts/db-decorators\";\n\nexport class RegistrationRequestBuilder extends Model {\n  @required()\n  affiliation: string = \"\";\n  @minlength(1)\n  attrs?: IKeyValueAttribute[];\n  @required()\n  enrollmentID!: string;\n  @required()\n  enrollmentSecret!: string;\n  @min(0)\n  maxEnrollments?: number;\n  @required()\n  role!: string;\n\n  build(): IRegisterRequest {\n    const errs = this.hasErrors();\n    if (errs) throw new ValidationError(errs.toString());\n    const response: IRegisterRequest = {\n      enrollmentID: this.enrollmentID,\n      enrollmentSecret: this.enrollmentSecret,\n      role: this.role,\n      affiliation: this.affiliation,\n    };\n    if (typeof this.maxEnrollments !== \"undefined\")\n      response.maxEnrollments = this.maxEnrollments;\n    if (this.attrs) response.attrs = this.attrs;\n    return response;\n  }\n\n  setAffiliation(value: string) {\n    this.affiliation = value;\n    return this;\n  }\n\n  addAttr(attr: IKeyValueAttribute) {\n    this.attrs = this.attrs || [];\n    this.attrs.push(attr);\n    return this;\n  }\n\n  setAttrs(value: IKeyValueAttribute[]) {\n    this.attrs = value;\n    return this;\n  }\n\n  setEnrollmentID(value: string) {\n    this.enrollmentID = value;\n    return this;\n  }\n\n  setEnrollmentSecret(value: string) {\n    this.enrollmentSecret = value;\n    return this;\n  }\n\n  setMaxEnrollments(value: number) {\n    this.maxEnrollments = value;\n    return this;\n  }\n\n  setRole(value: CA_ROLE | string) {\n    this.role = value;\n    return this;\n  }\n}\n","/**\n * Enum representing the events emitted by an ERC20 contract.\n *\n * @remarks\n * This enum is used to identify the specific events that can be emitted by an ERC20 contract.\n * The events are named according to the EIP-20 standard.\n */\nexport enum ERC20Events {\n  /**\n   * Emitted when a `transfer` function is called successfully.\n   *\n   * @param from - The address of the sender.\n   * @param to - The address of the recipient.\n   * @param value - The amount of tokens transferred.\n   */\n  TRANSFER = \"Transfer\",\n\n  /**\n   * Emitted when an `approve` function is called successfully.\n   *\n   * @param owner - The address of the token owner.\n   * @param spender - The address of the approved spender.\n   * @param value - The amount of tokens approved for the spender.\n   */\n  APPROVAL = \"Approval\",\n}\n","import { Model, type ModelArg } from \"@decaf-ts/decorator-validation\";\nimport { column, createdAt, updatedAt } from \"@decaf-ts/core\";\nimport { version } from \"@decaf-ts/db-decorators\";\nimport { description, uses } from \"@decaf-ts/decoration\";\nimport { FabricFlavour } from \"../constants\";\n\n@uses(FabricFlavour)\nexport class FabricBaseModel extends Model {\n  @description(\"Stores the original timestamp of creation\")\n  @column()\n  @createdAt()\n  createdAt!: Date;\n\n  @description(\"Stores the timestamp of the last update\")\n  @column()\n  @updatedAt()\n  updatedAt!: Date;\n\n  @description(\"Stores the version of the model\")\n  @column()\n  @version()\n  version!: number;\n\n  constructor(arg?: ModelArg<FabricBaseModel>) {\n    super(arg);\n  }\n}\n","import { type ModelArg } from \"@decaf-ts/decorator-validation\";\nimport { column, createdBy, updatedBy } from \"@decaf-ts/core\";\nimport { description, uses } from \"@decaf-ts/decoration\";\nimport { FabricFlavour } from \"../constants\";\nimport { FabricBaseModel } from \"./FabricBaseModel\";\n\n@uses(FabricFlavour)\nexport abstract class FabricIdentifiedBaseModel extends FabricBaseModel {\n  @description(\"Stores the creator\")\n  @column()\n  @createdBy()\n  createdBy!: string;\n\n  @description(\"Stores the user that last updated the model\")\n  @column()\n  @updatedBy()\n  updatedBy!: string;\n\n  protected constructor(arg?: ModelArg<FabricIdentifiedBaseModel>) {\n    super(arg);\n  }\n}\n","import { Model } from \"@decaf-ts/decorator-validation\";\nimport { Constructor, Metadata } from \"@decaf-ts/decoration\";\nimport { FabricModelKeys } from \"../constants\";\nimport { SegregatedModel } from \"../types\";\nimport { DBKeys } from \"@decaf-ts/db-decorators\";\nimport { CollectionResolver, MirrorMetadata } from \"../decorators\";\n\nModel.prototype.isShared = function isShared<M extends Model>(\n  this: M\n): boolean {\n  return Model.isShared(this.constructor as Constructor<M>);\n};\n\nModel.prototype.isPrivate = function isPrivate<M extends Model>(\n  this: M\n): boolean {\n  return Model.isPrivate(this.constructor as Constructor<M>);\n};\n\nModel.prototype.segregate = function segregate<M extends Model>(\n  this: M\n): SegregatedModel<M> {\n  return Model.segregate(this);\n};\n\n(Model as any).segregate = function segregate<M extends Model>(\n  model: M\n): SegregatedModel<M> {\n  if (!Model.isTransient(model)) return { model: model };\n  const decoratedProperties =\n    Metadata.getAttributes(model.constructor as any) || [];\n\n  const transientProps = Metadata.get(\n    model.constructor as any,\n    DBKeys.TRANSIENT\n  );\n  const privateProperties = Metadata.get(\n    model.constructor as any,\n    FabricModelKeys.PRIVATE\n  );\n  const sharedProperties = Metadata.get(\n    model.constructor as any,\n    FabricModelKeys.SHARED\n  );\n\n  const result: SegregatedModel<M> = {\n    model: {} as Record<keyof M, any>,\n    public: {} as Record<keyof M, any>,\n    transient: {} as Record<keyof M, any>,\n    privates: {} as Record<keyof M, any>,\n    shared: {} as Record<keyof M, any>,\n  };\n\n  const transientKeys = Object.keys(transientProps || {});\n  const privateKeys = Object.keys(privateProperties || {});\n  const sharedKeys = Object.keys(sharedProperties || {});\n\n  // const pkKey = Model.pk(model.constructor as any);\n  for (const key of decoratedProperties) {\n    const value = model[key as keyof M];\n    const isTransient = transientKeys.includes(key);\n    const isPublic = !isTransient;\n    const isPrivate = privateKeys.includes(key);\n    const isShared = sharedKeys.includes(key);\n    // const isPrimaryKey = key === pkKey;\n\n    if (isTransient || isPrivate || isShared) {\n      result.transient = result.transient || ({} as any);\n      (result.transient as any)[key] = value;\n    }\n    if (isPrivate) {\n      result.privates = result.privates || ({} as any);\n      (result.privates as any)[key] = value;\n    }\n    if (isShared) {\n      result.shared = result.shared || ({} as any);\n      (result.shared as any)[key] = value;\n    }\n    if (isPublic) {\n      result.public = (result.public || {}) as any;\n      (result.public as any)[key] = value;\n    }\n  }\n\n  result.model = Model.build(result.public, model.constructor.name);\n  return result as SegregatedModel<M>;\n}.bind(Model);\n\n(Model as any).isPrivate = function isPrivate<M extends Model>(\n  model: M | Constructor<M>\n): boolean {\n  return !!Metadata.get(\n    typeof model !== \"function\" ? (model.constructor as any) : model,\n    FabricModelKeys.PRIVATE\n  );\n}.bind(Model);\n\n(Model as any).isShared = function isShared<M extends Model>(\n  model: M | Constructor<M>\n): boolean {\n  return !!Metadata.get(\n    typeof model !== \"function\" ? (model.constructor as any) : model,\n    FabricModelKeys.SHARED\n  );\n}.bind(Model);\n\n(Model as any).mirrored = function mirrored<M extends Model>(\n  model: M | Constructor<M>\n): boolean {\n  return Metadata.get(\n    typeof model !== \"function\" ? (model.constructor as any) : model,\n    Metadata.key(FabricModelKeys.FABRIC, FabricModelKeys.MIRROR)\n  );\n}.bind(Model);\n\n(Model as any).ownerOf = function ownerOf<M extends Model>(\n  model: M\n): string | undefined {\n  const meta = Metadata.get(\n    model.constructor as any,\n    Metadata.key(FabricModelKeys.FABRIC, FabricModelKeys.OWNED_BY)\n  );\n  if (!meta) return undefined;\n  return model[meta as keyof M] as string;\n}.bind(Model);\n\n(Model as any).mirroredAt = function mirroredAt<M extends Model>(\n  model: M | Constructor<M>\n): MirrorMetadata | undefined {\n  model = typeof model !== \"function\" ? (model.constructor as any) : model;\n  return Metadata.get(\n    model as any,\n    Metadata.key(FabricModelKeys.FABRIC, FabricModelKeys.MIRROR)\n  );\n}.bind(Model);\n\n(Model as any).collectionsFor = function collectionsFor<M extends Model>(\n  model: M | Constructor<M>\n): {\n  privateCols: (string | CollectionResolver)[];\n  sharedCols: (string | CollectionResolver)[];\n} {\n  const privateKeys: string[] = [FabricModelKeys.PRIVATE] as string[];\n  const sharedKeys: string[] = [FabricModelKeys.SHARED] as string[];\n\n  const privateKey = Metadata.key(...privateKeys);\n  const sharedKey = Metadata.key(...sharedKeys);\n\n  const constr = typeof model === \"function\" ? model : model.constructor;\n\n  const privateMeta: { collections: string[] } = Metadata.get(\n    constr as any,\n    privateKey\n  );\n  const sharedMeta: { collections: string[] } = Metadata.get(\n    constr as any,\n    sharedKey\n  );\n\n  return {\n    privateCols: privateMeta?.collections || [],\n    sharedCols: sharedMeta?.collections || [],\n  };\n}.bind(Model);\n","import {\n  AuthorizationError,\n  Repo,\n  Context,\n  UnsupportedError,\n  Repository,\n  ContextOf,\n} from \"@decaf-ts/core\";\nimport {\n  generated,\n  InternalError,\n  NotFoundError,\n  onCreate,\n  onDelete,\n  onRead,\n  onUpdate,\n  readonly,\n  transient,\n  ValidationError,\n  DBKeys,\n  DBOperations,\n  on,\n} from \"@decaf-ts/db-decorators\";\nimport { Model, required } from \"@decaf-ts/decorator-validation\";\nimport { FabricModelKeys } from \"./constants\";\nimport type { Context as HLContext } from \"fabric-contract-api\";\nimport { ClientIdentity } from \"fabric-shim-api\";\nimport { FabricERC20Contract } from \"../contracts/erc20/erc20contract\";\nimport {\n  apply,\n  Constructor,\n  Decoration,\n  metadata,\n  Metadata,\n  prop,\n  propMetadata,\n} from \"@decaf-ts/decoration\";\nimport { FabricFlags } from \"./types\";\nimport { toPascalCase } from \"@decaf-ts/logging\";\nimport { FabricContractFlags } from \"../contracts/types\";\nimport \"../shared/overrides\";\nimport { type FabricContractContext } from \"../contracts/ContractContext\";\n\n/**\n * @description Extracts the MSP ID from either a string or ClientIdentity object\n * @param identity - The identity value which can be a string MSP ID or ClientIdentity object\n * @returns The MSP ID as a string, or undefined if not available\n */\nexport function extractMspId(\n  identity: string | ClientIdentity | undefined\n): string | undefined {\n  if (!identity) return undefined;\n  if (typeof identity === \"string\") return identity;\n  return identity.getMSPID();\n}\n\n/**\n * Decorator for marking methods that require ownership authorization.\n * Checks the owner of the token before allowing the method to be executed.\n *\n * @example\n * ```typescript\n * class TokenContract extends Contract {\n *   @Owner()\n *   async Mint(ctx: Context, amount: number) {\n *     // Mint token logic\n *   }\n * }\n * ```\n *\n * @returns {MethodDecorator} A method decorator that checks ownership authorization.\n */\nexport function Owner() {\n  return function (\n    target: any,\n    propertyKey: string,\n    descriptor: PropertyDescriptor\n  ) {\n    const originalMethod = descriptor.value;\n\n    descriptor.value = async function (\n      this: FabricERC20Contract,\n      ...args: any[]\n    ) {\n      const ctx: HLContext = args[0];\n      const acountId = ctx.clientIdentity.getID();\n\n      const select = await (this as FabricERC20Contract)[\n        \"tokenRepository\"\n      ].select();\n\n      const tokens = await select.execute(ctx);\n\n      if (tokens.length == 0) {\n        throw new NotFoundError(\"No tokens avaialble\");\n      }\n\n      if (tokens.length > 1) {\n        throw new NotFoundError(`To many token available : ${tokens.length}`);\n      }\n\n      if (tokens[0].owner != acountId) {\n        throw new AuthorizationError(\n          `User not authorized to run ${propertyKey} on the token`\n        );\n      }\n\n      return await originalMethod.apply(this, args);\n    };\n\n    return descriptor;\n  };\n}\n\nexport async function ownedByOnCreate<\n  M extends Model<boolean>,\n  R extends Repo<M>,\n  V,\n>(\n  this: R,\n  context: ContextOf<R>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const { stub } = context as any;\n\n  const creator = await stub.getCreator();\n  const owner = creator.mspid;\n\n  const setOwnedByKeyValue = function <M extends Model>(\n    target: M,\n    propertyKey: string,\n    value: string | number | bigint\n  ) {\n    Object.defineProperty(target, propertyKey, {\n      enumerable: true,\n      writable: false,\n      configurable: true,\n      value: value,\n    });\n  };\n\n  setOwnedByKeyValue(model, key as string, owner);\n}\n\nexport function ownedBy() {\n  function ownedBy() {\n    return function (obj: any, attribute?: any) {\n      return apply(\n        required(),\n        generated(),\n        readonly(),\n        onCreate(ownedByOnCreate),\n        propMetadata(\n          Metadata.key(FabricModelKeys.FABRIC, FabricModelKeys.OWNED_BY),\n          attribute\n        )\n      )(obj, attribute);\n    };\n  }\n\n  return Decoration.for(FabricModelKeys.OWNED_BY)\n    .define({\n      decorator: ownedBy,\n      args: [],\n    })\n    .apply();\n}\n\nexport async function transactionIdOnCreate<\n  M extends Model<boolean>,\n  R extends Repo<M>,\n  V,\n>(\n  this: R,\n  context: ContextOf<R>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const { stub } = context as any;\n  model[key] = stub.getTxID();\n}\n\nexport function transactionId() {\n  function transactionId() {\n    return function (obj: any, attribute?: any) {\n      return apply(\n        required(),\n        readonly(),\n        onCreate(transactionIdOnCreate),\n        onUpdate(transactionIdOnCreate),\n        propMetadata(\n          Metadata.key(\n            FabricModelKeys.FABRIC,\n            attribute,\n            FabricModelKeys.TRANSACTION_ID\n          ),\n          attribute\n        )\n      )(obj, attribute);\n    };\n  }\n\n  return Decoration.for(FabricModelKeys.TRANSACTION_ID)\n    .define({\n      decorator: transactionId,\n      args: [],\n    })\n    .apply();\n}\n\nexport type MirrorCondition = (msp: string) => boolean;\n\nexport type MirrorMetadata = {\n  condition?: MirrorCondition;\n  resolver: CollectionResolver | string;\n  mspId: string;\n};\n\nexport async function evalMirrorMetadata<M extends Model>(\n  model: M,\n  resolver: undefined | string | CollectionResolver,\n  ctx: Context<FabricContractFlags>\n) {\n  let collection: CollectionResolver | string | undefined = resolver;\n  if (typeof collection !== \"string\") {\n    try {\n      const owner =\n        Model.ownerOf(model) || ctx.get(\"stub\").getCreator().toString();\n      if (resolver && typeof resolver === \"function\")\n        collection = await resolver(model, owner, ctx);\n    } catch (e: unknown) {\n      throw new InternalError(`Failed to resolve collection mirror name: ${e}`);\n    }\n  }\n\n  if (!collection || typeof collection !== \"string\")\n    throw new InternalError(\n      `No collection found model ${model.constructor.name}`\n    );\n  return collection;\n}\n\nexport async function createMirrorHandler<\n  M extends Model,\n  R extends Repository<M, any>,\n>(\n  this: R,\n  context: Context<FabricContractFlags>,\n  data: MirrorMetadata,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const collection = await evalMirrorMetadata(model, data.resolver, context);\n  const fabricCtx = context as FabricContractContext;\n  const sourceModel = model;\n  // Put mirror flags directly on context so adapter.prepare() and adapter.create() can see them\n  fabricCtx.put(\"mirror\" as any, true);\n  fabricCtx.put(\"mirrorCollection\" as any, collection);\n  try {\n    const repo = this.override(\n      Object.assign({}, (this as any)._overrides, {\n        mirror: true,\n        mirrorCollection: collection,\n        ignoreValidation: true,\n        ignoreHandlers: true,\n      } as any)\n    );\n    const mirror = await repo.create(sourceModel, context);\n    context.logger.info(\n      `Mirror for ${Model.tableName(this.class)} created with ${Model.pk(model) as string}: ${mirror[Model.pk(model)]}`\n    );\n  } finally {\n    // Clean up mirror flags from context\n    fabricCtx.put(\"mirror\" as any, undefined);\n    fabricCtx.put(\"mirrorCollection\" as any, undefined);\n  }\n}\n\nexport async function updateMirrorHandler<\n  M extends Model,\n  R extends Repository<M, any>,\n>(\n  this: R,\n  context: Context<FabricContractFlags>,\n  data: MirrorMetadata,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const collection = await evalMirrorMetadata(model, data.resolver, context);\n  const fabricCtx = context as FabricContractContext;\n  const sourceModel = model;\n  fabricCtx.put(\"mirror\" as any, true);\n  fabricCtx.put(\"mirrorCollection\" as any, collection);\n  try {\n    const repo = this.override(\n      Object.assign({}, (this as any)._overrides, {\n        mirror: true,\n        mirrorCollection: collection,\n        ignoreValidation: true,\n        ignoreHandlers: true,\n        applyUpdateValidation: false,\n        mergeForUpdate: false,\n      } as any)\n    );\n    await repo.update(sourceModel, context);\n    context.logger.info(\n      `Mirror for ${Model.tableName(this.class)} updated: ${(model as any)[Model.pk(model)]}`\n    );\n  } finally {\n    fabricCtx.put(\"mirror\" as any, undefined);\n    fabricCtx.put(\"mirrorCollection\" as any, undefined);\n  }\n}\n\nexport async function deleteMirrorHandler<\n  M extends Model,\n  R extends Repository<M, any>,\n>(\n  this: R,\n  context: Context<FabricContractFlags>,\n  data: MirrorMetadata,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const collection = await evalMirrorMetadata(model, data.resolver, context);\n  const fabricCtx = context as FabricContractContext;\n  fabricCtx.put(\"mirror\" as any, true);\n  fabricCtx.put(\"mirrorCollection\" as any, collection);\n  fabricCtx.put(\"segregated\" as any, collection);\n  try {\n    const pkProp = Model.pk(model) as keyof M;\n    const id = model[pkProp];\n    const repo = this.override(\n      Object.assign({}, (this as any)._overrides, {\n        segregated: collection,\n        mirror: true,\n        ignoreValidation: true,\n        ignoreHandlers: true,\n      } as any)\n    );\n    try {\n      await repo.delete(id as any, context);\n    } catch {\n      // May already be deleted by adapter.deleteSegregatedCollections\n    }\n    context.logger.info(\n      `Mirror for ${Model.tableName(this.class)} deleted: ${String(id)}`\n    );\n  } finally {\n    fabricCtx.put(\"mirror\" as any, undefined);\n    fabricCtx.put(\"mirrorCollection\" as any, undefined);\n    fabricCtx.put(\"segregated\" as any, undefined);\n  }\n}\n\nexport async function mirrorWriteGuard<\n  M extends Model,\n  R extends Repository<M, any>,\n>(\n  this: R,\n  context: Context<FabricContractFlags>,\n  data: MirrorMetadata,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  key: keyof M,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  model: M\n): Promise<void> {\n  const msp = extractMspId(\n    context.get(\"identity\") as string | ClientIdentity | undefined\n  );\n  if (!msp) return;\n  if (msp === data.mspId || (data.condition && data.condition(msp))) {\n    throw new AuthorizationError(\n      `Organization ${msp} is not authorized to modify mirrored data`\n    );\n  }\n}\n\nexport async function readMirrorHandler<\n  M extends Model,\n  R extends Repository<M, any>,\n>(\n  this: R,\n  context: Context<FabricContractFlags>,\n  data: MirrorMetadata,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const msp = extractMspId(\n    context.get(\"identity\") as string | ClientIdentity | undefined\n  );\n\n  if (!msp) return;\n\n  const collection = await evalMirrorMetadata(model, data.resolver, context);\n  const fabricCtx = context as FabricContractContext;\n  const matches = msp === data.mspId || (data.condition && data.condition(msp));\n\n  if (matches) {\n    context.logger.info(\n      `Mirror read: MSP ${msp} matches, routing reads to mirror collection ${collection}`\n    );\n    // Route reads exclusively through the mirror collection\n    fabricCtx.put(\"mirror\" as any, true);\n    fabricCtx.put(\"mirrorCollection\" as any, collection);\n    fabricCtx.put(\"fullySegregated\", true);\n    fabricCtx.readFrom(collection);\n  }\n  // When MSP does NOT match, normal read flow — all data is in public state\n}\n\nexport function mirror(\n  collection: CollectionResolver | string,\n  mspIdOrCondition?: string | MirrorCondition,\n  condition?: MirrorCondition\n) {\n  const isConditionOnly =\n    typeof mspIdOrCondition !== \"string\" && Boolean(mspIdOrCondition);\n  const mspId = isConditionOnly\n    ? undefined\n    : (mspIdOrCondition as string | undefined);\n  const cond = isConditionOnly\n    ? (mspIdOrCondition as MirrorCondition)\n    : condition;\n\n  function mirror(\n    resolver: CollectionResolver | string,\n    mspId: string,\n    condition?: MirrorCondition\n  ) {\n    const meta: MirrorMetadata = {\n      condition: condition,\n      mspId: mspId,\n      resolver: resolver,\n    };\n    return apply(\n      metadata(\n        Metadata.key(FabricModelKeys.FABRIC, FabricModelKeys.MIRROR),\n        meta\n      ),\n      // Read handler runs early (priority 30) to set up context before any reads\n      onRead(readMirrorHandler as any, meta, { priority: 30 }),\n      // Write guards — reject matching MSPs before any processing\n      onCreate(mirrorWriteGuard as any, meta, { priority: 20 }),\n      onUpdate(mirrorWriteGuard as any, meta, { priority: 20 }),\n      onDelete(mirrorWriteGuard as any, meta, { priority: 20 }),\n      // Mirror sync handlers — write full model after other handlers (priority 100)\n      onCreate(createMirrorHandler as any, meta, { priority: 100 }),\n      onUpdate(updateMirrorHandler as any, meta, { priority: 100 }),\n      onDelete(deleteMirrorHandler as any, meta, { priority: 100 })\n    );\n  }\n\n  return Decoration.for(FabricModelKeys.MIRROR)\n    .define({\n      decorator: mirror,\n      args: [collection, mspId, cond],\n    })\n    .apply();\n}\n\nexport type CollectionResolver = <M extends Model>(\n  model: M | Constructor<M>,\n  msp?: string,\n  ...args: any[]\n) => string;\n\nexport const ModelCollection: CollectionResolver = <M extends Model>(\n  model: M | Constructor<M>,\n  mspId?: string\n) => {\n  const orgName =\n    mspId || (typeof model !== \"function\" ? Model.ownerOf(model) : undefined);\n  const constr = typeof model === \"function\" ? model : model.constructor;\n  if (!orgName)\n    throw new InternalError(\n      `Model ${constr.name} is not owned by any organization. did you use @ownedBy() (or provide the name)?`\n    );\n  return `${toPascalCase(constr.name)}${orgName ? toPascalCase(orgName) : \"\"}`;\n};\n\nexport function NamespaceCollection(namespace: string): CollectionResolver {\n  return <M extends Model>(model: M | Constructor<M>, mspId?: string) => {\n    const orgName =\n      mspId || (typeof model !== \"function\" ? Model.ownerOf(model) : undefined);\n    const constr = typeof model === \"function\" ? model : model.constructor;\n    if (!orgName)\n      throw new InternalError(\n        `Model ${constr.name} is not owned by any organization. did you use @ownedBy() (or provide the name)?`\n      );\n    return `${namespace}${orgName ? toPascalCase(orgName) : \"\"}`;\n  };\n}\n\nexport const ImplicitPrivateCollection: CollectionResolver = <M extends Model>(\n  model: M | Constructor<M>,\n  mspId?: string\n) => {\n  const orgName =\n    mspId || (typeof model !== \"function\" ? Model.ownerOf(model) : undefined);\n  if (!orgName)\n    throw new InternalError(\n      `Model ${model.constructor.name} is not owned by any organization. did you use @ownedBy() (or provide the name)?`\n    );\n  return `__${toPascalCase(orgName)}PrivateCollection`;\n};\n\nexport type SegregatedDataMetadata = {\n  collections: string | CollectionResolver;\n};\n\n/**\n * @description Priority for early collection extraction (before pk generation at priority 60)\n * @summary This priority ensures collections are registered in context before any sequence\n * operations occur, allowing sequences to be replicated to private/shared collections.\n */\nexport const SEGREGATED_COLLECTION_EXTRACTION_PRIORITY = 35;\n\nexport function applySegregationFlags<M extends Model>(\n  clazz: M,\n  collections: string[],\n  ctx: any\n) {\n  // Register collections early using readFrom - this allows sequence code\n  // to know which collections to replicate to during pk generation\n  if (collections.length > 0) {\n    (ctx as FabricContractContext).readFrom(collections);\n  }\n\n  // Check if model is fully segregated (all non-pk properties are private/shared/transient).\n  // Use Model.segregate() which is the canonical way to determine what's transient,\n  // rather than reading DBKeys.TRANSIENT metadata which may not accumulate correctly\n  // when class-level @privateData applies decorators iteratively.\n  if (!ctx.isFullySegregated && collections.length) {\n    if (!hasPublicProperties(clazz.constructor as Constructor<M>)) {\n      ctx.markFullySegregated();\n    }\n  }\n}\n\nexport async function applyMirrorFlags<M extends Model>(\n  clazz: Constructor<M>,\n  msp: string | undefined,\n  ctx: FabricContractContext\n) {\n  if (!msp) return;\n  const mirrorMeta = Model.mirroredAt(clazz);\n  if (!mirrorMeta) return;\n  const matches =\n    msp === mirrorMeta.mspId ||\n    (mirrorMeta.condition && mirrorMeta.condition(msp));\n  if (!matches) return;\n  const collection = await evalMirrorMetadata(\n    new clazz(),\n    mirrorMeta.resolver,\n    ctx\n  );\n  // Mirror MSP matches — route reads exclusively through the mirror\n  // collection. Clear any previously registered collections so queries\n  // go ONLY to the mirror, not to the regular private/shared ones.\n  ctx.put(\"segregateRead\", undefined);\n  ctx.put(\"segregateReadStack\", undefined);\n  ctx.put(\"fullySegregated\", true);\n  ctx.put(\"mirror\" as any, true);\n  ctx.put(\"mirrorCollection\" as any, collection);\n  ctx.readFrom(collection);\n}\n\nfunction hasPublicProperties<M extends Model>(clazz: Constructor<M>): boolean {\n  const attributes = Metadata.getAttributes(clazz) || [];\n  const pk = Model.pk(clazz);\n  const transientMeta = Metadata.get(clazz as any, DBKeys.TRANSIENT) || {};\n  const privateMeta =\n    Metadata.get(clazz as any, Metadata.key(FabricModelKeys.PRIVATE)) || {};\n  const sharedMeta =\n    Metadata.get(clazz as any, Metadata.key(FabricModelKeys.SHARED)) || {};\n\n  return attributes.some((attr) => {\n    if (attr === pk) return false;\n    if (attr in transientMeta) return false;\n    if (attr in privateMeta) return false;\n    if (attr in sharedMeta) return false;\n    return true;\n  });\n}\n\n/**\n * @description Early handler to extract and register collections in context\n * @summary Runs with priority < 40 to extract collection names before pk generation (priority 60).\n * This allows FabricContractSequence to know which collections to replicate to.\n * @template M - Type that extends Model\n * @param {ContextOf<Repository<M, any>>} context - The execution context\n * @param {SegregatedDataMetadata | SegregatedDataMetadata[]} data - The segregated data metadata\n * @param {string | string[]} keys - The property key(s) being segregated\n * @param {M} model - The model instance\n * @return {Promise<void>}\n */\nexport async function extractSegregatedCollections<M extends Model>(\n  this: Repository<M, any>,\n  context: ContextOf<typeof this>,\n  data: SegregatedDataMetadata | SegregatedDataMetadata[],\n  keys: keyof M | (keyof M)[],\n  model: M\n): Promise<void> {\n  const dataArray = (\n    Array.isArray(data) ? data : [data]\n  ) as SegregatedDataMetadata[];\n\n  const msp =\n    Model.ownerOf(model) ||\n    extractMspId(\n      context.get(\"identity\") as string | ClientIdentity | undefined\n    );\n  if (!msp) {\n    // Can't extract collections without MSP, will be caught by later handlers\n    return;\n  }\n\n  const collections: string[] = [];\n  for (const metadata of dataArray) {\n    const collectionResolver = metadata.collections;\n    const collection =\n      typeof collectionResolver === \"string\"\n        ? collectionResolver\n        : collectionResolver(model, msp, context);\n    if (collection && !collections.includes(collection)) {\n      collections.push(collection);\n    }\n  }\n  applySegregationFlags(model, collections, context);\n\n  // Store segregation metadata on the adapter (persists across context chains).\n  // The Sequence creates its own context via logCtx, losing context-stored flags.\n  const seqName = Model.sequenceName(model, \"pk\");\n  (context as any).setSequenceSegregation(\n    seqName,\n    (context as any).isFullySegregated,\n    collections\n  );\n}\n\nexport async function segregatedDataOnCreate<M extends Model>(\n  this: Repository<M, any>,\n  context: ContextOf<typeof this>,\n  data: SegregatedDataMetadata | SegregatedDataMetadata[],\n  keys: keyof M | (keyof M)[],\n  model: M\n): Promise<void> {\n  const dataArray = (\n    Array.isArray(data) ? data : [data]\n  ) as SegregatedDataMetadata[];\n  const keyArray = (Array.isArray(keys) ? keys : [keys]) as (keyof M)[];\n  if (keyArray.length !== dataArray.length)\n    throw new InternalError(\n      `Segregated data keys and metadata length mismatch`\n    );\n\n  const msp =\n    Model.ownerOf(model) ||\n    extractMspId(\n      context.get(\"identity\") as string | ClientIdentity | undefined\n    );\n  if (!msp)\n    throw new ValidationError(\n      `There's no assigned organization for model ${model.constructor.name}`\n    );\n\n  const collectionResolver = dataArray[0].collections;\n  const collection =\n    typeof collectionResolver === \"string\"\n      ? collectionResolver\n      : collectionResolver(model, msp, context);\n\n  // Validate all keys resolve to the same collection\n  keyArray.forEach((_k, i) => {\n    const c =\n      typeof dataArray[i].collections === \"string\"\n        ? dataArray[i].collections\n        : dataArray[i].collections(model, msp, context);\n    if (c !== collection)\n      throw new UnsupportedError(\n        `Segregated data collection mismatch: ${c} vs ${collection}`\n      );\n  });\n\n  const keyStrings = keyArray.map((key) => String(key));\n  // Store the segregated model — prepare() will filter to collection-specific fields\n  (context as FabricContractContext).writeTo(collection, keyStrings);\n}\n\nexport async function segregatedDataOnRead<M extends Model>(\n  this: Repository<M, any>,\n  context: Context<FabricFlags>,\n  data: SegregatedDataMetadata | SegregatedDataMetadata[],\n  keys: keyof M | (keyof M)[],\n  model: M\n): Promise<void> {\n  const dataArray = (\n    Array.isArray(data) ? data : [data]\n  ) as SegregatedDataMetadata[];\n  const keyArray = (Array.isArray(keys) ? keys : [keys]) as (keyof M)[];\n  if (keyArray.length !== dataArray.length)\n    throw new InternalError(\n      `Segregated data keys and metadata length mismatch`\n    );\n\n  const msp = Model.ownerOf(model) || extractMspId(context.get(\"identity\"));\n  if (!msp)\n    throw new ValidationError(\n      `There's no assigned organization for model ${model.constructor.name}`\n    );\n\n  const collectionResolver = dataArray[0].collections;\n  const collection =\n    typeof collectionResolver === \"string\"\n      ? collectionResolver\n      : await collectionResolver(model, msp, context);\n\n  (context as FabricContractContext).readFrom(collection);\n}\n\nexport async function segregatedDataOnUpdate<M extends Model>(\n  this: Repository<M, any>,\n  context: ContextOf<typeof this>,\n  data: SegregatedDataMetadata | SegregatedDataMetadata[],\n  key: keyof M | (keyof M)[],\n  model: M,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  oldModel: M\n): Promise<void> {\n  const dataArray = (\n    Array.isArray(data) ? data : [data]\n  ) as SegregatedDataMetadata[];\n  const keyArray = (Array.isArray(key) ? key : [key]) as (keyof M)[];\n  if (keyArray.length !== dataArray.length)\n    throw new InternalError(\n      `Segregated data keys and metadata length mismatch`\n    );\n\n  const msp =\n    Model.ownerOf(model) ||\n    extractMspId(\n      context.get(\"identity\") as string | ClientIdentity | undefined\n    );\n  if (!msp)\n    throw new ValidationError(\n      `There's no assigned organization for model ${model.constructor.name}`\n    );\n\n  const collectionResolver = dataArray[0].collections;\n  const collection =\n    typeof collectionResolver === \"string\"\n      ? collectionResolver\n      : collectionResolver(model, msp, context);\n\n  keyArray.forEach((k, i) => {\n    const c =\n      typeof dataArray[i].collections === \"string\"\n        ? dataArray[i].collections\n        : dataArray[i].collections(model, msp, context);\n    if (c !== collection)\n      throw new UnsupportedError(\n        `Segregated data collection mismatch: ${c} vs ${collection}`\n      );\n  });\n\n  const keyStrings = (keyArray as (keyof M)[]).map((key) => String(key));\n  // Store the original model — prepare() will filter to collection-specific fields\n  (context as FabricContractContext).writeTo(collection, keyStrings);\n}\n\nexport async function segregatedDataOnDelete<\n  M extends Model,\n  R extends Repository<M, any>,\n  V extends SegregatedDataMetadata,\n>(\n  this: R,\n  context: ContextOf<R>,\n  data: V | V[],\n  key: (keyof M)[],\n  model: M\n): Promise<void> {\n  const dataArray = (Array.isArray(data) ? data : [data]) as V[];\n  const keyArray = (Array.isArray(key) ? key : [key]) as (keyof M)[];\n  if (keyArray.length !== dataArray.length)\n    throw new InternalError(\n      `Segregated data keys and metadata length mismatch`\n    );\n\n  const msp =\n    Model.ownerOf(model) ||\n    extractMspId(\n      context.get(\"identity\") as string | ClientIdentity | undefined\n    );\n  if (!msp)\n    throw new ValidationError(\n      `There's no assigned organization for model ${model.constructor.name}`\n    );\n\n  const collectionResolver = dataArray[0].collections;\n  const collection =\n    typeof collectionResolver === \"string\"\n      ? collectionResolver\n      : collectionResolver(model, msp, context);\n\n  (context as FabricContractContext).readFrom(collection);\n}\n\nfunction segregated(\n  collection: string | CollectionResolver,\n  type: FabricModelKeys.PRIVATE | FabricModelKeys.SHARED,\n  filter?: (propName: string) => boolean\n) {\n  return function innerSegregated(target: object, propertyKey?: any) {\n    function segregatedDec(target: object, propertyKey?: any) {\n      const key = Metadata.key(type, propertyKey);\n      const constr: Constructor = target.constructor as Constructor;\n\n      const meta = Metadata.get(constr as Constructor, key) || {};\n      const collections = new Set(meta.collections || []);\n      collections.add(collection);\n      meta.collections = [...collections];\n      Metadata.set(constr as Constructor, key, meta);\n\n      const constrMeta = Metadata.get(constr as Constructor, type) || {};\n      const constrCollections = new Set(constrMeta.collections || []);\n      constrCollections.add(collection);\n      constrMeta.collections = [...constrCollections];\n      Metadata.set(constr as Constructor, type, constrMeta);\n\n      const transientMeta =\n        Metadata.get(constr as Constructor, DBKeys.TRANSIENT) || {};\n      const updatedTransientMeta = {\n        ...transientMeta,\n        [propertyKey as any]: {},\n      };\n      Metadata.set(\n        constr as Constructor,\n        DBKeys.TRANSIENT,\n        updatedTransientMeta\n      );\n    }\n\n    const decs: any[] = [];\n    if (!propertyKey) {\n      // decorated at the class level\n      const properties = Metadata.getAttributes(target as Constructor);\n      properties?.forEach((p) => {\n        if (!filter || filter(p)) {\n          segregated(collection, type)((target as any).prototype, p);\n        }\n      });\n      return target;\n    } else {\n      const groupName =\n        typeof collection === \"string\" ? collection : collection.toString();\n      // Use different group names for extraction vs data handlers to prevent merging\n      const extractGroupName = `${groupName}:extract`;\n      const dataGroupName = `${groupName}:data`;\n      const earlyExtractionMeta = { collections: collection };\n      const earlyExtractionGroupSort = {\n        priority: SEGREGATED_COLLECTION_EXTRACTION_PRIORITY,\n        group: extractGroupName,\n      };\n      decs.push(\n        prop(),\n        transient(),\n        segregatedDec,\n        // Early extraction handlers - run BEFORE pk generation (priority 60)\n        // This ensures collections are registered in context for sequence replication\n        // We register for each operation explicitly to ensure proper handler lookup\n        on(\n          DBOperations.ALL,\n          extractSegregatedCollections as any,\n          earlyExtractionMeta,\n          earlyExtractionGroupSort\n        ),\n        // Main handlers for segregated data operations (priority 95)\n        onCreate(\n          segregatedDataOnCreate,\n          { collections: collection },\n          {\n            priority: 95,\n            group: dataGroupName,\n          }\n        ),\n        onRead(\n          segregatedDataOnRead as any,\n          { collections: collection },\n          {\n            priority: 95,\n            group: dataGroupName,\n          }\n        ),\n        onUpdate(\n          segregatedDataOnUpdate as any,\n          { collections: collection },\n          {\n            priority: 95,\n            group: dataGroupName,\n          }\n        ),\n        onDelete(\n          segregatedDataOnDelete as any,\n          { collections: collection },\n          {\n            priority: 95,\n            group: dataGroupName,\n          }\n        )\n      );\n    }\n    return apply(...decs)(target, propertyKey);\n  };\n}\n\nexport function privateData(\n  collection: string | CollectionResolver = ImplicitPrivateCollection\n) {\n  function privateData(collection: string | CollectionResolver) {\n    return segregated(collection, FabricModelKeys.PRIVATE);\n  }\n\n  return Decoration.for(FabricModelKeys.PRIVATE)\n    .define({\n      decorator: privateData,\n      args: [collection],\n    })\n    .apply();\n}\n\nexport function sharedData(collection: string | CollectionResolver) {\n  function sharedData(collection: string | CollectionResolver) {\n    return segregated(collection, FabricModelKeys.SHARED);\n  }\n\n  return Decoration.for(FabricModelKeys.SHARED)\n    .define({\n      decorator: sharedData,\n      args: [collection],\n    })\n    .apply();\n}\n","/* eslint-disable @typescript-eslint/no-require-imports */\nimport { Constructor, Metadata } from \"@decaf-ts/decoration\";\nimport {\n  JSONSerializer,\n  Model,\n  ModelKeys,\n} from \"@decaf-ts/decorator-validation\";\n\n/**\n * @description Recursively sorts object keys without reordering arrays\n * @param {any} obj - The value to process\n * @return {any} A copy with sorted object keys but preserved array order\n */\nexport function sortKeysOnlyRecursive(obj: any): any {\n  if (obj === null || typeof obj !== \"object\") return obj;\n  if (Array.isArray(obj)) return obj.map(sortKeysOnlyRecursive);\n  if (obj.constructor !== Object) return obj;\n  return Object.keys(obj)\n    .sort()\n    .reduce((acc: Record<string, any>, key) => {\n      acc[key] = sortKeysOnlyRecursive(obj[key]);\n      return acc;\n    }, {});\n}\n\n/**\n * @description Deterministic JSON serializer for Fabric models\n * @summary Ensures stable, deterministic JSON output by sorting object keys recursively before stringification, which is important for Fabric endorsement and hashing. Extends JSONSerializer to plug into existing Decaf model serialization flow.\n * @template M - The Decaf Model subtype serialized by this instance\n * @param {void} [constructor] No public constructor arguments\n * @class DeterministicSerializer\n * @example\n * const serializer = new DeterministicSerializer<MyModel>();\n * const json = serializer.serialize(model);\n * const rebuilt = serializer.deserialize(json);\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant DS as DeterministicSerializer\n *   Caller->>DS: serialize(model)\n *   DS->>DS: preSerialize(model)\n *   DS->>DS: sort-keys-recursive\n *   DS->>DS: json-stringify-deterministic\n *   DS-->>Caller: string\n *   Caller->>DS: deserialize(string)\n *   DS-->>Caller: model\n */\nexport class DeterministicSerializer<\n  M extends Model,\n> extends JSONSerializer<M> {\n  constructor() {\n    super();\n  }\n  protected override preSerialize(model: M) {\n    // TODO: nested preserialization (so increase performance when deserializing)\n    // TODO: Verify why there is no metadata\n    const toSerialize: Record<string, any> = Object.assign({}, model);\n    let metadata;\n    try {\n      metadata = Metadata.modelName(model.constructor as Constructor);\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (error: unknown) {\n      metadata = undefined;\n    }\n    toSerialize[ModelKeys.ANCHOR] = metadata || model.constructor.name;\n\n    const preSerialize = function preSerialize(\n      this: DeterministicSerializer<any>,\n      obj: any\n    ): any {\n      // eslint-disable-next-line @typescript-eslint/no-this-alias\n      const self = this;\n      if (typeof obj !== \"object\") return obj;\n      if (Array.isArray(obj)) return obj.map((o) => preSerialize.call(self, o));\n      return this.preSerialize.call(this, obj);\n    }.bind(this);\n\n    Model.relations(model).forEach((r) => {\n      toSerialize[r] = preSerialize(toSerialize[r]);\n    });\n    return toSerialize;\n  }\n\n  /**\n   * @summary Rebuilds a model from a serialization\n   * @param {string} str\n   *\n   * @throws {Error} If it fails to parse the string, or to build the model\n   */\n  override deserialize(str: string): M {\n    const deserialization = JSON.parse(str);\n    const className = deserialization[ModelKeys.ANCHOR];\n    if (!className)\n      throw new Error(\"Could not find class reference in serialized model\");\n    const model: M = Model.build(deserialization, className) as unknown as M;\n    return model;\n  }\n\n  /**\n   * @description Serialize a model into a deterministic JSON string\n   * @summary Prepares the model with preSerialize, sorts keys recursively, and stringifies deterministically for stable ordering\n   * @param {M} model - The model instance to serialize\n   * @return {string} Deterministic JSON representation of the model\n   */\n  override serialize(model: M): string {\n    const stringify = require(\"json-stringify-deterministic\");\n    return stringify(sortKeysOnlyRecursive(this.preSerialize(model)));\n  }\n}\n","import { BulkCrudOperationKeys, OperationKeys } from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Generates a Fabric event name from components\n * @summary Creates a standardized event name by joining table, event, and optional owner with underscores\n * @param {string} table - The table/collection name\n * @param {OperationKeys | BulkCrudOperationKeys | string} event - The event type\n * @param {string} [owner] - Optional owner identifier\n * @return {string} The generated event name in format \"table_event\" or \"table_event_owner\"\n * @function generateFabricEventName\n * @memberOf module:for-fabric.shared\n */\nexport function generateFabricEventName(\n  table: string,\n  event: OperationKeys | BulkCrudOperationKeys | string,\n  owner?: string\n) {\n  const params = [table, event];\n  if (owner) params.push(owner);\n  return params.join(\"_\");\n}\n\n/**\n * @description Parses a Fabric event name into its components\n * @summary Splits an event name by underscores and extracts table, event, and optional owner\n * @param {string} name - The event name to parse\n * @return {{table: string, event: OperationKeys | BulkCrudOperationKeys | string, owner: string}} The parsed components as a structured object\n * @throws {InternalError} If the event name format is invalid\n * @function parseEventName\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant Parser as parseEventName\n *   Caller->>Parser: parseEventName(name)\n *   Parser->>Parser: split name by \"_\"\n *   alt parts length invalid\n *     Parser-->>Caller: throw InternalError\n *   else\n *     Parser-->>Caller: { table, event, owner? }\n *   end\n * @memberOf module:for-fabric.shared\n */\nexport function parseEventName(name: string): {\n  table?: string;\n  event: OperationKeys | BulkCrudOperationKeys | string;\n  owner?: string;\n} {\n  const parts = name.split(\"_\");\n  if (parts.length < 2 || parts.length > 3)\n    return { table: undefined, event: name, owner: undefined };\n  return {\n    table: parts[0],\n    event: parts[1],\n    owner: parts[2],\n  } as {\n    table: string;\n    event: OperationKeys | BulkCrudOperationKeys | string;\n    owner?: string;\n  };\n}\n","import { stringFormat } from \"@decaf-ts/decorator-validation\";\nimport { OverflowError } from \"./errors\";\nimport { ValidationError } from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Overflow-safe addition operation\n * @summary Adds two numbers and verifies no overflow by reverse-checking the operands\n * @param {number} a - First operand\n * @param {number} b - Second operand\n * @return {number} The sum of a and b\n * @function add\n * @throws {OverflowError} on addition overflow\n * @memberOf module:for-fabric.shared\n */\nexport function add(a: number, b: number): number {\n  const c = a + b;\n  if (a !== c - b || b !== c - a) {\n    throw new OverflowError(`Addition overflow: ${a} + ${b}`);\n  }\n  return c;\n}\n\n/**\n * @description Overflow-safe subtraction operation\n * @summary Subtracts b from a and validates no overflow by reverse-checking the operands\n * @param {number} a - Minuend\n * @param {number} b - Subtrahend\n * @return {number} The difference a - b\n * @function sub\n * @throws {OverflowError} on subtaction overflow\n * @memberOf module:for-fabric.shared\n */\nexport function sub(a: number, b: number): number {\n  const c = a - b;\n  if (a !== c + b || b !== a - c) {\n    throw new OverflowError(`Subtraction overflow: ${a} - ${b}`);\n  }\n  return c;\n}\n\n/**\n * @summary Safe Integer Parse\n *\n * @param {string} string\n *\n * @function safeParseInt\n *\n * @throws {ValidationError} if parseInt returns NaN\n *\n * @memberOf module:for-fabric.shared\n */\nexport function safeParseInt(string: string): number {\n  // Regular expression to check if string only have digits\n  const digitRegex = /^\\d+$/;\n  if (!digitRegex.test(string)) {\n    throw new ValidationError(\n      stringFormat(\"Failed to parse: {0}\", \"string contains digits\")\n    );\n  }\n  const parsedint = parseInt(string);\n  if (isNaN(parsedint)) {\n    throw new ValidationError(\n      stringFormat(\"Failed to parse: {0}\", \"string is not a parsable integer\")\n    );\n  }\n  return parsedint;\n}\n","import {\n  JSONSerializer,\n  Model,\n  ModelKeys,\n} from \"@decaf-ts/decorator-validation\";\nimport { Constructor, Metadata } from \"@decaf-ts/decoration\";\nimport { sortKeysOnlyRecursive } from \"./DeterministicSerializer\";\n\nexport class SimpleDeterministicSerializer<\n  M extends Model,\n> extends JSONSerializer<M> {\n  constructor() {\n    super();\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  override deserialize(str: string, tableName?: string): M {\n    const deserialization = JSON.parse(str);\n    // const className = tableName;\n    // if (!className)\n    //   throw new Error(\"Could not find class reference in serialized model\");\n\n    // // this will return undefined values\n    // const model: M = Model.build(deserialization, className) as unknown as M;\n\n    // // Populate Model\n    // const processedDesealization = Object.keys(model).reduce(\n    //   (accum: M, key) => {\n    //     (accum as Record<string, any>)[key] =\n    //       deserialization[Repository.column(accum, key)];\n    //     return accum;\n    //   },\n    //   model\n    // );\n\n    // const result = Model.build(\n    //   processedDesealization,\n    //   className\n    // ) as unknown as M;\n\n    // return result;\n    return deserialization;\n  }\n\n  override serialize(model: M, putAnchor = true): string {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const stringify = require(\"json-stringify-deterministic\");\n    const preSerialization = this.preSerialize(model, putAnchor);\n    return stringify(sortKeysOnlyRecursive(preSerialization));\n  }\n\n  protected override preSerialize(model: M, putAnchor: boolean = true) {\n    // TODO: nested preserialization (so increase performance when deserializing)\n    // TODO: Verify why there is no metadata\n    const toSerialize: Record<string, any> = Object.assign({}, model);\n    let metadata;\n    try {\n      metadata = Metadata.modelName(model.constructor as Constructor);\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (error: unknown) {\n      metadata = undefined;\n    }\n    if (putAnchor)\n      toSerialize[ModelKeys.ANCHOR] = metadata || model.constructor.name;\n\n    function preSerialize(\n      this: SimpleDeterministicSerializer<any>,\n      obj: any\n    ): any {\n      if (typeof obj !== \"object\") return obj;\n      if (Array.isArray(obj)) return obj.map(preSerialize);\n      return this.preSerialize(obj);\n    }\n    Model.relations(model).forEach((r) => {\n      toSerialize[r] = preSerialize.call(this, toSerialize[r]);\n    });\n    return toSerialize;\n  }\n}\n","import {\n  AuthorizationError,\n  ClientBasedService,\n  Context,\n  MaybeContextualArg,\n  PersistenceKeys,\n} from \"@decaf-ts/core\";\nimport FabricCAServices, {\n  AffiliationService,\n  IAttributeRequest,\n  IdentityService,\n  IEnrollResponse,\n  IIdentityRequest,\n  IRegisterRequest,\n  IRevokeRequest,\n  IServiceResponse,\n  TLSOptions,\n} from \"fabric-ca-client\";\nimport { CAConfig, Credentials } from \"../../shared/types\";\nimport {\n  ConflictError,\n  InternalError,\n  NotFoundError,\n  OperationKeys,\n} from \"@decaf-ts/db-decorators\";\nimport { CoreUtils, getAkiAndSerialFromCert } from \"../utils\";\nimport {\n  CertificateResponse,\n  FabricIdentity,\n  GetCertificatesRequest,\n  IdentityResponse,\n} from \"../../shared/fabric-types\";\nimport { User } from \"fabric-common\";\nimport { RegistrationError } from \"../../shared/errors\";\nimport { CA_ROLE } from \"./constants\";\nimport { IKeyValueAttribute } from \"./FabricEnrollmentService\";\nimport { Identity } from \"../../shared/index\";\nimport { CryptoUtils } from \"../crypto\";\n\nexport class FabricIdentityService extends ClientBasedService<\n  FabricCAServices,\n  CAConfig\n> {\n  protected _user!: User;\n\n  constructor() {\n    super();\n  }\n\n  protected get rootClient(): { newCertificateService: any } {\n    return (this.client as any)[\"_FabricCaServices\"] as any;\n  }\n\n  protected get user(): User {\n    if (!this._user)\n      throw new InternalError(\n        \"Fabric identity service not properly setup: missing user\"\n      );\n    return this._user;\n  }\n\n  protected get certificates() {\n    return this.rootClient.newCertificateService();\n  }\n\n  protected get affiliations(): AffiliationService {\n    return this.client.newAffiliationService();\n  }\n\n  protected get identities(): IdentityService {\n    return this.client.newIdentityService();\n  }\n\n  protected async getUser(cfg: CAConfig, ctx: Context) {\n    const log = ctx.logger.for(this.getUser);\n    const { caName, caCert, caKey, url, hsm } = cfg;\n\n    log.info(`Creating CA user for ${caName} at ${url}`);\n    log.verbose(`Retrieving CA certificate from ${caCert}`);\n    const certificate = await CoreUtils.getFirstDirFileNameContent(caCert);\n    let key: string | undefined;\n    if (!hsm) {\n      if (!caKey) {\n        throw new InternalError(\n          `Missing caKey configuration for CA ${caName}. Provide a key directory or configure HSM support.`\n        );\n      }\n      log.debug(`Retrieving CA key from ${caKey}`);\n      key = await CoreUtils.getFirstDirFileNameContent(caKey);\n    } else {\n      log.debug(\n        `Using HSM configuration for CA ${caName} with library ${hsm.library}`\n      );\n    }\n    log.debug(`Loading Admin user for ca ${caName}`);\n    this._user = await CoreUtils.getCAUser(\"admin\", key, certificate, caName, {\n      hsm,\n    });\n    return this._user;\n  }\n\n  override async initialize(\n    ...args: MaybeContextualArg<any>\n  ): Promise<{ config: CAConfig; client: FabricCAServices }> {\n    const { log, ctx } = (\n      await this.logCtx(args, PersistenceKeys.INITIALIZATION, true)\n    ).for(this.initialize);\n    const [config] = args;\n    if (!config) throw new InternalError(\"Missing Fabric CA configuration\");\n\n    const { url, tls, caName } = config;\n    log.info(`Initializing CA Client for CA ${config.caName} at ${config.url}`);\n    const { trustedRoots, verify } = tls as TLSOptions;\n\n    const root = (trustedRoots as string[])[0] as string;\n    log.debug(`Retrieving CA certificate from ${root}. cwd: ${process.cwd()}`);\n\n    const certificate = await CoreUtils.getFileContent(root);\n\n    log.debug(`CA Certificate: ${certificate.toString()}`);\n\n    const client = new FabricCAServices(\n      url,\n      {\n        trustedRoots: Buffer.from(certificate),\n        verify,\n      } as TLSOptions,\n      caName\n    );\n\n    const user = await this.getUser(config, ctx);\n    log.debug(`CA user loaded: ${user.getName()}`);\n    return {\n      config,\n      client,\n    };\n  }\n\n  async getCertificates(...args: MaybeContextualArg<any>): Promise<string[]>;\n  async getCertificates(\n    request: GetCertificatesRequest,\n    ...args: MaybeContextualArg<any>\n  ): Promise<string[]>;\n  async getCertificates<MAP extends boolean>(\n    doMap: MAP,\n    ...args: MaybeContextualArg<any>\n  ): Promise<MAP extends false ? CertificateResponse : string[]>;\n  async getCertificates<MAP extends boolean>(\n    request: GetCertificatesRequest,\n    doMap: MAP,\n    ...args: MaybeContextualArg<any>\n  ): Promise<MAP extends false ? CertificateResponse : string[]>;\n  async getCertificates<MAP extends boolean>(\n    request?: GetCertificatesRequest | MAP,\n    doMap: MAP = true as MAP,\n    ...args: MaybeContextualArg<any>\n  ): Promise<MAP extends false ? CertificateResponse : string[]> {\n    if (request instanceof Context) {\n      args = [request];\n      doMap = true as MAP;\n      request = undefined;\n    } else if (typeof request === \"boolean\") {\n      doMap = request;\n      request = undefined;\n    } else if (typeof doMap !== \"boolean\") {\n      args = [doMap as MaybeContextualArg<any>, ...args];\n      doMap = true as MAP;\n    }\n\n    const { log } = (await this.logCtx(args, OperationKeys.READ, true)).for(\n      this.getCertificates\n    );\n    log.debug(\n      `Retrieving certificates${request ? ` for ${request.id}` : \"\"} for CA ${this.config.caName}`\n    );\n    const response: CertificateResponse = (\n      await this.certificates.getCertificates(request || {}, this.user)\n    ).result;\n    log.verbose(`Found ${response.certs.length} certificates`);\n    log.debug(response.certs);\n    return (\n      doMap ? response.certs.map((c) => c.PEM) : response\n    ) as MAP extends false ? CertificateResponse : string[];\n  }\n\n  async getIdentities(ctx: Context): Promise<FabricIdentity[]> {\n    const log = ctx.logger.for(this.getIdentities);\n    log.verbose(`Retrieving Identities under CA ${this.config.caName}`);\n    const response: IdentityResponse = (await this.identities.getAll(this.user))\n      .result;\n    log.verbose(`Found ${response.identities.length} Identities`);\n    log.debug(response.identities);\n    return response.identities;\n  }\n\n  /**\n   * @description Retrieve affiliations from the CA.\n   * @summary Queries the CA for the list of affiliations available under the configured CA.\n   * @return {string} The affiliations result payload.\n   */\n  async getAffiliations(ctx: Context) {\n    const log = ctx.logger.for(this.getAffiliations);\n    log.verbose(`Retrieving Affiliations under CA ${this.config.caName}`);\n    const response = (await this.affiliations.getAll(this.user)).result;\n    log.verbose(`Found ${response.a.length} Affiliations`);\n    log.debug(JSON.stringify(response));\n    return response;\n  }\n\n  protected parseError(e: Error) {\n    const regexp = /.*code:\\s(\\d+).*?message:\\s[\"'](.+)[\"']/gs;\n    const match = regexp.exec(e.message);\n    if (!match) return new RegistrationError(e);\n    const [, code, message] = match;\n    switch (code) {\n      case \"74\":\n      case \"71\":\n        return new ConflictError(message);\n      case \"20\":\n        return new AuthorizationError(message);\n      default:\n        return new RegistrationError(message);\n    }\n  }\n\n  /**\n   * @description Read identity details from the CA by enrollment ID.\n   * @summary Retrieves and validates a single identity, throwing NotFoundError when missing.\n   * @param {string} enrollmentId - Enrollment ID to lookup.\n   * @return {Promise<FabricIdentity>} The identity details stored in the CA.\n   */\n  async read(\n    enrollmentId: string,\n    ...args: MaybeContextualArg<any>\n  ): Promise<FabricIdentity> {\n    const { log } = (await this.logCtx(args, OperationKeys.READ, true)).for(\n      this.read\n    );\n    log.verbose(`Retrieving identity with enrollment ID ${enrollmentId}`);\n    let result: IServiceResponse;\n    try {\n      result = await this.identities.getOne(enrollmentId, this.user);\n    } catch (e: any) {\n      throw new NotFoundError(\n        `Couldn't find enrollment with id ${enrollmentId}: ${e}`\n      );\n    }\n\n    if (!result.success)\n      throw new NotFoundError(\n        `Couldn't find enrollment with id ${enrollmentId}: ${result.errors.join(\"\\n\")}`\n      );\n\n    return result.result as FabricIdentity;\n  }\n\n  /**\n   * @description Register a new identity with the CA.\n   * @summary Submits a registration request for a new enrollment ID, returning the enrollment secret upon success.\n   * @param {Credentials} model - Credentials containing userName and password for the new identity.\n   * @param {boolean} [isSuperUser=false] - Whether to register the identity as a super user.\n   * @param {string} [affiliation=\"\"] - Affiliation string (e.g., org1.department1).\n   * @param {CA_ROLE | string} [userRole] - Role to assign to the identity.\n   * @param {IKeyValueAttribute} [attrs] - Optional attributes to attach to the identity.\n   * @param {number} [maxEnrollments] - Maximum number of enrollments allowed for the identity.\n   * @return {Promise<string>} The enrollment secret for the registered identity.\n   */\n  async register(\n    model: Credentials,\n    isSuperUser: boolean = false,\n    affiliation: string = \"\",\n    userRole?: CA_ROLE | string,\n    attrs?: IKeyValueAttribute,\n    maxEnrollments?: number,\n    ...args: MaybeContextualArg<any>\n  ): Promise<string> {\n    const { log } = (await this.logCtx(args, \"register\", true)).for(\n      this.register\n    );\n\n    let registration: string;\n    try {\n      const { userName, password } = model;\n      const props = {\n        enrollmentID: userName as string,\n        enrollmentSecret: password,\n        affiliation: affiliation,\n        userRole: userRole,\n        attrs: attrs,\n        maxEnrollments: maxEnrollments,\n      } as IRegisterRequest;\n      registration = await this.client.register(props, this.user);\n      log.info(\n        `Registration for ${userName} created with user type ${userRole ?? \"Undefined Role\"} ${isSuperUser ? \"as super user\" : \"\"}`\n      );\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n    return registration;\n  }\n\n  protected static identityFromEnrollment(\n    enrollment: IEnrollResponse,\n    mspId: string,\n    ctx: Context\n  ): Identity {\n    const log = ctx.logger.for(this.identityFromEnrollment);\n    const { certificate, key, rootCertificate } = enrollment;\n    log.verbose(\n      `Generating Identity from certificate ${certificate} in msp ${mspId}`\n    );\n    const clientId = CryptoUtils.fabricIdFromCertificate(certificate);\n    const id = CryptoUtils.encode(clientId);\n    log.debug(`Identity ${clientId} and encodedId ${id}`);\n    return new Identity({\n      id: id,\n      credentials: {\n        id: id,\n        certificate: certificate,\n        privateKey: key.toBytes(),\n        rootCertificate: rootCertificate,\n      },\n      mspId: mspId,\n    });\n  }\n\n  /**\n   * @description Enroll an identity with the CA using a registration secret.\n   * @summary Exchanges the enrollment ID and secret for certificates, returning a constructed Identity model.\n   * @param {string} enrollmentId - Enrollment ID to enroll.\n   * @param {string} registration - Enrollment secret returned at registration time.\n   * @return {Promise<Identity>} The enrolled identity object with credentials.\n   */\n  async enroll(\n    enrollmentId: string,\n    registration: string,\n    ...args: MaybeContextualArg<any>\n  ): Promise<Identity> {\n    const { log, ctx } = (await this.logCtx(args, \"enroll\", true)).for(\n      this.enroll\n    );\n    let identity: Identity;\n    try {\n      log.debug(`Enrolling ${enrollmentId}`);\n      const enrollment: IEnrollResponse = await this.client.enroll({\n        enrollmentID: enrollmentId,\n        enrollmentSecret: registration,\n      });\n      identity = FabricIdentityService.identityFromEnrollment(\n        enrollment,\n        this.config.caName,\n        ctx\n      );\n      log.info(\n        `Successfully enrolled ${enrollmentId} under ${this.config.caName} as ${identity.id}`\n      );\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n    return identity;\n  }\n\n  /**\n   * @description Register and enroll a new identity in one step.\n   * @summary Registers a new enrollment ID with the CA and immediately exchanges the secret to enroll, returning the created Identity.\n   * @param {Credentials} model - Credentials for the new identity containing userName and password.\n   * @param {boolean} [isSuperUser=false] - Whether to register the identity as a super user.\n   * @param {string} [affiliation=\"\"] - Affiliation string (e.g., org1.department1).\n   * @param {CA_ROLE | string} [userRole] - Role to assign to the identity.\n   * @param {IKeyValueAttribute} [attrs] - Optional attributes to attach to the identity.\n   * @param {number} [maxEnrollments] - Maximum number of enrollments allowed for the identity.\n   * @return {Promise<Identity>} The enrolled identity.\n   */\n  async registerAndEnroll(\n    model: Credentials,\n    isSuperUser: boolean = false,\n    affiliation: string = \"\",\n    userRole?: CA_ROLE | string,\n    attrs?: IKeyValueAttribute,\n    maxEnrollments?: number,\n    ...args: MaybeContextualArg<any>\n  ): Promise<Identity> {\n    const { ctx } = (await this.logCtx(args, \"register-enroll\", true)).for(\n      this.registerAndEnroll\n    );\n    const registration = await this.register(\n      model,\n      isSuperUser,\n      affiliation,\n      userRole,\n      attrs,\n      maxEnrollments,\n      ctx\n    );\n    const { userName } = model;\n    return this.enroll(userName as string, registration, ctx);\n  }\n\n  /**\n   * @description Re-enroll an existing identity using its current enrollment.\n   * @summary Renews the enrollment certificate by calling the CA reenroll.\n   * @param {User} currentUser - Already enrolled user, must have a signing identity.\n   * @return {Promise<Identity>} The renewed identity object with new credentials.\n   */\n  async updateIdentity(\n    enrollmentId: string,\n    identity: { certificate: string; privateKey: string },\n    identityRequest: IIdentityRequest,\n    ...args: MaybeContextualArg<any>\n  ): Promise<Identity> {\n    const { log, ctx } = (await this.logCtx(args, \"reenroll\", true)).for(\n      this.updateIdentity\n    );\n\n    try {\n      log.info(`Renewing identity for ${enrollmentId}`);\n\n      // Update attributes in the CA registry (admin operation). This changes the \"source of truth\".\n      const identityService = this.client.newIdentityService();\n\n      const caUserIdentity = (await identityService.getOne(\n        enrollmentId,\n        this.user\n      )) as { result: { attrs?: IKeyValueAttribute[] } };\n\n      await identityService.update(enrollmentId, identityRequest, this.user); // as IServiceResponse & { result: IIdentityRequest };\n\n      // Reenroll as the user. Request must be signed using the existing certificate.\n      const reenrollUser = User.createUser(\n        enrollmentId,\n        \"\", // enrollmentSecret not required for reenroll\n        this.user.getMspid(),\n        identity.certificate,\n        identity.privateKey\n      );\n      reenrollUser.setCryptoSuite(this.user.getCryptoSuite());\n\n      const enrollmentAttrs: IAttributeRequest[] = (\n        caUserIdentity.result.attrs || []\n      ).map(({ name }) => ({\n        name,\n        optional: false,\n      }));\n\n      const enrollment = await this.client.reenroll(\n        reenrollUser,\n        enrollmentAttrs\n      );\n\n      const renewedIdentity = FabricIdentityService.identityFromEnrollment(\n        enrollment,\n        this.config.caName,\n        ctx\n      );\n\n      // Revoke the previous certificate only, so the old cert becomes invalid.\n      log.debug(`Revoking previous certificates for ${enrollmentId}`);\n      const { aki, serial } = getAkiAndSerialFromCert(identity.certificate);\n      await this.revoke(enrollmentId, { aki, serial }, args);\n\n      log.debug(`Renew identity successful for ${enrollmentId}`);\n      return renewedIdentity;\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n  }\n\n  /**\n   * Revokes the enrollment of an identity with the specified enrollment ID.\n   *\n   * @param enrollmentId - The enrollment ID of the identity to be revoked.\n   *\n   * @returns A Promise that resolves to the result of the revocation operation.\n   *\n   * @throws {NotFoundError} If the enrollment with the specified ID does not exist.\n   * @throws {InternalError} If there is an error during the revocation process.\n   */\n  async revoke(\n    enrollmentId: string,\n    revokeOptions: Omit<IRevokeRequest, \"enrollmentID\">,\n    ...args: MaybeContextualArg<any>\n  ): Promise<IServiceResponse> {\n    const { log } = (await this.logCtx(args, \"revoke\", true)).for(this.revoke);\n    log.verbose(`Revoking identity with enrollment ID ${enrollmentId}`);\n    const identity = await this.read(enrollmentId);\n    if (!identity)\n      throw new NotFoundError(\n        `Could not find enrollment with id ${enrollmentId}`\n      );\n    let result: IServiceResponse;\n    try {\n      const reason =\n        Boolean(revokeOptions.serial) || Boolean(revokeOptions.aki)\n          ? \"Revoke User Certificate\"\n          : \"User Deletion\";\n\n      const revokeRequest: IRevokeRequest = {\n        reason,\n        ...revokeOptions,\n        enrollmentID: identity.id,\n      };\n\n      result = await this.client.revoke(revokeRequest, this.user);\n    } catch (e: unknown) {\n      throw new InternalError(\n        `Could not revoke enrollment with id ${enrollmentId}: ${e}`\n      );\n    }\n    if (!result.success)\n      throw new InternalError(\n        `Could not revoke enrollment with id ${enrollmentId}: ${result.errors.join(\"\\n\")}`\n      );\n    return result;\n  }\n}\n","/**\n * @description Certificate Authority role types used during enrollment and registration.\n * @summary Enumerates the standard Hyperledger Fabric CA roles that can be assigned to identities when registering with the CA service.\n * @enum {string}\n * @readonly\n * @memberOf module:for-fabric.client\n */\nexport enum CA_ROLE {\n  /** Administrator role with elevated privileges for managing identities and affiliations */\n  ADMIN = \"admin\",\n  /** Standard user role for application clients interacting with the network */\n  USER = \"user\",\n  /** Client role typically used for SDK-based interactions and service accounts */\n  CLIENT = \"client\",\n}\n","import { FabricClientFlags } from \"./types\";\n\nexport const DefaultFabricClientFlags: FabricClientFlags = Object.assign({\n  evaluateTimeout: 5,\n  endorseTimeout: 15,\n  submitTimeout: 5,\n  commitTimeout: 60,\n  legacy: false,\n  allowManualEndorsingOrgs: false,\n  allowGatewayOverride: false,\n  rebuildWithTransient: true,\n  encryptTransient: false,\n  syntheticEvents: true,\n}) as any;\n","import { isBrowser, MiniLogger } from \"@decaf-ts/logging\";\nimport { User } from \"fabric-common\";\nimport { Identity, Signer, signers } from \"@hyperledger/fabric-gateway\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\nimport { normalizeImport } from \"@decaf-ts/core\";\n\nconst log = new MiniLogger(\"fabric-fs\");\n\n/**\n * @description Loads content from a file or returns the content if already loaded\n * @summary Determines if the input is already content or a path to a file, and loads the file if needed\n * @param {string | Uint8Array} contentOrPath - The content or path to load\n * @param {Function} fileReader - Function to read the file if contentOrPath is a path\n * @return {Promise<string | Uint8Array | Buffer>} The content\n * @function contentOfLoadFile\n * @memberOf module:for-fabric.client\n */\nexport async function contentOfLoadFile(\n  contentOrPath: string | Uint8Array,\n  fileReader: (path: string) => Promise<string | Uint8Array | Buffer>\n) {\n  if (contentOrPath instanceof Uint8Array) return contentOrPath;\n  if (\n    contentOrPath.match(\n      /-----BEGIN (CERTIFICATE|KEY|PRIVATE KEY)-----.+?-----END \\1-----$/gms\n    )\n  )\n    return contentOrPath;\n  return await fileReader(contentOrPath);\n}\n\n/**\n * @description Reads a file from the file system\n * @summary Loads a file using the Node.js file system module\n * @param {string | Buffer} contentOrPath - The content or path to load\n * @return {Promise<Buffer>} The file content as a Buffer\n * @function readFile\n * @memberOf module:for-fabric.client\n */\nexport async function readFile(contentOrPath: string | Buffer) {\n  if (typeof contentOrPath !== \"string\") return contentOrPath;\n\n  const fileReader = async (path: string) => {\n    const { promises } = await normalizeImport(import(\"fs\"));\n    return await promises.readFile(path);\n  };\n\n  return await fileReader(contentOrPath);\n}\n\n/**\n * @description Creates a Certificate Authority user\n * @summary Initializes a user with the given credentials for interacting with a Fabric CA\n * @param {string} userName - The user name\n * @param {string} privateKey - The private key as a string\n * @param {string} certificate - The certificate as a string\n * @param {string} mspId - The Membership Service Provider ID\n * @return {Promise<User>} Promise resolving to the created user\n * @function getCAUser\n * @memberOf module:for-fabric.client\n */\nexport async function getCAUser(\n  userName: string,\n  privateKey: string,\n  certificate: string,\n  mspId: string\n): Promise<User> {\n  log.debug(\n    `Creating a CA ${mspId} user ${userName} with certificate ${certificate}`\n  );\n  const user = new User(userName);\n  const cryptoSuite = User.newCryptoSuite();\n  user.setCryptoSuite(cryptoSuite);\n  const importedKey = cryptoSuite.createKeyFromRaw(privateKey);\n  await user.setEnrollment(importedKey, certificate, mspId);\n  return user;\n}\n\n/**\n * @description Gets an identity from a certificate directory\n * @summary Loads a certificate from a directory and creates an Identity object\n * @param {string} mspId - The Membership Service Provider ID\n * @param {string} certDirectoryPath - Path to the directory containing the certificate\n * @return {Promise<Identity>} Promise resolving to the identity\n * @function getIdentity\n * @memberOf module:for-fabric.client\n */\nexport async function getIdentity(\n  mspId: string,\n  certDirectoryPath: string\n): Promise<Identity> {\n  const identityFileReader = async (path: string) => {\n    const { promises } = await normalizeImport(import(\"fs\"));\n    const certPath = await getFirstDirFileName(path);\n    const credentials = await promises.readFile(certPath);\n    return credentials;\n  };\n\n  const credentials: Uint8Array = (await contentOfLoadFile(\n    certDirectoryPath,\n    identityFileReader\n  )) as Uint8Array;\n\n  return { mspId, credentials };\n}\n\n/**\n * @description Gets the full path of the first file in a directory\n * @summary Reads a directory and returns the path to the first file found\n * @param {string} dirPath - Path to the directory\n * @return {Promise<string>} Promise resolving to the full path of the first file\n * @function getFirstDirFileName\n * @memberOf module:for-fabric.client\n */\nexport async function getFirstDirFileName(dirPath: string): Promise<string> {\n  const { promises } = await normalizeImport(import(\"fs\"));\n  const { join } = await normalizeImport(import(\"path\"));\n  const files = await promises.readdir(dirPath);\n  return join(dirPath, files[0]);\n}\n\n/**\n * @description Gets the content of the first file in a directory\n * @summary Reads a directory, finds the first file, and returns its content as a string\n * @param {string} dirPath - Path to the directory\n * @return {Promise<string>} Promise resolving to the content of the first file\n * @function getFirstDirFileNameContent\n * @memberOf module:for-fabric.client\n */\nexport async function getFirstDirFileNameContent(\n  dirPath: string\n): Promise<string> {\n  const { promises } = await normalizeImport(import(\"fs\"));\n  const { join } = await normalizeImport(import(\"path\"));\n  const files = await promises.readdir(dirPath);\n  return (await promises.readFile(join(dirPath, files[0]))).toString();\n}\n\n/**\n * @description Gets a signer from a key directory\n * @summary Loads a private key from a directory and creates a Signer for Fabric transactions\n * @param {string} keyDirectoryPath - Path to the directory containing the private key\n * @return {Promise<Signer>} Promise resolving to the signer\n * @function getSigner\n * @memberOf module:for-fabric.client\n */\nexport async function getSigner(keyDirectoryPath: string): Promise<Signer> {\n  const signerFileReader = async (path: string) => {\n    const { promises } = await normalizeImport(import(\"fs\"));\n    const keyPath = await getFirstDirFileName(path);\n    return await promises.readFile(keyPath);\n  };\n\n  const privateKeyPem = (await contentOfLoadFile(\n    keyDirectoryPath,\n    signerFileReader\n  )) as Buffer;\n  // Node based implementation\n  // privateKey = createPrivateKey(privateKeyPem);\n  // --\n\n  // web based implementation\n  const privateKey = await extractPrivateKey(privateKeyPem);\n  const keys = Object.getOwnPropertySymbols(privateKey);\n  const k = (privateKey as any)[keys[0]];\n  // --\n\n  return signers.newPrivateKeySigner(k as any);\n}\n\n/**\n * @description Extracts a private key from a PEM buffer\n * @summary Converts a PEM-encoded private key to a CryptoKey object\n * @param {Buffer} pem - The PEM-encoded private key\n * @return {Promise<CryptoKey>} Promise resolving to the CryptoKey\n * @function extractPrivateKey\n * @memberOf module:for-fabric.client\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant ExtractPrivateKey\n *   participant SubtleCrypto\n *\n *   Caller->>ExtractPrivateKey: extractPrivateKey(pem)\n *   ExtractPrivateKey->>ExtractPrivateKey: Get SubtleCrypto implementation\n *   ExtractPrivateKey->>ExtractPrivateKey: Parse PEM format\n *   ExtractPrivateKey->>ExtractPrivateKey: Convert to binary DER\n *   ExtractPrivateKey->>SubtleCrypto: importKey(pkcs8, binaryDer, options)\n *   SubtleCrypto-->>ExtractPrivateKey: CryptoKey\n *   ExtractPrivateKey-->>Caller: CryptoKey\n */\nexport async function extractPrivateKey(pem: Buffer) {\n  const libName = \"crypto\";\n  let subtle;\n  if (isBrowser()) {\n    subtle = (globalThis as any).crypto.subtle;\n  } else {\n    const lib = (await normalizeImport(import(libName))) as any;\n    subtle = lib.subtle || lib.webcrypto.subtle;\n  }\n\n  if (!subtle) throw new Error(\"Could not load SubtleCrypto module\");\n\n  function str2ab(str: string) {\n    const buf = new ArrayBuffer(str.length);\n    const bufView = new Uint8Array(buf);\n    for (let i = 0, strLen = str.length; i < strLen; i++) {\n      bufView[i] = str.charCodeAt(i);\n    }\n    return buf;\n  }\n\n  const str = pem\n    .toString(\"utf8\")\n    .replace(\"-----BEGIN PRIVATE KEY-----\", \"\")\n    .replaceAll(\"\\n\", \"\")\n    .replace(\"-----END PRIVATE KEY-----\", \"\");\n  const decoded = Buffer.from(str, \"base64\").toString(\"binary\");\n  const binaryDer = str2ab(decoded);\n\n  try {\n    const key = await subtle.importKey(\n      \"pkcs8\",\n      binaryDer,\n      {\n        name: \"ECDSA\",\n        namedCurve: \"P-256\",\n      },\n      true,\n      [\"sign\"]\n    );\n\n    return key;\n  } catch (e: any) {\n    throw new InternalError(e);\n  }\n}\n","import {\n  AdapterFlags,\n  Condition,\n  Context,\n  GroupOperator,\n  MaybeContextualArg,\n  Operator,\n  OrderDirection,\n  PersistenceKeys,\n  PreparedStatement,\n  PreparedStatementKeys,\n  QueryClause,\n  QueryError,\n  Repository,\n  SelectSelector,\n  Sequence,\n  Statement,\n  StatementExecutor,\n  ViewKind,\n} from \"@decaf-ts/core\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { FabricClientAdapter } from \"./FabricClientAdapter\";\nimport {\n  CouchDBKeys,\n  CouchDBOperator,\n  CouchDBGroupOperator,\n  CouchDBQueryLimit,\n  MangoQuery,\n  MangoOperator,\n  MangoSelector,\n  translateOperators,\n  generateDesignDocName,\n  generateViewName,\n  findViewMetadata,\n  CouchDBViewMetadata,\n  ViewResponse,\n} from \"@decaf-ts/for-couchdb\";\nimport { FabricClientFlags } from \"./types\";\nimport { toCamelCase } from \"@decaf-ts/logging\";\nimport { DBKeys, InternalError } from \"@decaf-ts/db-decorators\";\nimport { Metadata } from \"@decaf-ts/decoration\";\n\ntype FabricViewDescriptor = {\n  ddoc: string;\n  view: string;\n  options: Record<string, any>;\n};\n\ntype FabricAggregateInfo =\n  | {\n      kind: ViewKind;\n      meta: CouchDBViewMetadata;\n      descriptor: FabricViewDescriptor;\n      countDistinct?: boolean;\n    }\n  | {\n      kind: \"avg\";\n      attribute: string;\n      sumDescriptor: FabricViewDescriptor;\n      countDescriptor: FabricViewDescriptor;\n    };\n\nconst escapeRegExp = (value: string): string =>\n  value.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n\nfunction nextLexicographicString(value: string): string {\n  if (!value) return \"\\u0000\";\n  const chars = Array.from(value);\n  for (let i = chars.length - 1; i >= 0; i -= 1) {\n    const code = chars[i].codePointAt(0);\n    if (code === undefined) continue;\n    if (code < 0x10ffff) {\n      chars[i] = String.fromCodePoint(code + 1);\n      return chars.slice(0, i + 1).join(\"\");\n    }\n  }\n  return `${value}\\u0000`;\n}\n\nfunction prefixRange(prefix: string) {\n  return {\n    start: prefix,\n    end: nextLexicographicString(prefix),\n  };\n}\n\nexport class FabricClientStatement<M extends Model, R> extends Statement<\n  M,\n  FabricClientAdapter,\n  R,\n  MangoQuery\n> {\n  constructor(adapter: FabricClientAdapter, overrides?: Partial<AdapterFlags>) {\n    super(adapter, overrides);\n  }\n\n  protected override squash(\n    ctx: Context<FabricClientFlags>\n  ): PreparedStatement<any> | undefined {\n    const squashed: PreparedStatement<M> | undefined = super.squash(\n      ctx as never\n    );\n    if (!squashed) return squashed;\n\n    const { method, params, args } = squashed;\n    const { direction, limit } = params;\n    switch (method) {\n      case PreparedStatementKeys.FIND:\n        break;\n      case PreparedStatementKeys.PAGE:\n        args.push(direction, limit);\n        break;\n      case PreparedStatementKeys.FIND_BY:\n        break;\n      case PreparedStatementKeys.LIST_BY:\n        args.push(direction);\n        break;\n      case PreparedStatementKeys.PAGE_BY:\n        args.push(direction, limit);\n        break;\n      case PreparedStatementKeys.FIND_ONE_BY:\n        break;\n      default:\n        throw new InternalError(`Unsupported method ${method}`);\n    }\n\n    return squashed;\n  }\n\n  protected override async executePrepared(\n    ...argz: MaybeContextualArg<Context<FabricClientFlags>>\n  ): Promise<R> {\n    const repo = Repository.forModel(this.fromSelector, this.adapter.alias);\n    const { method, args } = this.prepared as PreparedStatement<any>;\n    return repo.statement(method, ...args, ...argz);\n  }\n\n  override async prepare(\n    ctx?: Context<FabricClientFlags>\n  ): Promise<StatementExecutor<M, R>> {\n    ctx =\n      ctx ||\n      (await this.adapter.context(\n        PersistenceKeys.QUERY,\n        this.overrides || {},\n        this.fromSelector\n      ));\n\n    if (\n      this.isSimpleQuery() &&\n      (ctx as Context<FabricClientFlags>).get(\"forcePrepareSimpleQueries\")\n    ) {\n      const squashed = this.squash(ctx as Context<FabricClientFlags>);\n      if (squashed) {\n        this.prepared = squashed;\n        return this;\n      }\n    }\n    const args: (string | number)[] = [];\n    const params: any = {} as any;\n\n    const prepared: PreparedStatement<any> = {\n      class: this.fromSelector,\n      args,\n      params,\n    } as any;\n\n    const method: string[] = [QueryClause.FIND_BY];\n\n    if (this.whereCondition) {\n      const parsed = this.prepareCondition(this.whereCondition, ctx as never);\n      method.push(parsed.method);\n      if (parsed.args && parsed.args.length)\n        args.push(...(parsed.args as (string | number)[]));\n    }\n    if (this.selectSelector)\n      method.push(\n        QueryClause.SELECT,\n        this.selectSelector.join(` ${QueryClause.AND.toLowerCase()} `)\n      );\n    if (this.orderBySelectors?.length) {\n      method.push(QueryClause.ORDER_BY, this.orderBySelectors[0][0] as string);\n      args.push(this.orderBySelectors[0][1] as any);\n    }\n    prepared.method = toCamelCase(method.join(\" \"));\n    prepared.params = params;\n    this.prepared = prepared;\n    return this;\n  }\n\n  /**\n   * @description Processes a record from CouchDB/Fabric\n   * @summary Extracts the ID from a CouchDB document and reverts it to a model instance\n   */\n  protected override processRecord(\n    record: any,\n    ctx: Context<FabricClientFlags>\n  ): M {\n    const pkAttr = Model.pk(this.fromSelector);\n    const type = Metadata.get(\n      this.fromSelector,\n      Metadata.key(DBKeys.ID, pkAttr as string)\n    )?.type;\n\n    if (record[CouchDBKeys.ID]) {\n      const [, ...keyArgs] = record[CouchDBKeys.ID].split(CouchDBKeys.SEPARATOR);\n      const id = keyArgs.join(\"_\");\n      record[pkAttr] = Sequence.parseValue(type as any, id);\n    }\n\n    return super.processRecord(record, ctx);\n  }\n\n  /**\n   * @description Executes a raw Mango query\n   * @summary Sends a raw Mango query to Fabric and processes the results\n   */\n  override async raw<R>(rawInput: MangoQuery, ...args: any[]): Promise<R> {\n    const { ctx } = this.logCtx(args, this.raw);\n    const aggregator = (rawInput as any)?.aggregateInfo;\n    if ((rawInput as any)?.aggregate && aggregator) {\n      return this.executeAggregate<R>(aggregator, ctx);\n    }\n    const results: any[] = await this.adapter.raw(\n      rawInput,\n      true,\n      this.fromSelector,\n      ctx\n    );\n\n    if (!this.selectSelector) {\n      const processed = results.map((r) => this.processRecord(r, ctx));\n      if (!ctx.getOrUndefined(\"afterQueryHandlers\")) {\n        return processed as unknown as R;\n      }\n      return (await this.applyAfterHandlersToResult(processed, ctx)) as R;\n    }\n    return results as R;\n  }\n\n  /**\n   * @description Builds a CouchDB Mango query from the statement\n   * @summary Converts the statement's conditions, selectors, and options into a CouchDB Mango query\n   */\n  protected override build(): MangoQuery {\n    const log = this.log.for(this.build);\n    const aggregateQuery = this.buildAggregateQuery();\n    if (aggregateQuery) return aggregateQuery;\n    const selectors: MangoSelector = {};\n    selectors[CouchDBKeys.TABLE] = {};\n    selectors[CouchDBKeys.TABLE] = Model.tableName(this.fromSelector);\n    const query: MangoQuery = { selector: selectors };\n    if (this.selectSelector) query.fields = this.selectSelector as string[];\n\n    if (this.whereCondition) {\n      const condition: MangoSelector = this.parseCondition(\n        Condition.and(\n          this.whereCondition,\n          Condition.attribute<M>(CouchDBKeys.TABLE as keyof M).eq(\n            query.selector[CouchDBKeys.TABLE]\n          )\n        )\n      ).selector;\n      const selectorKeys = Object.keys(condition) as MangoOperator[];\n      if (\n        selectorKeys.length === 1 &&\n        Object.values(CouchDBGroupOperator).indexOf(selectorKeys[0]) !== -1\n      )\n        switch (selectorKeys[0]) {\n          case CouchDBGroupOperator.AND:\n            condition[CouchDBGroupOperator.AND] = [\n              ...Object.values(\n                condition[CouchDBGroupOperator.AND] as MangoSelector\n              ).reduce((accum: MangoSelector[], val: any) => {\n                const keys = Object.keys(val);\n                if (keys.length !== 1)\n                  throw new Error(\n                    \"Too many keys in query selector. should be one\"\n                  );\n                const k = keys[0];\n                if (k === CouchDBGroupOperator.AND)\n                  accum.push(...(val[k] as any[]));\n                else accum.push(val);\n                return accum;\n              }, []),\n            ];\n            query.selector = condition;\n            break;\n          case CouchDBGroupOperator.OR: {\n            const s: Record<any, any> = {};\n            s[CouchDBGroupOperator.AND] = [\n              condition,\n              ...Object.entries(query.selector).map(([key, val]) => {\n                const result: Record<any, any> = {};\n                result[key] = val;\n                return result;\n              }),\n            ];\n            query.selector = s;\n            break;\n          }\n          default:\n            throw new Error(\"This should be impossible\");\n        }\n      else {\n        Object.entries(condition).forEach(([key, val]) => {\n          if (query.selector[key])\n            log.warn(\n              `A ${key} query param is about to be overridden: ${query.selector[key]} by ${val}`\n            );\n          query.selector[key] = val;\n        });\n      }\n    }\n\n    if (this.orderBySelectors?.length) {\n      query.sort = query.sort || [];\n      query.selector = query.selector || ({} as MangoSelector);\n      for (const [selectorKey, direction] of this.orderBySelectors) {\n        const selector = selectorKey as string;\n        const rec: Record<string, OrderDirection> = {};\n        rec[selector] = direction as OrderDirection;\n        (query.sort as Record<string, OrderDirection>[]).push(rec);\n        if (!query.selector[selector]) {\n          query.selector[selector] = {} as MangoSelector;\n          (query.selector[selector] as MangoSelector)[CouchDBOperator.BIGGER] =\n            null;\n        }\n      }\n    }\n\n    if (this.limitSelector) {\n      query.limit = this.limitSelector;\n    } else {\n      log.warn(\n        `No limit selector defined. Using default couchdb limit of ${CouchDBQueryLimit}`\n      );\n      query.limit = CouchDBQueryLimit;\n    }\n\n    if (this.offsetSelector) query.skip = this.offsetSelector;\n\n    return query;\n  }\n\n  /**\n   * @description Parses a condition into a CouchDB Mango query selector\n   * @summary Converts a Condition object into a CouchDB Mango query selector structure\n   */\n  protected override parseCondition(condition: Condition<M>): MangoQuery {\n    function merge(\n      op: MangoOperator,\n      obj1: MangoSelector,\n      obj2: MangoSelector\n    ): MangoQuery {\n      const result: MangoQuery = { selector: {} as MangoSelector };\n      result.selector[op] = [obj1, obj2];\n      return result;\n    }\n\n    const { attr1, operator, comparison } = condition as unknown as {\n      attr1: string | Condition<M>;\n      operator: Operator | GroupOperator;\n      comparison: any;\n    };\n\n    if (operator === Operator.STARTS_WITH) {\n      if (typeof attr1 !== \"string\")\n        throw new QueryError(\"STARTS_WITH requires an attribute name\");\n      if (typeof comparison !== \"string\")\n        throw new QueryError(\"STARTS_WITH requires a string comparison\");\n      const range = prefixRange(comparison);\n      const selector: MangoSelector = {} as MangoSelector;\n      selector[attr1] = {} as MangoSelector;\n      (selector[attr1] as MangoSelector)[CouchDBOperator.BIGGER_EQ] = range.start;\n      (selector[attr1] as MangoSelector)[CouchDBOperator.SMALLER] = range.end;\n      return { selector };\n    }\n\n    if (operator === Operator.ENDS_WITH) {\n      if (typeof attr1 !== \"string\")\n        throw new QueryError(\"ENDS_WITH requires an attribute name\");\n      if (typeof comparison !== \"string\")\n        throw new QueryError(\"ENDS_WITH requires a string comparison\");\n      const selector: MangoSelector = {} as MangoSelector;\n      selector[attr1] = {\n        [CouchDBOperator.REGEXP]: `${escapeRegExp(comparison)}$`,\n      } as MangoSelector;\n      return { selector };\n    }\n\n    if (operator === Operator.BETWEEN) {\n      const attr = attr1 as string;\n      if (!Array.isArray(comparison) || comparison.length !== 2)\n        throw new QueryError(\"BETWEEN operator requires [min, max] comparison\");\n      const [min, max] = comparison;\n      const opBetween: MangoSelector = {} as MangoSelector;\n      opBetween[attr] = {} as MangoSelector;\n      (opBetween[attr] as MangoSelector)[\n        translateOperators(Operator.BIGGER_EQ)\n      ] = min;\n      (opBetween[attr] as MangoSelector)[\n        translateOperators(Operator.SMALLER_EQ)\n      ] = max;\n      return { selector: opBetween };\n    }\n\n    let op: MangoSelector = {} as MangoSelector;\n    if (\n      [GroupOperator.AND, GroupOperator.OR, Operator.NOT].indexOf(\n        operator as GroupOperator\n      ) === -1\n    ) {\n      op[attr1 as string] = {} as MangoSelector;\n      (op[attr1 as string] as MangoSelector)[translateOperators(operator)] =\n        comparison;\n    } else if (operator === Operator.NOT) {\n      op = this.parseCondition(attr1 as Condition<M>).selector as MangoSelector;\n      op[translateOperators(Operator.NOT)] = {} as MangoSelector;\n      (op[translateOperators(Operator.NOT)] as MangoSelector)[\n        (attr1 as unknown as { attr1: string }).attr1\n      ] = comparison;\n    } else {\n      const op1: any = this.parseCondition(attr1 as Condition<M>).selector;\n      const op2: any = this.parseCondition(comparison as Condition<M>).selector;\n      op = merge(translateOperators(operator), op1, op2).selector;\n    }\n\n    return { selector: op };\n  }\n\n  /**\n   * @description Builds an aggregate query if aggregation is requested\n   * @summary Checks for aggregate operations and returns a special MangoQuery for them\n   */\n  private buildAggregateQuery(): MangoQuery | undefined {\n    if (!this.fromSelector) return undefined;\n    if (this.avgSelector) {\n      const attribute = String(this.avgSelector);\n      const sumInfo = this.createAggregateDescriptor(\"sum\", attribute);\n      const countInfo = this.createAggregateDescriptor(\"count\", attribute);\n      if (!sumInfo || !countInfo)\n        throw new QueryError(\n          `Avg operation requires sum and count views for attribute ${attribute}`\n        );\n      return this.createAggregateQuery({\n        kind: \"avg\",\n        attribute,\n        sumDescriptor: sumInfo.descriptor,\n        countDescriptor: countInfo.descriptor,\n      });\n    }\n\n    if (typeof this.countDistinctSelector !== \"undefined\") {\n      const attribute =\n        this.countDistinctSelector == null\n          ? undefined\n          : String(this.countDistinctSelector);\n      const info = this.createAggregateDescriptor(\"distinct\", attribute);\n      if (info) {\n        info.countDistinct = true;\n        return this.createAggregateQuery(info);\n      }\n    }\n\n    const aggregatorUsed =\n      typeof this.countSelector !== \"undefined\" ||\n      typeof this.countDistinctSelector !== \"undefined\" ||\n      !!this.minSelector ||\n      !!this.maxSelector ||\n      !!this.sumSelector ||\n      !!this.distinctSelector;\n\n    const aggregatorChecks: Array<[ViewKind, SelectSelector<M> | undefined]> = [\n      [\n        \"count\",\n        (this.countSelector ?? undefined) as SelectSelector<M> | undefined,\n      ],\n      [\"max\", this.maxSelector],\n      [\"min\", this.minSelector],\n      [\"sum\", this.sumSelector],\n      [\"distinct\", this.distinctSelector],\n    ];\n\n    for (const [kind, selector] of aggregatorChecks) {\n      const attribute = selector ? String(selector) : undefined;\n      const info = this.createAggregateDescriptor(kind, attribute);\n      if (info) return this.createAggregateQuery(info);\n    }\n\n    if (aggregatorUsed) {\n      throw new QueryError(\n        `No CouchDB view metadata found for table ${Model.tableName(\n          this.fromSelector\n        )} aggregator`\n      );\n    }\n    return undefined;\n  }\n\n  /**\n   * @description Creates an aggregate descriptor for a view-based aggregation\n   */\n  private createAggregateDescriptor(\n    kind: ViewKind,\n    attribute?: string\n  ): Extract<FabricAggregateInfo, { kind: ViewKind }> | undefined {\n    if (!this.fromSelector) return undefined;\n    const metas = findViewMetadata(this.fromSelector, kind, attribute);\n    if (!metas.length) return undefined;\n    const meta = metas[0];\n    const tableName = Model.tableName(this.fromSelector);\n    const viewName = generateViewName(tableName, meta.attribute, kind, meta);\n    const ddoc = meta.ddoc || generateDesignDocName(tableName, viewName);\n    const options: Record<string, any> = {\n      reduce: meta.reduce !== undefined ? true : !meta.returnDocs,\n    };\n    if (kind === \"distinct\" || kind === \"groupBy\") options.group = true;\n    return {\n      kind,\n      meta,\n      descriptor: {\n        ddoc,\n        view: viewName,\n        options,\n      },\n    };\n  }\n\n  /**\n   * @description Creates the special aggregate MangoQuery marker\n   */\n  private createAggregateQuery(\n    info: FabricAggregateInfo\n  ): MangoQuery & { aggregate: true; aggregateInfo: FabricAggregateInfo } {\n    return {\n      selector: {},\n      aggregate: true,\n      aggregateInfo: info,\n    } as MangoQuery & { aggregate: true; aggregateInfo: FabricAggregateInfo };\n  }\n\n  /**\n   * @description Gets the adapter cast to FabricClientAdapter for view access\n   */\n  private getFabricAdapter(): FabricClientAdapter {\n    return this.adapter as FabricClientAdapter;\n  }\n\n  /**\n   * @description Executes an aggregate query via adapter's view method\n   */\n  private async executeAggregate<R>(\n    info: FabricAggregateInfo,\n    ctx: Context<FabricClientFlags>\n  ): Promise<R> {\n    if (!this.isViewAggregate(info)) {\n      return this.handleAverage<R>(info, ctx);\n    }\n    const fabricAdapter = this.getFabricAdapter();\n    const viewInfo = info as Extract<FabricAggregateInfo, { kind: ViewKind }>;\n    const response = await fabricAdapter.view<ViewResponse>(\n      viewInfo.descriptor.ddoc,\n      viewInfo.descriptor.view,\n      viewInfo.descriptor.options,\n      ctx\n    );\n    return this.processViewResponse<R>(info, response);\n  }\n\n  /**\n   * @description Handles average calculation from sum and count views\n   */\n  private async handleAverage<R>(\n    info: FabricAggregateInfo,\n    ctx: Context<FabricClientFlags>\n  ): Promise<R> {\n    if (info.kind !== \"avg\")\n      throw new QueryError(\"Average descriptor is not valid\");\n    const fabricAdapter = this.getFabricAdapter();\n    const [sumDesc, countDesc] = [info.sumDescriptor, info.countDescriptor];\n    const [sumResponse, countResponse] = await Promise.all([\n      fabricAdapter.view<ViewResponse>(\n        sumDesc.ddoc,\n        sumDesc.view,\n        sumDesc.options,\n        ctx\n      ),\n      fabricAdapter.view<ViewResponse>(\n        countDesc.ddoc,\n        countDesc.view,\n        countDesc.options,\n        ctx\n      ),\n    ]);\n    const sum = sumResponse.rows?.[0]?.value ?? 0;\n    const count = countResponse.rows?.[0]?.value ?? 0;\n    if (!count) return 0 as unknown as R;\n    return (sum / count) as unknown as R;\n  }\n\n  /**\n   * @description Processes the view response based on aggregate kind\n   */\n  private processViewResponse<R>(\n    info: FabricAggregateInfo,\n    response: ViewResponse\n  ): R {\n    if (info.kind === \"avg\")\n      throw new QueryError(\n        \"Average results should be handled before processing rows\"\n      );\n    const rows = response.rows || [];\n    const viewInfo = info as Extract<FabricAggregateInfo, { kind: ViewKind }>;\n    const meta = viewInfo.meta;\n    if (viewInfo.countDistinct) {\n      return (rows.length || 0) as unknown as R;\n    }\n    if (viewInfo.kind === \"distinct\" || viewInfo.kind === \"groupBy\") {\n      return rows.map((row) => row.key ?? row.value) as unknown as R;\n    }\n    if (meta.returnDocs) {\n      return rows.map((row) => row.value ?? row.doc ?? row) as unknown as R;\n    }\n    if (!rows.length) {\n      return (viewInfo.kind === \"count\" ? 0 : null) as unknown as R;\n    }\n    return (rows[0].value ?? rows[0].key ?? null) as unknown as R;\n  }\n\n  /**\n   * @description Type guard to check if info is a view-based aggregate\n   */\n  private isViewAggregate(\n    info: FabricAggregateInfo\n  ): info is Extract<FabricAggregateInfo, { kind: ViewKind }> {\n    return info.kind !== \"avg\";\n  }\n}\n","import \"../shared/overrides\";\nimport {\n  CouchDBKeys,\n  type MangoQuery,\n  type ViewResponse,\n} from \"@decaf-ts/for-couchdb\";\nimport { Client } from \"@grpc/grpc-js\";\nimport * as grpc from \"@grpc/grpc-js\";\nimport {\n  Model,\n  type ModelConstructor,\n  type Serializer,\n} from \"@decaf-ts/decorator-validation\";\nimport { debug, final, Logging } from \"@decaf-ts/logging\";\nimport {\n  type PeerConfig,\n  type SegregatedModel,\n  type MspDetails,\n} from \"../shared/types\";\nimport {\n  connect,\n  type ConnectOptions,\n  Gateway,\n  Network,\n  ProposalOptions,\n  Contract as Contrakt,\n  type Signer,\n  GatewayError,\n  EndorseError,\n} from \"@hyperledger/fabric-gateway\";\nimport { Gateway as LegacyGateway, Wallets } from \"fabric-network\";\nimport type { Endorser } from \"fabric-common\";\nimport {\n  getIdentity,\n  getSigner,\n  getFirstDirFileNameContent,\n  readFile as readFsFile,\n} from \"./fabric-fs\";\nimport {\n  BaseError,\n  InternalError,\n  OperationKeys,\n  SerializationError,\n  BulkCrudOperationKeys,\n  NotFoundError,\n  ConflictError,\n  BadRequestError,\n  type PrimaryKeyType,\n  ValidationError,\n} from \"@decaf-ts/db-decorators\";\nimport {\n  Context,\n  Adapter,\n  type AdapterFlags,\n  AuthorizationError,\n  ConnectionError,\n  ForbiddenError,\n  MigrationError,\n  ObserverError,\n  PagingError,\n  PersistenceKeys,\n  QueryError,\n  Repository,\n  UnsupportedError,\n  Statement,\n  type PreparedStatement,\n  Paginator,\n  MaybeContextualArg,\n  ContextualArgs,\n  type PreparedModel,\n  AllOperationKeys,\n} from \"@decaf-ts/core\";\nimport { FabricFlavour } from \"../shared/constants\";\nimport { ClientSerializer } from \"../shared/ClientSerializer\";\nimport { FabricClientDispatch } from \"./FabricClientDispatch\";\n// import { HSMSignerFactoryCustom } from \"./fabric-hsm\";\nimport { type Constructor } from \"@decaf-ts/decoration\";\nimport { FabricClientStatement } from \"./FabricClientStatement\";\nimport { FabricClientPaginator } from \"./FabricClientPaginator\";\nimport { FabricClientRepository } from \"./FabricClientRepository\";\nimport {\n  EndorsementError,\n  EndorsementPolicyError,\n  MvccReadConflictError,\n  PhantomReadConflictError,\n  TransactionTimeoutError,\n} from \"../shared/errors\";\nimport { FabricClientFlags } from \"./types\";\nimport { DefaultFabricClientFlags } from \"./constants\";\nimport fs from \"fs\";\nimport { CryptoUtils } from \"./crypto\";\nimport { extractIds } from \"./ids/id-extraction\";\nimport { Identity } from \"../shared/index\";\n\ntype LegacyPeerTarget = {\n  mspId: string;\n  peerEndpoint: string;\n  peerHostAlias?: string;\n  tlsCert?: string | Buffer;\n};\n\ntype LegacyPeerWithName = LegacyPeerTarget & { name: string };\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 Adapter<\n  PeerConfig,\n  Client,\n  MangoQuery,\n  Context<FabricClientFlags>\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  protected static log = Logging.for(FabricClientAdapter);\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(\n      Object.assign({}, DefaultFabricClientFlags, config),\n      FabricFlavour,\n      alias\n    );\n  }\n\n  override Statement<M extends Model>(\n    overrides?: Partial<AdapterFlags>\n  ): Statement<M, FabricClientAdapter, any, MangoQuery> {\n    return new FabricClientStatement(this, overrides);\n  }\n\n  Paginator<M extends Model>(\n    query: PreparedStatement<any> | MangoQuery,\n    size: number,\n    clazz: Constructor<M>\n  ): Paginator<M, any, MangoQuery> {\n    return new FabricClientPaginator(this, query, size, clazz);\n  }\n\n  protected override async flags<M extends Model>(\n    operation: OperationKeys | string,\n    model: Constructor<M> | Constructor<M>[] | undefined,\n    flags: Partial<FabricClientFlags>,\n    ...args: any[]\n  ): Promise<FabricClientFlags> {\n    const mergedFlags = Object.assign({}, this.config, flags);\n    const f = Object.assign(\n      await super.flags(operation, model, mergedFlags, ...args)\n    );\n    return f;\n  }\n\n  override async context<M extends Model>(\n    operation: ((...args: any[]) => any) | AllOperationKeys,\n    overrides: Partial<FabricClientFlags>,\n    model: Constructor<M> | Constructor<M>[],\n    ...args: MaybeContextualArg<Context<any>>\n  ): Promise<Context<FabricClientFlags>> {\n    const log = this.log.for(this.context);\n    log.silly(\n      `creating new context for ${operation} operation on ${model ? (Array.isArray(model) ? model.map((m) => Model.tableName(m)) : Model.tableName(model)) : \"no\"} table ${overrides && Object.keys(overrides) ? Object.keys(overrides).length : \"no\"} with flag overrides`\n    );\n    let ctx = args.pop();\n    if (typeof ctx !== \"undefined\" && !(ctx instanceof Context)) {\n      args.push(ctx);\n      ctx = undefined;\n    }\n\n    overrides = ctx\n      ? Object.assign({}, ctx.toOverrides(), overrides)\n      : overrides;\n    const flags = await this.flags(\n      typeof operation === \"string\" ? operation : operation.name,\n      model,\n      overrides as Partial<FabricClientFlags>,\n      ...[...args, ctx].filter(Boolean)\n    );\n\n    if (ctx) {\n      if (!(ctx instanceof this.Context)) {\n        const newCtx = new this.Context().accumulate({\n          ...ctx[\"cache\"],\n          ...flags,\n          parentContext: ctx,\n        }) as any;\n        ctx.accumulate({\n          childContexts: [\n            ...(ctx.getOrUndefined(\"childContexts\") || []),\n            newCtx,\n          ],\n        });\n        return newCtx;\n      }\n      const currentOp = ctx.getOrUndefined(\"operation\");\n      const currentModel = ctx.getOrUndefined(\"affectedTables\");\n      if (\n        !currentOp ||\n        currentOp !== operation ||\n        (model && model !== currentModel)\n      ) {\n        const newCtx = new this.Context().accumulate({\n          ...ctx[\"cache\"],\n          ...flags,\n          parentContext: ctx,\n        }) as any;\n\n        ctx.accumulate({\n          childContexts: [\n            ...(ctx.getOrUndefined(\"childContexts\") || []),\n            newCtx,\n          ],\n        });\n        return newCtx;\n      }\n      return ctx.accumulate(flags) as any;\n    }\n\n    return new this.Context().accumulate({\n      ...flags,\n    }) as any;\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<\n    R extends Repository<\n      any,\n      Adapter<PeerConfig, Client, MangoQuery, Context<FabricClientFlags>>\n    >,\n  >(): Constructor<R> {\n    return FabricClientRepository as unknown as Constructor<R>;\n  }\n\n  protected createPrefix<M extends Model>(\n    clazz: Constructor<M>,\n    id: PrimaryKeyType,\n    model: Record<string, any>,\n    ...args: MaybeContextualArg<Context<FabricClientFlags>>\n  ): [Constructor<M>, PrimaryKeyType, Record<string, any>, ...any[], Context] {\n    const { ctxArgs } = this.logCtx(args, this.createPrefix);\n    const tableName = Model.tableName(clazz);\n    const record: Record<string, any> = {};\n    record[CouchDBKeys.TABLE] = tableName;\n    Object.assign(record, model);\n    return [clazz, id, record, ...ctxArgs];\n  }\n\n  /**\n   * @description Prepares multiple records for creation\n   * @summary Adds necessary CouchDB fields to multiple records before creation\n   * @param {string} tableName - The name of the table\n   * @param {string[]|number[]} ids - The IDs of the records\n   * @param models - The models to prepare\n   * @return A tuple containing the tableName, ids, and prepared records\n   * @throws {InternalError} If ids and models arrays have different lengths\n   */\n  protected createAllPrefix<M extends Model>(\n    clazz: Constructor<M>,\n    ids: string[] | number[],\n    models: Record<string, any>[],\n    ...args: MaybeContextualArg<Context<FabricClientFlags>>\n  ) {\n    const tableName = Model.tableName(clazz);\n    if (ids.length !== models.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n    const { ctxArgs } = this.logCtx(args, this.createAllPrefix);\n    const records = ids.map((id, count) => {\n      const record: Record<string, any> = {};\n      record[CouchDBKeys.TABLE] = tableName;\n      Object.assign(record, models[count]);\n      return record;\n    });\n    return [clazz, ids, records, ...ctxArgs];\n  }\n\n  protected updateAllPrefix<M extends Model>(\n    clazz: Constructor<M>,\n    ids: PrimaryKeyType[],\n    models: Record<string, any>[],\n    ...args: MaybeContextualArg<Context<FabricClientFlags>>\n  ) {\n    const tableName = Model.tableName(clazz);\n    if (ids.length !== models.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n    const { ctxArgs } = this.logCtx(args, this.updateAllPrefix);\n    const records = ids.map(() => {\n      const record: Record<string, any> = {};\n      record[CouchDBKeys.TABLE] = tableName;\n      return record;\n    });\n    return [clazz, ids, records, ...ctxArgs];\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<M extends Model>(\n    clazz: Constructor<M>,\n    ids: PrimaryKeyType[],\n    models: Record<string, any>[],\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<Record<string, any>[]> {\n    if (ids.length !== models.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n    //HERE!\n    const ctxArgs = [...(args as unknown as any[])];\n    const transient = ctxArgs.shift() as Record<string, any>;\n    const { log, ctx } = this.logCtx(\n      ctxArgs as ContextualArgs<Context<FabricClientFlags>>,\n      this.createAll\n    );\n    const tableName = Model.tableName(clazz);\n\n    log.info(`adding ${ids.length} entries to ${tableName} table`);\n    log.verbose(`pks: ${ids}`);\n    const hasTransient = transient && Object.keys(transient).length > 0;\n    const needsFullPayload =\n      hasTransient || this.shouldForceGatewayHydration(ctx);\n    const transientPayload = hasTransient ? { [tableName]: transient } : {};\n\n    const result = await this.submitTransaction(\n      ctx,\n      BulkCrudOperationKeys.CREATE_ALL,\n      [\n        JSON.stringify(\n          models.map((m) => this.serializer.serialize(m, clazz.name))\n        ),\n      ],\n      transientPayload as any,\n      this.getEndorsingOrganizations(ctx),\n      clazz.name\n    );\n\n    let res: Record<string, any>[];\n    try {\n      res = 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    if (\n      this.shouldRefreshAfterWrite(\n        clazz,\n        ctx,\n        needsFullPayload,\n        res[0][Model.pk(clazz) as string] || ids[0]\n      )\n    ) {\n      return this.readAll(\n        clazz,\n        extractIds(\n          clazz,\n          models.map((m, i) =>\n            Model.merge(Object.assign({}, m as any, transient[i] || {}), res[i])\n          ),\n          ids\n        ),\n        ctx\n      );\n    }\n\n    return res;\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<M extends Model>(\n    clazz: Constructor<M>,\n    ids: PrimaryKeyType[],\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<Record<string, any>[]> {\n    const { log, ctx } = this.logCtx(args, this.readAll);\n    const tableName = Model.tableName(clazz);\n    log.info(`reading ${ids.length} entries to ${tableName} table`);\n    log.verbose(`pks: ${ids}`);\n    const result = await this.evaluateTransaction(\n      ctx,\n      BulkCrudOperationKeys.READ_ALL,\n      [JSON.stringify(ids)],\n      undefined,\n      undefined,\n      clazz.name\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<M extends Model>(\n    clazz: Constructor<M>,\n    ids: PrimaryKeyType[],\n    models: Record<string, any>[],\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<Record<string, any>[]> {\n    if (ids.length !== models.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n    const ctxArgs = [...(args as unknown as any[])];\n    const transient = ctxArgs.shift() as Record<string, any>;\n    const { log, ctx } = this.logCtx(\n      ctxArgs as ContextualArgs<Context<FabricClientFlags>>,\n      this.updateAll\n    );\n    const tableName = Model.tableName(clazz);\n    log.info(`updating ${ids.length} entries to ${tableName} table`);\n    log.verbose(`pks: ${ids}`);\n    const hasTransient = transient && Object.keys(transient).length > 0;\n    const needsFullPayload =\n      hasTransient || this.shouldForceGatewayHydration(ctx);\n    const transientPayload = hasTransient ? { [tableName]: transient } : {};\n\n    const result = await this.submitTransaction(\n      ctx,\n      BulkCrudOperationKeys.UPDATE_ALL,\n      [\n        JSON.stringify(\n          models.map((m) => this.serializer.serialize(m, clazz.name))\n        ),\n      ],\n      transientPayload as any,\n      this.getEndorsingOrganizations(ctx),\n      clazz.name\n    );\n\n    let res: any;\n    try {\n      res = 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    if (this.shouldRefreshAfterWrite(clazz, ctx, needsFullPayload, ids[0])) {\n      return this.readAll(\n        clazz,\n        extractIds(\n          clazz,\n          models.map((m, i) =>\n            Model.merge(Object.assign({}, m as any, transient[i] || {}), res[i])\n          ),\n          ids\n        ),\n        ctx\n      );\n    }\n    return res;\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<M extends Model>(\n    clazz: Constructor<M>,\n    ids: PrimaryKeyType[],\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<Record<string, any>[]> {\n    const { log, ctx, ctxArgs } = this.logCtx(args, this.deleteAll);\n    const tableName = Model.tableName(clazz);\n\n    const needsFullPayload =\n      Model.isTransient(clazz) || this.shouldForceGatewayHydration(ctx);\n    let result: any;\n    const shouldHydrate = this.shouldRefreshAfterWrite(\n      clazz,\n      ctx,\n      needsFullPayload,\n      ids[0]\n    );\n    if (shouldHydrate) {\n      result = await this.readAll(clazz, ids, ...ctxArgs);\n    }\n\n    log.info(`deleting ${ids.length} entries to ${tableName} table`);\n    log.verbose(`pks: ${ids}`);\n    const res = await this.submitTransaction(\n      ctx,\n      BulkCrudOperationKeys.DELETE_ALL,\n      [JSON.stringify(ids)],\n      undefined,\n      this.getEndorsingOrganizations(ctx),\n      clazz.name\n    );\n    try {\n      return shouldHydrate\n        ? result\n        : JSON.parse(this.decode(res)).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    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): SegregatedModel<M> & PreparedModel {\n    const { log, ctx } = this.logCtx(args, this.prepare);\n    const split = Model.segregate(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    const mirrorMeta = Model.mirroredAt(model);\n    if (mirrorMeta) {\n      const mirrorMsp = mirrorMeta.mspId;\n      if (!mirrorMsp) throw new InternalError(`No mirror MSP could be found`);\n      let msps = this.getEndorsingOrganizations(ctx) || [];\n      msps = Array.isArray(msps) ? msps : [msps];\n      const merged = [...new Set([...msps, mirrorMsp])];\n      ctx.accumulate({\n        endorsingOrgs: merged,\n        endorsingOrganizations: merged,\n        legacy: true,\n      });\n    }\n\n    return {\n      record: split.model,\n      model: split.model,\n      id: model[Model.pk(model.constructor as Constructor<M>)] as string,\n      transient: split.transient,\n      privates: split.privates,\n      shared: split.shared,\n    };\n  }\n\n  override revert<M extends Model>(\n    obj: Record<string, any>,\n    clazz: Constructor<M>,\n    id: PrimaryKeyType,\n    transient?: Record<string, any>,\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): M {\n    const { log, ctx } = this.logCtx(args, this.revert);\n    if (\n      transient &&\n      this.shouldRebuildWithTransient(\n        ctx,\n        ctx.getOrUndefined(\"operation\") as string | undefined\n      )\n    ) {\n      log.verbose(\n        `re-adding transient properties: ${Object.keys(transient).join(\", \")}`\n      );\n      Object.entries(transient as Record<string, any>)\n        .filter(([, v]) => typeof v !== \"undefined\")\n        .forEach(([key, val]) => {\n          if (key in obj && (obj as any)[key] !== undefined)\n            log.warn(\n              `overwriting existing ${key}. if this is not a default value, this may pose a problem`\n            );\n          (obj as M)[key as keyof M] = val;\n        });\n    }\n\n    const result = new (clazz as Constructor<M>)(obj);\n\n    return result;\n  }\n\n  private shouldRebuildWithTransient(\n    ctx: Context<FabricClientFlags>,\n    operation?: string\n  ): boolean {\n    if (!ctx) return false;\n    if (ctx.getOrUndefined(\"rebuildWithTransient\")) return true;\n    const childRebuild =\n      typeof (ctx as any).getFromChildren === \"function\"\n        ? (ctx as any).getFromChildren(\"rebuildWithTransient\")\n        : undefined;\n    if (childRebuild) return true;\n    const resolvedOp = this.resolveOperation(ctx, operation);\n    if (!resolvedOp) return false;\n    const op = resolvedOp.toString().toLowerCase();\n    return (\n      op.includes(\"read\") ||\n      op.includes(\"find\") ||\n      op.includes(\"query\") ||\n      op.includes(\"statement\") ||\n      op.includes(\"page\")\n    );\n  }\n\n  private resolveOperation(\n    ctx: Context<FabricClientFlags>,\n    operation?: string\n  ): string | undefined {\n    if (operation) return operation;\n    if (typeof (ctx as any).getFromChildren === \"function\") {\n      return (ctx as any).getFromChildren(\"operation\");\n    }\n    return undefined;\n  }\n\n  private shouldRefreshAfterWrite<M extends Model>(\n    clazz: Constructor<M>,\n    ctx: Context<FabricClientFlags>,\n    hasTransient: boolean,\n    id?: PrimaryKeyType\n  ): boolean {\n    if (!hasTransient) return false;\n    const pk = Model.pk(clazz);\n    const composed = Model.composed(clazz, pk);\n    const generated = Model.generated(clazz, pk);\n    const hasId = id !== undefined && id !== null;\n    if (!hasId && composed) return true;\n    if (!hasId && generated) {\n      ctx.logger.warn(\n        `Cannot refresh record with private generated primary key`\n      );\n      return false;\n    }\n    return hasId;\n  }\n\n  private getEndorsingOrganizations(\n    ctx: Context<FabricClientFlags>\n  ): string[] | undefined {\n    const direct =\n      ctx.getOrUndefined(\"endorsingOrgs\") ||\n      (ctx.getOrUndefined(\"endorsingOrgs\") as string[] | undefined);\n    if (direct && direct.length) return direct;\n    return (\n      (ctx.getFromChildren(\"endorsingOrgs\") as string[] | undefined) ||\n      (ctx.getFromChildren(\"endorsingOrgs\") as string[] | undefined)\n    );\n  }\n\n  private shouldForceGatewayHydration(\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ctx: Context<FabricClientFlags>\n  ): boolean {\n    return !!this.config.allowGatewayOverride;\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()\n  @final()\n  override async create<M extends Model>(\n    clazz: Constructor<M>,\n    id: PrimaryKeyType,\n    model: Record<string, any>,\n    transient: Record<string, any> = {},\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<Record<string, any>> {\n    const ctxArgs = [...(args as unknown as any[])];\n    const { log, ctx } = this.logCtx(\n      ctxArgs as ContextualArgs<Context<FabricClientFlags>>,\n      this.create\n    );\n    const tableName = Model.tableName(clazz);\n    log.verbose(`adding entry to ${tableName} table`);\n    log.debug(`pk: ${id}`);\n    const hasTransient = transient && Object.keys(transient).length > 0;\n    const needsFullPayload =\n      hasTransient || this.shouldForceGatewayHydration(ctx);\n    const transientPayload = hasTransient ? { [tableName]: transient } : {};\n    const result = await this.submitTransaction(\n      ctx,\n      OperationKeys.CREATE,\n      [this.serializer.serialize(model, clazz.name)],\n      transientPayload as any,\n      this.getEndorsingOrganizations(ctx),\n      clazz.name\n    );\n    const deserialized = this.serializer.deserialize(this.decode(result));\n    if (this.shouldRefreshAfterWrite(clazz, ctx, needsFullPayload, id)) {\n      return this.read(\n        clazz,\n        extractIds(\n          clazz,\n          Model.merge(\n            Object.assign({}, model, transient || {}),\n            deserialized,\n            clazz\n          ),\n          id\n        ),\n        ctx\n      );\n    }\n    return deserialized;\n  }\n\n  @debug()\n  @final()\n  async healthcheck<M extends Model>(\n    clazz: Constructor<M>,\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<Record<string, any>> {\n    const { log, ctx } = this.logCtx(args, this.healthcheck);\n    const tableName = Model.tableName(clazz);\n\n    log.verbose(`reading entry from ${tableName} table`);\n    const result = await this.evaluateTransaction(\n      ctx,\n      \"healthcheck\",\n      [],\n      undefined,\n      undefined,\n      clazz.name\n    );\n    return JSON.parse(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()\n  @final()\n  async read<M extends Model>(\n    clazz: Constructor<M>,\n    id: PrimaryKeyType,\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<Record<string, any>> {\n    const { log, ctx } = this.logCtx(args, this.read);\n    const tableName = Model.tableName(clazz);\n\n    log.verbose(`reading entry from ${tableName} table`);\n    log.debug(`pk: ${id}`);\n    const result = await this.evaluateTransaction(\n      ctx,\n      OperationKeys.READ,\n      [id.toString()],\n      undefined,\n      undefined,\n      clazz.name\n    );\n    return this.serializer.deserialize(this.decode(result));\n  }\n\n  updatePrefix<M extends Model>(\n    clazz: Constructor<M>,\n    id: PrimaryKeyType,\n    model: Record<string, any>,\n    ...args: MaybeContextualArg<Context<FabricClientFlags>>\n  ) {\n    const tableName = Model.tableName(clazz);\n    const { ctxArgs } = this.logCtx(args, this.updatePrefix);\n    const record: Record<string, any> = {};\n    record[CouchDBKeys.TABLE] = tableName;\n    // record[CouchDBKeys.ID] = this.generateId(tableName, id);\n    Object.assign(record, model);\n    return [clazz, id, record, ...ctxArgs];\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()\n  @final()\n  async update<M extends Model>(\n    clazz: Constructor<M>,\n    id: PrimaryKeyType,\n    model: Record<string, any>,\n    transient: Record<string, any> = {},\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<Record<string, any>> {\n    const ctxArgs = [...(args as unknown as any[])];\n    const { log, ctx } = this.logCtx(\n      ctxArgs as ContextualArgs<Context<FabricClientFlags>>,\n      this.update\n    );\n    log.info(`CLIENT UPDATE class : ${typeof clazz}`);\n    const tableName = Model.tableName(clazz);\n    log.verbose(`updating entry to ${tableName} table`);\n    log.debug(`pk: ${id}`);\n    const hasTransient = transient && Object.keys(transient).length > 0;\n    const needsFullPayload =\n      hasTransient || this.shouldForceGatewayHydration(ctx);\n    const transientPayload = hasTransient ? { [tableName]: transient } : {};\n    const result = await this.submitTransaction(\n      ctx,\n      OperationKeys.UPDATE,\n      [this.serializer.serialize(model, clazz.name || clazz)], // TODO should be receving class but is receiving string\n      transientPayload as any,\n      this.getEndorsingOrganizations(ctx),\n      clazz.name\n    );\n    const deserialized = this.serializer.deserialize(this.decode(result));\n    if (this.shouldRefreshAfterWrite(clazz, ctx, needsFullPayload, id)) {\n      return this.read(\n        clazz,\n        extractIds(\n          clazz,\n          Model.merge(\n            Object.assign({}, model, transient || {}),\n            deserialized,\n            clazz\n          ),\n          id\n        ),\n        ctx\n      );\n    }\n    return deserialized;\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()\n  @final()\n  override async delete<M extends Model>(\n    clazz: Constructor<M>,\n    id: PrimaryKeyType,\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<Record<string, any>> {\n    const { log, ctx } = this.logCtx(args, this.delete);\n    const tableName = Model.tableName(clazz);\n    const needsFullPayload =\n      Model.isTransient(clazz) || this.shouldForceGatewayHydration(ctx);\n    let result: any;\n    const shouldHydrate = this.shouldRefreshAfterWrite(\n      clazz,\n      ctx,\n      needsFullPayload,\n      id\n    );\n    if (shouldHydrate) {\n      result = await this.read(clazz, id, ctx);\n    }\n\n    log.verbose(`deleting entry from ${tableName} table`);\n    log.debug(`pk: ${id}`);\n    const res = await this.submitTransaction(\n      ctx,\n      OperationKeys.DELETE,\n      [id.toString()],\n      undefined,\n      this.getEndorsingOrganizations(ctx),\n      clazz.name\n    );\n    return shouldHydrate\n      ? result\n      : this.serializer.deserialize(this.decode(res));\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()\n  async raw<V, D extends boolean>(\n    rawInput: MangoQuery,\n    docsOnly: D = true as D,\n    clazz: ModelConstructor<any>,\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<V> {\n    const { log, ctx } = this.logCtx(args, this.raw);\n    const tableName = clazz.name;\n    log.info(`Performing raw statement on table ${Model.tableName(clazz)}`);\n    let transactionResult: any;\n    try {\n      transactionResult = await this.evaluateTransaction(\n        ctx,\n        \"raw\",\n        [JSON.stringify(rawInput), docsOnly],\n        undefined,\n        undefined,\n        tableName\n      );\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 Executes a CouchDB view query against the Fabric chaincode\n   * @summary Evaluates a transaction to query a design document view\n   * @template R - The view response type\n   * @param {string} ddoc - Design document name\n   * @param {string} viewName - View name\n   * @param {Record<string, any>} options - View query options\n   * @param {...ContextualArgs<Context<FabricClientFlags>>} args - Optional contextual arguments\n   * @return {Promise<ViewResponse<R>>} The view response\n   */\n  @debug()\n  async view<R>(\n    ddoc: string,\n    viewName: string,\n    options: Record<string, any>,\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<ViewResponse<R>> {\n    const { log, ctx } = this.logCtx(args, this.view);\n    log.info(`Querying view ${ddoc}/${viewName}`);\n    let transactionResult: any;\n    try {\n      transactionResult = await this.evaluateTransaction(\n        ctx,\n        \"view\",\n        [ddoc, viewName, JSON.stringify(options)],\n        undefined,\n        undefined,\n        undefined\n      );\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n    let result: ViewResponse<R>;\n    try {\n      result = JSON.parse(this.decode(transactionResult));\n    } catch (e: any) {\n      throw new SerializationError(`Failed to process view result: ${e}`);\n    }\n    return result;\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(ctx: Context<FabricClientFlags>): Promise<Gateway> {\n    return FabricClientAdapter.getGateway(ctx, this.config, this.client);\n  }\n\n  private getContractName(className?: string) {\n    if (!className) return undefined;\n    return `${className}Contract`;\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(\n    ctx: Context<FabricClientFlags>,\n    contractName?: string\n  ): Promise<Contrakt> {\n    return FabricClientAdapter.getContract(\n      await this.Gateway(ctx),\n      this.config,\n      contractName\n    );\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    ctx: Context<FabricClientFlags>,\n    api: string,\n    submit = true,\n    args?: any[],\n    transientData: Record<string, string> = {},\n    endorsingOrganizations?: string[],\n    className?: string\n  ): Promise<Uint8Array> {\n    const log = this.log.for(this.transaction);\n    const gateway = await this.Gateway(ctx);\n    try {\n      const contract = await this.Contract(\n        ctx,\n        this.getContractName(className)\n      );\n      log.verbose(\n        `${submit ? \"Submit\" : \"Evaluate\"}ting transaction ${this.getContractName(className) || 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      endorsingOrganizations = endorsingOrganizations?.length\n        ? endorsingOrganizations\n        : undefined;\n      const proposalOptions: ProposalOptions = {\n        arguments: args || [],\n        transientData: Object.entries(transientData).reduce(\n          (acc, [key, val]) => {\n            acc[key] = JSON.stringify(val);\n            return acc;\n          },\n          {} as typeof transientData\n        ),\n        endorsingOrganizations: ctx.getOrUndefined(\"allowManualEndorsingOrgs\")\n          ? endorsingOrganizations || undefined\n          : undefined, // mspId list\n      };\n\n      return await method.call(contract, api, proposalOptions);\n    } catch (e: any) {\n      throw this.parseError(e);\n    } finally {\n      this.log.debug(`Closing ${this.config.mspId} gateway connection`);\n      gateway.close();\n    }\n  }\n\n  private shouldUseLegacyGateway(ctx: Context<FabricClientFlags>): boolean {\n    return !!ctx.getOrUndefined(\"legacy\") && !!this.config.allowGatewayOverride;\n  }\n\n  private prepareLegacyArgs(args?: any[]): string[] {\n    return (args || []).map((arg) =>\n      typeof arg === \"string\" ? arg : JSON.stringify(arg)\n    );\n  }\n\n  private buildLegacyTransient(\n    transientData?: Record<string, string>\n  ): Record<string, Buffer> | undefined {\n    if (!transientData) return undefined;\n    const entries = Object.entries(transientData);\n    if (!entries.length) return undefined;\n    const map: Record<string, Buffer> = {};\n    for (const [key, value] of entries) {\n      map[key] = Buffer.from(JSON.stringify(value));\n    }\n    return map;\n  }\n\n  private resolveLegacyMspCount(): number {\n    const configured = this.config.legacyMspCount ?? 1;\n    const parsed = Number(configured);\n    if (!Number.isFinite(parsed) || parsed < 1) return 1;\n    return Math.floor(parsed);\n  }\n\n  private pickLegacyCandidates(\n    candidates: MspDetails[],\n    limit: number\n  ): MspDetails[] {\n    if (!candidates.length || limit <= 0) return [];\n    const available = [...candidates];\n    const target = Math.min(limit, available.length);\n    const picked: MspDetails[] = [];\n    while (picked.length < target && available.length) {\n      const idx = Math.floor(Math.random() * available.length);\n      const [selection] = available.splice(idx, 1);\n      if (selection) {\n        picked.push(selection);\n      }\n    }\n    return picked;\n  }\n\n  private buildLegacyPeerConfigs(\n    ctx: Context<FabricClientFlags>\n  ): LegacyPeerTarget[] {\n    const peers: LegacyPeerTarget[] = [\n      {\n        mspId: this.config.mspId,\n        peerEndpoint: this.config.peerEndpoint,\n        peerHostAlias: this.config.peerHostAlias,\n        tlsCert: this.config.tlsCert,\n      },\n    ];\n\n    let endorsingOrgs = this.getEndorsingOrganizations(ctx) || [];\n    endorsingOrgs = Array.isArray(endorsingOrgs)\n      ? endorsingOrgs\n      : [endorsingOrgs];\n    const endorsers =\n      endorsingOrgs.filter((org): org is string => Boolean(org)) || [];\n    const extras = endorsers.filter((org) => org !== this.config.mspId);\n    if (!extras.length) return peers;\n\n    const map = this.config.mspMap;\n    const legacyCount = this.resolveLegacyMspCount();\n    for (const msp of extras) {\n      const candidates = map?.[msp];\n      if (!candidates?.length) {\n        throw new UnsupportedError(\n          `No peer mapping available for MSP ${msp}. Provide it via config.mspMap`\n        );\n      }\n      const selections = this.pickLegacyCandidates(candidates, legacyCount);\n      if (!selections.length) {\n        throw new UnsupportedError(\n          `No valid peer mapping available for MSP ${msp}. Provide it via config.mspMap`\n        );\n      }\n      for (const choice of selections) {\n        if (!choice.endpoint) {\n          throw new UnsupportedError(\n            `Invalid peer mapping for MSP ${msp}: missing endpoint`\n          );\n        }\n        peers.push({\n          mspId: msp,\n          peerEndpoint: choice.endpoint,\n          peerHostAlias: choice.alias,\n          tlsCert: choice.tlsCert || this.config.tlsCert,\n        });\n      }\n    }\n\n    return peers;\n  }\n\n  private async submitLegacyWithExplicitEndorsers(\n    ctx: Context<FabricClientFlags>,\n    fcn: string,\n    args: string[],\n    transientMap: Record<string, Buffer> | undefined,\n    peerConfigs: LegacyPeerTarget[],\n    className?: string\n  ): Promise<Uint8Array> {\n    const log = this.log.for(this.submitLegacyWithExplicitEndorsers);\n    const peers = this.normalizeLegacyPeers(peerConfigs);\n    const identityMaterial = await this.resolveLegacyIdentityMaterial();\n    const wallet = await Wallets.newInMemoryWallet();\n    const identityLabel = `${this.config.mspId}-legacy`;\n    await wallet.put(identityLabel, {\n      credentials: {\n        certificate: identityMaterial.certificate,\n        privateKey: identityMaterial.privateKey,\n      },\n      mspId: this.config.mspId,\n      type: \"X.509\",\n    } as Identity);\n\n    const connectionProfile = await this.buildLegacyConnectionProfile(peers);\n    const gateway = new LegacyGateway();\n\n    try {\n      await gateway.connect(connectionProfile, {\n        identity: identityLabel,\n        wallet,\n        discovery: {\n          enabled: true,\n          asLocalhost: this.shouldTreatPeersAsLocalhost(peers),\n        },\n        tlsInfo: {\n          certificate: identityMaterial.certificate,\n          key: identityMaterial.privateKey,\n        },\n      });\n\n      const network = await gateway.getNetwork(this.config.channel);\n      const contract = network.getContract(\n        this.config.chaincodeName,\n        this.getContractName(className)\n      );\n      const transaction = contract.createTransaction(fcn);\n\n      if (transientMap) {\n        transaction.setTransient(transientMap);\n      }\n\n      const endorsers = peers\n        .map((peer) => network.getChannel().getEndorser(peer.name))\n        .filter((endorser): endorser is Endorser => Boolean(endorser));\n      if (endorsers.length) {\n        transaction.setEndorsingPeers(endorsers);\n      }\n\n      log.verbose(\n        `Legacy submitting ${this.getContractName(className) || this.config.contractName}.${fcn} via peers ${peers.map((p) => p.peerEndpoint).join(\", \")}`\n      );\n\n      const result = await transaction.submit(...args);\n      return Uint8Array.from(result);\n    } catch (e: any) {\n      throw this.parseError(e);\n    } finally {\n      gateway.disconnect();\n    }\n  }\n\n  private normalizeLegacyPeers(\n    peers: LegacyPeerTarget[]\n  ): LegacyPeerWithName[] {\n    const deduped = new Map<string, LegacyPeerWithName>();\n    const addPeer = (peer: LegacyPeerTarget) => {\n      const key = `${peer.peerEndpoint}|${peer.peerHostAlias || \"\"}`;\n      if (deduped.has(key)) return;\n      const name = `peer-${peer.mspId}-${deduped.size}`;\n      deduped.set(key, {\n        ...peer,\n        name,\n      });\n    };\n\n    peers.forEach(addPeer);\n    addPeer({\n      mspId: this.config.mspId,\n      peerEndpoint: this.config.peerEndpoint,\n      peerHostAlias: this.config.peerHostAlias,\n    });\n\n    return Array.from(deduped.values());\n  }\n\n  private async resolveLegacyIdentityMaterial(): Promise<{\n    certificate: string;\n    privateKey: string;\n  }> {\n    const certificate = await this.readPemInput(\n      this.config.certCertOrDirectoryPath\n    );\n    const privateKey = await this.readPemInput(\n      this.config.keyCertOrDirectoryPath\n    );\n    return { certificate, privateKey };\n  }\n\n  private async buildLegacyConnectionProfile(peers: LegacyPeerWithName[]) {\n    const peerEntries: Record<string, any> = {};\n    const channelPeers: Record<string, any> = {};\n    const orgs: Record<string, any> = {};\n    for (const peer of peers) {\n      const tlsPem = await this.readPemInput(\n        peer.tlsCert || this.config.tlsCert\n      );\n      const hostname =\n        peer.peerHostAlias || this.extractHost(peer.peerEndpoint);\n      peerEntries[peer.name] = {\n        url: this.ensureGrpcUrl(peer.peerEndpoint),\n        tlsCACerts: { pem: tlsPem },\n        grpcOptions: {\n          \"ssl-target-name-override\": hostname,\n          hostnameOverride: hostname,\n        },\n      };\n      channelPeers[peer.name] = {\n        endorsingPeer: true,\n        chaincodeQuery: true,\n        ledgerQuery: true,\n        eventSource: true,\n      };\n      orgs[peer.mspId] = orgs[peer.mspId] || {\n        mspid: peer.mspId,\n        peers: [],\n      };\n      orgs[peer.mspId].peers.push(peer.name);\n    }\n\n    return {\n      name: \"legacy-manual\",\n      version: \"1.0.0\",\n      client: {\n        organization: this.config.mspId,\n      },\n      organizations: orgs,\n      peers: peerEntries,\n      orderers: {},\n      channels: {\n        [this.config.channel]: {\n          peers: channelPeers,\n        },\n      },\n    };\n  }\n\n  private shouldTreatPeersAsLocalhost(peers: LegacyPeerWithName[]): boolean {\n    return peers.every((peer) => this.isLocalEndpoint(peer.peerEndpoint));\n  }\n\n  private isLocalEndpoint(endpoint: string): boolean {\n    const host = this.extractHost(endpoint).toLowerCase();\n    return host === \"localhost\" || host === \"127.0.0.1\";\n  }\n\n  private extractHost(endpoint: string): string {\n    const sanitized = endpoint.replace(/^grpcs?:\\/\\//, \"\");\n    return sanitized.split(\":\")[0];\n  }\n\n  private ensureGrpcUrl(endpoint: string): string {\n    if (/^grpcs?:\\/\\//i.test(endpoint)) return endpoint;\n    return `grpcs://${endpoint}`;\n  }\n\n  private async readPemInput(source?: string | Buffer): Promise<string> {\n    if (!source) throw new InternalError(\"Missing certificate or key material\");\n    if (Buffer.isBuffer(source)) return source.toString(\"utf8\");\n    const trimmed = source.trim();\n    if (/-----BEGIN [A-Z ]+-----/.test(trimmed)) return trimmed;\n    const stats = await fs.promises.stat(source).catch(() => undefined);\n    if (stats?.isDirectory()) {\n      return await getFirstDirFileNameContent(source);\n    }\n    return (await readFsFile(source)).toString();\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<E extends BaseError>(err: Error | string): E {\n    return FabricClientAdapter.parseError<E>(err);\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    ctx: Context<FabricClientFlags>,\n    api: string,\n    args?: any[],\n    transientData?: Record<string, string>,\n    endorsingOrganizations?: Array<string>,\n    className?: string\n  ): Promise<Uint8Array> {\n    if (this.shouldUseLegacyGateway(ctx)) {\n      const legacyArgs = this.prepareLegacyArgs(args);\n      const transientMap = this.buildLegacyTransient(transientData);\n      const peerConfigs = this.buildLegacyPeerConfigs(ctx);\n      return this.submitLegacyWithExplicitEndorsers(\n        ctx,\n        api,\n        legacyArgs,\n        transientMap,\n        peerConfigs,\n        className\n      );\n    }\n    return this.transaction(\n      ctx,\n      api,\n      true,\n      args,\n      transientData,\n      endorsingOrganizations,\n      className\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    ctx: Context<FabricClientFlags>,\n    api: string,\n    args?: any[],\n    transientData?: Record<string, string>,\n    endorsingOrganizations?: Array<string>,\n    className?: string\n  ): Promise<Uint8Array> {\n    return this.transaction(\n      ctx,\n      api,\n      false,\n      args,\n      transientData,\n      endorsingOrganizations,\n      className\n    );\n  }\n\n  /**\n   * @description Shuts down the connection to the Fabric network\n   * @summary Closes the active dispatch (which in turn closes any gateway\n   * event subscription) via the base class, then closes the gRPC client.\n   * Works correctly regardless of whether `syntheticEvents` is enabled.\n   * @return {Promise<void>} Promise that resolves when all connections are closed\n   */\n  override async shutdown(...args: MaybeContextualArg<Context<FabricClientFlags>>): Promise<void> {\n    // Base class handles dispatch.close() internally.\n    await super.shutdown(...args);\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(\n    gateway: Gateway,\n    config: PeerConfig,\n    contractName?: string\n  ): 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 ${contractName || config.contractName} from network ${config.channel}`\n      );\n      contractName = contractName ? contractName : config.contractName;\n      contract = network.getContract(config.chaincodeName, 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 = Logging.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(\n    ctx: Context<FabricClientFlags>,\n    config: PeerConfig,\n    client?: Client\n  ) {\n    return (await this.getConnection(\n      client || (await this.getClient(config)),\n      config,\n      ctx\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    let pathOrCert: string | Buffer = config.tlsCert as string | Buffer;\n\n    if (typeof pathOrCert === \"string\") {\n      if (\n        pathOrCert.match(\n          /-----BEGIN (CERTIFICATE|KEY|PRIVATE KEY)-----.+?-----END \\1-----$/gms\n        )\n      ) {\n        pathOrCert = Buffer.from(pathOrCert, \"utf8\");\n      } else {\n        try {\n          pathOrCert = Buffer.from(fs.readFileSync(pathOrCert, \"utf8\"));\n        } catch (e: unknown) {\n          throw new InternalError(\n            `Failed to read the tls certificate from ${pathOrCert}: ${e}`\n          );\n        }\n      }\n    }\n\n    const tlsCredentials = grpc.credentials.createSsl(pathOrCert);\n    log.debug(`generating Gateway Client for url ${config.peerEndpoint}`);\n    return new Client(config.peerEndpoint, tlsCredentials, {\n      \"grpc.max_receive_message_length\": (config.sizeLimit || 15) * 1024 * 1024,\n      \"grpc.max_send_message_length\": (config.sizeLimit || 15) * 1024 * 1024,\n    });\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(\n    client: Client,\n    config: PeerConfig,\n    ctx: Context<FabricClientFlags>\n  ) {\n    const log = Logging.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 as any\n    );\n    try {\n      log.debug(\n        `preparing transaction signer for ${CryptoUtils.fabricIdFromCertificate(identity.credentials.toString())}`\n      );\n    } catch (e: unknown) {\n      log.error(`Failed to extract Fabric ID from certificate`, e as Error);\n    }\n\n    let signer: Signer;\n    const close = () => {};\n    if (!config.hsm) {\n      signer = await getSigner(config.keyCertOrDirectoryPath as any);\n    } else {\n      // const hsm = new HSMSignerFactoryCustom(config.hsm.library);\n      // const identifier = hsm.getSKIFromCertificatePath(\n      //   config.certCertOrDirectoryPath as any\n      // );\n      // const pkcs11Signer = hsm.newSigner({\n      //   label: config.hsm.tokenLabel as string,\n      //   pin: String(config.hsm.pin) as string,\n      //   identifier: identifier,\n      //   // userType: 1 /*CKU_USER */,\n      // });\n      // signer = pkcs11Signer.signer;\n      // close = pkcs11Signer.close;\n      throw new UnsupportedError(\"HSM NOT IMPLEMENTED\");\n    }\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() + 1000 * ctx.get(\"evaluateTimeout\") }; // defaults to 5 seconds\n      },\n      endorseOptions: () => {\n        return { deadline: Date.now() + 1000 * ctx.get(\"endorseTimeout\") }; // defaults to 15 seconds\n      },\n      submitOptions: () => {\n        return { deadline: Date.now() + 1000 * ctx.get(\"submitTimeout\") }; // defaults to 5 seconds\n      },\n      commitStatusOptions: () => {\n        return { deadline: Date.now() + 1000 * ctx.get(\"commitTimeout\") }; // defaults to 1 minute\n      },\n    } as ConnectOptions;\n\n    log.debug(`Connecting to ${config.mspId}`);\n    const gateway = connect(options);\n\n    // TODO: replace?\n    if (config.hsm) {\n      gateway.close = new Proxy(gateway.close, {\n        apply(target: () => void, thisArg: any, argArray: any[]): any {\n          Reflect.apply(target, thisArg, argArray);\n          close();\n        },\n      });\n    }\n\n    return gateway;\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(): FabricClientDispatch {\n    return new FabricClientAdapter[\"_baseDispatch\"](this.client);\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 parseError<E extends BaseError>(\n    err: Error | string | GatewayError\n  ): E {\n    // if (\n    //   MISSING_PRIVATE_DATA_REGEX.test(\n    //     typeof err === \"string\" ? err : err.message\n    //   )\n    // )\n    //   return new UnauthorizedPrivateDataAccess(err) as E;\n\n    let msg = typeof err === \"string\" ? err : err.message;\n    if (err instanceof GatewayError && err.details.length && err.code === 10) {\n      msg = `${err.details[0].message}`;\n    }\n\n    if (\n      err instanceof EndorseError &&\n      err.details.length &&\n      err.code === 10 &&\n      err.details[0].message?.includes(UnsupportedError.name)\n    ) {\n      msg = `${err.details[0].message}`;\n    }\n\n    if (msg.includes(\"MVCC_READ_CONFLICT\"))\n      return new MvccReadConflictError(err) as E;\n\n    if (msg.includes(\"DEADLINE_EXCEEDED\"))\n      return new TransactionTimeoutError(err) as E;\n\n    if (msg.includes(\"ENDORSEMENT_POLICY_FAILURE\"))\n      return new EndorsementPolicyError(err) as E;\n\n    if (msg.includes(\"PHANTOM_READ_CONFLICT\"))\n      return new PhantomReadConflictError(err) as E;\n\n    if (err instanceof Error && (err as any).code) {\n      switch ((err as any).code) {\n        case 9:\n          return new EndorsementError(err) as E;\n      }\n    }\n\n    if (msg.includes(ValidationError.name))\n      return new ValidationError(err) as E;\n    if (msg.includes(NotFoundError.name)) return new NotFoundError(err) as E;\n    if (msg.includes(ConflictError.name)) return new ConflictError(err) as E;\n    if (msg.includes(BadRequestError.name))\n      return new BadRequestError(err) as E;\n    if (msg.includes(QueryError.name)) return new QueryError(err) as E;\n    if (msg.includes(PagingError.name)) return new PagingError(err) as E;\n    if (msg.includes(UnsupportedError.name))\n      return new UnsupportedError(err) as E;\n    if (msg.includes(MigrationError.name)) return new MigrationError(err) as E;\n    if (msg.includes(ObserverError.name)) return new ObserverError(err) as E;\n    if (msg.includes(AuthorizationError.name))\n      return new AuthorizationError(err) as E;\n    if (msg.includes(ForbiddenError.name)) return new ForbiddenError(err) as E;\n    if (msg.includes(ConnectionError.name))\n      return new ConnectionError(err) as E;\n    if (msg.includes(SerializationError.name))\n      return new SerializationError(err) as E;\n    return new InternalError(err) as E;\n  }\n}\n\nFabricClientAdapter.decoration();\nAdapter.setCurrent(FabricFlavour);\n","import {\n  Adapter,\n  ContextualArgs,\n  Dispatch,\n  EventIds,\n  UnsupportedError,\n  Context,\n  MaybeContextualArg,\n  PersistenceKeys,\n} from \"@decaf-ts/core\";\nimport { PeerConfig } from \"../shared/types\";\nimport { Client } from \"@grpc/grpc-js\";\nimport { FabricClientAdapter } from \"./FabricClientAdapter\";\nimport {\n  BulkCrudOperationKeys,\n  InternalError,\n  OperationKeys,\n} from \"@decaf-ts/db-decorators\";\nimport {\n  ChaincodeEvent,\n  CloseableAsyncIterable,\n} from \"@hyperledger/fabric-gateway\";\nimport { parseEventName } from \"../shared/events\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { Constructor } from \"@decaf-ts/decoration\";\nimport { FabricClientFlags } from \"./types\";\n\n/**\n * @description Event dispatcher for Hyperledger Fabric chaincode events\n * @summary Listens for and processes events emitted by Fabric chaincode, dispatching them to registered observers\n * @template PeerConfig - Configuration type for connecting to a Fabric peer\n * @param client - gRPC client for connecting to the Fabric network\n * @class FabricClientDispatch\n * @example\n * ```typescript\n * // Create a new FabricDispatch instance\n * const client = await FabricAdapter.getClient(peerConfig);\n * const dispatch = new FabricDispatch(client);\n *\n * // Configure the dispatch with peer configuration\n * dispatch.configure(peerConfig);\n *\n * // Register an observer for a specific table and event\n * dispatch.observe('users', 'create', (id) => {\n *   console.log(`User created: ${id}`);\n * });\n *\n * // Start listening for events\n * await dispatch.start();\n * ```\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant FabricDispatch\n *   participant Gateway\n *   participant Network\n *   participant Chaincode\n *\n *   Client->>FabricDispatch: new FabricDispatch(client)\n *   Client->>FabricDispatch: configure(peerConfig)\n *   Client->>FabricDispatch: observe(table, event, callback)\n *   Client->>FabricDispatch: start()\n *   FabricDispatch->>FabricDispatch: initialize()\n *   FabricDispatch->>Gateway: getGateway(config, client)\n *   Gateway->>Network: getNetwork(channel)\n *   Network->>Network: getChaincodeEvents(chaincodeName)\n *   FabricDispatch->>FabricDispatch: handleEvents()\n *   loop For each event\n *     Chaincode-->>FabricDispatch: ChaincodeEvent\n *     FabricDispatch->>FabricDispatch: parseEventName(eventName)\n *     FabricDispatch->>FabricDispatch: parsePayload(payload)\n *     FabricDispatch->>FabricDispatch: updateObservers(table, event, id)\n *     FabricDispatch-->>Client: callback(id)\n *   end\n */\nexport class FabricClientDispatch extends Dispatch<FabricClientAdapter> {\n  /**\n   * @description Event listening stack for chaincode events\n   */\n  private listeningStack?: CloseableAsyncIterable<ChaincodeEvent>;\n\n  /**\n   * @description Text decoder for converting event payloads from bytes to strings\n   */\n  private decoder = new TextDecoder(\"utf8\");\n\n  /**\n   * @description Creates a new FabricDispatch instance\n   * @summary Initializes a dispatcher for Fabric chaincode events\n   * @param {Client} client - gRPC client for connecting to the Fabric network\n   */\n  constructor(protected client: Client) {\n    super();\n  }\n\n  /**\n   * @description Closes the event listening connection\n   * @summary Stops listening for chaincode events and releases resources\n   * @return {Promise<void>} Promise that resolves when the connection is closed\n   */\n  override async close(\n    ...ctxArgs: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<void> {\n    const { log, ctxArgs: loggedArgs } = (\n      await this.logCtx(ctxArgs, PersistenceKeys.SHUTDOWN, true)\n    ).for(this.close);\n    try {\n      await super.close(...loggedArgs);\n    } catch (e: unknown) {\n      log.error(`Failed to close Fabric proxies event listener`, e as Error);\n    }\n    if (this.listeningStack) {\n      try {\n        await this.listeningStack.close();\n      } catch (e: unknown) {\n        log.error(`Failed to close Fabric event listener`, e as Error);\n      } finally {\n        this.listeningStack = undefined;\n      }\n    }\n  }\n\n  /**\n   * @description Parses event payload from binary format\n   * @summary Converts a Uint8Array containing JSON to an object with an id property\n   * @param {Uint8Array} jsonBytes - The binary payload from the chaincode event\n   * @return {{ id: string }} The parsed payload containing the record ID\n   */\n  private parsePayload(jsonBytes: Uint8Array): { id: string; result?: any } {\n    const json = this.decoder.decode(jsonBytes);\n    return JSON.parse(json);\n  }\n\n  /**\n   * @description Starts observing an adapter\n   * @summary Connects this dispatch to an adapter to monitor its operations\n   * @param {Adapter<any, any, any, any>} observer - The adapter to observe\n   * @return {void}\n   */\n  override observe(observer: Adapter<any, any, any, any>): () => void {\n    if (!(observer instanceof FabricClientAdapter))\n      throw new UnsupportedError(\n        \"Only FabricClientAdapter can be observed by dispatch\"\n      );\n    super.observe(observer as FabricClientAdapter);\n    return () => this.unObserve(observer);\n  }\n\n  /**\n   * @description Updates observers about a database event\n   * @summary Notifies observers about a change in the database\n   * @param {string} table - The name of the table where the change occurred\n   * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of operation that occurred\n   * @param {any} payload - The event payload\n   * @return {Promise<void>} A promise that resolves when all observers have been notified\n   */\n  override async updateObservers(\n    model: Constructor<any> | string,\n    event: OperationKeys | BulkCrudOperationKeys | string,\n    id: EventIds,\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<void> {\n    const { log, ctxArgs } = Adapter.logCtx<Context<FabricClientFlags>>(\n      this.updateObservers,\n      event,\n      false,\n      ...args\n    );\n    if (!this.adapter) {\n      log.verbose(\n        `No adapter observed for dispatch; skipping observer update for ${typeof model === \"string\" ? model : Model.tableName(model)}:${event}`\n      );\n      return;\n    }\n    try {\n      await this.adapter.refresh(model, event, id, ...ctxArgs);\n    } catch (e: unknown) {\n      throw new InternalError(`Failed to refresh dispatch: ${e}`);\n    }\n  }\n\n  /**\n   * @description Processes incoming chaincode events\n   * @summary Listens for events from the chaincode and dispatches them to registered observers\n   * @return {Promise<void>} Promise that resolves when event handling stops\n   * @mermaid\n   * sequenceDiagram\n   *   participant FabricDispatch\n   *   participant EventStack\n   *   participant EventParser\n   *   participant Observers\n   *\n   *   FabricDispatch->>FabricDispatch: handleEvents()\n   *   FabricDispatch->>EventStack: for await (const evt of listeningStack)\n   *   EventStack-->>FabricDispatch: ChaincodeEvent\n   *   FabricDispatch->>EventParser: parseEventName(evt.eventName)\n   *   EventParser-->>FabricDispatch: { table, event, owner }\n   *   FabricDispatch->>FabricDispatch: Check if event is for this MSP\n   *   FabricDispatch->>FabricDispatch: parsePayload(evt.payload)\n   *   FabricDispatch->>Observers: updateObservers(table, event, payload.id)\n   *   Observers-->>FabricDispatch: Callbacks executed\n   */\n  protected async handleEvents(\n    ctxArg?: Context<FabricClientFlags>\n  ): Promise<void> {\n    if (!this.listeningStack)\n      throw new InternalError(\n        `Event stack not initialized. Ensure that \"startListening\" is called before attempting this operation.`\n      );\n\n    if (!this.adapter || !this.adapter.config)\n      throw new InternalError(`No adapter found. should be impossible`);\n\n    const ctx =\n      ctxArg ||\n      (await this.adapter.context(\n        OperationKeys.READ,\n        {\n          correlationId: this.adapter.config.chaincodeName,\n        },\n        (this.models && this.models[0]) || (Model as unknown as Constructor)\n      ));\n    const log = this.log.for(this.handleEvents);\n\n    log.info(\n      `Listening for incoming events on chaincode \"${this.adapter.config.chaincodeName}\" on channel \"${this.adapter.config.channel}\"...`\n    );\n\n    try {\n      for await (const evt of this.listeningStack) {\n        const { table, event, owner } = parseEventName(evt.eventName);\n        if (\n          this.adapter.config?.mspEventOnly &&\n          owner &&\n          owner !== this.adapter.config?.mspId\n        )\n          continue;\n        const payload: { id: string; result?: any } = this.parsePayload(\n          evt.payload\n        );\n        try {\n          const targetModel = table\n            ? Model.get(table)\n            : Model.get(this.models[0].name);\n          const modelRef = targetModel ?? (table || this.models[0]?.name);\n          const observerArgs = payload.result ? [payload.result, ctx] : [ctx];\n          await this.updateObservers(\n            modelRef as Constructor | string,\n            event,\n            payload.id as string,\n            ...(observerArgs as ContextualArgs<any>)\n          );\n        } catch (e: unknown) {\n          log.error(\n            `Failed update observables for table ${table} event ${event} id: ${payload.id}: ${e}`\n          );\n        }\n      }\n    } catch (e: any) {\n      log.error(\n        `Failed to read event for chaincode \"${this.adapter.config.chaincodeName}\" on channel \"${this.adapter.config.channel}\": ${e}`\n      );\n      await this.close(ctx);\n    }\n  }\n\n  /**\n   * @description Initializes the event listener\n   * @summary Sets up event dispatching for the observed adapter. When\n   * `syntheticEvents` is true (the default) no gateway connection is opened;\n   * instead every CRUD operation is wrapped with a Proxy that fires\n   * `updateObservers` for **all** models. When `syntheticEvents` is false the\n   * existing gateway-based chaincode-event subscription is established and the\n   * local Proxy fallback is limited to fully-segregated (transient) models only.\n   * @return {Promise<void>} Promise that resolves when initialization is complete\n   */\n  protected override async initialize(): Promise<void> {\n    if (!this.adapter)\n      throw new InternalError(`No adapter or config observed for dispatch`);\n\n    const syntheticEvents = this.adapter.config.syntheticEvents !== false;\n\n    if (!syntheticEvents) {\n      // Gateway-based chaincode-event subscription (non-synthetic path)\n      const context = await this.adapter.context(\n        \"dispatch\",\n        {\n          correlationId: this.adapter.config.chaincodeName,\n        },\n        Model as any\n      );\n      const { ctx } = this.logCtx([context], this.initialize);\n      const gateway = await FabricClientAdapter.getGateway(\n        ctx,\n        this.adapter.config as PeerConfig,\n        this.client\n      );\n      const network = gateway.getNetwork(this.adapter.config.channel);\n      if (!this.adapter)\n        throw new InternalError(`No adapter observed for dispatch`);\n      this.listeningStack = await network.getChaincodeEvents(\n        this.adapter.config.chaincodeName\n      );\n      this.handleEvents(ctx);\n    }\n\n    // Proxy CRUD methods.\n    // • syntheticEvents = true  → notify for ALL models (replaces gateway events entirely)\n    // • syntheticEvents = false → notify only for fully-segregated (transient) models\n    //   (the gateway subscription handles public models)\n    (\n      [\n        OperationKeys.CREATE,\n        OperationKeys.UPDATE,\n        OperationKeys.DELETE,\n        BulkCrudOperationKeys.CREATE_ALL,\n        BulkCrudOperationKeys.UPDATE_ALL,\n        BulkCrudOperationKeys.DELETE_ALL,\n      ] as (keyof Adapter<any, any, any, any>)[]\n    ).forEach((toWrap) => {\n      if (!this.adapter)\n        throw new InternalError(\n          `No adapter provided for the fallback of fully segregated models`\n        );\n      if (!this.adapter[toWrap])\n        throw new InternalError(\n          `Method ${toWrap} not found in ${this.adapter.alias} adapter to bind Observables Dispatch`\n        );\n\n      let descriptor = Object.getOwnPropertyDescriptor(this.adapter, toWrap);\n      let proto: any = this.adapter;\n      while (!descriptor && proto !== Object.prototype) {\n        proto = Object.getPrototypeOf(proto);\n        descriptor = Object.getOwnPropertyDescriptor(proto, toWrap);\n      }\n\n      if (!descriptor || !descriptor.writable) {\n        this.log.error(\n          `Could not find method ${toWrap} to bind Observables Dispatch`\n        );\n        return;\n      }\n      function bulkToSingle(method: string) {\n        switch (method) {\n          case BulkCrudOperationKeys.CREATE_ALL:\n            return OperationKeys.CREATE;\n          case BulkCrudOperationKeys.UPDATE_ALL:\n            return OperationKeys.UPDATE;\n          case BulkCrudOperationKeys.DELETE_ALL:\n            return OperationKeys.DELETE;\n          default:\n            return method;\n        }\n      }\n\n      // @ts-expect-error because there are read only properties\n      this.adapter[toWrap] = new Proxy(this.adapter[toWrap], {\n        apply: async (\n          target: any,\n          thisArg: FabricClientAdapter,\n          argArray: any[]\n        ) => {\n          // Run the original method unchanged so transient data is preserved\n          const result = await target.apply(thisArg, argArray);\n\n          const clazz: Constructor<any> = argArray[0];\n          // When syntheticEvents is false, public models emit a chaincode event\n          // on the contract side; skip the local fallback to avoid\n          // double-notification. When syntheticEvents is true we handle all models.\n          if (!syntheticEvents && !Model.isTransient(clazz)) return result;\n\n          // Context is always the last element of argArray\n          const { log, ctxArgs, ctx } = thisArg[\"logCtx\"](\n            argArray.slice(argArray.length - 1),\n            target\n          );\n          const ids = argArray[1];\n          const resultArgs: any[] = [clazz, bulkToSingle(toWrap), ids];\n\n          if (ctx.getOrUndefined(\"observeFullResult\")) {\n            resultArgs.push(result);\n          }\n          this.updateObservers(\n            ...(resultArgs as Parameters<typeof this.updateObservers>),\n            ...ctxArgs\n          ).catch((e: unknown) =>\n            log.error(\n              `Failed to dispatch observer refresh for ${toWrap} on ${clazz.name || clazz} for ${ids}: ${e}`\n            )\n          );\n          return result;\n        },\n      });\n    });\n  }\n}\n\nif (FabricClientAdapter)\n  FabricClientAdapter[\"_baseDispatch\"] = FabricClientDispatch;\n","import { Metadata } from \"@decaf-ts/decoration\";\n\nexport const VERSION = \"##VERSION##\";\nexport const PACKAGE_NAME = \"##PACKAGE##\";\n\nMetadata.registerLibrary(PACKAGE_NAME, VERSION);\n"],"names":["ensureDirectoryExistence","filePath","fs","require","path","dirname","existsSync","mkdirSync","generateModelIndexes","m","generateIndexes","generateModelDesignDocs","accum","views","generateViews","storage","forEach","doc","_id","readModelFile","file","exports","join","process","cwd","parentPath","name","values","Object","filter","e","Model","async","readModelFolders","folders","result","folder","files","readdirSync","withFileTypes","recursive","f","isFile","endsWith","push","writeIndexes","indexes","p","collection","index","resolve","writeFileSync","JSON","stringify","undefined","writeDesignDocs","designDocs","length","docId","replace","payload","_rev","collectionFor","collectionName","policy","requiredPeerCount","maxPeerCount","blockToLive","memberOnlyRead","memberOnlyWrite","privateCollectionFor","mspId","c","endorsementPolicy","signaturePolicy","sharedCollectionFor","mspIds","map","extractCollections","overrides","mirror","privateCols","sharedCols","collectionsFor","resolveCollection","arg","InternalError","privateDefaults","assign","sharedDefaults","mirrorMeta","mirroredAt","privates","flat","resolved","resolver","some","includes","shared","writeCollections","cols","fileName","writeCollectionDesignDocs","docs","FabricClientPaginator","Paginator","constructor","adapter","query","size","clazz","super","prepare","rawStatement","UnsupportedError","page","args","isSerializedPage","obj","Array","isArray","data","FabricClientRepository","Repository","force","this","_overrides","ignoreValidation","ignoreHandlers","allowRawStatements","forcePrepareSimpleQueries","forcePrepareComplexQueries","allowGenerationOverride","rebuildWithTransient","override","flags","for","ObserverHandler","paginateBy","key","order","ref","offset","limit","log","ctxArgs","logCtx","PreparedStatementKeys","PAGE_BY","verbose","tableName","class","statement","bookmark","listBy","LIST_BY","findBy","value","FIND_BY","findOneBy","FIND_ONE_BY","find","OrderDirection","ASC","FIND","direction","PAGE","ctx","PersistenceKeys","STATEMENT","callArgs","slice","parse","decode","evaluateTransaction","hydrated","r","CouchDBKeys","TABLE","d","applyAfterRead","getOrUndefined","enforceDBDecorators","OperationKeys","READ","AFTER","Promise","all","entry","countOf","COUNT_OF","stmtArgs","maxOf","MAX_OF","minOf","MIN_OF","avgOf","AVG_OF","sumOf","SUM_OF","distinctOf","DISTINCT_OF","groupOf","GROUP_OF","healthcheck","create","model","debug","ensureLegacyMirrorFlag","prepared","record","id","transient","revert","update","createAllPrefix","models","CREATE","get","ignoreValidate","ON","ignoredProps","errors","hasErrors","errorMessages","reduceErrorsToPrint","ValidationError","createAll","ids","payloads","transients","created","i","readAll","keys","records","updateAll","updated","u","accumulate","legacy","ERC20Token","BaseModel","__decorate","pk","type","String","prototype","column","required","table","ERC20Wallet","Allowance","ClientSerializer","JSONSerializer","preSerialize","modelName","toSerialize","metadata","Metadata","SerializationError","ModelKeys","ANCHOR","deserialize","str","deserialization","className","Error","build","serialize","FabricERC20ClientRepository","serializer","decoder","TextDecoder","updateObservers","event","observerHandler","count","parsedId","Sequence","parseValue","sequenceFor","tokenName","symbol","decimals","Number","totalSupply","total","balanceOf","owner","balance","transfer","to","transferred","submitTransaction","toString","transferFrom","from","contextArgs","Context","approve","spender","approved","allowance","initialize","token","initiliazed","checkInitialized","mint","amount","burn","burnFrom","account","clientAccountBalance","serializedAccountBalance","clientAccountID","extractIds","composed","pkProps","extractId","composeAttributeValue","IdentityCredentials","description","FabricModelKeys","IdentityType","FabricFlavour","Identity","X509","oneToOne","Cascade","CASCADE","delete","CoreUtils","logger","MiniLogger","contentOfLoadFile","contentOrPath","fileReader","Uint8Array","match","readFile","promises","normalizeImport","import","getCAUser","userName","privateKey","certificate","options","stringFormat","user","User","config","hsm","software","lib","library","slot","label","tokenLabel","pin","cryptoSuite","getCryptoSuite","setCryptoSuite","enrollmentKey","getHSMEnrollmentKey","getSoftwareEnrollmentKey","setEnrollment","newCryptoSuite","createKeyFromRaw","ski","keyIdHex","trim","Buffer","getCertificateSKI","getKey","isPrivate","x509","X509Certificate","jwk","publicKey","export","format","prefix","x","y","crypto","createHash","concat","digest","getIdentity","certDirectoryPath","identityFileReader","certPath","getFirstDirFileName","credentials","dirPath","readdir","getFirstDirFileNameContent","getFileContent","getSigner","keyDirectoryPath","signerFileReader","keyPath","privateKeyPem","extractPrivateKey","getOwnPropertySymbols","k","signers","newPrivateKeySigner","pem","libName","subtle","globalThis","window","Crypto","webcrypto","str2ab","buf","ArrayBuffer","bufView","strLen","charCodeAt","replaceAll","decoded","binaryDer","importKey","namedCurve","getAkiAndSerialFromCert","cert","x509Certificate","X509Cert","akiExt","extensions","aki","toUpperCase","startsWith","serial","serialNumber","cryptoProvider","set","BASE_ALPHABET","CRYPTO","BaseEncoder","alphabet","baseMap","j","charAt","xc","base","leader","factor","Math","iFactor","encode","source","isView","buffer","byteOffset","byteLength","zeroes","pbegin","pend","b58","carry","it1","it2","repeat","decodeUnsafe","psz","b256","it3","it4","vch","CryptoUtils","b58encoder","BASE58","fabricIdFromCertificate","subject","issuer","stringToArrayBuffer","extractKey","usages","RegExp","extractPublicKey","sign","buff","hash","b","padStart","verify","signature","encrypt","getSubtleCrypto","isBrowser","decrypt","getMaster","textEncoder","TextEncoder","genGenesis","randomUUID","importedKey","KEY_ALGORYTHM","iv","getDerivationKey","salt","saltBuffer","saltHashed","params","HASH","iterations","ITERATIONS","derivation","deriveBits","KEYLENGTH","ivlen","keylen","derivedKey","importedEncryptionKey","ALGORYTHM","encryptPin","text","keyObject","textBuffer","encryptedText","decryptPin","textDecoder","decryptedText","OverflowError","msg","BalanceError","AllowanceError","RegistrationError","AuthorizationError","MissingContextError","UnauthorizedPrivateDataAccess","BaseError","NotInitializedError","MissingPKCSS11Lib","EndorsementError","message","MvccReadConflictError","PhantomReadConflictError","EndorsementPolicyError","TransactionLimitsError","code","TransactionTimeoutError","TransactionBufferSizeError","HFCAIdentityType","HFCAIdentityAttributes","FabricEnrollmentService","LoggedClass","caConfig","caName","caCert","caKey","url","CA","ca","tls","trustedRoots","root","FabricCAServices","Client","client","Certificate","certificateService","newCertificateService","Affiliations","affiliationService","newAffiliationService","Identities","identityService","newIdentityService","getCertificates","request","doMap","response","certs","PEM","getIdentities","identitiesService","getAll","identities","parseError","regexp","exec","ConflictError","getAffiliations","a","read","enrollmentId","getOne","NotFoundError","success","register","isSuperUser","affiliation","userRole","attrs","maxEnrollments","registration","password","props","enrollmentID","enrollmentSecret","info","identityFromEnrollment","enrollment","rootCertificate","Logging","clientId","now","Date","toBytes","createdOn","updatedOn","enroll","identity","registerAndEnroll","revoke","reason","RegistrationRequestBuilder","errs","role","setAffiliation","addAttr","attr","setAttrs","setEnrollmentID","setEnrollmentSecret","setMaxEnrollments","setRole","minlength","min","ERC20Events","FabricBaseModel","createdAt","updatedAt","version","uses","FabricIdentifiedBaseModel","createdBy","updatedBy","isShared","segregate","isTransient","decoratedProperties","getAttributes","transientProps","DBKeys","TRANSIENT","privateProperties","PRIVATE","sharedProperties","SHARED","public","transientKeys","privateKeys","sharedKeys","isPublic","bind","mirrored","FABRIC","MIRROR","ownerOf","meta","OWNED_BY","sharedKey","constr","privateMeta","sharedMeta","collections","extractMspId","getMSPID","Owner","target","propertyKey","descriptor","originalMethod","acountId","clientIdentity","getID","select","tokens","execute","apply","ownedByOnCreate","context","stub","creator","getCreator","mspid","setOwnedByKeyValue","defineProperty","enumerable","writable","configurable","ownedBy","attribute","generated","readonly","onCreate","propMetadata","Decoration","define","decorator","transactionIdOnCreate","getTxID","transactionId","onUpdate","TRANSACTION_ID","evalMirrorMetadata","createMirrorHandler","fabricCtx","sourceModel","put","repo","mirrorCollection","updateMirrorHandler","applyUpdateValidation","mergeForUpdate","deleteMirrorHandler","pkProp","segregated","mirrorWriteGuard","msp","condition","readMirrorHandler","matches","readFrom","mspIdOrCondition","isConditionOnly","Boolean","cond","onRead","priority","onDelete","ModelCollection","orgName","toPascalCase","NamespaceCollection","namespace","ImplicitPrivateCollection","SEGREGATED_COLLECTION_EXTRACTION_PRIORITY","applySegregationFlags","isFullySegregated","hasPublicProperties","markFullySegregated","applyMirrorFlags","attributes","transientMeta","extractSegregatedCollections","dataArray","collectionResolver","seqName","sequenceName","setSequenceSegregation","segregatedDataOnCreate","keyArray","_k","keyStrings","writeTo","segregatedDataOnRead","segregatedDataOnUpdate","oldModel","segregatedDataOnDelete","innerSegregated","segregatedDec","Set","add","constrMeta","constrCollections","updatedTransientMeta","decs","properties","groupName","extractGroupName","dataGroupName","earlyExtractionMeta","earlyExtractionGroupSort","group","prop","on","DBOperations","ALL","privateData","sharedData","sortKeysOnlyRecursive","sort","reduce","acc","DeterministicSerializer","error","self","o","call","relations","generateFabricEventName","parseEventName","parts","split","sub","safeParseInt","string","digitRegex","test","parsedint","parseInt","isNaN","SimpleDeterministicSerializer","putAnchor","preSerialization","FabricIdentityService","ClientBasedService","rootClient","_user","certificates","affiliations","getUser","cfg","INITIALIZATION","getName","updateIdentity","identityRequest","caUserIdentity","reenrollUser","createUser","getMspid","enrollmentAttrs","optional","reenroll","renewedIdentity","revokeOptions","revokeRequest","CA_ROLE","DefaultFabricClientFlags","evaluateTimeout","endorseTimeout","submitTimeout","commitTimeout","allowManualEndorsingOrgs","allowGatewayOverride","encryptTransient","syntheticEvents","escapeRegExp","nextLexicographicString","chars","codePointAt","fromCodePoint","prefixRange","start","end","FabricClientStatement","Statement","squash","squashed","method","executePrepared","argz","forModel","fromSelector","alias","QUERY","isSimpleQuery","QueryClause","whereCondition","parsed","prepareCondition","selectSelector","SELECT","AND","toLowerCase","orderBySelectors","ORDER_BY","toCamelCase","processRecord","pkAttr","ID","keyArgs","SEPARATOR","raw","rawInput","aggregator","aggregateInfo","aggregate","executeAggregate","results","processed","applyAfterHandlersToResult","aggregateQuery","buildAggregateQuery","selectors","selector","fields","parseCondition","Condition","and","eq","selectorKeys","CouchDBGroupOperator","indexOf","val","OR","s","entries","warn","selectorKey","rec","CouchDBOperator","BIGGER","limitSelector","CouchDBQueryLimit","offsetSelector","skip","merge","op","obj1","obj2","attr1","operator","comparison","Operator","STARTS_WITH","QueryError","range","BIGGER_EQ","SMALLER","ENDS_WITH","REGEXP","BETWEEN","max","opBetween","translateOperators","SMALLER_EQ","GroupOperator","NOT","op1","op2","avgSelector","sumInfo","createAggregateDescriptor","countInfo","createAggregateQuery","kind","sumDescriptor","countDescriptor","countDistinctSelector","countDistinct","aggregatorUsed","countSelector","minSelector","maxSelector","sumSelector","distinctSelector","aggregatorChecks","metas","findViewMetadata","viewName","generateViewName","ddoc","generateDesignDocName","returnDocs","view","getFabricAdapter","isViewAggregate","handleAverage","fabricAdapter","viewInfo","processViewResponse","sumDesc","countDesc","sumResponse","countResponse","sum","rows","row","FabricClientAdapter","Adapter","operation","mergedFlags","silly","pop","toOverrides","newCtx","parentContext","childContexts","currentOp","currentModel","repository","createPrefix","updateAllPrefix","shift","hasTransient","needsFullPayload","shouldForceGatewayHydration","transientPayload","BulkCrudOperationKeys","CREATE_ALL","getEndorsingOrganizations","res","shouldRefreshAfterWrite","READ_ALL","UPDATE_ALL","deleteAll","shouldHydrate","DELETE_ALL","METADATA","mirrorMsp","msps","merged","endorsingOrgs","endorsingOrganizations","shouldRebuildWithTransient","v","childRebuild","getFromChildren","resolvedOp","resolveOperation","hasId","direct","deserialized","updatePrefix","UPDATE","DELETE","docsOnly","transactionResult","parseRecord","isModel","el","getClient","_client","Gateway","getGateway","getContractName","Contract","contractName","getContract","transaction","api","submit","transientData","gateway","contract","evaluate","proposalOptions","arguments","close","shouldUseLegacyGateway","prepareLegacyArgs","buildLegacyTransient","resolveLegacyMspCount","configured","legacyMspCount","isFinite","floor","pickLegacyCandidates","candidates","available","picked","idx","random","selection","splice","buildLegacyPeerConfigs","peers","peerEndpoint","peerHostAlias","tlsCert","endorsers","org","extras","mspMap","legacyCount","selections","choice","endpoint","submitLegacyWithExplicitEndorsers","fcn","transientMap","peerConfigs","normalizeLegacyPeers","identityMaterial","resolveLegacyIdentityMaterial","wallet","Wallets","newInMemoryWallet","identityLabel","connectionProfile","buildLegacyConnectionProfile","LegacyGateway","connect","discovery","enabled","asLocalhost","shouldTreatPeersAsLocalhost","tlsInfo","network","getNetwork","channel","chaincodeName","createTransaction","setTransient","peer","getChannel","getEndorser","endorser","setEndorsingPeers","disconnect","deduped","Map","addPeer","has","readPemInput","certCertOrDirectoryPath","keyCertOrDirectoryPath","peerEntries","channelPeers","orgs","tlsPem","hostname","extractHost","ensureGrpcUrl","tlsCACerts","grpcOptions","hostnameOverride","endorsingPeer","chaincodeQuery","ledgerQuery","eventSource","organization","organizations","orderers","channels","every","isLocalEndpoint","host","sanitized","isBuffer","trimmed","stats","stat","catch","isDirectory","readFsFile","err","legacyArgs","shutdown","channelName","getConnection","pathOrCert","readFileSync","tlsCredentials","grpc","createSsl","sizeLimit","signer","evaluateOptions","deadline","endorseOptions","submitOptions","commitStatusOptions","Proxy","thisArg","argArray","Reflect","Dispatch","GatewayError","details","EndorseError","BadRequestError","PagingError","MigrationError","ObserverError","ForbiddenError","ConnectionError","final","D","_a","decoration","setCurrent","FabricClientDispatch","loggedArgs","SHUTDOWN","listeningStack","parsePayload","jsonBytes","json","observe","observer","unObserve","refresh","handleEvents","ctxArg","correlationId","evt","eventName","mspEventOnly","targetModel","modelRef","observerArgs","getChaincodeEvents","toWrap","getOwnPropertyDescriptor","proto","getPrototypeOf","bulkToSingle","resultArgs","VERSION","PACKAGE_NAME","registerLibrary"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"for-fabric.js","sources":["../src/client/indexes/generation.ts","../src/client/collections/generation.ts","../src/client/FabricClientPaginator.ts","../src/client/FabricClientRepository.ts","../src/contracts/erc20/models.ts","../src/shared/ClientSerializer.ts","../src/client/erc20/FabricERC20ClientRepository.ts","../src/client/ids/id-extraction.ts","../src/shared/model/IdentityCredentials.ts","../src/shared/constants.ts","../src/shared/model/Identity.ts","../src/client/utils.ts","../src/client/crypto.ts","../src/shared/errors.ts","../src/client/services/FabricEnrollmentService.ts","../src/client/services/RegistrationRequestBuilder.ts","../src/shared/erc20/erc20-constants.ts","../src/shared/model/FabricBaseModel.ts","../src/shared/model/FabricIdentifiedBaseModel.ts","../src/shared/overrides/overrides.ts","../src/shared/decorators.ts","../src/shared/DeterministicSerializer.ts","../src/shared/events.ts","../src/shared/math.ts","../src/shared/SimpleDeterministicSerializer.ts","../src/client/services/FabricIdentityService.ts","../src/client/services/constants.ts","../src/client/constants.ts","../src/client/fabric-fs.ts","../src/client/FabricClientStatement.ts","../src/client/FabricClientAdapter.ts","../src/client/FabricClientDispatch.ts","../src/version.ts"],"sourcesContent":["import { Constructor } from \"@decaf-ts/decoration\";\nimport {\n  CreateIndexRequest,\n  CouchDBDesignDoc,\n  generateIndexes,\n  generateViews,\n} from \"@decaf-ts/for-couchdb\";\nimport { Model, ModelConstructor } from \"@decaf-ts/decorator-validation\";\n\nexport type Index = CreateIndexRequest;\n\nfunction ensureDirectoryExistence(filePath: string) {\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const fs = require(\"fs\");\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const path = require(\"path\");\n  const dirname: string = path.dirname(filePath);\n  if (fs.existsSync(dirname)) {\n    return true;\n  }\n  ensureDirectoryExistence(dirname);\n  fs.mkdirSync(dirname);\n}\n\nexport function generateModelIndexes<M extends Model>(\n  m: Constructor<M>\n): Index[] {\n  return generateIndexes([m]);\n}\n\nexport function generateModelDesignDocs<M extends Model>(\n  m: Constructor<M>,\n  accum?: Record<string, CouchDBDesignDoc>\n): CouchDBDesignDoc[] {\n  const views = generateViews([m]);\n  const storage: Record<string, CouchDBDesignDoc> = accum || {};\n  views.forEach((doc) => {\n    storage[doc._id] = doc;\n  });\n  return views;\n}\n\nexport function readModelFile(file: any) {\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const path = require(\"path\");\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const exports = require(path.join(process.cwd(), file.parentPath, file.name));\n\n  const values = Object.values(exports).filter((e) => {\n    try {\n      const m = new (e as Constructor)();\n      return m instanceof Model;\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (e: unknown) {\n      return false;\n    }\n  }) as ModelConstructor<any>[];\n  return values;\n}\n\nexport async function readModelFolders(\n  ...folders: string[]\n): Promise<ModelConstructor<any>[]> {\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const fs = require(\"fs\");\n\n  const result: ModelConstructor<any>[] = [];\n\n  for (const folder of folders) {\n    const files = fs\n      .readdirSync(folder, {\n        withFileTypes: true,\n        recursive: true,\n      })\n      .filter((f: any) => f.isFile() && f.name.endsWith(\"js\"));\n    for (const file of files) {\n      result.push(...readModelFile(file));\n    }\n  }\n  return result;\n}\n\nexport function writeIndexes(\n  indexes: Index[],\n  p: string = process.cwd(),\n  collection?: string\n) {\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const fs = require(\"fs\");\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const path = require(\"path\");\n\n  indexes.forEach((index) => {\n    const file = path.resolve(\n      path.join(\n        p,\n        `./META-INF/statedb/couchdb/${collection ? `collections/${collection}/` : \"\"}indexes/${index.name}.json`\n      )\n    );\n    ensureDirectoryExistence(file);\n    fs.writeFileSync(file, JSON.stringify(index, undefined, 2));\n  });\n}\n\nexport function writeDesignDocs(\n  designDocs: CouchDBDesignDoc[],\n  p: string = process.cwd(),\n  collection?: string\n) {\n  if (!designDocs.length) return;\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const fs = require(\"fs\");\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const path = require(\"path\");\n\n  designDocs.forEach((doc) => {\n    const docId = doc._id.replace(/^_design\\//, \"\");\n    const file = path.resolve(\n      path.join(\n        p,\n        `./META-INF/statedb/couchdb/${collection ? `collections/${collection}/` : \"\"}design_docs/${docId}.json`\n      )\n    );\n    ensureDirectoryExistence(file);\n    const payload = { ...doc };\n    delete payload._rev;\n    fs.writeFileSync(file, JSON.stringify(payload, undefined, 2));\n  });\n}\n","import { Constructor } from \"@decaf-ts/decoration\";\nimport { CouchDBDesignDoc } from \"@decaf-ts/for-couchdb\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\nimport { CollectionResolver } from \"../../shared/index\";\nimport { writeDesignDocs } from \"../indexes/generation\";\n\n//\n// export type FabricCollection = {\n//   name: \"collectionMarbles\";\n//   policy: \"OR('Org1MSP.member', 'Org2MSP.member')\";\n//   requiredPeerCount: 0;\n//   maxPeerCount: 3;\n//   blockToLive: 0;\n//   memberOnlyRead: true;\n//   memberOnlyWrite: true;\n//   endorsementPolicy: {\n//     identities: [\n//       { role: { name: \"member\"; mspId: \"Org1MSP\" } },\n//       { role: { name: \"member\"; mspId: \"Org2MSP\" } },\n//     ];\n//     rule: \"OR('Org1MSP.member', 'Org2MSP.member')\";\n//   };\n// };\n\nexport type FabricPolicyIdentity = {\n  role: {\n    name: string;\n    mspId: string;\n  };\n};\n\nexport type FabricCollection = {\n  name: string;\n  policy: string;\n  requiredPeerCount: number;\n  maxPeerCount: number;\n  blockToLive: number;\n  memberOnlyRead: boolean;\n  memberOnlyWrite: boolean;\n  endorsementPolicy: {\n    identities: FabricPolicyIdentity[];\n    rule: string;\n  };\n};\n\nexport type PrivateCollection = {\n  name: string;\n  policy: string;\n  requiredPeerCount: number;\n  maxPeerCount: number;\n  blockToLive: number;\n  memberOnlyRead: boolean;\n  memberOnlyWrite: boolean;\n  endorsementPolicy?: {\n    signaturePolicy: string;\n  };\n};\n\nexport function collectionFor(\n  collectionName: string,\n  policy: string,\n  requiredPeerCount: number,\n  maxPeerCount: number,\n  blockToLive: number,\n  memberOnlyRead: boolean,\n  memberOnlyWrite: boolean\n): PrivateCollection {\n  return {\n    name: collectionName,\n    policy: policy,\n    requiredPeerCount,\n    maxPeerCount,\n    blockToLive,\n    memberOnlyRead,\n    memberOnlyWrite,\n  };\n}\n\nexport function privateCollectionFor(\n  mspId: string,\n  collectionName: string = `${mspId}Private`,\n  requiredPeerCount: number = 0,\n  maxPeerCount: number = 0,\n  blockToLive: number = 0,\n  memberOnlyRead: boolean = true,\n  memberOnlyWrite: boolean = true\n): PrivateCollection {\n  const c = collectionFor(\n    collectionName,\n    `OR('${mspId}.member')`,\n    requiredPeerCount,\n    maxPeerCount,\n    blockToLive,\n    memberOnlyRead,\n    memberOnlyWrite\n  );\n\n  c.endorsementPolicy = {\n    signaturePolicy: `OR('${mspId}.peer')`,\n  };\n  return c;\n}\n\nexport function sharedCollectionFor(\n  mspIds: string[],\n  collectionName: string,\n  requiredPeerCount: number = 1,\n  maxPeerCount: number = 2,\n  blockToLive: number = 0,\n  memberOnlyRead: boolean = true,\n  memberOnlyWrite: boolean = true\n): PrivateCollection {\n  const c = collectionFor(\n    collectionName,\n    `OR(${mspIds.map((m) => `'${m}.member'`).join(\",\")})`,\n    requiredPeerCount,\n    maxPeerCount,\n    blockToLive,\n    memberOnlyRead,\n    memberOnlyWrite\n  );\n  c.endorsementPolicy = {\n    signaturePolicy: `AND(${mspIds.map((m) => `'${m}.peer'`).join(\",\")})`,\n  };\n  return c;\n}\n\nexport async function extractCollections<M extends Model>(\n  m: Constructor<M>,\n  mspIds: string[],\n  overrides: {\n    privateCols?: Partial<PrivateCollection>;\n    sharedCols?: Partial<PrivateCollection>;\n  } = {},\n  mirror: boolean = false\n) {\n  let { privateCols, sharedCols } = Model.collectionsFor(m);\n\n  function resolveCollection(arg: string | CollectionResolver): string {\n    try {\n      if (typeof arg === \"string\") return arg;\n      return arg(m, mspIds[0]) as string;\n    } catch (e: unknown) {\n      throw new InternalError(e as Error);\n    }\n  }\n\n  privateCols = privateCols.map(resolveCollection);\n  sharedCols = sharedCols.map(resolveCollection);\n\n  const privateDefaults = Object.assign(\n    {},\n    {\n      requiredPeerCount: 0,\n      maxPeerCount: 0,\n      blockToLive: 0,\n      memberOnlyRead: true,\n      memberOnlyWrite: true,\n    },\n    overrides?.privateCols || {}\n  );\n  const sharedDefaults = Object.assign(\n    {},\n    {\n      requiredPeerCount: 1,\n      maxPeerCount: 2,\n      blockToLive: 0,\n      memberOnlyRead: true,\n      memberOnlyWrite: true,\n    },\n    overrides?.sharedCols || {}\n  );\n\n  const mirrorMeta = mirror ? Model.mirroredAt(m) : undefined;\n\n  const privates = mspIds\n    .map((mspId) =>\n      (privateCols as string[]).map((p) => {\n        const { requiredPeerCount, maxPeerCount, blockToLive, memberOnlyRead } =\n          privateDefaults;\n        return privateCollectionFor(\n          mspId,\n          p,\n          requiredPeerCount,\n          maxPeerCount,\n          blockToLive,\n          memberOnlyRead,\n          false\n        );\n      })\n    )\n    .flat();\n\n  if (mirrorMeta && mirrorMeta.mspId) {\n    const resolved =\n      typeof mirrorMeta.resolver === \"string\"\n        ? mirrorMeta.resolver\n        : mirrorMeta.resolver(m, mirrorMeta.mspId);\n    if (\n      resolved &&\n      !privates.some(\n        (p) => p.name === resolved && p.policy.includes(mirrorMeta.mspId)\n      )\n    ) {\n      const { requiredPeerCount, maxPeerCount, blockToLive, memberOnlyRead } =\n        privateDefaults;\n      privates.push(\n        privateCollectionFor(\n          mirrorMeta.mspId,\n          resolved,\n          requiredPeerCount,\n          maxPeerCount,\n          blockToLive,\n          memberOnlyRead,\n          false\n        )\n      );\n    }\n  }\n\n  const shared = (sharedCols as string[]).map((p) => {\n    const {\n      requiredPeerCount,\n      maxPeerCount,\n      blockToLive,\n      memberOnlyRead,\n      memberOnlyWrite,\n    } = sharedDefaults;\n    return sharedCollectionFor(\n      mspIds,\n      p,\n      requiredPeerCount,\n      maxPeerCount,\n      blockToLive,\n      memberOnlyRead,\n      memberOnlyWrite\n    );\n  });\n\n  return {\n    privates,\n    shared,\n  };\n}\n\nexport function writeCollections(\n  cols: PrivateCollection[],\n  p: string = process.cwd(),\n  fileName = \"collections_config\"\n) {\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const fs = require(\"fs\");\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const path = require(\"path\");\n\n  function ensureDirectoryExistence(filePath: string) {\n    const dirname: string = path.dirname(filePath) as string;\n    if (fs.existsSync(dirname)) {\n      return true;\n    }\n    ensureDirectoryExistence(dirname);\n    fs.mkdirSync(dirname);\n  }\n\n  const file = path.resolve(path.join(p, `./META-INF/${fileName}.json`));\n  ensureDirectoryExistence(file);\n  fs.writeFileSync(file, JSON.stringify(cols, undefined, 2));\n}\n\nexport function writeCollectionDesignDocs(\n  docs: CouchDBDesignDoc[],\n  p: string = process.cwd(),\n  collection?: string\n) {\n  if (!docs?.length) return;\n  writeDesignDocs(docs, p, collection);\n}\n","import {\n  MaybeContextualArg,\n  Paginator,\n  PreparedStatement,\n  SerializedPage,\n  UnsupportedError,\n} from \"@decaf-ts/core\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { Constructor } from \"@decaf-ts/decoration\";\nimport { FabricClientAdapter } from \"./FabricClientAdapter\";\nimport { MangoQuery } from \"@decaf-ts/for-couchdb\";\n\nexport class FabricClientPaginator<M extends Model> extends Paginator<\n  M,\n  M[],\n  MangoQuery\n> {\n  bookmark?: string;\n\n  constructor(\n    adapter: FabricClientAdapter,\n    query: MangoQuery | PreparedStatement<any>,\n    size: number,\n    clazz: Constructor<M>\n  ) {\n    super(adapter, query, size, clazz);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  protected prepare(rawStatement: MangoQuery): MangoQuery {\n    throw new UnsupportedError(\n      `Raw query access must be implemented by a subclass. only prepared statements are natively available`\n    );\n  }\n\n  override page(\n    page: number = 1,\n    ...args: MaybeContextualArg<any>\n  ): Promise<M[]> {\n    return super.page(page, ...args); // this will fail for non-prepared statements\n  }\n\n  static override isSerializedPage(obj: SerializedPage<any> | any) {\n    return obj && typeof obj === \"object\" && Array.isArray(obj.data);\n  }\n}\n","import type { MaybeContextualArg } from \"@decaf-ts/core\";\nimport {\n  ContextOf,\n  DirectionLimitOffset,\n  FlagsOf,\n  ObserverHandler,\n  OrderDirection,\n  Paginator,\n  PersistenceKeys,\n  PreparedStatementKeys,\n  Repository,\n  SerializedPage,\n} from \"@decaf-ts/core\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { Constructor } from \"@decaf-ts/decoration\";\nimport { type FabricClientAdapter } from \"./FabricClientAdapter\";\nimport {\n  BulkCrudOperationKeys,\n  enforceDBDecorators,\n  OperationKeys,\n  PrimaryKeyType,\n  reduceErrorsToPrint,\n  ValidationError,\n} from \"@decaf-ts/db-decorators\";\nimport { CouchDBKeys } from \"@decaf-ts/for-couchdb\";\nimport { FabricClientPaginator } from \"./FabricClientPaginator\";\n\n/**\n * @description Repository implementation for Fabric client operations\n * @summary Extends the generic Repository to prepare context and arguments for CRUD operations executed via a Fabric client Adapter, wiring RepositoryFlags and Fabric-specific overrides.\n * @template M extends Model - The model type handled by this repository\n * @param {Adapter<any, MangoQuery, FabricFlags, Context<FabricFlags>>} [adapter] - Optional adapter instance used to execute operations\n * @param {Constructor<M>} [clazz] - Optional model constructor used by the repository\n * @return {void}\n * @class FabricClientRepository\n * @example\n * import { Repository } from \"@decaf-ts/core\";\n * import { FabricClientRepository } from \"@decaf-ts/for-fabric\";\n *\n * class User extends Model { id!: string; name!: string; }\n * const repo = new FabricClientRepository<User>();\n * const created = await repo.create(new User({ id: \"1\", name: \"Alice\" }));\n * const loaded = await repo.read(\"1\");\n *\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant Repo as FabricClientRepository\n *   participant Adapter\n *   App->>Repo: create(model)\n *   Repo->>Repo: createPrefix(model, ...args)\n *   Repo->>Adapter: create(table, id, model, flags)\n *   Adapter-->>Repo: result\n *   Repo-->>App: model\n */\nexport class FabricClientRepository<\n  M extends Model,\n  A extends FabricClientAdapter = FabricClientAdapter,\n> extends Repository<M, A> {\n  protected override _overrides = Object.assign({}, super[\"_overrides\"], {\n    ignoreValidation: true,\n    ignoreHandlers: true,\n    allowRawStatements: false,\n    forcePrepareSimpleQueries: true,\n    forcePrepareComplexQueries: true,\n    allowGenerationOverride: false,\n    rebuildWithTransient: false,\n  });\n\n  constructor(adapter?: A, clazz?: Constructor<M>, force: boolean = false) {\n    super(adapter, clazz, force);\n  }\n\n  override override(flags: Partial<FlagsOf<ContextOf<A>>>): this {\n    return super\n      .override(Object.assign({}, flags, this._overrides))\n      .for(flags as any);\n  }\n\n  protected override ObserverHandler(): ObserverHandler {\n    return super.ObserverHandler();\n  }\n\n  override async paginateBy(\n    key: keyof M,\n    order: OrderDirection,\n    ref: Omit<DirectionLimitOffset, \"direction\"> = {\n      offset: 1,\n      limit: 10,\n    },\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<SerializedPage<M>> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.PAGE_BY, true)\n    ).for(this.paginateBy);\n    log.verbose(\n      `paginating ${Model.tableName(this.class)} with page size ${ref.limit}`\n    );\n    return this.statement(\n      this.paginateBy.name,\n      key,\n      order,\n      { limit: ref.limit, offset: ref.offset, bookmark: ref.bookmark },\n      ...ctxArgs\n    );\n  }\n\n  override async listBy(\n    key: keyof M,\n    order: OrderDirection,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<M[]> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.LIST_BY, true)\n    ).for(this.listBy);\n    log.verbose(\n      `listing ${Model.tableName(this.class)} by ${key as string} ${order}`\n    );\n    return (await this.statement(\n      this.listBy.name,\n      key,\n      order,\n      ...ctxArgs\n    )) as any;\n  }\n\n  override async findBy(\n    key: keyof M,\n    value: any,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<M[]> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.FIND_BY, true)\n    ).for(this.findBy);\n    log.verbose(\n      `finding all ${Model.tableName(this.class)} with ${key as string} ${value}`\n    );\n    return (await this.statement(\n      this.findBy.name,\n      key,\n      value,\n      ...ctxArgs\n    )) as any;\n  }\n\n  override async findOneBy(\n    key: keyof M,\n    value: any,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<M> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.FIND_ONE_BY, true)\n    ).for(this.findOneBy);\n    log.verbose(\n      `finding One ${Model.tableName(this.class)} with ${key as string} ${value}`\n    );\n    return (await this.statement(\n      this.findOneBy.name,\n      key,\n      value,\n      ...ctxArgs\n    )) as any;\n  }\n\n  override async find(\n    value: string,\n    order: OrderDirection = OrderDirection.ASC,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<M[]> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.FIND, true)\n    ).for(this.find);\n    log.verbose(\n      `finding ${Model.tableName(this.class)} by default query attributes`\n    );\n    return (await this.statement(\n      this.find.name,\n      value,\n      order,\n      ...ctxArgs\n    )) as any;\n  }\n\n  override async page(\n    value: string,\n    direction: OrderDirection = OrderDirection.ASC,\n    ref: Omit<DirectionLimitOffset, \"direction\"> = {\n      offset: 1,\n      limit: 10,\n    },\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<SerializedPage<M>> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.PAGE, true)\n    ).for(this.page);\n    log.verbose(\n      `paging ${Model.tableName(this.class)} by default query attributes`\n    );\n    return (await this.statement(\n      this.page.name,\n      value,\n      direction,\n      ref,\n      ...ctxArgs\n    )) as any;\n  }\n\n  override async statement(\n    name: string,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<any> {\n    const { log, ctx, ctxArgs } = (\n      await this.logCtx(args, PersistenceKeys.STATEMENT, true)\n    ).for(this.statement);\n    log.verbose(`Executing prepared statement ${name}`);\n    const callArgs = ctxArgs.slice(0, -1);\n    const result = JSON.parse(\n      this.adapter.decode(\n        await this.adapter.evaluateTransaction(\n          ctx,\n          PersistenceKeys.STATEMENT,\n          [name, JSON.stringify(callArgs)],\n          undefined,\n          undefined,\n          this.class.name\n        )\n      )\n    );\n\n    let hydrated: any;\n    if (Array.isArray(result)) {\n      hydrated = result.map((r: any) =>\n        (r as any)[CouchDBKeys.TABLE] &&\n        (r as any)[CouchDBKeys.TABLE] === Model.tableName(this.class)\n          ? (new this.class(r) as M)\n          : r\n      );\n    } else if (\n      (result as any)[CouchDBKeys.TABLE] &&\n      (result as any)[CouchDBKeys.TABLE] === Model.tableName(this.class)\n    ) {\n      hydrated = new this.class(result) as M;\n    } else if (FabricClientPaginator.isSerializedPage(result)) {\n      hydrated = Object.assign(result, {\n        data: result.data.map((d: any) => new this.class(d) as M),\n      });\n    } else {\n      hydrated = result;\n    }\n\n    return this.applyAfterRead(hydrated, ctx);\n  }\n\n  private async applyAfterRead(value: any, ctx: ContextOf<A>): Promise<any> {\n    if (!ctx.getOrUndefined(\"afterQueryHandlers\")) return value;\n    if (value instanceof Model) {\n      await enforceDBDecorators<M, Repository<M, A>, any>(\n        this,\n        ctx,\n        value as M,\n        OperationKeys.READ,\n        OperationKeys.AFTER\n      );\n      return value;\n    }\n    if (Array.isArray(value)) {\n      await Promise.all(value.map((entry) => this.applyAfterRead(entry, ctx)));\n      return value;\n    }\n    if (FabricClientPaginator.isSerializedPage(value)) {\n      await this.applyAfterRead(value.data, ctx);\n      return value;\n    }\n    return value;\n  }\n\n  override async countOf(\n    key?: keyof M,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<number> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.COUNT_OF, true)\n    ).for(this.countOf);\n    log.verbose(\n      `counting ${Model.tableName(this.class)}${key ? ` by ${key as string}` : \"\"}`\n    );\n    const stmtArgs = key ? [key, ...ctxArgs] : ctxArgs;\n    return this.statement(PreparedStatementKeys.COUNT_OF, ...stmtArgs);\n  }\n\n  override async maxOf<K extends keyof M>(\n    key: K,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<M[K]> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.MAX_OF, true)\n    ).for(this.maxOf);\n    log.verbose(\n      `finding max of ${key as string} in ${Model.tableName(this.class)}`\n    );\n    return this.statement(PreparedStatementKeys.MAX_OF, key, ...ctxArgs);\n  }\n\n  override async minOf<K extends keyof M>(\n    key: K,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<M[K]> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.MIN_OF, true)\n    ).for(this.minOf);\n    log.verbose(\n      `finding min of ${key as string} in ${Model.tableName(this.class)}`\n    );\n    return this.statement(PreparedStatementKeys.MIN_OF, key, ...ctxArgs);\n  }\n\n  override async avgOf<K extends keyof M>(\n    key: K,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<number> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.AVG_OF, true)\n    ).for(this.avgOf);\n    log.verbose(\n      `calculating avg of ${key as string} in ${Model.tableName(this.class)}`\n    );\n    return this.statement(PreparedStatementKeys.AVG_OF, key, ...ctxArgs);\n  }\n\n  override async sumOf<K extends keyof M>(\n    key: K,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<number> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.SUM_OF, true)\n    ).for(this.sumOf);\n    log.verbose(\n      `calculating sum of ${key as string} in ${Model.tableName(this.class)}`\n    );\n    return this.statement(PreparedStatementKeys.SUM_OF, key, ...ctxArgs);\n  }\n\n  override async distinctOf<K extends keyof M>(\n    key: K,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<M[K][]> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.DISTINCT_OF, true)\n    ).for(this.distinctOf);\n    log.verbose(\n      `finding distinct values of ${key as string} in ${Model.tableName(this.class)}`\n    );\n    return this.statement(PreparedStatementKeys.DISTINCT_OF, key, ...ctxArgs);\n  }\n\n  override async groupOf<K extends keyof M>(\n    key: K,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<Record<string, M[]>> {\n    const { log, ctxArgs } = (\n      await this.logCtx(args, PreparedStatementKeys.GROUP_OF, true)\n    ).for(this.groupOf);\n    log.verbose(`grouping ${Model.tableName(this.class)} by ${key as string}`);\n    return this.statement(PreparedStatementKeys.GROUP_OF, key, ...ctxArgs);\n  }\n\n  async healthcheck(...args: MaybeContextualArg<ContextOf<A>>) {\n    const { ctxArgs } = this.logCtx(args, this.healthcheck);\n\n    const result = await this.adapter.healthcheck(this.class, ...ctxArgs);\n\n    return result;\n  }\n\n  override async create(\n    model: M,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<M> {\n    const { ctx, log, ctxArgs } = this.logCtx(args, this.create);\n    log.debug(\n      `Creating new ${this.class.name} in table ${Model.tableName(this.class)}`\n    );\n    this.ensureLegacyMirrorFlag(ctx, model);\n    const prepared = this.adapter.prepare(model, ctx);\n    const { record, id, transient } = prepared;\n    const result = await this.adapter.create(\n      this.class,\n      id,\n      record,\n      transient,\n      ...ctxArgs\n    );\n    return this.adapter.revert<M>(result, this.class, id, transient, ctx);\n  }\n\n  override async update(\n    model: M,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<M> {\n    const { ctxArgs, log, ctx } = this.logCtx(args, this.update);\n    this.ensureLegacyMirrorFlag(ctx, model);\n    const prepared = this.adapter.prepare(model, ctx);\n    const { id, transient } = prepared;\n    let record = prepared.record;\n    log.debug(\n      `updating ${this.class.name} in table ${Model.tableName(this.class)} with id ${id}`\n    );\n    record = await this.adapter.update(\n      this.class,\n      id,\n      record,\n      transient,\n      ...ctxArgs\n    );\n    return this.adapter.revert<M>(record, this.class, id, transient, ctx);\n  }\n\n  protected override async createAllPrefix(\n    models: M[],\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<[M[], ...any[], ContextOf<A>]> {\n    const { ctx, ctxArgs } = (\n      await this.logCtx(args, OperationKeys.CREATE, true)\n    ).for(this.createAllPrefix);\n    const ignoreHandlers = ctx.get(\"ignoreHandlers\");\n    const ignoreValidate = ctx.get(\"ignoreValidation\");\n    if (!models.length) return [models, ...ctxArgs] as any;\n\n    models = await Promise.all(\n      models.map(async (m) => {\n        m = new this.class(m);\n        if (!ignoreHandlers)\n          await enforceDBDecorators<M, Repository<M, A>, any>(\n            this,\n            ctx,\n            m,\n            OperationKeys.CREATE,\n            OperationKeys.ON\n          );\n        return m;\n      })\n    );\n\n    if (!ignoreValidate) {\n      const ignoredProps = ctx.get(\"ignoredValidationProperties\") || [];\n\n      const errors = await Promise.all(\n        models.map((m) => Promise.resolve(m.hasErrors(...ignoredProps)))\n      );\n\n      const errorMessages = reduceErrorsToPrint(errors);\n\n      if (errorMessages) throw new ValidationError(errorMessages);\n    }\n    return [models, ...ctxArgs] as any;\n  }\n\n  override async createAll(\n    models: M[],\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<M[]> {\n    if (!models.length) return models;\n    const { ctx, log, ctxArgs } = this.logCtx(args, this.createAll);\n    log.debug(\n      `Creating ${models.length} new ${this.class.name} in table ${Model.tableName(this.class)}`\n    );\n\n    models.forEach((model) => this.ensureLegacyMirrorFlag(ctx, model));\n    const prepared = models.map((m) => this.adapter.prepare(m, ctx));\n    const ids = prepared.map((p) => p.id);\n    const payloads = prepared.map((p) => p.record);\n    const transients = prepared.map((p) => p.transient);\n    const created = await this.adapter.createAll(\n      this.class,\n      ids as PrimaryKeyType[],\n      payloads,\n      transients,\n      ...ctxArgs\n    );\n    return Promise.all(\n      created.map(async (r, i) => {\n        const id = ids[i];\n        return this.adapter.revert<M>(r, this.class, id, transients[i], ctx);\n      })\n    );\n  }\n\n  override async readAll(\n    keys: PrimaryKeyType[],\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ) {\n    const { ctx, log, ctxArgs } = this.logCtx(args, this.readAll);\n    log.debug(\n      `reading ${keys.length} ${this.class.name} in table ${Model.tableName(this.class)}`\n    );\n    const records = await this.adapter.readAll(this.class, keys, ...ctxArgs);\n    return records.map((r, i) =>\n      this.adapter.revert(r, this.class, keys[i], {}, ctx)\n    );\n  }\n\n  override async updateAll(\n    models: M[],\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<M[]> {\n    const { ctx, log, ctxArgs } = this.logCtx(args, this.updateAll);\n    log.debug(\n      `Updating ${models.length} new ${this.class.name} in table ${Model.tableName(this.class)}`\n    );\n\n    models.forEach((model) => this.ensureLegacyMirrorFlag(ctx, model));\n    const prepared = models.map((m) => this.adapter.prepare(m, ctx));\n    const ids = prepared.map((p) => p.id);\n    const updated = await this.adapter.updateAll(\n      this.class,\n      ids as PrimaryKeyType[],\n      prepared.map((r) => r.record),\n      prepared.map((r) => r.transient),\n      ...ctxArgs\n    );\n    return Promise.all(\n      updated.map(async (u, i) => {\n        const id = ids[i];\n        return this.adapter.revert<M>(\n          u,\n          this.class,\n          id,\n          prepared[i].transient,\n          ctx\n        );\n      })\n    );\n  }\n\n  private ensureLegacyMirrorFlag(ctx: ContextOf<A>, model: M): void {\n    if (Model.mirroredAt(model)) {\n      ctx.accumulate({ legacy: true });\n    }\n  }\n}\n","import { BaseModel, column, pk, table } from \"@decaf-ts/core\";\nimport { model, type ModelArg, required } from \"@decaf-ts/decorator-validation\";\n\n/**\n * @description ERC20 token metadata model\n * @summary Represents an ERC20 token definition within the Fabric ERC20 sample, including name, symbol, decimals, and the owning identity. Used to define the unique token managed by the contract.\n * @param {ModelArg<ERC20Token>} [m] - Optional partial data or another instance to initialize the model\n * @return {void}\n * @class ERC20Token\n * @example\n * const token = new ERC20Token({ name: \"MyToken\", symbol: \"MTK\", decimals: 18, owner: \"x509::...\" });\n * // Persist through a repository: await repo.create(token, ctx)\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant Repo\n *   participant Adapter\n *   App->>Repo: create(new ERC20Token({...}), ctx)\n *   Repo->>Adapter: create(table, id=name, record, flags)\n *   Adapter-->>Repo: stored\n *   Repo-->>App: model\n */\n@table(\"erc20_tokens\")\n@model()\nexport class ERC20Token extends BaseModel {\n  @pk({ type: String })\n  /**\n   * @description Token unique name\n   * @summary Serves as the primary key for the ERC20 token definition; typically a human-readable identifier\n   */\n  name!: string;\n\n  @column()\n  @required()\n  /**\n   * @description Owning identity of the token\n   * @summary X.509 subject or MSP identity string that denotes who owns/controls the token definition\n   */\n  owner!: string;\n  @column()\n  @required()\n  /**\n   * @description Token symbol\n   * @summary Short ticker-like symbol used to represent the token (e.g., MTK)\n   */\n  symbol!: string;\n  @column()\n  @required()\n  /**\n   * @description Decimal precision for token amounts\n   * @summary Number of digits after the decimal separator used when formatting token balances\n   */\n  decimals!: number;\n\n  constructor(m?: ModelArg<ERC20Wallet>) {\n    super(m);\n  }\n}\n\n/**\n * @description ERC20 wallet model\n * @summary Represents a holder account for an ERC20 token within the Fabric network, tracking balance and token association.\n * @param {ModelArg<ERC20Wallet>} [m] - Optional partial data or another instance to initialize the model\n * @return {void}\n * @class ERC20Wallet\n * @example\n * const wallet = new ERC20Wallet({ id: \"acct1\", token: \"MyToken\", balance: 1000 });\n * // Update balance via repository: await repo.update(wallet, ctx)\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant Repo\n *   App->>Repo: read(\"acct1\", ctx)\n *   Repo-->>App: ERC20Wallet\n */\n@table(\"erc20_wallets\")\n@model()\nexport class ERC20Wallet extends BaseModel {\n  @pk({ type: String })\n  /**\n   * @description Wallet unique identifier\n   * @summary Primary key for the wallet; commonly references an account or identity\n   */\n  id!: string;\n\n  @column()\n  @required()\n  /**\n   * @description Associated token name\n   * @summary References the ERC20Token this wallet holds; maintained as a relationship for cascading updates/deletes\n   */\n  token!: string;\n\n  @column()\n  @required()\n  /**\n   * @description Token balance for this wallet\n   * @summary Current amount of the associated token held by this wallet\n   */\n  balance!: number;\n\n  @column()\n  /**\n   * @description Captive flag or identifier\n   * @summary Optional field used by some flows to mark non-transferable funds or managed custody\n   */\n  captive!: string;\n\n  constructor(m?: ModelArg<ERC20Wallet>) {\n    super(m);\n  }\n}\n\n/**\n * @description ERC20 allowance model\n * @summary Captures an approval relationship where an owner allows a spender to transfer up to a certain value from the owner's wallet.\n * @param {ModelArg<Allowance>} [m] - Optional partial data or another instance to initialize the model\n * @return {void}\n * @class Allowance\n * @example\n * const allowance = new Allowance({ owner: \"acct1\", spender: \"acct2\", value: 50 });\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   App->>App: new Allowance({ owner, spender, value })\n */\n@table(\"erc20_allowances\")\n@model()\nexport class Allowance extends BaseModel {\n  @pk({ type: String })\n  /**\n   * @description Allowance unique identifier\n   * @summary Primary key for the allowance; typically a unique identifier for the approval relationship\n   */\n  @column()\n  @required()\n  /**\n   * @description Owner wallet identifier\n   * @summary Wallet that authorizes the allowance\n   */\n  owner!: string;\n\n  @column()\n  @required()\n  /**\n   * @description Spender wallet identifier\n   * @summary Wallet allowed to spend up to the approved value from the owner\n   */\n  spender!: string;\n\n  @column()\n  @required()\n  /**\n   * @description Approved value\n   * @summary Maximum token amount the spender may transfer on behalf of the owner\n   */\n  value!: number;\n\n  constructor(m?: ModelArg<Allowance>) {\n    super(m);\n  }\n}\n","import {\n  JSONSerializer,\n  Model,\n  ModelKeys,\n} from \"@decaf-ts/decorator-validation\";\nimport { SerializationError } from \"@decaf-ts/db-decorators\";\nimport { Constructor, Metadata } from \"@decaf-ts/decoration\";\n\n/**\n * @description Client-side JSON serializer for Decaf models targeting Hyperledger Fabric\n * @summary Extends the base JSONSerializer to embed model metadata (anchor) required to reconstruct instances on the client, and to safely serialize/deserialize Fabric-bound models.\n * @template M extends Model - The Decaf model type handled by this serializer\n * @param {void} [constructor] No public constructor arguments; provided for documentation completeness\n * @return {void}\n * @class ClientSerializer\n * @example\n * const serializer = new ClientSerializer<User>();\n * const json = serializer.serialize(new User({ id: \"1\", name: \"Alice\" }));\n * const user = serializer.deserialize(json);\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant Serializer as ClientSerializer\n *   participant Model\n *   App->>Serializer: serialize(model)\n *   Serializer->>Serializer: preSerialize(model)\n *   Serializer-->>App: JSON string\n *   App->>Serializer: deserialize(json)\n *   Serializer->>Serializer: JSON.parse(json)\n *   Serializer->>Model: Model.build(parsed, anchor)\n *   Model-->>App: instance\n */\nexport class ClientSerializer<M extends Model> extends JSONSerializer<M> {\n  constructor() {\n    super();\n  }\n  /**\n   * @description Prepare a model for JSON serialization embedding class anchor\n   * @summary Clones the model and injects the class metadata anchor so it can be reconstructed during deserialization. Falls back to provided table name if metadata is not available.\n   * @template M - Model type handled by this serializer\n   * @param {M} model - The model instance to serialize\n   * @param {string} [modelName] - Optional table name to use when metadata cannot be derived\n   * @return {Record<string, any>} A plain object ready to be JSON.stringify'd\n   */\n  protected override preSerialize(model: M, modelName?: string) {\n    // TODO: nested preserialization (so increase performance when deserializing)\n    const toSerialize: Record<string, any> = Object.assign({}, model);\n    let metadata = Metadata.modelName(model.constructor as Constructor<M>);\n\n    if (!metadata || metadata === \"Object\")\n      if (modelName) metadata = modelName;\n      else\n        throw new SerializationError(\n          `Could not find metadata for ${model.constructor.name}`\n        );\n    toSerialize[ModelKeys.ANCHOR] = metadata;\n    return toSerialize;\n  }\n\n  /**\n   * @description Rebuilds a model from its JSON serialization\n   * @summary Parses the JSON string, retrieves the embedded model anchor, and uses Model.build to reconstruct the original instance\n   * @param {string} str - The JSON string previously produced by serialize\n   * @return {M} The reconstructed model instance\n   */\n  override deserialize(str: string): M {\n    const deserialization = JSON.parse(str);\n    const className = deserialization[ModelKeys.ANCHOR];\n    if (!className)\n      throw new Error(\"Could not find class reference in serialized model\");\n    const model: M = Model.build(deserialization, className) as unknown as M;\n    return model;\n  }\n\n  /**\n   * @description Serializes a model to a JSON string\n   * @summary Prepares the model via preSerialize, embedding metadata needed for reconstruction, and returns a JSON string representation\n   * @param {M} model - The model instance to serialize\n   * @param {string} [table] - Optional table name to include as anchor when metadata is unavailable\n   * @return {string} A JSON string containing the serialized model with anchor metadata\n   */\n  override serialize(model: M, modelName?: string): string {\n    return JSON.stringify(this.preSerialize(model, modelName));\n  }\n}\n","import { FabricClientRepository } from \"../FabricClientRepository\";\nimport { ERC20Token, ERC20Wallet } from \"../../contracts/erc20/models\";\nimport { Model, Serializer } from \"@decaf-ts/decorator-validation\";\nimport { FabricClientAdapter } from \"../FabricClientAdapter\";\nimport { ClientSerializer } from \"../../shared/ClientSerializer\";\nimport {\n  Context,\n  ContextOf,\n  ContextualArgs,\n  EventIds,\n  MaybeContextualArg,\n  Sequence,\n} from \"@decaf-ts/core\";\nimport {\n  BulkCrudOperationKeys,\n  InternalError,\n  OperationKeys,\n} from \"@decaf-ts/db-decorators\";\nimport { Constructor } from \"@decaf-ts/decoration\";\n/**\n * Repository for interacting with ERC20 contracts on a Hyperledger Fabric network.\n * Extends the base FabricClientRepository class and utilizes the ClientSerializer for data serialization.\n */\nexport class FabricERC20ClientRepository<\n  A extends FabricClientAdapter,\n> extends FabricClientRepository<ERC20Wallet, A> {\n  private static serializer = new ClientSerializer();\n\n  protected readonly serializer: Serializer<any> =\n    FabricERC20ClientRepository.serializer;\n\n  private static decoder = new TextDecoder(\"utf8\");\n\n  /**\n   * @description Notifies all observers of an event.\n   * @summary Updates all registered observers with information about a database event.\n   * @param {string} table - The table name where the event occurred.\n   * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of event that occurred.\n   * @param {EventIds} id - The ID or IDs of the affected records.\n   * @param {...any[]} args - Additional arguments.\n   * @return {Promise<void>} A promise that resolves when all observers have been notified.\n   * @throws {InternalError} If the observer handler is not initialized.\n   */\n  override async updateObservers<M extends Model>(\n    table: Constructor<M> | string,\n    event: OperationKeys | BulkCrudOperationKeys | string,\n    id: EventIds,\n    ...args: ContextualArgs<ContextOf<A>>\n  ): Promise<void> {\n    if (!this.observerHandler)\n      throw new InternalError(\n        \"ObserverHandler not initialized. Did you register any observables?\"\n      );\n    const { log, ctxArgs } = this.logCtx(args, this.updateObservers);\n    log.verbose(\n      `Updating ${this.observerHandler.count()} observers for ${this}`\n    );\n\n    table = (\n      typeof table === \"string\" ? Model.get(table) : table\n    ) as Constructor<M>;\n    let parsedId: string | string[] | undefined;\n\n    if (id === undefined) {\n      parsedId = undefined;\n    } else if (Array.isArray(id)) {\n      parsedId = id.map(\n        (i) => Sequence.parseValue(Model.sequenceFor(table).type, i) as string\n      );\n    } else {\n      parsedId = Sequence.parseValue(\n        Model.sequenceFor(table).type,\n        id\n      ) as string;\n    }\n    await this.observerHandler.updateObservers(\n      table,\n      event,\n      parsedId!,\n      ...ctxArgs\n    );\n  }\n\n  /**\n   * Decodes a Uint8Array into a string using the TextDecoder.\n   *\n   * @param data - The Uint8Array to decode.\n   * @returns The decoded string.\n   */\n  decode(data: Uint8Array): string {\n    return FabricERC20ClientRepository.decoder.decode(data);\n  }\n\n  constructor(adapter?: A) {\n    super(adapter, ERC20Wallet);\n  }\n\n  /**\n   * Retrieves the name of the ERC20 token.\n   *\n   * @description\n   * This function interacts with the blockchain network to fetch the name of the ERC20 token.\n   * It calls the \"TokenName\" transaction on the smart contract and decodes the returned data.\n   *\n   * @returns {Promise<string>} A promise that resolves with the name of the ERC20 token.\n   *\n   * @throws {Error} If the transaction fails or the decoding process fails.\n   */\n  async tokenName(...args: MaybeContextualArg<ContextOf<A>>): Promise<string> {\n    const { ctx } = (await this.logCtx(args, \"tokenName\", true)).for(\n      this.tokenName\n    );\n    const name = await this.adapter.evaluateTransaction(ctx, \"TokenName\");\n    return this.decode(name);\n  }\n\n  /**\n   * Retrieves the symbol of the ERC20 token.\n   *\n   * This function interacts with the blockchain network to fetch the symbol of the ERC20 token.\n   * It calls the \"Symbol\" transaction on the smart contract and decodes the returned data.\n   *\n   * @returns {Promise<string>} A promise that resolves with the symbol of the ERC20 token.\n   *\n   * @throws {Error} If the transaction fails or the decoding process fails.\n   */\n  async symbol(...args: MaybeContextualArg<ContextOf<A>>): Promise<string> {\n    const { ctx } = (await this.logCtx(args, \"symbol\", true)).for(this.symbol);\n    const symbol = await this.adapter.evaluateTransaction(ctx, \"Symbol\");\n    return this.decode(symbol);\n  }\n\n  /**\n   * Retrieves the number of decimal places for the ERC20 token.\n   *\n   * This function interacts with the blockchain network to fetch the number of decimal places for the ERC20 token.\n   * It calls the \"Decimals\" transaction on the smart contract and decodes the returned data.\n   *\n   * @returns {Promise<number>} A promise that resolves with the number of decimal places for the ERC20 token.\n   *\n   * @throws {Error} If the transaction fails or the decoding process fails.\n   */\n  async decimals(...args: MaybeContextualArg<ContextOf<A>>): Promise<number> {\n    const { ctx } = (await this.logCtx(args, \"decimals\", true)).for(\n      this.decimals\n    );\n    const decimals = await this.adapter.evaluateTransaction(ctx, \"Decimals\");\n    return Number(this.decode(decimals));\n  }\n\n  /**\n   * Retrieves the total supply of the ERC20 token.\n   *\n   * This function interacts with the blockchain network to fetch the total supply of the ERC20 token.\n   * It calls the \"TotalSupply\" transaction on the smart contract and decodes the returned data.\n   *\n   * @returns {Promise<number>} A promise that resolves with the total supply of the ERC20 token.\n   *\n   * @throws {Error} If the transaction fails or the decoding process fails.\n   */\n  async totalSupply(\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<number> {\n    const { ctx } = (await this.logCtx(args, \"totalSupply\", true)).for(\n      this.totalSupply\n    );\n    const total = await this.adapter.evaluateTransaction(ctx, \"TotalSupply\");\n    return Number(this.decode(total));\n  }\n\n  /**\n   * Retrieves the balance of the ERC20 token for a specified owner.\n   *\n   * @description\n   * This function interacts with the blockchain network to fetch the balance of the ERC20 token for a given owner.\n   * It calls the \"BalanceOf\" transaction on the smart contract with the provided owner's address as a parameter.\n   * The returned data is then decoded and converted to a number.\n   *\n   * @param owner - The address of the ERC20 token owner.\n   *\n   * @returns {Promise<number>} A promise that resolves with the balance of the ERC20 token for the specified owner.\n   *\n   * @throws {Error} If the transaction fails or the decoding process fails.\n   */\n  async balanceOf(\n    owner: string,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<number> {\n    const { ctx } = (await this.logCtx(args, \"balance\", true)).for(\n      this.balanceOf\n    );\n    const balance = await this.adapter.evaluateTransaction(ctx, \"BalanceOf\", [\n      owner,\n    ]);\n    return Number(this.decode(balance));\n  }\n\n  /**\n   * Transfers a specified amount of ERC20 tokens to a recipient.\n   *\n   * @description\n   * This function interacts with the blockchain network to transfer a specified amount of ERC20 tokens to a recipient.\n   * It calls the \"Transfer\" transaction on the smart contract with the recipient's address and the transfer amount as parameters.\n   * The returned data is then decoded and checked to determine if the transfer was successful.\n   *\n   * @param to - The address of the recipient.\n   * @param value - The amount of ERC20 tokens to transfer.\n   *\n   * @returns {Promise<boolean>} A promise that resolves with `true` if the transfer was successful, and `false` otherwise.\n   *\n   * @throws {Error} If the transaction fails or the decoding process fails.\n   */\n  async transfer(\n    to: string,\n    value: number,\n    ...args: MaybeContextualArg<ContextOf<A>>\n  ): Promise<boolean> {\n    const { ctx } = (await this.logCtx(args, \"transfer\", true)).for(\n      this.transfer\n    );\n    const transferred = await this.adapter.submitTransaction(ctx, \"Transfer\", [\n      to,\n      value.toString(),\n    ]);\n    return this.decode(transferred) === \"true\" ? true : false;\n  }\n\n  /**\n   * Transfers a specified amount of ERC20 tokens from one account to another.\n   *\n   * @description\n   * This function interacts with the blockchain network to transfer a specified amount of ERC20 tokens from one account to another.\n   * For this transfer to work the spender ( account that will trigger this function ) need to have the value approved as an allowance by the sender.\n   * It calls the \"TransferFrom\" transaction on the smart contract with the sender's address, recipient's address, and the transfer amount as parameters.\n   * The returned data is then decoded and checked to determine if the transfer was successful.\n   *\n   * @param from - The address of the sender.\n   * @param to - The address of the recipient.\n   * @param value - The amount of ERC20 tokens to transfer.\n   *\n   * @returns {Promise<boolean>} A promise that resolves with `true` if the transfer was successful, and `false` otherwise.\n   *\n   * @throws {Error} If the transaction fails or the decoding process fails.\n   */\n  async transferFrom(\n    from: string,\n    to: string,\n    value: number\n  ): Promise<boolean> {\n    const contextArgs = await Context.args(\n      \"transferFrom\",\n      this.class,\n      [],\n      this.adapter,\n      this._overrides || {}\n    );\n    const { ctx } = this.logCtx(contextArgs.args, this.transferFrom);\n    const transferred = await this.adapter.submitTransaction(\n      ctx,\n      \"TransferFrom\",\n      [from, to, value.toString()]\n    );\n\n    return this.decode(transferred) === \"true\" ? true : false;\n  }\n\n  /**\n   * Approves a specified amount of ERC20 tokens to be spent by a specified spender.\n   *\n   * This function interacts with the blockchain network to approve a specified amount of ERC20 tokens to be spent by a specified spender.\n   * It calls the \"Approve\" transaction on the smart contract with the spender's address and the approval amount as parameters.\n   * The returned data is then decoded and checked to determine if the approval was successful.\n   *\n   * @param spender - The address of the spender.\n   * @param value - The amount of ERC20 tokens to approve for the spender.\n   *\n   * @returns {Promise<boolean>} A promise that resolves with `true` if the approval was successful, and `false` otherwise.\n   *\n   * @throws {Error} If the transaction fails or the decoding process fails.\n   */\n  async approve(spender: string, value: number): Promise<boolean> {\n    const contextArgs = await Context.args(\n      \"approve\",\n      this.class,\n      [],\n      this.adapter,\n      this._overrides || {}\n    );\n    const { ctx } = this.logCtx(contextArgs.args, this.approve);\n    const approved = await this.adapter.submitTransaction(ctx, \"Approve\", [\n      spender,\n      value.toString(),\n    ]);\n    return this.decode(approved) === \"true\" ? true : false;\n  }\n\n  /**\n   * Retrieves the allowance of ERC20 tokens that the specified owner has approved for a spender.\n   *\n   * @description\n   * This function interacts with the blockchain network to fetch the allowance of ERC20 tokens that the specified owner has approved for a spender.\n   * It calls the \"Allowance\" transaction on the smart contract with the owner's address and the spender's address as parameters.\n   * The returned data is then decoded and converted to a number.\n   *\n   * @param owner - The address of the ERC20 token owner.\n   * @param spender - The address of the spender.\n   *\n   * @returns {Promise<number>} A promise that resolves with the allowance of ERC20 tokens that the specified owner has approved for the spender.\n   *\n   * @throws {Error} If the transaction fails or the decoding process fails.\n   */\n  async allowance(owner: string, spender: string): Promise<number> {\n    const contextArgs = await Context.args(\n      \"allowance\",\n      this.class,\n      [],\n      this.adapter,\n      this._overrides || {}\n    );\n    const { ctx } = this.logCtx(contextArgs.args, this.allowance);\n    const allowance = await this.adapter.submitTransaction(ctx, \"Allowance\", [\n      owner,\n      spender,\n    ]);\n    return Number(this.decode(allowance));\n  }\n\n  /**\n   * Initializes the ERC20 contract with the provided token information.\n   *\n   * @description\n   * This function interacts with the blockchain network to initialize the ERC20 contract with the given token information.\n   * It calls the \"Initialize\" transaction on the smart contract with the serialized token data as a parameter.\n   * The returned data is then decoded and checked to determine if the initialization was successful.\n   *\n   * @param token - The ERC20 token information to initialize the contract with.\n   *\n   * @returns {Promise<boolean>} A promise that resolves with `true` if the initialization was successful, and `false` otherwise.\n   *\n   * @throws {Error} If the transaction fails or the decoding process fails.\n   */\n  async initialize(token: ERC20Token): Promise<boolean> {\n    const contextArgs = await Context.args(\n      \"initialize\",\n      this.class,\n      [],\n      this.adapter,\n      this._overrides || {}\n    );\n    const { ctx } = this.logCtx(contextArgs.args, this.initialize);\n    const initiliazed = await this.adapter.submitTransaction(\n      ctx,\n      \"Initialize\",\n      [FabricERC20ClientRepository.serializer.serialize(token)]\n    );\n\n    return this.decode(initiliazed) === \"true\" ? true : false;\n  }\n\n  /**\n   * Checks if the ERC20 contract has been initialized.\n   *\n   * This function interacts with the blockchain network to verify if the ERC20 contract has been initialized.\n   * It calls the \"CheckInitialized\" transaction on the smart contract, which does not require any parameters.\n   *\n   * @returns {Promise<void>} A promise that resolves when the initialization check is completed.\n   *\n   * @throws {Error} If the transaction fails.\n   */\n  async checkInitialized(): Promise<void> {\n    const contextArgs = await Context.args(\n      \"checkInitialized\",\n      this.class,\n      [],\n      this.adapter,\n      this._overrides || {}\n    );\n    const { ctx } = this.logCtx(contextArgs.args, this.checkInitialized);\n    await this.adapter.evaluateTransaction(ctx, \"CheckInitialized\");\n  }\n\n  /**\n   * Mints a specified amount of ERC20 tokens.\n   *\n   * @description\n   * This function interacts with the blockchain network to mint a specified amount of ERC20 tokens.\n   * It calls the \"Mint\" transaction on the smart contract with the minting amount as a parameter.\n   * The function does not return any value, but it updates the minter's number of tokens.\n   *\n   * @param amount - The amount of ERC20 tokens to mint.\n   *\n   * @returns {Promise<void>} A promise that resolves when the minting process is completed.\n   *\n   * @throws {Error} If the transaction fails.\n   */\n  async mint(amount: number): Promise<void> {\n    const contextArgs = await Context.args(\n      \"mint\",\n      this.class,\n      [],\n      this.adapter,\n      this._overrides || {}\n    );\n    const { ctx } = this.logCtx(contextArgs.args, this.mint);\n    await this.adapter.submitTransaction(ctx, \"Mint\", [amount.toString()]);\n  }\n\n  /**\n   * Burns a specified amount of ERC20 tokens from the minter's account.\n   *\n   * This function interacts with the blockchain network to burn a specified amount of ERC20 tokens.\n   * It calls the \"Burn\" transaction on the smart contract with the burning amount as a parameter.\n   * The function does not return any value, but it decreases the minter's number of tokens.\n   *\n   * @param amount - The amount of ERC20 tokens to burn.\n   *\n   * @returns {Promise<void>} A promise that resolves when the burning process is completed.\n   *\n   * @throws {Error} If the transaction fails.\n   */\n  async burn(amount: number): Promise<void> {\n    const contextArgs = await Context.args(\n      \"burn\",\n      this.class,\n      [],\n      this.adapter,\n      this._overrides || {}\n    );\n    const { ctx } = this.logCtx(contextArgs.args, this.burn);\n    await this.adapter.submitTransaction(ctx, \"Burn\", [amount.toString()]);\n  }\n\n  /**\n   * Burns a specified amount of ERC20 tokens from a specified account.\n   *\n   * This function interacts with the blockchain network to burn a specified amount of ERC20 tokens from a given account.\n   * It calls the \"BurnFrom\" transaction on the smart contract with the account's address and the burning amount as parameters.\n   * The function does not return any value, but it decreases the specified account's number of tokens.\n   *\n   * @param account - The address of the account from which to burn the ERC20 tokens.\n   * @param amount - The amount of ERC20 tokens to burn.\n   *\n   * @returns {Promise<void>} A promise that resolves when the burning process is completed.\n   *\n   * @throws {Error} If the transaction fails.\n   */\n  async burnFrom(account: string, amount: number): Promise<void> {\n    const contextArgs = await Context.args(\n      \"burnFrom\",\n      this.class,\n      [],\n      this.adapter,\n      this._overrides || {}\n    );\n    const { ctx } = this.logCtx(contextArgs.args, this.burnFrom);\n    await this.adapter.submitTransaction(ctx, \"BurnFrom\", [\n      account,\n      amount.toString(),\n    ]);\n  }\n\n  /**\n   * Retrieves the balance of ERC20 tokens associated with the client's account.\n   *\n   * This function interacts with the blockchain network to fetch the balance of ERC20 tokens associated with the client's account.\n   * It calls the \"ClientAccountBalance\" transaction on the smart contract, which does not require any parameters.\n   * The returned data is then decoded and converted to a number.\n   *\n   * @returns {Promise<number>} A promise that resolves with the balance of ERC20 tokens associated with the client's account.\n   *\n   * @throws {Error} If the transaction fails or the decoding process fails.\n   */\n  async clientAccountBalance(): Promise<number> {\n    const contextArgs = await Context.args(\n      \"accountBalance\",\n      this.class,\n      [],\n      this.adapter,\n      this._overrides || {}\n    );\n    const { ctx } = this.logCtx(contextArgs.args, this.clientAccountBalance);\n    const serializedAccountBalance = await this.adapter.evaluateTransaction(\n      ctx,\n      \"ClientAccountBalance\"\n    );\n\n    return Number(this.decode(serializedAccountBalance));\n  }\n\n  /**\n   * Retrieves the client's account ID from the blockchain network.\n   *\n   * This function interacts with the blockchain network to fetch the client's account ID.\n   * It calls the \"ClientAccountID\" transaction on the smart contract, which does not require any parameters.\n   * The returned data is then decoded and returned as a string.\n   *\n   * @returns {Promise<string>} A promise that resolves with the client's account ID.\n   *\n   * @throws {Error} If the transaction fails or the decoding process fails.\n   */\n  async clientAccountID(): Promise<string> {\n    const contextArgs = await Context.args(\n      \"accountId\",\n      this.class,\n      [],\n      this.adapter,\n      this._overrides || {}\n    );\n    const { ctx } = this.logCtx(contextArgs.args, this.clientAccountID);\n    const clientAccountID = await this.adapter.evaluateTransaction(\n      ctx,\n      \"ClientAccountID\"\n    );\n\n    return this.decode(clientAccountID);\n  }\n}\n","import { Model } from \"@decaf-ts/decorator-validation\";\nimport { InternalError, PrimaryKeyType } from \"@decaf-ts/db-decorators\";\nimport { Constructor } from \"@decaf-ts/decoration\";\nimport { SequenceOptions } from \"@decaf-ts/core\";\nimport { composeAttributeValue } from \"@decaf-ts/db-decorators\";\n\nexport function extractIds<M extends Model>(\n  clazz: Constructor<M>,\n  models: M | M[] | Record<string, any> | Record<string, any>[],\n  ids: PrimaryKeyType | PrimaryKeyType[]\n) {\n  let pk: keyof M;\n  let composed: any;\n  let pkProps: SequenceOptions;\n\n  function extractId(m: M | Record<string, any>, ids: PrimaryKeyType) {\n    pk = pk || Model.pk(clazz);\n    pkProps = pkProps || Model.sequenceFor(clazz);\n    composed = composed || Model.composed(clazz, pk);\n\n    if (composed) {\n      return composeAttributeValue(m as any, composed);\n    }\n\n    const id = (m as any)[pk] || ids;\n    if (typeof id === \"undefined\")\n      throw new InternalError(`could not rebuild id for ${m.constructor.name}`);\n    return id;\n  }\n\n  if (Array.isArray(models)) {\n    if (!Array.isArray(ids) || ids.length !== models.length)\n      throw new InternalError(\n        \"inconsistent parameters. both must be arrays of equal length\"\n      );\n    return models.map((m, i) => extractId(m, ids[i]));\n  }\n  return extractId(models, ids as PrimaryKeyType);\n}\n","import { BaseModel, column, pk } from \"@decaf-ts/core\";\nimport { model, type ModelArg, required } from \"@decaf-ts/decorator-validation\";\nimport { description } from \"@decaf-ts/decoration\";\n\n/**\n * @description Identity credential model storing cryptographic materials\n * @summary Holds certificate chain and private key information for a Fabric identity, managed as a separate entity linked from Identity\n * @param {ModelArg<IdentityCredentials>} [arg] - Optional initialization object used to populate model fields\n * @class IdentityCredentials\n * @example\n * // Create credentials entry\n * const creds = new IdentityCredentials({ id: \"creds1\", certificate: \"...\", rootCertificate: \"...\", privateKey: \"...\" });\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant Model as IdentityCredentials\n *   App->>Model: new IdentityCredentials({ id, certificate, rootCertificate, privateKey })\n *   Model-->>App: instance\n * @see model\n */\n@model()\nexport class IdentityCredentials extends BaseModel {\n  /**\n   * @description Unique identifier of the credentials record\n   * @summary Primary key for referencing this credentials entry\n   */\n  @description(\"Unique identifier of the credentials record\")\n  @column()\n  @pk()\n  id!: string;\n\n  /**\n   * @description PEM-encoded X.509 certificate for the identity\n   * @summary Leaf certificate associated with the identity\n   */\n  @description(\"PEM-encoded X.509 certificate for the identity\")\n  @column()\n  @required()\n  certificate!: string;\n\n  /**\n   * @description PEM-encoded root or intermediate certificate\n   * @summary Root of trust used to validate the leaf certificate\n   */\n  @description(\"PEM-encoded root or intermediate certificate\")\n  @column()\n  @required()\n  rootCertificate!: string;\n\n  /**\n   * @description PEM-encoded private key material\n   * @summary Private key corresponding to the identity certificate\n   */\n  @description(\"PEM-encoded private key\")\n  @column()\n  @required()\n  privateKey!: string;\n\n  constructor(arg?: ModelArg<IdentityCredentials>) {\n    super(arg);\n  }\n}\n","/**\n * @description Keys used to mark Fabric-specific model metadata\n * @summary Enumeration of special keys used by the serialization layer to persist Fabric-related flags on models\n * @enum {string}\n * @readonly\n * @memberOf module:for-fabric.shared\n */\nexport enum FabricModelKeys {\n  /** Private data marker used to tag properties or models for Fabric private collections */\n  PRIVATE = \"private\",\n  SHARED = \"shared\",\n  /** Namespace prefix used for Fabric-specific metadata keys */\n  FABRIC = \"fabric\",\n  OWNED_BY = \"owned-by\",\n  TRANSACTION_ID = \"transaction-id\",\n  MIRROR = \"mirror\",\n}\n/**\n * @description Supported identity types for Fabric credentials\n * @summary Enumeration of identity formats recognized by this library\n * @enum {string}\n * @readonly\n * @memberOf module:for-fabric.shared\n */\nexport enum IdentityType {\n  /** Standard X.509 identity format used by Hyperledger Fabric */\n  X509 = \"X.509\",\n}\n\n/**\n * @description String identifier for the Fabric adapter flavour\n * @summary Used to tag adapters/repositories that operate against Hyperledger Fabric\n * @const FabricFlavour\n * @memberOf module:for-fabric.shared\n */\nexport const FabricFlavour = \"hlf-fabric\";\n","import {\n  BaseModel,\n  Cascade,\n  column,\n  index,\n  oneToOne,\n  pk,\n} from \"@decaf-ts/core\";\nimport { model, type ModelArg, required } from \"@decaf-ts/decorator-validation\";\nimport { IdentityCredentials } from \"./IdentityCredentials\";\nimport { IdentityType } from \"../constants\";\nimport { description } from \"@decaf-ts/decoration\";\n\n/**\n * @description Identity model representing a Fabric wallet entry\n * @summary Encapsulates an identity stored in a Fabric wallet, including its MSP identifier, credential linkage, and type information. Built on BaseModel for integration with Decaf validation and persistence.\n * @param {ModelArg<Identity>} [arg] - Optional initialization object used to populate model fields\n * @class Identity\n * @example\n * // Create a new identity referencing existing credentials\n * const id = new Identity({ id: \"user1\", mspId: \"Org1MSP\", type: IdentityType.X509 });\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant Model as Identity\n *   App->>Model: new Identity({ id, mspId, type })\n *   Model-->>App: instance\n */\n@model()\nexport class Identity extends BaseModel {\n  /**\n   * @description Unique identifier of the identity in the wallet\n   * @summary Primary key used to reference this identity record\n   */\n  @description(\"Unique identifier of the identity\")\n  @pk()\n  id!: string;\n\n  /**\n   * @description Link to the identity credentials stored separately\n   * @summary One-to-one relationship to the credentials entity; cascades on update and delete\n   */\n  @oneToOne(IdentityCredentials, {\n    update: Cascade.CASCADE,\n    delete: Cascade.CASCADE,\n  })\n  credentials!: IdentityCredentials;\n\n  /**\n   * @description Membership Service Provider identifier\n   * @summary The MSP ID corresponding to the organization that issued this identity\n   */\n  @column()\n  @required()\n  @index()\n  mspId!: string;\n\n  /**\n   * @description Type of identity\n   * @summary Indicates the identity encoding/format; defaults to X.509\n   */\n  @column()\n  @required()\n  type: IdentityType = IdentityType.X509;\n\n  constructor(arg: ModelArg<Identity>) {\n    super(arg);\n  }\n}\n","import { stringFormat } from \"@decaf-ts/decorator-validation\";\nimport { Logger, MiniLogger } from \"@decaf-ts/logging\";\nimport { Identity, Signer, signers } from \"@hyperledger/fabric-gateway\";\nimport { CryptoSetting, ICryptoSuite, User } from \"fabric-common\";\nimport { HSMOptions } from \"../shared/types\";\nimport { normalizeImport } from \"@decaf-ts/core\";\nimport crypto, { X509Certificate } from \"crypto\";\nimport { X509Certificate as X509Cert } from \"@peculiar/x509\";\n\n/**\n * @description Core utilities for interacting with files, crypto identities, and Fabric SDK helpers\n * @summary Provides static helper methods to read credentials and keys from disk or raw content, construct Fabric gateway Identities and Signers, and perform common filesystem operations used by the Fabric client tooling.\n * @class CoreUtils\n * @example\n * // Read an identity and signer from directories\n * const identity = await CoreUtils.getIdentity('Org1MSP', '/msp/signcerts');\n * const signer = await CoreUtils.getSigner('/msp/keystore');\n * // Build a CA user\n * const user = await CoreUtils.getCAUser('appUser', pemKey, pemCert, 'Org1MSP');\n */\nexport class CoreUtils {\n  private static logger: Logger = new MiniLogger(CoreUtils.name);\n\n  private static cryptoSuite: ICryptoSuite;\n\n  private constructor() {}\n\n  /**\n   * @description Resolve file content from a path or return provided raw content\n   * @summary If the input is a Uint8Array or PEM content, returns it as-is; otherwise uses a provided async fileReader to load the content from disk.\n   * @param {string|Uint8Array} contentOrPath - Either a raw content buffer/string or a filesystem path\n   * @param {function(string): Promise<string|Uint8Array|Buffer>} fileReader - Async function to read file content when a path is provided\n   * @return {Promise<string|Uint8Array|Buffer>} The content to be used downstream\n   */\n  private static async contentOfLoadFile(\n    contentOrPath: string | Uint8Array,\n    fileReader: (path: string) => Promise<string | Uint8Array | Buffer>\n  ) {\n    if (contentOrPath instanceof Uint8Array) return contentOrPath;\n    if (\n      contentOrPath.match(\n        /-----BEGIN (CERTIFICATE|KEY|PRIVATE KEY)-----.+?-----END \\1-----$/gms\n      )\n    )\n      return contentOrPath;\n    return await fileReader(contentOrPath);\n  }\n\n  /**\n   * @description Read file content from a path or return provided Buffer\n   * @summary Convenience wrapper that loads a file using fs.promises when a path string is provided; otherwise returns the given Buffer directly.\n   * @param {string|Buffer} contentOrPath - Path to a file on disk or an already-loaded Buffer\n   * @return {Promise<string|Uint8Array|Buffer>} The file content as a Buffer/string depending on reader\n   */\n  static async readFile(contentOrPath: string | Buffer) {\n    if (typeof contentOrPath !== \"string\") return contentOrPath;\n\n    const fileReader = async (path: string) => {\n      const { promises } = await normalizeImport(import(\"fs\"));\n      return await promises.readFile(path);\n    };\n\n    return await fileReader(contentOrPath);\n  }\n\n  /**\n   * @description Create a Fabric CA User object with enrollment\n   * @summary Constructs a fabric-common User, sets a crypto suite, imports the provided private key, and sets enrollment with certificate and MSP ID.\n   * @param {string} userName - The user name for the CA user\n   * @param {string} privateKey - PEM-encoded private key\n   * @param {string} certificate - PEM-encoded X.509 certificate\n   * @param {string} mspId - Membership Service Provider identifier\n   * @return {Promise<User>} The enrolled Fabric User instance\n   */\n  static async getCAUser(\n    userName: string,\n    privateKey: string | undefined,\n    certificate: string,\n    mspId: string,\n    options?: { hsm?: HSMOptions }\n  ): Promise<User> {\n    this.logger.debug(\n      stringFormat(\n        \"Creating CA {0} user {1} with certificate {2}\",\n        mspId,\n        userName,\n        certificate\n      )\n    );\n    const user = new User(userName);\n    const config = options?.hsm\n      ? {\n          software: false,\n          lib: options.hsm.library,\n          slot: options.hsm.slot,\n          label: options.hsm.tokenLabel,\n          pin: String(options.hsm.pin),\n        }\n      : undefined;\n    const cryptoSuite = this.getCryptoSuite(config);\n\n    user.setCryptoSuite(cryptoSuite);\n    const enrollmentKey = options?.hsm\n      ? await this.getHSMEnrollmentKey(cryptoSuite, certificate, options.hsm)\n      : this.getSoftwareEnrollmentKey(cryptoSuite, privateKey);\n    await user.setEnrollment(enrollmentKey, certificate, mspId);\n    return user;\n  }\n\n  static getCryptoSuite(options?: CryptoSetting): ICryptoSuite {\n    if (!options) return User.newCryptoSuite();\n    if (CoreUtils.cryptoSuite) return CoreUtils.cryptoSuite;\n\n    CoreUtils.cryptoSuite = User.newCryptoSuite(options);\n    return CoreUtils.cryptoSuite;\n  }\n\n  private static getSoftwareEnrollmentKey(\n    cryptoSuite: any,\n    privateKey?: string\n  ) {\n    if (!privateKey) {\n      throw new Error(\n        \"Private key must be provided when HSM configuration is not supplied\"\n      );\n    }\n    return cryptoSuite.createKeyFromRaw(privateKey);\n  }\n\n  private static async getHSMEnrollmentKey(\n    cryptoSuite: any,\n    certificate: string,\n    hsm: HSMOptions\n  ) {\n    const ski =\n      hsm.keyIdHex && hsm.keyIdHex.trim().length > 0\n        ? Buffer.from(hsm.keyIdHex, \"hex\")\n        : await this.getCertificateSKI(certificate);\n    const key = await cryptoSuite.getKey(ski);\n    if (!key || (typeof key.isPrivate === \"function\" && !key.isPrivate())) {\n      throw new Error(\"Unable to resolve private key from HSM\");\n    }\n    return key;\n  }\n\n  static async getCertificateSKI(certificate: string): Promise<Buffer> {\n    const x509 = new X509Certificate(certificate);\n    const jwk = x509.publicKey.export({ format: \"jwk\" });\n    const prefix = Buffer.from([0x04]);\n    const x = Buffer.from(jwk.x || \"\", \"base64url\");\n    const y = Buffer.from(jwk.y || \"\", \"base64url\");\n    return crypto\n      .createHash(\"sha256\")\n      .update(Buffer.concat([prefix, x, y]))\n      .digest();\n  }\n\n  /**\n   * @description Build a Fabric Gateway Identity from an MSP ID and certificate\n   * @summary Reads a certificate from a directory path or accepts raw content and returns an Identity object suitable for the Fabric Gateway.\n   * @param {string} mspId - Membership Service Provider ID\n   * @param {string} certDirectoryPath - Path to a directory containing the certificate file, or PEM content\n   * @return {Promise<Identity>} The identity containing mspId and certificate credentials\n   */\n  static async getIdentity(\n    mspId: string,\n    certDirectoryPath: string\n  ): Promise<Identity> {\n    const identityFileReader = async (path: string) => {\n      const { promises } = await normalizeImport(import(\"fs\"));\n      const certPath = await this.getFirstDirFileName(path);\n      const credentials = await promises.readFile(certPath);\n      return credentials;\n    };\n\n    const credentials: Uint8Array = (await this.contentOfLoadFile(\n      certDirectoryPath,\n      identityFileReader\n    )) as Uint8Array;\n\n    return { mspId, credentials };\n  }\n\n  static async getFirstDirFileName(dirPath: string): Promise<string> {\n    const { promises } = await normalizeImport(import(\"fs\"));\n    const { join } = await normalizeImport(import(\"path\"));\n    const files = await promises.readdir(dirPath);\n    return join(dirPath, files[0]);\n  }\n\n  static async getFirstDirFileNameContent(dirPath: string): Promise<string> {\n    const { promises } = await normalizeImport(import(\"fs\"));\n    const { join } = await normalizeImport(import(\"path\"));\n    const files = await promises.readdir(dirPath);\n    return (await promises.readFile(join(dirPath, files[0]))).toString();\n  }\n\n  static async getFileContent(filePath: string): Promise<string> {\n    const { promises } = await normalizeImport(import(\"fs\"));\n    return (await promises.readFile(filePath)).toString();\n  }\n\n  static async getSigner(keyDirectoryPath: string): Promise<Signer> {\n    const signerFileReader = async (path: string) => {\n      const { promises } = await normalizeImport(import(\"fs\"));\n      const keyPath = await this.getFirstDirFileName(path);\n      return await promises.readFile(keyPath);\n    };\n\n    const privateKeyPem = (await this.contentOfLoadFile(\n      keyDirectoryPath,\n      signerFileReader\n    )) as Buffer;\n    const privateKey = await this.extractPrivateKey(privateKeyPem);\n    const keys = Object.getOwnPropertySymbols(privateKey);\n    const k = (privateKey as any)[keys[0]];\n    // --\n\n    return signers.newPrivateKeySigner(k as any);\n  }\n\n  private static async extractPrivateKey(pem: Buffer) {\n    const libName = \"crypto\";\n    let subtle: any;\n    if (\n      (globalThis as any).window &&\n      ((globalThis as any).window as { Crypto: any }).Crypto\n    ) {\n      subtle = ((globalThis as any).Crypto as any).subtle;\n    } else {\n      const lib = (await normalizeImport(import(libName))) as any;\n      subtle = lib.subtle || lib.webcrypto.subtle;\n    }\n\n    if (!subtle) throw new Error(\"Could not load SubtleCrypto module\");\n\n    function str2ab(str: string) {\n      const buf = new ArrayBuffer(str.length);\n      const bufView = new Uint8Array(buf);\n      for (let i = 0, strLen = str.length; i < strLen; i++) {\n        bufView[i] = str.charCodeAt(i);\n      }\n      return buf;\n    }\n\n    const str = pem\n      .toString(\"utf8\")\n      .replace(\"-----BEGIN PRIVATE KEY-----\", \"\")\n      .replaceAll(\"\\n\", \"\")\n      .replace(\"-----END PRIVATE KEY-----\", \"\");\n    const decoded = Buffer.from(str, \"base64\").toString(\"binary\");\n    const binaryDer = str2ab(decoded);\n    const key = await subtle.importKey(\n      \"pkcs8\",\n      binaryDer,\n      {\n        name: \"ECDSA\",\n        namedCurve: \"P-256\",\n      },\n      true,\n      [\"sign\"]\n    );\n\n    return key;\n  }\n}\n\n/**\n * Extracts the certificate Serial Number and the AKI (Authority Key Identifier)\n * in the format Fabric CA expects (plain hex, no colons).\n */\nexport function getAkiAndSerialFromCert(cert: string): {\n  aki: string;\n  serial: string;\n} {\n  const x509Certificate = new X509Cert(cert);\n\n  // Find the AKI (Authority Key Identifier) extension by its OID: 2.5.29.35\n  const akiExt = x509Certificate.extensions?.find(\n    (e) => e.type === \"2.5.29.35\"\n  );\n  if (!akiExt) {\n    throw new Error(\n      \"Authority Key Identifier (AKI) extension not found in certificate.\"\n    );\n  }\n\n  // akiExt.value is the extension content in DER bytes. Convert it to a hex string.\n  let aki = Buffer.from(new Uint8Array(akiExt.value))\n    .toString(\"hex\")\n    .toUpperCase();\n\n  /**\n   * Common case:\n   * The DER-encoded AKI extension often starts with:\n   *   30 16 80 14 <20-byte keyIdentifier>\n   * In hex, that's \"30168014\" + 40 hex chars (20 bytes).\n   *\n   * Fabric CA expects ONLY the 20-byte keyIdentifier (40 hex chars),\n   * so we strip the \"30168014\" prefix when present.\n   */\n  if (aki.startsWith(\"30168014\") && aki.length >= 8 + 40)\n    aki = aki.slice(8, 8 + 40);\n\n  return { aki, serial: x509Certificate.serialNumber };\n}\n","import * as x509 from \"@peculiar/x509\";\nimport { Crypto, CryptoKey } from \"@peculiar/webcrypto\";\nimport { stringFormat } from \"@decaf-ts/decorator-validation\";\nimport { isBrowser, MiniLogger } from \"@decaf-ts/logging\";\n\nconst crypto = new Crypto();\nx509.cryptoProvider.set(crypto);\n\nexport enum BASE_ALPHABET {\n  BASE2 = \"01\",\n  BASE8 = \"01234567\",\n  BASE11 = \"0123456789a\",\n  BASE16 = \"0123456789abcdef\",\n  BASE32 = \"0123456789ABCDEFGHJKMNPQRSTVWXYZ\",\n  BASE32_Z = \"ybndrfg8ejkmcpqxot1uwisza345h769\",\n  BASE36 = \"0123456789abcdefghijklmnopqrstuvwxyz\",\n  BASE58 = \"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz\",\n  BASE62 = \"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\",\n  BASE64 = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\",\n  BASE67 = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.!~\",\n}\n\nexport type keyObject = {\n  iv: ArrayBuffer;\n  key: CryptoKey;\n};\n\nexport enum CRYPTO {\n  HASH = \"SHA-256\",\n  ITERATIONS = 1000,\n  KEYLENGTH = 48,\n  DERIVED_IV_LENGTH = 16,\n  DERIVED_KEY_LENGTH = 32, // Because SHA-256 used has a native size of 32 bytes\n  ALGORYTHM = \"AES-GCM\",\n  KEY_ALGORYTHM = \"PBKDF2\",\n}\n\nexport class BaseEncoder {\n  private readonly baseMap: Uint8Array = new Uint8Array(256);\n  private readonly base: number;\n  private readonly leader: string;\n  private readonly factor: number;\n  private readonly iFactor: number;\n\n  constructor(private alphabet: BASE_ALPHABET) {\n    if (this.alphabet.length >= 255) throw new Error(\"Alphabet too long\");\n\n    for (let j = 0; j < this.baseMap.length; j++) this.baseMap[j] = 255;\n\n    for (let i = 0; i < alphabet.length; i++) {\n      const x = alphabet.charAt(i);\n      const xc = x.charCodeAt(0);\n      if (this.baseMap[xc] !== 255) throw new Error(x + \" is ambiguous\");\n\n      this.baseMap[xc] = i;\n    }\n\n    this.base = this.alphabet.length;\n    this.leader = this.alphabet.charAt(0);\n    this.factor = Math.log(this.base) / Math.log(256); // log(BASE) / log(256), rounded up\n    this.iFactor = Math.log(256) / Math.log(this.base); // log(256) / log(BASE), rounded up\n  }\n\n  encode(source: Uint8Array | DataView | any[] | string) {\n    if (typeof source === \"string\") {\n      source = Buffer.from(source);\n    } else if (ArrayBuffer.isView(source)) {\n      source = new Uint8Array(\n        source.buffer,\n        source.byteOffset,\n        source.byteLength\n      );\n    } else if (Array.isArray(source)) {\n      source = Uint8Array.from(source);\n    }\n\n    if (source.length === 0) return \"\";\n\n    // Skip & count leading zeroes.\n    let zeroes = 0;\n    let length = 0;\n    let pbegin = 0;\n    const pend = source.length;\n    while (pbegin !== pend && source[pbegin] === 0) {\n      pbegin++;\n      zeroes++;\n    }\n    // Allocate enough space in big-endian base58 representation.\n    const size = ((pend - pbegin) * this.iFactor + 1) >>> 0;\n    const b58 = new Uint8Array(size);\n    // Process the bytes.\n    while (pbegin !== pend) {\n      let carry = source[pbegin];\n      // Apply \"b58 = b58 * 256 + ch\".\n      let i = 0;\n      for (\n        let it1 = size - 1;\n        (carry !== 0 || i < length) && it1 !== -1;\n        it1--, i++\n      ) {\n        carry += (256 * b58[it1]) >>> 0;\n        b58[it1] = carry % this.base >>> 0;\n        carry = (carry / this.base) >>> 0;\n      }\n      if (carry !== 0) throw new Error(\"Non-zero carry\");\n\n      length = i;\n      pbegin++;\n    }\n    // Skip leading zeroes in base58 result.\n    let it2 = size - length;\n    while (it2 !== size && b58[it2] === 0) it2++;\n\n    // Translate the result into a string.\n    let str = this.leader.repeat(zeroes);\n    for (; it2 < size; ++it2) {\n      str += this.alphabet.charAt(b58[it2]);\n    }\n    return str;\n  }\n\n  private decodeUnsafe(source: string): Uint8Array | undefined {\n    if (source.length === 0) return new Uint8Array(0);\n\n    let psz = 0;\n    // Skip and count leading '1's.\n    let zeroes = 0;\n    let length = 0;\n    while (source[psz] === this.leader) {\n      zeroes++;\n      psz++;\n    }\n    // Allocate enough space in big-endian base256 representation.\n    const size = ((source.length - psz) * this.factor + 1) >>> 0; // log(58) / log(256), rounded up.\n    const b256 = new Uint8Array(size);\n    // Process the characters.\n    while (source[psz]) {\n      // Decode character\n      let carry = this.baseMap[source.charCodeAt(psz)];\n      // Invalid character\n      if (carry === 255) return;\n\n      let i = 0;\n      for (\n        let it3 = size - 1;\n        (carry !== 0 || i < length) && it3 !== -1;\n        it3--, i++\n      ) {\n        carry += (this.base * b256[it3]) >>> 0;\n        b256[it3] = carry % 256 >>> 0;\n        carry = (carry / 256) >>> 0;\n      }\n      if (carry !== 0) throw new Error(\"Non-zero carry\");\n\n      length = i;\n      psz++;\n    }\n    // Skip leading zeroes in b256.\n    let it4 = size - length;\n    while (it4 !== size && b256[it4] === 0) it4++;\n\n    const vch = new Uint8Array(zeroes + (size - it4));\n    let j = zeroes;\n    while (it4 !== size) vch[j++] = b256[it4++];\n\n    return vch;\n  }\n\n  decode(source: string) {\n    const buffer = this.decodeUnsafe(source);\n    if (buffer) return buffer;\n    throw new Error(\"Non-base\" + this.base + \" character\");\n  }\n}\n\nexport class CryptoUtils {\n  private static readonly b58encoder = new BaseEncoder(BASE_ALPHABET.BASE58);\n  private static readonly logger = new MiniLogger(CryptoUtils.name);\n  private constructor() {}\n\n  static fabricIdFromCertificate(certificate: string) {\n    this.logger.debug(stringFormat(\"Parsing certificate: {0}\", certificate));\n    const cert = new x509.X509Certificate(certificate);\n    const { subject, issuer } = cert;\n    this.logger.debug(\n      stringFormat(\n        \"Certificate parsed with subject {0} and issuer {1}\",\n        subject,\n        issuer\n      )\n    );\n    return `x509::/${subject.replaceAll(\", \", \"/\")}::/${issuer.replaceAll(\", \", \"/\")}`;\n  }\n\n  static encode(str: string): string {\n    return this.b58encoder.encode(str);\n  }\n  static decode(str: string): string {\n    const decoded = this.b58encoder.decode(str);\n    const result = new TextDecoder().decode(decoded);\n    return result;\n  }\n\n  static stringToArrayBuffer(str: string) {\n    const buf = new ArrayBuffer(str.length);\n    const bufView = new Uint8Array(buf);\n    for (let i = 0, strLen = str.length; i < strLen; i++) {\n      bufView[i] = str.charCodeAt(i);\n    }\n    return buf;\n  }\n\n  private static async extractKey(\n    type: \"private\" | \"public\",\n    pem: Buffer | string,\n    usages?: any[]\n  ) {\n    const subtle = crypto.subtle;\n\n    const str = pem\n      .toString(\"utf8\")\n      .replace(\n        new RegExp(`-----BEGIN (${type.toUpperCase()} KEY|CERTIFICATE)-----`),\n        \"\"\n      )\n      .replaceAll(\"\\n\", \"\")\n      .replace(\n        new RegExp(`-----END (${type.toUpperCase()} KEY|CERTIFICATE)-----`),\n        \"\"\n      );\n    const decoded = Buffer.from(str, \"base64\").toString(\"binary\");\n    const binaryDer = this.stringToArrayBuffer(decoded);\n    const key = await subtle.importKey(\n      \"pkcs8\",\n      binaryDer,\n      {\n        name: \"ECDSA\",\n        namedCurve: \"P-256\",\n      },\n      true,\n      usages ? usages : [\"sign\"]\n    );\n\n    return key;\n  }\n\n  static async extractPrivateKey(pem: Buffer | string, usages?: any[]) {\n    return this.extractKey(\"private\", pem, usages);\n  }\n\n  static async extractPublicKey(pem: Buffer | string, usages?: any[]) {\n    return this.extractKey(\"public\", pem, usages);\n  }\n\n  static async sign(privateKey: string, data: Buffer): Promise<string> {\n    const key = await this.extractPrivateKey(privateKey);\n    const buff = (await crypto.subtle.sign(\n      {\n        name: \"ECDSA\",\n        hash: \"SHA-256\",\n      },\n      key,\n      data as any\n    )) as ArrayBuffer;\n\n    return Array.from(new Uint8Array(buff))\n      .map((b) => b.toString(16).padStart(2, \"0\"))\n      .join(\"\");\n  }\n\n  static async verify(\n    certificate: string,\n    signature: Buffer | string,\n    data: Buffer | string\n  ): Promise<boolean> {\n    const cert = new x509.X509Certificate(certificate);\n    const key = await cert.publicKey.export();\n    signature = (\n      typeof signature === \"string\" ? Buffer.from(signature, \"hex\") : signature\n    ) as Buffer;\n    data = (typeof data === \"string\" ? Buffer.from(data) : data) as Buffer;\n    return crypto.subtle.verify(\n      {\n        name: \"ECDSA\",\n        hash: \"SHA-256\",\n      },\n      key,\n      signature as any,\n      data as any\n    );\n  }\n\n  static async encrypt(certificate: string, data: string | Buffer) {\n    const cert = new x509.X509Certificate(certificate);\n    const key = await cert.publicKey.export();\n    data = (typeof data === \"string\" ? Buffer.from(data) : data) as Buffer;\n    const buff = await this.getSubtleCrypto().encrypt(\n      {\n        name: \"ECDSA\",\n      },\n      key,\n      data\n    );\n\n    return Array.from(new Uint8Array(buff))\n      .map((b) => b.toString(16).padStart(2, \"0\"))\n      .join(\"\");\n  }\n\n  private static getSubtleCrypto() {\n    return isBrowser()\n      ? (globalThis as any).window.crypto.subtle\n      : crypto.subtle;\n  }\n\n  static async decrypt(privateKey: string, data: string | Buffer) {\n    const key = await this.extractPrivateKey(privateKey);\n    data = (\n      typeof data === \"string\" ? Buffer.from(data, \"hex\") : data\n    ) as Buffer;\n    return this.getSubtleCrypto().decrypt(\n      {\n        name: \"ECDSA\",\n      },\n      key,\n      data\n    );\n  }\n\n  /**\n   * @summary Util function to get a random master key\n   *\n   * @description If data is not passed, a random ArrayBuffer will be generated\n   *\n   * @param {ArrayBuffer} data encrytion data\n   *\n   * @function getMaster\n   */\n  static async getMaster(data?: ArrayBuffer): Promise<keyObject> {\n    const textEncoder = new TextEncoder();\n    if (data === undefined) {\n      const genGenesis = crypto.randomUUID();\n      data = textEncoder.encode(genGenesis).buffer;\n    }\n\n    const importedKey = await this.getSubtleCrypto().importKey(\n      \"raw\",\n      data,\n      CRYPTO.KEY_ALGORYTHM as string,\n      false,\n      [\"deriveBits\"]\n    );\n\n    return {\n      key: importedKey,\n      iv: data!,\n    };\n  }\n\n  /**\n   * @summary Util function to derive a key from another key\n   *\n   * @param {string} salt\n   * @param {CryptoKey} key Original key\n   *\n   * @function getDerivationKey\n   */\n  static async getDerivationKey(salt: string, key: CryptoKey) {\n    const textEncoder = new TextEncoder();\n    const saltBuffer = textEncoder.encode(salt);\n    const saltHashed = await this.getSubtleCrypto().digest(\n      \"SHA-256\",\n      saltBuffer\n    );\n    const params = {\n      name: CRYPTO.KEY_ALGORYTHM as string,\n      hash: CRYPTO.HASH,\n      salt: saltHashed,\n      iterations: CRYPTO.ITERATIONS,\n    };\n    const derivation = await this.getSubtleCrypto().deriveBits(\n      params,\n      key,\n      CRYPTO.KEYLENGTH * 8\n    );\n    return this.getKey(derivation);\n  }\n\n  /**\n   * @summary Util function to get the key and IV from the CrytoKey array\n   *\n   * @param {ArrayBuffer} derivation\n   *\n   * @function getKey\n   */\n  static async getKey(derivation: ArrayBuffer) {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    const ivlen = 16;\n    const keylen = 32;\n    const derivedKey = derivation.slice(0, keylen);\n    const iv = derivation.slice(keylen);\n    const importedEncryptionKey = await this.getSubtleCrypto().importKey(\n      \"raw\",\n      derivedKey,\n      { name: CRYPTO.ALGORYTHM as string },\n      false,\n      [\"encrypt\", \"decrypt\"]\n    );\n    return {\n      key: importedEncryptionKey,\n      iv: iv,\n    };\n  }\n\n  /**\n   * @summary Util function to decrypt data\n   *\n   * @param {string} text\n   * @param {keyObject} keyObject\n   *\n   * @function encrypt\n   */\n  static async encryptPin(\n    text: string,\n    keyObject: keyObject\n  ): Promise<ArrayBuffer> {\n    const textEncoder = new TextEncoder();\n    const textBuffer = textEncoder.encode(text);\n    const encryptedText = await this.getSubtleCrypto().encrypt(\n      { name: CRYPTO.ALGORYTHM as string, iv: keyObject.iv },\n      keyObject.key,\n      textBuffer\n    );\n    return encryptedText;\n  }\n\n  /**\n   * @summary Util function to decrypt data\n   *\n   * @param {BufferSource} encryptedText\n   * @param {keyObject} keyObject\n   *\n   * @function decrypt\n   */\n  static async decryptPin(\n    encryptedText: ArrayBuffer,\n    keyObject: keyObject\n  ): Promise<string> {\n    const textDecoder = new TextDecoder();\n    const decryptedText = await this.getSubtleCrypto().decrypt(\n      { name: CRYPTO.ALGORYTHM as string, iv: keyObject.iv },\n      keyObject.key,\n      encryptedText\n    );\n    return textDecoder.decode(decryptedText);\n  }\n}\n","import { BaseError, InternalError } from \"@decaf-ts/db-decorators\";\nimport { AuthorizationError } from \"@decaf-ts/core\";\n// import { MISSING_PRIVATE_DATA_ERROR_MESSAGE } from \"../contracts/private-data\";\n/**\n * @summary Represents an overflow error in arithmetic operations in Smart Contracts\n *\n * @param {string} msg the error message\n *\n * @class OverflowError\n * @extends InternalError\n *\n * @category Errors\n */\nexport class OverflowError extends InternalError {\n  constructor(msg: string | Error) {\n    super(msg, OverflowError.name);\n  }\n}\n\n/**\n * @summary Represents a failure in balance to perform a transaction in Smart Contracts\n *\n * @param {string} msg the error message\n *\n * @class BalanceError\n * @extends InternalError\n *\n * @category Errors\n */\nexport class BalanceError extends InternalError {\n  constructor(msg: string | Error) {\n    super(msg, BalanceError.name);\n  }\n}\n\n/**\n * @summary Represents a failure in balance to perform a transaction in Smart Contracts\n *\n * @param {string} msg the error message\n *\n * @class BalanceError\n * @extends InternalError\n *\n * @category Errors\n */\nexport class AllowanceError extends InternalError {\n  constructor(msg: string | Error) {\n    super(msg, AllowanceError.name);\n  }\n}\n\n/**\n * @summary Represents a failure registrating new entities\n *\n * @param {string} msg the error message\n *\n * @class RegistrationError\n *\n * @categort Errors\n */\nexport class RegistrationError extends AuthorizationError {\n  constructor(msg: string | Error) {\n    super(msg, RegistrationError.name);\n  }\n}\n\n/**\n * @description Error thrown when an unsupported operation is attempted\n * @summary This error is thrown when an operation is requested that is not supported by the current\n * persistence adapter or configuration. It extends the BaseError class and sets a 500 status code.\n * @param {string|Error} msg - The error message or an Error object to wrap\n * @class UnsupportedError\n * @example\n * ```typescript\n * // Throwing an UnsupportedError\n * if (!adapter.supportsTransactions()) {\n *   throw new UnsupportedError('Transactions are not supported by this adapter');\n * }\n *\n * // Catching an UnsupportedError\n * try {\n *   await adapter.beginTransaction();\n * } catch (error) {\n *   if (error instanceof UnsupportedError) {\n *     console.error('Operation not supported:', error.message);\n *   }\n * }\n * ```\n *\n * @category Errors\n */\nexport class MissingContextError extends InternalError {\n  constructor(msg: string | Error) {\n    super(msg, MissingContextError.name, 500);\n  }\n}\n\nexport class UnauthorizedPrivateDataAccess extends BaseError {\n  constructor(msg: string | Error = \"MISSING_PRIVATE_DATA_ERROR_MESSAGE\") {\n    super(UnauthorizedPrivateDataAccess.name, msg, 403);\n  }\n}\n\n/**\n * Represents an error that occurs when a required initialization step is not performed.\n *\n * @class NotInitializedError\n * @extends BaseError\n *\n * @category Errors\n *\n * @param {string | Error} msg - The error message or an Error object to wrap.\n *\n * @throws {NotInitializedError} - Throws an error when a required initialization step is not performed.\n *\n * @example\n * ```typescript\n * // Initialize the application\n * if (!isInitialized) {\n *   throw new NotInitializedError('Application is not initialized');\n * }\n *\n * // Catching an NotInitializedError\n * try {\n *   // Perform operations that require initialization\n * } catch (error) {\n *   if (error instanceof NotInitializedError) {\n *     console.error('Initialization error:', error.message);\n *   }\n * }\n * ```\n */\nexport class NotInitializedError extends BaseError {\n  constructor(msg: string | Error) {\n    super(NotInitializedError.name, msg, 409);\n  }\n}\n\nexport class MissingPKCSS11Lib extends InternalError {\n  constructor(msg: string | Error) {\n    super(msg, MissingPKCSS11Lib.name, 500);\n  }\n}\n\nexport class EndorsementError extends InternalError {\n  constructor(message: string | Error) {\n    super(message, EndorsementError.name, 500);\n  }\n}\n\nexport class MvccReadConflictError extends InternalError {\n  constructor(message: string | Error) {\n    super(message, MvccReadConflictError.name, 500);\n  }\n}\n\nexport class PhantomReadConflictError extends InternalError {\n  constructor(message: string | Error) {\n    super(message, PhantomReadConflictError.name, 500);\n  }\n}\n\nexport class EndorsementPolicyError extends InternalError {\n  constructor(message: string | Error) {\n    super(message, EndorsementPolicyError.name, 500);\n  }\n}\n\nexport class TransactionLimitsError extends InternalError {\n  constructor(\n    message: string | Error,\n    name: string = TransactionLimitsError.name,\n    code = 590\n  ) {\n    super(message, name, code);\n  }\n}\n\nexport class TransactionTimeoutError extends InternalError {\n  constructor(message: string | Error) {\n    super(message, TransactionTimeoutError.name, 591);\n  }\n}\n\nexport class TransactionBufferSizeError extends InternalError {\n  constructor(message: string | Error) {\n    super(message, TransactionBufferSizeError.name, 592);\n  }\n}\n","import FabricCAServices from \"fabric-ca-client\";\nimport {\n  AffiliationService,\n  IdentityService,\n  IEnrollResponse,\n  IRegisterRequest,\n  IServiceResponse,\n  TLSOptions,\n} from \"fabric-ca-client\";\nimport { User } from \"fabric-common\";\nimport { CAConfig, Credentials } from \"../../shared/types\";\nimport { Identity } from \"../../shared/model/Identity\";\nimport { AuthorizationError } from \"@decaf-ts/core\";\nimport {\n  ConflictError,\n  InternalError,\n  NotFoundError,\n} from \"@decaf-ts/db-decorators\";\nimport { CoreUtils } from \"../utils\";\nimport { CA_ROLE } from \"./constants\";\nimport { CryptoUtils } from \"../crypto\";\nimport {\n  CertificateResponse,\n  FabricIdentity,\n  GetCertificatesRequest,\n  IdentityResponse,\n} from \"../../shared/fabric-types\";\nimport { RegistrationError } from \"../../shared/errors\";\nimport { LoggedClass, Logging } from \"@decaf-ts/logging\";\n\n/**\n * @description Hyperledger Fabric CA identity types.\n * @summary Enumerates the supported identity types recognized by Fabric CA for registration and identity management.\n * @enum {string}\n * @readonly\n * @memberOf module:for-fabric.client\n */\nexport enum HFCAIdentityType {\n  PEER = \"peer\",\n  ORDERER = \"orderer\",\n  CLIENT = \"client\",\n  USER = \"user\",\n  ADMIN = \"admin\",\n}\n/**\n * @description Key/value attribute used during CA registration.\n * @summary Represents an attribute entry that can be attached to a Fabric CA identity during registration, optionally marking it for inclusion in ecert.\n * @interface IKeyValueAttribute\n * @template T\n * @param {string} name - Attribute name.\n * @param {string} value - Attribute value.\n * @param {boolean} [ecert] - Whether the attribute should be included in the enrollment certificate (ECert).\n * @memberOf module:for-fabric.client\n */\nexport interface IKeyValueAttribute {\n  name: string;\n  value: string;\n  ecert?: boolean;\n}\n\n/**\n * @description Standard Fabric CA identity attribute keys.\n * @summary Enumerates well-known Fabric CA attribute keys that can be assigned to identities for delegations and permissions.\n * @enum {string}\n * @readonly\n * @memberOf module:for-fabric.client\n */\nexport enum HFCAIdentityAttributes {\n  HFREGISTRARROLES = \"hf.Registrar.Roles\",\n  HFREGISTRARDELEGATEROLES = \"hf.Registrar.DelegateRoles\",\n  HFREGISTRARATTRIBUTES = \"hf.Registrar.Attributes\",\n  HFINTERMEDIATECA = \"hf.IntermediateCA\",\n  HFREVOKER = \"hf.Revoker\",\n  HFAFFILIATIONMGR = \"hf.AffiliationMgr\",\n  HFGENCRL = \"hf.GenCRL\",\n}\n\n/**\n * @description Service wrapper for interacting with a Fabric CA.\n * @summary Provides high-level operations for managing identities against a Hyperledger Fabric Certificate Authority, including registration, enrollment, revocation, and administrative queries. Encapsulates lower-level Fabric CA client calls with consistent logging and error mapping.\n * @param {CAConfig} caConfig - Connection and TLS configuration for the target CA.\n * @class FabricEnrollmentService\n * @example\n * // Register and enroll a new user\n * const svc = new FabricEnrollmentService({\n *   url: 'https://localhost:7054',\n *   caName: 'Org1CA',\n *   tls: { trustedRoots: ['/path/to/ca.pem'], verify: false },\n *   caCert: '/path/to/admin/certDir',\n *   caKey: '/path/to/admin/keyDir'\n * });\n * await svc.register({ userName: 'alice', password: 's3cr3t' }, false, 'org1.department1', CA_ROLE.USER);\n * const id = await svc.enroll('alice', 's3cr3t');\n * @mermaid\n * sequenceDiagram\n *   autonumber\n *   participant App\n *   participant Svc as FabricEnrollmentService\n *   participant CA as Fabric CA\n *   App->>Svc: register(credentials, ...)\n *   Svc->>CA: register(request, adminUser)\n *   CA-->>Svc: enrollmentSecret\n *   Svc-->>App: secret\n *   App->>Svc: enroll(enrollmentId, secret)\n *   Svc->>CA: enroll({enrollmentID, secret})\n *   CA-->>Svc: certificates\n *   Svc-->>App: Identity\n */\nexport class FabricEnrollmentService extends LoggedClass {\n  private ca?: FabricCAServices;\n\n  private certificateService?: any;\n\n  private affiliationService?: AffiliationService;\n\n  private identityService?: IdentityService;\n\n  private client?: any;\n\n  private user?: User;\n\n  constructor(private caConfig: CAConfig) {\n    CoreUtils.getCryptoSuite(\n      caConfig.hsm\n        ? {\n            software: false,\n            lib: caConfig.hsm.library,\n            slot: caConfig.hsm.slot,\n            label: caConfig.hsm.tokenLabel,\n            pin: String(caConfig.hsm.pin),\n          }\n        : undefined\n    );\n    super();\n  }\n\n  protected async User(): Promise<User> {\n    if (this.user) return this.user;\n    const { caName, caCert, caKey, url, hsm } = this.caConfig;\n    const log = this.log.for(this.User);\n    log.debug(`Creating CA user for ${caName} at ${url}`);\n    log.debug(`Retrieving CA certificate from ${caCert}`);\n    const certificate = await CoreUtils.getFirstDirFileNameContent(caCert);\n    let key: string | undefined;\n    if (!hsm) {\n      if (!caKey) {\n        throw new InternalError(\n          `Missing caKey configuration for CA ${caName}. Provide a key directory or configure HSM support.`\n        );\n      }\n      log.debug(`Retrieving CA key from ${caKey}`);\n      key = await CoreUtils.getFirstDirFileNameContent(caKey);\n    } else {\n      log.debug(\n        `Using HSM configuration for CA ${caName} with library ${hsm.library}`\n      );\n    }\n    log.debug(`Loading Admin user for ca ${caName}`);\n    this.user = await CoreUtils.getCAUser(\"admin\", key, certificate, caName, {\n      hsm,\n    });\n    return this.user;\n  }\n\n  protected async CA(): Promise<FabricCAServices> {\n    if (this.ca) return this.ca;\n    const log = this.log.for(this.CA);\n    const { url, tls, caName } = this.caConfig;\n\n    // FOR Some Reason the verification fails need to investigate this works for now\n    // eslint-disable-next-line prefer-const\n    let { trustedRoots, verify } = tls as TLSOptions;\n\n    const root = (trustedRoots as string[])[0] as string;\n    log.debug(`Retrieving CA certificate from ${root}. cwd: ${process.cwd()}`);\n\n    const certificate = await CoreUtils.getFileContent(root);\n    log.debug(`Creating CA Client for CA ${caName} under ${url}`);\n    this.ca = new FabricCAServices(\n      url,\n      {\n        trustedRoots: Buffer.from(certificate),\n        verify,\n      } as TLSOptions,\n      caName\n    );\n    return this.ca;\n  }\n\n  protected async Client(): Promise<{ newCertificateService: any }> {\n    if (this.client) return this.client;\n    const ca = await this.CA();\n    this.client = (ca as any)[\"_FabricCAServices\"];\n    return this.client;\n  }\n\n  protected async Certificate() {\n    if (!this.certificateService)\n      this.certificateService = (await this.Client()).newCertificateService();\n    return this.certificateService;\n  }\n\n  protected async Affiliations() {\n    if (!this.affiliationService)\n      this.affiliationService = (await this.CA()).newAffiliationService();\n    return this.affiliationService;\n  }\n\n  protected async Identities() {\n    if (!this.identityService)\n      this.identityService = (await this.CA()).newIdentityService();\n    return this.identityService;\n  }\n\n  /**\n   * @description Retrieve certificates from the CA.\n   * @summary Calls the CA certificate service to list certificates, optionally mapping to PEM strings only.\n   * @param {GetCertificatesRequest} [request] - Optional filter request for certificate lookup.\n   * @param {boolean} [doMap=true] - When true, returns array of PEM strings; otherwise returns full response object.\n   * @return {Promise<string[] | CertificateResponse>} Array of PEM strings or the full certificate response.\n   */\n  async getCertificates(\n    request?: GetCertificatesRequest,\n    doMap = true\n  ): Promise<string[] | CertificateResponse> {\n    const certificateService = await this.Certificate();\n    const user = await this.User();\n    const log = this.log.for(this.getCertificates);\n    log.debug(\n      `Retrieving certificates${request ? ` for ${request.id}` : \"\"} for CA ${this.caConfig.caName}`\n    );\n    const response: CertificateResponse = (\n      await certificateService.getCertificates(request || {}, user)\n    ).result;\n    log.debug(\n      `Found ${response.certs.length} certificates: ${JSON.stringify(response)}`\n    );\n    return doMap ? response.certs.map((c) => c.PEM) : response;\n  }\n\n  /**\n   * @description List identities registered in the CA.\n   * @summary Queries the CA identity service to fetch all identities and returns the list as FabricIdentity objects.\n   * @return {Promise<FabricIdentity[]>} The list of identities registered in the CA.\n   */\n  async getIdentities(): Promise<FabricIdentity[]> {\n    const identitiesService = await this.Identities();\n    const log = this.log.for(this.getIdentities);\n    log.debug(`Retrieving Identities under CA ${this.caConfig.caName}`);\n    const response: IdentityResponse = (\n      await identitiesService.getAll(await this.User())\n    ).result;\n    log.debug(\n      `Found ${response.identities.length} Identities: ${JSON.stringify(response)}`\n    );\n    return response.identities;\n  }\n\n  protected parseError(e: Error) {\n    const regexp = /.*code:\\s(\\d+).*?message:\\s[\"'](.+)[\"']/gs;\n    const match = regexp.exec(e.message);\n    if (!match) return new RegistrationError(e);\n    const [, code, message] = match;\n    switch (code) {\n      case \"74\":\n      case \"71\":\n        return new ConflictError(message);\n      case \"20\":\n        return new AuthorizationError(message);\n      default:\n        return new RegistrationError(message);\n    }\n  }\n\n  /**\n   * @description Retrieve affiliations from the CA.\n   * @summary Queries the CA for the list of affiliations available under the configured CA.\n   * @return {string} The affiliations result payload.\n   */\n  async getAffiliations() {\n    const affiliationService = await this.Affiliations();\n    const log = this.log.for(this.getAffiliations);\n    log.debug(`Retrieving Affiliations under CA ${this.caConfig.caName}`);\n    const response = (await affiliationService.getAll(await this.User()))\n      .result;\n    log.debug(\n      `Found ${response.a.length} Affiliations: ${JSON.stringify(response)}`\n    );\n    return response;\n  }\n\n  /**\n   * @description Read identity details from the CA by enrollment ID.\n   * @summary Retrieves and validates a single identity, throwing NotFoundError when missing.\n   * @param {string} enrollmentId - Enrollment ID to lookup.\n   * @return {Promise<FabricIdentity>} The identity details stored in the CA.\n   */\n  async read(enrollmentId: string) {\n    const ca = await this.CA();\n    const user = await this.User();\n    let result: IServiceResponse;\n    try {\n      result = await ca.newIdentityService().getOne(enrollmentId, user);\n    } catch (e: any) {\n      throw new NotFoundError(\n        `Couldn't find enrollment with id ${enrollmentId}: ${e}`\n      );\n    }\n\n    if (!result.success)\n      throw new NotFoundError(\n        `Couldn't find enrollment with id ${enrollmentId}: ${result.errors.join(\"\\n\")}`\n      );\n\n    return result.result as FabricIdentity;\n  }\n\n  /**\n   * @description Register a new identity with the CA.\n   * @summary Submits a registration request for a new enrollment ID, returning the enrollment secret upon success.\n   * @param {Credentials} model - Credentials containing userName and password for the new identity.\n   * @param {boolean} [isSuperUser=false] - Whether to register the identity as a super user.\n   * @param {string} [affiliation=\"\"] - Affiliation string (e.g., org1.department1).\n   * @param {CA_ROLE | string} [userRole] - Role to assign to the identity.\n   * @param {IKeyValueAttribute} [attrs] - Optional attributes to attach to the identity.\n   * @param {number} [maxEnrollments] - Maximum number of enrollments allowed for the identity.\n   * @return {Promise<string>} The enrollment secret for the registered identity.\n   */\n  async register(\n    model: Credentials,\n    isSuperUser: boolean = false,\n    affiliation: string = \"\",\n    userRole?: CA_ROLE | string,\n    attrs?: IKeyValueAttribute,\n    maxEnrollments?: number\n  ): Promise<string> {\n    let registration: string;\n    const log = this.log.for(this.register);\n    try {\n      const { userName, password } = model;\n      const ca = await this.CA();\n      const user = await this.User();\n      const props = {\n        enrollmentID: userName as string,\n        enrollmentSecret: password,\n        affiliation: affiliation,\n        userRole: userRole,\n        attrs: attrs,\n        maxEnrollments: maxEnrollments,\n      } as IRegisterRequest;\n      registration = await ca.register(props, user);\n      log.info(\n        `Registration for ${userName} created with user type ${userRole ?? \"Undefined Role\"} ${isSuperUser ? \"as super user\" : \"\"}`\n      );\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n    return registration;\n  }\n\n  protected static identityFromEnrollment(\n    enrollment: IEnrollResponse,\n    mspId: string\n  ): Identity {\n    const { certificate, key, rootCertificate } = enrollment;\n    const log = Logging.for(FabricEnrollmentService, {}).for(\n      this.identityFromEnrollment\n    );\n    log.debug(\n      `Generating Identity from certificate ${certificate} in msp ${mspId}`\n    );\n    const clientId = CryptoUtils.fabricIdFromCertificate(certificate);\n    const id = CryptoUtils.encode(clientId);\n    log.debug(`Identity ${clientId} and encodedId ${id}`);\n    const now = new Date();\n    return new Identity({\n      id: id,\n      credentials: {\n        id: id,\n        certificate: certificate,\n        privateKey: key.toBytes(),\n        rootCertificate: rootCertificate,\n        createdOn: now,\n        updatedOn: now,\n      },\n      mspId: mspId,\n      createdOn: now,\n      updatedOn: now,\n    });\n  }\n\n  /**\n   * @description Enroll an identity with the CA using a registration secret.\n   * @summary Exchanges the enrollment ID and secret for certificates, returning a constructed Identity model.\n   * @param {string} enrollmentId - Enrollment ID to enroll.\n   * @param {string} registration - Enrollment secret returned at registration time.\n   * @return {Promise<Identity>} The enrolled identity object with credentials.\n   */\n  async enroll(enrollmentId: string, registration: string) {\n    let identity: Identity;\n    const log = this.log.for(this.enroll);\n    try {\n      const ca = await this.CA();\n      log.debug(`Enrolling ${enrollmentId}`);\n      const enrollment: IEnrollResponse = await ca.enroll({\n        enrollmentID: enrollmentId,\n        enrollmentSecret: registration,\n      });\n      identity = FabricEnrollmentService.identityFromEnrollment(\n        enrollment,\n        this.caConfig.caName\n      );\n      log.info(\n        `Successfully enrolled ${enrollmentId} under ${this.caConfig.caName} as ${identity.id}`\n      );\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n    return identity;\n  }\n\n  /**\n   * @description Register and enroll a new identity in one step.\n   * @summary Registers a new enrollment ID with the CA and immediately exchanges the secret to enroll, returning the created Identity.\n   * @param {Credentials} model - Credentials for the new identity containing userName and password.\n   * @param {boolean} [isSuperUser=false] - Whether to register the identity as a super user.\n   * @param {string} [affiliation=\"\"] - Affiliation string (e.g., org1.department1).\n   * @param {CA_ROLE | string} [userRole] - Role to assign to the identity.\n   * @param {IKeyValueAttribute} [attrs] - Optional attributes to attach to the identity.\n   * @param {number} [maxEnrollments] - Maximum number of enrollments allowed for the identity.\n   * @return {Promise<Identity>} The enrolled identity.\n   */\n  async registerAndEnroll(\n    model: Credentials,\n    isSuperUser: boolean = false,\n    affiliation: string = \"\",\n    userRole?: CA_ROLE | string,\n    attrs?: IKeyValueAttribute,\n    maxEnrollments?: number\n  ): Promise<Identity> {\n    const registration = await this.register(\n      model,\n      isSuperUser,\n      affiliation,\n      userRole,\n      attrs,\n      maxEnrollments\n    );\n    const { userName } = model;\n    return this.enroll(userName as string, registration);\n  }\n\n  /**\n   * Revokes the enrollment of an identity with the specified enrollment ID.\n   *\n   * @param enrollmentId - The enrollment ID of the identity to be revoked.\n   *\n   * @returns A Promise that resolves to the result of the revocation operation.\n   *\n   * @throws {NotFoundError} If the enrollment with the specified ID does not exist.\n   * @throws {InternalError} If there is an error during the revocation process.\n   */\n  async revoke(enrollmentId: string) {\n    const ca = await this.CA();\n    const user = await this.User();\n    const identity = await this.read(enrollmentId);\n    if (!identity)\n      throw new NotFoundError(\n        `Could not find enrollment with id ${enrollmentId}`\n      );\n    let result: IServiceResponse;\n    try {\n      result = await ca.revoke(\n        { enrollmentID: identity.id, reason: \"User Deletation\" },\n        user\n      );\n    } catch (e: unknown) {\n      throw new InternalError(\n        `Could not revoke enrollment with id ${enrollmentId}: ${e}`\n      );\n    }\n    if (!result.success)\n      throw new InternalError(\n        `Could not revoke enrollment with id ${enrollmentId}: ${result.errors.join(\"\\n\")}`\n      );\n    return result;\n  }\n}\n","import { IRegisterRequest, IKeyValueAttribute } from \"fabric-ca-client\";\nimport { CA_ROLE } from \"./constants\";\nimport {\n  min,\n  minlength,\n  Model,\n  required,\n} from \"@decaf-ts/decorator-validation\";\nimport { ValidationError } from \"@decaf-ts/db-decorators\";\n\nexport class RegistrationRequestBuilder extends Model {\n  @required()\n  affiliation: string = \"\";\n  @minlength(1)\n  attrs?: IKeyValueAttribute[];\n  @required()\n  enrollmentID!: string;\n  @required()\n  enrollmentSecret!: string;\n  @min(0)\n  maxEnrollments?: number;\n  @required()\n  role!: string;\n\n  build(): IRegisterRequest {\n    const errs = this.hasErrors();\n    if (errs) throw new ValidationError(errs.toString());\n    const response: IRegisterRequest = {\n      enrollmentID: this.enrollmentID,\n      enrollmentSecret: this.enrollmentSecret,\n      role: this.role,\n      affiliation: this.affiliation,\n    };\n    if (typeof this.maxEnrollments !== \"undefined\")\n      response.maxEnrollments = this.maxEnrollments;\n    if (this.attrs) response.attrs = this.attrs;\n    return response;\n  }\n\n  setAffiliation(value: string) {\n    this.affiliation = value;\n    return this;\n  }\n\n  addAttr(attr: IKeyValueAttribute) {\n    this.attrs = this.attrs || [];\n    this.attrs.push(attr);\n    return this;\n  }\n\n  setAttrs(value: IKeyValueAttribute[]) {\n    this.attrs = value;\n    return this;\n  }\n\n  setEnrollmentID(value: string) {\n    this.enrollmentID = value;\n    return this;\n  }\n\n  setEnrollmentSecret(value: string) {\n    this.enrollmentSecret = value;\n    return this;\n  }\n\n  setMaxEnrollments(value: number) {\n    this.maxEnrollments = value;\n    return this;\n  }\n\n  setRole(value: CA_ROLE | string) {\n    this.role = value;\n    return this;\n  }\n}\n","/**\n * Enum representing the events emitted by an ERC20 contract.\n *\n * @remarks\n * This enum is used to identify the specific events that can be emitted by an ERC20 contract.\n * The events are named according to the EIP-20 standard.\n */\nexport enum ERC20Events {\n  /**\n   * Emitted when a `transfer` function is called successfully.\n   *\n   * @param from - The address of the sender.\n   * @param to - The address of the recipient.\n   * @param value - The amount of tokens transferred.\n   */\n  TRANSFER = \"Transfer\",\n\n  /**\n   * Emitted when an `approve` function is called successfully.\n   *\n   * @param owner - The address of the token owner.\n   * @param spender - The address of the approved spender.\n   * @param value - The amount of tokens approved for the spender.\n   */\n  APPROVAL = \"Approval\",\n}\n","import { Model, type ModelArg } from \"@decaf-ts/decorator-validation\";\nimport { column, createdAt, updatedAt } from \"@decaf-ts/core\";\nimport { version } from \"@decaf-ts/db-decorators\";\nimport { description, uses } from \"@decaf-ts/decoration\";\nimport { FabricFlavour } from \"../constants\";\n\n@uses(FabricFlavour)\nexport class FabricBaseModel extends Model {\n  @description(\"Stores the original timestamp of creation\")\n  @column()\n  @createdAt()\n  createdAt!: Date;\n\n  @description(\"Stores the timestamp of the last update\")\n  @column()\n  @updatedAt()\n  updatedAt!: Date;\n\n  @description(\"Stores the version of the model\")\n  @column()\n  @version()\n  version!: number;\n\n  constructor(arg?: ModelArg<FabricBaseModel>) {\n    super(arg);\n  }\n}\n","import { type ModelArg } from \"@decaf-ts/decorator-validation\";\nimport { column, createdBy, updatedBy } from \"@decaf-ts/core\";\nimport { description, uses } from \"@decaf-ts/decoration\";\nimport { FabricFlavour } from \"../constants\";\nimport { FabricBaseModel } from \"./FabricBaseModel\";\n\n@uses(FabricFlavour)\nexport abstract class FabricIdentifiedBaseModel extends FabricBaseModel {\n  @description(\"Stores the creator\")\n  @column()\n  @createdBy()\n  createdBy!: string;\n\n  @description(\"Stores the user that last updated the model\")\n  @column()\n  @updatedBy()\n  updatedBy!: string;\n\n  protected constructor(arg?: ModelArg<FabricIdentifiedBaseModel>) {\n    super(arg);\n  }\n}\n","import { Model } from \"@decaf-ts/decorator-validation\";\nimport { Constructor, Metadata } from \"@decaf-ts/decoration\";\nimport { FabricModelKeys } from \"../constants\";\nimport { SegregatedModel } from \"../types\";\nimport { DBKeys } from \"@decaf-ts/db-decorators\";\nimport { CollectionResolver, MirrorMetadata } from \"../decorators\";\n\nModel.prototype.isShared = function isShared<M extends Model>(\n  this: M\n): boolean {\n  return Model.isShared(this.constructor as Constructor<M>);\n};\n\nModel.prototype.isPrivate = function isPrivate<M extends Model>(\n  this: M\n): boolean {\n  return Model.isPrivate(this.constructor as Constructor<M>);\n};\n\nModel.prototype.segregate = function segregate<M extends Model>(\n  this: M\n): SegregatedModel<M> {\n  return Model.segregate(this);\n};\n\n(Model as any).segregate = function segregate<M extends Model>(\n  model: M\n): SegregatedModel<M> {\n  if (!Model.isTransient(model)) return { model: model };\n  const decoratedProperties =\n    Metadata.getAttributes(model.constructor as any) || [];\n\n  const transientProps = Metadata.get(\n    model.constructor as any,\n    DBKeys.TRANSIENT\n  );\n  const privateProperties = Metadata.get(\n    model.constructor as any,\n    FabricModelKeys.PRIVATE\n  );\n  const sharedProperties = Metadata.get(\n    model.constructor as any,\n    FabricModelKeys.SHARED\n  );\n\n  const result: SegregatedModel<M> = {\n    model: {} as Record<keyof M, any>,\n    public: {} as Record<keyof M, any>,\n    transient: {} as Record<keyof M, any>,\n    privates: {} as Record<keyof M, any>,\n    shared: {} as Record<keyof M, any>,\n  };\n\n  const transientKeys = Object.keys(transientProps || {});\n  const privateKeys = Object.keys(privateProperties || {});\n  const sharedKeys = Object.keys(sharedProperties || {});\n\n  // const pkKey = Model.pk(model.constructor as any);\n  for (const key of decoratedProperties) {\n    const value = model[key as keyof M];\n    const isTransient = transientKeys.includes(key);\n    const isPublic = !isTransient;\n    const isPrivate = privateKeys.includes(key);\n    const isShared = sharedKeys.includes(key);\n    // const isPrimaryKey = key === pkKey;\n\n    if (isTransient || isPrivate || isShared) {\n      result.transient = result.transient || ({} as any);\n      (result.transient as any)[key] = value;\n    }\n    if (isPrivate) {\n      result.privates = result.privates || ({} as any);\n      (result.privates as any)[key] = value;\n    }\n    if (isShared) {\n      result.shared = result.shared || ({} as any);\n      (result.shared as any)[key] = value;\n    }\n    if (isPublic) {\n      result.public = (result.public || {}) as any;\n      (result.public as any)[key] = value;\n    }\n  }\n\n  result.model = Model.build(result.public, model.constructor.name);\n  return result as SegregatedModel<M>;\n}.bind(Model);\n\n(Model as any).isPrivate = function isPrivate<M extends Model>(\n  model: M | Constructor<M>\n): boolean {\n  return !!Metadata.get(\n    typeof model !== \"function\" ? (model.constructor as any) : model,\n    FabricModelKeys.PRIVATE\n  );\n}.bind(Model);\n\n(Model as any).isShared = function isShared<M extends Model>(\n  model: M | Constructor<M>\n): boolean {\n  return !!Metadata.get(\n    typeof model !== \"function\" ? (model.constructor as any) : model,\n    FabricModelKeys.SHARED\n  );\n}.bind(Model);\n\n(Model as any).mirrored = function mirrored<M extends Model>(\n  model: M | Constructor<M>\n): boolean {\n  return Metadata.get(\n    typeof model !== \"function\" ? (model.constructor as any) : model,\n    Metadata.key(FabricModelKeys.FABRIC, FabricModelKeys.MIRROR)\n  );\n}.bind(Model);\n\n(Model as any).ownerOf = function ownerOf<M extends Model>(\n  model: M\n): string | undefined {\n  const meta = Metadata.get(\n    model.constructor as any,\n    Metadata.key(FabricModelKeys.FABRIC, FabricModelKeys.OWNED_BY)\n  );\n  if (!meta) return undefined;\n  return model[meta as keyof M] as string;\n}.bind(Model);\n\n(Model as any).mirroredAt = function mirroredAt<M extends Model>(\n  model: M | Constructor<M>\n): MirrorMetadata | undefined {\n  model = typeof model !== \"function\" ? (model.constructor as any) : model;\n  return Metadata.get(\n    model as any,\n    Metadata.key(FabricModelKeys.FABRIC, FabricModelKeys.MIRROR)\n  );\n}.bind(Model);\n\n(Model as any).collectionsFor = function collectionsFor<M extends Model>(\n  model: M | Constructor<M>\n): {\n  privateCols: (string | CollectionResolver)[];\n  sharedCols: (string | CollectionResolver)[];\n} {\n  const privateKeys: string[] = [FabricModelKeys.PRIVATE] as string[];\n  const sharedKeys: string[] = [FabricModelKeys.SHARED] as string[];\n\n  const privateKey = Metadata.key(...privateKeys);\n  const sharedKey = Metadata.key(...sharedKeys);\n\n  const constr = typeof model === \"function\" ? model : model.constructor;\n\n  const privateMeta: { collections: string[] } = Metadata.get(\n    constr as any,\n    privateKey\n  );\n  const sharedMeta: { collections: string[] } = Metadata.get(\n    constr as any,\n    sharedKey\n  );\n\n  return {\n    privateCols: privateMeta?.collections || [],\n    sharedCols: sharedMeta?.collections || [],\n  };\n}.bind(Model);\n","import {\n  AuthorizationError,\n  Repo,\n  Context,\n  UnsupportedError,\n  Repository,\n  ContextOf,\n} from \"@decaf-ts/core\";\nimport {\n  generated,\n  InternalError,\n  NotFoundError,\n  onCreate,\n  onDelete,\n  onRead,\n  onUpdate,\n  readonly,\n  transient,\n  ValidationError,\n  DBKeys,\n  DBOperations,\n  on,\n} from \"@decaf-ts/db-decorators\";\nimport { Model, required } from \"@decaf-ts/decorator-validation\";\nimport { FabricModelKeys } from \"./constants\";\nimport type { Context as HLContext } from \"fabric-contract-api\";\nimport { ClientIdentity } from \"fabric-shim-api\";\nimport { FabricERC20Contract } from \"../contracts/erc20/erc20contract\";\nimport {\n  apply,\n  Constructor,\n  Decoration,\n  metadata,\n  Metadata,\n  prop,\n  propMetadata,\n} from \"@decaf-ts/decoration\";\nimport { FabricFlags } from \"./types\";\nimport { toPascalCase } from \"@decaf-ts/logging\";\nimport { FabricContractFlags } from \"../contracts/types\";\nimport \"../shared/overrides\";\nimport { type FabricContractContext } from \"../contracts/ContractContext\";\n\n/**\n * @description Extracts the MSP ID from either a string or ClientIdentity object\n * @param identity - The identity value which can be a string MSP ID or ClientIdentity object\n * @returns The MSP ID as a string, or undefined if not available\n */\nexport function extractMspId(\n  identity: string | ClientIdentity | undefined\n): string | undefined {\n  if (!identity) return undefined;\n  if (typeof identity === \"string\") return identity;\n  return identity.getMSPID();\n}\n\n/**\n * Decorator for marking methods that require ownership authorization.\n * Checks the owner of the token before allowing the method to be executed.\n *\n * @example\n * ```typescript\n * class TokenContract extends Contract {\n *   @Owner()\n *   async Mint(ctx: Context, amount: number) {\n *     // Mint token logic\n *   }\n * }\n * ```\n *\n * @returns {MethodDecorator} A method decorator that checks ownership authorization.\n */\nexport function Owner() {\n  return function (\n    target: any,\n    propertyKey: string,\n    descriptor: PropertyDescriptor\n  ) {\n    const originalMethod = descriptor.value;\n\n    descriptor.value = async function (\n      this: FabricERC20Contract,\n      ...args: any[]\n    ) {\n      const ctx: HLContext = args[0];\n      const acountId = ctx.clientIdentity.getID();\n\n      const select = await (this as FabricERC20Contract)[\n        \"tokenRepository\"\n      ].select();\n\n      const tokens = await select.execute(ctx);\n\n      if (tokens.length == 0) {\n        throw new NotFoundError(\"No tokens avaialble\");\n      }\n\n      if (tokens.length > 1) {\n        throw new NotFoundError(`To many token available : ${tokens.length}`);\n      }\n\n      if (tokens[0].owner != acountId) {\n        throw new AuthorizationError(\n          `User not authorized to run ${propertyKey} on the token`\n        );\n      }\n\n      return await originalMethod.apply(this, args);\n    };\n\n    return descriptor;\n  };\n}\n\nexport async function ownedByOnCreate<\n  M extends Model<boolean>,\n  R extends Repo<M>,\n  V,\n>(\n  this: R,\n  context: ContextOf<R>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const { stub } = context as any;\n\n  const creator = await stub.getCreator();\n  const owner = creator.mspid;\n\n  const setOwnedByKeyValue = function <M extends Model>(\n    target: M,\n    propertyKey: string,\n    value: string | number | bigint\n  ) {\n    Object.defineProperty(target, propertyKey, {\n      enumerable: true,\n      writable: false,\n      configurable: true,\n      value: value,\n    });\n  };\n\n  setOwnedByKeyValue(model, key as string, owner);\n}\n\nexport function ownedBy() {\n  function ownedBy() {\n    return function (obj: any, attribute?: any) {\n      return apply(\n        required(),\n        generated(),\n        readonly(),\n        onCreate(ownedByOnCreate),\n        propMetadata(\n          Metadata.key(FabricModelKeys.FABRIC, FabricModelKeys.OWNED_BY),\n          attribute\n        )\n      )(obj, attribute);\n    };\n  }\n\n  return Decoration.for(FabricModelKeys.OWNED_BY)\n    .define({\n      decorator: ownedBy,\n      args: [],\n    })\n    .apply();\n}\n\nexport async function transactionIdOnCreate<\n  M extends Model<boolean>,\n  R extends Repo<M>,\n  V,\n>(\n  this: R,\n  context: ContextOf<R>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const { stub } = context as any;\n  model[key] = stub.getTxID();\n}\n\nexport function transactionId() {\n  function transactionId() {\n    return function (obj: any, attribute?: any) {\n      return apply(\n        required(),\n        readonly(),\n        onCreate(transactionIdOnCreate),\n        onUpdate(transactionIdOnCreate),\n        propMetadata(\n          Metadata.key(\n            FabricModelKeys.FABRIC,\n            attribute,\n            FabricModelKeys.TRANSACTION_ID\n          ),\n          attribute\n        )\n      )(obj, attribute);\n    };\n  }\n\n  return Decoration.for(FabricModelKeys.TRANSACTION_ID)\n    .define({\n      decorator: transactionId,\n      args: [],\n    })\n    .apply();\n}\n\nexport type MirrorCondition = (msp: string) => boolean;\n\nexport type MirrorMetadata = {\n  condition?: MirrorCondition;\n  resolver: CollectionResolver | string;\n  mspId: string;\n};\n\nexport async function evalMirrorMetadata<M extends Model>(\n  model: M,\n  resolver: undefined | string | CollectionResolver,\n  ctx: Context<FabricContractFlags>\n) {\n  let collection: CollectionResolver | string | undefined = resolver;\n  if (typeof collection !== \"string\") {\n    try {\n      const owner =\n        Model.ownerOf(model) || ctx.get(\"stub\").getCreator().toString();\n      if (resolver && typeof resolver === \"function\")\n        collection = await resolver(model, owner, ctx);\n    } catch (e: unknown) {\n      throw new InternalError(`Failed to resolve collection mirror name: ${e}`);\n    }\n  }\n\n  if (!collection || typeof collection !== \"string\")\n    throw new InternalError(\n      `No collection found model ${model.constructor.name}`\n    );\n  return collection;\n}\n\nexport async function createMirrorHandler<\n  M extends Model,\n  R extends Repository<M, any>,\n>(\n  this: R,\n  context: Context<FabricContractFlags>,\n  data: MirrorMetadata,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const collection = await evalMirrorMetadata(model, data.resolver, context);\n  const fabricCtx = context as FabricContractContext;\n  const sourceModel = model;\n  // Put mirror flags directly on context so adapter.prepare() and adapter.create() can see them\n  fabricCtx.put(\"mirror\" as any, true);\n  fabricCtx.put(\"mirrorCollection\" as any, collection);\n  try {\n    const repo = this.override(\n      Object.assign({}, (this as any)._overrides, {\n        mirror: true,\n        mirrorCollection: collection,\n        ignoreValidation: true,\n        ignoreHandlers: true,\n      } as any)\n    );\n    const mirror = await repo.create(sourceModel, context);\n    context.logger.info(\n      `Mirror for ${Model.tableName(this.class)} created with ${Model.pk(model) as string}: ${mirror[Model.pk(model)]}`\n    );\n  } finally {\n    // Clean up mirror flags from context\n    fabricCtx.put(\"mirror\" as any, undefined);\n    fabricCtx.put(\"mirrorCollection\" as any, undefined);\n  }\n}\n\nexport async function updateMirrorHandler<\n  M extends Model,\n  R extends Repository<M, any>,\n>(\n  this: R,\n  context: Context<FabricContractFlags>,\n  data: MirrorMetadata,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const collection = await evalMirrorMetadata(model, data.resolver, context);\n  const fabricCtx = context as FabricContractContext;\n  const sourceModel = model;\n  fabricCtx.put(\"mirror\" as any, true);\n  fabricCtx.put(\"mirrorCollection\" as any, collection);\n  try {\n    const repo = this.override(\n      Object.assign({}, (this as any)._overrides, {\n        mirror: true,\n        mirrorCollection: collection,\n        ignoreValidation: true,\n        ignoreHandlers: true,\n        applyUpdateValidation: false,\n        mergeForUpdate: false,\n      } as any)\n    );\n    await repo.update(sourceModel, context);\n    context.logger.info(\n      `Mirror for ${Model.tableName(this.class)} updated: ${(model as any)[Model.pk(model)]}`\n    );\n  } finally {\n    fabricCtx.put(\"mirror\" as any, undefined);\n    fabricCtx.put(\"mirrorCollection\" as any, undefined);\n  }\n}\n\nexport async function deleteMirrorHandler<\n  M extends Model,\n  R extends Repository<M, any>,\n>(\n  this: R,\n  context: Context<FabricContractFlags>,\n  data: MirrorMetadata,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const collection = await evalMirrorMetadata(model, data.resolver, context);\n  const fabricCtx = context as FabricContractContext;\n  fabricCtx.put(\"mirror\" as any, true);\n  fabricCtx.put(\"mirrorCollection\" as any, collection);\n  fabricCtx.put(\"segregated\" as any, collection);\n  try {\n    const pkProp = Model.pk(model) as keyof M;\n    const id = model[pkProp];\n    const repo = this.override(\n      Object.assign({}, (this as any)._overrides, {\n        segregated: collection,\n        mirror: true,\n        ignoreValidation: true,\n        ignoreHandlers: true,\n      } as any)\n    );\n    try {\n      await repo.delete(id as any, context);\n    } catch {\n      // May already be deleted by adapter.deleteSegregatedCollections\n    }\n    context.logger.info(\n      `Mirror for ${Model.tableName(this.class)} deleted: ${String(id)}`\n    );\n  } finally {\n    fabricCtx.put(\"mirror\" as any, undefined);\n    fabricCtx.put(\"mirrorCollection\" as any, undefined);\n    fabricCtx.put(\"segregated\" as any, undefined);\n  }\n}\n\nexport async function mirrorWriteGuard<\n  M extends Model,\n  R extends Repository<M, any>,\n>(\n  this: R,\n  context: Context<FabricContractFlags>,\n  data: MirrorMetadata,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  key: keyof M,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  model: M\n): Promise<void> {\n  const msp = extractMspId(\n    context.get(\"identity\") as string | ClientIdentity | undefined\n  );\n  if (!msp) return;\n  if (msp === data.mspId || (data.condition && data.condition(msp))) {\n    throw new AuthorizationError(\n      `Organization ${msp} is not authorized to modify mirrored data`\n    );\n  }\n}\n\nexport async function readMirrorHandler<\n  M extends Model,\n  R extends Repository<M, any>,\n>(\n  this: R,\n  context: Context<FabricContractFlags>,\n  data: MirrorMetadata,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const msp = extractMspId(\n    context.get(\"identity\") as string | ClientIdentity | undefined\n  );\n\n  if (!msp) return;\n\n  const collection = await evalMirrorMetadata(model, data.resolver, context);\n  const fabricCtx = context as FabricContractContext;\n  const matches = msp === data.mspId || (data.condition && data.condition(msp));\n\n  if (matches) {\n    context.logger.info(\n      `Mirror read: MSP ${msp} matches, routing reads to mirror collection ${collection}`\n    );\n    // Route reads exclusively through the mirror collection\n    fabricCtx.put(\"mirror\" as any, true);\n    fabricCtx.put(\"mirrorCollection\" as any, collection);\n    fabricCtx.put(\"fullySegregated\", true);\n    fabricCtx.readFrom(collection);\n  }\n  // When MSP does NOT match, normal read flow — all data is in public state\n}\n\nexport function mirror(\n  collection: CollectionResolver | string,\n  mspIdOrCondition?: string | MirrorCondition,\n  condition?: MirrorCondition\n) {\n  const isConditionOnly =\n    typeof mspIdOrCondition !== \"string\" && Boolean(mspIdOrCondition);\n  const mspId = isConditionOnly\n    ? undefined\n    : (mspIdOrCondition as string | undefined);\n  const cond = isConditionOnly\n    ? (mspIdOrCondition as MirrorCondition)\n    : condition;\n\n  function mirror(\n    resolver: CollectionResolver | string,\n    mspId: string,\n    condition?: MirrorCondition\n  ) {\n    const meta: MirrorMetadata = {\n      condition: condition,\n      mspId: mspId,\n      resolver: resolver,\n    };\n    return apply(\n      metadata(\n        Metadata.key(FabricModelKeys.FABRIC, FabricModelKeys.MIRROR),\n        meta\n      ),\n      // Read handler runs early (priority 30) to set up context before any reads\n      onRead(readMirrorHandler as any, meta, { priority: 30 }),\n      // Write guards — reject matching MSPs before any processing\n      onCreate(mirrorWriteGuard as any, meta, { priority: 20 }),\n      onUpdate(mirrorWriteGuard as any, meta, { priority: 20 }),\n      onDelete(mirrorWriteGuard as any, meta, { priority: 20 }),\n      // Mirror sync handlers — write full model after other handlers (priority 100)\n      onCreate(createMirrorHandler as any, meta, { priority: 100 }),\n      onUpdate(updateMirrorHandler as any, meta, { priority: 100 }),\n      onDelete(deleteMirrorHandler as any, meta, { priority: 100 })\n    );\n  }\n\n  return Decoration.for(FabricModelKeys.MIRROR)\n    .define({\n      decorator: mirror,\n      args: [collection, mspId, cond],\n    })\n    .apply();\n}\n\nexport type CollectionResolver = <M extends Model>(\n  model: M | Constructor<M>,\n  msp?: string,\n  ...args: any[]\n) => string;\n\nexport const ModelCollection: CollectionResolver = <M extends Model>(\n  model: M | Constructor<M>,\n  mspId?: string\n) => {\n  const orgName =\n    mspId || (typeof model !== \"function\" ? Model.ownerOf(model) : undefined);\n  const constr = typeof model === \"function\" ? model : model.constructor;\n  if (!orgName)\n    throw new InternalError(\n      `Model ${constr.name} is not owned by any organization. did you use @ownedBy() (or provide the name)?`\n    );\n  return `${toPascalCase(constr.name)}${orgName ? toPascalCase(orgName) : \"\"}`;\n};\n\nexport function NamespaceCollection(namespace: string): CollectionResolver {\n  return <M extends Model>(model: M | Constructor<M>, mspId?: string) => {\n    const orgName =\n      mspId || (typeof model !== \"function\" ? Model.ownerOf(model) : undefined);\n    const constr = typeof model === \"function\" ? model : model.constructor;\n    if (!orgName)\n      throw new InternalError(\n        `Model ${constr.name} is not owned by any organization. did you use @ownedBy() (or provide the name)?`\n      );\n    return `${namespace}${orgName ? toPascalCase(orgName) : \"\"}`;\n  };\n}\n\nexport const ImplicitPrivateCollection: CollectionResolver = <M extends Model>(\n  model: M | Constructor<M>,\n  mspId?: string\n) => {\n  const orgName =\n    mspId || (typeof model !== \"function\" ? Model.ownerOf(model) : undefined);\n  if (!orgName)\n    throw new InternalError(\n      `Model ${model.constructor.name} is not owned by any organization. did you use @ownedBy() (or provide the name)?`\n    );\n  return `__${toPascalCase(orgName)}PrivateCollection`;\n};\n\nexport type SegregatedDataMetadata = {\n  collections: string | CollectionResolver;\n};\n\n/**\n * @description Priority for early collection extraction (before pk generation at priority 60)\n * @summary This priority ensures collections are registered in context before any sequence\n * operations occur, allowing sequences to be replicated to private/shared collections.\n */\nexport const SEGREGATED_COLLECTION_EXTRACTION_PRIORITY = 35;\n\nexport function applySegregationFlags<M extends Model>(\n  clazz: M,\n  collections: string[],\n  ctx: any\n) {\n  // Register collections early using readFrom - this allows sequence code\n  // to know which collections to replicate to during pk generation\n  if (collections.length > 0) {\n    (ctx as FabricContractContext).readFrom(collections);\n  }\n\n  // Check if model is fully segregated (all non-pk properties are private/shared/transient).\n  // Use Model.segregate() which is the canonical way to determine what's transient,\n  // rather than reading DBKeys.TRANSIENT metadata which may not accumulate correctly\n  // when class-level @privateData applies decorators iteratively.\n  if (!ctx.isFullySegregated && collections.length) {\n    if (!hasPublicProperties(clazz.constructor as Constructor<M>)) {\n      ctx.markFullySegregated();\n    }\n  }\n}\n\nexport async function applyMirrorFlags<M extends Model>(\n  clazz: Constructor<M>,\n  msp: string | undefined,\n  ctx: FabricContractContext\n) {\n  if (!msp) return;\n  const mirrorMeta = Model.mirroredAt(clazz);\n  if (!mirrorMeta) return;\n  const matches =\n    msp === mirrorMeta.mspId ||\n    (mirrorMeta.condition && mirrorMeta.condition(msp));\n  if (!matches) return;\n  const collection = await evalMirrorMetadata(\n    new clazz(),\n    mirrorMeta.resolver,\n    ctx\n  );\n  // Mirror MSP matches — route reads exclusively through the mirror\n  // collection. Clear any previously registered collections so queries\n  // go ONLY to the mirror, not to the regular private/shared ones.\n  ctx.put(\"segregateRead\", undefined);\n  ctx.put(\"segregateReadStack\", undefined);\n  ctx.put(\"fullySegregated\", true);\n  ctx.put(\"mirror\" as any, true);\n  ctx.put(\"mirrorCollection\" as any, collection);\n  ctx.readFrom(collection);\n}\n\nfunction hasPublicProperties<M extends Model>(clazz: Constructor<M>): boolean {\n  const attributes = Metadata.getAttributes(clazz) || [];\n  const pk = Model.pk(clazz);\n  const transientMeta = Metadata.get(clazz as any, DBKeys.TRANSIENT) || {};\n  const privateMeta =\n    Metadata.get(clazz as any, Metadata.key(FabricModelKeys.PRIVATE)) || {};\n  const sharedMeta =\n    Metadata.get(clazz as any, Metadata.key(FabricModelKeys.SHARED)) || {};\n\n  return attributes.some((attr) => {\n    if (attr === pk) return false;\n    if (attr in transientMeta) return false;\n    if (attr in privateMeta) return false;\n    if (attr in sharedMeta) return false;\n    return true;\n  });\n}\n\n/**\n * @description Early handler to extract and register collections in context\n * @summary Runs with priority < 40 to extract collection names before pk generation (priority 60).\n * This allows FabricContractSequence to know which collections to replicate to.\n * @template M - Type that extends Model\n * @param {ContextOf<Repository<M, any>>} context - The execution context\n * @param {SegregatedDataMetadata | SegregatedDataMetadata[]} data - The segregated data metadata\n * @param {string | string[]} keys - The property key(s) being segregated\n * @param {M} model - The model instance\n * @return {Promise<void>}\n */\nexport async function extractSegregatedCollections<M extends Model>(\n  this: Repository<M, any>,\n  context: ContextOf<typeof this>,\n  data: SegregatedDataMetadata | SegregatedDataMetadata[],\n  keys: keyof M | (keyof M)[],\n  model: M\n): Promise<void> {\n  const dataArray = (\n    Array.isArray(data) ? data : [data]\n  ) as SegregatedDataMetadata[];\n\n  const msp =\n    Model.ownerOf(model) ||\n    extractMspId(\n      context.get(\"identity\") as string | ClientIdentity | undefined\n    );\n  if (!msp) {\n    // Can't extract collections without MSP, will be caught by later handlers\n    return;\n  }\n\n  const collections: string[] = [];\n  for (const metadata of dataArray) {\n    const collectionResolver = metadata.collections;\n    const collection =\n      typeof collectionResolver === \"string\"\n        ? collectionResolver\n        : collectionResolver(model, msp, context);\n    if (collection && !collections.includes(collection)) {\n      collections.push(collection);\n    }\n  }\n  applySegregationFlags(model, collections, context);\n\n  // Store segregation metadata on the adapter (persists across context chains).\n  // The Sequence creates its own context via logCtx, losing context-stored flags.\n  const seqName = Model.sequenceName(model, \"pk\");\n  (context as any).setSequenceSegregation(\n    seqName,\n    (context as any).isFullySegregated,\n    collections\n  );\n}\n\nexport async function segregatedDataOnCreate<M extends Model>(\n  this: Repository<M, any>,\n  context: ContextOf<typeof this>,\n  data: SegregatedDataMetadata | SegregatedDataMetadata[],\n  keys: keyof M | (keyof M)[],\n  model: M\n): Promise<void> {\n  const dataArray = (\n    Array.isArray(data) ? data : [data]\n  ) as SegregatedDataMetadata[];\n  const keyArray = (Array.isArray(keys) ? keys : [keys]) as (keyof M)[];\n  if (keyArray.length !== dataArray.length)\n    throw new InternalError(\n      `Segregated data keys and metadata length mismatch`\n    );\n\n  const msp =\n    Model.ownerOf(model) ||\n    extractMspId(\n      context.get(\"identity\") as string | ClientIdentity | undefined\n    );\n  if (!msp)\n    throw new ValidationError(\n      `There's no assigned organization for model ${model.constructor.name}`\n    );\n\n  const collectionResolver = dataArray[0].collections;\n  const collection =\n    typeof collectionResolver === \"string\"\n      ? collectionResolver\n      : collectionResolver(model, msp, context);\n\n  // Validate all keys resolve to the same collection\n  keyArray.forEach((_k, i) => {\n    const c =\n      typeof dataArray[i].collections === \"string\"\n        ? dataArray[i].collections\n        : dataArray[i].collections(model, msp, context);\n    if (c !== collection)\n      throw new UnsupportedError(\n        `Segregated data collection mismatch: ${c} vs ${collection}`\n      );\n  });\n\n  const keyStrings = keyArray.map((key) => String(key));\n  // Store the segregated model — prepare() will filter to collection-specific fields\n  (context as FabricContractContext).writeTo(collection, keyStrings);\n}\n\nexport async function segregatedDataOnRead<M extends Model>(\n  this: Repository<M, any>,\n  context: Context<FabricFlags>,\n  data: SegregatedDataMetadata | SegregatedDataMetadata[],\n  keys: keyof M | (keyof M)[],\n  model: M\n): Promise<void> {\n  const dataArray = (\n    Array.isArray(data) ? data : [data]\n  ) as SegregatedDataMetadata[];\n  const keyArray = (Array.isArray(keys) ? keys : [keys]) as (keyof M)[];\n  if (keyArray.length !== dataArray.length)\n    throw new InternalError(\n      `Segregated data keys and metadata length mismatch`\n    );\n\n  const msp = Model.ownerOf(model) || extractMspId(context.get(\"identity\"));\n  if (!msp)\n    throw new ValidationError(\n      `There's no assigned organization for model ${model.constructor.name}`\n    );\n\n  const collectionResolver = dataArray[0].collections;\n  const collection =\n    typeof collectionResolver === \"string\"\n      ? collectionResolver\n      : await collectionResolver(model, msp, context);\n\n  (context as FabricContractContext).readFrom(collection);\n}\n\nexport async function segregatedDataOnUpdate<M extends Model>(\n  this: Repository<M, any>,\n  context: ContextOf<typeof this>,\n  data: SegregatedDataMetadata | SegregatedDataMetadata[],\n  key: keyof M | (keyof M)[],\n  model: M,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  oldModel: M\n): Promise<void> {\n  const dataArray = (\n    Array.isArray(data) ? data : [data]\n  ) as SegregatedDataMetadata[];\n  const keyArray = (Array.isArray(key) ? key : [key]) as (keyof M)[];\n  if (keyArray.length !== dataArray.length)\n    throw new InternalError(\n      `Segregated data keys and metadata length mismatch`\n    );\n\n  const msp =\n    Model.ownerOf(model) ||\n    extractMspId(\n      context.get(\"identity\") as string | ClientIdentity | undefined\n    );\n  if (!msp)\n    throw new ValidationError(\n      `There's no assigned organization for model ${model.constructor.name}`\n    );\n\n  const collectionResolver = dataArray[0].collections;\n  const collection =\n    typeof collectionResolver === \"string\"\n      ? collectionResolver\n      : collectionResolver(model, msp, context);\n\n  keyArray.forEach((k, i) => {\n    const c =\n      typeof dataArray[i].collections === \"string\"\n        ? dataArray[i].collections\n        : dataArray[i].collections(model, msp, context);\n    if (c !== collection)\n      throw new UnsupportedError(\n        `Segregated data collection mismatch: ${c} vs ${collection}`\n      );\n  });\n\n  const keyStrings = (keyArray as (keyof M)[]).map((key) => String(key));\n  // Store the original model — prepare() will filter to collection-specific fields\n  (context as FabricContractContext).writeTo(collection, keyStrings);\n}\n\nexport async function segregatedDataOnDelete<\n  M extends Model,\n  R extends Repository<M, any>,\n  V extends SegregatedDataMetadata,\n>(\n  this: R,\n  context: ContextOf<R>,\n  data: V | V[],\n  key: (keyof M)[],\n  model: M\n): Promise<void> {\n  const dataArray = (Array.isArray(data) ? data : [data]) as V[];\n  const keyArray = (Array.isArray(key) ? key : [key]) as (keyof M)[];\n  if (keyArray.length !== dataArray.length)\n    throw new InternalError(\n      `Segregated data keys and metadata length mismatch`\n    );\n\n  const msp =\n    Model.ownerOf(model) ||\n    extractMspId(\n      context.get(\"identity\") as string | ClientIdentity | undefined\n    );\n  if (!msp)\n    throw new ValidationError(\n      `There's no assigned organization for model ${model.constructor.name}`\n    );\n\n  const collectionResolver = dataArray[0].collections;\n  const collection =\n    typeof collectionResolver === \"string\"\n      ? collectionResolver\n      : collectionResolver(model, msp, context);\n\n  (context as FabricContractContext).readFrom(collection);\n}\n\nfunction segregated(\n  collection: string | CollectionResolver,\n  type: FabricModelKeys.PRIVATE | FabricModelKeys.SHARED,\n  filter?: (propName: string) => boolean\n) {\n  return function innerSegregated(target: object, propertyKey?: any) {\n    function segregatedDec(target: object, propertyKey?: any) {\n      const key = Metadata.key(type, propertyKey);\n      const constr: Constructor = target.constructor as Constructor;\n\n      const meta = Metadata.get(constr as Constructor, key) || {};\n      const collections = new Set(meta.collections || []);\n      collections.add(collection);\n      meta.collections = [...collections];\n      Metadata.set(constr as Constructor, key, meta);\n\n      const constrMeta = Metadata.get(constr as Constructor, type) || {};\n      const constrCollections = new Set(constrMeta.collections || []);\n      constrCollections.add(collection);\n      constrMeta.collections = [...constrCollections];\n      Metadata.set(constr as Constructor, type, constrMeta);\n\n      const transientMeta =\n        Metadata.get(constr as Constructor, DBKeys.TRANSIENT) || {};\n      const updatedTransientMeta = {\n        ...transientMeta,\n        [propertyKey as any]: {},\n      };\n      Metadata.set(\n        constr as Constructor,\n        DBKeys.TRANSIENT,\n        updatedTransientMeta\n      );\n    }\n\n    const decs: any[] = [];\n    if (!propertyKey) {\n      // decorated at the class level\n      const properties = Metadata.getAttributes(target as Constructor);\n      properties?.forEach((p) => {\n        if (!filter || filter(p)) {\n          segregated(collection, type)((target as any).prototype, p);\n        }\n      });\n      return target;\n    } else {\n      const groupName =\n        typeof collection === \"string\" ? collection : collection.toString();\n      // Use different group names for extraction vs data handlers to prevent merging\n      const extractGroupName = `${groupName}:extract`;\n      const dataGroupName = `${groupName}:data`;\n      const earlyExtractionMeta = { collections: collection };\n      const earlyExtractionGroupSort = {\n        priority: SEGREGATED_COLLECTION_EXTRACTION_PRIORITY,\n        group: extractGroupName,\n      };\n      decs.push(\n        prop(),\n        transient(),\n        segregatedDec,\n        // Early extraction handlers - run BEFORE pk generation (priority 60)\n        // This ensures collections are registered in context for sequence replication\n        // We register for each operation explicitly to ensure proper handler lookup\n        on(\n          DBOperations.ALL,\n          extractSegregatedCollections as any,\n          earlyExtractionMeta,\n          earlyExtractionGroupSort\n        ),\n        // Main handlers for segregated data operations (priority 95)\n        onCreate(\n          segregatedDataOnCreate,\n          { collections: collection },\n          {\n            priority: 95,\n            group: dataGroupName,\n          }\n        ),\n        onRead(\n          segregatedDataOnRead as any,\n          { collections: collection },\n          {\n            priority: 95,\n            group: dataGroupName,\n          }\n        ),\n        onUpdate(\n          segregatedDataOnUpdate as any,\n          { collections: collection },\n          {\n            priority: 95,\n            group: dataGroupName,\n          }\n        ),\n        onDelete(\n          segregatedDataOnDelete as any,\n          { collections: collection },\n          {\n            priority: 95,\n            group: dataGroupName,\n          }\n        )\n      );\n    }\n    return apply(...decs)(target, propertyKey);\n  };\n}\n\nexport function privateData(\n  collection: string | CollectionResolver = ImplicitPrivateCollection\n) {\n  function privateData(collection: string | CollectionResolver) {\n    return segregated(collection, FabricModelKeys.PRIVATE);\n  }\n\n  return Decoration.for(FabricModelKeys.PRIVATE)\n    .define({\n      decorator: privateData,\n      args: [collection],\n    })\n    .apply();\n}\n\nexport function sharedData(collection: string | CollectionResolver) {\n  function sharedData(collection: string | CollectionResolver) {\n    return segregated(collection, FabricModelKeys.SHARED);\n  }\n\n  return Decoration.for(FabricModelKeys.SHARED)\n    .define({\n      decorator: sharedData,\n      args: [collection],\n    })\n    .apply();\n}\n","/* eslint-disable @typescript-eslint/no-require-imports */\nimport { Constructor, Metadata } from \"@decaf-ts/decoration\";\nimport {\n  JSONSerializer,\n  Model,\n  ModelKeys,\n} from \"@decaf-ts/decorator-validation\";\n\n/**\n * @description Recursively sorts object keys without reordering arrays\n * @param {any} obj - The value to process\n * @return {any} A copy with sorted object keys but preserved array order\n */\nexport function sortKeysOnlyRecursive(obj: any): any {\n  if (obj === null || typeof obj !== \"object\") return obj;\n  if (Array.isArray(obj)) return obj.map(sortKeysOnlyRecursive);\n  if (obj.constructor !== Object) return obj;\n  return Object.keys(obj)\n    .sort()\n    .reduce((acc: Record<string, any>, key) => {\n      acc[key] = sortKeysOnlyRecursive(obj[key]);\n      return acc;\n    }, {});\n}\n\n/**\n * @description Deterministic JSON serializer for Fabric models\n * @summary Ensures stable, deterministic JSON output by sorting object keys recursively before stringification, which is important for Fabric endorsement and hashing. Extends JSONSerializer to plug into existing Decaf model serialization flow.\n * @template M - The Decaf Model subtype serialized by this instance\n * @param {void} [constructor] No public constructor arguments\n * @class DeterministicSerializer\n * @example\n * const serializer = new DeterministicSerializer<MyModel>();\n * const json = serializer.serialize(model);\n * const rebuilt = serializer.deserialize(json);\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant DS as DeterministicSerializer\n *   Caller->>DS: serialize(model)\n *   DS->>DS: preSerialize(model)\n *   DS->>DS: sort-keys-recursive\n *   DS->>DS: json-stringify-deterministic\n *   DS-->>Caller: string\n *   Caller->>DS: deserialize(string)\n *   DS-->>Caller: model\n */\nexport class DeterministicSerializer<\n  M extends Model,\n> extends JSONSerializer<M> {\n  constructor() {\n    super();\n  }\n  protected override preSerialize(model: M) {\n    // TODO: nested preserialization (so increase performance when deserializing)\n    // TODO: Verify why there is no metadata\n    const toSerialize: Record<string, any> = Object.assign({}, model);\n    let metadata;\n    try {\n      metadata = Metadata.modelName(model.constructor as Constructor);\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (error: unknown) {\n      metadata = undefined;\n    }\n    toSerialize[ModelKeys.ANCHOR] = metadata || model.constructor.name;\n\n    const preSerialize = function preSerialize(\n      this: DeterministicSerializer<any>,\n      obj: any\n    ): any {\n      // eslint-disable-next-line @typescript-eslint/no-this-alias\n      const self = this;\n      if (typeof obj !== \"object\") return obj;\n      if (Array.isArray(obj)) return obj.map((o) => preSerialize.call(self, o));\n      return this.preSerialize.call(this, obj);\n    }.bind(this);\n\n    Model.relations(model).forEach((r) => {\n      toSerialize[r] = preSerialize(toSerialize[r]);\n    });\n    return toSerialize;\n  }\n\n  /**\n   * @summary Rebuilds a model from a serialization\n   * @param {string} str\n   *\n   * @throws {Error} If it fails to parse the string, or to build the model\n   */\n  override deserialize(str: string): M {\n    const deserialization = JSON.parse(str);\n    const className = deserialization[ModelKeys.ANCHOR];\n    if (!className)\n      throw new Error(\"Could not find class reference in serialized model\");\n    const model: M = Model.build(deserialization, className) as unknown as M;\n    return model;\n  }\n\n  /**\n   * @description Serialize a model into a deterministic JSON string\n   * @summary Prepares the model with preSerialize, sorts keys recursively, and stringifies deterministically for stable ordering\n   * @param {M} model - The model instance to serialize\n   * @return {string} Deterministic JSON representation of the model\n   */\n  override serialize(model: M): string {\n    const stringify = require(\"json-stringify-deterministic\");\n    return stringify(sortKeysOnlyRecursive(this.preSerialize(model)));\n  }\n}\n","import { BulkCrudOperationKeys, OperationKeys } from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Generates a Fabric event name from components\n * @summary Creates a standardized event name by joining table, event, and optional owner with underscores\n * @param {string} table - The table/collection name\n * @param {OperationKeys | BulkCrudOperationKeys | string} event - The event type\n * @param {string} [owner] - Optional owner identifier\n * @return {string} The generated event name in format \"table_event\" or \"table_event_owner\"\n * @function generateFabricEventName\n * @memberOf module:for-fabric.shared\n */\nexport function generateFabricEventName(\n  table: string,\n  event: OperationKeys | BulkCrudOperationKeys | string,\n  owner?: string\n) {\n  const params = [table, event];\n  if (owner) params.push(owner);\n  return params.join(\"_\");\n}\n\n/**\n * @description Parses a Fabric event name into its components\n * @summary Splits an event name by underscores and extracts table, event, and optional owner\n * @param {string} name - The event name to parse\n * @return {{table: string, event: OperationKeys | BulkCrudOperationKeys | string, owner: string}} The parsed components as a structured object\n * @throws {InternalError} If the event name format is invalid\n * @function parseEventName\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant Parser as parseEventName\n *   Caller->>Parser: parseEventName(name)\n *   Parser->>Parser: split name by \"_\"\n *   alt parts length invalid\n *     Parser-->>Caller: throw InternalError\n *   else\n *     Parser-->>Caller: { table, event, owner? }\n *   end\n * @memberOf module:for-fabric.shared\n */\nexport function parseEventName(name: string): {\n  table?: string;\n  event: OperationKeys | BulkCrudOperationKeys | string;\n  owner?: string;\n} {\n  const parts = name.split(\"_\");\n  if (parts.length < 2 || parts.length > 3)\n    return { table: undefined, event: name, owner: undefined };\n  return {\n    table: parts[0],\n    event: parts[1],\n    owner: parts[2],\n  } as {\n    table: string;\n    event: OperationKeys | BulkCrudOperationKeys | string;\n    owner?: string;\n  };\n}\n","import { stringFormat } from \"@decaf-ts/decorator-validation\";\nimport { OverflowError } from \"./errors\";\nimport { ValidationError } from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Overflow-safe addition operation\n * @summary Adds two numbers and verifies no overflow by reverse-checking the operands\n * @param {number} a - First operand\n * @param {number} b - Second operand\n * @return {number} The sum of a and b\n * @function add\n * @throws {OverflowError} on addition overflow\n * @memberOf module:for-fabric.shared\n */\nexport function add(a: number, b: number): number {\n  const c = a + b;\n  if (a !== c - b || b !== c - a) {\n    throw new OverflowError(`Addition overflow: ${a} + ${b}`);\n  }\n  return c;\n}\n\n/**\n * @description Overflow-safe subtraction operation\n * @summary Subtracts b from a and validates no overflow by reverse-checking the operands\n * @param {number} a - Minuend\n * @param {number} b - Subtrahend\n * @return {number} The difference a - b\n * @function sub\n * @throws {OverflowError} on subtaction overflow\n * @memberOf module:for-fabric.shared\n */\nexport function sub(a: number, b: number): number {\n  const c = a - b;\n  if (a !== c + b || b !== a - c) {\n    throw new OverflowError(`Subtraction overflow: ${a} - ${b}`);\n  }\n  return c;\n}\n\n/**\n * @summary Safe Integer Parse\n *\n * @param {string} string\n *\n * @function safeParseInt\n *\n * @throws {ValidationError} if parseInt returns NaN\n *\n * @memberOf module:for-fabric.shared\n */\nexport function safeParseInt(string: string): number {\n  // Regular expression to check if string only have digits\n  const digitRegex = /^\\d+$/;\n  if (!digitRegex.test(string)) {\n    throw new ValidationError(\n      stringFormat(\"Failed to parse: {0}\", \"string contains digits\")\n    );\n  }\n  const parsedint = parseInt(string);\n  if (isNaN(parsedint)) {\n    throw new ValidationError(\n      stringFormat(\"Failed to parse: {0}\", \"string is not a parsable integer\")\n    );\n  }\n  return parsedint;\n}\n","import {\n  JSONSerializer,\n  Model,\n  ModelKeys,\n} from \"@decaf-ts/decorator-validation\";\nimport { Constructor, Metadata } from \"@decaf-ts/decoration\";\nimport { sortKeysOnlyRecursive } from \"./DeterministicSerializer\";\n\nexport class SimpleDeterministicSerializer<\n  M extends Model,\n> extends JSONSerializer<M> {\n  constructor() {\n    super();\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  override deserialize(str: string, tableName?: string): M {\n    const deserialization = JSON.parse(str);\n    // const className = tableName;\n    // if (!className)\n    //   throw new Error(\"Could not find class reference in serialized model\");\n\n    // // this will return undefined values\n    // const model: M = Model.build(deserialization, className) as unknown as M;\n\n    // // Populate Model\n    // const processedDesealization = Object.keys(model).reduce(\n    //   (accum: M, key) => {\n    //     (accum as Record<string, any>)[key] =\n    //       deserialization[Repository.column(accum, key)];\n    //     return accum;\n    //   },\n    //   model\n    // );\n\n    // const result = Model.build(\n    //   processedDesealization,\n    //   className\n    // ) as unknown as M;\n\n    // return result;\n    return deserialization;\n  }\n\n  override serialize(model: M, putAnchor = true): string {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const stringify = require(\"json-stringify-deterministic\");\n    const preSerialization = this.preSerialize(model, putAnchor);\n    return stringify(sortKeysOnlyRecursive(preSerialization));\n  }\n\n  protected override preSerialize(model: M, putAnchor: boolean = true) {\n    // TODO: nested preserialization (so increase performance when deserializing)\n    // TODO: Verify why there is no metadata\n    const toSerialize: Record<string, any> = Object.assign({}, model);\n    let metadata;\n    try {\n      metadata = Metadata.modelName(model.constructor as Constructor);\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (error: unknown) {\n      metadata = undefined;\n    }\n    if (putAnchor)\n      toSerialize[ModelKeys.ANCHOR] = metadata || model.constructor.name;\n\n    function preSerialize(\n      this: SimpleDeterministicSerializer<any>,\n      obj: any\n    ): any {\n      if (typeof obj !== \"object\") return obj;\n      if (Array.isArray(obj)) return obj.map(preSerialize);\n      return this.preSerialize(obj);\n    }\n    Model.relations(model).forEach((r) => {\n      toSerialize[r] = preSerialize.call(this, toSerialize[r]);\n    });\n    return toSerialize;\n  }\n}\n","import {\n  AuthorizationError,\n  ClientBasedService,\n  Context,\n  MaybeContextualArg,\n  PersistenceKeys,\n} from \"@decaf-ts/core\";\nimport FabricCAServices, {\n  AffiliationService,\n  IAttributeRequest,\n  IdentityService,\n  IEnrollResponse,\n  IIdentityRequest,\n  IRegisterRequest,\n  IRevokeRequest,\n  IServiceResponse,\n  TLSOptions,\n} from \"fabric-ca-client\";\nimport { CAConfig, Credentials } from \"../../shared/types\";\nimport {\n  ConflictError,\n  InternalError,\n  NotFoundError,\n  OperationKeys,\n} from \"@decaf-ts/db-decorators\";\nimport { CoreUtils, getAkiAndSerialFromCert } from \"../utils\";\nimport {\n  CertificateResponse,\n  FabricIdentity,\n  GetCertificatesRequest,\n  IdentityResponse,\n} from \"../../shared/fabric-types\";\nimport { User } from \"fabric-common\";\nimport { RegistrationError } from \"../../shared/errors\";\nimport { CA_ROLE } from \"./constants\";\nimport { IKeyValueAttribute } from \"./FabricEnrollmentService\";\nimport { Identity } from \"../../shared/index\";\nimport { CryptoUtils } from \"../crypto\";\n\nexport class FabricIdentityService extends ClientBasedService<\n  FabricCAServices,\n  CAConfig\n> {\n  protected _user!: User;\n\n  constructor() {\n    super();\n  }\n\n  protected get rootClient(): { newCertificateService: any } {\n    return (this.client as any)[\"_FabricCaServices\"] as any;\n  }\n\n  protected get user(): User {\n    if (!this._user)\n      throw new InternalError(\n        \"Fabric identity service not properly setup: missing user\"\n      );\n    return this._user;\n  }\n\n  protected get certificates() {\n    return this.rootClient.newCertificateService();\n  }\n\n  protected get affiliations(): AffiliationService {\n    return this.client.newAffiliationService();\n  }\n\n  protected get identities(): IdentityService {\n    return this.client.newIdentityService();\n  }\n\n  protected async getUser(cfg: CAConfig, ctx: Context) {\n    const log = ctx.logger.for(this.getUser);\n    const { caName, caCert, caKey, url, hsm } = cfg;\n\n    log.info(`Creating CA user for ${caName} at ${url}`);\n    log.verbose(`Retrieving CA certificate from ${caCert}`);\n    const certificate = await CoreUtils.getFirstDirFileNameContent(caCert);\n    let key: string | undefined;\n    if (!hsm) {\n      if (!caKey) {\n        throw new InternalError(\n          `Missing caKey configuration for CA ${caName}. Provide a key directory or configure HSM support.`\n        );\n      }\n      log.debug(`Retrieving CA key from ${caKey}`);\n      key = await CoreUtils.getFirstDirFileNameContent(caKey);\n    } else {\n      log.debug(\n        `Using HSM configuration for CA ${caName} with library ${hsm.library}`\n      );\n    }\n    log.debug(`Loading Admin user for ca ${caName}`);\n    this._user = await CoreUtils.getCAUser(\"admin\", key, certificate, caName, {\n      hsm,\n    });\n    return this._user;\n  }\n\n  override async initialize(\n    ...args: MaybeContextualArg<any>\n  ): Promise<{ config: CAConfig; client: FabricCAServices }> {\n    const { log, ctx } = (\n      await this.logCtx(args, PersistenceKeys.INITIALIZATION, true)\n    ).for(this.initialize);\n    const [config] = args;\n    if (!config) throw new InternalError(\"Missing Fabric CA configuration\");\n\n    const { url, tls, caName } = config;\n    log.info(`Initializing CA Client for CA ${config.caName} at ${config.url}`);\n    const { trustedRoots, verify } = tls as TLSOptions;\n\n    const root = (trustedRoots as string[])[0] as string;\n    log.debug(`Retrieving CA certificate from ${root}. cwd: ${process.cwd()}`);\n\n    const certificate = await CoreUtils.getFileContent(root);\n\n    log.debug(`CA Certificate: ${certificate.toString()}`);\n\n    const client = new FabricCAServices(\n      url,\n      {\n        trustedRoots: Buffer.from(certificate),\n        verify,\n      } as TLSOptions,\n      caName\n    );\n\n    const user = await this.getUser(config, ctx);\n    log.debug(`CA user loaded: ${user.getName()}`);\n    return {\n      config,\n      client,\n    };\n  }\n\n  async getCertificates(...args: MaybeContextualArg<any>): Promise<string[]>;\n  async getCertificates(\n    request: GetCertificatesRequest,\n    ...args: MaybeContextualArg<any>\n  ): Promise<string[]>;\n  async getCertificates<MAP extends boolean>(\n    doMap: MAP,\n    ...args: MaybeContextualArg<any>\n  ): Promise<MAP extends false ? CertificateResponse : string[]>;\n  async getCertificates<MAP extends boolean>(\n    request: GetCertificatesRequest,\n    doMap: MAP,\n    ...args: MaybeContextualArg<any>\n  ): Promise<MAP extends false ? CertificateResponse : string[]>;\n  async getCertificates<MAP extends boolean>(\n    request?: GetCertificatesRequest | MAP,\n    doMap: MAP = true as MAP,\n    ...args: MaybeContextualArg<any>\n  ): Promise<MAP extends false ? CertificateResponse : string[]> {\n    if (request instanceof Context) {\n      args = [request];\n      doMap = true as MAP;\n      request = undefined;\n    } else if (typeof request === \"boolean\") {\n      doMap = request;\n      request = undefined;\n    } else if (typeof doMap !== \"boolean\") {\n      args = [doMap as MaybeContextualArg<any>, ...args];\n      doMap = true as MAP;\n    }\n\n    const { log } = (await this.logCtx(args, OperationKeys.READ, true)).for(\n      this.getCertificates\n    );\n    log.debug(\n      `Retrieving certificates${request ? ` for ${request.id}` : \"\"} for CA ${this.config.caName}`\n    );\n    const response: CertificateResponse = (\n      await this.certificates.getCertificates(request || {}, this.user)\n    ).result;\n    log.verbose(`Found ${response.certs.length} certificates`);\n    log.debug(response.certs);\n    return (\n      doMap ? response.certs.map((c) => c.PEM) : response\n    ) as MAP extends false ? CertificateResponse : string[];\n  }\n\n  async getIdentities(ctx: Context): Promise<FabricIdentity[]> {\n    const log = ctx.logger.for(this.getIdentities);\n    log.verbose(`Retrieving Identities under CA ${this.config.caName}`);\n    const response: IdentityResponse = (await this.identities.getAll(this.user))\n      .result;\n    log.verbose(`Found ${response.identities.length} Identities`);\n    log.debug(response.identities);\n    return response.identities;\n  }\n\n  /**\n   * @description Retrieve affiliations from the CA.\n   * @summary Queries the CA for the list of affiliations available under the configured CA.\n   * @return {string} The affiliations result payload.\n   */\n  async getAffiliations(ctx: Context) {\n    const log = ctx.logger.for(this.getAffiliations);\n    log.verbose(`Retrieving Affiliations under CA ${this.config.caName}`);\n    const response = (await this.affiliations.getAll(this.user)).result;\n    log.verbose(`Found ${response.a.length} Affiliations`);\n    log.debug(JSON.stringify(response));\n    return response;\n  }\n\n  protected parseError(e: Error) {\n    const regexp = /.*code:\\s(\\d+).*?message:\\s[\"'](.+)[\"']/gs;\n    const match = regexp.exec(e.message);\n    if (!match) return new RegistrationError(e);\n    const [, code, message] = match;\n    switch (code) {\n      case \"74\":\n      case \"71\":\n        return new ConflictError(message);\n      case \"20\":\n        return new AuthorizationError(message);\n      default:\n        return new RegistrationError(message);\n    }\n  }\n\n  /**\n   * @description Read identity details from the CA by enrollment ID.\n   * @summary Retrieves and validates a single identity, throwing NotFoundError when missing.\n   * @param {string} enrollmentId - Enrollment ID to lookup.\n   * @return {Promise<FabricIdentity>} The identity details stored in the CA.\n   */\n  async read(\n    enrollmentId: string,\n    ...args: MaybeContextualArg<any>\n  ): Promise<FabricIdentity> {\n    const { log } = (await this.logCtx(args, OperationKeys.READ, true)).for(\n      this.read\n    );\n    log.verbose(`Retrieving identity with enrollment ID ${enrollmentId}`);\n    let result: IServiceResponse;\n    try {\n      result = await this.identities.getOne(enrollmentId, this.user);\n    } catch (e: any) {\n      throw new NotFoundError(\n        `Couldn't find enrollment with id ${enrollmentId}: ${e}`\n      );\n    }\n\n    if (!result.success)\n      throw new NotFoundError(\n        `Couldn't find enrollment with id ${enrollmentId}: ${result.errors.join(\"\\n\")}`\n      );\n\n    return result.result as FabricIdentity;\n  }\n\n  /**\n   * @description Register a new identity with the CA.\n   * @summary Submits a registration request for a new enrollment ID, returning the enrollment secret upon success.\n   * @param {Credentials} model - Credentials containing userName and password for the new identity.\n   * @param {boolean} [isSuperUser=false] - Whether to register the identity as a super user.\n   * @param {string} [affiliation=\"\"] - Affiliation string (e.g., org1.department1).\n   * @param {CA_ROLE | string} [userRole] - Role to assign to the identity.\n   * @param {IKeyValueAttribute} [attrs] - Optional attributes to attach to the identity.\n   * @param {number} [maxEnrollments] - Maximum number of enrollments allowed for the identity.\n   * @return {Promise<string>} The enrollment secret for the registered identity.\n   */\n  async register(\n    model: Credentials,\n    isSuperUser: boolean = false,\n    affiliation: string = \"\",\n    userRole?: CA_ROLE | string,\n    attrs?: IKeyValueAttribute,\n    maxEnrollments?: number,\n    ...args: MaybeContextualArg<any>\n  ): Promise<string> {\n    const { log } = (await this.logCtx(args, \"register\", true)).for(\n      this.register\n    );\n\n    let registration: string;\n    try {\n      const { userName, password } = model;\n      const props = {\n        enrollmentID: userName as string,\n        enrollmentSecret: password,\n        affiliation: affiliation,\n        userRole: userRole,\n        attrs: attrs,\n        maxEnrollments: maxEnrollments,\n      } as IRegisterRequest;\n      registration = await this.client.register(props, this.user);\n      log.info(\n        `Registration for ${userName} created with user type ${userRole ?? \"Undefined Role\"} ${isSuperUser ? \"as super user\" : \"\"}`\n      );\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n    return registration;\n  }\n\n  protected static identityFromEnrollment(\n    enrollment: IEnrollResponse,\n    mspId: string,\n    ctx: Context\n  ): Identity {\n    const log = ctx.logger.for(this.identityFromEnrollment);\n    const { certificate, key, rootCertificate } = enrollment;\n    log.verbose(\n      `Generating Identity from certificate ${certificate} in msp ${mspId}`\n    );\n    const clientId = CryptoUtils.fabricIdFromCertificate(certificate);\n    const id = CryptoUtils.encode(clientId);\n    log.debug(`Identity ${clientId} and encodedId ${id}`);\n    return new Identity({\n      id: id,\n      credentials: {\n        id: id,\n        certificate: certificate,\n        privateKey: key.toBytes(),\n        rootCertificate: rootCertificate,\n      },\n      mspId: mspId,\n    });\n  }\n\n  /**\n   * @description Enroll an identity with the CA using a registration secret.\n   * @summary Exchanges the enrollment ID and secret for certificates, returning a constructed Identity model.\n   * @param {string} enrollmentId - Enrollment ID to enroll.\n   * @param {string} registration - Enrollment secret returned at registration time.\n   * @return {Promise<Identity>} The enrolled identity object with credentials.\n   */\n  async enroll(\n    enrollmentId: string,\n    registration: string,\n    ...args: MaybeContextualArg<any>\n  ): Promise<Identity> {\n    const { log, ctx } = (await this.logCtx(args, \"enroll\", true)).for(\n      this.enroll\n    );\n    let identity: Identity;\n    try {\n      log.debug(`Enrolling ${enrollmentId}`);\n      const enrollment: IEnrollResponse = await this.client.enroll({\n        enrollmentID: enrollmentId,\n        enrollmentSecret: registration,\n      });\n      identity = FabricIdentityService.identityFromEnrollment(\n        enrollment,\n        this.config.caName,\n        ctx\n      );\n      log.info(\n        `Successfully enrolled ${enrollmentId} under ${this.config.caName} as ${identity.id}`\n      );\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n    return identity;\n  }\n\n  /**\n   * @description Register and enroll a new identity in one step.\n   * @summary Registers a new enrollment ID with the CA and immediately exchanges the secret to enroll, returning the created Identity.\n   * @param {Credentials} model - Credentials for the new identity containing userName and password.\n   * @param {boolean} [isSuperUser=false] - Whether to register the identity as a super user.\n   * @param {string} [affiliation=\"\"] - Affiliation string (e.g., org1.department1).\n   * @param {CA_ROLE | string} [userRole] - Role to assign to the identity.\n   * @param {IKeyValueAttribute} [attrs] - Optional attributes to attach to the identity.\n   * @param {number} [maxEnrollments] - Maximum number of enrollments allowed for the identity.\n   * @return {Promise<Identity>} The enrolled identity.\n   */\n  async registerAndEnroll(\n    model: Credentials,\n    isSuperUser: boolean = false,\n    affiliation: string = \"\",\n    userRole?: CA_ROLE | string,\n    attrs?: IKeyValueAttribute,\n    maxEnrollments?: number,\n    ...args: MaybeContextualArg<any>\n  ): Promise<Identity> {\n    const { ctx } = (await this.logCtx(args, \"register-enroll\", true)).for(\n      this.registerAndEnroll\n    );\n    const registration = await this.register(\n      model,\n      isSuperUser,\n      affiliation,\n      userRole,\n      attrs,\n      maxEnrollments,\n      ctx\n    );\n    const { userName } = model;\n    return this.enroll(userName as string, registration, ctx);\n  }\n\n  /**\n   * @description Re-enroll an existing identity using its current enrollment.\n   * @summary Renews the enrollment certificate by calling the CA reenroll.\n   * @param {User} currentUser - Already enrolled user, must have a signing identity.\n   * @return {Promise<Identity>} The renewed identity object with new credentials.\n   */\n  async updateIdentity(\n    enrollmentId: string,\n    identity: { certificate: string; privateKey: string },\n    identityRequest: IIdentityRequest,\n    ...args: MaybeContextualArg<any>\n  ): Promise<Identity> {\n    const { log, ctx } = (await this.logCtx(args, \"reenroll\", true)).for(\n      this.updateIdentity\n    );\n\n    try {\n      log.info(`Renewing identity for ${enrollmentId}`);\n\n      // Update attributes in the CA registry (admin operation). This changes the \"source of truth\".\n      const identityService = this.client.newIdentityService();\n\n      const caUserIdentity = (await identityService.getOne(\n        enrollmentId,\n        this.user\n      )) as { result: { attrs?: IKeyValueAttribute[] } };\n\n      await identityService.update(enrollmentId, identityRequest, this.user); // as IServiceResponse & { result: IIdentityRequest };\n\n      // Reenroll as the user. Request must be signed using the existing certificate.\n      const reenrollUser = User.createUser(\n        enrollmentId,\n        \"\", // enrollmentSecret not required for reenroll\n        this.user.getMspid(),\n        identity.certificate,\n        identity.privateKey\n      );\n      reenrollUser.setCryptoSuite(this.user.getCryptoSuite());\n\n      const enrollmentAttrs: IAttributeRequest[] = (\n        caUserIdentity.result.attrs || []\n      ).map(({ name }) => ({\n        name,\n        optional: false,\n      }));\n\n      const enrollment = await this.client.reenroll(\n        reenrollUser,\n        enrollmentAttrs\n      );\n\n      const renewedIdentity = FabricIdentityService.identityFromEnrollment(\n        enrollment,\n        this.config.caName,\n        ctx\n      );\n\n      // Revoke the previous certificate only, so the old cert becomes invalid.\n      log.debug(`Revoking previous certificates for ${enrollmentId}`);\n      const { aki, serial } = getAkiAndSerialFromCert(identity.certificate);\n      await this.revoke(enrollmentId, { aki, serial }, args);\n\n      log.debug(`Renew identity successful for ${enrollmentId}`);\n      return renewedIdentity;\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n  }\n\n  /**\n   * Revokes the enrollment of an identity with the specified enrollment ID.\n   *\n   * @param enrollmentId - The enrollment ID of the identity to be revoked.\n   *\n   * @returns A Promise that resolves to the result of the revocation operation.\n   *\n   * @throws {NotFoundError} If the enrollment with the specified ID does not exist.\n   * @throws {InternalError} If there is an error during the revocation process.\n   */\n  async revoke(\n    enrollmentId: string,\n    revokeOptions: Omit<IRevokeRequest, \"enrollmentID\">,\n    ...args: MaybeContextualArg<any>\n  ): Promise<IServiceResponse> {\n    const { log } = (await this.logCtx(args, \"revoke\", true)).for(this.revoke);\n    log.verbose(`Revoking identity with enrollment ID ${enrollmentId}`);\n    const identity = await this.read(enrollmentId);\n    if (!identity)\n      throw new NotFoundError(\n        `Could not find enrollment with id ${enrollmentId}`\n      );\n    let result: IServiceResponse;\n    try {\n      const reason =\n        Boolean(revokeOptions.serial) || Boolean(revokeOptions.aki)\n          ? \"Revoke User Certificate\"\n          : \"User Deletion\";\n\n      const revokeRequest: IRevokeRequest = {\n        reason,\n        ...revokeOptions,\n        enrollmentID: identity.id,\n      };\n\n      result = await this.client.revoke(revokeRequest, this.user);\n    } catch (e: unknown) {\n      throw new InternalError(\n        `Could not revoke enrollment with id ${enrollmentId}: ${e}`\n      );\n    }\n    if (!result.success)\n      throw new InternalError(\n        `Could not revoke enrollment with id ${enrollmentId}: ${result.errors.join(\"\\n\")}`\n      );\n    return result;\n  }\n}\n","/**\n * @description Certificate Authority role types used during enrollment and registration.\n * @summary Enumerates the standard Hyperledger Fabric CA roles that can be assigned to identities when registering with the CA service.\n * @enum {string}\n * @readonly\n * @memberOf module:for-fabric.client\n */\nexport enum CA_ROLE {\n  /** Administrator role with elevated privileges for managing identities and affiliations */\n  ADMIN = \"admin\",\n  /** Standard user role for application clients interacting with the network */\n  USER = \"user\",\n  /** Client role typically used for SDK-based interactions and service accounts */\n  CLIENT = \"client\",\n}\n","import { FabricClientFlags } from \"./types\";\n\nexport const DefaultFabricClientFlags: FabricClientFlags = Object.assign({\n  evaluateTimeout: 5,\n  endorseTimeout: 15,\n  submitTimeout: 5,\n  commitTimeout: 60,\n  legacy: false,\n  allowManualEndorsingOrgs: false,\n  allowGatewayOverride: false,\n  rebuildWithTransient: true,\n  encryptTransient: false,\n  syntheticEvents: true,\n}) as any;\n","import { isBrowser, MiniLogger } from \"@decaf-ts/logging\";\nimport { User } from \"fabric-common\";\nimport { Identity, Signer, signers } from \"@hyperledger/fabric-gateway\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\nimport { normalizeImport } from \"@decaf-ts/core\";\n\nconst log = new MiniLogger(\"fabric-fs\");\n\n/**\n * @description Loads content from a file or returns the content if already loaded\n * @summary Determines if the input is already content or a path to a file, and loads the file if needed\n * @param {string | Uint8Array} contentOrPath - The content or path to load\n * @param {Function} fileReader - Function to read the file if contentOrPath is a path\n * @return {Promise<string | Uint8Array | Buffer>} The content\n * @function contentOfLoadFile\n * @memberOf module:for-fabric.client\n */\nexport async function contentOfLoadFile(\n  contentOrPath: string | Uint8Array,\n  fileReader: (path: string) => Promise<string | Uint8Array | Buffer>\n) {\n  if (contentOrPath instanceof Uint8Array) return contentOrPath;\n  if (\n    contentOrPath.match(\n      /-----BEGIN (CERTIFICATE|KEY|PRIVATE KEY)-----.+?-----END \\1-----$/gms\n    )\n  )\n    return contentOrPath;\n  return await fileReader(contentOrPath);\n}\n\n/**\n * @description Reads a file from the file system\n * @summary Loads a file using the Node.js file system module\n * @param {string | Buffer} contentOrPath - The content or path to load\n * @return {Promise<Buffer>} The file content as a Buffer\n * @function readFile\n * @memberOf module:for-fabric.client\n */\nexport async function readFile(contentOrPath: string | Buffer) {\n  if (typeof contentOrPath !== \"string\") return contentOrPath;\n\n  const fileReader = async (path: string) => {\n    const { promises } = await normalizeImport(import(\"fs\"));\n    return await promises.readFile(path);\n  };\n\n  return await fileReader(contentOrPath);\n}\n\n/**\n * @description Creates a Certificate Authority user\n * @summary Initializes a user with the given credentials for interacting with a Fabric CA\n * @param {string} userName - The user name\n * @param {string} privateKey - The private key as a string\n * @param {string} certificate - The certificate as a string\n * @param {string} mspId - The Membership Service Provider ID\n * @return {Promise<User>} Promise resolving to the created user\n * @function getCAUser\n * @memberOf module:for-fabric.client\n */\nexport async function getCAUser(\n  userName: string,\n  privateKey: string,\n  certificate: string,\n  mspId: string\n): Promise<User> {\n  log.debug(\n    `Creating a CA ${mspId} user ${userName} with certificate ${certificate}`\n  );\n  const user = new User(userName);\n  const cryptoSuite = User.newCryptoSuite();\n  user.setCryptoSuite(cryptoSuite);\n  const importedKey = cryptoSuite.createKeyFromRaw(privateKey);\n  await user.setEnrollment(importedKey, certificate, mspId);\n  return user;\n}\n\n/**\n * @description Gets an identity from a certificate directory\n * @summary Loads a certificate from a directory and creates an Identity object\n * @param {string} mspId - The Membership Service Provider ID\n * @param {string} certDirectoryPath - Path to the directory containing the certificate\n * @return {Promise<Identity>} Promise resolving to the identity\n * @function getIdentity\n * @memberOf module:for-fabric.client\n */\nexport async function getIdentity(\n  mspId: string,\n  certDirectoryPath: string\n): Promise<Identity> {\n  const identityFileReader = async (path: string) => {\n    const { promises } = await normalizeImport(import(\"fs\"));\n    const certPath = await getFirstDirFileName(path);\n    const credentials = await promises.readFile(certPath);\n    return credentials;\n  };\n\n  const credentials: Uint8Array = (await contentOfLoadFile(\n    certDirectoryPath,\n    identityFileReader\n  )) as Uint8Array;\n\n  return { mspId, credentials };\n}\n\n/**\n * @description Gets the full path of the first file in a directory\n * @summary Reads a directory and returns the path to the first file found\n * @param {string} dirPath - Path to the directory\n * @return {Promise<string>} Promise resolving to the full path of the first file\n * @function getFirstDirFileName\n * @memberOf module:for-fabric.client\n */\nexport async function getFirstDirFileName(dirPath: string): Promise<string> {\n  const { promises } = await normalizeImport(import(\"fs\"));\n  const { join } = await normalizeImport(import(\"path\"));\n  const files = await promises.readdir(dirPath);\n  return join(dirPath, files[0]);\n}\n\n/**\n * @description Gets the content of the first file in a directory\n * @summary Reads a directory, finds the first file, and returns its content as a string\n * @param {string} dirPath - Path to the directory\n * @return {Promise<string>} Promise resolving to the content of the first file\n * @function getFirstDirFileNameContent\n * @memberOf module:for-fabric.client\n */\nexport async function getFirstDirFileNameContent(\n  dirPath: string\n): Promise<string> {\n  const { promises } = await normalizeImport(import(\"fs\"));\n  const { join } = await normalizeImport(import(\"path\"));\n  const files = await promises.readdir(dirPath);\n  return (await promises.readFile(join(dirPath, files[0]))).toString();\n}\n\n/**\n * @description Gets a signer from a key directory\n * @summary Loads a private key from a directory and creates a Signer for Fabric transactions\n * @param {string} keyDirectoryPath - Path to the directory containing the private key\n * @return {Promise<Signer>} Promise resolving to the signer\n * @function getSigner\n * @memberOf module:for-fabric.client\n */\nexport async function getSigner(keyDirectoryPath: string): Promise<Signer> {\n  const signerFileReader = async (path: string) => {\n    const { promises } = await normalizeImport(import(\"fs\"));\n    const keyPath = await getFirstDirFileName(path);\n    return await promises.readFile(keyPath);\n  };\n\n  const privateKeyPem = (await contentOfLoadFile(\n    keyDirectoryPath,\n    signerFileReader\n  )) as Buffer;\n\n  let k;\n  if (isBrowser()) {\n    // web based implementation\n    const privateKey = await extractPrivateKey(privateKeyPem);\n    const keys = Object.getOwnPropertySymbols(privateKey);\n    k = (privateKey as any)[keys[0]];\n  } else {\n    // Node based implementation\n    const { createPrivateKey } = await import(\"crypto\");\n    k = createPrivateKey(privateKeyPem);\n  }\n\n  return signers.newPrivateKeySigner(k as any);\n}\n\n/**\n * @description Extracts a private key from a PEM buffer\n * @summary Converts a PEM-encoded private key to a CryptoKey object\n * @param {Buffer} pem - The PEM-encoded private key\n * @return {Promise<CryptoKey>} Promise resolving to the CryptoKey\n * @function extractPrivateKey\n * @memberOf module:for-fabric.client\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant ExtractPrivateKey\n *   participant SubtleCrypto\n *\n *   Caller->>ExtractPrivateKey: extractPrivateKey(pem)\n *   ExtractPrivateKey->>ExtractPrivateKey: Get SubtleCrypto implementation\n *   ExtractPrivateKey->>ExtractPrivateKey: Parse PEM format\n *   ExtractPrivateKey->>ExtractPrivateKey: Convert to binary DER\n *   ExtractPrivateKey->>SubtleCrypto: importKey(pkcs8, binaryDer, options)\n *   SubtleCrypto-->>ExtractPrivateKey: CryptoKey\n *   ExtractPrivateKey-->>Caller: CryptoKey\n */\nexport async function extractPrivateKey(pem: Buffer) {\n  // const libName = \"node:crypto\";\n  let subtle;\n  // if (isBrowser()) {\n  // eslint-disable-next-line prefer-const\n  subtle = (globalThis as any).crypto.subtle;\n  // } else {\n  //   const lib = (await normalizeImport(import(libName))) as any;\n  //   subtle = lib.subtle || lib.webcrypto.subtle;\n  // }\n\n  if (!subtle) throw new Error(\"Could not load SubtleCrypto module\");\n\n  function str2ab(str: string) {\n    const buf = new ArrayBuffer(str.length);\n    const bufView = new Uint8Array(buf);\n    for (let i = 0, strLen = str.length; i < strLen; i++) {\n      bufView[i] = str.charCodeAt(i);\n    }\n    return buf;\n  }\n\n  const str = pem\n    .toString(\"utf8\")\n    .replace(\"-----BEGIN PRIVATE KEY-----\", \"\")\n    .replaceAll(\"\\n\", \"\")\n    .replace(\"-----END PRIVATE KEY-----\", \"\");\n  const decoded = Buffer.from(str, \"base64\").toString(\"binary\");\n  const binaryDer = str2ab(decoded);\n\n  try {\n    const key = await subtle.importKey(\n      \"pkcs8\",\n      binaryDer,\n      {\n        name: \"ECDSA\",\n        namedCurve: \"P-256\",\n      },\n      true,\n      [\"sign\"]\n    );\n\n    return key;\n  } catch (e: any) {\n    throw new InternalError(e);\n  }\n}\n","import {\n  AdapterFlags,\n  Condition,\n  Context,\n  GroupOperator,\n  MaybeContextualArg,\n  Operator,\n  OrderDirection,\n  PersistenceKeys,\n  PreparedStatement,\n  PreparedStatementKeys,\n  QueryClause,\n  QueryError,\n  Repository,\n  SelectSelector,\n  Sequence,\n  Statement,\n  StatementExecutor,\n  ViewKind,\n} from \"@decaf-ts/core\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { FabricClientAdapter } from \"./FabricClientAdapter\";\nimport {\n  CouchDBKeys,\n  CouchDBOperator,\n  CouchDBGroupOperator,\n  CouchDBQueryLimit,\n  MangoQuery,\n  MangoOperator,\n  MangoSelector,\n  translateOperators,\n  generateDesignDocName,\n  generateViewName,\n  findViewMetadata,\n  CouchDBViewMetadata,\n  ViewResponse,\n} from \"@decaf-ts/for-couchdb\";\nimport { FabricClientFlags } from \"./types\";\nimport { toCamelCase } from \"@decaf-ts/logging\";\nimport { DBKeys, InternalError } from \"@decaf-ts/db-decorators\";\nimport { Metadata } from \"@decaf-ts/decoration\";\n\ntype FabricViewDescriptor = {\n  ddoc: string;\n  view: string;\n  options: Record<string, any>;\n};\n\ntype FabricAggregateInfo =\n  | {\n      kind: ViewKind;\n      meta: CouchDBViewMetadata;\n      descriptor: FabricViewDescriptor;\n      countDistinct?: boolean;\n    }\n  | {\n      kind: \"avg\";\n      attribute: string;\n      sumDescriptor: FabricViewDescriptor;\n      countDescriptor: FabricViewDescriptor;\n    };\n\nconst escapeRegExp = (value: string): string =>\n  value.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n\nfunction nextLexicographicString(value: string): string {\n  if (!value) return \"\\u0000\";\n  const chars = Array.from(value);\n  for (let i = chars.length - 1; i >= 0; i -= 1) {\n    const code = chars[i].codePointAt(0);\n    if (code === undefined) continue;\n    if (code < 0x10ffff) {\n      chars[i] = String.fromCodePoint(code + 1);\n      return chars.slice(0, i + 1).join(\"\");\n    }\n  }\n  return `${value}\\u0000`;\n}\n\nfunction prefixRange(prefix: string) {\n  return {\n    start: prefix,\n    end: nextLexicographicString(prefix),\n  };\n}\n\nexport class FabricClientStatement<M extends Model, R> extends Statement<\n  M,\n  FabricClientAdapter,\n  R,\n  MangoQuery\n> {\n  constructor(adapter: FabricClientAdapter, overrides?: Partial<AdapterFlags>) {\n    super(adapter, overrides);\n  }\n\n  protected override squash(\n    ctx: Context<FabricClientFlags>\n  ): PreparedStatement<any> | undefined {\n    const squashed: PreparedStatement<M> | undefined = super.squash(\n      ctx as never\n    );\n    if (!squashed) return squashed;\n\n    const { method, params, args } = squashed;\n    const { direction, limit } = params;\n    switch (method) {\n      case PreparedStatementKeys.FIND:\n        break;\n      case PreparedStatementKeys.PAGE:\n        args.push(direction, limit);\n        break;\n      case PreparedStatementKeys.FIND_BY:\n        break;\n      case PreparedStatementKeys.LIST_BY:\n        args.push(direction);\n        break;\n      case PreparedStatementKeys.PAGE_BY:\n        args.push(direction, limit);\n        break;\n      case PreparedStatementKeys.FIND_ONE_BY:\n        break;\n      default:\n        throw new InternalError(`Unsupported method ${method}`);\n    }\n\n    return squashed;\n  }\n\n  protected override async executePrepared(\n    ...argz: MaybeContextualArg<Context<FabricClientFlags>>\n  ): Promise<R> {\n    const repo = Repository.forModel(this.fromSelector, this.adapter.alias);\n    const { method, args } = this.prepared as PreparedStatement<any>;\n    return repo.statement(method, ...args, ...argz);\n  }\n\n  override async prepare(\n    ctx?: Context<FabricClientFlags>\n  ): Promise<StatementExecutor<M, R>> {\n    ctx =\n      ctx ||\n      (await this.adapter.context(\n        PersistenceKeys.QUERY,\n        this.overrides || {},\n        this.fromSelector\n      ));\n\n    if (\n      this.isSimpleQuery() &&\n      (ctx as Context<FabricClientFlags>).get(\"forcePrepareSimpleQueries\")\n    ) {\n      const squashed = this.squash(ctx as Context<FabricClientFlags>);\n      if (squashed) {\n        this.prepared = squashed;\n        return this;\n      }\n    }\n    const args: (string | number)[] = [];\n    const params: any = {} as any;\n\n    const prepared: PreparedStatement<any> = {\n      class: this.fromSelector,\n      args,\n      params,\n    } as any;\n\n    const method: string[] = [QueryClause.FIND_BY];\n\n    if (this.whereCondition) {\n      const parsed = this.prepareCondition(this.whereCondition, ctx as never);\n      method.push(parsed.method);\n      if (parsed.args && parsed.args.length)\n        args.push(...(parsed.args as (string | number)[]));\n    }\n    if (this.selectSelector)\n      method.push(\n        QueryClause.SELECT,\n        this.selectSelector.join(` ${QueryClause.AND.toLowerCase()} `)\n      );\n    if (this.orderBySelectors?.length) {\n      method.push(QueryClause.ORDER_BY, this.orderBySelectors[0][0] as string);\n      args.push(this.orderBySelectors[0][1] as any);\n    }\n    prepared.method = toCamelCase(method.join(\" \"));\n    prepared.params = params;\n    this.prepared = prepared;\n    return this;\n  }\n\n  /**\n   * @description Processes a record from CouchDB/Fabric\n   * @summary Extracts the ID from a CouchDB document and reverts it to a model instance\n   */\n  protected override processRecord(\n    record: any,\n    ctx: Context<FabricClientFlags>\n  ): M {\n    const pkAttr = Model.pk(this.fromSelector);\n    const type = Metadata.get(\n      this.fromSelector,\n      Metadata.key(DBKeys.ID, pkAttr as string)\n    )?.type;\n\n    if (record[CouchDBKeys.ID]) {\n      const [, ...keyArgs] = record[CouchDBKeys.ID].split(CouchDBKeys.SEPARATOR);\n      const id = keyArgs.join(\"_\");\n      record[pkAttr] = Sequence.parseValue(type as any, id);\n    }\n\n    return super.processRecord(record, ctx);\n  }\n\n  /**\n   * @description Executes a raw Mango query\n   * @summary Sends a raw Mango query to Fabric and processes the results\n   */\n  override async raw<R>(rawInput: MangoQuery, ...args: any[]): Promise<R> {\n    const { ctx } = this.logCtx(args, this.raw);\n    const aggregator = (rawInput as any)?.aggregateInfo;\n    if ((rawInput as any)?.aggregate && aggregator) {\n      return this.executeAggregate<R>(aggregator, ctx);\n    }\n    const results: any[] = await this.adapter.raw(\n      rawInput,\n      true,\n      this.fromSelector,\n      ctx\n    );\n\n    if (!this.selectSelector) {\n      const processed = results.map((r) => this.processRecord(r, ctx));\n      if (!ctx.getOrUndefined(\"afterQueryHandlers\")) {\n        return processed as unknown as R;\n      }\n      return (await this.applyAfterHandlersToResult(processed, ctx)) as R;\n    }\n    return results as R;\n  }\n\n  /**\n   * @description Builds a CouchDB Mango query from the statement\n   * @summary Converts the statement's conditions, selectors, and options into a CouchDB Mango query\n   */\n  protected override build(): MangoQuery {\n    const log = this.log.for(this.build);\n    const aggregateQuery = this.buildAggregateQuery();\n    if (aggregateQuery) return aggregateQuery;\n    const selectors: MangoSelector = {};\n    selectors[CouchDBKeys.TABLE] = {};\n    selectors[CouchDBKeys.TABLE] = Model.tableName(this.fromSelector);\n    const query: MangoQuery = { selector: selectors };\n    if (this.selectSelector) query.fields = this.selectSelector as string[];\n\n    if (this.whereCondition) {\n      const condition: MangoSelector = this.parseCondition(\n        Condition.and(\n          this.whereCondition,\n          Condition.attribute<M>(CouchDBKeys.TABLE as keyof M).eq(\n            query.selector[CouchDBKeys.TABLE]\n          )\n        )\n      ).selector;\n      const selectorKeys = Object.keys(condition) as MangoOperator[];\n      if (\n        selectorKeys.length === 1 &&\n        Object.values(CouchDBGroupOperator).indexOf(selectorKeys[0]) !== -1\n      )\n        switch (selectorKeys[0]) {\n          case CouchDBGroupOperator.AND:\n            condition[CouchDBGroupOperator.AND] = [\n              ...Object.values(\n                condition[CouchDBGroupOperator.AND] as MangoSelector\n              ).reduce((accum: MangoSelector[], val: any) => {\n                const keys = Object.keys(val);\n                if (keys.length !== 1)\n                  throw new Error(\n                    \"Too many keys in query selector. should be one\"\n                  );\n                const k = keys[0];\n                if (k === CouchDBGroupOperator.AND)\n                  accum.push(...(val[k] as any[]));\n                else accum.push(val);\n                return accum;\n              }, []),\n            ];\n            query.selector = condition;\n            break;\n          case CouchDBGroupOperator.OR: {\n            const s: Record<any, any> = {};\n            s[CouchDBGroupOperator.AND] = [\n              condition,\n              ...Object.entries(query.selector).map(([key, val]) => {\n                const result: Record<any, any> = {};\n                result[key] = val;\n                return result;\n              }),\n            ];\n            query.selector = s;\n            break;\n          }\n          default:\n            throw new Error(\"This should be impossible\");\n        }\n      else {\n        Object.entries(condition).forEach(([key, val]) => {\n          if (query.selector[key])\n            log.warn(\n              `A ${key} query param is about to be overridden: ${query.selector[key]} by ${val}`\n            );\n          query.selector[key] = val;\n        });\n      }\n    }\n\n    if (this.orderBySelectors?.length) {\n      query.sort = query.sort || [];\n      query.selector = query.selector || ({} as MangoSelector);\n      for (const [selectorKey, direction] of this.orderBySelectors) {\n        const selector = selectorKey as string;\n        const rec: Record<string, OrderDirection> = {};\n        rec[selector] = direction as OrderDirection;\n        (query.sort as Record<string, OrderDirection>[]).push(rec);\n        if (!query.selector[selector]) {\n          query.selector[selector] = {} as MangoSelector;\n          (query.selector[selector] as MangoSelector)[CouchDBOperator.BIGGER] =\n            null;\n        }\n      }\n    }\n\n    if (this.limitSelector) {\n      query.limit = this.limitSelector;\n    } else {\n      log.warn(\n        `No limit selector defined. Using default couchdb limit of ${CouchDBQueryLimit}`\n      );\n      query.limit = CouchDBQueryLimit;\n    }\n\n    if (this.offsetSelector) query.skip = this.offsetSelector;\n\n    return query;\n  }\n\n  /**\n   * @description Parses a condition into a CouchDB Mango query selector\n   * @summary Converts a Condition object into a CouchDB Mango query selector structure\n   */\n  protected override parseCondition(condition: Condition<M>): MangoQuery {\n    function merge(\n      op: MangoOperator,\n      obj1: MangoSelector,\n      obj2: MangoSelector\n    ): MangoQuery {\n      const result: MangoQuery = { selector: {} as MangoSelector };\n      result.selector[op] = [obj1, obj2];\n      return result;\n    }\n\n    const { attr1, operator, comparison } = condition as unknown as {\n      attr1: string | Condition<M>;\n      operator: Operator | GroupOperator;\n      comparison: any;\n    };\n\n    if (operator === Operator.STARTS_WITH) {\n      if (typeof attr1 !== \"string\")\n        throw new QueryError(\"STARTS_WITH requires an attribute name\");\n      if (typeof comparison !== \"string\")\n        throw new QueryError(\"STARTS_WITH requires a string comparison\");\n      const range = prefixRange(comparison);\n      const selector: MangoSelector = {} as MangoSelector;\n      selector[attr1] = {} as MangoSelector;\n      (selector[attr1] as MangoSelector)[CouchDBOperator.BIGGER_EQ] = range.start;\n      (selector[attr1] as MangoSelector)[CouchDBOperator.SMALLER] = range.end;\n      return { selector };\n    }\n\n    if (operator === Operator.ENDS_WITH) {\n      if (typeof attr1 !== \"string\")\n        throw new QueryError(\"ENDS_WITH requires an attribute name\");\n      if (typeof comparison !== \"string\")\n        throw new QueryError(\"ENDS_WITH requires a string comparison\");\n      const selector: MangoSelector = {} as MangoSelector;\n      selector[attr1] = {\n        [CouchDBOperator.REGEXP]: `${escapeRegExp(comparison)}$`,\n      } as MangoSelector;\n      return { selector };\n    }\n\n    if (operator === Operator.BETWEEN) {\n      const attr = attr1 as string;\n      if (!Array.isArray(comparison) || comparison.length !== 2)\n        throw new QueryError(\"BETWEEN operator requires [min, max] comparison\");\n      const [min, max] = comparison;\n      const opBetween: MangoSelector = {} as MangoSelector;\n      opBetween[attr] = {} as MangoSelector;\n      (opBetween[attr] as MangoSelector)[\n        translateOperators(Operator.BIGGER_EQ)\n      ] = min;\n      (opBetween[attr] as MangoSelector)[\n        translateOperators(Operator.SMALLER_EQ)\n      ] = max;\n      return { selector: opBetween };\n    }\n\n    let op: MangoSelector = {} as MangoSelector;\n    if (\n      [GroupOperator.AND, GroupOperator.OR, Operator.NOT].indexOf(\n        operator as GroupOperator\n      ) === -1\n    ) {\n      op[attr1 as string] = {} as MangoSelector;\n      (op[attr1 as string] as MangoSelector)[translateOperators(operator)] =\n        comparison;\n    } else if (operator === Operator.NOT) {\n      op = this.parseCondition(attr1 as Condition<M>).selector as MangoSelector;\n      op[translateOperators(Operator.NOT)] = {} as MangoSelector;\n      (op[translateOperators(Operator.NOT)] as MangoSelector)[\n        (attr1 as unknown as { attr1: string }).attr1\n      ] = comparison;\n    } else {\n      const op1: any = this.parseCondition(attr1 as Condition<M>).selector;\n      const op2: any = this.parseCondition(comparison as Condition<M>).selector;\n      op = merge(translateOperators(operator), op1, op2).selector;\n    }\n\n    return { selector: op };\n  }\n\n  /**\n   * @description Builds an aggregate query if aggregation is requested\n   * @summary Checks for aggregate operations and returns a special MangoQuery for them\n   */\n  private buildAggregateQuery(): MangoQuery | undefined {\n    if (!this.fromSelector) return undefined;\n    if (this.avgSelector) {\n      const attribute = String(this.avgSelector);\n      const sumInfo = this.createAggregateDescriptor(\"sum\", attribute);\n      const countInfo = this.createAggregateDescriptor(\"count\", attribute);\n      if (!sumInfo || !countInfo)\n        throw new QueryError(\n          `Avg operation requires sum and count views for attribute ${attribute}`\n        );\n      return this.createAggregateQuery({\n        kind: \"avg\",\n        attribute,\n        sumDescriptor: sumInfo.descriptor,\n        countDescriptor: countInfo.descriptor,\n      });\n    }\n\n    if (typeof this.countDistinctSelector !== \"undefined\") {\n      const attribute =\n        this.countDistinctSelector == null\n          ? undefined\n          : String(this.countDistinctSelector);\n      const info = this.createAggregateDescriptor(\"distinct\", attribute);\n      if (info) {\n        info.countDistinct = true;\n        return this.createAggregateQuery(info);\n      }\n    }\n\n    const aggregatorUsed =\n      typeof this.countSelector !== \"undefined\" ||\n      typeof this.countDistinctSelector !== \"undefined\" ||\n      !!this.minSelector ||\n      !!this.maxSelector ||\n      !!this.sumSelector ||\n      !!this.distinctSelector;\n\n    const aggregatorChecks: Array<[ViewKind, SelectSelector<M> | undefined]> = [\n      [\n        \"count\",\n        (this.countSelector ?? undefined) as SelectSelector<M> | undefined,\n      ],\n      [\"max\", this.maxSelector],\n      [\"min\", this.minSelector],\n      [\"sum\", this.sumSelector],\n      [\"distinct\", this.distinctSelector],\n    ];\n\n    for (const [kind, selector] of aggregatorChecks) {\n      const attribute = selector ? String(selector) : undefined;\n      const info = this.createAggregateDescriptor(kind, attribute);\n      if (info) return this.createAggregateQuery(info);\n    }\n\n    if (aggregatorUsed) {\n      throw new QueryError(\n        `No CouchDB view metadata found for table ${Model.tableName(\n          this.fromSelector\n        )} aggregator`\n      );\n    }\n    return undefined;\n  }\n\n  /**\n   * @description Creates an aggregate descriptor for a view-based aggregation\n   */\n  private createAggregateDescriptor(\n    kind: ViewKind,\n    attribute?: string\n  ): Extract<FabricAggregateInfo, { kind: ViewKind }> | undefined {\n    if (!this.fromSelector) return undefined;\n    const metas = findViewMetadata(this.fromSelector, kind, attribute);\n    if (!metas.length) return undefined;\n    const meta = metas[0];\n    const tableName = Model.tableName(this.fromSelector);\n    const viewName = generateViewName(tableName, meta.attribute, kind, meta);\n    const ddoc = meta.ddoc || generateDesignDocName(tableName, viewName);\n    const options: Record<string, any> = {\n      reduce: meta.reduce !== undefined ? true : !meta.returnDocs,\n    };\n    if (kind === \"distinct\" || kind === \"groupBy\") options.group = true;\n    return {\n      kind,\n      meta,\n      descriptor: {\n        ddoc,\n        view: viewName,\n        options,\n      },\n    };\n  }\n\n  /**\n   * @description Creates the special aggregate MangoQuery marker\n   */\n  private createAggregateQuery(\n    info: FabricAggregateInfo\n  ): MangoQuery & { aggregate: true; aggregateInfo: FabricAggregateInfo } {\n    return {\n      selector: {},\n      aggregate: true,\n      aggregateInfo: info,\n    } as MangoQuery & { aggregate: true; aggregateInfo: FabricAggregateInfo };\n  }\n\n  /**\n   * @description Gets the adapter cast to FabricClientAdapter for view access\n   */\n  private getFabricAdapter(): FabricClientAdapter {\n    return this.adapter as FabricClientAdapter;\n  }\n\n  /**\n   * @description Executes an aggregate query via adapter's view method\n   */\n  private async executeAggregate<R>(\n    info: FabricAggregateInfo,\n    ctx: Context<FabricClientFlags>\n  ): Promise<R> {\n    if (!this.isViewAggregate(info)) {\n      return this.handleAverage<R>(info, ctx);\n    }\n    const fabricAdapter = this.getFabricAdapter();\n    const viewInfo = info as Extract<FabricAggregateInfo, { kind: ViewKind }>;\n    const response = await fabricAdapter.view<ViewResponse>(\n      viewInfo.descriptor.ddoc,\n      viewInfo.descriptor.view,\n      viewInfo.descriptor.options,\n      ctx\n    );\n    return this.processViewResponse<R>(info, response);\n  }\n\n  /**\n   * @description Handles average calculation from sum and count views\n   */\n  private async handleAverage<R>(\n    info: FabricAggregateInfo,\n    ctx: Context<FabricClientFlags>\n  ): Promise<R> {\n    if (info.kind !== \"avg\")\n      throw new QueryError(\"Average descriptor is not valid\");\n    const fabricAdapter = this.getFabricAdapter();\n    const [sumDesc, countDesc] = [info.sumDescriptor, info.countDescriptor];\n    const [sumResponse, countResponse] = await Promise.all([\n      fabricAdapter.view<ViewResponse>(\n        sumDesc.ddoc,\n        sumDesc.view,\n        sumDesc.options,\n        ctx\n      ),\n      fabricAdapter.view<ViewResponse>(\n        countDesc.ddoc,\n        countDesc.view,\n        countDesc.options,\n        ctx\n      ),\n    ]);\n    const sum = sumResponse.rows?.[0]?.value ?? 0;\n    const count = countResponse.rows?.[0]?.value ?? 0;\n    if (!count) return 0 as unknown as R;\n    return (sum / count) as unknown as R;\n  }\n\n  /**\n   * @description Processes the view response based on aggregate kind\n   */\n  private processViewResponse<R>(\n    info: FabricAggregateInfo,\n    response: ViewResponse\n  ): R {\n    if (info.kind === \"avg\")\n      throw new QueryError(\n        \"Average results should be handled before processing rows\"\n      );\n    const rows = response.rows || [];\n    const viewInfo = info as Extract<FabricAggregateInfo, { kind: ViewKind }>;\n    const meta = viewInfo.meta;\n    if (viewInfo.countDistinct) {\n      return (rows.length || 0) as unknown as R;\n    }\n    if (viewInfo.kind === \"distinct\" || viewInfo.kind === \"groupBy\") {\n      return rows.map((row) => row.key ?? row.value) as unknown as R;\n    }\n    if (meta.returnDocs) {\n      return rows.map((row) => row.value ?? row.doc ?? row) as unknown as R;\n    }\n    if (!rows.length) {\n      return (viewInfo.kind === \"count\" ? 0 : null) as unknown as R;\n    }\n    return (rows[0].value ?? rows[0].key ?? null) as unknown as R;\n  }\n\n  /**\n   * @description Type guard to check if info is a view-based aggregate\n   */\n  private isViewAggregate(\n    info: FabricAggregateInfo\n  ): info is Extract<FabricAggregateInfo, { kind: ViewKind }> {\n    return info.kind !== \"avg\";\n  }\n}\n","import \"../shared/overrides\";\nimport {\n  CouchDBKeys,\n  type MangoQuery,\n  type ViewResponse,\n} from \"@decaf-ts/for-couchdb\";\nimport { Client } from \"@grpc/grpc-js\";\nimport * as grpc from \"@grpc/grpc-js\";\nimport {\n  Model,\n  type ModelConstructor,\n  type Serializer,\n} from \"@decaf-ts/decorator-validation\";\nimport { debug, final, Logging } from \"@decaf-ts/logging\";\nimport {\n  type PeerConfig,\n  type SegregatedModel,\n  type MspDetails,\n} from \"../shared/types\";\nimport {\n  connect,\n  type ConnectOptions,\n  Gateway,\n  Network,\n  ProposalOptions,\n  Contract as Contrakt,\n  type Signer,\n  GatewayError,\n  EndorseError,\n} from \"@hyperledger/fabric-gateway\";\nimport { Gateway as LegacyGateway, Wallets } from \"fabric-network\";\nimport type { Endorser } from \"fabric-common\";\nimport {\n  getIdentity,\n  getSigner,\n  getFirstDirFileNameContent,\n  readFile as readFsFile,\n} from \"./fabric-fs\";\nimport {\n  BaseError,\n  InternalError,\n  OperationKeys,\n  SerializationError,\n  BulkCrudOperationKeys,\n  NotFoundError,\n  ConflictError,\n  BadRequestError,\n  type PrimaryKeyType,\n  ValidationError,\n} from \"@decaf-ts/db-decorators\";\nimport {\n  Context,\n  Adapter,\n  type AdapterFlags,\n  AuthorizationError,\n  ConnectionError,\n  ForbiddenError,\n  MigrationError,\n  ObserverError,\n  PagingError,\n  PersistenceKeys,\n  QueryError,\n  Repository,\n  UnsupportedError,\n  Statement,\n  type PreparedStatement,\n  Paginator,\n  MaybeContextualArg,\n  ContextualArgs,\n  type PreparedModel,\n  AllOperationKeys,\n} from \"@decaf-ts/core\";\nimport { FabricFlavour } from \"../shared/constants\";\nimport { ClientSerializer } from \"../shared/ClientSerializer\";\nimport { FabricClientDispatch } from \"./FabricClientDispatch\";\n// import { HSMSignerFactoryCustom } from \"./fabric-hsm\";\nimport { type Constructor } from \"@decaf-ts/decoration\";\nimport { FabricClientStatement } from \"./FabricClientStatement\";\nimport { FabricClientPaginator } from \"./FabricClientPaginator\";\nimport { FabricClientRepository } from \"./FabricClientRepository\";\nimport {\n  EndorsementError,\n  EndorsementPolicyError,\n  MvccReadConflictError,\n  PhantomReadConflictError,\n  TransactionTimeoutError,\n} from \"../shared/errors\";\nimport { FabricClientFlags } from \"./types\";\nimport { DefaultFabricClientFlags } from \"./constants\";\nimport fs from \"fs\";\nimport { CryptoUtils } from \"./crypto\";\nimport { extractIds } from \"./ids/id-extraction\";\nimport { Identity } from \"../shared/index\";\n\ntype LegacyPeerTarget = {\n  mspId: string;\n  peerEndpoint: string;\n  peerHostAlias?: string;\n  tlsCert?: string | Buffer;\n};\n\ntype LegacyPeerWithName = LegacyPeerTarget & { name: string };\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 Adapter<\n  PeerConfig,\n  Client,\n  MangoQuery,\n  Context<FabricClientFlags>\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  protected static log = Logging.for(FabricClientAdapter);\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(\n      Object.assign({}, DefaultFabricClientFlags, config),\n      FabricFlavour,\n      alias\n    );\n  }\n\n  override Statement<M extends Model>(\n    overrides?: Partial<AdapterFlags>\n  ): Statement<M, FabricClientAdapter, any, MangoQuery> {\n    return new FabricClientStatement(this, overrides);\n  }\n\n  Paginator<M extends Model>(\n    query: PreparedStatement<any> | MangoQuery,\n    size: number,\n    clazz: Constructor<M>\n  ): Paginator<M, any, MangoQuery> {\n    return new FabricClientPaginator(this, query, size, clazz);\n  }\n\n  protected override async flags<M extends Model>(\n    operation: OperationKeys | string,\n    model: Constructor<M> | Constructor<M>[] | undefined,\n    flags: Partial<FabricClientFlags>,\n    ...args: any[]\n  ): Promise<FabricClientFlags> {\n    const mergedFlags = Object.assign({}, this.config, flags);\n    const f = Object.assign(\n      await super.flags(operation, model, mergedFlags, ...args)\n    );\n    return f;\n  }\n\n  override async context<M extends Model>(\n    operation: ((...args: any[]) => any) | AllOperationKeys,\n    overrides: Partial<FabricClientFlags>,\n    model: Constructor<M> | Constructor<M>[],\n    ...args: MaybeContextualArg<Context<any>>\n  ): Promise<Context<FabricClientFlags>> {\n    const log = this.log.for(this.context);\n    log.silly(\n      `creating new context for ${operation} operation on ${model ? (Array.isArray(model) ? model.map((m) => Model.tableName(m)) : Model.tableName(model)) : \"no\"} table ${overrides && Object.keys(overrides) ? Object.keys(overrides).length : \"no\"} with flag overrides`\n    );\n    let ctx = args.pop();\n    if (typeof ctx !== \"undefined\" && !(ctx instanceof Context)) {\n      args.push(ctx);\n      ctx = undefined;\n    }\n\n    overrides = ctx\n      ? Object.assign({}, ctx.toOverrides(), overrides)\n      : overrides;\n    const flags = await this.flags(\n      typeof operation === \"string\" ? operation : operation.name,\n      model,\n      overrides as Partial<FabricClientFlags>,\n      ...[...args, ctx].filter(Boolean)\n    );\n\n    if (ctx) {\n      if (!(ctx instanceof this.Context)) {\n        const newCtx = new this.Context().accumulate({\n          ...ctx[\"cache\"],\n          ...flags,\n          parentContext: ctx,\n        }) as any;\n        ctx.accumulate({\n          childContexts: [\n            ...(ctx.getOrUndefined(\"childContexts\") || []),\n            newCtx,\n          ],\n        });\n        return newCtx;\n      }\n      const currentOp = ctx.getOrUndefined(\"operation\");\n      const currentModel = ctx.getOrUndefined(\"affectedTables\");\n      if (\n        !currentOp ||\n        currentOp !== operation ||\n        (model && model !== currentModel)\n      ) {\n        const newCtx = new this.Context().accumulate({\n          ...ctx[\"cache\"],\n          ...flags,\n          parentContext: ctx,\n        }) as any;\n\n        ctx.accumulate({\n          childContexts: [\n            ...(ctx.getOrUndefined(\"childContexts\") || []),\n            newCtx,\n          ],\n        });\n        return newCtx;\n      }\n      return ctx.accumulate(flags) as any;\n    }\n\n    return new this.Context().accumulate({\n      ...flags,\n    }) as any;\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<\n    R extends Repository<\n      any,\n      Adapter<PeerConfig, Client, MangoQuery, Context<FabricClientFlags>>\n    >,\n  >(): Constructor<R> {\n    return FabricClientRepository as unknown as Constructor<R>;\n  }\n\n  protected createPrefix<M extends Model>(\n    clazz: Constructor<M>,\n    id: PrimaryKeyType,\n    model: Record<string, any>,\n    ...args: MaybeContextualArg<Context<FabricClientFlags>>\n  ): [Constructor<M>, PrimaryKeyType, Record<string, any>, ...any[], Context] {\n    const { ctxArgs } = this.logCtx(args, this.createPrefix);\n    const tableName = Model.tableName(clazz);\n    const record: Record<string, any> = {};\n    record[CouchDBKeys.TABLE] = tableName;\n    Object.assign(record, model);\n    return [clazz, id, record, ...ctxArgs];\n  }\n\n  /**\n   * @description Prepares multiple records for creation\n   * @summary Adds necessary CouchDB fields to multiple records before creation\n   * @param {string} tableName - The name of the table\n   * @param {string[]|number[]} ids - The IDs of the records\n   * @param models - The models to prepare\n   * @return A tuple containing the tableName, ids, and prepared records\n   * @throws {InternalError} If ids and models arrays have different lengths\n   */\n  protected createAllPrefix<M extends Model>(\n    clazz: Constructor<M>,\n    ids: string[] | number[],\n    models: Record<string, any>[],\n    ...args: MaybeContextualArg<Context<FabricClientFlags>>\n  ) {\n    const tableName = Model.tableName(clazz);\n    if (ids.length !== models.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n    const { ctxArgs } = this.logCtx(args, this.createAllPrefix);\n    const records = ids.map((id, count) => {\n      const record: Record<string, any> = {};\n      record[CouchDBKeys.TABLE] = tableName;\n      Object.assign(record, models[count]);\n      return record;\n    });\n    return [clazz, ids, records, ...ctxArgs];\n  }\n\n  protected updateAllPrefix<M extends Model>(\n    clazz: Constructor<M>,\n    ids: PrimaryKeyType[],\n    models: Record<string, any>[],\n    ...args: MaybeContextualArg<Context<FabricClientFlags>>\n  ) {\n    const tableName = Model.tableName(clazz);\n    if (ids.length !== models.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n    const { ctxArgs } = this.logCtx(args, this.updateAllPrefix);\n    const records = ids.map(() => {\n      const record: Record<string, any> = {};\n      record[CouchDBKeys.TABLE] = tableName;\n      return record;\n    });\n    return [clazz, ids, records, ...ctxArgs];\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<M extends Model>(\n    clazz: Constructor<M>,\n    ids: PrimaryKeyType[],\n    models: Record<string, any>[],\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<Record<string, any>[]> {\n    if (ids.length !== models.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n    //HERE!\n    const ctxArgs = [...(args as unknown as any[])];\n    const transient = ctxArgs.shift() as Record<string, any>;\n    const { log, ctx } = this.logCtx(\n      ctxArgs as ContextualArgs<Context<FabricClientFlags>>,\n      this.createAll\n    );\n    const tableName = Model.tableName(clazz);\n\n    log.info(`adding ${ids.length} entries to ${tableName} table`);\n    log.verbose(`pks: ${ids}`);\n    const hasTransient = transient && Object.keys(transient).length > 0;\n    const needsFullPayload =\n      hasTransient || this.shouldForceGatewayHydration(ctx);\n    const transientPayload = hasTransient ? { [tableName]: transient } : {};\n\n    const result = await this.submitTransaction(\n      ctx,\n      BulkCrudOperationKeys.CREATE_ALL,\n      [\n        JSON.stringify(\n          models.map((m) => this.serializer.serialize(m, clazz.name))\n        ),\n      ],\n      transientPayload as any,\n      this.getEndorsingOrganizations(ctx),\n      clazz.name\n    );\n\n    let res: Record<string, any>[];\n    try {\n      res = 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    if (\n      this.shouldRefreshAfterWrite(\n        clazz,\n        ctx,\n        needsFullPayload,\n        res[0][Model.pk(clazz) as string] || ids[0]\n      )\n    ) {\n      return this.readAll(\n        clazz,\n        extractIds(\n          clazz,\n          models.map((m, i) =>\n            Model.merge(Object.assign({}, m as any, transient[i] || {}), res[i])\n          ),\n          ids\n        ),\n        ctx\n      );\n    }\n\n    return res;\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<M extends Model>(\n    clazz: Constructor<M>,\n    ids: PrimaryKeyType[],\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<Record<string, any>[]> {\n    const { log, ctx } = this.logCtx(args, this.readAll);\n    const tableName = Model.tableName(clazz);\n    log.info(`reading ${ids.length} entries to ${tableName} table`);\n    log.verbose(`pks: ${ids}`);\n    const result = await this.evaluateTransaction(\n      ctx,\n      BulkCrudOperationKeys.READ_ALL,\n      [JSON.stringify(ids)],\n      undefined,\n      undefined,\n      clazz.name\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<M extends Model>(\n    clazz: Constructor<M>,\n    ids: PrimaryKeyType[],\n    models: Record<string, any>[],\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<Record<string, any>[]> {\n    if (ids.length !== models.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n    const ctxArgs = [...(args as unknown as any[])];\n    const transient = ctxArgs.shift() as Record<string, any>;\n    const { log, ctx } = this.logCtx(\n      ctxArgs as ContextualArgs<Context<FabricClientFlags>>,\n      this.updateAll\n    );\n    const tableName = Model.tableName(clazz);\n    log.info(`updating ${ids.length} entries to ${tableName} table`);\n    log.verbose(`pks: ${ids}`);\n    const hasTransient = transient && Object.keys(transient).length > 0;\n    const needsFullPayload =\n      hasTransient || this.shouldForceGatewayHydration(ctx);\n    const transientPayload = hasTransient ? { [tableName]: transient } : {};\n\n    const result = await this.submitTransaction(\n      ctx,\n      BulkCrudOperationKeys.UPDATE_ALL,\n      [\n        JSON.stringify(\n          models.map((m) => this.serializer.serialize(m, clazz.name))\n        ),\n      ],\n      transientPayload as any,\n      this.getEndorsingOrganizations(ctx),\n      clazz.name\n    );\n\n    let res: any;\n    try {\n      res = 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    if (this.shouldRefreshAfterWrite(clazz, ctx, needsFullPayload, ids[0])) {\n      return this.readAll(\n        clazz,\n        extractIds(\n          clazz,\n          models.map((m, i) =>\n            Model.merge(Object.assign({}, m as any, transient[i] || {}), res[i])\n          ),\n          ids\n        ),\n        ctx\n      );\n    }\n    return res;\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<M extends Model>(\n    clazz: Constructor<M>,\n    ids: PrimaryKeyType[],\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<Record<string, any>[]> {\n    const { log, ctx, ctxArgs } = this.logCtx(args, this.deleteAll);\n    const tableName = Model.tableName(clazz);\n\n    const needsFullPayload =\n      Model.isTransient(clazz) || this.shouldForceGatewayHydration(ctx);\n    let result: any;\n    const shouldHydrate = this.shouldRefreshAfterWrite(\n      clazz,\n      ctx,\n      needsFullPayload,\n      ids[0]\n    );\n    if (shouldHydrate) {\n      result = await this.readAll(clazz, ids, ...ctxArgs);\n    }\n\n    log.info(`deleting ${ids.length} entries to ${tableName} table`);\n    log.verbose(`pks: ${ids}`);\n    const res = await this.submitTransaction(\n      ctx,\n      BulkCrudOperationKeys.DELETE_ALL,\n      [JSON.stringify(ids)],\n      undefined,\n      this.getEndorsingOrganizations(ctx),\n      clazz.name\n    );\n    try {\n      return shouldHydrate\n        ? result\n        : JSON.parse(this.decode(res)).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    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): SegregatedModel<M> & PreparedModel {\n    const { log, ctx } = this.logCtx(args, this.prepare);\n    const split = Model.segregate(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    const mirrorMeta = Model.mirroredAt(model);\n    if (mirrorMeta) {\n      const mirrorMsp = mirrorMeta.mspId;\n      if (!mirrorMsp) throw new InternalError(`No mirror MSP could be found`);\n      let msps = this.getEndorsingOrganizations(ctx) || [];\n      msps = Array.isArray(msps) ? msps : [msps];\n      const merged = [...new Set([...msps, mirrorMsp])];\n      ctx.accumulate({\n        endorsingOrgs: merged,\n        endorsingOrganizations: merged,\n        legacy: true,\n      });\n    }\n\n    return {\n      record: split.model,\n      model: split.model,\n      id: model[Model.pk(model.constructor as Constructor<M>)] as string,\n      transient: split.transient,\n      privates: split.privates,\n      shared: split.shared,\n    };\n  }\n\n  override revert<M extends Model>(\n    obj: Record<string, any>,\n    clazz: Constructor<M>,\n    id: PrimaryKeyType,\n    transient?: Record<string, any>,\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): M {\n    const { log, ctx } = this.logCtx(args, this.revert);\n    if (\n      transient &&\n      this.shouldRebuildWithTransient(\n        ctx,\n        ctx.getOrUndefined(\"operation\") as string | undefined\n      )\n    ) {\n      log.verbose(\n        `re-adding transient properties: ${Object.keys(transient).join(\", \")}`\n      );\n      Object.entries(transient as Record<string, any>)\n        .filter(([, v]) => typeof v !== \"undefined\")\n        .forEach(([key, val]) => {\n          if (key in obj && (obj as any)[key] !== undefined)\n            log.warn(\n              `overwriting existing ${key}. if this is not a default value, this may pose a problem`\n            );\n          (obj as M)[key as keyof M] = val;\n        });\n    }\n\n    const result = new (clazz as Constructor<M>)(obj);\n\n    return result;\n  }\n\n  private shouldRebuildWithTransient(\n    ctx: Context<FabricClientFlags>,\n    operation?: string\n  ): boolean {\n    if (!ctx) return false;\n    if (ctx.getOrUndefined(\"rebuildWithTransient\")) return true;\n    const childRebuild =\n      typeof (ctx as any).getFromChildren === \"function\"\n        ? (ctx as any).getFromChildren(\"rebuildWithTransient\")\n        : undefined;\n    if (childRebuild) return true;\n    const resolvedOp = this.resolveOperation(ctx, operation);\n    if (!resolvedOp) return false;\n    const op = resolvedOp.toString().toLowerCase();\n    return (\n      op.includes(\"read\") ||\n      op.includes(\"find\") ||\n      op.includes(\"query\") ||\n      op.includes(\"statement\") ||\n      op.includes(\"page\")\n    );\n  }\n\n  private resolveOperation(\n    ctx: Context<FabricClientFlags>,\n    operation?: string\n  ): string | undefined {\n    if (operation) return operation;\n    if (typeof (ctx as any).getFromChildren === \"function\") {\n      return (ctx as any).getFromChildren(\"operation\");\n    }\n    return undefined;\n  }\n\n  private shouldRefreshAfterWrite<M extends Model>(\n    clazz: Constructor<M>,\n    ctx: Context<FabricClientFlags>,\n    hasTransient: boolean,\n    id?: PrimaryKeyType\n  ): boolean {\n    if (!hasTransient) return false;\n    const pk = Model.pk(clazz);\n    const composed = Model.composed(clazz, pk);\n    const generated = Model.generated(clazz, pk);\n    const hasId = id !== undefined && id !== null;\n    if (!hasId && composed) return true;\n    if (!hasId && generated) {\n      ctx.logger.warn(\n        `Cannot refresh record with private generated primary key`\n      );\n      return false;\n    }\n    return hasId;\n  }\n\n  private getEndorsingOrganizations(\n    ctx: Context<FabricClientFlags>\n  ): string[] | undefined {\n    const direct =\n      ctx.getOrUndefined(\"endorsingOrgs\") ||\n      (ctx.getOrUndefined(\"endorsingOrgs\") as string[] | undefined);\n    if (direct && direct.length) return direct;\n    return (\n      (ctx.getFromChildren(\"endorsingOrgs\") as string[] | undefined) ||\n      (ctx.getFromChildren(\"endorsingOrgs\") as string[] | undefined)\n    );\n  }\n\n  private shouldForceGatewayHydration(\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ctx: Context<FabricClientFlags>\n  ): boolean {\n    return !!this.config.allowGatewayOverride;\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()\n  @final()\n  override async create<M extends Model>(\n    clazz: Constructor<M>,\n    id: PrimaryKeyType,\n    model: Record<string, any>,\n    transient: Record<string, any> = {},\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<Record<string, any>> {\n    const ctxArgs = [...(args as unknown as any[])];\n    const { log, ctx } = this.logCtx(\n      ctxArgs as ContextualArgs<Context<FabricClientFlags>>,\n      this.create\n    );\n    const tableName = Model.tableName(clazz);\n    log.verbose(`adding entry to ${tableName} table`);\n    log.debug(`pk: ${id}`);\n    const hasTransient = transient && Object.keys(transient).length > 0;\n    const needsFullPayload =\n      hasTransient || this.shouldForceGatewayHydration(ctx);\n    const transientPayload = hasTransient ? { [tableName]: transient } : {};\n    const result = await this.submitTransaction(\n      ctx,\n      OperationKeys.CREATE,\n      [this.serializer.serialize(model, clazz.name)],\n      transientPayload as any,\n      this.getEndorsingOrganizations(ctx),\n      clazz.name\n    );\n    const deserialized = this.serializer.deserialize(this.decode(result));\n    if (this.shouldRefreshAfterWrite(clazz, ctx, needsFullPayload, id)) {\n      return this.read(\n        clazz,\n        extractIds(\n          clazz,\n          Model.merge(\n            Object.assign({}, model, transient || {}),\n            deserialized,\n            clazz\n          ),\n          id\n        ),\n        ctx\n      );\n    }\n    return deserialized;\n  }\n\n  @debug()\n  @final()\n  async healthcheck<M extends Model>(\n    clazz: Constructor<M>,\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<Record<string, any>> {\n    const { log, ctx } = this.logCtx(args, this.healthcheck);\n    const tableName = Model.tableName(clazz);\n\n    log.verbose(`reading entry from ${tableName} table`);\n    const result = await this.evaluateTransaction(\n      ctx,\n      \"healthcheck\",\n      [],\n      undefined,\n      undefined,\n      clazz.name\n    );\n    return JSON.parse(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()\n  @final()\n  async read<M extends Model>(\n    clazz: Constructor<M>,\n    id: PrimaryKeyType,\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<Record<string, any>> {\n    const { log, ctx } = this.logCtx(args, this.read);\n    const tableName = Model.tableName(clazz);\n\n    log.verbose(`reading entry from ${tableName} table`);\n    log.debug(`pk: ${id}`);\n    const result = await this.evaluateTransaction(\n      ctx,\n      OperationKeys.READ,\n      [id.toString()],\n      undefined,\n      undefined,\n      clazz.name\n    );\n    return this.serializer.deserialize(this.decode(result));\n  }\n\n  updatePrefix<M extends Model>(\n    clazz: Constructor<M>,\n    id: PrimaryKeyType,\n    model: Record<string, any>,\n    ...args: MaybeContextualArg<Context<FabricClientFlags>>\n  ) {\n    const tableName = Model.tableName(clazz);\n    const { ctxArgs } = this.logCtx(args, this.updatePrefix);\n    const record: Record<string, any> = {};\n    record[CouchDBKeys.TABLE] = tableName;\n    // record[CouchDBKeys.ID] = this.generateId(tableName, id);\n    Object.assign(record, model);\n    return [clazz, id, record, ...ctxArgs];\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()\n  @final()\n  async update<M extends Model>(\n    clazz: Constructor<M>,\n    id: PrimaryKeyType,\n    model: Record<string, any>,\n    transient: Record<string, any> = {},\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<Record<string, any>> {\n    const ctxArgs = [...(args as unknown as any[])];\n    const { log, ctx } = this.logCtx(\n      ctxArgs as ContextualArgs<Context<FabricClientFlags>>,\n      this.update\n    );\n    log.info(`CLIENT UPDATE class : ${typeof clazz}`);\n    const tableName = Model.tableName(clazz);\n    log.verbose(`updating entry to ${tableName} table`);\n    log.debug(`pk: ${id}`);\n    const hasTransient = transient && Object.keys(transient).length > 0;\n    const needsFullPayload =\n      hasTransient || this.shouldForceGatewayHydration(ctx);\n    const transientPayload = hasTransient ? { [tableName]: transient } : {};\n    const result = await this.submitTransaction(\n      ctx,\n      OperationKeys.UPDATE,\n      [this.serializer.serialize(model, clazz.name || clazz)], // TODO should be receving class but is receiving string\n      transientPayload as any,\n      this.getEndorsingOrganizations(ctx),\n      clazz.name\n    );\n    const deserialized = this.serializer.deserialize(this.decode(result));\n    if (this.shouldRefreshAfterWrite(clazz, ctx, needsFullPayload, id)) {\n      return this.read(\n        clazz,\n        extractIds(\n          clazz,\n          Model.merge(\n            Object.assign({}, model, transient || {}),\n            deserialized,\n            clazz\n          ),\n          id\n        ),\n        ctx\n      );\n    }\n    return deserialized;\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()\n  @final()\n  override async delete<M extends Model>(\n    clazz: Constructor<M>,\n    id: PrimaryKeyType,\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<Record<string, any>> {\n    const { log, ctx } = this.logCtx(args, this.delete);\n    const tableName = Model.tableName(clazz);\n    const needsFullPayload =\n      Model.isTransient(clazz) || this.shouldForceGatewayHydration(ctx);\n    let result: any;\n    const shouldHydrate = this.shouldRefreshAfterWrite(\n      clazz,\n      ctx,\n      needsFullPayload,\n      id\n    );\n    if (shouldHydrate) {\n      result = await this.read(clazz, id, ctx);\n    }\n\n    log.verbose(`deleting entry from ${tableName} table`);\n    log.debug(`pk: ${id}`);\n    const res = await this.submitTransaction(\n      ctx,\n      OperationKeys.DELETE,\n      [id.toString()],\n      undefined,\n      this.getEndorsingOrganizations(ctx),\n      clazz.name\n    );\n    return shouldHydrate\n      ? result\n      : this.serializer.deserialize(this.decode(res));\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()\n  async raw<V, D extends boolean>(\n    rawInput: MangoQuery,\n    docsOnly: D = true as D,\n    clazz: ModelConstructor<any>,\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<V> {\n    const { log, ctx } = this.logCtx(args, this.raw);\n    const tableName = clazz.name;\n    log.info(`Performing raw statement on table ${Model.tableName(clazz)}`);\n    let transactionResult: any;\n    try {\n      transactionResult = await this.evaluateTransaction(\n        ctx,\n        \"raw\",\n        [JSON.stringify(rawInput), docsOnly],\n        undefined,\n        undefined,\n        tableName\n      );\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 Executes a CouchDB view query against the Fabric chaincode\n   * @summary Evaluates a transaction to query a design document view\n   * @template R - The view response type\n   * @param {string} ddoc - Design document name\n   * @param {string} viewName - View name\n   * @param {Record<string, any>} options - View query options\n   * @param {...ContextualArgs<Context<FabricClientFlags>>} args - Optional contextual arguments\n   * @return {Promise<ViewResponse<R>>} The view response\n   */\n  @debug()\n  async view<R>(\n    ddoc: string,\n    viewName: string,\n    options: Record<string, any>,\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<ViewResponse<R>> {\n    const { log, ctx } = this.logCtx(args, this.view);\n    log.info(`Querying view ${ddoc}/${viewName}`);\n    let transactionResult: any;\n    try {\n      transactionResult = await this.evaluateTransaction(\n        ctx,\n        \"view\",\n        [ddoc, viewName, JSON.stringify(options)],\n        undefined,\n        undefined,\n        undefined\n      );\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n    let result: ViewResponse<R>;\n    try {\n      result = JSON.parse(this.decode(transactionResult));\n    } catch (e: any) {\n      throw new SerializationError(`Failed to process view result: ${e}`);\n    }\n    return result;\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(ctx: Context<FabricClientFlags>): Promise<Gateway> {\n    return FabricClientAdapter.getGateway(ctx, this.config, this.client);\n  }\n\n  private getContractName(className?: string) {\n    if (!className) return undefined;\n    return `${className}Contract`;\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(\n    ctx: Context<FabricClientFlags>,\n    contractName?: string\n  ): Promise<Contrakt> {\n    return FabricClientAdapter.getContract(\n      await this.Gateway(ctx),\n      this.config,\n      contractName\n    );\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    ctx: Context<FabricClientFlags>,\n    api: string,\n    submit = true,\n    args?: any[],\n    transientData: Record<string, string> = {},\n    endorsingOrganizations?: string[],\n    className?: string\n  ): Promise<Uint8Array> {\n    const log = this.log.for(this.transaction);\n    const gateway = await this.Gateway(ctx);\n    try {\n      const contract = await this.Contract(\n        ctx,\n        this.getContractName(className)\n      );\n      log.verbose(\n        `${submit ? \"Submit\" : \"Evaluate\"}ting transaction ${this.getContractName(className) || 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      endorsingOrganizations = endorsingOrganizations?.length\n        ? endorsingOrganizations\n        : undefined;\n      const proposalOptions: ProposalOptions = {\n        arguments: args || [],\n        transientData: Object.entries(transientData).reduce(\n          (acc, [key, val]) => {\n            acc[key] = JSON.stringify(val);\n            return acc;\n          },\n          {} as typeof transientData\n        ),\n        endorsingOrganizations: ctx.getOrUndefined(\"allowManualEndorsingOrgs\")\n          ? endorsingOrganizations || undefined\n          : undefined, // mspId list\n      };\n\n      return await method.call(contract, api, proposalOptions);\n    } catch (e: any) {\n      throw this.parseError(e);\n    } finally {\n      this.log.debug(`Closing ${this.config.mspId} gateway connection`);\n      gateway.close();\n    }\n  }\n\n  private shouldUseLegacyGateway(ctx: Context<FabricClientFlags>): boolean {\n    return !!ctx.getOrUndefined(\"legacy\") && !!this.config.allowGatewayOverride;\n  }\n\n  private prepareLegacyArgs(args?: any[]): string[] {\n    return (args || []).map((arg) =>\n      typeof arg === \"string\" ? arg : JSON.stringify(arg)\n    );\n  }\n\n  private buildLegacyTransient(\n    transientData?: Record<string, string>\n  ): Record<string, Buffer> | undefined {\n    if (!transientData) return undefined;\n    const entries = Object.entries(transientData);\n    if (!entries.length) return undefined;\n    const map: Record<string, Buffer> = {};\n    for (const [key, value] of entries) {\n      map[key] = Buffer.from(JSON.stringify(value));\n    }\n    return map;\n  }\n\n  private resolveLegacyMspCount(): number {\n    const configured = this.config.legacyMspCount ?? 1;\n    const parsed = Number(configured);\n    if (!Number.isFinite(parsed) || parsed < 1) return 1;\n    return Math.floor(parsed);\n  }\n\n  private pickLegacyCandidates(\n    candidates: MspDetails[],\n    limit: number\n  ): MspDetails[] {\n    if (!candidates.length || limit <= 0) return [];\n    const available = [...candidates];\n    const target = Math.min(limit, available.length);\n    const picked: MspDetails[] = [];\n    while (picked.length < target && available.length) {\n      const idx = Math.floor(Math.random() * available.length);\n      const [selection] = available.splice(idx, 1);\n      if (selection) {\n        picked.push(selection);\n      }\n    }\n    return picked;\n  }\n\n  private buildLegacyPeerConfigs(\n    ctx: Context<FabricClientFlags>\n  ): LegacyPeerTarget[] {\n    const peers: LegacyPeerTarget[] = [\n      {\n        mspId: this.config.mspId,\n        peerEndpoint: this.config.peerEndpoint,\n        peerHostAlias: this.config.peerHostAlias,\n        tlsCert: this.config.tlsCert,\n      },\n    ];\n\n    let endorsingOrgs = this.getEndorsingOrganizations(ctx) || [];\n    endorsingOrgs = Array.isArray(endorsingOrgs)\n      ? endorsingOrgs\n      : [endorsingOrgs];\n    const endorsers =\n      endorsingOrgs.filter((org): org is string => Boolean(org)) || [];\n    const extras = endorsers.filter((org) => org !== this.config.mspId);\n    if (!extras.length) return peers;\n\n    const map = this.config.mspMap;\n    const legacyCount = this.resolveLegacyMspCount();\n    for (const msp of extras) {\n      const candidates = map?.[msp];\n      if (!candidates?.length) {\n        throw new UnsupportedError(\n          `No peer mapping available for MSP ${msp}. Provide it via config.mspMap`\n        );\n      }\n      const selections = this.pickLegacyCandidates(candidates, legacyCount);\n      if (!selections.length) {\n        throw new UnsupportedError(\n          `No valid peer mapping available for MSP ${msp}. Provide it via config.mspMap`\n        );\n      }\n      for (const choice of selections) {\n        if (!choice.endpoint) {\n          throw new UnsupportedError(\n            `Invalid peer mapping for MSP ${msp}: missing endpoint`\n          );\n        }\n        peers.push({\n          mspId: msp,\n          peerEndpoint: choice.endpoint,\n          peerHostAlias: choice.alias,\n          tlsCert: choice.tlsCert || this.config.tlsCert,\n        });\n      }\n    }\n\n    return peers;\n  }\n\n  private async submitLegacyWithExplicitEndorsers(\n    ctx: Context<FabricClientFlags>,\n    fcn: string,\n    args: string[],\n    transientMap: Record<string, Buffer> | undefined,\n    peerConfigs: LegacyPeerTarget[],\n    className?: string\n  ): Promise<Uint8Array> {\n    const log = this.log.for(this.submitLegacyWithExplicitEndorsers);\n    const peers = this.normalizeLegacyPeers(peerConfigs);\n    const identityMaterial = await this.resolveLegacyIdentityMaterial();\n    const wallet = await Wallets.newInMemoryWallet();\n    const identityLabel = `${this.config.mspId}-legacy`;\n    await wallet.put(identityLabel, {\n      credentials: {\n        certificate: identityMaterial.certificate,\n        privateKey: identityMaterial.privateKey,\n      },\n      mspId: this.config.mspId,\n      type: \"X.509\",\n    } as Identity);\n\n    const connectionProfile = await this.buildLegacyConnectionProfile(peers);\n    const gateway = new LegacyGateway();\n\n    try {\n      await gateway.connect(connectionProfile, {\n        identity: identityLabel,\n        wallet,\n        discovery: {\n          enabled: true,\n          asLocalhost: this.shouldTreatPeersAsLocalhost(peers),\n        },\n        tlsInfo: {\n          certificate: identityMaterial.certificate,\n          key: identityMaterial.privateKey,\n        },\n      });\n\n      const network = await gateway.getNetwork(this.config.channel);\n      const contract = network.getContract(\n        this.config.chaincodeName,\n        this.getContractName(className)\n      );\n      const transaction = contract.createTransaction(fcn);\n\n      if (transientMap) {\n        transaction.setTransient(transientMap);\n      }\n\n      const endorsers = peers\n        .map((peer) => network.getChannel().getEndorser(peer.name))\n        .filter((endorser): endorser is Endorser => Boolean(endorser));\n      if (endorsers.length) {\n        transaction.setEndorsingPeers(endorsers);\n      }\n\n      log.verbose(\n        `Legacy submitting ${this.getContractName(className) || this.config.contractName}.${fcn} via peers ${peers.map((p) => p.peerEndpoint).join(\", \")}`\n      );\n\n      const result = await transaction.submit(...args);\n      return Uint8Array.from(result);\n    } catch (e: any) {\n      throw this.parseError(e);\n    } finally {\n      gateway.disconnect();\n    }\n  }\n\n  private normalizeLegacyPeers(\n    peers: LegacyPeerTarget[]\n  ): LegacyPeerWithName[] {\n    const deduped = new Map<string, LegacyPeerWithName>();\n    const addPeer = (peer: LegacyPeerTarget) => {\n      const key = `${peer.peerEndpoint}|${peer.peerHostAlias || \"\"}`;\n      if (deduped.has(key)) return;\n      const name = `peer-${peer.mspId}-${deduped.size}`;\n      deduped.set(key, {\n        ...peer,\n        name,\n      });\n    };\n\n    peers.forEach(addPeer);\n    addPeer({\n      mspId: this.config.mspId,\n      peerEndpoint: this.config.peerEndpoint,\n      peerHostAlias: this.config.peerHostAlias,\n    });\n\n    return Array.from(deduped.values());\n  }\n\n  private async resolveLegacyIdentityMaterial(): Promise<{\n    certificate: string;\n    privateKey: string;\n  }> {\n    const certificate = await this.readPemInput(\n      this.config.certCertOrDirectoryPath\n    );\n    const privateKey = await this.readPemInput(\n      this.config.keyCertOrDirectoryPath\n    );\n    return { certificate, privateKey };\n  }\n\n  private async buildLegacyConnectionProfile(peers: LegacyPeerWithName[]) {\n    const peerEntries: Record<string, any> = {};\n    const channelPeers: Record<string, any> = {};\n    const orgs: Record<string, any> = {};\n    for (const peer of peers) {\n      const tlsPem = await this.readPemInput(\n        peer.tlsCert || this.config.tlsCert\n      );\n      const hostname =\n        peer.peerHostAlias || this.extractHost(peer.peerEndpoint);\n      peerEntries[peer.name] = {\n        url: this.ensureGrpcUrl(peer.peerEndpoint),\n        tlsCACerts: { pem: tlsPem },\n        grpcOptions: {\n          \"ssl-target-name-override\": hostname,\n          hostnameOverride: hostname,\n        },\n      };\n      channelPeers[peer.name] = {\n        endorsingPeer: true,\n        chaincodeQuery: true,\n        ledgerQuery: true,\n        eventSource: true,\n      };\n      orgs[peer.mspId] = orgs[peer.mspId] || {\n        mspid: peer.mspId,\n        peers: [],\n      };\n      orgs[peer.mspId].peers.push(peer.name);\n    }\n\n    return {\n      name: \"legacy-manual\",\n      version: \"1.0.0\",\n      client: {\n        organization: this.config.mspId,\n      },\n      organizations: orgs,\n      peers: peerEntries,\n      orderers: {},\n      channels: {\n        [this.config.channel]: {\n          peers: channelPeers,\n        },\n      },\n    };\n  }\n\n  private shouldTreatPeersAsLocalhost(peers: LegacyPeerWithName[]): boolean {\n    return peers.every((peer) => this.isLocalEndpoint(peer.peerEndpoint));\n  }\n\n  private isLocalEndpoint(endpoint: string): boolean {\n    const host = this.extractHost(endpoint).toLowerCase();\n    return host === \"localhost\" || host === \"127.0.0.1\";\n  }\n\n  private extractHost(endpoint: string): string {\n    const sanitized = endpoint.replace(/^grpcs?:\\/\\//, \"\");\n    return sanitized.split(\":\")[0];\n  }\n\n  private ensureGrpcUrl(endpoint: string): string {\n    if (/^grpcs?:\\/\\//i.test(endpoint)) return endpoint;\n    return `grpcs://${endpoint}`;\n  }\n\n  private async readPemInput(source?: string | Buffer): Promise<string> {\n    if (!source) throw new InternalError(\"Missing certificate or key material\");\n    if (Buffer.isBuffer(source)) return source.toString(\"utf8\");\n    const trimmed = source.trim();\n    if (/-----BEGIN [A-Z ]+-----/.test(trimmed)) return trimmed;\n    const stats = await fs.promises.stat(source).catch(() => undefined);\n    if (stats?.isDirectory()) {\n      return await getFirstDirFileNameContent(source);\n    }\n    return (await readFsFile(source)).toString();\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<E extends BaseError>(err: Error | string): E {\n    return FabricClientAdapter.parseError<E>(err);\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    ctx: Context<FabricClientFlags>,\n    api: string,\n    args?: any[],\n    transientData?: Record<string, string>,\n    endorsingOrganizations?: Array<string>,\n    className?: string\n  ): Promise<Uint8Array> {\n    if (this.shouldUseLegacyGateway(ctx)) {\n      const legacyArgs = this.prepareLegacyArgs(args);\n      const transientMap = this.buildLegacyTransient(transientData);\n      const peerConfigs = this.buildLegacyPeerConfigs(ctx);\n      return this.submitLegacyWithExplicitEndorsers(\n        ctx,\n        api,\n        legacyArgs,\n        transientMap,\n        peerConfigs,\n        className\n      );\n    }\n    return this.transaction(\n      ctx,\n      api,\n      true,\n      args,\n      transientData,\n      endorsingOrganizations,\n      className\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    ctx: Context<FabricClientFlags>,\n    api: string,\n    args?: any[],\n    transientData?: Record<string, string>,\n    endorsingOrganizations?: Array<string>,\n    className?: string\n  ): Promise<Uint8Array> {\n    return this.transaction(\n      ctx,\n      api,\n      false,\n      args,\n      transientData,\n      endorsingOrganizations,\n      className\n    );\n  }\n\n  /**\n   * @description Shuts down the connection to the Fabric network\n   * @summary Closes the active dispatch (which in turn closes any gateway\n   * event subscription) via the base class, then closes the gRPC client.\n   * Works correctly regardless of whether `syntheticEvents` is enabled.\n   * @return {Promise<void>} Promise that resolves when all connections are closed\n   */\n  override async shutdown(...args: MaybeContextualArg<Context<FabricClientFlags>>): Promise<void> {\n    // Base class handles dispatch.close() internally.\n    await super.shutdown(...args);\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(\n    gateway: Gateway,\n    config: PeerConfig,\n    contractName?: string\n  ): 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 ${contractName || config.contractName} from network ${config.channel}`\n      );\n      contractName = contractName ? contractName : config.contractName;\n      contract = network.getContract(config.chaincodeName, 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 = Logging.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(\n    ctx: Context<FabricClientFlags>,\n    config: PeerConfig,\n    client?: Client\n  ) {\n    return (await this.getConnection(\n      client || (await this.getClient(config)),\n      config,\n      ctx\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    let pathOrCert: string | Buffer = config.tlsCert as string | Buffer;\n\n    if (typeof pathOrCert === \"string\") {\n      if (\n        pathOrCert.match(\n          /-----BEGIN (CERTIFICATE|KEY|PRIVATE KEY)-----.+?-----END \\1-----$/gms\n        )\n      ) {\n        pathOrCert = Buffer.from(pathOrCert, \"utf8\");\n      } else {\n        try {\n          pathOrCert = Buffer.from(fs.readFileSync(pathOrCert, \"utf8\"));\n        } catch (e: unknown) {\n          throw new InternalError(\n            `Failed to read the tls certificate from ${pathOrCert}: ${e}`\n          );\n        }\n      }\n    }\n\n    const tlsCredentials = grpc.credentials.createSsl(pathOrCert);\n    log.debug(`generating Gateway Client for url ${config.peerEndpoint}`);\n    return new Client(config.peerEndpoint, tlsCredentials, {\n      \"grpc.max_receive_message_length\": (config.sizeLimit || 15) * 1024 * 1024,\n      \"grpc.max_send_message_length\": (config.sizeLimit || 15) * 1024 * 1024,\n    });\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(\n    client: Client,\n    config: PeerConfig,\n    ctx: Context<FabricClientFlags>\n  ) {\n    const log = Logging.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 as any\n    );\n    try {\n      log.debug(\n        `preparing transaction signer for ${CryptoUtils.fabricIdFromCertificate(identity.credentials.toString())}`\n      );\n    } catch (e: unknown) {\n      log.error(`Failed to extract Fabric ID from certificate`, e as Error);\n    }\n\n    let signer: Signer;\n    const close = () => {};\n    if (!config.hsm) {\n      signer = await getSigner(config.keyCertOrDirectoryPath as any);\n    } else {\n      // const hsm = new HSMSignerFactoryCustom(config.hsm.library);\n      // const identifier = hsm.getSKIFromCertificatePath(\n      //   config.certCertOrDirectoryPath as any\n      // );\n      // const pkcs11Signer = hsm.newSigner({\n      //   label: config.hsm.tokenLabel as string,\n      //   pin: String(config.hsm.pin) as string,\n      //   identifier: identifier,\n      //   // userType: 1 /*CKU_USER */,\n      // });\n      // signer = pkcs11Signer.signer;\n      // close = pkcs11Signer.close;\n      throw new UnsupportedError(\"HSM NOT IMPLEMENTED\");\n    }\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() + 1000 * ctx.get(\"evaluateTimeout\") }; // defaults to 5 seconds\n      },\n      endorseOptions: () => {\n        return { deadline: Date.now() + 1000 * ctx.get(\"endorseTimeout\") }; // defaults to 15 seconds\n      },\n      submitOptions: () => {\n        return { deadline: Date.now() + 1000 * ctx.get(\"submitTimeout\") }; // defaults to 5 seconds\n      },\n      commitStatusOptions: () => {\n        return { deadline: Date.now() + 1000 * ctx.get(\"commitTimeout\") }; // defaults to 1 minute\n      },\n    } as ConnectOptions;\n\n    log.debug(`Connecting to ${config.mspId}`);\n    const gateway = connect(options);\n\n    // TODO: replace?\n    if (config.hsm) {\n      gateway.close = new Proxy(gateway.close, {\n        apply(target: () => void, thisArg: any, argArray: any[]): any {\n          Reflect.apply(target, thisArg, argArray);\n          close();\n        },\n      });\n    }\n\n    return gateway;\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(): FabricClientDispatch {\n    return new FabricClientAdapter[\"_baseDispatch\"](this.client);\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 parseError<E extends BaseError>(\n    err: Error | string | GatewayError\n  ): E {\n    // if (\n    //   MISSING_PRIVATE_DATA_REGEX.test(\n    //     typeof err === \"string\" ? err : err.message\n    //   )\n    // )\n    //   return new UnauthorizedPrivateDataAccess(err) as E;\n\n    let msg = typeof err === \"string\" ? err : err.message;\n    if (err instanceof GatewayError && err.details.length && err.code === 10) {\n      msg = `${err.details[0].message}`;\n    }\n\n    if (\n      err instanceof EndorseError &&\n      err.details.length &&\n      err.code === 10 &&\n      err.details[0].message?.includes(UnsupportedError.name)\n    ) {\n      msg = `${err.details[0].message}`;\n    }\n\n    if (msg.includes(\"MVCC_READ_CONFLICT\"))\n      return new MvccReadConflictError(err) as E;\n\n    if (msg.includes(\"DEADLINE_EXCEEDED\"))\n      return new TransactionTimeoutError(err) as E;\n\n    if (msg.includes(\"ENDORSEMENT_POLICY_FAILURE\"))\n      return new EndorsementPolicyError(err) as E;\n\n    if (msg.includes(\"PHANTOM_READ_CONFLICT\"))\n      return new PhantomReadConflictError(err) as E;\n\n    if (err instanceof Error && (err as any).code) {\n      switch ((err as any).code) {\n        case 9:\n          return new EndorsementError(err) as E;\n      }\n    }\n\n    if (msg.includes(ValidationError.name))\n      return new ValidationError(err) as E;\n    if (msg.includes(NotFoundError.name)) return new NotFoundError(err) as E;\n    if (msg.includes(ConflictError.name)) return new ConflictError(err) as E;\n    if (msg.includes(BadRequestError.name))\n      return new BadRequestError(err) as E;\n    if (msg.includes(QueryError.name)) return new QueryError(err) as E;\n    if (msg.includes(PagingError.name)) return new PagingError(err) as E;\n    if (msg.includes(UnsupportedError.name))\n      return new UnsupportedError(err) as E;\n    if (msg.includes(MigrationError.name)) return new MigrationError(err) as E;\n    if (msg.includes(ObserverError.name)) return new ObserverError(err) as E;\n    if (msg.includes(AuthorizationError.name))\n      return new AuthorizationError(err) as E;\n    if (msg.includes(ForbiddenError.name)) return new ForbiddenError(err) as E;\n    if (msg.includes(ConnectionError.name))\n      return new ConnectionError(err) as E;\n    if (msg.includes(SerializationError.name))\n      return new SerializationError(err) as E;\n    return new InternalError(err) as E;\n  }\n}\n\nFabricClientAdapter.decoration();\nAdapter.setCurrent(FabricFlavour);\n","import {\n  Adapter,\n  ContextualArgs,\n  Dispatch,\n  EventIds,\n  UnsupportedError,\n  Context,\n  MaybeContextualArg,\n  PersistenceKeys,\n} from \"@decaf-ts/core\";\nimport { PeerConfig } from \"../shared/types\";\nimport { Client } from \"@grpc/grpc-js\";\nimport { FabricClientAdapter } from \"./FabricClientAdapter\";\nimport {\n  BulkCrudOperationKeys,\n  InternalError,\n  OperationKeys,\n} from \"@decaf-ts/db-decorators\";\nimport {\n  ChaincodeEvent,\n  CloseableAsyncIterable,\n} from \"@hyperledger/fabric-gateway\";\nimport { parseEventName } from \"../shared/events\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { Constructor } from \"@decaf-ts/decoration\";\nimport { FabricClientFlags } from \"./types\";\n\n/**\n * @description Event dispatcher for Hyperledger Fabric chaincode events\n * @summary Listens for and processes events emitted by Fabric chaincode, dispatching them to registered observers\n * @template PeerConfig - Configuration type for connecting to a Fabric peer\n * @param client - gRPC client for connecting to the Fabric network\n * @class FabricClientDispatch\n * @example\n * ```typescript\n * // Create a new FabricDispatch instance\n * const client = await FabricAdapter.getClient(peerConfig);\n * const dispatch = new FabricDispatch(client);\n *\n * // Configure the dispatch with peer configuration\n * dispatch.configure(peerConfig);\n *\n * // Register an observer for a specific table and event\n * dispatch.observe('users', 'create', (id) => {\n *   console.log(`User created: ${id}`);\n * });\n *\n * // Start listening for events\n * await dispatch.start();\n * ```\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant FabricDispatch\n *   participant Gateway\n *   participant Network\n *   participant Chaincode\n *\n *   Client->>FabricDispatch: new FabricDispatch(client)\n *   Client->>FabricDispatch: configure(peerConfig)\n *   Client->>FabricDispatch: observe(table, event, callback)\n *   Client->>FabricDispatch: start()\n *   FabricDispatch->>FabricDispatch: initialize()\n *   FabricDispatch->>Gateway: getGateway(config, client)\n *   Gateway->>Network: getNetwork(channel)\n *   Network->>Network: getChaincodeEvents(chaincodeName)\n *   FabricDispatch->>FabricDispatch: handleEvents()\n *   loop For each event\n *     Chaincode-->>FabricDispatch: ChaincodeEvent\n *     FabricDispatch->>FabricDispatch: parseEventName(eventName)\n *     FabricDispatch->>FabricDispatch: parsePayload(payload)\n *     FabricDispatch->>FabricDispatch: updateObservers(table, event, id)\n *     FabricDispatch-->>Client: callback(id)\n *   end\n */\nexport class FabricClientDispatch extends Dispatch<FabricClientAdapter> {\n  /**\n   * @description Event listening stack for chaincode events\n   */\n  private listeningStack?: CloseableAsyncIterable<ChaincodeEvent>;\n\n  /**\n   * @description Text decoder for converting event payloads from bytes to strings\n   */\n  private decoder = new TextDecoder(\"utf8\");\n\n  /**\n   * @description Creates a new FabricDispatch instance\n   * @summary Initializes a dispatcher for Fabric chaincode events\n   * @param {Client} client - gRPC client for connecting to the Fabric network\n   */\n  constructor(protected client: Client) {\n    super();\n  }\n\n  /**\n   * @description Closes the event listening connection\n   * @summary Stops listening for chaincode events and releases resources\n   * @return {Promise<void>} Promise that resolves when the connection is closed\n   */\n  override async close(\n    ...ctxArgs: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<void> {\n    const { log, ctxArgs: loggedArgs } = (\n      await this.logCtx(ctxArgs, PersistenceKeys.SHUTDOWN, true)\n    ).for(this.close);\n    try {\n      await super.close(...loggedArgs);\n    } catch (e: unknown) {\n      log.error(`Failed to close Fabric proxies event listener`, e as Error);\n    }\n    if (this.listeningStack) {\n      try {\n        await this.listeningStack.close();\n      } catch (e: unknown) {\n        log.error(`Failed to close Fabric event listener`, e as Error);\n      } finally {\n        this.listeningStack = undefined;\n      }\n    }\n  }\n\n  /**\n   * @description Parses event payload from binary format\n   * @summary Converts a Uint8Array containing JSON to an object with an id property\n   * @param {Uint8Array} jsonBytes - The binary payload from the chaincode event\n   * @return {{ id: string }} The parsed payload containing the record ID\n   */\n  private parsePayload(jsonBytes: Uint8Array): { id: string; result?: any } {\n    const json = this.decoder.decode(jsonBytes);\n    return JSON.parse(json);\n  }\n\n  /**\n   * @description Starts observing an adapter\n   * @summary Connects this dispatch to an adapter to monitor its operations\n   * @param {Adapter<any, any, any, any>} observer - The adapter to observe\n   * @return {void}\n   */\n  override observe(observer: Adapter<any, any, any, any>): () => void {\n    if (!(observer instanceof FabricClientAdapter))\n      throw new UnsupportedError(\n        \"Only FabricClientAdapter can be observed by dispatch\"\n      );\n    super.observe(observer as FabricClientAdapter);\n    return () => this.unObserve(observer);\n  }\n\n  /**\n   * @description Updates observers about a database event\n   * @summary Notifies observers about a change in the database\n   * @param {string} table - The name of the table where the change occurred\n   * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of operation that occurred\n   * @param {any} payload - The event payload\n   * @return {Promise<void>} A promise that resolves when all observers have been notified\n   */\n  override async updateObservers(\n    model: Constructor<any> | string,\n    event: OperationKeys | BulkCrudOperationKeys | string,\n    id: EventIds,\n    ...args: ContextualArgs<Context<FabricClientFlags>>\n  ): Promise<void> {\n    const { log, ctxArgs } = Adapter.logCtx<Context<FabricClientFlags>>(\n      this.updateObservers,\n      event,\n      false,\n      ...args\n    );\n    if (!this.adapter) {\n      log.verbose(\n        `No adapter observed for dispatch; skipping observer update for ${typeof model === \"string\" ? model : Model.tableName(model)}:${event}`\n      );\n      return;\n    }\n    try {\n      await this.adapter.refresh(model, event, id, ...ctxArgs);\n    } catch (e: unknown) {\n      throw new InternalError(`Failed to refresh dispatch: ${e}`);\n    }\n  }\n\n  /**\n   * @description Processes incoming chaincode events\n   * @summary Listens for events from the chaincode and dispatches them to registered observers\n   * @return {Promise<void>} Promise that resolves when event handling stops\n   * @mermaid\n   * sequenceDiagram\n   *   participant FabricDispatch\n   *   participant EventStack\n   *   participant EventParser\n   *   participant Observers\n   *\n   *   FabricDispatch->>FabricDispatch: handleEvents()\n   *   FabricDispatch->>EventStack: for await (const evt of listeningStack)\n   *   EventStack-->>FabricDispatch: ChaincodeEvent\n   *   FabricDispatch->>EventParser: parseEventName(evt.eventName)\n   *   EventParser-->>FabricDispatch: { table, event, owner }\n   *   FabricDispatch->>FabricDispatch: Check if event is for this MSP\n   *   FabricDispatch->>FabricDispatch: parsePayload(evt.payload)\n   *   FabricDispatch->>Observers: updateObservers(table, event, payload.id)\n   *   Observers-->>FabricDispatch: Callbacks executed\n   */\n  protected async handleEvents(\n    ctxArg?: Context<FabricClientFlags>\n  ): Promise<void> {\n    if (!this.listeningStack)\n      throw new InternalError(\n        `Event stack not initialized. Ensure that \"startListening\" is called before attempting this operation.`\n      );\n\n    if (!this.adapter || !this.adapter.config)\n      throw new InternalError(`No adapter found. should be impossible`);\n\n    const ctx =\n      ctxArg ||\n      (await this.adapter.context(\n        OperationKeys.READ,\n        {\n          correlationId: this.adapter.config.chaincodeName,\n        },\n        (this.models && this.models[0]) || (Model as unknown as Constructor)\n      ));\n    const log = this.log.for(this.handleEvents);\n\n    log.info(\n      `Listening for incoming events on chaincode \"${this.adapter.config.chaincodeName}\" on channel \"${this.adapter.config.channel}\"...`\n    );\n\n    try {\n      for await (const evt of this.listeningStack) {\n        const { table, event, owner } = parseEventName(evt.eventName);\n        if (\n          this.adapter.config?.mspEventOnly &&\n          owner &&\n          owner !== this.adapter.config?.mspId\n        )\n          continue;\n        const payload: { id: string; result?: any } = this.parsePayload(\n          evt.payload\n        );\n        try {\n          const targetModel = table\n            ? Model.get(table)\n            : Model.get(this.models[0].name);\n          const modelRef = targetModel ?? (table || this.models[0]?.name);\n          const observerArgs = payload.result ? [payload.result, ctx] : [ctx];\n          await this.updateObservers(\n            modelRef as Constructor | string,\n            event,\n            payload.id as string,\n            ...(observerArgs as ContextualArgs<any>)\n          );\n        } catch (e: unknown) {\n          log.error(\n            `Failed update observables for table ${table} event ${event} id: ${payload.id}: ${e}`\n          );\n        }\n      }\n    } catch (e: any) {\n      log.error(\n        `Failed to read event for chaincode \"${this.adapter.config.chaincodeName}\" on channel \"${this.adapter.config.channel}\": ${e}`\n      );\n      await this.close(ctx);\n    }\n  }\n\n  /**\n   * @description Initializes the event listener\n   * @summary Sets up event dispatching for the observed adapter. When\n   * `syntheticEvents` is true (the default) no gateway connection is opened;\n   * instead every CRUD operation is wrapped with a Proxy that fires\n   * `updateObservers` for **all** models. When `syntheticEvents` is false the\n   * existing gateway-based chaincode-event subscription is established and the\n   * local Proxy fallback is limited to fully-segregated (transient) models only.\n   * @return {Promise<void>} Promise that resolves when initialization is complete\n   */\n  protected override async initialize(): Promise<void> {\n    if (!this.adapter)\n      throw new InternalError(`No adapter or config observed for dispatch`);\n\n    const syntheticEvents = this.adapter.config.syntheticEvents !== false;\n\n    if (!syntheticEvents) {\n      // Gateway-based chaincode-event subscription (non-synthetic path)\n      const context = await this.adapter.context(\n        \"dispatch\",\n        {\n          correlationId: this.adapter.config.chaincodeName,\n        },\n        Model as any\n      );\n      const { ctx } = this.logCtx([context], this.initialize);\n      const gateway = await FabricClientAdapter.getGateway(\n        ctx,\n        this.adapter.config as PeerConfig,\n        this.client\n      );\n      const network = gateway.getNetwork(this.adapter.config.channel);\n      if (!this.adapter)\n        throw new InternalError(`No adapter observed for dispatch`);\n      this.listeningStack = await network.getChaincodeEvents(\n        this.adapter.config.chaincodeName\n      );\n      this.handleEvents(ctx);\n    }\n\n    // Proxy CRUD methods.\n    // • syntheticEvents = true  → notify for ALL models (replaces gateway events entirely)\n    // • syntheticEvents = false → notify only for fully-segregated (transient) models\n    //   (the gateway subscription handles public models)\n    (\n      [\n        OperationKeys.CREATE,\n        OperationKeys.UPDATE,\n        OperationKeys.DELETE,\n        BulkCrudOperationKeys.CREATE_ALL,\n        BulkCrudOperationKeys.UPDATE_ALL,\n        BulkCrudOperationKeys.DELETE_ALL,\n      ] as (keyof Adapter<any, any, any, any>)[]\n    ).forEach((toWrap) => {\n      if (!this.adapter)\n        throw new InternalError(\n          `No adapter provided for the fallback of fully segregated models`\n        );\n      if (!this.adapter[toWrap])\n        throw new InternalError(\n          `Method ${toWrap} not found in ${this.adapter.alias} adapter to bind Observables Dispatch`\n        );\n\n      let descriptor = Object.getOwnPropertyDescriptor(this.adapter, toWrap);\n      let proto: any = this.adapter;\n      while (!descriptor && proto !== Object.prototype) {\n        proto = Object.getPrototypeOf(proto);\n        descriptor = Object.getOwnPropertyDescriptor(proto, toWrap);\n      }\n\n      if (!descriptor || !descriptor.writable) {\n        this.log.error(\n          `Could not find method ${toWrap} to bind Observables Dispatch`\n        );\n        return;\n      }\n      function bulkToSingle(method: string) {\n        switch (method) {\n          case BulkCrudOperationKeys.CREATE_ALL:\n            return OperationKeys.CREATE;\n          case BulkCrudOperationKeys.UPDATE_ALL:\n            return OperationKeys.UPDATE;\n          case BulkCrudOperationKeys.DELETE_ALL:\n            return OperationKeys.DELETE;\n          default:\n            return method;\n        }\n      }\n\n      // @ts-expect-error because there are read only properties\n      this.adapter[toWrap] = new Proxy(this.adapter[toWrap], {\n        apply: async (\n          target: any,\n          thisArg: FabricClientAdapter,\n          argArray: any[]\n        ) => {\n          // Run the original method unchanged so transient data is preserved\n          const result = await target.apply(thisArg, argArray);\n\n          const clazz: Constructor<any> = argArray[0];\n          // When syntheticEvents is false, public models emit a chaincode event\n          // on the contract side; skip the local fallback to avoid\n          // double-notification. When syntheticEvents is true we handle all models.\n          if (!syntheticEvents && !Model.isTransient(clazz)) return result;\n\n          // Context is always the last element of argArray\n          const { log, ctxArgs, ctx } = thisArg[\"logCtx\"](\n            argArray.slice(argArray.length - 1),\n            target\n          );\n          const ids = argArray[1];\n          const resultArgs: any[] = [clazz, bulkToSingle(toWrap), ids];\n\n          if (ctx.getOrUndefined(\"observeFullResult\")) {\n            resultArgs.push(result);\n          }\n          this.updateObservers(\n            ...(resultArgs as Parameters<typeof this.updateObservers>),\n            ...ctxArgs\n          ).catch((e: unknown) =>\n            log.error(\n              `Failed to dispatch observer refresh for ${toWrap} on ${clazz.name || clazz} for ${ids}: ${e}`\n            )\n          );\n          return result;\n        },\n      });\n    });\n  }\n}\n\nif (FabricClientAdapter)\n  FabricClientAdapter[\"_baseDispatch\"] = FabricClientDispatch;\n","import { Metadata } from \"@decaf-ts/decoration\";\n\nexport const VERSION = \"##VERSION##\";\nexport const PACKAGE_NAME = \"##PACKAGE##\";\n\nMetadata.registerLibrary(PACKAGE_NAME, VERSION);\n"],"names":["ensureDirectoryExistence","filePath","fs","require","path","dirname","existsSync","mkdirSync","generateModelIndexes","m","generateIndexes","generateModelDesignDocs","accum","views","generateViews","storage","forEach","doc","_id","readModelFile","file","exports","join","process","cwd","parentPath","name","values","Object","filter","e","Model","async","readModelFolders","folders","result","folder","files","readdirSync","withFileTypes","recursive","f","isFile","endsWith","push","writeIndexes","indexes","p","collection","index","resolve","writeFileSync","JSON","stringify","undefined","writeDesignDocs","designDocs","length","docId","replace","payload","_rev","collectionFor","collectionName","policy","requiredPeerCount","maxPeerCount","blockToLive","memberOnlyRead","memberOnlyWrite","privateCollectionFor","mspId","c","endorsementPolicy","signaturePolicy","sharedCollectionFor","mspIds","map","extractCollections","overrides","mirror","privateCols","sharedCols","collectionsFor","resolveCollection","arg","InternalError","privateDefaults","assign","sharedDefaults","mirrorMeta","mirroredAt","privates","flat","resolved","resolver","some","includes","shared","writeCollections","cols","fileName","writeCollectionDesignDocs","docs","FabricClientPaginator","Paginator","constructor","adapter","query","size","clazz","super","prepare","rawStatement","UnsupportedError","page","args","isSerializedPage","obj","Array","isArray","data","FabricClientRepository","Repository","force","this","_overrides","ignoreValidation","ignoreHandlers","allowRawStatements","forcePrepareSimpleQueries","forcePrepareComplexQueries","allowGenerationOverride","rebuildWithTransient","override","flags","for","ObserverHandler","paginateBy","key","order","ref","offset","limit","log","ctxArgs","logCtx","PreparedStatementKeys","PAGE_BY","verbose","tableName","class","statement","bookmark","listBy","LIST_BY","findBy","value","FIND_BY","findOneBy","FIND_ONE_BY","find","OrderDirection","ASC","FIND","direction","PAGE","ctx","PersistenceKeys","STATEMENT","callArgs","slice","parse","decode","evaluateTransaction","hydrated","r","CouchDBKeys","TABLE","d","applyAfterRead","getOrUndefined","enforceDBDecorators","OperationKeys","READ","AFTER","Promise","all","entry","countOf","COUNT_OF","stmtArgs","maxOf","MAX_OF","minOf","MIN_OF","avgOf","AVG_OF","sumOf","SUM_OF","distinctOf","DISTINCT_OF","groupOf","GROUP_OF","healthcheck","create","model","debug","ensureLegacyMirrorFlag","prepared","record","id","transient","revert","update","createAllPrefix","models","CREATE","get","ignoreValidate","ON","ignoredProps","errors","hasErrors","errorMessages","reduceErrorsToPrint","ValidationError","createAll","ids","payloads","transients","created","i","readAll","keys","records","updateAll","updated","u","accumulate","legacy","ERC20Token","BaseModel","__decorate","pk","type","String","prototype","column","required","table","ERC20Wallet","Allowance","ClientSerializer","JSONSerializer","preSerialize","modelName","toSerialize","metadata","Metadata","SerializationError","ModelKeys","ANCHOR","deserialize","str","deserialization","className","Error","build","serialize","FabricERC20ClientRepository","serializer","decoder","TextDecoder","updateObservers","event","observerHandler","count","parsedId","Sequence","parseValue","sequenceFor","tokenName","symbol","decimals","Number","totalSupply","total","balanceOf","owner","balance","transfer","to","transferred","submitTransaction","toString","transferFrom","from","contextArgs","Context","approve","spender","approved","allowance","initialize","token","initiliazed","checkInitialized","mint","amount","burn","burnFrom","account","clientAccountBalance","serializedAccountBalance","clientAccountID","extractIds","composed","pkProps","extractId","composeAttributeValue","IdentityCredentials","description","FabricModelKeys","IdentityType","FabricFlavour","Identity","X509","oneToOne","Cascade","CASCADE","delete","CoreUtils","logger","MiniLogger","contentOfLoadFile","contentOrPath","fileReader","Uint8Array","match","readFile","promises","normalizeImport","import","getCAUser","userName","privateKey","certificate","options","stringFormat","user","User","config","hsm","software","lib","library","slot","label","tokenLabel","pin","cryptoSuite","getCryptoSuite","setCryptoSuite","enrollmentKey","getHSMEnrollmentKey","getSoftwareEnrollmentKey","setEnrollment","newCryptoSuite","createKeyFromRaw","ski","keyIdHex","trim","Buffer","getCertificateSKI","getKey","isPrivate","x509","X509Certificate","jwk","publicKey","export","format","prefix","x","y","crypto","createHash","concat","digest","getIdentity","certDirectoryPath","identityFileReader","certPath","getFirstDirFileName","credentials","dirPath","readdir","getFirstDirFileNameContent","getFileContent","getSigner","keyDirectoryPath","signerFileReader","keyPath","privateKeyPem","extractPrivateKey","getOwnPropertySymbols","k","signers","newPrivateKeySigner","pem","libName","subtle","globalThis","window","Crypto","webcrypto","str2ab","buf","ArrayBuffer","bufView","strLen","charCodeAt","replaceAll","decoded","binaryDer","importKey","namedCurve","getAkiAndSerialFromCert","cert","x509Certificate","X509Cert","akiExt","extensions","aki","toUpperCase","startsWith","serial","serialNumber","cryptoProvider","set","BASE_ALPHABET","CRYPTO","BaseEncoder","alphabet","baseMap","j","charAt","xc","base","leader","factor","Math","iFactor","encode","source","isView","buffer","byteOffset","byteLength","zeroes","pbegin","pend","b58","carry","it1","it2","repeat","decodeUnsafe","psz","b256","it3","it4","vch","CryptoUtils","b58encoder","BASE58","fabricIdFromCertificate","subject","issuer","stringToArrayBuffer","extractKey","usages","RegExp","extractPublicKey","sign","buff","hash","b","padStart","verify","signature","encrypt","getSubtleCrypto","isBrowser","decrypt","getMaster","textEncoder","TextEncoder","genGenesis","randomUUID","importedKey","KEY_ALGORYTHM","iv","getDerivationKey","salt","saltBuffer","saltHashed","params","HASH","iterations","ITERATIONS","derivation","deriveBits","KEYLENGTH","ivlen","keylen","derivedKey","importedEncryptionKey","ALGORYTHM","encryptPin","text","keyObject","textBuffer","encryptedText","decryptPin","textDecoder","decryptedText","OverflowError","msg","BalanceError","AllowanceError","RegistrationError","AuthorizationError","MissingContextError","UnauthorizedPrivateDataAccess","BaseError","NotInitializedError","MissingPKCSS11Lib","EndorsementError","message","MvccReadConflictError","PhantomReadConflictError","EndorsementPolicyError","TransactionLimitsError","code","TransactionTimeoutError","TransactionBufferSizeError","HFCAIdentityType","HFCAIdentityAttributes","FabricEnrollmentService","LoggedClass","caConfig","caName","caCert","caKey","url","CA","ca","tls","trustedRoots","root","FabricCAServices","Client","client","Certificate","certificateService","newCertificateService","Affiliations","affiliationService","newAffiliationService","Identities","identityService","newIdentityService","getCertificates","request","doMap","response","certs","PEM","getIdentities","identitiesService","getAll","identities","parseError","regexp","exec","ConflictError","getAffiliations","a","read","enrollmentId","getOne","NotFoundError","success","register","isSuperUser","affiliation","userRole","attrs","maxEnrollments","registration","password","props","enrollmentID","enrollmentSecret","info","identityFromEnrollment","enrollment","rootCertificate","Logging","clientId","now","Date","toBytes","createdOn","updatedOn","enroll","identity","registerAndEnroll","revoke","reason","RegistrationRequestBuilder","errs","role","setAffiliation","addAttr","attr","setAttrs","setEnrollmentID","setEnrollmentSecret","setMaxEnrollments","setRole","minlength","min","ERC20Events","FabricBaseModel","createdAt","updatedAt","version","uses","FabricIdentifiedBaseModel","createdBy","updatedBy","isShared","segregate","isTransient","decoratedProperties","getAttributes","transientProps","DBKeys","TRANSIENT","privateProperties","PRIVATE","sharedProperties","SHARED","public","transientKeys","privateKeys","sharedKeys","isPublic","bind","mirrored","FABRIC","MIRROR","ownerOf","meta","OWNED_BY","sharedKey","constr","privateMeta","sharedMeta","collections","extractMspId","getMSPID","Owner","target","propertyKey","descriptor","originalMethod","acountId","clientIdentity","getID","select","tokens","execute","apply","ownedByOnCreate","context","stub","creator","getCreator","mspid","setOwnedByKeyValue","defineProperty","enumerable","writable","configurable","ownedBy","attribute","generated","readonly","onCreate","propMetadata","Decoration","define","decorator","transactionIdOnCreate","getTxID","transactionId","onUpdate","TRANSACTION_ID","evalMirrorMetadata","createMirrorHandler","fabricCtx","sourceModel","put","repo","mirrorCollection","updateMirrorHandler","applyUpdateValidation","mergeForUpdate","deleteMirrorHandler","pkProp","segregated","mirrorWriteGuard","msp","condition","readMirrorHandler","matches","readFrom","mspIdOrCondition","isConditionOnly","Boolean","cond","onRead","priority","onDelete","ModelCollection","orgName","toPascalCase","NamespaceCollection","namespace","ImplicitPrivateCollection","SEGREGATED_COLLECTION_EXTRACTION_PRIORITY","applySegregationFlags","isFullySegregated","hasPublicProperties","markFullySegregated","applyMirrorFlags","attributes","transientMeta","extractSegregatedCollections","dataArray","collectionResolver","seqName","sequenceName","setSequenceSegregation","segregatedDataOnCreate","keyArray","_k","keyStrings","writeTo","segregatedDataOnRead","segregatedDataOnUpdate","oldModel","segregatedDataOnDelete","innerSegregated","segregatedDec","Set","add","constrMeta","constrCollections","updatedTransientMeta","decs","properties","groupName","extractGroupName","dataGroupName","earlyExtractionMeta","earlyExtractionGroupSort","group","prop","on","DBOperations","ALL","privateData","sharedData","sortKeysOnlyRecursive","sort","reduce","acc","DeterministicSerializer","error","self","o","call","relations","generateFabricEventName","parseEventName","parts","split","sub","safeParseInt","string","digitRegex","test","parsedint","parseInt","isNaN","SimpleDeterministicSerializer","putAnchor","preSerialization","FabricIdentityService","ClientBasedService","rootClient","_user","certificates","affiliations","getUser","cfg","INITIALIZATION","getName","updateIdentity","identityRequest","caUserIdentity","reenrollUser","createUser","getMspid","enrollmentAttrs","optional","reenroll","renewedIdentity","revokeOptions","revokeRequest","CA_ROLE","DefaultFabricClientFlags","evaluateTimeout","endorseTimeout","submitTimeout","commitTimeout","allowManualEndorsingOrgs","allowGatewayOverride","encryptTransient","syntheticEvents","createPrivateKey","escapeRegExp","nextLexicographicString","chars","codePointAt","fromCodePoint","prefixRange","start","end","FabricClientStatement","Statement","squash","squashed","method","executePrepared","argz","forModel","fromSelector","alias","QUERY","isSimpleQuery","QueryClause","whereCondition","parsed","prepareCondition","selectSelector","SELECT","AND","toLowerCase","orderBySelectors","ORDER_BY","toCamelCase","processRecord","pkAttr","ID","keyArgs","SEPARATOR","raw","rawInput","aggregator","aggregateInfo","aggregate","executeAggregate","results","processed","applyAfterHandlersToResult","aggregateQuery","buildAggregateQuery","selectors","selector","fields","parseCondition","Condition","and","eq","selectorKeys","CouchDBGroupOperator","indexOf","val","OR","s","entries","warn","selectorKey","rec","CouchDBOperator","BIGGER","limitSelector","CouchDBQueryLimit","offsetSelector","skip","merge","op","obj1","obj2","attr1","operator","comparison","Operator","STARTS_WITH","QueryError","range","BIGGER_EQ","SMALLER","ENDS_WITH","REGEXP","BETWEEN","max","opBetween","translateOperators","SMALLER_EQ","GroupOperator","NOT","op1","op2","avgSelector","sumInfo","createAggregateDescriptor","countInfo","createAggregateQuery","kind","sumDescriptor","countDescriptor","countDistinctSelector","countDistinct","aggregatorUsed","countSelector","minSelector","maxSelector","sumSelector","distinctSelector","aggregatorChecks","metas","findViewMetadata","viewName","generateViewName","ddoc","generateDesignDocName","returnDocs","view","getFabricAdapter","isViewAggregate","handleAverage","fabricAdapter","viewInfo","processViewResponse","sumDesc","countDesc","sumResponse","countResponse","sum","rows","row","FabricClientAdapter","Adapter","operation","mergedFlags","silly","pop","toOverrides","newCtx","parentContext","childContexts","currentOp","currentModel","repository","createPrefix","updateAllPrefix","shift","hasTransient","needsFullPayload","shouldForceGatewayHydration","transientPayload","BulkCrudOperationKeys","CREATE_ALL","getEndorsingOrganizations","res","shouldRefreshAfterWrite","READ_ALL","UPDATE_ALL","deleteAll","shouldHydrate","DELETE_ALL","METADATA","mirrorMsp","msps","merged","endorsingOrgs","endorsingOrganizations","shouldRebuildWithTransient","v","childRebuild","getFromChildren","resolvedOp","resolveOperation","hasId","direct","deserialized","updatePrefix","UPDATE","DELETE","docsOnly","transactionResult","parseRecord","isModel","el","getClient","_client","Gateway","getGateway","getContractName","Contract","contractName","getContract","transaction","api","submit","transientData","gateway","contract","evaluate","proposalOptions","arguments","close","shouldUseLegacyGateway","prepareLegacyArgs","buildLegacyTransient","resolveLegacyMspCount","configured","legacyMspCount","isFinite","floor","pickLegacyCandidates","candidates","available","picked","idx","random","selection","splice","buildLegacyPeerConfigs","peers","peerEndpoint","peerHostAlias","tlsCert","endorsers","org","extras","mspMap","legacyCount","selections","choice","endpoint","submitLegacyWithExplicitEndorsers","fcn","transientMap","peerConfigs","normalizeLegacyPeers","identityMaterial","resolveLegacyIdentityMaterial","wallet","Wallets","newInMemoryWallet","identityLabel","connectionProfile","buildLegacyConnectionProfile","LegacyGateway","connect","discovery","enabled","asLocalhost","shouldTreatPeersAsLocalhost","tlsInfo","network","getNetwork","channel","chaincodeName","createTransaction","setTransient","peer","getChannel","getEndorser","endorser","setEndorsingPeers","disconnect","deduped","Map","addPeer","has","readPemInput","certCertOrDirectoryPath","keyCertOrDirectoryPath","peerEntries","channelPeers","orgs","tlsPem","hostname","extractHost","ensureGrpcUrl","tlsCACerts","grpcOptions","hostnameOverride","endorsingPeer","chaincodeQuery","ledgerQuery","eventSource","organization","organizations","orderers","channels","every","isLocalEndpoint","host","sanitized","isBuffer","trimmed","stats","stat","catch","isDirectory","readFsFile","err","legacyArgs","shutdown","channelName","getConnection","pathOrCert","readFileSync","tlsCredentials","grpc","createSsl","sizeLimit","signer","evaluateOptions","deadline","endorseOptions","submitOptions","commitStatusOptions","Proxy","thisArg","argArray","Reflect","Dispatch","GatewayError","details","EndorseError","BadRequestError","PagingError","MigrationError","ObserverError","ForbiddenError","ConnectionError","final","D","_a","decoration","setCurrent","FabricClientDispatch","loggedArgs","SHUTDOWN","listeningStack","parsePayload","jsonBytes","json","observe","observer","unObserve","refresh","handleEvents","ctxArg","correlationId","evt","eventName","mspEventOnly","targetModel","modelRef","observerArgs","getChaincodeEvents","toWrap","getOwnPropertyDescriptor","proto","getPrototypeOf","bulkToSingle","resultArgs","VERSION","PACKAGE_NAME","registerLibrary"],"mappings":"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"}