@konplit-services/common 1.0.268 → 1.0.270

package/build/events/subjects.d.ts

@@ -67,6 +67,8 @@ export declare enum Subjects {
     TransactionDeclined = "events.transaction.declined",
     TransactionDailyResetAmountCreated = "events.transaction.daily.reset.created",
     TransactionAmountUpdateSyncCreated = "events.transaction.amount.update.sync.created",
+    TransactionExpiryDelayCreated = "events.transaction.expiry.delay.created",
+    TransactionExpiryDelayUpdated = "events.transaction.expiry.delay.updated",
     QRDynamicCodeCancelled = "events.qrdynamiccode.cancelled",
     QRQueryOrderStatus = "events.qrqueryorder.status",
     QRQueryStatusDelay = "events.qrqueryorder.delay",

package/build/events/subjects.js

@@ -91,6 +91,8 @@ var Subjects;
     Subjects["TransactionDeclined"] = "events.transaction.declined";
     Subjects["TransactionDailyResetAmountCreated"] = "events.transaction.daily.reset.created";
     Subjects["TransactionAmountUpdateSyncCreated"] = "events.transaction.amount.update.sync.created";
+    Subjects["TransactionExpiryDelayCreated"] = "events.transaction.expiry.delay.created";
+    Subjects["TransactionExpiryDelayUpdated"] = "events.transaction.expiry.delay.updated";
     //NIBSS
     //QRCODE
     Subjects["QRDynamicCodeCancelled"] = "events.qrdynamiccode.cancelled";

package/build/events/transaction-events/interfaces/expiry-delay-timer.interface.d.ts

@@ -0,0 +1,10 @@
+import { StreamEvent, StreamName, Subjects } from "../../subjects";
+export interface TransactionExpiryDelayEvent {
+    subject: Subjects.TransactionExpiryDelayCreated;
+    streamName: StreamName.name;
+    streamEvents: StreamEvent.Event;
+    data: {
+        transactionId: string;
+        delay: number;
+    };
+}

package/build/events/transaction-events/interfaces/expiry-delay-timer.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/events/transaction-events/interfaces/expiry-delay-timer.update.interface.d.ts

@@ -0,0 +1,9 @@
+import { StreamEvent, StreamName, Subjects } from "../../subjects";
+export interface TransactionExpiryDelayCompletedEvent {
+    subject: Subjects.TransactionExpiryDelayUpdated;
+    streamName: StreamName.name;
+    streamEvents: StreamEvent.Event;
+    data: {
+        transactionId: string;
+    };
+}

package/build/events/transaction-events/interfaces/expiry-delay-timer.update.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/helper/encryptions.d.ts

@@ -0,0 +1,58 @@
+/// <reference types="node" />
+/**
+ * this is how the aes key and iv should be generated
+ *
+ * @returns
+ */
+export declare const generateAesKeyAndIv: () => {
+    aesKey: Buffer;
+    iv: Buffer;
+};
+/**
+ *
+ * @param data the data as string to be encrypted use JSON.stringify on objects
+ * @param aesKey
+ * @param iv
+ * @returns base 64 of the iv and encrypted data in iv:data
+ */
+export declare const encryptWithAes: (data: string, aesKey: Buffer, iv: Buffer) => string;
+/**
+ *
+ * @param aesKey  the key generated  for encryption
+ * @param publicKey  the public key shared will always be on the validation payload
+ * @returns
+ */
+export declare const encryptWithRsaPublicKey: (aesKey: Buffer, publicKey: string) => string;
+/**
+ *
+ * @param encryptedAesKey the encrypted Aes key to be decrypted by the private key for transaction processing
+ * @param privateKey the secured save private key
+ * @returns
+ */
+export declare const decryptWithRsaPrivateKey: (encryptedAesKey: string, privateKey: string) => Buffer;
+/**
+ *
+ * @param encryptedDataWithIv the encrypted data that was encrypted in the format iv:data
+ * @param aesKey the AES key as Buffer obtain from the decryption of the data
+ * @returns return data as string
+ */
+export declare const decryptWithAes: (encryptedDataWithIv: string, aesKey: Buffer) => string;
+/**
+ *
+ * @param data data to be encrpted as string
+ * @param publicKey  the RSA public key
+ * @returns
+ */
+export declare const hybridEncrypt: (data: string, publicKey: string) => {
+    encryptedData: string;
+    encryptedAesKey: string;
+    iv: string;
+};
+/**
+ *
+ * @param encryptedData  the encrypted data as a strig
+ * @param encryptedAesKey  the encrypted AESKey data as string
+ * @param privateKey the private key of the RSA
+ * @returns  string
+ */
+export declare const hybridDecrypt: (encryptedData: string, encryptedAesKey: string, privateKey: string) => string;

package/build/helper/encryptions.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hybridDecrypt = exports.hybridEncrypt = exports.decryptWithAes = exports.decryptWithRsaPrivateKey = exports.encryptWithRsaPublicKey = exports.encryptWithAes = exports.generateAesKeyAndIv = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+/**
+ * this is how the aes key and iv should be generated
+ *
+ * @returns
+ */
+const generateAesKeyAndIv = () => {
+    const aesKey = crypto_1.default.randomBytes(32); // 256-bit key
+    const iv = crypto_1.default.randomBytes(16); // 128-bit IV
+    return { aesKey, iv };
+};
+exports.generateAesKeyAndIv = generateAesKeyAndIv;
+/**
+ *
+ * @param data the data as string to be encrypted use JSON.stringify on objects
+ * @param aesKey
+ * @param iv
+ * @returns base 64 of the iv and encrypted data in iv:data
+ */
+const encryptWithAes = (data, aesKey, iv) => {
+    const cipher = crypto_1.default.createCipheriv("aes-256-cbc", aesKey, iv);
+    let encrypted = cipher.update(data, "utf8", "base64");
+    encrypted += cipher.final("base64");
+    // Prepend the IV to the ciphertext (IV is not secret but must be unique)
+    return iv.toString("base64") + ":" + encrypted;
+};
+exports.encryptWithAes = encryptWithAes;
+/**
+ *
+ * @param aesKey  the key generated  for encryption
+ * @param publicKey  the public key shared will always be on the validation payload
+ * @returns
+ */
+const encryptWithRsaPublicKey = (aesKey, publicKey) => {
+    const encryptedKey = crypto_1.default.publicEncrypt({
+        key: publicKey,
+        padding: crypto_1.default.constants.RSA_PKCS1_OAEP_PADDING,
+        oaepHash: "sha256",
+    }, aesKey);
+    return encryptedKey.toString("base64");
+};
+exports.encryptWithRsaPublicKey = encryptWithRsaPublicKey;
+/**
+ *
+ * @param encryptedAesKey the encrypted Aes key to be decrypted by the private key for transaction processing
+ * @param privateKey the secured save private key
+ * @returns
+ */
+const decryptWithRsaPrivateKey = (encryptedAesKey, privateKey) => {
+    const decryptedKey = crypto_1.default.privateDecrypt({
+        key: privateKey,
+        padding: crypto_1.default.constants.RSA_PKCS1_OAEP_PADDING,
+        oaepHash: "sha256",
+    }, Buffer.from(encryptedAesKey, "base64"));
+    return decryptedKey;
+};
+exports.decryptWithRsaPrivateKey = decryptWithRsaPrivateKey;
+/**
+ *
+ * @param encryptedDataWithIv the encrypted data that was encrypted in the format iv:data
+ * @param aesKey the AES key as Buffer obtain from the decryption of the data
+ * @returns return data as string
+ */
+const decryptWithAes = (encryptedDataWithIv, aesKey) => {
+    // Split the IV and the encrypted data
+    const [ivBase64, encryptedData] = encryptedDataWithIv.split(":");
+    const iv = Buffer.from(ivBase64, "base64");
+    // Decrypt the data
+    const decipher = crypto_1.default.createDecipheriv("aes-256-cbc", aesKey, iv);
+    let decrypted = decipher.update(encryptedData, "base64", "utf8");
+    decrypted += decipher.final("utf8");
+    return decrypted;
+};
+exports.decryptWithAes = decryptWithAes;
+/**
+ *
+ * @param data data to be encrpted as string
+ * @param publicKey  the RSA public key
+ * @returns
+ */
+const hybridEncrypt = (data, publicKey) => {
+    // Step 1: Generate AES key and IV
+    const { aesKey, iv } = (0, exports.generateAesKeyAndIv)();
+    // Step 2: Encrypt data with AES
+    const encryptedData = (0, exports.encryptWithAes)(data, aesKey, iv);
+    // Step 3: Encrypt AES key with RSA public key
+    const encryptedAesKey = (0, exports.encryptWithRsaPublicKey)(aesKey, publicKey);
+    // Return the encrypted data, encrypted AES key, and IV
+    return {
+        encryptedData,
+        encryptedAesKey,
+        iv: iv.toString("base64"), // IV is not secret but must be unique no need to return it
+    };
+};
+exports.hybridEncrypt = hybridEncrypt;
+/**
+ *
+ * @param encryptedData  the encrypted data as a strig
+ * @param encryptedAesKey  the encrypted AESKey data as string
+ * @param privateKey the private key of the RSA
+ * @returns  string
+ */
+const hybridDecrypt = (encryptedData, encryptedAesKey, privateKey) => {
+    // Step 1: Decrypt AES key with RSA private key
+    const aesKey = (0, exports.decryptWithRsaPrivateKey)(encryptedAesKey, privateKey);
+    const decryptedData = (0, exports.decryptWithAes)(encryptedData, aesKey);
+    return decryptedData;
+};
+exports.hybridDecrypt = hybridDecrypt;

package/build/helper/index.d.ts

@@ -45,3 +45,4 @@ export * from "./keys";
 export * from "./wallet-transaction.types";
 export * from "./generate-query-params";
 export * from "./subscription-cron-expression";
+export * from "./encryptions";

package/build/helper/index.js

@@ -61,3 +61,4 @@ __exportStar(require("./keys"), exports);
 __exportStar(require("./wallet-transaction.types"), exports);
 __exportStar(require("./generate-query-params"), exports);
 __exportStar(require("./subscription-cron-expression"), exports);
+__exportStar(require("./encryptions"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@konplit-services/common",
-  "version": "1.0.268",
+  "version": "1.0.270",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",