write tests with using getting key from Hub

Author: ArtemHvozdov

contracts/Hub.sol

@@ -39,9 +39,9 @@ contract Hub {
         emit PublicKeyRegistered(heir, publicKey);
     }
 
-    function registerPubKeyOracle(bytes calldata publicKey) public {
-        registeredKeys[msg.sender] = publicKey;
-        emit PublicKeyRegistered(msg.sender, publicKey);
+    function registerPubKeyOracle(address oracle, bytes calldata publicKey) public {
+        registeredKeys[oracle] = publicKey;
+        emit PublicKeyRegistered(oracle, publicKey);
     }
 
     //Function for getting public keys

dapps/utils/compress-key-browser-version.js

@@ -1,13 +1,18 @@
-// const compressKey = require('./compress-key.js');
-
-const compressKey = require('./compress-key-browser-version.js');
 const sodium = require('sodium-universal');
 const CryptoJS = require('crypto-js');
 const cryptoConfigConstant = require('./crypto-config-constant.js');
 
 async function decryptIM(encryptedMessage, recipientPrivateKey, senderPublicKey) {
     return new Promise((resolve, reject) => {
         try {
+            if (recipientPrivateKey.startsWith("0x")) {
+                recipientPrivateKey = recipientPrivateKey.substring(2);
+            }
+
+            if (senderPublicKey.startsWith("0x")) {
+                senderPublicKey = senderPublicKey.substring(2);
+            }
+
             const privKeyBuf = Uint8Array.from(recipientPrivateKey.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
             const pubKeyBuf = Uint8Array.from(senderPublicKey.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
 

dapps/utils/compress-key.js

@@ -1,13 +1,23 @@
-// const compressKey = require('./compress-key.js');
-
-const compressKey = require('./compress-key-browser-version.js');
 const sodium = require('sodium-universal');
 const CryptoJS = require('crypto-js');
 const cryptoConfigConstant = require('./crypto-config-constant.js');
 
 async function encryptIM(message, senderPrivateKey, recipientPublicKey) {
     return new Promise((resolve, reject) => {
         try {
+
+            if (typeof message === 'object') {
+                message = JSON.stringify(message);
+            }
+
+            if (senderPrivateKey.startsWith("0x")) {
+                senderPrivateKey = senderPrivateKey.substring(2);
+            }
+
+            if (recipientPublicKey.startsWith("0x")) {
+                recipientPublicKey = recipientPublicKey.substring(2);
+            }
+
             const privKeyBuf = Uint8Array.from(senderPrivateKey.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
             const pubKeyBuf = Uint8Array.from(recipientPublicKey.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
 

dapps/utils/decrypt-im-browser-version.js

@@ -82,7 +82,7 @@ describe("Encryption and Decryption", function () {
         expect(decryptedMessageFromOwnerToOracle).to.equal(encryptedMessage)
     })
 
-    it("create new account using ether.js and private key", async function () {
+    it("should encrypt the message, send it to Oracle, Oracle should encrypt and send it Heir, Heir should decrypt it from Oracle and decrypt it from Owner ", async function () {
         const message = "Hello, world!";
 
         // Encrypting a message from Owner to Heir

dapps/utils/decrypt-im.js

@@ -51,8 +51,8 @@ describe("Hub Contract", function () {
         it("should register public key for oracle", async function () {
             const expectedPublicKey = "0x9876543210FEDCBA"; // Expected public key value by oracle
 
-            await hubContract.connect(owner).registerPubKeyOracle(expectedPublicKey);
-            const registeredPublicKey = await hubContract.registeredKeys(owner.address);
+            await hubContract.connect(owner).registerPubKeyOracle(oracle.address, expectedPublicKey);
+            const registeredPublicKey = await hubContract.registeredKeys(oracle.address);
 
             expect(registeredPublicKey.toLowerCase()).to.equal(expectedPublicKey.toLowerCase());
         });

dapps/utils/encrypt-im-browser-version.js

@@ -1,32 +1,64 @@
-// const { expect } = require("chai");
-// const {ethers} = require("hardhat");
-// const encryptIM = require("./../dapps/utils/encrypt-im.js");
-// const decryptIM = require("./../dapps/utils/decrypt-im.js");
-// const { describe } = require("mocha");
-
-
-// describe("New encrypr decrypt tests functions", function() {
-//     let Hub;
-//     let hubContract;
-//     let owner;
-//     let heir;
-//     let oracle;
-
-//     before(async function() {
-//         Hub = await ethers.getContractFactory("Hub");
-//         [owner, heir, oracle] = await ethers.getSigners();
-//         ethers.ge
-
-//         hubContract = await Hub.deploy();
-//         await hubContract.deployed();
-//     })
-
-//     it("should encrypt and decrypt the message in Hub Smart Contract", async function() {
-//         const ownerPublicKey = await owner.getPublicKey();
-
-//         await hubContract.connect(owner).registerPubKeyOwner(ownerPublicKey);
-//         const registerPubKeyHeirByOwner = await hubContract.registeredKeys(owner.address);
-
-//         expect(registerPubKeyHeirByOwner).to.equal(ownerPublicKey);
-//     })
-// })
+const { expect } = require("chai");
+const { ethers } = require("hardhat");
+
+const encryptIM = require("./../dapps/utils/encrypt-im-browser-version.js");
+const decryptIM = require("./../dapps/utils/decrypt-im-browser-version.js");
+
+describe("New encryption and decryption", function () {
+    let Hub;
+    let hubContract;
+    let owner;
+    let heir;
+    let oracle;
+
+    before(async function () {
+        Hub = await ethers.getContractFactory("Hub");
+        [owner, heir, oracle] = await ethers.getSigners();
+        ethers.ge
+
+        hubContract = await Hub.deploy();
+        await hubContract.deployed();
+    });
+
+    const accounts = {
+        Owner: {
+            address: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+            publicKey: '9adac7a7558764cf6bc45d88968b7d1e27b95e641c2827fba034350e91a44d22',
+            privateKey: 'ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+        },
+        Heir: {
+            address: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
+            publicKey: '107302eea84f3f75c50184df4102862bf50f6fbcee88bf9d7d33852ab90f302d',
+            privateKey: '59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d',
+        },
+        Oracle: {
+            address: "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",
+            publicKey: '9a09fdb91965386b6705c734ed36c3265144967b823e23a1b665ae8be922683c',
+            privateKey: '5de4111afa1a4b94908f83103eb1f1706367c2e68ca870fc3fb9a804cdab365a',
+        }
+    }
+
+    it("should register public keys for owner, heir, and oracle", async function () {
+        const ownerPublicKey = '0x' + accounts.Owner.publicKey;
+        const heirPublicKey = '0x' + accounts.Heir.publicKey;
+        const oraclePublicKey = '0x' + accounts.Oracle.publicKey;
+
+        const message = "Hello world!";
+    
+        await hubContract.connect(owner).registerPubKeyOwner(ownerPublicKey);
+        await hubContract.connect(owner).registerPubKeyHeir(heir.address, heirPublicKey);
+        await hubContract.connect(owner).registerPubKeyOracle(oracle.address, oraclePublicKey);
+       
+        const contractPublicKeyOwner = await hubContract.getPubKey(owner.address);
+        const contractPublicKeyHeir = await hubContract.getPubKey(heir.address);
+        const contractPublicKeyOracle = await hubContract.getPubKey(oracle.address);
+
+        const encryptedMessage = await encryptIM(message, accounts.Owner.privateKey, contractPublicKeyHeir);
+        console.log("encryptedMessage:", encryptedMessage)
+
+        const decryptedMessage = await decryptIM(encryptedMessage, accounts.Heir.privateKey, contractPublicKeyOwner);
+        console.log("decryptedMessage:", decryptedMessage)
+
+        expect(decryptedMessage).to.equal(message);
+    });
+})