chore: bump version to 0.3.18

Author: chao-peng-story

setup.py

@@ -5,7 +5,7 @@
 
 setup(
     name="story_protocol_python_sdk",
-    version="0.3.17",
+    version="0.3.18",
     packages=find_packages(where="src", exclude=["tests"]),
     package_dir={"": "src"},
     install_requires=["web3>=7.0.0", "pytest", "python-dotenv", "base58"],

src/story_protocol_python_sdk/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.3.17"
+__version__ = "0.3.18"
 
 from .resources.Dispute import Dispute
 from .resources.IPAccount import IPAccount

src/story_protocol_python_sdk/abi/GroupingModule/GroupingModule_client.py

@@ -47,9 +47,9 @@ def removeIp(self, groupIpId, ipIds):
         return self.contract.functions.removeIp(groupIpId, ipIds).transact()
 
     def build_removeIp_transaction(self, groupIpId, ipIds, tx_params):
-        return self.contract.functions.removeIp(
-            groupIpId, ipIds
-        ).build_transaction(tx_params)
+        return self.contract.functions.removeIp(groupIpId, ipIds).build_transaction(
+            tx_params
+        )
 
     def claimReward(self, groupId, token, ipIds):
         return self.contract.functions.claimReward(groupId, token, ipIds).transact()

src/story_protocol_python_sdk/abi/LicenseToken/LicenseToken_client.py

@@ -32,9 +32,7 @@ def __init__(self, web3: Web3):
         self.contract = self.web3.eth.contract(address=contract_address, abi=abi)
 
     def getTotalTokensByLicensor(self, licensorIpId):
-        return self.contract.functions.getTotalTokensByLicensor(
-            licensorIpId
-        ).call()
+        return self.contract.functions.getTotalTokensByLicensor(licensorIpId).call()
 
     def ownerOf(self, tokenId):
         return self.contract.functions.ownerOf(tokenId).call()

src/story_protocol_python_sdk/resources/IPAsset.py

@@ -2417,7 +2417,7 @@ def is_registered(self, ip_id: str) -> bool:
         """
         if not ip_id:
             raise ValueError("is_registered: ip_id is required")
-        
+
         if not self.web3.is_address(ip_id):
             raise ValueError(f"is_registered: invalid IP ID address format: {ip_id}")
 
@@ -2443,7 +2443,9 @@ def _parse_tx_ip_registered_event(self, tx_receipt: dict) -> list[RegisteredIP]:
                 )
                 registered_ips.append(
                     RegisteredIP(
-                        ip_id=self.web3.to_checksum_address(event_result["args"]["ipId"]),
+                        ip_id=self.web3.to_checksum_address(
+                            event_result["args"]["ipId"]
+                        ),
                         token_id=event_result["args"]["tokenId"],
                     )
                 )

src/story_protocol_python_sdk/resources/Royalty.py

@@ -260,7 +260,9 @@ def batch_claim_all_revenue(
             receipts = []
             claimed_tokens = []
 
-            use_multicall = options.get("use_multicall_when_possible", True) if options else True
+            use_multicall = (
+                options.get("use_multicall_when_possible", True) if options else True
+            )
 
             # If only 1 ancestor IP or multicall is disabled, call claim_all_revenue for each
             if len(ancestor_ips) == 1 or not use_multicall:
@@ -338,14 +340,18 @@ def batch_claim_all_revenue(
             wip_claimable_amounts = 0
 
             for claimer in claimers:
-                owns_claimer, is_claimer_ip, ip_account = self._get_claimer_info(claimer)
+                owns_claimer, is_claimer_ip, ip_account = self._get_claimer_info(
+                    claimer
+                )
 
                 # If ownsClaimer is false, skip
                 if not owns_claimer:
                     continue
 
                 filter_claimed_tokens = [
-                    token for token in aggregated_claimed_tokens if token["claimer"] == claimer
+                    token
+                    for token in aggregated_claimed_tokens
+                    if token["claimer"] == claimer
                 ]
 
                 # Transfer claimed tokens from IP to wallet if wallet owns IP

src/story_protocol_python_sdk/utils/transaction_utils.py

@@ -44,9 +44,7 @@ def _get_transaction_options(
     # Gas: bump for replacement, or use tx_options
     if bump_gas:
         try:
-            opts["gasPrice"] = int(
-                web3.eth.gas_price * REPLACEMENT_GAS_BUMP_RATIO
-            )
+            opts["gasPrice"] = int(web3.eth.gas_price * REPLACEMENT_GAS_BUMP_RATIO)
         except Exception:
             opts["gasPrice"] = web3.to_wei(2, "gwei")
     else:
@@ -65,10 +63,7 @@ def _get_transaction_options(
 def _is_retryable_send_error(exc: Exception) -> bool:
     """True if we should retry send (same nonce, higher gas)."""
     msg = str(exc).lower()
-    return (
-        "replacement transaction underpriced" in msg
-        or "nonce too low" in msg
-    )
+    return "replacement transaction underpriced" in msg or "nonce too low" in msg
 
 
 def _send_one(

tests/integration/test_integration_group.py

@@ -376,9 +376,7 @@ def _normalize_address(web3, addr: str) -> str:
 class TestAddIpsToGroupAndRemoveIpsFromGroup:
     """Integration tests for add_ips_to_group and remove_ips_from_group with strict on-chain verification."""
 
-    def test_add_ips_to_group(
-        self, story_client: StoryClient, nft_collection: Address
-    ):
+    def test_add_ips_to_group(self, story_client: StoryClient, nft_collection: Address):
         """Test adding IPs to an existing group; verify chain state via AddedIpToGroup event and get_claimable_reward."""
         result1 = GroupTestHelper.mint_and_register_ip_asset_with_pil_terms(
             story_client, nft_collection
@@ -403,17 +401,19 @@ def test_add_ips_to_group(
         assert isinstance(result["tx_hash"], str)
         assert len(result["tx_hash"]) > 0
         # Strict: verify on-chain AddedIpToGroup event
-        assert "tx_receipt" in result, "add_ips_to_group must return tx_receipt for verification"
+        assert (
+            "tx_receipt" in result
+        ), "add_ips_to_group must return tx_receipt for verification"
         added_events = story_client.Group.get_added_ip_to_group_events(
             result["tx_receipt"]
         )
         assert len(added_events) == 1
-        assert _normalize_address(story_client.web3, added_events[0]["groupId"]) == _normalize_address(
-            story_client.web3, group_ip_id
-        )
-        assert set(_normalize_address(story_client.web3, a) for a in added_events[0]["ipIds"]) == {
-            _normalize_address(story_client.web3, ip_id2)
-        }
+        assert _normalize_address(
+            story_client.web3, added_events[0]["groupId"]
+        ) == _normalize_address(story_client.web3, group_ip_id)
+        assert set(
+            _normalize_address(story_client.web3, a) for a in added_events[0]["ipIds"]
+        ) == {_normalize_address(story_client.web3, ip_id2)}
         # Verify new member is in group: get_claimable_reward for [ip_id1, ip_id2] should succeed
         claimable = story_client.Group.get_claimable_reward(
             group_ip_id=group_ip_id,
@@ -454,12 +454,12 @@ def test_add_ips_to_group_with_max_reward_share(
             result["tx_receipt"]
         )
         assert len(added_events) == 1
-        assert _normalize_address(story_client.web3, added_events[0]["groupId"]) == _normalize_address(
-            story_client.web3, group_ip_id
-        )
-        assert set(_normalize_address(story_client.web3, a) for a in added_events[0]["ipIds"]) == {
-            _normalize_address(story_client.web3, ip_id2)
-        }
+        assert _normalize_address(
+            story_client.web3, added_events[0]["groupId"]
+        ) == _normalize_address(story_client.web3, group_ip_id)
+        assert set(
+            _normalize_address(story_client.web3, a) for a in added_events[0]["ipIds"]
+        ) == {_normalize_address(story_client.web3, ip_id2)}
 
     def test_remove_ips_from_group(
         self, story_client: StoryClient, nft_collection: Address
@@ -492,12 +492,12 @@ def test_remove_ips_from_group(
             result["tx_receipt"]
         )
         assert len(removed_events) == 1
-        assert _normalize_address(story_client.web3, removed_events[0]["groupId"]) == _normalize_address(
-            story_client.web3, group_ip_id
-        )
-        assert set(_normalize_address(story_client.web3, a) for a in removed_events[0]["ipIds"]) == {
-            _normalize_address(story_client.web3, ip_id2)
-        }
+        assert _normalize_address(
+            story_client.web3, removed_events[0]["groupId"]
+        ) == _normalize_address(story_client.web3, group_ip_id)
+        assert set(
+            _normalize_address(story_client.web3, a) for a in removed_events[0]["ipIds"]
+        ) == {_normalize_address(story_client.web3, ip_id2)}
         # After remove, only ip_id1 remains; get_claimable_reward for [ip_id1] must succeed
         claimable = story_client.Group.get_claimable_reward(
             group_ip_id=group_ip_id,
@@ -540,7 +540,9 @@ def test_add_then_remove_ips_from_group(
             add_result["tx_receipt"]
         )
         assert len(added_events) == 1
-        assert set(_normalize_address(story_client.web3, a) for a in added_events[0]["ipIds"]) == {
+        assert set(
+            _normalize_address(story_client.web3, a) for a in added_events[0]["ipIds"]
+        ) == {
             _normalize_address(story_client.web3, ip_id2),
             _normalize_address(story_client.web3, ip_id3),
         }
@@ -556,9 +558,9 @@ def test_add_then_remove_ips_from_group(
             remove_result["tx_receipt"]
         )
         assert len(removed_events) == 1
-        assert set(_normalize_address(story_client.web3, a) for a in removed_events[0]["ipIds"]) == {
-            _normalize_address(story_client.web3, ip_id2)
-        }
+        assert set(
+            _normalize_address(story_client.web3, a) for a in removed_events[0]["ipIds"]
+        ) == {_normalize_address(story_client.web3, ip_id2)}
 
         # Final state: only ip_id1 and ip_id3 are members
         claimable = story_client.Group.get_claimable_reward(

tests/integration/test_integration_royalty.py

@@ -153,7 +153,7 @@ def test_pay_royalty_invalid_amount(
 
     def test_batch_claim_all_revenue_single_ancestor(self, story_client: StoryClient):
         """Test batch claiming revenue using the same pattern as test_claim_all_revenue
-        
+
         This test verifies that batch_claim_all_revenue works correctly by:
         1. Creating a derivative chain A->B->C
         2. Using batch_claim_all_revenue to claim revenue for A
@@ -242,8 +242,12 @@ def wrapper_derivative_with_wip(parent_ip_id, license_terms_id):
 
         # Build derivative chain: A -> B -> C -> D (same as test_claim_all_revenue)
         ip_b = wrapper_derivative_with_wip(ip_a, license_terms_id)  # B pays 100 WIP
-        ip_c = wrapper_derivative_with_wip(ip_b, license_terms_id)  # C pays 100 WIP (10 to A, 90 to B)
-        wrapper_derivative_with_wip(ip_c, license_terms_id)  # D pays 100 WIP (10 to A, 10 to B, 80 to C)
+        ip_c = wrapper_derivative_with_wip(
+            ip_b, license_terms_id
+        )  # C pays 100 WIP (10 to A, 90 to B)
+        wrapper_derivative_with_wip(
+            ip_c, license_terms_id
+        )  # D pays 100 WIP (10 to A, 10 to B, 80 to C)
 
         # Batch claim revenue for IP A (should get 120 WIP: 100 from B + 10 from C + 10 from D)
         # Note: Only pass [ip_b, ip_c] as child_ip_ids, not ip_d, matching test_claim_all_revenue
@@ -271,13 +275,15 @@ def wrapper_derivative_with_wip(parent_ip_id, license_terms_id):
         assert len(response["receipts"]) >= 1
         assert "claimed_tokens" in response
         assert len(response["claimed_tokens"]) >= 1
-        
+
         # Verify IP A received 120 WIP tokens (100 from B + 10 from C + 10 from D)
         assert response["claimed_tokens"][0]["amount"] == 120
 
-    def test_batch_claim_all_revenue_multiple_ancestors(self, story_client: StoryClient):
+    def test_batch_claim_all_revenue_multiple_ancestors(
+        self, story_client: StoryClient
+    ):
         """Test batch claiming revenue from multiple ancestor IPs
-        
+
         This test creates two independent derivative chains and claims revenue for both ancestors:
         - Chain 1: A1 -> B1 -> C1 -> D1 (A1 gets 120 WIP)
         - Chain 2: A2 -> B2 -> C2 (A2 gets 110 WIP)
@@ -373,7 +379,7 @@ def wrapper_derivative_with_wip(parent_ip_id, license_terms_id):
             spg_nft_contract=spg_nft_contract,
         )
         ip_a2 = ip_a2_response["ip_id"]
-        
+
         # Attach the same license terms to IP A2
         story_client.License.attach_license_terms(
             ip_id=ip_a2,
@@ -383,7 +389,7 @@ def wrapper_derivative_with_wip(parent_ip_id, license_terms_id):
 
         # Build derivative chain 2: A2 -> B2 -> C2
         ip_b2 = wrapper_derivative_with_wip(ip_a2, license_terms_id)
-        ip_c2 = wrapper_derivative_with_wip(ip_b2, license_terms_id)
+        wrapper_derivative_with_wip(ip_b2, license_terms_id)
 
         # Batch claim revenue for both ancestors (disable multicall to avoid potential issues)
         response = story_client.Royalty.batch_claim_all_revenue(
@@ -420,11 +426,13 @@ def wrapper_derivative_with_wip(parent_ip_id, license_terms_id):
         assert len(response["receipts"]) >= 2
         assert "claimed_tokens" in response
         assert len(response["claimed_tokens"]) == 2  # Two ancestors claimed
-        
+
         # Verify both ancestors received their expected amounts
         # A1 should get 120 WIP (100 from B1 + 10 from C1 + 10 from D1)
         # A2 should get 110 WIP (100 from B2 + 10 from C2)
-        claimed_amounts = {token["claimer"]: token["amount"] for token in response["claimed_tokens"]}
+        claimed_amounts = {
+            token["claimer"]: token["amount"] for token in response["claimed_tokens"]
+        }
         assert claimed_amounts[ip_a1] == 120
         assert claimed_amounts[ip_a2] == 110
 

tests/unit/resources/test_batch_claim_all_revenue.py

@@ -78,30 +78,35 @@ def test_batch_claim_all_revenue_multiple_ancestors_with_multicall(
                 ],
             ):
                 with patch.object(
-                    royalty_client, "_get_claimer_info", return_value=(False, False, None)
+                    royalty_client,
+                    "_get_claimer_info",
+                    return_value=(False, False, None),
                 ):
                     with patch(
                         "story_protocol_python_sdk.resources.Royalty.build_and_send_transaction",
-                        return_value={"tx_hash": TX_HASH.hex(), "tx_receipt": {"logs": []}},
+                        return_value={
+                            "tx_hash": TX_HASH.hex(),
+                            "tx_receipt": {"logs": []},
+                        },
                     ):
                         result = royalty_client.batch_claim_all_revenue(
-                        ancestor_ips=[
-                            {
-                                "ip_id": ADDRESS,
-                                "claimer": ADDRESS,
-                                "child_ip_ids": [],
-                                "royalty_policies": [],
-                                "currency_tokens": [WIP_TOKEN_ADDRESS],
-                            },
-                            {
-                                "ip_id": ACCOUNT_ADDRESS,
-                                "claimer": ACCOUNT_ADDRESS,
-                                "child_ip_ids": [],
-                                "royalty_policies": [],
-                                "currency_tokens": [WIP_TOKEN_ADDRESS],
-                            },
-                        ],
-                    )
+                            ancestor_ips=[
+                                {
+                                    "ip_id": ADDRESS,
+                                    "claimer": ADDRESS,
+                                    "child_ip_ids": [],
+                                    "royalty_policies": [],
+                                    "currency_tokens": [WIP_TOKEN_ADDRESS],
+                                },
+                                {
+                                    "ip_id": ACCOUNT_ADDRESS,
+                                    "claimer": ACCOUNT_ADDRESS,
+                                    "child_ip_ids": [],
+                                    "royalty_policies": [],
+                                    "currency_tokens": [WIP_TOKEN_ADDRESS],
+                                },
+                            ],
+                        )
                     assert len(result["tx_hashes"]) == 1
                     assert len(result["receipts"]) == 1
                     assert len(result["claimed_tokens"]) == 2