diff --git a/README-CN.md b/README-CN.md
index cb1786e14..aad2fda89 100644
--- a/README-CN.md
+++ b/README-CN.md
@@ -224,7 +224,7 @@ DAPP架构请参考文章--[从架构维度看Web2.0与Web3.0应用之别](https
 3. [Curve](defi/Curve/README.md) ⌛
 4. [Compound](defi/Compound/readme.md) ✅
 5. [Aave](https://docs.aave.com/portal/)  ✅
-6. [Liquity](defi/Liquity/readme.md) ⌛
+6. [Liquity](defi/Liquity/) ⌛
 7. [Euler](defi/Euler/readme.md) ⌛
 8. [SNX](https://github.com/Synthetixio)⌛
 9. [YFI](https://yearn.finance/)⌛
@@ -233,7 +233,7 @@ DAPP架构请参考文章--[从架构维度看Web2.0与Web3.0应用之别](https
 12. [OPYN](https://v2.opyn.co/)⌛
 13. [Alchemix](https://github.com/alchemix-finance/alchemix-protocol) ✅
 14. [AMPL](https://roninchow.gitbook.io/ampleforth-cn/technology) [👉 认领这个 Task](https://github.com/rebase-network/Dapp-Learning/issues/new)
-15. [RAI](https://www.youtube.com/watch?v=ADK91Zw4sJA&list=PL-GxJch-YeZerVVV8dY8qU2VkJfbnSfdN&index=3)
+15. [RAI](defi/RAI/)⌛
 16. [DYDX](https://dydx.exchange/)[👉 认领这个 Task](https://github.com/rebase-network/Dapp-Learning/issues/new)
 17. [INDEX](https://mp.weixin.qq.com/s/PXOY3G6AIbhzRUptjYoWIw)[👉 认领这个 Task](https://github.com/rebase-network/Dapp-Learning/issues/new)
 18. [DODO](https://dodoex.github.io/docs/zh/docs/tradeApi) [👉 认领这个 Task](https://github.com/rebase-network/Dapp-Learning/issues/new)
diff --git a/README.md b/README.md
index 941408a6a..353ee9967 100644
--- a/README.md
+++ b/README.md
@@ -218,7 +218,7 @@ You can refer to our study group's learning roadmap, which is better with the vi
 03. [Curve](defi/Curve/README.md) ⌛
 04. [Compound](defi/Compound/readme.md) ✅
 05. [Aave](https://docs.aave.com/portal/)  ✅
-06. [Liquity](defi/Liquity/readme.md) ✅
+06. [Liquity](defi/Liquity/) ✅
 07. [Euler](defi/Euler/readme.md) ⌛
 08. [SNX](https://github.com/Synthetixio) [👉 Pick up this Task](https://github.com/Dapp-Learning-DAO/Dapp-Learning/issues/new)
 09. [YFI](https://yearn.finance/) ⌛
@@ -227,7 +227,7 @@ You can refer to our study group's learning roadmap, which is better with the vi
 12. [OPYN](https://v2.opyn.co/)⌛
 13. [Alchemix](https://github.com/alchemix-finance/alchemix-protocol) ✅
 14. [AMPL](https://roninchow.gitbook.io/ampleforth-cn/technology) [👉 Pick up this Task](https://github.com/Dapp-Learning-DAO/Dapp-Learning/issues/new)
-15. [RAI](https://www.youtube.com/watch?v=ADK91Zw4sJA& list=PL-GxJch-YeZerVVV8dY8qU2VkJfbnSfdN&index=3)
+15. [RAI](defi/RAI/)⌛
 16. [DYDX](https://dydx.exchange/)[👉 Pick up this Task](https://github.com/Dapp-Learning-DAO/Dapp-Learning/issues/new)
 17. [INDEX](https://mp.weixin.qq.com/s/PXOY3G6AIbhzRUptjYoWIw)[👉 Pick up this Task](https://github.com/Dapp-Learning-DAO/Dapp-Learning/issues/new)
 18. [DODO Trading API](https://dodoex.github.io/docs/zh/docs/tradeApi) [👉 Pick up this Task](https://github.com/Dapp-Learning-DAO/Dapp-Learning/issues/new)
@@ -249,6 +249,7 @@ You can refer to our study group's learning roadmap, which is better with the vi
 - 04. [Rarible](https://docs.rarible.org/overview/union/)
 - 05. [Zora](https://docs.zora.co/)
 - 06. [Alchemy](https://www.alchemy.com/nft-api)
+- 07. [Infura](https://www.infura.io/platform/nft-api)
 
 ## DAO advanced tasks
 
diff --git a/basic/02-web3js-transaction/index.js b/basic/02-web3js-transaction/index.js
index 659c78c99..5ce9a694d 100644
--- a/basic/02-web3js-transaction/index.js
+++ b/basic/02-web3js-transaction/index.js
@@ -5,6 +5,10 @@ const contractOfIncrementer = require('./compile');
 require('dotenv').config();
 const privatekey = process.env.PRIVATE_KEY;
 
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 /*
    -- Define Provider --
 */
@@ -155,11 +159,8 @@ const Trans = async () => {
   // goerli don't support http protocol to event listen, need to use websocket
   // more details , please refer to  https://medium.com/blockcentric/listening-for-smart-contract-events-on-public-blockchains-fdb5a8ac8b9a
   const web3Socket = new Web3(
-    new Web3.providers.WebsocketProvider(
       'wss://goerli.infura.io/ws/v3/' + process.env.INFURA_ID
-    )
   );
-  incrementer = new web3Socket.eth.Contract(abi, createReceipt.contractAddress);
 
   // listen to  Increment event only once
   incrementer.once('Increment', (error, event) => {
@@ -167,9 +168,20 @@ const Trans = async () => {
   });
 
   // listen to Increment event continuously
-  incrementer.events.Increment(() => {
-    console.log('I am a longlive event listener, I get a event now');
-  });
+  web3Socket.eth.subscribe('logs',{
+    address: createReceipt.contractAddress,
+    topics: []
+  },(error,result) => {
+    if(error){
+      console.error(error)
+    }
+  }
+  ).on("data", (event) => {
+      console.log("New event: ", event);
+    })
+    .on("error", (error) => {
+      console.error("Error: ", error);
+    });
 
   for (let step = 0; step < 3; step++) {
     incrementTransaction = await web3.eth.accounts.signTransaction(
@@ -183,6 +195,9 @@ const Trans = async () => {
 
     await web3.eth.sendSignedTransaction(incrementTransaction.rawTransaction);
 
+    console.log("Waiting for events")
+    await sleep(3000);
+    
     if (step == 2) {
       // clear all the listeners
       web3Socket.eth.clearSubscriptions();
diff --git a/basic/14-chainlink-price-feed/README-CN.md b/basic/14-chainlink-price-feed/README-CN.md
index 2bf240d62..519589f57 100644
--- a/basic/14-chainlink-price-feed/README-CN.md
+++ b/basic/14-chainlink-price-feed/README-CN.md
@@ -3,6 +3,8 @@
 
 区块链是非常安全可靠的价值交换网络，但却无法安全防篡改地获取链下数据或将数据发送至链下系统。使用 Chainlink 预言机喂价, 通过预言机网络在链上直接获取实时金融市场价格数据
 
+首先，我们可以在[这里](https://docs.chain.link/data-feeds/price-feeds/addresses)找到各个网络的喂价合约地址。然后，以ETH_USD为例，表示一个ETH能兑换多少USD，注意不要理解反了，不是ETH per USD的意思。接下来无论链上还是链下，我们都需要通过读取喂价器合约的方式获取价格信息。
+
 ## 测试流程
 
 ### 配置私钥
@@ -28,7 +30,7 @@ npx hardhat run scripts/01-PriceConsumerV3Deploy.js --network goerli
 ```
 
 ### 链下调用喂价机
-
+#### 获取最新数据
 ```js
 // ./UsingDataFeedsByEthers.js
 require('dotenv').config();
@@ -74,6 +76,29 @@ Latest Round Data [
 - 完整示例看这里 [:point_right: UsingDataFeedsByEthers.js](./UsingDataFeedsByEthers.js)
 
 
+#### 链下获取历史数据
+
+Chainlink链上Api提供两个接口：
+- latestRoundData：获取最新价格数据
+- getRoundData：获取历史价格数据
+
+首先，了解什么round。chainlink会将链下聚合器的数据持续更新到链上，每次更新，就会更新roundId。更新的间隔是不定时的，快则几分钟更新一次，慢则几个小时，甚至几天更新一次价格。
+
+其次，roundId的构成，由两部分：phaseId和aggregatorRoundId. roundId生成方式如下：
+```
+roundId = (phaseId << 64)  | aggregatorRoundId
+```
+其中：
+- phaseId表示历史上聚合器的版本，从1开始，每次聚合器更新，就会让phase+1.
+- aggregatorRoundId表示对应聚合器版本下的轮数，每次更新一次喂价器数据，就会让这个编号加1.
+
+所以，遍历历史数据的思路如下：
+- 先根据latestRoundData，读取最新的phaseId.
+- phaseId从1开始，然后遍历aggregatorRoundId，也从1开始，如果遇到revert错误，就将phaseId+1.
+
+可以参考例子:[ethers获取历史数据](./scripts/04-HistoryData.js)
+
+
 
 ### Chainlink VRF
 
@@ -154,3 +179,6 @@ SubscriptionId=ddddd
 - https://learnblockchain.cn/article/2558
 - https://learnblockchain.cn/article/1056
 - https://mp.weixin.qq.com/s/h0uTWY7vzd-CMdr1pE7_YQ
+- https://docs.chain.link/data-feeds/examples
+- https://docs.chain.link/data-feeds/historical-data
+- https://docs.chain.link/data-feeds/price-feeds/addresses
\ No newline at end of file
diff --git a/basic/14-chainlink-price-feed/hardhat.config.js b/basic/14-chainlink-price-feed/hardhat.config.js
index 7ed4e3f73..13de0d632 100644
--- a/basic/14-chainlink-price-feed/hardhat.config.js
+++ b/basic/14-chainlink-price-feed/hardhat.config.js
@@ -39,10 +39,10 @@ module.exports = {
       //   url: mainnetRpcUrl
       // }
     },
-    goerli: {
-      url: 'https://goerli.infura.io/v3/' + process.env.INFURA_ID, //<---- YOUR INFURA ID! (or it won't work)
-      accounts: [mnemonic()],
-    },
+    // goerli: {
+    //   url: 'https://goerli.infura.io/v3/' + process.env.INFURA_ID, //<---- YOUR INFURA ID! (or it won't work)
+    //   accounts: [mnemonic()],
+    // },
   },
   namedAccounts: {
     deployer: {
diff --git a/basic/14-chainlink-price-feed/package.json b/basic/14-chainlink-price-feed/package.json
index 225f43faa..7ec18f2ad 100644
--- a/basic/14-chainlink-price-feed/package.json
+++ b/basic/14-chainlink-price-feed/package.json
@@ -24,6 +24,7 @@
   "dependencies": {
     "@chainlink/contracts": "^0.4.0",
     "@nomiclabs/hardhat-etherscan": "^3.0.1",
-    "dotenv": "^10.0.0"
+    "dotenv": "^10.0.0",
+    "moment": "^2.29.4"
   }
 }
diff --git a/basic/14-chainlink-price-feed/scripts/04-HistoryData.js b/basic/14-chainlink-price-feed/scripts/04-HistoryData.js
new file mode 100644
index 000000000..842fe639e
--- /dev/null
+++ b/basic/14-chainlink-price-feed/scripts/04-HistoryData.js
@@ -0,0 +1,129 @@
+// We require the Hardhat Runtime Environment explicitly here. This is optional
+// but useful for running the script in a standalone fashion through `node <script>`.
+//
+// You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
+// will compile your contracts, add the Hardhat Runtime Environment's members to the
+// global scope, and execute the script.
+
+const moment = require('moment');
+
+const aggregatorV3InterfaceABI = [
+  {
+    inputs: [],
+    name: "decimals",
+    outputs: [{ internalType: "uint8", name: "", type: "uint8" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "description",
+    outputs: [{ internalType: "string", name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [{ internalType: "uint80", name: "_roundId", type: "uint80" }],
+    name: "getRoundData",
+    outputs: [
+      { internalType: "uint80", name: "roundId", type: "uint80" },
+      { internalType: "int256", name: "answer", type: "int256" },
+      { internalType: "uint256", name: "startedAt", type: "uint256" },
+      { internalType: "uint256", name: "updatedAt", type: "uint256" },
+      { internalType: "uint80", name: "answeredInRound", type: "uint80" },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "latestRoundData",
+    outputs: [
+      { internalType: "uint80", name: "roundId", type: "uint80" },
+      { internalType: "int256", name: "answer", type: "int256" },
+      { internalType: "uint256", name: "startedAt", type: "uint256" },
+      { internalType: "uint256", name: "updatedAt", type: "uint256" },
+      { internalType: "uint80", name: "answeredInRound", type: "uint80" },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "version",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+]
+
+async function main() {
+
+  const { ethers, BigNumber } = require("ethers") // for nodejs only
+
+  const provider = new ethers.providers.JsonRpcProvider("https://rpc.ankr.com/eth_sepolia")
+  //eth_usd: one eth worths how many usd
+  const addr = "0x694AA1769357215DE4FAC081bf1f309aDC325306"
+  const priceFeed = new ethers.Contract(addr, aggregatorV3InterfaceABI, provider)
+
+  //1. 获取最新的round
+  const latestRound = await priceFeed.latestRoundData();
+
+  //see https://docs.chain.link/data-feeds/historical-data
+  const mask = BigNumber.from('0xFFFFFFFFFFFFFFFF');//right most 64bits with 1
+
+  const latestPhaseId = latestRound.roundId.shr(64);
+  const latestAggregatorRoundId = latestRound.roundId.and(mask);
+
+  console.log('latesPhaseId '+latestPhaseId.toString())
+  console.log('latestAggregatorRoundId '+latestAggregatorRoundId.toString())
+
+  for (var phase = BigNumber.from(1);phase.lte(latestPhaseId);phase=phase.add(1)){
+    for (var agRound = BigNumber.from(1); agRound.lte(mask) ; agRound=agRound.add(1)){
+     
+      const [inPhase, roundData] = await downloadRoundData(priceFeed, phase, agRound);
+      if (!inPhase){
+        console.log('should start a new phase')
+        break;
+      }
+      processRoundData(phase, agRound, roundData)
+      await new Promise(r => setTimeout(r, 1000));
+
+    }
+  }
+}
+
+async function downloadRoundData(priceFeed, phase, agRound){
+  const roundId = phase.shl(64).or(agRound);
+  const maxRetries = 10
+  var tries = 1;
+  while (tries <= maxRetries){
+    try{
+      const roundData = await priceFeed.getRoundData(roundId);
+      return [true, roundData] //still same phase, rounddata
+    }
+    catch(e){
+      if(e.message.includes('Transaction reverted')){
+        return [false, undefined]//out of the current phase, should start new one
+      } else{
+        console.log(e.message)
+        tries++;//just retry, may be network connection issues
+        await new Promise(r => setTimeout(r, 1000));
+      }
+    }
+  }
+  throw Error('Totally failed. dont know why');
+
+
+}
+function processRoundData(phase, agRound, roundData){
+  //Todo:insert it into database
+  //目前只是打印
+  console.log(`phase:${phase}, agRound:${agRound}`);
+  console.log(`answer:${ethers.utils.formatUnits(roundData.answer, 8)}`);
+  console.log(`updatedAt:${moment(roundData.updatedAt*1000).format('YYYY-MM-DD HH:mm:ss')}`);      
+
+}
+
+
+main()
\ No newline at end of file
diff --git a/basic/38-ether-rust/Cargo.lock b/basic/38-ether-rust/Cargo.lock
index b81b7cb2b..2c5c1d8ff 100644
--- a/basic/38-ether-rust/Cargo.lock
+++ b/basic/38-ether-rust/Cargo.lock
@@ -1537,9 +1537,9 @@ dependencies = [
 
 [[package]]
 name = "h2"
-version = "0.3.13"
+version = "0.3.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37a82c6d637fc9515a4694bbf1cb2457b79d81ce52b3108bdeea58b07dd34a57"
+checksum = "66b91535aa35fea1523ad1b86cb6b53c28e0ae566ba4a460f4457e936cad7c6f"
 dependencies = [
  "bytes",
  "fnv",
@@ -2131,9 +2131,9 @@ dependencies = [
 
 [[package]]
 name = "openssl"
-version = "0.10.40"
+version = "0.10.48"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb81a6430ac911acb25fe5ac8f1d2af1b4ea8a4fdfda0f1ee4292af2e2d8eb0e"
+checksum = "518915b97df115dd36109bfa429a48b8f737bd05508cf9588977b599648926d2"
 dependencies = [
  "bitflags",
  "cfg-if",
@@ -2163,9 +2163,9 @@ checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
 
 [[package]]
 name = "openssl-sys"
-version = "0.9.74"
+version = "0.9.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "835363342df5fba8354c5b453325b110ffd54044e588c539cf2f20a8014e4cb1"
+checksum = "666416d899cf077260dac8698d60a60b435a46d57e82acb1be3d0dad87284e5b"
 dependencies = [
  "autocfg",
  "cc",
diff --git a/basic/43-EVM/etk/GasOptimizedForSudo.md b/basic/43-EVM/etk/GasOptimizedForSudo.md
index 1feff6ec1..dc90fc6cb 100644
--- a/basic/43-EVM/etk/GasOptimizedForSudo.md
+++ b/basic/43-EVM/etk/GasOptimizedForSudo.md
@@ -84,7 +84,7 @@ runtimeStart:
     swap1                               #0 returndatasize success 0 returndatasize
     dup1                                #0 0 returndatasize success 0 returndatasize
     returndatacopy                      #success 0 returndatasize
-    push1 labelreturn                   #labelreturn success 0 returndatasize
+    push1 labelreturn-runtimeStart      #labelreturn success 0 returndatasize
     jumpi                               #0 returndatasize
     revert                              #
 labelreturn:    
@@ -147,4 +147,4 @@ function cloneETHPair(
         instance := create(0, ptr, 0x7c)
     }
 }
-```
\ No newline at end of file
+```
diff --git a/dao/DID/polygonid/README.md b/dao/DID/polygonid/README.md
new file mode 100644
index 000000000..6532c57bc
--- /dev/null
+++ b/dao/DID/polygonid/README.md
@@ -0,0 +1,100 @@
+
+# 简介
+did包含Issuer、Holder、Verifier三个角色，其中Issuer将声明Claim分发给Holder，Holder可向Verifier提供关于Claim上数据的证明，证明可带有隐私保护特性。
+
+iden3提供了did的基础设施，而polygonId则基于iden3实现了完整的did流程，包括身份创建、Claim分发、数据的证明、Claim的撤销等。
+
+polygonId曾经有一个测试网站，上面可以体验整个流程，目前似乎已不能访问，但可以参考[这篇笔记](https://www.notion.so/Iden3-784989e8163146b4ac2c6f9c2c81f867)的前两节，体验一下整个流程。
+
+
+# 基本概念
+
+## 技术概念
+- Babyjubjub：一种椭圆曲线。对zk友好，基于该曲线的验签操作可以节省大量的约束，因为它基于一个特殊素数，而这个素数正好是zksnark使用的那个素数，也就意味着省去了繁杂的求模约束。
+
+- Sparse Merkle Tree：稀疏默克尔树，这是一种特殊的merkle tree，它构建在一个“地址空间”之伤，它的每个叶子结点都位于某个“地址”，而这个"地址"里可以有数据，也可以没有数据，因此可以用来证明一个数据不存在,证明的方式是，为相应的叶子节点构建merkle proof，验证者用空值和merkle proof恢复出树根并比较即可。
+
+
+## iden3概念
+- Claim: 一个Claim记录了所属主体的数据。它上面有8个槽位，每个槽位占31字节。有些槽位记录了元数据信息，包括数据主体、Claim的到期时间等。其他槽位可以记录你想要的声明数据，取决于业务场景，比如你可以放姓名、年龄、职位等。注意，由于Claim记录了私有数据，它需要隐私地保存，通常用polygon钱包，或者专门的托管服务器。
+
+- Tree：每一个iden3的用户都保存有三棵树，每一个树都是一个稀疏默克尔树。
+    - Claims Tree ：保存用户的Claim。每当用户以Issuer角色分发出一张Claim，或者以Holder身份领取一张Claim，都会把Claims插入到树中。Claim的前4个槽位的哈希值，决定了将插入到树中的哪个叶子节点；换言之，Claim的前4个槽位的哈希值，唯一的决定了Claim的id。注意，由于Claims Tree保存了Claims，所以这棵树是私有的。
+    - Revocation Tree：这棵树被用于撤销Claim。每个Claim都有一个特殊的id，称为Revocation Nonce。当Issuer需要撤销发出的Claim时，需要把这个Claim的Revocation Nonce存储到这棵树中；当Holder尝试证明Claim的有效性时，必须证明这个Claim没有被撤销，也就是提供Issuer的Revocation Tree中，对应null值的merkle proof。这棵树需要公开访问。
+    - Roots Tree：每次Claim Tree被更新，新的树根就会存入这棵树中。
+
+- 状态：一个用户，它下面的三棵树的树根，拼起来的哈希就是这个用户的状态。状态根，存储在区块链上。
+
+# 运行原理
+
+理解了上面的内容，我们来简单梳理一下整个iden3的运行原理。
+## 初始化
+初始情况下，用户使用BabyJubJub，生成一个密钥对，公钥被记录在一个特殊的Claim上，这个Claim唯一记录的信息就是公钥。这个Claim会插入到用户的Claims Tree中，而此时的树根凑出来的初始状态，将决定了用户的did。
+
+用户可以自己决定是否将状态根同步上链，不上链，就无法完成整个流程。
+
+## 发放
+假设A、B、C三个用户都完成了初始化。此时A想给B分发一个Claim，表示B的身份信息。他构建好一个Claim，上面主要记录如下内容：
+- 数据主体：B的did
+- 声明信息：出生日期
+
+A将这个Claim存放到自己的Claims Tree中，并将状态转移上链，通过zksnark证明自己状态转移的合法性，内容包括：
+- 提供了正确的签名，所签署的哈希为（旧状态，新状态）
+- 存储签名公钥的那个Claim，位于旧的Claims Tree中
+- 旧的Claim树根，和其他两个树根，计算出的状态，和旧状态一致
+- 发放的Claim位于新的Claims Tree中
+- 新的Claim树根，和其他两个树根，计算出的状态，和新状态一致
+
+
+A现在还需要把这个Claim传送给B。在此之前，需要解决一个问题，即确保只有B可以领取Claim，其他人不可以领取。为此，A需要执行额外的认证环节。A生成认证Json，上面包括如下信息：
+
+- 数据主体：B的did
+- 认证模式：也就是如何证明自己是B用户。例如，对什么数据做签名（通常是一个哈希值），采用什么手段证明自己（通常是zk），如果用zk，使用哪一个电路等。
+- 回调url：B需要把自己的证明发送往这个回调url，认证成功后，会进行下载功能。
+
+通常，这个json被封装在一个二维码中。
+## 接收
+B使用polygon钱包这类专用客户端，扫描二维码，获取里面的Json，然后根据json，构造证明，向里面的回调url发送证明后，下载得到Claim。
+
+这个Claim也会存入B自己的Claims Tree中，并向区块链上同步自己的状态变更，附带的证明逻辑和前文A类似。
+
+## 校验
+B现在想向C证明，自己持有A发出的Claim，并证明自己年龄大于18岁。怎么做？
+
+B根据电路，构建出一个zk证明，zk证明的私有输入包括：
+- Claim
+- AuthClaim
+- Claim的Proof
+- AuthClaim的Proof
+- Claim的未撤销证明
+- AuthClaim的未撤销证明
+- 签名
+- 待签署数据
+
+
+公开输入包括：
+- 状态根
+- 常数18
+- 当前日期
+
+证明的逻辑大致包括：
+- 先根据AuthClaim记录的公钥，验证签名
+- 结合AuthClaim的proof，验证AuthClaim的有效性
+    - 除了核对Claims Tree，还要验证AuthClaim未撤销，即用空数据和“未撤销证明”生成Revocation Tree的状态根，和输入的状态根对比
+- 结合Claim的proof，验证Claim的有效性
+    - 除了核对Claims Tree，还要验证Claim未撤销，即用空数据和“未撤销证明”生成Revocation Tree的状态根，和输入的状态根对比
+- 验证Claim上记录的出生日期，加18，不超过当前日期。
+- 
+当然，还包括对公有输入的验证，比如对于状态根和合约记录的一致、当前日期是否正确等。
+
+## 撤销
+
+如果A想撤销这个Claim，只需把Claim的Revocation Nonce插入到自己的Revocation Tree中，并将新的状态根同步到链上。
+
+这样，当B要基于这个Claim构造证明时，无法提供出“未撤销证明”，那么也就无法继续进行下去了。
+
+
+
+# 参考资料
+- https://www.notion.so/dapplearning/Iden3-784989e8163146b4ac2c6f9c2c81f867
+- https://github.com/0xPolygonID/sh-id-platform
diff --git a/defi/Euler/hack/2023-03-15-11-05-38.png b/defi/Euler/hack/2023-03-15-11-05-38.png
new file mode 100644
index 000000000..e82d6d916
Binary files /dev/null and b/defi/Euler/hack/2023-03-15-11-05-38.png differ
diff --git a/defi/Euler/hack/2023-03-15-14-45-44.png b/defi/Euler/hack/2023-03-15-14-45-44.png
new file mode 100644
index 000000000..57e648d28
Binary files /dev/null and b/defi/Euler/hack/2023-03-15-14-45-44.png differ
diff --git a/defi/Euler/hack/2023-03-16-14-29-24.png b/defi/Euler/hack/2023-03-16-14-29-24.png
new file mode 100644
index 000000000..9a8e6ad3a
Binary files /dev/null and b/defi/Euler/hack/2023-03-16-14-29-24.png differ
diff --git a/defi/Euler/hack/EulerAttack.md b/defi/Euler/hack/EulerAttack.md
new file mode 100644
index 000000000..9e7a484f3
--- /dev/null
+++ b/defi/Euler/hack/EulerAttack.md
@@ -0,0 +1,272 @@
+# Euler Attack Post mortem
+Euler 在3月13日被攻击，损失了2B USD。攻击者的攻击代码异常简约，但反应出的是我方对于Euler项目的理解层次不同，深度不够。
+Euler项目在挖矿前就进行过详细的调研，也组织过相应的学习讨论，当时得出的结论是代码质量高，项目方靠谱。为达到Hacker对于Euler的理解深度，特重新梳理了一遍Euler项目的业务逻辑以及他的智能合约架构，以帮助我方理解其深层次原理。
+
+## 整体架构图
+![](2023-03-15-11-05-38.png)
+## 业务逻辑流程图
+### eToken.deposit:
+```sequence
+sender -> proxy(eToken): call deposit
+proxy(eToken) -> Euler: call dispatch
+Euler -> Impl(eToken): delegatecall deposit
+sender --> Euler: Dai transfer amountA
+Impl(eToken) --> sender: mint eDai amountB
+Impl(eToken) -> InterestRate: deleagatecall update IR
+Impl(eToken) -> RiskManager: delegatecall check liquidity
+Euler -> proxy(eToken): call emitEvent
+```
+
+$$
+\gamma = \frac{totalBorrow}{poolSize+totalBorrow}
+$$
+$$
+exchangeRate = \frac{poolSize+totalBorrow}{totalSupply}=\frac{amountA}{amountB}
+$$
+```python
+r = (cash + totalBorrow) / totalSupply
+r
+# deposit
+amount = 100
+cash = cash + amount
+share1 = amount / r
+totalSupply = totalSupply + share1
+# r = (cash + totalBorrow) / totalSupply
+share1
+```
+
+### eToken.withdraw
+```sequence
+sender -> proxy(eToken): call withdraw
+proxy(eToken) -> Euler: call dispatch
+Euler -> Impl(eToken): delegatecall withdraw
+Euler --> sender: Dai transfer amountA
+sender --> Impl(eToken): burn eDai amountB
+Impl(eToken) -> InterestRate: deleagatecall update IR
+Impl(eToken) -> RiskManager: delegatecall check liquidity
+Euler -> proxy(eToken): call emitEvent
+```
+
+### eToken.mint
+```sequence
+sender -> proxy(eToken): call mint
+proxy(eToken) -> Euler: call dispatch
+Euler -> Impl(eToken): delegatecall mint
+Impl(eToken) --> sender: mint eDai amount * 19
+Impl(dToken) --> sender: mint dDai amount * 19
+Impl(dToken) -> InterestRate: deleagatecall update IR
+Impl(eToken) -> InterestRate: deleagatecall update IR
+Impl(eToken) -> RiskManager: delegatecall check liquidity
+Euler -> proxy(eToken): call emitEvent
+```
+mint本质上是一个放大杠杆的操作，它允许用户最大放大到19倍杠杆。类似于compound中的循环贷，底层的资产事实上都锁在Euler协议里，并没有transfer出去给到用户。只是给用户记账。
+```python
+# mint
+amount = 100 * 19
+debt = amount
+share2 = amount / r
+totalSupply += share2
+totalBorrow += amount
+# r = (cash + totalBorrow) / totalSupply
+share2 + share1
+```
+### eToken.burn
+```sequence
+sender -> proxy(eToken): call burn
+proxy(eToken) -> Euler: call dispatch
+Euler -> Impl(eToken): delegatecall burn
+sender --> Impl(eToken): burn eDai amount
+sender --> Impl(dToken): burn dDai amount
+Impl(dToken) -> InterestRate: deleagatecall update IR
+Impl(eToken) -> InterestRate: deleagatecall update IR
+Impl(eToken) -> RiskManager: delegatecall check liquidity
+Euler -> proxy(eToken): call emitEvent
+```
+
+burn本质上是降低杠杆的操作，是mint的反操作。
+
+### eToken.transferFrom
+```sequence
+sender -> proxy(eToken): call transferfrom
+proxy(eToken) -> Euler: call dispatch
+Euler -> Impl(eToken): delegatecall transferfrom
+sender --> Impl(eToken): transferfrom eDai to amount
+Impl(eToken) -> RiskManager: delegatecall check liquidity From
+Impl(eToken) -> RiskManager: delegatecall check liquidity To
+Euler -> proxy(eToken): call emitEvent
+```
+
+### eToken.donateToReserves
+```sequence
+sender -> proxy(eToken): call donateToReserves
+proxy(eToken) -> Euler: call dispatch
+Euler -> Impl(eToken): delegatecall donateToReserves
+sender --> Impl(eToken): burn eDai amount
+Impl(eToken) --> pool: mint eDai amount
+Euler -> proxy(eToken): call emitEvent
+```
+```python
+# donate
+delta = 500
+share = share1 + share2 - delta
+share
+```
+### dToken.borrow
+```sequence
+sender -> proxy(dToken): call borrow
+proxy(dToken) -> Euler: call dispatch
+Euler -> Impl(dToken): delegatecall borrow
+Euler --> sender: Dai transfer amountA
+Impl(dToken) --> sender: mint dDai amountA
+Impl(dToken) -> InterestRate: deleagatecall update IR
+Impl(dToken) -> RiskManager: delegatecall check liquidity
+Euler -> proxy(dToken): call emitEvent
+```
+### dToken.repay
+```sequence
+sender -> proxy(dToken): call borrow
+proxy(dToken) -> Euler: call dispatch
+Euler -> Impl(dToken): delegatecall borrow
+sender --> Euler: Dai transfer amountA
+sender --> Impl(dToken): burn dDai amountA
+Impl(dToken) -> InterestRate: deleagatecall update IR
+Impl(dToken) -> RiskManager: delegatecall check liquidity
+Euler -> proxy(dToken): call emitEvent
+```
+### dToken.transferFrom
+```sequence
+sender -> proxy(dToken): call transferFrom
+proxy(dToken) -> Euler: call dispatch
+Euler -> Impl(dToken): delegatecall transferFrom
+Impl(dToken) -> Impl(dToken): check allowance[to][from] > amount
+sender --> Impl(dToken): transfer dDai amountA to To addr
+Impl(dToken) -> RiskManager: delegatecall check liquidity To
+Euler -> proxy(dToken): call emitEvent
+```
+### Liquidation.liquidate
+```sequence
+liquidator -> proxy(liquidate): call liquidate
+proxy(liquidate)->Euler: call dispatch
+Euler -> Impl(liquidate): delegatecall liquidate
+Impl(liquidate) -> RiskManager: getAccountLiquidity violator
+Impl(liquidate) -> Impl(liquidate): calculate
+Note right of Impl(liquidate):discount = 1 - healthFactor
+Note right of Impl(liquidate):discount <= 0.2, conversionRate = 1/1/(1-discount)
+Note right of Impl(liquidate):repay = dToken amount, yield = repay * conversionRate
+
+Impl(dToken) --> liquidator: transfer dToken  from violator to liquidator amount = repay
+Impl(dToken) --> liquidator: transfer dToken from violator to liquidator for fee = 0.02 * repay
+Impl(eToken) --> liquidator: transfer eToken from violator to liquidator amount = yield
+Impl(liquidate) -> RiskManager: delegatecall check liquidity liquidator
+Euler -> proxy(liquidate): call emitEvent
+```
+具体的清算时，其计算方式如下：
+```python
+# liquidation
+discount = 0.02 + 1 - hf
+discount = 0.2 if discount > 0.2 else discount
+cr = 1/1/(1-discount)
+
+repay = debt
+profit = repay * cr
+
+repay = share*r/cr if repay > share*r else repay
+profit = share*r if profit > share*r else profit
+
+repay = repay * 1.02
+withdrawAmount = profit - repay/0.95
+discount,cr,repay, profit,withdrawAmount
+
+```
+## Key Process
+### Risk Manager Check Liquidity
+针对同一种token，即持有eToken又持有dToken的情况，需要按照一下两种来分析：
+1. eToken价值低于dToken价值，则折算时，debtVal分为两部分：其一是eToken换算的等值dToken数量 t1, 其二是用户持有的单方向debt头寸差值的价值: (debt-t1)/bf
+```python
+colVal = share*r*0.95*p
+t1 = share*r*0.95
+t2 = (debt-t1)/bf
+debtVal = (t1+t2)*p
+hf = colVal/debtVal
+colVal,debtVal,hf
+```
+2. eToken价值高于dToken价值时，则collVal也分为两部分：其一是dToken换算的等值eToken数量 t1， 其二是差值部分的折算价值: (share*r - t1)*cf
+```python
+debtVal = debt*p
+t1 = debt/0.95
+t2 = (share*r -t1)*cf
+colVal = (t1+t2)*p
+hf = colVal/debtVal
+debtVal,colVal,hf
+```
+
+### reserve 部分计算：
+Euler 选择将reserve换成eToken存放在池子里，这样可以持续的吃利息。类比于compound，就是将compound的reserve部分重新deposit到池子中。
+同样的，问题的核心是保证exchange rate不变：
+$$
+r = \frac{casth+borrow-reserve}{totalSupply_0}=\frac{cash+borrow}{totalSupply_1}
+$$
+```python
+r1 = (cash + borrow - reserve) / totalSupply
+r2 = (cash + borrow) / totalSupply'
+reserve = (borrow * (1 + IR)^deltaT - borrow) * feeRatio
+totalSupply' / totalSupply = (cash + borrow) / (cash + borrow - reserve)
+```
+```js
+uint256 poolAssets = assetCache.poolSize + (newTotalBorrows / INTERNAL_DEBT_PRECISION);
+newTotalBalances = poolAssets * newTotalBalances / (poolAssets - feeAmount);
+newReserveBalance += newTotalBalances - assetCache.totalBalances;
+```
+
+### liquidation process中如果不是同一种token清算，保证用户健康度>1.25的计算公式推导
+
+推导的核心是：
+$$ 
+ hf = \frac{collVal - \delta \cdot cf \cdot cr}{debtVal - \delta / bf} > 1.25
+$$
+其中，$\delta$是需要偿还的债务价值，即dToken数量 * p， bf是borrow factor，cf是collaterall factory， cr是清算的激励因子
+则：
+$$
+\delta > \frac{1.25 * debtVal - collVal}{1.25/bf - cr \cdot cf}
+$$
+对应于代码：
+```python
+borrowAdj = 1.25 / bf
+collAdj = cf / (1 - dc) = cf * cr
+if borrowAdj <= collAdj :
+    repay = MAX
+else:
+    repay = (1.25 * debtVal - collVal) / (borrowAdj - collAdj) / p
+```
+
+### isolated 资产，cross资产
+针对isolated资产，比如COMP：
+isolated = true, cf = 0, bf = 28 / 40 = 0.7
+针对cross资产，比如LUSD:
+isolated = false, cf = 0, bf = 28 / 40 = 0.7
+具体的判断逻辑在requireLiquidity里面：
+如果isolated=true,那么必须要求numBorrow=1
+如果isolated=false,则可以借任意多种资产
+
+当借的资产类型是isolated时，此时isolated=true，当Mint时，即放大杠杆时，isolated=true
+
+只有collateral资产的cf > 0
+
+为什么要设计isolated资产类型和cross资产类型？让它无法用作抵押品，降低系统风险。
+
+## 核心漏洞
+mint最大可以放大19倍杠杆，而清算最多可以获得0.25倍的利润，所以19*0.25>1 超过了本金，导致只要构造一个可以清算自己的条件，就可以通过放大杠杆后清算自己获利。
+而通过donate可以构造一个绝佳的清算自己的情况，即将自己的eToken捐出，此时自己的dToken仍在，所以就资不抵债，符合清算逻辑。
+
+### timeline
+
+![](2023-03-16-14-29-24.png)
+https://twitter.com/tayvano_/status/1635368952774950912
+
+
+2023-03-13 18:05:23 local time - Euler Pause 1st
+https://openchain.xyz/trace/ethereum/0xb69b097fb373319659ddd31ac528e471830f50244905f0717cd13bc04f0a88b8
+2023-03-13 18:05:23 local time
+https://etherscan.io/tx/0xb69b097fb373319659ddd31ac528e471830f50244905f0717cd13bc04f0a88b8
+2023-03-13 19:44:23 local time
+https://openchain.xyz/trace/ethereum/0x90d26bb5126df219e707093487ba2a48b271e73ddba7e54bb5ae299c48dfc0fa
\ No newline at end of file
diff --git a/defi/Lido/Read.md b/defi/Lido/Read.md
new file mode 100644
index 000000000..07d390a08
--- /dev/null
+++ b/defi/Lido/Read.md
@@ -0,0 +1,8 @@
+# Lido
+
+Lido 作为以太坊LSD (ETH Liquid Staking Derivatives)的龙头项目，对于以太坊的POS机制有重要的影响，因此值得好好研究。
+
+
+References:
+- DefiLlama dashboard https://defillama.com/lsd 
+- contracts repo: https://github.com/lidofinance/lido-dao
\ No newline at end of file
diff --git a/defi/RAI/GEB.md b/defi/RAI/GEB.md
new file mode 100644
index 000000000..16ef3ce5a
--- /dev/null
+++ b/defi/RAI/GEB.md
@@ -0,0 +1,469 @@
+# Reflexer GEB
+
+GEB 协议的核心仓库，是 MCD(MakerDAO-dss)的修改版，具有几个核心的改进：
+
+- 可以理解的变量名称
+- 自主反馈机制，改变系统参与者的激励
+- 可添加 SAFE 保险
+- 固定和递增的折扣拍卖（而不是英国式拍卖）用于出售抵押品
+- 自动调整系统中的几个参数
+- 一组合约，约束了长期治理的参数控制
+- 可以一次将稳定费用发送到多个地址
+- 可以在盈余拍卖和其他类型的策略之间切换，以删除系统中的盈余
+- 每种抵押品类型有两个价格：一个用于生成债务，另一个专门用于清算 SAFE
+- stability fee treasury 可以支付 Oracle 调用或其他自动化系统的合约费用
+
+## Flow
+
+![GEB_overview](<https://1187825898-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-M9jdHretGKCtWYz5jZR%2F-MZCEBuqpWiVDbzkVeUa%2F-MZCEJv2Xvz-xIw0JAwy%2FGEB_overview%20(1).png?alt=media&token=d1233706-ec95-443b-8d45-97f973d18208>)
+
+[GEB Overview Diagram](https://viewer.diagrams.net/?target=blank&highlight=0000ff&layers=1&nav=1&title=GEB_overview.drawio#Uhttps%3A%2F%2Fdrive.google.com%2Fuc%3Fid%3D1nIcaY8N8StVCfyAL_ztbmETJX2bvY3a9%26export%3Ddownload)
+
+### build DSProxy
+
+`GebProxyRegistry.build(address owner)` 创建属于用户的 `DSProxy`, 注册 proxy 地址
+
+- `proxy = new DSProxy()`
+- `proxies[owner] = msg.sender`
+
+```solidity
+
+// geb-proxy-registry/
+// deploys a new proxy instance sets custom owner of proxy
+contract GebProxyRegistry {
+    function build(address owner) public returns (address payable proxy) {
+        require(proxies[owner] == DSProxy(0) || proxies[owner].owner() != owner); // Not allow new proxy if the user already has one and remains being the owner
+        proxy = factory.build(owner);
+        proxies[owner] = DSProxy(proxy);
+        emit Build(owner, proxy);
+    }
+}
+```
+
+### openLockETHAndGenerateDebt
+
+1. `DSProxy.execute(address _target, bytes memory _data)` 组装操作，调用 Proxy 执行交易
+2. `GebProxyActions.openLockETHAndGenerateDebt()` Actions 模块执行开仓, 抵押ETH，借出 RAI
+   - `GebProxyActions.openSAFE(address manager, bytes32 collateralType, address usr)`
+   - `GebSafeManager.openSAFE(bytes32 collateralType, address usr)`
+     - `new SAFEHandler(safeEngine)` 创建 SAFEHandler 合约
+   - `GebProxyActions.lockETHAndGenerateDebt()`
+     - `ethJoin_join(ethJoin, safeHandler, msg.value)` 通过 adaptor 转入 ETH 抵押资产
+     - `GebSafeManager.modifySAFECollateralization()` 创建 SAFE 仓位
+       - `GebSafeManager._getGeneratedDeltaDebt()` 增加SAFE债务，包含税收
+       - `SAFEEngine.modifySAFECollateralization()`
+     - `transferInternalCoins()` 将 RAI token 转给用户
+       - `BasicTokenAdapters.exit(address account, uint256 wad)`
+         - `SAFEEngine.modifyCollateralBalance()`
+
+```solidity
+// ds-proxy/src/proxy.sol
+contract DSProxy is DSAuth, DSNote {
+    // step 1
+    function execute(address _target, bytes memory _data) {
+        // target.delegatecall()
+    }
+}
+
+// geb-proxy-actions/src/GebProxyActions.sol
+contract GebProxyActions is BasicActions {
+    // step 2
+    function openLockETHAndGenerateDebt(
+        address manager,
+        address taxCollector,
+        address ethJoin,
+        address coinJoin,
+        bytes32 collateralType,
+        uint deltaWad
+    ) external payable returns (uint safe) {
+        safe = openSAFE(manager, collateralType, address(this));
+        lockETHAndGenerateDebt(manager, taxCollector, ethJoin, coinJoin, safe, deltaWad);
+    }
+
+    // step 3
+    /// @notice Opens a brand new Safe
+    /// @param manager address - Safe Manager
+    /// @param collateralType bytes32 - collateral type
+    /// @param usr address - Owner of the safe
+    function openSAFE(
+        address manager,
+        bytes32 collateralType,
+        address usr
+    ) public returns (uint safe) {
+        safe = ManagerLike(manager).openSAFE(collateralType, usr);
+    }
+}
+
+// geb-safe-manager/src/GebSafeManager.sol
+contract GebSafeManager {
+    // step 4
+    function openSAFE(
+        bytes32 collateralType,
+        address usr
+    ) public returns (uint) {
+        // safei is SAFE id
+        safes[safei] = address(new SAFEHandler(safeEngine));
+        ...
+        return safei;
+    }
+}
+
+// geb-proxy-actions/src/GebProxyActions.sol
+contract GebProxyActions is BasicActions {
+    // step 5
+    /// @notice Locks Eth, generates debt and sends COIN amount (deltaWad) to msg.sender
+    /// @param manager address
+    /// @param taxCollector address
+    /// @param ethJoin address
+    /// @param coinJoin address
+    /// @param safe uint - Safe Id
+    /// @param deltaWad uint - Amount
+    function lockETHAndGenerateDebt(
+        address manager,
+        address taxCollector,
+        address ethJoin,
+        address coinJoin,
+        uint safe,
+        uint deltaWad
+    ) public payable {
+    }
+}
+
+// geb-safe-manager/src/GebSafeManager.sol
+contract GebSafeManager {
+    // step 6
+    function modifySAFECollateralization(
+        uint safe,
+        int deltaCollateral,
+        int deltaDebt
+    ) public safeAllowed(safe) {
+        // SAFEEngine.modifySAFECollateralization()
+    }
+}
+
+```
+
+## Core Module
+
+### SAFE Engine
+
+> The SAFE, system coin and collateral database
+
+SAFE Engine 存储所有的 SAFE (用户的抵押和债务仓位) 并跟踪所有的债务和抵押平衡。该合约是最重要的系统组件，因此为了尽可能减少错误的可能性，它没有任何外部依赖。
+
+1. Coin cannot exist without collateral
+2. The Safe data structure is the SAFE
+3. Similarly, a collateral is an collateralType
+
+```solidity
+struct SAFE {
+    // Total amount of collateral locked in a SAFE
+    uint256 lockedCollateral;  // [wad]
+    // Total amount of debt generated by a SAFE
+    uint256 generatedDebt;     // [wad]
+}
+
+struct CollateralType {
+    // Total debt issued for this specific collateral type
+    uint256 debtAmount;        // [wad]
+    // Accumulator for interest accrued on this collateral type
+    uint256 accumulatedRate;   // [ray]
+    // Floor price at which a SAFE is allowed to generate debt
+    uint256 safetyPrice;       // [ray]
+    // Maximum amount of debt that can be generated with this collateral type
+    uint256 debtCeiling;       // [rad]
+    // Minimum amount of debt that must be generated by a SAFE using this collateral
+    uint256 debtFloor;         // [rad]
+    // Price at which a SAFE gets liquidated
+    uint256 liquidationPrice;  // [ray]
+}
+```
+
+SafeEngine 中的方法被编写为尽可能通用，因此其接口可能相当冗长。应注意确保参数的顺序不混淆。
+
+任何已通过 SafeEngine 授权的模块均具有完全的根访问权限，因此可以窃取系统中的所有抵押品。这意味着添加新的抵押品类型（及其相关适配器 Adapters）具有相当大的风险。
+
+#### SAFE Management
+
+- 任何人都可以通过 `modifySAFECollateralization` 来管理 SAFE，该方法可以使用用户提供的抵押品 `tokenCollateral` 来修改对应地址的 SAFE 仓位，并修改 `debtDestination` 的 `coinBalance`
+
+- `confiscateSAFECollateralAndDebt` 通常由 `LiquidationEngine` 来调用，将债务从 SAFE 转移到另一个地址的 `debtBalance`
+
+- `debtBalance` 表示坏账，可以使用 `settleDebt(uint rad)` 方法通过与等量系统币 (RAI) 抵消来消除。
+  在 `settleDebt(uint rad)` 中，msg.sender 用作 `coinBalance` 和 `debtBalance` 的地址。
+
+- coinBalance[user: address] - 在系统内用户有多少 coin ，该数量不会反应在 ERC20 合约中
+
+```solidity
+/**
+* @notice Nullify an amount of coins with an equal amount of debt
+* @param rad Amount of debt & coins to destroy
+*/
+function settleDebt(uint256 rad) external {
+    address account       = msg.sender;
+    debtBalance[account]  = subtract(debtBalance[account], rad);
+    coinBalance[account]  = subtract(coinBalance[account], rad);
+    globalUnbackedDebt    = subtract(globalUnbackedDebt, rad);
+    globalDebt            = subtract(globalDebt, rad);
+    emit SettleDebt(account, rad, debtBalance[account], coinBalance[account], globalUnbackedDebt, globalDebt);
+}
+```
+
+#### Stability Fee Accrual
+
+accumulatedRates 有助于将针对 collateralType 产生的标准化债务（generatedDebt）转换为该债务的现值（实际债务发行量+利息）。该费率通过 updateAccumulatedRate（由 TaxCollector 调用）更新。每次更新后，新计提的稳定费用都会添加到 surplusDst 的 coinBalance 中。
+
+### Liquidation Engine
+
+> The protocol's liquidation mechanism
+
+LiquidationEngine 使外部参与者能够清算 SAFEs 并将其抵押品发送到 CollateralAuctionHouse，同时将部分债务发送到 AccountingEngine。
+
+- liquidateSAFE 不会让 SAFE 带着债务离开且没有抵押品
+- liquidateSAFE 不会让 SAFE 累积 dust， 即数量微小的清算残余
+- 如果 `amountToRaise` + `currentOnAuctionSystemCoins` 超过了 `onAuctionSystemCoinLimit` ，liquidateSAFE 不会启动新的拍卖。
+- 如果所选的 SAFESaviour 地址未被治理机构列入白名单，则 `protectSAFE` 将被撤销 (revert)
+
+```solidity
+// geb/src/single/LiquidationEngine.sol
+function liquidateSAFE(bytes32 collateralType, address safe) external returns (uint256 auctionId) {
+    /*
+    1. 相应的仓位债务和抵押价值的检查，是否可以清算
+    2. 被清算人若有设置 safeSaviours，转入补充抵押资产
+    3. collateralToSell = (实际债务 / 可清算的债务上限) * 仓位中所有抵押资产
+    4. amountToRaise = limitAdjustedDebt * accumulatedRate / liquidationPenalty
+       该Safe仓位被清算最大值后，扣除的抵押价值 = 最大的债务 * 债务累计系数 / 惩罚折扣
+    5. CollateralAuctionHouse.startAuction() 仓位进入竞价拍卖流程
+    */
+}
+```
+
+liquidateSAFE 可以随时调用，但只有当目标 SAFE 处于亏损状态时才会成功。当锁定的抵押品（lockedCollateral）乘以抵押品的清算价格（liquidationPrice）小于其当前价值的负债时（已生成的债务乘以抵押品的累积利率 `accumulatedRate` ），就意味着 SAFE 处于亏损状态。
+
+- liquidationPrice 是由抵押品的清算比例调整的代理报告价格。尽管 Safety ratios 和清算比率的值可以相等，但二者之间有明显区别：
+
+- Safety ratios 是在对 SAFE 的抵押品产生债务时使用的最小抵押率。在清算比率下更为保守（更高）
+
+清算比率是 SAFE 的最小抵押率，在该抵押率下，SAFE 将被清算
+
+如果正在被目标的 SAFE 所有者用 saviour 来保护其位置， liquidateSAFE 可能会提前终止尝试进行清算。
+
+## Accounting Engine
+
+> The protocol's accountant, keeping track of surplus and deficit
+
+AccountingEngine 接收系统盈余和系统债务。它通过债务拍卖来弥补赤字，通过拍卖（Burning/RecyclingSurplusAuctionHouse）或转移（到 extraSurplusReceiver）来处理剩余。
+
+### Accounting Debt
+
+当 SAFE 被清算时，被查封 (confiscate) 的债务会被放入到 AccountingEngine 的队列中。此时的时间戳是清算 SAFE 行动的区块时间戳（`debtQueue[timestamp]`）。一旦 `AccountingEngine.popDebtDelay`（债务清算延迟）过期，该债务就可以通过 popDebtFromQueue 得到释放。一旦该债务被释放，就可以使用从 SAFE 清算中收集的剩余款项进行结算，或者如果没有收集足够的剩余款项，则可以使用 `DebtAuctionHouse` 进行拍卖。注意：只有在 `canPrintProtocolTokens` 返回 true 并且 `canPrintProtocolTokens` 未发生意外逆转时， AccountingEngine 才能开始一个新的债务拍卖。
+
+主要风险涉及到 popDebtDelay < CollateralAuctionHouse.totalAuctionLength，这会导致债务拍卖在相关抵押品拍卖完成之前开始。
+
+### Auctioning Surplus
+
+当 AccountingEngine 拥有超过 surplusBuffer 的剩余余额（`safeEngine.coinBalance[accountingEngine] > surplusBuffer`）时，如果超出缓冲区的额外剩余款项没有被保留用于抵消引擎的坏账（`safeEngine.debtBalance[accountingEngine]`），并且 `extraSurplusIsTransferred` 为 0，则可以使用 `Burning/RecyclingSurplusAuctionHouse` 进行拍卖。此过程将导致销毁协议代币，以换取拍卖的剩余款项。
+
+### Transferring Extra Surplus
+
+当 AccountingEngine 中的余额高于 surplusBuffer（`safeEngine.coinBalance [accountingEngine]> surplusBuffer`）时，如果超出缓冲区的额外余额未保留用于抵消引擎的坏账（`safeEngine.debtBalance [accountingEngine]`）且 `extraSurplusIsTransferred` 为 1，则可以将额外余额转移给 `extraSurplusReceiver。`
+
+### Disabling the Accounting Engine
+
+当授权地址调用 AccountingEngine.disableContract 时，系统将尝试尽可能清算剩余的 `safeEngine.debtBalance[accountingEngine]`。
+
+## Auction Module
+
+> Maintaining system balance by covering shortfall and disbursing surplus
+
+拍卖模块旨在通过参与抵押品、债务和盈余拍卖，激励外部参与者推动系统回到安全状态
+
+- `CollateralAuctionHouse` 用于出售已成为不足抵押的 SAFE 中的抵押品，以保持系统的整体健康。有两种类型的抵押品拍卖：
+
+  - `English Auction` 要求竞标者用逐渐增加的系统币竞标固定数量的抵押品，只有一个竞标者可以获胜。此拍卖类型有两个阶段：增加竞标金额，在此阶段中，竞标者提交更高的系统币竞标，而在第二个阶段中，降低售出数量，竞标者接受较低数量的抵押品，以获得获胜的系统币竞标。
+
+  - 另一方面，`FixedDiscount`, `IncreasingDiscount` 拍卖只有一个阶段（购买抵押品），其中竞标者提交系统币，而智能合约以比市场价格更低的折扣价格向其提供抵押品。这些拍卖类型与英式拍卖相比更具有资本效率和用户友好性。它们还允许任何人使用闪电贷购买抵押品。
+
+  - 默认情况下，合约将使用抵押品的 OSM 价格（相对于实际抵押品市场价格有所滞后）和系统币的 redemption price 来计算为每个个人竞标提供多少抵押品。如果规定在 FSM 价格和 redemption price 内部偏离一定限额，治理机构可以设置合约的参数，以便使用抵押品的中位数价格或系统币的市场价格。
+
+- `DebtAuctionHouse` 用于通过将协议代币拍卖出一定数量的盈余（系统币）来摆脱会计引擎的债务。拍卖完成后，将收到的盈余发送到会计引擎，以抵消恶性债务，并且为获胜的竞标者铸造协议代币
+
+- `SurplusAuctionHouse`（包括 Burning, Recycling and PostSettlement 3 个版本）用于通过拍卖一定数量的内部系统加密币，换取协议代币来清除 AccountingEngine 的盈余。拍卖结算后，拍卖行会将获胜的协议代币烧掉，或将竞标结果转移到外部地址，然后将内部系统加密币发送给获胜的竞标者，具体情况取决于拍卖行的决定。
+
+## Oracle Module
+
+> The "source of truth" for collateral and system coin prices
+
+Oracle 模块负责将价格源更新输入并推入系统。它由三个核心组件组成：medianizer 获取某种资产的价格源，FSM(Feed Security Module)为从 medianizer 获取的价格引入延迟，OracleRelayer 按赎回价格将价格数据除以质押率（提交价格的资产的质押率），然后将结果再次除以质押率，并将最终输出推入 SAFEEngine 中。该模块也可用于为系统的反馈机制或旨在自主设置系统参数的其他合约提供价格源数据。
+
+- `DSValue` 是 medianizer 的简化版本。它用于测试 Oracle 基础设施。合约创建者可以指定哪些地址被允许在合约内更新价格源。
+- `OSM`（Oracle Security Module）确保从 medianizer 传播的新价格值在经过指定延迟后，才会被系统接受。
+- `DSM`（Dampened Security Module）是类似 OSM 的合约，限制了两个连续价格源更新之间的最大价格变化。
+- `FsmGovernanceInterface` 是一个抽象，旨在帮助治理停止 OSMs.
+- `OracleRelayer` 是 OSM 和核心系统（SAFEEngine）之间的纽带。它将每个价格源除以最新的赎回价格，然后再次除以质押率，最后保存最终结果。事实上，中继器将为每种抵押品类型存储两种不同的价格：一个安全价格仅在 SAFE 用户想生成债务时使用，另一个是清算引擎调用 LiquidateSAFE 时使用的清算价格。中继器还负责存储赎回价格并使用赎回费率进行更新。
+- `GovernanceLedPriceFeedMedianizer` 和 `ChainlinkPriceFeedMedianizer` 为系统中使用的每个令牌提供新鲜的价格源。两者之间的主要区别在于，治理主导版本维护了价格源合约的白名单，由代币持有人授权（并激励）将价格推送到系统中，而 Chainlink 版本不依赖于 GEB 的治理来正常运行（除了代币持有人需要指向 Chainlink 聚合器的升级版本的情况之外）。
+- `UniswapConsecutiveSlotsPriceFeedMedianizer` 利用 Uniswap v2 基础设施来实现 TWAP，以提供价格源。它需要连接到一个单独的 oracle，以帮助将 TWAP 结果转换为另一种货币（例如美元、欧元等）。
+
+### Oracle Relayer
+
+> The glue between price feeds and the SAFE Engine
+
+OracleRelayer 作为 FSMs 和 SAFEEngine 之间的接口合约，仅存储当前的抵押品类型列表，以及当前赎回价格和赎回率。该中继器将依赖治理来设置每种抵押品的安全系数和清算比率，并可能还会依赖外部反馈机制来更新赎回率，从而影响赎回价格。
+
+#### UpdateCollateralPrice
+
+`updateCollateralPrice` 是一个公开调用的函数。该函数接受一个表示需要更新（安全和清算）价格的抵押物类型的 bytes32。updateCollateralPrice 分为三个阶段：
+
+- `getResultWithValidity` - 与抵押品类型的 orcl 进行交互，返回一个值以及它是否有效（若价格无效就返回 false 的布尔值）。如果 isValid == true，就进行第二个外部调用。
+
+- 在计算安全价格(`safetyPrice`)和清算价格(`liquidationPrice`)时，`_redemptionPrice` 是至关重要的，因为它定义了系统代币与一个单位的抵押品之间的关系。从 OSM 获取的值被*divided* 通过（已更新的）赎回价格（得到抵押品价值与系统代币的比率），然后再次被抵押品类型的 safetyCRatio (计算安全价格时）和抵押品类型的 `liquidationCRatio`（计算清算价格时）divided。
+
+- 然后调用 `cdpEngine.modifyParameters` 以更新系统内的抵押物价格。
+
+$$
+{redemptionPrice_{new}} = {redemptionPrice_{old}} \cdot {redemptionRate}^{\Delta t}
+$$
+
+```solidity
+// geb/src/single/OracleRelayer.sol
+/**
+* @notice Update the collateral price inside the system (inside SAFEEngine)
+* @param collateralType The collateral we want to update prices (safety and liquidation prices) for
+*/
+function updateCollateralPrice(bytes32 collateralType) external {
+    (uint256 priceFeedValue, bool hasValidValue) =
+        collateralTypes[collateralType].orcl.getResultWithValidity();
+    uint256 redemptionPrice_ = redemptionPrice();
+    uint256 safetyPrice_ = hasValidValue ? rdivide(rdivide(multiply(uint256(priceFeedValue), 10 ** 9), redemptionPrice_), collateralTypes[collateralType].safetyCRatio) : 0;
+    uint256 liquidationPrice_ = hasValidValue ? rdivide(rdivide(multiply(uint256(priceFeedValue), 10 ** 9), redemptionPrice_), collateralTypes[collateralType].liquidationCRatio) : 0;
+
+    safeEngine.modifyParameters(collateralType, "safetyPrice", safetyPrice_);
+    safeEngine.modifyParameters(collateralType, "liquidationPrice", liquidationPrice_);
+    emit UpdateCollateralPrice(collateralType, priceFeedValue, safetyPrice_, liquidationPrice_);
+}
+
+/**
+* @notice Fetch the latest redemption price by first updating it
+*/
+function redemptionPrice() public returns (uint256) {
+    if (now > redemptionPriceUpdateTime) return updateRedemptionPrice();
+    return _redemptionPrice;
+}
+
+/**
+* @notice Update the redemption price using the current redemption rate
+*/
+function updateRedemptionPrice() internal returns (uint256) {
+    // Update redemption price
+    _redemptionPrice = rmultiply(
+        rpower(redemptionRate, subtract(now, redemptionPriceUpdateTime), RAY),
+        _redemptionPrice
+    );
+    if (_redemptionPrice == 0) _redemptionPrice = 1;
+    redemptionPriceUpdateTime = now;
+    emit UpdateRedemptionPrice(_redemptionPrice);
+    // Return updated redemption price
+    return _redemptionPrice;
+}
+
+```
+
+## Token Module
+
+> ERC20 tokens, authority contracts and adapters for exiting and joining collateral in an out of the system
+
+- DSDelegateToken
+- Coin
+- BasicTokenAdapters
+- AdvancedTokenAdapters
+- ProtocolTokenAuthority
+- GebPrintingPermissions
+
+- 系统币（System Coin | RAI）：这是核心系统认为价值等同于其内部债务单位的代币。
+- 协议代币（Protocol Token | FLX）：一种 ds-token，继承了 UNI 和 COMP 的委派能力。它包含了销毁和授权铸造的逻辑。该代币可用于管理系统和作为资本重组的来源。
+- 协议代币授权（Protocol Token Authority）：确定谁有资格铸造和烧毁协议代币的权威合约。
+- Geb 铸造权限（Geb Printing Permissions）：允许多个债务拍卖合约铸造协议代币的权限系统。
+- 代币适配器（Token Adapters）：
+  - 抵押品适配器（Collateral Adapters）：允许任何人将抵押品进入或退出 GEB。
+  - Coin Join：用于使系统币以 ERC20 的形式退出系统，并以 SAFEEngine.coinBalance 的形式进入系统的适配器。
+
+## Money Market Module
+
+> Interest rate setters and collectors
+
+Relevant smart contracts:
+
+- TaxCollector 合约
+
+Money Market Module 包含了治理（或自治利率设定者）可用于设定和收取稳定费用的组件。
+
+## Sustainability Module
+
+> The protocol's resource management engine
+
+Relevant smart contracts:
+
+- StabilityFeeTreasury
+- FSM Wrapper
+- Increasing Treasury Reimbursement
+- Mandatory Fixed Treasury Reimbursement
+- Increasing Reward Relayer
+
+可持续性模块分配资源给那些更新关键系统组件（如预言机）的参与者，即使他们没有对协议进行治理的权限也可以执行。
+
+- StabilityFeeTreasury——此合约试图为自己保持“最佳”数量的稳定费，以确保其能向维护协议的其他合约（或某些情况下为个人）提供资金。任何人都可以定期调用功能来重新计算要保留在国库中的最佳资金金额。超过最佳值的任何剩余资金都将转移到 `extraSurplusReceiver` 中。
+- FSMWrapper —— 此合约旨在作为 FSM 类合约的资金来源，并充当允许其他合约从与包装器集成的 FSM 中读取数据的接口。
+- IncreasingTreasuryReimbursement——此合约旨在被继承并用作提供逐步增加的稳定费奖励（从 SF 国库中提取）任何人都可调用。
+- MandatoryFixedTreasuryReimbursement，旨在被继承并用作向任何地址提供固定稳定费奖励（从 SF 国库中提取）的方法。
+- IncreasingRewardRelayer，旨在从 StabilityFeeTreasury 中获取资金并将其发送到自定义地址。它继承自 IncreasingTreasuryReimbursement 合约的功能。
+
+### Stability Fee Treasury
+
+> The protocol's invoice processor
+
+StabilityFeeTreasury 旨在允许其他合约或 EOA 拉取资金（稳定费），以资助其运营。国库设置为 TaxCollector 的 secondaryReceiver。任何人都可以定期调用合约，重新计算在国库中应该保留的最佳的费用数量，并将任何额外的剩余资金发送到 extraSurplusReceiver 中。
+
+Treasury 的资金来源是稳定费，可以来自 TaxCollector 或愿意将系统代币发送到 Treasury 的任何人。治理机构也可以使用 takeFunds 将内部系统代币从源地址转移到 Treasury。
+
+治理机构负责设置授权地址，这些地址可以从 Treasury 中提取资金（如果其总额或每块津贴允许的话），同时设置 Treasury 参数以确定合约中应始终保留的资金最佳数量。我们定义“最佳”是最近一次 transferSurplusFunds 调用以来 Treasury 发生的开支的乘数（expensesMultiplier）。
+
+transferSurplusFunds 是 Treasury 重新计算其应保留储备资金的方式，并将任何剩余资金转入 extraSurplusReceiver。请注意，重新计算最佳值和从合约转移剩余款项之间存在时间延迟。
+
+发送资金到 extraSurplusReceiver 或 Treasury 本身
+
+如果治理机构想使用 giveFunds 将资金发送到 extraSurplusReceiver，则 expensesAccumulator 不会增加。如果某个地址想要 pullFunds 并将它们发送到 extraSurplusReceiver，则 pullFunds 将 revert。
+
+如果 dstAccount 是 Treasury 合约本身，则 pullFunds 将静默失败，而 giveFunds 将 revert。
+
+## Automation Module
+
+> A set of contracts in charge with automating a GEB
+
+Relevant smart contracts:
+
+- CollateralAuctionThrottler
+- SingleSpotDebtCeilingSetter
+- ESMThresholdSetter
+
+自动化模块是一套用于自动化 GEB 部署中参数设置的合约。它们旨在减轻系统管理的负担，使社区能够将精力集中于其他领域。
+
+- CollateralAuctionThrottler - 这个合约限制了任何给定时间等待通过抵押品拍卖来覆盖的坏账的数量
+
+- SingleSpotDebtCeilingSetter - 这个合约通过查看 SAFEEngine 中的当前 globalDebt 来重新计算特定抵押品类型的债务上限
+
+- ESMThresholdSSetter - 这个合约通过使用 ESM 重新计算燃烧和触发结算所需的阈值
+
+## Governance Module
+
+> Tools for achieving consensus
+
+- ​DSPause - 规定了社区投票或多签钱包交易发出和执行的 间隔时间 (delay)
+
+## Shutdown Module
+
+> Winding down system operations
+
+Shutdown Module 负责在发生严重威胁时（如长期市场失序、黑客攻击或安全漏洞），对系统进行关机处理，并将所有抵押物资退还给用户。结算可以由紧急关机模块（ESM）触发，在这种情况下，治理需要存入（并销毁）一定数量的协议代币，或者如果治理方可以直接访问 GlobalSettlement，则可以绕过 ESM 并结算系统。
+
+- GlobalSettlement-该合约关闭 GEB 并确保 SAFE 和系统代币用户收到他们应得的资产净值。硬币持有人可以赎回的抵押品价值将根据结算时系统盈余或赤字而异。有可能，硬币持有人将获得少于或多于- OracleRelayer.redemptionPrice 的抵押品价值。
+- ESM-如果足够的代币在 ESM 中存入（并随后被销毁），该合约可以触发全局结算。
diff --git a/defi/RAI/GovernanceMinimization.md b/defi/RAI/GovernanceMinimization.md
new file mode 100644
index 000000000..cc0a2b172
--- /dev/null
+++ b/defi/RAI/GovernanceMinimization.md
@@ -0,0 +1,89 @@
+# Governance Minimization
+
+最小化治理意味着在 GEB 部署过程中采取的一系列步骤，最终使治理无法控制或升级大多数核心合约，许多参数将由其他外部合约自主设置。
+
+## Requirements for Governance Minimization
+
+为了实现 GEB 的治理最小化，需要满足以下几个要求
+
+- 协议的治理不能添加或计划添加更多的抵押品种类
+- 所有治理最小化基础设施必须经过生产环境的审计和测试
+- 系统必须积累足够的盈余在其主要财政中，以承担至少 6 个月的预言机、PID、状态管理等费用
+
+## How Much Can GEB Be Governance Minimized
+
+GEB 的每个组件都有不同程度的治理最小化潜力。
+
+- Accounting Engine - 治理可能需要继续控制系统 Staking 池的设置，直到该池实现治理最小化为止；initialDebtAuctionMintedTokens 和 debtAuctionBidSize 将需要由连接到预言机的外部合约进行设置（因此该外部合约将无法完全实现治理最小化）；可选的合约可以设置 surplusBuffer，以覆盖系统货币未偿还的供应量减去来自账户引擎和稳定费用财政的盈余的特定比例；另一个外部合约应该奖励调用 popDebtFromQueue 的地址。
+
+- Liquidation Engine - 治理将保持控制连接和断开救世者的能力；治理可以选择授权外部合约自动设置 onAuctionSystemCoinLimit
+
+- Oracle Relayer - 治理可能被允许将兑换率设为 0％；除此之外，治理完全可以被移除
+
+- SAFE Engine - 治理需要允许外部合约每隔几个小时/天自动设置每种抵押品的债务上限；治理应该允许合约根据最新的赎回价格调整债务下限；取决于系统中有多少种抵押品，自动设置债务上限可能不可行，而是需要手动投票来降低/提高债务上限
+
+- Stability Fee Treasury - 治理应该长期维护这个组件
+
+- Tax Collector - 治理可以选择有限控制设置稳定费率；有限控制指的是为每种抵押品设置上限和下限，例如每年 1-2％之间；除此之外，合约可以最小化治理
+
+- PID 控制器 - 治理可能需要长期保持对该组件的一定控制；社区将在 GEB 在主网运行至少 1 年后更了解需要多少控制；保持（有限的）控制的一个原因是当系统的稳定币在交易所上没有足够的流动性时，控制器应该被暂停；注：即使治理对 PID 保持某种程度的控制，OracleRelayer 也会对赎回率设置上限和下限，以防止潜在的治理攻击立即摧毁协议
+
+...
+
+其他组件情况: <https://docs.reflexer.finance/ungovernance/governance-minimization-guide>
+
+## 自动化基础设施
+
+几个 GEB 合约需要授权其他组件在治理最小化之后自动设置其某些参数。以下是每个 GEB 合约的外部组件
+
+- 清算引擎 - 可选合约，以系统货币减去会计引擎和稳定费用库中的剩余依据为百分比自动设置 onAuctionSystemCoinLimit。
+
+- 会计引擎 - 可选合约可能会设置 surplusBuffer，以覆盖系统货币未偿还供应量的特定百分比，不包括会计引擎和稳定费用库中的剩余金还有稳定费用库/，一个强制性的合约，根据协议令牌和系统币市场价格定期设置 initialDebtAuctionMintedTokens 和 debtAuctionBidSize。
+
+- ESM - thresholdSetter，自动将 triggerThreshold 设置为当前协议令牌未偿还供应量的百分比。
+
+- Stability Fee Treasury - 治理可能需要创建外部合约，以重置具有 perBlock 津贴> 0 的地址的总津贴，并允许根据最新的赎回价格自动设置参数，例如 minimumFundsRequired， pullFundsMinThreshold 等。
+
+- SAFE Engine - 一个定期调整每种抵押品类型的债务上限的合约；另一个定期根据最新的赎回价格调整债务下限的合约；实现取决于每个 GEB 的设置（它具有多少种抵押品类型，每种抵押品应覆盖多少百分比的系统货币等）。
+
+最后，从 Stability Fee Treasury 中提取资金的合约可能需要根据最新的赎回价格定期调整其 baseUpdateCallerReward 和 maxUpdateCallerReward。
+
+## 治理最小化层次
+
+GEB（例如 RAI）将经历三个级别（或阶段）的治理最小化：
+
+### Level 1
+
+发布后 14 个月截止日期
+
+在此阶段，治理将从以下控制中删除：
+
+- LiquidationEngine
+- DebtAuctionHouse
+- SurplusAuctionHouse
+- Collateral Auction Houses
+- OracleRelayer
+- Coin (ERC20)
+- CollateralJoin contracts
+- 协议中自动设置参数的合约（除了自动剩余缓冲区设置器）
+- TaxCollector
+- ESM
+
+### Level 2
+
+发布后 18 个月的截止日期
+
+在此阶段，治理将从以下控制中删除：
+
+- SAFEEngine
+- AccountingEngine
+- GlobalSettlement
+- Lender of First Resort Pool (and adjacent contracts)
+- RAI Controller
+- ProtocolTokenAuthority（因此放弃授权/撤销授权新旧债务拍卖行打印令牌的可能性）
+- ProtocolTokenPrintingPermissions
+- Auto Surplus Buffer Setter
+
+## Level 3
+
+此时，所有剩余的治理必须由社区掌握。社区将评估完全从更多合约中删除控制的可行性（例如 PID）。
\ No newline at end of file
diff --git a/defi/RAI/PID.md b/defi/RAI/PID.md
new file mode 100644
index 000000000..aa9490b7d
--- /dev/null
+++ b/defi/RAI/PID.md
@@ -0,0 +1,180 @@
+# RAI PID
+
+relative repo:
+
+- <https://github.com/reflexer-labs/geb-rrfm-calculators>
+- <https://github.com/reflexer-labs/geb-rrfm-rate-setter>
+
+## compute redemption price rate by PID
+
+目前 RAI 使用了 P 和 I，没有使用 D
+
+$$
+\begin{align*}
+accumulatedLeak &= {perSecondCumulativeLeak}^{\Delta t} \\
+P &= redemptionPrice - marketPrice \\
+I &= accumulatedLeak \cdot I_{old} + \frac{P + P_{old}}{2} \cdot \Delta t
+\end{align*}
+$$
+
+Multiply P by Kp and I by Ki and then sum P & I in order to return the result
+
+$$
+P = P_{old} \cdot Kp \\
+I = I_{old} \cdot Ki \\
+PI = P + I
+$$
+
+If the `P * Kp + I * Ki` output breaks the noise barrier, you can recompute a non null rate. Also make sure the sum is not null
+
+如果计算出的负反馈参数绝对值需要足够大，即忽略太小的反馈参数
+
+目前线上 [PIRawPerSecondCalculator](https://etherscan.io/address/0xdda334de7a9c57a641616492175ca203ba8cf981) `noiseBarrier` 为 1， 即 `|PI| >= 0`, 不会忽略
+
+$$
+|PI| >= (2 - noiseBarrier) \cdot redemptionPrice - redemptionPrice
+$$
+
+Return a redemption rate bounded by feedbackOutputLowerBound and feedbackOutputUpperBound as well as the timeline over which that rate will take effect
+
+`getBoundedRedemptionRate()` 对 rate 做一些限制处理
+
+- `feedbackOutputLowerBound <= PI <= feedbackOutputUpperBound`
+- 目前线上 `feedbackOutputLowerBound = -999999.999999999999999999999` `feedbackOutputUpperBound = 1000000000000000000000000` 所以这个限制可以忽略
+- 如果 `PI < 0 && PI <= defaultRedemptionRate` , 则设置 `PI = NEGATIVE_RATE_LIMIT`
+  - (`defaultRedemptionRate = -1000000`, `NEGATIVE_RATE_LIMIT` 近似 1)
+- 如果 `defaultRedemptionRate < PI < 1` 则 `PI = defaultRedemptionRate - NEGATIVE_RATE_LIMIT`
+- 如果 `1 <= PI` 则 `PI = defaultRedemptionRate + PI`
+
+### 调用流程
+
+1. `PIRateSetter.updateRate()` 每隔一段时间，触发 redemption price rate 更新
+   - 该函数任何人都可以触发，并拿一点奖励补偿 gas 费用，目前设置的间隔是 12 个小时
+   - `orcl.getResultWithValidity()` 从 oracle 拿到 `MarketPrice`
+   - `oracleRelayer.redemptionPrice()` 获取之前的 `redemptionPrice`
+2. `PIRawPerSecondCalculator.computeRate()` PID 模块计算新的反馈参数
+   - `updateDeviationHistory(proportionalTerm, accumulatedLeak)`
+   - `PI = getGainAdjustedPIOutput(P, I)` 计算 PI 反馈参数
+   - `breaksNoiseBarrier()` 过滤太小的反馈参数
+   - `getBoundedRedemptionRate()` 对 PI 做一些限制
+
+```solidity
+// geb-rrfm-rate-setter/src/PIRateSetter.sol
+contract PIRateSetter {
+    function updateRate(address feeReceiver) external {
+        ...
+        // accumulatedLeak
+        uint256 iapcr      = (defaultLeak == 1) ? RAY : rpower(pidCalculator.pscl(), pidCalculator.tlv(), RAY);
+        uint256 calculated = pidCalculator.computeRate(
+            marketPrice,
+            redemptionPrice,
+            iapcr
+        );
+        // set rate
+        try setterRelayer.relayRate(calculated, feeReceiver) {
+          ...
+        }
+    }
+}
+
+// geb-rrfm-calculators/src/calculator/PIRawPerSecondCalculator.sol
+contract PIRawPerSecondCalculator is SafeMath, SignedSafeMath {
+    /*
+    * @notice Compute a new redemption rate
+    * @param marketPrice The system coin market price
+    * @param redemptionPrice The system coin redemption price
+    * @param accumulatedLeak The total leak that will be applied to priceDeviationCumulative (the integral) before the latest
+    *        proportional term is added
+    */
+    function computeRate(
+      uint marketPrice,
+      uint redemptionPrice,
+      uint accumulatedLeak
+    ) external returns (uint256) {
+        ...
+        // The proportional term is just redemption - market. Market is read as having 18 decimals so we multiply by 10**9
+        int256 proportionalTerm = subtract(int(redemptionPrice), multiply(int(marketPrice), int(10**9)));
+        // Update the integral term by passing the proportional (current deviation) and the total leak that will be applied to the integral
+        updateDeviationHistory(proportionalTerm, accumulatedLeak);
+        // Set the last update time to now
+        lastUpdateTime = now;
+        // Multiply P by Kp and I by Ki and then sum P & I in order to return the result
+        int256 piOutput = getGainAdjustedPIOutput(proportionalTerm, priceDeviationCumulative);
+        // If the P * Kp + I * Ki output breaks the noise barrier, you can recompute a non null rate. Also make sure the sum is not null
+        if (
+          breaksNoiseBarrier(absolute(piOutput), redemptionPrice) &&
+          piOutput != 0
+        ) {
+          // Get the new redemption rate by taking into account the feedbackOutputUpperBound and feedbackOutputLowerBound
+          (uint newRedemptionRate, ) = getBoundedRedemptionRate(piOutput);
+          return newRedemptionRate;
+        } else {
+          return TWENTY_SEVEN_DECIMAL_NUMBER;
+        }
+    }
+
+    /*
+    * @notice Push new observations in deviationObservations & historicalCumulativeDeviations while also updating priceDeviationCumulative
+    * @param proportionalTerm The proportionalTerm
+    * @param accumulatedLeak The total leak (similar to a negative interest rate) applied to priceDeviationCumulative before proportionalTerm is added to it
+    */
+    function updateDeviationHistory(int proportionalTerm, uint accumulatedLeak) internal {
+        (int256 virtualDeviationCumulative, ) =
+          getNextPriceDeviationCumulative(proportionalTerm, accumulatedLeak);
+        priceDeviationCumulative = virtualDeviationCumulative;
+        historicalCumulativeDeviations.push(priceDeviationCumulative);
+        deviationObservations.push(DeviationObservation(now, proportionalTerm, priceDeviationCumulative));
+    }
+
+    /*
+    * @notice Compute a new priceDeviationCumulative (integral term)
+    * @param proportionalTerm The proportional term (redemptionPrice - marketPrice)
+    * @param accumulatedLeak The total leak applied to priceDeviationCumulative before it is summed with the new time adjusted deviation
+    */
+    function getNextPriceDeviationCumulative(int proportionalTerm, uint accumulatedLeak) public isReader view returns (int256, int256) {
+        int256 lastProportionalTerm      = getLastProportionalTerm();
+        uint256 timeElapsed              = (lastUpdateTime == 0) ? 0 : subtract(now, lastUpdateTime);
+        int256 newTimeAdjustedDeviation  = multiply(riemannSum(proportionalTerm, lastProportionalTerm), int(timeElapsed));
+        int256 leakedPriceCumulative     = divide(multiply(int(accumulatedLeak), priceDeviationCumulative), int(TWENTY_SEVEN_DECIMAL_NUMBER));
+
+        return (
+          addition(leakedPriceCumulative, newTimeAdjustedDeviation),
+          newTimeAdjustedDeviation
+        );
+    }
+
+    /*
+    * @notice Return a redemption rate bounded by feedbackOutputLowerBound and feedbackOutputUpperBound as well as the
+              timeline over which that rate will take effect
+    * @param piOutput The raw redemption rate computed from the proportional and integral terms
+    */
+    function getBoundedRedemptionRate(int piOutput) public isReader view returns (uint256, uint256) {
+        int  boundedPIOutput = piOutput;
+        uint newRedemptionRate;
+
+        if (piOutput < feedbackOutputLowerBound) {
+          boundedPIOutput = feedbackOutputLowerBound;
+        } else if (piOutput > int(feedbackOutputUpperBound)) {
+          boundedPIOutput = int(feedbackOutputUpperBound);
+        }
+
+        // newRedemptionRate cannot be lower than 10^0 (1) because of the way rpower is designed
+        bool negativeOutputExceedsHundred = (boundedPIOutput < 0 && -boundedPIOutput >= int(defaultRedemptionRate));
+
+        // If it is smaller than 1, set it to the nagative rate limit
+        if (negativeOutputExceedsHundred) {
+          newRedemptionRate = NEGATIVE_RATE_LIMIT;
+        } else {
+          // If boundedPIOutput is lower than -int(NEGATIVE_RATE_LIMIT) set newRedemptionRate to 1
+          if (boundedPIOutput < 0 && boundedPIOutput <= -int(NEGATIVE_RATE_LIMIT)) {
+            newRedemptionRate = uint(addition(int(defaultRedemptionRate), -int(NEGATIVE_RATE_LIMIT)));
+          } else {
+            // Otherwise add defaultRedemptionRate and boundedPIOutput together
+            newRedemptionRate = uint(addition(int(defaultRedemptionRate), boundedPIOutput));
+          }
+        }
+
+        return (newRedemptionRate, defaultGlobalTimeline);
+    }
+}
+```
diff --git a/defi/RAI/README.md b/defi/RAI/README.md
new file mode 100644
index 000000000..1a4436081
--- /dev/null
+++ b/defi/RAI/README.md
@@ -0,0 +1,212 @@
+# RAI
+
+- whitepaper: [Rai: A Low Volatility, Trust Minimized Collateral for the DeFi Ecosystem](https://github.com/reflexer-labs/whitepapers/blob/master/English/rai-english.pdf)
+- doc: <https://docs.reflexer.finance/>
+- site: <https://reflexer.finance/>
+
+![GEB_overview](<https://1187825898-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-M9jdHretGKCtWYz5jZR%2F-MZCEBuqpWiVDbzkVeUa%2F-MZCEJv2Xvz-xIw0JAwy%2FGEB_overview%20(1).png?alt=media&token=d1233706-ec95-443b-8d45-97f973d18208>)
+
+[GEB Overview Diagram](https://viewer.diagrams.net/?target=blank&highlight=0000ff&layers=1&nav=1&title=GEB_overview.drawio#Uhttps%3A%2F%2Fdrive.google.com%2Fuc%3Fid%3D1nIcaY8N8StVCfyAL_ztbmETJX2bvY3a9%26export%3Ddownload)
+
+## 介绍
+
+1. 什么是 RAI？和 DAI 的区别是什么？
+   Reflexer 是在 2021 年推出的一款稳定币协议，RAI 是该协议的稳定币。RAI 本身由 ETH 抵押生成，但并不锚定美元或者某一特定指数，而是通过 Reflexer 特有的机制设计使得 RAI 本身的价格波动很小，从而实现“稳定币”的稳定特性。
+   RAI 本身的生成机制和 DAI 一样，都是抵押某个资产而生成。但 RAI 和 DAI 的区别主要有两点，一是 RAI 的抵押资产只能是 ETH，而 DAI 的抵押资产有好几种；二是 RAI 并不像 DAI 一样锚定美元的价值，而 RAI 的价格是浮动的，并依托市场机制的博弈使得该价格的波动性并不像风险资产（BTC/ETH/各类山寨）那样剧烈。
+   RAI 将比风险资产更稳定，但是比稳定币更波动。
+
+2. RAI 的稳定机制
+   RAI 有两个价格，一是赎回价格（redemption price），二是二级市场交易价格（market price）。RAI 会通过一个赎回比率（redemption rate）来控制赎回价格，以及控制市场价格始终围绕赎回价格来回波动。RAI 主要依赖这两类角色--SAFE users 和 holders 的博弈来改变 RAI 的供需。
+   SAFE users 是抵押 ETH 生成 RAI 的投资者，那么 RAI 就相当于 SAFE users 的负债，注意这里的负债计价采用的是赎回价格，和市场价格无关，当 SAFE users 想要还清债务时，也是按照赎回价格偿还给协议并支付一定利息；而 holders 则是通过市场价格购买 RAI 的人。
+
+### 平衡机制
+
+1. **当市场价格大于赎回价格时**
+   通过 PID 控制模块（后面展开叙述）协议将会输出一个负的赎回比率，负的赎回比率意味着 RAI 的赎回价格会不断下降。因为预期未来赎回价格会下降，就会鼓励 users 现在抵押生成更多的 RAI 然后在市场上卖掉，等到未来价格更低的时候再从市场上买回来还掉债务，这样就依靠 RAI 价格下跌赚取了收益（类似于融券做空）。而对于 holders 而言，未来赎回价格的下跌也会联动到市场价格的下跌，因此 holders 就有动机选择卖掉 RAI 以规避 RAI 价格的下跌。这两种行为都会导致市场上 RAI 供给的增加，从而使得 RAI 的市场价格逐渐下降，降到和赎回价格一致。
+2. **当市场价格小于赎回价格时**
+   协议将会输出一个正的赎回比率，正的赎回比率会导致赎回价格不断上涨，而预期到赎回价格未来会上涨，users 就从市场上购买 RAI 来尽早还清债务，否则未来再还债就会花更大的成本；holders 预期到未来价格会不断上涨，也就会更加有动力持币，甚至会吸引新的 holders 入场买 RAI。这两种行为都会导致对 RAI 的需求增大，从而导致 RAI 的价格不断上涨接近赎回价格。
+
+3. RAI 的治理机制和治理代币 FLX 的价值捕获能力
+
+RAI 采用的是双代币机制，有单独的治理代币，其治理代币是 FLX，FLX 对于 RAI 就像 MKR 对于 DAI 一样。
+
+目前 FLX 除了能参与治理以外，协议向 user 收取的利息一部分会用于回购销毁 FLX，同时协议对组建 FLX/ETH 这个 LP 也有一定的激励。
+
+## 代码
+
+## RAI 支持 LSD 的讨论
+
+<https://community.reflexer.finance/t/can-oracles-double-as-co-stakers-how-rai-like-systems-might-safely-support-staked-eth/397>
+
+## 稳定币不可能三角
+
+<https://stablecoins.wtf/resources/the-stablecoin-trillema#price-stability>
+
+与前文提到的蒙代尔的三元悖论类似，在加密世界中，也有人提出了关于加密稳定币的三元悖论，即稳定币的资本效率、价格稳定性和去中心化三者也不能同时存在。笔者认为这种分类也有一定道理，试图同时获得这三者的 ESD/BAC/UST 最终都走向了灭亡。
+
+<https://research.mintventures.fund/2023/03/10/zh-reflexer-finance-rai-non-pegged-over-colleteral-decentralized-stablecoin/>
+
+## PID
+
+1. Monetary policy and PID control: <https://www.imfs-frankfurt.de/fileadmin/user_upload/Events_2018/MMCI_Conference/Papers/09-Raymond_Hawkins-Monetary_Policy_and_PID_Control.pdf>
+2. V 神文章 : Two thought experiments to evaluate automated stablecoins
+3. RAI
+
+![controller_monitoring_small](https://reflexer-labs.github.io/geb-data-science/controller/output/controller_monitoring_small.png)
+
+RAI history 180 days
+
+redemption price 受到 market price 的反馈(p_rate, i_rate)，再影响 market price
+
+## RAI Use-Cases
+
+### Unique Money Markets
+
+如果 Alice 从货币市场借款并支付 5%的年利率来借出 RAI，而且 RAI 的赎回价格每年下降 10%，那么她实际上每年获得 5%的收益。这是因为预计 RAI 的市场价格在一年内会下降 10%。 另一方面，Bob 可能以 4%的年利率出借 RAI，但如果赎回率是-10%，他的净利率为-6%。
+
+还有另一种情况，Bob 以 4%的年利率出借 RAI，而赎回率为每年 10%。总的来说，Bob 在他的头寸上每年赚取 14%的利润（假设 RAI 在下一年中的价格会升值 10%）。同时，借用 RAI 以每年 5%的利率的 Alice 将支付总计 15%的费用（5%的货币借贷利率加上预计的一年内 RAI 价格上涨 10%）。
+
+### Stacked Funding Rates
+
+### 期权
+
+开发者可以构建一个期权协议，考虑到赎回利率的变化来确定看涨/看跌期权的价格。这是因为赎回利率可以被认为是 RAI 的内在利率。
+
+### Pegged Coins/Synthetic Assets
+
+构建固定货币的项目可以使用 RAI 作为 ETH 的更稳定的替代品。在 ETH 市场严重崩溃的情况下，RAI 可以为其持有者提供更多时间解除其仓位，然后再进行清算。
+
+### Yield Aggregator
+
+部署资本以为用户获得最佳收益的协议（例如 Yearn）可以利用 RAI（及其内在的赎回利率）来提高收益。例如，将 RAI 的正赎回利率与在 Compound 或 Aave 上的借贷相结合，是一种优化收益的可能方式。
+
+### Sophisticated Arbitrageurs
+
+套利者（或其他交易者）可以查看赎回价格行为并将此数据点与其他数据（例如市场情绪）相结合，以找到执行交易的理想时间。
+
+一些套利商可以向资本池提供专门的 RAI 交易服务。他们可以借用资金，并与资本池分成利润。
+
+### Portfolio Management Strategies
+
+## Governance Minimization
+
+最小化治理意味着在 GEB 部署过程中采取的一系列步骤，最终使治理无法控制或升级大多数核心合约，许多参数将由其他外部合约自主设置。
+
+[Governance Minimization.md](./GovernanceMinimization.md)
+
+## GEB
+
+GEB 协议的核心仓库，是 MCD(MakerDAO-dss)的修改版，具有几个核心的改进：
+
+- 可以理解的变量名称
+- 自主反馈机制，改变系统参与者的激励
+- 可添加 SAFE 保险
+- 固定和递增的折扣拍卖（而不是英国式拍卖）用于出售抵押品
+- 自动调整系统中的几个参数
+- 一组合约，约束了长期治理的参数控制
+- 可以一次将稳定费用发送到多个地址
+- 可以在盈余拍卖和其他类型的策略之间切换，以删除系统中的盈余
+- 每种抵押品类型有两个价格：一个用于生成债务，另一个专门用于清算 SAFE
+- stability fee treasury 可以支付 Oracle 调用或其他自动化系统的 gas 费用
+
+## FLX
+
+FLX token 在 RAI 协议中有两个主要功能：
+
+- 后备机制：FLX 股东是 RAI 协议出现问题时的第一道防线。第二道防线是通过债务拍卖市场发行新的 FLX 代币，以 RAI 代币为交换获取这些新的 FLX 代币。
+- 取消治理：一旦治理最小化完成，FLX 持有人将能够从 RAI 中移除任何剩余的治理组件，或者如果需要的话，继续管理可能难以取得治理的组件（例如预言机或与其他协议交互的任何组件）。
+
+在协议最小化治理之前，RAI 将设置三种手续费（向借款人收取的稳定费率）：
+
+1. stability fee treasury，这是智能合约，负责支付 Oracle 更新或任何其他旨在自动化 RAI 参数的合约。
+2. FLX 持有人，这是协议的第一道防线。
+3. 回购和销毁，旨在通过以 RAI 代币交换 FLX 代币并随后销毁 FLX 代币来拍卖 RAI 代币。
+
+对于 FLX 持有人而言，为其所产生的 RAI 代币将以 FLX 代币的形式进行拍卖。拍卖所得的 FLX 代币将随后发送到股权池。
+
+至于回购和销毁，则首先在协议的资产负债表中累积 RAI 代币。一旦资产负债表中的 RAI 代币足够多，协议就可以开始拍卖一些 RAI 代币，以换取随后销毁的 FLX 代币。
+
+为了更直观地理解这些信息，您可以查看下面的图表：
+
+![visualize](https://1187825898-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-M9jdHretGKCtWYz5jZR%2F-MgQYhDfSPb3lErtlIOO%2F-MgQbThRT20MvC16AqVK%2FUntitled%20Diagram.png?alt=media&token=104fb695-efee-4d5c-8a67-9079a9e6a662)
+
+## Addresses
+
+```json
+// geb-subgraph/config/main.json
+
+{
+  "NETWORK": "mainnet",
+  "PROXY_REGISTRY_STARTING_BLOCK": "5834628",
+  "ETH_FROM": "0x7FAfc11677649DB6AbFEC127B4B776D585520ae1",
+  "STARTING_BLOCK_NUMBER": "11848304",
+  "PROXY_DEPLOYER": "0x631e38D6Dc0F4A26F6BE0d3d0E4ebA3d02033aB4",
+  "COIN_TYPE": "INDEX",
+  "GOVERNANCE_TYPE": "MULTISIG-SAFE",
+  "MULTICALL": "0x51812e07497586ce025D798Bb44b6d11bBEe3a01",
+  "FAUCET": "0x0000000000000000000000000000000000000000",
+  "GEB_MULTISIG": "0x427A277eA53e25143B3b509C684aA4D0EB8bA01b",
+  "GEB_MULTISIG_PROXY": "0x2695b1dC32899c07d177A287f006b6569216a5a1",
+  "GEB_DEPLOY": "0x24AcC85528e6dd5B9C297fb8821522D36B1Ae09f",
+  "GEB_PROT": "0x6243d8CEA23066d098a15582d81a598b4e8391F4",
+  "PROTOCOL_TOKEN_AUTHORITY": "0xcb8479840A5576B1cafBb3FA7276e04Df122FDc7",
+  "GEB_PAUSE_AUTHORITY": "0x1490a828957f1E23491c8d69273d684B15c6E25A",
+  "GEB_POLLING_EMITTER": "0xf7Da963B88194a9bc6775e93d39c70c6e3f04f6F",
+  "GEB_SAFE_ENGINE": "0xCC88a9d330da1133Df3A7bD823B95e52511A6962",
+  "GEB_TAX_COLLECTOR": "0xcDB05aEda142a1B0D6044C09C64e4226c1a281EB",
+  "GEB_LIQUIDATION_ENGINE": "0x4fFbAA89d648079Faafc7852dE49EA1dc92f9976",
+  "GEB_ACCOUNTING_ENGINE": "0xcEe6Aa1aB47d0Fb0f24f51A3072EC16E20F90fcE",
+  "GEB_COIN_JOIN": "0x0A5653CCa4DB1B6E265F47CAf6969e64f1CFdC45",
+  "GEB_SURPLUS_AUCTION_HOUSE": "0x4EEfDaE928ca97817302242a851f317Be1B85C90",
+  "GEB_DEBT_AUCTION_HOUSE": "0x1896adBE708bF91158748B3F33738Ba497A69e8f",
+  "GEB_PAUSE": "0x2cDE6A1147B0EE61726b86d83Fd548401B1162c7",
+  "GEB_PAUSE_PROXY": "0xa57A4e6170930ac547C147CdF26aE4682FA8262E",
+  "GEB_GOV_ACTIONS": "0x0463bF18c2457B00402A7639fa1DFB7d60f659Ee",
+  "GEB_COIN": "0x03ab458634910AaD20eF5f1C8ee96F1D6ac54919",
+  "GEB_ORACLE_RELAYER": "0x4ed9C0dCa0479bC64d8f4EB3007126D5791f7851",
+  "GEB_GLOBAL_SETTLEMENT": "0xee4cf96e5359d9619197fd82b6ef2a9eae7b91e1",
+  "GEB_STABILITY_FEE_TREASURY": "0x83533fdd3285f48204215E9CF38C785371258E76",
+  "GEB_ESM": "0xa33Ea2Ac39902d4A206D6A1F8D38c7330C80f094",
+  "GEB_ESM_TOKEN_BURNER": "0xB10409FC293F987841964C4FcFEf887D9ece799B",
+  "GEB_RRFM_CALCULATOR": "0xddA334de7A9C57A641616492175ca203Ba8Cf981",
+  "GEB_DUMMY_RRFM_CALCULATOR": "0x9F02ddBFb4B045Df83D45c4d644027FBD7d72A6D",
+  "GEB_RRFM_SETTER": "0x7acfc14dbf2decd1c9213db32ae7784626daeb48",
+  "PROXY_ACTIONS": "0x880CECbC56F48bCE5E0eF4070017C0a4270F64Ed",
+  "PROXY_ACTIONS_INCENTIVES": "0x88A77b8Ff53329f88B8B6F9e29835FEc287349e0",
+  "PROXY_ACTIONS_GLOBAL_SETTLEMENT": "0x17b5d9914194a08c7Ef14451BA15E8aE4f92Cb93",
+  "PROXY_DEBT_AUCTION_ACTIONS": "0x3615A303674eC8bC0432f7e1BE8449A63a19d6Ef",
+  "PROXY_SURPLUS_AUCTION_ACTIONS": "0x16B0BF0Bf031A3691f4bD600e5340fEDd149C0ED",
+  "SAFE_MANAGER": "0xEfe0B4cA532769a3AE758fD82E1426a03A94F185",
+  "GET_SAFES": "0xdf4BC9aA98cC8eCd90Ba2BEe73aD4a1a9C8d202B",
+  "FSM_GOV_INTERFACE": "0xe24F8B30fd28c90462c9BbC87A9A2a823636F533",
+  "PROXY_FACTORY": "0xA26e15C895EFc0616177B7c1e7270A4C7D51C997",
+  "PROXY_REGISTRY": "0x4678f0a6958e4D2Bc4F1BAF7Bc52E8F3564f3fE4",
+  "MEDIANIZER_RAI": "0x92dC9b16be52De059279916c1eF810877f85F960",
+  "SPOT_RAI": "0x7235a0094eD56eB2Bd0de168d307C8990233645f",
+  "SPOT_FEED_SECURITY_MODULE_RAI": "0x0000000000000000000000000000000000000000",
+  "ETH": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+  "MEDIANIZER_ETH": "0xb825e25856bD98b3f2FAF2aEb6Cb8742B38C4025",
+  "FEED_SECURITY_MODULE_ETH": "0xD4A0E3EC2A937E7CCa4A192756a8439A8BF4bA91",
+  "GEB_JOIN_ETH_A": "0x2D3cD7b81c93f188F3CB8aD87c8Acc73d6226e3A",
+  "GEB_COLLATERAL_AUCTION_HOUSE_ETH_A": "0x7fFdF1Dfef2bfeE32054C8E922959fB235679aDE",
+  "PROXY_PAUSE_ACTIONS": "0x27a54e99dE813CE2E41BAa7F44d1F19FBA22B36D",
+  "PROXY_PAUSE_SCHEDULE_ACTIONS": "0x6a2714404Be6613A952A80266840ffe916194632",
+  "GEB_INCENTIVES_MINER": "0xa706d4c39c315288113020f3e2D7e1095e912a20",
+  "UNISWAP_FACTORY": "0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f",
+  "UNISWAP_ROUTER": "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",
+  "GEB_DS_COMPARE": "0x10122261ff9520C590c0c3A679b7E3dFC8B09C64",
+  "GEB_TX_MANAGER": "0xB7272627825D1cb633f705BC269F8e11126D7A25",
+  "GEB_COIN_UNISWAP_POOL": "0x8aE720a71622e824F576b4A8C03031066548A3B1",
+  "GEB_SINGLE_CEILING_SETTER": "0x54999Ee378b339f405a4a8a1c2f7722CD25960fa",
+  "CHAINLINK_AGGREGATOR": "0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419",
+  "GEB_STAKING_AUCTION_HOUSE": "0x0000000000000000000000000000000000000000"
+}
+```
+
+## 参考链接
+
+- Stability without Pegs: <https://medium.com/reflexer-labs/stability-without-pegs-8c6a1cbc7fbd>
+- 视频解析: <https://www.youtube.com/watch?v=ADK91Zw4sJA&list=PL-GxJch-YeZerVVV8dY8qU2VkJfbnSfdN&index=3>
+- tokenengineeringcommunity: <https://tokenengineeringcommunity.github.io/website/>
+- RAI--升级版的 DAI？ <https://mirror.xyz/0x4011631B550E4c5C105FE90c2b7f03Fdbd344454/Bumv5mmOt8Sj85IpcGGMJvox4XLdrH0ce-4CJS_Wd6o>
+- 基于 BTC 的稳定币：<https://cryptohayes.medium.com/dust-on-crust-300d4b5cf3ec>
diff --git a/defi/RAI/readme.md b/defi/RAI/readme.md
deleted file mode 100644
index c8627407b..000000000
--- a/defi/RAI/readme.md
+++ /dev/null
@@ -1,46 +0,0 @@
-# RAI
-
-
-## 介绍
-1. 什么是RAI？和DAI的区别是什么？
-Reflexer是在2021年推出的一款稳定币协议，RAI是该协议的稳定币。RAI本身由ETH抵押生成，但并不锚定美元或者某一特定指数，而是通过Reflexer特有的机制设计使得RAI本身的价格波动很小，从而实现“稳定币”的稳定特性。
-RAI本身的生成机制和DAI一样，都是抵押某个资产而生成。但RAI和DAI的区别主要有两点，一是RAI的抵押资产只能是ETH，而DAI的抵押资产有好几种；二是RAI并不像DAI一样锚定美元的价值，而RAI的价格是浮动的，并依托市场机制的博弈使得该价格的波动性并不像风险资产（BTC/ETH/各类山寨）那样剧烈。
-RAI将比风险资产更稳定，但是比稳定币更波动。
-
-2. RAI的稳定机制
-RAI有两个价格，一是赎回价格（redemption price），二是二级市场交易价格（market price）。RAI会通过一个赎回比率（redemption rate）来控制赎回价格，以及控制市场价格始终围绕赎回价格来回波动。RAI主要依赖这两类角色--SAFE users和holders的博弈来改变RAI的供需。
-SAFE users是抵押ETH生成RAI的投资者，那么RAI就相当于SAFE users的负债，注意这里的负债计价采用的是赎回价格，和市场价格无关，当SAFE users想要还清债务时，也是按照赎回价格偿还给协议并支付一定利息；而holders则是通过市场价格购买RAI的人。
-
-**平衡机制**
-1. **当市场价格大于赎回价格时**
-通过PID控制模块（后面展开叙述）协议将会输出一个负的赎回比率，负的赎回比率意味着RAI的赎回价格会不断下降。因为预期未来赎回价格会下降，就会鼓励users现在抵押生成更多的RAI然后在市场上卖掉，等到未来价格更低的时候再从市场上买回来还掉债务，这样就依靠RAI价格下跌赚取了收益（类似于融券做空）。而对于holders而言，未来赎回价格的下跌也会联动到市场价格的下跌，因此holders就有动机选择卖掉RAI以规避RAI价格的下跌。这两种行为都会导致市场上RAI供给的增加，从而使得RAI的市场价格逐渐下降，降到和赎回价格一致。
-2. **当市场价格小于赎回价格时**
-协议将会输出一个正的赎回比率，正的赎回比率会导致赎回价格不断上涨，而预期到赎回价格未来会上涨，users就从市场上购买RAI来尽早还清债务，否则未来再还债就会花更大的成本；holders预期到未来价格会不断上涨，也就会更加有动力持币，甚至会吸引新的holders入场买RAI。这两种行为都会导致对RAI的需求增大，从而导致RAI的价格不断上涨接近赎回价格。
-
-3. RAI的治理机制和治理代币FLX的价值捕获能力
-
-RAI采用的是双代币机制，有单独的治理代币，其治理代币是FLX，FLX对于RAI就像MKR对于DAI一样。
-
-目前FLX除了能参与治理以外，协议向user收取的利息一部分会用于回购销毁FLX，同时协议对组建FLX/ETH这个LP也有一定的激励。
-## PID
-1. Monetary policy and PID control: https://www.imfs-frankfurt.de/fileadmin/user_upload/Events_2018/MMCI_Conference/Papers/09-Raymond_Hawkins-Monetary_Policy_and_PID_Control.pdf
-2. V神文章 :  Two thought experiments to evaluate automated stablecoins
-3. RAI
-
-## 代码
-
-## RAI支持LSD的讨论
-https://community.reflexer.finance/t/can-oracles-double-as-co-stakers-how-rai-like-systems-might-safely-support-staked-eth/397
-
-## 稳定币不可能三角：
-https://stablecoins.wtf/resources/the-stablecoin-trillema#price-stability
-与前文提到的蒙代尔的三元悖论类似，在加密世界中，也有人提出了关于加密稳定币的三元悖论，即稳定币的资本效率、价格稳定性和去中心化三者也不能同时存在。笔者认为这种分类也有一定道理，试图同时获得这三者的ESD/BAC/UST最终都走向了灭亡。
-
-https://research.mintventures.fund/2023/03/10/zh-reflexer-finance-rai-non-pegged-over-colleteral-decentralized-stablecoin/
-
-
-## 参考链接
-- 视频解析: https://www.youtube.com/watch?v=ADK91Zw4sJA&list=PL-GxJch-YeZerVVV8dY8qU2VkJfbnSfdN&index=3
-- tokenengineeringcommunity: https://tokenengineeringcommunity.github.io/website/
-- RAI--升级版的DAI？ https://mirror.xyz/0x4011631B550E4c5C105FE90c2b7f03Fdbd344454/Bumv5mmOt8Sj85IpcGGMJvox4XLdrH0ce-4CJS_Wd6o
-- 基于BTC的稳定币：https://cryptohayes.medium.com/dust-on-crust-300d4b5cf3ec
\ No newline at end of file