Feat: price per byte (#208)

* changes reward => pricePerByte

* collateral => collateralPerByte

* updates tests

* introduces AskHelpers to compute price and collateral per slot

* adds public view function returning currentCollateral for the slot

* updates names for price and collateral

* uses pricePerSlotPerSecond in maxPriceHelper

* adds collateralPerSlot helper

* makes sure that the intended use of the <<currentCollateral>> view function is demonstrated in tests

* formatting

* fix comment

* mints more tokens so that it can be used with contracts tests in nim-codex

* Renaming <<collateral>> and <<reward>> to <<collateralPerByte>> and <<pricePerBytePerSecond>> respectively (merged in the meantime to the master)

Author: marcinczenko

contracts/Marketplace.sol

@@ -42,6 +42,7 @@ contract Marketplace is SlotReservations, Proofs, StateRetrieval, Endian {
   using EnumerableSet for EnumerableSet.Bytes32Set;
   using EnumerableSet for EnumerableSet.AddressSet;
   using Requests for Request;
+  using AskHelpers for Ask;
 
   IERC20 private immutable _token;
   MarketplaceConfig private _config;
@@ -72,14 +73,20 @@ contract Marketplace is SlotReservations, Proofs, StateRetrieval, Endian {
     SlotState state;
     RequestId requestId;
     /// @notice Timestamp that signals when slot was filled
-    /// @dev Used for calculating payouts as hosts are paid based on time they actually host the content
+    /// @dev Used for calculating payouts as hosts are paid
+    ///      based on time they actually host the content
     uint256 filledAt;
     uint256 slotIndex;
-    /// @notice Tracks the current amount of host's collateral that is to be payed out at the end of Slot's lifespan.
-    /// @dev When Slot is filled, the collateral is collected in amount of request.ask.collateral
-    /// @dev When Host is slashed for missing a proof the slashed amount is reflected in this variable
+    /// @notice Tracks the current amount of host's collateral that is
+    ///         to be payed out at the end of Slot's lifespan.
+    /// @dev    When Slot is filled, the collateral is collected in amount
+    ///         of request.ask.collateralPerByte * request.ask.slotSize
+    ///         (== request.ask.collateralPerSlot() when using the AskHelpers library)
+    /// @dev    When Host is slashed for missing a proof the slashed amount is
+    ///         reflected in this variable
     uint256 currentCollateral;
-    address host; // address used for collateral interactions and identifying hosts
+    /// @notice address used for collateral interactions and identifying hosts
+    address host;
   }
 
   struct ActiveSlot {
@@ -120,6 +127,10 @@ contract Marketplace is SlotReservations, Proofs, StateRetrieval, Endian {
     return _token;
   }
 
+  function currentCollateral(SlotId slotId) public view returns (uint256) {
+    return _slots[slotId].currentCollateral;
+  }
+
   function requestStorage(Request calldata request) public {
     RequestId id = request.id();
 
@@ -137,10 +148,10 @@ contract Marketplace is SlotReservations, Proofs, StateRetrieval, Endian {
     if (request.ask.proofProbability == 0) {
       revert Marketplace_InsufficientProofProbability();
     }
-    if (request.ask.collateral == 0) {
+    if (request.ask.collateralPerByte == 0) {
       revert Marketplace_InsufficientCollateral();
     }
-    if (request.ask.reward == 0) {
+    if (request.ask.pricePerBytePerSecond == 0) {
       revert Marketplace_InsufficientReward();
     }
     if (bytes(request.content.cid).length == 0) {
@@ -205,20 +216,20 @@ contract Marketplace is SlotReservations, Proofs, StateRetrieval, Endian {
 
     // Collect collateral
     uint256 collateralAmount;
+    uint256 collateralPerSlot = request.ask.collateralPerSlot();
     if (slotState(slotId) == SlotState.Repair) {
       // Host is repairing a slot and is entitled for repair reward, so he gets "discounted collateral"
       // in this way he gets "physically" the reward at the end of the request when the full amount of collateral
       // is returned to him.
       collateralAmount =
-        request.ask.collateral -
-        ((request.ask.collateral * _config.collateral.repairRewardPercentage) /
-          100);
+        collateralPerSlot -
+        ((collateralPerSlot * _config.collateral.repairRewardPercentage) / 100);
     } else {
-      collateralAmount = request.ask.collateral;
+      collateralAmount = collateralPerSlot;
     }
     _transferFrom(msg.sender, collateralAmount);
     _marketplaceTotals.received += collateralAmount;
-    slot.currentCollateral = request.ask.collateral; // Even if he has collateral discounted, he is operating with full collateral
+    slot.currentCollateral = collateralPerSlot; // Even if he has collateral discounted, he is operating with full collateral
 
     _addToMySlots(slot.host, slotId);
 
@@ -326,7 +337,7 @@ contract Marketplace is SlotReservations, Proofs, StateRetrieval, Endian {
     // TODO: Reward for validator that calls this function
 
     if (missingProofs(slotId) % _config.collateral.slashCriterion == 0) {
-      uint256 slashedAmount = (request.ask.collateral *
+      uint256 slashedAmount = (request.ask.collateralPerSlot() *
         _config.collateral.slashPercentage) / 100;
       slot.currentCollateral -= slashedAmount;
       if (
@@ -586,7 +597,9 @@ contract Marketplace is SlotReservations, Proofs, StateRetrieval, Endian {
     Request storage request = _requests[requestId];
     if (startingTimestamp >= endingTimestamp)
       revert Marketplace_StartNotBeforeExpiry();
-    return (endingTimestamp - startingTimestamp) * request.ask.reward;
+    return
+      (endingTimestamp - startingTimestamp) *
+      request.ask.pricePerSlotPerSecond();
   }
 
   function getHost(SlotId slotId) public view returns (address) {

contracts/Requests.sol

@@ -17,8 +17,8 @@ struct Ask {
   uint256 slotSize; // amount of storage per slot (in number of bytes)
   uint256 duration; // how long content should be stored (in seconds)
   uint256 proofProbability; // how often storage proofs are required
-  uint256 reward; // amount of tokens paid per second per slot to hosts
-  uint256 collateral; // amount of tokens required to be deposited by the hosts in order to fill the slot
+  uint256 pricePerBytePerSecond; // amount of tokens paid per second per byte to hosts
+  uint256 collateralPerByte; // amount of tokens per byte required to be deposited by the hosts in order to fill the slot
   uint64 maxSlotLoss; // Max slots that can be lost without data considered to be lost
 }
 
@@ -45,7 +45,21 @@ enum SlotState {
   Repair // when slot slot was forcible freed (host was kicked out from hosting the slot because of too many missed proofs) and needs to be repaired
 }
 
+library AskHelpers {
+  function collateralPerSlot(Ask memory ask) internal pure returns (uint256) {
+    return ask.collateralPerByte * ask.slotSize;
+  }
+
+  function pricePerSlotPerSecond(
+    Ask memory ask
+  ) internal pure returns (uint256) {
+    return ask.pricePerBytePerSecond * ask.slotSize;
+  }
+}
+
 library Requests {
+  using AskHelpers for Ask;
+
   function id(Request memory request) internal pure returns (RequestId) {
     return RequestId.wrap(keccak256(abi.encode(request)));
   }
@@ -76,6 +90,9 @@ library Requests {
   }
 
   function maxPrice(Request memory request) internal pure returns (uint256) {
-    return request.ask.slots * request.ask.duration * request.ask.reward;
+    return
+      request.ask.slots *
+      request.ask.duration *
+      request.ask.pricePerSlotPerSecond();
   }
 }

deploy/token.js

@@ -1,16 +1,31 @@
-const MINTED_TOKENS = 1_000_000_000
+const MINTED_TOKENS = 1_000_000_000_000_000
 
-module.exports = async ({ deployments, getNamedAccounts, getUnnamedAccounts, network }) => {
+module.exports = async ({
+  deployments,
+  getNamedAccounts,
+  getUnnamedAccounts,
+  network,
+}) => {
   const { deployer } = await getNamedAccounts()
-  const tokenDeployment = await deployments.deploy("TestToken", { from: deployer })
-  const token = await hre.ethers.getContractAt("TestToken", tokenDeployment.address)
+  const tokenDeployment = await deployments.deploy("TestToken", {
+    from: deployer,
+  })
+  const token = await hre.ethers.getContractAt(
+    "TestToken",
+    tokenDeployment.address
+  )
 
-  const accounts = [...Object.values(await getNamedAccounts()), ...(await getUnnamedAccounts())]
+  const accounts = [
+    ...Object.values(await getNamedAccounts()),
+    ...(await getUnnamedAccounts()),
+  ]
   if (network.tags.local) {
     for (const account of accounts) {
       console.log(`Minting ${MINTED_TOKENS} tokens to address ${account}`)
 
-      const transaction = await token.mint(account, MINTED_TOKENS, { from: deployer })
+      const transaction = await token.mint(account, MINTED_TOKENS, {
+        from: deployer,
+      })
       await transaction.wait()
     }
     console.log()