feat: Add transferCrypto method to TCK

Signed-off-by: aceppaluni <aceppaluni@gmail.com>

Author: aceppaluni

tck/handlers/__init__.py

@@ -8,6 +8,7 @@
     key,
     sdk,  # setup, reset
     topic,
+    transfer,
 )
 from .registry import (
     get_all_handlers,

tck/handlers/transfer.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from hiero_sdk_python import (
+    AccountId,
+    Hbar,
+    NftId,
+    TokenId,
+    TransferTransaction,
+)
+from hiero_sdk_python.response_code import ResponseCode
+from tck.handlers.registry import rpc_method
+from tck.param.transfer import TransferCryptoParams
+from tck.response.transfer import TransferCryptoResponse
+from tck.util.client_utils import get_client
+
+
+def _build_transfer_transaction(params: TransferCryptoParams) -> TransferTransaction:
+    tx = TransferTransaction()
+
+    tx.set_grpc_deadline(params.grpcDeadline)
+
+    if not params.transfers:
+        return tx
+
+    for entry in params.transfers:
+        ## HBAR Transfer
+        if entry.hbar is not None:
+            hbar = entry.hbar
+            account = AccountId.from_string(hbar.evmAddress if hbar.evmAddress else hbar.accountId)
+            amount = Hbar.from_string(int(hbar.amount))
+
+            if entry.approved:
+                tx.add_approved_hbar_transfer(account, amount)
+            else:
+                tx.add_hbar_transfer(account, amount)
+
+        ## Token Transfer
+        elif entry.token is not None:
+            token = entry.tokem
+
+            token_id = TokenId.from_string(token.tokenId)
+            account = AccountId.from_string(token.accountId)
+
+            if token.decimals is not None:
+                decimals = int(token.decimals)
+
+                if entry.approved:
+                    tx.add_approved_token_transfer_with_decimals(token_id, account, int(token.amount), decimals)
+                else:
+                    tx.add_token_transfer_with_decimals(token_id, account, int(token.amount), decimals)
+            else:
+                if entry.approved:
+                    tx.add_approved_token_transfer(token_id, account, int(token.amount))
+                else:
+                    tx.add_token_transfer(token_id, account, int(token.amount))
+
+        ## NFT Transfer
+        elif entry.nft is not None:
+            nft = entry.nft
+
+            nft_id = NftId(TokenId.from_string(nft.tokenId), int(nft.serialNumber))
+
+            sender = AccountId.from_string(nft.senderAccountId)
+            receiver = AccountId.from_string(nft.receiverAccountId)
+
+            if entry.approved:
+                tx.add_approved_nft_transfer(nft_id, sender, receiver)
+            else:
+                tx.add_nft_transfer(nft_id, sender, receiver)
+
+    return tx
+
+
+@rpc_method("transferCrypto")
+def transfer_crypto(params: TransferCryptoParams) -> TransferCryptoResponse:
+    client = get_client(params.sessionId)
+
+    tx = _build_transfer_transaction(params)
+
+    if hasattr(params, "commonTransactionParams") and params.commonTransactionParams:
+        tx.apply_common_params(params.commonTransactionParams)
+
+    receipt = tx.execute(client, wait_for_receipt=False).get_receipt(
+        client,
+        validate_status=True,
+    )
+
+    return TransferCryptoResponse(status=ResponseCode(receipt.status).name)

tck/param/transfer.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from tck.param.base import BaseTransactionParams
+from tck.util.param_utils import parse_session_id, to_bool
+
+
+@dataclass
+class HbarTransferParams:
+    accountId: str | None = None
+    evmAddress: str | None = None
+    amount: str | None = None
+
+    @classmethod
+    def parse_json_params(cls, params: dict[str, object]) -> HbarTransferParams:
+        return cls(accountId=params.get("accountId"), evmAddress=params.get("evmAddress"), amount=params.get("amount"))
+
+
+@dataclass
+class TokenTransferParams:
+    tokenId: str | None = None
+    accountId: str | None = None
+    amount: str | None = None
+    decimals: str | None = None
+
+    @classmethod
+    def parse_json_params(cls, params: dict[str, object]) -> TokenTransferParams:
+        return cls(
+            tokenId=params.get("tokenId"),
+            accountId=params.get("accountId"),
+            amount=params.get("amount"),
+            decimals=params.get("decimals"),
+        )
+
+
+@dataclass
+class NftTransferParams:
+    tokenId: str | None = None
+    serialNumber: str | None = None
+    senderAccountId: str | None = None
+    receiverAccountId: str | None = None
+
+    @classmethod
+    def parse_json_params(cls, params: dict[str, object]) -> NftTransferParams:
+        return cls(
+            tokenId=params.get("tokenId"),
+            serialNumber=params.get("serialNumber"),
+            senderAccountId=params.get("senderAccountId"),
+            receiverAccountId=params.get("receiverAccountId"),
+        )
+
+
+@dataclass
+class TransferParams:
+    hbar: HbarTransferParams | None = None
+    token: TokenTransferParams | None = None
+    nft: NftTransferParams | None = None
+    approved: bool | None = None
+
+    @classmethod
+    def parse_json_params(cls, params: dict[str, object]) -> TransferParams:
+        return cls(
+            hbar=HbarTransferParams.parse_json_params(params["hbar"]) if params.get("hbar") is not None else None,
+            token=TokenTransferParams.parse_json_params(params["token"]) if params.get("token") is not None else None,
+            nft=NftTransferParams.parse_json_params(params["nft"]) if params.get("nft") is not None else None,
+            approved=to_bool(params.get("approved")) if "approved" in params else None,
+        )
+
+
+@dataclass
+class TransferCryptoParams(BaseTransactionParams):
+    transfers: list[TransferParams] | None = None
+
+    @classmethod
+    def parse_json_params(cls, params: dict) -> TransferCryptoParams:
+        transfers_raw = params.get("transfers")
+
+        return cls(
+            sessionId=parse_session_id(params),
+            commonTransactionParams=params.get("commonTransactionParams"),
+            transfers=[TransferParams.parse_json_params(t) for t in transfers_raw] if transfers_raw else None,
+        )

tck/response/transfer.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class TransferCryptoResponse:
+    status: str | None = None