Merged local trigger contracts

parsing.py

@@ -417,7 +417,7 @@ def extract_contract_conditions(text, contract_type, marker=None, blocktime=None
                 searchResult = pattern.search(rule).group(2)
                 minimumsubscriptionamount = searchResult.split(marker)[0]
                 try:
-                    extractedRules['minimumsubscriptionamount'] = float(minimumsubscriptionamount)
+                    extractedRules['minimumsubscrbyiptionamount'] = float(minimumsubscriptionamount)
                 except:
                     logger.info("Minimum subscription amount entered is not a decimal")
             elif rule[:25] == 'maximumsubscriptionamount':
@@ -446,36 +446,35 @@ def extract_contract_conditions(text, contract_type, marker=None, blocktime=None
                 continue
             elif rule[:7] == 'subtype':
                 # todo : recheck the regular expression for subtype, find an elegant version which covers all permutations and combinations
-                pattern = re.compile('(?<=subtype\s=\s).*')
-                subtype = pattern.search(rule).group(0)
+                pattern = re.compile('(^subtype\s*=\s*)(.*)')
+                subtype = pattern.search(rule).group(2)
                 extractedRules['subtype'] = subtype
             elif rule[:15] == 'accepting_token':
-                pattern = re.compile('(?<=accepting_token\s=\s).*(?<!#)')
-                accepting_token = pattern.search(rule).group(0)
+                pattern = re.compile('(?<=accepting_token\s=\s)(.*)(?<!#)')
+                accepting_token = pattern.search(rule).group(1)
                 extractedRules['accepting_token'] = accepting_token
             elif rule[:13] == 'selling_token':
-                pattern = re.compile('(?<=selling_token\s=\s).*(?<!#)')
-                selling_token = pattern.search(rule).group(0)
+                pattern = re.compile('(?<=selling_token\s=\s)(.*)(?<!#)')
+                selling_token = pattern.search(rule).group(1)
                 extractedRules['selling_token'] = selling_token
             elif rule[:9] == 'pricetype':
-                pattern = re.compile('(^pricetype\s*=\s*).*')
-                priceType = pattern.search(rule).group(0)
+                pattern = re.compile('(^pricetype\s*=\s*)(.*)')
+                priceType = pattern.search(rule).group(2)
                 priceType = priceType.replace("'","").replace('"', '')
                 extractedRules['priceType'] = priceType
             elif rule[:5] == 'price':
-                pattern = re.compile('(^price\s*=\s*).*')
-                price = pattern.search(rule).group(0)
+                pattern = re.compile('(^price\s*=\s*)(.*)')
+                price = pattern.search(rule).group(2)
                 if price[0]=="'" or price[0]=='"':
                     price = price[1:]
                 if price[-1]=="'" or price[-1]=='"':
                     price = price[:-1]
                 extractedRules['price'] = float(price)
             elif rule[:9].lower() == 'direction':
-                pattern = re.compile('(?<=direction\s=\s).*')
-                direction = pattern.search(rule).group(0)
+                pattern = re.compile('(?<=direction\s=\s)(.*)')
+                direction = pattern.search(rule).group(1)
                 extractedRules['direction'] = direction
-            # else:
-            #    pdb.set_trace()
+        
         if len(extractedRules) > 1:
             return extractedRules
         else:
@@ -485,7 +484,6 @@ def extract_contract_conditions(text, contract_type, marker=None, blocktime=None
 
 def extract_tokenswap_contract_conditions(processed_text, contract_type, contract_token):
     rulestext = re.split('contract-conditions:\s*', processed_text)[-1]
-    # rulelist = re.split('\d\.\s*', rulestext)
     rulelist = []
     numberList = re.findall(r'\(\d\d*\)', rulestext)
 
@@ -511,10 +509,11 @@ def extract_tokenswap_contract_conditions(processed_text, contract_type, contrac
                 continue
             elif rule[:7] == 'subtype':
                 # todo : recheck the regular expression for subtype, find an elegant version which covers all permutations and combinations
-                '''pattern = re.compile('(^subtype\s*=\s*).*')
-                searchResult = pattern.search(rule).group(0)
-                subtype = searchResult.split(marker)[0]'''
-                extractedRules['subtype'] = rule.split('=')[1].strip()
+                pattern = re.compile('(^subtype\s*=\s*)(.*)')
+                searchResult = pattern.search(rule).group(2)
+                subtype = searchResult.split(marker)[0]
+                #extractedRules['subtype'] = rule.split('=')[1].strip()
+                extractedRules['subtype'] = subtype
             elif rule[:15] == 'accepting_token':
                 pattern = re.compile('(?<=accepting_token\s=\s).*(?<!#)')
                 accepting_token = pattern.search(rule).group(0)
@@ -539,8 +538,7 @@ def extract_tokenswap_contract_conditions(processed_text, contract_type, contrac
                 pattern = re.compile('(?<=direction\s=\s).*')
                 direction = pattern.search(rule).group(0)
                 extractedRules['direction'] = direction
-            # else:
-            #    pdb.set_trace()
+
         if len(extractedRules) > 1:
             return extractedRules
         else:

test_db.py

@@ -0,0 +1,85 @@
+import argparse 
+import configparser 
+import json 
+import logging 
+import os 
+import shutil 
+import sys 
+import pyflo 
+import requests 
+import socketio 
+from sqlalchemy import create_engine, func 
+from sqlalchemy.orm import sessionmaker 
+import time 
+import arrow 
+import parsing 
+from config import * 
+from datetime import datetime 
+from ast import literal_eval 
+from models import SystemData, TokenBase, ActiveTable, ConsumedTable, TransferLogs, TransactionHistory, TokenContractAssociation, RejectedTransactionHistory, ContractBase, ContractStructure, ContractParticipants, ContractTransactionHistory, ContractDeposits, ConsumedInfo, ContractWinners, ContinuosContractBase, ContractStructure2, ContractParticipants2, ContractDeposits2, ContractTransactionHistory2, SystemBase, ActiveContracts, SystemData, ContractAddressMapping, TokenAddressMapping, DatabaseTypeMapping, TimeActions, RejectedContractTransactionHistory, RejectedTransactionHistory, LatestCacheBase, LatestTransactions, LatestBlocks
+from statef_processing import process_stateF 
+import pdb 
+
+# Configuration of required variables 
+config = configparser.ConfigParser()
+config.read('config.ini')
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG)
+
+formatter = logging.Formatter('%(asctime)s:%(name)s:%(message)s')
+file_handler = logging.FileHandler(os.path.join(config['DEFAULT']['DATA_PATH'],'tracking.log'))
+file_handler.setLevel(logging.INFO)
+file_handler.setFormatter(formatter)
+
+stream_handler = logging.StreamHandler()
+stream_handler.setFormatter(formatter)
+
+logger.addHandler(file_handler)
+logger.addHandler(stream_handler)
+
+def create_database_connection(type, parameters):
+    if type == 'token':
+        path = os.path.join(config['DEFAULT']['DATA_PATH'], 'tokens', f"{parameters['token_name']}.db")
+        engine = create_engine(f"sqlite:///{path}", echo=True)
+    elif type == 'smart_contract':
+        path = os.path.join(config['DEFAULT']['DATA_PATH'], 'smartContracts', f"{parameters['contract_name']}-{parameters['contract_address']}.db")
+        engine = create_engine(f"sqlite:///{path}", echo=True)
+    elif type == 'system_dbs':
+        path = os.path.join(config['DEFAULT']['DATA_PATH'], f"system.db")
+        engine = create_engine(f"sqlite:///{path}", echo=False)
+    elif type == 'latest_cache':
+        path = os.path.join(config['DEFAULT']['DATA_PATH'], f"latestCache.db")
+        engine = create_engine(f"sqlite:///{path}", echo=False)
+
+    connection = engine.connect()
+    return connection
+
+
+def create_database_session_orm(type, parameters, base):
+    if type == 'token':
+        path = os.path.join(config['DEFAULT']['DATA_PATH'], 'tokens', f"{parameters['token_name']}.db")
+        engine = create_engine(f"sqlite:///{path}", echo=True)
+        base.metadata.create_all(bind=engine)
+        session = sessionmaker(bind=engine)()
+
+    elif type == 'smart_contract':
+        path = os.path.join(config['DEFAULT']['DATA_PATH'], 'smartContracts', f"{parameters['contract_name']}-{parameters['contract_address']}.db")
+        engine = create_engine(f"sqlite:///{path}", echo=True)
+        base.metadata.create_all(bind=engine)
+        session = sessionmaker(bind=engine)()
+
+    elif type == 'system_dbs':
+        path = os.path.join(config['DEFAULT']['DATA_PATH'], f"{parameters['db_name']}.db")
+        engine = create_engine(f"sqlite:///{path}", echo=False)
+        base.metadata.create_all(bind=engine)
+        session = sessionmaker(bind=engine)()
+    
+    return session
+
+
+# Connect to system.db with a session 
+systemdb_session = create_database_session_orm('system_dbs', {'db_name':'system'}, SystemBase)
+timeactions_tx_hashes = []
+activeContracts = systemdb_session.query(ActiveContracts).all()
+pdb.set_trace()

test_rollback_new.py

@@ -145,7 +145,7 @@ def rollback_address_balance_processing(db_session, senderAddress, receiverAddre
     # for receiver, if the currentaddressbalance is 0 then do nothing .. and if the currentaddressbalance is not 0 then update the last occurence of receiver address 
     sender_query = db_session.query(ActiveTable).filter(ActiveTable.address==senderAddress).order_by(ActiveTable.id.desc()).first() 
     sender_query.addressBalance = new_senderBalance 
-
+    
     if new_receiverBalance != 0 and new_receiverBalance > 0:
         receiver_query = db_session.query(ActiveTable).filter(ActiveTable.address==receiverAddress).order_by(ActiveTable.id.desc()).limit(2).all()
         if len(receiver_query) == 2:
@@ -216,7 +216,7 @@ def rollback_database(blockNumber, dbtype, dbname):
                 break
             outputAddress = activeTable_entry.address
             transferAmount = activeTable_entry.transferBalance
-            inputAddress = None
+            inputAddress = None            
 
             # Find out consumedpid and partially consumed pids 
             parentid = None 

tracktokens_smartcontracts.py

@@ -130,14 +130,14 @@ def processBlock(blockindex=None, blockhash=None):
 
     blockinfo = newMultiRequest(f"block/{blockhash}") 
 
-    pause_index = 2294310
+    pause_index = 2291729
     if blockindex == pause_index:
         print(f'Paused at {pause_index}')
-        pdb.set_trace()
     # Check smartContracts which will be triggered locally, and not by the contract committee
-    checkLocaltriggerContracts(blockinfo)
+    #checkLocaltriggerContracts(blockinfo)
     # Check if any deposits have to be returned 
-    checkReturnDeposits(blockinfo)
+    #checkReturnDeposits(blockinfo)
+    checkLocal_expiry_trigger_deposit(blockinfo)
 
     # todo Rule 8 - read every transaction from every block to find and parse flodata
     counter = 0
@@ -151,7 +151,7 @@ def processBlock(blockindex=None, blockhash=None):
         logger.info(f"Transaction {transaction_counter} : {transaction}")
         current_index = -1
         
-        if transaction in ['64abe801d12224d10422de88070a76ad8c6d17b533ba5288fb0961b4cbf6adf4']:
+        if transaction in ['8eed51ae47575fd78413f9be5a7909cf2653b6fedacf093e35b592319e478b21']:
             pass
 
         # TODO CLEANUP - REMOVE THIS WHILE SECTION, WHY IS IT HERE?
@@ -388,38 +388,6 @@ def transferToken(tokenIdentification, tokenAmount, inputAddress, outputAddress,
             return 1
 
 
-def trigger_internal_contract(tokenAmount_sum, contractStructure, transaction_data, blockinfo, parsed_data, connection, contract_name, contract_address, transaction_subType):
-    # Trigger the contract
-    payeeAddress = json.loads(contractStructure['payeeAddress'])
-    tokenIdentification = contractStructure['tokenIdentification']
-    contractAddress = contractStructure['contractAddress']
-
-    for floaddress in payeeAddress.keys():
-        transferAmount = tokenAmount_sum * (payeeAddress[floaddress]/100)
-        returnval = transferToken(tokenIdentification, transferAmount, contractAddress, floaddress, transaction_data=transaction_data, blockinfo = blockinfo, parsed_data = parsed_data)
-        if returnval is None:
-            logger.critical("Something went wrong in the token transfer method while doing local Smart Contract Trigger")
-            return 0
-
-        # Add transaction to ContractTransactionHistory
-        session = create_database_session_orm('smart_contract', {'contract_name': f"{contract_name}", 'contract_address': f"{contract_address}"}, ContractBase)
-        session.add(ContractTransactionHistory(transactionType='trigger',
-                                            transactionSubType=transaction_subType,
-                                            sourceFloAddress=contractAddress,
-                                            destFloAddress=floaddress,
-                                            transferAmount=transferAmount,
-                                            blockNumber=blockinfo['height'],
-                                            blockHash=blockinfo['hash'],
-                                            time=blockinfo['time']))
-        session.commit()
-        session.close()
-    return 1
-
-
-def check_local_trigger_conditions():
-    pass
-
-
 def checkLocaltriggerContracts(blockinfo):
     connection = create_database_connection('system_dbs', {'db_name':"system"})
     # todo : filter activeContracts which only have local triggers
@@ -446,12 +414,6 @@ def checkLocaltriggerContracts(blockinfo):
             contractStructure['exitconditions'] = conditionDict
         del counter, conditionDict
 
-        # TODO - FIGURE A BETTER SOLUTION FOR THIS 
-        transaction_data = {}
-        transaction_data['txid'] = 'internalTrigger'
-        parsed_data = {}
-        parsed_data['type'] = 'internalTrigger'
-
         if 'contractAddress' not in contractStructure.keys():
             contractStructure['contractAddress'] = contract[1]
 
@@ -700,6 +662,10 @@ def checkReturnDeposits(blockinfo):
                         # Check if the contract has blockchain trigger or committee trigger
                         if 'exitconditions' in contractStructure:
                             # This is a committee trigger contract
+
+                            if 'maximumsubscriptionamount' in contractStructure:
+                                pass
+                            
                             expiryTime = contractStructure['expiryTime']
                             expirytime_split = expiryTime.split(' ')
                             parse_string = '{}/{}/{} {}'.format(expirytime_split[3], parsing.months[expirytime_split[1]],
@@ -746,15 +712,10 @@ def checkReturnDeposits(blockinfo):
                                         connection.close()
 
                                 connection = create_database_connection('system_dbs', {'db_name':'system'})
-                                connection.execute(
-                                    'update activecontracts set status="expired" where contractName="{}" and contractAddress="{}"'.format(
-                                        contract[0], contract[1]))
-                                connection.execute(
-                                    'update activecontracts set expirydate="{}" where contractName="{}" and contractAddress="{}"'.format(
-                                        blockinfo['time'],
-                                        contract[0], contract[1]))
+                                connection.execute('update activecontracts set status="expired" where contractName="{}" and contractAddress="{}"'.format(contract[0], contract[1]))
+                                connection.execute('update activecontracts set expirydate="{}" where contractName="{}" and contractAddress="{}"'.format(blockinfo['time'], contract[0], contract[1]))
                                 connection.close()
-
+                            
                         elif 'payeeAddress' in contractStructure:
                             # This is a local trigger contract
                             if 'maximumsubscriptionamount' in contractStructure:
@@ -797,6 +758,7 @@ def checkReturnDeposits(blockinfo):
                                     connection.close()
                                     return
 
+                            
                             expiryTime = contractStructure['expiryTime']
                             expirytime_split = expiryTime.split(' ')
                             parse_string = '{}/{}/{} {}'.format(expirytime_split[3], parsing.months[expirytime_split[1]],
@@ -813,18 +775,13 @@ def checkReturnDeposits(blockinfo):
                                         contractParticipants = connection.execute('select participantAddress, tokenAmount, transactionHash from contractparticipants').fetchall()[0][0]
 
                                         for participant in contractParticipants:
-                                            tokenIdentification = connection.execute(
-                                                'select * from contractstructure where attribute="tokenIdentification"').fetchall()[0][0]
-                                            contractAddress = connection.execute(
-                                                'select * from contractstructure where attribute="contractAddress"').fetchall()[0][0]
+                                            tokenIdentification = connection.execute('select * from contractstructure where attribute="tokenIdentification"').fetchall()[0][0]
+                                            contractAddress = connection.execute('select * from contractstructure where attribute="contractAddress"').fetchall()[0][0]
                                             returnval = transferToken(tokenIdentification, participant[1], contractAddress, participant[0], blockinfo = blockinfo)
                                             if returnval is None:
-                                                logger.critical(
-                                                    "Something went wrong in the token transfer method while doing local Smart Contract Trigger")
+                                                logger.critical("Something went wrong in the token transfer method while doing local Smart Contract Trigger")
                                                 return
-                                            connection.execute(
-                                                'update contractparticipants set winningAmount="{}" where participantAddress="{}" and transactionHash="{}"'.format(
-                                                    (participant[1], participant[0], participant[2])))
+                                            connection.execute('update contractparticipants set winningAmount="{}" where participantAddress="{}" and transactionHash="{}"'.format((participant[1], participant[0], participant[2])))
 
                                         # add transaction to ContractTransactionHistory
                                         session = create_database_session_orm('smart_contract', {'contract_name': f"{contract[0]}", 'contract_address': f"{contract[1]}"}, ContractBase)
@@ -880,6 +837,238 @@ def checkReturnDeposits(blockinfo):
                                 return
 
 
+def trigger_internal_contract(tokenAmount_sum, contractStructure, transaction_data, blockinfo, parsed_data, connection, contract_name, contract_address, transaction_subType):
+    # Trigger the contract
+    payeeAddress = json.loads(contractStructure['payeeAddress'])
+    tokenIdentification = contractStructure['tokenIdentification']
+
+    for floaddress in payeeAddress.keys():
+        transferAmount = tokenAmount_sum * (payeeAddress[floaddress]/100)
+        returnval = transferToken(tokenIdentification, transferAmount, contract_address, floaddress, transaction_data=transaction_data, blockinfo = blockinfo, parsed_data = parsed_data)
+        if returnval is None:
+            logger.critical("Something went wrong in the token transfer method while doing local Smart Contract Trigger")
+            return 0
+
+        # Add transaction to ContractTransactionHistory
+        session = create_database_session_orm('smart_contract', {'contract_name': f"{contract_name}", 'contract_address': f"{contract_address}"}, ContractBase)
+        session.add(ContractTransactionHistory(transactionType='trigger',
+                                            transactionSubType=transaction_subType,
+                                            sourceFloAddress=contract_address,
+                                            destFloAddress=floaddress,
+                                            transferAmount=transferAmount,
+                                            blockNumber=blockinfo['height'],
+                                            blockHash=blockinfo['hash'],
+                                            time=blockinfo['time']))
+        session.commit()
+        session.close()
+    return 1
+
+
+def process_minimum_subscriptionamount(contractStructure, connection):
+    minimumsubscriptionamount = float(contractStructure['minimumsubscriptionamount'])
+    tokenAmount_sum = connection.execute('select IFNULL(sum(tokenAmount), 0) from contractparticipants').fetchall()[0][0]
+    if tokenAmount_sum < minimumsubscriptionamount:
+        # Initialize payback to contract participants
+        contractParticipants = connection.execute('select participantAddress, tokenAmount, transactionHash from contractparticipants').fetchall()[0][0]
+
+        for participant in contractParticipants:
+            tokenIdentification = contractStructure['tokenIdentification']
+            contractAddress = connection.execute('select * from contractstructure where attribute="contractAddress"').fetchall()[0][0]
+            returnval = transferToken(tokenIdentification, participant[1], contractAddress, participant[0], blockinfo = blockinfo)
+            if returnval is None:
+                logger.critical("Something went wrong in the token transfer method while doing local Smart Contract Trigger. THIS IS CRITICAL ERROR")
+                return
+            connection.execute('update contractparticipants set winningAmount="{}" where participantAddress="{}" and transactionHash="{}"'.format((participant[1], participant[0], participant[2])))
+
+        # add transaction to ContractTransactionHistory
+        session = create_database_session_orm('smart_contract', {'contract_name': f"{contractStructure['contractName']}", 'contract_address': f"{contractStructure['contractAddress']}"}, ContractBase)
+        session.add(ContractTransactionHistory(transactionType='trigger',
+                                            transactionSubType='minimumsubscriptionamount-payback',
+                                            transferAmount=None,
+                                            blockNumber=blockinfo['height'],
+                                            blockHash=blockinfo['hash'],
+                                            time=blockinfo['time']))
+        session.commit()
+        session.close()
+
+
+def checkLocal_expiry_trigger_deposit(blockinfo):
+    # Connect to system.db with a session 
+    systemdb_session = create_database_session_orm('system_dbs', {'db_name':'system'}, SystemBase)
+    timeactions_tx_hashes = []
+    active_contracts = systemdb_session.query(TimeActions).filter(TimeActions.status == 'active').all()
+    for query in active_contracts:
+        query_time = convert_datetime_to_arrowobject(query.time)
+        blocktime = parsing.arrow.get(blockinfo['time']).to('Asia/Kolkata')
+        if query.activity == 'contract-deposit':
+            if blocktime > query_time:
+                # find the status of the deposit 
+                # the deposit is unique
+                # find the total sum to be returned from the smart contract's participation table 
+                contract_db = create_database_session_orm('smart_contract', {'contract_name': query.contractName, 'contract_address': query.contractAddress}, ContractBase)
+                deposit_query = contract_db.query(ContractDeposits).filter(ContractDeposits.transactionHash == query.transactionHash).first()
+                depositorAddress = deposit_query.depositorAddress
+                total_deposit_amount = deposit_query.depositAmount
+                amount_participated = contract_db.query(func.sum(ContractParticipants.tokenAmount)).all()[0][0]
+                if amount_participated is None:
+                    amount_participated = 0 
+                returnAmount = float(total_deposit_amount) - float(amount_participated)
+                # Do a token transfer back to the deposit address 
+                sellingToken = contract_db.query(ContractStructure.value).filter(ContractStructure.attribute == 'selling_token').first()[0]
+                tx_block_string = f"{query.transactionHash}{blockinfo['height']}".encode('utf-8').hex()
+                parsed_data = {}
+                parsed_data['type'] = 'expired_deposit'
+                transaction_data = {}
+                #transaction_data['txid'] = pyflo.sha256(tx_block_string).hex()
+                transaction_data['txid'] = query.transactionHash
+                transaction_data['blockheight'] = blockinfo['height']
+                returnval = transferToken(sellingToken, returnAmount, query.contractAddress, depositorAddress, transaction_data=transaction_data, parsed_data=parsed_data, blockinfo=blockinfo)
+                if returnval is None:
+                    logger.critical("Something went wrong in the token transfer method while return contract deposit. THIS IS CRITICAL ERROR")
+                    return
+                else:
+                    old_depositBalance = contract_db.query(ContractDeposits.depositBalance).order_by(ContractDeposits.id.desc()).first()
+                    if old_depositBalance is None:
+                        logger.info('Something is wrong in the databases. Cannot do a deposit return without any previously available deposits in the database')
+                        return 0
+                    else:
+                        old_depositBalance = old_depositBalance[0]
+
+                    contract_db.add(ContractDeposits(
+                        depositorAddress = deposit_query.depositorAddress,
+                        depositAmount = returnAmount,
+                        depositBalance = old_depositBalance - returnAmount,
+                        expiryTime = deposit_query.expiryTime,
+                        unix_expiryTime = 0,
+                        status = 'deposit-return',
+                        transactionHash = deposit_query.transactionHash,
+                        blockNumber = blockinfo['height'],
+                        blockHash = blockinfo['hash']
+                    ))
+
+                    contract_db.add(ContractTransactionHistory(
+                        transactionType = 'smartContractDepositReturn',
+                        transactionSubType = '',
+                        sourceFloAddress = query.contractAddress,
+                        destFloAddress = depositorAddress,
+                        transferAmount = returnAmount,
+                        blockNumber = blockinfo['height'],
+                        blockHash = blockinfo['hash'],
+                        time = blockinfo['time'],
+                        transactionHash = deposit_query.transactionHash,
+                        blockchainReference = '',
+                        jsonData = '',
+                        parsedFloData = ''
+                    ))
+
+                    systemdb_session.add(TimeActions(
+                        time = query.time,
+                        activity = query.activity,
+                        status = 'returned',
+                        contractName = query.contractName,
+                        contractAddress = query.contractAddress,
+                        contractType = query.contractType,
+                        tokens_db = query.tokens_db,
+                        parsed_data = query.parsed_data,
+                        transactionHash = query.transactionHash,
+                        blockNumber = blockinfo['height']
+                    ))
+
+                    contract_db.commit()
+                    systemdb_session.commit()
+                    updateLatestTransaction(transaction_data, parsed_data, f"{query.contractName}-{query.contractAddress}")
+
+        elif query.activity == 'contract-time-trigger':
+            connection = create_database_session_orm('smart_contract', {'contract_name': query.contractName, 'contract_address': query.contractAddress}, ContractBase)
+            # todo : filter activeContracts which only have local triggers
+            attributevaluepair = connection.execute("select attribute, value from contractstructure where attribute != 'contractName' and attribute != 'flodata' and attribute != 'contractAddress'").fetchall()
+            contractStructure = {}
+            conditionDict = {}
+            counter = 0
+            for item in attributevaluepair:
+                if list(item)[0] == 'exitconditions':
+                    conditionDict[counter] = list(item)[1]
+                    counter = counter + 1
+                else:
+                    contractStructure[list(item)[0]] = list(item)[1]
+            if len(conditionDict) > 0:
+                contractStructure['exitconditions'] = conditionDict
+            del counter, conditionDict
+
+            if contractStructure['contractType'] == 'one-time-event':
+                if 'exitconditions' in contractStructure: # Committee trigger contract type
+                    tokenAmount_sum = connection.execute('select IFNULL(sum(tokenAmount), 0) from contractparticipants').fetchall()[0][0]
+                    # maximumsubscription check, if reached then expire the contract 
+                    if 'maximumsubscriptionamount' in contractStructure:
+                        maximumsubscriptionamount = connection.execute('select value from contractstructure where attribute=="maximumsubscriptionamount"').fetchall()[0][0]
+                        maximumsubscriptionamount = float(maximumsubscriptionamount)
+                        if tokenAmount_sum >= maximumsubscriptionamount:
+                            # Expire the contract
+                            connection = create_database_connection('system_dbs', {'db_name':'system'})
+                            connection.execute('update activecontracts set status="expired", expirydate="{}" where contractName="{}" and contractAddress="{}"'.format(blockinfo['time'], query.contractName, query.contractAddress))
+                            connection.execute('update time_actions set status="expired" where contractName="{}" and contractAddress="{}"'.format(query.contractName, query.contractAddress))
+                            connection.close()
+                                   
+                    if blocktime > query_time:
+                        if 'minimumsubscriptionamount' in contractStructure:
+                            process_minimum_subscriptionamount(contractStructure, connection)
+                            connection = create_database_connection('system_dbs', {'db_name':'system'})
+                            connection.execute('update activecontracts set status="expired", expirydate="{}" where contractName="{}" and contractAddress="{}"'.format(blockinfo['time'], query.contractName, query.contractAddress))
+                            connection.execute('update time_actions set status="expired" where contractName="{}" and contractAddress="{}"'.format(query.contractName, query.contractAddress))
+                            connection.close()
+                            return 
+
+                        # Expire the contract      
+                        connection = create_database_connection('system_dbs', {'db_name':'system'})
+                        connection.execute('update activecontracts set status="expired", expirydate="{}" where contractName="{}" and contractAddress="{}"'.format(blockinfo['time'], query.contractName, query.contractAddress))
+                        connection.execute('update time_actions set status="expired" where contractName="{}" and contractAddress="{}"'.format(query.contractName, query.contractAddress))
+                        connection.close()         
+                
+                elif 'payeeAddress' in contractStructure: # Internal trigger contract type
+                    # TODO - FIGURE A BETTER SOLUTION FOR THIS 
+                    transaction_data = {}
+                    transaction_data['txid'] = 'internalTrigger'
+                    parsed_data = {}
+                    parsed_data['type'] = 'internalTrigger'
+
+                    tokenAmount_sum = connection.execute('select IFNULL(sum(tokenAmount), 0) from contractparticipants').fetchall()[0][0]
+                    # maximumsubscription check, if reached then trigger the contract
+                    if 'maximumsubscriptionamount' in contractStructure:
+                        maximumsubscriptionamount = connection.execute('select value from contractstructure where attribute=="maximumsubscriptionamount"').fetchall()[0][0]
+                        maximumsubscriptionamount = float(maximumsubscriptionamount)
+                        if tokenAmount_sum >= maximumsubscriptionamount:
+                            # Trigger the contract
+                            success_returnval = trigger_internal_contract(tokenAmount_sum, contractStructure, transaction_data, blockinfo, parsed_data, connection, contract_name=query.contractName, contract_address=query.contractAddress, transaction_subType='maximumsubscriptionamount')
+                            if not success_returnval:
+                                return 0
+    
+                            connection = create_database_connection('system_dbs', {'db_name':'system'})
+                            connection.execute('update activecontracts set status="closed", closeDate="{}", expiryDate="{}" where contractName="{}" and contractAddress="{}"'.format(blockinfo['time'], blockinfo['time'], query.contractName, query.contractAddress))
+                            connection.execute('update time_actions set status="closed" where contractName="{}" and contractAddress="{}"'.format(query.contractName, query.contractAddress))                            
+                            connection.close()
+                            return
+      
+                    if blocktime > query_time: 
+                        if 'minimumsubscriptionamount' in contractStructure:
+                            process_minimum_subscriptionamount(contractStructure, connection)
+                            connection = create_database_connection('system_dbs', {'db_name':'system'})
+                            connection.execute('update activecontracts set status="closed", closeDate="{}", expiryDate="{}" where contractName="{}" and contractAddress="{}"'.format(blockinfo['time'], blockinfo['time'], query.contractName, query.contractAddress))
+                            connection.execute('update time_actions set status="closed" where contractName="{}" and contractAddress="{}"'.format(query.contractName, query.contractAddress))
+                            connection.close()
+                            return
+                        
+                        # Trigger the contract
+                        success_returnval = trigger_internal_contract(tokenAmount_sum, contractStructure, transaction_data, blockinfo, parsed_data, connection, contract_name=query.contractName, contract_address=query.contractAddress, transaction_subType='expiryTime')
+                        if not success_returnval:
+                            return 0
+
+                        connection = create_database_connection('system_dbs', {'db_name':'system'})
+                        connection.execute('update activecontracts set status="closed", closeDate="{}", expiryDate="{}" where contractName="{}" and contractAddress="{}"'.format(blockinfo['time'], blockinfo['time'], query.contractName, query.contractAddress))
+                        connection.execute('update time_actions set status="closed" where contractName="{}" and contractAddress="{}"'.format(query.contractName, query.contractAddress))
+                        connection.close()
+                        return
+                     
+
 def processTransaction(transaction_data, parsed_data, blockinfo):
     # Do the necessary checks for the inputs and outputs
     # todo Rule 38 - Here we are doing FLO processing. We attach asset amounts to a FLO address, so every FLO address
@@ -1994,17 +2183,17 @@ def processTransaction(transaction_data, parsed_data, blockinfo):
                                                     keyword='',
                                                     object_format='',
                                                     blockNumber=transaction_data['blockheight']))
-                    if 'payeeAddress' in parsed_data['contractConditions']:
-                        session.add(TimeActions(time=parsed_data['contractConditions']['expiryTime'], 
-                                                activity='contract-trigger',
-                                                status='active',
-                                                contractName=parsed_data['contractName'],
-                                                contractAddress=inputadd,
-                                                contractType='one-time-event-trigger',
-                                                tokens_db=json.dumps([parsed_data['tokenIdentification']]),
-                                                parsed_data=json.dumps(parsed_data),
-                                                transactionHash=transaction_data['txid'],
-                                                blockNumber=transaction_data['blockheight']))
+
+                    session.add(TimeActions(time=parsed_data['contractConditions']['expiryTime'], 
+                                            activity='contract-time-trigger',
+                                            status='active',
+                                            contractName=parsed_data['contractName'],
+                                            contractAddress=inputadd,
+                                            contractType='one-time-event-trigger',
+                                            tokens_db=json.dumps([parsed_data['tokenIdentification']]),
+                                            parsed_data=json.dumps(parsed_data),
+                                            transactionHash=transaction_data['txid'],
+                                            blockNumber=transaction_data['blockheight']))
 
                     session.commit()
                     session.close()