brawny 0.1.13__py3-none-any.whl → 0.1.22__py3-none-any.whl

brawny/tx/intent.py

@@ -17,10 +17,14 @@ from uuid import UUID, uuid4
 from brawny.logging import LogEvents, get_logger
 from brawny.metrics import INTENT_TRANSITIONS, get_metrics
 from brawny.model.enums import IntentStatus
+from brawny.model.errors import CancelledCheckError
 from brawny.model.types import TxIntent, TxIntentSpec, Trigger, idempotency_key
+from brawny.types import ClaimedIntent
+from brawny.utils import db_address, is_valid_address
 
 if TYPE_CHECKING:
     from brawny.db.base import Database
+    from brawny.model.contexts import CancellationToken
 
 logger = get_logger(__name__)
 
@@ -58,6 +62,7 @@ def create_intent(
     broadcast_group: str | None = None,
     broadcast_endpoints: list[str] | None = None,
     trigger: Trigger | None = None,
+    cancellation_token: "CancellationToken | None" = None,
 ) -> tuple[TxIntent, bool]:
     """Create a new transaction intent with idempotency.
 
@@ -76,13 +81,28 @@ def create_intent(
     Returns:
         Tuple of (intent, is_new) where is_new is True if newly created
     """
+    # Resolve signer alias early; idempotency is scoped to canonical address.
+    signer_alias: str | None = None
+    if is_valid_address(spec.signer_address):
+        resolved_signer = spec.signer_address
+    else:
+        if isinstance(spec.signer_address, str) and spec.signer_address.startswith("0x"):
+            raise ValueError(f"Invalid signer address: {spec.signer_address}")
+        from brawny.api import get_address_from_alias
+
+        signer_alias = spec.signer_address
+        resolved_signer = get_address_from_alias(spec.signer_address)
+
+    canonical_signer = db_address(resolved_signer)
+    canonical_to = db_address(spec.to_address)
+
     # Generate idempotency key from job_id and parts
     idem_key = idempotency_key(job_id, *idem_parts)
 
     # Check for existing intent (scoped to chain + signer)
     existing = db.get_intent_by_idempotency_key(
         chain_id=chain_id,
-        signer_address=spec.signer_address.lower(),
+        signer_address=canonical_signer,
         idempotency_key=idem_key,
     )
     if existing:
@@ -91,12 +111,15 @@ def create_intent(
             job_id=job_id,
             idempotency_key=idem_key,
             chain_id=chain_id,
-            signer=spec.signer_address.lower(),
+            signer=canonical_signer,
             existing_intent_id=str(existing.intent_id),
             existing_status=existing.status.value,
         )
         return existing, False
 
+    if cancellation_token is not None and cancellation_token.cancelled:
+        raise CancelledCheckError("Check cancelled before intent creation")
+
     # Calculate deadline if specified
     deadline_ts: datetime | None = None
     if spec.deadline_seconds:
@@ -118,9 +141,10 @@ def create_intent(
         intent_id=intent_id,
         job_id=job_id,
         chain_id=chain_id,
-        signer_address=spec.signer_address.lower(),
+        signer_address=canonical_signer,
+        signer_alias=signer_alias,
         idempotency_key=idem_key,
-        to_address=spec.to_address.lower(),
+        to_address=canonical_to,
         data=spec.data,
         value_wei=spec.value_wei,
         gas_limit=spec.gas_limit,
@@ -138,7 +162,7 @@ def create_intent(
         # This is expected with idempotency - just get the existing one
         existing = db.get_intent_by_idempotency_key(
             chain_id=chain_id,
-            signer_address=spec.signer_address.lower(),
+            signer_address=canonical_signer,
             idempotency_key=idem_key,
         )
         if existing:
@@ -147,7 +171,7 @@ def create_intent(
                 job_id=job_id,
                 idempotency_key=idem_key,
                 chain_id=chain_id,
-                signer=spec.signer_address.lower(),
+                signer=canonical_signer,
                 existing_intent_id=str(existing.intent_id),
                 note="race_condition",
             )
@@ -160,8 +184,8 @@ def create_intent(
         intent_id=str(intent.intent_id),
         job_id=job_id,
         idempotency_key=idem_key,
-        signer=spec.signer_address,
-        to=spec.to_address,
+        signer=canonical_signer,
+        to=canonical_to,
     )
 
     return intent, True
@@ -207,11 +231,11 @@ def claim_intent(
     db: Database,
     worker_id: str,
     claimed_by: str | None = None,
-) -> TxIntent | None:
+    lease_seconds: int = 300,
+) -> ClaimedIntent | None:
     """Claim the next available intent for processing.
 
-    Uses FOR UPDATE SKIP LOCKED (PostgreSQL) or
-    IMMEDIATE transaction locking (SQLite) to prevent
+    Uses IMMEDIATE transaction locking (SQLite) to prevent
     multiple workers from claiming the same intent.
 
     Args:
@@ -224,18 +248,21 @@ def claim_intent(
     # Generate unique claim token
     claim_token = f"{worker_id}_{uuid4().hex[:8]}"
 
-    intent = db.claim_next_intent(claim_token, claimed_by=claimed_by)
+    claimed = db.claim_next_intent(
+        claim_token,
+        claimed_by=claimed_by,
+        lease_seconds=lease_seconds,
+    )
 
-    if intent:
+    if claimed:
         logger.info(
             LogEvents.INTENT_CLAIM,
-            intent_id=str(intent.intent_id),
-            job_id=intent.job_id,
+            intent_id=str(claimed.intent_id),
             worker_id=worker_id,
             claim_token=claim_token,
         )
 
-    return intent
+    return claimed
 
 
 def release_claim(db: Database, intent_id: UUID) -> bool:
@@ -297,6 +324,8 @@ def transition_intent(
     to_status: IntentStatus,
     reason: str,
     chain_id: int | None = None,
+    actor: str | None = None,
+    source: str | None = None,
 ) -> bool:
     """Transition an intent using the centralized transition map.
 
@@ -333,6 +362,15 @@ def transition_intent(
             to_status=to_status.value,
             reason=reason,
         )
+        db.record_mutation_audit(
+            entity_type="intent",
+            entity_id=str(intent_id),
+            action=f"transition:{to_status.value}",
+            actor=actor,
+            reason=reason,
+            source=source,
+            metadata={"from_status": old_status, "to_status": to_status.value},
+        )
         logger.info(
             "intent.transition",
             intent_id=str(intent_id),

brawny/tx/monitor.py

@@ -30,6 +30,7 @@ from brawny.metrics import (
 from brawny.model.enums import AttemptStatus, IntentStatus, NonceStatus
 from brawny.model.errors import DatabaseError, FailureType, FailureStage
 from brawny._rpc.errors import RPCError
+from brawny.timeout import Deadline
 from brawny.tx.intent import transition_intent
 
 if TYPE_CHECKING:
@@ -37,11 +38,13 @@ if TYPE_CHECKING:
     from brawny.db.base import Database
     from brawny.lifecycle import LifecycleDispatcher
     from brawny.model.types import TxAttempt, TxIntent
-    from brawny._rpc.manager import RPCManager
+    from brawny._rpc.clients import ReadClient
     from brawny.tx.nonce import NonceManager
 
 logger = get_logger(__name__)
 
+MONITOR_TICK_TIMEOUT_SECONDS = 10.0
+
 
 class ConfirmationResult(str, Enum):
     """Result of confirmation monitoring."""
@@ -78,7 +81,7 @@ class TxMonitor:
     def __init__(
         self,
         db: Database,
-        rpc: RPCManager,
+        rpc: ReadClient,
         nonce_manager: NonceManager,
         config: Config,
         lifecycle: "LifecycleDispatcher | None" = None,
@@ -101,6 +104,7 @@ class TxMonitor:
         self,
         intent: TxIntent,
         attempt: TxAttempt,
+        deadline: Deadline | None = None,
     ) -> ConfirmationStatus:
         """Check confirmation status for a transaction attempt.
 
@@ -114,6 +118,8 @@ class TxMonitor:
         Returns:
             Current confirmation status
         """
+        if deadline is not None and deadline.expired():
+            return ConfirmationStatus(result=ConfirmationResult.PENDING)
         if not attempt.tx_hash:
             logger.warning(
                 "monitor.no_tx_hash",
@@ -123,11 +129,11 @@ class TxMonitor:
             return ConfirmationStatus(result=ConfirmationResult.PENDING)
 
         # Get receipt
-        receipt = self._rpc.get_transaction_receipt(attempt.tx_hash)
+        receipt = self._rpc.get_transaction_receipt(attempt.tx_hash, deadline=deadline)
 
         if receipt is None:
             # No receipt yet - check if nonce has been consumed by another tx
-            if self._is_nonce_consumed(intent, attempt):
+            if self._is_nonce_consumed(intent, attempt, deadline):
                 metrics = get_metrics()
                 metrics.counter(TX_FAILED).inc(
                     chain_id=intent.chain_id,
@@ -137,7 +143,7 @@ class TxMonitor:
                 return ConfirmationStatus(result=ConfirmationResult.DROPPED)
 
             # Check if stuck
-            if self._is_stuck(attempt):
+            if self._is_stuck(attempt, deadline):
                 metrics = get_metrics()
                 metrics.counter(TX_FAILED).inc(
                     chain_id=intent.chain_id,
@@ -161,7 +167,7 @@ class TxMonitor:
 
         # Verify block hash matches current chain
         try:
-            current_block = self._rpc.get_block(receipt_block_number)
+            current_block = self._rpc.get_block(receipt_block_number, deadline=deadline)
             current_hash = current_block.get("hash")
             if hasattr(current_hash, "hex"):
                 current_hash = current_hash.hex()
@@ -188,7 +194,7 @@ class TxMonitor:
             return ConfirmationStatus(result=ConfirmationResult.PENDING)
 
         # Count confirmations
-        current_block_number = self._rpc.get_block_number()
+        current_block_number = self._rpc.get_block_number(deadline=deadline)
         confirmations = current_block_number - receipt_block_number + 1
 
         # Check if confirmed with enough confirmations
@@ -241,7 +247,12 @@ class TxMonitor:
             block_hash=receipt_block_hash,
         )
 
-    def _is_nonce_consumed(self, intent: TxIntent, attempt: TxAttempt) -> bool:
+    def _is_nonce_consumed(
+        self,
+        intent: TxIntent,
+        attempt: TxAttempt,
+        deadline: Deadline | None,
+    ) -> bool:
         """Check if the nonce has been consumed by another transaction.
 
         Args:
@@ -257,12 +268,13 @@ class TxMonitor:
             chain_nonce = self._rpc.get_transaction_count(
                 signer_address,
                 "latest",  # Use "latest" not "pending" to check confirmed
+                deadline=deadline,
             )
 
             # If chain nonce is greater than our nonce, it was consumed
             if chain_nonce > attempt.nonce:
                 # Verify our tx isn't the one that consumed it
-                receipt = self._rpc.get_transaction_receipt(attempt.tx_hash)
+                receipt = self._rpc.get_transaction_receipt(attempt.tx_hash, deadline=deadline)
                 if receipt is None:
                     # Nonce consumed but not by our tx
                     logger.warning(
@@ -281,7 +293,7 @@ class TxMonitor:
             )
             return False
 
-    def _is_stuck(self, attempt: TxAttempt) -> bool:
+    def _is_stuck(self, attempt: TxAttempt, deadline: Deadline | None) -> bool:
         """Check if transaction is stuck.
 
         Stuck is defined as:
@@ -304,7 +316,7 @@ class TxMonitor:
 
         # Check blocks elapsed
         try:
-            current_block = self._rpc.get_block_number()
+            current_block = self._rpc.get_block_number(deadline=deadline)
             blocks_since = current_block - attempt.broadcast_block
             if blocks_since > self._config.stuck_tx_blocks:
                 return True
@@ -584,10 +596,17 @@ class TxMonitor:
         }
 
         pending = self.get_pending_attempts()
+        deadline = Deadline.from_seconds(MONITOR_TICK_TIMEOUT_SECONDS)
 
         for intent, attempt in pending:
+            if deadline.expired():
+                logger.warning(
+                    "monitor.tick_timeout",
+                    pending_remaining=len(pending),
+                )
+                break
             try:
-                status = self.check_confirmation(intent, attempt)
+                status = self.check_confirmation(intent, attempt, deadline=deadline)
 
                 if status.result == ConfirmationResult.CONFIRMED:
                     self.handle_confirmed(intent, attempt, status)