128 lines
4.6 KiB
Solidity
128 lines
4.6 KiB
Solidity
// https://tornado.cash
|
|
/*
|
|
* d888888P dP a88888b. dP
|
|
* 88 88 d8' `88 88
|
|
* 88 .d8888b. 88d888b. 88d888b. .d8888b. .d888b88 .d8888b. 88 .d8888b. .d8888b. 88d888b.
|
|
* 88 88' `88 88' `88 88' `88 88' `88 88' `88 88' `88 88 88' `88 Y8ooooo. 88' `88
|
|
* 88 88. .88 88 88 88 88. .88 88. .88 88. .88 dP Y8. .88 88. .88 88 88 88
|
|
* dP `88888P' dP dP dP `88888P8 `88888P8 `88888P' 88 Y88888P' `88888P8 `88888P' dP dP
|
|
* ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
|
|
*/
|
|
|
|
pragma solidity ^0.5.8;
|
|
|
|
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol"; // todo: maybe remove?
|
|
|
|
contract IVerifier {
|
|
function verifyProof(bytes memory _proof, uint256[10] memory _input) public returns(bool);
|
|
}
|
|
|
|
contract TornadoPool is ReentrancyGuard {
|
|
uint256 public constant FIELD_SIZE = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
|
|
uint256 public constant MAX_EXT_AMOUNT = 2**248 - 1;
|
|
|
|
mapping(bytes32 => bool) public nullifierHashes;
|
|
bytes32 public currentRoot;
|
|
uint public currentCommitmentIndex;
|
|
IVerifier public verifier;
|
|
|
|
// todo: event Transaction();
|
|
event NewCommitment(bytes32 commitment, uint index);
|
|
event NewNullifier(bytes32 nullifier);
|
|
event Withdraw(bytes32 indexed nullifier); // todo emit it on withdraw so we can easily find the withdraw tx for user on UI
|
|
|
|
/**
|
|
@dev The constructor
|
|
@param _verifier the address of SNARK verifier for this contract
|
|
*/
|
|
constructor(IVerifier _verifier, bytes32 _currentRoot) public {
|
|
verifier = _verifier;
|
|
currentRoot = _currentRoot;
|
|
}
|
|
|
|
function transaction(
|
|
bytes calldata _proof,
|
|
bytes32 _root,
|
|
bytes32 _newRoot,
|
|
bytes32[2] calldata _inputNullifiers,
|
|
bytes32[2] calldata _outputCommitments,
|
|
uint256 _extAmount,
|
|
uint256 _fee,
|
|
address payable _recipient,
|
|
address payable _relayer
|
|
)
|
|
external payable nonReentrant
|
|
{
|
|
require(currentRoot == _root, "Invalid merkle root");
|
|
require(!isSpent(_inputNullifiers[0]), "Input 0 is already spent");
|
|
require(!isSpent(_inputNullifiers[1]), "Input 1 is already spent");
|
|
require(verifier.verifyProof(_proof, [
|
|
uint256(_root),
|
|
uint256(_newRoot),
|
|
uint256(_inputNullifiers[0]),
|
|
uint256(_inputNullifiers[1]),
|
|
uint256(_outputCommitments[0]),
|
|
uint256(_outputCommitments[1]),
|
|
_extAmount,
|
|
_fee,
|
|
uint256(_recipient),
|
|
uint256(_relayer)
|
|
]), "Invalid transaction proof");
|
|
|
|
currentRoot = _newRoot;
|
|
nullifierHashes[_inputNullifiers[0]] = true;
|
|
nullifierHashes[_inputNullifiers[1]] = true;
|
|
|
|
int256 extAmount = calculateExternalAmount(_extAmount);
|
|
if (extAmount > 0) {
|
|
require(msg.value == uint256(extAmount), "Incorrect amount of ETH sent on deposit");
|
|
} else {
|
|
require(msg.value == 0, "Sent ETH amount should be 0 for withdrawal");
|
|
transfer(_recipient, uint256(-extAmount));
|
|
}
|
|
|
|
if (_fee > 0) {
|
|
transfer(_relayer, _fee);
|
|
}
|
|
|
|
// todo enforce currentCommitmentIndex value in snark
|
|
emit NewCommitment(_outputCommitments[0], currentCommitmentIndex++);
|
|
emit NewCommitment(_outputCommitments[1], currentCommitmentIndex++);
|
|
emit NewNullifier(_inputNullifiers[0]);
|
|
emit NewNullifier(_inputNullifiers[1]);
|
|
// emit Transaction();
|
|
}
|
|
|
|
function calculateExternalAmount(uint256 _extAmount) public pure returns(int256) {
|
|
// -MAX_EXT_AMOUNT < extAmount < MAX_EXT_AMOUNT
|
|
if (_extAmount < MAX_EXT_AMOUNT) {
|
|
return int256(_extAmount);
|
|
} else if (_extAmount > FIELD_SIZE - MAX_EXT_AMOUNT) {
|
|
// FIELD_SIZE - MAX_EXT_AMOUNT < _extAmount < FIELD_SIZE
|
|
return -(int256(FIELD_SIZE) - int256(_extAmount));
|
|
} else {
|
|
revert("Invalid extAmount value");
|
|
}
|
|
}
|
|
|
|
function transfer(address payable to, uint256 amount) internal {
|
|
(bool success, ) = to.call.value(amount)("");
|
|
require(success, "payment did not go through");
|
|
}
|
|
|
|
/** @dev whether a note is already spent */
|
|
function isSpent(bytes32 _nullifierHash) public view returns(bool) {
|
|
return nullifierHashes[_nullifierHash];
|
|
}
|
|
|
|
/** @dev whether an array of notes is already spent */
|
|
function isSpentArray(bytes32[] calldata _nullifierHashes) external view returns(bool[] memory spent) {
|
|
spent = new bool[](_nullifierHashes.length);
|
|
for(uint i = 0; i < _nullifierHashes.length; i++) {
|
|
if (isSpent(_nullifierHashes[i])) {
|
|
spent[i] = true;
|
|
}
|
|
}
|
|
}
|
|
}
|