fix: resolve split-payments lint failures

Author: brendanjryan

src/mpp/methods/tempo/intents.py

@@ -59,8 +59,8 @@ def _parse_memo_bytes(memo: str | None) -> bytes | None:
     hex_str = memo[2:] if memo.startswith("0x") else memo
     try:
         b = bytes.fromhex(hex_str)
-    except ValueError:
-        raise VerificationError(f"Invalid memo hex: {memo}")
+    except ValueError as err:
+        raise VerificationError(f"Invalid memo hex: {memo}") from err
     if len(b) != 32:
         raise VerificationError(f"Memo must be exactly 32 bytes, got {len(b)}")
     return b
@@ -87,11 +87,13 @@ def get_transfers(
     the top-level memo. Split transfers follow in declaration order.
     """
     if not splits:
-        return [Transfer(
-            amount=total_amount,
-            recipient=primary_recipient,
-            memo=_parse_memo_bytes(primary_memo),
-        )]
+        return [
+            Transfer(
+                amount=total_amount,
+                recipient=primary_recipient,
+                memo=_parse_memo_bytes(primary_memo),
+            )
+        ]
 
     if len(splits) > MAX_SPLITS:
         raise VerificationError(f"Too many splits: {len(splits)} (max {MAX_SPLITS})")
@@ -104,23 +106,27 @@ def get_transfers(
         if amt <= 0:
             raise VerificationError("Split amount must be greater than zero")
         split_sum += amt
-        split_transfers.append(Transfer(
-            amount=amt,
-            recipient=s.recipient,
-            memo=_parse_memo_bytes(s.memo),
-        ))
+        split_transfers.append(
+            Transfer(
+                amount=amt,
+                recipient=s.recipient,
+                memo=_parse_memo_bytes(s.memo),
+            )
+        )
 
     if split_sum >= total_amount:
         raise VerificationError(
             f"Sum of splits ({split_sum}) must be less than total amount ({total_amount})"
         )
 
     primary_amount = total_amount - split_sum
-    transfers = [Transfer(
-        amount=primary_amount,
-        recipient=primary_recipient,
-        memo=_parse_memo_bytes(primary_memo),
-    )]
+    transfers = [
+        Transfer(
+            amount=primary_amount,
+            recipient=primary_recipient,
+            memo=_parse_memo_bytes(primary_memo),
+        )
+    ]
     transfers.extend(split_transfers)
     return transfers
 
@@ -506,12 +512,16 @@ def _verify_transfer_logs(
         if len(expected) == 1:
             t = expected[0]
             return self._verify_single_transfer_log(
-                receipt, request.currency, t.recipient, t.amount, t.memo,
+                receipt,
+                request.currency,
+                t.recipient,
+                t.amount,
+                t.memo,
                 expected_sender,
             )
 
         # Multi-transfer: order-insensitive matching
-        sorted_expected = sorted(expected, key=lambda t: (0 if t.memo else 1))
+        sorted_expected = sorted(expected, key=lambda t: 0 if t.memo else 1)
         logs = receipt.get("logs", [])
         used_logs: set[int] = set()
 
@@ -547,7 +557,10 @@ def _verify_transfer_logs(
                     amount = int(data[2:66], 16)
                     memo_topic = topics[3]
                     expected_memo_hex = "0x" + transfer.memo.hex()
-                    if amount == transfer.amount and memo_topic.lower() == expected_memo_hex.lower():
+                    if (
+                        amount == transfer.amount
+                        and memo_topic.lower() == expected_memo_hex.lower()
+                    ):
                         used_logs.add(log_idx)
                         found = True
                         break
@@ -778,7 +791,7 @@ def _validate_calls(self, calls: tuple, request: ChargeRequest) -> None:
             request.methodDetails.splits,
         )
 
-        sorted_expected = sorted(expected, key=lambda t: (0 if t.memo else 1))
+        sorted_expected = sorted(expected, key=lambda t: 0 if t.memo else 1)
         used_calls: set[int] = set()
 
         for transfer in sorted_expected:
@@ -830,7 +843,7 @@ def _validate_transaction_payload(self, signature: str, request: ChargeRequest)
             request.methodDetails.splits,
         )
 
-        sorted_expected = sorted(expected, key=lambda t: (0 if t.memo else 1))
+        sorted_expected = sorted(expected, key=lambda t: 0 if t.memo else 1)
         used_calls: set[int] = set()
 
         for transfer in sorted_expected:
@@ -843,7 +856,9 @@ def _validate_transaction_payload(self, signature: str, request: ChargeRequest)
                 call_to_bytes, call_data_bytes = call_item[0], call_item[2]
                 if not call_to_bytes or not call_data_bytes:
                     continue
-                to_hex = call_to_bytes.hex() if isinstance(call_to_bytes, bytes) else str(call_to_bytes)
+                to_hex = (
+                    call_to_bytes.hex() if isinstance(call_to_bytes, bytes) else str(call_to_bytes)
+                )
                 if ("0x" + to_hex).lower() != request.currency.lower():
                     continue
                 raw = call_data_bytes

tests/test_tempo.py

@@ -28,7 +28,6 @@
     TRANSFER_WITH_MEMO_SELECTOR,
     TRANSFER_WITH_MEMO_TOPIC,
     ChargeIntent,
-    Transfer,
     _match_single_transfer_calldata,
     _match_transfer_calldata,
     _parse_memo_bytes,
@@ -2498,23 +2497,54 @@ def test_empty_splits_returns_single_transfer(self) -> None:
         assert len(transfers) == 1
 
     def test_single_split(self) -> None:
-        splits = [Split(amount="300000", recipient="0x1111111111111111111111111111111111111111")]
-        transfers = get_transfers(1_000_000, "0x2222222222222222222222222222222222222222", None, splits)
+        splits = [
+            Split(
+                amount="300000",
+                recipient="0x1111111111111111111111111111111111111111",
+            )
+        ]
+        transfers = get_transfers(
+            1_000_000,
+            "0x2222222222222222222222222222222222222222",
+            None,
+            splits,
+        )
         assert len(transfers) == 2
         assert transfers[0].amount == 700_000  # primary gets remainder
         assert transfers[1].amount == 300_000
 
     def test_primary_inherits_memo(self) -> None:
         memo = "0x" + "ab" * 32
-        splits = [Split(amount="100000", recipient="0x1111111111111111111111111111111111111111")]
-        transfers = get_transfers(1_000_000, "0x2222222222222222222222222222222222222222", memo, splits)
+        splits = [
+            Split(
+                amount="100000",
+                recipient="0x1111111111111111111111111111111111111111",
+            )
+        ]
+        transfers = get_transfers(
+            1_000_000,
+            "0x2222222222222222222222222222222222222222",
+            memo,
+            splits,
+        )
         assert transfers[0].memo is not None
         assert transfers[1].memo is None
 
     def test_split_with_memo(self) -> None:
         split_memo = "0x" + "cd" * 32
-        splits = [Split(amount="100000", recipient="0x1111111111111111111111111111111111111111", memo=split_memo)]
-        transfers = get_transfers(1_000_000, "0x2222222222222222222222222222222222222222", None, splits)
+        splits = [
+            Split(
+                amount="100000",
+                recipient="0x1111111111111111111111111111111111111111",
+                memo=split_memo,
+            )
+        ]
+        transfers = get_transfers(
+            1_000_000,
+            "0x2222222222222222222222222222222222222222",
+            None,
+            splits,
+        )
         assert transfers[1].memo is not None
         assert transfers[1].memo[0] == 0xCD
 
@@ -2524,7 +2554,12 @@ def test_multiple_splits_preserve_order(self) -> None:
             Split(amount="200000", recipient="0x2222222222222222222222222222222222222222"),
             Split(amount="50000", recipient="0x3333333333333333333333333333333333333333"),
         ]
-        transfers = get_transfers(1_000_000, "0x4444444444444444444444444444444444444444", None, splits)
+        transfers = get_transfers(
+            1_000_000,
+            "0x4444444444444444444444444444444444444444",
+            None,
+            splits,
+        )
         assert len(transfers) == 4
         assert transfers[0].amount == 650_000  # primary
         assert transfers[1].amount == 100_000
@@ -2548,18 +2583,21 @@ def test_rejects_zero_split_amount(self) -> None:
 
     def test_rejects_too_many_splits(self) -> None:
         splits = [
-            Split(amount="1000", recipient=f"0x{hex(i + 2)[2:].zfill(40)}")
-            for i in range(11)
+            Split(amount="1000", recipient=f"0x{hex(i + 2)[2:].zfill(40)}") for i in range(11)
         ]
         with pytest.raises(VerificationError, match="Too many splits"):
             get_transfers(1_000_000, "0x0000000000000000000000000000000000000001", None, splits)
 
     def test_max_splits_allowed(self) -> None:
         splits = [
-            Split(amount="1000", recipient=f"0x{hex(i + 2)[2:].zfill(40)}")
-            for i in range(10)
+            Split(amount="1000", recipient=f"0x{hex(i + 2)[2:].zfill(40)}") for i in range(10)
         ]
-        transfers = get_transfers(1_000_000, "0x0000000000000000000000000000000000000001", None, splits)
+        transfers = get_transfers(
+            1_000_000,
+            "0x0000000000000000000000000000000000000001",
+            None,
+            splits,
+        )
         assert len(transfers) == 11
         assert transfers[0].amount == 990_000
 
@@ -2778,18 +2816,50 @@ class TestMatchSingleTransferCalldata:
     AMOUNT = 1000000
     MEMO = bytes.fromhex("ab" * 32)
 
-    def _build_calldata(self, selector: str, recipient: str, amount: int, memo_hex: str = "") -> str:
+    def _build_calldata(
+        self,
+        selector: str,
+        recipient: str,
+        amount: int,
+        memo_hex: str = "",
+    ) -> str:
         to_padded = recipient[2:].lower().zfill(64)
         amount_padded = hex(amount)[2:].zfill(64)
         return f"{selector}{to_padded}{amount_padded}{memo_hex}"
 
     def test_memo_requires_transfer_with_memo_selector(self) -> None:
-        calldata = self._build_calldata(TRANSFER_SELECTOR, self.RECIPIENT, self.AMOUNT, "ab" * 32)
-        assert _match_single_transfer_calldata(calldata, self.RECIPIENT, self.AMOUNT, self.MEMO) is False
+        calldata = self._build_calldata(
+            TRANSFER_SELECTOR,
+            self.RECIPIENT,
+            self.AMOUNT,
+            "ab" * 32,
+        )
+        assert (
+            _match_single_transfer_calldata(
+                calldata,
+                self.RECIPIENT,
+                self.AMOUNT,
+                self.MEMO,
+            )
+            is False
+        )
 
     def test_memo_accepts_correct_selector(self) -> None:
-        calldata = self._build_calldata(TRANSFER_WITH_MEMO_SELECTOR, self.RECIPIENT, self.AMOUNT, "ab" * 32)
-        assert _match_single_transfer_calldata(calldata, self.RECIPIENT, self.AMOUNT, self.MEMO) is True
+        calldata = self._build_calldata(
+            TRANSFER_WITH_MEMO_SELECTOR,
+            self.RECIPIENT,
+            self.AMOUNT,
+            "ab" * 32,
+        )
+        assert (
+            _match_single_transfer_calldata(
+                calldata,
+                self.RECIPIENT,
+                self.AMOUNT,
+                self.MEMO,
+            )
+            is True
+        )
 
     def test_no_memo_rejects_transfer_with_memo_selector(self) -> None:
         """When no memo expected, transferWithMemo calldata must be rejected."""
@@ -2832,10 +2902,14 @@ def test_single_transfer_rejects_transfer_with_memo_log(self) -> None:
             methodDetails=MethodDetails(),
         )
         receipt = {
-            "logs": [self._make_log(
-                TRANSFER_WITH_MEMO_TOPIC, self.RECIPIENT, self.AMOUNT,
-                memo="0x" + "ff" * 32,
-            )],
+            "logs": [
+                self._make_log(
+                    TRANSFER_WITH_MEMO_TOPIC,
+                    self.RECIPIENT,
+                    self.AMOUNT,
+                    memo="0x" + "ff" * 32,
+                )
+            ],
         }
         assert intent._verify_transfer_logs(receipt, request) is False
 
@@ -2856,7 +2930,9 @@ def test_multi_split_rejects_transfer_with_memo_log_for_memoless(self) -> None:
                 self._make_log(TRANSFER_TOPIC, self.RECIPIENT, 700000),
                 # split as TransferWithMemo (should be rejected)
                 self._make_log(
-                    TRANSFER_WITH_MEMO_TOPIC, self.SPLIT_RECIPIENT, 300000,
+                    TRANSFER_WITH_MEMO_TOPIC,
+                    self.SPLIT_RECIPIENT,
+                    300000,
                     memo="0x" + "ff" * 32,
                 ),
             ],
@@ -2869,8 +2945,8 @@ class TestSplitsFeePayerRejection:
 
     @pytest.mark.anyio
     async def test_splits_with_fee_payer_raises(self, monkeypatch: pytest.MonkeyPatch) -> None:
-        from mpp.server import Mpp
         from mpp.methods.tempo import tempo
+        from mpp.server import Mpp
 
         monkeypatch.setenv("MPP_SECRET_KEY", "test-secret-key")
         server = Mpp.create(
@@ -2883,7 +2959,12 @@ async def test_splits_with_fee_payer_raises(self, monkeypatch: pytest.MonkeyPatc
             await server.charge(
                 authorization=None,
                 amount="1.00",
-                splits=[{"amount": "300000", "recipient": "0x1111111111111111111111111111111111111111"}],
+                splits=[
+                    {
+                        "amount": "300000",
+                        "recipient": "0x1111111111111111111111111111111111111111",
+                    }
+                ],
                 fee_payer=True,
             )
 
@@ -2900,11 +2981,23 @@ def test_short_primary_memo_raises(self) -> None:
             get_transfers(1_000_000, "0x01", "0x" + "ab" * 10, None)
 
     def test_invalid_split_memo_raises(self) -> None:
-        splits = [Split(amount="100000", recipient="0x1111111111111111111111111111111111111111", memo="badhex")]
+        splits = [
+            Split(
+                amount="100000",
+                recipient="0x1111111111111111111111111111111111111111",
+                memo="badhex",
+            )
+        ]
         with pytest.raises(VerificationError, match="Invalid memo hex"):
             get_transfers(1_000_000, "0x01", None, splits)
 
     def test_short_split_memo_raises(self) -> None:
-        splits = [Split(amount="100000", recipient="0x1111111111111111111111111111111111111111", memo="0x" + "ab" * 5)]
+        splits = [
+            Split(
+                amount="100000",
+                recipient="0x1111111111111111111111111111111111111111",
+                memo="0x" + "ab" * 5,
+            )
+        ]
         with pytest.raises(VerificationError, match="exactly 32 bytes"):
             get_transfers(1_000_000, "0x01", None, splits)