fix lint

Author: billbsing

convex_api/__init__.py

@@ -5,8 +5,8 @@
 """
 
 from convex_api.account import Account                   # noqa: F401
-from convex_api.api import API                    # noqa: F401
+from convex_api.api import API                           # noqa: F401
+from convex_api.contract import Contract                 # noqa: F401
 from convex_api.key_pair import KeyPair                  # noqa: F401
 
-
 __version__ = "__version__ = '0.2.2'"

convex_api/api.py

@@ -660,6 +660,13 @@ def resolve_name(self, name):
         """
         return self._registry.resolve_address(name)
 
+    def load_contract(self, name):
+        from convex_api.contract import Contract
+
+        contract = Contract(self)
+        if contract.load(name=name):
+            return contract
+
     def _transaction_post(self, url, data, sequence_retry_count=20):
         max_sleep_time_seconds = 1
         while sequence_retry_count >= 0:

convex_api/contract.py

@@ -0,0 +1,96 @@
+"""
+
+
+Convex Contract
+
+"""
+
+from convex_api.utils import to_address
+
+
+class Contract:
+    def __init__(self, convex):
+        self._convex = convex
+        self._name = None
+        self._address = None
+        self._owner_address = None
+
+    def load(self, name=None, address=None, owner_address=None):
+
+        if name:
+            address = self.resolve_address(name)
+            owner_address = self.resolve_owner_address(name)
+            self._name = name
+
+        if address is None:
+            raise ValueError('no contract found')
+
+        if owner_address is None:
+            owner_address = address
+
+        self._address = address
+        self._owner_address = owner_address
+        return self._address
+
+    def deploy(self, account, text=None, filename=None, name=None, owner_account=None):
+        if filename:
+            with open(filename, 'r') as fp:
+                text = fp.read()
+        if text is None:
+            raise ValueError('You need to provide a contract filename or text to deploy')
+        deploy_line = f"""
+(deploy
+    (quote
+        (do
+            {text}
+        )
+    )
+)
+    """
+        result = self._convex.send(deploy_line, account)
+        if result and 'value' in result:
+            address = to_address(result["value"])
+            if name:
+                if owner_account is None:
+                    owner_account = account
+                self._convex.registry.register(name, address, owner_account)
+            return address
+
+    def register(self, name, address, account):
+        return self._convex.registry.register(name, address, account)
+
+    def send(self, transaction, account):
+        if not self._address:
+            raise ValueError(f'No contract address found for {self._name}')
+        return self._convex.send(f'(call #{self._address} {transaction})', account)
+
+    def query(self, transaction, account_address=None):
+        if not self._address:
+            raise ValueError(f'No contract address found for {self._name}')
+        if account_address is None:
+            account_address = to_address(account_address)
+        if account_address is None:
+            account_address = self._address
+        return self._convex.query(f'(call #{self._address} {transaction})', account_address)
+
+    def resolve_address(self, name):
+        return self._convex.registry.resolve_address(name)
+
+    def resolve_owner_address(self, name):
+        return self._convex.registry.resolve_owner(name)
+
+    @property
+    def is_registered(self):
+        return self._address is not None
+
+    @property
+    def address(self):
+        return self._address
+
+    @property
+    def owner_address(self):
+        return self._owner_address
+
+    @property
+    def name(self):
+        return self._name

convex_api/utils.py

@@ -6,11 +6,12 @@
 import binascii
 import re
 
+
 from cryptography.hazmat.backends.openssl.backend import backend
 from cryptography.hazmat.primitives import hashes
 
 
-def to_address(text):
+def to_address(value):
     """
     Convert address text with possible leading '#' to an interger address value.
 
@@ -19,15 +20,16 @@ def to_address(text):
     :returns: Integer address or None if not a valid address
 
     """
-    if isinstance(text, int):
-        return int(text)
-    if isinstance(text, str):
+    if isinstance(value, int):
+        return int(value)
+    elif is_account(value):
+        return value.address
+    elif isinstance(value, str):
         try:
-            value = int(re.sub(r'^#', '', text.strip()))
+            address = int(re.sub(r'^#', '', value.strip()))
         except ValueError:
             return None
-        return value
-    return None
+        return address
 
 
 def is_address(text):
@@ -178,3 +180,8 @@ def to_hex(value):
     :returns: Returns a hex string with a preappended '0x'
     """
     return add_0x_prefix(binascii.hexlify(value).decode())
+
+
+def is_account(value):
+    from convex_api import Account
+    return isinstance(value, Account)

tests/intergration/test_contract.py

@@ -0,0 +1,50 @@
+"""
+
+    Test contract
+
+"""
+import pytest
+
+from convex_api import (
+    Account,
+    API,
+    Contract
+)
+
+
+TEST_FUNDING_AMOUNT = 8888888
+
+TEST_CONTRACT_FILENAME = './tests/resources/test_contract.cvx'
+TEST_CONTRACT_NAME = 'test_contract_starfish'
+
+
+def test_convex_api_deploy_contract(convex_url, test_account):
+    convex = API(convex_url)
+
+    # create a contract object
+    contract = Contract(convex)
+
+    # set the default owner to the test_account
+    owner_account = test_account
+
+    # see if it has already been created by another test account
+    owner_address = contract.resolve_owner_address(TEST_CONTRACT_NAME)
+    if owner_address:
+        # if so then rebuild the owner account using the same key_pair
+        owner_account = Account(test_account.key_pair, owner_address)
+    else:
+        owner_address = test_account.address
+
+    # deploy the contract
+    contract_address = contract.deploy(owner_account, filename=TEST_CONTRACT_FILENAME, name=TEST_CONTRACT_NAME)
+    assert(contract_address)
+    # load the contract - should be the same address
+    new_address = contract.load(TEST_CONTRACT_NAME)
+    assert(contract_address == new_address)
+    assert(contract_address == contract.address)
+    assert(owner_address == contract.owner_address)
+
+
+    contract = convex.load_contract(TEST_CONTRACT_NAME)
+    assert(contract)
+    assert(contract_address == contract.address)

tests/resources/test_contract.cvx

@@ -0,0 +1,14 @@
+(def stored-data
+    ^{:private? true}
+    nil
+)
+(defn get
+    ^{:callable? true}
+    []
+    stored-data
+)
+(defn set
+    ^{:callable? true}
+    [x]
+    ( def stored-data x)
+)