518 lines
20 KiB
TypeScript
518 lines
20 KiB
TypeScript
import { ContractSource, Resolver } from '@0x/sol-resolver';
|
|
import { fetchAsync, logUtils } from '@0x/utils';
|
|
import chalk from 'chalk';
|
|
import { exec, spawn } from 'child_process';
|
|
import { ContractArtifact } from 'ethereum-types';
|
|
import * as ethUtil from 'ethereumjs-util';
|
|
import * as _ from 'lodash';
|
|
import * as path from 'path';
|
|
import * as requireFromString from 'require-from-string';
|
|
import * as solc from 'solc';
|
|
import { promisify } from 'util';
|
|
|
|
import { constants } from './constants';
|
|
import { fsWrapper } from './fs_wrapper';
|
|
import { BinaryPaths, CompilationError } from './types';
|
|
|
|
/**
|
|
* Gets contract data or returns if an artifact does not exist.
|
|
* @param artifactsDir Path to the artifacts directory.
|
|
* @param contractName Name of contract.
|
|
* @return Contract data or undefined.
|
|
*/
|
|
export async function getContractArtifactIfExistsAsync(
|
|
artifactsDir: string,
|
|
contractName: string,
|
|
): Promise<ContractArtifact | void> {
|
|
let contractArtifact;
|
|
const currentArtifactPath = `${artifactsDir}/${path.basename(
|
|
contractName,
|
|
constants.SOLIDITY_FILE_EXTENSION,
|
|
)}.json`;
|
|
try {
|
|
const opts = {
|
|
encoding: 'utf8',
|
|
};
|
|
const contractArtifactString = await fsWrapper.readFileAsync(currentArtifactPath, opts);
|
|
contractArtifact = JSON.parse(contractArtifactString);
|
|
return contractArtifact;
|
|
} catch (err) {
|
|
return undefined;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a directory if it does not already exist.
|
|
* @param artifactsDir Path to the directory.
|
|
*/
|
|
export async function createDirIfDoesNotExistAsync(dirPath: string): Promise<void> {
|
|
if (!fsWrapper.doesPathExistSync(dirPath)) {
|
|
logUtils.warn(`Creating directory at ${dirPath}...`);
|
|
await fsWrapper.mkdirpAsync(dirPath);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Searches Solidity source code for compiler version range.
|
|
* @param source Source code of contract.
|
|
* @return Solc compiler version range.
|
|
*/
|
|
export function parseSolidityVersionRange(source: string): string {
|
|
const SOLIDITY_VERSION_RANGE_REGEX = /pragma\s+solidity\s+(.*);/;
|
|
const solcVersionRangeMatch = source.match(SOLIDITY_VERSION_RANGE_REGEX);
|
|
if (solcVersionRangeMatch === null) {
|
|
throw new Error('Could not find Solidity version range in source');
|
|
}
|
|
const solcVersionRange = solcVersionRangeMatch[1];
|
|
return solcVersionRange;
|
|
}
|
|
|
|
/**
|
|
* Normalizes the path found in the error message. If it cannot be normalized
|
|
* the original error message is returned.
|
|
* Example: converts 'base/Token.sol:6:46: Warning: Unused local variable'
|
|
* to 'Token.sol:6:46: Warning: Unused local variable'
|
|
* This is used to prevent logging the same error multiple times.
|
|
* @param errMsg An error message from the compiled output.
|
|
* @return The error message with directories truncated from the contract path.
|
|
*/
|
|
export function getNormalizedErrMsg(errMsg: string): string {
|
|
const SOLIDITY_FILE_EXTENSION_REGEX = /(.*\.sol):/;
|
|
const errPathMatch = errMsg.match(SOLIDITY_FILE_EXTENSION_REGEX);
|
|
if (errPathMatch === null) {
|
|
// This can occur if solidity outputs a general warning, e.g
|
|
// Warning: This is a pre-release compiler version, please do not use it in production.
|
|
return errMsg;
|
|
}
|
|
const errPath = errPathMatch[0];
|
|
const baseContract = path.basename(errPath);
|
|
const normalizedErrMsg = errMsg.replace(errPath, baseContract);
|
|
return normalizedErrMsg;
|
|
}
|
|
|
|
/**
|
|
* Parses the contract source code and extracts the dendencies
|
|
* @param source Contract source code
|
|
* @return List of dependendencies
|
|
*/
|
|
export function parseDependencies(contractSource: ContractSource): string[] {
|
|
// TODO: Use a proper parser
|
|
const source = contractSource.source;
|
|
const IMPORT_REGEX = /(import\s)/;
|
|
const DEPENDENCY_PATH_REGEX = /"([^"]+)"/; // Source: https://github.com/BlockChainCompany/soljitsu/blob/master/lib/shared.js
|
|
const dependencies: string[] = [];
|
|
const lines = source.split('\n');
|
|
_.forEach(lines, line => {
|
|
if (line.match(IMPORT_REGEX) !== null) {
|
|
const dependencyMatch = line.match(DEPENDENCY_PATH_REGEX);
|
|
if (dependencyMatch !== null) {
|
|
let dependencyPath = dependencyMatch[1];
|
|
if (dependencyPath.startsWith('.')) {
|
|
dependencyPath = path.join(path.dirname(contractSource.path), dependencyPath);
|
|
}
|
|
dependencies.push(dependencyPath);
|
|
}
|
|
}
|
|
});
|
|
return dependencies;
|
|
}
|
|
|
|
let solcJSReleasesCache: BinaryPaths | undefined;
|
|
|
|
/**
|
|
* Fetches the list of available solidity compilers
|
|
* @param isOfflineMode Offline mode flag
|
|
*/
|
|
export async function getSolcJSReleasesAsync(isOfflineMode: boolean): Promise<BinaryPaths> {
|
|
if (isOfflineMode) {
|
|
return constants.SOLC_BIN_PATHS;
|
|
}
|
|
if (solcJSReleasesCache === undefined) {
|
|
const versionList = await fetch('https://ethereum.github.io/solc-bin/bin/list.json');
|
|
const versionListJSON = await versionList.json();
|
|
solcJSReleasesCache = versionListJSON.releases;
|
|
}
|
|
return solcJSReleasesCache as BinaryPaths;
|
|
}
|
|
|
|
/**
|
|
* Compiles the contracts and prints errors/warnings
|
|
* @param solcInstance Instance of a solc compiler
|
|
* @param standardInput Solidity standard JSON input
|
|
* @param isOfflineMode Offline mode flag
|
|
*/
|
|
export async function compileSolcJSAsync(
|
|
solcInstance: solc.SolcInstance,
|
|
standardInput: solc.StandardInput,
|
|
): Promise<solc.StandardOutput> {
|
|
const standardInputStr = JSON.stringify(standardInput);
|
|
const standardOutputStr = solcInstance.compileStandardWrapper(standardInputStr);
|
|
const compiled: solc.StandardOutput = JSON.parse(standardOutputStr);
|
|
return compiled;
|
|
}
|
|
|
|
/**
|
|
* Compiles the contracts and prints errors/warnings
|
|
* @param solidityVersion Solidity version
|
|
* @param standardInput Solidity standard JSON input
|
|
*/
|
|
export async function compileDockerAsync(
|
|
solidityVersion: string,
|
|
standardInput: solc.StandardInput,
|
|
): Promise<solc.StandardOutput> {
|
|
const standardInputStr = JSON.stringify(standardInput, null, 2);
|
|
// prettier-ignore
|
|
const dockerArgs = [
|
|
'run',
|
|
'-i',
|
|
'-a', 'stdin',
|
|
'-a', 'stdout',
|
|
'-a', 'stderr',
|
|
`ethereum/solc:${solidityVersion}`,
|
|
'solc', '--standard-json',
|
|
];
|
|
return new Promise<solc.StandardOutput>((accept, reject) => {
|
|
const p = spawn('docker', dockerArgs, { shell: true, stdio: ['pipe', 'pipe', 'inherit'] });
|
|
p.stdin.write(standardInputStr);
|
|
p.stdin.end();
|
|
let fullOutput = '';
|
|
p.stdout.on('data', (chunk: string) => {
|
|
fullOutput += chunk;
|
|
});
|
|
p.on('close', code => {
|
|
if (code !== 0) {
|
|
reject('Compilation failed');
|
|
}
|
|
accept(JSON.parse(fullOutput));
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Example "relative" paths:
|
|
* /user/leo/0x-monorepo/contracts/extensions/contracts/extension.sol -> extension.sol
|
|
* /user/leo/0x-monorepo/node_modules/@0x/contracts-protocol/contracts/exchange.sol -> @0x/contracts-protocol/contracts/exchange.sol
|
|
*/
|
|
function makeContractPathRelative(
|
|
absolutePath: string,
|
|
contractsDir: string,
|
|
dependencyNameToPath: { [dependencyName: string]: string },
|
|
): string {
|
|
let contractPath = absolutePath.replace(`${contractsDir}/`, '');
|
|
_.map(dependencyNameToPath, (packagePath: string, dependencyName: string) => {
|
|
contractPath = contractPath.replace(packagePath, dependencyName);
|
|
});
|
|
return contractPath;
|
|
}
|
|
|
|
/**
|
|
* Makes the path relative removing all system-dependent data. Converts absolute paths to a format suitable for artifacts.
|
|
* @param absolutePathToSmth Absolute path to contract or source
|
|
* @param contractsDir Current package contracts directory location
|
|
* @param dependencyNameToPath Mapping of dependency name to package path
|
|
*/
|
|
export function makeContractPathsRelative(
|
|
absolutePathToSmth: { [absoluteContractPath: string]: any },
|
|
contractsDir: string,
|
|
dependencyNameToPath: { [dependencyName: string]: string },
|
|
): { [contractPath: string]: any } {
|
|
return _.mapKeys(absolutePathToSmth, (_val: any, absoluteContractPath: string) =>
|
|
makeContractPathRelative(absoluteContractPath, contractsDir, dependencyNameToPath),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Separates errors from warnings, formats the messages and prints them. Throws if there is any compilation error (not warning).
|
|
* @param solcErrors The errors field of standard JSON output that contains errors and warnings.
|
|
*/
|
|
export function printCompilationErrorsAndWarnings(solcErrors: solc.SolcError[]): void {
|
|
const SOLIDITY_WARNING = 'warning';
|
|
const errors = _.filter(solcErrors, entry => entry.severity !== SOLIDITY_WARNING);
|
|
const warnings = _.filter(solcErrors, entry => entry.severity === SOLIDITY_WARNING);
|
|
if (!_.isEmpty(errors)) {
|
|
errors.forEach(error => {
|
|
const normalizedErrMsg = getNormalizedErrMsg(error.formattedMessage || error.message);
|
|
logUtils.log(chalk.red('error'), normalizedErrMsg);
|
|
});
|
|
throw new CompilationError(errors.length);
|
|
} else {
|
|
warnings.forEach(warning => {
|
|
const normalizedWarningMsg = getNormalizedErrMsg(warning.formattedMessage || warning.message);
|
|
logUtils.log(chalk.yellow('warning'), normalizedWarningMsg);
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the source tree hash for a file and its dependencies.
|
|
* @param fileName Name of contract file.
|
|
*/
|
|
export function getSourceTreeHash(resolver: Resolver, importPath: string): Buffer {
|
|
const contractSource = resolver.resolve(importPath);
|
|
const dependencies = parseDependencies(contractSource);
|
|
const sourceHash = ethUtil.sha3(contractSource.source);
|
|
if (dependencies.length === 0) {
|
|
return sourceHash;
|
|
} else {
|
|
const dependencySourceTreeHashes = _.map(dependencies, (dependency: string) => {
|
|
try {
|
|
return getSourceTreeHash(resolver, dependency);
|
|
} catch (e) {
|
|
if (/Error when trying to resolve dependencies for/.test((e as Error).message)) {
|
|
throw e;
|
|
} else {
|
|
throw Error(`Error when trying to resolve dependencies for ${importPath}: ${(e as Error).message}`);
|
|
}
|
|
}
|
|
});
|
|
const sourceTreeHashesBuffer = Buffer.concat([sourceHash, ...dependencySourceTreeHashes]);
|
|
const sourceTreeHash = ethUtil.sha3(sourceTreeHashesBuffer);
|
|
return sourceTreeHash;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Mapping of absolute contract path to compilation ID and source code.
|
|
*/
|
|
export interface CompiledSources {
|
|
[sourcePath: string]: { id: number; content: string };
|
|
}
|
|
|
|
/**
|
|
* Contract sources by import path.
|
|
*/
|
|
export interface CompiledImports {
|
|
[importPath: string]: { id: number; content: string };
|
|
}
|
|
|
|
/**
|
|
* Recursively parses imports from sources starting from `contractPath`.
|
|
* @return Sources required by imports.
|
|
*/
|
|
export function getSourcesWithDependencies(
|
|
contractPath: string,
|
|
sourcesByAbsolutePath: CompiledSources,
|
|
importRemappings: { [prefix: string]: string },
|
|
): CompiledImports {
|
|
const compiledImports = { [`./${path.basename(contractPath)}`]: sourcesByAbsolutePath[contractPath] };
|
|
recursivelyGatherDependencySources(
|
|
contractPath,
|
|
path.dirname(contractPath),
|
|
sourcesByAbsolutePath,
|
|
importRemappings,
|
|
compiledImports,
|
|
);
|
|
return compiledImports;
|
|
}
|
|
|
|
function recursivelyGatherDependencySources(
|
|
contractPath: string,
|
|
rootDir: string,
|
|
sourcesByAbsolutePath: CompiledSources,
|
|
importRemappings: { [prefix: string]: string },
|
|
compiledImports: CompiledImports,
|
|
visitedAbsolutePaths: { [absPath: string]: boolean } = {},
|
|
importRootDir?: string,
|
|
): void {
|
|
if (visitedAbsolutePaths[contractPath]) {
|
|
return;
|
|
} else {
|
|
visitedAbsolutePaths[contractPath] = true;
|
|
}
|
|
const contractSource = sourcesByAbsolutePath[contractPath].content;
|
|
const importStatementMatches = contractSource.match(/\nimport[^;]*;/g);
|
|
if (importStatementMatches === null) {
|
|
return;
|
|
}
|
|
const lastPathSeparatorPos = contractPath.lastIndexOf('/');
|
|
const contractFolder = lastPathSeparatorPos === -1 ? '' : contractPath.slice(0, lastPathSeparatorPos + 1);
|
|
for (const importStatementMatch of importStatementMatches) {
|
|
const importPathMatches = importStatementMatch.match(/\"([^\"]*)\"/);
|
|
if (importPathMatches === null || importPathMatches.length === 0) {
|
|
continue;
|
|
}
|
|
|
|
let importPath = importPathMatches[1];
|
|
let absPath = importPath;
|
|
let _importRootDir = importRootDir;
|
|
if (importPath.startsWith('.')) {
|
|
absPath = path.join(contractFolder, importPath);
|
|
if (_importRootDir) {
|
|
// If there's an `_importRootDir`, we're in a package, so express
|
|
// the import path as within the package.
|
|
importPath = path.join(_importRootDir, importPath);
|
|
} else {
|
|
// Express relative imports paths as paths from the root directory.
|
|
importPath = path.relative(rootDir, absPath);
|
|
if (!importPath.startsWith('.')) {
|
|
importPath = `./${importPath}`;
|
|
}
|
|
}
|
|
} else {
|
|
for (const [prefix, replacement] of Object.entries(importRemappings)) {
|
|
if (importPath.startsWith(prefix)) {
|
|
absPath = `${replacement}${importPath.substr(prefix.length)}`;
|
|
_importRootDir = path.dirname(importPath);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
compiledImports[importPath] = sourcesByAbsolutePath[absPath];
|
|
recursivelyGatherDependencySources(
|
|
absPath,
|
|
rootDir,
|
|
sourcesByAbsolutePath,
|
|
importRemappings,
|
|
compiledImports,
|
|
visitedAbsolutePaths,
|
|
_importRootDir,
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the solidity compiler instance. If the compiler is already cached - gets it from FS,
|
|
* otherwise - fetches it and caches it.
|
|
* @param solidityVersion The solidity version. e.g. 0.5.0
|
|
* @param isOfflineMode Offline mode flag
|
|
*/
|
|
export async function getSolcJSAsync(solidityVersion: string, isOfflineMode: boolean): Promise<solc.SolcInstance> {
|
|
const solcJSReleases = await getSolcJSReleasesAsync(isOfflineMode);
|
|
const fullSolcVersion = solcJSReleases[solidityVersion];
|
|
if (fullSolcVersion === undefined) {
|
|
throw new Error(`${solidityVersion} is not a known compiler version`);
|
|
}
|
|
const compilerBinFilename = path.join(constants.SOLC_BIN_DIR, fullSolcVersion);
|
|
let solcjs: string;
|
|
if (await fsWrapper.doesFileExistAsync(compilerBinFilename)) {
|
|
solcjs = (await fsWrapper.readFileAsync(compilerBinFilename)).toString();
|
|
} else {
|
|
logUtils.warn(`Downloading ${fullSolcVersion}...`);
|
|
const url = `${constants.BASE_COMPILER_URL}${fullSolcVersion}`;
|
|
const response = await fetchAsync(url);
|
|
const SUCCESS_STATUS = 200;
|
|
if (response.status !== SUCCESS_STATUS) {
|
|
throw new Error(`Failed to load ${fullSolcVersion}`);
|
|
}
|
|
solcjs = await response.text();
|
|
await fsWrapper.writeFileAsync(compilerBinFilename, solcjs);
|
|
}
|
|
if (solcjs.length === 0) {
|
|
throw new Error('No compiler available');
|
|
}
|
|
const solcInstance = solc.setupMethods(requireFromString(solcjs, compilerBinFilename));
|
|
return solcInstance;
|
|
}
|
|
|
|
/**
|
|
* Gets the solidity compiler instance from a module path.
|
|
* @param path The path to the solc module.
|
|
*/
|
|
export function getSolcJSFromPath(modulePath: string): solc.SolcInstance {
|
|
return require(modulePath);
|
|
}
|
|
|
|
/**
|
|
* Gets the solidity compiler version from a module path.
|
|
* @param path The path to the solc module.
|
|
*/
|
|
export function getSolcJSVersionFromPath(modulePath: string): string {
|
|
return normalizeSolcVersion(require(modulePath).version());
|
|
}
|
|
|
|
/**
|
|
* Solidity compiler emits the bytecode without a 0x prefix for a hex. This function fixes it if bytecode is present.
|
|
* @param compiledContract The standard JSON output section for a contract. Geth modified in place.
|
|
*/
|
|
export function addHexPrefixToContractBytecode(compiledContract: solc.StandardContractOutput): void {
|
|
if (compiledContract.evm !== undefined) {
|
|
if (compiledContract.evm.bytecode !== undefined && compiledContract.evm.bytecode.object !== undefined) {
|
|
compiledContract.evm.bytecode.object = ethUtil.addHexPrefix(compiledContract.evm.bytecode.object);
|
|
}
|
|
if (
|
|
compiledContract.evm.deployedBytecode !== undefined &&
|
|
compiledContract.evm.deployedBytecode.object !== undefined
|
|
) {
|
|
compiledContract.evm.deployedBytecode.object = ethUtil.addHexPrefix(
|
|
compiledContract.evm.deployedBytecode.object,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Takes the list of resolved contract sources from `SpyResolver` and produces a mapping from dependency name
|
|
* to package path used in `remappings` later, as well as in generating the "relative" source paths saved to the artifact files.
|
|
* @param contractSources The list of resolved contract sources
|
|
*/
|
|
export function getDependencyNameToPackagePath(
|
|
contractSources: ContractSource[],
|
|
): { [dependencyName: string]: string } {
|
|
const allTouchedFiles = contractSources.map(contractSource => `${contractSource.absolutePath}`);
|
|
const NODE_MODULES = 'node_modules';
|
|
const allTouchedDependencies = _.filter(allTouchedFiles, filePath => filePath.includes(NODE_MODULES));
|
|
const dependencyNameToPath: { [dependencyName: string]: string } = {};
|
|
_.map(allTouchedDependencies, dependencyFilePath => {
|
|
const lastNodeModulesStart = dependencyFilePath.lastIndexOf(NODE_MODULES);
|
|
const lastNodeModulesEnd = lastNodeModulesStart + NODE_MODULES.length;
|
|
const importPath = dependencyFilePath.substr(lastNodeModulesEnd + 1);
|
|
let packageName;
|
|
let packageScopeIfExists;
|
|
let dependencyName;
|
|
if (_.startsWith(importPath, '@')) {
|
|
[packageScopeIfExists, packageName] = importPath.split('/');
|
|
dependencyName = `${packageScopeIfExists}/${packageName}`;
|
|
} else {
|
|
[packageName] = importPath.split('/');
|
|
dependencyName = `${packageName}`;
|
|
}
|
|
const dependencyPackagePath = path.join(dependencyFilePath.substr(0, lastNodeModulesEnd), dependencyName);
|
|
dependencyNameToPath[dependencyName] = dependencyPackagePath;
|
|
});
|
|
return dependencyNameToPath;
|
|
}
|
|
|
|
/**
|
|
* Extract the solidity version (e.g., '0.5.9') from a solc version (e.g., `0.5.9+commit.34d3134f`).
|
|
*/
|
|
export function getSolidityVersionFromSolcVersion(solcVersion: string): string {
|
|
const m = /(\d+\.\d+\.\d+)\+commit\.[a-fA-F0-9]{8}/.exec(solcVersion);
|
|
if (!m) {
|
|
throw new Error(`Unable to parse solc version string "${solcVersion}"`);
|
|
}
|
|
return m[1];
|
|
}
|
|
|
|
/**
|
|
* Strips any extra characters before and after the version + commit hash of a solc version string.
|
|
*/
|
|
export function normalizeSolcVersion(fullSolcVersion: string): string {
|
|
const m = /\d+\.\d+\.\d+\+commit\.[a-fA-F0-9]{8}/.exec(fullSolcVersion);
|
|
if (!m) {
|
|
throw new Error(`Unable to parse solc version string "${fullSolcVersion}"`);
|
|
}
|
|
return m[0];
|
|
}
|
|
|
|
/**
|
|
* Gets the full version string of a dockerized solc.
|
|
*/
|
|
export async function getDockerFullSolcVersionAsync(solidityVersion: string): Promise<string> {
|
|
const dockerCommand = `docker run ethereum/solc:${solidityVersion} --version`;
|
|
const versionCommandOutput = (await promisify(exec)(dockerCommand)).stdout.toString();
|
|
const versionCommandOutputParts = versionCommandOutput.split(' ');
|
|
return normalizeSolcVersion(versionCommandOutputParts[versionCommandOutputParts.length - 1].trim());
|
|
}
|
|
|
|
/**
|
|
* Gets the full version string of a JS module solc.
|
|
*/
|
|
export async function getJSFullSolcVersionAsync(
|
|
solidityVersion: string,
|
|
isOfflineMode: boolean = false,
|
|
): Promise<string> {
|
|
return normalizeSolcVersion((await getSolcJSAsync(solidityVersion, isOfflineMode)).version());
|
|
}
|
|
|
|
// tslint:disable-next-line: max-file-line-count
|