Fork System

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/C.sol

@@ -7,6 +7,7 @@ import "./interfaces/IFertilizer.sol";
 import "./interfaces/IProxyAdmin.sol";
 import "./libraries/Decimal.sol";
 import "./interfaces/IPipeline.sol";
+import {AppStorage, LibAppStorage} from "contracts/libraries/LibAppStorage.sol";
 
 /**
  * @title C
@@ -56,6 +57,13 @@ library C {
     // Special index to indicate the data to copy is the operator address.
     uint80 internal constant OPERATOR_COPY_INDEX = type(uint80).max - 1;
 
+    //////////////////// Fork ////////////////////
+    uint256 internal constant DEST_FIELD = 1;
+
+    function getSeasonPeriod() internal pure returns (uint256) {
+        return CURRENT_SEASON_PERIOD;
+    }
+
     function getRootsBase() internal pure returns (uint256) {
         return ROOTS_BASE;
     }
@@ -79,4 +87,9 @@ library C {
     function pipeline() internal pure returns (IPipeline) {
         return IPipeline(PIPELINE);
     }
+
+    function bean() internal view returns (address) {
+        AppStorage storage s = LibAppStorage.diamondStorage();
+        return s.sys.tokens.bean;
+    }
 }

protocol/contracts/beanstalk/ForkSystem/TransmitInFacet.sol

@@ -0,0 +1,40 @@
+/**
+ * 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 assets,
+        bytes calldata //data
+    ) external fundsSafu {
+        require(s.sys.supportedSourceForks[msg.sender], "Unsupported source");
+        require(assets.length >= 2, "Insufficient data provided");
+
+        LibTransmitIn.transmitInDeposits(user, assets[0]);
+        LibTransmitIn.transmitInPlots(user, assets[1]);
+        if (assets.length > 2) {
+            LibTransmitIn.transmitInFertilizer(user, assets[2]);
+        }
+        // additional assets can be processed here in the future
+    }
+}

protocol/contracts/beanstalk/ForkSystem/TransmitOutFacet.sol

@@ -0,0 +1,54 @@
+/**
+ * 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.
+     * @param assets Contains abi encoded deposits, plots, and fertilizer.
+     * @param data Currently unused but remains available for paramaters such as minimum output requirements.
+     */
+    function transmitOut(
+        address destination,
+        bytes[] calldata assets,
+        bytes calldata data
+    ) external fundsSafu {
+        require(assets.length >= 3, "Missing asset data");
+
+        bytes[] memory deposits = LibTransmitOut.transmitOutDeposits(
+            LibTractor._user(),
+            destination,
+            abi.decode(assets[0], (LibTransmitOut.SourceDeposit[]))
+        );
+        bytes[] memory plots = LibTransmitOut.transmitOutPlots(
+            LibTractor._user(),
+            abi.decode(assets[1], (LibTransmitOut.SourcePlot[]))
+        );
+        bytes[] memory fertilizer = LibTransmitOut.transmitOutFertilizer(
+            LibTractor._user(),
+            abi.decode(assets[2], (LibTransmitOut.SourceFertilizer[]))
+        );
+
+        bytes[][] memory processedAssets = new bytes[][](3);
+        processedAssets[0] = deposits;
+        processedAssets[1] = plots;
+        processedAssets[2] = fertilizer;
+
+        // Reverts if Destination fails to handle transmitted assets.
+        ITransmitInFacet(destination).transmitIn(LibTractor._user(), processedAssets, data);
+    }
+}

protocol/contracts/beanstalk/Invariable.sol

@@ -195,7 +195,7 @@ abstract contract Invariable {
                     s.sys.silo.unripeSettings[s.sys.tokens.urBean].balanceOfUnderlying + // unchopped underlying beans
                     s.sys.orderLockedBeans;
                 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(s.sys.tokens.urLp)) {
                 entitlements[i] += s.sys.silo.unripeSettings[s.sys.tokens.urLp].balanceOfUnderlying;

protocol/contracts/beanstalk/barn/FertilizerFacet.sol

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

protocol/contracts/beanstalk/field/FieldFacet.sol

@@ -15,6 +15,7 @@ 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";
 import {BeanstalkERC20} from "contracts/tokens/ERC20/BeanstalkERC20.sol";
 
 interface IBeanstalk {
@@ -145,6 +146,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,
@@ -163,6 +165,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,
@@ -172,48 +175,55 @@ contract FieldFacet is Invariable, ReentrancyGuard {
             // The Plot is partially harvestable if its index is less than
             // the current harvestable index.
             require(plots[i] < s.sys.fields[fieldId].harvestable, "Field: Plot not Harvestable");
-            uint256 harvested = _harvestPlot(LibTractor._user(), fieldId, plots[i]);
-            beansHarvested += harvested;
+            beansHarvested += _harvestPlot(LibTractor._user(), fieldId, plots[i]);
         }
-        s.sys.fields[fieldId].harvested += beansHarvested;
+        s.sys.fields[fieldId].totalHarvested += 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.
-        uint256 pods = s.accts[account].fields[fieldId].plots[index];
-        require(pods > 0, "Field: no plot");
+    ) private returns (uint256 beansHarvested) {
+        // 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 plotPods = s.accts[account].fields[fieldId].plots[index];
+        require(plotPods > 0, "Field: no plot");
 
         // Calculate how many Pods are harvestable.
         // The upstream _harvest function checks that at least some Pods
         // are harvestable.
-        harvestablePods = s.sys.fields[fieldId].harvestable.sub(index);
+        uint256 harvestablePods = s.sys.fields[fieldId].harvestable.sub(index);
+
+        LibMarket._cancelPodListing(account, fieldId, index);
 
-        LibMarket._cancelPodListing(LibTractor._user(), fieldId, index);
+        LibField.deletePlot(account, fieldId, index);
 
-        delete s.accts[account].fields[fieldId].plots[index];
-        LibDibbler.removePlotIndexFromAccount(account, fieldId, index);
+        beansHarvested = plotPods <= harvestablePods ? plotPods : harvestablePods;
+        s.sys.fields[fieldId].processed += beansHarvested;
+
+        // If burning a Slashed Plot, amount harvestable does not change.
+        if (account == address(0)) {
+            s.sys.fields[fieldId].harvestable += beansHarvested;
+            return 0;
+        }
 
         // If the entire Plot was harvested, exit.
-        if (harvestablePods >= pods) {
-            return pods;
+        if (beansHarvested == plotPods) {
+            return beansHarvested;
         }
 
         // Create a new Plot with remaining Pods.
-        uint256 newIndex = index.add(harvestablePods);
-        s.accts[account].fields[fieldId].plots[newIndex] = pods.sub(harvestablePods);
-        s.accts[account].fields[fieldId].plotIndexes.push(newIndex);
-        s.accts[account].fields[fieldId].piIndex[newIndex] =
-            s.accts[account].fields[fieldId].plotIndexes.length -
-            1;
+        uint256 newIndex = index.add(beansHarvested);
+        LibField.createPlot(account, fieldId, newIndex, plotPods.sub(beansHarvested));
     }
 
     //////////////////// CONFIG /////////////////////
@@ -270,42 +280,60 @@ 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 totalProcessed(uint256 fieldId) public view returns (uint256) {
+        return s.sys.fields[fieldId].processed;
+    }
+
+    /**
+     * @notice Returns the number of Pods that have been Harvested. Not including Slashed plots.
      * @param fieldId The index of the Field to query.
      */
     function totalHarvested(uint256 fieldId) public view returns (uint256) {
-        return s.sys.fields[fieldId].harvested;
+        return s.sys.fields[fieldId].totalHarvested;
+    }
+
+    /**
+     * @notice Returns the number of Pods that have been Slashed.
+     * @param fieldId The index of the Field to query.
+     */
+    function totalSlashed(uint256 fieldId) public view returns (uint256) {
+        return s.sys.fields[fieldId].processed - s.sys.fields[fieldId].totalHarvested;
     }
 
     /**
      * @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

@@ -0,0 +1,28 @@
+/*
+ SPDX-License-Identifier: MIT
+*/
+
+pragma solidity ^0.8.20;
+
+import {InitializeDiamond} from "contracts/beanstalk/init/InitializeDiamond.sol";
+import {C} from "contracts/C.sol";
+import {IBean} from "contracts/interfaces/IBean.sol";
+import {LibConstant} from "test/foundry/utils/LibConstant.sol";
+
+/**
+ * @author Publius, Brean
+ * @title InitDiamond
+ * @notice InitDiamond initializes the Beanstalk Diamond.
+ * A new bean token and bean:TOKEN well are deployed.
+ *
+ **/
+contract InitDiamond is InitializeDiamond {
+    // initial reward for deploying beanstalk.
+    uint256 constant INIT_SUPPLY = 100e6;
+
+    function init() external {
+        initializeDiamond(LibConstant.BEAN, LibConstant.BEAN_ETH_WELL);
+
+        IBean(s.sys.tokens.bean).mint(msg.sender, INIT_SUPPLY);
+    }
+}

protocol/contracts/beanstalk/init/InitDistribution.sol

@@ -29,6 +29,8 @@ contract InitDistribution {
     AppStorage internal s;
     IBeanstalk beanstalk;
 
+    uint256 internal constant ACTIVE_FIELD = 0;
+
     function init(address shipmentPlanner) external {
         beanstalk = IBeanstalk(address(this));
         require(
@@ -48,7 +50,7 @@ contract InitDistribution {
             shipmentPlanner,
             ShipmentPlanner.getFieldPlan.selector,
             ShipmentRecipient.FIELD,
-            abi.encode(uint256(0))
+            abi.encode(ACTIVE_FIELD)
         );
 
         shipmentRoutes[2] = ShipmentRoute(
@@ -60,7 +62,7 @@ contract InitDistribution {
 
         beanstalk.setShipmentRoutes(shipmentRoutes);
         beanstalk.addField();
-        beanstalk.setActiveField(0, 1);
+        beanstalk.setActiveField(ACTIVE_FIELD, 1);
 
         // TODO: Initialize Field values from priors.
     }