355 lines
11 KiB
TypeScript
355 lines
11 KiB
TypeScript
import fs from 'fs';
|
|
import path from 'path';
|
|
import hardhat, { ethers } from 'hardhat';
|
|
import {
|
|
type ERC20Mock,
|
|
type InstanceRegistry,
|
|
ERC20Mock__factory,
|
|
TORN__factory,
|
|
Governance__factory,
|
|
ETHTornado__factory,
|
|
ERC20Tornado__factory,
|
|
Vesting__factory,
|
|
TestnetGovernanceProxy__factory,
|
|
TestnetAdminProxy__factory,
|
|
GasCompensationVault__factory,
|
|
InstanceRegistry__factory,
|
|
GovernanceProposalStateUpgrade__factory,
|
|
RelayerRegistry__factory,
|
|
TornadoStakingRewards__factory,
|
|
TornadoRouter__factory,
|
|
TornadoVault__factory,
|
|
Echoer__factory,
|
|
TestnetFeeManager__factory,
|
|
} from '../typechain-types';
|
|
import type { SignerWithAddress } from '@nomicfoundation/hardhat-ethers/signers';
|
|
const {
|
|
ZeroAddress,
|
|
parseEther,
|
|
deployContract
|
|
} = ethers;
|
|
|
|
type contracts = {
|
|
[key in string]: {
|
|
DAI: string,
|
|
ENS: string,
|
|
}
|
|
}
|
|
|
|
const contracts: contracts = {
|
|
hardhat: {
|
|
DAI: '',
|
|
ENS: '',
|
|
},
|
|
develop: {
|
|
DAI: '',
|
|
ENS: '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e',
|
|
},
|
|
sepolia: {
|
|
// https://staging.aave.com/faucet/
|
|
DAI: '0xFF34B3d4Aee8ddCd6F9AFFFB6Fe49bD371b8a357',
|
|
ENS: '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e',
|
|
}
|
|
};
|
|
|
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
|
const toFixedHex = (number: number, length = 32) => {
|
|
return '0x' + BigInt(number).toString(16).padStart(length * 2, '0');
|
|
};
|
|
|
|
async function deployHasher(owner: SignerWithAddress) {
|
|
const bytecode = fs.readFileSync(path.join(__dirname, './hasherBytecode.txt'), { encoding: 'utf8' });
|
|
|
|
const txReceipt = await owner.sendTransaction({ data: bytecode }).then(t => t.wait());
|
|
|
|
return txReceipt?.contractAddress as unknown as string;
|
|
}
|
|
|
|
async function deployInstances() {
|
|
const [owner] = await ethers.getSigners();
|
|
const { DAI: daiAddress } = contracts[hardhat.network.name];
|
|
|
|
let DAI: ERC20Mock;
|
|
|
|
if (!daiAddress) {
|
|
DAI = await new ERC20Mock__factory(owner).deploy();
|
|
await DAI.waitForDeployment();
|
|
|
|
await DAI.mint(owner.address, parseEther('100000000')).then(t => t.wait());
|
|
} else {
|
|
DAI = ERC20Mock__factory.connect(daiAddress, owner);
|
|
}
|
|
|
|
const Hasher = await deployHasher(owner);
|
|
|
|
const Verifier = await deployContract('Verifier');
|
|
await Verifier.waitForDeployment();
|
|
|
|
const ETHTornadoFactory = new ETHTornado__factory(owner);
|
|
|
|
const ETHTornado1 = await ETHTornadoFactory.deploy(Verifier.target, Hasher, parseEther('0.1'), 20);
|
|
await ETHTornado1.waitForDeployment();
|
|
const ETHTornado2 = await ETHTornadoFactory.deploy(Verifier.target, Hasher, parseEther('1'), 20);
|
|
await ETHTornado2.waitForDeployment();
|
|
const ETHTornado3 = await ETHTornadoFactory.deploy(Verifier.target, Hasher, parseEther('10'), 20);
|
|
await ETHTornado3.waitForDeployment();
|
|
const ETHTornado4 = await ETHTornadoFactory.deploy(Verifier.target, Hasher, parseEther('100'), 20);
|
|
await ETHTornado4.waitForDeployment();
|
|
|
|
// Check if deposit works
|
|
// console.log(await ETHTornado1.deposit(toFixedHex(42), { value: parseEther('0.1') }).then(t => t.wait()))
|
|
|
|
const DAITornadoFactory = new ERC20Tornado__factory(owner);
|
|
|
|
const DAITornado1 = await DAITornadoFactory.deploy(Verifier.target, Hasher, parseEther('100'), 20, DAI.target);
|
|
await DAITornado1.waitForDeployment();
|
|
const DAITornado2 = await DAITornadoFactory.deploy(Verifier.target, Hasher, parseEther('1000'), 20, DAI.target);
|
|
await DAITornado2.waitForDeployment();
|
|
const DAITornado3 = await DAITornadoFactory.deploy(Verifier.target, Hasher, parseEther('10000'), 20, DAI.target);
|
|
await DAITornado3.waitForDeployment();
|
|
const DAITornado4 = await DAITornadoFactory.deploy(Verifier.target, Hasher, parseEther('100000'), 20, DAI.target);
|
|
await DAITornado4.waitForDeployment();
|
|
|
|
const ethInstance = {
|
|
isERC20: false,
|
|
token: ZeroAddress,
|
|
state: 1,
|
|
uniswapPoolSwappingFee: 0,
|
|
protocolFeePercentage: 0,
|
|
};
|
|
|
|
const daiInstance = {
|
|
isERC20: true,
|
|
token: DAI.target,
|
|
state: 1,
|
|
uniswapPoolSwappingFee: 3000,
|
|
protocolFeePercentage: 0,
|
|
};
|
|
|
|
const instances = [
|
|
{
|
|
addr: ETHTornado1.target,
|
|
instance: ethInstance,
|
|
},
|
|
{
|
|
addr: ETHTornado2.target,
|
|
instance: {
|
|
...ethInstance,
|
|
protocolFeePercentage: 30,
|
|
},
|
|
},
|
|
{
|
|
addr: ETHTornado3.target,
|
|
instance: {
|
|
...ethInstance,
|
|
protocolFeePercentage: 30,
|
|
},
|
|
},
|
|
{
|
|
addr: ETHTornado4.target,
|
|
instance: {
|
|
...ethInstance,
|
|
protocolFeePercentage: 30,
|
|
},
|
|
},
|
|
{
|
|
addr: DAITornado1.target,
|
|
instance: daiInstance,
|
|
},
|
|
{
|
|
addr: DAITornado2.target,
|
|
instance: daiInstance,
|
|
},
|
|
{
|
|
addr: DAITornado3.target,
|
|
instance: {
|
|
...daiInstance,
|
|
protocolFeePercentage: 30,
|
|
},
|
|
},
|
|
{
|
|
addr: DAITornado4.target,
|
|
instance: {
|
|
...daiInstance,
|
|
protocolFeePercentage: 30,
|
|
},
|
|
},
|
|
];
|
|
|
|
console.log({
|
|
DAI: DAI.target,
|
|
Hasher: Hasher,
|
|
Verifier: Verifier.target,
|
|
instances,
|
|
});
|
|
|
|
return {
|
|
DAI,
|
|
Hasher,
|
|
Verifier,
|
|
instances,
|
|
};
|
|
}
|
|
|
|
async function deployGovernance(instances: InstanceRegistry.TornadoStruct[]): Promise<void> {
|
|
const [owner] = await ethers.getSigners();
|
|
const { ENS: ensAddress } = contracts[hardhat.network.name];
|
|
|
|
// Deploy V1 logic contact first
|
|
const GovernanceV1 = await new Governance__factory(owner).deploy();
|
|
await GovernanceV1.waitForDeployment();
|
|
|
|
// This is what almost every contract would need for constructor args
|
|
const GovernanceProxy = await new TestnetGovernanceProxy__factory(owner).deploy(GovernanceV1.target, '0x');
|
|
await GovernanceProxy.waitForDeployment();
|
|
|
|
const TORN = await new TORN__factory(owner).deploy(
|
|
GovernanceProxy.target,
|
|
0,
|
|
[
|
|
{
|
|
to: owner.address,
|
|
amount: parseEther('10000000')
|
|
}
|
|
]
|
|
);
|
|
await TORN.waitForDeployment();
|
|
|
|
// Initialize governance v1 with TORN address
|
|
await (Governance__factory.connect(GovernanceProxy.target as string, owner)).initialize(TORN.target).then(t => t.wait());
|
|
|
|
// Create governance vesting contract
|
|
const GovernanceVesting = await new Vesting__factory(owner).deploy(
|
|
TORN.target,
|
|
GovernanceProxy.target,
|
|
0,
|
|
3,
|
|
60
|
|
);
|
|
await GovernanceVesting.waitForDeployment();
|
|
|
|
await TORN.transfer(GovernanceVesting.target, parseEther('2500000')).then(t => t.wait());
|
|
|
|
// Deploy other governance contracts
|
|
const ProxyFactory = new TestnetAdminProxy__factory(owner);
|
|
|
|
// Deploy gas compensation vault
|
|
const GasCompensationVault = await new GasCompensationVault__factory(owner).deploy(GovernanceProxy.target);
|
|
await GasCompensationVault.waitForDeployment();
|
|
|
|
// Deploy user vault
|
|
const TornadoVault = await new TornadoVault__factory(owner).deploy(TORN.target, GovernanceProxy.target);
|
|
await TornadoVault.waitForDeployment();
|
|
|
|
// Deploy instance registry
|
|
const InstanceRegistryImpl = await new InstanceRegistry__factory(owner).deploy(GovernanceProxy.target);
|
|
await InstanceRegistryImpl.waitForDeployment();
|
|
|
|
const InstanceRegistryProxy = await ProxyFactory.deploy(InstanceRegistryImpl.target, GovernanceProxy.target, '0x');
|
|
await InstanceRegistryProxy.waitForDeployment();
|
|
|
|
// Deploy FeeManager
|
|
const FeeManagerImpl = await new TestnetFeeManager__factory(owner).deploy(TORN.target, GovernanceProxy.target, InstanceRegistryProxy.target);
|
|
await FeeManagerImpl.waitForDeployment();
|
|
|
|
const FeeManagerProxy = await ProxyFactory.deploy(FeeManagerImpl.target, GovernanceProxy.target, '0x');
|
|
await FeeManagerProxy.waitForDeployment();
|
|
|
|
// Deploy RelayerRegistry & TornadoStakingRewards
|
|
const RelayerRegistryMock = await new RelayerRegistry__factory(owner).deploy(
|
|
TORN.target,
|
|
GovernanceProxy.target,
|
|
ensAddress || ZeroAddress,
|
|
ZeroAddress, // Use this as zero address as we don't know the proxy address yet
|
|
FeeManagerProxy.target,
|
|
);
|
|
await RelayerRegistryMock.waitForDeployment();
|
|
|
|
const RelayerRegistryProxy = await ProxyFactory.deploy(RelayerRegistryMock.target, GovernanceProxy.target, '0x');
|
|
await RelayerRegistryProxy.waitForDeployment();
|
|
|
|
const TornadoStakingRewardsImpl = await new TornadoStakingRewards__factory(owner).deploy(
|
|
GovernanceProxy.target,
|
|
TORN.target,
|
|
RelayerRegistryProxy.target
|
|
);
|
|
await TornadoStakingRewardsImpl.waitForDeployment();
|
|
|
|
const TornadoStakingRewardsProxy = await ProxyFactory.deploy(TornadoStakingRewardsImpl.target, GovernanceProxy.target, '0x');
|
|
await TornadoStakingRewardsProxy.waitForDeployment();
|
|
|
|
const RelayerRegistryImpl = await new RelayerRegistry__factory(owner).deploy(
|
|
TORN.target,
|
|
GovernanceProxy.target,
|
|
ensAddress || ZeroAddress,
|
|
TornadoStakingRewardsProxy.target,
|
|
FeeManagerProxy.target,
|
|
);
|
|
await RelayerRegistryImpl.waitForDeployment();
|
|
|
|
await (TestnetAdminProxy__factory.connect(RelayerRegistryProxy.target as string, owner)).upgradeToOwner(RelayerRegistryImpl.target).then(t => t.wait());
|
|
|
|
// Deploy Echoer
|
|
const Echoer = await new Echoer__factory(owner).deploy();
|
|
await Echoer.waitForDeployment();
|
|
|
|
// Deploy TornadoRouter
|
|
const TornadoRouter = await new TornadoRouter__factory(owner).deploy(
|
|
GovernanceProxy.target,
|
|
InstanceRegistryProxy.target,
|
|
RelayerRegistryProxy.target
|
|
);
|
|
await TornadoRouter.waitForDeployment();
|
|
|
|
// Initialize InstanceRegistry
|
|
await (InstanceRegistry__factory.connect(InstanceRegistryProxy.target as string, owner)).initialize(
|
|
instances,
|
|
TornadoRouter.target
|
|
).then(t => t.wait());
|
|
|
|
// Initialize RelayerRegistry
|
|
await (RelayerRegistry__factory.connect(RelayerRegistryProxy.target as string, owner)).initialize(
|
|
TornadoRouter.target
|
|
).then(t => t.wait());
|
|
|
|
// Upgrade Governance
|
|
const GovernanceV5 = await new GovernanceProposalStateUpgrade__factory(owner).deploy(
|
|
TornadoStakingRewardsProxy.target,
|
|
GasCompensationVault.target,
|
|
TornadoVault.target
|
|
);
|
|
await GovernanceV5.waitForDeployment();
|
|
|
|
await (TestnetGovernanceProxy__factory.connect(GovernanceProxy.target as string, owner)).upgradeToOwner(GovernanceV5.target).then(t => t.wait());
|
|
|
|
// Finalize contracts
|
|
await owner.sendTransaction({ to: GasCompensationVault.target, value: parseEther('0.1') }).then(t => t.wait());
|
|
|
|
console.log({
|
|
TORN: TORN.target,
|
|
GovernanceProxy: GovernanceProxy.target,
|
|
GovernanceV1: GovernanceV1.target,
|
|
GovernanceV5: GovernanceV5.target,
|
|
GovernanceVesting: GovernanceVesting.target,
|
|
GasCompensationVault: GasCompensationVault.target,
|
|
TornadoVault: TornadoVault.target,
|
|
InstanceRegistryProxy: InstanceRegistryProxy.target,
|
|
InstanceRegistryImpl: InstanceRegistryImpl.target,
|
|
FeeManagerProxy: FeeManagerProxy.target,
|
|
FeeManagerImpl: FeeManagerImpl.target,
|
|
RelayerRegistryProxy: RelayerRegistryProxy.target,
|
|
RelayerRegistryImpl: RelayerRegistryImpl.target,
|
|
RelayerRegistryMock: RelayerRegistryMock.target,
|
|
TornadoStakingRewardsProxy: TornadoStakingRewardsProxy.target,
|
|
TornadoStakingRewardsImpl: TornadoStakingRewardsImpl.target,
|
|
TornadoRouter: TornadoRouter.target,
|
|
Echoer: Echoer.target,
|
|
});
|
|
}
|
|
|
|
async function deploy() {
|
|
const { instances } = await deployInstances();
|
|
await deployGovernance(instances);
|
|
}
|
|
|
|
deploy(); |