final Hash blockHash, final Long blockNumber) { assertThat(Hash.fromHexString(result.getString("hash"))).isEqualTo(transaction.hash()); assertThat(Long.decode(result.getString("nonce"))).isEqualByComparingTo(transaction.getNonce()); if (blockHash != null) { assertThat(Hash.fromHexString(result.getString("blockHash"))).isEqualTo(blockHash); assertThat(result.getValue("transactionIndex")).isNull(); assertThat(Address.fromHexString(result.getString("from"))).isEqualTo(transaction.getSender()); if (transaction.getTo().isPresent()) { assertThat(Address.fromHexString(result.getString("to"))) .isEqualTo(transaction.getTo().get()); } else { assertThat(result.getValue("to")).isNull(); assertThat(Wei.fromHexString(result.getString("value"))).isEqualTo(transaction.getValue()); assertThat(Wei.fromHexString(result.getString("gasPrice"))) .isEqualTo(transaction.getGasPrice()); assertThat(Long.decode(result.getString("gas"))).isEqualTo(transaction.getGasLimit()); assertThat(BytesValue.fromHexString(result.getString("input"))) .isEqualTo(transaction.getPayload());
@Test public void shouldDecodeInterestingRlpFromARealTransactionGeneratedUsingRemixAndASimpleContract() { final String encodedString = "0xf902560c843b9aca00832dc6c08080b90202608060405234801561001057600080fd5b506040516020806101e283398101604052516000556101ae806100346000396000f30060806040526004361061006c5763ffffffff7c01000000000000000000000000000000000000000000000000000000006000350416632113522a81146100715780632a1afcd9146100af5780633bc5de30146100d657806360fe47b1146100eb578063db613e8114610105575b600080fd5b34801561007d57600080fd5b5061008661011a565b6040805173ffffffffffffffffffffffffffffffffffffffff9092168252519081900360200190f35b3480156100bb57600080fd5b506100c4610136565b60408051918252519081900360200190f35b3480156100e257600080fd5b506100c461013c565b3480156100f757600080fd5b50610103600435610142565b005b34801561011157600080fd5b50610086610166565b60015473ffffffffffffffffffffffffffffffffffffffff1681565b60005481565b60005490565b6000556001805473ffffffffffffffffffffffffffffffffffffffff191633179055565b60015473ffffffffffffffffffffffffffffffffffffffff16905600a165627a7a723058208293fac83e9cc01039adf5e41eefd557d1324a3a4c830a4802fa1dd2515227a20029000000000000000000000000000000000000000000000000000000000000007b820fe8a009e7b69af4c318e7fb915f53649bd9f99e5423d41c2cd6a01ab69bb34a951b2fa01b5d39b7c9041ec022d13e6e89eec2cddbe27572eda7956ada5de1032cd5da15"; final BytesValue encoded = BytesValue.fromHexString(encodedString); final RLPInput input = RLP.input(encoded); final Transaction transaction = Transaction.readFrom(input); assertNotNull(transaction); assertTrue(transaction.isContractCreation()); assertEquals(2018, transaction.getChainId().getAsInt()); assertEquals( Address.fromHexString("0xfe3b557e8fb62b89f4916b721be55ceb828dbd73"), transaction.getSender()); }
private Transaction transaction(final Hash hash) { final Transaction tx = mock(Transaction.class); when(tx.hash()).thenReturn(hash); return tx; }
public Transaction get(final GeneralStateTestCaseSpec.Indexes indexes) { return Transaction.builder() .nonce(nonce) .gasPrice(gasPrice) .gasLimit(gasLimits.get(indexes.gas).asUInt256().toLong()) .to(to) .value(values.get(indexes.value)) .payload(payloads.get(indexes.data)) .signAndBuild(keys); } }
public void milestone(final String milestone) { final TransactionTestCaseSpec.Expectation expected = spec.expectation(milestone); try { final BytesValue rlp = spec.getRlp(); // Test transaction deserialization (will throw an exception if it fails). final Transaction transaction = Transaction.readFrom(RLP.input(rlp)); if (!transactionValidator(milestone).validate(transaction).isValid()) { throw new RuntimeException(String.format("Transaction is invalid %s", transaction)); } // Test rlp encoding final BytesValue actualRlp = RLP.encode(transaction::writeTo); Assert.assertTrue(expected.isSucceeds()); Assert.assertEquals(rlp, actualRlp); Assert.assertEquals(expected.getSender(), transaction.getSender()); Assert.assertEquals(expected.getHash(), transaction.hash()); } catch (final Exception e) { Assert.assertFalse(expected.isSucceeds()); } } }
@Test public void shouldCalculateCorrectGasEstimateWhenGasLimitWasSufficient() { when(transaction.getGasLimit()).thenReturn(10L); when(result.getGasRemaining()).thenReturn(3L); assertThat(transientTransactionProcessingResult.getGasEstimate()).isEqualTo(7L); } }
private Account accountWithBalance(final Wei balance) { return account(balance, basicTransaction.getNonce()); }
@Test public void shouldRejectNonWhitelistedTransactionWhenWhitelistEnabled() { transactionPool.setAccountWhitelist(accountWhitelistController); givenTransactionIsValid(transaction1); when(accountWhitelistController.isAccountWhiteListSet()).thenReturn(true); when(accountWhitelistController.contains(transaction1.getSender().toString())) .thenReturn(false); assertThat(transactionPool.addLocalTransaction(transaction1)) .isEqualTo(ValidationResult.invalid(TX_SENDER_NOT_AUTHORIZED)); assertTransactionNotPending(transaction1); verifyZeroInteractions(batchAddedListener); }
@Before public void setUp() { when(transaction.hash()).thenReturn(transactionHash); }
private Transaction createTransaction(final int transactionNumber) { return Transaction.builder() .gasLimit(100) .gasPrice(Wei.of(5)) .nonce(transactionNumber) .payload(BytesValue.EMPTY) .to(Address.ID) .value(Wei.of(transactionNumber)) .sender(Address.ID) .chainId(1) .signAndBuild(keyPair); }
@Test public void shouldCalculateCorrectGasEstimateWhenConsumedAllGas() { when(transaction.getGasLimit()).thenReturn(5L); when(result.getGasRemaining()).thenReturn(0L); assertThat(transientTransactionProcessingResult.getGasEstimate()).isEqualTo(5L); }
@Test public void shouldRejectTransactionWhenTransactionNonceBelowAccountNonce() { final MainnetTransactionValidator validator = new MainnetTransactionValidator(gasCalculator, false, 1); final Account account = accountWithNonce(basicTransaction.getNonce() + 1); assertThat(validator.validateForSender(basicTransaction, account, OptionalLong.empty())) .isEqualTo(ValidationResult.invalid(NONCE_TOO_LOW)); }
@Test public void shouldAllowWhitelistedTransactionWhenWhitelistEnabled() { transactionPool.setAccountWhitelist(accountWhitelistController); givenTransactionIsValid(transaction1); when(accountWhitelistController.isAccountWhiteListSet()).thenReturn(true); when(accountWhitelistController.contains(transaction1.getSender().toString())).thenReturn(true); assertThat(transactionPool.addLocalTransaction(transaction1)).isEqualTo(valid()); assertTransactionPending(transaction1); }
private List<Hash> transactionsWithHashOnly() { final List<Hash> hashes = new ArrayList<>(); for (final TransactionWithMetadata transactionWithMetadata : transactionsWithMetadata()) { hashes.add(transactionWithMetadata.getTransaction().hash()); } return hashes; }
@Test public void shouldReturnFailureResultWhenProcessingFails() { final CallParameter callParameter = callParameter(); mockBlockchainForBlockHeader(Hash.ZERO, 1L); mockWorldStateForAccount(Hash.ZERO, Address.fromHexString("0x0"), 1L); final Transaction expectedTransaction = Transaction.builder() .nonce(1L) .gasPrice(callParameter.getGasPrice()) .gasLimit(callParameter.getGasLimit()) .to(callParameter.getTo()) .sender(callParameter.getFrom()) .value(callParameter.getValue()) .payload(callParameter.getPayload()) .signature(FAKE_SIGNATURE) .build(); mockProcessorStatusForTransaction(1L, expectedTransaction, Status.FAILED, null); final Optional<TransientTransactionProcessingResult> result = transientTransactionProcessor.process(callParameter, 1L); assertThat(result.get().isSuccessful()).isFalse(); verifyTransactionWasProcessed(expectedTransaction); }
@Test public void shouldCalculateCorrectGasEstimateWhenGasWasInsufficient() { when(transaction.getGasLimit()).thenReturn(1L); when(result.getGasRemaining()).thenReturn(-5L); assertThat(transientTransactionProcessingResult.getGasEstimate()).isEqualTo(6L); }
@Test public void shouldRejectTransactionWhenTransactionNonceAboveAccountNonce() { final MainnetTransactionValidator validator = new MainnetTransactionValidator(gasCalculator, false, 1); final Account account = accountWithNonce(basicTransaction.getNonce() - 1); assertThat(validator.validateForSender(basicTransaction, account, OptionalLong.empty())) .isEqualTo(ValidationResult.invalid(INCORRECT_NONCE)); }
private void assertTransactionPending(final Transaction t) { assertThat(transactions.getTransactionByHash(t.hash())).contains(t); }
@Test public void shouldReturnSuccessfulResultWhenProcessingIsSuccessful() { final CallParameter callParameter = callParameter(); mockBlockchainForBlockHeader(Hash.ZERO, 1L); mockWorldStateForAccount(Hash.ZERO, callParameter.getFrom(), 1L); final Transaction expectedTransaction = Transaction.builder() .nonce(1L) .gasPrice(callParameter.getGasPrice()) .gasLimit(callParameter.getGasLimit()) .to(callParameter.getTo()) .sender(callParameter.getFrom()) .value(callParameter.getValue()) .payload(callParameter.getPayload()) .signature(FAKE_SIGNATURE) .build(); mockProcessorStatusForTransaction( 1L, expectedTransaction, Status.SUCCESSFUL, callParameter.getPayload()); final Optional<TransientTransactionProcessingResult> result = transientTransactionProcessor.process(callParameter, 1L); assertThat(result.get().isSuccessful()).isTrue(); verifyTransactionWasProcessed(expectedTransaction); }