Qa

.gitignore

@@ -18,7 +18,7 @@ venv/
 __pycache__/
 
 .vscode
-
+.idea
 .DS_Store
 
 # Byte-compiled / optimized / DLL files
@@ -172,4 +172,6 @@ cython_debug/
 #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/
+#.idea/
+
+logs/

app/codes/auth/auth.py

@@ -6,6 +6,17 @@
 from ...nvalues import ZERO_ADDRESS
 
 
+def get_node_wallet_public():
+    wallet = get_wallet()
+    if wallet:
+        return {
+            'address': wallet['address'],
+            'public': wallet['public']
+        }
+    else:
+        return None
+
+
 def get_node_wallet_address():
     wallet = get_wallet()
     if wallet:
@@ -36,7 +47,6 @@ def get_auth():
                 'public': wallet['public'],
             }
             auth_data['signature'] = sign_object(private_key, auth_data)
-            print('auth', auth_data)
             return auth_data
     except:
         auth_data = {}

app/codes/blockchain.py

@@ -6,12 +6,17 @@
 
 import sqlite3
 
-from ..constants import NEWRL_DB
+from app.codes.clock.global_time import get_corrected_time_ms
+from app.codes.receiptmanager import update_receipts_in_state
+
+from .fs.temp_manager import remove_block_from_temp
+from ..constants import BLOCK_TIME_INTERVAL_SECONDS, NEWRL_DB, NO_BLOCK_TIMEOUT
 from .utils import get_time_ms
 from .crypto import calculate_hash
-from .state_updater import update_db_states
+from .state_updater import update_db_states, update_trust_scores
 from .utils import get_time_ms
 from .auth.auth import get_node_wallet_address
+from .fs.mempool_manager import remove_transaction_from_mempool
 
 
 class Blockchain:
@@ -20,7 +25,7 @@ class Blockchain:
     def __init__(self) -> None:
         self.chain = []
 
-    def create_block(self, cur, block, block_hash):
+    def create_block(self, cur, block, block_hash, creator_wallet=None):
         """Create a block and store to db"""
         transactions_hash = self.calculate_hash(block['text']['transactions'])
         db_block_data = (
@@ -29,9 +34,10 @@ def create_block(self, cur, block, block_hash):
             block['proof'],
             block['previous_hash'],
             block_hash,
+            creator_wallet,
             transactions_hash
         )
-        cur.execute('INSERT OR IGNORE INTO blocks (block_index, timestamp, proof, previous_hash, hash, transactions_hash) VALUES (?, ?, ?, ?, ?, ?)', db_block_data)
+        cur.execute('INSERT OR IGNORE INTO blocks (block_index, timestamp, proof, previous_hash, hash, creator_wallet, transactions_hash) VALUES (?, ?, ?, ?, ?, ?, ?)', db_block_data)
         return block
 
     def get_block(self, block_index):
@@ -40,13 +46,19 @@ def get_block(self, block_index):
         cur = con.cursor()
         block_cursor = cur.execute(
             'SELECT * FROM blocks where block_index=?', (block_index,)).fetchone()
+
+        if block_cursor is None:
+            return None
         block = dict(block_cursor)
 
         transactions_cursor = cur.execute(
             'SELECT * FROM transactions where block_index=?', (block_index,)).fetchall()
         transactions = [dict(ix) for ix in transactions_cursor]
+        transactions = list(map(lambda t: 
+            {'transaction': t, 'signatures': [] if t['signatures'] is None else json.loads(t['signatures'])},
+            transactions))
         block['text'] = {
-            'transactions': transactions
+            'transactions': transactions,
         }
 
         return block
@@ -96,11 +108,10 @@ def mine_block(self, cur, text, fees=0):
 
         block = {
             'index': last_block_index + 1,
-            'timestamp': get_time_ms(),
+            'timestamp': get_corrected_time_ms(),
             'proof': 0,
             'text': text,
             'creator_wallet': get_node_wallet_address(),
-            'fees': fees,
             'previous_hash': last_block_hash
         }
 
@@ -110,6 +121,54 @@ def mine_block(self, cur, text, fees=0):
         block = self.create_block(cur, block, block_hash)
         return block
 
+    def propose_block(self, cur, text):
+        """Propose a new block and not add to chain"""
+        last_block_cursor = cur.execute(
+            'SELECT block_index, hash FROM blocks ORDER BY block_index DESC LIMIT 1')
+        last_block = last_block_cursor.fetchone()
+        last_block_index = last_block[0] if last_block is not None else 0
+        last_block_hash = last_block[1] if last_block is not None else 0
+        print(f'Proposing a block with index {last_block_index + 1}')
+
+        block = {
+            'index': last_block_index + 1,
+            'timestamp': get_corrected_time_ms(),
+            'proof': 0,
+            'text': text,
+            'creator_wallet': get_node_wallet_address(),
+            'previous_hash': last_block_hash
+        }
+        return block
+
+    def mine_empty_block(self, new_block_timestamp=None):
+        """Mine an empty block"""
+        print("Mining empty block")
+        con = sqlite3.connect(NEWRL_DB)
+        cur = con.cursor()
+        last_block_cursor = cur.execute(
+            'SELECT block_index, hash, timestamp FROM blocks ORDER BY block_index DESC LIMIT 1')
+        last_block = last_block_cursor.fetchone()
+        con.close()
+        last_block_index = last_block[0] if last_block is not None else 0
+        last_block_hash = last_block[1] if last_block is not None else 0
+        last_block_timestamp = last_block[2] if last_block is not None else 0
+
+        EMPTY_BLOCK_NONCE = 42
+
+        if new_block_timestamp is None:
+            new_block_timestamp = int(last_block_timestamp) + (BLOCK_TIME_INTERVAL_SECONDS + NO_BLOCK_TIMEOUT) * 1000
+
+        block = {
+            'index': last_block_index + 1,
+            'timestamp': new_block_timestamp,
+            'proof': EMPTY_BLOCK_NONCE,
+            'text': {"transactions": [], "signatures": []},
+            'creator_wallet': None,
+            'previous_hash': last_block_hash
+        }
+
+        return block
+
     def get_latest_ts(self, cur=None):
         """Get the timestamp of latest block"""
         should_close_db_conn = False
@@ -129,12 +188,14 @@ def get_latest_ts(self, cur=None):
         return ts
 
 
-def add_block(cur, block, block_hash=None):
+def add_block(cur, block, block_hash):
     """Add a block to db, add transactions and update states"""
+    last_block = get_last_block(cur)
+    if last_block is not None and last_block['hash'] != block['previous_hash']:
+        print('Previous block hash does not match current block data')
+        return
     # Needed for backward compatibility of blocks
     block_index = block['block_index'] if 'block_index' in block else block['index']
-    if not block_hash:
-        block_hash = block['hash'] if 'hash' in block else ''
     # transactions_hash = block['transactions_hash'] if 'transactions_hash' in block else ''
     transactions_hash = calculate_hash(block['text']['transactions'])
     print('Adding block', block_index)
@@ -144,10 +205,19 @@ def add_block(cur, block, block_hash=None):
         block['proof'],
         block['previous_hash'],
         block_hash,
+        block['creator_wallet'],
         transactions_hash
     )
-    cur.execute('INSERT OR IGNORE INTO blocks (block_index, timestamp, proof, previous_hash, hash, transactions_hash) VALUES (?, ?, ?, ?, ?, ?)', db_block_data)
+    cur.execute('INSERT OR IGNORE INTO blocks (block_index, timestamp, proof, previous_hash, hash, creator_wallet, transactions_hash) VALUES (?, ?, ?, ?, ?, ?, ?)', db_block_data)
     update_db_states(cur, block)
+    # update_receipts_in_state(cur, block)
+    # update_trust_scores(cur, block)
+
+    for transaction in block['text']['transactions']:
+        transaction = transaction['transaction']
+        transaction_code = transaction['transaction_code'] if 'transaction_code' in transaction else transaction['trans_code']
+        remove_transaction_from_mempool(transaction_code)
+    remove_block_from_temp(block_index)
 
 
 def get_last_block_index():
@@ -162,20 +232,41 @@ def get_last_block_index():
     return last_block[0] if last_block is not None else 0
 
 
-def get_last_block_hash():
+def get_last_block(cur=None):
     """Get last block hash from db"""
-    con = sqlite3.connect(NEWRL_DB)
-    cur = con.cursor()
+    cursor_opened_inside = False
+    if cur is None:
+        con = sqlite3.connect(NEWRL_DB)
+        cur = con.cursor()
+        cursor_opened_inside = True
     last_block_cursor = cur.execute(
-        'SELECT block_index, hash FROM blocks ORDER BY block_index DESC LIMIT 1'
+        'SELECT block_index, hash, timestamp FROM blocks ORDER BY block_index DESC LIMIT 1'
     )
     last_block = last_block_cursor.fetchone()
-    con.close()
+
+    if cursor_opened_inside:
+        con.close()
 
     if last_block is not None:
         return {
             'index': last_block[0],
-            'hash': last_block[1]
+            'hash': last_block[1],
+            'timestamp': last_block[2]
         }
     else:
         return None
+
+
+def block_exists(block_index):
+        con = sqlite3.connect(NEWRL_DB)
+        cur = con.cursor()
+        block_cursor = cur.execute(
+            'SELECT * FROM blocks where block_index=?', (block_index,)).fetchone()
+
+        if block_cursor is not None:
+            block_exists = True
+        else:
+            block_exists = False
+
+        con.close()
+        return block_exists

app/codes/chainscanner.py

@@ -71,24 +71,66 @@ def download_state():
 
     balances_cursor = cur.execute('SELECT * FROM balances').fetchall()
     balances = [dict(ix) for ix in balances_cursor]
+
+    contracts_cursor = cur.execute('SELECT * FROM contracts').fetchall()
+    contracts = [dict(ix) for ix in contracts_cursor]
 
     state = {
         'wallets': wallets,
         'tokens': tokens,
         'balances': balances,
+        'contracts': contracts
     }
     return state
 
 
+def get_block(block_index):
+    chain = Blockchain()
+    return chain.get_block(block_index)
+
 def get_transaction(transaction_code):
     con = sqlite3.connect(NEWRL_DB)
     con.row_factory = sqlite3.Row
     cur = con.cursor()
     transaction_cursor = cur.execute(
         'SELECT * FROM transactions where transaction_code=?', (transaction_code,)).fetchone()
+    if transaction_cursor is None:
+        return None
     return dict(transaction_cursor)
 
 
+def get_wallet(wallet_address):
+    con = sqlite3.connect(NEWRL_DB)
+    con.row_factory = sqlite3.Row
+    cur = con.cursor()
+    cur = cur.execute(
+        'SELECT * FROM wallets where wallet_address=?', (wallet_address,)).fetchone()
+    if cur is None:
+        return None
+    return dict(cur)
+
+
+def get_token(token_code):
+    con = sqlite3.connect(NEWRL_DB)
+    con.row_factory = sqlite3.Row
+    cur = con.cursor()
+    cur = cur.execute(
+        'SELECT * FROM tokens where tokencode=?', (token_code,)).fetchone()
+    if cur is None:
+        return None
+    return dict(cur)
+
+def get_contract(contract_address):
+    con = sqlite3.connect(NEWRL_DB)
+    con.row_factory = sqlite3.Row
+    cur = con.cursor()
+    cur = cur.execute(
+        'SELECT * FROM contracts where address=?', (contract_address,)).fetchone()
+    if cur is None:
+        return None
+    return dict(cur)
+
+
 def download_chain():
     con = sqlite3.connect(NEWRL_DB)
     con.row_factory = sqlite3.Row