@decaf-ts/for-fabric 0.0.2

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

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

package/lib/esm/client/fabric-fs.js

@@ -0,0 +1,191 @@
+import { normalizeImport } from "@decaf-ts/utils";
+import { isBrowser, Logging } from "@decaf-ts/logging";
+import { User } from "fabric-common";
+import { signers } from "@hyperledger/fabric-gateway";
+import { InternalError } from "@decaf-ts/db-decorators";
+const log = Logging.for("fabric-fs");
+/**
+ * @description Loads content from a file or returns the content if already loaded
+ * @summary Determines if the input is already content or a path to a file, and loads the file if needed
+ * @param {string | Uint8Array} contentOrPath - The content or path to load
+ * @param {Function} fileReader - Function to read the file if contentOrPath is a path
+ * @return {Promise<string | Uint8Array | Buffer>} The content
+ * @function contentOfLoadFile
+ * @memberOf module:for-fabric.client
+ */
+export async function contentOfLoadFile(contentOrPath, fileReader) {
+    if (contentOrPath instanceof Uint8Array)
+        return contentOrPath;
+    if (contentOrPath.match(/-----BEGIN (CERTIFICATE|KEY|PRIVATE KEY)-----.+?-----END \1-----$/gms))
+        return contentOrPath;
+    return await fileReader(contentOrPath);
+}
+/**
+ * @description Reads a file from the file system
+ * @summary Loads a file using the Node.js file system module
+ * @param {string | Buffer} contentOrPath - The content or path to load
+ * @return {Promise<Buffer>} The file content as a Buffer
+ * @function readFile
+ * @memberOf module:for-fabric.client
+ */
+export async function readFile(contentOrPath) {
+    if (typeof contentOrPath !== "string")
+        return contentOrPath;
+    const fileReader = async (path) => {
+        const { promises } = await normalizeImport(import("fs"));
+        return await promises.readFile(path);
+    };
+    return await fileReader(contentOrPath);
+}
+/**
+ * @description Creates a Certificate Authority user
+ * @summary Initializes a user with the given credentials for interacting with a Fabric CA
+ * @param {string} userName - The user name
+ * @param {string} privateKey - The private key as a string
+ * @param {string} certificate - The certificate as a string
+ * @param {string} mspId - The Membership Service Provider ID
+ * @return {Promise<User>} Promise resolving to the created user
+ * @function getCAUser
+ * @memberOf module:for-fabric.client
+ */
+export async function getCAUser(userName, privateKey, certificate, mspId) {
+    log.debug(`Creating a CA ${mspId} user ${userName} with certificate ${certificate}`);
+    const user = new User(userName);
+    const cryptoSuite = User.newCryptoSuite();
+    user.setCryptoSuite(cryptoSuite);
+    const importedKey = cryptoSuite.createKeyFromRaw(privateKey);
+    await user.setEnrollment(importedKey, certificate, mspId);
+    return user;
+}
+/**
+ * @description Gets an identity from a certificate directory
+ * @summary Loads a certificate from a directory and creates an Identity object
+ * @param {string} mspId - The Membership Service Provider ID
+ * @param {string} certDirectoryPath - Path to the directory containing the certificate
+ * @return {Promise<Identity>} Promise resolving to the identity
+ * @function getIdentity
+ * @memberOf module:for-fabric.client
+ */
+export async function getIdentity(mspId, certDirectoryPath) {
+    const identityFileReader = async (path) => {
+        const { promises } = await normalizeImport(import("fs"));
+        const certPath = await getFirstDirFileName(path);
+        const credentials = await promises.readFile(certPath);
+        return credentials;
+    };
+    const credentials = (await contentOfLoadFile(certDirectoryPath, identityFileReader));
+    return { mspId, credentials };
+}
+/**
+ * @description Gets the full path of the first file in a directory
+ * @summary Reads a directory and returns the path to the first file found
+ * @param {string} dirPath - Path to the directory
+ * @return {Promise<string>} Promise resolving to the full path of the first file
+ * @function getFirstDirFileName
+ * @memberOf module:for-fabric.client
+ */
+export async function getFirstDirFileName(dirPath) {
+    const { promises } = await normalizeImport(import("fs"));
+    const { join } = await normalizeImport(import("path"));
+    const files = await promises.readdir(dirPath);
+    return join(dirPath, files[0]);
+}
+/**
+ * @description Gets the content of the first file in a directory
+ * @summary Reads a directory, finds the first file, and returns its content as a string
+ * @param {string} dirPath - Path to the directory
+ * @return {Promise<string>} Promise resolving to the content of the first file
+ * @function getFirstDirFileNameContent
+ * @memberOf module:for-fabric.client
+ */
+export async function getFirstDirFileNameContent(dirPath) {
+    const { promises } = await normalizeImport(import("fs"));
+    const { join } = await normalizeImport(import("path"));
+    const files = await promises.readdir(dirPath);
+    return (await promises.readFile(join(dirPath, files[0]))).toString();
+}
+/**
+ * @description Gets a signer from a key directory
+ * @summary Loads a private key from a directory and creates a Signer for Fabric transactions
+ * @param {string} keyDirectoryPath - Path to the directory containing the private key
+ * @return {Promise<Signer>} Promise resolving to the signer
+ * @function getSigner
+ * @memberOf module:for-fabric.client
+ */
+export async function getSigner(keyDirectoryPath) {
+    const signerFileReader = async (path) => {
+        const { promises } = await normalizeImport(import("fs"));
+        const keyPath = await getFirstDirFileName(path);
+        return await promises.readFile(keyPath);
+    };
+    const privateKeyPem = (await contentOfLoadFile(keyDirectoryPath, signerFileReader));
+    // Node based implementation
+    // privateKey = createPrivateKey(privateKeyPem);
+    // --
+    // web based implementation
+    const privateKey = await extractPrivateKey(privateKeyPem);
+    const keys = Object.getOwnPropertySymbols(privateKey);
+    const k = privateKey[keys[0]];
+    // --
+    return signers.newPrivateKeySigner(k);
+}
+/**
+ * @description Extracts a private key from a PEM buffer
+ * @summary Converts a PEM-encoded private key to a CryptoKey object
+ * @param {Buffer} pem - The PEM-encoded private key
+ * @return {Promise<CryptoKey>} Promise resolving to the CryptoKey
+ * @function extractPrivateKey
+ * @memberOf module:for-fabric.client
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant ExtractPrivateKey
+ *   participant SubtleCrypto
+ *
+ *   Caller->>ExtractPrivateKey: extractPrivateKey(pem)
+ *   ExtractPrivateKey->>ExtractPrivateKey: Get SubtleCrypto implementation
+ *   ExtractPrivateKey->>ExtractPrivateKey: Parse PEM format
+ *   ExtractPrivateKey->>ExtractPrivateKey: Convert to binary DER
+ *   ExtractPrivateKey->>SubtleCrypto: importKey(pkcs8, binaryDer, options)
+ *   SubtleCrypto-->>ExtractPrivateKey: CryptoKey
+ *   ExtractPrivateKey-->>Caller: CryptoKey
+ */
+export 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;
+    }
+    if (!subtle)
+        throw new Error("Could not load SubtleCrypto module");
+    function str2ab(str) {
+        const buf = new ArrayBuffer(str.length);
+        const bufView = new Uint8Array(buf);
+        for (let i = 0, strLen = str.length; i < strLen; i++) {
+            bufView[i] = str.charCodeAt(i);
+        }
+        return buf;
+    }
+    const str = pem
+        .toString("utf8")
+        .replace("-----BEGIN PRIVATE KEY-----", "")
+        .replaceAll("\n", "")
+        .replace("-----END PRIVATE KEY-----", "");
+    const decoded = Buffer.from(str, "base64").toString("binary");
+    const binaryDer = str2ab(decoded);
+    try {
+        const key = await subtle.importKey("pkcs8", binaryDer, {
+            name: "ECDSA",
+            namedCurve: "P-256",
+        }, true, ["sign"]);
+        return key;
+    }
+    catch (e) {
+        throw new InternalError(e);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fabric-fs.js","sourceRoot":"","sources":["../../../src/client/fabric-fs.ts"],"names":[],"mappings":"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","sourcesContent":["import { normalizeImport } from \"@decaf-ts/utils\";\nimport { isBrowser, Logging } from \"@decaf-ts/logging\";\nimport { User } from \"fabric-common\";\nimport { Identity, Signer, signers } from \"@hyperledger/fabric-gateway\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\n\nconst log = Logging.for(\"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"]}

package/lib/esm/client/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @description Hyperledger Fabric Client Module for Decaf-ts
+ * @summary This module provides client-side utilities and adapters to interact with Hyperledger Fabric networks using Decaf-ts. It exposes the Fabric client adapter, event dispatch utilities, and filesystem helpers for loading identities and keys.
+ * @module client
+ * @memberOf module:for-fabric
+ * @example
+ * // Create a client adapter and submit a transaction
+ * // See also: {@link module:for-fabric~FabricClientAdapter} and {@link module:for-fabric~FabricClientDispatch}
+ */
+export * from "./fabric-fs";
+export * from "./FabricClientAdapter";
+export * from "./FabricClientDispatch";
+export * from "../shared/types";

package/lib/esm/client/index.js

@@ -0,0 +1,14 @@
+/**
+ * @description Hyperledger Fabric Client Module for Decaf-ts
+ * @summary This module provides client-side utilities and adapters to interact with Hyperledger Fabric networks using Decaf-ts. It exposes the Fabric client adapter, event dispatch utilities, and filesystem helpers for loading identities and keys.
+ * @module client
+ * @memberOf module:for-fabric
+ * @example
+ * // Create a client adapter and submit a transaction
+ * // See also: {@link module:for-fabric~FabricClientAdapter} and {@link module:for-fabric~FabricClientDispatch}
+ */
+export * from "./fabric-fs.js";
+export * from "./FabricClientAdapter.js";
+export * from "./FabricClientDispatch.js";
+export * from "./../shared/types.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY2xpZW50L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7OztHQVFHO0FBRUgsK0JBQTRCO0FBQzVCLHlDQUFzQztBQUN0QywwQ0FBdUM7QUFDdkMscUNBQWdDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAZGVzY3JpcHRpb24gSHlwZXJsZWRnZXIgRmFicmljIENsaWVudCBNb2R1bGUgZm9yIERlY2FmLXRzXG4gKiBAc3VtbWFyeSBUaGlzIG1vZHVsZSBwcm92aWRlcyBjbGllbnQtc2lkZSB1dGlsaXRpZXMgYW5kIGFkYXB0ZXJzIHRvIGludGVyYWN0IHdpdGggSHlwZXJsZWRnZXIgRmFicmljIG5ldHdvcmtzIHVzaW5nIERlY2FmLXRzLiBJdCBleHBvc2VzIHRoZSBGYWJyaWMgY2xpZW50IGFkYXB0ZXIsIGV2ZW50IGRpc3BhdGNoIHV0aWxpdGllcywgYW5kIGZpbGVzeXN0ZW0gaGVscGVycyBmb3IgbG9hZGluZyBpZGVudGl0aWVzIGFuZCBrZXlzLlxuICogQG1vZHVsZSBjbGllbnRcbiAqIEBtZW1iZXJPZiBtb2R1bGU6Zm9yLWZhYnJpY1xuICogQGV4YW1wbGVcbiAqIC8vIENyZWF0ZSBhIGNsaWVudCBhZGFwdGVyIGFuZCBzdWJtaXQgYSB0cmFuc2FjdGlvblxuICogLy8gU2VlIGFsc286IHtAbGluayBtb2R1bGU6Zm9yLWZhYnJpY35GYWJyaWNDbGllbnRBZGFwdGVyfSBhbmQge0BsaW5rIG1vZHVsZTpmb3ItZmFicmljfkZhYnJpY0NsaWVudERpc3BhdGNofVxuICovXG5cbmV4cG9ydCAqIGZyb20gXCIuL2ZhYnJpYy1mc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vRmFicmljQ2xpZW50QWRhcHRlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vRmFicmljQ2xpZW50RGlzcGF0Y2hcIjtcbmV4cG9ydCAqIGZyb20gXCIuLi9zaGFyZWQvdHlwZXNcIjtcbiJdfQ==

package/lib/esm/client/logging.d.ts

@@ -0,0 +1,60 @@
+import { Logger, LogLevel, MiniLogger, StringLike } from "@decaf-ts/logging";
+import { LoggingConfig } from "@decaf-ts/logging";
+/**
+ * @description Logger implementation tailored for Hyperledger Fabric clients.
+ * @summary Adapts the decaf-ts MiniLogger to route messages through a per-context Fabric logger, honoring configured log levels and formatting.
+ * @param {string} context - The logging context name used to scope the logger instance.
+ * @param {Partial<LoggingConfig> | undefined} conf - Optional logging configuration to override defaults for this context.
+ * @class FabricLogger
+ * @example
+ * ```typescript
+ * // In a Fabric client/service
+ * const logger = new FabricLogger('MyFabricService', { level: 'info' });
+ * logger.info('Processing transaction');
+ * logger.debug('Transaction details', { txId: '123' });
+ * logger.error('Something went wrong');
+ * ```
+ * @mermaid
+ * sequenceDiagram
+ *   autonumber
+ *   participant C as Caller
+ *   participant FL as FabricLogger
+ *   participant ML as MiniLogger (delegate)
+ *   C->>FL: info('Processing transaction')
+ *   FL->>FL: createLog(level,msg,stack)
+ *   FL->>ML: info(log)
+ *   C->>FL: error(new Error('x'))
+ *   FL->>FL: createLog(level,msg,stack)
+ *   FL->>ML: error(log)
+ */
+export declare class FabricLogger extends MiniLogger {
+    /**
+     * @description The underlying Fabric logger instance
+     */
+    protected logger: Logger;
+    constructor(context: string, conf: Partial<LoggingConfig> | undefined);
+    /**
+     * @description Logs a message at the specified level.
+     * @summary Overrides the base MiniLogger.log to forward to the internal Fabric-aware logger, enforcing configured thresholds.
+     * @param {LogLevel} level - The log level to use for this message.
+     * @param {StringLike | Error} msg - The message or error to log.
+     * @param {string} [stack] - Optional stack trace string for errors.
+     * @return {void}
+     * @mermaid
+     * sequenceDiagram
+     *   autonumber
+     *   participant C as Caller
+     *   participant FL as FabricLogger
+     *   participant ML as MiniLogger (delegate)
+     *   C->>FL: log(level, msg, stack?)
+     *   FL->>FL: check configured level
+     *   alt below threshold
+     *     FL-->>C: return
+     *   else above threshold
+     *     FL->>FL: createLog(level, msg, stack)
+     *     FL->>ML: method.call(logger, log)
+     *     ML-->>FL: void
+     *   end
+     */
+    protected log(level: LogLevel, msg: StringLike | Error, stack?: Error): void;
+}

package/lib/esm/client/logging.js

@@ -0,0 +1,98 @@
+import { Logging, LogLevel, MiniLogger, NumericLogLevels, } from "@decaf-ts/logging";
+/**
+ * @description Logger implementation tailored for Hyperledger Fabric clients.
+ * @summary Adapts the decaf-ts MiniLogger to route messages through a per-context Fabric logger, honoring configured log levels and formatting.
+ * @param {string} context - The logging context name used to scope the logger instance.
+ * @param {Partial<LoggingConfig> | undefined} conf - Optional logging configuration to override defaults for this context.
+ * @class FabricLogger
+ * @example
+ * ```typescript
+ * // In a Fabric client/service
+ * const logger = new FabricLogger('MyFabricService', { level: 'info' });
+ * logger.info('Processing transaction');
+ * logger.debug('Transaction details', { txId: '123' });
+ * logger.error('Something went wrong');
+ * ```
+ * @mermaid
+ * sequenceDiagram
+ *   autonumber
+ *   participant C as Caller
+ *   participant FL as FabricLogger
+ *   participant ML as MiniLogger (delegate)
+ *   C->>FL: info('Processing transaction')
+ *   FL->>FL: createLog(level,msg,stack)
+ *   FL->>ML: info(log)
+ *   C->>FL: error(new Error('x'))
+ *   FL->>FL: createLog(level,msg,stack)
+ *   FL->>ML: error(log)
+ */
+export class FabricLogger extends MiniLogger {
+    constructor(context, conf) {
+        super(context, conf);
+        this.logger = new MiniLogger(context, conf);
+    }
+    /**
+     * @description Logs a message at the specified level.
+     * @summary Overrides the base MiniLogger.log to forward to the internal Fabric-aware logger, enforcing configured thresholds.
+     * @param {LogLevel} level - The log level to use for this message.
+     * @param {StringLike | Error} msg - The message or error to log.
+     * @param {string} [stack] - Optional stack trace string for errors.
+     * @return {void}
+     * @mermaid
+     * sequenceDiagram
+     *   autonumber
+     *   participant C as Caller
+     *   participant FL as FabricLogger
+     *   participant ML as MiniLogger (delegate)
+     *   C->>FL: log(level, msg, stack?)
+     *   FL->>FL: check configured level
+     *   alt below threshold
+     *     FL-->>C: return
+     *   else above threshold
+     *     FL->>FL: createLog(level, msg, stack)
+     *     FL->>ML: method.call(logger, log)
+     *     ML-->>FL: void
+     *   end
+     */
+    log(level, msg, stack) {
+        if (NumericLogLevels[this.config("level")] <
+            NumericLogLevels[level])
+            return;
+        let method;
+        switch (level) {
+            case LogLevel.info:
+                method = this.logger.info;
+                break;
+            case LogLevel.verbose:
+                method = this.logger.verbose;
+                break;
+            case LogLevel.debug:
+                method = this.logger.debug;
+                break;
+            case LogLevel.error:
+                method = this.logger.error;
+                break;
+            case LogLevel.silly:
+                method = this.logger.silly;
+                break;
+            default:
+                throw new Error("Invalid log level");
+        }
+        method.call(this.logger, this.createLog(level, msg, stack));
+    }
+}
+/**
+ * @description Factory function for creating FabricLogger instances.
+ * @summary Produces a new FabricLogger bound to the provided context name and configuration.
+ * @param {string} object - The logging context name.
+ * @param {Partial<LoggingConfig> | undefined} config - Optional logging configuration.
+ * @return {FabricLogger} A new FabricLogger instance.
+ * @function factory
+ * @memberOf module:for-fabric.client
+ */
+const factory = (object, config) => {
+    return new FabricLogger(object, config || {});
+};
+// Set the factory as the default logger factory
+Logging.setFactory(factory);
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/client/services/LoggedService.d.ts

@@ -0,0 +1,42 @@
+import { Logger } from "@decaf-ts/logging";
+/**
+ * @description Base service with logging utilities.
+ * @summary Provides a lightweight abstract class that equips inheriting services with per-instance and static logger accessors using the decaf-ts logging facility. Intended to standardize logging across client-side services.
+ * @param {void} constructor - No constructor parameters; inheritors should call super().
+ * @class LoggedService
+ * @example
+ * // Extend LoggedService to gain logging helpers
+ * class UserService extends LoggedService {
+ *   async doWork() {
+ *     const log = this.log.for(this.doWork);
+ *     log.info("Working...");
+ *   }
+ * }
+ *
+ * // Static logger for class-level logging
+ * const sLog = (UserService as any).log;
+ * sLog.debug("Class level message");
+ */
+export declare abstract class LoggedService {
+    /**
+     * @description Cached static logger shared by all instances of this class
+     */
+    private static _log?;
+    /**
+     * @description Lazily created logger scoped to the concrete service instance
+     */
+    private _log?;
+    protected constructor();
+    /**
+     * @description Retrieves or creates the instance logger
+     * @summary Lazily initializes a logger using the class name of the concrete service and returns it for use in instance methods
+     * @return {Logger} The instance-specific logger
+     */
+    protected get log(): Logger;
+    /**
+     * @description Retrieves or creates the static logger for the class
+     * @summary Provides a logger not bound to a specific instance, suitable for class-level diagnostics
+     * @return {Logger} The class-level logger
+     */
+    protected static get log(): Logger;
+}

package/lib/esm/client/services/LoggedService.js

@@ -0,0 +1,43 @@
+import { Logging } from "@decaf-ts/logging";
+/**
+ * @description Base service with logging utilities.
+ * @summary Provides a lightweight abstract class that equips inheriting services with per-instance and static logger accessors using the decaf-ts logging facility. Intended to standardize logging across client-side services.
+ * @param {void} constructor - No constructor parameters; inheritors should call super().
+ * @class LoggedService
+ * @example
+ * // Extend LoggedService to gain logging helpers
+ * class UserService extends LoggedService {
+ *   async doWork() {
+ *     const log = this.log.for(this.doWork);
+ *     log.info("Working...");
+ *   }
+ * }
+ *
+ * // Static logger for class-level logging
+ * const sLog = (UserService as any).log;
+ * sLog.debug("Class level message");
+ */
+export class LoggedService {
+    constructor() { }
+    /**
+     * @description Retrieves or creates the instance logger
+     * @summary Lazily initializes a logger using the class name of the concrete service and returns it for use in instance methods
+     * @return {Logger} The instance-specific logger
+     */
+    get log() {
+        if (!this._log)
+            this._log = Logging.for(this.constructor.name);
+        return this._log;
+    }
+    /**
+     * @description Retrieves or creates the static logger for the class
+     * @summary Provides a logger not bound to a specific instance, suitable for class-level diagnostics
+     * @return {Logger} The class-level logger
+     */
+    static get log() {
+        if (!LoggedService._log)
+            LoggedService._log = Logging.get();
+        return LoggedService._log;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/client/services/constants.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @description Certificate Authority role types used during enrollment and registration.
+ * @summary Enumerates the standard Hyperledger Fabric CA roles that can be assigned to identities when registering with the CA service.
+ * @enum {string}
+ * @readonly
+ * @memberOf module:for-fabric.client
+ */
+export declare enum CA_ROLE {
+    /** Administrator role with elevated privileges for managing identities and affiliations */
+    ADMIN = "admin",
+    /** Standard user role for application clients interacting with the network */
+    USER = "user",
+    /** Client role typically used for SDK-based interactions and service accounts */
+    CLIENT = "client"
+}

package/lib/esm/client/services/constants.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2NsaWVudC9zZXJ2aWNlcy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGRlc2NyaXB0aW9uIENlcnRpZmljYXRlIEF1dGhvcml0eSByb2xlIHR5cGVzIHVzZWQgZHVyaW5nIGVucm9sbG1lbnQgYW5kIHJlZ2lzdHJhdGlvbi5cbiAqIEBzdW1tYXJ5IEVudW1lcmF0ZXMgdGhlIHN0YW5kYXJkIEh5cGVybGVkZ2VyIEZhYnJpYyBDQSByb2xlcyB0aGF0IGNhbiBiZSBhc3NpZ25lZCB0byBpZGVudGl0aWVzIHdoZW4gcmVnaXN0ZXJpbmcgd2l0aCB0aGUgQ0Egc2VydmljZS5cbiAqIEBlbnVtIHtzdHJpbmd9XG4gKiBAcmVhZG9ubHlcbiAqIEBtZW1iZXJPZiBtb2R1bGU6Zm9yLWZhYnJpYy5jbGllbnRcbiAqL1xuZXhwb3J0IGRlY2xhcmUgZW51bSBDQV9ST0xFIHtcbiAgLyoqIEFkbWluaXN0cmF0b3Igcm9sZSB3aXRoIGVsZXZhdGVkIHByaXZpbGVnZXMgZm9yIG1hbmFnaW5nIGlkZW50aXRpZXMgYW5kIGFmZmlsaWF0aW9ucyAqL1xuICBBRE1JTiA9IFwiYWRtaW5cIixcbiAgLyoqIFN0YW5kYXJkIHVzZXIgcm9sZSBmb3IgYXBwbGljYXRpb24gY2xpZW50cyBpbnRlcmFjdGluZyB3aXRoIHRoZSBuZXR3b3JrICovXG4gIFVTRVIgPSBcInVzZXJcIixcbiAgLyoqIENsaWVudCByb2xlIHR5cGljYWxseSB1c2VkIGZvciBTREstYmFzZWQgaW50ZXJhY3Rpb25zIGFuZCBzZXJ2aWNlIGFjY291bnRzICovXG4gIENMSUVOVCA9IFwiY2xpZW50XCIsXG59XG4iXX0=