feat: appeals undetermined transactions (#657)

* feat: add rollup transaction db table

* fix: drop audit table, change id and nonce of rollup, only make one finalized rollup transaction

* create rollup transaction for every validator

* add function to mock in consensus test

* feat: add appeal window, accepted queue, basic test

* fix: old tests were stuck on accepted state, add usage of thread

* refactor consensus into states

* feat: added appeal flow when transaction is accepted including the loop when appeal failed and succeeded

* fix: adding tests for appeals and fixing minor bugs

* refactor: merge main and PR #573 into this branch

* feat: add appeal_failed in db, select new validators when appealed based on formula

* docs: cleanup consensus mechanism base file

* test: checking the number of validators for different appeals

* feat: adding appeal window to undetermined state

* feat: change timestamp_accepted and add appeal_undetermined in database

* feat: undetermined to pending, activate frontend button in undetermined state and add button also to modal

* feat: leader only has no appeal button and no appeal window

* feat: implement the state transitions to process the appeal
- Add N+2 validators, remove leader
- Use latest data of transaction when in pending state and not the old one from the crawler
- Write consensus data before setting status to have it updated in frontend when going to transaction info modal
- Do not deploy contract when transaction was in the undetermined state

* test: add test for leader appeals

* refactor: merge 593-appeals-add-validators-when-appealed into 604-appeals-implement-sequential-appeals-fail

* refactor: merging changed file permissions

* fix: appealing a write method gave a KeyError because of wrong conversation of transaction

* docs: update transaction_processor argument description

* fix: all appeals disagreed because of pending_transactions type

* refactor: undo change because of merge

* fix: do not reset finality window when leader appeal failed, leader_only check in appeal_window

* fix: set value in database migration file

* fix: add leader_only check for modal appeal button, comment out modal appeal button

* fix: do not show appeal button when finality window is finished, checking on finalized state gave a small delay in showing when appeal failed and finality window was exceeded

* fix: we do not emit messages when the transaction goes from undetermined to finalized

* fix: complete merge

* fix: redirect leader appeal is processed by appeal queue, not pending queue

* fix: test increase wait time to get to finalized

* fix: use appeal property of the transaction in frontend

* fix: comment out appeal buttons

* refactor: clean up prints

* fix: check status typo

* fix: update consensus test

* fix: update test_get_highest_timestamp

---------

Co-authored-by: Cristiam Da Silva <cristiam86@gmail.com>

Author: kstroobants

backend/consensus/base.py

@@ -18,7 +18,9 @@ def __init__(self, session: Session):
         self.all_validators = self.validators_registry.get_all_validators()
         self.pending_transactions = self._load_pending_transactions()
         self.num_validators = len(self.all_validators)
-        self.accepted_transactions = self._load_accepted_transactions()
+        self.accepted_undetermined_transactions = (
+            self._load_accepted_undetermined_transactions()
+        )
 
     def _load_pending_transactions(self) -> List[dict]:
         """Load and return the list of pending transactions from the database."""
@@ -41,19 +43,23 @@ def get_all_validators(self):
         """Return the list of all validators."""
         return self.all_validators
 
-    def _load_accepted_transactions(self) -> List[dict]:
-        """Load and return the list of accepted transactions from the database."""
+    def _load_accepted_undetermined_transactions(self) -> List[dict]:
+        """Load and return the list of accepted and undetermined transactions from the database."""
 
         accepted_transactions = (
             self.session.query(Transactions)
-            .filter(Transactions.status == TransactionStatus.ACCEPTED)
+            .filter(
+                (Transactions.status == TransactionStatus.ACCEPTED)
+                | (Transactions.status == TransactionStatus.UNDETERMINED)
+            )
+            .order_by(Transactions.timestamp_awaiting_finalization)
             .all()
         )
         return [
             TransactionsProcessor._parse_transaction_data(transaction)
             for transaction in accepted_transactions
         ]
 
-    def get_accepted_transactions(self):
-        """Return the list of accepted transactions."""
-        return self.accepted_transactions
+    def get_accepted_undetermined_transactions(self):
+        """Return the list of accepted and undetermined transactions."""
+        return self.accepted_undetermined_transactions

backend/database_handler/chain_snapshot.py

@@ -0,0 +1,55 @@
+"""appeal_undetermined
+
+Revision ID: a4a32d27dde2
+Revises: 2a4ac5eb9455
+Create Date: 2024-11-25 14:49:46.916279
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = "a4a32d27dde2"
+down_revision: Union[str, None] = "2a4ac5eb9455"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column(
+        "transactions", sa.Column("appeal_undetermined", sa.Boolean(), nullable=True)
+    )
+    op.execute(
+        "UPDATE transactions SET appeal_undetermined = FALSE WHERE appeal_undetermined IS NULL"
+    )
+    op.alter_column("transactions", "appeal_undetermined", nullable=False)
+    op.add_column(
+        "transactions",
+        sa.Column("timestamp_awaiting_finalization", sa.BigInteger(), nullable=True),
+    )
+    op.execute(
+        "UPDATE transactions SET timestamp_awaiting_finalization = 0 WHERE timestamp_awaiting_finalization IS NULL"
+    )
+    op.drop_column("transactions", "timestamp_accepted")
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column(
+        "transactions",
+        sa.Column(
+            "timestamp_accepted", sa.BIGINT(), autoincrement=False, nullable=True
+        ),
+    )
+    op.execute(
+        "UPDATE transactions SET timestamp_accepted = 0 WHERE timestamp_accepted IS NULL"
+    )
+    op.drop_column("transactions", "timestamp_awaiting_finalization")
+    op.drop_column("transactions", "appeal_undetermined")
+    # ### end Alembic commands ###

backend/database_handler/migration/versions/a4a32d27dde2_appeal_undetermined.py

@@ -116,7 +116,10 @@ class Transactions(Base):
         init=False,
     )
     appealed: Mapped[bool] = mapped_column(Boolean, default=False)
-    timestamp_accepted: Mapped[Optional[int]] = mapped_column(BigInteger, default=None)
+    appeal_undetermined: Mapped[bool] = mapped_column(Boolean, default=False)
+    timestamp_awaiting_finalization: Mapped[Optional[int]] = mapped_column(
+        BigInteger, default=None
+    )
 
 
 class Validators(Base):

backend/database_handler/models.py

@@ -63,8 +63,9 @@ def _parse_transaction_data(transaction_data: Transactions) -> dict:
             ],
             "ghost_contract_address": transaction_data.ghost_contract_address,
             "appealed": transaction_data.appealed,
-            "timestamp_accepted": transaction_data.timestamp_accepted,
+            "timestamp_awaiting_finalization": transaction_data.timestamp_awaiting_finalization,
             "appeal_failed": transaction_data.appeal_failed,
+            "appeal_undetermined": transaction_data.appeal_undetermined,
         }
 
     @staticmethod
@@ -171,8 +172,9 @@ def insert_transaction(
             ),
             ghost_contract_address=ghost_contract_address,
             appealed=False,
-            timestamp_accepted=None,
+            timestamp_awaiting_finalization=None,
             appeal_failed=0,
+            appeal_undetermined=False,
         )
 
         self.session.add(new_transaction)
@@ -293,21 +295,27 @@ def set_transaction_appeal(self, transaction_hash: str, appeal: bool):
         transaction = (
             self.session.query(Transactions).filter_by(hash=transaction_hash).one()
         )
-        if (transaction.status == TransactionStatus.ACCEPTED.value) or (
-            transaction.status == TransactionStatus.UNDETERMINED.value
+        # You can only appeal the transaction if it is in accepted or undetermined state
+        # Setting it to false is always allowed
+        if (
+            (not appeal)
+            or (transaction.status == TransactionStatus.ACCEPTED)
+            or (transaction.status == TransactionStatus.UNDETERMINED)
         ):
             transaction.appealed = appeal
 
-    def set_transaction_timestamp_accepted(
-        self, transaction_hash: str, timestamp_accepted: int = None
+    def set_transaction_timestamp_awaiting_finalization(
+        self, transaction_hash: str, timestamp_awaiting_finalization: int = None
     ):
         transaction = (
             self.session.query(Transactions).filter_by(hash=transaction_hash).one()
         )
-        if timestamp_accepted:
-            transaction.timestamp_accepted = timestamp_accepted
+        if timestamp_awaiting_finalization:
+            transaction.timestamp_awaiting_finalization = (
+                timestamp_awaiting_finalization
+            )
         else:
-            transaction.timestamp_accepted = int(time.time())
+            transaction.timestamp_awaiting_finalization = int(time.time())
 
     def set_transaction_appeal_failed(self, transaction_hash: str, appeal_failed: int):
         if appeal_failed < 0:
@@ -317,30 +325,38 @@ def set_transaction_appeal_failed(self, transaction_hash: str, appeal_failed: in
         )
         transaction.appeal_failed = appeal_failed
 
+    def set_transaction_appeal_undetermined(
+        self, transaction_hash: str, appeal_undetermined: bool
+    ):
+        transaction = (
+            self.session.query(Transactions).filter_by(hash=transaction_hash).one()
+        )
+        transaction.appeal_undetermined = appeal_undetermined
+
     def get_highest_timestamp(self) -> int:
         transaction = (
             self.session.query(Transactions)
-            .filter(Transactions.timestamp_accepted.isnot(None))
-            .order_by(desc(Transactions.timestamp_accepted))
+            .filter(Transactions.timestamp_awaiting_finalization.isnot(None))
+            .order_by(desc(Transactions.timestamp_awaiting_finalization))
             .first()
         )
         if transaction is None:
             return 0
-        return transaction.timestamp_accepted
+        return transaction.timestamp_awaiting_finalization
 
     def get_transactions_for_block(
         self, block_number: int, include_full_tx: bool
     ) -> dict:
         transactions = (
             self.session.query(Transactions)
-            .filter(Transactions.timestamp_accepted == block_number)
+            .filter(Transactions.timestamp_awaiting_finalization == block_number)
             .all()
         )
 
         block_hash = "0x" + "0" * 64
         parent_hash = "0x" + "0" * 64  # Placeholder for parent block hash
         timestamp = (
-            transactions[0].timestamp_accepted
+            transactions[0].timestamp_awaiting_finalization
             if len(transactions) > 0
             else int(time.time())
         )

backend/database_handler/transactions_processor.py

@@ -83,8 +83,9 @@ class Transaction:
     created_at: str | None = None
     ghost_contract_address: str | None = None
     appealed: bool = False
-    timestamp_accepted: int | None = None
+    timestamp_awaiting_finalization: int | None = None
     appeal_failed: int = 0
+    appeal_undetermined: bool = False
 
     def to_dict(self):
         return {
@@ -106,8 +107,9 @@ def to_dict(self):
             "created_at": self.created_at,
             "ghost_contract_address": self.ghost_contract_address,
             "appealed": self.appealed,
-            "timestamp_accepted": self.timestamp_accepted,
+            "timestamp_awaiting_finalization": self.timestamp_awaiting_finalization,
             "appeal_failed": self.appeal_failed,
+            "appeal_undetermined": self.appeal_undetermined,
         }
 
     @classmethod
@@ -131,6 +133,9 @@ def from_dict(cls, input: dict) -> "Transaction":
             created_at=input.get("created_at"),
             ghost_contract_address=input.get("ghost_contract_address"),
             appealed=input.get("appealed"),
-            timestamp_accepted=input.get("timestamp_accepted"),
+            timestamp_awaiting_finalization=input.get(
+                "timestamp_awaiting_finalization"
+            ),
             appeal_failed=input.get("appeal_failed", 0),
+            appeal_undetermined=input.get("appeal_undetermined", False),
         )

backend/domain/types.py

@@ -18,6 +18,7 @@ const transactionsStore = useTransactionsStore();
 
 const props = defineProps<{
   transaction: TransactionItem;
+  finalityWindow: number;
 }>();
 
 const isDetailsModalOpen = ref(false);
@@ -44,20 +45,17 @@ const shortHash = computed(() => {
   return props.transaction.hash?.slice(0, 6);
 });
 
-const isAppealed = ref(false);
+const appealed = ref(props.transaction.data.appealed);
 
 const handleSetTransactionAppeal = () => {
   transactionsStore.setTransactionAppeal(props.transaction.hash);
-
-  isAppealed.value = true;
+  appealed.value = true;
 };
 
 watch(
-  () => props.transaction.status,
-  (newStatus) => {
-    if (newStatus !== 'ACCEPTED') {
-      isAppealed.value = false;
-    }
+  () => props.transaction.data.appealed,
+  (newVal) => {
+    appealed.value = newVal;
   },
 );
 
@@ -155,8 +153,15 @@ function prettifyTxData(x: any): any {
       <!-- <TransactionStatusBadge
         as="button"
         @click.stop="handleSetTransactionAppeal"
-        :class="{ '!bg-green-500': isAppealed }"
-        v-if="transaction.status == 'ACCEPTED'"
+        :class="{ '!bg-green-500': appealed }"
+        v-if="
+          transaction.data.leader_only == false &&
+          (transaction.status == 'ACCEPTED' ||
+            transaction.status == 'UNDETERMINED') &&
+          Date.now() / 1000 -
+            transaction.data.timestamp_awaiting_finalization <=
+            finalityWindow
+        "
         v-tooltip="'Appeal transaction'"
       >
         <div class="flex items-center gap-1">
@@ -226,6 +231,25 @@ function prettifyTxData(x: any): any {
             >
               {{ transaction.status }}
             </TransactionStatusBadge>
+            <!-- <TransactionStatusBadge
+              as="button"
+              @click.stop="handleSetTransactionAppeal"
+              :class="{ '!bg-green-500': appealed }"
+              v-if="
+                transaction.data.leader_only == false &&
+                (transaction.status == 'ACCEPTED' ||
+                  transaction.status == 'UNDETERMINED') &&
+                Date.now() / 1000 -
+                  transaction.data.timestamp_awaiting_finalization <=
+                  finalityWindow
+              "
+              v-tooltip="'Appeal transaction'"
+            >
+              <div class="flex items-center gap-1">
+                APPEAL
+                <GavelIcon class="h-3 w-3" />
+              </div>
+            </TransactionStatusBadge> -->
           </p>
         </div>
 

frontend/src/components/Simulator/TransactionItem.vue

@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { ref, computed } from 'vue';
+import { ref, computed, defineProps } from 'vue';
 import { useContractsStore, useTransactionsStore } from '@/stores';
 import { TrashIcon } from '@heroicons/vue/24/solid';
 import TransactionItem from './TransactionItem.vue';
@@ -9,6 +9,10 @@ import EmptyListPlaceholder from '@/components/Simulator/EmptyListPlaceholder.vu
 const contractsStore = useContractsStore();
 const transactionsStore = useTransactionsStore();
 
+const props = defineProps({
+  finalityWindow: Number,
+});
+
 const transactions = computed(() => {
   const contractTransactions = transactionsStore.transactions.filter(
     (t) => t.localContractId === contractsStore.currentContractId,
@@ -54,6 +58,7 @@ const handleClearTransactions = () => {
         v-for="transaction in transactions"
         :key="transaction.hash"
         :transaction="transaction"
+        :finalityWindow="props.finalityWindow ?? 0"
       />
     </div>
 

frontend/src/components/Simulator/TransactionsList.vue

@@ -196,7 +196,6 @@ export class JsonRpcService implements IJsonRpcService {
   }
 
   async setFinalityWindowTime(time: number): Promise<any> {
-    console.log('Setting finality window time:', time, 'Type:', typeof time);
     return this.callRpcMethod<any>(
       'sim_setFinalityWindowTime',
       [time],

frontend/src/services/JsonRpcService.ts

@@ -102,7 +102,10 @@ const isFinalityWindowValid = computed(() => {
           id="tutorial-write-methods"
           :leaderOnly="leaderOnly"
         />
-        <TransactionsList id="tutorial-tx-response" />
+        <TransactionsList
+          id="tutorial-tx-response"
+          :finalityWindow="finalityWindow"
+        />
       </template>
     </template>
 

frontend/src/views/Simulator/RunDebugView.vue

@@ -140,13 +140,17 @@ def test_get_highest_timestamp(transactions_processor: TransactionsProcessor):
     )
     transactions_processor.session.commit()
     assert transactions_processor.get_highest_timestamp() == 0
-    transactions_processor.set_transaction_timestamp_accepted(tx1_hash, 1000)
+    transactions_processor.set_transaction_timestamp_awaiting_finalization(
+        tx1_hash, 1000
+    )
 
     # Second transaction with timestamp 2000
     tx2_hash = transactions_processor.insert_transaction(
         from_address, to_address, data, 1.0, 1, 1, True
     )
-    transactions_processor.set_transaction_timestamp_accepted(tx2_hash, 2000)
+    transactions_processor.set_transaction_timestamp_awaiting_finalization(
+        tx2_hash, 2000
+    )
 
     # Third transaction with no timestamp (should be ignored)
     transactions_processor.insert_transaction(