/
index.js
203 lines (176 loc) · 6.93 KB
/
index.js
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
let async = require('../../utils/async_extend.js');
let SolcW = require('./solcW.js');
class Solidity {
constructor(embark, options) {
this.embark = embark;
this.logger = embark.logger;
this.events = embark.events;
this.ipc = options.ipc;
this.solcAlreadyLoaded = false;
this.solcW = null;
this.useDashboard = options.useDashboard;
this.options = embark.config.embarkConfig.options.solc;
this.storageConfig = embark.config.storageConfig;
this.providerUrl = null;
embark.registerCompiler(".sol", this.compile_solidity.bind(this));
embark.registerAPICall(
'post',
'/embark-api/contract/compile',
(req, res) => {
if(typeof req.body.code !== 'string'){
return res.send({error: 'Body parameter \'code\' must be a string'});
}
const input = {[req.body.name]: {content: req.body.code.replace(/\r\n/g, '\n')}};
this.compile_solidity_code(input, {}, true, {}, (errors, result) => {
const responseData = {errors: errors, result: result};
this.logger.trace(`POST response /embark-api/contract/compile:\n ${JSON.stringify(responseData)}`);
res.send(responseData);
});
}
);
}
_compile(jsonObj, returnAllErrors, callback) {
const self = this;
self.solcW.compile(jsonObj, function (err, output) {
self.events.emit('contracts:compile:solc', jsonObj);
if(err){
return callback(err);
}
if (output.errors && returnAllErrors) {
return callback(output.errors);
}
if (output.errors) {
for (let i=0; i<output.errors.length; i++) {
if (output.errors[i].type === 'Warning') {
self.logger.warn(output.errors[i].formattedMessage);
}
if (output.errors[i].type === 'Error' || output.errors[i].severity === 'error') {
return callback(new Error("Solidity errors: " + output.errors[i].formattedMessage).message);
}
}
}
self.events.emit('contracts:compiled:solc', output);
callback(null, output);
});
}
compile_solidity_code(codeInputs, originalFilepaths, returnAllErrors, options = {}, cb) {
const self = this;
async.waterfall([
function loadCompiler(callback) {
if (self.solcAlreadyLoaded) {
return callback();
}
let storageConfig = self.storageConfig;
if (storageConfig && storageConfig.upload && storageConfig.upload.getUrl) {
self.providerUrl = storageConfig.upload.getUrl;
}
self.solcW = new SolcW(self.embark, {logger: self.logger, events: self.events, ipc: self.ipc, useDashboard: self.useDashboard, providerUrl: self.providerUrl});
self.logger.info(__("loading solc compiler") + "...");
self.solcW.load_compiler(function (err) {
self.solcAlreadyLoaded = true;
callback(err);
});
},
function compileContracts(callback) {
self.logger.info(__("compiling solidity contracts") + "...");
let jsonObj = {
language: 'Solidity',
sources: codeInputs,
settings: {
optimizer: {
enabled: (!options.disableOptimizations && self.options.optimize),
runs: self.options["optimize-runs"]
},
outputSelection: {
'*': {
'': ['ast', 'legacyAST'], // legacyAST is needed by the debugger, for now
'*': [
'abi',
'devdoc',
'evm.bytecode',
'evm.deployedBytecode',
'evm.gasEstimates',
'evm.legacyAssembly',
'evm.methodIdentifiers',
'metadata',
'userdoc'
]
}
}
}
};
self._compile(jsonObj, returnAllErrors, callback);
},
function createCompiledObject(output, callback) {
let json = output.contracts;
if (!output || !output.contracts) {
return callback(new Error(__("error compiling for unknown reasons")));
}
if (Object.keys(output.contracts).length === 0 && output.sourceList && output.sourceList.length > 0) {
return callback(new Error(__("error compiling. There are sources available but no code could be compiled, likely due to fatal errors in the solidity code")).message);
}
let compiled_object = {};
for (let contractFile in json) {
for (let contractName in json[contractFile]) {
let contract = json[contractFile][contractName];
const className = contractName;
let filename = contractFile;
compiled_object[className] = {};
compiled_object[className].code = contract.evm.bytecode.object;
compiled_object[className].linkReferences = contract.evm.bytecode.linkReferences;
compiled_object[className].runtimeBytecode = contract.evm.deployedBytecode.object;
compiled_object[className].realRuntimeBytecode = contract.evm.deployedBytecode.object.slice(0, -68);
compiled_object[className].swarmHash = contract.evm.deployedBytecode.object.slice(-68).slice(0, 64);
compiled_object[className].gasEstimates = contract.evm.gasEstimates;
compiled_object[className].functionHashes = contract.evm.methodIdentifiers;
compiled_object[className].abiDefinition = contract.abi;
compiled_object[className].filename = filename;
compiled_object[className].originalFilename = originalFilepaths[filename];
}
}
callback(null, compiled_object);
}
], function (err, result) {
cb(err, result);
});
}
compile_solidity(contractFiles, options, cb) {
if (!contractFiles.length) {
return cb();
}
let self = this;
let input = {};
let originalFilepath = {};
async.waterfall([
function prepareInput(callback) {
async.each(contractFiles,
function (file, fileCb) {
let filename = file.filename;
for (let directory of self.embark.config.contractDirectories) {
let match = new RegExp("^" + directory);
filename = filename.replace(match, '');
}
originalFilepath[filename] = file.filename;
file.content(function (fileContent) {
if (!fileContent) {
self.logger.error(__('Error while loading the content of ') + filename);
return fileCb();
}
input[filename] = {content: fileContent.replace(/\r\n/g, '\n')};
fileCb();
});
},
function (err) {
callback(err);
}
);
},
function compile(callback) {
self.compile_solidity_code(input, originalFilepath, false, options, callback);
}
], function (err, result) {
cb(err, result);
});
}
}
module.exports = Solidity;