crowetic/protocol
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use solc.compileStandardWrapper

Browse Source
This commit is contained in:
Leonid Logvinov
2018-04-06 18:37:48 +02:00
parent 4dd9f29769
commit 442017f93a
7 changed files with 208 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
packages/deployer/package.json
View File

@@ -73,6 +73,7 @@
"@0xproject/utils": "^0.5.1", "@0xproject/utils": "^0.5.1",
"@0xproject/web3-wrapper": "^0.6.0", "@0xproject/web3-wrapper": "^0.6.0",
"@types/yargs": "^11.0.0", "@types/yargs": "^11.0.0",
"chalk": "^2.3.0",
"ethereumjs-util": "^5.1.1", "ethereumjs-util": "^5.1.1",
"isomorphic-fetch": "^2.2.1", "isomorphic-fetch": "^2.2.1",
"lodash": "^4.17.4", "lodash": "^4.17.4",

3
packages/deployer/src/cli.ts
View File

@@ -78,8 +78,7 @@ function getContractsSetFromList(contracts: string): Set<string> {
} }
const contractsArray = contracts.split(','); const contractsArray = contracts.split(',');
_.forEach(contractsArray, contractName => { _.forEach(contractsArray, contractName => {
const fileName = `${contractName}${constants.SOLIDITY_FILE_EXTENSION}`; specifiedContracts.add(contractName);
specifiedContracts.add(fileName);
}); });
return specifiedContracts; return specifiedContracts;
} }

115
packages/deployer/src/compiler.ts
View File

@@ -1,5 +1,6 @@
import { ContractAbi } from '@0xproject/types'; import { ContractAbi } from '@0xproject/types';
import { logUtils, promisify } from '@0xproject/utils'; import { logUtils, promisify } from '@0xproject/utils';
import chalk from 'chalk';
import * as ethUtil from 'ethereumjs-util'; import * as ethUtil from 'ethereumjs-util';
import * as fs from 'fs'; import * as fs from 'fs';
import 'isomorphic-fetch'; import 'isomorphic-fetch';
@@ -62,14 +63,19 @@ export class Compiler {
let sources: ContractSources = {}; let sources: ContractSources = {};
for (const fileName of dirContents) { for (const fileName of dirContents) {
const contentPath = `${dirPath}/${fileName}`; const contentPath = `${dirPath}/${fileName}`;
const contractName = path.basename(fileName, constants.SOLIDITY_FILE_EXTENSION);
const absoluteFilePath = path.resolve(contentPath);
if (path.extname(fileName) === constants.SOLIDITY_FILE_EXTENSION) { if (path.extname(fileName) === constants.SOLIDITY_FILE_EXTENSION) {
try { try {
const opts = { const opts = {
encoding: 'utf8', encoding: 'utf8',
}; };
const source = await fsWrapper.readFileAsync(contentPath, opts); const source = await fsWrapper.readFileAsync(contentPath, opts);
sources[fileName] = source; sources[contractName] = {
logUtils.log(`Reading ${fileName} source...`); source,
absoluteFilePath,
};
logUtils.log(`Reading ${contractName} source...`);
} catch (err) { } catch (err) {
logUtils.log(`Could not find file at ${contentPath}`); logUtils.log(`Could not find file at ${contentPath}`);
} }
@@ -106,24 +112,27 @@ export class Compiler {
await createDirIfDoesNotExistAsync(this._artifactsDir); await createDirIfDoesNotExistAsync(this._artifactsDir);
await createDirIfDoesNotExistAsync(SOLC_BIN_DIR); await createDirIfDoesNotExistAsync(SOLC_BIN_DIR);
this._contractSources = await Compiler._getContractSourcesAsync(this._contractsDir); this._contractSources = await Compiler._getContractSourcesAsync(this._contractsDir);
_.forIn(this._contractSources, this._setContractSpecificSourceData.bind(this)); for (const contractName of _.keys(this._contractSources)) {
const fileNames = this._specifiedContracts.has(ALL_CONTRACTS_IDENTIFIER) const contractSource = this._contractSources[contractName];
this._setContractSpecificSourceData(contractSource.source, contractName);
}
const contractNames = this._specifiedContracts.has(ALL_CONTRACTS_IDENTIFIER)
? _.keys(this._contractSources) ? _.keys(this._contractSources)
: Array.from(this._specifiedContracts.values()); : Array.from(this._specifiedContracts.values());
for (const fileName of fileNames) { for (const contractName of contractNames) {
await this._compileContractAsync(fileName); await this._compileContractAsync(contractName);
} }
} }
/** /**
* Compiles contract and saves artifact to artifactsDir. * Compiles contract and saves artifact to artifactsDir.
* @param fileName Name of contract with '.sol' extension. * @param fileName Name of contract with '.sol' extension.
*/ */
private async _compileContractAsync(fileName: string): Promise<void> { private async _compileContractAsync(contractName: string): Promise<void> {
if (_.isUndefined(this._contractSources)) { if (_.isUndefined(this._contractSources)) {
throw new Error('Contract sources not yet initialized'); throw new Error('Contract sources not yet initialized');
} }
const contractSpecificSourceData = this._contractSourceData[fileName]; const contractSpecificSourceData = this._contractSourceData[contractName];
const currentArtifactIfExists = await getContractArtifactIfExistsAsync(this._artifactsDir, fileName); const currentArtifactIfExists = await getContractArtifactIfExistsAsync(this._artifactsDir, contractName);
const sourceHash = `0x${contractSpecificSourceData.sourceHash.toString('hex')}`; const sourceHash = `0x${contractSpecificSourceData.sourceHash.toString('hex')}`;
const sourceTreeHash = `0x${contractSpecificSourceData.sourceTreeHash.toString('hex')}`; const sourceTreeHash = `0x${contractSpecificSourceData.sourceTreeHash.toString('hex')}`;
@@ -162,49 +171,69 @@ export class Compiler {
} }
const solcInstance = solc.setupMethods(requireFromString(solcjs, compilerBinFilename)); const solcInstance = solc.setupMethods(requireFromString(solcjs, compilerBinFilename));
logUtils.log(`Compiling ${fileName} with Solidity v${solcVersion}...`); logUtils.log(`Compiling ${contractName} with Solidity v${solcVersion}...`);
const source = this._contractSources[fileName]; const source = this._contractSources[contractName].source;
const input = { const absoluteFilePath = this._contractSources[contractName].absoluteFilePath;
[fileName]: source, const standardInput: solc.StandardInput = {
language: 'Solidity',
sources: {
[absoluteFilePath]: {
urls: [`file://${absoluteFilePath}`],
},
},
settings: {
optimizer: {
enabled: this._optimizerEnabled,
},
outputSelection: {
'*': {
'*': [
'abi',
'evm.bytecode.object',
'evm.bytecode.sourceMap',
'evm.deployedBytecode.object',
'evm.deployedBytecode.sourceMap',
],
},
},
},
}; };
const sourcesToCompile = { const compiled: solc.StandardOutput = JSON.parse(
sources: input, solcInstance.compileStandardWrapper(JSON.stringify(standardInput), importPath =>
};
const compiled = solcInstance.compile(sourcesToCompile, Number(this._optimizerEnabled), importPath =>
findImportIfExist(this._contractSources, importPath), findImportIfExist(this._contractSources, importPath),
),
); );
if (!_.isUndefined(compiled.errors)) { if (!_.isUndefined(compiled.errors)) {
const SOLIDITY_WARNING_PREFIX = 'Warning'; const SOLIDITY_WARNING = 'warning';
const isError = (errorOrWarning: string) => !errorOrWarning.includes(SOLIDITY_WARNING_PREFIX); const isError = (entry: any) => entry.severity !== SOLIDITY_WARNING;
const isWarning = (errorOrWarning: string) => errorOrWarning.includes(SOLIDITY_WARNING_PREFIX); const isWarning = (entry: any) => entry.severity === SOLIDITY_WARNING;
const errors = _.filter(compiled.errors, isError); const errors = _.filter(compiled.errors, isError);
const warnings = _.filter(compiled.errors, isWarning); const warnings = _.filter(compiled.errors, isWarning);
if (!_.isEmpty(errors)) { if (!_.isEmpty(errors)) {
errors.forEach(errMsg => { errors.forEach(error => {
const normalizedErrMsg = getNormalizedErrMsg(errMsg); const normalizedErrMsg = getNormalizedErrMsg(error.formattedMessage);
logUtils.log(normalizedErrMsg); logUtils.log(chalk.red(normalizedErrMsg));
}); });
process.exit(1); process.exit(1);
} else { } else {
warnings.forEach(errMsg => { warnings.forEach(warning => {
const normalizedErrMsg = getNormalizedErrMsg(errMsg); const normalizedWarningMsg = getNormalizedErrMsg(warning.formattedMessage);
logUtils.log(normalizedErrMsg); logUtils.log(chalk.yellow(normalizedWarningMsg));
}); });
} }
} }
const contractName = path.basename(fileName, constants.SOLIDITY_FILE_EXTENSION); const compiledData = compiled.contracts[absoluteFilePath][contractName];
const contractIdentifier = `${fileName}:${contractName}`; if (_.isUndefined(compiledData)) {
if (_.isUndefined(compiled.contracts[contractIdentifier])) {
throw new Error( throw new Error(
`Contract ${contractName} not found in ${fileName}. Please make sure your contract has the same name as it's file name`, `Contract ${contractName} not found in ${absoluteFilePath}. Please make sure your contract has the same name as it's file name`,
); );
} }
const abi: ContractAbi = JSON.parse(compiled.contracts[contractIdentifier].interface); const abi: ContractAbi = compiledData.abi;
const bytecode = `0x${compiled.contracts[contractIdentifier].bytecode}`; const bytecode = `0x${compiledData.evm.bytecode.object}`;
const runtimeBytecode = `0x${compiled.contracts[contractIdentifier].runtimeBytecode}`; const runtimeBytecode = `0x${compiledData.evm.deployedBytecode.object}`;
const sourceMap = compiled.contracts[contractIdentifier].srcmap; const sourceMap = compiledData.evm.bytecode.sourceMap;
const sourceMapRuntime = compiled.contracts[contractIdentifier].srcmapRuntime; const sourceMapRuntime = compiledData.evm.deployedBytecode.sourceMap;
const sources = _.keys(compiled.sources); const sources = _.keys(compiled.sources);
const updated_at = Date.now(); const updated_at = Date.now();
const contractNetworkData: ContractNetworkData = { const contractNetworkData: ContractNetworkData = {
@@ -243,22 +272,22 @@ export class Compiler {
const artifactString = utils.stringifyWithFormatting(newArtifact); const artifactString = utils.stringifyWithFormatting(newArtifact);
const currentArtifactPath = `${this._artifactsDir}/${contractName}.json`; const currentArtifactPath = `${this._artifactsDir}/${contractName}.json`;
await fsWrapper.writeFileAsync(currentArtifactPath, artifactString); await fsWrapper.writeFileAsync(currentArtifactPath, artifactString);
logUtils.log(`${fileName} artifact saved!`); logUtils.log(`${contractName} artifact saved!`);
} }
/** /**
* Gets contract dependendencies and keccak256 hash from source. * Gets contract dependendencies and keccak256 hash from source.
* @param source Source code of contract. * @param source Source code of contract.
* @return Object with contract dependencies and keccak256 hash of source. * @return Object with contract dependencies and keccak256 hash of source.
*/ */
private _setContractSpecificSourceData(source: string, fileName: string): void { private _setContractSpecificSourceData(source: string, contractName: string): void {
if (!_.isUndefined(this._contractSourceData[fileName])) { if (!_.isUndefined(this._contractSourceData[contractName])) {
return; return;
} }
const sourceHash = ethUtil.sha3(source); const sourceHash = ethUtil.sha3(source);
const solcVersionRange = parseSolidityVersionRange(source); const solcVersionRange = parseSolidityVersionRange(source);
const dependencies = parseDependencies(source); const dependencies = parseDependencies(source);
const sourceTreeHash = this._getSourceTreeHash(fileName, sourceHash, dependencies); const sourceTreeHash = this._getSourceTreeHash(sourceHash, dependencies);
this._contractSourceData[fileName] = { this._contractSourceData[contractName] = {
dependencies, dependencies,
solcVersionRange, solcVersionRange,
sourceHash, sourceHash,
@@ -269,15 +298,15 @@ export class Compiler {
* Gets the source tree hash for a file and its dependencies. * Gets the source tree hash for a file and its dependencies.
* @param fileName Name of contract file. * @param fileName Name of contract file.
*/ */
private _getSourceTreeHash(fileName: string, sourceHash: Buffer, dependencies: string[]): Buffer { private _getSourceTreeHash(sourceHash: Buffer, dependencies: string[]): Buffer {
if (dependencies.length === 0) { if (dependencies.length === 0) {
return sourceHash; return sourceHash;
} else { } else {
const dependencySourceTreeHashes = _.map(dependencies, dependency => { const dependencySourceTreeHashes = _.map(dependencies, dependency => {
const source = this._contractSources[dependency]; const source = this._contractSources[dependency].source;
this._setContractSpecificSourceData(source, dependency); this._setContractSpecificSourceData(source, dependency);
const sourceData = this._contractSourceData[dependency]; const sourceData = this._contractSourceData[dependency];
return this._getSourceTreeHash(dependency, sourceData.sourceHash, sourceData.dependencies); return this._getSourceTreeHash(sourceData.sourceHash, sourceData.dependencies);
}); });
const sourceTreeHashesBuffer = Buffer.concat([sourceHash, ...dependencySourceTreeHashes]); const sourceTreeHashesBuffer = Buffer.concat([sourceHash, ...dependencySourceTreeHashes]);
const sourceTreeHash = ethUtil.sha3(sourceTreeHashesBuffer); const sourceTreeHash = ethUtil.sha3(sourceTreeHashesBuffer);

18
packages/deployer/src/utils/compiler.ts
View File

@@ -10,15 +10,14 @@ import { ContractArtifact, ContractSources } from './types';
/** /**
* Gets contract data on network or returns if an artifact does not exist. * Gets contract data on network or returns if an artifact does not exist.
* @param artifactsDir Path to the artifacts directory. * @param artifactsDir Path to the artifacts directory.
* @param fileName Name of contract file. * @param contractName Name of contract.
* @return Contract data on network or undefined. * @return Contract data on network or undefined.
*/ */
export async function getContractArtifactIfExistsAsync( export async function getContractArtifactIfExistsAsync(
artifactsDir: string, artifactsDir: string,
fileName: string, contractName: string,
): Promise<ContractArtifact | void> { ): Promise<ContractArtifact | void> {
let contractArtifact; let contractArtifact;
const contractName = path.basename(fileName, constants.SOLIDITY_FILE_EXTENSION);
const currentArtifactPath = `${artifactsDir}/${contractName}.json`; const currentArtifactPath = `${artifactsDir}/${contractName}.json`;
try { try {
const opts = { const opts = {
@@ -28,7 +27,7 @@ export async function getContractArtifactIfExistsAsync(
contractArtifact = JSON.parse(contractArtifactString); contractArtifact = JSON.parse(contractArtifactString);
return contractArtifact; return contractArtifact;
} catch (err) { } catch (err) {
logUtils.log(`Artifact for ${fileName} does not exist`); logUtils.log(`Artifact for ${contractName} does not exist`);
return undefined; return undefined;
} }
} }
@@ -95,8 +94,8 @@ export function parseDependencies(source: string): string[] {
const dependencyMatch = line.match(DEPENDENCY_PATH_REGEX); const dependencyMatch = line.match(DEPENDENCY_PATH_REGEX);
if (!_.isNull(dependencyMatch)) { if (!_.isNull(dependencyMatch)) {
const dependencyPath = dependencyMatch[1]; const dependencyPath = dependencyMatch[1];
const basenName = path.basename(dependencyPath); const contractName = path.basename(dependencyPath, constants.SOLIDITY_FILE_EXTENSION);
dependencies.push(basenName); dependencies.push(contractName);
} }
} }
}); });
@@ -105,16 +104,15 @@ export function parseDependencies(source: string): string[] {
/** /**
* Callback to resolve dependencies with `solc.compile`. * Callback to resolve dependencies with `solc.compile`.
* Throws error if contractSources not yet initialized.
* @param contractSources Source codes of contracts. * @param contractSources Source codes of contracts.
* @param importPath Path to an imported dependency. * @param importPath Path to an imported dependency.
* @return Import contents object containing source code of dependency. * @return Import contents object containing source code of dependency.
*/ */
export function findImportIfExist(contractSources: ContractSources, importPath: string): solc.ImportContents { export function findImportIfExist(contractSources: ContractSources, importPath: string): solc.ImportContents {
const fileName = path.basename(importPath); const contractName = path.basename(importPath, constants.SOLIDITY_FILE_EXTENSION);
const source = contractSources[fileName]; const source = contractSources[contractName].source;
if (_.isUndefined(source)) { if (_.isUndefined(source)) {
throw new Error(`Contract source not found for ${fileName}`); throw new Error(`Contract source not found for ${contractName}`);
} }
const importContents: solc.ImportContents = { const importContents: solc.ImportContents = {
contents: source, contents: source,

7
packages/deployer/src/utils/types.ts
View File

@@ -75,11 +75,14 @@ export interface UrlDeployerOptions extends BaseDeployerOptions {
export type DeployerOptions = UrlDeployerOptions | ProviderDeployerOptions; export type DeployerOptions = UrlDeployerOptions | ProviderDeployerOptions;
export interface ContractSources { export interface ContractSources {
[key: string]: string; [key: string]: {
source: string;
absoluteFilePath: string;
};
} }
export interface ContractSourceData { export interface ContractSourceData {
[key: string]: ContractSpecificSourceData; [contractName: string]: ContractSpecificSourceData;
} }
export interface ContractSpecificSourceData { export interface ContractSpecificSourceData {

8
packages/metacoin/artifacts/Metacoin.json
View File

@@ -156,13 +156,13 @@
"type": "event" "type": "event"
} }
], ],
"bytecode": "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", "bytecode": "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",
"runtime_bytecode": "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", "runtime_bytecode": "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",
"updated_at": 1523361870927, "updated_at": 1523362081750,
"source_map": "60:1093:0:-;;;389:72;;;;;;;;449:5;426:8;:20;435:10;426:20;;;;;;;;;;;;;;;:28;;;;60:1093;;;;;;", "source_map": "60:1093:0:-;;;389:72;;;;;;;;449:5;426:8;:20;435:10;426:20;;;;;;;;;;;;;;;:28;;;;60:1093;;;;;;",
"source_map_runtime": "60:1093:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;978:172;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;84:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;467:352;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;825:147;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;978:172;1051:3;1073:70;1082:18;:31;;;1115:18;:27;;;1073:8;:70::i;:::-;1066:77;;978:172;;;:::o;84:41::-;;;;;;;;;;;;;;;;;:::o;467:352::-;528:12;579;:19;;;556:8;:20;565:10;556:20;;;;;;;;;;;;;;;;:42;552:60;;;607:5;600:12;;;;552:60;646:12;:19;;;622:8;:20;631:10;622:20;;;;;;;;;;;;;;;;:43;;;;;;;;;;;704:12;:19;;;675:8;:25;684:12;:15;;;675:25;;;;;;;;;;;;;;;;:48;;;;;;;;;;;754:12;:15;;;733:58;;742:10;733:58;;;771:12;:19;;;733:58;;;;;;;;;;;;;;;808:4;801:11;;467:352;;;;:::o;825:147::-;903:3;918:22;927:12;918:8;:22::i;:::-;;957:8;950:15;;;;825:147;;;;:::o;5:118:-1:-;;72:46;110:6;97:20;72:46;;;63:55;;57:66;;;;;171:510;;294:4;282:9;277:3;273:19;269:30;266:2;;;312:1;309;302:12;266:2;330:20;345:4;330:20;;;321:29;;408:1;439:73;508:3;499:6;488:9;484:22;439:73;;;433:3;426:5;422:15;415:98;360:164;578:2;611:48;655:3;646:6;635:9;631:22;611:48;;;604:4;597:5;593:16;586:74;534:137;260:421;;;;;723:465;;836:4;824:9;819:3;815:19;811:30;808:2;;;854:1;851;844:12;808:2;872:20;887:4;872:20;;;863:29;;940:1;971:49;1016:3;1007:6;996:9;992:22;971:49;;;965:3;958:5;954:15;947:74;902:130;1084:2;1117:49;1162:3;1153:6;1142:9;1138:22;1117:49;;;1110:4;1103:5;1099:16;1092:75;1042:136;802:386;;;;;1230:469;;1347:4;1335:9;1330:3;1326:19;1322:30;1319:2;;;1365:1;1362;1355:12;1319:2;1383:20;1398:4;1383:20;;;1374:29;;1451:1;1482:49;1527:3;1518:6;1507:9;1503:22;1482:49;;;1476:3;1469:5;1465:15;1458:74;1413:130;1595:2;1628:49;1673:3;1664:6;1653:9;1649:22;1628:49;;;1621:4;1614:5;1610:16;1603:75;1553:136;1313:386;;;;;1706:118;;1773:46;1811:6;1798:20;1773:46;;;1764:55;;1758:66;;;;;1831:116;;1897:45;1934:6;1921:20;1897:45;;;1888:54;;1882:65;;;;;1954:241;;2058:2;2046:9;2037:7;2033:23;2029:32;2026:2;;;2074:1;2071;2064:12;2026:2;2109:1;2126:53;2171:7;2162:6;2151:9;2147:22;2126:53;;;2116:63;;2088:97;2020:175;;;;;2202:309;;2340:2;2328:9;2319:7;2315:23;2311:32;2308:2;;;2356:1;2353;2346:12;2308:2;2391:1;2408:87;2487:7;2478:6;2467:9;2463:22;2408:87;;;2398:97;;2370:131;2302:209;;;;;2518:297;;2650:2;2638:9;2629:7;2625:23;2621:32;2618:2;;;2666:1;2663;2656:12;2618:2;2701:1;2718:81;2791:7;2782:6;2771:9;2767:22;2718:81;;;2708:91;;2680:125;2612:203;;;;;2822:420;;;2970:2;2958:9;2949:7;2945:23;2941:32;2938:2;;;2986:1;2983;2976:12;2938:2;3021:1;3038:81;3111:7;3102:6;3091:9;3087:22;3038:81;;;3028:91;;3000:125;3156:2;3174:52;3218:7;3209:6;3198:9;3194:22;3174:52;;;3164:62;;3135:97;2932:310;;;;;;3249:101;3316:28;3338:5;3316:28;;;3311:3;3304:41;3298:52;;;3357:107;3428:30;3452:5;3428:30;;;3423:3;3416:43;3410:54;;;3471:110;3544:31;3569:5;3544:31;;;3539:3;3532:44;3526:55;;;3588:181;;3690:2;3679:9;3675:18;3667:26;;3704:55;3756:1;3745:9;3741:17;3732:6;3704:55;;;3661:108;;;;;3776:189;;3882:2;3871:9;3867:18;3859:26;;3896:59;3952:1;3941:9;3937:17;3928:6;3896:59;;;3853:112;;;;;3972:193;;4080:2;4069:9;4065:18;4057:26;;4094:61;4152:1;4141:9;4137:17;4128:6;4094:61;;;4051:114;;;;;4172:256;;4234:2;4228:9;4218:19;;4272:4;4264:6;4260:17;4371:6;4359:10;4356:22;4335:18;4323:10;4320:34;4317:62;4314:2;;;4392:1;4389;4382:12;4314:2;4412:10;4408:2;4401:22;4212:216;;;;;4435:92;;4515:5;4508:13;4501:21;4490:32;;4484:43;;;;4534:78;;4602:5;4591:16;;4585:27;;;;4619:79;;4688:5;4677:16;;4671:27;;;;4705:128;;4785:42;4778:5;4774:54;4763:65;;4757:76;;;;4840:79;;4909:5;4898:16;;4892:27;;;;4926:95;;5005:10;4998:5;4994:22;4983:33;;4977:44;;;", "source_map_runtime": "60:1093:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;978:172;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;84:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;467:352;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;825:147;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;978:172;1051:3;1073:70;1082:18;:31;;;1115:18;:27;;;1073:8;:70::i;:::-;1066:77;;978:172;;;:::o;84:41::-;;;;;;;;;;;;;;;;;:::o;467:352::-;528:12;579;:19;;;556:8;:20;565:10;556:20;;;;;;;;;;;;;;;;:42;552:60;;;607:5;600:12;;;;552:60;646:12;:19;;;622:8;:20;631:10;622:20;;;;;;;;;;;;;;;;:43;;;;;;;;;;;704:12;:19;;;675:8;:25;684:12;:15;;;675:25;;;;;;;;;;;;;;;;:48;;;;;;;;;;;754:12;:15;;;733:58;;742:10;733:58;;;771:12;:19;;;733:58;;;;;;;;;;;;;;;808:4;801:11;;467:352;;;;:::o;825:147::-;903:3;918:22;927:12;918:8;:22::i;:::-;;957:8;950:15;;;;825:147;;;;:::o;5:118:-1:-;;72:46;110:6;97:20;72:46;;;63:55;;57:66;;;;;171:510;;294:4;282:9;277:3;273:19;269:30;266:2;;;312:1;309;302:12;266:2;330:20;345:4;330:20;;;321:29;;408:1;439:73;508:3;499:6;488:9;484:22;439:73;;;433:3;426:5;422:15;415:98;360:164;578:2;611:48;655:3;646:6;635:9;631:22;611:48;;;604:4;597:5;593:16;586:74;534:137;260:421;;;;;723:465;;836:4;824:9;819:3;815:19;811:30;808:2;;;854:1;851;844:12;808:2;872:20;887:4;872:20;;;863:29;;940:1;971:49;1016:3;1007:6;996:9;992:22;971:49;;;965:3;958:5;954:15;947:74;902:130;1084:2;1117:49;1162:3;1153:6;1142:9;1138:22;1117:49;;;1110:4;1103:5;1099:16;1092:75;1042:136;802:386;;;;;1230:469;;1347:4;1335:9;1330:3;1326:19;1322:30;1319:2;;;1365:1;1362;1355:12;1319:2;1383:20;1398:4;1383:20;;;1374:29;;1451:1;1482:49;1527:3;1518:6;1507:9;1503:22;1482:49;;;1476:3;1469:5;1465:15;1458:74;1413:130;1595:2;1628:49;1673:3;1664:6;1653:9;1649:22;1628:49;;;1621:4;1614:5;1610:16;1603:75;1553:136;1313:386;;;;;1706:118;;1773:46;1811:6;1798:20;1773:46;;;1764:55;;1758:66;;;;;1831:116;;1897:45;1934:6;1921:20;1897:45;;;1888:54;;1882:65;;;;;1954:241;;2058:2;2046:9;2037:7;2033:23;2029:32;2026:2;;;2074:1;2071;2064:12;2026:2;2109:1;2126:53;2171:7;2162:6;2151:9;2147:22;2126:53;;;2116:63;;2088:97;2020:175;;;;;2202:309;;2340:2;2328:9;2319:7;2315:23;2311:32;2308:2;;;2356:1;2353;2346:12;2308:2;2391:1;2408:87;2487:7;2478:6;2467:9;2463:22;2408:87;;;2398:97;;2370:131;2302:209;;;;;2518:297;;2650:2;2638:9;2629:7;2625:23;2621:32;2618:2;;;2666:1;2663;2656:12;2618:2;2701:1;2718:81;2791:7;2782:6;2771:9;2767:22;2718:81;;;2708:91;;2680:125;2612:203;;;;;2822:420;;;2970:2;2958:9;2949:7;2945:23;2941:32;2938:2;;;2986:1;2983;2976:12;2938:2;3021:1;3038:81;3111:7;3102:6;3091:9;3087:22;3038:81;;;3028:91;;3000:125;3156:2;3174:52;3218:7;3209:6;3198:9;3194:22;3174:52;;;3164:62;;3135:97;2932:310;;;;;;3249:101;3316:28;3338:5;3316:28;;;3311:3;3304:41;3298:52;;;3357:107;3428:30;3452:5;3428:30;;;3423:3;3416:43;3410:54;;;3471:110;3544:31;3569:5;3544:31;;;3539:3;3532:44;3526:55;;;3588:181;;3690:2;3679:9;3675:18;3667:26;;3704:55;3756:1;3745:9;3741:17;3732:6;3704:55;;;3661:108;;;;;3776:189;;3882:2;3871:9;3867:18;3859:26;;3896:59;3952:1;3941:9;3937:17;3928:6;3896:59;;;3853:112;;;;;3972:193;;4080:2;4069:9;4065:18;4057:26;;4094:61;4152:1;4141:9;4137:17;4128:6;4094:61;;;4051:114;;;;;4172:256;;4234:2;4228:9;4218:19;;4272:4;4264:6;4260:17;4371:6;4359:10;4356:22;4335:18;4323:10;4320:34;4317:62;4314:2;;;4392:1;4389;4382:12;4314:2;4412:10;4408:2;4401:22;4212:216;;;;;4435:92;;4515:5;4508:13;4501:21;4490:32;;4484:43;;;;4534:78;;4602:5;4591:16;;4585:27;;;;4619:79;;4688:5;4677:16;;4671:27;;;;4705:128;;4785:42;4778:5;4774:54;4763:65;;4757:76;;;;4840:79;;4909:5;4898:16;;4892:27;;;;4926:95;;5005:10;4998:5;4994:22;4983:33;;4977:44;;;",
"sources": [ "sources": [
"Metacoin.sol" "/Users/leonidlogvinov/Dev/0x/0x-monorepo/packages/metacoin/contracts/Metacoin.sol"
] ]
} }
} }

116
packages/typescript-typings/types/solc/index.d.ts vendored
View File

@@ -26,12 +26,128 @@ declare module 'solc' {
[fileName: string]: string; [fileName: string]: string;
}; };
} }
export interface BaseSource {
keccak256?: string;
}
export interface InMemorySource extends BaseSource {
content: string;
}
export interface UrlSource extends BaseSource {
urls: string[];
}
export type Source = UrlSource | InMemorySource;
export type OutputField =
| '*'
| 'ast'
| 'legacyAST'
| 'abi'
| 'devdoc'
| 'userdoc'
| 'metadata'
| 'ir'
| 'evm.assembly'
| 'evm.legacyAssembly'
| 'evm.bytecode.object'
| 'evm.bytecode.opcodes'
| 'evm.bytecode.sourceMap'
| 'evm.bytecode.linkReferences'
| 'evm.deployedBytecode.object'
| 'evm.deployedBytecode.opcodes'
| 'evm.deployedBytecode.sourceMap'
| 'evm.deployedBytecode.linkReferences'
| 'evm.methodIdentifiers'
| 'evm.gasEstimates'
| 'ewasm.wast'
| 'ewasm.wasm';
export interface StandardInput {
language: 'Solidity' | 'serpent' | 'lll' | 'assembly';
sources: {
[fileName: string]: Source;
};
settings: {
remappings?: string[];
optimizer?: {
enabled: boolean;
runs?: number;
};
evmVersion?: 'homestead' | 'tangerineWhistle' | 'spuriousDragon' | 'byzantium' | 'constantinople';
metadata?: {
useLiteralContent: true;
};
libraries?: {
[fileName: string]: {
[libName: string]: string;
};
};
outputSelection: {
[fileName: string]: {
[contractName: string]: OutputField[];
};
};
};
}
export type ErrorType =
| 'JSONError'
| 'IOError'
| 'ParserError'
| 'DocstringParsingError'
| 'SyntaxError'
| 'DeclarationError'
| 'TypeError'
| 'UnimplementedFeatureError'
| 'InternalCompilerError'
| 'Exception'
| 'CompilerError'
| 'FatalError'
| 'Warning';
export type ErrorSeverity = 'error' | 'warning';
export interface Error {
sourceLocation?: {
file: string;
start: number;
end: number;
};
type: ErrorType;
component: 'general' | 'ewasm';
severity: ErrorSeverity;
message: string;
formattedMessage?: string;
}
import { ContractAbi } from '@0xproject/types';
export interface StandardOutput {
errors: Error[];
sources: {
[fileName: string]: {
id: number;
ast?: object;
legacyAST?: object;
};
};
contracts: {
[fileName: string]: {
[contractName: string]: {
abi: ContractAbi;
evm: {
bytecode: {
object: string;
sourceMap: string;
};
deployedBytecode: {
object: string;
sourceMap: string;
};
};
};
};
};
}
export interface SolcInstance { export interface SolcInstance {
compile( compile(
sources: InputSources, sources: InputSources,
optimizerEnabled: number, optimizerEnabled: number,
findImports: (importPath: string) => ImportContents, findImports: (importPath: string) => ImportContents,
): CompilationResult; ): CompilationResult;
compileStandardWrapper(input: string, findImports: (importPath: string) => ImportContents): string;
} }
export function loadRemoteVersion(versionName: string, cb: (err: Error | null, res?: SolcInstance) => void): void; export function loadRemoteVersion(versionName: string, cb: (err: Error | null, res?: SolcInstance) => void): void;
export function setupMethods(solcBin: any): SolcInstance; export function setupMethods(solcBin: any): SolcInstance;