Examples with EVM org.hyperledger.besu.evm.EVM used on opensource projects

Example 1 with EVM

use of org.hyperledger.besu.evm.EVM in project besu by hyperledger.

the class PrevRanDaoOperationTest method pushesPrevRandaoWhenDifficultyZero.

@Test
public void pushesPrevRandaoWhenDifficultyZero() {
    PrevRanDaoOperation op = new PrevRanDaoOperation(new LondonGasCalculator());
    MessageFrame messageFrame = mock(MessageFrame.class);
    BlockValues blockHeader = mock(BlockValues.class);
    Bytes32 prevRandao = Bytes32.fromHexString("0xb0b0face");
    when(blockHeader.getDifficultyBytes()).thenReturn(UInt256.ZERO);
    when(blockHeader.getMixHashOrPrevRandao()).thenReturn(prevRandao);
    when(messageFrame.getBlockValues()).thenReturn(blockHeader);
    EVM evm = mock(EVM.class);
    Operation.OperationResult r = op.executeFixedCostOperation(messageFrame, evm);
    assertThat(r.getHaltReason()).isNotPresent();
    verify(messageFrame).pushStackItem(prevRandao);
}

Example 2 with EVM

use of org.hyperledger.besu.evm.EVM in project besu by hyperledger.

the class ProtocolSpecBuilder method build.

public ProtocolSpec build(final ProtocolSchedule protocolSchedule) {
    checkNotNull(gasCalculatorBuilder, "Missing gasCalculator");
    checkNotNull(gasLimitCalculator, "Missing gasLimitCalculator");
    checkNotNull(evmBuilder, "Missing operation registry");
    checkNotNull(evmConfiguration, "Missing evm configuration");
    checkNotNull(transactionValidatorBuilder, "Missing transaction validator");
    checkNotNull(privateTransactionValidatorBuilder, "Missing private transaction validator");
    checkNotNull(contractCreationProcessorBuilder, "Missing contract creation processor");
    checkNotNull(precompileContractRegistryBuilder, "Missing precompile contract registry");
    checkNotNull(messageCallProcessorBuilder, "Missing message call processor");
    checkNotNull(transactionProcessorBuilder, "Missing transaction processor");
    checkNotNull(privateTransactionProcessorBuilder, "Missing private transaction processor");
    checkNotNull(blockHeaderValidatorBuilder, "Missing block header validator");
    checkNotNull(blockBodyValidatorBuilder, "Missing block body validator");
    checkNotNull(blockProcessorBuilder, "Missing block processor");
    checkNotNull(blockImporterBuilder, "Missing block importer");
    checkNotNull(blockValidatorBuilder, "Missing block validator");
    checkNotNull(blockHeaderFunctions, "Missing block hash function");
    checkNotNull(blockReward, "Missing block reward");
    checkNotNull(difficultyCalculator, "Missing difficulty calculator");
    checkNotNull(transactionReceiptFactory, "Missing transaction receipt factory");
    checkNotNull(name, "Missing name");
    checkNotNull(miningBeneficiaryCalculator, "Missing Mining Beneficiary Calculator");
    checkNotNull(protocolSchedule, "Missing protocol schedule");
    checkNotNull(privacyParameters, "Missing privacy parameters");
    checkNotNull(feeMarket, "Missing fee market");
    checkNotNull(badBlockManager, "Missing bad blocks manager");
    final GasCalculator gasCalculator = gasCalculatorBuilder.get();
    final EVM evm = evmBuilder.apply(gasCalculator, evmConfiguration);
    final PrecompiledContractConfiguration precompiledContractConfiguration = new PrecompiledContractConfiguration(gasCalculator, privacyParameters);
    final MainnetTransactionValidator transactionValidator = transactionValidatorBuilder.apply(gasCalculator);
    final AbstractMessageProcessor contractCreationProcessor = contractCreationProcessorBuilder.apply(gasCalculator, evm);
    final PrecompileContractRegistry precompileContractRegistry = precompileContractRegistryBuilder.apply(precompiledContractConfiguration);
    final AbstractMessageProcessor messageCallProcessor = messageCallProcessorBuilder.apply(evm, precompileContractRegistry);
    final MainnetTransactionProcessor transactionProcessor = transactionProcessorBuilder.apply(gasCalculator, transactionValidator, contractCreationProcessor, messageCallProcessor);
    final BlockHeaderValidator blockHeaderValidator = blockHeaderValidatorBuilder.apply(feeMarket).difficultyCalculator(difficultyCalculator).build();
    final BlockHeaderValidator ommerHeaderValidator = ommerHeaderValidatorBuilder.apply(feeMarket).difficultyCalculator(difficultyCalculator).build();
    final BlockBodyValidator blockBodyValidator = blockBodyValidatorBuilder.apply(protocolSchedule);
    BlockProcessor blockProcessor = blockProcessorBuilder.apply(transactionProcessor, transactionReceiptFactory, blockReward, miningBeneficiaryCalculator, skipZeroBlockRewards, privacyParameters.getGoQuorumPrivacyParameters());
    // Set private Tx Processor
    PrivateTransactionProcessor privateTransactionProcessor = null;
    if (privacyParameters.isEnabled()) {
        final PrivateTransactionValidator privateTransactionValidator = privateTransactionValidatorBuilder.apply();
        privateTransactionProcessor = privateTransactionProcessorBuilder.apply(gasCalculator, transactionValidator, contractCreationProcessor, messageCallProcessor, privateTransactionValidator);
        if (privacyParameters.isPrivacyPluginEnabled()) {
            final PrivacyPluginPrecompiledContract privacyPluginPrecompiledContract = (PrivacyPluginPrecompiledContract) precompileContractRegistry.get(PLUGIN_PRIVACY);
            privacyPluginPrecompiledContract.setPrivateTransactionProcessor(privateTransactionProcessor);
        } else if (privacyParameters.isFlexiblePrivacyGroupsEnabled()) {
            final FlexiblePrivacyPrecompiledContract flexiblePrivacyPrecompiledContract = (FlexiblePrivacyPrecompiledContract) precompileContractRegistry.get(FLEXIBLE_PRIVACY);
            flexiblePrivacyPrecompiledContract.setPrivateTransactionProcessor(privateTransactionProcessor);
        } else {
            final PrivacyPrecompiledContract privacyPrecompiledContract = (PrivacyPrecompiledContract) precompileContractRegistry.get(DEFAULT_PRIVACY);
            privacyPrecompiledContract.setPrivateTransactionProcessor(privateTransactionProcessor);
        }
        blockProcessor = new PrivacyBlockProcessor(blockProcessor, protocolSchedule, privacyParameters.getEnclave(), privacyParameters.getPrivateStateStorage(), privacyParameters.getPrivateWorldStateArchive(), privacyParameters.getPrivateStateRootResolver(), privacyParameters.getPrivateStateGenesisAllocator());
    }
    final BlockValidator blockValidator = blockValidatorBuilder.apply(blockHeaderValidator, blockBodyValidator, blockProcessor, badBlockManager, privacyParameters.getGoQuorumPrivacyParameters());
    final BlockImporter blockImporter = blockImporterBuilder.apply(blockValidator);
    return new ProtocolSpec(name, evm, transactionValidator, transactionProcessor, privateTransactionProcessor, blockHeaderValidator, ommerHeaderValidator, blockBodyValidator, blockProcessor, blockImporter, blockValidator, blockHeaderFunctions, transactionReceiptFactory, difficultyCalculator, blockReward, miningBeneficiaryCalculator, precompileContractRegistry, skipZeroBlockRewards, gasCalculator, gasLimitCalculator, feeMarket, badBlockManager, Optional.ofNullable(powHasher));
}

Example 3 with EVM

use of org.hyperledger.besu.evm.EVM in project besu by hyperledger.

the class CreateOperationTest method messageFrameStackTooDeep.

@Test
public void messageFrameStackTooDeep() {
    final UInt256 memoryOffset = UInt256.fromHexString("0xFF");
    final UInt256 memoryLength = UInt256.valueOf(SIMPLE_CREATE.size());
    final ArrayDeque<MessageFrame> messageFrameStack = new ArrayDeque<>();
    final MessageFrame messageFrame = testMemoryFrame(memoryOffset, memoryLength, UInt256.ZERO, 1025, messageFrameStack);
    when(worldUpdater.getAccount(any())).thenReturn(account);
    when(account.getMutable()).thenReturn(mutableAccount);
    when(mutableAccount.getBalance()).thenReturn(Wei.ZERO);
    when(mutableAccount.getNonce()).thenReturn(55L);
    final EVM evm = MainnetEVMs.london(EvmConfiguration.DEFAULT);
    operation.execute(messageFrame, evm);
    assertThat(messageFrame.getStackItem(0)).isEqualTo(UInt256.ZERO);
}

Example 4 with EVM

use of org.hyperledger.besu.evm.EVM in project besu by hyperledger.

the class CreateOperationTest method nonceTooLarge.

@Test
public void nonceTooLarge() {
    final UInt256 memoryOffset = UInt256.fromHexString("0xFF");
    final UInt256 memoryLength = UInt256.valueOf(SIMPLE_CREATE.size());
    final ArrayDeque<MessageFrame> messageFrameStack = new ArrayDeque<>();
    final MessageFrame messageFrame = testMemoryFrame(memoryOffset, memoryLength, UInt256.ZERO, 1, messageFrameStack);
    when(worldUpdater.getAccount(any())).thenReturn(account);
    when(account.getMutable()).thenReturn(mutableAccount);
    when(mutableAccount.getBalance()).thenReturn(Wei.ZERO);
    when(mutableAccount.getNonce()).thenReturn(-1L);
    final EVM evm = MainnetEVMs.london(EvmConfiguration.DEFAULT);
    operation.execute(messageFrame, evm);
    assertThat(messageFrame.getStackItem(0)).isEqualTo(UInt256.ZERO);
}

Example 5 with EVM

use of org.hyperledger.besu.evm.EVM in project besu by hyperledger.

the class CreateOperationTest method notEnoughValue.

@Test
public void notEnoughValue() {
    final UInt256 memoryOffset = UInt256.fromHexString("0xFF");
    final UInt256 memoryLength = UInt256.valueOf(SIMPLE_CREATE.size());
    final ArrayDeque<MessageFrame> messageFrameStack = new ArrayDeque<>();
    final MessageFrame messageFrame = testMemoryFrame(memoryOffset, memoryLength, UInt256.valueOf(1), 1, messageFrameStack);
    for (int i = 0; i < 1025; i++) {
        messageFrameStack.add(messageFrame);
    }
    when(worldUpdater.getAccount(any())).thenReturn(account);
    when(account.getMutable()).thenReturn(mutableAccount);
    when(mutableAccount.getBalance()).thenReturn(Wei.ZERO);
    when(mutableAccount.getNonce()).thenReturn(55L);
    final EVM evm = MainnetEVMs.london(EvmConfiguration.DEFAULT);
    operation.execute(messageFrame, evm);
    assertThat(messageFrame.getStackItem(0)).isEqualTo(UInt256.ZERO);
}