init

contracts/ETHMixer.sol

@@ -12,8 +12,10 @@
 pragma solidity ^0.5.8;
 
 import "./Mixer.sol";
+import "@openzeppelin/contracts-ethereum-package/contracts/GSN/GSNRecipient.sol";
+import "@openzeppelin/contracts-ethereum-package/contracts/GSN/IRelayHub.sol";
 
-contract ETHMixer is Mixer {
+contract ETHMixer is Mixer, GSNRecipient {
   constructor(
     address _verifier,
     uint256 _mixDenomination,
@@ -23,14 +25,77 @@ contract ETHMixer is Mixer {
   ) Mixer(_verifier, _mixDenomination, _merkleTreeHeight, _emptyElement, _operator) public {
   }
 
-  function _processWithdraw(address payable _receiver, address payable _relayer, uint256 _fee) internal {
-    _receiver.transfer(mixDenomination - _fee);
-    if (_fee > 0) {
-      _relayer.transfer(_fee);
-    }
+  function _processWithdraw(address payable _receiver) internal {
+    _receiver.transfer(mixDenomination);
   }
 
   function _processDeposit() internal {
     require(msg.value == mixDenomination, "Please send `mixDenomination` ETH along with transaction");
   }
+
+  function withdrawViaRelayer(uint256[2] memory a, uint256[2][2] memory b, uint256[2] memory c, uint256[3] memory input) public {
+    uint256 root = input[0];
+    uint256 nullifierHash = input[1];
+    require(!nullifierHashes[nullifierHash], "The note has been already spent");
+
+    require(isKnownRoot(root), "Cannot find your merkle root"); // Make sure to use a recent one
+    require(verifier.verifyProof(a, b, c, input), "Invalid withdraw proof");
+    nullifierHashes[nullifierHash] = true;
+    // we will process withdraw in postRelayedCall func
+  }
+
+  // gsn related stuff
+  // this func is called by a Relayer via the RelayerHub before sending a tx
+  function acceptRelayedCall(
+    address relay,
+    address from,
+    bytes calldata encodedFunction,
+    uint256 transactionFee,
+    uint256 gasPrice,
+    uint256 gasLimit,
+    uint256 nonce,
+    bytes calldata approvalData,
+    uint256 maxPossibleCharge
+  ) external view returns (uint256, bytes memory) {
+    // think of a withdraw dry-run
+    if (_computeCharge(gasLimit, gasPrice, transactionFee) * 2 > mixDenomination) {
+      return (1, "Fee exceeds 50% of transfer value");
+    }
+
+    if (!compareBytesWithSelector(encodedFunction, this.withdrawViaRelayer.selector)) {
+      return (2, "Only withdrawViaRelayer can be called");
+    }
+
+    return _approveRelayedCall();
+  }
+
+  // this func is called by RelayerHub right before calling a target func
+  function preRelayedCall(bytes calldata /*context*/) external returns (bytes32) {}
+
+  event Debug(uint actualCharge, bytes context, address recipient);
+  // this func is called by RelayerHub right after calling a target func
+  function postRelayedCall(bytes memory context, bool /*success*/, uint actualCharge, bytes32 /*preRetVal*/) public {
+    IRelayHub relayHub = IRelayHub(getHubAddr());
+    address payable recipient;
+    assembly {
+      recipient := sload(add(context, 324)) // 4 + (8 * 32) + (32) + (32) == selector + proof + root + nullifier
+    }
+    emit Debug(actualCharge, context, recipient);
+
+    recipient.transfer(mixDenomination - actualCharge);
+    relayHub.depositFor.value(actualCharge)(address(this));
+    // or we can send actualCharge somewhere else...
+  }
+
+  function compareBytesWithSelector(bytes memory data, bytes4 sel) internal pure returns (bool) {
+    return data[0] == sel[0]
+        && data[1] == sel[1]
+        && data[2] == sel[2]
+        && data[3] == sel[3];
+  }
+
+  function withdrawFundsFromHub(uint256 amount, address payable dest) external {
+    require(msg.sender == operator, "unauthorized");
+    IRelayHub(getHubAddr()).withdraw(amount, dest);
+  }
 }

contracts/Mixer.sol

@@ -14,7 +14,7 @@ pragma solidity ^0.5.8;
 import "./MerkleTreeWithHistory.sol";
 
 contract IVerifier {
-  function verifyProof(uint256[2] memory a, uint256[2][2] memory b, uint256[2] memory c, uint256[5] memory input) public returns(bool);
+  function verifyProof(uint256[2] memory a, uint256[2][2] memory b, uint256[2] memory c, uint256[3] memory input) public returns(bool);
 }
 
 contract Mixer is MerkleTreeWithHistory {
@@ -29,7 +29,7 @@ contract Mixer is MerkleTreeWithHistory {
   uint256 public mixDenomination;
 
   event Deposit(uint256 indexed commitment, uint256 leafIndex, uint256 timestamp);
-  event Withdraw(address to, uint256 nullifierHash, address indexed relayer, uint256 fee);
+  event Withdraw(address to, uint256 nullifierHash, address indexed relayer);
 
   /**
     @dev The constructor
@@ -75,20 +75,17 @@ contract Mixer is MerkleTreeWithHistory {
       - the receiver of funds
       - optional fee that goes to the transaction sender (usually a relay)
   */
-  function withdraw(uint256[2] memory a, uint256[2][2] memory b, uint256[2] memory c, uint256[5] memory input) public {
+  function withdraw(uint256[2] memory a, uint256[2][2] memory b, uint256[2] memory c, uint256[3] memory input) public {
     uint256 root = input[0];
     uint256 nullifierHash = input[1];
     address payable receiver = address(input[2]);
-    address payable relayer = address(input[3]);
-    uint256 fee = input[4];
-    require(fee < mixDenomination, "Fee exceeds transfer value");
     require(!nullifierHashes[nullifierHash], "The note has been already spent");
 
     require(isKnownRoot(root), "Cannot find your merkle root"); // Make sure to use a recent one
     require(verifier.verifyProof(a, b, c, input), "Invalid withdraw proof");
     nullifierHashes[nullifierHash] = true;
-    _processWithdraw(receiver, relayer, fee);
-    emit Withdraw(receiver, nullifierHash, relayer, fee);
+    _processWithdraw(receiver);
+    emit Withdraw(receiver, nullifierHash, receiver);
   }
 
   function toggleDeposits() external {
@@ -106,6 +103,5 @@ contract Mixer is MerkleTreeWithHistory {
   }
 
   function _processDeposit() internal {}
-  function _processWithdraw(address payable _receiver, address payable _relayer, uint256 _fee) internal {}
-
+  function _processWithdraw(address payable _receiver) internal {}
 }