Change value to amount for consistency (#31)

Author: arr00

contracts/token/ConfidentialFungibleToken.sol

@@ -30,7 +30,7 @@ abstract contract ConfidentialFungibleToken is IConfidentialFungibleToken {
 
     mapping(address holder => euint64) private _balances;
     mapping(address holder => mapping(address spender => uint48)) private _operators;
-    mapping(uint256 requestId => euint64 encryptedValue) private _requestHandles;
+    mapping(uint256 requestId => euint64 encryptedAmount) private _requestHandles;
     euint64 private _totalSupply;
     string private _name;
     string private _symbol;
@@ -49,11 +49,11 @@ abstract contract ConfidentialFungibleToken is IConfidentialFungibleToken {
     error ConfidentialFungibleTokenZeroBalance(address holder);
 
     /**
-     * @dev The caller `user` does not have access to the encrypted value `amount`.
+     * @dev The caller `user` does not have access to the encrypted amount `amount`.
      *
      * NOTE: Try using the equivalent transfer function with an input proof.
      */
-    error ConfidentialFungibleTokenUnauthorizedUseOfEncryptedValue(euint64 amount, address user);
+    error ConfidentialFungibleTokenUnauthorizedUseOfEncryptedAmount(euint64 amount, address user);
 
     /// @dev The given caller `caller` is not authorized for the current operation.
     error ConfidentialFungibleTokenUnauthorizedCaller(address caller);
@@ -129,7 +129,7 @@ abstract contract ConfidentialFungibleToken is IConfidentialFungibleToken {
     function confidentialTransfer(address to, euint64 amount) public virtual returns (euint64 transferred) {
         require(
             amount.isAllowed(msg.sender),
-            ConfidentialFungibleTokenUnauthorizedUseOfEncryptedValue(amount, msg.sender)
+            ConfidentialFungibleTokenUnauthorizedUseOfEncryptedAmount(amount, msg.sender)
         );
         transferred = _transfer(msg.sender, to, amount);
         transferred.allowTransient(msg.sender);
@@ -155,7 +155,7 @@ abstract contract ConfidentialFungibleToken is IConfidentialFungibleToken {
     ) public virtual returns (euint64 transferred) {
         require(
             amount.isAllowed(msg.sender),
-            ConfidentialFungibleTokenUnauthorizedUseOfEncryptedValue(amount, msg.sender)
+            ConfidentialFungibleTokenUnauthorizedUseOfEncryptedAmount(amount, msg.sender)
         );
         require(isOperator(from, msg.sender), ConfidentialFungibleTokenUnauthorizedSpender(from, msg.sender));
         transferred = _transfer(from, to, amount);
@@ -181,7 +181,7 @@ abstract contract ConfidentialFungibleToken is IConfidentialFungibleToken {
     ) public virtual returns (euint64 transferred) {
         require(
             amount.isAllowed(msg.sender),
-            ConfidentialFungibleTokenUnauthorizedUseOfEncryptedValue(amount, msg.sender)
+            ConfidentialFungibleTokenUnauthorizedUseOfEncryptedAmount(amount, msg.sender)
         );
         transferred = _transferAndCall(msg.sender, to, amount, data);
         transferred.allowTransient(msg.sender);
@@ -209,7 +209,7 @@ abstract contract ConfidentialFungibleToken is IConfidentialFungibleToken {
     ) public virtual returns (euint64 transferred) {
         require(
             amount.isAllowed(msg.sender),
-            ConfidentialFungibleTokenUnauthorizedUseOfEncryptedValue(amount, msg.sender)
+            ConfidentialFungibleTokenUnauthorizedUseOfEncryptedAmount(amount, msg.sender)
         );
         require(isOperator(from, msg.sender), ConfidentialFungibleTokenUnauthorizedSpender(from, msg.sender));
         transferred = _transferAndCall(from, to, amount, data);
@@ -226,7 +226,7 @@ abstract contract ConfidentialFungibleToken is IConfidentialFungibleToken {
     function discloseEncryptedAmount(euint64 encryptedAmount) public virtual {
         require(
             encryptedAmount.isAllowed(msg.sender) && encryptedAmount.isAllowed(address(this)),
-            ConfidentialFungibleTokenUnauthorizedUseOfEncryptedValue(encryptedAmount, msg.sender)
+            ConfidentialFungibleTokenUnauthorizedUseOfEncryptedAmount(encryptedAmount, msg.sender)
         );
 
         uint256[] memory cts = new uint256[](1);

contracts/token/extensions/ConfidentialFungibleTokenERC20Wrapper.sol

@@ -77,35 +77,35 @@ abstract contract ConfidentialFungibleTokenERC20Wrapper is ConfidentialFungibleT
     function onTransferReceived(
         address /*operator*/,
         address from,
-        uint256 value,
+        uint256 amount,
         bytes calldata data
     ) public virtual returns (bytes4) {
         // check caller is the token contract
         require(address(underlying()) == msg.sender, ConfidentialFungibleTokenUnauthorizedCaller(msg.sender));
 
         // transfer excess back to the sender
-        uint256 excess = value % rate();
+        uint256 excess = amount % rate();
         if (excess > 0) SafeERC20.safeTransfer(underlying(), from, excess);
 
         // mint confidential token
         address to = data.length < 20 ? from : address(bytes20(data));
-        _mint(to, (value / rate()).toUint64().asEuint64());
+        _mint(to, (amount / rate()).toUint64().asEuint64());
 
         // return magic value
         return IERC1363Receiver.onTransferReceived.selector;
     }
 
     /**
-     * @dev Wraps value `value` of the underlying token into a confidential token and sends it to
-     * `to`. Tokens are exchanged at a fixed rate specified by {rate} such that `value / rate()` confidential
+     * @dev Wraps amount `amount` of the underlying token into a confidential token and sends it to
+     * `to`. Tokens are exchanged at a fixed rate specified by {rate} such that `amount / rate()` confidential
      * tokens are sent. Amount transferred in is rounded down to the nearest multiple of {rate}.
      */
-    function wrap(address to, uint256 value) public virtual {
+    function wrap(address to, uint256 amount) public virtual {
         // take ownership of the tokens
-        SafeERC20.safeTransferFrom(underlying(), msg.sender, address(this), value - (value % rate()));
+        SafeERC20.safeTransferFrom(underlying(), msg.sender, address(this), amount - (amount % rate()));
 
         // mint confidential token
-        _mint(to, (value / rate()).toUint64().asEuint64());
+        _mint(to, (amount / rate()).toUint64().asEuint64());
     }
 
     /**
@@ -119,7 +119,7 @@ abstract contract ConfidentialFungibleTokenERC20Wrapper is ConfidentialFungibleT
     function unwrap(address from, address to, euint64 amount) public virtual {
         require(
             amount.isAllowed(msg.sender),
-            ConfidentialFungibleTokenUnauthorizedUseOfEncryptedValue(amount, msg.sender)
+            ConfidentialFungibleTokenUnauthorizedUseOfEncryptedAmount(amount, msg.sender)
         );
         _unwrap(from, to, amount);
     }

contracts/token/utils/ConfidentialFungibleTokenUtils.sol

@@ -23,12 +23,12 @@ library ConfidentialFungibleTokenUtils {
         address operator,
         address from,
         address to,
-        euint64 value,
+        euint64 amount,
         bytes calldata data
     ) internal returns (ebool) {
         if (to.code.length > 0) {
             try
-                IConfidentialFungibleTokenReceiver(to).onConfidentialTransferReceived(operator, from, value, data)
+                IConfidentialFungibleTokenReceiver(to).onConfidentialTransferReceived(operator, from, amount, data)
             returns (ebool retval) {
                 return retval;
             } catch (bytes memory reason) {

test/token/ConfidentialFungibleToken.test.ts

@@ -336,7 +336,7 @@ describe("ConfidentialFungibleToken", function () {
 
             const recipientBalanceHandle = await this.token.balanceOf(this.recipient);
             await expect(callTransfer(this.token, this.holder, this.recipient, recipientBalanceHandle))
-              .to.be.revertedWithCustomError(this.token, "ConfidentialFungibleTokenUnauthorizedUseOfEncryptedValue")
+              .to.be.revertedWithCustomError(this.token, "ConfidentialFungibleTokenUnauthorizedUseOfEncryptedAmount")
               .withArgs(recipientBalanceHandle, this.holder);
           });
         });
@@ -501,7 +501,7 @@ describe("ConfidentialFungibleToken", function () {
       const holderBalanceHandle = await this.token.balanceOf(this.holder);
 
       await expect(this.token.connect(this.recipient).discloseEncryptedAmount(holderBalanceHandle))
-        .to.be.revertedWithCustomError(this.token, "ConfidentialFungibleTokenUnauthorizedUseOfEncryptedValue")
+        .to.be.revertedWithCustomError(this.token, "ConfidentialFungibleTokenUnauthorizedUseOfEncryptedAmount")
         .withArgs(holderBalanceHandle, this.recipient);
     });
 

test/token/extensions/ConfidentialFungibleWrapper.test.ts

@@ -229,7 +229,7 @@ describe("ConfidentialFungibleTokenWrapper", function () {
       const totalSupplyHandle = await this.wrapper.totalSupply();
 
       await expect(this.wrapper.connect(this.holder).unwrap(this.holder, this.holder, totalSupplyHandle))
-        .to.be.revertedWithCustomError(this.wrapper, "ConfidentialFungibleTokenUnauthorizedUseOfEncryptedValue")
+        .to.be.revertedWithCustomError(this.wrapper, "ConfidentialFungibleTokenUnauthorizedUseOfEncryptedAmount")
         .withArgs(totalSupplyHandle, this.holder);
     });