generated from balancer/balancer-examples
-
Notifications
You must be signed in to change notification settings - Fork 5
/
hardhat.config.ts
236 lines (200 loc) · 9.48 KB
/
hardhat.config.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
import '@nomiclabs/hardhat-ethers';
import '@nomiclabs/hardhat-waffle';
import 'hardhat-local-networks-config-plugin';
import './src/setupTests';
import test from './src/test';
import { task } from 'hardhat/config';
import { TASK_TEST } from 'hardhat/builtin-tasks/task-names';
import { HardhatRuntimeEnvironment } from 'hardhat/types';
import path from 'path';
import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
import { checkArtifact, extractArtifact } from './src/task-libraries/artifact';
import Task, { TaskMode } from './src/task';
import Verifier from './src/task-libraries/verifier';
import { Logger } from './src/task-libraries/logger';
import { checkActionIds, checkActionIdUniqueness, saveActionIds } from './src/task-libraries/actionId';
import { saveContractDeploymentAddresses } from './src';
task('deploy', 'Run deployment task')
.addParam('id', 'Deployment task ID')
.addFlag('force', 'Ignore previous deployments')
.addOptionalParam('key', 'Etherscan API key to verify contracts')
.setAction(
async (args: { id: string; force?: boolean; key?: string; verbose?: boolean }, hre: HardhatRuntimeEnvironment) => {
Logger.setDefaults(false, args.verbose || false);
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const apiKey = args.key ?? (hre.config.networks[hre.network.name] as any).verificationAPIKey;
const verifier = apiKey ? new Verifier(hre.network, apiKey) : undefined;
await new Task(args.id, TaskMode.LIVE, hre.network.name, verifier).run(args);
}
);
task('verify-contract', `Verify a task's deployment on a block explorer`)
.addParam('id', 'Deployment task ID')
.addParam('name', 'Contract name')
.addParam('address', 'Contract address')
.addParam('args', 'ABI-encoded constructor arguments')
.addOptionalParam('key', 'Etherscan API key to verify contracts')
.setAction(
async (
args: { id: string; name: string; address: string; key: string; args: string; verbose?: boolean },
hre: HardhatRuntimeEnvironment
) => {
Logger.setDefaults(false, args.verbose || false);
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const apiKey = args.key ?? (hre.config.networks[hre.network.name] as any).verificationAPIKey;
const verifier = apiKey ? new Verifier(hre.network, apiKey) : undefined;
// Contracts can only be verified in Live mode
await new Task(args.id, TaskMode.LIVE, hre.network.name, verifier).verify(args.name, args.address, args.args);
}
);
task('extract-artifacts', `Extract contract artifacts from their build-info`)
.addOptionalParam('id', 'Specific task ID')
.addOptionalParam('file', 'Target build-info file name')
.addOptionalParam('name', 'Contract name')
.setAction(async (args: { id?: string; file?: string; name?: string; verbose?: boolean }) => {
Logger.setDefaults(false, args.verbose || false);
if (args.id) {
const taskObj = new Task(args.id, TaskMode.READ_ONLY);
extractArtifact(taskObj, args.file, args.name);
} else {
for (const taskID of Task.getAllTaskIds()) {
const taskObj = new Task(taskID, TaskMode.READ_ONLY);
extractArtifact(taskObj, args.file, args.name);
}
}
});
task('check-deployments', `Check that all tasks' deployments correspond to their build-info and inputs`)
.addOptionalParam('id', 'Specific task ID')
.setAction(async (args: { id?: string; force?: boolean; verbose?: boolean }, hre: HardhatRuntimeEnvironment) => {
// The force argument above is actually not passed (and not required or used in CHECK mode), but it is the easiest
// way to address type issues.
Logger.setDefaults(false, args.verbose || false);
if (args.id) {
await new Task(args.id, TaskMode.CHECK, hre.network.name).run(args);
} else {
for (const taskID of Task.getAllTaskIds()) {
if (taskID.startsWith('00000000-')) {
continue;
}
const taskObj = new Task(taskID, TaskMode.CHECK, hre.network.name);
const outputDir = path.resolve(taskObj.dir(), 'output');
if (existsSync(outputDir) && statSync(outputDir).isDirectory()) {
const outputFiles = readdirSync(outputDir);
if (outputFiles.some((outputFile) => outputFile.includes(hre.network.name))) {
// Not all tasks have outputs for all networks, so we skip those that don't
await taskObj.run(args);
}
}
}
}
});
task('check-artifacts', `check that contract artifacts correspond to their build-info`)
.addOptionalParam('id', 'Specific task ID')
.setAction(async (args: { id?: string; verbose?: boolean }) => {
Logger.setDefaults(false, args.verbose || false);
if (args.id) {
const taskObj = new Task(args.id, TaskMode.READ_ONLY);
checkArtifact(taskObj);
} else {
for (const taskID of Task.getAllTaskIds()) {
const taskObj = new Task(taskID, TaskMode.READ_ONLY);
checkArtifact(taskObj);
}
}
});
task('save-action-ids', `Print the action IDs for a particular contract and checks their uniqueness`)
.addOptionalParam('id', 'Specific task ID')
.addOptionalParam('name', 'Contract name')
.addOptionalParam('address', 'Address of Pool created from a factory')
.setAction(
async (args: { id: string; name: string; address?: string; verbose?: boolean }, hre: HardhatRuntimeEnvironment) => {
async function saveActionIdsTask(
saveArgs: { id: string; name: string; address?: string; verbose?: boolean },
saveHre: HardhatRuntimeEnvironment
) {
Logger.setDefaults(false, saveArgs.verbose || false);
// The user is calculating action IDs for a contract which isn't included in the task outputs.
// Most likely this is for a pool which is to be deployed from a factory contract deployed as part of the task.
if (saveArgs.address) {
if (!saveArgs.id || !saveArgs.name) {
throw new Error(
"Provided an address for Pool created from a factory but didn't specify task or contract name."
);
}
const taskObj = new Task(saveArgs.id, TaskMode.READ_ONLY, saveHre.network.name);
await saveActionIds(taskObj, saveArgs.name, saveArgs.address);
return;
}
// The user is calculating the action IDs for a particular task or contract within a particular task.
if (saveArgs.id && saveArgs.name) {
const taskObj = new Task(saveArgs.id, TaskMode.READ_ONLY, saveHre.network.name);
await saveActionIds(taskObj, saveArgs.name);
return;
}
async function generateActionIdsForTask(taskId: string): Promise<void> {
const taskObj = new Task(taskId, TaskMode.READ_ONLY, saveHre.network.name);
const outputDir = path.resolve(taskObj.dir(), 'output');
if (existsSync(outputDir) && statSync(outputDir).isDirectory()) {
for (const outputFile of readdirSync(outputDir)) {
const outputFilePath = path.resolve(outputDir, outputFile);
if (outputFile.includes(saveHre.network.name) && statSync(outputFilePath).isFile()) {
const fileContents = JSON.parse(readFileSync(outputFilePath).toString());
const contractNames = Object.keys(fileContents);
for (const contractName of contractNames) {
await saveActionIds(taskObj, contractName);
}
}
}
}
}
if (saveArgs.id) {
await generateActionIdsForTask(saveArgs.id);
return;
}
// We're calculating action IDs for whichever contracts we can pull enough information from disk for.
// This will calculate action IDs for any contracts which are a named output from a task.
for (const taskID of Task.getAllTaskIds()) {
await generateActionIdsForTask(taskID);
}
}
await saveActionIdsTask(args, hre);
checkActionIdUniqueness(hre.network.name);
}
);
task('check-action-ids', `Check that contract action-ids correspond the expected values`)
.addOptionalParam('id', 'Specific task ID')
.setAction(async (args: { id?: string; verbose?: boolean }, hre: HardhatRuntimeEnvironment) => {
Logger.setDefaults(false, args.verbose || false);
if (args.id) {
const taskObj = new Task(args.id, TaskMode.READ_ONLY, hre.network.name);
await checkActionIds(taskObj);
} else {
for (const taskID of Task.getAllTaskIds()) {
const taskObj = new Task(taskID, TaskMode.READ_ONLY, hre.network.name);
await checkActionIds(taskObj);
}
}
checkActionIdUniqueness(hre.network.name);
});
task('build-address-lookup', `Build a lookup table from contract addresses to the relevant deployment`)
.addOptionalParam('id', 'Specific task ID')
.setAction(async (args: { id?: string; verbose?: boolean }, hre: HardhatRuntimeEnvironment) => {
Logger.setDefaults(false, args.verbose || false);
if (args.id) {
const taskObj = new Task(args.id, TaskMode.READ_ONLY, hre.network.name);
saveContractDeploymentAddresses(taskObj);
} else {
for (const taskID of Task.getAllTaskIds()) {
if (taskID.startsWith('00000000-')) {
continue;
}
const taskObj = new Task(taskID, TaskMode.READ_ONLY, hre.network.name);
saveContractDeploymentAddresses(taskObj);
}
}
});
task(TASK_TEST).addOptionalParam('id', 'Specific task ID of the fork test to run.').setAction(test);
export default {
mocha: {
timeout: 600000,
},
};