feat: consensus appeal success should rollback all newer transactions to pending

backend/database_handler/chain_snapshot.py

@@ -18,14 +18,17 @@ 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."""
 
         pending_transactions = (
             self.session.query(Transactions)
             .filter(Transactions.status == TransactionStatus.PENDING)
+            .order_by(Transactions.created_at)
             .all()
         )
         return [
@@ -41,19 +44,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/migration/versions/a4a32d27dde2_appeal_undetermined.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/models.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/transactions_processor.py

@@ -61,8 +61,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
@@ -225,8 +226,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)
@@ -348,16 +350,18 @@ def set_transaction_appeal(self, transaction_hash: str, appeal: bool):
         )
         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:
@@ -366,3 +370,32 @@ def set_transaction_appeal_failed(self, transaction_hash: str, appeal_failed: in
             self.session.query(Transactions).filter_by(hash=transaction_hash).one()
         )
         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_newer_transactions(self, transaction_hash: str):
+        transaction = (
+            self.session.query(Transactions).filter_by(hash=transaction_hash).one()
+        )
+        address = transaction.to_address or transaction.from_address
+        transactions = (
+            self.session.query(Transactions)
+            .filter(
+                Transactions.created_at > transaction.created_at,
+                or_(
+                    Transactions.to_address == address,
+                    Transactions.from_address == address,
+                ),
+            )
+            .order_by(Transactions.created_at)
+            .all()
+        )
+        return [
+            self._parse_transaction_data(transaction) for transaction in transactions
+        ]

backend/domain/types.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),
         )

frontend/src/components/Simulator/TransactionItem.vue

@@ -18,6 +18,7 @@
 
 const props = defineProps<{
   transaction: TransactionItem;
+  finalityWindow: number;
 }>();
 
 const isDetailsModalOpen = ref(false);
@@ -55,7 +56,7 @@
 watch(
   () => props.transaction.status,
   (newStatus) => {
-    if (newStatus !== 'ACCEPTED') {
+    if (newStatus !== 'ACCEPTED' && newStatus !== 'UNDETERMINED') {
       isAppealed.value = false;
     }
   },
@@ -156,7 +157,11 @@
         as="button"
         @click.stop="handleSetTransactionAppeal"
         :class="{ '!bg-green-500': isAppealed }"
-        v-if="transaction.status == 'ACCEPTED'"
+        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,22 @@
             >
               {{ transaction.status }}
             </TransactionStatusBadge>
+            <!-- <TransactionStatusBadge
+              as="button"
+              @click.stop="handleSetTransactionAppeal"
+              :class="{ '!bg-green-500': isAppealed }"
+              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/TransactionsList.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 @@
 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 @@
         v-for="transaction in transactions"
         :key="transaction.hash"
         :transaction="transaction"
+        :finalityWindow="props.finalityWindow ?? 0"
       />
     </div>
 

frontend/src/services/JsonRpcService.ts

@@ -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/views/Simulator/RunDebugView.vue

@@ -102,7 +102,10 @@
           id="tutorial-write-methods"
           :leaderOnly="leaderOnly"
         />
-        <TransactionsList id="tutorial-tx-response" />
+        <TransactionsList
+          id="tutorial-tx-response"
+          :finalityWindow="finalityWindow"
+        />
       </template>
     </template>