Feat add support for v3 transactions

pragma/core/contract.py

@@ -2,7 +2,7 @@
 
 from starknet_py.contract import Contract as StarknetContract
 from starknet_py.contract import ContractFunction, InvokeResult
-from starknet_py.net.client_models import SentTransactionResponse
+from starknet_py.net.client_models import SentTransactionResponse, ResourceBounds
 
 
 class Contract(StarknetContract):
@@ -21,6 +21,8 @@
     *args,
     max_fee: Optional[int] = None,
     auto_estimate: bool = False,
+    enable_strk_fees: Optional[bool] = False,
+    l1_resource_bounds: Optional[ResourceBounds] = None,
     callback: Optional[Callable[[SentTransactionResponse], None]] = None,
     **kwargs,
 ) -> InvokeResult:
@@ -29,18 +31,27 @@
     This is useful for tracking the nonce changes
     """
 
-    prepared_call = self.prepare_invoke_v1(*args, **kwargs)
+    prepared_call = (
+        self.prepare_invoke_v3(*args, **kwargs)
+        if enable_strk_fees
+        else self.prepare_invoke_v1(*args, **kwargs)
+    )
 
     # transfer ownership to the prepared call
     self = prepared_call
     if max_fee is not None:
         self.max_fee = max_fee
 
-    transaction = await self.get_account.sign_invoke_v1(
-        calls=self,
-        max_fee=self.max_fee,
-        auto_estimate=auto_estimate,
+    transaction = (
+        await self.get_account.sign_invoke_v3(
+            calls=self,
+            l1_resource_bounds=l1_resource_bounds,
+            auto_estimate=auto_estimate,
+        )
+        if enable_strk_fees
+        else await self.get_account.sign_invoke_v1(calls=self, max_fee=max_fee)
     )
+
     response = await self._client.send_transaction(transaction)
     if callback:
         await callback(transaction.nonce, response.transaction_hash)
@@ -59,4 +70,4 @@
 
 
 # patch contract function to use new invoke function
-ContractFunction.invoke_v1 = invoke_
+ContractFunction.invoke = invoke_

pragma/core/mixins/oracle.py

@@ -8,6 +8,8 @@
 from starknet_py.contract import InvokeResult
 from starknet_py.net.account.account import Account
 from starknet_py.net.client import Client
+from starknet_py.net.client_models import ResourceBounds
+
 
 from pragma.core.contract import Contract
 from pragma.core.entry import Entry, FutureEntry, SpotEntry
@@ -43,14 +45,17 @@
         publisher: int,
         volume: int = 0,
         max_fee: int = int(1e18),
+        enable_strk_fees: Optional[bool] = False,
+        l1_resource_bounds: Optional[ResourceBounds] = None,
+        auto_estimate: Optional[bool] = False,
     ) -> InvokeResult:
         if not self.is_user_client:
             raise AttributeError(
                 "Must set account. "
                 "You may do this by invoking "
                 "self._setup_account_client(private_key, account_contract_address)"
             )
-        invocation = await self.oracle.functions["publish_data"].invoke_v1(
+        invocation = await self.oracle.functions["publish_data"].invoke(
             new_entry={
                 "Spot": {
                     "base": {
@@ -64,6 +69,9 @@
                 }
             },
             max_fee=max_fee,
+            l1_resource_bounds=l1_resource_bounds,
+            auto_estimate=auto_estimate,
+            enable_strk_fees=enable_strk_fees,
         )
         return invocation
 
@@ -72,6 +80,9 @@
         entries: List[Entry],
         pagination: Optional[int] = 40,
         max_fee=int(1e18),
+        enable_strk_fees: Optional[bool] = False,
+        l1_resource_bounds: Optional[ResourceBounds] = None,
+        auto_estimate: Optional[bool] = False,
     ) -> List[InvokeResult]:
         if len(entries) == 0:
             logger.warning("Skipping publishing as entries array is empty")
@@ -84,11 +95,12 @@
             index = 0
             while index < len(serialized_spot_entries):
                 entries_subset = serialized_spot_entries[index : index + pagination]
-                invocation = await self.oracle.functions[
-                    "publish_data_entries"
-                ].invoke_v1(
+                invocation = await self.oracle.functions["publish_data_entries"].invoke(
                     new_entries=[{"Spot": entry} for entry in entries_subset],
+                    enable_strk_fees=enable_strk_fees,
                     max_fee=max_fee,
+                    l1_resource_bounds=l1_resource_bounds,
+                    auto_estimate=auto_estimate,
                     callback=self.track_nonce,
                 )
                 index += pagination
@@ -100,9 +112,12 @@
                     hex(invocation.hash),
                 )
         elif len(serialized_spot_entries) > 0:
-            invocation = await self.oracle.functions["publish_data_entries"].invoke_v1(
+            invocation = await self.oracle.functions["publish_data_entries"].invoke(
                 new_entries=[{"Spot": entry} for entry in serialized_spot_entries],
                 max_fee=max_fee,
+                enable_strk_fees=enable_strk_fees,
+                l1_resource_bounds=l1_resource_bounds,
+                auto_estimate=auto_estimate,
                 callback=self.track_nonce,
             )
             invocations.append(invocation)
@@ -119,11 +134,12 @@
             index = 0
             while index < len(serialized_future_entries):
                 entries_subset = serialized_future_entries[index : index + pagination]
-                invocation = await self.oracle.functions[
-                    "publish_data_entries"
-                ].invoke_v1(
+                invocation = await self.oracle.functions["publish_data_entries"].invoke(
                     new_entries=[{"Future": entry} for entry in entries_subset],
                     max_fee=max_fee,
+                    enable_strk_fees=enable_strk_fees,
+                    l1_resource_bounds=l1_resource_bounds,
+                    auto_estimate=auto_estimate,
                     callback=self.track_nonce,
                 )
                 index += pagination
@@ -135,9 +151,12 @@
                     hex(invocation.hash),
                 )
         elif len(serialized_future_entries) > 0:
-            invocation = await self.oracle.functions["publish_data_entries"].invoke_v1(
+            invocation = await self.oracle.functions["publish_data_entries"].invoke(
                 new_entries=[{"Future": entry} for entry in serialized_future_entries],
                 max_fee=max_fee,
+                enable_strk_fees=enable_strk_fees,
+                l1_resource_bounds=l1_resource_bounds,
+                auto_estimate=auto_estimate,
                 callback=self.track_nonce,
             )
             invocations.append(invocation)
@@ -296,7 +315,7 @@
                 "You may do this by invoking "
                 "self._setup_account_client(private_key, account_contract_address)"
             )
-        invocation = await self.oracle.functions["set_checkpoint"].invoke_v1(
+        invocation = await self.oracle.functions["set_checkpoint"].invoke(
             DataType(DataTypes.SPOT, pair_id, None).serialize(),
             aggregation_mode.serialize(),
             max_fee=max_fee,
@@ -317,7 +336,7 @@
                 "You may do this by invoking "
                 "self._setup_account_client(private_key, account_contract_address)"
             )
-        invocation = await self.oracle.functions["set_checkpoint"].invoke_v1(
+        invocation = await self.oracle.functions["set_checkpoint"].invoke(
             DataType(DataTypes.FUTURE, pair_id, expiry_timestamp).serialize(),
             aggregation_mode.serialize(),
             max_fee=max_fee,
@@ -345,7 +364,7 @@
             index = 0
             while index < len(pair_ids):
                 pair_ids_subset = pair_ids[index : index + pagination]
-                invocation = await self.oracle.functions["set_checkpoints"].invoke_v1(
+                invocation = await self.oracle.functions["set_checkpoints"].invoke(
                     pair_ids_subset,
                     expiry_timestamps,
                     aggregation_mode.serialize(),
@@ -359,7 +378,7 @@
                     hex(invocation.hash),
                 )
         else:
-            invocation = await self.oracle.functions["set_checkpoints"].invoke_v1(
+            invocation = await self.oracle.functions["set_checkpoints"].invoke(
                 pair_ids,
                 expiry_timestamps,
                 aggregation_mode.serialize(),
@@ -387,7 +406,7 @@
             index = 0
             while index < len(pair_ids):
                 pair_ids_subset = pair_ids[index : index + pagination]
-                invocation = await self.oracle.set_checkpoints.invoke_v1(
+                invocation = await self.oracle.set_checkpoints.invoke(
                     [
                         DataType(DataTypes.SPOT, pair_id, None).serialize()
                         for pair_id in pair_ids_subset
@@ -403,7 +422,7 @@
                     hex(invocation.hash),
                 )
         else:
-            invocation = await self.oracle.set_checkpoints.invoke_v1(
+            invocation = await self.oracle.set_checkpoints.invoke(
                 [
                     DataType(DataTypes.SPOT, pair_id, None).serialize()
                     for pair_id in pair_ids
@@ -423,7 +442,7 @@
         implementation_hash: int,
         max_fee=int(1e18),
     ) -> InvokeResult:
-        invocation = await self.oracle.functions["upgrade"].invoke_v1(
+        invocation = await self.oracle.functions["upgrade"].invoke(
             implementation_hash,
             max_fee=max_fee,
         )

pragma/tests/api_client_test.py

@@ -27,7 +27,7 @@
 @pytest.fixture(scope="module")
 def forked_client(request, module_mocker, pytestconfig) -> Client:
     """
-    This module-scope fixture prepares a forked katana
+    This module-scope fixture prepares a forked starknet
     client for e2e testing.
 
     :return: a starknet Client
@@ -54,7 +54,7 @@ def forked_client(request, module_mocker, pytestconfig) -> Client:
         str(1),
     ]
     if block_number is not None:
-        print(f"forking katana at block {block_number}")
+        print(f"forking starknet at block {block_number}")
         command.extend(["--fork-block-number", str(block_number)])
     subprocess.Popen(command)  # pylint: disable=consider-using-with
     time.sleep(10)

pragma/tests/client_test.py

@@ -15,6 +15,8 @@
 from pragma.core.utils import str_to_felt
 from pragma.tests.constants import CURRENCIES, PAIRS
 from pragma.tests.utils import read_contract, wait_for_acceptance
+from starknet_py.net.client_models import ResourceBounds
+
 
 PUBLISHER_NAME = "PRAGMA"
 
@@ -216,7 +218,9 @@ async def test_client_oracle_mixin_spot(pragma_client: PragmaClient):
         ETH_PAIR, 200, timestamp + 10, SOURCE_1, publisher_name, volume=20
     )
 
-    invocations = await pragma_client.publish_many([spot_entry_1, spot_entry_2])
+    invocations = await pragma_client.publish_many(
+        [spot_entry_1, spot_entry_2], auto_estimate=True
+    )
     await invocations[len(invocations) - 1].wait_for_acceptance()
     # Fails for UNKNOWN source
     unknown_source = "UNKNOWN"
@@ -246,7 +250,12 @@ async def test_client_oracle_mixin_spot(pragma_client: PragmaClient):
         ETH_PAIR, 100, timestamp + 450, SOURCE_1, publisher_name, volume=10
     )
     try:
-        invocations = await pragma_client.publish_many([spot_entry_future])
+        invocations = await pragma_client.publish_many(
+            [spot_entry_future],
+            l1_resource_bounds=ResourceBounds(
+                max_price_per_unit=500 * 10**9, max_amount=10**7
+            ),
+        )
     except TransactionRevertedError as err:
         # err_msg = "Execution was reverted; failure reason: [0x54696d657374616d7020697320696e2074686520667574757265]"
         err_msg = "Unknown Starknet error"
@@ -264,7 +273,9 @@ async def test_client_oracle_mixin_spot(pragma_client: PragmaClient):
         ETH_PAIR, 200, timestamp + 30, SOURCE_2, publisher_name, volume=20
     )
 
-    invocations = await pragma_client.publish_many([spot_entry_1, spot_entry_2])
+    invocations = await pragma_client.publish_many(
+        [spot_entry_1, spot_entry_2], auto_estimate=True
+    )
     await invocations[len(invocations) - 1].wait_for_acceptance()
     res = await pragma_client.get_spot(ETH_PAIR)
     assert res.price == 150
@@ -301,7 +312,9 @@ async def test_client_oracle_mixin_future(pragma_client: PragmaClient):
         volume=20000,
     )
 
-    invocations = await pragma_client.publish_many([future_entry_1, future_entry_2])
+    invocations = await pragma_client.publish_many(
+        [future_entry_1, future_entry_2], auto_estimate=True
+    )
     await invocations[len(invocations) - 1].wait_for_acceptance()
     # Check entries
     entries = await pragma_client.get_future_entries(
@@ -332,7 +345,9 @@ async def test_client_oracle_mixin_future(pragma_client: PragmaClient):
         volume=20,
     )
 
-    invocations = await pragma_client.publish_many([future_entry_1, future_entry_2])
+    invocations = await pragma_client.publish_many(
+        [future_entry_1, future_entry_2], auto_estimate=True
+    )
     await invocations[len(invocations) - 1].wait_for_acceptance()
     res = await pragma_client.get_future(ETH_PAIR, expiry_timestamp)
     assert res.price == 150
@@ -351,7 +366,12 @@ async def test_client_oracle_mixin_future(pragma_client: PragmaClient):
         volume=10,
     )
     try:
-        await pragma_client.publish_many([future_entry_future])
+        await pragma_client.publish_many(
+            [future_entry_future],
+            l1_resource_bounds=ResourceBounds(
+                max_price_per_unit=500 * 10**9, max_amount=10**7
+            ),
+        )
     except TransactionRevertedError as err:
         # err_msg = "Execution was reverted; failure reason: [0x54696d657374616d7020697320696e2074686520667574757265]"
         err_msg = "Unknown Starknet error"

pragma/tests/publisher_test.py

@@ -91,7 +91,7 @@ async def test_publisher_client_spot(pragma_client: PragmaClient):
 
     # Publish SPOT data
     print(data)
-    await publisher.publish_many(data, pagination=PAGINATION)
+    await publisher.publish_many(data, pagination=PAGINATION, auto_estimate=True)
 
 
 @pytest.mark.asyncio
@@ -118,7 +118,7 @@ async def test_publisher_client_future(pragma_client: PragmaClient):
         d for d in data_async if isinstance(d, FutureEntry)
     ]
     print(data_list)
-    await publisher.publish_many(data_list, pagination=PAGINATION)
+    await publisher.publish_many(data_list, pagination=PAGINATION, auto_estimate=True)
 
 
 @pytest.mark.asyncio
@@ -149,7 +149,7 @@ async def test_publisher_client_all_assets(pragma_client: PragmaClient):
 
     data = [d for d in data if isinstance(d, Entry)]
     print(data)
-    await publisher.publish_many(data, pagination=PAGINATION)
+    await publisher.publish_many(data, pagination=PAGINATION, auto_estimate=True)
 
 
 def asset_valid_data_type(data: Sequence[Entry], data_type: Entry):

stagecoach/jobs/publishers/custom/app.py

@@ -62,7 +62,9 @@ async def publish_all(assets):
 
     # Use your own custom logic
     _entries = fetch_entries(assets)
-    await publisher_client.publish_many(_entries, max_fee=int(max_fee))
+    await publisher_client.publish_many(
+        _entries, max_fee=int(max_fee), auto_estimate=True
+    )
 
     logger.info("Publishing the following entries:")
     for entry in _entries:

stagecoach/jobs/publishers/starknet_publisher/app.py

@@ -44,6 +44,7 @@
 PAGINATION = os.environ.get("PAGINATION")
 RPC_URL = os.environ.get("RPC_URL")
 MAX_FEE = int(os.getenv("MAX_FEE", int(1e17)))
+ENABLE_STRK_FEES = os.environ.get("ENABLE_STRK_FEES", "False")
 
 DEVIATION_THRESHOLD = float(os.getenv("DEVIATION_THRESHOLD", 0.01))
 FREQUENCY_SECONDS = int(os.getenv("FREQUENCY_SECONDS", 60))
@@ -164,10 +165,16 @@ async def _handler(assets):
 
     _entries = await publisher_client.fetch()
     print("entries", _entries)
+
+    enable_strk_fees = ENABLE_STRK_FEES.lower() in ("true", "1", "yes")
+
+    print(f"ENABLE_STRK_FEES is set to: {enable_strk_fees}")
     response = await publisher_client.publish_many(
         _entries,
         pagination=PAGINATION,
         max_fee=MAX_FEE,
+        enable_strk_fees=enable_strk_fees,
+        auto_estimate=True,  # For safety or should we switch to l1_resource_bounds for cost ?
     )
 
     print(