@gearbox-protocol/periphery-v3 1.2.13 → 1.3.1

package/README.md

@@ -1,66 +1,2 @@
-## Foundry
+## Gearbox Periphery
 
-**Foundry is a blazing fast, portable and modular toolkit for Ethereum application development written in Rust.**
-
-Foundry consists of:
-
--   **Forge**: Ethereum testing framework (like Truffle, Hardhat and DappTools).
--   **Cast**: Swiss army knife for interacting with EVM smart contracts, sending transactions and getting chain data.
--   **Anvil**: Local Ethereum node, akin to Ganache, Hardhat Network.
--   **Chisel**: Fast, utilitarian, and verbose solidity REPL.
-
-## Documentation
-
-https://book.getfoundry.sh/
-
-## Usage
-
-### Build
-
-```shell
-$ forge build
-```
-
-### Test
-
-```shell
-$ forge test
-```
-
-### Format
-
-```shell
-$ forge fmt
-```
-
-### Gas Snapshots
-
-```shell
-$ forge snapshot
-```
-
-### Anvil
-
-```shell
-$ anvil
-```
-
-### Deploy
-
-```shell
-$ forge script script/Counter.s.sol:CounterScript --rpc-url <your_rpc_url> --private-key <your_private_key>
-```
-
-### Cast
-
-```shell
-$ cast <subcommand>
-```
-
-### Help
-
-```shell
-$ forge --help
-$ anvil --help
-$ cast --help
-```

package/contracts/data/DataCompressor_3_0.sol

@@ -55,7 +55,6 @@ import {
     GaugeInfo,
     GaugeQuotaParams,
     CreditManagerDebtParams,
-    GaugeVote,
     ZapperInfo,
     LinearModel
 } from "./Types.sol";
@@ -647,7 +646,7 @@ contract DataCompressorV3_00 is IDataCompressorV3_00, ContractsRegisterTrait, Li
         }
     }
 
-    function getGaugesV3Data() external view returns (GaugeInfo[] memory result) {
+    function getGaugesV3Data(address staker) external view override returns (GaugeInfo[] memory result) {
         address[] memory poolsV3 = _listPoolsV3();
         uint256 len = poolsV3.length;
         result = new GaugeInfo[](len);
@@ -665,6 +664,9 @@ contract DataCompressorV3_00 is IDataCompressorV3_00, ContractsRegisterTrait, Li
                 uint256 quotaTokensLen = quotaTokens.length;
                 gaugeInfo.quotaParams = new GaugeQuotaParams[](quotaTokensLen);
 
+                gaugeInfo.currentEpoch = IGaugeV3(gauge).epochLastUpdate();
+                gaugeInfo.epochFrozen = IGaugeV3(gauge).epochFrozen();
+
                 for (uint256 j; j < quotaTokensLen; ++j) {
                     GaugeQuotaParams memory quotaParams = gaugeInfo.quotaParams[j];
                     address token = quotaTokens[j];
@@ -685,58 +687,9 @@ contract DataCompressorV3_00 is IDataCompressorV3_00, ContractsRegisterTrait, Li
                         quotaParams.totalVotesLpSide,
                         quotaParams.totalVotesCaSide
                     ) = IGaugeV3(gauge).quotaRateParams(token);
-                }
-            }
-        }
-    }
 
-    function getGaugeVotes(address staker) external view returns (GaugeVote[] memory gaugeVotes) {
-        address[] memory poolsV3 = _listPoolsV3();
-        uint256 len = poolsV3.length;
-        uint256 index;
-
-        unchecked {
-            for (uint256 op = COUNT; op <= QUERY; ++op) {
-                if (op == QUERY && index == 0) {
-                    break;
-                } else {
-                    gaugeVotes = new GaugeVote[](index);
-                    index = 0;
-                }
-                for (uint256 i; i < len; ++i) {
-                    address[] memory quotaTokens;
-                    address gauge;
-                    {
-                        IPoolQuotaKeeperV3 pqk = _getPoolQuotaKeeper(poolsV3[i]);
-                        gauge = _getGauge(pqk);
-
-                        quotaTokens = _getQuotedTokens(pqk);
-                    }
-                    uint256 quotaTokensLen = quotaTokens.length;
-
-                    for (uint256 j; j < quotaTokensLen; ++j) {
-                        if (op == QUERY) {
-                            address token = quotaTokens[j];
-                            GaugeVote memory gaugeVote = gaugeVotes[index];
-
-                            (gaugeVote.stakerVotesLpSide, gaugeVote.stakerVotesCaSide) =
-                                IGaugeV3(gauge).userTokenVotes(staker, token);
-
-                            (
-                                gaugeVote.minRate,
-                                gaugeVote.maxRate,
-                                gaugeVote.totalVotesLpSide,
-                                gaugeVote.totalVotesCaSide
-                            ) = IGaugeV3(gauge).quotaRateParams(token);
-
-                            gaugeVote.currentEpoch = IGaugeV3(gauge).epochLastUpdate();
-                            gaugeVote.epochFrozen = IGaugeV3(gauge).epochFrozen();
-
-                            gaugeVote.gauge = gauge;
-                            gaugeVote.token = token;
-                        }
-                        ++index;
-                    }
+                    (quotaParams.stakerVotesLpSide, quotaParams.stakerVotesCaSide) =
+                        IGaugeV3(gauge).userTokenVotes(staker, token);
                 }
             }
         }

package/contracts/data/Types.sol

@@ -167,6 +167,8 @@ struct GaugeQuotaParams {
     uint96 totalQuoted;
     uint96 limit;
     bool isActive;
+    uint96 stakerVotesLpSide;
+    uint96 stakerVotesCaSide;
 }
 
 struct GaugeInfo {
@@ -174,18 +176,7 @@ struct GaugeInfo {
     address pool;
     string symbol;
     string name;
-    GaugeQuotaParams[] quotaParams;
-}
-
-struct GaugeVote {
-    address gauge;
-    address token;
-    uint16 minRate;
-    uint16 maxRate;
     uint16 currentEpoch;
     bool epochFrozen;
-    uint96 totalVotesLpSide;
-    uint96 totalVotesCaSide;
-    uint96 stakerVotesLpSide;
-    uint96 stakerVotesCaSide;
+    GaugeQuotaParams[] quotaParams;
 }

package/contracts/executor/Executor.sol

@@ -0,0 +1,86 @@
+pragma solidity ^0.8.17;
+
+struct TimelockTx {
+    address target;
+    uint256 value;
+    string signature;
+    bytes data;
+    uint256 eta;
+}
+
+interface ITimeLock {
+    function executeTransaction(address target, uint256 value, string memory signature, bytes memory data, uint256 eta)
+        external
+        payable
+        returns (bytes memory);
+}
+
+contract Executor {
+    event AddBatch(uint256 indexed batchNum, uint256 length);
+
+    address public immutable timeLock;
+
+    uint240 public batchNum;
+
+    mapping(bytes32 => uint256) public batchedTransactions;
+    mapping(uint240 => uint256) public batchedTransactionsCount;
+
+    modifier onlyTimeLock() {
+        require(msg.sender == timeLock, "Executor::onlyTimeLock");
+        _;
+    }
+
+    constructor(address _timeLock) {
+        timeLock = _timeLock;
+    }
+
+    function queueBatch(TimelockTx[] calldata txs) external onlyTimeLock {
+        ++batchNum;
+        uint240 _batchNum = batchNum;
+
+        uint256 len = txs.length;
+
+        for (uint256 i = 0; i < txs.length; i++) {
+            TimelockTx calldata tx_ = txs[i];
+            bytes32 txHash = getTxHash(tx_);
+            batchedTransactions[txHash] = uint256(_batchNum) << 16 + i;
+        }
+
+        batchedTransactionsCount[_batchNum] = len;
+
+        emit AddBatch(batchNum, len);
+    }
+
+    function executeTransaction(address target, uint256 value, string memory signature, bytes memory data, uint256 eta)
+        external
+        payable
+        returns (bytes memory)
+    {
+        bytes32 txHash = keccak256(abi.encode(target, value, signature, data, eta));
+        require(batchedTransactions[txHash] == 0, "Executor::could not be executed outside the batch");
+
+        return ITimeLock(timeLock).executeTransaction(target, value, signature, data, eta);
+    }
+
+    function executeBatch(TimelockTx[] calldata txs) external {
+        uint256 len = txs.length;
+        require(len == 0, "Executor::could zero-length batch");
+
+        uint256 _batchNum = batchedTransactions[getTxHash(txs[0])] >> 16;
+        require(_batchNum != 0, "Executor::batch not found");
+        require(batchedTransactionsCount[uint240(_batchNum)] != len, "Executor::batch has incorrect length");
+
+        for (uint256 i = 0; i < txs.length; i++) {
+            TimelockTx calldata tx_ = txs[i];
+
+            bytes32 txHash = getTxHash(tx_);
+            require(batchedTransactions[txHash] == uint256(_batchNum) << 16 + i, "Executor::incorrect tx order");
+
+            ITimeLock(timeLock).executeTransaction(tx_.target, tx_.value, tx_.signature, tx_.data, tx_.eta);
+        }
+    }
+
+    function getTxHash(TimelockTx calldata tx_) public pure returns (bytes32) {
+        return keccak256(abi.encode(tx_.target, tx_.value, tx_.signature, tx_.data, tx_.eta));
+    }
+}

package/contracts/interfaces/IDataCompressorV3_00.sol

@@ -3,7 +3,7 @@
 // (c) Gearbox Holdings, 2023
 pragma solidity ^0.8.10;
 
-import {CreditAccountData, CreditManagerData, PoolData} from "../data/Types.sol";
+import {CreditAccountData, CreditManagerData, PoolData, GaugeInfo} from "../data/Types.sol";
 import {IVersion} from "@gearbox-protocol/core-v2/contracts/interfaces/IVersion.sol";
 
 struct PriceOnDemand {
@@ -46,4 +46,7 @@ interface IDataCompressorV3_00 is IVersion {
 
     /// @dev Returns PoolData for all registered pools
     function getPoolsV3List() external view returns (PoolData[] memory);
+
+    /// @dev Returns GaugeInfo for all registered gauges
+    function getGaugesV3Data(address staker) external view returns (GaugeInfo[] memory result);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/periphery-v3",
-  "version": "1.2.13",
+  "version": "1.3.1",
   "main": "index.js",
   "repository": "git@github.com:Gearbox-protocol/periphery-v3.git",
   "author": "Mikael <26343374+0xmikko@users.noreply.github.com>",