wip tck support

Signed-off-by: LukeBair <[email protected]>

Author: LukeBair

pyproject.toml

@@ -18,7 +18,8 @@ dependencies = [
     "grpcio==1.68.1",
     "cryptography==44.0.0",
     "python-dotenv==1.0.1",
-    "requests==2.32.3"
+    "requests==2.32.3",
+    "jsonrpcserver>=5.0.9",
 ]
 classifiers = [
     "Development Status :: 2 - Pre-Alpha",

tck/README.md

@@ -0,0 +1,60 @@
+import utils
+
+from jsonrpcserver import method, Success
+from hiero_sdk_python.account.account_create_transaction import AccountCreateTransaction
+from key_identifier import KeyIdentifier
+
+# NOTE: The problem is I need to use a string to identify whether or not a key is ecdsa, ed25519, public or private
+#  The PrivateKey class has a 'from_string' class which I can take advantage of easily
+#  The PublicKey doesnt have anything helpful, once you have a reference to it you can check if it is ed25519 or ecdsa
+#  So I will likely have to add a way to check for the public key, this can be done outside of the PublicKey class,
+#   but to keep consistency with the PrivateKey class it would be really nice to have a 'from_string' class in there
+#   Ill take a look into it rn to see if it is something I am capable of doing well (I know a way I could but its dookie)
+#   It doesnt look like something that I really have any right doing, Im not really sure where to start with the ec key,
+#   I'll look into it again
+#  Ignoring KeyLists right now
+#  The """...""" block is taken directly from the tck AccountCreateTransaction.md & combined with the intellij
+#   autogenerated """...""" block
+@method
+def createAccount(key: str = None, initialBalance: str = None, receiverSignatureRequired: bool = None, autoRenewPeriod: str = None,
+    memo: str = None, maxAutoTokenAssociations: int = None, stakedAccountId: str = None, stakedNodeId: str = None,
+    declineStakingReward: bool = None, alias: str = None, commonTransactionParams: dict = None):
+    """
+    :param key: string, optional, DER-encoded hex string representation for private or public keys. Keylists and threshold keys are the hex of the serialized protobuf bytes.
+    :param initialBalance: Units of tinybars, optional
+    :param receiverSignatureRequired: bool, optional
+    :param autoRenewPeriod: string, Units of seconds, optional
+    :param memo: string, optional
+    :param maxAutoTokenAssociations: int32, optional
+    :param stakedAccountId: string, optional
+    :param stakedNodeId: string, optional
+    :param declineStakingReward: bool, optional
+    :param alias: string, optional, Hex string representation of the keccak-256 hash of an ECDSAsecp256k1 public key type.
+    :param commonTransactionParams: JSON object, optional
+
+    :return accountId: string, The ID of the created account.
+    :return status:	string, The status of the submitted AccountCreateTransaction (from a TransactionReceipt).
+    """
+    key_and_public = KeyIdentifier.identify(key)
+
+    if key_and_public[1] is False:
+        public_key = key_and_public[0].public_key()
+    else:
+        public_key = key_and_public[0]
+
+    # TODO: add all of the other transaction parameters
+    transaction = (
+        AccountCreateTransaction()
+        .set_key(public_key)
+        .set_account_memo(memo)
+        .freeze_with(utils.__client)
+    )
+    # WARNING: I believe that this is right, but im not sure what the case is if the key parameter is a Private Key
+    #  why the heck are they giving me a private key anyways...
+    transaction.sign(utils.__operatorPrivateKey)
+    receipt = transaction.execute(utils.__client)
+
+    return Success({
+        "accountId": receipt.accountId,
+        "status": receipt.status,
+    })

tck/__init__.py

@@ -0,0 +1,25 @@
+from cryptography.hazmat.primitives.asymmetric import ed25519, ec
+from hiero_sdk_python import PublicKey, PrivateKey
+
+class KeyIdentifier:
+
+    # NOTE: after having AI try and fail to write this code for a couple tries Im going to give it a crack
+    #  to prove that AI isnt better than a 19 year old bum. Also cause they cant do it and im cocky.
+    #  So this method will have to do a couple things, it will need to be able to identify from bytes and a string.
+    #  Hedera's DER keys seem to be in a hex format
+    # TODO: The fact that identify() and is_public() have super similar code is disgusting
+    # NOTE: You can probably take some of this code and use it for importing an existing key: https://docs.hedera.com/hedera/sdks-and-apis/sdks/keys/import-an-existing-key
+
+    @classmethod
+    def identify(cls, key: str) -> tuple[None | PublicKey | PrivateKey, bool | None]:
+        """
+        This function will either return a cryptography ...Key object, or it will return None, should not be used
+        for anything outside of the TCK code.
+        """
+        try:
+            return PublicKey.from_string(key), True
+        except ValueError:
+            try:
+                return PrivateKey.from_string(key), False
+            except ValueError:
+                return None, None

tck/account_create.py

@@ -0,0 +1,9 @@
+import logging
+import utils
+import account_create
+from jsonrpcserver import serve, method
+
+logging.basicConfig(level=logging.DEBUG)
+
+if __name__ == '__main__':
+    serve(port=8545)  # Specify your desired port here

tck/key_identifier.py

@@ -0,0 +1,53 @@
+from hiero_sdk_python.account.account_id import AccountId
+from hiero_sdk_python.client.client import Client
+from jsonrpcserver import Success, method, InvalidParams
+from hiero_sdk_python.crypto.private_key import PrivateKey
+
+__operatorAccountId: AccountId
+__operatorPrivateKey: PrivateKey
+__client: Client = Client()
+
+@method
+def setup(operatorAccountId: str=None, operatorPrivateKey: str=None, nodeIp: str=None, nodeAccountId: str=None, mirrorNetworkIp: str=None):
+    global __client, __operatorAccountId, __operatorPrivateKey
+    __operatorAccountId = AccountId.from_string(operatorAccountId)
+    __operatorPrivateKey = PrivateKey.from_string(operatorPrivateKey[2:])
+    __client.set_operator(__operatorAccountId, __operatorPrivateKey)
+
+    return Success({
+        "message":"Successfully setup custom client.",
+        "status":"SUCCESS"
+    })
+
+@method
+def reset():
+    global  __operatorAccountId, __operatorPrivateKey, __client
+
+    __operatorAccountId = None
+    __operatorPrivateKey = None
+    __client = Client()
+
+    return Success({
+        "message":"Successfully reset client.",
+        "status":"SUCCESS"
+    })
+
+@method
+def generateKey(type: str=None, fromKey: str=None, threshold: int=None, keys: list=None):
+    if type == "ed25519PublicKey":
+        new_account_private_key = PrivateKey.from_string(fromKey)
+        new_account_public_key = new_account_private_key.public_key()
+        return Success({"key": new_account_public_key.to_string_raw()})
+
+    elif type == "ecdsaSecp256k1PublicKey":
+        new_account_private_key = PrivateKey.from_string(fromKey)
+        new_account_public_key = new_account_private_key.public_key()
+        return Success({"key": new_account_public_key.to_string_raw()})
+
+    elif type == "ed25519PrivateKey":
+        new_account_private_key = PrivateKey.generate()
+        return Success({"key": new_account_private_key.to_string_raw()})
+
+    else:
+        return InvalidParams("Unknown type")
+

tck/server.py

@@ -0,0 +1,7 @@
+from cryptography.hazmat.primitives.asymmetric.ec import EllipticCurvePublicKey
+
+from tck.key_identifier import KeyIdentifier
+
+
+def test_key_identifier():
+    assert isinstance(KeyIdentifier().identify("302d300706052b8104000a03220002ffda8e4c9faf6d2b89189196f76c8c6448f7f04e00f56ccff63ba857c2782661"), EllipticCurvePublicKey)