Top 10 Examples of "solc in functional component" in JavaScript

function compileContract(name, filename) {
    console.log('compiling contract', name);
    var input = fs.readFileSync(filename).toString();
    var sources = {};
    sources[filename] = input;
    var output = solc.compile({ sources: sources }, 1, findImports); // 1 activates the optimiser

    return output.contracts[name];
}

const compile = async (filename) => {
  filename = filename.replace('.sol', '')

  const filePath = path.join(CONTRACTS_PATH, filename + '.sol')
  const source = fs.readFileSync(filePath, 'utf-8')

  // grabs the contract reference
  const compiled = solc.compile(source, 1)

  const contract = compiled.contracts[':' + filename]

  if (contract) {
    console.log('  OK!')
  }

  if (compiled.errors) {
    if (contract) {
      console.log('warnings:')
    } else {
      console.log('errors:')
    }

    console.log(compiled.errors)
  }

before(function(done) {
    this.timeout(10000);

    // Compile first
    var result = solc.compile(fs.readFileSync("./test/Example.sol", {encoding: "utf8"}), 1);

    // Clean up after solidity. Only remove solidity's listener,
    // which happens to be the first.
    process.removeListener("uncaughtException", process.listeners("uncaughtException")[0]);

    var compiled = Schema.normalize(result.contracts["Example"]);
    abi = compiled.abi;
    binary = compiled.bytecode;

    // Setup
    var dirPath = temp.mkdirSync({
      dir: path.resolve("./"),
      prefix: 'tmp-test-contract-'
    });

    var expected_filepath = path.join(dirPath, "Example.json");

async function deploy(contractName, { from, args, log }) {
    var sources = {
      [contractName]: {
        content: fs.readFileSync(`${contracts}/${contractName}.sol`).toString()
      }
    }
    var compileOpts = JSON.stringify({ ...solcOpts, sources })

    // Compile the contract using solc
    var rawOutput = solc.compileStandardWrapper(
      compileOpts,
      findImportsPath(contracts)
    )
    var output = JSON.parse(rawOutput)

    // If there were any compilation errors, throw them
    if (output.errors) {
      output.errors.forEach(err => {
        if (!err.formattedMessage.match(/Warning:/)) {
          throw new SyntaxError(err.formattedMessage)
        }
      })
    }

    var { abi, evm: { bytecode } } = output.contracts[contractName][
      contractName

// Deploy linked libraries
    for (let linkedFile in bytecode.linkReferences) {
      for (let linkedLib in bytecode.linkReferences[linkedFile]) {
        let libObj = output.contracts[linkedFile][linkedLib]
        let LibContract = new web3.eth.Contract(libObj.abi)
        var libContract = await LibContract.deploy({
          data: libObj.evm.bytecode.object
        }).send({
          from,
          gas: 3000000
        })

        let libs = { [`${linkedFile}:${linkedLib}`]: libContract._address }

        bytecode.object = linker.linkBytecode(bytecode.object, libs)
      }
    }

    if (!bytecode.object) {
      throw new Error(
        'No Bytecode. Do the method signatures match the interface?'
      )
    }

    if (process.env.BUILD) {
      fs.writeFileSync(
        __dirname + '/../src/contracts/' + contractName + '.js',
        'module.exports = ' +
          JSON.stringify(
            {
              abi,

},
      settings: {
        outputSelection: {
          "*": {
            "*": [
              "abi",
              "evm.bytecode.object",
              "evm.bytecode.sourceMap",
              "evm.deployedBytecode.object",
              "evm.deployedBytecode.sourceMap"
            ]
          }
        }
      }
    });
    var solcOut = JSON.parse(solc.compileStandard(solcIn));

    // contracts now grouped by solidity source file
    var rawA = solcOut.contracts["A.sol"].A;

    var A = Schema.normalize(rawA);

    var expected = {
      abi: rawA.abi,
      bytecode: "0x" + rawA.evm.bytecode.object,
      deployedBytecode: "0x" + rawA.evm.deployedBytecode.object,
      sourceMap: rawA.evm.bytecode.sourceMap,
      deployedSourceMap: rawA.evm.deployedBytecode.sourceMap
    };

    Object.keys(expected).forEach(function (key)  {
      var expectedValue = expected[key];

async function main() {
  console.log("Compiling contracts...");
  var inputs = {}; 
    for (contract of Contracts){
      var parts = contract.split(':');
      inputs[contract+'.sol'] =  fs.readFileSync("./contracts/"+parts[0]+".sol", 'utf8');
    }
    try{ 
      var output = solc.compile({ sources: inputs }, 1, findImports)
    }
    catch(error){
      console.log(error);
    }
    for (err in output.errors){
      console.log(output.errors[err]);
    }
    if (!output.contracts || Object.keys(output.contracts).length == 0){
      throw("Didn't compile");
    }
    // new RegExp('__([a-zA-Z.:]+)[_]*', 'g');
    // const libraryRE = /__([a-zA-Z.:]+)[_]*/g.compile();
    const libraryRE = new RegExp('__([a-zA-Z.:]+)[_]*', 'g');
    for (var property in output.contracts) {
      if (output.contracts.hasOwnProperty(property)) {
        var contract = output.contracts[property];

function compileContracts(source_files) {
    // Load the inputs
    const sources = {};

    for ( const file of source_files ) {
        sources[file] = fs.readFileSync(file).toString();
    }
    
    // Compile the input
    const output = solc.compile({
        sources: sources
    }, 1);
    console.log(23423,output);
    const result = {};

    // Parse all compiled contracts
    for ( const k in  output.contracts ) {
        // Find which contract was compiled
        const contractKey = k.split(':').pop();
        const contract = output.contracts[k];

        // Get the bytecode and ABI
        const bytecode = contract.bytecode;
        const abi = JSON.parse(contract.interface);

        result[contractKey] = {

outputSelection: {
      '*': {
        '': [ 'legacyAST' ],
        '*': [ 'abi', 'metadata', 'devdoc', 'userdoc', 'evm.legacyAssembly', 'evm.bytecode', 'evm.deployedBytecode', 'evm.methodIdentifiers', 'evm.gasEstimates' ]
      }
    }
  }
}

inputJson.sources[shortFilename] = {content: fs.readFileSync(filename).toString()}

console.dir(inputJson)

console.log('compiling...')

let compilationData = JSON.parse(solc.compileStandardWrapper(JSON.stringify(inputJson)))
console.dir(Object.keys(compilationData))
var compilation = {}
compilation.data = compilationData
compilation.source = { sources: inputJson.sources }
console.dir(compilation)
console.dir(compilation.data.errors)

var cmdLine = new CmdLine()
cmdLine.connect('http', 'http://localhost:8545')
cmdLine.loadCompilationResult(compilation)
cmdLine.initDebugger()

// var deployContract = function (cb) {
//   let _web3 = cmdLine.debugger.debugger.web3
//
//   let blockNumber = null

let file_folder = answers['file_folder'];

  console.log('Current working directory: '+file_folder)
  // make sure the file to be compiled in under current folder
  var file_path = file_folder +'/'+file_name;
  console.log('File being compiled and compared: '+file_name);
  // read contract file as input or log err message otherwise
  var input = fs.readFileSync(file_path,'utf8');
  var bytecode_from_compiler;
  var bytecode_from_blockchain;
  console.log('==========================================')
  console.log('Compiler Version: '+solc_version)
  // use specified solc version on the fly by loading from github
  console.log(chalk.bold.green('Compiling in progress, ')+' Please be patient...')

  solc.loadRemoteVersion(solc_version, function(err, solc_specific){
  	if(err){
  		console.log('Solc failed to loaded'+err);
	  }
	  
	var input_json = {  language: "Solidity",
						sources: 
							{file: {"content": input} },
						settings: {
									optimizer: {
										// disabled by default
										enabled: is_optimized,
										runs: 200
									},
									outputSelection: {
									"*": {
										"*": [ "*" ]