Updated free call logic, signatures and user interface

Author: Arondondon

snet/sdk/concurrency_manager.py

@@ -3,12 +3,11 @@
 import grpc
 import web3
 
-from snet.sdk.service_client import ServiceClient
 from snet.sdk.utils.utils import RESOURCES_PATH, add_to_path
 
 
 class ConcurrencyManager:
-    def __init__(self, concurrent_calls: int):
+    def __init__(self, concurrent_calls: int=1):
         self.__concurrent_calls: int = concurrent_calls
         self.__token: str = ''
         self.__planned_amount: int = 0
@@ -18,14 +17,18 @@ def __init__(self, concurrent_calls: int):
     def concurrent_calls(self) -> int:
         return self.__concurrent_calls
 
+    @concurrent_calls.setter
+    def concurrent_calls(self, concurrent_calls: int):
+        self.__concurrent_calls = concurrent_calls
+
     def get_token(self, service_client, channel, service_call_price):
         if len(self.__token) == 0:
             self.__token = self.__get_token(service_client, channel, service_call_price)
         elif self.__used_amount >= self.__planned_amount:
             self.__token = self.__get_token(service_client, channel, service_call_price, new_token=True)
         return self.__token
 
-    def __get_token(self, service_client: ServiceClient, channel, service_call_price, new_token=False):
+    def __get_token(self, service_client, channel, service_call_price, new_token=False):
         if not new_token:
             amount = channel.state["last_signed_amount"]
             if amount != 0:
@@ -47,13 +50,13 @@ def __get_token(self, service_client: ServiceClient, channel, service_call_price
         self.__planned_amount = token_reply.planned_amount
         return token_reply.token
 
-    def __get_stub_for_get_token(self, service_client: ServiceClient):
+    def __get_stub_for_get_token(self, service_client):
         grpc_channel = service_client.get_grpc_base_channel()
         with add_to_path(str(RESOURCES_PATH.joinpath("proto"))):
             token_service_pb2_grpc = importlib.import_module("token_service_pb2_grpc")
         return token_service_pb2_grpc.TokenServiceStub(grpc_channel)
 
-    def __get_token_for_amount(self, service_client: ServiceClient, channel, amount):
+    def __get_token_for_amount(self, service_client, channel, amount):
         nonce = channel.state["nonce"]
         stub = self.__get_stub_for_get_token(service_client)
         with add_to_path(str(RESOURCES_PATH.joinpath("proto"))):

snet/sdk/payment_strategies/default_payment_strategy.py

@@ -1,4 +1,3 @@
-from snet.sdk.concurrency_manager import ConcurrencyManager
 from snet.sdk.payment_strategies.freecall_payment_strategy import FreeCallPaymentStrategy
 from snet.sdk.payment_strategies.paidcall_payment_strategy import PaidCallPaymentStrategy
 from snet.sdk.payment_strategies.prepaid_payment_strategy import PrePaidPaymentStrategy
@@ -16,13 +15,13 @@ def set_channel(self, channel):
     def get_payment_metadata(self, service_client):
         free_call_payment_strategy = FreeCallPaymentStrategy()
 
-        if free_call_payment_strategy.is_free_call_available(service_client):
+        if free_call_payment_strategy.get_free_calls_available(service_client) > 0:
             metadata = free_call_payment_strategy.get_payment_metadata(service_client)
         else:
             if service_client.get_concurrency_flag():
                 concurrent_calls = service_client.get_concurrent_calls()
                 payment_strategy = PrePaidPaymentStrategy(concurrent_calls)
-                metadata = payment_strategy.get_payment_metadata(service_client, self.channel)
+                metadata = payment_strategy.get_payment_metadata(service_client)
             else:
                 payment_strategy = PaidCallPaymentStrategy()
                 metadata = payment_strategy.get_payment_metadata(service_client)

snet/sdk/payment_strategies/freecall_payment_strategy.py

@@ -12,9 +12,8 @@ def __init__(self):
         self._user_address = None
         self._free_call_token = None
         self._token_expiration_block = None
-        self._free_calls_available = None
 
-    def is_free_call_available(self, service_client) -> bool:
+    def get_free_calls_available(self, service_client) -> int:
         if not self._user_address:
             self._user_address = service_client.account.signer_address
 
@@ -31,29 +30,27 @@ def is_free_call_available(self, service_client) -> bool:
         with add_to_path(str(RESOURCES_PATH.joinpath("proto"))):
             state_service_pb2_grpc = importlib.import_module("state_service_pb2_grpc")
 
-        signature = self.generate_signature(service_client, current_block_number)
+        signature, _ = self.generate_signature(service_client, current_block_number)
         request = state_service_pb2.FreeCallStateRequest(
             address=self._user_address,
             free_call_token=self._free_call_token,
             signature=signature,
             current_block=current_block_number
         )
 
-        channel = service_client._get_grpc_channel()
+        channel = service_client.get_grpc_base_channel()
         stub = state_service_pb2_grpc.FreeCallStateServiceStub(channel)
 
         try:
             response = stub.GetFreeCallsAvailable(request)
-            if response.free_calls_available > 0:
-                return True
-            return False
+            return response.free_calls_available
         except grpc.RpcError as e:
             if self._user_address:
                 print(f"Warning: {e.details()}")
-            return False
+            return 0
 
     def get_payment_metadata(self, service_client) -> list:
-        if self.is_free_call_available(service_client):
+        if self.get_free_calls_available(service_client) <= 0:
             raise Exception(f"Free calls limit for address {self._user_address} has expired. Please use another payment strategy")
         signature, current_block_number = self.generate_signature(service_client)
         metadata = [("snet-free-call-auth-token-bin", self._free_call_token),
@@ -96,7 +93,7 @@ def get_free_call_token_details(self, service_client, current_block_number=None)
         with add_to_path(str(RESOURCES_PATH.joinpath("proto"))):
             state_service_pb2_grpc = importlib.import_module("state_service_pb2_grpc")
 
-        channel = service_client._get_grpc_channel()
+        channel = service_client.get_grpc_base_channel()
         stub = state_service_pb2_grpc.FreeCallStateServiceStub(channel)
         response = stub.GetFreeCallToken(request)
 

snet/sdk/payment_strategies/prepaid_payment_strategy.py

@@ -4,14 +4,17 @@
 
 class PrePaidPaymentStrategy(PaymentStrategy):
 
-    def __init__(self, concurrent_calls: int, block_offset: int = 240, call_allowance: int = 1):
+    def __init__(self, concurrent_calls: int=1, block_offset: int = 240, call_allowance: int = 1):
         self.concurrency_manager = ConcurrencyManager(concurrent_calls)
         self.block_offset = block_offset
         self.call_allowance = call_allowance
 
     def get_price(self, service_client):
         return service_client.get_price() * self.concurrency_manager.concurrent_calls
 
+    def set_concurrent_calls(self, concurrent_calls):
+        self.concurrency_manager.concurrent_calls = concurrent_calls
+
     def get_payment_metadata(self, service_client):
         channel = self.select_channel(service_client)
         token = self.concurrency_manager.get_token(service_client, channel, self.get_price(service_client))

snet/sdk/service_client.py

@@ -12,12 +12,12 @@
 from eth_account.messages import defunct_hash_message
 from rfc3986 import urlparse
 
-from snet.sdk import generic_client_interceptor
+from snet.sdk import generic_client_interceptor, FreeCallPaymentStrategy
 from snet.sdk.account import Account
 from snet.sdk.mpe.mpe_contract import MPEContract
 from snet.sdk.mpe.payment_channel import PaymentChannel
 from snet.sdk.mpe.payment_channel_provider import PaymentChannelProvider
-from snet.sdk.payment_strategies import default_payment_strategy as strategy
+from snet.sdk.payment_strategies.prepaid_payment_strategy import PrePaidPaymentStrategy
 from snet.sdk.resources.root_certificate import certificate
 from snet.sdk.storage_provider.service_metadata import MPEServiceMetadata
 from snet.sdk.custom_typing import ModuleName, ServiceStub
@@ -51,6 +51,8 @@ def __init__(
         self.service_metadata = service_metadata
         self.group = group
         self.payment_strategy = payment_strategy
+        if isinstance(payment_strategy, PrePaidPaymentStrategy):
+            self.payment_strategy.set_concurrent_calls(options["concurrent_calls"])
         self.options = options
         self.mpe_address = mpe_contract.contract.address
         self.account = account
@@ -322,3 +324,10 @@ def get_services_and_messages_info_as_pretty_string(self) -> str:
             for field_type, field_name in fields:
                 string_output += f"  Field: {field_type} {field_name}\n"
         return string_output
+
+    def get_free_calls_available(self) -> int:
+        payment_strategy = self.payment_strategy
+        if not isinstance(payment_strategy, FreeCallPaymentStrategy):
+            payment_strategy = FreeCallPaymentStrategy()
+
+        return payment_strategy.get_free_calls_available(self)