Allow missing accounts to create zero-cost transactions

ethereum/core/src/main/java/tech/pegasys/pantheon/ethereum/core/Account.java

@@ -35,6 +35,9 @@
  */
 public interface Account {
 
+  long DEFAULT_NONCE = 0L;
+  Wei DEFAULT_BALANCE = Wei.ZERO;
+
   /**
    * The Keccak-256 hash of the account address.
    *

ethereum/core/src/main/java/tech/pegasys/pantheon/ethereum/core/WorldUpdater.java

@@ -51,7 +51,7 @@ public interface WorldUpdater extends MutableWorldView {
    *     and storage.
    */
   default MutableAccount createAccount(final Address address) {
-    return createAccount(address, 0L, Wei.ZERO);
+    return createAccount(address, Account.DEFAULT_NONCE, Account.DEFAULT_BALANCE);
   }
 
   /**

ethereum/core/src/main/java/tech/pegasys/pantheon/ethereum/mainnet/MainnetTransactionValidator.java

@@ -24,6 +24,7 @@
 import tech.pegasys.pantheon.ethereum.core.Account;
 import tech.pegasys.pantheon.ethereum.core.Gas;
 import tech.pegasys.pantheon.ethereum.core.Transaction;
+import tech.pegasys.pantheon.ethereum.core.Wei;
 import tech.pegasys.pantheon.ethereum.vm.GasCalculator;
 
 import java.util.OptionalInt;
@@ -86,32 +87,36 @@ public ValidationResult<TransactionInvalidReason> validate(final Transaction tra
   @Override
   public ValidationResult<TransactionInvalidReason> validateForSender(
       final Transaction transaction, final Account sender, final OptionalLong maximumNonce) {
-    if (sender == null) {
-      return ValidationResult.invalid(UPFRONT_COST_EXCEEDS_BALANCE, "Unknown sender account");
+
+    Wei balance = Account.DEFAULT_BALANCE;
+    long nonce = Account.DEFAULT_NONCE;
+
+    if (sender != null) {
+      balance = sender.getBalance();
+      nonce = sender.getNonce();
     }
-    if (transaction.getUpfrontCost().compareTo(sender.getBalance()) > 0) {
+
+    if (transaction.getUpfrontCost().compareTo(balance) > 0) {
       return ValidationResult.invalid(
           UPFRONT_COST_EXCEEDS_BALANCE,
           String.format(
               "transaction up-front cost %s exceeds transaction sender account balance %s",
-              transaction.getUpfrontCost(), sender.getBalance()));
+              transaction.getUpfrontCost(), balance));
     }
 
-    if (transaction.getNonce() < sender.getNonce()) {
+    if (transaction.getNonce() < nonce) {
       return ValidationResult.invalid(
           NONCE_TOO_LOW,
           String.format(
-              "transaction nonce %s below sender account nonce %s",
-              transaction.getNonce(), sender.getNonce()));
+              "transaction nonce %s below sender account nonce %s", transaction.getNonce(), nonce));
     }
 
-    if (violatesMaximumNonce(transaction, maximumNonce)
-        && sender.getNonce() != transaction.getNonce()) {
+    if (violatesMaximumNonce(transaction, maximumNonce) && nonce != transaction.getNonce()) {
       return ValidationResult.invalid(
           INCORRECT_NONCE,
           String.format(
               "transaction nonce %s does not match sender account nonce %s.",
-              transaction.getNonce(), sender.getNonce()));
+              transaction.getNonce(), nonce));
     }
 
     return ValidationResult.valid();

ethereum/core/src/test/java/tech/pegasys/pantheon/ethereum/mainnet/MainnetTransactionValidatorTest.java

@@ -24,6 +24,7 @@
 
 import tech.pegasys.pantheon.crypto.SECP256K1.KeyPair;
 import tech.pegasys.pantheon.ethereum.core.Account;
+import tech.pegasys.pantheon.ethereum.core.Address;
 import tech.pegasys.pantheon.ethereum.core.Gas;
 import tech.pegasys.pantheon.ethereum.core.Transaction;
 import tech.pegasys.pantheon.ethereum.core.TransactionTestFixture;
@@ -83,16 +84,6 @@ public void shouldRejectTransactionWhenSenderAccountDoesNotExist() {
         .isEqualTo(ValidationResult.invalid(UPFRONT_COST_EXCEEDS_BALANCE));
   }
 
-  @Test
-  public void shouldRejectTransactionWhenSenderAccountHasInsufficentBalance() {
-    final MainnetTransactionValidator validator =
-        new MainnetTransactionValidator(gasCalculator, false, 1);
-
-    final Account account = accountWithBalance(basicTransaction.getUpfrontCost().minus(Wei.of(1)));
-    assertThat(validator.validateForSender(basicTransaction, account, OptionalLong.empty()))
-        .isEqualTo(ValidationResult.invalid(UPFRONT_COST_EXCEEDS_BALANCE));
-  }
-
   @Test
   public void shouldRejectTransactionWhenTransactionNonceBelowAccountNonce() {
     final MainnetTransactionValidator validator =
@@ -152,6 +143,22 @@ public void shouldRejectTransactionWhenNonceExceedsMaximumAllowedNonce() {
         .isEqualTo(ValidationResult.invalid(INCORRECT_NONCE));
   }
 
+  @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());
+  }
+
   private Account accountWithNonce(final long nonce) {
     return account(basicTransaction.getUpfrontCost(), nonce);
   }