feat: switch to extend_by for extend_entity

Author: Matthias Zimmermann

README.md

@@ -528,5 +528,3 @@ Pre-commit hooks run automatically on `git commit` and will:
 function gl { git log --format="%C(green)%ad%C(reset) %C(yellow)%h%C(reset)%C(auto)%d%C(reset) %s" --date=format:"%Y-%m-%d_%H:%M:%S" -n ${1:-10}; }
 alias gs='git status'
 ```
-
-

src/arkiv/module.py

@@ -125,12 +125,12 @@ def update_entity(
     def extend_entity(
         self,
         entity_key: EntityKey,
-        number_of_blocks: int,
+        extend_by: int,
         tx_params: TxParams | None = None,
     ) -> TransactionReceipt:
         # Docstring inherited from ArkivModuleBase.extend_entity
         # Create the extend operation and execute TX
-        extend_op = ExtendOp(key=entity_key, number_of_blocks=number_of_blocks)
+        extend_op = ExtendOp(key=entity_key, extend_by=extend_by)
         operations = Operations(extensions=[extend_op])
         receipt = self.execute(operations, tx_params)
 

src/arkiv/module_async.py

@@ -124,12 +124,12 @@ async def update_entity(  # type: ignore[override]
     async def extend_entity(  # type: ignore[override]
         self,
         entity_key: EntityKey,
-        number_of_blocks: int,
+        extend_by: int,
         tx_params: TxParams | None = None,
     ) -> TransactionReceipt:
         # Docstring inherited from ArkivModuleBase.extend_entity
         # Create the extend operation and execute TX
-        extend_op = ExtendOp(key=entity_key, number_of_blocks=number_of_blocks)
+        extend_op = ExtendOp(key=entity_key, extend_by=extend_by)
         operations = Operations(extensions=[extend_op])
         receipt = await self.execute(operations, tx_params)
 

src/arkiv/module_base.py

@@ -289,7 +289,7 @@ def change_owner(
     def extend_entity(
         self,
         entity_key: EntityKey,
-        number_of_blocks: int,
+        extend_by: int,
         tx_params: TxParams | None = None,
     ) -> TransactionReceipt:
         """

src/arkiv/types.py

@@ -234,7 +234,7 @@ class ExtendOp:
     """Class to represent a entity lifetime extend operation."""
 
     key: EntityKey
-    number_of_blocks: int
+    extend_by: int
 
 
 @dataclass(frozen=True)

src/arkiv/utils.py

@@ -779,7 +779,7 @@ def rlp_encode_transaction(tx: Operations) -> bytes:
         [
             [
                 entity_key_to_bytes(element.key),
-                element.number_of_blocks,
+                to_blocks(seconds=element.extend_by),
             ]
             for element in tx.extensions
         ],

tests/test_async_entity_extend.py

@@ -36,14 +36,15 @@ async def test_async_extend_entity_basic(
         initial_expiration = entity_before.expires_at_block
         assert initial_expiration is not None, "Entity should have expiration block"
 
-        # Extend the entity by 50 blocks
-        number_of_blocks = 50
+        # Extend the entity by 50 seconds
+        seconds = 50
+        number_of_blocks = async_arkiv_client_http.arkiv.to_blocks(seconds=seconds)
         receipt = await async_arkiv_client_http.arkiv.extend_entity(
-            entity_key, number_of_blocks
+            entity_key, extend_by=seconds
         )
 
         check_tx_hash("test_async_extend_entity_basic_extend", receipt)
-        logger.info(f"Extended entity {entity_key} by {number_of_blocks} blocks")
+        logger.info(f"Extended entity {entity_key} by {seconds} seconds")
 
         # Verify expiration increased
         entity_after = await async_arkiv_client_http.arkiv.get_entity(entity_key)
@@ -76,10 +77,11 @@ async def test_async_extend_entities_sequentially(
             assert expiration is not None, f"Entity {i} should have an expiration block"
 
         # Extend all entities sequentially
-        number_of_blocks = 50
+        seconds = 50
+        number_of_blocks = async_arkiv_client_http.arkiv.to_blocks(seconds=seconds)
         for i, entity_key in enumerate(entity_keys):
             receipt = await async_arkiv_client_http.arkiv.extend_entity(
-                entity_key, number_of_blocks
+                entity_key, extend_by=seconds
             )
             check_entity_key(entity_key, f"test_async_extend_entities_sequentially_{i}")
             check_tx_hash(f"test_async_extend_entities_sequentially_{i}", receipt)

tests/test_async_watch_entity.py

@@ -140,7 +140,7 @@ async def on_extended(event: ExtendEvent, tx_hash: TxHash) -> None:
             )
 
             receipt = await async_arkiv_client_http.arkiv.extend_entity(
-                entity_key, number_of_blocks=100
+                entity_key, extend_by=100
             )
 
             # Wait for event

tests/test_entity_create_parallel.py

@@ -101,17 +101,17 @@ def client_creation_task(
             entity_index = tx_no * batch_size + entity_no
             payload = random_payload()
             attributes = random_attributes(client_idx, entity_index)
-            btl = random_expires_in()
-            entities_in_batch.append((payload, attributes, btl))
+            expires_in = random_expires_in()
+            entities_in_batch.append((payload, attributes, expires_in))
 
         # Create entity/entities based on batch_size
         try:
             if batch_size == 1:
                 # Single entity creation
-                payload, attributes, btl = entities_in_batch[0]
+                payload, attributes, expires_in = entities_in_batch[0]
                 try:
                     entity_key, tx_hash = client.arkiv.create_entity(
-                        payload=payload, attributes=attributes, expires_in=btl
+                        payload=payload, attributes=attributes, expires_in=expires_in
                     )
                     logger.info(
                         f"Entity creation TX[{client_idx}][{tx_no}]: {tx_hash} (1 entity)"
@@ -135,7 +135,7 @@ def client_creation_task(
                     )
                     # Store all created entities with their expected data
                     for i, entity_key in enumerate(entity_keys):
-                        payload, attributes, btl = entities_in_batch[i]
+                        payload, attributes, expires_in = entities_in_batch[i]
                         created_entities.append((entity_key, payload, attributes))
                 except HTTPError as e:
                     logger.error(f"Error creating entities[{client_idx}][{tx_no}]: {e}")

tests/test_entity_extend.py

@@ -42,23 +42,24 @@ def test_extend_entity_simple(self, arkiv_client_http: Arkiv) -> None:
         logger.info(f"Initial expiration block: {initial_expiration}")
 
         # Extend the entity by 50 blocks
-        number_of_blocks = 50
+        seconds = 50
         extend_tx_hash = arkiv_client_http.arkiv.extend_entity(
-            entity_key, number_of_blocks
+            entity_key, extend_by=seconds
         )
 
         label = "extend_entity"
         check_tx_hash(label, extend_tx_hash)
         logger.info(
-            f"{label}: Extended entity {entity_key} by {number_of_blocks} blocks, tx_hash: {extend_tx_hash}"
+            f"{label}: Extended entity {entity_key} by {seconds} seconds, tx_hash: {extend_tx_hash}"
         )
 
         # Verify the entity still exists and expiration increased
         entity_after = arkiv_client_http.arkiv.get_entity(entity_key)
         logger.info(f"Entity after extension: {entity_after}")
-        assert entity_after.expires_at_block == initial_expiration + number_of_blocks, (
-            f"Expiration should increase by {number_of_blocks} blocks"
-        )
+        assert (
+            entity_after.expires_at_block
+            == initial_expiration + arkiv_client_http.arkiv.to_blocks(seconds)
+        ), f"Expiration should increase by {seconds} seconds"
 
         logger.info(
             f"{label}: Entity expiration increased from {initial_expiration} to {entity_after.expires_at_block}"
@@ -85,7 +86,9 @@ def test_extend_entity_multiple_times(self, arkiv_client_http: Arkiv) -> None:
 
         # Verify final expiration
         entity_final = arkiv_client_http.arkiv.get_entity(entity_key)
-        expected_expiration = initial_expiration + sum(extensions)
+        expected_expiration = initial_expiration + arkiv_client_http.arkiv.to_blocks(
+            sum(extensions)
+        )
         assert entity_final.expires_at_block == expected_expiration, (
             f"Expiration should be {expected_expiration}"
         )
@@ -121,10 +124,8 @@ def test_extend_entity_execute_bulk(self, arkiv_client_http: Arkiv) -> None:
             initial_expirations[entity_key] = expires_at
 
         # Bulk extend
-        number_of_blocks = 200
-        extend_ops = [
-            ExtendOp(key=key, number_of_blocks=number_of_blocks) for key in entity_keys
-        ]
+        seconds = 200
+        extend_ops = [ExtendOp(key=key, extend_by=seconds) for key in entity_keys]
         operations = Operations(extensions=extend_ops)
         receipt = arkiv_client_http.arkiv.execute(operations)
 
@@ -140,7 +141,11 @@ def test_extend_entity_execute_bulk(self, arkiv_client_http: Arkiv) -> None:
         # Verify all expirations increased
         for entity_key in entity_keys:
             entity = arkiv_client_http.arkiv.get_entity(entity_key)
-            expected_expiration = initial_expirations[entity_key] + number_of_blocks
+            expected_expiration = (
+                initial_expirations[entity_key]
+                + arkiv_client_http.arkiv.to_blocks(seconds)
+                # + seconds / ArkivModuleBase.BLOCK_TIME_SECONDS
+            )
             assert entity.expires_at_block == expected_expiration, (
                 f"Entity {entity_key} expiration should be {expected_expiration}"
             )
@@ -222,7 +227,7 @@ def test_extend_entity_minimal_blocks(self, arkiv_client_http: Arkiv) -> None:
         )
 
         # Extend by just 1 block
-        extend_tx_hash = arkiv_client_http.arkiv.extend_entity(entity_key, 1)
+        extend_tx_hash = arkiv_client_http.arkiv.extend_entity(entity_key, extend_by=2)
         check_tx_hash("extend_minimal", extend_tx_hash)
 
         # Verify expiration increased by 1