diff --git a/basic/79-hardhat-foundry/.env.example b/basic/79-hardhat-foundry/.env.example
new file mode 100644
index 000000000..8196bef02
--- /dev/null
+++ b/basic/79-hardhat-foundry/.env.example
@@ -0,0 +1,4 @@
+PRIVATE_KEY=0x0000000000000000000000000000000000000000000000000000000000000000
+ETHERSCAN_BSC=
+ETHERSCAN_ETH=
+ETHERSCAN_ARB=
diff --git a/basic/79-hardhat-foundry/.gitignore b/basic/79-hardhat-foundry/.gitignore
new file mode 100644
index 000000000..a14cb90b6
--- /dev/null
+++ b/basic/79-hardhat-foundry/.gitignore
@@ -0,0 +1,84 @@
+*.swp
+*.swo
+
+# Logs
+logs
+*.log
+
+# Runtime data
+pids
+*.pid
+*.seed
+allFiredEvents
+scTopics
+
+# Coverage directory used by tools like istanbul
+coverage
+coverage.json
+coverageEnv
+
+# node-waf configuration
+.lock-wscript
+
+# Dependency directory
+node_modules
+
+# Debug log from npm
+npm-debug.log
+
+# local env variables
+.env
+
+# truffle build directory
+build/
+
+# macOS
+.DS_Store
+
+# truffle
+.node-xmlhttprequest-*
+
+# IntelliJ IDE
+.idea
+
+# vscode IDE
+.vscode
+
+# docs artifacts
+docs/modules/api
+
+# only used to package @openzeppelin/contracts
+contracts/build/
+contracts/README.md
+
+# temporary artifact from solidity-coverage
+.coverage_artifacts
+.coverage_cache
+.coverage_contracts
+
+# hardat-exposed
+contracts-exposed
+
+# Hardhat
+cache
+artifacts
+
+# Foundry
+out
+cache_forge
+
+# Certora
+.certora*
+.last_confs
+certora_*
+.zip-output-url.txt
+
+# extends
+/abi
+/abi-pure
+
+/typechain-types
+/**/*.js
+
+/lib
+/contracts/diamond-2
diff --git a/basic/79-hardhat-foundry/.gitmodules b/basic/79-hardhat-foundry/.gitmodules
new file mode 100644
index 000000000..4e7cc8a7d
--- /dev/null
+++ b/basic/79-hardhat-foundry/.gitmodules
@@ -0,0 +1,6 @@
+[submodule "lib/forge-std"]
+	path = lib/forge-std
+	url = https://github.com/foundry-rs/forge-std
+[submodule "contracts/diamond-2"]
+	path = contracts/diamond-2
+	url = https://github.com/mudgen/diamond-2-hardhat.git
diff --git a/basic/79-hardhat-foundry/README.en.md b/basic/79-hardhat-foundry/README.en.md
new file mode 100644
index 000000000..6b628579e
--- /dev/null
+++ b/basic/79-hardhat-foundry/README.en.md
@@ -0,0 +1,559 @@
+# Hardhat-Foundry
+## Preface
+
+1. **Question 1: Why use `hardhat`?**
+
+   A few years ago, `remix` and `truffle` were popular. At that time, `remix` lacked tools like `console`, and `truffle` didn't have a `debug` feature. `tenderly` was nowhere to be found in the browser, and issues in the code could only be addressed through `code review` and `revert` tests. **Back then, we lacked a comprehensive engineering framework, and most projects had only a few contracts.**
+
+   Later, `hardhat` became popular. It allowed debugging code using `console.log`, forked networks without the need for `Ganache` or `Geth`, and wrote tests without needing to review the function names and parameters inside contracts (`Typescript`)... So, **it's time to use `hardhat`; it has truly made significant advancements beyond `truffle`.**
+
+2. **Question 2: I'm already using `hardhat`, why do I need `foundry`?**
+
+   `hardhat` has **some minor pain points**, such as:
+
+    - Tedious preparation for contract testing (deployment and initialization).
+    - Cumbersome testing of `Library` contracts.
+    - Data type conversions in certain scenarios.
+    - Data encoding and decoding.
+    - Frustration when reproducing utility functions in the JS layer, and more.
+
+   To address these issues, **`foundry` appeared, innovatively suggesting using the `Solidity` language to test `Solidity`**!!! Now, you can write tests with minimal code!
+
+3. **Question 3: Why not fully embrace `foundry`?**
+
+   `foundry` has its shortcomings. You may struggle with its dependency management (you might need to copy links from GitHub), cross-platform compatibility, a variety of CMD commands, and perhaps the inability to reuse some mature testing scripts (js/ts), and more. **`foundry` is revolutionary but hasn't fully inherited the wealth of its predecessors—JS ecosystem/hardhat ecosystem**, which is somewhat regrettable.
+
+4. **Question 4: How should I choose a development framework?**
+
+   I won't go into a detailed discussion of the pros and cons of `remix`, `truffle`, `hardhat`, and `foundry`, and then throw the choice back to you. Here, I will give you a direct answer—**unless there is a major innovation, go ahead and choose `hardhat-foundry` without thinking twice**. This is the best combination I have come up with after experiencing numerous technical iterations and project practices, so feel free to use it. If you really like `foundry`, my friend, unless you have completely transformed into a professional contract tester, it is not recommended to use pure `foundry`. Developers will always need to write or deal with some `js/ts` scripts.
+
+   Combining the strengths of many is always the best choice.
+
+## Preparation
+
+- Download the `forge` program: https://github.com/foundry-rs/foundry/releases
+- Set up environment variables.
+- Create a project (I personally recommend `solidity-framework`).
+
+-----
+
+Some useful links:
+
+- `ChainList`: https://chainlist.org/
+
+  Here you can find RPC links that you can copy and use with ease. You don't need to register on `Infura` (especially if you're a beginner).
+
+- `Tenderly` https://dashboard.tenderly.co/explorer
+
+  Here, you can search for transaction call stacks, examine the execution flow of transactions, etc. (if the contract is open-source).
+
+- `foundry` https://github.com/Dapp-Learning-DAO/Dapp-Learning/tree/main/basic/41-foundry
+
+  Excellent introductory points summarized by the predecessors at `Dapp-Learning`. I recommend browsing this.
+
+## Core Operations
+
+**Remember not to try to memorize all functions except the core operations**.
+
+1. **Contract Compilation**
+
+- `npx hardhat compile`
+
+2. **Contract Testing**
+
+- `npx hardhat test` | For more usage, `npx hardhat test --help`
+- `forge test`  | `forge test --mc <filename match> -vv`
+
+3. **Local Blockchain Network [Recommended `hardhat`]**
+
+- `npx hardhat node`
+
+4. **Run TS scripts on a specific blockchain network (e.g., deployment)**
+
+- `npx hardhat --network <network name> run <script path>`
+
+> Important Notes
+
+- `forge --help` for a complete list of commands (some commands may have bugs).
+- `forge debug <contract path> --sig <function signature> [parameter list]` Debugging functions is suitable for low-level assembly development, assisting in observing the stack and memory data.
+
+## Configuration Instructions
+
+- Project Dependencies
+
+```json
+{
+  "name": "11-hardhat-foundry",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@chainlink/contracts": "^0.8.0", // Oracle contract provider, you might need its interface
+    "@nomicfoundation/hardhat-foundry": "^1.1.1", // Foundry environment file generator
+    "@nomicfoundation/hardhat-toolbox": "^3.0.0", // Hardhat environment suite for testing, development, and open source
+    "@openzeppelin/contracts": "^5.0.0", // OpenZeppelin contract library
+    "@openzeppelin/contracts-upgradeable": "^5.0.0", // OpenZeppelin upgradeable contract library
+    "@openzeppelin/hardhat-upgrades": "^2.3.3", // JavaScript/TypeScript script package for OpenZeppelin upgrades library
+    "dotenv": "^16.3.1", // Runtime environment variable injection to access custom configurations like private keys directly in code
+    "hardhat": "^2.19.0", // Hardhat framework
+    "hardhat-abi-exporter": "^2.10.1", // (Optional) pure ABI generator, used in combination with abigen for generating contract operation files for Go/Java backend developers
+    "hardhat-diamond-abi": "^3.0.1", // (Optional) Diamond contract interface synthesis, aggregates the interfaces of multiple contracts into one interface file
+    "hardhat-exposed": "^0.3.13", // (Optional) Contract internal interface exposure for testing convenience
+    "hardhat-ignore-warnings": "^0.2.9", // (Optional) Ignore warning messages, useful for legacy project development
+    "uniswap-v2-deploy-plugin": "^0.0.4" // (Optional) One-click setup of Uniswap V2 test environment
+  }
+}
+```
+
+- Project Configuration (some features are not enabled)
+
+```ts
+import {HardhatUserConfig} from "hardhat/config";
+import "@nomicfoundation/hardhat-toolbox";
+import "@nomicfoundation/hardhat-foundry";
+import "@openzeppelin/hardhat-upgrades";
+import "hardhat-abi-exporter";
+import "dotenv/config";
+import "hardhat-ignore-warnings";
+import "hardhat-diamond-abi";
+import {Fragment, FunctionFragment} from "ethers";
+
+const funcNameSet = new Set<string>()
+const funcSelectorMap = new Map<string, string>()
+const eventErrorSet = new Set<string>()
+const config: HardhatUserConfig = {
+    // warnings: {
+    //     'contracts/legacy/**/*': {
+    //         default: 'error',
+    //     },
+    // },
+    diamondAbi: {
+        name: "DiamondCombined",
+        include: ["Facet"],
+        strict: true,
+        filter: function (abiElement, index, fullAbi, fullyQualifiedName) {
+            if (fullyQualifiedName.endsWith("Test1Facet") || fullyQualifiedName.endsWith("Test2Facet")) {
+                return false
+            }
+            // distinct event and error
+            if (abiElement.type === "event" || abiElement.type === "error") {
+                const minimalAbi = Fragment.from(abiElement).format("minimal")
+                if (eventErrorSet.has(minimalAbi)) {
+                    return false
+                }
+                eventErrorSet.add(minimalAbi)
+                return true;
+            }
+            const selector = FunctionFragment.from(abiElement).selector
+            if (funcSelectorMap.has(selector)) {
+                throw new Error(`${FunctionFragment.from(abiElement).selector}, see:\n\t${Fragment.from(abiElement).format("minimal")}::${fullyQualifiedName}\n\t${funcSelectorMap.get(selector)}\n`)
+            }
+            funcSelectorMap.set(selector, `${Fragment.from(abiElement).format("minimal")}::${fullyQualifiedName}`)
+            if (!funcNameSet.has(fullyQualifiedName)) {
+                funcNameSet.add(fullyQualifiedName)
+                console.log(` >>> [hardhat-diamond-abi] ${fullyQualifiedName}`)
+            }
+            return true;
+        },
+    },
+    abiExporter: [{
+        runOnCompile: true,
+        clear: true,
+        path: './abi-pure/general',
+        format: "json"
+    }, {
+        runOnCompile: true,
+        clear: true,
+        path: './abi-pure/ethers',
+        pretty: true
+    }],
+    networks: {
+        hardhat: {
+            mining: {
+                interval: 50
+            }
+            // forking: {
+            //   url: "https://arbitrum.public-rpc.com",
+            //   // blockNumber: 132401260
+            // }
+        },
+        bsc: {
+            url: "https://bsc.rpc.blxrbdn.com",
+            accounts: [process.env.PRIVATE_KEY as string],
+        },
+        bsc_testnet: {
+            url: "https://bsc-testnet.publicnode.com",
+            accounts: [process.env.PRIVATE_KEY as string],
+        },
+        bsc_op_testnet: {
+            url: "https://opbnb-testnet-rpc.bnbchain.org",
+            accounts: [process.env.PRIVATE_KEY as string],
+        },
+        eth: {
+            url: "https://eth.public-rpc.com",
+            accounts: [process.env.PRIVATE_KEY as string],
+        },
+        arbitrum: {
+            url: "https://endpoints.omniatech.io/v1/arbitrum/one/public",
+            accounts: [process.env.PRIVATE_KEY as string],
+        },
+        arbitrum_goerli: {
+            url: "https://arbitrum-goerli.publicnode.com",
+            accounts: [process.env.PRIVATE_KEY as string],
+        }
+    },
+    etherscan: {
+        apiKey: process.env.ETHERSCAN_BSC as string
+    },
+    solidity: {
+        compilers: [
+            standardSettings("0.8.21"),
+        ]
+    },
+};
+
+function standardSettings(version: string) {
+    return {
+        version: version,
+        settings: {
+            optimizer: {
+                enabled: true,
+                runs: 200,
+            },
+            // viaIR: true
+        },
+    }
+}
+
+export default config;
+```
+
+- .gitignore for Team Collaboration (Recommended to be edited flexibly based on the project)
+
+```git
+*.swp
+*.swo
+
+# Logs
+logs
+*.log
+
+# Runtime data
+pids
+*.pid
+*.seed
+allFiredEvents
+scTopics
+
+# Coverage directory used by tools like istanbul
+coverage
+coverage.json
+coverageEnv
+
+# node-waf configuration
+.lock-wscript
+
+# Dependency directory
+node_modules
+
+# Debug log from npm
+npm-debug.log
+
+# local env variables
+.env
+
+# truffle build directory
+build/
+
+# macOS
+.DS_Store
+
+# truffle
+.node-xmlhttprequest-*
+
+# IntelliJ IDE
+.idea
+
+# vscode IDE
+.vscode
+
+# docs artifacts
+docs/modules/api
+
+# only used to package @openzeppelin/contracts
+contracts/build/
+contracts/README.md
+
+# temporary artifact from solidity-coverage
+.coverage_artifacts
+.coverage_cache
+.coverage_contracts
+
+# hardat-exposed
+contracts-exposed
+
+# Hardhat
+cache
+artifacts
+
+# Foundry
+out
+cache_forge
+
+# Certora
+.certora*
+.last_confs
+certora_*
+.zip-output-url.txt
+
+# extends
+/abi
+/abi-pure
+
+/typechain-types
+# Note: Here, all JavaScript files are ignored
+/**/*.js
+```
+
+## Testing Techniques
+
+### hardhat
+
+#### Contract Layer Testing
+
+Contracts can be debugged, and debugging output will be displayed on the Hardhat local network using the following syntax:
+
+```solidity
+import "hardhat/console.log";
+
+// TODO Add log statements at critical points in the contract
+console.log(parameter1, parameter2...);
+
+```
+
+#### Unit Testing/Functional Testing
+
+The `describe` function's callback functions include four testing-related functions: `it`, `before`, `beforeEach`, and `afterEach`, as follows:
+
+- `it`: Tests a unit, simulating a testing behavior. Units are independent, and they do not share state with each other.
+- `before`: Executes before all unit tests, only running once. It is typically used for initialization, such as reading deployment accounts.
+- `beforeEach`: Executes before each unit test, running once for every test. It is often used to execute the `loadFixture` function.
+- `afterEach`: Executes after each unit test, running once for every test. It is rarely used.
+
+The `loadFixture(func)` function is a blockchain network snapshot function that records the blockchain state when `func` is first executed. In subsequent uses, it directly restores the state instead of re-executing the setup.
+
+```typescript
+describe("Diamond Contract", () => {
+    let user: HardhatEthersSigner;
+
+    afterEach(() => {
+        console.log("afterEach------------------------------------");
+    });
+
+    beforeEach(() => {
+        console.log("beforeEach------------------------------------");
+    });
+
+    before("user", async () => {
+        console.log("before------------------------------------");
+        const accounts = await ethers.getSigners();
+        user = accounts[0];
+    });
+
+    async function deployFixture() {
+        return await Diamonds.deploy(false);
+    }
+
+    it("Proxy Test Example", async () => {
+        const diamond = await loadFixture(deployFixture);
+        const [example] = await deploy(false, "Example");
+        await diamond.proxy(example);
+        await (await (example.attach(diamond.address) as Example).setNumber(1024n)).wait();
+        expect(await (example.attach(diamond.address) as Example).getNumber()).eq(1024n);
+    });
+
+    it("Upgrade Test Example", async () => {
+        const diamond = await loadFixture(deployFixture);
+        const [oldExample] = await deploy(false, "Example");
+        await diamond.proxy(oldExample);
+        const [newExample] = await deploy(false, "Example");
+        await diamond.upgrade(oldExample.address, newExample);
+        // assert
+        const selector = (newExample as any as Example).interface.getFunction("setNumber").selector;
+        expect(await diamond.facetAddress(selector)).eq(newExample.address);
+    });
+});
+```
+
+#### Project Testing
+
+Project testing often involves multi-platform integration, such as `hardhat + Golang`. Therefore, it's important to maintain the blockchain network state persistently. In general, you will write these tests in the `scripts/` folder. Here are the relevant commands:
+
+- Scenario 1: Local Network Testing (including `fork`)
+    - `npx hardhat node`
+    - `npx hardhat --network hardhat run <script-path>`
+
+- Scenario 2: Online Blockchain Testing (Testnet)
+    - `npx hardhat --network <network-name> run <script-path>`
+
+### foundry
+
+#### Contract Layer Testing
+
+```solidity
+import {console} from "forge-std/Test.sol";
+
+// TODO: Place log messages at key locations in your contract
+console.log(parameter1, parameter2, ...);
+```
+
+#### Unit Testing
+
+**It is not recommended to use foundry for writing functional tests. Front-end developers may need contract usage examples, so functional tests written in JavaScript/TypeScript are more reusable.**
+
+> foundry Contract Testing with new
+
+The new method is usually used in conjunction with a setUp function. It cannot be used to test internal contract functions. Here's an example:
+
+```solidity
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import {Test, console2} from "forge-std/Test.sol";
+import {Example} from "../contracts/Example.sol";
+
+contract ExampleTest is Test {
+    Example public example;
+
+    // Set up the test environment for each unit test (this function is executed automatically)
+    function setUp() public {
+        example = new Example();
+        example.setNumber(0);
+    }
+
+    // Regular unit test
+    function test_setNumber() public {
+        example.setNumber(1024);
+        assertEq(example.getNumber(), 1024);
+    }
+
+    // Fuzz testing
+    function testFuzz_SetNumber(uint256 x) public {
+        example.setNumber(x);
+        assertEq(example.getNumber(), x);
+    }
+}
+```
+
+> foundry Contract Testing with library
+
+It's important to note that foundry doesn't support generating test coverage reports for libraries. Any library functions called within contracts are identified as having 100% test coverage, and there's no workaround.
+
+```solidity
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import {Test, console2} from "forge-std/Test.sol";
+import {LibExample} from "../contracts/LibExample.sol";
+
+contract LibExampleTest is Test {
+
+    // Fuzz testing: Verify that values smaller than type(uint160).max can be converted successfully
+    function testFuzz_toUint160(uint256 n) public {
+        // Skip if n > type(uint160).max
+        vm.assume(n <= type(uint160).max);
+        LibExample.toUint160(n);
+    }
+
+    // Fuzz testing: Verify that values greater than type(uint160).max throw an exception
+    function testFailFuzz_toUint160_overflow(uint256 n) public {
+        // Skip if n < type(uint160).max
+        vm.assume(n > type(uint160).max);
+        LibExample.toUint160(n);
+    }
+}
+```
+
+> foundry Contract Testing with override
+
+```cmd
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import {Test, console2} from "forge-std/Test.sol";
+import {OverrideExample} from "../contracts/OverrideExample.sol";
+
+contract OverrideExampleTest1 is Test, OverrideExample {
+
+    function setUp() public {
+        // init
+        until = 10 days;
+    }
+
+    // override
+    function _blockTimestamp() internal view override returns (uint256) {
+        return 10 days;
+    }
+
+    function test_transfer() public {
+        transfer();
+    }
+}
+```
+
+```cmd
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import {Test, console2} from "forge-std/Test.sol";
+import {OverrideExample} from "../contracts/OverrideExample.sol";
+
+contract OverrideExampleTest2 is Test, OverrideExample {
+
+    function setUp() public {
+        // init
+        until = 10 days;
+    }
+
+    function testFail_transfer(uint256 x) public {
+        transfer();
+    }
+}
+```
+
+> foundry Contract Testing with JSON
+
+Using JSON for contract testing is not recommended unless your company has specialized tools for generating JSON test data.
+
+```solidity
+// 0- foundry.toml project configuration (./ indicates the project root)
+fs_permissions = [{ access = "read-write", path = "./"}]
+// 1- Contract inheritance
+contract Xxx is Test
+// 2- Interface integration
+using stdJson for string;
+// 3- Usage syntax (.XxxDatas represents accessing the XxxDatas property in the JSON)
+string memory json = vm.readFile("./test/testdata/Xxx.t.json");
+bytes memory bytesData = json.parseRaw(".XxxDatas");
+XxxData[] memory t = abi.decode(bytesData, (XxxData[]));
+
+// Note:
+// 1- The order of struct fields must be sorted strictly in alphabetical order, e.g., XxxData
+// 2- Numeric values in JSON must not be enclosed in double quotes. You can use scientific notation, e.g., 200e18.
+// 3- The argument for json.parseRaw can be an empty string ("") to load the entire JSON file.
+```
+
+## Conclusion
+
+My friend, I started my journey in traditional development and later ventured into blockchain development, but unfortunately, I've forgotten at least 90% of what I've learned over time. Therefore, I strongly dislike listing detailed knowledge points, as it's a waste of everyone's time.
+
+In my opinion, explaining the minimum knowledge subset is the most important. This is also the principle behind my current sharing – providing the least amount of information to help you get started quickly. It might take you just 1 hour or maybe 10 minutes to say, "Oh, I've got it, I can start developing."
+
+`Less is more.`
+
diff --git a/basic/79-hardhat-foundry/README.md b/basic/79-hardhat-foundry/README.md
new file mode 100644
index 000000000..3cc95404c
--- /dev/null
+++ b/basic/79-hardhat-foundry/README.md
@@ -0,0 +1,549 @@
+# Hardhat-Foundry
+
+## 前言
+
+1. **问题一: 为什么需要用`hardhat`?**
+
+   早些年流行`remix`和`truffle`，那时候的`remix`没有`console`等工具，`truffle`没有`debug`功能，`tenderly`在浏览器看不到身影，代码问题只能`code review`和`revert`测试。**彼时，我们缺乏完善的工程化框架，大多数项目只有寥寥数份合约。**
+
+   后来，`hardhat`开始流行，它能以`console.log`的方式调试代码，它`fork`网络不需要`Ganache`或`Geth`，它写测试不用回看合约里面的函数名和参数是什么(`Typescript`)......所以，**是时候使用`hardhat`了，它真的在`truffle`的肩膀上，向前走了很远。**
+
+2. **问题二: 我已经在用`hardhat`了，为什么还需要`foundry`?**
+
+   `hardhat`有**一些小痛点**，比如: 合约测试的准备程序很枯燥(部署和初始化)、`Library`合约的测试很繁琐，某些场景下的数据类型转换、数据编码解码、在JS层重现工具函数很烦恼等等。
+
+   为了解决以上问题，**`foundry`出现了，它创新式地提出用`Solidity`语言来测试`Solidity`**!!! 现在，你可以用最少的代码写测试!
+
+3. **问题三: 为什么不全力奔向`foundry`?**
+
+   `foundry`有不完善的地方，你会苦恼它的依赖管理(你或许需要去github上复制链接)，你会苦恼它的跨平台兼容性，你会苦恼它五花八门的CMD命令，你也或许会苦恼某些成熟的测试脚本(js/ts)不能复用，等等。**`foundry`是革命性的，但却没能完整的继承前辈们的财富——JS生态/hardhat生态**，这一点颇为遗憾。
+   
+4. **问题四: 我该如何选择开发框架?**
+
+   我不打算论述一番`remix`、`truffle`、`hardhat`和`foundry`的优缺点，然后把选择题抛给你。在这里，我会直接给你答案——**除非有了更大的革新，否则请无脑选择`hardhat-foundry`。**这是我经历N轮技术迭代和项目实践后的最佳搭配，请放心食用。如果你真的很喜欢`foundry`，朋友，除非你已经彻底转为专业的合约测试人员，否则不建议使用纯`foundry`。开发人员总是免不了会需要写或者接触一些`js/ts`的脚本的。
+
+   集百家之长永远是最佳选择。
+
+## 准备工作
+
+- 下载`forge`程序: https://github.com/foundry-rs/foundry/releases
+- 添加环境变量
+- 搭建项目(个人推荐`solidity-framework`)
+
+-----
+
+一些有用的网址
+
+- `ChainList`: https://chainlist.org/
+
+  这里有一键复制即用的RPC链接，你不需要注册`Infura`(尤其新手)。
+
+- `Tenderly` https://dashboard.tenderly.co/explorer
+
+  这里可以搜索交易的调用栈，查看交易的执行流等(如果合约已经开源的话)。
+  
+- `foundry` https://github.com/Dapp-Learning-DAO/Dapp-Learning/tree/main/basic/41-foundry
+
+  `Dapp-Learning`前辈总结的优秀入门要点，建议浏览。
+
+## 核心操作
+
+**除了核心操作外，不要试图去记住所有的功能，谨记**。
+
+1. **合约编译**
+
+  - `npx hardhat compile`
+
+2. **合约测试**
+
+  - `npx hardhat test` | 更多用法: `npx hardhat test --help`
+  - `forge test`  | `forge test --mc <文件名匹配> -vv`
+
+3. **本地区块链网络[推荐`hardhat`]**
+
+  - `npx hardhat node`
+
+4. **在指定的区块链网络上运行TS脚本(比如部署)**
+
+  - `npx hardhat --network <网络名> run <脚本路径>`
+
+> 说明事项
+
+- `forge --help` 完整命令列表(有些命令有`Bug`)
+- `forge debug <合约路径> --sig <函数头> [参数列表]`调试函数适合底层汇编开发，辅助堆栈和内存的数据观察。
+
+## 配置说明
+
+- 项目依赖
+
+```json
+{
+  "name": "11-hardhat-foundry",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@chainlink/contracts": "^0.8.0", // 合约预言机提供商，你或许会用到它的接口
+    "@nomicfoundation/hardhat-foundry": "^1.1.1", // foundry运行环境的文件生成器
+    "@nomicfoundation/hardhat-toolbox": "^3.0.0",// hardhat环境套件，你需要的测试，开发，开源都有
+    "@openzeppelin/contracts": "^5.0.0",// openzeppelin合约库
+    "@openzeppelin/contracts-upgradeable": "^5.0.0", // openzeppelin升级适配的合约库
+    "@openzeppelin/hardhat-upgrades": "^2.3.3",// openzeppelin升级库的js/ts脚本包
+    "dotenv": "^16.3.1",// 运行时环境变量注入，让我们能在代码中直接访问某些自定义的特殊配置，比如私钥
+    "hardhat": "^2.19.0",// hardhat框架
+    "hardhat-abi-exporter": "^2.10.1",// (了解)纯abi生成器，配合 abigen 为go/java等后端人员生成合约操作文件
+    "hardhat-diamond-abi": "^3.0.1", // (了解) 钻石合约接口合成，让多个合约的接口聚合到一个接口文件中
+    "hardhat-exposed": "^0.3.13", // (了解)合约内部接口暴露，方便测试
+    "hardhat-ignore-warnings": "^0.2.9", // (了解) 警告信息忽略，老项目兼容开发或许会用到
+    "uniswap-v2-deploy-plugin": "^0.0.4" // (了解) 一键搭建uniswapv2测试环境
+  }
+}
+```
+
+- 项目配置(一些功能并未启用)
+
+```ts
+import {HardhatUserConfig} from "hardhat/config";
+import "@nomicfoundation/hardhat-toolbox";
+import "@nomicfoundation/hardhat-foundry";
+import "@openzeppelin/hardhat-upgrades";
+import "hardhat-abi-exporter";
+import "dotenv/config";
+import "hardhat-ignore-warnings";
+import "hardhat-diamond-abi";
+import {Fragment, FunctionFragment} from "ethers";
+
+const funcNameSet = new Set<string>()
+const funcSelectorMap = new Map<string, string>()
+const eventErrorSet = new Set<string>()
+const config: HardhatUserConfig = {
+    // warnings: {
+    //     'contracts/legacy/**/*': {
+    //         default: 'error',
+    //     },
+    // },
+    diamondAbi: {
+        name: "DiamondCombined",
+        include: ["Facet"],
+        strict: true,
+        filter: function (abiElement, index, fullAbi, fullyQualifiedName) {
+            if (fullyQualifiedName.endsWith("Test1Facet") || fullyQualifiedName.endsWith("Test2Facet")) {
+                return false
+            }
+            // distinct event and error
+            if (abiElement.type === "event" || abiElement.type === "error") {
+                const minimalAbi = Fragment.from(abiElement).format("minimal")
+                if (eventErrorSet.has(minimalAbi)) {
+                    return false
+                }
+                eventErrorSet.add(minimalAbi)
+                return true;
+            }
+            const selector = FunctionFragment.from(abiElement).selector
+            if (funcSelectorMap.has(selector)) {
+                throw new Error(`${FunctionFragment.from(abiElement).selector}, see:\n\t${Fragment.from(abiElement).format("minimal")}::${fullyQualifiedName}\n\t${funcSelectorMap.get(selector)}\n`)
+            }
+            funcSelectorMap.set(selector, `${Fragment.from(abiElement).format("minimal")}::${fullyQualifiedName}`)
+            if (!funcNameSet.has(fullyQualifiedName)) {
+                funcNameSet.add(fullyQualifiedName)
+                console.log(` >>> [hardhat-diamond-abi] ${fullyQualifiedName}`)
+            }
+            return true;
+        },
+    },
+    abiExporter: [{
+        runOnCompile: true,
+        clear: true,
+        path: './abi-pure/general',
+        format: "json"
+    }, {
+        runOnCompile: true,
+        clear: true,
+        path: './abi-pure/ethers',
+        pretty: true
+    }],
+    networks: {
+        hardhat: {
+            mining: {
+                interval: 50
+            }
+            // forking: {
+            //   url: "https://arbitrum.public-rpc.com",
+            //   // blockNumber: 132401260
+            // }
+        },
+        bsc: {
+            url: "https://bsc.rpc.blxrbdn.com",
+            accounts: [process.env.PRIVATE_KEY as string],
+        },
+        bsc_testnet: {
+            url: "https://bsc-testnet.publicnode.com",
+            accounts: [process.env.PRIVATE_KEY as string],
+        },
+        bsc_op_testnet: {
+            url: "https://opbnb-testnet-rpc.bnbchain.org",
+            accounts: [process.env.PRIVATE_KEY as string],
+        },
+        eth: {
+            url: "https://eth.public-rpc.com",
+            accounts: [process.env.PRIVATE_KEY as string],
+        },
+        arbitrum: {
+            url: "https://endpoints.omniatech.io/v1/arbitrum/one/public",
+            accounts: [process.env.PRIVATE_KEY as string],
+        },
+        arbitrum_goerli: {
+            url: "https://arbitrum-goerli.publicnode.com",
+            accounts: [process.env.PRIVATE_KEY as string],
+        }
+    },
+    etherscan: {
+        apiKey: process.env.ETHERSCAN_BSC as string
+    },
+    solidity: {
+        compilers: [
+            standardSettings("0.8.21"),
+        ]
+    },
+};
+
+function standardSettings(version: string) {
+    return {
+        version: version,
+        settings: {
+            optimizer: {
+                enabled: true,
+                runs: 200,
+            },
+            // viaIR: true
+        },
+    }
+}
+
+export default config;
+```
+
+- `.gitignore` 团队协作(建议根据项目灵活编辑)
+
+```git
+*.swp
+*.swo
+
+# Logs
+logs
+*.log
+
+# Runtime data
+pids
+*.pid
+*.seed
+allFiredEvents
+scTopics
+
+# Coverage directory used by tools like istanbul
+coverage
+coverage.json
+coverageEnv
+
+# node-waf configuration
+.lock-wscript
+
+# Dependency directory
+node_modules
+
+# Debug log from npm
+npm-debug.log
+
+# local env variables
+.env
+
+# truffle build directory
+build/
+
+# macOS
+.DS_Store
+
+# truffle
+.node-xmlhttprequest-*
+
+# IntelliJ IDE
+.idea
+
+# vscode IDE
+.vscode
+
+# docs artifacts
+docs/modules/api
+
+# only used to package @openzeppelin/contracts
+contracts/build/
+contracts/README.md
+
+# temporary artifact from solidity-coverage
+.coverage_artifacts
+.coverage_cache
+.coverage_contracts
+
+# hardat-exposed
+contracts-exposed
+
+# Hardhat
+cache
+artifacts
+
+# Foundry
+out
+cache_forge
+
+# Certora
+.certora*
+.last_confs
+certora_*
+.zip-output-url.txt
+
+# extends
+/abi
+/abi-pure
+
+/typechain-types
+# 注意: 这里忽略了所有js
+/**/*.js
+```
+
+## 测试技巧
+
+### hardhat
+
+#### 合约层测试
+
+合约也是可以调试的，调试输出信息将展示在hardhat本地网络，使用语法如下:
+
+```solidity
+import "hardhat/console.log";
+
+
+// TODO 在合约的关键位置进行日志打印
+console.log(参数1，参数2...);
+```
+
+#### 单元测试/功能测试
+
+`describe`函数的回调函数有`it`|`before`|`beforeeach/aftereeach`|`describe`四类测试相关的函数，如下: 
+
+- `it` 测试单元，用来模拟一次测试行为，测试单元之间相互独立，状态不传递
+- `before` 在所有测试单元执行之前执行，仅会执行一次，一般用来初始化，比如: 读取部署账号
+- `beforeeach` 在每个单元测试执行前执行，每个单元测试都会执行一次，一般用来执行loadFixture函数
+- `aftereeach` 在每个单元测试执行后执行，每个单元测试都会执行一次，很少使用
+
+`loadFixture(func)`函数是区块链网络闪存函数，它会记录下`func`首次被执行时的区块链状态，后续每次使用直接进行状态恢复而不是重复执行。
+
+```typescript
+describe("钻石合约", () => {
+    let user: HardhatEthersSigner
+    afterEach(()=>{
+        console.log("afterEach------------------------------------")
+    })
+    beforeEach(()=>{
+        console.log("beforeEach------------------------------------")
+    })
+    before("user", async () => {
+        console.log("before------------------------------------")
+        const accounts = await ethers.getSigners()
+        user = accounts[0]
+    })
+
+    async function deployFixture() {
+        return await Diamonds.deploy(false)
+    }
+
+    it("代理测试样例", async () => {
+        const diamond = await loadFixture(deployFixture);
+        const [example] = await deploy(false, "Example")
+        await diamond.proxy(example);
+        await (await (example.attach(diamond.address) as Example).setNumber(1024n)).wait()
+        expect(await (example.attach(diamond.address) as Example).getNumber()).eq(1024n)
+    });
+    it("升级测试样例", async () => {
+        const diamond = await loadFixture(deployFixture);
+        const [oldExample] = await deploy(false, "Example")
+        await diamond.proxy(oldExample)
+        const [newExample] = await deploy(false, "Example")
+        await diamond.upgrade(oldExample.address, newExample)
+        // assert
+        const selector = (newExample as any as Example).interface.getFunction("setNumber").selector
+        expect(await diamond.facetAddress(selector)).eq(newExample.address)
+    });
+});
+```
+
+#### 项目测试
+
+项目测试一般涉及多端联调，比如: `hardhat+Golang`，因此需要保证区块链网络状态时维持的，持久的，一般我们会在`scripts/`文件夹编写，相关命令如下:
+
+- 情况一: 本地网络测试(含`fork`)
+  - `npx hardhat node`
+  - `npx hardhat --network hardhat run <脚本路径>`
+- 情况二: 线上区块链测试(测试网)
+  - `npx hardhat --network <网络名> run <脚本路径>`
+
+### foundry
+
+#### 合约层测试
+
+```solidity
+import {console} from "forge-std/Test.sol";
+
+// TODO 在合约的关键位置进行日志打印
+console.log(参数1，参数2...);
+```
+
+#### 单元测试
+
+**不建议用`foundry`写功能测试，前端可能需要合约使用样例，所以你用`js/ts`写的功能测试是可以复用的。**
+
+> `foundry`的合约测试之 `new`
+
+`new`方式一般会配合`setUp`函数，它不能测试合约的内部函数，如下:
+
+```solidity
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import {Test, console2} from "forge-std/Test.sol";
+import {Example} from "../contracts/Example.sol";
+
+contract ExampleTest is Test {
+    Example public example;
+
+	// 每个单元测试的测试前环境(该函数会被自动执行)
+    function setUp() public {
+        example = new Example();
+        example.setNumber(0);
+    }
+
+	// 普通单元测试
+    function test_setNumber() public {
+        example.setNumber(1024);
+        assertEq(example.getNumber(), 1024);
+    }
+
+    // 模糊测试
+    function testFuzz_SetNumber(uint256 x) public {
+        example.setNumber(x);
+        assertEq(example.getNumber(), x);
+    }
+}
+```
+
+> `foundry`的合约测试之 `library`
+
+说明一点，`foundry`不支持`library`的测试覆盖报告生成，凡是被调用，皆会被识别为100%，没有解决方案。
+
+```solidity
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import {Test, console2} from "forge-std/Test.sol";
+import {LibExample} from "../contracts/LibExample.sol";
+
+contract LibExampleTest is Test {
+
+    // 模糊测试: 测试小于type(uint160).max的参数值能正常转换
+    function testFuzz_toUint160(uint256 n) public {
+        // if n > type(uint160).max, skip
+        vm.assume(n <= type(uint160).max);
+        LibExample.toUint160(n);
+    }
+
+    // 模糊测试: 测试大于type(uint160).max的参数值抛出异常
+    function testFailFuzz_toUint160_overflow(uint256 n) public {
+        // if n < type(uint160).max, skip
+        vm.assume(n > type(uint160).max);
+        LibExample.toUint160(n);
+    }
+}
+```
+
+> `foundry`的合约测试之 `override`
+
+```cmd
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import {Test, console2} from "forge-std/Test.sol";
+import {OverrideExample} from "../contracts/OverrideExample.sol";
+
+contract OverrideExampleTest1 is Test, OverrideExample {
+
+    function setUp() public {
+        // init
+        until = 10 days;
+    }
+
+    // override
+    function _blockTimestamp() internal view override returns (uint256) {
+        return 10 days;
+    }
+
+    function test_transfer() public {
+        transfer();
+    }
+}
+```
+
+```cmd
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import {Test, console2} from "forge-std/Test.sol";
+import {OverrideExample} from "../contracts/OverrideExample.sol";
+
+contract OverrideExampleTest2 is Test, OverrideExample {
+
+    function setUp() public {
+        // init
+        until = 10 days;
+    }
+
+    function testFail_transfer(uint256 x) public {
+        transfer();
+    }
+}
+```
+
+> `foundry`的合约测试之 `json`
+
+除非公司有专业测试生成JSON，否则不太建议使用。
+
+```solidity
+// 0- foundry.toml项目配置 (./代表项目根目录)
+fs_permissions = [{ access = "read-write", path = "./"}]
+// 1- 合约继承
+contract Xxx is Test
+// 2- 接口集成
+using stdJson for string;
+// 3- 使用语法 (.XxxDatas代表取JSON的XxxDatas属性)
+string memory json = vm.readFile("./test/testdata/Xxx.t.json");
+bytes memory bytesData = json.parseRaw(".XxxDatas");
+XxxData[] memory t = abi.decode(bytesData, (XxxData[]));
+
+// 注意事项: 
+// 1- 结构体的字段顺序必须严格安装字母排序进行排序!!!!! 比如: XxxData
+// 2- JSON中的数字绝对不能使用"括起来!!!! 另外，可以使用科学计数法，如200e18!!
+// 3- json.parseRaw的参数可以为 ""，表示加载整个json文件
+```
+
+## 结语
+
+朋友，我是一个人走上的传统开发，也是一个人走上的区块链开发，很不幸，我期间学过的至少90%的知识都已经荒废了。所以我很反感知识点的罗列和详尽的讲解，这完全是在浪费大家的生命。
+
+我认为，最小知识子集的讲解才是最重要的，这也是我本次分享的原则——以最少的东西让大家最快地入门，或许1个小时或许10分钟，你就可以说，"哦，我会了，我能开发了"。
+
+`Less is more.`
+
diff --git a/basic/79-hardhat-foundry/contracts/Example.sol b/basic/79-hardhat-foundry/contracts/Example.sol
new file mode 100644
index 000000000..2a639aa8e
--- /dev/null
+++ b/basic/79-hardhat-foundry/contracts/Example.sol
@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import "hardhat/console.sol";
+
+contract Example {
+    bytes32 constant STORAGE_POSITION = keccak256("diamond.example.storage");
+
+    struct ExampleStorage {
+        uint256 number;
+    }
+
+    function Storage() internal pure returns (ExampleStorage storage s) {
+        bytes32 position = STORAGE_POSITION;
+        assembly {
+            s.slot := position
+        }
+        return s;
+    }
+
+    function setNumber(uint256 newNumber) public {
+        console.log("\t setNumber:", newNumber);
+        Storage().number = newNumber;
+    }
+
+    function getNumber() view public returns (uint256) {
+        console.log("\t getNumber:", Storage().number);
+        return Storage().number;
+    }
+}
diff --git a/basic/79-hardhat-foundry/contracts/LibExample.sol b/basic/79-hardhat-foundry/contracts/LibExample.sol
new file mode 100644
index 000000000..c8c744528
--- /dev/null
+++ b/basic/79-hardhat-foundry/contracts/LibExample.sol
@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+library LibExample {
+    function toUint160(uint256 y) internal pure returns (uint160 z) {
+        require((z = uint160(y)) == y);
+    }
+}
diff --git a/basic/79-hardhat-foundry/contracts/NewExample.sol b/basic/79-hardhat-foundry/contracts/NewExample.sol
new file mode 100644
index 000000000..846692f9e
--- /dev/null
+++ b/basic/79-hardhat-foundry/contracts/NewExample.sol
@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import "hardhat/console.sol";
+
+contract NewExample {
+    bytes32 constant STORAGE_POSITION = keccak256("diamond.example.storage");
+
+    struct ExampleStorage {
+        uint256 number;
+    }
+
+    function Storage() internal pure returns (ExampleStorage storage s) {
+        bytes32 position = STORAGE_POSITION;
+        assembly {
+            s.slot := position
+        }
+        return s;
+    }
+
+    function setNumber(uint256 newNumber) public {
+        console.log("\t setNumber:", newNumber);
+        Storage().number = newNumber;
+    }
+
+    function getNumber() view public returns (uint256) {
+        console.log("\t getNumber:", Storage().number);
+        return Storage().number;
+    }
+}
diff --git a/basic/79-hardhat-foundry/contracts/OverrideExample.sol b/basic/79-hardhat-foundry/contracts/OverrideExample.sol
new file mode 100644
index 000000000..89935e07e
--- /dev/null
+++ b/basic/79-hardhat-foundry/contracts/OverrideExample.sol
@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+contract OverrideExample {
+
+    uint256 public until;
+
+    constructor(){
+        until = block.timestamp;
+    }
+
+    function _blockTimestamp() internal view virtual returns (uint256) {
+        return block.timestamp;
+    }
+
+    function transfer() public {
+        require(until <= _blockTimestamp(), "Time has not yet come.");
+        // TODO
+    }
+}
diff --git a/basic/79-hardhat-foundry/foundry.toml b/basic/79-hardhat-foundry/foundry.toml
new file mode 100644
index 000000000..e47a2eebf
--- /dev/null
+++ b/basic/79-hardhat-foundry/foundry.toml
@@ -0,0 +1,8 @@
+[profile.default]
+src = 'contracts'
+out = 'out'
+libs = ['node_modules', 'lib']
+test = 'test'
+cache_path  = 'cache_forge'
+
+no_match_test = "contracts"
diff --git a/basic/79-hardhat-foundry/hardhat.config.ts b/basic/79-hardhat-foundry/hardhat.config.ts
new file mode 100644
index 000000000..6eb2486f4
--- /dev/null
+++ b/basic/79-hardhat-foundry/hardhat.config.ts
@@ -0,0 +1,118 @@
+import {HardhatUserConfig} from "hardhat/config";
+import "@nomicfoundation/hardhat-toolbox";
+import "@nomicfoundation/hardhat-foundry";
+import "@openzeppelin/hardhat-upgrades";
+import "hardhat-abi-exporter";
+import "dotenv/config";
+import "hardhat-ignore-warnings";
+import "hardhat-diamond-abi";
+import {Fragment, FunctionFragment} from "ethers";
+
+const funcNameSet = new Set<string>()
+const funcSelectorMap = new Map<string, string>()
+const eventErrorSet = new Set<string>()
+const config: HardhatUserConfig = {
+    // warnings: {
+    //     'contracts/legacy/**/*': {
+    //         default: 'error',
+    //     },
+    // },
+    diamondAbi: {
+        name: "DiamondCombined",
+        include: ["Facet"],
+        strict: true,
+        filter: function (abiElement, index, fullAbi, fullyQualifiedName) {
+            if (fullyQualifiedName.endsWith("Test1Facet") || fullyQualifiedName.endsWith("Test2Facet")) {
+                return false
+            }
+            // distinct event and error
+            if (abiElement.type === "event" || abiElement.type === "error") {
+                const minimalAbi = Fragment.from(abiElement).format("minimal")
+                if (eventErrorSet.has(minimalAbi)) {
+                    return false
+                }
+                eventErrorSet.add(minimalAbi)
+                return true;
+            }
+            const selector = FunctionFragment.from(abiElement).selector
+            if (funcSelectorMap.has(selector)) {
+                throw new Error(`${FunctionFragment.from(abiElement).selector}, see:\n\t${Fragment.from(abiElement).format("minimal")}::${fullyQualifiedName}\n\t${funcSelectorMap.get(selector)}\n`)
+            }
+            funcSelectorMap.set(selector, `${Fragment.from(abiElement).format("minimal")}::${fullyQualifiedName}`)
+            if (!funcNameSet.has(fullyQualifiedName)) {
+                funcNameSet.add(fullyQualifiedName)
+                console.log(` >>> [hardhat-diamond-abi] ${fullyQualifiedName}`)
+            }
+            return true;
+        },
+    },
+    abiExporter: [{
+        runOnCompile: true,
+        clear: true,
+        path: './abi-pure/general',
+        format: "json"
+    }, {
+        runOnCompile: true,
+        clear: true,
+        path: './abi-pure/ethers',
+        pretty: true
+    }],
+    networks: {
+        hardhat: {
+            mining: {
+                interval: 50
+            }
+            // forking: {
+            //   url: "https://arbitrum.public-rpc.com",
+            //   // blockNumber: 132401260
+            // }
+        },
+        bsc: {
+            url: "https://bsc.rpc.blxrbdn.com",
+            accounts: [process.env.PRIVATE_KEY as string],
+        },
+        bsc_testnet: {
+            url: "https://bsc-testnet.publicnode.com",
+            accounts: [process.env.PRIVATE_KEY as string],
+        },
+        bsc_op_testnet: {
+            url: "https://opbnb-testnet-rpc.bnbchain.org",
+            accounts: [process.env.PRIVATE_KEY as string],
+        },
+        eth: {
+            url: "https://eth.public-rpc.com",
+            accounts: [process.env.PRIVATE_KEY as string],
+        },
+        arbitrum: {
+            url: "https://endpoints.omniatech.io/v1/arbitrum/one/public",
+            accounts: [process.env.PRIVATE_KEY as string],
+        },
+        arbitrum_goerli: {
+            url: "https://arbitrum-goerli.publicnode.com",
+            accounts: [process.env.PRIVATE_KEY as string],
+        }
+    },
+    etherscan: {
+        apiKey: process.env.ETHERSCAN_BSC as string
+    },
+    solidity: {
+        compilers: [
+            standardSettings("0.8.21"),
+        ]
+    },
+};
+
+function standardSettings(version: string) {
+    return {
+        version: version,
+        settings: {
+            optimizer: {
+                enabled: true,
+                runs: 200,
+            },
+            // viaIR: true
+        },
+    }
+}
+
+export default config;
diff --git a/basic/79-hardhat-foundry/package.json b/basic/79-hardhat-foundry/package.json
new file mode 100644
index 000000000..0f0d92915
--- /dev/null
+++ b/basic/79-hardhat-foundry/package.json
@@ -0,0 +1,27 @@
+{
+  "name": "79-hardhat-foundry",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@chainlink/contracts": "^0.8.0",
+    "@nomicfoundation/hardhat-foundry": "^1.1.1",
+    "@nomicfoundation/hardhat-toolbox": "^3.0.0",
+    "@openzeppelin/contracts": "^5.0.0",
+    "@openzeppelin/contracts-upgradeable": "^5.0.0",
+    "@openzeppelin/hardhat-upgrades": "^2.3.3",
+    "dotenv": "^16.3.1",
+    "hardhat": "^2.19.0",
+    "hardhat-abi-exporter": "^2.10.1",
+    "hardhat-diamond-abi": "^3.0.1",
+    "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/scripts/deploy.ts b/basic/79-hardhat-foundry/scripts/deploy.ts
new file mode 100644
index 000000000..54ad6db05
--- /dev/null
+++ b/basic/79-hardhat-foundry/scripts/deploy.ts
@@ -0,0 +1,13 @@
+import { ethers } from "hardhat";
+
+async function main() {
+  const example = await ethers.deployContract("Example");
+  await example.waitForDeployment();
+}
+
+// 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/79-hardhat-foundry/scripts/libraries/Diamonds.ts b/basic/79-hardhat-foundry/scripts/libraries/Diamonds.ts
new file mode 100644
index 000000000..7866a0d52
--- /dev/null
+++ b/basic/79-hardhat-foundry/scripts/libraries/Diamonds.ts
@@ -0,0 +1,346 @@
+import {
+    AddressLike,
+    BaseContract,
+    BytesLike,
+    Contract,
+    ContractRunner,
+    FunctionFragment,
+} from "ethers"
+import { ethers } from "hardhat"
+import { DiamondCutFacet, DiamondLoupeFacet, OwnershipFacet } from "./typechain-types"
+import { deploy } from "./deployLib"
+import DiamondAbi from "./abi/Diamond.json"
+/**
+ * 钻石合约的类型，包含多个功能接口。
+ */
+export type Diamond = DiamondCutFacet & DiamondLoupeFacet & OwnershipFacet & {
+    /**
+     * 钻石合约的地址。
+     */
+    address: string,
+    logic?: {
+        /**
+         * 钻石合约的切面功能。
+         */
+        diamondCutFacet: string,
+        /**
+         * 钻石合约的放大镜功能(用于查看切面)
+         */
+        diamondLoupeFacet: string,
+        /**
+         * 钻石合约的所有权功能。
+         */
+        ownershipFacet: string,
+    },
+    /**
+     * 代理功能，用于创建代理合约。
+     */
+    proxy: typeof DiamondAction.prototype.proxy,
+    /**
+     * 编码代理功能，用于生成代理合约的编码数据。
+     */
+    encodeProxy: typeof DiamondAction.prototype.encodeProxy,
+    /**
+     * 升级功能，用于升级合约。
+     */
+    upgrade: typeof DiamondAction.prototype.upgrade,
+    /**
+     * 编码升级功能，用于生成升级合约的编码数据。
+     */
+    encodeUpgrade: typeof DiamondAction.prototype.encodeUpgrade,
+}
+
+/**
+ * 钻石合约的切面操作类型。
+ */
+export const FacetCutAction = { Add: 0, Replace: 1, Remove: 2 }
+
+/**
+ * 选择器的类型，包含合约、克隆函数和名称函数。
+ */
+export type Selectors = string[] & {
+    /**
+     * 合约的基础信息。
+     */
+    contract: BaseContract,
+    /**
+     * 克隆选择器，用于复制选择器数组。
+     * @param functionNameOrSigs 要复制的选择器数组或函数名。
+     * @param exclude 是否排除选择器。
+     * @returns 复制后的选择器。
+     */
+    clone: (functionNameOrSigs: string[], exclude?: boolean) => Selectors,
+    /**
+     * 获取选择器名称映射。
+     * @returns 选择器名称映射。
+     */
+    names: () => { [name: string]: string }
+}
+
+export class Diamonds {
+    // Diamond version: 2
+    /**
+     * 部署Diamond合约并返回一个Diamond实例。
+     * @param {boolean} isVerify - 是否需要验证合约部署。
+     * @returns {Promise<Diamond>} - 包含Diamond合约的Promise。
+     */
+    static deploy = async (isVerify: boolean): Promise<Diamond> => {
+        // 获取部署合约的所有者
+        const owner = (await ethers.getSigners())[0]
+
+        // 部署各个Diamond合约的关键组件
+        const [
+            diamondInit,
+            diamondCutFacet,
+            diamondLoupeFacet,
+            ownershipFacet,
+        ] = await deploy(isVerify, "DiamondInit", "DiamondCutFacet", "DiamondLoupeFacet", "OwnershipFacet")
+
+        // 部署Diamond代理合约
+        const [diamondProxy] = await deploy(isVerify, ["Diamond", [owner.address, diamondCutFacet.address]])
+
+        // 创建Diamond合约实例
+        const diamond = new Contract(diamondProxy.address, DiamondAbi, owner) as any as Diamond
+        diamond.address = diamondProxy.address
+        diamond.logic = {
+            diamondCutFacet: diamondCutFacet.address,
+            diamondLoupeFacet: diamondLoupeFacet.address,
+            ownershipFacet: ownershipFacet.address,
+        }
+
+        // 执行diamondCut并初始化
+        const tx = await diamond.diamondCut([
+            {
+                facetAddress: diamondLoupeFacet.address,
+                action: FacetCutAction.Add,
+                functionSelectors: Diamonds.parseSelectors(diamondLoupeFacet),
+            },
+            {
+                facetAddress: ownershipFacet.address,
+                action: FacetCutAction.Add,
+                functionSelectors: Diamonds.parseSelectors(ownershipFacet),
+            }
+        ], diamondInit.address, diamondInit.interface.encodeFunctionData("init"))
+        await tx.wait()
+
+        // 返回包含Diamond实例的Promise
+        return Diamonds.withAction(diamond)
+    }
+
+
+    /**
+     * 通过指定的Diamond合约地址和运行者创建一个Diamond实例。
+     * @param {string} diamond - 要创建实例的Diamond合约地址。
+     * @param {ContractRunner | null | undefined} runner - 可选参数，用于指定合约运行者。
+     * @returns {Diamond} - 包含Diamond合约的实例。
+     */
+    static from = (diamond: string, runner?: ContractRunner | null | undefined): Diamond => {
+        // 创建一个Diamond合约实例并返回
+        return Diamonds.withAction(new Contract(diamond, DiamondAbi, runner) as any as Diamond)
+    }
+
+
+    /**
+     * 解析指定合约的函数选择器并返回一个函数选择器集合。
+     * @param {BaseContract} contract - 要解析函数选择器的合约对象。
+     * @param {string[]} funcHeaderOrSigs - 可选参数，要包含或排除的函数头部或签名数组。
+     * @returns {Selectors} - 包含函数选择器的集合。
+     */
+    static parseSelectors = (contract: BaseContract, funcHeaderOrSigs?: string[]) => {
+        let selectors: Selectors = [] as any
+
+        // 遍历合约接口中的每个函数并将其选择器添加到集合中
+        contract.interface.forEachFunction((func: FunctionFragment) => {
+            selectors.push(func.selector)
+        })
+
+        selectors.contract = contract
+
+        // 获取函数名称的映射
+        selectors.names = function () {
+            let names = {} as { [name: string]: string }
+            contract.interface.forEachFunction((func: FunctionFragment) => {
+                for (let selector of this) {
+                    if (func.selector == selector) {
+                        names[selector] = func.format("minimal")
+                        break
+                    }
+                }
+            })
+            return names
+        }
+
+        // 克隆选择器集合并可选择性地排除或包含特定函数头部或签名
+        selectors.clone = function (funcHeaderOrSigs: string[], exclude?: boolean) {
+            const selectors = this.filter((selector: string) => {
+                for (const funcHeaderOrSig of funcHeaderOrSigs) {
+                    if (selector === Diamonds.parseSelector(funcHeaderOrSig)) {
+                        return !exclude
+                    }
+                }
+                return exclude
+            }) as Selectors
+            console.log(selectors)
+            selectors.contract = this.contract
+            selectors.clone = this.clone.bind(selectors)
+            selectors.names = this.names.bind(selectors)
+            return selectors
+        }
+
+        // 如果提供了要包含或排除的函数头部或签名数组，则应用克隆操作
+        if (funcHeaderOrSigs?.length) selectors = selectors.clone(funcHeaderOrSigs)
+        return selectors
+    }
+
+
+    /**
+     * 创建包含DiamondAction功能的Diamond实例。
+     * @param {Diamond} diamond - 要添加DiamondAction功能的Diamond实例。
+     * @returns {Diamond} - 包含DiamondAction功能的Diamond实例。
+     */
+    private static withAction = (diamond: Diamond): Diamond => {
+        // 创建DiamondAction实例并将其功能添加到Diamond
+        const diamondAction = new DiamondAction(diamond)
+        diamond.proxy = diamondAction.proxy
+        diamond.upgrade = diamondAction.upgrade
+        diamond.encodeProxy = diamondAction.encodeProxy
+        diamond.encodeUpgrade = diamondAction.encodeUpgrade
+
+        return diamond
+    }
+
+
+    /**
+     * 解析函数头部或签名并返回相应的函数选择器。
+     * @param {string} funcHeaderOrSig - 要解析的函数头部或签名。
+     * @returns {string | undefined} - 如果函数头部或签名有效，则返回相应的函数选择器；否则返回undefined。
+     */
+    private static parseSelector = (funcHeaderOrSig: string) => {
+        // 如果提供的字符串以 "0x" 开头，认为它已经是一个函数选择器，直接返回
+        if (funcHeaderOrSig.startsWith("0x")) {
+            return funcHeaderOrSig
+        }
+
+        // 如果提供的字符串包含 "("，则视为函数头部，通过 FunctionFragment 解析并返回相应的函数选择器
+        if (funcHeaderOrSig.includes("(")) {
+            return FunctionFragment.from(funcHeaderOrSig).selector
+        }
+        // 如果不符合以上条件，则返回undefined
+    }
+}
+
+/**
+ * 钻石操作类，用于管理钻石合约的操作。
+ */
+class DiamondAction {
+    readonly diamond: Diamond
+
+    /**
+     * 创建一个新的DiamondAction实例。
+     * @param diamond 钻石合约实例。
+     */
+    constructor(diamond: Diamond) {
+        this.diamond = diamond
+    }
+
+    /**
+     * 创建代理合约。
+     * @param newFacet 新的合约。
+     * @param init 初始化地址。
+     * @param initData 初始化数据。
+     * @returns 返回代理合约的结果。
+     */
+    proxy = async (newFacet: BaseContract, init?: AddressLike, initData?: BytesLike) => {
+        return await this.do(undefined, newFacet, init, initData)
+    }
+
+    /**
+     * 编码代理合约。
+     * @param newFacet 新的合约。
+     * @param init 初始化地址。
+     * @param initData 初始化数据。
+     * @returns 返回编码后的代理合约数据。
+     */
+    encodeProxy = async (newFacet: BaseContract, init?: AddressLike, initData?: BytesLike) => {
+        return await this.encodeDo(undefined, newFacet, init, initData)
+    }
+
+    /**
+     * 升级合约。
+     * @param oldFacet 旧合约地址。
+     * @param newFacet 新的合约。
+     * @param init 初始化地址。
+     * @param initData 初始化数据。
+     * @returns 返回升级合约的结果。
+     */
+    upgrade = async (oldFacet: AddressLike, newFacet: BaseContract, init?: AddressLike, initData?: BytesLike) => {
+        return await this.do(oldFacet, newFacet, init, initData)
+    }
+
+    /**
+     * 编码升级合约。
+     * @param oldFacet 旧合约地址。
+     * @param newFacet 新的合约。
+     * @param init 初始化地址。
+     * @param initData 初始化数据。
+     * @returns 返回编码后的升级合约数据。
+     */
+    encodeUpgrade = async (oldFacet: AddressLike, newFacet: BaseContract, init?: AddressLike, initData?: BytesLike) => {
+        return await this.encodeDo(oldFacet, newFacet, init, initData)
+    }
+
+    private do = async (oldFacet: AddressLike | undefined, newFacet: BaseContract, init?: AddressLike, initData?: BytesLike) => {
+        const data = await this.encodeDo(oldFacet, newFacet, init, initData)
+        if (this.diamond?.runner?.sendTransaction) {
+            const tx = await this.diamond.runner.sendTransaction({
+                to: this.diamond.address,
+                data: data
+            })
+            return await tx.wait()
+        }
+        throw new Error("Signer not exist!")
+    }
+
+    private encodeDo = async (oldFacet: AddressLike | undefined, newFacet: BaseContract, init?: AddressLike, initData?: BytesLike) => {
+        const chainSelectors = !oldFacet ? [] : await this.diamond.facetFunctionSelectors(oldFacet)
+        const localSelectors = Diamonds.parseSelectors(newFacet)
+        const onlyLocals = localSelectors.filter(item => !chainSelectors.includes(item))
+        const onlyChains = chainSelectors.filter(item => !localSelectors.includes(item))
+        const bothExists = chainSelectors.filter(chainSelector => {
+            for (let localSelector of localSelectors) {
+                if (chainSelector === localSelector) {
+                    return true
+                }
+            }
+        })
+        const cut = []
+        const newContractAddress = await newFacet.getAddress()
+        // 添加
+        if (onlyLocals.length) {
+            cut.push({
+                facetAddress: newContractAddress,
+                action: FacetCutAction.Add,
+                functionSelectors: onlyLocals
+            })
+        }
+        // 移除
+        if (onlyChains.length) {
+            cut.push({
+                facetAddress: ethers.ZeroAddress,
+                action: FacetCutAction.Remove,
+                functionSelectors: onlyChains
+            })
+        }
+        // 替换
+        if (bothExists.length) {
+            cut.push({
+                facetAddress: newContractAddress,
+                action: FacetCutAction.Replace,
+                functionSelectors: bothExists
+            })
+        }
+        if (cut.length == 0) throw new Error("Nothing need to upgrade!")
+        return this.diamond.interface.encodeFunctionData("diamondCut", [cut, init ?? ethers.ZeroAddress, initData ?? "0x"])
+    }
+}
+
diff --git a/basic/79-hardhat-foundry/scripts/libraries/abi/Diamond.json b/basic/79-hardhat-foundry/scripts/libraries/abi/Diamond.json
new file mode 100644
index 000000000..2ab77d4e4
--- /dev/null
+++ b/basic/79-hardhat-foundry/scripts/libraries/abi/Diamond.json
@@ -0,0 +1,240 @@
+[
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_initializationContractAddress",
+        "type": "address"
+      },
+      {
+        "internalType": "bytes",
+        "name": "_calldata",
+        "type": "bytes"
+      }
+    ],
+    "name": "InitializationFunctionReverted",
+    "type": "error"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "components": [
+          {
+            "internalType": "address",
+            "name": "facetAddress",
+            "type": "address"
+          },
+          {
+            "internalType": "enum IDiamondCut.FacetCutAction",
+            "name": "action",
+            "type": "uint8"
+          },
+          {
+            "internalType": "bytes4[]",
+            "name": "functionSelectors",
+            "type": "bytes4[]"
+          }
+        ],
+        "indexed": false,
+        "internalType": "struct IDiamondCut.FacetCut[]",
+        "name": "_diamondCut",
+        "type": "tuple[]"
+      },
+      {
+        "indexed": false,
+        "internalType": "address",
+        "name": "_init",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "bytes",
+        "name": "_calldata",
+        "type": "bytes"
+      }
+    ],
+    "name": "DiamondCut",
+    "type": "event"
+  },
+  {
+    "inputs": [
+      {
+        "components": [
+          {
+            "internalType": "address",
+            "name": "facetAddress",
+            "type": "address"
+          },
+          {
+            "internalType": "enum IDiamondCut.FacetCutAction",
+            "name": "action",
+            "type": "uint8"
+          },
+          {
+            "internalType": "bytes4[]",
+            "name": "functionSelectors",
+            "type": "bytes4[]"
+          }
+        ],
+        "internalType": "struct IDiamondCut.FacetCut[]",
+        "name": "_diamondCut",
+        "type": "tuple[]"
+      },
+      {
+        "internalType": "address",
+        "name": "_init",
+        "type": "address"
+      },
+      {
+        "internalType": "bytes",
+        "name": "_calldata",
+        "type": "bytes"
+      }
+    ],
+    "name": "diamondCut",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes4",
+        "name": "_functionSelector",
+        "type": "bytes4"
+      }
+    ],
+    "name": "facetAddress",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "facetAddress_",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "facetAddresses",
+    "outputs": [
+      {
+        "internalType": "address[]",
+        "name": "facetAddresses_",
+        "type": "address[]"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_facet",
+        "type": "address"
+      }
+    ],
+    "name": "facetFunctionSelectors",
+    "outputs": [
+      {
+        "internalType": "bytes4[]",
+        "name": "_facetFunctionSelectors",
+        "type": "bytes4[]"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "facets",
+    "outputs": [
+      {
+        "components": [
+          {
+            "internalType": "address",
+            "name": "facetAddress",
+            "type": "address"
+          },
+          {
+            "internalType": "bytes4[]",
+            "name": "functionSelectors",
+            "type": "bytes4[]"
+          }
+        ],
+        "internalType": "struct IDiamondLoupe.Facet[]",
+        "name": "facets_",
+        "type": "tuple[]"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes4",
+        "name": "_interfaceId",
+        "type": "bytes4"
+      }
+    ],
+    "name": "supportsInterface",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "previousOwner",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "newOwner",
+        "type": "address"
+      }
+    ],
+    "name": "OwnershipTransferred",
+    "type": "event"
+  },
+  {
+    "inputs": [],
+    "name": "owner",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "owner_",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_newOwner",
+        "type": "address"
+      }
+    ],
+    "name": "transferOwnership",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  }
+]
diff --git a/basic/79-hardhat-foundry/scripts/libraries/deployLib.ts b/basic/79-hardhat-foundry/scripts/libraries/deployLib.ts
new file mode 100644
index 000000000..b8cb6673f
--- /dev/null
+++ b/basic/79-hardhat-foundry/scripts/libraries/deployLib.ts
@@ -0,0 +1,135 @@
+import {ethers, network, run} from "hardhat";
+import {BaseContract} from "ethers";
+import fs from "fs";
+import path from "path";
+import logger from "./logger";
+
+/*
+* deploy 批量部署合约(额外扩充属性:address)，参数: 合约名 || [合约名，构造参数列表]
+* 假设 Test.sol 的构造函数无参，Test1.sol 的构造函数参数为: uint256,uint256
+* 例子1: 单部署 Test.sol : batchDeploy("Test")
+* 例子2: 单部署 Test1.sol: batchDeploy(["Test1", [60, 0]])
+* 例子3: 批量部署 Test.sol + Test1.sol: batchDeploy("Test", ["Test1", [60, 0]])
+* */
+export async function deploy(isVerify: boolean, ...names: (string | [string, any[]])[]): Promise<(BaseContract & { address: string }) []> {
+    const instances = await _deploy(...names)
+    if (isVerify) {
+        if (network.name !== "hardhat") {
+            await new Promise(resolve => setTimeout(resolve, 1000))
+            logger.info("verify......")
+            await new Promise(resolve => setTimeout(resolve, 1000))
+            for (let i = 0; i < names.length; i++) {
+                let info = names[i]
+                if (typeof info === 'string') {
+                    await verify(info, instances[i].address)
+                } else {
+                    if (info.length != 2 || info[1] == undefined) {
+                        continue
+                    }
+                    await verify(info[0], instances[i].address, ...info[1])
+                }
+            }
+        } else {
+            logger.warning("[hardhat] verify ignored")
+        }
+    }
+    return instances
+}
+
+async function _deploy(...names: (string | [string, any[]])[]): Promise<(BaseContract & { address: string }) []> {
+    const accounts = await ethers.getSigners()
+    logger.log(`${"Deployer".padStart(20, "-")}  ${accounts[0].address} ${("[" + network.name + "]").padEnd(20, "-")}`)
+    const promFuncs = []
+    for (let info of names) {
+        promFuncs.push((async () => {
+            let name: string, prom: any;
+            if (typeof info === 'string') {
+                const Instance = await ethers.getContractFactory(info)
+                prom = Instance.deploy()
+                name = info
+            } else {
+                const Instance = await ethers.getContractFactory(info[0])
+                if (info.length != 2 || info[1] == undefined) {
+                    logger.error(`ERROR params: name = ${info[0]}, args = ${info[1]}`)
+                    // @ts-ignore
+                    return
+                }
+                prom = Instance.deploy(...info[1])
+                name = info[0]
+            }
+            prom.then(async (contract: any) => {
+                contract.address = await contract.getAddress()
+                logger.info(`${name.padEnd(20)}: ${contract.address} [DeployedHash: ${contract.deploymentTransaction().hash}]`)
+                return contract
+            }).catch((e: Error) => {
+                logger.info(`ERROR "${name}" Deployed Failed: args = [${typeof info === 'string' ? "null" : info[1]}] : ${e.message}`)
+            })
+            return prom
+        })())
+    }
+    const instances = (await Promise.all(await Promise.all(promFuncs))).filter((c) => c)
+    if (names.length != instances.length) {
+        logger.error("Error exist")
+        process.exit(1)
+    }
+    return instances;
+}
+
+// https://github.com/NomicFoundation/hardhat/tree/main/packages/hardhat-verify
+export async function verify(name: string, address: string, ...args: any) {
+    await run("verify:verify", {
+        contract: `${parseVerifyPath(name)}:${name}`,
+        address: address,
+        constructorArguments: args ?? [],
+    });
+}
+
+/**
+ * 查找contract文件的路径。
+ * 如果找不到，它会输出错误信息并退出程序。
+ * @param filename
+ * @param rootDir
+ * @returns contract文件路径
+ */
+function parseVerifyPath(filename: string, rootDir?: string): string {
+    let rootDirectory = rootDir ?? __dirname
+    while (1) {
+        let files = fs.readdirSync(rootDirectory)
+        if (files.includes("package.json") && files.includes("contracts")) {
+            rootDirectory = path.join(rootDirectory, files[files.indexOf("contracts")])
+            break
+        }
+        let newRootDirectory = path.join(rootDirectory, "../")
+        if (rootDirectory === newRootDirectory) {
+            logger.error(`Error: Can't find any contract project: from=${rootDirectory} to=${__dirname}`)
+            process.exit(1)
+        }
+        rootDirectory = newRootDirectory
+    }
+    if (!filename.endsWith(".sol")) {
+        filename = filename.trim() + ".sol"
+    }
+    let targetFile: string = "";
+    const findFile = (rootDirectory: string) => {
+        const files = fs.readdirSync(rootDirectory);
+        for (let file of files) {
+            const filePath = path.join(rootDirectory, file);
+            const stats = fs.statSync(filePath);
+            if (stats.isDirectory()) {
+                if (targetFile) return;
+                findFile(filePath);
+            } else if (stats.isFile()) {
+                if (file === filename) {
+                    targetFile = filePath
+                    return
+                }
+            }
+        }
+    }
+    findFile(rootDirectory)
+    if (!targetFile) {
+        logger.error(`Error: Can't find file: ${filename}`)
+        process.exit(1)
+    }
+    return targetFile.replace(rootDirectory, "contracts").replace(/\\/g, "/");
+}
diff --git a/basic/79-hardhat-foundry/scripts/libraries/logger.ts b/basic/79-hardhat-foundry/scripts/libraries/logger.ts
new file mode 100644
index 000000000..d372ecfa0
--- /dev/null
+++ b/basic/79-hardhat-foundry/scripts/libraries/logger.ts
@@ -0,0 +1,31 @@
+import chalk from "chalk";
+
+const log = (...message: any[]) => write(...plainObject(message));
+const success = (...message: any[]) => write(chalk.green(...plainObject(message)));
+const warning = (...message: any[]) => write(chalk.yellow(...plainObject(message)));
+const info = (...message: any[]) => write(chalk.blue(...plainObject(message)));
+const error = (...message: any[]) => write(chalk.red(...plainObject(message)))
+const debug = (...message: any[]) => write(chalk.whiteBright("🔧 [DEBUG]", ...plainObject(message)))
+const write = (...message: any[]): void => {
+    if (process.env.APP_ENV !== "test") {
+        // TODO 记录日志
+        console.log(...message);
+    }
+};
+const plainObject = (message: any[]): any[] => {
+    const wrapped: any[] = []
+    for (const item of message) {
+        if (typeof item === "object") {
+            try {
+                wrapped.push(JSON.stringify(item))
+            } catch (e) {
+                wrapped.push(item)
+            }
+        } else {
+            wrapped.push(item)
+        }
+    }
+    return wrapped
+};
+
+export default {success, warning, info, error, log, debug};
diff --git a/basic/79-hardhat-foundry/scripts/libraries/typechain-types/common.ts b/basic/79-hardhat-foundry/scripts/libraries/typechain-types/common.ts
new file mode 100644
index 000000000..192c895b7
--- /dev/null
+++ b/basic/79-hardhat-foundry/scripts/libraries/typechain-types/common.ts
@@ -0,0 +1,129 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  FunctionFragment,
+  Typed,
+  EventFragment,
+  ContractTransaction,
+  ContractTransactionResponse,
+  DeferredTopicFilter,
+  EventLog,
+  TransactionRequest,
+  LogDescription,
+} from "ethers";
+
+export interface TypedDeferredTopicFilter<_TCEvent extends TypedContractEvent>
+  extends DeferredTopicFilter {}
+
+export interface TypedContractEvent<
+  InputTuple extends Array<any> = any,
+  OutputTuple extends Array<any> = any,
+  OutputObject = any
+> {
+  (...args: Partial<InputTuple>): TypedDeferredTopicFilter<
+    TypedContractEvent<InputTuple, OutputTuple, OutputObject>
+  >;
+  name: string;
+  fragment: EventFragment;
+  getFragment(...args: Partial<InputTuple>): EventFragment;
+}
+
+type __TypechainAOutputTuple<T> = T extends TypedContractEvent<
+  infer _U,
+  infer W
+>
+  ? W
+  : never;
+type __TypechainOutputObject<T> = T extends TypedContractEvent<
+  infer _U,
+  infer _W,
+  infer V
+>
+  ? V
+  : never;
+
+export interface TypedEventLog<TCEvent extends TypedContractEvent>
+  extends Omit<EventLog, "args"> {
+  args: __TypechainAOutputTuple<TCEvent> & __TypechainOutputObject<TCEvent>;
+}
+
+export interface TypedLogDescription<TCEvent extends TypedContractEvent>
+  extends Omit<LogDescription, "args"> {
+  args: __TypechainAOutputTuple<TCEvent> & __TypechainOutputObject<TCEvent>;
+}
+
+export type TypedListener<TCEvent extends TypedContractEvent> = (
+  ...listenerArg: [
+    ...__TypechainAOutputTuple<TCEvent>,
+    TypedEventLog<TCEvent>,
+    ...undefined[]
+  ]
+) => void;
+
+export type MinEthersFactory<C, ARGS> = {
+  deploy(...a: ARGS[]): Promise<C>;
+};
+
+export type GetContractTypeFromFactory<F> = F extends MinEthersFactory<
+  infer C,
+  any
+>
+  ? C
+  : never;
+export type GetARGsTypeFromFactory<F> = F extends MinEthersFactory<any, any>
+  ? Parameters<F["deploy"]>
+  : never;
+
+export type StateMutability = "nonpayable" | "payable" | "view";
+
+export type BaseOverrides = Omit<TransactionRequest, "to" | "data">;
+export type NonPayableOverrides = Omit<
+  BaseOverrides,
+  "value" | "blockTag" | "enableCcipRead"
+>;
+export type PayableOverrides = Omit<
+  BaseOverrides,
+  "blockTag" | "enableCcipRead"
+>;
+export type ViewOverrides = Omit<TransactionRequest, "to" | "data">;
+export type Overrides<S extends StateMutability> = S extends "nonpayable"
+  ? NonPayableOverrides
+  : S extends "payable"
+  ? PayableOverrides
+  : ViewOverrides;
+
+export type PostfixOverrides<A extends Array<any>, S extends StateMutability> =
+  | A
+  | [...A, Overrides<S>];
+export type ContractMethodArgs<
+  A extends Array<any>,
+  S extends StateMutability
+> = PostfixOverrides<{ [I in keyof A]-?: A[I] | Typed }, S>;
+
+export type DefaultReturnType<R> = R extends Array<any> ? R[0] : R;
+
+// export interface ContractMethod<A extends Array<any> = Array<any>, R = any, D extends R | ContractTransactionResponse = R | ContractTransactionResponse> {
+export interface TypedContractMethod<
+  A extends Array<any> = Array<any>,
+  R = any,
+  S extends StateMutability = "payable"
+> {
+  (...args: ContractMethodArgs<A, S>): S extends "view"
+    ? Promise<DefaultReturnType<R>>
+    : Promise<ContractTransactionResponse>;
+
+  name: string;
+
+  fragment: FunctionFragment;
+
+  getFragment(...args: ContractMethodArgs<A, S>): FunctionFragment;
+
+  populateTransaction(
+    ...args: ContractMethodArgs<A, S>
+  ): Promise<ContractTransaction>;
+  staticCall(...args: ContractMethodArgs<A, S>): Promise<DefaultReturnType<R>>;
+  send(...args: ContractMethodArgs<A, S>): Promise<ContractTransactionResponse>;
+  estimateGas(...args: ContractMethodArgs<A, S>): Promise<bigint>;
+  staticCallResult(...args: ContractMethodArgs<A, S>): Promise<R>;
+}
diff --git a/basic/79-hardhat-foundry/scripts/libraries/typechain-types/contracts/DiamondCutFacet.ts b/basic/79-hardhat-foundry/scripts/libraries/typechain-types/contracts/DiamondCutFacet.ts
new file mode 100644
index 000000000..082cbc33d
--- /dev/null
+++ b/basic/79-hardhat-foundry/scripts/libraries/typechain-types/contracts/DiamondCutFacet.ts
@@ -0,0 +1,164 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../common";
+
+export declare namespace IDiamondCut {
+  export type FacetCutStruct = {
+    facetAddress: AddressLike;
+    action: BigNumberish;
+    functionSelectors: BytesLike[];
+  };
+
+  export type FacetCutStructOutput = [
+    facetAddress: string,
+    action: bigint,
+    functionSelectors: string[]
+  ] & { facetAddress: string; action: bigint; functionSelectors: string[] };
+}
+
+export interface DiamondCutFacetInterface extends Interface {
+  getFunction(nameOrSignature: "diamondCut"): FunctionFragment;
+
+  getEvent(nameOrSignatureOrTopic: "DiamondCut"): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "diamondCut",
+    values: [IDiamondCut.FacetCutStruct[], AddressLike, BytesLike]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "diamondCut", data: BytesLike): Result;
+}
+
+export namespace DiamondCutEvent {
+  export type InputTuple = [
+    _diamondCut: IDiamondCut.FacetCutStruct[],
+    _init: AddressLike,
+    _calldata: BytesLike
+  ];
+  export type OutputTuple = [
+    _diamondCut: IDiamondCut.FacetCutStructOutput[],
+    _init: string,
+    _calldata: string
+  ];
+  export interface OutputObject {
+    _diamondCut: IDiamondCut.FacetCutStructOutput[];
+    _init: string;
+    _calldata: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface DiamondCutFacet extends BaseContract {
+  connect(runner?: ContractRunner | null): DiamondCutFacet;
+  waitForDeployment(): Promise<this>;
+
+  interface: DiamondCutFacetInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  diamondCut: TypedContractMethod<
+    [
+      _diamondCut: IDiamondCut.FacetCutStruct[],
+      _init: AddressLike,
+      _calldata: BytesLike
+    ],
+    [void],
+    "nonpayable"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "diamondCut"
+  ): TypedContractMethod<
+    [
+      _diamondCut: IDiamondCut.FacetCutStruct[],
+      _init: AddressLike,
+      _calldata: BytesLike
+    ],
+    [void],
+    "nonpayable"
+  >;
+
+  getEvent(
+    key: "DiamondCut"
+  ): TypedContractEvent<
+    DiamondCutEvent.InputTuple,
+    DiamondCutEvent.OutputTuple,
+    DiamondCutEvent.OutputObject
+  >;
+
+  filters: {
+    "DiamondCut(tuple[],address,bytes)": TypedContractEvent<
+      DiamondCutEvent.InputTuple,
+      DiamondCutEvent.OutputTuple,
+      DiamondCutEvent.OutputObject
+    >;
+    DiamondCut: TypedContractEvent<
+      DiamondCutEvent.InputTuple,
+      DiamondCutEvent.OutputTuple,
+      DiamondCutEvent.OutputObject
+    >;
+  };
+}
diff --git a/basic/79-hardhat-foundry/scripts/libraries/typechain-types/contracts/DiamondInit.ts b/basic/79-hardhat-foundry/scripts/libraries/typechain-types/contracts/DiamondInit.ts
new file mode 100644
index 000000000..483ce89fc
--- /dev/null
+++ b/basic/79-hardhat-foundry/scripts/libraries/typechain-types/contracts/DiamondInit.ts
@@ -0,0 +1,84 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedListener,
+  TypedContractMethod,
+} from "../common";
+
+export interface DiamondInitInterface extends Interface {
+  getFunction(nameOrSignature: "init"): FunctionFragment;
+
+  encodeFunctionData(functionFragment: "init", values?: undefined): string;
+
+  decodeFunctionResult(functionFragment: "init", data: BytesLike): Result;
+}
+
+export interface DiamondInit extends BaseContract {
+  connect(runner?: ContractRunner | null): DiamondInit;
+  waitForDeployment(): Promise<this>;
+
+  interface: DiamondInitInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  init: TypedContractMethod<[], [void], "nonpayable">;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "init"
+  ): TypedContractMethod<[], [void], "nonpayable">;
+
+  filters: {};
+}
diff --git a/basic/79-hardhat-foundry/scripts/libraries/typechain-types/contracts/DiamondLoupeFacet.ts b/basic/79-hardhat-foundry/scripts/libraries/typechain-types/contracts/DiamondLoupeFacet.ts
new file mode 100644
index 000000000..f976e46f3
--- /dev/null
+++ b/basic/79-hardhat-foundry/scripts/libraries/typechain-types/contracts/DiamondLoupeFacet.ts
@@ -0,0 +1,168 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedListener,
+  TypedContractMethod,
+} from "../common";
+
+export declare namespace IDiamondLoupe {
+  export type FacetStruct = {
+    facetAddress: AddressLike;
+    functionSelectors: BytesLike[];
+  };
+
+  export type FacetStructOutput = [
+    facetAddress: string,
+    functionSelectors: string[]
+  ] & { facetAddress: string; functionSelectors: string[] };
+}
+
+export interface DiamondLoupeFacetInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "facetAddress"
+      | "facetAddresses"
+      | "facetFunctionSelectors"
+      | "facets"
+      | "supportsInterface"
+  ): FunctionFragment;
+
+  encodeFunctionData(
+    functionFragment: "facetAddress",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "facetAddresses",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "facetFunctionSelectors",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(functionFragment: "facets", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "supportsInterface",
+    values: [BytesLike]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "facetAddress",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "facetAddresses",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "facetFunctionSelectors",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "facets", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "supportsInterface",
+    data: BytesLike
+  ): Result;
+}
+
+export interface DiamondLoupeFacet extends BaseContract {
+  connect(runner?: ContractRunner | null): DiamondLoupeFacet;
+  waitForDeployment(): Promise<this>;
+
+  interface: DiamondLoupeFacetInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  facetAddress: TypedContractMethod<
+    [_functionSelector: BytesLike],
+    [string],
+    "view"
+  >;
+
+  facetAddresses: TypedContractMethod<[], [string[]], "view">;
+
+  facetFunctionSelectors: TypedContractMethod<
+    [_facet: AddressLike],
+    [string[]],
+    "view"
+  >;
+
+  facets: TypedContractMethod<[], [IDiamondLoupe.FacetStructOutput[]], "view">;
+
+  supportsInterface: TypedContractMethod<
+    [_interfaceId: BytesLike],
+    [boolean],
+    "view"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "facetAddress"
+  ): TypedContractMethod<[_functionSelector: BytesLike], [string], "view">;
+  getFunction(
+    nameOrSignature: "facetAddresses"
+  ): TypedContractMethod<[], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "facetFunctionSelectors"
+  ): TypedContractMethod<[_facet: AddressLike], [string[]], "view">;
+  getFunction(
+    nameOrSignature: "facets"
+  ): TypedContractMethod<[], [IDiamondLoupe.FacetStructOutput[]], "view">;
+  getFunction(
+    nameOrSignature: "supportsInterface"
+  ): TypedContractMethod<[_interfaceId: BytesLike], [boolean], "view">;
+
+  filters: {};
+}
diff --git a/basic/79-hardhat-foundry/scripts/libraries/typechain-types/contracts/OwnershipFacet.ts b/basic/79-hardhat-foundry/scripts/libraries/typechain-types/contracts/OwnershipFacet.ts
new file mode 100644
index 000000000..78b6d35e4
--- /dev/null
+++ b/basic/79-hardhat-foundry/scripts/libraries/typechain-types/contracts/OwnershipFacet.ts
@@ -0,0 +1,143 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../common";
+
+export interface OwnershipFacetInterface extends Interface {
+  getFunction(nameOrSignature: "owner" | "transferOwnership"): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic:
+      | "OwnershipTransferred(address,address)"
+  ): EventFragment;
+
+  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "transferOwnership",
+    values: [AddressLike]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "transferOwnership",
+    data: BytesLike
+  ): Result;
+}
+
+export namespace OwnershipTransferred_address_address_Event {
+  export type InputTuple = [previousOwner: AddressLike, newOwner: AddressLike];
+  export type OutputTuple = [previousOwner: string, newOwner: string];
+  export interface OutputObject {
+    previousOwner: string;
+    newOwner: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface OwnershipFacet extends BaseContract {
+  connect(runner?: ContractRunner | null): OwnershipFacet;
+  waitForDeployment(): Promise<this>;
+
+  interface: OwnershipFacetInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  owner: TypedContractMethod<[], [string], "view">;
+
+  transferOwnership: TypedContractMethod<
+    [_newOwner: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "owner"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "transferOwnership"
+  ): TypedContractMethod<[_newOwner: AddressLike], [void], "nonpayable">;
+
+  getEvent(
+    key: "OwnershipTransferred(address,address)"
+  ): TypedContractEvent<
+    OwnershipTransferred_address_address_Event.InputTuple,
+    OwnershipTransferred_address_address_Event.OutputTuple,
+    OwnershipTransferred_address_address_Event.OutputObject
+  >;
+  getEvent(
+    key: "OwnershipTransferred(address,address)"
+  ): TypedContractEvent<
+    OwnershipTransferred_address_address_Event.InputTuple,
+    OwnershipTransferred_address_address_Event.OutputTuple,
+    OwnershipTransferred_address_address_Event.OutputObject
+  >;
+
+  filters: {
+    "OwnershipTransferred(address,address)": TypedContractEvent<
+      OwnershipTransferred_address_address_Event.InputTuple,
+      OwnershipTransferred_address_address_Event.OutputTuple,
+      OwnershipTransferred_address_address_Event.OutputObject
+    >;
+  };
+}
diff --git a/basic/79-hardhat-foundry/scripts/libraries/typechain-types/index.ts b/basic/79-hardhat-foundry/scripts/libraries/typechain-types/index.ts
new file mode 100644
index 000000000..9a518600d
--- /dev/null
+++ b/basic/79-hardhat-foundry/scripts/libraries/typechain-types/index.ts
@@ -0,0 +1,4 @@
+export type {DiamondInit} from "./contracts/DiamondInit";
+export type {DiamondCutFacet} from "./contracts/DiamondCutFacet";
+export type {DiamondLoupeFacet} from "./contracts/DiamondLoupeFacet";
+export type {OwnershipFacet} from "./contracts/OwnershipFacet";
diff --git a/basic/79-hardhat-foundry/test/LibExample.t.sol b/basic/79-hardhat-foundry/test/LibExample.t.sol
new file mode 100644
index 000000000..9999e2824
--- /dev/null
+++ b/basic/79-hardhat-foundry/test/LibExample.t.sol
@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import {Test, console2} from "forge-std/Test.sol";
+import {LibExample} from "../contracts/LibExample.sol";
+
+contract LibExampleTest is Test {
+
+    // 模糊测试: 测试小于type(uint160).max的参数值能正常转换
+    function testFuzz_toUint160(uint256 n) public {
+        // if n > type(uint160).max, skip
+        vm.assume(n <= type(uint160).max);
+        LibExample.toUint160(n);
+    }
+
+    // 模糊测试: 测试大于type(uint160).max的参数值抛出异常
+    function testFailFuzz_toUint160_overflow(uint256 n) public {
+        // if n < type(uint160).max, skip
+        vm.assume(n > type(uint160).max);
+        LibExample.toUint160(n);
+    }
+}
diff --git a/basic/79-hardhat-foundry/test/NewExample.t.sol b/basic/79-hardhat-foundry/test/NewExample.t.sol
new file mode 100644
index 000000000..5311dbfd1
--- /dev/null
+++ b/basic/79-hardhat-foundry/test/NewExample.t.sol
@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import {Test, console2} from "forge-std/Test.sol";
+import {NewExample} from "../contracts/NewExample.sol";
+
+contract ExampleTest is Test {
+    NewExample public example;
+
+    function setUp() public {
+        example = new NewExample();
+        example.setNumber(0);
+    }
+
+    function test_setNumber() public {
+        example.setNumber(1024);
+        assertEq(example.getNumber(), 1024);
+    }
+
+    function testFuzz_SetNumber(uint256 x) public {
+        example.setNumber(x);
+        assertEq(example.getNumber(), x);
+    }
+}
diff --git a/basic/79-hardhat-foundry/test/OverrideExample.t1.sol b/basic/79-hardhat-foundry/test/OverrideExample.t1.sol
new file mode 100644
index 000000000..502a9c3c9
--- /dev/null
+++ b/basic/79-hardhat-foundry/test/OverrideExample.t1.sol
@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import {Test, console2} from "forge-std/Test.sol";
+import {OverrideExample} from "../contracts/OverrideExample.sol";
+
+contract OverrideExampleTest1 is Test, OverrideExample {
+
+    function setUp() public {
+        // init
+        until = 10 days;
+    }
+
+    // override
+    function _blockTimestamp() internal view override returns (uint256) {
+        return 10 days;
+    }
+
+    function test_transfer() public {
+        transfer();
+    }
+}
diff --git a/basic/79-hardhat-foundry/test/OverrideExample.t2.sol b/basic/79-hardhat-foundry/test/OverrideExample.t2.sol
new file mode 100644
index 000000000..304a63705
--- /dev/null
+++ b/basic/79-hardhat-foundry/test/OverrideExample.t2.sol
@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import {Test, console2} from "forge-std/Test.sol";
+import {OverrideExample} from "../contracts/OverrideExample.sol";
+
+contract OverrideExampleTest2 is Test, OverrideExample {
+
+    function setUp() public {
+        // init
+        until = 10 days;
+    }
+
+    function testFail_transfer(uint256 x) public {
+        transfer();
+    }
+}
diff --git a/basic/79-hardhat-foundry/test/diamond.ts b/basic/79-hardhat-foundry/test/diamond.ts
new file mode 100644
index 000000000..d450a1b1c
--- /dev/null
+++ b/basic/79-hardhat-foundry/test/diamond.ts
@@ -0,0 +1,44 @@
+import {ethers} from "hardhat";
+import {deploy} from "../scripts/libraries/deployLib";
+import {Example} from "../typechain-types";
+import {loadFixture} from "@nomicfoundation/hardhat-toolbox/network-helpers";
+import {expect} from "chai";
+import {HardhatEthersSigner} from "@nomicfoundation/hardhat-ethers/signers"
+import {Diamonds} from "../scripts/libraries/Diamonds";
+
+describe("钻石合约", () => {
+    let user: HardhatEthersSigner
+    afterEach(()=>{
+        console.log("afterEach------------------------------------")
+    })
+    beforeEach(()=>{
+        console.log("beforeEach------------------------------------")
+    })
+    before("user", async () => {
+        console.log("before------------------------------------")
+        const accounts = await ethers.getSigners()
+        user = accounts[0]
+    })
+
+    async function deployFixture() {
+        return await Diamonds.deploy(false)
+    }
+
+    it("代理测试样例", async () => {
+        const diamond = await loadFixture(deployFixture);
+        const [example] = await deploy(false, "Example")
+        await diamond.proxy(example);
+        await (await (example.attach(diamond.address) as Example).setNumber(1024n)).wait()
+        expect(await (example.attach(diamond.address) as Example).getNumber()).eq(1024n)
+    });
+    it("升级测试样例", async () => {
+        const diamond = await loadFixture(deployFixture);
+        const [oldExample] = await deploy(false, "Example")
+        await diamond.proxy(oldExample)
+        const [newExample] = await deploy(false, "Example")
+        await diamond.upgrade(oldExample.address, newExample)
+        // assert
+        const selector = (newExample as any as Example).interface.getFunction("setNumber").selector
+        expect(await diamond.facetAddress(selector)).eq(newExample.address)
+    });
+});
diff --git a/basic/79-hardhat-foundry/tsconfig.json b/basic/79-hardhat-foundry/tsconfig.json
new file mode 100644
index 000000000..5b230643a
--- /dev/null
+++ b/basic/79-hardhat-foundry/tsconfig.json
@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true
+  }
+}