Lineage extension

protocol/README.md

@@ -51,9 +51,13 @@ _Note: The Beanstalk repo is a monorepo with induvidual projects inside it. See
 
 1. Clone the repository and install dependencies
 
+*If using Mac on Apple Silicon*
+`/usr/sbin/softwareupdate --install-rosetta --agree-to-license`
+
 ```bash
 git clone https://github.com/BeanstalkFarms/Beanstalk
 cd Beanstalk/protocol
+export YARN_IGNORE_NODE=1
 yarn
 ```
 

protocol/contracts/beanstalk/ForkSystem/TransmitInFacet.sol

@@ -0,0 +1,38 @@
+/**
+ * SPDX-License-Identifier: MIT
+ **/
+
+pragma solidity ^0.8.20;
+
+import {AppStorage} from "contracts/beanstalk/storage/AppStorage.sol";
+import {Invariable} from "contracts/beanstalk/Invariable.sol";
+import {LibTransmitIn} from "contracts/libraries/ForkSystem/LibTransmitIn.sol";
+
+/**
+ * @title TransmitInFacet
+ * @author funderbrker
+ * @notice Destination instance logic for receiving transmitted assets from another version.
+ * @notice Destination has knowledge of valid Sources and their configurations at deployment time.
+ **/
+contract TransmitInFacet is Invariable {
+    AppStorage internal s;
+
+    /**
+     * @notice Process the inbound migration locally.
+     * @dev Reverts if failure to mint assets or handle migration in.
+     * @dev Arguments are bytes because different sources may use different encodings.
+     */
+    function transmitIn(
+        address user,
+        bytes[] calldata deposits,
+        bytes[] calldata plots,
+        bytes[] calldata fertilizer,
+        bytes calldata // data
+    ) external fundsSafu {
+        require(s.sys.supportedSourceForks[msg.sender], "Unsupported source");
+
+        LibTransmitIn.transmitInDeposits(user, deposits);
+        LibTransmitIn.transmitInPlots(user, plots);
+        LibTransmitIn.transmitInFertilizer(user, fertilizer);
+    }
+}

protocol/contracts/beanstalk/ForkSystem/TransmitOutFacet.sol

@@ -0,0 +1,50 @@
+/**
+ * SPDX-License-Identifier: MIT
+ **/
+
+pragma solidity ^0.8.20;
+
+import {Invariable} from "contracts/beanstalk/Invariable.sol";
+import {LibTractor} from "contracts/libraries/LibTractor.sol";
+import {LibTransmitOut} from "contracts/libraries/ForkSystem/LibTransmitOut.sol";
+import {ITransmitInFacet} from "contracts/interfaces/ITransmitInFacet.sol";
+
+/**
+ * @title TransmitOutFacet
+ * @author funderbrker
+ * @notice Source instance logic for migrating assets to new version.
+ * @notice Source instance has no knowledge of possible Destinations or their configurations.
+ **/
+contract TransmitOutFacet is Invariable {
+    /**
+     * @notice Process the outbound migration and transfer necessary assets to destination.
+     * @dev Reverts if failure to burn assets or destination fails.
+     */
+    function transmitOut(
+        address destination,
+        LibTransmitOut.SourceDeposit[] calldata sourceDeposits,
+        LibTransmitOut.SourcePlot[] calldata sourcePlots,
+        LibTransmitOut.SourceFertilizer[] calldata sourceFertilizer,
+        bytes calldata // data
+    ) external fundsSafu {
+        bytes[] memory deposits = LibTransmitOut.transmitOutDeposits(
+            LibTractor._user(),
+            destination,
+            sourceDeposits
+        );
+        bytes[] memory plots = LibTransmitOut.transmitOutPlots(LibTractor._user(), sourcePlots);
+        bytes[] memory fertilizer = LibTransmitOut.transmitOutFertilizer(
+            LibTractor._user(),
+            sourceFertilizer
+        );
+
+        // Reverts if Destination fails to handle transmitted assets.
+        ITransmitInFacet(destination).transmitIn(
+            LibTractor._user(),
+            deposits,
+            plots,
+            fertilizer,
+            abi.encode("")
+        );
+    }
+}

protocol/contracts/beanstalk/Invariable.sol

@@ -186,7 +186,7 @@ abstract contract Invariable {
                         s.sys.fert.leftoverBeans) + // unrinsed rinsable beans
                     s.sys.silo.unripeSettings[C.UNRIPE_BEAN].balanceOfUnderlying; // unchopped underlying beans
                 for (uint256 j; j < s.sys.fieldCount; j++) {
-                    entitlements[i] += (s.sys.fields[j].harvestable - s.sys.fields[j].harvested); // unharvested harvestable beans
+                    entitlements[i] += (s.sys.fields[j].harvestable - s.sys.fields[j].processed); // unharvested harvestable beans
                 }
             } else if (tokens[i] == LibUnripe._getUnderlyingToken(C.UNRIPE_LP)) {
                 entitlements[i] += s.sys.silo.unripeSettings[C.UNRIPE_LP].balanceOfUnderlying;

protocol/contracts/beanstalk/barn/FertilizerFacet.sol

@@ -48,9 +48,7 @@ contract FertilizerFacet is Invariable {
         uint256[] calldata ids,
         LibTransfer.To mode
     ) external payable fundsSafu noSupplyChange oneOutFlow(C.BEAN) {
-        uint256 amount = C.fertilizer().beanstalkUpdate(LibTractor._user(), ids, s.sys.fert.bpf);
-        s.sys.fert.fertilizedPaidIndex += amount;
-        LibTransfer.sendToken(C.bean(), amount, LibTractor._user(), mode);
+        LibFertilizer.claimFertilized(ids, mode);
     }
 
     /**

protocol/contracts/beanstalk/field/FieldFacet.sol

@@ -16,6 +16,8 @@ import {ReentrancyGuard} from "../ReentrancyGuard.sol";
 import {Invariable} from "contracts/beanstalk/Invariable.sol";
 import {LibDiamond} from "contracts/libraries/LibDiamond.sol";
 import {LibMarket} from "contracts/libraries/LibMarket.sol";
+import {LibField} from "contracts/libraries/LibField.sol";
+
 
 interface IBeanstalk {
     function cancelPodListing(uint256 fieldId, uint256 index) external;
@@ -156,6 +158,7 @@ contract FieldFacet is Invariable, ReentrancyGuard {
      *
      * Pods are "burned" when the corresponding Plot is deleted from
      * `s.accts[account].fields[fieldId].plots`.
+     * @dev If Plot has been Slashed, burn the Plot. Anyone can burn Slashed Plots.
      */
     function harvest(
         uint256 fieldId,
@@ -169,6 +172,7 @@ contract FieldFacet is Invariable, ReentrancyGuard {
     /**
      * @dev Ensure that each Plot is at least partially harvestable, burn the Plot,
      * update the total harvested, and emit a {Harvest} event.
+     * @dev If Plot has been Slashed, burn the Plot.
      */
     function _harvest(
         uint256 fieldId,
@@ -181,20 +185,24 @@ contract FieldFacet is Invariable, ReentrancyGuard {
             uint256 harvested = _harvestPlot(LibTractor._user(), fieldId, plots[i]);
             beansHarvested += harvested;
         }
-        s.sys.fields[fieldId].harvested += beansHarvested;
+        s.sys.fields[fieldId].processed += beansHarvested;
         emit Harvest(LibTractor._user(), fieldId, plots, beansHarvested);
     }
 
     /**
      * @dev Check if a Plot is at least partially Harvestable; calculate how many
      * Pods are Harvestable, create a new Plot if necessary.
+     * @dev If Plot has been Slashed, burn the Plot.
      */
     function _harvestPlot(
         address account,
         uint256 fieldId,
         uint256 index
     ) private returns (uint256 harvestablePods) {
-        // Check that `account` holds this Plot.
+        // If Plot held by null address, it has been Slashed. Burn Plot.
+        if (s.accts[address(0)].fields[fieldId].plots[index] > 0) {
+            account = address(0);
+        }
         uint256 pods = s.accts[account].fields[fieldId].plots[index];
         require(pods > 0, "Field: no plot");
 
@@ -203,10 +211,14 @@ contract FieldFacet is Invariable, ReentrancyGuard {
         // are harvestable.
         harvestablePods = s.sys.fields[fieldId].harvestable.sub(index);
 
-        LibMarket._cancelPodListing(LibTractor._user(), fieldId, index);
+        LibMarket._cancelPodListing(account, fieldId, index);
 
-        delete s.accts[account].fields[fieldId].plots[index];
-        LibDibbler.removePlotIndexFromAccount(account, fieldId, index);
+        LibField.deletePlot(account, fieldId, index);
+
+        // If burning a Slashed Plot, amount harvestable does not decrease.
+        if (account == address(0)) {
+            s.sys.fields[fieldId].harvestable += harvestablePods;
+        }
 
         // If the entire Plot was harvested, exit.
         if (harvestablePods >= pods) {
@@ -273,42 +285,44 @@ contract FieldFacet is Invariable, ReentrancyGuard {
 
     /**
      * @notice Returns the number of outstanding Pods. Includes Pods that are
-     * currently Harvestable but have not yet been Harvested.
+     * currently Harvestable or Burnable but have not yet been Harvested.
      * @param fieldId The index of the Field to query.
      */
     function totalPods(uint256 fieldId) public view returns (uint256) {
-        return s.sys.fields[fieldId].pods - s.sys.fields[fieldId].harvested;
+        return s.sys.fields[fieldId].pods - s.sys.fields[fieldId].processed;
     }
 
     /**
-     * @notice Returns the number of Pods that have ever been Harvested.
+     * @notice Returns the number of Pods that have ever been Harvested or Burned.
      * @param fieldId The index of the Field to query.
      */
-    function totalHarvested(uint256 fieldId) public view returns (uint256) {
-        return s.sys.fields[fieldId].harvested;
+    function totalProcessed(uint256 fieldId) public view returns (uint256) {
+        return s.sys.fields[fieldId].processed;
     }
 
     /**
      * @notice Returns the number of Pods that are currently Harvestable but
      * have not yet been Harvested.
      * @dev This is the number of Pods that Beanstalk is prepared to pay back,
      * but that haven’t yet been claimed via the `harvest()` function.
+     * @dev Cannot use this number as an index, as there is no accounting for Slashed plots.
      * @param fieldId The index of the Field to query.
      */
     function totalHarvestable(uint256 fieldId) public view returns (uint256) {
-        return s.sys.fields[fieldId].harvestable - s.sys.fields[fieldId].harvested;
+        return s.sys.fields[fieldId].harvestable - s.sys.fields[fieldId].processed;
     }
 
     /**
      * @notice Returns the number of Pods that are currently Harvestable for the active Field.
+     * @dev Cannot use this number as an index, as there is no accounting for Slashed plots.
      */
     function totalHarvestableForActiveField() public view returns (uint256) {
-        return
-            s.sys.fields[s.sys.activeField].harvestable - s.sys.fields[s.sys.activeField].harvested;
+        return totalHarvestable(s.sys.activeField);
     }
 
     /**
      * @notice Returns the number of Pods that are not yet Harvestable. Also known as the Pod Line.
+     * @dev Includes Slashed Pods.
      * @param fieldId The index of the Field to query.
      */
     function totalUnharvestable(uint256 fieldId) public view returns (uint256) {

protocol/contracts/beanstalk/init/InitDiamond.sol

@@ -4,68 +4,23 @@
 
 pragma solidity ^0.8.20;
 
-import {AppStorage} from "../storage/AppStorage.sol";
-import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
-import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
-import {IDiamondCut} from "../../interfaces/IDiamondCut.sol";
-import {IDiamondLoupe} from "../../interfaces/IDiamondLoupe.sol";
-import {LibDiamond} from "../../libraries/LibDiamond.sol";
-import {LibIncentive} from "../../libraries/LibIncentive.sol";
-import {LibCases} from "../../libraries/LibCases.sol";
-import {LibGauge} from "contracts/libraries/LibGauge.sol";
-import {C} from "../../C.sol";
-import {IBean} from "../../interfaces/IBean.sol";
-import {IWETH} from "../../interfaces/IWETH.sol";
-import {MockToken} from "../../mocks/MockToken.sol";
-import {Weather} from "contracts/beanstalk/sun/SeasonFacet/Weather.sol";
-import {LibIncentive} from "contracts/libraries/LibIncentive.sol";
+import {InitializeDiamond} from "contracts/beanstalk/init/InitializeDiamond.sol";
+import {C} from "contracts/C.sol";
 
 /**
- * @author Publius
+ * @author Publius, Brean
  * @title InitDiamond
  * @notice InitDiamond initializes the Beanstalk Diamond.
+ * A new bean token and bean:TOKEN well are deployed.
+ *
  **/
-contract InitDiamond is Weather {
-    address private constant PEG_PAIR = address(0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc);
+contract InitDiamond is InitializeDiamond {
+    // initial reward for deploying beanstalk.
+    uint256 constant INIT_SUPPLY = 100e6;
 
     function init() external {
-        LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();
+        initializeDiamond(C.BEAN, C.BEAN_ETH_WELL);
 
-        ds.supportedInterfaces[type(IERC165).interfaceId] = true;
-        ds.supportedInterfaces[type(IDiamondCut).interfaceId] = true;
-        ds.supportedInterfaces[type(IDiamondLoupe).interfaceId] = true;
-        ds.supportedInterfaces[0xd9b67a26] = true; // ERC1155
-        ds.supportedInterfaces[0x0e89341c] = true; // ERC1155Metadata
-
-        LibCases.setCasesV2();
-        s.sys.weather.temp = 1;
-
-        s.sys.season.current = 1;
-        s.sys.season.withdrawSeasons = 25;
-        s.sys.season.period = C.getSeasonPeriod();
-        s.sys.season.timestamp = block.timestamp;
-        s.sys.season.start = s.sys.season.period > 0
-            ? (block.timestamp / s.sys.season.period) * s.sys.season.period
-            : block.timestamp;
-
-        s.sys.weather.thisSowTime = type(uint32).max;
-        s.sys.weather.lastSowTime = type(uint32).max;
-        s.sys.isFarm = 1;
-
-        s.sys.usdTokenPrice[C.BEAN_ETH_WELL] = 1;
-        s.sys.twaReserves[C.BEAN_ETH_WELL].reserve0 = 1;
-        s.sys.twaReserves[C.BEAN_ETH_WELL].reserve1 = 1;
-
-        s.sys.seedGauge.beanToMaxLpGpPerBdvRatio = 50e18; // 50%
-        s.sys.seedGauge.averageGrownStalkPerBdvPerSeason = 3e6;
-
-        emit BeanToMaxLpGpPerBdvRatioChange(
-            s.sys.season.current,
-            type(uint256).max,
-            int80(int128(s.sys.seedGauge.beanToMaxLpGpPerBdvRatio))
-        );
-        emit LibGauge.UpdateAverageStalkPerBdvPerSeason(
-            s.sys.seedGauge.averageGrownStalkPerBdvPerSeason
-        );
+        C.bean().mint(msg.sender, INIT_SUPPLY);
     }
-}
+}