feat: allow making payments using auth client

Author: mfontanini

pyproject.toml

@@ -9,6 +9,7 @@ license = {text = "MIT"}
 readme = "README.rst"
 requires-python = ">=3.9"
 dependencies = [
+    "cosmpy==0.9.2",
     "requests==2.32.3",
     "secp256k1==0.14.0",
 ]

src/nuc/authority.py

@@ -2,13 +2,19 @@
 Authority service APIs.
 """
 
+import logging
+import hashlib
 from datetime import datetime, timedelta, timezone
 from dataclasses import dataclass
 import secrets
 import json
 import requests
 from secp256k1 import PrivateKey, PublicKey
 
+from nuc.payer import Payer
+
+logger = logging.getLogger(__name__)
+
 
 DEFAULT_REQUEST_TIMEOUT: float = 10
 
@@ -102,6 +108,45 @@ def request_token(self, key: PrivateKey) -> str:
         response = response.json()
         return response["token"]
 
+    def pay_subscription(
+        self,
+        our_public_key: PublicKey,
+        payer: Payer,
+    ) -> None:
+        """
+        Pay for a subscription.
+
+        Arguments
+        ---------
+
+        our_public_key
+            The public key the subscription is for.
+        payer
+            The payer that will be used.
+        """
+        public_key = self.about().public_key.serialize()
+        payload = json.dumps(
+            {
+                "nonce": secrets.token_bytes(16).hex(),
+                "service_public_key": public_key.hex(),
+            }
+        ).encode("utf8")
+        # Note: add proper value later on
+        tx_hash = payer.pay(hashlib.sha256(payload).digest(), amount_unil=1)
+
+        request = {
+            "tx_hash": tx_hash,
+            "payload": payload.hex(),
+            "public_key": our_public_key.serialize().hex(),
+        }
+
+        response = requests.post(
+            f"{self._base_url}/api/v1/payments/validate",
+            json=request,
+            timeout=self._timeout_seconds,
+        )
+        response.raise_for_status()
+
     def about(self) -> AuthorityServiceAbout:
         """
         Get information about the authority service.

src/nuc/payer.py

@@ -0,0 +1,83 @@
+"""
+Nilchain payer.
+"""
+
+import logging
+from cosmpy.aerial.tx import Transaction
+from cosmpy.aerial.wallet import Address, LocalWallet
+from cosmpy.crypto.keypairs import PrivateKey as NilchainPrivateKey
+from cosmpy.aerial.client import (
+    LedgerClient,
+    NetworkConfig,
+    prepare_and_broadcast_basic_transaction,
+)
+
+# pylint: disable=E0611
+from .proto.tx_pb2 import MsgPayFor, Amount
+
+logger = logging.getLogger(__name__)
+
+
+DEFAULT_QUERY_TIMEOUT_SECONDS = 30
+DEFAULT_QUERY_POLL_SECONDS = 1
+
+
+class Payer:
+    """
+    A payer that allows making payments on nilchain.
+    """
+
+    def __init__(
+        self,
+        wallet_private_key: NilchainPrivateKey,
+        chain_id: str,
+        grpc_endpoint: str,
+        gas_limit: int,
+        query_timeout_seconds: int = DEFAULT_QUERY_TIMEOUT_SECONDS,
+        query_poll_seconds: int = DEFAULT_QUERY_POLL_SECONDS,
+    ) -> None:
+        self.wallet = LocalWallet(wallet_private_key, "nillion")
+        self.gas_limit = gas_limit
+        payments_config = NetworkConfig(
+            chain_id=chain_id,
+            url=f"grpc+{grpc_endpoint}/",
+            fee_minimum_gas_price=0,
+            fee_denomination="unil",
+            staking_denomination="unil",
+            faucet_url=None,
+        )
+        self.client = LedgerClient(
+            payments_config,
+            query_interval_secs=query_poll_seconds,
+            query_timeout_secs=query_timeout_seconds,
+        )
+
+    def pay(self, resource: bytes, amount_unil: int) -> str:
+        """
+        Perform a `MsgPayFor` payment for the given resource.
+
+        Arguments
+        ---------
+
+        resource
+            The resource to use in the transaction.
+        amount_unil
+            The amount of unil to send in the payment.
+        """
+
+        transaction = Transaction()
+        message = MsgPayFor(
+            resource=resource,
+            from_address=str(Address(self.wallet.public_key(), "nillion")),
+            amount=[Amount(denom="unil", amount=str(amount_unil))],
+        )
+        transaction.add_message(message)
+
+        submitted_transaction = prepare_and_broadcast_basic_transaction(
+            self.client, transaction, self.wallet, gas_limit=self.gas_limit
+        )
+
+        tx_hash = submitted_transaction.tx_hash
+        logger.info("Waiting for transaction %s to be committed", tx_hash)
+        submitted_transaction.wait_to_complete()
+        return tx_hash

src/nuc/proto/tx_pb2.py

@@ -0,0 +1,37 @@
+from google.protobuf.internal import containers as _containers
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from typing import (
+    ClassVar as _ClassVar,
+    Iterable as _Iterable,
+    Mapping as _Mapping,
+    Optional as _Optional,
+    Union as _Union,
+)
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class MsgPayFor(_message.Message):
+    __slots__ = ("resource", "from_address", "amount")
+    RESOURCE_FIELD_NUMBER: _ClassVar[int]
+    FROM_ADDRESS_FIELD_NUMBER: _ClassVar[int]
+    AMOUNT_FIELD_NUMBER: _ClassVar[int]
+    resource: bytes
+    from_address: str
+    amount: _containers.RepeatedCompositeFieldContainer[Amount]
+    def __init__(
+        self,
+        resource: _Optional[bytes] = ...,
+        from_address: _Optional[str] = ...,
+        amount: _Optional[_Iterable[_Union[Amount, _Mapping]]] = ...,
+    ) -> None: ...
+
+class Amount(_message.Message):
+    __slots__ = ("denom", "amount")
+    DENOM_FIELD_NUMBER: _ClassVar[int]
+    AMOUNT_FIELD_NUMBER: _ClassVar[int]
+    denom: str
+    amount: str
+    def __init__(
+        self, denom: _Optional[str] = ..., amount: _Optional[str] = ...
+    ) -> None: ...