tornadocash/tornado-pool-factory
1
0
Fork 0
mirror of https://github.com/tornadocash/tornado-pool-factory synced 2024-02-02 15:04:08 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #3 from tornadocash/TC-128-native-currency-pool

Browse Source 
TC-128 native currency pools
This commit is contained in:
Alexander Drygin 2022-07-29 15:38:04 +03:00 committed by GitHub
commit e8fd9d5d73
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
17 changed files with 748 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
README.md
View File

@ -4,28 +4,28 @@
This repository contains:
1. `InstanceFactory` - instance factory for the creation new Tornado ERC20 pools
2. `InstanceFactoryWithRegistry` - governance proposal factory for the addition of new Tornado ERC20 instances to the Tornado router
1. `InstanceFactory` - instance factory for the creation new Tornado ERC20/native pools
2. `InstanceProposalCreator` - governance proposal factory for the addition of new Tornado instances to the Tornado router
### InstanceFactory
Anyone can create a new ERC20 instance by calling `createInstanceClone` method of the factory with parameters:
Anyone can create a new instance by calling `createInstanceClone` method of the factory with parameters:
1. `address token` - address of ERC20 token for a new instance
1. `address token` - address of ERC20 token for a new instance, zero address for the native instance
2. `uint256 denomination` - denomination for new instance (tokens can only be deposited in certain denominations into instances)
### InstanceFactoryWithRegistry
### InstanceProposalCreator
Anyone can create governance proposal for the addition of a new ERC20 instance by calling `createProposalApprove/createProposalPermit` method of the factory with parameters (proposal creation fee in TORN is charged from sender):
Anyone can create governance proposal for the addition of a new instance by calling `createProposalApprove/createProposalPermit` method of the factory with parameters (proposal creation fee in TORN is charged from sender):
1. `address token` - address of ERC20 token for a new instance
2. `uint24 uniswapPoolSwappingFee` - fee value of Uniswap instance which will be used for `TORN/token` price determination. `3000` means 0.3% fee Uniswap pool.
1. `address token` - address of ERC20 token for a new instance, zero address for the native instance
2. `uint24 uniswapPoolSwappingFee` - fee value of Uniswap instance which will be used for `TORN/token` price determination. `3000` means 0.3% fee Uniswap pool. Zero value for the native instance.
3. `uint256[] denominations` - list of denominations for each new instance (tokens can only be deposited in certain denominations into instances).
4. `uint32[] protocolFees` - list of protocol fees for each new instance (this fee is only charged from registrated relayer during withdrawal process). `100` means 1% of instance denomination fee for withdrawal throw registrated relayer.
## Factory parameters
### InstanceFactoryWithRegistry
### InstanceProposalCreator
1. `max number of new instances in one proposal` - the current version supports the addition of a maximum of 4 instances at once.
2. `proposal creation fee` - this fee is charged from creator of proposal during `createProposalApprove/createProposalPermit` factory method execution. It can be changed by governance. Default value is stored in `config.js`.
@ -34,7 +34,7 @@ Anyone can create governance proposal for the addition of a new ERC20 instance b
## Warnings
1. This version of the factory creates a proposal for **immutable** Tornado instance initialization.
2. For `InstanceFactoryWithRegistry` users should manually propose a proposal after its creation using the factory (in governance UI for example). As `propose()` method caller must have 1000 TORN locked in the governance. Moreover, the proposer can't propose more than one proposal simultaneously.
2. For `InstanceProposalCreator` users should manually propose a proposal after its creation using the factory (in governance UI for example). As `propose()` method caller must have 1000 TORN locked in the governance. Moreover, the proposer can't propose more than one proposal simultaneously.
## Tests
@ -61,10 +61,12 @@ Check config.js for actual values.
With `salt` = `0x0000000000000000000000000000000000000000000000000000000047941987` address must be:
1. `MultipleInstanceFactory` - `0x8a1BCFc608DdF6c4715277a24310B9E8ecc4c110`
2. `MultipleInstanceFactory proxy` - `0x0F9AE1d1ABbDd441B813ada0B038df130b2a6A86`
3. `InstanceFactoryWithRegistry` - `0x557fB18B66088728Ea975136de46714983aa4f2E`
4. `InstanceFactoryWithRegistry proxy` - `0x4D1b1c294dA4D14aC0e0Eed7BcD4Db3fe2bDe4C3`
1. `SidechainInstanceFactory` - `0xE24B853247B37375A080553082a5385Dda95E8cf`
2. `SidechainInstanceFactory proxy` - `0x168de886aC22e73b3306e234579794340a0eb746`
3. `InstanceFactory` - `0x8B85eB475Ac8D286DcF307346a6EAE9E9c93665d`
4. `InstanceFactory proxy` - `0xf30827C1588b17ABAeF855DF92bf6B60615F3e9C`
5. `InstanceProposalCreator` - `0xe1FcF99262F00cCbe2CE6cC70CE956C7e5728C10`
6. `InstanceProposalCreator proxy` - `0xa9189801C88fe8222001d2ee962A6A4150DB6026`
Check addresses with current config:
@ -73,19 +75,19 @@ Check addresses with current config:
node -e 'require("./src/generateAddresses").generateWithLog()'
```
Deploy MultipleInstanceFactory:
Deploy SidechainInstanceFactory:
```shell
yarn hardhat run scripts/deployMultipleInstanceFactory.js --network mainnet
yarn hardhat run scripts/deploySidechainInstanceFactory.js --network mainnet
```
Deploy InstanceFactoryWithRegistry:
Deploy InstanceProposalCreator:
```shell
yarn hardhat run scripts/deployInstanceFactoryWithRegistry.js --network mainnet
yarn hardhat run scripts/deployInstanceProposalCreator.js --network mainnet
```
Verify InstanceFactory on Etherscan:
Verify on Etherscan:
```
yarn hardhat verify --network <network-name> <contract-address> <constructor-arguments>

8
contracts/AddInstanceProposal.sol
View File

@ -4,10 +4,10 @@ pragma solidity 0.7.6;
pragma abicoder v2;
import "./interfaces/IInstanceRegistry.sol";
import "./InstanceFactory.sol";
import "./interfaces/IInstanceFactory.sol";
contract AddInstanceProposal {
InstanceFactory public immutable instanceFactory;
IInstanceFactory public immutable instanceFactory;
IInstanceRegistry public immutable instanceRegistry;
address public immutable token;
uint24 public immutable uniswapPoolSwappingFee;
@ -32,7 +32,7 @@ contract AddInstanceProposal {
uint256[] memory _denominations,
uint32[] memory _protocolFees
) {
instanceFactory = InstanceFactory(_instanceFactory);
instanceFactory = IInstanceFactory(_instanceFactory);
instanceRegistry = IInstanceRegistry(_instanceRegistry);
token = _token;
uniswapPoolSwappingFee = _uniswapPoolSwappingFee;
@ -57,7 +57,7 @@ contract AddInstanceProposal {
address instance = instanceFactory.createInstanceClone(denominationByIndex(i), token);
IInstanceRegistry.Instance memory newInstanceData = IInstanceRegistry.Instance(
true,
token != address(0),
IERC20(token),
IInstanceRegistry.InstanceState.ENABLED,
uniswapPoolSwappingFee,

54
contracts/InstanceFactory.sol
View File

@ -6,20 +6,22 @@ pragma abicoder v2;
import { Address } from "@openzeppelin/contracts/utils/Address.sol";
import { Initializable } from "@openzeppelin/contracts/proxy/Initializable.sol";
import "@openzeppelin/contracts/proxy/Clones.sol";
import "./ERC20TornadoCloneable.sol";
import "./instances/ERC20TornadoCloneable.sol";
import "./instances/ETHTornadoCloneable.sol";
contract InstanceFactory is Initializable {
using Clones for address;
using Address for address;
address public admin;
address public implementation;
address public ERC20Impl;
address public nativeCurImpl;
address public verifier;
address public hasher;
uint32 public merkleTreeHeight;
event NewTreeHeightSet(uint32 indexed newTreeHeight);
event NewImplementationSet(address indexed newImplemenentation, address verifier, address hasher);
event NewImplementationSet(address indexed ERC20Impl, address indexed nativeCurImpl, address verifier, address hasher);
event NewInstanceCloneCreated(address indexed clone);
modifier onlyAdmin() {
@ -43,30 +45,49 @@ contract InstanceFactory is Initializable {
merkleTreeHeight = _merkleTreeHeight;
admin = _admin;
ERC20TornadoCloneable implContract = new ERC20TornadoCloneable(_verifier, _hasher);
implementation = address(implContract);
ERC20TornadoCloneable ERC20ImplContract = new ERC20TornadoCloneable(_verifier, _hasher);
ERC20Impl = address(ERC20ImplContract);
ETHTornadoCloneable nativeCurImplContract = new ETHTornadoCloneable(_verifier, _hasher);
nativeCurImpl = address(nativeCurImplContract);
}
/**
* @dev Creates new Tornado instance.
* @param _denomination denomination of new Tornado instance
* @param _token address of ERC20 token for a new instance
* @param _token address of ERC20 token for a new instance, if zero address, then it will be ETH
*/
function createInstanceClone(uint256 _denomination, address _token) public virtual returns (address) {
function createInstanceClone(uint256 _denomination, address _token) public virtual onlyAdmin returns (address clone) {
return _createInstanceClone(_denomination, _token);
}
function _createInstanceClone(uint256 _denomination, address _token) internal returns (address clone) {
bytes32 salt = keccak256(abi.encodePacked(_denomination, _token));
address newClone = implementation.predictDeterministicAddress(salt);
if (!newClone.isContract()) {
implementation.cloneDeterministic(salt);
emit NewInstanceCloneCreated(newClone);
ERC20TornadoCloneable(newClone).init(_denomination, merkleTreeHeight, _token);
if (_token == address(0)) {
clone = nativeCurImpl.predictDeterministicAddress(salt);
if (!clone.isContract()) {
nativeCurImpl.cloneDeterministic(salt);
emit NewInstanceCloneCreated(clone);
ETHTornadoCloneable(clone).init(_denomination, merkleTreeHeight);
}
return newClone;
} else {
clone = ERC20Impl.predictDeterministicAddress(salt);
if (!clone.isContract()) {
ERC20Impl.cloneDeterministic(salt);
emit NewInstanceCloneCreated(clone);
ERC20TornadoCloneable(clone).init(_denomination, merkleTreeHeight, _token);
}
}
return clone;
}
function getInstanceAddress(uint256 _denomination, address _token) public view returns (address) {
bytes32 salt = keccak256(abi.encodePacked(_denomination, _token));
return implementation.predictDeterministicAddress(salt);
if (_token == address(0)) {
return nativeCurImpl.predictDeterministicAddress(salt);
} else {
return ERC20Impl.predictDeterministicAddress(salt);
}
}
function setMerkleTreeHeight(uint32 _merkleTreeHeight) external onlyAdmin {
@ -77,7 +98,8 @@ contract InstanceFactory is Initializable {
function generateNewImplementation(address _verifier, address _hasher) external onlyAdmin {
verifier = _verifier;
hasher = _hasher;
implementation = address(new ERC20TornadoCloneable(_verifier, _hasher));
emit NewImplementationSet(implementation, _verifier, _hasher);
ERC20Impl = address(new ERC20TornadoCloneable(_verifier, _hasher));
nativeCurImpl = address(new ETHTornadoCloneable(_verifier, _hasher));
emit NewImplementationSet(ERC20Impl, nativeCurImpl, _verifier, _hasher);
}
}

44
contracts/InstanceFactoryWithRegistry.sol → contracts/InstanceProposalCreator.sol
View File

@ -5,17 +5,19 @@ pragma abicoder v2;
import { Address } from "@openzeppelin/contracts/utils/Address.sol";
import "./AddInstanceProposal.sol";
import "./InstanceFactory.sol";
import "./interfaces/IInstanceFactory.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { IERC20Permit } from "@openzeppelin/contracts/drafts/IERC20Permit.sol";
import { IUniswapV3Factory } from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Factory.sol";
import { IUniswapV3PoolState } from "@uniswap/v3-core/contracts/interfaces/pool/IUniswapV3PoolState.sol";
import { Initializable } from "@openzeppelin/contracts/proxy/Initializable.sol";
contract InstanceFactoryWithRegistry is InstanceFactory {
contract InstanceProposalCreator is Initializable {
using Address for address;
address public immutable governance;
address public immutable torn;
IInstanceFactory public immutable instanceFactory;
address public immutable instanceRegistry;
IUniswapV3Factory public immutable UniswapV3Factory;
address public immutable WETH;
@ -36,12 +38,14 @@ contract InstanceFactoryWithRegistry is InstanceFactory {
constructor(
address _governance,
address _instanceFactory,
address _instanceRegistry,
address _torn,
address _UniswapV3Factory,
address _WETH
) {
governance = _governance;
instanceFactory = IInstanceFactory(_instanceFactory);
instanceRegistry = _instanceRegistry;
torn = _torn;
UniswapV3Factory = IUniswapV3Factory(_UniswapV3Factory);
@ -53,28 +57,11 @@ contract InstanceFactoryWithRegistry is InstanceFactory {
* @dev this contract will be deployed behind a proxy and should not assign values at logic address,
* params left out because self explainable
* */
function initialize(
address _verifier,
address _hasher,
uint32 _merkleTreeHeight,
address _governance,
uint16 _TWAPSlotsMin,
uint256 _creationFee
) external initializer {
initialize(_verifier, _hasher, _merkleTreeHeight, _governance);
function initialize(uint16 _TWAPSlotsMin, uint256 _creationFee) external initializer {
TWAPSlotsMin = _TWAPSlotsMin;
creationFee = _creationFee;
}
/**
* @dev Creates new Tornado instances. Throws if called by any account other than the Governance.
* @param _denomination denomination of new Tornado instance
* @param _token address of ERC20 token for a new instance
*/
function createInstanceClone(uint256 _denomination, address _token) public override onlyGovernance returns (address) {
return super.createInstanceClone(_denomination, _token);
}
/**
* @dev Creates AddInstanceProposal with approve.
* @param _token address of ERC20 token for a new instance
@ -125,14 +112,14 @@ contract InstanceFactoryWithRegistry is InstanceFactory {
uint256[] memory _denominations,
uint32[] memory _protocolFees
) internal returns (address) {
require(_token.isContract(), "Token is not contract");
require(_token == address(0) || _token.isContract(), "Token is not contract");
require(_denominations.length > 0, "Empty denominations");
require(_denominations.length == _protocolFees.length, "Incorrect denominations/fees length");
// check Uniswap Pool
for (uint8 i = 0; i < _protocolFees.length; i++) {
if (_protocolFees[i] > 0) {
require(_protocolFees[i] <= 10000, "Protocol fee is more than 100%");
if (_protocolFees[i] > 0 && _token != address(0)) {
// pool exists
address poolAddr = UniswapV3Factory.getPool(_token, WETH, _uniswapPoolSwappingFee);
require(poolAddr != address(0), "Uniswap pool is not exist");
@ -144,19 +131,26 @@ contract InstanceFactoryWithRegistry is InstanceFactory {
}
address proposal = address(
new AddInstanceProposal(address(this), instanceRegistry, _token, _uniswapPoolSwappingFee, _denominations, _protocolFees)
new AddInstanceProposal(
address(instanceFactory),
instanceRegistry,
_token,
_uniswapPoolSwappingFee,
_denominations,
_protocolFees
)
);
emit NewGovernanceProposalCreated(proposal);
return proposal;
}
function setCreationFee(uint256 _creationFee) external onlyAdmin {
function setCreationFee(uint256 _creationFee) external onlyGovernance {
creationFee = _creationFee;
emit NewCreationFeeSet(_creationFee);
}
function setTWAPSlotsMin(uint16 _TWAPSlotsMin) external onlyAdmin {
function setTWAPSlotsMin(uint16 _TWAPSlotsMin) external onlyGovernance {
TWAPSlotsMin = _TWAPSlotsMin;
emit NewTWAPSlotsMinSet(_TWAPSlotsMin);
}

20
contracts/MultipleInstanceFactory.sol
View File

@ -1,20 +0,0 @@
// SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
import "./InstanceFactory.sol";
contract MultipleInstanceFactory is InstanceFactory {
/**
* @dev Creates new Tornado instances.
* @param _token address of ERC20 token for a new instance
* @param _denominations list of denominations for each new instance
*/
function createInstanceClones(address _token, uint256[] memory _denominations) external returns (address[] memory) {
address[] memory newClones = new address[](_denominations.length);
for (uint256 i = 0; i < _denominations.length; i++) {
newClones[i] = createInstanceClone(_denominations[i], _token);
}
return newClones;
}
}

29
contracts/SidechainInstanceFactory.sol Normal file
View File

@ -0,0 +1,29 @@
// SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
import "./InstanceFactory.sol";
contract SidechainInstanceFactory is InstanceFactory {
/**
* @dev Creates new Tornado instance. Overriding to move onlyAdmin check for sidechains.
* @param _denomination denomination of new Tornado instance
* @param _token address of ERC20 token for a new instance, if zero address, then it will be ETH
*/
function createInstanceClone(uint256 _denomination, address _token) public override returns (address clone) {
return _createInstanceClone(_denomination, _token);
}
/**
* @dev Creates new Tornado instances.
* @param _token address of ERC20 token for a new instance
* @param _denominations list of denominations for each new instance
*/
function createInstanceClones(address _token, uint256[] memory _denominations) external returns (address[] memory) {
address[] memory newClones = new address[](_denominations.length);
for (uint256 i = 0; i < _denominations.length; i++) {
newClones[i] = _createInstanceClone(_denominations[i], _token);
}
return newClones;
}
}

0
contracts/ERC20TornadoCloneable.sol → contracts/instances/ERC20TornadoCloneable.sol
View File

26
contracts/instances/ETHTornadoCloneable.sol Normal file
View File

@ -0,0 +1,26 @@
// SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
pragma abicoder v2;
import "tornado-core/contracts/ETHTornado.sol";
contract ETHTornadoCloneable is ETHTornado {
constructor(address verifier, address hasher) ETHTornado(IVerifier(verifier), IHasher(hasher), 1, 1) {}
function init(uint256 _denomination, uint32 _merkleTreeHeight) external {
require(denomination == 0 && levels == 0, "already initialized");
require(_denomination > 0, "denomination should be greater than 0");
denomination = _denomination;
require(_merkleTreeHeight > 0, "_levels should be greater than zero");
require(_merkleTreeHeight < 32, "_levels should be less than 32");
levels = _merkleTreeHeight;
for (uint32 i = 0; i < _merkleTreeHeight; i++) {
filledSubtrees[i] = zeros(i);
}
roots[0] = zeros(_merkleTreeHeight - 1);
}
}

8
contracts/interfaces/IInstanceFactory.sol Normal file
View File

@ -0,0 +1,8 @@
// SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
pragma abicoder v2;
interface IInstanceFactory {
function createInstanceClone(uint256 denomination, address token) external returns (address);
}

1
hardhat.config.js
View File

@ -3,6 +3,7 @@ require('@nomiclabs/hardhat-waffle')
require('@nomiclabs/hardhat-etherscan')
require('hardhat-log-remover')
require('solidity-coverage')
require('hardhat-contract-sizer')
/**
* @type import('hardhat/config').HardhatUserConfig

1
package.json
View File

@ -34,6 +34,7 @@
"eslint-plugin-prettier": "^3.4.0",
"ethereum-waffle": "^3.4.0",
"hardhat": "^2.4.3",
"hardhat-contract-sizer": "^2.6.1",
"hardhat-log-remover": "^2.0.2",
"mocha-lcov-reporter": "^1.3.0",
"prettier": "^2.3.2",

16
scripts/deployInstanceFactoryWithRegistry.js → scripts/deployInstanceProposalCreator.js
View File

@ -14,14 +14,14 @@ async function deploy({ address, bytecode, singletonFactory }) {
async function main() {
const singletonFactory = await ethers.getContractAt('SingletonFactory', config.singletonFactory)
const contracts = await generate()
await deploy({ ...contracts.factoryWithRegistryContract.implementation, singletonFactory })
await deploy({ ...contracts.factoryWithRegistryContract.proxy, singletonFactory })
console.log(
`Instance factory with registry contract have been deployed on ${contracts.factoryWithRegistryContract.implementation.address} address`,
)
console.log(
`Instance factory with registry proxy contract have been deployed on ${contracts.factoryWithRegistryContract.proxy.address} address`,
)
await deploy({ ...contracts.factory.implementation, singletonFactory })
console.log(`Instance factory contract have been deployed on ${contracts.factory.implementation.address}`)
await deploy({ ...contracts.factory.proxy, singletonFactory })
console.log(`Instance factory proxy contract have been deployed on ${contracts.factory.proxy.address}`)
await deploy({ ...contracts.proposalCreator.implementation, singletonFactory })
console.log(`Proposal creator have been deployed on ${contracts.proposalCreator.implementation.address}`)
await deploy({ ...contracts.proposalCreator.proxy, singletonFactory })
console.log(`Proposal creator proxy have been deployed on ${contracts.proposalCreator.proxy.address}`)
}
main()

8
scripts/deployMultipleInstanceFactory.js → scripts/deploySidechainInstanceFactory.js
View File

@ -14,13 +14,13 @@ async function deploy({ address, bytecode, singletonFactory }) {
async function main() {
const singletonFactory = await ethers.getContractAt('SingletonFactory', config.singletonFactory)
const contracts = await generate()
await deploy({ ...contracts.factoryContract.implementation, singletonFactory })
await deploy({ ...contracts.factoryContract.proxy, singletonFactory })
await deploy({ ...contracts.sidechainFactory.implementation, singletonFactory })
await deploy({ ...contracts.sidechainFactory.proxy, singletonFactory })
console.log(
`MultipleInstanceFactory contract have been deployed on ${contracts.factoryContract.implementation.address} address`,
`SidechainInstanceFactory contract have been deployed on ${contracts.sidechainFactory.implementation.address} address`,
)
console.log(
`MultipleInstanceFactory proxy contract have been deployed on ${contracts.factoryContract.proxy.address} address`,
`SidechainInstanceFactory proxy contract have been deployed on ${contracts.sidechainFactory.proxy.address} address`,
)
}

60
src/generateAddresses.js
View File

@ -36,52 +36,62 @@ async function upgradableContract({ contractName, implConstructorArgs, proxyCons
}
async function generate(config = defaultConfig) {
// factory contract -----------------------------------------------
const FactoryFactory = await ethers.getContractFactory('MultipleInstanceFactory')
const FactoryInitData = FactoryFactory.interface.encodeFunctionData('initialize', [
// sidechain factory contract -------------------------------------
const SidechainFactory = await ethers.getContractFactory('SidechainInstanceFactory')
const SidechainFactoryInitData = SidechainFactory.interface.encodeFunctionData('initialize', [
config.verifier,
config.hasher,
config.merkleTreeHeight,
config.admin,
])
const factoryContract = await upgradableContract({
contractName: 'MultipleInstanceFactory',
const sidechainFactory = await upgradableContract({
contractName: 'SidechainInstanceFactory',
implConstructorArgs: [],
proxyConstructorArgs: [config.admin, FactoryInitData],
proxyConstructorArgs: [config.admin, SidechainFactoryInitData],
salt: config.salt,
})
// factory with registry contract ---------------------------------
const FactoryWithRegistryFactory = await ethers.getContractFactory('InstanceFactoryWithRegistry')
const FactoryWithRegistryInitData = FactoryWithRegistryFactory.interface.encodeFunctionData(
'initialize(address,address,uint32,address,uint16,uint256)',
[
const Factory = await ethers.getContractFactory('InstanceFactory')
const FactoryInitData = Factory.interface.encodeFunctionData('initialize', [
config.verifier,
config.hasher,
config.merkleTreeHeight,
config.governance,
])
const factory = await upgradableContract({
contractName: 'InstanceFactory',
implConstructorArgs: [],
proxyConstructorArgs: [config.governance, FactoryInitData],
salt: config.salt,
})
const ProposalCreator = await ethers.getContractFactory('InstanceProposalCreator')
const ProposalCreatorInitData = ProposalCreator.interface.encodeFunctionData('initialize', [
config.TWAPSlotsMin,
config.creationFee,
],
)
])
const factoryWithRegistryContract = await upgradableContract({
contractName: 'InstanceFactoryWithRegistry',
const proposalCreator = await upgradableContract({
contractName: 'InstanceProposalCreator',
implConstructorArgs: [
config.governance,
factory.proxy.address,
config.instanceRegistry,
config.TORN,
config.UniswapV3Factory,
config.WETH,
],
proxyConstructorArgs: [config.governance, FactoryWithRegistryInitData],
proxyConstructorArgs: [config.governance, ProposalCreatorInitData],
salt: config.salt,
})
const result = {
factoryContract,
factoryWithRegistryContract,
sidechainFactory,
factory,
proposalCreator,
}
return result
@ -89,16 +99,12 @@ async function generate(config = defaultConfig) {
async function generateWithLog() {
const contracts = await generate()
console.log('MultipleInstanceFactory contract: ', contracts.factoryContract.implementation.address)
console.log('MultipleInstanceFactory proxy contract: ', contracts.factoryContract.proxy.address)
console.log(
'Instance factory with registry contract: ',
contracts.factoryWithRegistryContract.implementation.address,
)
console.log(
'Instance factory with registry proxy contract: ',
contracts.factoryWithRegistryContract.proxy.address,
)
console.log('SidechainInstanceFactory contract: ', contracts.sidechainFactory.implementation.address)
console.log('SidechainInstanceFactory proxy contract: ', contracts.sidechainFactory.proxy.address)
console.log('Instance factory contract: ', contracts.factory.implementation.address)
console.log('Instance factory proxy contract: ', contracts.factory.proxy.address)
console.log('Proposal creator contract: ', contracts.proposalCreator.implementation.address)
console.log('Proposal creator proxy contract: ', contracts.proposalCreator.proxy.address)
return contracts
}

480
test/factory.with.registry.test.js
View File

@ -51,31 +51,37 @@ describe('Instance Factory With Registry Tests', () => {
config.instanceRegistry,
)
// deploy InstanceFactoryWithRegistry with CREATE2
// deploy InstanceProposalCreator with CREATE2
const singletonFactory = await ethers.getContractAt(
'SingletonFactory',
config.singletonFactoryVerboseWrapper,
)
const contracts = await generate()
if (
(await ethers.provider.getCode(contracts.factoryWithRegistryContract.implementation.address)) == '0x'
) {
await singletonFactory.deploy(
contracts.factoryWithRegistryContract.implementation.bytecode,
config.salt,
{
gasLimit: config.deployGasLimit,
},
)
}
if ((await ethers.provider.getCode(contracts.factoryWithRegistryContract.proxy.address)) == '0x') {
await singletonFactory.deploy(contracts.factoryWithRegistryContract.proxy.bytecode, config.salt, {
if ((await ethers.provider.getCode(contracts.factory.implementation.address)) == '0x') {
await singletonFactory.deploy(contracts.factory.implementation.bytecode, config.salt, {
gasLimit: config.deployGasLimit,
})
}
const instanceFactory = await ethers.getContractAt(
'InstanceFactoryWithRegistry',
contracts.factoryWithRegistryContract.proxy.address,
if ((await ethers.provider.getCode(contracts.factory.proxy.address)) == '0x') {
await singletonFactory.deploy(contracts.factory.proxy.bytecode, config.salt, {
gasLimit: config.deployGasLimit,
})
}
const instanceFactory = await ethers.getContractAt('InstanceFactory', contracts.factory.proxy.address)
if ((await ethers.provider.getCode(contracts.proposalCreator.implementation.address)) == '0x') {
await singletonFactory.deploy(contracts.proposalCreator.implementation.bytecode, config.salt, {
gasLimit: config.deployGasLimit,
})
}
if ((await ethers.provider.getCode(contracts.proposalCreator.proxy.address)) == '0x') {
await singletonFactory.deploy(contracts.proposalCreator.proxy.bytecode, config.salt, {
gasLimit: config.deployGasLimit,
})
}
const proposalCreator = await ethers.getContractAt(
'InstanceProposalCreator',
contracts.proposalCreator.proxy.address,
)
return {
@ -90,73 +96,80 @@ describe('Instance Factory With Registry Tests', () => {
compToken,
instanceRegistry,
instanceFactory,
proposalCreator,
}
}
it('Should have initialized all successfully', async function () {
const { sender, gov, tornToken, instanceRegistry, instanceFactory } = await loadFixture(fixture)
const { sender, gov, tornToken, instanceRegistry, instanceFactory, proposalCreator } = await loadFixture(
fixture,
)
expect(sender.address).to.exist
expect(gov.address).to.exist
expect(tornToken.address).to.exist
expect(instanceRegistry.address).to.exist
expect(instanceFactory.address).to.exist
expect(proposalCreator.address).to.exist
})
it('Should set correct params for factory', async function () {
const { instanceFactory } = await loadFixture(fixture)
const { instanceFactory, proposalCreator } = await loadFixture(fixture)
expect(await instanceFactory.governance()).to.be.equal(config.governance)
expect(await proposalCreator.governance()).to.be.equal(config.governance)
expect(await instanceFactory.verifier()).to.be.equal(config.verifier)
expect(await instanceFactory.hasher()).to.be.equal(config.hasher)
expect(await instanceFactory.merkleTreeHeight()).to.be.equal(config.merkleTreeHeight)
expect(await instanceFactory.implementation()).to.exist
expect(await instanceFactory.creationFee()).to.be.equal(config.creationFee)
expect(await instanceFactory.torn()).to.be.equal(config.TORN)
expect(await instanceFactory.TWAPSlotsMin()).to.be.equal(config.TWAPSlotsMin)
expect(await instanceFactory.WETH()).to.be.equal(config.WETH)
expect(await instanceFactory.UniswapV3Factory()).to.be.equal(config.UniswapV3Factory)
expect(await instanceFactory.ERC20Impl()).to.exist
expect(await instanceFactory.nativeCurImpl()).to.exist
expect(await proposalCreator.creationFee()).to.be.equal(config.creationFee)
expect(await proposalCreator.torn()).to.be.equal(config.TORN)
expect(await proposalCreator.TWAPSlotsMin()).to.be.equal(config.TWAPSlotsMin)
expect(await proposalCreator.WETH()).to.be.equal(config.WETH)
expect(await proposalCreator.UniswapV3Factory()).to.be.equal(config.UniswapV3Factory)
})
it('Governance should be able to set factory params', async function () {
let { instanceFactory, gov } = await loadFixture(fixture)
it('Governance should be able to set factory/proposalCreator params', async function () {
let { instanceFactory, proposalCreator, gov } = await loadFixture(fixture)
await expect(instanceFactory.setMerkleTreeHeight(1)).to.be.reverted
const govSigner = await getSignerFromAddress(gov.address)
instanceFactory = await instanceFactory.connect(govSigner)
proposalCreator = await proposalCreator.connect(govSigner)
await instanceFactory.generateNewImplementation(addressZero, addressZero)
await instanceFactory.setMerkleTreeHeight(1)
await instanceFactory.setCreationFee(0)
await instanceFactory.setTWAPSlotsMin(0)
await proposalCreator.setCreationFee(0)
await proposalCreator.setTWAPSlotsMin(0)
expect(await instanceFactory.verifier()).to.be.equal(addressZero)
expect(await instanceFactory.hasher()).to.be.equal(addressZero)
expect(await instanceFactory.merkleTreeHeight()).to.be.equal(1)
expect(await instanceFactory.creationFee()).to.be.equal(0)
expect(await instanceFactory.TWAPSlotsMin()).to.be.equal(0)
expect(await proposalCreator.creationFee()).to.be.equal(0)
expect(await proposalCreator.TWAPSlotsMin()).to.be.equal(0)
await instanceFactory.generateNewImplementation(config.verifier, config.hasher)
await instanceFactory.setMerkleTreeHeight(config.merkleTreeHeight)
await instanceFactory.setCreationFee(config.creationFee)
await instanceFactory.setTWAPSlotsMin(config.TWAPSlotsMin)
await proposalCreator.setCreationFee(config.creationFee)
await proposalCreator.setTWAPSlotsMin(config.TWAPSlotsMin)
expect(await instanceFactory.verifier()).to.be.equal(config.verifier)
expect(await instanceFactory.hasher()).to.be.equal(config.hasher)
expect(await instanceFactory.merkleTreeHeight()).to.be.equal(config.merkleTreeHeight)
expect(await instanceFactory.creationFee()).to.be.equal(config.creationFee)
expect(await instanceFactory.TWAPSlotsMin()).to.be.equal(config.TWAPSlotsMin)
expect(await proposalCreator.creationFee()).to.be.equal(config.creationFee)
expect(await proposalCreator.TWAPSlotsMin()).to.be.equal(config.TWAPSlotsMin)
})
it('Should successfully deploy/propose/execute proposal - add instance', async function () {
let { sender, instanceFactory, gov, instanceRegistry, tornWhale, tornToken } = await loadFixture(fixture)
let { sender, instanceFactory, proposalCreator, gov, instanceRegistry, tornWhale, tornToken } =
await loadFixture(fixture)
// deploy proposal ----------------------------------------------
await tornToken.connect(tornWhale).transfer(sender.address, config.creationFee)
await tornToken.approve(instanceFactory.address, config.creationFee)
await tornToken.approve(proposalCreator.address, config.creationFee)
await expect(() =>
instanceFactory
proposalCreator
.connect(sender)
.createProposalApprove(config.COMP, 3000, [ethers.utils.parseEther('100')], [30]),
).to.changeTokenBalances(
@ -165,7 +178,7 @@ describe('Instance Factory With Registry Tests', () => {
[BigNumber.from(0).sub(config.creationFee), config.creationFee],
)
let logs = await instanceFactory.queryFilter('NewGovernanceProposalCreated')
let logs = await proposalCreator.queryFilter('NewGovernanceProposalCreated')
const proposal = await ethers.getContractAt(
'AddInstanceProposal',
ethers.utils.getAddress('0x' + logs[logs.length - 1].topics[1].slice(-40)),
@ -235,7 +248,8 @@ describe('Instance Factory With Registry Tests', () => {
})
it('Should successfully deploy/propose/execute proposal - add instances', async function () {
let { sender, instanceFactory, gov, instanceRegistry, tornWhale, tornToken } = await loadFixture(fixture)
let { sender, instanceFactory, proposalCreator, gov, instanceRegistry, tornWhale, tornToken } =
await loadFixture(fixture)
const denominations = [
ethers.utils.parseEther('1'),
@ -249,17 +263,17 @@ describe('Instance Factory With Registry Tests', () => {
// deploy proposal ----------------------------------------------
await tornToken.connect(tornWhale).transfer(sender.address, config.creationFee)
await tornToken.approve(instanceFactory.address, config.creationFee)
await tornToken.approve(proposalCreator.address, config.creationFee)
await expect(() =>
instanceFactory.connect(sender).createProposalApprove(config.COMP, 3000, denominations, protocolFees),
proposalCreator.connect(sender).createProposalApprove(config.COMP, 3000, denominations, protocolFees),
).to.changeTokenBalances(
tornToken,
[sender, gov],
[BigNumber.from(0).sub(config.creationFee), config.creationFee],
)
let logs = await instanceFactory.queryFilter('NewGovernanceProposalCreated')
let logs = await proposalCreator.queryFilter('NewGovernanceProposalCreated')
const proposal = await ethers.getContractAt(
'AddInstanceProposal',
ethers.utils.getAddress('0x' + logs[logs.length - 1].topics[1].slice(-40)),
@ -333,7 +347,9 @@ describe('Instance Factory With Registry Tests', () => {
})
it('Should successfully deploy proposal with permit', async function () {
let { instanceFactory, gov, instanceRegistry, tornWhale, tornToken } = await loadFixture(fixture)
let { instanceFactory, proposalCreator, gov, instanceRegistry, tornWhale, tornToken } = await loadFixture(
fixture,
)
const privateKey = '0xc87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3'
const publicKey = '0x' + ethers.utils.computeAddress(Buffer.from(privateKey.slice(2), 'hex'))
@ -358,7 +374,7 @@ describe('Instance Factory With Registry Tests', () => {
const curTimestamp = Math.trunc(new Date().getTime() / 1000)
const args = {
owner: sender,
spender: instanceFactory.address,
spender: proposalCreator.address,
value: config.creationFee,
nonce: 0,
deadline: curTimestamp + 1000,
@ -370,7 +386,7 @@ describe('Instance Factory With Registry Tests', () => {
expect(signer).to.equal(sender.address)
await expect(() =>
instanceFactory.createProposalPermit(
proposalCreator.createProposalPermit(
config.COMP,
3000,
[ethers.utils.parseEther('100')],
@ -387,7 +403,7 @@ describe('Instance Factory With Registry Tests', () => {
[BigNumber.from(0).sub(config.creationFee), config.creationFee],
)
let logs = await instanceFactory.queryFilter('NewGovernanceProposalCreated')
let logs = await proposalCreator.queryFilter('NewGovernanceProposalCreated')
const proposal = await ethers.getContractAt(
'AddInstanceProposal',
ethers.utils.getAddress('0x' + logs[logs.length - 1].topics[1].slice(-40)),
@ -403,15 +419,15 @@ describe('Instance Factory With Registry Tests', () => {
})
it('Should deposit and withdraw into the new instance', async function () {
let { sender, instanceFactory, gov, tornWhale, tornToken, router, compToken, compWhale } =
let { sender, proposalCreator, gov, tornWhale, tornToken, router, compToken, compWhale } =
await loadFixture(fixture)
// deploy proposal ----------------------------------------------
await tornToken.connect(tornWhale).transfer(sender.address, config.creationFee)
await tornToken.approve(instanceFactory.address, config.creationFee)
await tornToken.approve(proposalCreator.address, config.creationFee)
await expect(() =>
instanceFactory
proposalCreator
.connect(sender)
.createProposalApprove(config.COMP, 3000, [ethers.utils.parseEther('100')], [30]),
).to.changeTokenBalances(
@ -420,7 +436,7 @@ describe('Instance Factory With Registry Tests', () => {
[BigNumber.from(0).sub(config.creationFee), config.creationFee],
)
let logs = await instanceFactory.queryFilter('NewGovernanceProposalCreated')
let logs = await proposalCreator.queryFilter('NewGovernanceProposalCreated')
const proposal = await ethers.getContractAt(
'AddInstanceProposal',
ethers.utils.getAddress('0x' + logs[logs.length - 1].topics[1].slice(-40)),
@ -486,36 +502,382 @@ describe('Instance Factory With Registry Tests', () => {
})
it('Should not deploy proposal with incorrect Uniswap pool', async function () {
let { sender, instanceFactory, tornWhale, tornToken } = await loadFixture(fixture)
let { sender, proposalCreator, tornWhale, tornToken } = await loadFixture(fixture)
// deploy proposal ----------------------------------------------
await tornToken.connect(tornWhale).transfer(sender.address, config.creationFee)
await tornToken.approve(instanceFactory.address, config.creationFee)
await tornToken.approve(proposalCreator.address, config.creationFee)
await expect(
instanceFactory
proposalCreator
.connect(sender)
.createProposalApprove(config.COMP, 4000, [ethers.utils.parseEther('100')], [30]),
).to.be.revertedWith('Uniswap pool is not exist')
await expect(
instanceFactory
proposalCreator
.connect(sender)
.createProposalApprove(config.COMP, 10000, [ethers.utils.parseEther('100')], [30]),
).to.be.revertedWith('Uniswap pool TWAP slots number is low')
})
it('Should not deploy proposal with incorrect protocol fee', async function () {
let { sender, instanceFactory, tornWhale, tornToken } = await loadFixture(fixture)
let { sender, proposalCreator, tornWhale, tornToken } = await loadFixture(fixture)
// deploy proposal ----------------------------------------------
await tornToken.connect(tornWhale).transfer(sender.address, config.creationFee)
await tornToken.approve(instanceFactory.address, config.creationFee)
await tornToken.approve(proposalCreator.address, config.creationFee)
await expect(
instanceFactory
proposalCreator
.connect(sender)
.createProposalApprove(config.COMP, 3000, [ethers.utils.parseEther('100')], [10300]),
).to.be.revertedWith('Protocol fee is more than 100%')
})
it('Should successfully deploy/propose/execute proposal - add native instance', async function () {
let { sender, instanceFactory, proposalCreator, gov, instanceRegistry, tornWhale, tornToken } =
await loadFixture(fixture)
const denomination = ethers.utils.parseEther('1.5')
// deploy proposal ----------------------------------------------
await tornToken.connect(tornWhale).transfer(sender.address, config.creationFee)
await tornToken.approve(proposalCreator.address, config.creationFee)
await expect(() =>
proposalCreator.connect(sender).createProposalApprove(addressZero, 0, [denomination], [30]),
).to.changeTokenBalances(
tornToken,
[sender, gov],
[BigNumber.from(0).sub(config.creationFee), config.creationFee],
)
let logs = await proposalCreator.queryFilter('NewGovernanceProposalCreated')
const proposal = await ethers.getContractAt(
'AddInstanceProposal',
ethers.utils.getAddress('0x' + logs[logs.length - 1].topics[1].slice(-40)),
)
expect(await proposal.instanceFactory()).to.be.equal(instanceFactory.address)
expect(await proposal.instanceRegistry()).to.be.equal(instanceRegistry.address)
expect(await proposal.token()).to.be.equal(addressZero)
expect(await proposal.uniswapPoolSwappingFee()).to.be.equal(0)
expect(await proposal.numInstances()).to.be.equal(1)
expect(await proposal.protocolFeeByIndex(0)).to.be.equal(30)
expect(await proposal.denominationByIndex(0)).to.be.equal(denomination)
// propose proposal ---------------------------------------------
let response, id, state
gov = await gov.connect(tornWhale)
await tornToken.connect(tornWhale).approve(gov.address, ethers.utils.parseEther('26000'))
await gov.lockWithApproval(ethers.utils.parseEther('26000'))
response = await gov.propose(proposal.address, 'ETH 1.5 instance proposal')
id = await gov.latestProposalIds(tornWhale.address)
state = await gov.state(id)
const { events } = await response.wait()
const args = events.find(({ event }) => event == 'ProposalCreated').args
expect(args.id).to.be.equal(id)
expect(args.proposer).to.be.equal(tornWhale.address)
expect(args.target).to.be.equal(proposal.address)
expect(args.description).to.be.equal('ETH 1.5 instance proposal')
expect(state).to.be.equal(ProposalState.Pending)
// execute proposal ---------------------------------------------
await minewait((await gov.VOTING_DELAY()).add(1).toNumber())
await expect(gov.castVote(id, true)).to.not.be.reverted
expect(await gov.state(id)).to.be.equal(ProposalState.Active)
await minewait(
(
await gov.VOTING_PERIOD()
)
.add(await gov.EXECUTION_DELAY())
.add(96400)
.toNumber(),
)
expect(await gov.state(id)).to.be.equal(ProposalState.AwaitingExecution)
let tx = await gov.execute(id)
expect(await gov.state(id)).to.be.equal(ProposalState.Executed)
// check instance initialization --------------------------------
let receipt = await tx.wait()
const instanceAddr = '0x' + receipt.events[0].topics[1].toString().slice(-40)
const instance = await ethers.getContractAt('ETHTornadoCloneable', instanceAddr)
expect(await instance.verifier()).to.be.equal(config.verifier)
expect(await instance.hasher()).to.be.equal(config.hasher)
expect(await instance.levels()).to.be.equal(config.merkleTreeHeight)
expect(await instance.denomination()).to.equal(denomination)
const instanceData = await instanceRegistry.instances(instance.address)
expect(instanceData.isERC20).to.be.equal(false)
expect(instanceData.token).to.be.equal(addressZero)
expect(instanceData.state).to.be.equal(1)
expect(instanceData.uniswapPoolSwappingFee).to.be.equal(0)
expect(instanceData.protocolFeePercentage).to.be.equal(30)
})
it('Should successfully deploy/propose/execute proposal - add native instances', async function () {
let { sender, instanceFactory, proposalCreator, gov, instanceRegistry, tornWhale, tornToken } =
await loadFixture(fixture)
const denominations = [
ethers.utils.parseEther('1.5'),
ethers.utils.parseEther('10.5'),
ethers.utils.parseEther('100.5'),
ethers.utils.parseEther('1000.5'),
]
const numInstances = denominations.length
const protocolFees = [30, 30, 30, 30]
// deploy proposal ----------------------------------------------
await tornToken.connect(tornWhale).transfer(sender.address, config.creationFee)
await tornToken.approve(proposalCreator.address, config.creationFee)
await expect(() =>
proposalCreator.connect(sender).createProposalApprove(addressZero, 0, denominations, protocolFees),
).to.changeTokenBalances(
tornToken,
[sender, gov],
[BigNumber.from(0).sub(config.creationFee), config.creationFee],
)
let logs = await proposalCreator.queryFilter('NewGovernanceProposalCreated')
const proposal = await ethers.getContractAt(
'AddInstanceProposal',
ethers.utils.getAddress('0x' + logs[logs.length - 1].topics[1].slice(-40)),
)
expect(await proposal.instanceFactory()).to.be.equal(instanceFactory.address)
expect(await proposal.instanceRegistry()).to.be.equal(instanceRegistry.address)
expect(await proposal.token()).to.be.equal(addressZero)
expect(await proposal.uniswapPoolSwappingFee()).to.be.equal(0)
expect(await proposal.numInstances()).to.be.equal(numInstances)
for (let i = 0; i < numInstances; i++) {
expect(await proposal.protocolFeeByIndex(i)).to.be.equal(protocolFees[i])
expect(await proposal.denominationByIndex(i)).to.be.equal(denominations[i])
}
// propose proposal ---------------------------------------------
let response, id, state
gov = await gov.connect(tornWhale)
await tornToken.connect(tornWhale).approve(gov.address, ethers.utils.parseEther('26000'))
await gov.lockWithApproval(ethers.utils.parseEther('26000'))
response = await gov.propose(proposal.address, 'ETH instances proposal')
id = await gov.latestProposalIds(tornWhale.address)
state = await gov.state(id)
const { events } = await response.wait()
const args = events.find(({ event }) => event == 'ProposalCreated').args
expect(args.id).to.be.equal(id)
expect(args.proposer).to.be.equal(tornWhale.address)
expect(args.target).to.be.equal(proposal.address)
expect(args.description).to.be.equal('ETH instances proposal')
expect(state).to.be.equal(ProposalState.Pending)
// execute proposal ---------------------------------------------
await minewait((await gov.VOTING_DELAY()).add(1).toNumber())
await expect(gov.castVote(id, true)).to.not.be.reverted
expect(await gov.state(id)).to.be.equal(ProposalState.Active)
await minewait(
(
await gov.VOTING_PERIOD()
)
.add(await gov.EXECUTION_DELAY())
.add(96400)
.toNumber(),
)
expect(await gov.state(id)).to.be.equal(ProposalState.AwaitingExecution)
await gov.execute(id)
expect(await gov.state(id)).to.be.equal(ProposalState.Executed)
// check instances initialization -------------------------------
logs = await instanceFactory.queryFilter('NewInstanceCloneCreated')
for (let i = 0; i < numInstances; i++) {
let instanceAddr = '0x' + logs[logs.length - numInstances + i].topics[1].slice(-40)
let instance = await ethers.getContractAt('ETHTornadoCloneable', instanceAddr)
expect(await instance.verifier()).to.be.equal(config.verifier)
expect(await instance.hasher()).to.be.equal(config.hasher)
expect(await instance.levels()).to.be.equal(config.merkleTreeHeight)
expect(await instance.denomination()).to.equal(denominations[i])
let instanceData = await instanceRegistry.instances(instance.address)
expect(instanceData.isERC20).to.be.equal(false)
expect(instanceData.token).to.be.equal(addressZero)
expect(instanceData.state).to.be.equal(1)
expect(instanceData.uniswapPoolSwappingFee).to.be.equal(0)
expect(instanceData.protocolFeePercentage).to.be.equal(protocolFees[i])
}
})
it('Should successfully deploy proposal with permit for native', async function () {
let { instanceFactory, proposalCreator, gov, instanceRegistry, tornWhale, tornToken } = await loadFixture(
fixture,
)
const denomination = ethers.utils.parseEther('1.5')
const privateKey = '0xc87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3'
const publicKey = '0x' + ethers.utils.computeAddress(Buffer.from(privateKey.slice(2), 'hex'))
const sender = await ethers.getSigner(publicKey.slice(2))
await expect(() =>
tornToken.connect(tornWhale).transfer(sender.address, config.creationFee),
).to.changeTokenBalances(
tornToken,
[tornWhale, sender],
[BigNumber.from(0).sub(config.creationFee), config.creationFee],
)
// prepare permit data
const domain = {
name: await tornToken.name(),
version: '1',
chainId: 1,
verifyingContract: tornToken.address,
}
const curTimestamp = Math.trunc(new Date().getTime() / 1000)
const args = {
owner: sender,
spender: proposalCreator.address,
value: config.creationFee,
nonce: 0,
deadline: curTimestamp + 1000,
}
const permitSigner = new PermitSigner(domain, args)
const signature = await permitSigner.getSignature(privateKey)
const signer = await permitSigner.getSignerAddress(args, signature.hex)
expect(signer).to.equal(sender.address)
await expect(() =>
proposalCreator.createProposalPermit(
addressZero,
0,
[denomination],
[30],
sender.address,
args.deadline.toString(),
signature.v,
signature.r,
signature.s,
),
).to.changeTokenBalances(
tornToken,
[sender, gov],
[BigNumber.from(0).sub(config.creationFee), config.creationFee],
)
let logs = await proposalCreator.queryFilter('NewGovernanceProposalCreated')
const proposal = await ethers.getContractAt(
'AddInstanceProposal',
ethers.utils.getAddress('0x' + logs[logs.length - 1].topics[1].slice(-40)),
)
expect(await proposal.instanceFactory()).to.be.equal(instanceFactory.address)
expect(await proposal.instanceRegistry()).to.be.equal(instanceRegistry.address)
expect(await proposal.token()).to.be.equal(addressZero)
expect(await proposal.uniswapPoolSwappingFee()).to.be.equal(0)
expect(await proposal.numInstances()).to.be.equal(1)
expect(await proposal.protocolFeeByIndex(0)).to.be.equal(30)
expect(await proposal.denominationByIndex(0)).to.be.equal(denomination)
})
it('Should deposit and withdraw into the new native instance', async function () {
let { sender, proposalCreator, gov, tornWhale, tornToken, router } = await loadFixture(fixture)
const denomination = ethers.utils.parseEther('1.5')
// deploy proposal ----------------------------------------------
await tornToken.connect(tornWhale).transfer(sender.address, config.creationFee)
await tornToken.approve(proposalCreator.address, config.creationFee)
await expect(() =>
proposalCreator.connect(sender).createProposalApprove(addressZero, 0, [denomination], [30]),
).to.changeTokenBalances(
tornToken,
[sender, gov],
[BigNumber.from(0).sub(config.creationFee), config.creationFee],
)
let logs = await proposalCreator.queryFilter('NewGovernanceProposalCreated')
const proposal = await ethers.getContractAt(
'AddInstanceProposal',
ethers.utils.getAddress('0x' + logs[logs.length - 1].topics[1].slice(-40)),
)
// propose proposal ---------------------------------------------
let id
gov = await gov.connect(tornWhale)
await tornToken.connect(tornWhale).approve(gov.address, ethers.utils.parseEther('26000'))
await gov.lockWithApproval(ethers.utils.parseEther('26000'))
await gov.propose(proposal.address, 'ETH instance proposal')
id = await gov.latestProposalIds(tornWhale.address)
// execute proposal ---------------------------------------------
await minewait((await gov.VOTING_DELAY()).add(1).toNumber())
await expect(gov.castVote(id, true)).to.not.be.reverted
await minewait(
(
await gov.VOTING_PERIOD()
)
.add(await gov.EXECUTION_DELAY())
.add(96400)
.toNumber(),
)
let tx = await gov.execute(id)
let receipt = await tx.wait()
const instanceAddr = '0x' + receipt.events[0].topics[1].toString().slice(-40)
const instance = await ethers.getContractAt('ETHTornadoCloneable', instanceAddr)
// check instance work ------------------------------------------
const depo = createDeposit({
nullifier: rbigint(31),
secret: rbigint(31),
})
await expect(() =>
router.deposit(instance.address, toHex(depo.commitment), [], { value: denomination }),
).to.changeEtherBalances([sender, instance], [BigNumber.from(0).sub(denomination), denomination])
let pevents = await instance.queryFilter('Deposit')
await initialize({ merkleTreeHeight: 20 })
const { proof, args } = await generateProof({
deposit: depo,
recipient: sender.address,
events: pevents,
})
await expect(() => router.withdraw(instance.address, proof, ...args)).to.changeEtherBalances(
[instance, sender],
[BigNumber.from(0).sub(denomination), denomination],
)
})
it('Should not deploy native currency proposal with incorrect protocol fee', async function () {
let { sender, proposalCreator, tornWhale, tornToken } = await loadFixture(fixture)
// deploy proposal ----------------------------------------------
await tornToken.connect(tornWhale).transfer(sender.address, config.creationFee)
await tornToken.approve(proposalCreator.address, config.creationFee)
await expect(
proposalCreator
.connect(sender)
.createProposalApprove(addressZero, 0, [ethers.utils.parseEther('1.5')], [10300]),
).to.be.revertedWith('Protocol fee is more than 100%')
})
})

115
test/multiple.instance.factory.test.js → test/sidechain.instance.factory.test.js
View File

@ -8,7 +8,7 @@ const { getSignerFromAddress } = require('./utils')
const { generate } = require('../src/generateAddresses')
const { rbigint, createDeposit, toHex, generateProof, initialize } = require('tornado-cli')
describe('Multiple Instance Factory Tests', () => {
describe('Sidechain Instance Factory Tests', () => {
const addressZero = ethers.constants.AddressZero
async function fixture() {
@ -34,19 +34,19 @@ describe('Multiple Instance Factory Tests', () => {
config.singletonFactoryVerboseWrapper,
)
const contracts = await generate()
if ((await ethers.provider.getCode(contracts.factoryContract.implementation.address)) == '0x') {
await singletonFactory.deploy(contracts.factoryContract.implementation.bytecode, config.salt, {
if ((await ethers.provider.getCode(contracts.sidechainFactory.implementation.address)) == '0x') {
await singletonFactory.deploy(contracts.sidechainFactory.implementation.bytecode, config.salt, {
gasLimit: config.deployGasLimit,
})
}
if ((await ethers.provider.getCode(contracts.factoryContract.proxy.address)) == '0x') {
await singletonFactory.deploy(contracts.factoryContract.proxy.bytecode, config.salt, {
if ((await ethers.provider.getCode(contracts.sidechainFactory.proxy.address)) == '0x') {
await singletonFactory.deploy(contracts.sidechainFactory.proxy.bytecode, config.salt, {
gasLimit: config.deployGasLimit,
})
}
const instanceFactory = await ethers.getContractAt(
'MultipleInstanceFactory',
contracts.factoryContract.proxy.address,
'SidechainInstanceFactory',
contracts.sidechainFactory.proxy.address,
)
return {
@ -72,10 +72,11 @@ describe('Multiple Instance Factory Tests', () => {
expect(await instanceFactory.verifier()).to.be.equal(config.verifier)
expect(await instanceFactory.hasher()).to.be.equal(config.hasher)
expect(await instanceFactory.merkleTreeHeight()).to.be.equal(config.merkleTreeHeight)
expect(await instanceFactory.implementation()).to.exist
expect(await instanceFactory.ERC20Impl()).to.exist
expect(await instanceFactory.nativeCurImpl()).to.exist
})
it('Governance should be able to set factory params', async function () {
it('Admin should be able to set factory params', async function () {
let { instanceFactory, owner } = await loadFixture(fixture)
await expect(instanceFactory.setMerkleTreeHeight(1)).to.be.reverted
@ -196,4 +197,100 @@ describe('Multiple Instance Factory Tests', () => {
[BigNumber.from(0).sub(value), value],
)
})
it('Should successfully add native currency instance', async function () {
let { sender, instanceFactory } = await loadFixture(fixture)
const denomination = ethers.utils.parseEther('1')
// deploy instance
await instanceFactory.connect(sender).createInstanceClone(denomination, addressZero)
// check instance initialization
let logs = await instanceFactory.queryFilter('NewInstanceCloneCreated')
const instance = await ethers.getContractAt(
'ETHTornadoCloneable',
ethers.utils.getAddress('0x' + logs[logs.length - 1].topics[1].slice(-40)),
)
expect(await instance.verifier()).to.be.equal(config.verifier)
expect(await instance.hasher()).to.be.equal(config.hasher)
expect(await instance.levels()).to.be.equal(config.merkleTreeHeight)
expect(await instance.denomination()).to.equal(denomination)
// try to deploy the same instance again
await instanceFactory.connect(sender).createInstanceClone(denomination, addressZero)
// check that instance has not been created - no new NewInstanceCloneCreated event
let curLogs = await instanceFactory.queryFilter('NewInstanceCloneCreated')
expect(curLogs.length).to.be.equal(logs.length)
})
it('Should successfully add native currency instances', async function () {
let { sender, instanceFactory } = await loadFixture(fixture)
const denominations = [
ethers.utils.parseEther('1'),
ethers.utils.parseEther('10'),
ethers.utils.parseEther('100'),
ethers.utils.parseEther('1000'),
]
const numInstances = denominations.length
// deploy instances
await instanceFactory.connect(sender).createInstanceClones(addressZero, denominations)
// check instance initialization
let logs = await instanceFactory.queryFilter('NewInstanceCloneCreated')
for (let i = 0; i < numInstances; i++) {
let instanceAddr = '0x' + logs[logs.length - numInstances + i].topics[1].slice(-40)
let instance = await ethers.getContractAt('ETHTornadoCloneable', instanceAddr)
expect(await instance.verifier()).to.be.equal(config.verifier)
expect(await instance.hasher()).to.be.equal(config.hasher)
expect(await instance.levels()).to.be.equal(config.merkleTreeHeight)
expect(await instance.denomination()).to.equal(denominations[i])
}
})
it('Should deposit and withdraw into the new native currency instance', async function () {
let { sender, instanceFactory } = await loadFixture(fixture)
const denomination = ethers.utils.parseEther('1.5')
// deploy instance
await instanceFactory.connect(sender).createInstanceClone(denomination, addressZero)
let logs = await instanceFactory.queryFilter('NewInstanceCloneCreated')
const instance = await ethers.getContractAt(
'ETHTornadoCloneable',
ethers.utils.getAddress('0x' + logs[logs.length - 1].topics[1].slice(-40)),
)
// check instance work ------------------------------------------
const depo = createDeposit({
nullifier: rbigint(31),
secret: rbigint(31),
})
await expect(() =>
instance.connect(sender).deposit(toHex(depo.commitment), {
value: denomination,
}),
).to.changeEtherBalances([sender, instance], [BigNumber.from(0).sub(denomination), denomination])
let pevents = await instance.queryFilter('Deposit')
await initialize({ merkleTreeHeight: 20 })
const { proof, args } = await generateProof({
deposit: depo,
recipient: sender.address,
events: pevents,
})
await expect(() => instance.withdraw(proof, ...args)).to.changeEtherBalances(
[instance, sender],
[BigNumber.from(0).sub(denomination), denomination],
)
})
})

22
yarn.lock
View File

@ -617,6 +617,11 @@
"@babel/helper-validator-identifier" "^7.14.9"
to-fast-properties "^2.0.0"
"@colors/colors@1.5.0":
version "1.5.0"
resolved "https://registry.yarnpkg.com/@colors/colors/-/colors-1.5.0.tgz#bb504579c1cae923e6576a4f5da43d25f97bdbd9"
integrity sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==
"@consento/sync-randombytes@^1.0.4", "@consento/sync-randombytes@^1.0.5":
version "1.0.5"
resolved "https://registry.yarnpkg.com/@consento/sync-randombytes/-/sync-randombytes-1.0.5.tgz#5be6bc58c6a6fa6e09f04cc684d037e29e6c28d5"
@ -6311,6 +6316,15 @@ cli-spinners@^2.0.0:
resolved "https://registry.yarnpkg.com/cli-spinners/-/cli-spinners-2.6.1.tgz#adc954ebe281c37a6319bfa401e6dd2488ffb70d"
integrity sha512-x/5fWmGMnbKQAaNwN+UZlV79qBLM9JFnJuJ03gIi5whrob0xV0ofNVHy9DhwGdsMJQc2OKv0oGmLzvaqvAVv+g==
cli-table3@^0.6.0:
version "0.6.2"
resolved "https://registry.yarnpkg.com/cli-table3/-/cli-table3-0.6.2.tgz#aaf5df9d8b5bf12634dc8b3040806a0c07120d2a"
integrity sha512-QyavHCaIC80cMivimWu4aWHilIpiDpfm3hGmqAmXVL1UsnbLuBSMd21hTX6VY4ZSDSM73ESLeF8TOYId3rBTbw==
dependencies:
string-width "^4.2.0"
optionalDependencies:
"@colors/colors" "1.5.0"
cli-width@^2.0.0:
version "2.2.1"
resolved "https://registry.yarnpkg.com/cli-width/-/cli-width-2.2.1.tgz#b0433d0b4e9c847ef18868a4ef16fd5fc8271c48"
@ -10216,6 +10230,14 @@ har-validator@~5.1.3:
ajv "^6.12.3"
har-schema "^2.0.0"
hardhat-contract-sizer@^2.6.1:
version "2.6.1"
resolved "https://registry.yarnpkg.com/hardhat-contract-sizer/-/hardhat-contract-sizer-2.6.1.tgz#2b0046a55fa1ec96f19fdab7fde372377401c874"
integrity sha512-b8wS7DBvyo22kmVwpzstAQTdDCThpl/ySBqZh5ga9Yxjf61/uTL12TEg5nl7lDeWy73ntEUzxMwY6XxbQEc2wA==
dependencies:
chalk "^4.0.0"
cli-table3 "^0.6.0"
hardhat-log-remover@^2.0.2:
version "2.0.2"
resolved "https://registry.yarnpkg.com/hardhat-log-remover/-/hardhat-log-remover-2.0.2.tgz#6014fe2c515ced1e0eaa7a4d854e37695aaac61a"