Merkle Tree Project

client/index.js

@@ -5,13 +5,27 @@ const MerkleTree = require('../utils/MerkleTree');
 const serverUrl = 'http://localhost:1225';
 
 async function main() {
-  // TODO: how do we prove to the server we're on the nice list? 
+  // TODO: how do we prove to the server we're on the nice list?
+  const tree = new MerkleTree(niceList);
 
-  const { data: gift } = await axios.post(`${serverUrl}/gift`, {
-    // TODO: add request body parameters here!
-  });
+    const name = "Ephyrian";  // Example name to prove
 
-  console.log({ gift });
+    const index = niceList.findIndex(n => n === name); 
+
+      const proof = tree.getProof(index);
+
+      const root = tree.getRoot();   /* Only for demonstration, not to be sent */
+
+
+      const { data: gift } = await axios.post(`${serverUrl}/gift`, {
+        // TODO: add request body parameters here!
+        name: name,
+        proof: proof,
+        root: root  /* This could be for additional verification */
+      });
+
+      console.log("Sending to server:", { name, proof });
+      console.log({ gift });
 }
 
 main();

server/index.js

@@ -1,21 +1,27 @@
 const express = require('express');
-const verifyProof = require('../utils/verifyProof');
+const { verifyProof, concat } = require('../utils/verifyProof');
+const { keccak256 } = require('ethereum-cryptography/keccak');
 
 const port = 1225;
 
 const app = express();
 app.use(express.json());
 
 // TODO: hardcode a merkle root here representing the whole nice list
-// paste the hex string in here, without the 0x prefix
-const MERKLE_ROOT = '';
+// (paste the hex string in here, without the 0x prefix)
+const MERKLE_ROOT = '4cdf89e56895bbcabd3551d431b8ba74239d026cfac7af5fcb1c15934a4eaf34';
 
 app.post('/gift', (req, res) => {
   // grab the parameters from the front-end here
-  const body = req.body;
+  const { name, proof } = req.body;
+  const leaf = keccak256(Buffer.from(name)).toString('hex'); // Assuming names are stored as simple hex strings in the tree
+
+  console.log("Received proof for:", name, " with proof:", proof);
 
   // TODO: prove that a name is in the list 
-  const isInTheList = false;
+  const isInTheList = verifyProof(proof, leaf, MERKLE_ROOT, concat);
+  console.log("Verification result:", isInTheList);
+
   if(isInTheList) {
     res.send("You got a toy robot!");
   }
@@ -24,6 +30,7 @@ app.post('/gift', (req, res) => {
   }
 });
 
+
 app.listen(port, () => {
   console.log(`Listening on port ${port}!`);
-});
+});

utils/MerkleTree.js

@@ -67,4 +67,4 @@ class MerkleTree {
   }
 }
 
-module.exports = MerkleTree;
+module.exports = MerkleTree;

utils/niceList.json

@@ -998,5 +998,10 @@
   "Everett Bergnaum DVM",
   "Mr. Marty Fahey",
   "Joel Raynor",
-  "Edmond Carroll PhD"
-]
+  "Edmond Carroll PhD",
+  "Homer J. Simpson",
+  "Peter Griffin",
+  "Stan Smith",
+  "Cleveland Brown",
+  "Ephyrian"
+]

utils/verifyProof.js

@@ -1,23 +1,41 @@
 const { keccak256 } = require('ethereum-cryptography/keccak');
-const { hexToBytes, bytesToHex } = require('ethereum-cryptography/utils');
+const { bytesToHex } = require('ethereum-cryptography/utils');
 
 const concat = (left, right) => keccak256(Buffer.concat([left, right]));
 
 function verifyProof(proof, leaf, root) {
-  proof = proof.map(({data, left}) => ({ 
-    left, data: hexToBytes(data)
+
+    proof = proof.map(({data, left}) => ({ 
+    left, data: Buffer.from(data, 'hex')
   }));
+
   let data = keccak256(Buffer.from(leaf));
+  console.log("Initial hash from leaf:", bytesToHex(data));
 
   for (let i = 0; i < proof.length; i++) {
-    if (proof[i].left) {
-      data = concat(proof[i].data, data);
-    } else {
-      data = concat(data, proof[i].data);
-    }
+
+    console.log(`Step ${i}, applying data: ${bytesToHex(proof[i].data)}, left: ${proof[i].left}`);
+
+    data = proof[i].left ? concat(proof[i].data, data) : concat(data, proof[i].data);
+    console.log(`Hash after step ${i}:`, bytesToHex(data));
   }
 
-  return bytesToHex(data) === root;
+    const finalComputedRoot = bytesToHex(data);
+
+  console.log("Computed root:", bytesToHex(data));
+  console.log("Expected root:", root);
+
+  return finalComputedRoot === root;
 }
 
-module.exports = verifyProof;
+module.exports = { verifyProof, concat };
+
+
+
+
+
+
+
+
+
+