Group/v2

contracts/anchors/AnchorBase.sol

@@ -41,20 +41,28 @@ abstract contract AnchorBase is LinkableTree {
     @dev Inserts a commitment into the tree
     @param _commitment the note commitment = Poseidon(chainId, nullifier, secret)
   */
-  function insert(bytes32 _commitment) public payable nonReentrant returns(uint32) {
+  function insert(bytes32 _commitment) internal returns(uint32) {
     require(!commitments[_commitment], "The commitment has been submitted");
 
     uint32 insertedIndex = _insert(_commitment);
     commitments[_commitment] = true;
-    _processInsertion();
-
     emit Insertion(_commitment, insertedIndex, block.timestamp);
 
     return insertedIndex;
   }
 
-  /** @dev this function is defined in a child contract */
-  function _processInsertion() internal virtual;
+  function insertTwo(bytes32 _firstCommitment, bytes32 _secondCommitment) internal returns(uint32) {
+    require(!commitments[_firstCommitment], "The commitment has been submitted");
+    require(!commitments[_secondCommitment], "The commitment has been submitted");
+
+    uint32 insertedIndex = _insertTwo(_firstCommitment, _secondCommitment);
+    commitments[_firstCommitment] = true;
+    commitments[_secondCommitment] = true;
+    emit Insertion(_firstCommitment, insertedIndex, block.timestamp);
+    emit Insertion(_secondCommitment, insertedIndex + 1, block.timestamp);
+
+    return insertedIndex;
+  }
 
   function verify(
     bytes memory _proof,

contracts/anchors/FixedDepositAnchor.sol

@@ -21,9 +21,10 @@ contract FixedDepositAnchor is AnchorBase, IFixedDepositAnchor {
 
   address public immutable token;
   uint256 public immutable denomination;
+
   // currency events
   event Deposit(address sender, uint32 indexed leafIndex, bytes32 indexed commitment, uint256 timestamp);
-  event Withdrawal(address to, bytes32 nullifierHash, address indexed relayer, uint256 fee);
+  event Withdrawal(address to, address indexed relayer, uint256 fee);
   event Refresh(bytes32 indexed commitment, bytes32 nullifierHash, uint32 insertedIndex);
 
   struct EncodeInputsData {
@@ -34,6 +35,7 @@ contract FixedDepositAnchor is AnchorBase, IFixedDepositAnchor {
     uint256 _fee;
     uint256 _refund;
   }
+
   /**
     @dev The constructor
     @param _verifier the address of SNARK verifier for this contract
@@ -56,13 +58,10 @@ contract FixedDepositAnchor is AnchorBase, IFixedDepositAnchor {
   }
 
   function deposit(bytes32 _commitment) override public payable {
-    uint32 insertedIndex = insert(_commitment);
-    emit Deposit(msg.sender, insertedIndex, _commitment, block.timestamp);
-  }
-
-  function _processInsertion() internal override {
     require(msg.value == 0, "ETH value is supposed to be 0 for ERC20 instance");
+    uint32 insertedIndex = insert(_commitment);
     IMintableERC20(token).transferFrom(msg.sender, address(this), denomination);
+    emit Deposit(msg.sender, insertedIndex, _commitment, block.timestamp);
   }
 
   /**
@@ -80,17 +79,8 @@ contract FixedDepositAnchor is AnchorBase, IFixedDepositAnchor {
     require(_publicInputs._fee <= denomination, "Fee exceeds transfer value");
     require(!isSpent(_publicInputs._nullifierHash), "The note has been already spent");
 
-    (bytes memory encodedInput, bytes32[] memory roots) = _encodeInputs(
-      _publicInputs._roots,
-      EncodeInputsData(
-        _publicInputs._nullifierHash,
-        _publicInputs._refreshCommitment,
-        address(_publicInputs._recipient),
-        address(_publicInputs._relayer),
-        _publicInputs._fee,
-        _publicInputs._refund
-      )
-    );
+    (bytes memory encodedInput, bytes32[] memory roots) = _encodeInputsWithPublicInputs(_publicInputs);
+
     require(isValidRoots(roots), "Invalid roots");
     require(verify(_proof, encodedInput), "Invalid withdraw proof");
 
@@ -103,11 +93,6 @@ contract FixedDepositAnchor is AnchorBase, IFixedDepositAnchor {
         _publicInputs._fee,
         _publicInputs._refund
       );
-      emit Withdrawal(_publicInputs._recipient,
-        _publicInputs._nullifierHash,
-        _publicInputs._relayer,
-        _publicInputs._fee
-      );
     } else {
       require(!commitments[_publicInputs._refreshCommitment], "The commitment has been submitted");
       uint32 insertedIndex = _insert(_publicInputs._refreshCommitment);
@@ -144,6 +129,8 @@ contract FixedDepositAnchor is AnchorBase, IFixedDepositAnchor {
       }
     }
 
+    emit Withdrawal(_recipient, _relayer, _fee);
+
     if (_refund > 0) {
       (bool success, ) = _recipient.call{ value: _refund }("");
       if (!success) {
@@ -207,17 +194,7 @@ contract FixedDepositAnchor is AnchorBase, IFixedDepositAnchor {
     require(_publicInputs._fee <= denomination, "Fee exceeds transfer value");
     require(!nullifierHashes[_publicInputs._nullifierHash], "The note has been already spent");
 
-    (bytes memory encodedInput, bytes32[] memory roots) = _encodeInputs(
-      _publicInputs._roots,
-      EncodeInputsData(
-        _publicInputs._nullifierHash,
-        _publicInputs._refreshCommitment,
-        address(_publicInputs._recipient),
-        address(_publicInputs._relayer),
-        _publicInputs._fee,
-        _publicInputs._refund
-      )
-    );
+    (bytes memory encodedInput, bytes32[] memory roots) = _encodeInputsWithPublicInputs(_publicInputs);
 
     require(isValidRoots(roots), "Invalid roots");
     require(verify(_proof, encodedInput), "Invalid withdraw proof");
@@ -236,13 +213,6 @@ contract FixedDepositAnchor is AnchorBase, IFixedDepositAnchor {
       denomination - _publicInputs._fee,
       address(_publicInputs._recipient)
     );
-
-    emit Withdrawal(
-      _publicInputs._recipient,
-      _publicInputs._nullifierHash,
-      _publicInputs._relayer,
-      _publicInputs._fee
-    );
   }
 
   function getDenomination() override  external view returns (uint) {
@@ -253,6 +223,22 @@ contract FixedDepositAnchor is AnchorBase, IFixedDepositAnchor {
     return token;
   }
 
+  function _encodeInputsWithPublicInputs(
+    PublicInputs calldata _publicInputs
+  ) internal view returns (bytes memory encodedInput, bytes32[] memory roots) {
+    return _encodeInputs(
+      _publicInputs._roots,
+      EncodeInputsData(
+        _publicInputs._nullifierHash,
+        _publicInputs._refreshCommitment,
+        address(_publicInputs._recipient),
+        address(_publicInputs._relayer),
+        _publicInputs._fee,
+        _publicInputs._refund
+      )
+    );
+  }
+
   function _encodeInputs(
     bytes calldata _roots,
     EncodeInputsData memory encodeInputsData

contracts/anchors/LinkableTree.sol

@@ -92,6 +92,23 @@ abstract contract LinkableTree is MerkleTreePoseidon, ReentrancyGuard {
     }
   }
 
+  /** @dev */
+  function getLatestNeighborEdges() public view returns (Edge[] memory edges) {
+    edges = new Edge[](maxEdges);
+    for (uint256 i = 0; i < maxEdges; i++) {
+      if (edgeList.length >= i + 1) {
+        edges[i] = edgeList[i];
+      } else {
+        edges[i] = Edge({
+          // merkle tree height for zeros
+          root: zeros(levels),
+          chainID: 0,
+          latestLeafIndex: 0
+        });
+      }
+    }
+  }
+
   function getLatestNeighborRoots() public view returns (bytes32[] memory roots) {
     roots = new bytes32[](maxEdges);
     for (uint256 i = 0; i < maxEdges; i++) {

contracts/handlers/AnchorHandler.sol

@@ -105,6 +105,10 @@ contract AnchorHandler is IExecutor, HandlerHelpers {
             uint32 leafIndex = uint32(bytes4(arguments[8:12]));
             bytes32 merkleRoot = bytes32(arguments[12:44]);
             anchor.updateEdge(sourceChainId, merkleRoot, leafIndex);
+        } else if (functionSig == bytes4(keccak256("configureLimits(uint256,uint256)"))) {
+            uint256 _minimalWithdrawalAmount = uint256(bytes32(arguments[4:36]));
+            uint256 _maximumDepositAmount = uint256(bytes32(arguments[36:68]));
+            anchor.configureLimits(_minimalWithdrawalAmount, _maximumDepositAmount);
         } else {
             revert("Invalid function sig");
         }

contracts/interfaces/ILinkableAnchor.sol

@@ -8,6 +8,8 @@ pragma solidity ^0.8.0;
 interface ILinkableAnchor {
   function setHandler(address _handler, uint32 nonce) external;
   function setVerifier(address _verifier) external;
+  function configureLimits(uint256 _minimalWithdrawalAmount, uint256 _maximumDepositAmount) external;
+
   function updateEdge(
     uint256 sourceChainID,
     bytes32 root,

contracts/trees/MerkleTreeWithHistoryPoseidon.sol

@@ -6,8 +6,9 @@
 pragma solidity ^0.8.0;
 
 import "./Poseidon.sol";
+import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
 
-abstract contract MerkleTreeWithHistoryPoseidon {
+abstract contract MerkleTreeWithHistoryPoseidon is Initializable {
   uint256 public constant FIELD_SIZE = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
   uint256 public constant ZERO_VALUE = 21663839004416932945382355908790599225266501822907911457504978515578255421292; // = keccak256("tornado") % FIELD_SIZE
   IPoseidonT3 public immutable hasher;
@@ -62,6 +63,34 @@ abstract contract MerkleTreeWithHistoryPoseidon {
     return _nextIndex;
   }
 
+  // Modified to insert pairs of leaves for better efficiency
+  function _insertTwo(bytes32 _leaf1, bytes32 _leaf2) internal returns (uint32 index) {
+    uint32 _nextIndex = nextIndex;
+    require(_nextIndex != uint32(2)**levels, "Merkle tree is full. No more leaves can be added");
+    uint32 currentIndex = _nextIndex / 2;
+    bytes32 currentLevelHash = hashLeftRight(hasher, _leaf1, _leaf2);
+    bytes32 left;
+    bytes32 right;
+    for (uint32 i = 1; i < levels; i++) {
+      if (currentIndex % 2 == 0) {
+        left = currentLevelHash;
+        right = zeros(i);
+        filledSubtrees[i] = currentLevelHash;
+      } else {
+        left = filledSubtrees[i];
+        right = currentLevelHash;
+      }
+      currentLevelHash = hashLeftRight(hasher, left, right);
+      currentIndex /= 2;
+    }
+
+    uint32 newRootIndex = (currentRootIndex + 1) % ROOT_HISTORY_SIZE;
+    currentRootIndex = newRootIndex;
+    roots[newRootIndex] = currentLevelHash;
+    nextIndex = _nextIndex + 2;
+    return _nextIndex;
+  }
+
   /**
     @dev Whether the root is present in the root history
   */
@@ -92,4 +121,6 @@ abstract contract MerkleTreeWithHistoryPoseidon {
 
   /** @dev this function is defined in a child contract */
   function zeros(uint256 i) public virtual pure returns (bytes32);
+
+  function _initialize() internal {}
 }