private Transaction createTransaction() { return txTestFixture.createTransaction(keyPair); }
private List<TransactionWithMetadata> transactionsWithMetadata() { final TransactionWithMetadata t1 = new TransactionWithMetadata( txTestFixture.createTransaction(KeyPair.generate()), 0L, Hash.ZERO, 0); final TransactionWithMetadata t2 = new TransactionWithMetadata( txTestFixture.createTransaction(KeyPair.generate()), 1L, Hash.ZERO, 1); return Lists.newArrayList(t1, t2); }
private Transaction transaction(final int nonce) { return new TransactionTestFixture().nonce(nonce).createTransaction(KEYS); } }
private Transaction transactionWithNonceAndSender(final int nonce, final KeyPair keyPair) { return new TransactionTestFixture().nonce(nonce).createTransaction(keyPair); }
public BlockWithMetadata<TransactionWithMetadata, Hash> blockWithMetadata( final BlockHeader header) { final KeyPair keyPair = KeyPair.generate(); final List<TransactionWithMetadata> transactions = new ArrayList<>(); for (int i = 0; i < 3; i++) { final Transaction transaction = transactionTestFixture.createTransaction(keyPair); transactions.add( new TransactionWithMetadata(transaction, header.getNumber(), header.getHash(), 0)); } final List<Hash> ommers = new ArrayList<>(); ommers.add(Hash.ZERO); return new BlockWithMetadata<>(header, transactions, ommers, header.getDifficulty(), 0); } }
private Transaction createTransaction(final int transactionNumber) { return new TransactionTestFixture() .nonce(transactionNumber) .gasLimit(0) .createTransaction(KEY_PAIR1); }
public BlockWithMetadata<TransactionWithMetadata, Hash> blockWithMetadata( final BlockHeader header) { final KeyPair keyPair = KeyPair.generate(); final List<TransactionWithMetadata> transactions = new ArrayList<>(); for (int i = 0; i < 3; i++) { final Transaction transaction = transactionTestFixture.createTransaction(keyPair); transactions.add( new TransactionWithMetadata(transaction, header.getNumber(), header.getHash(), 0)); } final List<Hash> ommers = new ArrayList<>(); ommers.add(Hash.ZERO); return new BlockWithMetadata<>(header, transactions, ommers, header.getDifficulty(), 0); } }
@Test public void shouldRejectLocalTransactionsWhereGasLimitExceedBlockGasLimit() { final TransactionTestFixture builder = new TransactionTestFixture(); final Transaction transaction1 = builder.gasLimit(genesisBlockGasLimit + 1).createTransaction(KEY_PAIR1); givenTransactionIsValid(transaction1); assertThat(transactionPool.addLocalTransaction(transaction1)) .isEqualTo(ValidationResult.invalid(EXCEEDS_BLOCK_GAS_LIMIT)); assertTransactionNotPending(transaction1); verifyZeroInteractions(batchAddedListener); }
@Test public void shouldRejectTransactionIfIntrinsicGasExceedsGasLimit() { final MainnetTransactionValidator validator = new MainnetTransactionValidator(gasCalculator, false); final Transaction transaction = new TransactionTestFixture().gasLimit(10).chainId(0).createTransaction(senderKeys); when(gasCalculator.transactionIntrinsicGasCost(transaction)).thenReturn(Gas.of(50)); assertThat(validator.validate(transaction)) .isEqualTo(ValidationResult.invalid(INTRINSIC_GAS_EXCEEDS_GAS_LIMIT)); }
@Test public void shouldAcceptTransactionWhenNonceEqualsMaximumAllowedNonce() { final MainnetTransactionValidator validator = new MainnetTransactionValidator(gasCalculator, false, 1); final Transaction transaction = new TransactionTestFixture().nonce(10).createTransaction(senderKeys); final Account account = accountWithNonce(5); assertThat(validator.validateForSender(transaction, account, OptionalLong.of(10))) .isEqualTo(ValidationResult.valid()); }
@Test public void shouldRejectTransactionWhenNonceExceedsMaximumAllowedNonce() { final MainnetTransactionValidator validator = new MainnetTransactionValidator(gasCalculator, false, 1); final Transaction transaction = new TransactionTestFixture().nonce(11).createTransaction(senderKeys); final Account account = accountWithNonce(5); assertThat(validator.validateForSender(transaction, account, OptionalLong.of(10))) .isEqualTo(ValidationResult.invalid(INCORRECT_NONCE)); }
@Test public void shouldAcceptTransactionWhenNonceBetweenAccountNonceAndMaximumAllowedNonce() { final MainnetTransactionValidator validator = new MainnetTransactionValidator(gasCalculator, false, 1); final Transaction transaction = new TransactionTestFixture().nonce(10).createTransaction(senderKeys); final Account account = accountWithNonce(5); assertThat(validator.validateForSender(transaction, account, OptionalLong.of(15))) .isEqualTo(ValidationResult.valid()); }
@Test public void shouldRejectRemoteTransactionsWhereGasLimitExceedBlockGasLimit() { final TransactionTestFixture builder = new TransactionTestFixture(); final Transaction transaction1 = builder.gasLimit(genesisBlockGasLimit + 1).createTransaction(KEY_PAIR1); givenTransactionIsValid(transaction1); transactionPool.addRemoteTransactions(singleton(transaction1)); assertTransactionNotPending(transaction1); verifyZeroInteractions(batchAddedListener); }
@Test public void shouldNotNotifyBatchListenerWhenRemoteTransactionDoesNotReplaceExisting() { final TransactionTestFixture builder = new TransactionTestFixture(); final Transaction transaction1 = builder.nonce(1).gasPrice(Wei.of(10)).createTransaction(KEY_PAIR1); final Transaction transaction2 = builder.nonce(1).gasPrice(Wei.of(5)).createTransaction(KEY_PAIR1); when(transactionValidator.validate(any(Transaction.class))).thenReturn(valid()); when(transactionValidator.validateForSender( eq(transaction1), nullable(Account.class), eq(OptionalLong.empty()))) .thenReturn(valid()); when(transactionValidator.validateForSender( eq(transaction2), nullable(Account.class), eq(OptionalLong.of(2)))) .thenReturn(valid()); transactionPool.addRemoteTransactions(singletonList(transaction1)); transactionPool.addRemoteTransactions(singletonList(transaction2)); assertTransactionPending(transaction1); verify(batchAddedListener).onTransactionsAdded(singleton(transaction1)); verify(batchAddedListener, never()).onTransactionsAdded(singleton(transaction2)); }
@Test public void shouldAllowSequenceOfTransactionsWithIncreasingNonceFromSameSenderWhenSentInBatchOutOfOrder() { final TransactionTestFixture builder = new TransactionTestFixture(); final Transaction transaction1 = builder.nonce(1).createTransaction(KEY_PAIR1); final Transaction transaction2 = builder.nonce(2).createTransaction(KEY_PAIR1); final Transaction transaction3 = builder.nonce(3).createTransaction(KEY_PAIR1); when(transactionValidator.validate(any(Transaction.class))).thenReturn(valid()); when(transactionValidator.validateForSender( eq(transaction1), nullable(Account.class), eq(OptionalLong.empty()))) .thenReturn(valid()); when(transactionValidator.validateForSender( eq(transaction2), nullable(Account.class), eq(OptionalLong.of(2)))) .thenReturn(valid()); when(transactionValidator.validateForSender( eq(transaction3), nullable(Account.class), eq(OptionalLong.of(3)))) .thenReturn(valid()); transactionPool.addRemoteTransactions(asList(transaction3, transaction1, transaction2)); assertTransactionPending(transaction1); assertTransactionPending(transaction2); assertTransactionPending(transaction3); }
@Test public void shouldAllowSequenceOfTransactionsWithIncreasingNonceFromSameSender() { final TransactionTestFixture builder = new TransactionTestFixture(); final Transaction transaction1 = builder.nonce(1).createTransaction(KEY_PAIR1); final Transaction transaction2 = builder.nonce(2).createTransaction(KEY_PAIR1); final Transaction transaction3 = builder.nonce(3).createTransaction(KEY_PAIR1); when(transactionValidator.validate(any(Transaction.class))).thenReturn(valid()); when(transactionValidator.validateForSender( eq(transaction1), nullable(Account.class), eq(OptionalLong.empty()))) .thenReturn(valid()); when(transactionValidator.validateForSender( eq(transaction2), nullable(Account.class), eq(OptionalLong.of(2)))) .thenReturn(valid()); when(transactionValidator.validateForSender( eq(transaction3), nullable(Account.class), eq(OptionalLong.of(3)))) .thenReturn(valid()); assertThat(transactionPool.addLocalTransaction(transaction1)).isEqualTo(valid()); assertThat(transactionPool.addLocalTransaction(transaction2)).isEqualTo(valid()); assertThat(transactionPool.addLocalTransaction(transaction3)).isEqualTo(valid()); assertTransactionPending(transaction1); assertTransactionPending(transaction2); assertTransactionPending(transaction3); }
private Transaction createTransaction(final int transactionNumber) { return new TransactionTestFixture() .value(Wei.of(transactionNumber)) .nonce(transactionNumber) .createTransaction(KEYS1); } }
@Test public void shouldNotNotifyBatchListenerWhenLocalTransactionDoesNotReplaceExisting() { final TransactionTestFixture builder = new TransactionTestFixture(); final Transaction transaction1 = builder.nonce(1).gasPrice(Wei.of(10)).createTransaction(KEY_PAIR1); final Transaction transaction2 = builder.nonce(1).gasPrice(Wei.of(5)).createTransaction(KEY_PAIR1); when(transactionValidator.validate(any(Transaction.class))).thenReturn(valid()); when(transactionValidator.validateForSender( eq(transaction1), nullable(Account.class), eq(OptionalLong.empty()))) .thenReturn(valid()); when(transactionValidator.validateForSender( eq(transaction2), nullable(Account.class), eq(OptionalLong.of(2)))) .thenReturn(valid()); transactionPool.addLocalTransaction(transaction1); transactionPool.addLocalTransaction(transaction2); assertTransactionPending(transaction1); verify(batchAddedListener).onTransactionsAdded(singletonList(transaction1)); verify(batchAddedListener, never()).onTransactionsAdded(singletonList(transaction2)); }
private Transaction transactionWithNonceSenderAndGasPrice( final int nonce, final KeyPair keyPair, final long gasPrice) { return new TransactionTestFixture() .nonce(nonce) .gasPrice(Wei.of(gasPrice)) .createTransaction(keyPair); }
@Test public void transactionWithNullSenderCanBeValidIfGasPriceAndValueIsZero() { final MainnetTransactionValidator validator = new MainnetTransactionValidator(gasCalculator, false, 1); final TransactionTestFixture builder = new TransactionTestFixture(); final KeyPair senderKeyPair = KeyPair.generate(); final Address arbitrarySender = Address.fromHexString("1"); builder.gasPrice(Wei.ZERO).nonce(0).sender(arbitrarySender).value(Wei.ZERO); assertThat( validator.validateForSender( builder.createTransaction(senderKeyPair), null, OptionalLong.of(10))) .isEqualTo(ValidationResult.valid()); }