Java CompilationResult类代码示例

import org.ethereum.solidity.compiler.CompilationResult; //导入依赖的package包/类
public CompilationResult.ContractMetadata compileContract(String contractPath) throws
				IOException {

	logger.info("Compiling contract...");

	SolidityCompiler.Result result = solidityCompiler.compileSrc(new File(contractPath), true,
					true,
					SolidityCompiler.Options.ABI, SolidityCompiler.Options.BIN);
	if (result.isFailed()) {
		throw new RuntimeException("Contract compilation failed:\n" + result.errors);
	}
	System.out.println(new File(contractPath).getAbsolutePath());
	CompilationResult res = CompilationResult.parse(result.output);
	if (res.contracts.isEmpty()) {
		throw new RuntimeException("Compilation failed, no contracts returned:\n" + result.errors);
	}
	Iterator<CompilationResult.ContractMetadata> iterator = res.contracts.values()
					.iterator();
	CompilationResult.ContractMetadata metadata = iterator.next();
	metadata = iterator.next();
	if (metadata.bin == null || metadata.bin.isEmpty()) {
		throw new RuntimeException("Compilation failed, no binary returned:\n" + result.errors);
	}

	return metadata;
}
 

import org.ethereum.solidity.compiler.CompilationResult; //导入依赖的package包/类
@Test
public void simpleTest() throws IOException {
    String contract =
        "pragma solidity ^0.4.7;\n" +
                "\n" +
                "contract a {\n" +
                "\n" +
                "        mapping(address => string) private mailbox;\n" +
                "\n" +
                "        event Mailed(address from, string message);\n" +
                "        event Read(address from, string message);\n" +
                "\n" +
                "}";

    SolidityCompiler.Result res = SolidityCompiler.compile(
            contract.getBytes(), true, ABI, BIN, INTERFACE, METADATA);
    System.out.println("Out: '" + res.output + "'");
    System.out.println("Err: '" + res.errors + "'");
    CompilationResult result = CompilationResult.parse(res.output);
    if (result.contracts.get("a") != null)
        System.out.println(result.contracts.get("a").bin);
    else
        Assert.fail();
}
 

import org.ethereum.solidity.compiler.CompilationResult; //导入依赖的package包/类
@Test
public void defaultFuncTest() throws IOException {
    String contractSrc =
        "pragma solidity ^0.4.7;\n" +
                "contract a {" +
                "        function() {throw;}" +
                "}";

    SolidityCompiler.Result res = SolidityCompiler.compile(
            contractSrc.getBytes(), true, ABI, BIN, INTERFACE, METADATA);
    System.out.println("Out: '" + res.output + "'");
    System.out.println("Err: '" + res.errors + "'");
    CompilationResult result = CompilationResult.parse(res.output);

    CompilationResult.ContractMetadata a = result.contracts.get("a");
    CallTransaction.Contract contract = new CallTransaction.Contract(a.abi);
    System.out.printf(contract.functions[0].toString());
}
 

import org.ethereum.solidity.compiler.CompilationResult; //导入依赖的package包/类
public String sendContractToNetwork(final boolean userContract) throws IOException, InterruptedException {
    LOGGER.info("Compiling contract...");
    final ECKey senderKey = ECKey.fromPrivate(decode(privateKey));
    CompilationResult.ContractMetadata contractBinary = null;
    if (userContract) {
        contractBinary = solidityCompilerService.compileUserContract();
    } else {
        contractBinary = solidityCompilerService.compileRegistryContract();
    }
    LOGGER.info("Preparing transaction to send contract to the network.");
    Transaction contractTransaction =
            sendTransaction(null, senderKey, ETHER_TO_TRANSFER_IN_WEI, decode(contractBinary.bin));
    if (contractTransaction != null) {
        return toHexString(contractTransaction.getContractAddress());
    } else {
        return null;
    }
}
 

import org.ethereum.solidity.compiler.CompilationResult; //导入依赖的package包/类
private String writeToContract(final String functionName, final String contractAddress,
                               final boolean isUserContract, final Object... args)
        throws IOException, InterruptedException {
    final ECKey senderKey = ECKey.fromPrivate(decode(privateKey));
    CompilationResult.ContractMetadata contractBinary = null;
    if (isUserContract) {
        contractBinary = solidityCompilerService.compileUserContract();
    } else {
        contractBinary = solidityCompilerService.compileRegistryContract();
    }
    CallTransaction.Contract compiledContract = new CallTransaction.Contract(contractBinary.abi);

    CallTransaction.Function function = compiledContract.getByName(functionName);
    byte[] functionCallBytes = function.encode(args);

    Transaction transaction =
            sendTransaction(contractAddress, senderKey, ETHER_TO_TRANSFER_IN_WEI, functionCallBytes);

    return toHexString(transaction.getHash());
}
 

import org.ethereum.solidity.compiler.CompilationResult; //导入依赖的package包/类
public Object[] readContract(final String functionName,
                             final String contractAddress, final Object... args) throws IOException {
    CompilationResult.ContractMetadata contractBinary = solidityCompilerService.compileUserContract();
    CallTransaction.Contract compiledContract = new CallTransaction.Contract(contractBinary.abi);

    CallTransaction.Function function = compiledContract.getByName(functionName);

    ProgramResult result;
    if (args != null) {
        result = getEthereum().callConstantFunction(contractAddress, function, args);
    } else {
        result = getEthereum().callConstantFunction(contractAddress, function);
    }
    Object[] functionResult = function.decodeResult(result.getHReturn());
    return functionResult;
}
 

import org.ethereum.solidity.compiler.CompilationResult; //导入依赖的package包/类
/**
 * Returns the already compiled contact.
 * 
 * @param filePath the filename and path of the combined json
 * @return the contract data (bin, abi)
 * @throws URISyntaxException
 * @throws FileNotFoundException
 * @throws IOException
 */
protected SolidityContractDetails getCompiledContract(String filePath) throws URISyntaxException, FileNotFoundException, IOException {
	SolidityContractDetails compiledContract = contracts.get(getQuallifiedContractName());
	if(compiledContract!=null)
		return compiledContract;

	File file = new File(this.getClass().getResource(filePath).toURI());
	String rawJson = IOUtils.toString(new FileInputStream(file), EthereumFacade.CHARSET);
	CompilationResult result = CompilationResult.parse(rawJson);
	
	ContractMetadata contractMetadata = result.contracts.get(getContractName());
	if (contractMetadata == null) {
		Optional<String> optional = result.contracts.keySet().stream()
				.filter(s -> s.endsWith(getQuallifiedContractName())).findFirst();
		if (optional.isPresent())
			contractMetadata = result.contracts.get(optional.get());
	}
	compiledContract =  new SolidityContractDetails(contractMetadata.abi, contractMetadata.bin,
			contractMetadata.metadata);

	contracts.put(getQuallifiedContractName(), compiledContract);
	return compiledContract;
}
 

import org.ethereum.solidity.compiler.CompilationResult; //导入依赖的package包/类
@Test
@Ignore
public void simpleTest() throws IOException {
    SystemProperties systemProperties = Mockito.mock(SystemProperties.class);
    String solc = System.getProperty("solc");
    if(StringUtils.isEmpty(solc))
        solc = "/usr/bin/solc";

    Mockito.when(systemProperties.customSolcPath()).thenReturn(solc);

    SolidityCompiler solidityCompiler = new SolidityCompiler(systemProperties);

    String contract =
        "contract a {" +
                "  int i1;" +
                "  function i() returns (int) {" +
                "    return i1;" +
                "  }" +
                "}";
    SolidityCompiler.Result res = solidityCompiler.compile(
            contract.getBytes(), true, SolidityCompiler.Options.ABI, SolidityCompiler.Options.BIN, SolidityCompiler.Options.INTERFACE);
    System.out.println("Out: '" + res.output + "'");
    System.out.println("Err: '" + res.errors + "'");
    CompilationResult result = CompilationResult.parse(res.output);
    CompilationResult.ContractMetadata cmeta = result.contracts.get("a");

    if (cmeta == null)
        cmeta = result.contracts.get("<stdin>:a");

    if (cmeta != null)
        System.out.println(cmeta.bin);
    else
        Assert.fail();
}
 

import org.ethereum.solidity.compiler.CompilationResult; //导入依赖的package包/类
private SolidityContractImpl createContractFromJson(String contractName, String json) throws IOException {
	CompilationResult result = CompilationResult.parse(json);
	if (contractName == null) {
	    if (result.contracts.size() > 1) {
	        throw new RuntimeException("Source contains more than 1 contact (" + result.contracts.keySet() + "). Please specify the contract name");
	    } else {
	        contractName = result.contracts.keySet().iterator().next();
	    }
	}

	return createContract(contractName, result);
}
 

import org.ethereum.solidity.compiler.CompilationResult; //导入依赖的package包/类
/**
 * @param contractName
 * @param result
 * @return
 */
private SolidityContractImpl createContract(String contractName, CompilationResult result) {
	ContractMetadata cMetaData = result.contracts.get(contractName);
	SolidityContractImpl contract = createContract(cMetaData);

	for (CompilationResult.ContractMetadata metadata : result.contracts.values()) {
	    contract.addRelatedContract(metadata.abi);
	}
	return contract;
}
 

import org.ethereum.solidity.compiler.CompilationResult; //导入依赖的package包/类
@Test
public void compileFilesTest() throws IOException {

    File source = new File("src/test/resources/solidity/file1.sol");

    SolidityCompiler.Result res = SolidityCompiler.compile(
            source, true, ABI, BIN, INTERFACE, METADATA);
    System.out.println("Out: '" + res.output + "'");
    System.out.println("Err: '" + res.errors + "'");
    CompilationResult result = CompilationResult.parse(res.output);

    CompilationResult.ContractMetadata a = result.contracts.get("test1");
    CallTransaction.Contract contract = new CallTransaction.Contract(a.abi);
    System.out.printf(contract.functions[0].toString());
}
 

import org.ethereum.solidity.compiler.CompilationResult; //导入依赖的package包/类
private ContractMetadata getContractMetadata(final Result result)
        throws IOException {
    CompilationResult compilationResult = parse(result.output);
    if (compilationResult.contracts.isEmpty()) {
        throw new RuntimeException("Compilation failed, no contracts returned:\n" + result.errors);
    }
    ContractMetadata metadata = compilationResult.contracts.values()
            .iterator().next();
    if (metadata.bin == null || metadata.bin.isEmpty()) {
        throw new RuntimeException("Compilation failed, no binary returned:\n" + result.errors);
    }
    return metadata;
}
 

import org.ethereum.solidity.compiler.CompilationResult; //导入依赖的package包/类
private void compile() throws IOException {
    InputStream solidityStream =  this.getClass().getResourceAsStream("/SimpleOwnedStorage.sol");
    String solidityString = IOUtils.toString(solidityStream);
    SolidityCompiler.Result result = SolidityCompiler.compile(solidityString.getBytes(), true,
            SolidityCompiler.Options.ABI, SolidityCompiler.Options.BIN);
    CompilationResult res = CompilationResult.parse(result.output);
    CompilationResult.ContractMetadata metadata = res.contracts.get("SimpleOwnedStorage");
    System.out.println(metadata.bin);
    System.out.println(metadata.abi);

}
 

import org.ethereum.solidity.compiler.CompilationResult; //导入依赖的package包/类
public CompileOutput(CompilationResult result, String sourceCode) {
    this();

    result.contracts.forEach((name, data) -> {
        contractData.put(name, new ContractData(data, sourceCode, result.version));
    });
}
 

import org.ethereum.solidity.compiler.CompilationResult; //导入依赖的package包/类
/**
 * Change the contract source.
 * 
 * @param contractSourceFile
 * @param compiled
 */
public void setContractSource(String contractSourceFile, boolean compiled) {
	try {
		if (!compiled) {
	        File contractSrc = new File(this.getClass().getResource(contractSourceFile).toURI());
			contractSource = SoliditySource.from(contractSrc);
		} else {
			String rawJson = IOUtils.toString(this.getClass().getResourceAsStream(contractSourceFile),
					EthereumFacade.CHARSET);
			compiledContracts = CompilationResult.parse(rawJson);
		}
	} catch (IOException | URISyntaxException e) {
		throw new IllegalArgumentException(e);
	}
}