@decaf-ts/for-fabric 0.0.2

package/lib/client/fabric-fs.cjs

@@ -0,0 +1,234 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contentOfLoadFile = contentOfLoadFile;
+exports.readFile = readFile;
+exports.getCAUser = getCAUser;
+exports.getIdentity = getIdentity;
+exports.getFirstDirFileName = getFirstDirFileName;
+exports.getFirstDirFileNameContent = getFirstDirFileNameContent;
+exports.getSigner = getSigner;
+exports.extractPrivateKey = extractPrivateKey;
+const utils_1 = require("@decaf-ts/utils");
+const logging_1 = require("@decaf-ts/logging");
+const fabric_common_1 = require("fabric-common");
+const fabric_gateway_1 = require("@hyperledger/fabric-gateway");
+const db_decorators_1 = require("@decaf-ts/db-decorators");
+const log = logging_1.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
+ */
+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
+ */
+async function readFile(contentOrPath) {
+    if (typeof contentOrPath !== "string")
+        return contentOrPath;
+    const fileReader = async (path) => {
+        const { promises } = await (0, utils_1.normalizeImport)(Promise.resolve().then(() => __importStar(require("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
+ */
+async function getCAUser(userName, privateKey, certificate, mspId) {
+    log.debug(`Creating a CA ${mspId} user ${userName} with certificate ${certificate}`);
+    const user = new fabric_common_1.User(userName);
+    const cryptoSuite = fabric_common_1.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
+ */
+async function getIdentity(mspId, certDirectoryPath) {
+    const identityFileReader = async (path) => {
+        const { promises } = await (0, utils_1.normalizeImport)(Promise.resolve().then(() => __importStar(require("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
+ */
+async function getFirstDirFileName(dirPath) {
+    const { promises } = await (0, utils_1.normalizeImport)(Promise.resolve().then(() => __importStar(require("fs"))));
+    const { join } = await (0, utils_1.normalizeImport)(Promise.resolve().then(() => __importStar(require("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
+ */
+async function getFirstDirFileNameContent(dirPath) {
+    const { promises } = await (0, utils_1.normalizeImport)(Promise.resolve().then(() => __importStar(require("fs"))));
+    const { join } = await (0, utils_1.normalizeImport)(Promise.resolve().then(() => __importStar(require("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
+ */
+async function getSigner(keyDirectoryPath) {
+    const signerFileReader = async (path) => {
+        const { promises } = await (0, utils_1.normalizeImport)(Promise.resolve().then(() => __importStar(require("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 fabric_gateway_1.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
+ */
+async function extractPrivateKey(pem) {
+    const libName = "crypto";
+    let subtle;
+    if ((0, logging_1.isBrowser)()) {
+        subtle = globalThis.crypto.subtle;
+    }
+    else {
+        const lib = (await (0, utils_1.normalizeImport)(Promise.resolve(`${libName}`).then(s => __importStar(require(s)))));
+        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 db_decorators_1.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/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/client/index.cjs

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * @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}
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./fabric-fs.cjs"), exports);
+__exportStar(require("./FabricClientAdapter.cjs"), exports);
+__exportStar(require("./FabricClientDispatch.cjs"), exports);
+__exportStar(require("./../shared/types.cjs"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2xpZW50L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7Ozs7R0FRRzs7Ozs7Ozs7Ozs7Ozs7OztBQUVILGtEQUE0QjtBQUM1Qiw0REFBc0M7QUFDdEMsNkRBQXVDO0FBQ3ZDLHdEQUFnQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGRlc2NyaXB0aW9uIEh5cGVybGVkZ2VyIEZhYnJpYyBDbGllbnQgTW9kdWxlIGZvciBEZWNhZi10c1xuICogQHN1bW1hcnkgVGhpcyBtb2R1bGUgcHJvdmlkZXMgY2xpZW50LXNpZGUgdXRpbGl0aWVzIGFuZCBhZGFwdGVycyB0byBpbnRlcmFjdCB3aXRoIEh5cGVybGVkZ2VyIEZhYnJpYyBuZXR3b3JrcyB1c2luZyBEZWNhZi10cy4gSXQgZXhwb3NlcyB0aGUgRmFicmljIGNsaWVudCBhZGFwdGVyLCBldmVudCBkaXNwYXRjaCB1dGlsaXRpZXMsIGFuZCBmaWxlc3lzdGVtIGhlbHBlcnMgZm9yIGxvYWRpbmcgaWRlbnRpdGllcyBhbmQga2V5cy5cbiAqIEBtb2R1bGUgY2xpZW50XG4gKiBAbWVtYmVyT2YgbW9kdWxlOmZvci1mYWJyaWNcbiAqIEBleGFtcGxlXG4gKiAvLyBDcmVhdGUgYSBjbGllbnQgYWRhcHRlciBhbmQgc3VibWl0IGEgdHJhbnNhY3Rpb25cbiAqIC8vIFNlZSBhbHNvOiB7QGxpbmsgbW9kdWxlOmZvci1mYWJyaWN+RmFicmljQ2xpZW50QWRhcHRlcn0gYW5kIHtAbGluayBtb2R1bGU6Zm9yLWZhYnJpY35GYWJyaWNDbGllbnREaXNwYXRjaH1cbiAqL1xuXG5leHBvcnQgKiBmcm9tIFwiLi9mYWJyaWMtZnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0ZhYnJpY0NsaWVudEFkYXB0ZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0ZhYnJpY0NsaWVudERpc3BhdGNoXCI7XG5leHBvcnQgKiBmcm9tIFwiLi4vc2hhcmVkL3R5cGVzXCI7XG4iXX0=

package/lib/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/client/logging.cjs

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FabricLogger = void 0;
+const logging_1 = require("@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)
+ */
+class FabricLogger extends logging_1.MiniLogger {
+    constructor(context, conf) {
+        super(context, conf);
+        this.logger = new logging_1.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 (logging_1.NumericLogLevels[this.config("level")] <
+            logging_1.NumericLogLevels[level])
+            return;
+        let method;
+        switch (level) {
+            case logging_1.LogLevel.info:
+                method = this.logger.info;
+                break;
+            case logging_1.LogLevel.verbose:
+                method = this.logger.verbose;
+                break;
+            case logging_1.LogLevel.debug:
+                method = this.logger.debug;
+                break;
+            case logging_1.LogLevel.error:
+                method = this.logger.error;
+                break;
+            case logging_1.LogLevel.silly:
+                method = this.logger.silly;
+                break;
+            default:
+                throw new Error("Invalid log level");
+        }
+        method.call(this.logger, this.createLog(level, msg, stack));
+    }
+}
+exports.FabricLogger = FabricLogger;
+/**
+ * @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_1.Logging.setFactory(factory);
+//# sourceMappingURL=data:application/json;base64,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

package/lib/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/client/services/LoggedService.cjs

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggedService = void 0;
+const logging_1 = require("@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");
+ */
+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_1.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_1.Logging.get();
+        return LoggedService._log;
+    }
+}
+exports.LoggedService = LoggedService;
+//# sourceMappingURL=data:application/json;base64,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