diff --git a/.gitmodules b/.gitmodules
index 322d68162..66888488c 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -4,3 +4,6 @@ url = https://github.com/OpenZeppelin/openzeppelin-contracts
 [submodule "dao/dao/Openzeppelin-DAO"]
 path = dao/dao/Openzeppelin-DAO
 url = https://github.com/tamphill/openzeppelin_dao.git
+[submodule "basic/79-hardhat-foundry/lib/openzeppelin-contracts"]
+	path = basic/79-hardhat-foundry/lib/openzeppelin-contracts
+	url = https://github.com/Openzeppelin/openzeppelin-contracts
diff --git a/basic/07-hardhat/contracts/Greeter.sol b/basic/07-hardhat/contracts/Greeter.sol
index 60502c5ad..e70e5bbf4 100644
--- a/basic/07-hardhat/contracts/Greeter.sol
+++ b/basic/07-hardhat/contracts/Greeter.sol
@@ -1,9 +1,6 @@
 //SPDX-License-Identifier: Unlicense
 pragma solidity ^0.8.0;
 
-
-
-
 contract Greeter {
   string greeting;
 
diff --git a/basic/07-hardhat/hardhat.config.js b/basic/07-hardhat/hardhat.config.js
index e1e514c7b..750b7a978 100644
--- a/basic/07-hardhat/hardhat.config.js
+++ b/basic/07-hardhat/hardhat.config.js
@@ -21,6 +21,11 @@ function mnemonic() {
 module.exports = {
   solidity: '0.8.0',
   networks: {
+    hardhat: {
+      forking: {
+        url: 'https://mainnet.infura.io/v3/'+ process.env.INFURA_ID,
+      }
+    },
     localhost: {
       url: 'http://localhost:8545',
       //gasPrice: 125000000000,  // you can adjust gasPrice locally to see how much it will cost on production
diff --git a/basic/07-hardhat/package.json b/basic/07-hardhat/package.json
index 813f723bc..291e9c9c2 100644
--- a/basic/07-hardhat/package.json
+++ b/basic/07-hardhat/package.json
@@ -23,5 +23,8 @@
     "hardhat-deploy-ethers": "^0.3.0-beta.13",
     "mocha": "^10.0.0",
     "sol-merger": "^3.1.0"
+  },
+  "dependencies": {
+    "@openzeppelin/contracts": "^5.0.0"
   }
 }
diff --git a/basic/07-hardhat/scripts/deploy.js b/basic/07-hardhat/scripts/deploy.js
index 701bc9c80..61c32f4dd 100644
--- a/basic/07-hardhat/scripts/deploy.js
+++ b/basic/07-hardhat/scripts/deploy.js
@@ -15,10 +15,9 @@ async function main() {
   const Token = await ethers.getContractFactory('SimpleToken');
   const token = await Token.deploy('SimpleToken', 'SimpleToken', 18, 10000000000);
 
-  console.log('Token address:', token.address);
+  console.log('deploy address:', token.address);
 
-  let balance = await token.balanceOf(deployer.address);
-  console.log(balance.toString());
+ 
 }
 
 // We recommend this pattern to be able to use async/await everywhere
diff --git a/basic/22-zk-snarkjs/.gitignore b/basic/22-zk-snarkjs/.gitignore
index 9a80525be..bf1344229 100644
--- a/basic/22-zk-snarkjs/.gitignore
+++ b/basic/22-zk-snarkjs/.gitignore
@@ -14,3 +14,4 @@ witness.wtns
 witness.json
 proof.json
 proving_key.json
+*//multiplier2_cpp/
\ No newline at end of file
diff --git a/basic/22-zk-snarkjs/circom2/Multiplier2.circom b/basic/22-zk-snarkjs/circom2/Multiplier2.circom
new file mode 100644
index 000000000..de5387f20
--- /dev/null
+++ b/basic/22-zk-snarkjs/circom2/Multiplier2.circom
@@ -0,0 +1,16 @@
+pragma circom 2.0.0;
+
+/*This circuit template checks that c is the multiplication of a and b.*/  
+
+template Multiplier2 () {  
+
+   // Declaration of signals.  
+   signal input a;  
+   signal input b;  
+   signal output c;  
+
+   // Constraints.  
+   c <== a * b;  
+}
+
+component main = Multiplier2();
\ No newline at end of file
diff --git a/basic/22-zk-snarkjs/circom2/circuit_final.zkey b/basic/22-zk-snarkjs/circom2/circuit_final.zkey
new file mode 100644
index 000000000..89e471828
Binary files /dev/null and b/basic/22-zk-snarkjs/circom2/circuit_final.zkey differ
diff --git a/basic/22-zk-snarkjs/circom2/multiplier2.r1cs b/basic/22-zk-snarkjs/circom2/multiplier2.r1cs
new file mode 100644
index 000000000..e61b9b091
Binary files /dev/null and b/basic/22-zk-snarkjs/circom2/multiplier2.r1cs differ
diff --git a/basic/22-zk-snarkjs/circom2/multiplier2.r1cs.json b/basic/22-zk-snarkjs/circom2/multiplier2.r1cs.json
new file mode 100644
index 000000000..959be3988
--- /dev/null
+++ b/basic/22-zk-snarkjs/circom2/multiplier2.r1cs.json
@@ -0,0 +1,34 @@
+{
+ "n8": 32,
+ "prime": "21888242871839275222246405745257275088548364400416034343698204186575808495617",
+ "nVars": 4,
+ "nOutputs": 1,
+ "nPubInputs": 0,
+ "nPrvInputs": 2,
+ "nLabels": 4,
+ "nConstraints": 1,
+ "useCustomGates": false,
+ "constraints": [
+  [
+   {
+    "2": "21888242871839275222246405745257275088548364400416034343698204186575808495616"
+   },
+   {
+    "3": "1"
+   },
+   {
+    "1": "21888242871839275222246405745257275088548364400416034343698204186575808495616"
+   }
+  ]
+ ],
+ "map": [
+  0,
+  1,
+  2,
+  3
+ ],
+ "customGates": [
+ ],
+ "customGatesUses": [
+ ]
+}
\ No newline at end of file
diff --git a/basic/22-zk-snarkjs/circom2/multiplier2.sym b/basic/22-zk-snarkjs/circom2/multiplier2.sym
new file mode 100644
index 000000000..9432aa87a
--- /dev/null
+++ b/basic/22-zk-snarkjs/circom2/multiplier2.sym
@@ -0,0 +1,3 @@
+1,1,0,main.c
+2,2,0,main.a
+3,3,0,main.b
diff --git a/basic/22-zk-snarkjs/circom2/multiplier2_0000.zkey b/basic/22-zk-snarkjs/circom2/multiplier2_0000.zkey
new file mode 100644
index 000000000..6bf9abad0
Binary files /dev/null and b/basic/22-zk-snarkjs/circom2/multiplier2_0000.zkey differ
diff --git a/basic/22-zk-snarkjs/circom2/multiplier2_0001.zkey b/basic/22-zk-snarkjs/circom2/multiplier2_0001.zkey
new file mode 100644
index 000000000..b8800ab1b
Binary files /dev/null and b/basic/22-zk-snarkjs/circom2/multiplier2_0001.zkey differ
diff --git a/basic/22-zk-snarkjs/circom2/multiplier2_js/generate_witness.js b/basic/22-zk-snarkjs/circom2/multiplier2_js/generate_witness.js
new file mode 100644
index 000000000..eabb86e58
--- /dev/null
+++ b/basic/22-zk-snarkjs/circom2/multiplier2_js/generate_witness.js
@@ -0,0 +1,20 @@
+const wc  = require("./witness_calculator.js");
+const { readFileSync, writeFile } = require("fs");
+
+if (process.argv.length != 5) {
+    console.log("Usage: node generate_witness.js <file.wasm> <input.json> <output.wtns>");
+} else {
+    const input = JSON.parse(readFileSync(process.argv[3], "utf8"));
+    
+    const buffer = readFileSync(process.argv[2]);
+    wc(buffer).then(async witnessCalculator => {
+	//    const w= await witnessCalculator.calculateWitness(input,0);
+	//    for (let i=0; i< w.length; i++){
+	//	console.log(w[i]);
+	//    }
+	const buff= await witnessCalculator.calculateWTNSBin(input,0);
+	writeFile(process.argv[4], buff, function(err) {
+	    if (err) throw err;
+	});
+    });
+}
diff --git a/basic/22-zk-snarkjs/circom2/multiplier2_js/multiplier2.wasm b/basic/22-zk-snarkjs/circom2/multiplier2_js/multiplier2.wasm
new file mode 100644
index 000000000..c8cecba52
Binary files /dev/null and b/basic/22-zk-snarkjs/circom2/multiplier2_js/multiplier2.wasm differ
diff --git a/basic/22-zk-snarkjs/circom2/multiplier2_js/witness_calculator.js b/basic/22-zk-snarkjs/circom2/multiplier2_js/witness_calculator.js
new file mode 100644
index 000000000..20e6e20ad
--- /dev/null
+++ b/basic/22-zk-snarkjs/circom2/multiplier2_js/witness_calculator.js
@@ -0,0 +1,337 @@
+module.exports = async function builder(code, options) {
+
+    options = options || {};
+
+    let wasmModule;
+    try {
+	wasmModule = await WebAssembly.compile(code);
+    }  catch (err) {
+	console.log(err);
+	console.log("\nTry to run circom --c in order to generate c++ code instead\n");
+	throw new Error(err);
+    }
+
+    let wc;
+
+    let errStr = "";
+    let msgStr = "";
+    
+    const instance = await WebAssembly.instantiate(wasmModule, {
+        runtime: {
+            exceptionHandler : function(code) {
+		let err;
+                if (code == 1) {
+                    err = "Signal not found.\n";
+                } else if (code == 2) {
+                    err = "Too many signals set.\n";
+                } else if (code == 3) {
+                    err = "Signal already set.\n";
+		} else if (code == 4) {
+                    err = "Assert Failed.\n";
+		} else if (code == 5) {
+                    err = "Not enough memory.\n";
+		} else if (code == 6) {
+                    err = "Input signal array access exceeds the size.\n";
+		} else {
+		    err = "Unknown error.\n";
+                }
+                throw new Error(err + errStr);
+            },
+	    printErrorMessage : function() {
+		errStr += getMessage() + "\n";
+                // console.error(getMessage());
+	    },
+	    writeBufferMessage : function() {
+			const msg = getMessage();
+			// Any calls to `log()` will always end with a `\n`, so that's when we print and reset
+			if (msg === "\n") {
+				console.log(msgStr);
+				msgStr = "";
+			} else {
+				// If we've buffered other content, put a space in between the items
+				if (msgStr !== "") {
+					msgStr += " "
+				}
+				// Then append the message to the message we are creating
+				msgStr += msg;
+			}
+	    },
+	    showSharedRWMemory : function() {
+		printSharedRWMemory ();
+            }
+
+        }
+    });
+
+    const sanityCheck =
+        options
+//        options &&
+//        (
+//            options.sanityCheck ||
+//            options.logGetSignal ||
+//            options.logSetSignal ||
+//            options.logStartComponent ||
+//            options.logFinishComponent
+//        );
+
+    
+    wc = new WitnessCalculator(instance, sanityCheck);
+    return wc;
+
+    function getMessage() {
+        var message = "";
+	var c = instance.exports.getMessageChar();
+        while ( c != 0 ) {
+	    message += String.fromCharCode(c);
+	    c = instance.exports.getMessageChar();
+	}
+        return message;
+    }
+	
+    function printSharedRWMemory () {
+	const shared_rw_memory_size = instance.exports.getFieldNumLen32();
+	const arr = new Uint32Array(shared_rw_memory_size);
+	for (let j=0; j<shared_rw_memory_size; j++) {
+	    arr[shared_rw_memory_size-1-j] = instance.exports.readSharedRWMemory(j);
+	}
+
+	// If we've buffered other content, put a space in between the items
+	if (msgStr !== "") {
+		msgStr += " "
+	}
+	// Then append the value to the message we are creating
+	msgStr += (fromArray32(arr).toString());
+	}
+
+};
+
+class WitnessCalculator {
+    constructor(instance, sanityCheck) {
+        this.instance = instance;
+
+	this.version = this.instance.exports.getVersion();
+        this.n32 = this.instance.exports.getFieldNumLen32();
+
+        this.instance.exports.getRawPrime();
+        const arr = new Uint32Array(this.n32);
+        for (let i=0; i<this.n32; i++) {
+            arr[this.n32-1-i] = this.instance.exports.readSharedRWMemory(i);
+        }
+        this.prime = fromArray32(arr);
+
+        this.witnessSize = this.instance.exports.getWitnessSize();
+
+        this.sanityCheck = sanityCheck;
+    }
+    
+    circom_version() {
+	return this.instance.exports.getVersion();
+    }
+
+    async _doCalculateWitness(input, sanityCheck) {
+	//input is assumed to be a map from signals to arrays of bigints
+        this.instance.exports.init((this.sanityCheck || sanityCheck) ? 1 : 0);
+        const keys = Object.keys(input);
+	var input_counter = 0;
+        keys.forEach( (k) => {
+            const h = fnvHash(k);
+            const hMSB = parseInt(h.slice(0,8), 16);
+            const hLSB = parseInt(h.slice(8,16), 16);
+            const fArr = flatArray(input[k]);
+	    let signalSize = this.instance.exports.getInputSignalSize(hMSB, hLSB);
+	    if (signalSize < 0){
+		throw new Error(`Signal ${k} not found\n`);
+	    }
+	    if (fArr.length < signalSize) {
+		throw new Error(`Not enough values for input signal ${k}\n`);
+	    }
+	    if (fArr.length > signalSize) {
+		throw new Error(`Too many values for input signal ${k}\n`);
+	    }
+            for (let i=0; i<fArr.length; i++) {
+                const arrFr = toArray32(normalize(fArr[i],this.prime),this.n32)
+                for (let j=0; j<this.n32; j++) {
+		    this.instance.exports.writeSharedRWMemory(j,arrFr[this.n32-1-j]);
+		}
+		try {
+                    this.instance.exports.setInputSignal(hMSB, hLSB,i);
+		    input_counter++;
+		} catch (err) {
+		    // console.log(`After adding signal ${i} of ${k}`)
+                    throw new Error(err);
+		}
+            }
+
+        });
+	if (input_counter < this.instance.exports.getInputSize()) {
+	    throw new Error(`Not all inputs have been set. Only ${input_counter} out of ${this.instance.exports.getInputSize()}`);
+	}
+    }
+
+    async calculateWitness(input, sanityCheck) {
+
+        const w = [];
+
+        await this._doCalculateWitness(input, sanityCheck);
+
+        for (let i=0; i<this.witnessSize; i++) {
+            this.instance.exports.getWitness(i);
+	    const arr = new Uint32Array(this.n32);
+            for (let j=0; j<this.n32; j++) {
+            arr[this.n32-1-j] = this.instance.exports.readSharedRWMemory(j);
+            }
+            w.push(fromArray32(arr));
+        }
+
+        return w;
+    }
+    
+
+    async calculateBinWitness(input, sanityCheck) {
+
+        const buff32 = new Uint32Array(this.witnessSize*this.n32);
+	const buff = new  Uint8Array( buff32.buffer);
+        await this._doCalculateWitness(input, sanityCheck);
+
+        for (let i=0; i<this.witnessSize; i++) {
+            this.instance.exports.getWitness(i);
+	    const pos = i*this.n32;
+            for (let j=0; j<this.n32; j++) {
+		buff32[pos+j] = this.instance.exports.readSharedRWMemory(j);
+            }
+        }
+
+	return buff;
+    }
+    
+
+    async calculateWTNSBin(input, sanityCheck) {
+
+        const buff32 = new Uint32Array(this.witnessSize*this.n32+this.n32+11);
+	const buff = new  Uint8Array( buff32.buffer);
+        await this._doCalculateWitness(input, sanityCheck);
+  
+	//"wtns"
+	buff[0] = "w".charCodeAt(0)
+	buff[1] = "t".charCodeAt(0)
+	buff[2] = "n".charCodeAt(0)
+	buff[3] = "s".charCodeAt(0)
+
+	//version 2
+	buff32[1] = 2;
+
+	//number of sections: 2
+	buff32[2] = 2;
+
+	//id section 1
+	buff32[3] = 1;
+
+	const n8 = this.n32*4;
+	//id section 1 length in 64bytes
+	const idSection1length = 8 + n8;
+	const idSection1lengthHex = idSection1length.toString(16);
+        buff32[4] = parseInt(idSection1lengthHex.slice(0,8), 16);
+        buff32[5] = parseInt(idSection1lengthHex.slice(8,16), 16);
+
+	//this.n32
+	buff32[6] = n8;
+
+	//prime number
+	this.instance.exports.getRawPrime();
+
+	var pos = 7;
+        for (let j=0; j<this.n32; j++) {
+	    buff32[pos+j] = this.instance.exports.readSharedRWMemory(j);
+        }
+	pos += this.n32;
+
+	// witness size
+	buff32[pos] = this.witnessSize;
+	pos++;
+
+	//id section 2
+	buff32[pos] = 2;
+	pos++;
+
+	// section 2 length
+	const idSection2length = n8*this.witnessSize;
+	const idSection2lengthHex = idSection2length.toString(16);
+        buff32[pos] = parseInt(idSection2lengthHex.slice(0,8), 16);
+        buff32[pos+1] = parseInt(idSection2lengthHex.slice(8,16), 16);
+
+	pos += 2;
+        for (let i=0; i<this.witnessSize; i++) {
+            this.instance.exports.getWitness(i);
+            for (let j=0; j<this.n32; j++) {
+		buff32[pos+j] = this.instance.exports.readSharedRWMemory(j);
+            }
+	    pos += this.n32;
+        }
+
+	return buff;
+    }
+
+}
+
+
+function toArray32(rem,size) {
+    const res = []; //new Uint32Array(size); //has no unshift
+    const radix = BigInt(0x100000000);
+    while (rem) {
+        res.unshift( Number(rem % radix));
+        rem = rem / radix;
+    }
+    if (size) {
+	var i = size - res.length;
+	while (i>0) {
+	    res.unshift(0);
+	    i--;
+	}
+    }
+    return res;
+}
+
+function fromArray32(arr) { //returns a BigInt
+    var res = BigInt(0);
+    const radix = BigInt(0x100000000);
+    for (let i = 0; i<arr.length; i++) {
+        res = res*radix + BigInt(arr[i]);
+    }
+    return res;
+}
+
+function flatArray(a) {
+    var res = [];
+    fillArray(res, a);
+    return res;
+
+    function fillArray(res, a) {
+        if (Array.isArray(a)) {
+            for (let i=0; i<a.length; i++) {
+                fillArray(res, a[i]);
+            }
+        } else {
+            res.push(a);
+        }
+    }
+}
+
+function normalize(n, prime) {
+    let res = BigInt(n) % prime
+    if (res < 0) res += prime
+    return res
+}
+
+function fnvHash(str) {
+    const uint64_max = BigInt(2) ** BigInt(64);
+    let hash = BigInt("0xCBF29CE484222325");
+    for (var i = 0; i < str.length; i++) {
+	hash ^= BigInt(str[i].charCodeAt());
+	hash *= BigInt(0x100000001B3);
+	hash %= uint64_max;
+    }
+    let shash = hash.toString(16);
+    let n = 16 - shash.length;
+    shash = '0'.repeat(n).concat(shash);
+    return shash;
+}
diff --git a/basic/22-zk-snarkjs/circom2/plonk/verification_key.json b/basic/22-zk-snarkjs/circom2/plonk/verification_key.json
new file mode 100644
index 000000000..a8d507c78
--- /dev/null
+++ b/basic/22-zk-snarkjs/circom2/plonk/verification_key.json
@@ -0,0 +1,94 @@
+{
+ "protocol": "groth16",
+ "curve": "bn128",
+ "nPublic": 1,
+ "vk_alpha_1": [
+  "5253868672545201124648698677088289555142021129357716645696773054382726861037",
+  "16767295459177503158737273790991340982009586210896243194337350327655975298969",
+  "1"
+ ],
+ "vk_beta_2": [
+  [
+   "13020819549771277211610313769058699131150885822436659242252693902346979949689",
+   "1517177208055623231036383643157791737914004038543285091176976763810633516024"
+  ],
+  [
+   "14093737879491093671247320146695948607359517051041418927268729764932906538891",
+   "7307514811841853286384695995993737967931697761470244287285024542422346434107"
+  ],
+  [
+   "1",
+   "0"
+  ]
+ ],
+ "vk_gamma_2": [
+  [
+   "10857046999023057135944570762232829481370756359578518086990519993285655852781",
+   "11559732032986387107991004021392285783925812861821192530917403151452391805634"
+  ],
+  [
+   "8495653923123431417604973247489272438418190587263600148770280649306958101930",
+   "4082367875863433681332203403145435568316851327593401208105741076214120093531"
+  ],
+  [
+   "1",
+   "0"
+  ]
+ ],
+ "vk_delta_2": [
+  [
+   "4388367894020072747245833611639303477786255804865803676095639566942415152421",
+   "3068521436480821370597636270305818368787362657628357104531391290259323356873"
+  ],
+  [
+   "20488555401460498307150365361877239532200986507036709879609922659129974700879",
+   "149614604007101980574802460526087370915479140660998551971860879828324825493"
+  ],
+  [
+   "1",
+   "0"
+  ]
+ ],
+ "vk_alphabeta_12": [
+  [
+   [
+    "13133565274151272560769280276735397184229165569289151475227442865674151057530",
+    "11213949567544027095593052391429014997969548036256331191197697145742334793949"
+   ],
+   [
+    "17288419249752856538683942545171912610864491293673116122817020145812982000589",
+    "12860456781133546755029165805563367003579499028789723572803112180306376088756"
+   ],
+   [
+    "11045624061092172240342207572417674984148923115447012344025325452815172669855",
+    "9543066913890842499751035412074041018653274919231952998225938865053309179704"
+   ]
+  ],
+  [
+   [
+    "17470391958921670350963645621832701731207895189103842718122416946914558519022",
+    "14431196000521955095883251577646021807199272255788007862541233693361585566445"
+   ],
+   [
+    "12904285926993215311132073871203353090645039531068617554663514572954237422526",
+    "12166126590120398910749749067405740642942750919534653546065915144891398240881"
+   ],
+   [
+    "9850273007738731858781653886585348995679822339531398050476742583531169330754",
+    "16434874283757837682284428287033035801944461026350170298947455458462149715354"
+   ]
+  ]
+ ],
+ "IC": [
+  [
+   "20051042181581545479939447722357565201638036042374374239908364633108925846952",
+   "19036623794848954414824512606821531123311848022955437018241695756043257614093",
+   "1"
+  ],
+  [
+   "16305314406124537814345102825906381211799744194477046235563220479013565680400",
+   "8339568598412892344378130691157116347853089604043378402456574632391806900354",
+   "1"
+  ]
+ ]
+}
\ No newline at end of file
diff --git a/basic/22-zk-snarkjs/circom2/plonk/verifier.sol b/basic/22-zk-snarkjs/circom2/plonk/verifier.sol
new file mode 100644
index 000000000..6b3f707a1
--- /dev/null
+++ b/basic/22-zk-snarkjs/circom2/plonk/verifier.sol
@@ -0,0 +1,170 @@
+// SPDX-License-Identifier: GPL-3.0
+/*
+    Copyright 2021 0KIMS association.
+
+    This file is generated with [snarkJS](https://github.com/iden3/snarkjs).
+
+    snarkJS is a free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    snarkJS is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+    or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
+    License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with snarkJS. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+pragma solidity >=0.7.0 <0.9.0;
+
+contract Groth16Verifier {
+    // Scalar field size
+    uint256 constant r    = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
+    // Base field size
+    uint256 constant q   = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
+
+    // Verification Key data
+    uint256 constant alphax  = 5253868672545201124648698677088289555142021129357716645696773054382726861037;
+    uint256 constant alphay  = 16767295459177503158737273790991340982009586210896243194337350327655975298969;
+    uint256 constant betax1  = 1517177208055623231036383643157791737914004038543285091176976763810633516024;
+    uint256 constant betax2  = 13020819549771277211610313769058699131150885822436659242252693902346979949689;
+    uint256 constant betay1  = 7307514811841853286384695995993737967931697761470244287285024542422346434107;
+    uint256 constant betay2  = 14093737879491093671247320146695948607359517051041418927268729764932906538891;
+    uint256 constant gammax1 = 11559732032986387107991004021392285783925812861821192530917403151452391805634;
+    uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781;
+    uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531;
+    uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930;
+    uint256 constant deltax1 = 3068521436480821370597636270305818368787362657628357104531391290259323356873;
+    uint256 constant deltax2 = 4388367894020072747245833611639303477786255804865803676095639566942415152421;
+    uint256 constant deltay1 = 149614604007101980574802460526087370915479140660998551971860879828324825493;
+    uint256 constant deltay2 = 20488555401460498307150365361877239532200986507036709879609922659129974700879;
+
+    
+    uint256 constant IC0x = 20051042181581545479939447722357565201638036042374374239908364633108925846952;
+    uint256 constant IC0y = 19036623794848954414824512606821531123311848022955437018241695756043257614093;
+    
+    uint256 constant IC1x = 16305314406124537814345102825906381211799744194477046235563220479013565680400;
+    uint256 constant IC1y = 8339568598412892344378130691157116347853089604043378402456574632391806900354;
+    
+ 
+    // Memory data
+    uint16 constant pVk = 0;
+    uint16 constant pPairing = 128;
+
+    uint16 constant pLastMem = 896;
+
+    function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[1] calldata _pubSignals) public view returns (bool) {
+        assembly {
+            function checkField(v) {
+                if iszero(lt(v, q)) {
+                    mstore(0, 0)
+                    return(0, 0x20)
+                }
+            }
+            
+            // G1 function to multiply a G1 value(x,y) to value in an address
+            function g1_mulAccC(pR, x, y, s) {
+                let success
+                let mIn := mload(0x40)
+                mstore(mIn, x)
+                mstore(add(mIn, 32), y)
+                mstore(add(mIn, 64), s)
+
+                success := staticcall(sub(gas(), 2000), 7, mIn, 96, mIn, 64)
+
+                if iszero(success) {
+                    mstore(0, 0)
+                    return(0, 0x20)
+                }
+
+                mstore(add(mIn, 64), mload(pR))
+                mstore(add(mIn, 96), mload(add(pR, 32)))
+
+                success := staticcall(sub(gas(), 2000), 6, mIn, 128, pR, 64)
+
+                if iszero(success) {
+                    mstore(0, 0)
+                    return(0, 0x20)
+                }
+            }
+
+            function checkPairing(pA, pB, pC, pubSignals, pMem) -> isOk {
+                let _pPairing := add(pMem, pPairing)
+                let _pVk := add(pMem, pVk)
+
+                mstore(_pVk, IC0x)
+                mstore(add(_pVk, 32), IC0y)
+
+                // Compute the linear combination vk_x
+                
+                g1_mulAccC(_pVk, IC1x, IC1y, calldataload(add(pubSignals, 0)))
+                
+
+                // -A
+                mstore(_pPairing, calldataload(pA))
+                mstore(add(_pPairing, 32), mod(sub(q, calldataload(add(pA, 32))), q))
+
+                // B
+                mstore(add(_pPairing, 64), calldataload(pB))
+                mstore(add(_pPairing, 96), calldataload(add(pB, 32)))
+                mstore(add(_pPairing, 128), calldataload(add(pB, 64)))
+                mstore(add(_pPairing, 160), calldataload(add(pB, 96)))
+
+                // alpha1
+                mstore(add(_pPairing, 192), alphax)
+                mstore(add(_pPairing, 224), alphay)
+
+                // beta2
+                mstore(add(_pPairing, 256), betax1)
+                mstore(add(_pPairing, 288), betax2)
+                mstore(add(_pPairing, 320), betay1)
+                mstore(add(_pPairing, 352), betay2)
+
+                // vk_x
+                mstore(add(_pPairing, 384), mload(add(pMem, pVk)))
+                mstore(add(_pPairing, 416), mload(add(pMem, add(pVk, 32))))
+
+
+                // gamma2
+                mstore(add(_pPairing, 448), gammax1)
+                mstore(add(_pPairing, 480), gammax2)
+                mstore(add(_pPairing, 512), gammay1)
+                mstore(add(_pPairing, 544), gammay2)
+
+                // C
+                mstore(add(_pPairing, 576), calldataload(pC))
+                mstore(add(_pPairing, 608), calldataload(add(pC, 32)))
+
+                // delta2
+                mstore(add(_pPairing, 640), deltax1)
+                mstore(add(_pPairing, 672), deltax2)
+                mstore(add(_pPairing, 704), deltay1)
+                mstore(add(_pPairing, 736), deltay2)
+
+
+                let success := staticcall(sub(gas(), 2000), 8, _pPairing, 768, _pPairing, 0x20)
+
+                isOk := and(success, mload(_pPairing))
+            }
+
+            let pMem := mload(0x40)
+            mstore(0x40, add(pMem, pLastMem))
+
+            // Validate that all evaluations ∈ F
+            
+            checkField(calldataload(add(_pubSignals, 0)))
+            
+            checkField(calldataload(add(_pubSignals, 32)))
+            
+
+            // Validate all evaluations
+            let isValid := checkPairing(_pA, _pB, _pC, _pubSignals, pMem)
+
+            mstore(0, isValid)
+             return(0, 0x20)
+         }
+     }
+ }
diff --git a/basic/22-zk-snarkjs/circom2/pot12_0000.ptau b/basic/22-zk-snarkjs/circom2/pot12_0000.ptau
new file mode 100644
index 000000000..d1fc4fa87
Binary files /dev/null and b/basic/22-zk-snarkjs/circom2/pot12_0000.ptau differ
diff --git a/basic/22-zk-snarkjs/circom2/pot12_0001.ptau b/basic/22-zk-snarkjs/circom2/pot12_0001.ptau
new file mode 100644
index 000000000..647a59ddc
Binary files /dev/null and b/basic/22-zk-snarkjs/circom2/pot12_0001.ptau differ
diff --git a/basic/22-zk-snarkjs/circom2/pot12_final.ptau b/basic/22-zk-snarkjs/circom2/pot12_final.ptau
new file mode 100644
index 000000000..ce86049f8
Binary files /dev/null and b/basic/22-zk-snarkjs/circom2/pot12_final.ptau differ
diff --git a/basic/22-zk-snarkjs/circom2/public.json b/basic/22-zk-snarkjs/circom2/public.json
new file mode 100644
index 000000000..bf2030970
--- /dev/null
+++ b/basic/22-zk-snarkjs/circom2/public.json
@@ -0,0 +1,3 @@
+[
+ "33"
+]
\ No newline at end of file
diff --git a/basic/22-zk-snarkjs/circom2/readme.md b/basic/22-zk-snarkjs/circom2/readme.md
new file mode 100644
index 000000000..8793fbaf1
--- /dev/null
+++ b/basic/22-zk-snarkjs/circom2/readme.md
@@ -0,0 +1,23 @@
+# circom2
+
+
+## circom 语法
+
+  1. <-- assigns a value to a signal without adding a constraint.
+  2. Whereas === adds a constraint without assigning a value.
+  3. <== both assigns a value to a signal and adds a contraint。Which means it’s just the combination of === and <--.
+
+## 参考资料
+
+- 创建第一个零知识 snark 电路: <https://learnblockchain.cn/article/1078>
+- 参考文档：<https://blog.iden3.io/first-zk-proof.html>
+- circom2 doc: <https://docs.circom.io/circom-language/basic-operators/>
+- snarkjs: <https://github.com/iden3/snarkjs>
+- 深入浅出零知识证明之 zk-SNARKs： <https://www.yuque.com/u428635/scg32w/edmn74>
+- ZK Jargon Decoder: <https://nmohnblatt.github.io/zk-jargon-decoder/foreword.html>
+- CTN rollup 分享：<https://www.bilibili.com/video/BV1oL4y1h7iE?p=1&share_medium=android&share_plat=android&share_session_id=9d2f7c31-a4dc-46a5-a2d9-4d6d0ebc3997&share_source=WEIXIN&share_tag=s_i&timestamp=1653798331&unique_k=921Lj1L&vd_source=3c62940e414c68a7f639c5737b9fd3d1>
+- zkRollup tutorial: <https://keen-noyce-c29dfa.netlify.app/#16>
+- 零知识证明的可信设置是否值得担心?: <https://www.sohu.com/a/468233201_100105055>
+- Diving into the zk-SNARKs Setup Phase: <https://medium.com/qed-it/diving-into-the-snarks-setup-phase-b7660242a0d7>
+- scaffold-eth-zk: <https://github.com/scaffold-eth/scaffold-eth-examples/tree/zk-voting-example>
+- online circom editor: https://zkrepl.dev/
\ No newline at end of file
diff --git a/basic/22-zk-snarkjs/circom2/verification_key.json b/basic/22-zk-snarkjs/circom2/verification_key.json
new file mode 100644
index 000000000..e6bbc2ca9
--- /dev/null
+++ b/basic/22-zk-snarkjs/circom2/verification_key.json
@@ -0,0 +1,63 @@
+{
+ "protocol": "plonk",
+ "curve": "bn128",
+ "nPublic": 1,
+ "power": 3,
+ "k1": "2",
+ "k2": "3",
+ "Qm": [
+  "6699088001123109952183962588223396229634400680774617861482376109866173590415",
+  "10472862863404696730237000817687961982481823937409036496392612294007500191870",
+  "1"
+ ],
+ "Ql": [
+  "7653042754748282460925155674115802066186740095112438098089677730825851742561",
+  "3881489376554609598818401640548973087844286524086744140689566043079220234653",
+  "1"
+ ],
+ "Qr": [
+  "0",
+  "1",
+  "0"
+ ],
+ "Qo": [
+  "6699088001123109952183962588223396229634400680774617861482376109866173590415",
+  "11415380008434578492009404927569313106214487219888787166296425600637726016713",
+  "1"
+ ],
+ "Qc": [
+  "0",
+  "1",
+  "0"
+ ],
+ "S1": [
+  "12595984855861242061649666268418958443285151063605611873146794297408558416836",
+  "13705084462179478240736413689935073047312759999024126566597654725029421808009",
+  "1"
+ ],
+ "S2": [
+  "16285909367754550288358159035997699094368387144009879119019270648519999440116",
+  "1295729502968671379118165227997341875919978495457150719822893621307947271783",
+  "1"
+ ],
+ "S3": [
+  "14606951403545053284258360588318930654368768246829249183502572774985607977923",
+  "9505097472223332796829678678148885853274639253871716812065493604196418738384",
+  "1"
+ ],
+ "X_2": [
+  [
+   "18935944361004143412805704977309399715739170487629982915447996963383767772739",
+   "6811002817459883196920556250750369153193187180198975763660544368610033000117"
+  ],
+  [
+   "21721768279008477101272404552028427623562871621192112392566662061814769383663",
+   "20846124843981009602488447623630715579517110693802445484941301159200541614978"
+  ],
+  [
+   "1",
+   "0"
+  ]
+ ],
+ "w": "19540430494807482326159819597004422086093766032135589407132600596362845576832"
+}
\ No newline at end of file
diff --git a/basic/22-zk-snarkjs/circom2/verifier.sol b/basic/22-zk-snarkjs/circom2/verifier.sol
new file mode 100644
index 000000000..524199137
--- /dev/null
+++ b/basic/22-zk-snarkjs/circom2/verifier.sol
@@ -0,0 +1,697 @@
+// SPDX-License-Identifier: GPL-3.0
+/*
+    Copyright 2021 0KIMS association.
+
+    This file is generated with [snarkJS](https://github.com/iden3/snarkjs).
+
+    snarkJS is a free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    snarkJS is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+    or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
+    License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with snarkJS. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+
+pragma solidity >=0.7.0 <0.9.0;
+
+import "hardhat/console.sol";
+
+contract PlonkVerifier {
+    // Omega
+    uint256 constant w1 = 19540430494807482326159819597004422086093766032135589407132600596362845576832;    
+    // Scalar field size
+    uint256 constant q  = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
+    // Base field size
+    uint256 constant qf = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
+    
+    // [1]_1
+    uint256 constant G1x = 1;
+    uint256 constant G1y = 2;
+    // [1]_2
+    uint256 constant G2x1 = 10857046999023057135944570762232829481370756359578518086990519993285655852781;
+    uint256 constant G2x2 = 11559732032986387107991004021392285783925812861821192530917403151452391805634;
+    uint256 constant G2y1 = 8495653923123431417604973247489272438418190587263600148770280649306958101930;
+    uint256 constant G2y2 = 4082367875863433681332203403145435568316851327593401208105741076214120093531;
+    
+    // Verification Key data
+    uint32 constant n         = 8;
+    uint16 constant nPublic   = 1;
+    uint16 constant nLagrange = 1;
+    
+    uint256 constant Qmx  = 6699088001123109952183962588223396229634400680774617861482376109866173590415;
+    uint256 constant Qmy  = 10472862863404696730237000817687961982481823937409036496392612294007500191870;
+    uint256 constant Qlx  = 7653042754748282460925155674115802066186740095112438098089677730825851742561;
+    uint256 constant Qly  = 3881489376554609598818401640548973087844286524086744140689566043079220234653;
+    uint256 constant Qrx  = 0;
+    uint256 constant Qry  = 0;
+    uint256 constant Qox  = 6699088001123109952183962588223396229634400680774617861482376109866173590415;
+    uint256 constant Qoy  = 11415380008434578492009404927569313106214487219888787166296425600637726016713;
+    uint256 constant Qcx  = 0;
+    uint256 constant Qcy  = 0;
+    uint256 constant S1x  = 12595984855861242061649666268418958443285151063605611873146794297408558416836;
+    uint256 constant S1y  = 13705084462179478240736413689935073047312759999024126566597654725029421808009;
+    uint256 constant S2x  = 16285909367754550288358159035997699094368387144009879119019270648519999440116;
+    uint256 constant S2y  = 1295729502968671379118165227997341875919978495457150719822893621307947271783;
+    uint256 constant S3x  = 14606951403545053284258360588318930654368768246829249183502572774985607977923;
+    uint256 constant S3y  = 9505097472223332796829678678148885853274639253871716812065493604196418738384;
+    uint256 constant k1   = 2;
+    uint256 constant k2   = 3;
+    uint256 constant X2x1 = 18935944361004143412805704977309399715739170487629982915447996963383767772739;
+    uint256 constant X2x2 = 6811002817459883196920556250750369153193187180198975763660544368610033000117;
+    uint256 constant X2y1 = 21721768279008477101272404552028427623562871621192112392566662061814769383663;
+    uint256 constant X2y2 = 20846124843981009602488447623630715579517110693802445484941301159200541614978;
+    
+    // Proof calldata
+    // Byte offset of every parameter of the calldata
+    // Polynomial commitments
+    uint16 constant pA       = 4 + 0;
+    uint16 constant pB       = 4 + 64;
+    uint16 constant pC       = 4 + 128;
+    uint16 constant pZ       = 4 + 192;
+    uint16 constant pT1      = 4 + 256;
+    uint16 constant pT2      = 4 + 320;
+    uint16 constant pT3      = 4 + 384;
+    uint16 constant pWxi     = 4 + 448;
+    uint16 constant pWxiw    = 4 + 512;
+    // Opening evaluations
+    uint16 constant pEval_a  = 4 + 576;
+    uint16 constant pEval_b  = 4 + 608;
+    uint16 constant pEval_c  = 4 + 640;
+    uint16 constant pEval_s1 = 4 + 672;
+    uint16 constant pEval_s2 = 4 + 704;
+    uint16 constant pEval_zw = 4 + 736;
+    
+    // Memory data
+    // Challenges
+    uint16 constant pAlpha  = 0;
+    uint16 constant pBeta   = 32;
+    uint16 constant pGamma  = 64;
+    uint16 constant pXi     = 96;
+    uint16 constant pXin    = 128;
+    uint16 constant pBetaXi = 160;
+    uint16 constant pV1     = 192;
+    uint16 constant pV2     = 224;
+    uint16 constant pV3     = 256;
+    uint16 constant pV4     = 288;
+    uint16 constant pV5     = 320;
+    uint16 constant pU      = 352;
+    
+    uint16 constant pPI      = 384;
+    uint16 constant pEval_r0 = 416;
+    uint16 constant pD       = 448;
+    uint16 constant pF       = 512;
+    uint16 constant pE       = 576;
+    uint16 constant pTmp     = 640;
+    uint16 constant pAlpha2  = 704;
+    uint16 constant pZh      = 736;
+    uint16 constant pZhInv   = 768;
+
+    
+    uint16 constant pEval_l1 = 800;
+    
+    
+    
+    uint16 constant lastMem = 832;
+
+    function verifyProof(uint256[24] calldata _proof, uint256[1] calldata _pubSignals) public view returns (bool) {
+        assembly {
+            /////////
+            // Computes the inverse using the extended euclidean algorithm
+            /////////
+            function inverse(a, q) -> inv {
+                let t := 0     
+                let newt := 1
+                let r := q     
+                let newr := a
+                let quotient
+                let aux
+                
+                for { } newr { } {
+                    quotient := sdiv(r, newr)
+                    aux := sub(t, mul(quotient, newt))
+                    t:= newt
+                    newt:= aux
+                    
+                    aux := sub(r,mul(quotient, newr))
+                    r := newr
+                    newr := aux
+                }
+                
+                if gt(r, 1) { revert(0,0) }
+                if slt(t, 0) { t:= add(t, q) }
+
+                inv := t
+            }
+            
+            ///////
+            // Computes the inverse of an array of values
+            // See https://vitalik.ca/general/2018/07/21/starks_part_3.html in section where explain fields operations
+            //////
+            function inverseArray(pVals, n) {
+    
+                let pAux := mload(0x40)     // Point to the next free position
+                let pIn := pVals
+                let lastPIn := add(pVals, mul(n, 32))  // Read n elemnts
+                let acc := mload(pIn)       // Read the first element
+                pIn := add(pIn, 32)         // Point to the second element
+                let inv
+    
+                
+                for { } lt(pIn, lastPIn) { 
+                    pAux := add(pAux, 32) 
+                    pIn := add(pIn, 32)
+                } 
+                {
+                    mstore(pAux, acc)
+                    acc := mulmod(acc, mload(pIn), q)
+                }
+                acc := inverse(acc, q)
+                
+                // At this point pAux pint to the next free position we substract 1 to point to the last used
+                pAux := sub(pAux, 32)
+                // pIn points to the n+1 element, we substract to point to n
+                pIn := sub(pIn, 32)
+                lastPIn := pVals  // We don't process the first element 
+                for { } gt(pIn, lastPIn) { 
+                    pAux := sub(pAux, 32) 
+                    pIn := sub(pIn, 32)
+                } 
+                {
+                    inv := mulmod(acc, mload(pAux), q)
+                    acc := mulmod(acc, mload(pIn), q)
+                    mstore(pIn, inv)
+                }
+                // pIn points to first element, we just set it.
+                mstore(pIn, acc)
+            }
+            
+            function checkField(v) {
+                if iszero(lt(v, q)) {
+                    mstore(0, 0)
+                    return(0,0x20)
+                }
+            }
+            
+            function checkInput() {
+                checkField(calldataload(pEval_a))
+                checkField(calldataload(pEval_b))
+                checkField(calldataload(pEval_c))
+                checkField(calldataload(pEval_s1))
+                checkField(calldataload(pEval_s2))
+                checkField(calldataload(pEval_zw))
+            }
+            
+            function calculateChallenges(pMem, pPublic) {
+                let beta
+                let aux
+
+                let mIn := mload(0x40)     // Pointer to the next free memory position
+
+                // Compute challenge.beta & challenge.gamma
+                mstore(mIn, Qmx)
+                mstore(add(mIn, 32), Qmy)
+                mstore(add(mIn, 64), Qlx)
+                mstore(add(mIn, 96), Qly)
+                mstore(add(mIn, 128), Qrx)
+                mstore(add(mIn, 160), Qry)
+                mstore(add(mIn, 192), Qox)
+                mstore(add(mIn, 224), Qoy)
+                mstore(add(mIn, 256), Qcx)
+                mstore(add(mIn, 288), Qcy)
+                mstore(add(mIn, 320), S1x)
+                mstore(add(mIn, 352), S1y)
+                mstore(add(mIn, 384), S2x)
+                mstore(add(mIn, 416), S2y)
+                mstore(add(mIn, 448), S3x)
+                mstore(add(mIn, 480), S3y)
+
+                
+                mstore(add(mIn, 512), calldataload(add(pPublic, 0)))
+                
+                mstore(add(mIn, 544 ), calldataload(pA))
+                mstore(add(mIn, 576 ), calldataload(add(pA, 32)))
+                mstore(add(mIn, 608 ), calldataload(pB))
+                mstore(add(mIn, 640 ), calldataload(add(pB, 32)))
+                mstore(add(mIn, 672 ), calldataload(pC))
+                mstore(add(mIn, 704 ), calldataload(add(pC, 32)))
+                
+                beta := mod(keccak256(mIn, 736), q) 
+                mstore(add(pMem, pBeta), beta)
+
+                // challenges.gamma
+                mstore(add(pMem, pGamma), mod(keccak256(add(pMem, pBeta), 32), q))
+                
+                // challenges.alpha
+                mstore(mIn, mload(add(pMem, pBeta)))
+                mstore(add(mIn, 32), mload(add(pMem, pGamma)))
+                mstore(add(mIn, 64), calldataload(pZ))
+                mstore(add(mIn, 96), calldataload(add(pZ, 32)))
+
+                aux := mod(keccak256(mIn, 128), q)
+                mstore(add(pMem, pAlpha), aux)
+                mstore(add(pMem, pAlpha2), mulmod(aux, aux, q))
+
+                // challenges.xi
+                mstore(mIn, aux)
+                mstore(add(mIn, 32),  calldataload(pT1))
+                mstore(add(mIn, 64),  calldataload(add(pT1, 32)))
+                mstore(add(mIn, 96),  calldataload(pT2))
+                mstore(add(mIn, 128), calldataload(add(pT2, 32)))
+                mstore(add(mIn, 160), calldataload(pT3))
+                mstore(add(mIn, 192), calldataload(add(pT3, 32)))
+
+                aux := mod(keccak256(mIn, 224), q)
+                mstore( add(pMem, pXi), aux)
+
+                // challenges.v
+                mstore(mIn, aux)
+                mstore(add(mIn, 32),  calldataload(pEval_a))
+                mstore(add(mIn, 64),  calldataload(pEval_b))
+                mstore(add(mIn, 96),  calldataload(pEval_c))
+                mstore(add(mIn, 128), calldataload(pEval_s1))
+                mstore(add(mIn, 160), calldataload(pEval_s2))
+                mstore(add(mIn, 192), calldataload(pEval_zw))
+
+                let v1 := mod(keccak256(mIn, 224), q)
+                mstore(add(pMem, pV1), v1)
+
+                // challenges.beta * challenges.xi
+                mstore(add(pMem, pBetaXi), mulmod(beta, aux, q))
+
+                // challenges.xi^n
+                
+                aux:= mulmod(aux, aux, q)
+                
+                aux:= mulmod(aux, aux, q)
+                
+                aux:= mulmod(aux, aux, q)
+                
+                mstore(add(pMem, pXin), aux)
+
+                // Zh
+                aux:= mod(add(sub(aux, 1), q), q)
+                mstore(add(pMem, pZh), aux)
+                mstore(add(pMem, pZhInv), aux)  // We will invert later together with lagrange pols
+                                
+                // challenges.v^2, challenges.v^3, challenges.v^4, challenges.v^5
+                aux := mulmod(v1, v1,  q)
+                mstore(add(pMem, pV2), aux)
+                aux := mulmod(aux, v1, q)
+                mstore(add(pMem, pV3), aux)
+                aux := mulmod(aux, v1, q)
+                mstore(add(pMem, pV4), aux)
+                aux := mulmod(aux, v1, q)
+                mstore(add(pMem, pV5), aux)
+
+                // challenges.u
+                mstore(mIn, calldataload(pWxi))
+                mstore(add(mIn, 32), calldataload(add(pWxi, 32)))
+                mstore(add(mIn, 64), calldataload(pWxiw))
+                mstore(add(mIn, 96), calldataload(add(pWxiw, 32)))
+
+                mstore(add(pMem, pU), mod(keccak256(mIn, 128), q))
+            }
+            
+            function calculateLagrange(pMem) {
+                let w := 1                
+                
+                mstore(
+                    add(pMem, pEval_l1), 
+                    mulmod(
+                        n, 
+                        mod(
+                            add(
+                                sub(
+                                    mload(add(pMem, pXi)), 
+                                    w
+                                ), 
+                                q
+                            ),
+                            q
+                        ), 
+                        q
+                    )
+                )
+                
+                
+                
+                inverseArray(add(pMem, pZhInv), 2 )
+                
+                let zh := mload(add(pMem, pZh))
+                w := 1
+                
+                
+                mstore(
+                    add(pMem, pEval_l1 ), 
+                    mulmod(
+                        mload(add(pMem, pEval_l1 )),
+                        zh,
+                        q
+                    )
+                )
+                
+                
+                
+
+
+            }
+            
+            function calculatePI(pMem, pPub) {
+                let pl := 0
+                
+                 
+                pl := mod(
+                    add(
+                        sub(
+                            pl,  
+                            mulmod(
+                                mload(add(pMem, pEval_l1)),
+                                calldataload(add(pPub, 0)),
+                                q
+                            )
+                        ),
+                        q
+                    ),
+                    q
+                )
+                
+                
+                mstore(add(pMem, pPI), pl)
+            }
+
+            function calculateR0(pMem) {
+                let e1 := mload(add(pMem, pPI))
+
+                let e2 :=  mulmod(mload(add(pMem, pEval_l1)), mload(add(pMem, pAlpha2)), q)
+
+                let e3a := addmod(
+                    calldataload(pEval_a),
+                    mulmod(mload(add(pMem, pBeta)), calldataload(pEval_s1), q),
+                    q)
+                e3a := addmod(e3a, mload(add(pMem, pGamma)), q)
+
+                let e3b := addmod(
+                    calldataload(pEval_b),
+                    mulmod(mload(add(pMem, pBeta)), calldataload(pEval_s2), q),
+                    q)
+                e3b := addmod(e3b, mload(add(pMem, pGamma)), q)
+
+                let e3c := addmod(
+                    calldataload(pEval_c),
+                    mload(add(pMem, pGamma)),
+                    q)
+
+                let e3 := mulmod(mulmod(e3a, e3b, q), e3c, q)
+                e3 := mulmod(e3, calldataload(pEval_zw), q)
+                e3 := mulmod(e3, mload(add(pMem, pAlpha)), q)
+            
+                let r0 := addmod(e1, mod(sub(q, e2), q), q)
+                r0 := addmod(r0, mod(sub(q, e3), q), q)
+                
+                mstore(add(pMem, pEval_r0) , r0)
+            }
+            
+            function g1_set(pR, pP) {
+                mstore(pR, mload(pP))
+                mstore(add(pR, 32), mload(add(pP,32)))
+            }   
+
+            function g1_setC(pR, x, y) {
+                mstore(pR, x)
+                mstore(add(pR, 32), y)
+            }
+
+            function g1_calldataSet(pR, pP) {
+                mstore(pR,          calldataload(pP))
+                mstore(add(pR, 32), calldataload(add(pP, 32)))
+            }
+
+            function g1_acc(pR, pP) {
+                let mIn := mload(0x40)
+                mstore(mIn, mload(pR))
+                mstore(add(mIn,32), mload(add(pR, 32)))
+                mstore(add(mIn,64), mload(pP))
+                mstore(add(mIn,96), mload(add(pP, 32)))
+
+                let success := staticcall(sub(gas(), 2000), 6, mIn, 128, pR, 64)
+                
+                if iszero(success) {
+                    mstore(0, 0)
+                    return(0,0x20)
+                }
+            }
+
+            function g1_mulAcc(pR, pP, s) {
+                let success
+                let mIn := mload(0x40)
+                mstore(mIn, mload(pP))
+                mstore(add(mIn,32), mload(add(pP, 32)))
+                mstore(add(mIn,64), s)
+
+                success := staticcall(sub(gas(), 2000), 7, mIn, 96, mIn, 64)
+                
+                if iszero(success) {
+                    mstore(0, 0)
+                    return(0,0x20)
+                }
+                
+                mstore(add(mIn,64), mload(pR))
+                mstore(add(mIn,96), mload(add(pR, 32)))
+
+                success := staticcall(sub(gas(), 2000), 6, mIn, 128, pR, 64)
+                
+                if iszero(success) {
+                    mstore(0, 0)
+                    return(0,0x20)
+                }
+                
+            }
+
+            function g1_mulAccC(pR, x, y, s) {
+                let success
+                let mIn := mload(0x40)
+                mstore(mIn, x)
+                mstore(add(mIn,32), y)
+                mstore(add(mIn,64), s)
+
+                success := staticcall(sub(gas(), 2000), 7, mIn, 96, mIn, 64)
+                
+                if iszero(success) {
+                    mstore(0, 0)
+                    return(0,0x20)
+                }
+                
+                mstore(add(mIn,64), mload(pR))
+                mstore(add(mIn,96), mload(add(pR, 32)))
+
+                success := staticcall(sub(gas(), 2000), 6, mIn, 128, pR, 64)
+                
+                if iszero(success) {
+                    mstore(0, 0)
+                    return(0,0x20)
+                }
+            }
+
+            function g1_mulSetC(pR, x, y, s) {
+                let success
+                let mIn := mload(0x40)
+                mstore(mIn, x)
+                mstore(add(mIn,32), y)
+                mstore(add(mIn,64), s)
+
+                success := staticcall(sub(gas(), 2000), 7, mIn, 96, pR, 64)
+                
+                if iszero(success) {
+                    mstore(0, 0)
+                    return(0,0x20)
+                }
+            }
+
+            function g1_mulSet(pR, pP, s) {
+                g1_mulSetC(pR, mload(pP), mload(add(pP, 32)), s)
+            }
+
+            function calculateD(pMem) {
+                let _pD:= add(pMem, pD)
+                let gamma := mload(add(pMem, pGamma))
+                let mIn := mload(0x40)
+                mstore(0x40, add(mIn, 256)) // d1, d2, d3 & d4 (4*64 bytes)
+
+                g1_setC(_pD, Qcx, Qcy)
+                g1_mulAccC(_pD, Qmx, Qmy, mulmod(calldataload(pEval_a), calldataload(pEval_b), q))
+                g1_mulAccC(_pD, Qlx, Qly, calldataload(pEval_a))
+                g1_mulAccC(_pD, Qrx, Qry, calldataload(pEval_b))
+                g1_mulAccC(_pD, Qox, Qoy, calldataload(pEval_c))            
+
+                let betaxi := mload(add(pMem, pBetaXi))
+                let val1 := addmod(
+                    addmod(calldataload(pEval_a), betaxi, q),
+                    gamma, q)
+
+                let val2 := addmod(
+                    addmod(
+                        calldataload(pEval_b),
+                        mulmod(betaxi, k1, q),
+                        q), gamma, q)
+
+                let val3 := addmod(
+                    addmod(
+                        calldataload(pEval_c),
+                        mulmod(betaxi, k2, q),
+                        q), gamma, q)
+
+                let d2a := mulmod(
+                    mulmod(mulmod(val1, val2, q), val3, q),
+                    mload(add(pMem, pAlpha)),
+                    q
+                )
+
+                let d2b := mulmod(
+                    mload(add(pMem, pEval_l1)),
+                    mload(add(pMem, pAlpha2)),
+                    q
+                )
+
+                // We'll use mIn to save d2
+                g1_calldataSet(add(mIn, 192), pZ)
+                g1_mulSet(
+                    mIn,
+                    add(mIn, 192),
+                    addmod(addmod(d2a, d2b, q), mload(add(pMem, pU)), q))
+
+
+                val1 := addmod(
+                    addmod(
+                        calldataload(pEval_a),
+                        mulmod(mload(add(pMem, pBeta)), calldataload(pEval_s1), q),
+                        q), gamma, q)
+
+                val2 := addmod(
+                    addmod(
+                        calldataload(pEval_b),
+                        mulmod(mload(add(pMem, pBeta)), calldataload(pEval_s2), q),
+                        q), gamma, q)
+    
+                val3 := mulmod(
+                    mulmod(mload(add(pMem, pAlpha)), mload(add(pMem, pBeta)), q),
+                    calldataload(pEval_zw), q)
+    
+
+                // We'll use mIn + 64 to save d3
+                g1_mulSetC(
+                    add(mIn, 64),
+                    S3x,
+                    S3y,
+                    mulmod(mulmod(val1, val2, q), val3, q))
+
+                // We'll use mIn + 128 to save d4
+                g1_calldataSet(add(mIn, 128), pT1)
+
+                g1_mulAccC(add(mIn, 128), calldataload(pT2), calldataload(add(pT2, 32)), mload(add(pMem, pXin)))
+                let xin2 := mulmod(mload(add(pMem, pXin)), mload(add(pMem, pXin)), q)
+                g1_mulAccC(add(mIn, 128), calldataload(pT3), calldataload(add(pT3, 32)) , xin2)
+                
+                g1_mulSetC(add(mIn, 128), mload(add(mIn, 128)), mload(add(mIn, 160)), mload(add(pMem, pZh)))
+
+                mstore(add(add(mIn, 64), 32), mod(sub(qf, mload(add(add(mIn, 64), 32))), qf))
+                mstore(add(mIn, 160), mod(sub(qf, mload(add(mIn, 160))), qf))
+                g1_acc(_pD, mIn)
+                g1_acc(_pD, add(mIn, 64))
+                g1_acc(_pD, add(mIn, 128))
+            }
+            
+            function calculateF(pMem) {
+                let p := add(pMem, pF)
+
+                g1_set(p, add(pMem, pD))
+                g1_mulAccC(p, calldataload(pA), calldataload(add(pA, 32)), mload(add(pMem, pV1)))
+                g1_mulAccC(p, calldataload(pB), calldataload(add(pB, 32)), mload(add(pMem, pV2)))
+                g1_mulAccC(p, calldataload(pC), calldataload(add(pC, 32)), mload(add(pMem, pV3)))
+                g1_mulAccC(p, S1x, S1y, mload(add(pMem, pV4)))
+                g1_mulAccC(p, S2x, S2y, mload(add(pMem, pV5)))
+            }
+            
+            function calculateE(pMem) {
+                let s := mod(sub(q, mload(add(pMem, pEval_r0))), q)
+
+                s := addmod(s, mulmod(calldataload(pEval_a),  mload(add(pMem, pV1)), q), q)
+                s := addmod(s, mulmod(calldataload(pEval_b),  mload(add(pMem, pV2)), q), q)
+                s := addmod(s, mulmod(calldataload(pEval_c),  mload(add(pMem, pV3)), q), q)
+                s := addmod(s, mulmod(calldataload(pEval_s1), mload(add(pMem, pV4)), q), q)
+                s := addmod(s, mulmod(calldataload(pEval_s2), mload(add(pMem, pV5)), q), q)
+                s := addmod(s, mulmod(calldataload(pEval_zw), mload(add(pMem, pU)),  q), q)
+
+                g1_mulSetC(add(pMem, pE), G1x, G1y, s)
+            }
+            
+            function checkPairing(pMem) -> isOk {
+                let mIn := mload(0x40)
+                mstore(0x40, add(mIn, 576)) // [0..383] = pairing data, [384..447] = pWxi, [448..512] = pWxiw
+
+                let _pWxi := add(mIn, 384)
+                let _pWxiw := add(mIn, 448)
+                let _aux := add(mIn, 512)
+
+                g1_calldataSet(_pWxi, pWxi)
+                g1_calldataSet(_pWxiw, pWxiw)
+
+                // A1
+                g1_mulSet(mIn, _pWxiw, mload(add(pMem, pU)))
+                g1_acc(mIn, _pWxi)
+                mstore(add(mIn, 32), mod(sub(qf, mload(add(mIn, 32))), qf))
+
+                // [X]_2
+                mstore(add(mIn,64), X2x2)
+                mstore(add(mIn,96), X2x1)
+                mstore(add(mIn,128), X2y2)
+                mstore(add(mIn,160), X2y1)
+
+                // B1
+                g1_mulSet(add(mIn, 192), _pWxi, mload(add(pMem, pXi)))
+
+                let s := mulmod(mload(add(pMem, pU)), mload(add(pMem, pXi)), q)
+                s := mulmod(s, w1, q)
+                g1_mulSet(_aux, _pWxiw, s)
+                g1_acc(add(mIn, 192), _aux)
+                g1_acc(add(mIn, 192), add(pMem, pF))
+                mstore(add(pMem, add(pE, 32)), mod(sub(qf, mload(add(pMem, add(pE, 32)))), qf))
+                g1_acc(add(mIn, 192), add(pMem, pE))
+
+                // [1]_2
+                mstore(add(mIn,256), G2x2)
+                mstore(add(mIn,288), G2x1)
+                mstore(add(mIn,320), G2y2)
+                mstore(add(mIn,352), G2y1)
+                
+                let success := staticcall(sub(gas(), 2000), 8, mIn, 384, mIn, 0x20)
+                
+                isOk := and(success, mload(mIn))
+            }
+            
+            let pMem := mload(0x40)
+            mstore(0x40, add(pMem, lastMem))
+            
+            checkInput()
+            calculateChallenges(pMem, _pubSignals)
+            calculateLagrange(pMem)
+            calculatePI(pMem, _pubSignals)
+            calculateR0(pMem)
+            calculateD(pMem)
+            calculateF(pMem)
+            calculateE(pMem)
+            let isValid := checkPairing(pMem)
+   
+            mstore(0x40, sub(pMem, lastMem))
+            mstore(0, isValid)
+            return(0,0x20)
+        }
+        
+    }
+}
\ No newline at end of file
diff --git a/basic/30-zksync-layer2/zkSync2.0-examples/package.json b/basic/30-zksync-layer2/zkSync2.0-examples/package.json
index 604ff828b..bad56b621 100644
--- a/basic/30-zksync-layer2/zkSync2.0-examples/package.json
+++ b/basic/30-zksync-layer2/zkSync2.0-examples/package.json
@@ -20,7 +20,7 @@
     "babel-eslint": "^10.1.0",
     "eslint": "^6.7.2",
     "eslint-plugin-vue": "^6.2.2",
-    "ethers": "^5.6.2",
+    "ethers": "^5.5.4",
     "hardhat": "^2.9.3",
     "ts-node": "^10.7.0",
     "typescript": "^4.6.3",
diff --git a/basic/34-scroll-layer2/contracts/MultipleSend.sol b/basic/34-scroll-layer2/contracts/MultipleSend.sol
new file mode 100644
index 000000000..31a33a012
--- /dev/null
+++ b/basic/34-scroll-layer2/contracts/MultipleSend.sol
@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+interface IERC20 {
+    function transferFrom(address from, address to, uint256 amount) external returns (bool);
+    function balanceOf(address account) external view returns (uint256);
+    function allowance(address owner, address spender) external view returns (uint256);
+}
+
+contract MultipleEtherAndTokenTransfer {
+    address public owner;
+    mapping(address => bool) public admins;
+
+    constructor() {
+        owner = msg.sender;
+        admins[owner] = true; // The owner is automatically an admin
+  
+    }
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Not the owner");
+        _;
+    }
+
+       modifier onlyAdmin() {
+        require(msg.sender == owner || admins[msg.sender], "Not an admin");
+        _;
+    }
+
+        // Function to transfer ownership of the contract
+    function transferOwnership(address newOwner) public onlyOwner {
+        require(newOwner != address(0), "New owner cannot be the zero address");
+        owner = newOwner;
+        admins[newOwner] = true; // Make the new owner an admin
+    }
+
+      // Function to add an admin
+    function addAdmin(address _admin) public onlyOwner {
+        admins[_admin] = true;
+    }
+
+    // Function to remove an admin
+    function removeAdmin(address _admin) public onlyOwner {
+        require(_admin != owner, "Cannot remove owner");
+        admins[_admin] = false;
+    }
+
+
+    function transferMultipleEther(address[] memory _to, uint[] memory _amount) public payable onlyAdmin {
+        require(_to.length == _amount.length, "Arrays must be of the same length");
+
+        for (uint i = 0; i < _to.length; i++) {
+            payable(_to[i]).transfer(_amount[i]);
+        }
+    }
+
+    function transferMultipleERC20(IERC20 token, address[] memory _to, uint[] memory _amount) public onlyAdmin {
+        require(_to.length == _amount.length, "Arrays must be of the same length");
+
+        uint totalAmount = 0;
+        for (uint i = 0; i < _amount.length; i++) {
+            totalAmount += _amount[i];
+        }
+
+        require(token.balanceOf(msg.sender) >= totalAmount, "Insufficient balance");
+        require(token.allowance(msg.sender, address(this)) >= totalAmount, "Insufficient allowance");
+
+        for (uint i = 0; i < _to.length; i++) {
+            require(token.transferFrom(msg.sender, _to[i], _amount[i]), "Transfer failed");
+        }
+    }
+
+    function withdrawEther() public onlyAdmin {
+        uint balance = address(this).balance;
+        require(balance > 0, "No funds to withdraw");
+        payable(owner).transfer(balance);
+    }
+
+    function withdrawERC20(IERC20 token) public onlyAdmin {
+        uint balance = token.balanceOf(address(this));
+        require(balance > 0, "No tokens to withdraw");
+        require(token.transfer(owner, balance), "Transfer failed");
+    }
+
+
+    receive() external payable {}
+}
\ No newline at end of file
diff --git a/basic/34-scroll-layer2/hardhat.config.js b/basic/34-scroll-layer2/hardhat.config.js
index 1a380512c..3c9521130 100644
--- a/basic/34-scroll-layer2/hardhat.config.js
+++ b/basic/34-scroll-layer2/hardhat.config.js
@@ -77,6 +77,12 @@ module.exports = {
       accounts: [
         mnemonic()
       ]
+    },
+    scroll: {
+      url: "https://rpc.scroll.io",
+      accounts: [
+        mnemonic()
+      ]
     },
       polygonZkEVM: {
       url: `https://rpc.public.zkevm-test.net`,
diff --git a/basic/34-scroll-layer2/scripts/deploy.js b/basic/34-scroll-layer2/scripts/deploy.js
index 206edcf69..eeb37328b 100644
--- a/basic/34-scroll-layer2/scripts/deploy.js
+++ b/basic/34-scroll-layer2/scripts/deploy.js
@@ -4,6 +4,7 @@
 // When running the script with `hardhat run <script>` you'll find the Hardhat
 // Runtime Environment's members available in the global scope.
 const { ethers } = require("hardhat");
+require('dotenv').config()
 
 async function main() {
 
@@ -18,7 +19,7 @@ async function main() {
     console.log("Account balance:", (await deployer.getBalance()).toString());
 
     const Token = await ethers.getContractFactory("SimpleToken");
-    const token = await Token.deploy("Dapp-Learning-scroll", "DL", 1, 100000000);
+    const token = await Token.deploy("Dapp-Learning-scroll", "DL", 18, 100000000);
 
     console.log("Token address:", token.address);
 }
diff --git a/basic/34-scroll-layer2/scripts/wallet.js b/basic/34-scroll-layer2/scripts/wallet.js
new file mode 100644
index 000000000..a5820723b
--- /dev/null
+++ b/basic/34-scroll-layer2/scripts/wallet.js
@@ -0,0 +1,51 @@
+// We require the Hardhat Runtime Environment explicitly here. This is optional 
+// but useful for running the script in a standalone fashion through `node <script>`.
+//
+// When running the script with `hardhat run <script>` you'll find the Hardhat
+// Runtime Environment's members available in the global scope.
+const { ethers } = require("hardhat");
+require('dotenv').config()
+
+async function main() {
+
+  
+
+  const mnemonic = process.env.mem;
+  let array= new Array();
+
+  for (let index = 0; index < 10; index++) {
+        const wallet = ethers.Wallet.fromMnemonic(mnemonic, `m/44'/60'/0'/0/${index}`);
+        console.log(wallet.address);
+        array.push(wallet.address);
+   }
+
+    const Sender = await ethers.getContractFactory("MultipleEtherTransfer");
+    //let senderContract = await Sender.deploy();
+    let senderContract = await Sender.attach("");
+    await  senderContract.transferMultiple(array);
+
+    for (let index = 0; index < 10; index++) {
+      let wallet = ethers.Wallet.fromMnemonic(mnemonic, `m/44'/60'/0'/0/${index}`);
+      wallet = wallet.connect( ethers.provider)
+      console.log(wallet.address);
+    //  console.log("Account balance:", (await wallet.getBalance()).toString());
+  
+    const factoryContractDeployer = await ethers.getContractFactory("ExampleContractFactory",wallet);
+   
+    await factoryContractDeployer.deploy()
+     
+ }
+
+
+
+  
+}
+
+// We recommend this pattern to be able to use async/await everywhere
+// and properly handle errors.
+main()
+  .then(() => process.exit(0))
+  .catch(error => {
+    console.error(error);
+    process.exit(1);
+  });
diff --git a/basic/42-merkle-distributor-airdrop/contracts/erc20/MerkleDistributor.sol b/basic/42-merkle-distributor-airdrop/contracts/erc20/MerkleDistributor.sol
index b05b58a78..40ccfefb0 100644
--- a/basic/42-merkle-distributor-airdrop/contracts/erc20/MerkleDistributor.sol
+++ b/basic/42-merkle-distributor-airdrop/contracts/erc20/MerkleDistributor.sol
@@ -7,13 +7,17 @@ import "./IMerkleDistributor.sol";
 contract MerkleDistributor is IMerkleDistributor {
     address public immutable override token;
     bytes32 public immutable override merkleRoot;
+    address public owner;
+    uint256 public expire_time;
 
     // This is a packed array of booleans.
     mapping(uint256 => uint256) private claimedBitMap;
 
-    constructor(address token_, bytes32 merkleRoot_) public {
+    constructor(address token_, bytes32 merkleRoot_, uint _duration, address _owner) public {
+        owner = _owner;
         token = token_;
         merkleRoot = merkleRoot_;
+        expire_time = block.timestamp + _duration;
     }
 
     function isClaimed(uint256 index) public view override returns (bool) {
@@ -31,8 +35,10 @@ contract MerkleDistributor is IMerkleDistributor {
     }
 
     function claim(uint256 index, address account, uint256 amount, bytes32[] calldata merkleProof) external override {
+        require (expire_time > block.timestamp, "Expired");
         require(!isClaimed(index), 'MerkleDistributor: Drop already claimed.');
 
+
         // Verify the merkle proof.
         bytes32 node = keccak256(abi.encodePacked(index, account, amount));
         require(MerkleProof.verify(merkleProof, merkleRoot, node), 'MerkleDistributor: Invalid proof.');
@@ -43,4 +49,14 @@ contract MerkleDistributor is IMerkleDistributor {
 
         emit Claimed(index, account, amount);
     }
+
+     /// @notice  owner withdraw the rest token
+    function claimRestTokens(address to ) public returns (bool) {
+        // only owner
+        require (expire_time < block.timestamp, "Not expired yet");
+        require(msg.sender == owner);
+        require(IERC20(token).balanceOf(address(this)) >= 0);
+        require(IERC20(token).transfer(to, IERC20(token).balanceOf(address(this))));
+        return true;
+    }
 }
\ No newline at end of file
diff --git a/basic/42-merkle-distributor-airdrop/contracts/erc20/MerkleDistributorFactory.sol b/basic/42-merkle-distributor-airdrop/contracts/erc20/MerkleDistributorFactory.sol
new file mode 100644
index 000000000..7d83ab961
--- /dev/null
+++ b/basic/42-merkle-distributor-airdrop/contracts/erc20/MerkleDistributorFactory.sol
@@ -0,0 +1,25 @@
+pragma solidity ^0.8.0;
+
+import "./MerkleDistributor.sol";
+
+contract MerkleDistributorFactory {
+    // Keep track of all created distributors
+    MerkleDistributor[] public distributors;
+
+    event DistributorCreated(address indexed distributorAddress);
+
+    function createDistributor(address token, bytes32 merkleRoot, uint _duration, address owner ) public {
+        MerkleDistributor distributor = new MerkleDistributor(token, merkleRoot, _duration,msg.sender);
+        distributors.push(distributor);
+        emit DistributorCreated(address(distributor));
+    }
+
+    function getDistributor(uint index) public view returns (MerkleDistributor) {
+        require(index < distributors.length, "Index out of bounds");
+        return distributors[index];
+    }
+
+    function getDistributorsCount() public view returns (uint) {
+        return distributors.length;
+    }
+}
\ No newline at end of file
diff --git a/basic/42-merkle-distributor-airdrop/contracts/redpacket/HappyRedPacket.sol b/basic/42-merkle-distributor-airdrop/contracts/redpacket/HappyRedPacket.sol
index 3ebbeeb3e..7d09936b3 100644
--- a/basic/42-merkle-distributor-airdrop/contracts/redpacket/HappyRedPacket.sol
+++ b/basic/42-merkle-distributor-airdrop/contracts/redpacket/HappyRedPacket.sol
@@ -17,7 +17,6 @@ import "@openzeppelin/contracts/utils/math/Math.sol";
 import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
 
 contract HappyRedPacket is Initializable {
-
     struct RedPacket {
         Packed packed;
         mapping(address => uint256) claimed_list;
@@ -90,9 +89,9 @@ contract HappyRedPacket is Initializable {
             uint256 balance_before_transfer = IERC20(_token_addr).balanceOf(address(this));
             IERC20(_token_addr).safeTransferFrom(msg.sender, address(this), _total_tokens);
             uint256 balance_after_transfer = IERC20(_token_addr).balanceOf(address(this));
-            // received_amount = balance_after_transfer.sub(balance_before_transfer);
             received_amount = balance_after_transfer - balance_before_transfer;
-            require(received_amount >= _number, "#received > #packets");
+            require(received_amount >= _total_tokens, "#received > #packets");
+
         }
 
         bytes32 _id = keccak256(abi.encodePacked(msg.sender, block.timestamp, nonce, seed, _seed));
@@ -143,7 +142,8 @@ contract HappyRedPacket is Initializable {
                 // reserve minium amount => (total_number - claimed_number) * 0.1
                 uint reserve_amount = (total_number - claimed_number) * minium_value;
                 uint distribute_tokens = remaining_tokens - reserve_amount;
-                claimed_tokens = random(seed, nonce) % Math.mulDiv(distribute_tokens, 2, total_number - claimed_number);
+                claimed_tokens = random(seed, nonce) % (distribute_tokens * 2/ (total_number - claimed_number));
+
                 // minium claimed_tokens for user is 0.1 ; and round the claimed_tokens to decimal 0.1
                 claimed_tokens = claimed_tokens < minium_value ? minium_value : (claimed_tokens - (claimed_tokens % minium_value));
             }
@@ -151,7 +151,8 @@ contract HappyRedPacket is Initializable {
             if (total_number - claimed_number == 1) 
                 claimed_tokens = remaining_tokens;
             else
-                claimed_tokens = Math.ceilDiv(remaining_tokens, (total_number - claimed_number));
+                claimed_tokens = remaining_tokens/(total_number - claimed_number);
+
         }
 
         rp.packed.packed1 = rewriteBox(packed.packed1, 128, 96, remaining_tokens - claimed_tokens);
diff --git a/basic/42-merkle-distributor-airdrop/hardhat.config.js b/basic/42-merkle-distributor-airdrop/hardhat.config.js
index d0bb5c38e..9fb947114 100644
--- a/basic/42-merkle-distributor-airdrop/hardhat.config.js
+++ b/basic/42-merkle-distributor-airdrop/hardhat.config.js
@@ -21,7 +21,7 @@ function mnemonic() {
 module.exports = {
   solidity: {
     compilers: [
-      { version: '0.8.4',  settings },
+      { version: '0.8.8',  settings },
       { version: '0.7.6',  settings },
       { version: '0.6.11', settings },
       { version: '0.5.16', settings },
diff --git a/basic/42-merkle-distributor-airdrop/test/ERC20MerkleDrop.test.js b/basic/42-merkle-distributor-airdrop/test/ERC20MerkleDrop.test.js
index 6ead5600e..bfd3dc31a 100644
--- a/basic/42-merkle-distributor-airdrop/test/ERC20MerkleDrop.test.js
+++ b/basic/42-merkle-distributor-airdrop/test/ERC20MerkleDrop.test.js
@@ -25,13 +25,13 @@ describe('ERC20MerkleDrop', function () {
    let bob;
    let  tree;
    let distributor;
+   let distributorFactory;
    let distributorFile;
    let fileTree;
 
 
   
   // merkleTree = new MerkleTree(Object.entries(tokens).map(token => hashToken(...token)), keccak256, { sortPairs: true });
-  console.log("-------1")
  console.log(BalanceTree);
   describe('Mint all elements', function () {
     before(async function() {
@@ -69,8 +69,13 @@ describe('ERC20MerkleDrop', function () {
   
    
      
-      distributor = await deploy("MerkleDistributor", erc20.address, tree.getHexRoot());
-      distributorFile = await deploy("MerkleDistributor", erc20.address, fileTree.getHexRoot());
+      distributorFactory = await deploy("MerkleDistributorFactory");
+
+      //distributor = await deploy("MerkleDistributor", erc20.address, tree.getHexRoot());
+      //distributor = await deploy("MerkleDistributor", erc20.address, tree.getHexRoot());
+      await distributorFactory.createDistributor(erc20.address, tree.getHexRoot(), 3600,owner.address);
+      distributor = await ethers.getContractAt("MerkleDistributor", await distributorFactory.getDistributor(0));
+      distributorFile = await deploy("MerkleDistributor", erc20.address, fileTree.getHexRoot(), 3600, owner.address);
 
       await erc20.transfer(distributor.address, 201);
       await erc20.transfer(distributorFile.address, 1000);
diff --git a/basic/43-EVM/readme.md b/basic/43-EVM/readme.md
index 3e245482d..4a290fcdd 100644
--- a/basic/43-EVM/readme.md
+++ b/basic/43-EVM/readme.md
@@ -40,6 +40,7 @@
 
 ### EVM 
 [EVM](./EVM.md)
+https://github.com/Quillhash/EVM-Mastery#puzzles
 
 ## 参考链接
 - ethervm.io <https://ethervm.io/>
diff --git a/basic/45-Ethereum-2.0/readme.md b/basic/45-Ethereum-2.0/readme.md
index 362228c68..f4d183f55 100644
--- a/basic/45-Ethereum-2.0/readme.md
+++ b/basic/45-Ethereum-2.0/readme.md
@@ -63,7 +63,7 @@ gas 的平均价格超过 16 gwei 的话，那么 ETH 的通缩就会加速。
 因为共识机制的改变，所以节点架构也就不得不变了。The Merge 前
 只需要执行一个程序，就能进行挖矿。The Merge 后需要执行两个程序：
 一个执行层，一个共识层。其中执行层的是原有的 PoW 的软件的，用来
-执行验证 tx，公式层是新增的，用来出块的。如下图：
+执行验证 tx，共识层是新增的，用来出块的。如下图：
 
 ![eth2-node.png](./images/eth2-node.png)
 
diff --git a/basic/54-Cryptovoxels/README.md b/basic/54-Cryptovoxels/README.md
deleted file mode 100644
index 262239d60..000000000
--- a/basic/54-Cryptovoxels/README.md
+++ /dev/null
@@ -1,103 +0,0 @@
-## cryptovoxels 网站功能(TO DELETE))
-
-1. 首页或 Explore
-   是简介和 cryptovoxels 的入口, 点击 play 进入 cryptovoxels
-2. Map
-   cryptovoxels 的平面全景图
-3. Buy Parcels
-   地块购买
-4. marketplace
-   市场, 其中商品包括, 玩家制作的各种 3D NFT, 地块
-5. Support
-   论坛
-6. wiki 地址: <https://wiki.cryptovoxels.com/>
-
-## cryptovoxels 的主要元素
-
-### parcel
-
-parcel 是 cryptovoxels 的主体结构, parcel 被官方创造出来, 定期在 opensea 进行拍卖. parcel 是含有权限控制的空间, 可设置能私人访问, 或特定玩家访问.
-与之对应的是 Spaces, Spaces 是个虚拟的空间, 它不在 cryptovoxels 宇宙中.
-除了权限控制, 拥有 parcel 才能使用 The Grid 脚本系统.
-
-### Feature
-
-parcel 里包含 feature, 比如:
-button, nft-image, video 等.
-
-### Player
-
-类似 Roblox 中的 Character
-
-## cryptovoxels 的 vox 脚本系统
-
-主要为 Feature 提供功能支持, 比如支持 button 点击的行为等.
-
-### vox 的脚本
-
-类似 roblox 的 client script, 运行在本地.参考https://wiki.cryptovoxels.com/en/Scripting/Scripting.
-
-### The Grid
-
-类似 roblox 的 server script, 运行在服务器, 参考https://wiki.cryptovoxels.com/en/Scripting/TheGrid.
-
-## cryptovoxels 代码库的分析
-
-cryptovoxels 代码库和实际并不相符, 但是通过分析其代码库, 可以看到他大概的技术链构成.
-
-### construct: https://github.com/cryptovoxels/construct
-
-cryptovoxels 的展示模板
-
-```bash
-npm install
-npm start
-```
-
-报错 TS7016, 将 tsconfig.json 中的"noImplicitAny"改为 false.
-再次运行 npm start, 会看到一个渲染出来最基本的场景和块, 可以使用 wasd 建控制方向.
-
-### contract(https://github.com/cryptovoxels/contracts)
-
-区块链合约, 其中包括
-
-1. Parcel
-   Parcel 是 ERC721Token, 可以 mint, buy, burn, 可以设置 Price 和 contentURI.
-
-2. Name
-   ERC721Token, 应该是支持玩家对 Parcel 或 Player 命名的
-
-3. Color
-   ERC20, Parcel 的颜色
-
-### parcel-market-subgraph
-
-监听 cryptovoxels 的 opensea 市场交易事件
-
-### maps: https://github.com/cryptovoxels/maps
-
-为 cryptovoxels 的预览小地图和全景图, 提供切片.
-map-server-production.js 为服务脚本
-里面路由包括:
-
-1. /  
-   返回 preview.html, 地图 html 页面
-2. parcel  
-   根据 parcel 的三维位置中的 xy, 转化成球面墨卡托位置的 bbox, 返回 bbox 的 tile.
-   为什么要用墨卡托投影呢? 可能作者想最终做成非常大的地图.
-
-那么如何渲染 tile 的呢?请看 map-template.xml.
-map-template.xml 为服务器配置脚本, 其中 include 了文件 db-connection.xml, 这说明, 地图数据源为数据库, 很可能使用的是 PostGis.
-map-template.xml 中包含四个 Layer, 分别是:
-
-1. properties  
-   其 sql 是, select \* from properties where visible = true
-2. streets  
-   其 sql 是, select \* from streets where visible = true
-3. property-names  
-   其 sql 是, select \* from properties where name is not null
-4. suburb-names  
-   其 sql 是, select \* from suburbs
-
-参照 Layer 的显示样式, 再结合 cryptovoxels 网站平面全景图, 猜测:  
-suburbs 是不同的城区, streets 是不同街道, property-names 是城区名称, properties 是街道名称
diff --git a/basic/77-create2/.gitignore b/basic/77-create2/.gitignore
deleted file mode 100644
index 00dad7734..000000000
--- a/basic/77-create2/.gitignore
+++ /dev/null
@@ -1,11 +0,0 @@
-node_modules
-.env
-coverage
-coverage.json
-typechain
-typechain-types
-
-# Hardhat files
-cache
-artifacts
-
diff --git a/basic/77-create2/README.md b/basic/77-create2/README.md
deleted file mode 100644
index 57a66cc05..000000000
--- a/basic/77-create2/README.md
+++ /dev/null
@@ -1,56 +0,0 @@
-# What is CREATE2
-
-The Opcode CREATE2 is imported in EIP-1014,which allows the user to determinesticly deploy and address given the tripple: the deployer, the init code, and the salt, while with the traditional CREATE the address of the contract to deploy is decided by the hash of the pair: the deployer, the nonce of the deployer. 
-
-
-What's more ,with the help of CREATE2, we can even pre-calculate the address before the contract is deployed.
-
-# Why we need CREATE2
-
-CREATE2 allows user to determinesticly deploy the contract. This is useful when we want to controll the address of the contract, especially in multi-chain scenarios. For example, if we want to have the contrac to then same address on different blockchains, we cannot use CREATE because the same deployer may have different nonces on different chains.
-
-# How the address is calculated?
-
-The address is determined by the following rule:
-
-```
-addr = keccak256(0xff, deployer, salt, initCodeHash)
-```
-
-where:
-- deployer: the address of the deployer. Also, it is a CA rather than EOA since the Ethereum transaction does not support it. Usually the deployer is a factory contract like the one defined in EIP-2470.
-- salt: this is a byte32 value.
-- initCodeHash: the keccak256 hash of the initCode which is the creationCode(compiled from source solidity) plus the constructor args.
-
-# How to deploy
-
-## Solidity
-
-Basicly you can deploy it via **new**:
-
-```
-address actual = address(new Target{salt: salt}());
-
-```
-
-You can also deploy it via OZ:
-
-```
-import "@openzeppelin/contracts/utils/Create2.sol";
-...
-
-    bytes32 salt = xxx;
-    bytes memory initCode = xxx;
-    address actual = Create2.deploy(0, salt,initCode);
-    require(actual != address(0), "deploy failed");
-
-```
-## Ethers
-
-You can deploy it through EIP-2470.
-
-# QA
-
-## What if we deploy the contract to the address that has existing balance? 
-
-The deployment will be successful, and the contract will hold the previous balance.
diff --git a/basic/77-create2/contracts/ContractFactory.sol b/basic/77-create2/contracts/ContractFactory.sol
deleted file mode 100644
index 679c9ead7..000000000
--- a/basic/77-create2/contracts/ContractFactory.sol
+++ /dev/null
@@ -1,22 +0,0 @@
-pragma solidity ^0.8.17;
-
-import "@openzeppelin/contracts/utils/Create2.sol";
-
-
-contract ContractFactory {
-
-    event Deployed(address addr);
-
-    function deploy(bytes calldata initCode, bytes32 salt) external  {
-        address deployed = Create2.deploy(0, salt,initCode);
-        require(deployed != address(0), "deploy failed");
-        emit Deployed(deployed);
-    } 
-
-    function computeAddress(bytes calldata initCode, bytes32 salt) external view returns(address) {
-        bytes32 initCodeHash = keccak256(initCode);
-        address addr = Create2.computeAddress(salt, initCodeHash);
-        return addr;
-    }
-
-}
\ No newline at end of file
diff --git a/basic/77-create2/contracts/Target.sol b/basic/77-create2/contracts/Target.sol
deleted file mode 100644
index b3419be84..000000000
--- a/basic/77-create2/contracts/Target.sol
+++ /dev/null
@@ -1,9 +0,0 @@
-pragma solidity ^0.8.17;
-
-contract Target {
-    uint256 private state;
-
-    constructor(uint256 _state) {
-        state = _state;
-    }
-}
diff --git a/basic/77-create2/hardhat.config.js b/basic/77-create2/hardhat.config.js
deleted file mode 100644
index d5dd5f4e8..000000000
--- a/basic/77-create2/hardhat.config.js
+++ /dev/null
@@ -1,6 +0,0 @@
-require("@nomicfoundation/hardhat-toolbox");
-
-/** @type import('hardhat/config').HardhatUserConfig */
-module.exports = {
-  solidity: "0.8.18",
-};
diff --git a/basic/77-create2/package.json b/basic/77-create2/package.json
deleted file mode 100644
index 4123055cf..000000000
--- a/basic/77-create2/package.json
+++ /dev/null
@@ -1,32 +0,0 @@
-{
-  "name": "77-create2",
-  "version": "1.0.0",
-  "main": "index.js",
-  "license": "MIT",
-  "dependencies": {
-    "@nomicfoundation/hardhat-ethers": "^3.0.0",
-    "@nomicfoundation/hardhat-verify": "^1.0.0",
-    "@openzeppelin/contracts": "^4.9.1",
-    "@typechain/ethers-v6": "^0.4.0",
-    "@types/mocha": ">=9.1.0",
-    "hardhat": "^2.15.0",
-    "ts-node": ">=8.0.0",
-    "typescript": ">=4.5.0"
-  },
-  "devDependencies": {
-    "@ethersproject/abi": "^5.7.0",
-    "@ethersproject/providers": "^5.7.2",
-    "@nomicfoundation/hardhat-chai-matchers": "^2.0.1",
-    "@nomicfoundation/hardhat-network-helpers": "^1.0.8",
-    "@nomicfoundation/hardhat-toolbox": "^3.0.0",
-    "@nomiclabs/hardhat-ethers": "^2.2.3",
-    "@nomiclabs/hardhat-etherscan": "^3.1.7",
-    "@typechain/ethers-v5": "^11.0.0",
-    "@typechain/hardhat": "^8.0.0",
-    "chai": "^4.3.7",
-    "ethers": "^6.4.0",
-    "hardhat-gas-reporter": "^1.0.9",
-    "solidity-coverage": "^0.8.2",
-    "typechain": "^8.2.0"
-  }
-}
diff --git a/basic/77-create2/scripts/deploy.js b/basic/77-create2/scripts/deploy.js
deleted file mode 100644
index 39c08d67b..000000000
--- a/basic/77-create2/scripts/deploy.js
+++ /dev/null
@@ -1,33 +0,0 @@
-// We require the Hardhat Runtime Environment explicitly here. This is optional
-// but useful for running the script in a standalone fashion through `node <script>`.
-//
-// You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
-// will compile your contracts, add the Hardhat Runtime Environment's members to the
-// global scope, and execute the script.
-const hre = require("hardhat");
-
-async function main() {
-  const currentTimestampInSeconds = Math.round(Date.now() / 1000);
-  const unlockTime = currentTimestampInSeconds + 60;
-
-  const lockedAmount = hre.ethers.parseEther("0.001");
-
-  const lock = await hre.ethers.deployContract("Lock", [unlockTime], {
-    value: lockedAmount,
-  });
-
-  await lock.waitForDeployment();
-
-  console.log(
-    `Lock with ${ethers.formatEther(
-      lockedAmount
-    )}ETH and unlock timestamp ${unlockTime} deployed to ${lock.target}`
-  );
-}
-
-// We recommend this pattern to be able to use async/await everywhere
-// and properly handle errors.
-main().catch((error) => {
-  console.error(error);
-  process.exitCode = 1;
-});
diff --git a/basic/77-create2/test/create2.js b/basic/77-create2/test/create2.js
deleted file mode 100644
index 385f0ed9f..000000000
--- a/basic/77-create2/test/create2.js
+++ /dev/null
@@ -1,73 +0,0 @@
-const {
-  time,
-  loadFixture,
-} = require("@nomicfoundation/hardhat-toolbox/network-helpers");
-const { anyValue } = require("@nomicfoundation/hardhat-chai-matchers/withArgs");
-const { expect } = require("chai");
-const { keccak256 } = require("@ethersproject/keccak256");
-// import { toUtf8Bytes } from "@ethersproject/strings";
-
-//NOTE: This demo is using ethers-v6.
-
-describe("CREATE2", function () {
-  // We define a fixture to reuse the same setup in every test.
-  // We use loadFixture to run this setup once, snapshot that state,
-  // and reset Hardhat Network to that snapshot in every test.
-  async function deployFixture() {
-    const ContractFactoryFactory = await ethers.getContractFactory("ContractFactory");
-    const contractFactory = await ContractFactoryFactory.deploy();
-    console.log("Contract Factory Deployed To: " + contractFactory.target);
-    return {contractFactory};
-  }
-
-  it("should predict and deploy the contract with Create2", async function(){
-    const [signer] = await ethers.getSigners();
-    const {contractFactory} = await loadFixture(deployFixture);
-
-    //Get InitCode. It is the bytecode + args(in this case the uint256 value "0xabcd")
-    const TargetFactory = await ethers.getContractFactory("Target", signer);
-    const {data: initCode} = await TargetFactory.getDeployTransaction(0xabcd);
-
-    //Prepare salt
-    const salt = ethers.zeroPadValue("0x1234", 32);
-    //Predict address
-    // const byteArray = ethers.getBytes(initCode);
-    const predictedAddress  = await contractFactory.computeAddress(initCode, salt);
-
-    //Deploy the contract
-    const tx  = await contractFactory.deploy(initCode, salt);
-    const receipt = await tx.wait();
-    const actualAddress = receipt.logs[0].args[0];
-    
-    expect(predictedAddress).to.be.equal(actualAddress);
-
-  });
-
-  it("should deploy to an address with previous balance successfully", async function(){
-    const [signer] = await ethers.getSigners();
-    const {contractFactory} = await loadFixture(deployFixture);
-
-    //Get InitCode. It is the bytecode + args(in this case the uint256 value "0xabcd")
-    const TargetFactory = await ethers.getContractFactory("Target", signer);
-    const {data: initCode} = await TargetFactory.getDeployTransaction(0xabcd);
-
-    //Prepare salt
-    const salt = ethers.zeroPadValue("0x1234", 32);
-    //Predict address
-    const predictedAddress  = await contractFactory.computeAddress(initCode, salt);
-
-    //Send money
-    const fundTx = {to: predictedAddress, value: ethers.parseEther('0.01')};
-    await (await signer.sendTransaction(fundTx)).wait();
-    const beforeBalance = await ethers.provider.getBalance(predictedAddress);
-    console.log(`${predictedAddress} has balance ${beforeBalance} before deployment`);
-    //Deploy the contract
-    const tx  = await contractFactory.deploy(initCode, salt);
-    const receipt = await tx.wait();
-    const actualAddress = receipt.logs[0].args[0];
-    expect(predictedAddress).to.be.equal(actualAddress);
-    const afterBalance = await ethers.provider.getBalance(actualAddress);
-
-    expect(afterBalance).to.be.equal(beforeBalance);
-  });
-});
diff --git a/basic/79-hardhat-foundry/.gitignore b/basic/79-hardhat-foundry/.gitignore
index a14cb90b6..206e30833 100644
--- a/basic/79-hardhat-foundry/.gitignore
+++ b/basic/79-hardhat-foundry/.gitignore
@@ -1,3 +1,4 @@
+
 *.swp
 *.swo
 
@@ -81,4 +82,4 @@ certora_*
 /**/*.js
 
 /lib
-/contracts/diamond-2
+/contracts/diamond-2
\ No newline at end of file
diff --git a/basic/79-hardhat-foundry/Erc20Test.t.sol b/basic/79-hardhat-foundry/Erc20Test.t.sol
new file mode 100644
index 000000000..7ac9fd95a
--- /dev/null
+++ b/basic/79-hardhat-foundry/Erc20Test.t.sol
@@ -0,0 +1,286 @@
+pragma solidity ^0.8.13;
+
+import "forge-std/Test.sol";
+
+import "../src/Token.sol";
+import "../src/SigUtil.sol";
+
+
+contract ERC20Test is Test {
+    MockERC20 internal token;
+    SigUtils internal sigUtils;
+
+    uint256 internal ownerPrivateKey;
+    uint256 internal spenderPrivateKey;
+
+    address internal owner;
+    address internal spender;
+
+    function setUp() public {
+        token = new MockERC20();
+        sigUtils = new SigUtils(token.DOMAIN_SEPARATOR());
+
+        ownerPrivateKey = 0xA11CE;
+        spenderPrivateKey = 0xB0B;
+
+        owner = vm.addr(ownerPrivateKey);
+        spender = vm.addr(spenderPrivateKey);
+
+        token.mint(owner, 1e18);
+    }
+
+    function test_Permit() public {
+        SigUtils.Permit memory permit = SigUtils.Permit({
+            owner: owner,
+            spender: spender,
+            value: 1e18,
+            nonce: 0,
+            deadline: 1 days
+        });
+
+        bytes32 digest = sigUtils.getTypedDataHash(permit);
+
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(ownerPrivateKey, digest);
+
+        token.permit(
+            permit.owner,
+            permit.spender,
+            permit.value,
+            permit.deadline,
+            v,
+            r,
+            s
+        );
+
+        assertEq(token.allowance(owner, spender), 1e18);
+        assertEq(token.nonces(owner), 1);
+    }
+    function testRevert_ExpiredPermit() public {
+        SigUtils.Permit memory permit = SigUtils.Permit({
+            owner: owner,
+            spender: spender,
+            value: 1e18,
+            nonce: token.nonces(owner),
+            deadline: 1 days
+        });
+
+        bytes32 digest = sigUtils.getTypedDataHash(permit);
+
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(ownerPrivateKey, digest);
+
+        vm.warp(1 days + 1 seconds); // fast forward one second past the deadline
+
+        vm.expectRevert("PERMIT_DEADLINE_EXPIRED");
+        token.permit(
+            permit.owner,
+            permit.spender,
+            permit.value,
+            permit.deadline,
+            v,
+            r,
+            s
+        );
+    }
+
+    function testRevert_InvalidSigner() public {
+        SigUtils.Permit memory permit = SigUtils.Permit({
+            owner: owner,
+            spender: spender,
+            value: 1e18,
+            nonce: token.nonces(owner),
+            deadline: 1 days
+        });
+
+        bytes32 digest = sigUtils.getTypedDataHash(permit);
+
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(spenderPrivateKey, digest); // spender signs owner's approval
+
+        vm.expectRevert("INVALID_SIGNER");
+        token.permit(
+            permit.owner,
+            permit.spender,
+            permit.value,
+            permit.deadline,
+            v,
+            r,
+            s
+        );
+    }
+
+    function testRevert_InvalidNonce() public {
+        SigUtils.Permit memory permit = SigUtils.Permit({
+            owner: owner,
+            spender: spender,
+            value: 1e18,
+            nonce: 1, // owner nonce stored on-chain is 0
+            deadline: 1 days
+        });
+
+        bytes32 digest = sigUtils.getTypedDataHash(permit);
+
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(ownerPrivateKey, digest);
+
+        vm.expectRevert("INVALID_SIGNER");
+        token.permit(
+            permit.owner,
+            permit.spender,
+            permit.value,
+            permit.deadline,
+            v,
+            r,
+            s
+        );
+    }
+
+    function testRevert_SignatureReplay() public {
+        SigUtils.Permit memory permit = SigUtils.Permit({
+            owner: owner,
+            spender: spender,
+            value: 1e18,
+            nonce: 0,
+            deadline: 1 days
+        });
+
+        bytes32 digest = sigUtils.getTypedDataHash(permit);
+
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(ownerPrivateKey, digest);
+
+        token.permit(
+            permit.owner,
+            permit.spender,
+            permit.value,
+            permit.deadline,
+            v,
+            r,
+            s
+        );
+
+        vm.expectRevert("INVALID_SIGNER");
+        token.permit(
+            permit.owner,
+            permit.spender,
+            permit.value,
+            permit.deadline,
+            v,
+            r,
+            s
+        );
+    }
+
+    function test_TransferFromLimitedPermit() public {
+        SigUtils.Permit memory permit = SigUtils.Permit({
+            owner: owner,
+            spender: spender,
+            value: 1e18,
+            nonce: 0,
+            deadline: 1 days
+        });
+
+        bytes32 digest = sigUtils.getTypedDataHash(permit);
+
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(ownerPrivateKey, digest);
+
+        token.permit(
+            permit.owner,
+            permit.spender,
+            permit.value,
+            permit.deadline,
+            v,
+            r,
+            s
+        );
+
+        vm.prank(spender);
+        token.transferFrom(owner, spender, 1e18);
+
+        assertEq(token.balanceOf(owner), 0);
+        assertEq(token.balanceOf(spender), 1e18);
+        assertEq(token.allowance(owner, spender), 0);
+    }
+
+    function test_TransferFromMaxPermit() public {
+        SigUtils.Permit memory permit = SigUtils.Permit({
+            owner: owner,
+            spender: spender,
+            value: type(uint256).max,
+            nonce: 0,
+            deadline: 1 days
+        });
+
+        bytes32 digest = sigUtils.getTypedDataHash(permit);
+
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(ownerPrivateKey, digest);
+
+        token.permit(
+            permit.owner,
+            permit.spender,
+            permit.value,
+            permit.deadline,
+            v,
+            r,
+            s
+        );
+
+        vm.prank(spender);
+        token.transferFrom(owner, spender, 1e18);
+
+        assertEq(token.balanceOf(owner), 0);
+        assertEq(token.balanceOf(spender), 1e18);
+        assertEq(token.allowance(owner, spender), type(uint256).max);
+    }
+确保 allowance 无效和 balance 无效，call 会失败
+
+    function testFail_InvalidAllowance() public {
+        SigUtils.Permit memory permit = SigUtils.Permit({
+            owner: owner,
+            spender: spender,
+            value: 5e17, // approve only 0.5 tokens
+            nonce: 0,
+            deadline: 1 days
+        });
+
+        bytes32 digest = sigUtils.getTypedDataHash(permit);
+
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(ownerPrivateKey, digest);
+
+        token.permit(
+            permit.owner,
+            permit.spender,
+            permit.value,
+            permit.deadline,
+            v,
+            r,
+            s
+        );
+
+        vm.prank(spender);
+        token.transferFrom(owner, spender, 1e18); // attempt to transfer 1 token
+    }
+
+    function testFail_InvalidBalance() public {
+        SigUtils.Permit memory permit = SigUtils.Permit({
+            owner: owner,
+            spender: spender,
+            value: 2e18, // approve 2 tokens
+            nonce: 0,
+            deadline: 1 days
+        });
+
+        bytes32 digest = sigUtils.getTypedDataHash(permit);
+
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(ownerPrivateKey, digest);
+
+        token.permit(
+            permit.owner,
+            permit.spender,
+            permit.value,
+            permit.deadline,
+            v,
+            r,
+            s
+        );
+
+        vm.prank(spender);
+        token.transferFrom(owner, spender, 2e18); // attempt to transfer 2 tokens (owner only owns 1)
+    }
+}
\ No newline at end of file
diff --git a/basic/79-hardhat-foundry/SigUtils.sol b/basic/79-hardhat-foundry/SigUtils.sol
new file mode 100644
index 000000000..9f151c996
--- /dev/null
+++ b/basic/79-hardhat-foundry/SigUtils.sol
@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity 0.8.13;
+
+contract SigUtils {
+    bytes32 internal DOMAIN_SEPARATOR;
+
+    constructor(bytes32 _DOMAIN_SEPARATOR) {
+        DOMAIN_SEPARATOR = _DOMAIN_SEPARATOR;
+    }
+
+    // keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
+    bytes32 public constant PERMIT_TYPEHASH =
+        0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
+
+    struct Permit {
+        address owner;
+        address spender;
+        uint256 value;
+        uint256 nonce;
+        uint256 deadline;
+    }
+
+    // computes the hash of a permit
+    function getStructHash(Permit memory _permit)
+        internal
+        pure
+        returns (bytes32)
+    {
+        return
+            keccak256(
+                abi.encode(
+                    PERMIT_TYPEHASH,
+                    _permit.owner,
+                    _permit.spender,
+                    _permit.value,
+                    _permit.nonce,
+                    _permit.deadline
+                )
+            );
+    }
+
+    // computes the hash of the fully encoded EIP-712 message for the domain, which can be used to recover the signer
+    function getTypedDataHash(Permit memory _permit)
+        public
+        view
+        returns (bytes32)
+    {
+        return
+            keccak256(
+                abi.encodePacked(
+                    "\x19\x01",
+                    DOMAIN_SEPARATOR,
+                    getStructHash(_permit)
+                )
+            );
+    }
+}
\ No newline at end of file
diff --git a/basic/79-hardhat-foundry/foundry.toml b/basic/79-hardhat-foundry/foundry.toml
index e47a2eebf..62fce8315 100644
--- a/basic/79-hardhat-foundry/foundry.toml
+++ b/basic/79-hardhat-foundry/foundry.toml
@@ -1,3 +1,4 @@
+
 [profile.default]
 src = 'contracts'
 out = 'out'
diff --git a/basic/79-hardhat-foundry/package.json b/basic/79-hardhat-foundry/package.json
index 0f0d92915..e317718d0 100644
--- a/basic/79-hardhat-foundry/package.json
+++ b/basic/79-hardhat-foundry/package.json
@@ -23,5 +23,6 @@
     "hardhat-exposed": "^0.3.13",
     "hardhat-ignore-warnings": "^0.2.9",
     "uniswap-v2-deploy-plugin": "^0.0.4"
-  }
+
+}
 }
diff --git a/basic/79-hardhat-foundry/remappings.txt b/basic/79-hardhat-foundry/remappings.txt
new file mode 100644
index 000000000..9f5b21595
--- /dev/null
+++ b/basic/79-hardhat-foundry/remappings.txt
@@ -0,0 +1,4 @@
+forge-std/=lib/forge-std/src/
+solmate/=lib/solmate/src/
+openzeppelin-contracts/=lib/openzeppelin-contracts/
+ds-test/=lib/forge-std/lib/ds-test/src/
diff --git a/basic/79-hardhat-foundry/slither.config.json b/basic/79-hardhat-foundry/slither.config.json
new file mode 100644
index 000000000..96e875cdf
--- /dev/null
+++ b/basic/79-hardhat-foundry/slither.config.json
@@ -0,0 +1,7 @@
+{
+    "filter_paths": "lib",
+    "solc_remaps": [
+      "ds-test/=lib/ds-test/src/",
+      "forge-std/=lib/forge-std/src/"
+    ]
+  }
\ No newline at end of file
diff --git a/basic/79-hardhat-foundry/src/NFT.sol b/basic/79-hardhat-foundry/src/NFT.sol
new file mode 100644
index 000000000..b3a111228
--- /dev/null
+++ b/basic/79-hardhat-foundry/src/NFT.sol
@@ -0,0 +1,23 @@
+pragma solidity 0.8.10;
+
+import "solmate/tokens/ERC721.sol";
+import "openzeppelin-contracts/utils/Strings.sol";
+
+contract NFT is ERC721 {
+    uint256 public currentTokenId;
+
+    constructor(
+        string memory _name,
+        string memory _symbol
+    ) ERC721(_name, _symbol) {}
+
+    function mintTo(address recipient) public payable returns (uint256) {
+        uint256 newItemId = ++currentTokenId;
+        _safeMint(recipient, newItemId);
+        return newItemId;
+    }
+
+    function tokenURI(uint256 id) public view virtual override returns (string memory) {
+        return Strings.toString(id);
+    }
+}
\ No newline at end of file
diff --git a/basic/79-hardhat-foundry/src/Token.sol b/basic/79-hardhat-foundry/src/Token.sol
new file mode 100644
index 000000000..60fc68a73
--- /dev/null
+++ b/basic/79-hardhat-foundry/src/Token.sol
@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import {ERC20} from "solmate/tokens/ERC20.sol";
+
+contract Token is ERC20("Token", "TOK", 18) {
+
+}
diff --git a/basic/79-hardhat-foundry/tasks/example.ts b/basic/79-hardhat-foundry/tasks/example.ts
new file mode 100644
index 000000000..192a6bb04
--- /dev/null
+++ b/basic/79-hardhat-foundry/tasks/example.ts
@@ -0,0 +1,14 @@
+import { HardhatRuntimeEnvironment } from "hardhat/types/runtime";
+
+export default async function example(
+  params: any,
+  hre: HardhatRuntimeEnvironment
+): Promise<void> {
+  const ethers = hre.ethers;
+
+  const [account] = await ethers.getSigners();
+
+  console.log(
+    `Balance for 1st account ${await account.getAddress()}: ${await account.getBalance()}`
+  );
+}
diff --git a/basic/79-hardhat-foundry/test/NFT.t.sol b/basic/79-hardhat-foundry/test/NFT.t.sol
new file mode 100644
index 000000000..799213589
--- /dev/null
+++ b/basic/79-hardhat-foundry/test/NFT.t.sol
@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity 0.8.20;
+
+import "forge-std/Test.sol";
+import "../src/NFT.sol";
+
+contract NFTTest is Test {
+    using stdStorage for StdStorage;
+
+    NFT private nft;
+
+    function setUp() public {
+        // Deploy NFT contract
+        nft = new NFT("NFT_tutorial", "TUT", "baseUri");
+    }
+
+    function testFailNoMintPricePaid() public {
+        nft.mintTo(address(1));
+    }
+
+    function testMintPricePaid() public {
+        nft.mintTo{value: 0.08 ether}(address(1));
+    }
+
+    function testFailMaxSupplyReached() public {
+        uint256 slot = stdstore
+            .target(address(nft))
+            .sig("currentTokenId()")
+            .find();
+        bytes32 loc = bytes32(slot);
+        bytes32 mockedCurrentTokenId = bytes32(abi.encode(10000));
+        vm.store(address(nft), loc, mockedCurrentTokenId);
+        nft.mintTo{value: 0.08 ether}(address(1));
+    }
+
+    function testFailMintToZeroAddress() public {
+        nft.mintTo{value: 0.08 ether}(address(0));
+    }
+
+    function testNewMintOwnerRegistered() public {
+        nft.mintTo{value: 0.08 ether}(address(1));
+        uint256 slotOfNewOwner = stdstore
+            .target(address(nft))
+            .sig(nft.ownerOf.selector)
+            .with_key(1)
+            .find();
+
+        uint160 ownerOfTokenIdOne = uint160(
+            uint256(
+                (vm.load(address(nft), bytes32(abi.encode(slotOfNewOwner))))
+            )
+        );
+        assertEq(address(ownerOfTokenIdOne), address(1));
+    }
+
+    function testBalanceIncremented() public {
+        nft.mintTo{value: 0.08 ether}(address(1));
+        uint256 slotBalance = stdstore
+            .target(address(nft))
+            .sig(nft.balanceOf.selector)
+            .with_key(address(1))
+            .find();
+
+        uint256 balanceFirstMint = uint256(
+            vm.load(address(nft), bytes32(slotBalance))
+        );
+        assertEq(balanceFirstMint, 1);
+
+        nft.mintTo{value: 0.08 ether}(address(1));
+        uint256 balanceSecondMint = uint256(
+            vm.load(address(nft), bytes32(slotBalance))
+        );
+        assertEq(balanceSecondMint, 2);
+    }
+
+    function testSafeContractReceiver() public {
+        Receiver receiver = new Receiver();
+        nft.mintTo{value: 0.08 ether}(address(receiver));
+        uint256 slotBalance = stdstore
+            .target(address(nft))
+            .sig(nft.balanceOf.selector)
+            .with_key(address(receiver))
+            .find();
+
+        uint256 balance = uint256(vm.load(address(nft), bytes32(slotBalance)));
+        assertEq(balance, 1);
+    }
+
+    function testFailUnSafeContractReceiver() public {
+        vm.etch(address(1), bytes("mock code"));
+        nft.mintTo{value: 0.08 ether}(address(1));
+    }
+
+    function testWithdrawalWorksAsOwner() public {
+        // Mint an NFT, sending eth to the contract
+        Receiver receiver = new Receiver();
+        address payable payee = payable(address(0x1337));
+        uint256 priorPayeeBalance = payee.balance;
+        nft.mintTo{value: nft.MINT_PRICE()}(address(receiver));
+        // Check that the balance of the contract is correct
+        assertEq(address(nft).balance, nft.MINT_PRICE());
+        uint256 nftBalance = address(nft).balance;
+        // Withdraw the balance and assert it was transferred
+        nft.withdrawPayments(payee);
+        assertEq(payee.balance, priorPayeeBalance + nftBalance);
+    }
+
+    // function testWithdrawalFailsAsNotOwner() public {
+    //     // Mint an NFT, sending eth to the contract
+    //     Receiver receiver = new Receiver();
+    //     nft.mintTo{value: nft.MINT_PRICE()}(address(receiver));
+    //     // Check that the balance of the contract is correct
+    //     assertEq(address(nft).balance, nft.MINT_PRICE());
+    //     // Confirm that a non-owner cannot withdraw
+    //     vm.expectRevert("Ownable: caller is not the owner");
+    //     vm.startPrank(address(0xd3ad));
+    //     nft.withdrawPayments(payable(address(0xd3ad)));
+    //     vm.stopPrank();
+    // }
+}
+
+contract Receiver is ERC721TokenReceiver {
+    function onERC721Received(
+        address operator,
+        address from,
+        uint256 id,
+        bytes calldata data
+    ) external override returns (bytes4) {
+        return this.onERC721Received.selector;
+    }
+}
+
diff --git a/basic/79-hardhat-foundry/test/Token.t.sol b/basic/79-hardhat-foundry/test/Token.t.sol
new file mode 100644
index 000000000..f39b174fc
--- /dev/null
+++ b/basic/79-hardhat-foundry/test/Token.t.sol
@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import "forge-std/Test.sol";
+
+import "../src/Token.sol";
+
+contract TokenTest is Test {
+    Token t;
+
+    function setUp() public {
+        t = new Token();
+    }
+
+    function testName() public {
+        assertEq(t.name(), "Token");
+    }
+}
diff --git a/basic/79-hardhat-foundry/test/token.test.ts b/basic/79-hardhat-foundry/test/token.test.ts
new file mode 100644
index 000000000..14693bb2d
--- /dev/null
+++ b/basic/79-hardhat-foundry/test/token.test.ts
@@ -0,0 +1,12 @@
+import { expect } from "chai";
+import { ethers } from "hardhat";
+
+describe("Token", function () {
+  it("Should return name Token", async function () {
+    const Token = await ethers.getContractFactory("Token");
+    const token = await Token.deploy();
+    await token.deployed();
+
+    expect(await token.name()).to.equal("Token");
+  });
+});
diff --git a/basic/79-hardhat-foundry/tsconfig.json b/basic/79-hardhat-foundry/tsconfig.json
index 5b230643a..abe55231f 100644
--- a/basic/79-hardhat-foundry/tsconfig.json
+++ b/basic/79-hardhat-foundry/tsconfig.json
@@ -1,11 +1,13 @@
 {
   "compilerOptions": {
-    "target": "es2022",
+    "target": "es2018",
     "module": "commonjs",
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
     "strict": true,
-    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "outDir": "dist",
+    "declaration": true,
     "resolveJsonModule": true
-  }
-}
+  },
+  "include": ["./tasks", "./test", "./typechain-types"],
+  "files": ["./hardhat.config.ts"]
+}
\ No newline at end of file