PR690 redo

build.gradle

@@ -12,8 +12,7 @@ def dirPack = "./pack"
 def dirLibFile = "lib"
 def dirModFile ="./mod"
 def javaHome = System.getProperty('java.home')
-
-def vmVersion = "0.3.1"
+def vmVersion = "0.3.2"
 def dirRuntimeJars = 'jars' // we'll store mod and lib stuff in here
 
 allprojects { 
@@ -60,7 +59,7 @@ task compileNative(type:Exec) {
         "-shared", 
         "-I${javaHome}/include", 
         "-I${javaHome}/include/linux", 
-        "-I${dirBuildNative}", 
+        "-I${dirBuildNative}",
         "-I${dirNative}/linux/sodium", 
         "-mtune=generic", 
         "-m64", 
@@ -196,7 +195,7 @@ task downloadFastVmGit(type:Download) {
     dest buildDir
 }
 
-task downloadSolidityGit(type:Download) { 
+task downloadSolidityGit(type:Download) {
     overwrite false // TODO This seems to work only when this task is directly invoked
     onlyIfModified true
     src "https://github.com/aionnetwork/aion_fastvm/releases/download/v${vmVersion}/solidity_v${vmVersion}.tar.gz"
@@ -283,18 +282,11 @@ task pack(type: Tar) {
         from "${dirPack}/rt"
         include '**'
     }
-    into('/aion/web3') {
+    into('/aion/console') {
         from "${dirPack}/web3"
         include '**'
     }
-    into('/aion/docs') {
-        from "${dirPack}/docs"
-        include '**'
-    }
-    into('/aion/clientAPI') {
-        from "${dirPack}/clientAPI"
-        include '**'
-    }
+
     into('/aion/script') {
         from "${dirPack}/script"
         include 'generateSslCert.sh', 'nohup_wrapper.sh'

deploy/serverList.csv

@@ -1,2 +1 @@
-52.237.31.69
-52.179.100.107
+13.89.244.125

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

@@ -28,22 +28,41 @@
 import org.aion.mcf.core.AccountState;
 import org.aion.mcf.db.IBlockStoreBase;
 import org.aion.precompiled.contracts.ATB.TokenBridgeContract;
+import org.aion.precompiled.contracts.Blake2bHashContract;
+import org.aion.precompiled.contracts.EDVerifyContract;
+import org.aion.precompiled.contracts.TXHashContract;
 import org.aion.vm.ExecutionContext;
 import org.aion.vm.IContractFactory;
 import org.aion.vm.IPrecompiledContract;
 
 /** A factory class that produces pre-compiled contract instances. */
 public class ContractFactory implements IContractFactory {
-    private static final String OWNER =
+
+    private static final String ADDR_OWNER =
             "0000000000000000000000000000000000000000000000000000000000000000";
-    private static final String TOTAL_CURRENCY =
+    private static final String ADDR_TOTAL_CURRENCY =
             "0000000000000000000000000000000000000000000000000000000000000100";
 
-    private static final String TOKEN_BRIDGE =
+    private static final String ADDR_TOKEN_BRIDGE =
             "0000000000000000000000000000000000000000000000000000000000000200";
-    private static final String TOKEN_BRIDGE_INITIAL_OWNER =
+    private static final String ADDR_TOKEN_BRIDGE_INITIAL_OWNER =
             "a008d7b29e8d1f4bfab428adce89dc219c4714b2c6bf3fd1131b688f9ad804aa";
 
+    private static final String ADDR_ED_VERIFY =
+            "0000000000000000000000000000000000000000000000000000000000000010";
+    private static final String ADDR_BLAKE2B_HASH =
+            "0000000000000000000000000000000000000000000000000000000000000011";
+    private static final String ADDR_TX_HASH =
+            "0000000000000000000000000000000000000000000000000000000000000012";
+
+    private static IPrecompiledContract PC_ED_VERIFY;
+    private static IPrecompiledContract PC_BLAKE2B_HASH;
+
+    static {
+        PC_ED_VERIFY = new EDVerifyContract();
+        PC_BLAKE2B_HASH = new Blake2bHashContract();
+    }
+
     public ContractFactory() {}
 
     /**
@@ -60,21 +79,27 @@ public IPrecompiledContract getPrecompiledContract(
             IRepositoryCache<AccountState, IDataWord, IBlockStoreBase<?, ?>> track) {
 
         switch (context.address().toString()) {
-            case TOTAL_CURRENCY:
-                // return new TotalCurrencyContract(track, context.sender(), Address.wrap(OWNER));
-                return null;
-            case TOKEN_BRIDGE:
+            case ADDR_TOKEN_BRIDGE:
                 TokenBridgeContract contract =
                         new TokenBridgeContract(
                                 context,
                                 track,
-                                Address.wrap(TOKEN_BRIDGE_INITIAL_OWNER),
-                                Address.wrap(TOKEN_BRIDGE));
+                                Address.wrap(ADDR_TOKEN_BRIDGE_INITIAL_OWNER),
+                                Address.wrap(ADDR_TOKEN_BRIDGE));
 
-                if (!context.origin().equals(Address.wrap(TOKEN_BRIDGE_INITIAL_OWNER))
-                        && !contract.isInitialized()) return null;
+                if (!context.origin().equals(Address.wrap(ADDR_TOKEN_BRIDGE_INITIAL_OWNER))
+                        && !contract.isInitialized()) {
+                    return null;
+                }
 
                 return contract;
+            case ADDR_ED_VERIFY:
+                return PC_ED_VERIFY;
+            case ADDR_BLAKE2B_HASH:
+                return PC_BLAKE2B_HASH;
+            case ADDR_TX_HASH:
+                return new TXHashContract(context);
+            case ADDR_TOTAL_CURRENCY:
             default:
                 return null;
         }
@@ -88,10 +113,12 @@ public IPrecompiledContract getPrecompiledContract(
      */
     public static boolean isPrecompiledContract(Address address) {
         switch (address.toString()) {
-            case TOTAL_CURRENCY:
-                return true;
-            case TOKEN_BRIDGE:
+            case ADDR_TOKEN_BRIDGE:
+            case ADDR_ED_VERIFY:
+            case ADDR_BLAKE2B_HASH:
+            case ADDR_TX_HASH:
                 return true;
+            case ADDR_TOTAL_CURRENCY:
             default:
                 return false;
         }
@@ -103,6 +130,33 @@ public static boolean isPrecompiledContract(Address address) {
      * @return the contract address.
      */
     public static Address getTotalCurrencyContractAddress() {
-        return Address.wrap(TOTAL_CURRENCY);
+        return Address.wrap(ADDR_TOTAL_CURRENCY);
+    }
+
+    /**
+     * Returns the address of the EdVerifyContract contract.
+     *
+     * @return the contract address
+     */
+    public static Address getEdVerifyContractAddress() {
+        return Address.wrap(ADDR_ED_VERIFY);
+    }
+
+    /**
+     * Returns the address of the TxHash contract.
+     *
+     * @return the contract address
+     */
+    public static Address getTxHashContractAddress() {
+        return Address.wrap(ADDR_TX_HASH);
+    }
+
+    /**
+     * Returns the address of the blake2b hash contract.
+     *
+     * @return the contract address
+     */
+    public static Address getBlake2bHashContractAddress() {
+        return Address.wrap(ADDR_BLAKE2B_HASH);
     }
 }

modPrecompiled/src/org/aion/precompiled/contracts/Blake2bHashContract.java

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2017-2018 Aion foundation.
+ *
+ *     This file is part of the aion network project.
+ *
+ *     The aion network project is free software: you can redistribute it
+ *     and/or modify it under the terms of the GNU General Public License
+ *     as published by the Free Software Foundation, either version 3 of
+ *     the License, or any later version.
+ *
+ *     The aion network project is distributed in the hope that it will
+ *     be useful, but WITHOUT ANY WARRANTY; without even the implied
+ *     warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *     See the GNU General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with the aion network project source files.
+ *     If not, see <https://www.gnu.org/licenses/>.
+ *
+ * Contributors:
+ *     Aion foundation.
+ */
+package org.aion.precompiled.contracts;
+
+import static org.aion.crypto.HashUtil.blake256;
+
+import com.google.common.annotations.VisibleForTesting;
+import org.aion.vm.AbstractExecutionResult.ResultCode;
+import org.aion.vm.ExecutionResult;
+import org.aion.vm.IPrecompiledContract;
+
+/**
+ * @author Jay Tseng
+ * @author William Zhai
+ * @implNote Base on benchmark the keccak256hash and blake2bhash precompiled contract blake2b is
+ *     5 times faster then keccak256. Therefore, blake2b modify the energy charge to 1/3 of the
+ *     Ethereum keccak256 precompiled contract charge.
+ */
+public class Blake2bHashContract implements IPrecompiledContract {
+
+    private static final long COST = 10L;
+    private static final int WORD_LENGTH = 4;
+    private static final int NRG_CHARGE_PER_WORD = 2;
+    private static final String INPUT_LENGTH_ERROR_MESSAGE = "incorrect size of the input data.";
+
+    public Blake2bHashContract() {}
+
+    /**
+     * Returns the hash of given input
+     *
+     * @param input data input; must be less or equal than 2 MB
+     * @return the returned blake2b 256bits hash is in ExecutionResult.getOutput
+     */
+    public ExecutionResult execute(byte[] input, long nrg) {
+
+        // check length
+        if (input == null || input.length == 0 || input.length > 2_097_152L) {
+            return new ExecutionResult(
+                    ResultCode.FAILURE, nrg - COST, INPUT_LENGTH_ERROR_MESSAGE.getBytes());
+        }
+
+        long additionalNRG =
+                ((long) Math.ceil(((double) input.length - 1) / WORD_LENGTH)) * NRG_CHARGE_PER_WORD;
+
+        // check input nrg
+        long nrgLeft = nrg - (COST + additionalNRG);
+
+        if (nrgLeft < 0) {
+            return new ExecutionResult(ResultCode.OUT_OF_NRG, 0);
+        }
+
+        return blake256Hash(input, nrgLeft);
+    }
+
+    private ExecutionResult blake256Hash(byte[] input, long nrg) {
+        byte[] hash = blake256(input);
+        return new ExecutionResult(ResultCode.SUCCESS, nrg, hash);
+    }
+
+    @VisibleForTesting
+    static byte[] setupInput(int operation, byte[] inputByteArray) {
+        byte[] ret = new byte[1 + inputByteArray.length];
+        ret[0] = (byte) operation;
+        System.arraycopy(inputByteArray, 0, ret, 1, inputByteArray.length);
+        return ret;
+    }
+}