diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3d84c692ca29e88f3013a3f4672329fadecb45fc..bde254b02ecb838a74763d79f572f815b5a562c8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -69,8 +69,8 @@ ENDIF(WIN32)
 FIND_PACKAGE(Boost 1.64 REQUIRED COMPONENTS
     thread
     date_time
-    system
     filesystem
+    system
     program_options
     signals
     serialization
diff --git a/Jenkinsfile b/Jenkinsfile
new file mode 100644
index 0000000000000000000000000000000000000000..a0d3d99423593f2c5a3887bc39a3f1fb35be8872
--- /dev/null
+++ b/Jenkinsfile
@@ -0,0 +1,38 @@
+pipeline {
+    agent any
+    stages {
+        stage('Build') {
+            parallel {
+                stage('Ubuntu') {
+                    steps {
+                        sh '''
+                            . $HOME/.bash_profile
+                            ./eosio_build.sh
+                        '''
+                    }
+                }
+                stage('MacOS') {
+                    steps {
+                        sh '''
+                            . $HOME/.bash_profile
+                            echo "Darwin build coming soon..."
+                        ''' 
+                    }
+                }
+                stage('Fedora') {
+                    steps {
+                        sh '''
+                            . $HOME/.bash_profile
+                            echo "Fedora build coming soon..."
+                        ''' 
+                    }
+                }
+            }
+        }
+    }
+    post { 
+        always { 
+            cleanWs()
+        }
+    }
+}
\ No newline at end of file
diff --git a/contracts/eosiolib/db.h b/contracts/eosiolib/db.h
index a74f7e2b80c7456186506c21027fbaccb67a6019..5bf6ea18b483f73ea2a36053a06b917014df98c5 100644
--- a/contracts/eosiolib/db.h
+++ b/contracts/eosiolib/db.h
@@ -1027,6 +1027,36 @@ int32_t store_i64i64i64( account_name scope, table_name table, account_name bta,
  * @return 1 if the record was updated, 0 if no record with key was found
  */
 int32_t update_i64i64i64( account_name scope, table_name table, account_name bta, const void* data, uint32_t len );
+///@}  dbi64i64i64 
+
+int32_t db_store_i64(account_name scope, table_name table, account_name payer, uint64_t id,  const void* data, uint32_t len);
+void db_update_i64(int32_t iterator, account_name payer, const void* data, uint32_t len);
+void db_remove_i64(int32_t iterator);
+int32_t db_get_i64(int32_t iterator, const void* data, uint32_t len);
+int32_t db_next_i64(int32_t iterator, uint64_t* primary);
+int32_t db_previous_i64(int32_t iterator, uint64_t* primary);
+int32_t db_find_i64(account_name code, account_name scope, table_name table, uint64_t id);
+int32_t db_lowerbound_i64( account_name code, account_name scope, table_name table, uint64_t id);
+int32_t db_upperbound_i64( account_name code, account_name scope, table_name table, uint64_t id);
+
+int32_t db_idx64_store(account_name scope, table_name table, account_name payer, uint64_t id, const uint64_t* secondary);
+void db_idx64_update(int32_t iterator, account_name payer, const uint64_t* secondary);
+void db_idx64_remove(int32_t iterator);
+int32_t db_idx64_next(int32_t iterator, uint64_t* primary);
+int32_t db_idx64_previous(int32_t iterator, uint64_t* primary);
+int32_t db_idx64_find_primary(account_name code, account_name scope, table_name table, uint64_t* secondary, uint64_t primary);
+int32_t db_idx64_find_secondary(account_name code, account_name scope, table_name table, const uint64_t* secondary, uint64_t* primary);
+int32_t db_idx64_lowerbound(account_name code, account_name scope, table_name table, uint64_t* secondary, uint64_t* primary);
+int32_t db_idx64_upperbound(account_name code, account_name scope, table_name table, uint64_t* secondary, uint64_t* primary);
+
+int32_t db_idx128_store(account_name scope, table_name table, account_name payer, uint64_t id, const uint128_t* secondary);
+void db_idx128_update(int32_t iterator, account_name payer, const uint128_t* secondary);
+void db_idx128_remove(int32_t iterator);
+int32_t db_idx128_next(int32_t iterator, uint64_t* primary);
+int32_t db_idx128_previous(int32_t iterator, uint64_t* primary);
+int32_t db_idx128_find_primary(account_name code, account_name scope, table_name table, uint128_t* secondary, uint64_t primary);
+int32_t db_idx128_find_secondary(account_name code, account_name scope, table_name table, const uint128_t* secondary, uint64_t* primary);
+int32_t db_idx128_lowerbound(account_name code, account_name scope, table_name table, uint128_t* secondary, uint64_t* primary);
+int32_t db_idx128_upperbound(account_name code, account_name scope, table_name table, uint128_t* secondary, uint64_t* primary);
 
-///@}  dbi64i64i64
 }
diff --git a/contracts/eosiolib/multi_index.hpp b/contracts/eosiolib/multi_index.hpp
index f6098cba5673c4882d68322927b642d68fb403f0..63f3ad81d9aed9b70a241da02db3e36964c948ee 100644
--- a/contracts/eosiolib/multi_index.hpp
+++ b/contracts/eosiolib/multi_index.hpp
@@ -11,36 +11,9 @@
 #include <eosiolib/types.hpp>
 #include <eosiolib/serialize.hpp>
 #include <eosiolib/datastream.hpp>
+#include <eosiolib/db.h>
 
 
-extern "C" {
-   int db_store_i64( uint64_t scope, uint64_t table, uint64_t payer, uint64_t id, char* buffer, size_t buffer_size );
-   void db_update_i64( int iterator, uint64_t payer, char* buffer, size_t buffer_size );
-   int db_find_i64( uint64_t code, uint64_t scope, uint64_t table, uint64_t id );
-   int db_lowerbound_i64( uint64_t code, uint64_t scope, uint64_t table, uint64_t id );
-   int db_get_i64( int iterator, char* buffer, size_t buffer_size );
-   void db_remove_i64( int iterator );
-   int db_next_i64( int iterator, uint64_t* pk );
-   int db_previous_i64( int iterator, uint64_t* pk );
-
-   int db_idx64_next( int iterator, uint64_t* primary );
-   int db_idx64_prev( int iterator, uint64_t* primary );
-   int db_idx64_find_primary( uint64_t code, uint64_t scope, uint64_t table, uint64_t* secondary, uint64_t primary );
-   int db_idx64_find_secondary( uint64_t code, uint64_t scope, uint64_t table, uint64_t* secondary, uint64_t* primary );
-   int db_idx64_lowerbound( uint64_t code, uint64_t scope, uint64_t table, uint64_t* secondary, uint64_t* primary );
-   int db_idx64_upperbound( uint64_t code, uint64_t scope, uint64_t table, uint64_t* secondary, uint64_t* primary );
-   void db_idx64_remove( int iterator );
-   void db_idx64_update( int iterator, uint64_t payer, const uint64_t* secondary );
-
-   int db_idx128_next( int iterator, uint64_t* primary );
-   int db_idx128_prev( int iterator, uint64_t* primary );
-   int db_idx128_find_primary( uint64_t code, uint64_t scope, uint64_t table, uint128_t* secondary, uint64_t primary );
-   int db_idx128_find_secondary( uint64_t code, uint64_t scope, uint64_t table, uint128_t* secondary, uint64_t* primary );
-   int db_idx128_lowerbound( uint64_t code, uint64_t scope, uint64_t table, uint128_t* secondary, uint64_t* primary );
-   int db_idx128_upperbound( uint64_t code, uint64_t scope, uint64_t table, uint128_t* secondary, uint64_t* primary );
-   void db_idx128_remove( int iterator );
-   void db_idx128_update( int iterator, uint64_t payer, const uint128_t* secondary );
-}
 
 
 namespace eosio {
@@ -54,14 +27,14 @@ struct secondary_iterator;
 template<>
 struct secondary_iterator<uint64_t> {
    static int db_idx_next( int iterator, uint64_t* primary ) { return db_idx64_next( iterator, primary ); }
-   static int db_idx_prev( int iterator, uint64_t* primary ) { return db_idx64_prev( iterator, primary ); }
+   static int db_idx_prev( int iterator, uint64_t* primary ) { return db_idx64_previous( iterator, primary ); }
    static void db_idx_remove( int iterator  )                 { db_idx64_remove( iterator ); }
 };
 
 template<>
 struct secondary_iterator<uint128_t> {
    static int db_idx_next( int iterator, uint64_t* primary ) { return db_idx128_next( iterator, primary ); }
-   static int db_idx_prev( int iterator, uint64_t* primary ) { return db_idx128_prev( iterator, primary ); }
+   static int db_idx_prev( int iterator, uint64_t* primary ) { return db_idx128_previous( iterator, primary ); }
    static void db_idx_remove( int iterator  )                 { db_idx128_remove( iterator ); }
 };
 
diff --git a/contracts/test_api/test_api.cpp b/contracts/test_api/test_api.cpp
index 19bdb6347dea56b0617d6892942e004beb089879..b3b6f98c2aa22ef11663b91e3af845d778924a66 100644
--- a/contracts/test_api/test_api.cpp
+++ b/contracts/test_api/test_api.cpp
@@ -17,6 +17,7 @@
 //#include "test_real.cpp"
 //#include "test_transaction.cpp"
 //#include "test_types.cpp"
+#include "test_db.cpp"
 
 extern "C" {
 
@@ -91,7 +92,14 @@ extern "C" {
 //      WASM_TEST_HANDLER(test_db, key_i64i64i64_under_limit);
 //      WASM_TEST_HANDLER(test_db, key_i64i64i64_available_space_exceed_limit);
 //      WASM_TEST_HANDLER(test_db, key_i64i64i64_another_under_limit);
-//
+
+      WASM_TEST_HANDLER(test_db, primary_i64_general);
+      WASM_TEST_HANDLER(test_db, primary_i64_lowerbound);
+      WASM_TEST_HANDLER(test_db, primary_i64_upperbound);
+      WASM_TEST_HANDLER(test_db, idx64_general);
+      WASM_TEST_HANDLER(test_db, idx64_lowerbound);
+      WASM_TEST_HANDLER(test_db, idx64_upperbound);
+
 //      //test crypto
 //      WASM_TEST_HANDLER(test_crypto, test_sha256);
 //      WASM_TEST_HANDLER(test_crypto, sha256_no_data);
diff --git a/contracts/test_api/test_api.hpp b/contracts/test_api/test_api.hpp
index 0107bbf2e2920ce8e1664ded9461de58a7efa2ab..a344a25fb4a4bbb29c88f7c0016ae86243f9ecff 100644
--- a/contracts/test_api/test_api.hpp
+++ b/contracts/test_api/test_api.hpp
@@ -117,6 +117,13 @@ struct test_db {
    static unsigned int key_i64i64i64_under_limit();
    static unsigned int key_i64i64i64_available_space_exceed_limit();
    static unsigned int key_i64i64i64_another_under_limit();
+      
+   static void primary_i64_general();
+   static void primary_i64_lowerbound();
+   static void primary_i64_upperbound();
+   static void idx64_general();
+   static void idx64_lowerbound();
+   static void idx64_upperbound();
 };
 
 struct test_crypto {
diff --git a/contracts/test_api/test_db.cpp b/contracts/test_api/test_db.cpp
index 9186c369fd8b3deb7e5353bcbab133b9be57b849..da780b2db843ca18c26612e07e3da6a99305b885 100644
--- a/contracts/test_api/test_db.cpp
+++ b/contracts/test_api/test_db.cpp
@@ -68,6 +68,8 @@ extern "C" {
   bool my_memcmp(void *s1, void *s2, uint32_t n);
 }
 
+#if 0
+
 unsigned int test_db::key_str_table() {
 
     const char* keys[] = { "alice", "bob", "carol", "dave" };
@@ -76,95 +78,99 @@ unsigned int test_db::key_str_table() {
     const char* atr[]  = { "atr", "atr", "atr", "atr" };
     const char* ztr[]  = { "ztr", "ztr", "ztr", "ztr" };
     
-    eosio::var_table<N(tester), N(tester), N(atr), char*> StringTableAtr;
-    eosio::var_table<N(tester), N(tester), N(ztr), char*> StringTableZtr;
-    eosio::var_table<N(tester), N(tester), N(str), char*> StringTableStr;
+    eosio::var_table<N(tester), N(tester), N(atr), N(tester), char*> StringTableAtr;
+    eosio::var_table<N(tester), N(tester), N(ztr), N(tester), char*> StringTableZtr;
+    eosio::var_table<N(tester), N(tester), N(str), N(tester), char*> StringTableStr;
 
     uint32_t res = 0;
 
     // fill some data in contiguous tables
     for( int ii = 0; ii < 4; ++ii ) {
         res = StringTableAtr.store( (char*)keys[ii], STRLEN(keys[ii]), (char*)atr[ii], STRLEN(atr[ii]) );
-        WASM_ASSERT( res != 0, "atr" );
+        eos_assert( res != 0, "atr" );
     
         res = StringTableZtr.store( (char*)keys[ii], STRLEN(keys[ii]), (char*)ztr[ii], STRLEN(ztr[ii]) );
-        WASM_ASSERT(res != 0, "ztr" );
+        eos_assert(res != 0, "ztr" );
     }
 
     char tmp[64];
     
     res = StringTableStr.store ((char *)keys[0], STRLEN(keys[0]), (char *)vals[0], STRLEN(vals[0]));
-    WASM_ASSERT(res != 0, "store alice" );
+    eos_assert(res != 0, "store alice" );
 
     res = StringTableStr.store((char *)keys[1], STRLEN(keys[1]), (char *)vals[1], STRLEN(vals[1]) );
-    WASM_ASSERT(res != 0, "store bob" );
+    eos_assert(res != 0, "store bob" );
 
     res = StringTableStr.store((char *)keys[2], STRLEN(keys[2]), (char *)vals[2], STRLEN(vals[2]) );
-    WASM_ASSERT(res != 0, "store carol" );
+    eos_assert(res != 0, "store carol" );
 
     res = StringTableStr.store((char *)keys[3], STRLEN(keys[3]), (char *)vals[3], STRLEN(vals[3]) );
-    WASM_ASSERT(res != 0, "store dave" );
+    eos_assert(res != 0, "store dave" );
 
     res = StringTableStr.load((char *)keys[0], STRLEN(keys[0]), tmp, 64);
-    WASM_ASSERT(res == STRLEN(vals[0]) && my_memcmp((void *)vals[0], (void *)tmp, res), "load alice");
+    eos_assert(res == STRLEN(vals[0]) && my_memcmp((void *)vals[0], (void *)tmp, res), "load alice");
 
     res = StringTableStr.load((char *)keys[1], STRLEN(keys[1]), tmp, 64);
-    WASM_ASSERT(res == STRLEN(vals[1]) && my_memcmp((void *)vals[1], (void *)tmp, res), "load bob");
+    eos_assert(res == STRLEN(vals[1]) && my_memcmp((void *)vals[1], (void *)tmp, res), "load bob");
 
     res = StringTableStr.load((char *)keys[2], STRLEN(keys[2]), tmp, 64);
-    WASM_ASSERT(res == STRLEN(vals[2]) && my_memcmp((void *)vals[2], (void *)tmp, res), "load carol");
+    eos_assert(res == STRLEN(vals[2]) && my_memcmp((void *)vals[2], (void *)tmp, res), "load carol");
 
     res = StringTableStr.load((char *)keys[3], STRLEN(keys[3]), tmp, 64);
-    WASM_ASSERT(res == STRLEN(vals[3]) && my_memcmp((void *)vals[3], (void *)tmp, res), "load dave");
+    eos_assert(res == STRLEN(vals[3]) && my_memcmp((void *)vals[3], (void *)tmp, res), "load dave");
 
     res = StringTableStr.previous((char *)keys[3], STRLEN(keys[3]), tmp, 64);
-    WASM_ASSERT(res == STRLEN(vals[2]) && my_memcmp((void *)vals[2], (void *)tmp, res), "back carol");
+    eos_assert(res == STRLEN(vals[2]) && my_memcmp((void *)vals[2], (void *)tmp, res), "back carol");
 
     res = StringTableStr.previous((char *)keys[2], STRLEN(keys[2]), tmp, 64);
-    WASM_ASSERT(res == STRLEN(vals[1]) && my_memcmp((void *)vals[1], (void *)tmp, res), "back dave");
+    eos_assert(res == STRLEN(vals[1]) && my_memcmp((void *)vals[1], (void *)tmp, res), "back dave");
 
     res = StringTableStr.previous((char *)keys[1], STRLEN(keys[1]), tmp, 64);
-    WASM_ASSERT(res == STRLEN(vals[0]) && my_memcmp((void *)vals[0], (void *)tmp, res), "back alice");
+    eos_assert(res == STRLEN(vals[0]) && my_memcmp((void *)vals[0], (void *)tmp, res), "back alice");
 
     res = StringTableStr.previous((char *)keys[0], STRLEN(keys[0]), tmp, 64);
-    WASM_ASSERT(res == -1, "no prev");
+    eos_assert(res == -1, "no prev");
 
     res = StringTableStr.next((char *)keys[0], STRLEN(keys[0]), tmp, 64);
-    WASM_ASSERT(res == STRLEN(vals[1]) && my_memcmp((void *)vals[1], (void *)tmp, res), "next bob");
+    eos_assert(res == STRLEN(vals[1]) && my_memcmp((void *)vals[1], (void *)tmp, res), "next bob");
 
     res = StringTableStr.next((char *)keys[1], STRLEN(keys[1]), tmp, 64);
-    WASM_ASSERT(res == STRLEN(vals[2]) && my_memcmp((void *)vals[2], (void *)tmp, res), "next carol");
+    eos_assert(res == STRLEN(vals[2]) && my_memcmp((void *)vals[2], (void *)tmp, res), "next carol");
 
     res = StringTableStr.next((char *)keys[2], STRLEN(keys[2]), tmp, 64);
-    WASM_ASSERT(res == STRLEN(vals[3]) && my_memcmp((void *)vals[3], (void *)tmp, res), "next dave");
+    eos_assert(res == STRLEN(vals[3]) && my_memcmp((void *)vals[3], (void *)tmp, res), "next dave");
 
     res = StringTableStr.next((char *)keys[3], STRLEN(keys[3]), tmp, 64);
-    WASM_ASSERT(res == -1, "no next");
+    eos_assert(res == -1, "no next");
 
     res = StringTableStr.next((char *)keys[0], STRLEN(keys[0]), tmp, 0);
-    WASM_ASSERT(res == 0, "next 0");
+    eos_assert(res == 0, "next 0");
 
     res = StringTableStr.front(tmp, 64);
-    WASM_ASSERT(res == STRLEN(vals[0]) && my_memcmp((void *)vals[0], (void *)tmp, res), "front alice");
+    eos_assert(res == STRLEN(vals[0]) && my_memcmp((void *)vals[0], (void *)tmp, res), "front alice");
 
     res = StringTableStr.back(tmp, 64);
-    WASM_ASSERT(res == STRLEN(vals[3]) && my_memcmp((void *)vals[3], (void *)tmp, res), "back dave");
+    eos_assert(res == STRLEN(vals[3]) && my_memcmp((void *)vals[3], (void *)tmp, res), "back dave");
 
     res = StringTableStr.lower_bound((char *)keys[0], STRLEN(keys[0]), tmp, 64);
-    WASM_ASSERT(res == STRLEN(vals[0]) && my_memcmp((void *)vals[0], (void *)tmp, res), "lowerbound alice");
+    eos_assert(res == STRLEN(vals[0]) && my_memcmp((void *)vals[0], (void *)tmp, res), "lowerbound alice");
 
     res = StringTableStr.upper_bound((char *)keys[0], STRLEN(keys[0]), tmp, 64);
-    WASM_ASSERT(res == STRLEN(vals[1]) && my_memcmp((void *)vals[1], (void *)tmp, res), "upperbound bob");
+    eos_assert(res == STRLEN(vals[1]) && my_memcmp((void *)vals[1], (void *)tmp, res), "upperbound bob");
 
     res = StringTableStr.lower_bound((char *)keys[3], STRLEN(keys[3]), tmp, 64);
-    WASM_ASSERT(res == STRLEN(vals[3]) && my_memcmp((void *)vals[3], (void *)tmp, res), "upperbound dave");
+    eos_assert(res == STRLEN(vals[3]) && my_memcmp((void *)vals[3], (void *)tmp, res), "upperbound dave");
 
     res = StringTableStr.upper_bound((char *)keys[3], STRLEN(keys[3]), tmp, 64);
-    WASM_ASSERT(res == -1, "no upper_bound");
+    eos_assert(res == -1, "no upper_bound");
 
-    return WASM_TEST_PASS;
+    return 1; // WASM_TEST_PASS;
 }
 
+#endif
+
+#if 0
+
 unsigned int test_db::key_str_general() {
 
   const char* keys[] = { "alice", "bob", "carol", "dave" };
@@ -178,86 +184,90 @@ unsigned int test_db::key_str_general() {
   //fill some data in contiguous tables
   for(int i=0; i < 4; ++i) {
     res = store_str(current_receiver(),  N(atr), (char *)keys[i], STRLEN(keys[i]), (char *)atr[i], STRLEN(atr[i]) );
-    WASM_ASSERT(res != 0, "atr" );
+    eos_assert(res != 0, "atr" );
 
     res = store_str(current_receiver(),  N(ztr), (char *)keys[i], STRLEN(keys[i]), (char *)ztr[i], STRLEN(ztr[i]) );
-    WASM_ASSERT(res != 0, "ztr" );
+    eos_assert(res != 0, "ztr" );
   }
 
   char tmp[64];
 
   res = store_str(current_receiver(),  N(str), (char *)keys[0], STRLEN(keys[0]), (char *)vals[0], STRLEN(vals[0]) );
-  WASM_ASSERT(res != 0, "store alice" );
+  eos_assert(res != 0, "store alice" );
 
   res = store_str(current_receiver(),  N(str), (char *)keys[1], STRLEN(keys[1]), (char *)vals[1], STRLEN(vals[1]) );
-  WASM_ASSERT(res != 0, "store bob" );
+  eos_assert(res != 0, "store bob" );
 
   res = store_str(current_receiver(),  N(str), (char *)keys[2], STRLEN(keys[2]), (char *)vals[2], STRLEN(vals[2]) );
-  WASM_ASSERT(res != 0, "store carol" );
+  eos_assert(res != 0, "store carol" );
 
   res = store_str(current_receiver(),  N(str), (char *)keys[3], STRLEN(keys[3]), (char *)vals[3], STRLEN(vals[3]) );
-  WASM_ASSERT(res != 0, "store dave" );
+  eos_assert(res != 0, "store dave" );
 
   res = load_str(current_receiver(), current_receiver(), N(str), (char *)keys[0], STRLEN(keys[0]), tmp, 64);
-  WASM_ASSERT(res == STRLEN(vals[0]) && my_memcmp((void *)vals[0], (void *)tmp, res), "load alice");
+  eos_assert(res == STRLEN(vals[0]) && my_memcmp((void *)vals[0], (void *)tmp, res), "load alice");
 
   res = load_str(current_receiver(), current_receiver(), N(str), (char *)keys[1], STRLEN(keys[1]), tmp, 64);
-  WASM_ASSERT(res == STRLEN(vals[1]) && my_memcmp((void *)vals[1], (void *)tmp, res), "load bob");
+  eos_assert(res == STRLEN(vals[1]) && my_memcmp((void *)vals[1], (void *)tmp, res), "load bob");
 
   res = load_str(current_receiver(), current_receiver(), N(str), (char *)keys[2], STRLEN(keys[2]), tmp, 64);
-  WASM_ASSERT(res == STRLEN(vals[2]) && my_memcmp((void *)vals[2], (void *)tmp, res), "load carol");
+  eos_assert(res == STRLEN(vals[2]) && my_memcmp((void *)vals[2], (void *)tmp, res), "load carol");
 
   res = load_str(current_receiver(), current_receiver(), N(str), (char *)keys[3], STRLEN(keys[3]), tmp, 64);
-  WASM_ASSERT(res == STRLEN(vals[3]) && my_memcmp((void *)vals[3], (void *)tmp, res), "load dave");
+  eos_assert(res == STRLEN(vals[3]) && my_memcmp((void *)vals[3], (void *)tmp, res), "load dave");
 
   res = previous_str(current_receiver(), current_receiver(), N(str), (char *)keys[3], STRLEN(keys[3]), tmp, 64);
-  WASM_ASSERT(res == STRLEN(vals[2]) && my_memcmp((void *)vals[2], (void *)tmp, res), "back carol");
+  eos_assert(res == STRLEN(vals[2]) && my_memcmp((void *)vals[2], (void *)tmp, res), "back carol");
 
   res = previous_str(current_receiver(), current_receiver(), N(str), (char *)keys[2], STRLEN(keys[2]), tmp, 64);
-  WASM_ASSERT(res == STRLEN(vals[1]) && my_memcmp((void *)vals[1], (void *)tmp, res), "back dave");
+  eos_assert(res == STRLEN(vals[1]) && my_memcmp((void *)vals[1], (void *)tmp, res), "back dave");
 
   res = previous_str(current_receiver(), current_receiver(), N(str), (char *)keys[1], STRLEN(keys[1]), tmp, 64);
-  WASM_ASSERT(res == STRLEN(vals[0]) && my_memcmp((void *)vals[0], (void *)tmp, res), "back alice");
+  eos_assert(res == STRLEN(vals[0]) && my_memcmp((void *)vals[0], (void *)tmp, res), "back alice");
 
   res = previous_str(current_receiver(), current_receiver(), N(str), (char *)keys[0], STRLEN(keys[0]), tmp, 64);
-  WASM_ASSERT(res == -1, "no prev");
+  eos_assert(res == -1, "no prev");
 
   res = next_str(current_receiver(), current_receiver(), N(str), (char *)keys[0], STRLEN(keys[0]), tmp, 64);
-  WASM_ASSERT(res == STRLEN(vals[1]) && my_memcmp((void *)vals[1], (void *)tmp, res), "next bob");
+  eos_assert(res == STRLEN(vals[1]) && my_memcmp((void *)vals[1], (void *)tmp, res), "next bob");
 
   res = next_str(current_receiver(), current_receiver(), N(str), (char *)keys[1], STRLEN(keys[1]), tmp, 64);
-  WASM_ASSERT(res == STRLEN(vals[2]) && my_memcmp((void *)vals[2], (void *)tmp, res), "next carol");
+  eos_assert(res == STRLEN(vals[2]) && my_memcmp((void *)vals[2], (void *)tmp, res), "next carol");
 
   res = next_str(current_receiver(), current_receiver(), N(str), (char *)keys[2], STRLEN(keys[2]), tmp, 64);
-  WASM_ASSERT(res == STRLEN(vals[3]) && my_memcmp((void *)vals[3], (void *)tmp, res), "next dave");
+  eos_assert(res == STRLEN(vals[3]) && my_memcmp((void *)vals[3], (void *)tmp, res), "next dave");
 
   res = next_str(current_receiver(), current_receiver(), N(str), (char *)keys[3], STRLEN(keys[3]), tmp, 64);
-  WASM_ASSERT(res == -1, "no next");
+  eos_assert(res == -1, "no next");
 
   res = next_str(current_receiver(), current_receiver(), N(str), (char *)keys[0], STRLEN(keys[0]), tmp, 0);
-  WASM_ASSERT(res == 0, "next 0");
+  eos_assert(res == 0, "next 0");
 
   res = front_str(current_receiver(), current_receiver(), N(str), tmp, 64);
-  WASM_ASSERT(res == STRLEN(vals[0]) && my_memcmp((void *)vals[0], (void *)tmp, res), "front alice");
+  eos_assert(res == STRLEN(vals[0]) && my_memcmp((void *)vals[0], (void *)tmp, res), "front alice");
 
   res = back_str(current_receiver(), current_receiver(), N(str), tmp, 64);
-  WASM_ASSERT(res == STRLEN(vals[3]) && my_memcmp((void *)vals[3], (void *)tmp, res), "back dave");
+  eos_assert(res == STRLEN(vals[3]) && my_memcmp((void *)vals[3], (void *)tmp, res), "back dave");
 
   res = lower_bound_str(current_receiver(), current_receiver(), N(str), (char *)keys[0], STRLEN(keys[0]), tmp, 64);
-  WASM_ASSERT(res == STRLEN(vals[0]) && my_memcmp((void *)vals[0], (void *)tmp, res), "lowerbound alice");
+  eos_assert(res == STRLEN(vals[0]) && my_memcmp((void *)vals[0], (void *)tmp, res), "lowerbound alice");
 
   res = upper_bound_str(current_receiver(), current_receiver(), N(str), (char *)keys[0], STRLEN(keys[0]), tmp, 64);
-  WASM_ASSERT(res == STRLEN(vals[1]) && my_memcmp((void *)vals[1], (void *)tmp, res), "upperbound bob");
+  eos_assert(res == STRLEN(vals[1]) && my_memcmp((void *)vals[1], (void *)tmp, res), "upperbound bob");
 
   res = lower_bound_str(current_receiver(), current_receiver(), N(str), (char *)keys[3], STRLEN(keys[3]), tmp, 64);
-  WASM_ASSERT(res == STRLEN(vals[3]) && my_memcmp((void *)vals[3], (void *)tmp, res), "upperbound dave");
+  eos_assert(res == STRLEN(vals[3]) && my_memcmp((void *)vals[3], (void *)tmp, res), "upperbound dave");
 
   res = upper_bound_str(current_receiver(), current_receiver(), N(str), (char *)keys[3], STRLEN(keys[3]), tmp, 64);
-  WASM_ASSERT(res == -1, "no upper_bound");
+  eos_assert(res == -1, "no upper_bound");
 
-  return WASM_TEST_PASS;
+  return 1;//WASM_TEST_PASS;
 }
 
+#endif
+
+#if 0
+
 unsigned int test_db::key_i64_general() {
 
   uint32_t res = 0;
@@ -268,16 +278,16 @@ unsigned int test_db::key_i64_general() {
   test_model dave { N(dave),  46, 6535354};
 
   res = store_i64(current_receiver(),  N(test_table), &dave,  sizeof(test_model));
-  WASM_ASSERT(res != 0, "store dave" );
+  eos_assert(res != 0, "store dave" );
 
   res = store_i64(current_receiver(), N(test_table), &carol, sizeof(test_model));
-  WASM_ASSERT(res != 0, "store carol" );
+  eos_assert(res != 0, "store carol" );
 
   res = store_i64(current_receiver(),   N(test_table), &bob,   sizeof(test_model));
-  WASM_ASSERT(res != 0, "store bob" );
+  eos_assert(res != 0, "store bob" );
 
   res = store_i64(current_receiver(), N(test_table), &alice, sizeof(test_model));
-  WASM_ASSERT(res != 0, "store alice" );
+  eos_assert(res != 0, "store alice" );
 
   //fill with different ages in adjacent tables
   dave.age=123;  store_i64(current_receiver(), N(test_tabld), &dave,  sizeof(test_model));
@@ -292,56 +302,56 @@ unsigned int test_db::key_i64_general() {
   test_model tmp;
 
   res = front_i64( current_receiver(), current_receiver(), N(test_table), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == sizeof(test_model) && tmp.name == N(alice) && tmp.age == 20 && tmp.phone == 4234622, "front_i64 1");
+  eos_assert(res == sizeof(test_model) && tmp.name == N(alice) && tmp.age == 20 && tmp.phone == 4234622, "front_i64 1");
   my_memset(&tmp, 0, sizeof(test_model));
 
   res = back_i64( current_receiver(), current_receiver(), N(test_table), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == sizeof(test_model) && tmp.name == N(dave) && tmp.age == 46 && tmp.phone == 6535354, "front_i64 2");
+  eos_assert(res == sizeof(test_model) && tmp.name == N(dave) && tmp.age == 46 && tmp.phone == 6535354, "front_i64 2");
 
   res = previous_i64( current_receiver(), current_receiver(), N(test_table), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == sizeof(test_model) && tmp.name == N(carol) && tmp.age == 30 && tmp.phone == 545342453, "carol previous");
+  eos_assert(res == sizeof(test_model) && tmp.name == N(carol) && tmp.age == 30 && tmp.phone == 545342453, "carol previous");
   
   res = previous_i64( current_receiver(), current_receiver(), N(test_table), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == sizeof(test_model) && tmp.name == N(bob) && tmp.age == 15 && tmp.phone == 11932435, "bob previous");
+  eos_assert(res == sizeof(test_model) && tmp.name == N(bob) && tmp.age == 15 && tmp.phone == 11932435, "bob previous");
 
   res = previous_i64( current_receiver(), current_receiver(), N(test_table), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == sizeof(test_model) && tmp.name == N(alice) && tmp.age == 20 && tmp.phone == 4234622, "alice previous");
+  eos_assert(res == sizeof(test_model) && tmp.name == N(alice) && tmp.age == 20 && tmp.phone == 4234622, "alice previous");
 
   res = previous_i64( current_receiver(), current_receiver(), N(test_table), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == -1, "previous null");
+  eos_assert(res == -1, "previous null");
 
   res = next_i64( current_receiver(), current_receiver(), N(test_table), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == sizeof(test_model) && tmp.name == N(bob) && tmp.age == 15 && tmp.phone == 11932435, "bob next");
+  eos_assert(res == sizeof(test_model) && tmp.name == N(bob) && tmp.age == 15 && tmp.phone == 11932435, "bob next");
 
   res = next_i64( current_receiver(), current_receiver(), N(test_table), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == sizeof(test_model) && tmp.name == N(carol) && tmp.age == 30 && tmp.phone == 545342453, "carol next");
+  eos_assert(res == sizeof(test_model) && tmp.name == N(carol) && tmp.age == 30 && tmp.phone == 545342453, "carol next");
 
   res = next_i64( current_receiver(), current_receiver(), N(test_table), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == sizeof(test_model) && tmp.name == N(dave) && tmp.age == 46 && tmp.phone == 6535354, "dave next");
+  eos_assert(res == sizeof(test_model) && tmp.name == N(dave) && tmp.age == 46 && tmp.phone == 6535354, "dave next");
 
   res = next_i64( current_receiver(), current_receiver(), N(test_table), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == -1, "next null");
+  eos_assert(res == -1, "next null");
 
   my_memset(&alice, 0, sizeof(test_model));
 
-  WASM_ASSERT(alice.name == 0 && alice.age == 0 && alice.phone == 0, "my_memset");
+  eos_assert(alice.name == 0 && alice.age == 0 && alice.phone == 0, "my_memset");
 
   alice.name = N(alice);
 
   res = load_i64(current_receiver(), current_receiver(), N(test_table), &alice, sizeof(test_model));
-  WASM_ASSERT(res == sizeof(test_model) && alice.age == 20 && alice.phone == 4234622, "alice error 1");
+  eos_assert(res == sizeof(test_model) && alice.age == 20 && alice.phone == 4234622, "alice error 1");
 
   alice.age = 21;
   alice.phone = 1234;
   
   res = store_i64(current_receiver(), N(test_table), &alice, sizeof(test_model));
-  WASM_ASSERT(res == 0, "store alice 2" );
+  eos_assert(res == 0, "store alice 2" );
 
   my_memset(&alice, 0, sizeof(test_model));
   alice.name = N(alice);
   
   res = load_i64(current_receiver(), current_receiver(), N(test_table), &alice, sizeof(test_model));
-  WASM_ASSERT(res == sizeof(test_model) && alice.age == 21 && alice.phone == 1234, "alice error 2");
+  eos_assert(res == sizeof(test_model) && alice.age == 21 && alice.phone == 1234, "alice error 2");
 
   my_memset(&bob, 0, sizeof(test_model));
   bob.name = N(bob);
@@ -353,72 +363,72 @@ unsigned int test_db::key_i64_general() {
   dave.name = N(dave);
 
   res = load_i64(current_receiver(), current_receiver(), N(test_table), &bob, sizeof(test_model));
-  WASM_ASSERT(res == sizeof(test_model) && bob.age == 15 && bob.phone == 11932435, "bob error 1");
+  eos_assert(res == sizeof(test_model) && bob.age == 15 && bob.phone == 11932435, "bob error 1");
 
   res = load_i64(current_receiver(), current_receiver(), N(test_table), &carol, sizeof(test_model));
-  WASM_ASSERT(res == sizeof(test_model) && carol.age == 30 && carol.phone == 545342453, "carol error 1");
+  eos_assert(res == sizeof(test_model) && carol.age == 30 && carol.phone == 545342453, "carol error 1");
 
   res = load_i64(current_receiver(), current_receiver(), N(test_table), &dave, sizeof(test_model));
-  WASM_ASSERT(res == sizeof(test_model) && dave.age == 46 && dave.phone == 6535354, "dave error 1");
+  eos_assert(res == sizeof(test_model) && dave.age == 46 && dave.phone == 6535354, "dave error 1");
 
   res = load_i64(current_receiver(), N(other_code), N(test_table), &alice, sizeof(test_model));
-  WASM_ASSERT(res == -1, "other_code");
+  eos_assert(res == -1, "other_code");
 
   res = load_i64(current_receiver(), current_receiver(), N(other_table), &alice, sizeof(test_model));
-  WASM_ASSERT(res == -1, "other_table");
+  eos_assert(res == -1, "other_table");
 
 
   test_model_v2 alicev2;
   alicev2.name = N(alice);
 
   res = load_i64(current_receiver(), current_receiver(), N(test_table), &alicev2, sizeof(test_model_v2));
-  WASM_ASSERT(res == sizeof(test_model) && alicev2.age == 21 && alicev2.phone == 1234, "alicev2 load");
+  eos_assert(res == sizeof(test_model) && alicev2.age == 21 && alicev2.phone == 1234, "alicev2 load");
 
   alicev2.new_field = 66655444;
   res = store_i64(current_receiver(), N(test_table), &alicev2, sizeof(test_model_v2));
-  WASM_ASSERT(res == 0, "store alice 3" );
+  eos_assert(res == 0, "store alice 3" );
 
   my_memset(&alicev2, 0, sizeof(test_model_v2));
   alicev2.name = N(alice);
 
   res = load_i64(current_receiver(), current_receiver(), N(test_table), &alicev2, sizeof(test_model_v2));
-  WASM_ASSERT(res == sizeof(test_model_v2) && alicev2.age == 21 && alicev2.phone == 1234 && alicev2.new_field == 66655444, "alice model v2");
+  eos_assert(res == sizeof(test_model_v2) && alicev2.age == 21 && alicev2.phone == 1234 && alicev2.new_field == 66655444, "alice model v2");
 
   my_memset(&tmp, 0, sizeof(test_model));
   tmp.name = N(bob);
   res = lower_bound_i64( current_receiver(), current_receiver(), N(test_table), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == sizeof(test_model) && tmp.name == N(bob), "lower_bound_i64 bob" );
+  eos_assert(res == sizeof(test_model) && tmp.name == N(bob), "lower_bound_i64 bob" );
 
   my_memset(&tmp, 0, sizeof(test_model));
   tmp.name = N(boc);
   res = lower_bound_i64( current_receiver(), current_receiver(), N(test_table), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == sizeof(test_model) && tmp.name == N(carol), "lower_bound_i64 carol" );
+  eos_assert(res == sizeof(test_model) && tmp.name == N(carol), "lower_bound_i64 carol" );
 
   my_memset(&tmp, 0, sizeof(test_model));
   tmp.name = N(dave);
   res = lower_bound_i64( current_receiver(), current_receiver(), N(test_table), &tmp, sizeof(uint64_t) );
-  WASM_ASSERT(res == sizeof(uint64_t) && tmp.name == N(dave), "lower_bound_i64 dave" );
+  eos_assert(res == sizeof(uint64_t) && tmp.name == N(dave), "lower_bound_i64 dave" );
 
   my_memset(&tmp, 0, sizeof(test_model));
   tmp.name = N(davf);
   res = lower_bound_i64( current_receiver(), current_receiver(), N(test_table), &tmp, sizeof(uint64_t) );
-  WASM_ASSERT(res == -1, "lower_bound_i64 fail" );
+  eos_assert(res == -1, "lower_bound_i64 fail" );
 
   my_memset(&tmp, 0, sizeof(test_model));
   tmp.name = N(alice);
   res = upper_bound_i64( current_receiver(), current_receiver(), N(test_table), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == sizeof(test_model) && tmp.age == 15 && tmp.name == N(bob), "upper_bound_i64 bob" );
+  eos_assert(res == sizeof(test_model) && tmp.age == 15 && tmp.name == N(bob), "upper_bound_i64 bob" );
 
   my_memset(&tmp, 0, sizeof(test_model));
   tmp.name = N(dave);
   res = upper_bound_i64( current_receiver(), current_receiver(), N(test_table), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == -1, "upper_bound_i64 dave" );
+  eos_assert(res == -1, "upper_bound_i64 dave" );
 
   test_model_v3 tmp2;
   tmp2.name = N(alice);
 
   res = load_i64(current_receiver(), current_receiver(), N(test_table), &tmp2, sizeof(test_model_v3));
-  WASM_ASSERT(res == sizeof(test_model_v2) &&
+  eos_assert(res == sizeof(test_model_v2) &&
               tmp2.age == 21 && 
               tmp2.phone == 1234 &&
               tmp2.new_field == 66655444,
@@ -426,10 +436,10 @@ unsigned int test_db::key_i64_general() {
 
   tmp2.another_field = 221122;
   res = update_i64(current_receiver(), N(test_table), &tmp2, sizeof(test_model_v3));
-  WASM_ASSERT(res == 1, "update_i64");
+  eos_assert(res == 1, "update_i64");
 
   res = load_i64(current_receiver(), current_receiver(), N(test_table), &tmp2, sizeof(test_model_v3));
-  WASM_ASSERT(res == sizeof(test_model_v3) &&
+  eos_assert(res == sizeof(test_model_v3) &&
               tmp2.age == 21 && 
               tmp2.phone == 1234 &&
               tmp2.new_field == 66655444 &&
@@ -438,10 +448,10 @@ unsigned int test_db::key_i64_general() {
 
   tmp2.age = 11;
   res = update_i64(current_receiver(), N(test_table), &tmp2,  sizeof(uint64_t)+1 );
-  WASM_ASSERT(res == 1, "update_i64 small");
+  eos_assert(res == 1, "update_i64 small");
 
   res = load_i64(current_receiver(), current_receiver(), N(test_table), &tmp2, sizeof(test_model_v3));
-  WASM_ASSERT(res == sizeof(test_model_v3) &&
+  eos_assert(res == sizeof(test_model_v3) &&
               tmp2.age == 11 && 
               tmp2.phone == 1234 &&
               tmp2.new_field == 66655444 &&
@@ -460,6 +470,10 @@ unsigned int test_db::key_i64_general() {
   return WASM_TEST_PASS;
 }
 
+#endif
+
+#if 0
+
 unsigned int test_db::key_i64_remove_all() {
   
   uint32_t res = 0;
@@ -467,47 +481,51 @@ unsigned int test_db::key_i64_remove_all() {
 
   key = N(alice);
   res = remove_i64(current_receiver(), N(test_table), &key);
-  WASM_ASSERT(res == 1, "remove alice");
+  eos_assert(res == 1, "remove alice");
   
   key = N(bob);
   res = remove_i64(current_receiver(),   N(test_table), &key);
-  WASM_ASSERT(res == 1, "remove bob");
+  eos_assert(res == 1, "remove bob");
   
   key = N(carol);
   res = remove_i64(current_receiver(), N(test_table), &key);
-  WASM_ASSERT(res == 1, "remove carol");
+  eos_assert(res == 1, "remove carol");
   
   key = N(dave);
   res = remove_i64(current_receiver(),  N(test_table), &key);
-  WASM_ASSERT(res == 1, "remove dave");
+  eos_assert(res == 1, "remove dave");
 
   test_model tmp;
   res = front_i64( current_receiver(), current_receiver(), N(test_table), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == -1, "front_i64 remove");
+  eos_assert(res == -1, "front_i64 remove");
 
   res = back_i64( current_receiver(), current_receiver(), N(test_table), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == -1, "back_i64_i64 remove");
+  eos_assert(res == -1, "back_i64_i64 remove");
   
   key = N(alice);
   res = remove_i64(current_receiver(), N(test_table), &key);
-  WASM_ASSERT(res == 0, "remove alice 1");
+  eos_assert(res == 0, "remove alice 1");
   
   key = N(bob);
   res = remove_i64(current_receiver(),   N(test_table), &key);
-  WASM_ASSERT(res == 0, "remove bob 1");
+  eos_assert(res == 0, "remove bob 1");
   
   key = N(carol);
   res = remove_i64(current_receiver(), N(test_table), &key);
-  WASM_ASSERT(res == 0, "remove carol 1");
+  eos_assert(res == 0, "remove carol 1");
   
   key = N(dave);
   res = remove_i64(current_receiver(),  N(test_table), &key);
-  WASM_ASSERT(res == 0, "remove dave 1");
+  eos_assert(res == 0, "remove dave 1");
 
  
   return WASM_TEST_PASS;
 }
 
+#endif
+
+#if 0
+
 unsigned int test_db::key_i64_small_load() {
   uint64_t dummy = 0;
   load_i64(current_receiver(), current_receiver(), N(just_uint64), &dummy, sizeof(uint64_t)-1);
@@ -536,10 +554,10 @@ unsigned int test_db::key_i64_not_found() {
   uint64_t dummy = 1000;
 
   auto res = load_i64(current_receiver(), current_receiver(), N(just_uint64), &dummy, sizeof(uint64_t));
-  WASM_ASSERT(res == -1, "i64_not_found load");
+  eos_assert(res == -1, "i64_not_found load");
 
   res = remove_i64(current_receiver(),  N(just_uint64), &dummy);
-  WASM_ASSERT(res == 0, "i64_not_found remove");
+  eos_assert(res == 0, "i64_not_found remove");
   return WASM_TEST_PASS;
 }
 
@@ -561,65 +579,65 @@ unsigned int test_db::key_i64_front_back() {
 
   my_memset(&tmp, 0, sizeof(test_model));
   res = front_i64( current_receiver(), current_receiver(), N(a), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == sizeof(test_model) && tmp.name == N(alice) && tmp.age == 20 && tmp.phone == 4234622, "key_i64_front 1");
+  eos_assert(res == sizeof(test_model) && tmp.name == N(alice) && tmp.age == 20 && tmp.phone == 4234622, "key_i64_front 1");
 
   my_memset(&tmp, 0, sizeof(test_model));
   res = back_i64( current_receiver(), current_receiver(), N(a), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == sizeof(test_model) && tmp.name == N(bob) && tmp.age == 15 && tmp.phone == 11932435, "key_i64_front 2");
+  eos_assert(res == sizeof(test_model) && tmp.name == N(bob) && tmp.age == 15 && tmp.phone == 11932435, "key_i64_front 2");
 
   my_memset(&tmp, 0, sizeof(test_model));
   res = front_i64( current_receiver(), current_receiver(), N(b), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == sizeof(test_model) && tmp.name == N(carol) && tmp.age == 30 && tmp.phone == 545342453, "key_i64_front 3");
+  eos_assert(res == sizeof(test_model) && tmp.name == N(carol) && tmp.age == 30 && tmp.phone == 545342453, "key_i64_front 3");
 
   my_memset(&tmp, 0, sizeof(test_model));
   res = back_i64( current_receiver(), current_receiver(), N(b), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == sizeof(test_model) && tmp.name == N(dave) && tmp.age == 46 && tmp.phone == 6535354, "key_i64_front 4");
+  eos_assert(res == sizeof(test_model) && tmp.name == N(dave) && tmp.age == 46 && tmp.phone == 6535354, "key_i64_front 4");
 
   uint64_t key = N(carol);
   remove_i64(current_receiver(), N(b), &key);
 
   my_memset(&tmp, 0, sizeof(test_model));
   res = front_i64( current_receiver(), current_receiver(), N(b), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == sizeof(test_model) && tmp.name == N(dave) && tmp.age == 46 && tmp.phone == 6535354, "key_i64_front 5");
+  eos_assert(res == sizeof(test_model) && tmp.name == N(dave) && tmp.age == 46 && tmp.phone == 6535354, "key_i64_front 5");
 
   my_memset(&tmp, 0, sizeof(test_model));
   res = back_i64( current_receiver(), current_receiver(), N(b), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == sizeof(test_model) && tmp.name == N(dave) && tmp.age == 46 && tmp.phone == 6535354, "key_i64_front 6");
+  eos_assert(res == sizeof(test_model) && tmp.name == N(dave) && tmp.age == 46 && tmp.phone == 6535354, "key_i64_front 6");
 
   my_memset(&tmp, 0, sizeof(test_model));
   res = front_i64( current_receiver(), current_receiver(), N(a), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == sizeof(test_model) && tmp.name == N(alice) && tmp.age == 20 && tmp.phone == 4234622, "key_i64_front 7");
+  eos_assert(res == sizeof(test_model) && tmp.name == N(alice) && tmp.age == 20 && tmp.phone == 4234622, "key_i64_front 7");
 
   my_memset(&tmp, 0, sizeof(test_model));
   res = back_i64( current_receiver(), current_receiver(), N(a), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == sizeof(test_model) && tmp.name == N(bob) && tmp.age == 15 && tmp.phone == 11932435, "key_i64_front 8");
+  eos_assert(res == sizeof(test_model) && tmp.name == N(bob) && tmp.age == 15 && tmp.phone == 11932435, "key_i64_front 8");
 
   key = N(dave);
   remove_i64(current_receiver(), N(b), &key);
   
   res = front_i64( current_receiver(), current_receiver(), N(b), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == -1, "key_i64_front 9");
+  eos_assert(res == -1, "key_i64_front 9");
   res = back_i64( current_receiver(), current_receiver(), N(b), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == -1, "key_i64_front 10");
+  eos_assert(res == -1, "key_i64_front 10");
 
   key = N(bob);
   remove_i64(current_receiver(), N(a), &key);
 
   my_memset(&tmp, 0, sizeof(test_model));
   res = front_i64( current_receiver(), current_receiver(), N(a), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == sizeof(test_model) && tmp.name == N(alice) && tmp.age == 20 && tmp.phone == 4234622, "key_i64_front 11");
+  eos_assert(res == sizeof(test_model) && tmp.name == N(alice) && tmp.age == 20 && tmp.phone == 4234622, "key_i64_front 11");
 
   my_memset(&tmp, 0, sizeof(test_model));
   res = back_i64( current_receiver(), current_receiver(), N(a), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == sizeof(test_model) && tmp.name == N(alice) && tmp.age == 20 && tmp.phone == 4234622, "key_i64_front 12");
+  eos_assert(res == sizeof(test_model) && tmp.name == N(alice) && tmp.age == 20 && tmp.phone == 4234622, "key_i64_front 12");
 
   key = N(alice);
   remove_i64(current_receiver(), N(a), &key);
 
   res = front_i64( current_receiver(), current_receiver(), N(a), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == -1, "key_i64_front 13");
+  eos_assert(res == -1, "key_i64_front 13");
   res = back_i64( current_receiver(), current_receiver(), N(a), &tmp, sizeof(test_model) );
-  WASM_ASSERT(res == -1, "key_i64_front 14");
+  eos_assert(res == -1, "key_i64_front 14");
 
   return WASM_TEST_PASS;
 }
@@ -635,16 +653,16 @@ unsigned int store_set_in_table(uint64_t table_name)
   TestModel128x2 alice22{2, 200, N(alice22), table_name};
 
   res = store_i128i128(current_receiver(),  table_name, &alice0,  sizeof(TestModel128x2));
-  WASM_ASSERT(res == 1, "store alice0" );
+  eos_assert(res == 1, "store alice0" );
 
   res = store_i128i128(current_receiver(),  table_name, &alice1,  sizeof(TestModel128x2));
-  WASM_ASSERT(res == 1, "store alice1" );
+  eos_assert(res == 1, "store alice1" );
 
   res = store_i128i128(current_receiver(),  table_name, &alice2,  sizeof(TestModel128x2));
-  WASM_ASSERT(res == 1, "store alice2" );
+  eos_assert(res == 1, "store alice2" );
 
   res = store_i128i128(current_receiver(),  table_name, &alice22,  sizeof(TestModel128x2));
-  WASM_ASSERT(res == 1, "store alice22" );
+  eos_assert(res == 1, "store alice22" );
 
   TestModel128x2 bob0{10, 1, N(bob0), table_name};
   TestModel128x2 bob1{11, 2, N(bob1), table_name};
@@ -652,16 +670,16 @@ unsigned int store_set_in_table(uint64_t table_name)
   TestModel128x2 bob3{13, 4, N(bob3), table_name};
 
   res = store_i128i128(current_receiver(),  table_name, &bob0,  sizeof(TestModel128x2));
-  WASM_ASSERT(res == 1, "store bob0" );
+  eos_assert(res == 1, "store bob0" );
 
   res = store_i128i128(current_receiver(),  table_name, &bob1,  sizeof(TestModel128x2));
-  WASM_ASSERT(res == 1, "store bob1" );
+  eos_assert(res == 1, "store bob1" );
 
   res = store_i128i128(current_receiver(),  table_name, &bob2,  sizeof(TestModel128x2));
-  WASM_ASSERT(res == 1, "store bob2" );
+  eos_assert(res == 1, "store bob2" );
 
   res = store_i128i128(current_receiver(),  table_name, &bob3,  sizeof(TestModel128x2));
-  WASM_ASSERT(res == 1, "store bob3" );
+  eos_assert(res == 1, "store bob3" );
 
   TestModel128x2 carol0{20, 900, N(carol0), table_name};
   TestModel128x2 carol1{21, 800, N(carol1), table_name};
@@ -669,16 +687,16 @@ unsigned int store_set_in_table(uint64_t table_name)
   TestModel128x2 carol3{23, 600, N(carol3), table_name};
 
   res = store_i128i128(current_receiver(),  table_name, &carol0,  sizeof(TestModel128x2));
-  WASM_ASSERT(res == 1, "store carol0" );
+  eos_assert(res == 1, "store carol0" );
 
   res = store_i128i128(current_receiver(),  table_name, &carol1,  sizeof(TestModel128x2));
-  WASM_ASSERT(res == 1, "store carol1" );
+  eos_assert(res == 1, "store carol1" );
 
   res = store_i128i128(current_receiver(),  table_name, &carol2,  sizeof(TestModel128x2));
-  WASM_ASSERT(res == 1, "store carol2" );
+  eos_assert(res == 1, "store carol2" );
 
   res = store_i128i128(current_receiver(),  table_name, &carol3,  sizeof(TestModel128x2));
-  WASM_ASSERT(res == 1, "store carol3" );
+  eos_assert(res == 1, "store carol3" );
 
   TestModel128x2 dave0{30, 8, N(dave0), table_name};
   TestModel128x2 dave1{31, 7, N(dave1), table_name};
@@ -686,16 +704,16 @@ unsigned int store_set_in_table(uint64_t table_name)
   TestModel128x2 dave3{33, 4, N(dave3), table_name};
 
   res = store_i128i128(current_receiver(),  table_name, &dave0,  sizeof(TestModel128x2));
-  WASM_ASSERT(res == 1, "store dave0" );
+  eos_assert(res == 1, "store dave0" );
 
   res = store_i128i128(current_receiver(),  table_name, &dave1,  sizeof(TestModel128x2));
-  WASM_ASSERT(res == 1, "store dave1" );
+  eos_assert(res == 1, "store dave1" );
 
   res = store_i128i128(current_receiver(),  table_name, &dave2,  sizeof(TestModel128x2));
-  WASM_ASSERT(res == 1, "store dave2" );
+  eos_assert(res == 1, "store dave2" );
 
   res = store_i128i128(current_receiver(),  table_name, &dave3,  sizeof(TestModel128x2));
-  WASM_ASSERT(res == 1, "store dave3" );
+  eos_assert(res == 1, "store dave3" );
 
   return WASM_TEST_PASS;
 }
@@ -706,11 +724,15 @@ unsigned int store_set_in_table(TestModel3xi64* records, int len, uint64_t table
     TestModel3xi64 *tmp = records+i;
     tmp->table = table_name;
     res = store_i64i64i64(current_receiver(),  table_name, tmp,  sizeof(TestModel3xi64));
-    WASM_ASSERT(res == 1, "store_set_in_table" );
+    eos_assert(res == 1, "store_set_in_table" );
   }
   return res;
 }
 
+#endif
+
+#if 0
+
 unsigned int test_db::key_i64i64i64_general() {
   
   uint32_t res = 0;
@@ -750,7 +772,7 @@ unsigned int test_db::key_i64i64i64_general() {
       eosio::print(msg, " : ", res, " a:", V.a, " b:", V.b, " c:", V.c, " t:", V.table, "inx:", uint64_t(I), " ("); \
       eosio::print(BS(res == sizeof(V)), " ", BS(records[I].a == V.a), " ", BS(records[I].b == V.b), " ", BS(records[I].c == V.c), " => ", N(table2), ")\n"); \
     } \
-    WASM_ASSERT( res == sizeof(V) && records[I].a == V.a && records[I].b == V.b && \
+    eos_assert( res == sizeof(V) && records[I].a == V.a && records[I].b == V.b && \
      records[I].c == V.c /*&& records[I].table == uint64_t(N(table2))*/, msg);
 
   #define LOAD_OK(I, O, T, INX, MSG) \
@@ -761,7 +783,7 @@ unsigned int test_db::key_i64i64i64_general() {
   #define LOAD_ER(I, O, T, MSG) \
     {eosio::remove_reference<decltype(V)>::type tmp; my_memset(&tmp, 0, sizeof(tmp));tmp = V; \
     res = LOAD(I, O, T, tmp); \
-    WASM_ASSERT(res == -1, MSG)}
+    eos_assert(res == -1, MSG)}
 
   #define FRONT_OK(I, O, T, INX, MSG) \
     {eosio::remove_reference<decltype(V)>::type tmp; my_memset(&tmp, 0, sizeof(tmp));tmp = V; \
@@ -812,7 +834,7 @@ unsigned int test_db::key_i64i64i64_general() {
       eosio::remove_reference<decltype(records[0])>::type tmp = records[I[j]]; \
       res = NEXT(I, i64i64i64, N(table2), tmp);\
       if(j+1<n){ TABLE1_ASSERT(I[j+1], tmp, "i64x3 NEXT " #I " ok "); } \
-      else { WASM_ASSERT(res == -1, "i64x3 NEXT " #I " fail "); }\
+      else { eos_assert(res == -1, "i64x3 NEXT " #I " fail "); }\
     } while(++j<n); \
   }
 
@@ -824,7 +846,7 @@ unsigned int test_db::key_i64i64i64_general() {
       eosio::remove_reference<decltype(records[0])>::type tmp = records[I[j]]; \
       res = PREV(I, i64i64i64, N(table2), tmp);\
       if(j>0){ TABLE1_ASSERT(I[j-1], tmp, "i64x3 PREV " #I " ok "); } \
-      else { WASM_ASSERT(res == -1, "i64x3 PREV " #I " fail "); }\
+      else { eos_assert(res == -1, "i64x3 PREV " #I " fail "); }\
     } while(--j>0); \
   }
 
@@ -866,7 +888,7 @@ unsigned int test_db::key_i64i64i64_general() {
     do { \
       eosio::remove_reference<decltype(records[0])>::type tmp = records[j]; \
       res = UPPER(I, i64i64i64, N(table2), tmp);\
-      if(res == -1) { WASM_ASSERT(I##_ub[j]==-1,"i64x3 UPPER " #I " fail ") } \
+      if(res == -1) { eos_assert(I##_ub[j]==-1,"i64x3 UPPER " #I " fail ") } \
       else { TABLE1_ASSERT(I##_ub[j], tmp, "i64x3 UPPER " #I " ok "); } \
     } while(++j<n); \
   }
@@ -879,21 +901,21 @@ unsigned int test_db::key_i64i64i64_general() {
   v2.a = records[6].a;
 
   res = LOAD(primary, i64i64i64, N(table2), v2);
-  WASM_ASSERT(res == sizeof(TestModel3xi64), "load v2");
+  eos_assert(res == sizeof(TestModel3xi64), "load v2");
 
   v2.new_field = 555;
 
   res = update_i64i64i64(current_receiver(),  N(table2), &v2, sizeof(TestModel3xi64_V2));
-  WASM_ASSERT(res == 1, "store v2");  
+  eos_assert(res == 1, "store v2");  
 
   res = LOAD(primary, i64i64i64, N(table2), v2);
-  WASM_ASSERT(res == sizeof(TestModel3xi64_V2), "load v2 updated");
+  eos_assert(res == sizeof(TestModel3xi64_V2), "load v2 updated");
 
   res = remove_i64i64i64(current_receiver(),  N(table2), &v2);
-  WASM_ASSERT(res == 1, "load v2 updated");
+  eos_assert(res == 1, "load v2 updated");
 
   res = LOAD(primary, i64i64i64, N(table2), v2);
-  WASM_ASSERT(res == -1, "load not found");
+  eos_assert(res == -1, "load not found");
 
   return WASM_TEST_PASS;
 }
@@ -917,7 +939,7 @@ unsigned int test_db::key_i128i128_general() {
 
   res = load_primary_i128i128( current_receiver(), current_receiver(), N(table5), &tmp, sizeof(TestModel128x2) );
 
-  WASM_ASSERT( res == sizeof(TestModel128x2) &&
+  eos_assert( res == sizeof(TestModel128x2) &&
                tmp.price == 800 &&
                tmp.extra == N(carol1) &&
                tmp.table_name == N(table5),
@@ -927,7 +949,7 @@ unsigned int test_db::key_i128i128_general() {
   tmp.price = 4;
   
   res = load_secondary_i128i128( current_receiver(), current_receiver(), N(table5), &tmp, sizeof(TestModel128x2) );
-  WASM_ASSERT( res == sizeof(TestModel128x2) &&
+  eos_assert( res == sizeof(TestModel128x2) &&
                tmp.number == 13 &&
                tmp.price == 4 &&
                tmp.extra == N(bob3) &&
@@ -935,7 +957,7 @@ unsigned int test_db::key_i128i128_general() {
               "bob3 secondary load");
 
   res = front_primary_i128i128( current_receiver(), current_receiver(), N(table5), &tmp, sizeof(TestModel128x2) );
-  WASM_ASSERT( res == sizeof(TestModel128x2) &&
+  eos_assert( res == sizeof(TestModel128x2) &&
                tmp.number == 0 &&
                tmp.price == 500 &&
                tmp.extra == N(alice0) &&
@@ -943,10 +965,10 @@ unsigned int test_db::key_i128i128_general() {
               "front primary load");
   
   res = previous_primary_i128i128( current_receiver(), current_receiver(), N(table5), &tmp, sizeof(TestModel128x2) );
-  WASM_ASSERT(res == -1, "previous primary fail");
+  eos_assert(res == -1, "previous primary fail");
 
   res = next_primary_i128i128( current_receiver(), current_receiver(), N(table5), &tmp, sizeof(TestModel128x2) );
-  WASM_ASSERT( res == sizeof(TestModel128x2) &&
+  eos_assert( res == sizeof(TestModel128x2) &&
                tmp.number == 1 &&
                tmp.price == 400 &&
                tmp.extra == N(alice1) &&
@@ -954,7 +976,7 @@ unsigned int test_db::key_i128i128_general() {
               "next primary ok");
 
   res = front_secondary_i128i128( current_receiver(), current_receiver(), N(table5), &tmp, sizeof(TestModel128x2) );
-  WASM_ASSERT( res == sizeof(TestModel128x2) &&
+  eos_assert( res == sizeof(TestModel128x2) &&
                tmp.number == 10 &&
                tmp.price == 1 &&
                tmp.extra == N(bob0) &&
@@ -962,10 +984,10 @@ unsigned int test_db::key_i128i128_general() {
               "front secondary ok");
   
   res = previous_secondary_i128i128( current_receiver(), current_receiver(), N(table5), &tmp, sizeof(TestModel128x2) );
-  WASM_ASSERT(res == -1, "previous secondary fail");
+  eos_assert(res == -1, "previous secondary fail");
 
   res = next_secondary_i128i128( current_receiver(), current_receiver(), N(table5), &tmp, sizeof(TestModel128x2) );
-  WASM_ASSERT( res == sizeof(TestModel128x2) &&
+  eos_assert( res == sizeof(TestModel128x2) &&
                tmp.number == 11 &&
                tmp.price == 2 &&
                tmp.extra == N(bob1) &&
@@ -973,7 +995,7 @@ unsigned int test_db::key_i128i128_general() {
               "next secondary ok");
 
   res = back_primary_i128i128( current_receiver(), current_receiver(), N(table5), &tmp, sizeof(TestModel128x2) );
-  WASM_ASSERT( res == sizeof(TestModel128x2) &&
+  eos_assert( res == sizeof(TestModel128x2) &&
                tmp.number == 33 &&
                tmp.price == 4 &&
                tmp.extra == N(dave3) &&
@@ -981,10 +1003,10 @@ unsigned int test_db::key_i128i128_general() {
               "back primary ok");
   
   res = next_primary_i128i128( current_receiver(), current_receiver(), N(table5), &tmp, sizeof(TestModel128x2) );
-  WASM_ASSERT(res == -1, "next primary fail");
+  eos_assert(res == -1, "next primary fail");
 
   res = previous_primary_i128i128( current_receiver(), current_receiver(), N(table5), &tmp, sizeof(TestModel128x2) );
-  WASM_ASSERT( res == sizeof(TestModel128x2) &&
+  eos_assert( res == sizeof(TestModel128x2) &&
                tmp.number == 32 &&
                tmp.price == 5 &&
                tmp.extra == N(dave2) &&
@@ -992,7 +1014,7 @@ unsigned int test_db::key_i128i128_general() {
               "previous primary ok");
 
   res = back_secondary_i128i128( current_receiver(), current_receiver(), N(table5), &tmp, sizeof(TestModel128x2) );
-  WASM_ASSERT( res == sizeof(TestModel128x2) &&
+  eos_assert( res == sizeof(TestModel128x2) &&
                tmp.number == 20 &&
                tmp.price == 900 &&
                tmp.extra == N(carol0) &&
@@ -1000,11 +1022,11 @@ unsigned int test_db::key_i128i128_general() {
               "back secondary ok");
   
   res = next_secondary_i128i128( current_receiver(), current_receiver(), N(table5), &tmp, sizeof(TestModel128x2) );
-  WASM_ASSERT(res == -1, "next secondary fail");
+  eos_assert(res == -1, "next secondary fail");
 
   res = previous_secondary_i128i128( current_receiver(), current_receiver(), N(table5), &tmp, sizeof(TestModel128x2) );
   
-  WASM_ASSERT( res == sizeof(TestModel128x2) &&
+  eos_assert( res == sizeof(TestModel128x2) &&
                tmp.number == 21 &&
                tmp.price == 800 &&
                tmp.extra == N(carol1) &&
@@ -1014,7 +1036,7 @@ unsigned int test_db::key_i128i128_general() {
   tmp.number = 1;
 
   res = lower_bound_primary_i128i128( current_receiver(), current_receiver(), N(table5), &tmp, sizeof(TestModel128x2) );
-  WASM_ASSERT( res == sizeof(TestModel128x2) &&
+  eos_assert( res == sizeof(TestModel128x2) &&
                tmp.number == 1 &&
                tmp.price == 400 &&
                tmp.extra == N(alice1) &&
@@ -1022,7 +1044,7 @@ unsigned int test_db::key_i128i128_general() {
               "lb primary ok");
 
   res = upper_bound_primary_i128i128( current_receiver(), current_receiver(), N(table5), &tmp, sizeof(TestModel128x2) );
-  WASM_ASSERT( res == sizeof(TestModel128x2) &&
+  eos_assert( res == sizeof(TestModel128x2) &&
                tmp.number == 2 &&
                tmp.price == 200 &&
                tmp.extra == N(alice22) &&
@@ -1032,7 +1054,7 @@ unsigned int test_db::key_i128i128_general() {
   tmp.price = 800;
 
   res = lower_bound_secondary_i128i128( current_receiver(), current_receiver(), N(table5), &tmp, sizeof(TestModel128x2) );
-  WASM_ASSERT( res == sizeof(TestModel128x2) &&
+  eos_assert( res == sizeof(TestModel128x2) &&
                tmp.number == 21 &&
                tmp.price == 800 &&
                tmp.extra == N(carol1) &&
@@ -1043,7 +1065,7 @@ unsigned int test_db::key_i128i128_general() {
   tmp2.price = 800;
 
   res = upper_bound_secondary_i128i128( current_receiver(), current_receiver(), N(table5), &tmp2, sizeof(TestModel128x2_V2) );
-  WASM_ASSERT( res == sizeof(TestModel128x2) &&
+  eos_assert( res == sizeof(TestModel128x2) &&
                tmp2.number == 20 &&
                tmp2.price == 900 &&
                tmp2.extra == N(carol0) &&
@@ -1052,13 +1074,13 @@ unsigned int test_db::key_i128i128_general() {
   
   tmp2.new_field = 123456;
   res = update_i128i128(current_receiver(), N(table5), &tmp2, sizeof(TestModel128x2_V2));
-  WASM_ASSERT( res == 1, "update_i128i128 ok");
+  eos_assert( res == 1, "update_i128i128 ok");
 
   my_memset(&tmp2, 0, sizeof(TestModel128x2_V2));
   tmp2.number = 20;
 
   res = load_primary_i128i128(current_receiver(), current_receiver(), N(table5), &tmp2, sizeof(TestModel128x2_V2));
-  WASM_ASSERT( res == sizeof(TestModel128x2_V2) &&
+  eos_assert( res == sizeof(TestModel128x2_V2) &&
                tmp2.number == 20 &&
                tmp2.price == 900 &&
                tmp2.extra == N(carol0) &&
@@ -1068,10 +1090,10 @@ unsigned int test_db::key_i128i128_general() {
 
   tmp2.extra = N(xxxxx);
   res = update_i128i128(current_receiver(), N(table5), &tmp2, sizeof(uint128_t)*2+sizeof(uint64_t));
-  WASM_ASSERT( res == 1, "update_i128i128 small ok");
+  eos_assert( res == 1, "update_i128i128 small ok");
 
   res = load_primary_i128i128(current_receiver(), current_receiver(), N(table5), &tmp2, sizeof(TestModel128x2_V2));
-  WASM_ASSERT( res == sizeof(TestModel128x2_V2) &&
+  eos_assert( res == sizeof(TestModel128x2_V2) &&
                tmp2.number == 20 &&
                tmp2.price == 900 &&
                tmp2.extra == N(xxxxx) &&
@@ -1082,6 +1104,10 @@ unsigned int test_db::key_i128i128_general() {
   return WASM_TEST_PASS;
 }
 
+#endif
+
+#if 0
+
 void set_key_str(int i, char* key_4_digit)
 {
    const char nums[] = "0123456789";
@@ -1518,3 +1544,355 @@ unsigned int test_db::key_i64i64i64_another_under_limit()
 
    return WASM_TEST_PASS;
 }
+
+#endif
+
+void test_db::primary_i64_general()
+{
+   auto table1 = N(table1);
+
+   int alice_itr = db_store_i64(current_receiver(), table1, current_receiver(), N(alice), "alice's info", strlen("alice's info"));
+   db_store_i64(current_receiver(), table1, current_receiver(), N(bob), "bob's info", strlen("bob's info"));
+   db_store_i64(current_receiver(), table1, current_receiver(), N(charlie), "charlie's info", strlen("charlies's info"));
+   db_store_i64(current_receiver(), table1, current_receiver(), N(allyson), "allyson's info", strlen("allyson's info"));
+
+
+   // find
+   {
+      uint64_t prim = 0;
+      int itr_next = db_next_i64(alice_itr, &prim);
+      int itr_next_expected = db_find_i64(current_receiver(), current_receiver(), table1, N(allyson));
+      eosio_assert(itr_next == itr_next_expected && prim == N(allyson), "primary_i64_general - db_find_i64" );
+      itr_next = db_next_i64(itr_next, &prim);
+      itr_next_expected = db_find_i64(current_receiver(), current_receiver(), table1, N(bob));
+      eosio_assert(itr_next == itr_next_expected && prim == N(bob), "primary_i64_general - db_next_i64");
+   }
+
+   // next
+   {
+      int charlie_itr = db_find_i64(current_receiver(), current_receiver(), table1, N(charlie));
+      // nothing after charlie
+      uint64_t prim = 0;
+      int end_itr = db_next_i64(charlie_itr, &prim);
+      eosio_assert(end_itr == -1, "primary_i64_general - db_next_i64");
+      // prim didn't change
+      eosio_assert(prim == 0, "primary_i64_general - db_next_i64");
+   }
+
+   // previous
+   {
+      int charlie_itr = db_find_i64(current_receiver(), current_receiver(), table1, N(charlie));
+      uint64_t prim = 0;
+      int itr_prev = db_previous_i64(charlie_itr, &prim);
+      int itr_prev_expected = db_find_i64(current_receiver(), current_receiver(), table1, N(bob));
+      eosio_assert(itr_prev == itr_prev_expected && prim == N(bob), "primary_i64_general - db_previous_i64");
+
+      itr_prev = db_previous_i64(itr_prev, &prim);
+      itr_prev_expected = db_find_i64(current_receiver(), current_receiver(), table1, N(allyson));
+      eosio_assert(itr_prev == itr_prev_expected && prim == N(allyson), "primary_i64_general - db_previous_i64");
+
+      itr_prev = db_previous_i64(itr_prev, &prim);
+      itr_prev_expected = db_find_i64(current_receiver(), current_receiver(), table1, N(alice));
+      eosio_assert(itr_prev == itr_prev_expected && prim == N(alice), "primary_i64_general - db_previous_i64");
+
+      itr_prev = db_previous_i64(itr_prev, &prim);
+      itr_prev_expected = -1;
+      eosio_assert(itr_prev == itr_prev_expected && prim == N(alice), "primary_i64_general - db_previous_i64");
+   }
+
+   // remove
+   {
+      int itr = db_find_i64(current_receiver(), current_receiver(), table1, N(alice));
+      eosio_assert(itr != -1, "primary_i64_general - db_find_i64");
+      db_remove_i64(itr);
+      itr = db_find_i64(current_receiver(), current_receiver(), table1, N(alice));
+      eosio_assert(itr == -1, "primary_i64_general - db_find_i64");
+   }
+
+   // get
+   {
+      int itr = db_find_i64(current_receiver(), current_receiver(), table1, N(bob));
+      eosio_assert(itr != -1, "");
+      int buffer_len = 5;
+      char value[50];
+      auto len = db_get_i64(itr, value, buffer_len);
+      value[buffer_len] = '\0';
+      std::string s(value);
+      eosio_assert(len == strlen("bob's info"), "primary_i64_general - db_get_i64");
+      eosio_assert(s == "bob's", "primary_i64_general - db_get_i64");
+      
+      buffer_len = 20;
+      db_get_i64(itr, value, buffer_len);
+      value[buffer_len] = '\0';
+      std::string sfull(value);
+      eosio_assert(sfull == "bob's info", "primary_i64_general - db_get_i64");
+   }
+
+   // update
+   {
+      int itr = db_find_i64(current_receiver(), current_receiver(), table1, N(bob));
+      eosio_assert(itr != -1, "");
+      const char* new_value = "bob's new info";
+      int new_value_len = strlen(new_value); 
+      db_update_i64(itr, current_receiver(), new_value, new_value_len);
+      char ret_value[50];
+      auto len = db_get_i64(itr, ret_value, new_value_len);
+      ret_value[new_value_len] = '\0';
+      std::string sret(ret_value);
+      eosio_assert(sret == "bob's new info", "primary_i64_general - db_update_i64");
+   }
+}
+
+void test_db::primary_i64_lowerbound()
+{
+   auto table = N(mytable);
+   db_store_i64(current_receiver(), table, current_receiver(), N(alice), "alice's info", strlen("alice's info"));
+   db_store_i64(current_receiver(), table, current_receiver(), N(bob), "bob's info", strlen("bob's info"));
+   db_store_i64(current_receiver(), table, current_receiver(), N(charlie), "charlie's info", strlen("charlies's info"));
+   db_store_i64(current_receiver(), table, current_receiver(), N(emily), "emily's info", strlen("emily's info"));
+   db_store_i64(current_receiver(), table, current_receiver(), N(allyson), "allyson's info", strlen("allyson's info"));
+   db_store_i64(current_receiver(), table, current_receiver(), N(joe), "nothing here", strlen("nothing here"));
+
+   const std::string err = "primary_i64_lowerbound";
+
+   {
+      int lb = db_lowerbound_i64(current_receiver(), current_receiver(), table, N(alice));
+      eosio_assert(lb == db_find_i64(current_receiver(), current_receiver(), table, N(alice)), err.c_str());
+   }
+   {
+      int lb = db_lowerbound_i64(current_receiver(), current_receiver(), table, N(billy));
+      eosio_assert(lb == db_find_i64(current_receiver(), current_receiver(), table, N(bob)), err.c_str());
+   }
+   {
+      int lb = db_lowerbound_i64(current_receiver(), current_receiver(), table, N(frank));
+      eosio_assert(lb == db_find_i64(current_receiver(), current_receiver(), table, N(joe)), err.c_str());
+   }
+   {
+      int lb = db_lowerbound_i64(current_receiver(), current_receiver(), table, N(joe));
+      eosio_assert(lb == db_find_i64(current_receiver(), current_receiver(), table, N(joe)), err.c_str());
+   }
+   {
+      int lb = db_lowerbound_i64(current_receiver(), current_receiver(), table, N(kevin));
+      eosio_assert(lb == -1, err.c_str());
+   }
+}
+
+void test_db::primary_i64_upperbound()
+{
+   auto table = N(mytable);
+   const std::string err = "primary_i64_upperbound";
+   {
+      int ub = db_upperbound_i64(current_receiver(), current_receiver(), table, N(alice));
+      eosio_assert(ub == db_find_i64(current_receiver(), current_receiver(), table, N(allyson)), err.c_str());
+   }
+   {
+      int ub = db_upperbound_i64(current_receiver(), current_receiver(), table, N(billy));
+      eosio_assert(ub == db_find_i64(current_receiver(), current_receiver(), table, N(bob)), err.c_str());
+   }
+   {
+      int ub = db_upperbound_i64(current_receiver(), current_receiver(), table, N(frank));
+      eosio_assert(ub == db_find_i64(current_receiver(), current_receiver(), table, N(joe)), err.c_str());
+   }
+   {
+      int ub = db_upperbound_i64(current_receiver(), current_receiver(), table, N(joe));
+      eosio_assert(ub == -1, err.c_str());
+   }
+   {
+      int ub = db_upperbound_i64(current_receiver(), current_receiver(), table, N(kevin));
+      eosio_assert(ub == -1, err.c_str());
+   }
+}
+
+void test_db::idx64_general()
+{
+   const auto table = N(myindextable);
+
+   typedef uint64_t secondary_type;
+
+   struct record {
+      uint64_t ssn;
+      secondary_type name;
+   };
+
+   record records[] = {{265, N(alice)},
+                       {781, N(bob)},
+                       {234, N(charlie)},
+                       {650, N(allyson)},
+                       {540, N(bob)},
+                       {976, N(emily)},
+                       {110, N(joe)}
+   };
+
+   for (int i = 0; i < sizeof(records)/sizeof(records[0]); ++i) {
+      db_idx64_store(current_receiver(), table, current_receiver(), records[i].ssn, &records[i].name);
+   }
+
+   // find_primary
+   {
+      secondary_type sec = 0;
+      int itr = db_idx64_find_primary(current_receiver(), current_receiver(), table, &sec, 999);
+      eosio_assert(itr == -1 && sec == 0, "idx64_general - db_idx64_find_primary");
+      itr = db_idx64_find_primary(current_receiver(), current_receiver(), table, &sec, 110);
+      eosio_assert(itr != -1 && sec == N(joe), "idx64_general - db_idx64_find_primary");
+      uint64_t prim_next = 0;
+      int itr_next = db_idx64_next(itr, &prim_next);
+      eosio_assert(itr_next == -1 && prim_next == 0, "idx64_general - db_idx64_find_primary");
+   }
+
+   // iterate forward starting with charlie
+   {
+      secondary_type sec = 0;
+      int itr = db_idx64_find_primary(current_receiver(), current_receiver(), table, &sec, 234);
+      eosio_assert(itr != -1 && sec == N(charlie), "idx64_general - db_idx64_find_primary");
+
+      uint64_t prim_next = 0;
+      int itr_next = db_idx64_next(itr, &prim_next);
+      eosio_assert(itr_next != -1 && prim_next == 976, "idx64_general - db_idx64_next");
+      secondary_type sec_next = 0;
+      int itr_next_expected = db_idx64_find_primary(current_receiver(), current_receiver(), table, &sec_next, prim_next);
+      eosio_assert(itr_next == itr_next_expected && sec_next == N(emily), "idx64_general - db_idx64_next");
+
+      itr_next = db_idx64_next(itr_next, &prim_next);
+      eosio_assert(itr_next != -1 && prim_next == 110, "idx64_general - db_idx64_next");
+      itr_next_expected = db_idx64_find_primary(current_receiver(), current_receiver(), table, &sec_next, prim_next);
+      eosio_assert(itr_next == itr_next_expected && sec_next == N(joe), "idx64_general - db_idx64_next");
+
+      itr_next = db_idx64_next(itr_next, &prim_next);
+      eosio_assert(itr_next == -1 && prim_next == 110, "idx64_general - db_idx64_next");
+   }
+
+   // iterate backward staring with second bob
+   {
+      secondary_type sec = 0;
+      int itr = db_idx64_find_primary(current_receiver(), current_receiver(), table, &sec, 781);
+      eosio_assert(itr != -1 && sec == N(bob), "idx64_general - db_idx64_find_primary");
+
+      uint64_t prim_prev = 0;
+      int itr_prev = db_idx64_previous(itr, &prim_prev);
+      eosio_assert(itr_prev != -1 && prim_prev == 540, "idx64_general - db_idx64_previous");
+
+      secondary_type sec_prev = 0;
+      int itr_prev_expected = db_idx64_find_primary(current_receiver(), current_receiver(), table, &sec_prev, prim_prev);
+      eosio_assert(itr_prev == itr_prev_expected && sec_prev == N(bob), "idx64_general - db_idx64_previous");
+
+      itr_prev = db_idx64_previous(itr_prev, &prim_prev);
+      eosio_assert(itr_prev != -1 && prim_prev == 650, "idx64_general - db_idx64_previous");
+      itr_prev_expected = db_idx64_find_primary(current_receiver(), current_receiver(), table, &sec_prev, prim_prev);
+      eosio_assert(itr_prev == itr_prev_expected && sec_prev == N(allyson), "idx64_general - db_idx64_previous");
+
+      itr_prev = db_idx64_previous(itr_prev, &prim_prev);
+      eosio_assert(itr_prev != -1 && prim_prev == 265, "idx64_general - db_idx64_previous");
+      itr_prev_expected = db_idx64_find_primary(current_receiver(), current_receiver(), table, &sec_prev, prim_prev);
+      eosio_assert(itr_prev == itr_prev_expected && sec_prev == N(alice), "idx64_general - db_idx64_previous");
+
+      itr_prev = db_idx64_previous(itr_prev, &prim_prev);
+      eosio_assert(itr_prev == -1 && prim_prev == 265, "idx64_general - db_idx64_previous");
+   }
+
+   // find_secondary
+   {
+      uint64_t prim = 0;
+      auto sec = N(bob);
+      int itr = db_idx64_find_secondary(current_receiver(), current_receiver(), table, &sec, &prim);
+      eosio_assert(itr != -1 && prim == 540, "idx64_general - db_idx64_find_secondary");
+
+      sec = N(emily);
+      itr = db_idx64_find_secondary(current_receiver(), current_receiver(), table, &sec, &prim);
+      eosio_assert(itr != -1 && prim == 976, "idx64_general - db_idx64_find_secondary");
+
+      sec = N(frank);
+      itr = db_idx64_find_secondary(current_receiver(), current_receiver(), table, &sec, &prim);
+      eosio_assert(itr == -1 && prim == 976, "idx64_general - db_idx64_find_secondary");
+   }
+
+   // update and remove
+   {
+      auto one_more_bob = N(bob);
+      const uint64_t ssn = 421;
+      int itr = db_idx64_store(current_receiver(), table, current_receiver(), ssn, &one_more_bob);
+      auto new_name = N(billy);
+      db_idx64_update(itr, current_receiver(), &new_name);
+      secondary_type sec = 0;
+      int sec_itr = db_idx64_find_primary(current_receiver(), current_receiver(), table, &sec, ssn);
+      eosio_assert(sec_itr == itr && sec == new_name, "idx64_general - db_idx64_update");
+      db_idx64_remove(itr);
+      int itrf = db_idx64_find_primary(current_receiver(), current_receiver(), table, &sec, ssn);
+      eosio_assert(itrf == -1, "idx64_general - db_idx64_remove");
+   }
+}
+
+void test_db::idx64_lowerbound()
+{
+   const auto table = N(myindextable);
+   typedef uint64_t secondary_type;
+   const std::string err = "idx64_lowerbound";
+   {
+      secondary_type lb_sec = N(alice);
+      uint64_t lb_prim = 0;
+      const uint64_t ssn = 265;
+      int lb = db_idx64_lowerbound(current_receiver(), current_receiver(), table, &lb_sec, &lb_prim);
+      eosio_assert(lb_prim == ssn && lb_sec == N(alice), err.c_str());
+      eosio_assert(lb == db_idx64_find_primary(current_receiver(), current_receiver(), table, &lb_sec, ssn), err.c_str());
+   }
+   {
+      secondary_type lb_sec = N(billy);
+      uint64_t lb_prim = 0;
+      const uint64_t ssn = 540;
+      int lb = db_idx64_lowerbound(current_receiver(), current_receiver(), table, &lb_sec, &lb_prim);
+      eosio_assert(lb_prim == ssn && lb_sec == N(bob), err.c_str());
+      eosio_assert(lb == db_idx64_find_primary(current_receiver(), current_receiver(), table, &lb_sec, ssn), err.c_str());
+   }
+   {
+      secondary_type lb_sec = N(joe);
+      uint64_t lb_prim = 0;
+      const uint64_t ssn = 110;
+      int lb = db_idx64_lowerbound(current_receiver(), current_receiver(), table, &lb_sec, &lb_prim);
+      eosio_assert(lb_prim == ssn && lb_sec == N(joe), err.c_str());
+      eosio_assert(lb == db_idx64_find_primary(current_receiver(), current_receiver(), table, &lb_sec, ssn), err.c_str());
+   }
+   {
+      secondary_type lb_sec = N(kevin);
+      uint64_t lb_prim = 0;
+      int lb = db_idx64_lowerbound(current_receiver(), current_receiver(), table, &lb_sec, &lb_prim);
+      eosio_assert(lb_prim == 0 && lb_sec == N(kevin), err.c_str());
+      eosio_assert(lb == -1, "");
+   }
+}
+
+void test_db::idx64_upperbound()
+{
+   const auto table = N(myindextable);
+   typedef uint64_t secondary_type;
+   const std::string err = "idx64_upperbound";
+   {
+      secondary_type ub_sec = N(alice);
+      uint64_t ub_prim = 0;
+      const uint64_t alice_ssn = 265, allyson_ssn = 650;
+      int ub = db_idx64_upperbound(current_receiver(), current_receiver(), table, &ub_sec, &ub_prim);
+      eosio_assert(ub_prim == allyson_ssn && ub_sec == N(allyson), "");
+      eosio_assert(ub == db_idx64_find_primary(current_receiver(), current_receiver(), table, &ub_sec, allyson_ssn), err.c_str());
+   }
+   {
+      secondary_type ub_sec = N(billy);
+      uint64_t ub_prim = 0;
+      const uint64_t bob_ssn = 540;
+      int ub = db_idx64_upperbound(current_receiver(), current_receiver(), table, &ub_sec, &ub_prim);
+      eosio_assert(ub_prim == bob_ssn && ub_sec == N(bob), "");
+      eosio_assert(ub == db_idx64_find_primary(current_receiver(), current_receiver(), table, &ub_sec, bob_ssn), err.c_str());
+   }
+   {
+      secondary_type ub_sec = N(joe);
+      uint64_t ub_prim = 0;
+      const uint64_t ssn = 110;
+      int ub = db_idx64_upperbound(current_receiver(), current_receiver(), table, &ub_sec, &ub_prim);
+      eosio_assert(ub_prim == 0 && ub_sec == N(joe), err.c_str());
+      eosio_assert(ub == -1, err.c_str());
+   }
+   {
+      secondary_type ub_sec = N(kevin);
+      uint64_t ub_prim = 0;
+      int ub = db_idx64_upperbound(current_receiver(), current_receiver(), table, &ub_sec, &ub_prim);
+      eosio_assert(ub_prim == 0 && ub_sec == N(kevin), err.c_str());
+      eosio_assert(ub == -1, err.c_str());
+   }
+}
diff --git a/libraries/appbase b/libraries/appbase
index a0cf75ad7c39137ebf03b0f3b0b4e5b7f731296b..ef2b0c8d64f770d80ce537ec04d0de4bdc4d3585 160000
--- a/libraries/appbase
+++ b/libraries/appbase
@@ -1 +1 @@
-Subproject commit a0cf75ad7c39137ebf03b0f3b0b4e5b7f731296b
+Subproject commit ef2b0c8d64f770d80ce537ec04d0de4bdc4d3585
diff --git a/libraries/chain/apply_context.cpp b/libraries/chain/apply_context.cpp
index 149e7939cf8d7bdeeda1a36f567961d3defba0fd..244484a53fac0fbc2e46e221ff3bbc8aa925b747 100644
--- a/libraries/chain/apply_context.cpp
+++ b/libraries/chain/apply_context.cpp
@@ -370,8 +370,7 @@ void apply_context::db_remove_i64( int iterator ) {
 
 int apply_context::db_get_i64( int iterator, char* buffer, size_t buffer_size ) {
    const key_value_object& obj = keyval_cache.get( iterator );
-   if( buffer_size >= obj.value.size() )
-      memcpy( buffer, obj.value.data(), obj.value.size() );
+   memcpy( buffer, obj.value.data(), std::min(obj.value.size(), buffer_size) );
    
    return obj.value.size();
 }
diff --git a/libraries/chain/include/eosio/chain/apply_context.hpp b/libraries/chain/include/eosio/chain/apply_context.hpp
index 51724a4fc800ac998e066e949933a3d7b8809db8..b7d2f935e691a74dd1e537ee2a5864b09aad943f 100644
--- a/libraries/chain/include/eosio/chain/apply_context.hpp
+++ b/libraries/chain/include/eosio/chain/apply_context.hpp
@@ -134,7 +134,7 @@ class apply_context {
                });
             }
 
-            int find_secondary( uint64_t code, uint64_t scope, uint64_t table, secondary_key_type& secondary, uint64_t& primary ) {
+            int find_secondary( uint64_t code, uint64_t scope, uint64_t table, const secondary_key_type& secondary, uint64_t& primary ) {
                auto tab = context.find_table( context.receiver, scope, table );
                if( !tab ) return -1;
 
@@ -142,7 +142,6 @@ class apply_context {
                if( !obj ) return -1;
 
                primary = obj->primary_key;
-               secondary = obj->secondary_key;
 
                itr_cache.cache_table( *tab );
                return itr_cache.add( *obj );
@@ -209,7 +208,6 @@ class apply_context {
                primary = itr->primary_key;
                return itr_cache.add(*itr);
             }
-
             
 
             int find_primary( uint64_t code, uint64_t scope, uint64_t table, secondary_key_type& secondary, uint64_t primary ) {
diff --git a/libraries/chain/wasm_interface.cpp b/libraries/chain/wasm_interface.cpp
index 54c472ae30c4688f5662fc357c69a468dead9c9b..5c15db4806d79f02e660dcc69769ed8767652697 100644
--- a/libraries/chain/wasm_interface.cpp
+++ b/libraries/chain/wasm_interface.cpp
@@ -715,7 +715,7 @@ class database_api : public context_aware_api {
          return context.db_lowerbound_i64( code, scope, table, id ); 
       }
       int db_upperbound_i64( uint64_t code, uint64_t scope, uint64_t table, uint64_t id ) { 
-         return context.db_lowerbound_i64( code, scope, table, id ); 
+         return context.db_upperbound_i64( code, scope, table, id ); 
       }
 
       int db_idx64_store( uint64_t scope, uint64_t table, uint64_t payer, uint64_t id, const uint64_t& secondary ) {
@@ -727,13 +727,12 @@ class database_api : public context_aware_api {
       void db_idx64_remove( int iterator ) {
          return context.idx64.remove( iterator );
       }
-      int db_idx64_find_secondary( uint64_t code, uint64_t scope, uint64_t table, uint64_t& secondary, uint64_t& primary ) {
+      int db_idx64_find_secondary( uint64_t code, uint64_t scope, uint64_t table, const uint64_t& secondary, uint64_t& primary ) {
          return context.idx64.find_secondary(code, scope, table, secondary, primary);
       }
       int db_idx64_find_primary( uint64_t code, uint64_t scope, uint64_t table, uint64_t& secondary, uint64_t primary ) {
-         return context.idx64.find_secondary(code, scope, table, secondary, primary);
+         return context.idx64.find_primary(code, scope, table, secondary, primary);
       }
-
       int db_idx64_lowerbound( uint64_t code, uint64_t scope, uint64_t table,  uint64_t& secondary, uint64_t& primary ) {
          return context.idx64.lowerbound_secondary(code, scope, table, secondary, primary);
       }
@@ -747,22 +746,6 @@ class database_api : public context_aware_api {
          return context.idx64.previous_secondary(iterator, primary);
       }
 
-      /*
-      int db_idx64_next( int iterator, uint64_t& primary ) {
-      }
-      int db_idx64_prev( int iterator, uint64_t& primary ) {
-      }
-      int db_idx64_find_primary( uint64_t code, uint64_t scope, uint64_t table, uint64_t& secondary, uint64_t primary ) {
-      }
-      int db_idx64_find_secondary( uint64_t code, uint64_t scope, uint64_t table, uint64_t& secondary, uint64_t& primary ) {
-      }
-      int db_idx64_lowerbound( uint64_t code, uint64_t scope, uint64_t table, uint64_t& secondary, uint64_t& primary ) {
-      }
-      int db_idx64_upperbound( uint64_t code, uint64_t scope, uint64_t table, uint64_t& secondary, uint64_t& primary ) {
-      }
-      */
-
-
       int db_idx128_store( uint64_t scope, uint64_t table, uint64_t payer, uint64_t id, const uint128_t& secondary ) {
          return context.idx128.store( scope, table, payer, id, secondary );
       }
@@ -775,7 +758,7 @@ class database_api : public context_aware_api {
       int db_idx128_find_primary( uint64_t code, uint64_t scope, uint64_t table, uint128_t& secondary, uint64_t primary ) {
          return context.idx128.find_primary( code, scope, table, secondary, primary );
       }
-      int db_idx128_find_secondary( uint64_t code, uint64_t scope, uint64_t table, uint128_t& secondary, uint64_t& primary ) {
+      int db_idx128_find_secondary( uint64_t code, uint64_t scope, uint64_t table, const uint128_t& secondary, uint64_t& primary ) {
          return context.idx128.find_secondary(code, scope, table, secondary, primary);
       }
       int db_idx128_lowerbound( uint64_t code, uint64_t scope, uint64_t table, uint128_t& secondary, uint64_t& primary ) {
diff --git a/libraries/chainbase b/libraries/chainbase
index d48ebabf56b4115753fcabb7648a0ffcf3b0f5e9..664fdd9e79263a894794f96959612ec2d1d013d0 160000
--- a/libraries/chainbase
+++ b/libraries/chainbase
@@ -1 +1 @@
-Subproject commit d48ebabf56b4115753fcabb7648a0ffcf3b0f5e9
+Subproject commit 664fdd9e79263a894794f96959612ec2d1d013d0
diff --git a/programs/eosioc/main.cpp b/programs/eosioc/main.cpp
index aea76e51c31afb6854174c4af98217b9445165cd..83760e9539cf460adbe48b0ff0bc1aec9867504e 100644
--- a/programs/eosioc/main.cpp
+++ b/programs/eosioc/main.cpp
@@ -54,8 +54,8 @@ Usage: ./eosc create account [OPTIONS] creator name OwnerKey ActiveKey
 Positionals:
   creator TEXT                The name of the account creating the new account
   name TEXT                   The name of the new account
-  OwnerKey TEXT               The owner public key for the account
-  ActiveKey TEXT              The active public key for the account
+  OwnerKey TEXT               The owner public key for the new account
+  ActiveKey TEXT              The active public key for the new account
 
 Options:
   -s,--skip-signature         Specify that unlocked wallet keys should not be used to sign transaction
@@ -489,8 +489,8 @@ int main( int argc, char** argv ) {
    auto createAccount = create->add_subcommand("account", localized("Create a new account on the blockchain"), false);
    createAccount->add_option("creator", creator, localized("The name of the account creating the new account"))->required();
    createAccount->add_option("name", account_name, localized("The name of the new account"))->required();
-   createAccount->add_option("OwnerKey", owner_key_str, localized("The owner public key for the account"))->required();
-   createAccount->add_option("ActiveKey", active_key_str, localized("The active public key for the account"))->required();
+   createAccount->add_option("OwnerKey", owner_key_str, localized("The owner public key for the new account"))->required();
+   createAccount->add_option("ActiveKey", active_key_str, localized("The active public key for the new account"))->required();
    createAccount->add_flag("-s,--skip-signature", skip_sign, localized("Specify that unlocked wallet keys should not be used to sign transaction"));
    add_standard_transaction_options(createAccount);
    createAccount->set_callback([&] {
diff --git a/scripts/eosio_build_darwin.sh b/scripts/eosio_build_darwin.sh
index 5e0418ee03684961d21b10dc2aff3dda3c1faed2..e0d14dac710e6239dda5af7d1b885296a2b38a37 100644
--- a/scripts/eosio_build_darwin.sh
+++ b/scripts/eosio_build_darwin.sh
@@ -165,13 +165,13 @@
 			exit;
 		fi
 		./configure
-		make
+		make -j${CPU_CORE}
 		if [ $? -ne 0 ]; then
 			printf "\tError compiling secp256k1-zkp.\n"
 			printf "\tExiting now.\n\n"
 			exit;
 		fi
-		sudo make install
+		sudo make -j${CPU_CORE} install
 		sudo rm -rf ${TEMP_DIR}/secp256k1-zkp
 	else
 		printf "\tsecp256k1 found at /usr/local/lib/\n"
@@ -183,7 +183,7 @@
 		git clone https://github.com/WebAssembly/binaryen
 		cd binaryen
 		git checkout tags/1.37.14
-		cmake . && make
+		cmake . && make -j${CPU_CORE}
 		if [ $? -ne 0 ]; then
 			printf "\tError compiling binaryen.\n"
 			printf "\tExiting now.\n\n"
@@ -217,7 +217,7 @@
 			printf "\tExiting now.\n\n"
 			exit;
 		fi
-		sudo make -j4 install
+		sudo make -j${CPU_CORE} install
 		sudo rm -rf ${TEMP_DIR}/wasm-compiler
 	else
 		printf "\tWASM found at /usr/local/wasm/bin/\n"
diff --git a/scripts/eosio_build_fedora.sh b/scripts/eosio_build_fedora.sh
index 32046df17b13afff6851b09faee250cd4b61e638..f0fbade737ed41d18cbd0638fb2ab5355ddd7e86 100644
--- a/scripts/eosio_build_fedora.sh
+++ b/scripts/eosio_build_fedora.sh
@@ -112,7 +112,7 @@
 		tar xf boost_1.66.0.tar.bz2
 		cd boost_1_66_0/
 		./bootstrap.sh "--prefix=$BOOST_ROOT"
-		./b2 install
+		./b2 -j${CPU_CORE} install
 		rm -rf ${TEMP_DIR}/boost_1_66_0/
 		rm -f  ${TEMP_DIR}/boost_1.66.0.tar.bz2
 	else
@@ -133,13 +133,13 @@
 			exit;
 		fi
 		./configure
-		make
+		make -j${CPU_CORE}
 		if [ $? -ne 0 ]; then
 			printf "\tError compiling secp256k1-zkp.\n"
 			printf "\tExiting now.\n\n"
 			exit;
 		fi
-		sudo make install
+		sudo make -j${CPU_CORE} install
 		rm -rf cd ${TEMP_DIR}/secp256k1-zkp
 	else
 		printf "\tsecp256k1 found\n"
@@ -153,7 +153,7 @@
 		git clone https://github.com/WebAssembly/binaryen
 		cd binaryen
 		git checkout tags/1.37.14
-		cmake . && make
+		cmake . && make -j${CPU_CORE}
 		if [ $? -ne 0 ]; then
 			printf "\tError compiling binaryen.\n"
 			printf "\tExiting now.\n\n"
@@ -185,13 +185,13 @@
 			printf "\tExiting now.\n\n"
 			exit;
 		fi
-		make -j$(nproc)
+		make -j${CPU_CORE}
 		if [ $? -ne 0 ]; then
 			printf "\tError compiling LLVM and clang with EXPERIMENTAL WASM support.\n"
 			printf "\tExiting now.\n\n"
 			exit;
 		fi
-		make install
+		make -j${CPU_CORE} install
 		rm -rf ${TEMP_DIR}/llvm-compiler 2>/dev/null
 	else
 		printf "\tWASM found at ${HOME}/opt/wasm\n"
diff --git a/scripts/eosio_build_ubuntu.sh b/scripts/eosio_build_ubuntu.sh
index e60bd5bf793bfbeb8fe7d600d92231947195bd1f..9b13ef2cd1e18d44eca6c36573dee08821133a69 100644
--- a/scripts/eosio_build_ubuntu.sh
+++ b/scripts/eosio_build_ubuntu.sh
@@ -94,7 +94,7 @@
 		tar xf boost_1.66.0.tar.bz2
 		cd boost_1_66_0/
 		./bootstrap.sh "--prefix=$BOOST_ROOT"
-		./b2 install
+		./b2 -j${CPU_CORE} install
 		rm -rf ${TEMP_DIR}/boost_1_66_0/
 		rm -f  ${TEMP_DIR}/boost_1.66.0.tar.bz2
 	else
@@ -115,13 +115,13 @@
 			exit;
 		fi
 		./configure
-		make
+		make -j${CPU_CORE}
 		if [ $? -ne 0 ]; then
 			printf "\tError compiling secp256k1-zkp.\n"
 			printf "\tExiting now.\n\n"
 			exit;
 		fi
-		sudo make install
+		sudo make -j${CPU_CORE} install
 		rm -rf cd ${TEMP_DIR}/secp256k1-zkp
 	else
 		printf "\tsecp256k1 found\n"
@@ -135,7 +135,7 @@
 		git clone https://github.com/WebAssembly/binaryen
 		cd binaryen
 		git checkout tags/1.37.14
-		cmake . && make
+		cmake . && make -j${CPU_CORE}
 		if [ $? -ne 0 ]; then
 			printf "\tError compiling binaryen.\n"
 			printf "\tExiting now.\n\n"
@@ -167,7 +167,7 @@
 			printf "\tExiting now.\n\n"
 			exit;
 		fi
-		make -j$(nproc)
+		make -j${CPU_CORE} install
 		if [ $? -ne 0 ]; then
 			printf "\tError compiling LLVM and clang with EXPERIMENTAL WASM support.\n"
 			printf "\tExiting now.\n\n"
diff --git a/tests/wasm_tests/wasm_tests.cpp b/tests/wasm_tests/wasm_tests.cpp
index 821b2772c415f7a8e62514c61a30b65719b4b193..e84f1da812c6ab43c911b286fa698dcad95cbff0 100644
--- a/tests/wasm_tests/wasm_tests.cpp
+++ b/tests/wasm_tests/wasm_tests.cpp
@@ -830,5 +830,96 @@ BOOST_FIXTURE_TEST_CASE( check_table_maximum, tester ) try {
 } FC_LOG_AND_RETHROW()
 #endif
 
+BOOST_FIXTURE_TEST_CASE( test_db, tester ) try {
+   produce_blocks(2);
+   
+   create_accounts( {N(tester)} );
+   produce_block();
+   
+   set_code(N(tester), test_api_wast);
+   //   set_code(N(tester), test_api_abi);
+   
+   produce_blocks(1);
+   
+   {
+      signed_transaction trx;
+      trx.actions.emplace_back(vector<permission_level>{{N(tester), config::active_name}},
+                               test_api_action<TEST_METHOD("test_db", "primary_i64_general")> {});
+      
+      set_tapos(trx);
+      trx.sign(get_private_key(N(tester), "active"), chain_id_type());
+      push_transaction(trx);
+      produce_block();
+      
+      BOOST_REQUIRE_EQUAL(true, chain_has_transaction(trx.id()));
+   }
+
+   {
+      signed_transaction trx;
+      trx.actions.emplace_back(vector<permission_level>{{N(tester), config::active_name}},
+                               test_api_action<TEST_METHOD("test_db", "primary_i64_lowerbound")> {});
+
+      set_tapos(trx);
+      trx.sign(get_private_key(N(tester), "active"), chain_id_type());
+      push_transaction(trx);
+      produce_block();
+
+      BOOST_REQUIRE_EQUAL(true, chain_has_transaction(trx.id()));
+   }
+
+   {
+      signed_transaction trx;
+      trx.actions.emplace_back(vector<permission_level>{{N(tester), config::active_name}},
+                               test_api_action<TEST_METHOD("test_db", "primary_i64_upperbound")> {});
+
+      set_tapos(trx);
+      trx.sign(get_private_key(N(tester), "active"), chain_id_type());
+      push_transaction(trx);
+      produce_block();
+
+      BOOST_REQUIRE_EQUAL(true, chain_has_transaction(trx.id()));
+   }
+
+   {
+      signed_transaction trx;
+      trx.actions.emplace_back(vector<permission_level>{{N(tester), config::active_name}},
+                               test_api_action<TEST_METHOD("test_db", "idx64_general")> {});
+      
+      set_tapos(trx);
+      trx.sign(get_private_key(N(tester), "active"), chain_id_type());
+      push_transaction(trx);
+      produce_block();
+      
+      BOOST_REQUIRE_EQUAL(true, chain_has_transaction(trx.id()));
+   }
+
+   {
+      signed_transaction trx;
+      trx.actions.emplace_back(vector<permission_level>{{N(tester), config::active_name}},
+                               test_api_action<TEST_METHOD("test_db", "idx64_lowerbound")> {});
+      
+      set_tapos(trx);
+      trx.sign(get_private_key(N(tester), "active"), chain_id_type());
+      push_transaction(trx);
+      produce_block();
+      
+      BOOST_REQUIRE_EQUAL(true, chain_has_transaction(trx.id()));
+   }
+
+   {
+      signed_transaction trx;
+      trx.actions.emplace_back(vector<permission_level>{{N(tester), config::active_name}},
+                               test_api_action<TEST_METHOD("test_db", "idx64_upperbound")> {});
+      
+      set_tapos(trx);
+      trx.sign(get_private_key(N(tester), "active"), chain_id_type());
+      push_transaction(trx);
+      produce_block();
+      
+      BOOST_REQUIRE_EQUAL(true, chain_has_transaction(trx.id()));
+   }
+
+} FC_LOG_AND_RETHROW() /// test_db
+
 
 BOOST_AUTO_TEST_SUITE_END()