scol 0.8.28

package/translate.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const linker_1 = __importDefault(require("./linker"));
+/// Translate old style version numbers to semver.
+/// Old style: 0.3.6-3fc68da5/Release-Emscripten/clang
+///            0.3.5-371690f0/Release-Emscripten/clang/Interpreter
+///            0.3.5-0/Release-Emscripten/clang/Interpreter
+///            0.2.0-e7098958/.-Emscripten/clang/int linked to libethereum-1.1.1-bbb80ab0/.-Emscripten/clang/int
+///            0.1.3-0/.-/clang/int linked to libethereum-0.9.92-0/.-/clang/int
+///            0.1.2-5c3bfd4b*/.-/clang/int
+///            0.1.1-6ff4cd6b/RelWithDebInfo-Emscripten/clang/int
+/// New style: 0.4.5+commit.b318366e.Emscripten.clang
+function versionToSemver(version) {
+    // FIXME: parse more detail, but this is a good start
+    const parsed = version.match(/^([0-9]+\.[0-9]+\.[0-9]+)-([0-9a-f]{8})[/*].*$/);
+    if (parsed) {
+        return parsed[1] + '+commit.' + parsed[2];
+    }
+    if (version.indexOf('0.1.3-0') !== -1) {
+        return '0.1.3';
+    }
+    if (version.indexOf('0.3.5-0') !== -1) {
+        return '0.3.5';
+    }
+    // assume it is already semver compatible
+    return version;
+}
+function translateErrors(ret, errors) {
+    for (const error in errors) {
+        let type = 'error';
+        let extractType = /^(.*):(\d+):(\d+):(.*):/;
+        extractType = extractType.exec(errors[error]);
+        if (extractType) {
+            type = extractType[4].trim();
+        }
+        else if (errors[error].indexOf(': Warning:')) {
+            type = 'Warning';
+        }
+        else if (errors[error].indexOf(': Error:')) {
+            type = 'Error';
+        }
+        ret.push({
+            type: type,
+            component: 'general',
+            severity: (type === 'Warning') ? 'warning' : 'error',
+            message: errors[error],
+            formattedMessage: errors[error]
+        });
+    }
+}
+function translateGasEstimates(gasEstimates) {
+    if (gasEstimates === null) {
+        return 'infinite';
+    }
+    if (typeof gasEstimates === 'number') {
+        return gasEstimates.toString();
+    }
+    const gasEstimatesTranslated = {};
+    for (const func in gasEstimates) {
+        gasEstimatesTranslated[func] = translateGasEstimates(gasEstimates[func]);
+    }
+    return gasEstimatesTranslated;
+}
+function translateJsonCompilerOutput(output, libraries) {
+    const ret = {};
+    ret.errors = [];
+    let errors;
+    if (output.error) {
+        errors = [output.error];
+    }
+    else {
+        errors = output.errors;
+    }
+    translateErrors(ret.errors, errors);
+    ret.contracts = {};
+    for (const contract in output.contracts) {
+        // Split name first, can be `contract`, `:contract` or `filename:contract`
+        const tmp = contract.match(/^((.*):)?([^:]+)$/);
+        if (tmp.length !== 4) {
+            // Force abort
+            return null;
+        }
+        let fileName = tmp[2];
+        if (fileName === undefined) {
+            // this is the case of `contract`
+            fileName = '';
+        }
+        const contractName = tmp[3];
+        const contractInput = output.contracts[contract];
+        const gasEstimates = contractInput.gasEstimates;
+        const translatedGasEstimates = {};
+        if (gasEstimates.creation) {
+            translatedGasEstimates.creation = {
+                codeDepositCost: translateGasEstimates(gasEstimates.creation[1]),
+                executionCost: translateGasEstimates(gasEstimates.creation[0])
+            };
+        }
+        if (gasEstimates.internal) {
+            translatedGasEstimates.internal = translateGasEstimates(gasEstimates.internal);
+        }
+        if (gasEstimates.external) {
+            translatedGasEstimates.external = translateGasEstimates(gasEstimates.external);
+        }
+        const contractOutput = {
+            abi: JSON.parse(contractInput.interface),
+            metadata: contractInput.metadata,
+            evm: {
+                legacyAssembly: contractInput.assembly,
+                bytecode: {
+                    object: contractInput.bytecode && linker_1.default.linkBytecode(contractInput.bytecode, libraries || {}),
+                    opcodes: contractInput.opcodes,
+                    sourceMap: contractInput.srcmap,
+                    linkReferences: contractInput.bytecode && linker_1.default.findLinkReferences(contractInput.bytecode)
+                },
+                deployedBytecode: {
+                    object: contractInput.runtimeBytecode && linker_1.default.linkBytecode(contractInput.runtimeBytecode, libraries || {}),
+                    sourceMap: contractInput.srcmapRuntime,
+                    linkReferences: contractInput.runtimeBytecode && linker_1.default.findLinkReferences(contractInput.runtimeBytecode)
+                },
+                methodIdentifiers: contractInput.functionHashes,
+                gasEstimates: translatedGasEstimates
+            }
+        };
+        if (!ret.contracts[fileName]) {
+            ret.contracts[fileName] = {};
+        }
+        ret.contracts[fileName][contractName] = contractOutput;
+    }
+    const sourceMap = {};
+    for (const sourceId in output.sourceList) {
+        sourceMap[output.sourceList[sourceId]] = sourceId;
+    }
+    ret.sources = {};
+    for (const source in output.sources) {
+        ret.sources[source] = {
+            id: sourceMap[source],
+            legacyAST: output.sources[source].AST
+        };
+    }
+    return ret;
+}
+function escapeString(text) {
+    return text
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r')
+        .replace(/\t/g, '\\t');
+}
+// 'asm' can be an object or a string
+function formatAssemblyText(asm, prefix, source) {
+    if (typeof asm === 'string' || asm === null || asm === undefined) {
+        return prefix + (asm || '') + '\n';
+    }
+    let text = prefix + '.code\n';
+    asm['.code'].forEach(function (item, i) {
+        const v = item.value === undefined ? '' : item.value;
+        let src = '';
+        if (source !== undefined && item.begin !== undefined && item.end !== undefined) {
+            src = escapeString(source.slice(item.begin, item.end));
+        }
+        if (src.length > 30) {
+            src = src.slice(0, 30) + '...';
+        }
+        if (item.name !== 'tag') {
+            text += '  ';
+        }
+        text += prefix + item.name + ' ' + v + '\t\t\t' + src + '\n';
+    });
+    text += prefix + '.data\n';
+    const asmData = asm['.data'] || [];
+    for (const i in asmData) {
+        const item = asmData[i];
+        text += '  ' + prefix + '' + i + ':\n';
+        text += formatAssemblyText(item, prefix + '    ', source);
+    }
+    return text;
+}
+function prettyPrintLegacyAssemblyJSON(assembly, source) {
+    return formatAssemblyText(assembly, '', source);
+}
+module.exports = {
+    versionToSemver,
+    translateJsonCompilerOutput,
+    prettyPrintLegacyAssemblyJSON
+};

package/verifyVersion.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const semver = __importStar(require("semver"));
+const _1 = __importDefault(require("./"));
+const { version: packageVersion } = require('./package.json');
+const solcVersion = _1.default.version();
+console.log('solcVersion: ' + solcVersion);
+console.log('packageVersion: ' + packageVersion);
+if (semver.eq(packageVersion, solcVersion)) {
+    console.log('Version matching');
+    process.exit(0);
+}
+else {
+    console.log('Version mismatch');
+    process.exit(1);
+}

package/wrapper.js

@@ -0,0 +1,143 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const memorystream_1 = __importDefault(require("memorystream"));
+const follow_redirects_1 = require("follow-redirects");
+const formatters_1 = require("./formatters");
+const helpers_1 = require("./common/helpers");
+const bindings_1 = __importDefault(require("./bindings"));
+const translate_1 = __importDefault(require("./translate"));
+const Module = module.constructor;
+function wrapper(soljson) {
+    const { coreBindings, compileBindings, methodFlags } = (0, bindings_1.default)(soljson);
+    return {
+        version: coreBindings.version,
+        semver: coreBindings.versionToSemver,
+        license: coreBindings.license,
+        lowlevel: {
+            compileSingle: compileBindings.compileJson,
+            compileMulti: compileBindings.compileJsonMulti,
+            compileCallback: compileBindings.compileJsonCallback,
+            compileStandard: compileBindings.compileStandard
+        },
+        features: {
+            legacySingleInput: methodFlags.compileJsonStandardSupported,
+            multipleInputs: methodFlags.compileJsonMultiSupported || methodFlags.compileJsonStandardSupported,
+            importCallback: methodFlags.compileJsonCallbackSuppported || methodFlags.compileJsonStandardSupported,
+            nativeStandardJSON: methodFlags.compileJsonStandardSupported
+        },
+        compile: compileStandardWrapper.bind(this, compileBindings),
+        // Loads the compiler of the given version from the github repository
+        // instead of from the local filesystem.
+        loadRemoteVersion,
+        // Use this if you want to add wrapper functions around the pure module.
+        setupMethods: wrapper
+    };
+}
+function loadRemoteVersion(versionString, callback) {
+    const memoryStream = new memorystream_1.default(null, { readable: false });
+    const url = `https://binaries.soliditylang.org/bin/soljson-${versionString}.js`;
+    follow_redirects_1.https.get(url, response => {
+        if (response.statusCode !== 200) {
+            callback(new Error(`Error retrieving binary: ${response.statusMessage}`));
+        }
+        else {
+            response.pipe(memoryStream);
+            response.on('end', () => {
+                // Based on the require-from-string package.
+                const soljson = new Module();
+                soljson._compile(memoryStream.toString(), `soljson-${versionString}.js`);
+                if (module.parent && module.parent.children) {
+                    // Make sure the module is plugged into the hierarchy correctly to have parent
+                    // properly garbage collected.
+                    module.parent.children.splice(module.parent.children.indexOf(soljson), 1);
+                }
+                callback(null, wrapper(soljson.exports));
+            });
+        }
+    }).on('error', function (error) {
+        callback(error);
+    });
+}
+// Expects a Standard JSON I/O but supports old compilers
+function compileStandardWrapper(compile, inputRaw, readCallback) {
+    if (!(0, helpers_1.isNil)(compile.compileStandard)) {
+        return compile.compileStandard(inputRaw, readCallback);
+    }
+    let input;
+    try {
+        input = JSON.parse(inputRaw);
+    }
+    catch (e) {
+        return (0, formatters_1.formatFatalError)(`Invalid JSON supplied: ${e.message}`);
+    }
+    if (input.language !== 'Solidity') {
+        return (0, formatters_1.formatFatalError)('Only "Solidity" is supported as a language.');
+    }
+    // NOTE: this is deliberately `== null`
+    if ((0, helpers_1.isNil)(input.sources) || input.sources.length === 0) {
+        return (0, formatters_1.formatFatalError)('No input sources specified.');
+    }
+    const sources = translateSources(input);
+    const optimize = isOptimizerEnabled(input);
+    const libraries = librariesSupplied(input);
+    if ((0, helpers_1.isNil)(sources) || Object.keys(sources).length === 0) {
+        return (0, formatters_1.formatFatalError)('Failed to process sources.');
+    }
+    // Try to wrap around old versions
+    if (!(0, helpers_1.isNil)(compile.compileJsonCallback)) {
+        const inputJson = JSON.stringify({ sources: sources });
+        const output = compile.compileJsonCallback(inputJson, optimize, readCallback);
+        return translateOutput(output, libraries);
+    }
+    if (!(0, helpers_1.isNil)(compile.compileJsonMulti)) {
+        const output = compile.compileJsonMulti(JSON.stringify({ sources: sources }), optimize);
+        return translateOutput(output, libraries);
+    }
+    // Try our luck with an ancient compiler
+    if (!(0, helpers_1.isNil)(compile.compileJson)) {
+        if (Object.keys(sources).length > 1) {
+            return (0, formatters_1.formatFatalError)('Multiple sources provided, but compiler only supports single input.');
+        }
+        const input = sources[Object.keys(sources)[0]];
+        const output = compile.compileJson(input, optimize);
+        return translateOutput(output, libraries);
+    }
+    return (0, formatters_1.formatFatalError)('Compiler does not support any known interface.');
+}
+function isOptimizerEnabled(input) {
+    return input.settings && input.settings.optimizer && input.settings.optimizer.enabled;
+}
+function translateSources(input) {
+    const sources = {};
+    for (const source in input.sources) {
+        if (input.sources[source].content !== null) {
+            sources[source] = input.sources[source].content;
+        }
+        else {
+            // force failure
+            return null;
+        }
+    }
+    return sources;
+}
+function librariesSupplied(input) {
+    if (!(0, helpers_1.isNil)(input.settings))
+        return input.settings.libraries;
+}
+function translateOutput(outputRaw, libraries) {
+    let parsedOutput;
+    try {
+        parsedOutput = JSON.parse(outputRaw);
+    }
+    catch (e) {
+        return (0, formatters_1.formatFatalError)(`Compiler returned invalid JSON: ${e.message}`);
+    }
+    const output = translate_1.default.translateJsonCompilerOutput(parsedOutput, libraries);
+    if ((0, helpers_1.isNil)(output)) {
+        return (0, formatters_1.formatFatalError)('Failed to process output.');
+    }
+    return JSON.stringify(output);
+}
+module.exports = wrapper;