Change Virtual Machines to receive TransactionInterfaces, not TransactionContexts

modAion/src/org/aion/zero/types/AionTransaction.java

@@ -31,6 +31,9 @@ public class AionTransaction extends AbstractTransaction {
             RLP_TX_TYPE = 7,
             RLP_TX_SIG = 8;
 
+    public static byte CALL_KIND = 0;
+    public static byte CREATE_KIND = 3;
+
     /* Tx in encoded form */
     protected byte[] rlpEncoded;
 
@@ -514,6 +517,11 @@ public long getTransactionCost() {
         return transactionCost(0);
     }
 
+    @Override
+    public byte getKind() {
+        return this.isContractCreationTransaction() ? CREATE_KIND : CALL_KIND;
+    }
+
     public long transactionCost(long blockNumber) {
         long nonZeroes = nonZeroBytesInData();
         long zeroes = zeroBytesInData();

modAionImpl/test/org/aion/zero/impl/PendingStateTest.java

@@ -67,7 +67,7 @@ public void testAddPendingTransactionSuccess() {
                 new AionTransaction(
                         BigInteger.ZERO.toByteArray(),
                         to,
-                        new byte[0],
+                        BigInteger.ZERO.toByteArray(),
                         new byte[0],
                         1_000_000L,
                         10_000_000_000L);
@@ -100,7 +100,7 @@ public void testAddPendingTransactionInvalidNrgPrice() {
                 new AionTransaction(
                         BigInteger.ZERO.toByteArray(),
                         to,
-                        new byte[0],
+                        BigInteger.ZERO.toByteArray(),
                         new byte[0],
                         1_000_000L,
                         1L);

modMcf/src/org/aion/mcf/vm/types/KernelInterfaceForFastVM.java

@@ -5,6 +5,7 @@
 import com.google.common.annotations.VisibleForTesting;
 import java.math.BigInteger;
 import org.aion.interfaces.db.RepositoryCache;
+import org.aion.interfaces.vm.DataWord;
 import org.aion.mcf.core.AccountState;
 import org.aion.mcf.db.IBlockStoreBase;
 import org.aion.mcf.tx.TransactionTypes;
@@ -23,16 +24,40 @@ public class KernelInterfaceForFastVM implements KernelInterface {
     public KernelInterfaceForFastVM(
             RepositoryCache<AccountState, IBlockStoreBase<?, ?>> repositoryCache,
             boolean allowNonceIncrement,
-            boolean isLocalCall) {
-
-        this(repositoryCache, allowNonceIncrement, isLocalCall, false);
-    }
+            boolean isLocalCall,
+            DataWord blockDifficulty,
+            long blockNumber,
+            long blockTimestamp,
+            long blockNrgLimit,
+            Address blockCoinbase) {
+        this(
+                repositoryCache,
+                allowNonceIncrement,
+                isLocalCall,
+                false,
+                blockDifficulty,
+                blockNumber,
+                blockTimestamp,
+                blockNrgLimit,
+                blockCoinbase);
+    }
+
+    private DataWord blockDifficulty;
+    private long blockNumber;
+    private long blockTimestamp;
+    private long blockNrgLimit;
+    private Address blockCoinbase;
 
     public KernelInterfaceForFastVM(
             RepositoryCache<AccountState, IBlockStoreBase<?, ?>> repositoryCache,
             boolean allowNonceIncrement,
             boolean isLocalCall,
-            boolean fork040Enable) {
+            boolean fork040Enable,
+            DataWord blockDifficulty,
+            long blockNumber,
+            long blockTimestamp,
+            long blockNrgLimit,
+            Address blockCoinbase) {
 
         if (repositoryCache == null) {
             throw new NullPointerException("Cannot set null repositoryCache!");
@@ -41,6 +66,11 @@ public KernelInterfaceForFastVM(
         this.allowNonceIncrement = allowNonceIncrement;
         this.isLocalCall = isLocalCall;
         this.fork040Enable = fork040Enable;
+        this.blockDifficulty = blockDifficulty;
+        this.blockNumber = blockNumber;
+        this.blockTimestamp = blockTimestamp;
+        this.blockNrgLimit = blockNrgLimit;
+        this.blockCoinbase = blockCoinbase;
     }
 
     @Override
@@ -49,7 +79,12 @@ public KernelInterfaceForFastVM makeChildKernelInterface() {
                 this.repositoryCache.startTracking(),
                 this.allowNonceIncrement,
                 this.isLocalCall,
-                this.fork040Enable);
+                this.fork040Enable,
+                this.blockDifficulty,
+                this.blockNumber,
+                this.blockTimestamp,
+                this.blockNrgLimit,
+                this.blockCoinbase);
     }
 
     @Override
@@ -302,4 +337,33 @@ private ByteArrayWrapper alignDataToWordSize(byte[] data) {
     public boolean isFork040Enable() {
         return this.fork040Enable;
     }
+
+    @Override
+    public long getBlockNumber() {
+        return blockNumber;
+    }
+
+    @Override
+    public long getBlockTimestamp() {
+        return blockTimestamp;
+    }
+
+    @Override
+    public long getBlockEnergyLimit() {
+        return blockNrgLimit;
+    }
+
+    @Override
+    public long getBlockDifficulty() {
+        if (blockDifficulty instanceof DataWordImpl) {
+            return ((DataWordImpl) blockDifficulty).longValue();
+        } else {
+            return ((DoubleDataWord) blockDifficulty).longValue();
+        }
+    }
+
+    @Override
+    public Address getMinerAddress() {
+        return blockCoinbase;
+    }
 }

modPrecompiled/src/org/aion/precompiled/PrecompiledTransactionResult.java

@@ -2,10 +2,19 @@
 
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import org.aion.types.Address;
+import org.aion.vm.api.interfaces.IExecutionLog;
+import org.aion.vm.api.interfaces.InternalTransactionInterface;
 import org.aion.vm.api.interfaces.KernelInterface;
 import org.aion.vm.api.interfaces.ResultCode;
 import org.aion.vm.api.interfaces.TransactionResult;
 import org.aion.util.bytes.ByteUtil;
+import org.aion.vm.api.interfaces.TransactionSideEffects;
 
 public class PrecompiledTransactionResult implements TransactionResult {
     private KernelInterface kernel;
@@ -152,6 +161,87 @@ public KernelInterface getKernelInterface() {
         return this.kernel;
     }
 
+    @Override
+    public TransactionSideEffects getSideEffects() {
+        return new TransactionSideEffects() {
+
+            private Set<Address> deleteAccounts = new HashSet<>();
+            private List<InternalTransactionInterface> internalTxs = new ArrayList<>();
+            private List<IExecutionLog> logs = new ArrayList<>();
+
+            @Override
+            public void merge(TransactionSideEffects other) {
+                addInternalTransactions(other.getInternalTransactions());
+                addAllToDeletedAddresses(other.getAddressesToBeDeleted());
+                addLogs(other.getExecutionLogs());
+            }
+
+            @Override
+            public void markAllInternalTransactionsAsRejected() {
+                for (InternalTransactionInterface tx : getInternalTransactions()) {
+                    tx.markAsRejected();
+                }
+            }
+
+            @Override
+            public void addInternalTransaction(InternalTransactionInterface tx) {
+                internalTxs.add(tx);
+            }
+
+            @Override
+            public void addInternalTransactions(List<InternalTransactionInterface> txs) {
+                for (InternalTransactionInterface tx : txs) {
+                    if (tx != null) {
+                        this.internalTxs.add(tx);
+                    }
+                }
+            }
+
+            @Override
+            public void addToDeletedAddresses(Address address) {
+                deleteAccounts.add(address);
+            }
+
+            @Override
+            public void addAllToDeletedAddresses(Collection<Address> addresses) {
+                for (Address addr : addresses) {
+                    if (addr != null) {
+                        deleteAccounts.add(addr);
+                    }
+                }
+            }
+
+            @Override
+            public void addLog(IExecutionLog log) {
+                logs.add(log);
+            }
+
+            @Override
+            public void addLogs(Collection<IExecutionLog> logs) {
+                for (IExecutionLog log : logs) {
+                    if (log != null) {
+                        this.logs.add(log);
+                    }
+                }
+            }
+
+            @Override
+            public List<InternalTransactionInterface> getInternalTransactions() {
+                return internalTxs;
+            }
+
+            @Override
+            public List<Address> getAddressesToBeDeleted() {
+                return new ArrayList<>(deleteAccounts);
+            }
+
+            @Override
+            public List<IExecutionLog> getExecutionLogs() {
+                return logs;
+            }
+        };
+    }
+
     @Override
     public String toString() {
         return "TransactionResult { code = " + this.code