Git-Mirrors/tornado-core
1
0
Fork 0
mirror of https://github.com/tornadocash/tornado-core.git synced 2025-07-20 22:08:45 -04:00
Code Issues Projects Releases Packages Wiki Activity

make the relayer great again

Browse source
This commit is contained in:
Alexey 2019-09-26 13:23:35 +03:00
parent a8331eea08
commit ee2772328c
7 changed files with 938 additions and 514 deletions
Download patch file Download diff file Expand all files Collapse all files

82
contracts/ETHMixer.sol
View file

@ -25,86 +25,14 @@ contract ETHMixer is Mixer, GSNRecipient {
) Mixer(_verifier, _mixDenomination, _merkleTreeHeight, _emptyElement, _operator) public {
}
function _processWithdraw(address payable _receiver) internal {
_receiver.transfer(mixDenomination);
function _processWithdraw(address payable _receiver, address payable _relayer, uint256 _fee) internal {
_receiver.transfer(mixDenomination - _fee);
if (_fee > 0) {
_relayer.transfer(_fee);
}
}
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];
address receiver = address(input[2]);
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;
emit Withdraw(receiver, nullifierHash, tx.origin);
// 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 memory encodedFunction,
uint256 transactionFee,
uint256 gasPrice,
uint256 gasLimit,
uint256 nonce,
bytes memory approvalData,
uint256 maxPossibleCharge
) public view returns (uint256, bytes memory) {
// think of a withdraw dry-run
if (!compareBytesWithSelector(encodedFunction, this.withdrawViaRelayer.selector)) {
return (1, "Only withdrawViaRelayer can be called");
}
bytes memory recipient;
assembly {
let dataPointer := add(encodedFunction, 32)
let recipientPointer := mload(add(dataPointer, 324)) // 4 + (8 * 32) + (32) + (32) == selector + proof + root + nullifier
mstore(recipient, 32) // save array length
mstore(add(recipient, 32), recipientPointer) // save recipient address
}
return (0, recipient);
}
// 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 := mload(add(context, 32))
}
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);
}
function upgradeRelayHub(address newRelayHub) external {
require(msg.sender == operator, "unauthorized");
_upgradeRelayHub(newRelayHub);
}
}

15
contracts/Mixer.sol
View file

@ -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[3] memory input) public returns(bool);
function verifyProof(uint256[2] memory a, uint256[2][2] memory b, uint256[2] memory c, uint256[5] 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);
event Withdraw(address to, uint256 nullifierHash, address indexed relayer, uint fee);
/**
@dev The constructor
@ -75,17 +75,20 @@ 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[3] memory input) public {
function withdraw(uint256[2] memory a, uint256[2][2] memory b, uint256[2] memory c, uint256[5] 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);
emit Withdraw(receiver, nullifierHash, receiver);
_processWithdraw(receiver, relayer, fee);
emit Withdraw(receiver, nullifierHash, relayer, fee);
}
function toggleDeposits() external {
@ -103,5 +106,5 @@ contract Mixer is MerkleTreeWithHistory {
}
function _processDeposit() internal {}
function _processWithdraw(address payable _receiver) internal {}
function _processWithdraw(address payable _receiver, address payable _relayer, uint256 _fee) internal {}
}