Updated FreeCallPaymentStrategy

Author: Arondondon

snet/sdk/__init__.py

@@ -103,6 +103,7 @@ def create_service_client(self,
                               org_id: str,
                               service_id: str,
                               group_name: str=None,
+                              payment_strategy: PaymentStrategy = None,
                               payment_strategy_type: PaymentStrategyType=PaymentStrategyType.DEFAULT,
                               address=None,
                               options=None,
@@ -135,7 +136,8 @@ def create_service_client(self,
         options['concurrency'] = self._sdk_config.get("concurrency", True)
         options['concurrent_calls'] = concurrent_calls
 
-
+        if payment_strategy is None:
+            payment_strategy = payment_strategy_type.value()
 
         service_metadata = self._metadata_provider.enhance_service_metadata(
             org_id, service_id
@@ -146,7 +148,8 @@ def create_service_client(self,
 
         pb2_module = self.get_module_by_keyword(keyword="pb2.py")
         _service_client = ServiceClient(org_id, service_id, service_metadata,
-                                        group, service_stubs, payment_strategy_type.value(),
+                                        group, service_stubs,
+                                        payment_strategy,
                                         options, self.mpe_contract,
                                         self.account, self.web3, pb2_module,
                                         self.payment_channel_provider,

snet/sdk/payment_strategies/default_payment_strategy.py

@@ -7,14 +7,9 @@
 
 class DefaultPaymentStrategy(PaymentStrategy):
 
-    def __init__(self, concurrent_calls: int = 1):
-        self.concurrent_calls = concurrent_calls
-        self.concurrencyManager = ConcurrencyManager(concurrent_calls)
+    def __init__(self):
         self.channel = None
 
-    def set_concurrency_token(self, token):
-        self.concurrencyManager.__token = token
-
     def set_channel(self, channel):
         self.channel = channel
 
@@ -25,7 +20,8 @@ def get_payment_metadata(self, service_client):
             metadata = free_call_payment_strategy.get_payment_metadata(service_client)
         else:
             if service_client.get_concurrency_flag():
-                payment_strategy = PrePaidPaymentStrategy(self.concurrencyManager)
+                concurrent_calls = service_client.get_concurrent_calls()
+                payment_strategy = PrePaidPaymentStrategy(concurrent_calls)
                 metadata = payment_strategy.get_payment_metadata(service_client, self.channel)
             else:
                 payment_strategy = PaidCallPaymentStrategy()
@@ -37,5 +33,6 @@ def get_price(self, service_client):
         pass
 
     def get_concurrency_token_and_channel(self, service_client):
-        payment_strategy = PrePaidPaymentStrategy(self.concurrencyManager)
+        concurrent_calls = service_client.get_concurrent_calls()
+        payment_strategy = PrePaidPaymentStrategy(concurrent_calls)
         return payment_strategy.get_concurrency_token_and_channel(service_client)

snet/sdk/payment_strategies/freecall_payment_strategy.py

@@ -1,42 +1,48 @@
 import importlib
-from urllib.parse import urlparse
 
 import grpc
-from grpc import _channel
 import web3
 
 from snet.sdk.payment_strategies.payment_strategy import PaymentStrategy
-from snet.sdk.resources.root_certificate import certificate
 from snet.sdk.utils.utils import RESOURCES_PATH, add_to_path
 
 class FreeCallPaymentStrategy(PaymentStrategy):
 
+    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:
-        try:
+        if not self._user_address:
             self._user_address = service_client.account.signer_address
-            self._free_call_token, self._token_expiry_date_block = self.get_free_call_token_details(service_client)
 
-            if not self._free_call_token:
-                return False
+        current_block_number = service_client.get_current_block_number()
 
-            with add_to_path(str(RESOURCES_PATH.joinpath("proto"))):
-                state_service_pb2 = importlib.import_module("state_service_pb2")
+        if (not self._free_call_token or
+                not self._token_expiration_block or
+                current_block_number > self._token_expiration_block):
+            self._free_call_token, self._token_expiration_block = self.get_free_call_token_details(service_client)
 
-            with add_to_path(str(RESOURCES_PATH.joinpath("proto"))):
-                state_service_pb2_grpc = importlib.import_module("state_service_pb2_grpc")
+        with add_to_path(str(RESOURCES_PATH.joinpath("proto"))):
+            state_service_pb2 = importlib.import_module("state_service_pb2")
 
-            signature, current_block_number = self.generate_signature(service_client)
+        with add_to_path(str(RESOURCES_PATH.joinpath("proto"))):
+            state_service_pb2_grpc = importlib.import_module("state_service_pb2_grpc")
 
-            request = state_service_pb2.FreeCallStateRequest()
-            request.user_address = self._user_address
-            request.token_for_free_call = self._free_call_token
-            request.token_expiry_date_block = self._token_expiry_date_block
-            request.signature = signature
-            request.current_block = 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 = self.select_channel(service_client)
+        channel = service_client._get_grpc_channel()
+        stub = state_service_pb2_grpc.FreeCallStateServiceStub(channel)
 
-            stub = state_service_pb2_grpc.FreeCallStateServiceStub(channel)
+        try:
             response = stub.GetFreeCallsAvailable(request)
             if response.free_calls_available > 0:
                 return True
@@ -45,10 +51,10 @@ def is_free_call_available(self, service_client) -> bool:
             if self._user_address:
                 print(f"Warning: {e.details()}")
             return False
-        except Exception as e:
-            return False
 
     def get_payment_metadata(self, service_client) -> list:
+        if self.is_free_call_available(service_client):
+            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),
                     ("snet-payment-type", "free-call"),
@@ -58,52 +64,39 @@ def get_payment_metadata(self, service_client) -> list:
 
         return metadata
 
-    def select_channel(self, service_client) -> _channel.Channel:
-        _, _, _, daemon_endpoint = service_client.get_service_details()
-        endpoint_object = urlparse(daemon_endpoint)
-        if endpoint_object.port is not None:
-            channel_endpoint = endpoint_object.hostname + ":" + str(endpoint_object.port)
-        else:
-            channel_endpoint = endpoint_object.hostname
-
-        if endpoint_object.scheme == "http":
-            channel = grpc.insecure_channel(channel_endpoint)
-        elif endpoint_object.scheme == "https":
-            channel = grpc.secure_channel(channel_endpoint, grpc.ssl_channel_credentials(root_certificates=certificate))
-        else:
-            raise ValueError('Unsupported scheme in service metadata ("{}")'.format(endpoint_object.scheme))
-        return channel
-
-    def generate_signature(self, service_client) -> tuple[bytes, int]:
+    def generate_signature(self, service_client, current_block_number=None, with_token=True) -> tuple[bytes, int]:
+        if not current_block_number:
+            current_block_number = service_client.get_current_block_number()
         org_id, service_id, group_id, _ = service_client.get_service_details()
 
-        if self._token_expiry_date_block == 0 or len(self._user_address) == 0 or len(self._free_call_token) == 0:
-            raise Exception(
-                "You are using default 'FreeCallPaymentStrategy' to use this strategy you need to pass "
-                "'free_call_auth_token-bin','user_address','free-call-token-expiry-block' in config")
+        message_types = ["string", "string", "string", "string", "string", "uint256", "bytes32"]
+        message_values = ["__prefix_free_trial", self._user_address, org_id, service_id, group_id,
+                          current_block_number, self._free_call_token]
 
-        current_block_number = service_client.get_current_block_number()
+        if not with_token:
+            message_types = message_types[:-1]
+            message_values = message_values[:-1]
 
-        message = web3.Web3.solidity_keccak(
-            ["string", "string", "string", "string", "string", "uint256", "bytes32"],
-            ["__prefix_free_trial", self._user_address, org_id, service_id, group_id, current_block_number,
-             self._free_call_token]
-        )
+        message = web3.Web3.solidity_keccak(message_types, message_values)
         return service_client.generate_signature(message), current_block_number
 
-    def get_free_call_token_details(self, service_client) -> tuple[bytes, int]:
+    def get_free_call_token_details(self, service_client, current_block_number=None) -> tuple[bytes, int]:
+
+        signature, current_block_number = self.generate_signature(service_client, current_block_number, with_token=False)
+
         with add_to_path(str(RESOURCES_PATH.joinpath("proto"))):
             state_service_pb2 = importlib.import_module("state_service_pb2")
 
         request = state_service_pb2.GetFreeCallTokenRequest(
             address=self._user_address,
-
+            signature=signature,
+            current_block=current_block_number
         )
 
         with add_to_path(str(RESOURCES_PATH.joinpath("proto"))):
             state_service_pb2_grpc = importlib.import_module("state_service_pb2_grpc")
 
-        channel = self.select_channel(service_client)
+        channel = service_client._get_grpc_channel()
         stub = state_service_pb2_grpc.FreeCallStateServiceStub(channel)
         response = stub.GetFreeCallToken(request)
 

snet/sdk/payment_strategies/prepaid_payment_strategy.py

@@ -4,18 +4,16 @@
 
 class PrePaidPaymentStrategy(PaymentStrategy):
 
-    def __init__(self, concurrency_manager: ConcurrencyManager,
-                 block_offset: int = 240, call_allowance: int = 1):
-        self.concurrency_manager = concurrency_manager
+    def __init__(self, concurrent_calls: int, 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 get_payment_metadata(self, service_client, channel):
-        if channel is None:
-            channel = self.select_channel(service_client)
+    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))
         metadata = [
             ("snet-payment-type", "prepaid-call"),

snet/sdk/service_client.py

@@ -240,6 +240,9 @@ def get_concurrency_flag(self) -> bool:
     def get_concurrency_token_and_channel(self) -> tuple[str, PaymentChannel]:
         return self.payment_strategy.get_concurrency_token_and_channel(self)
 
+    def get_concurrent_calls(self):
+        return self.options.get('concurrent_calls', 1)
+
     def set_concurrency_token_and_channel(self, token: str,
                                           channel: PaymentChannel) -> None:
         self.payment_strategy.concurrency_token = token