Fix test case and update types

Author: sanlee42

README.md

@@ -47,7 +47,7 @@ def transfer(cli: client.Client, sender: local_account.LocalAccount, receipt: st
     now_seconds = int(node_info.get('now_seconds'))
     # expired after 12 hours
     expiration_timestamp_secs = now_seconds + 43200
-    raw_txn = types.RawTransaction(
+    raw_txn = types.RawUserTransaction(
         sender=sender.account_address,
         sequence_number=seq_num,
         payload=script,

examples/p2p_transfer.py

@@ -22,7 +22,7 @@ def transfer(cli: client.Client, sender: local_account.LocalAccount, receipt: st
     now_seconds = int(node_info.get('now_seconds'))
     # expired after 12 hours
     expiration_timestamp_secs = now_seconds + 43200
-    raw_txn = types.RawTransaction(
+    raw_txn = types.RawUserTransaction(
         sender=sender.account_address,
         sequence_number=seq_num,
         payload=script,

examples/p2p_transfer_by_address.py

@@ -21,7 +21,7 @@ def transfer(cli: client.Client, sender: local_account.LocalAccount, receiver: t
     now_seconds = int(node_info.get('now_seconds'))
     # expired after 12 hours
     expiration_timestamp_secs = now_seconds + 43200
-    raw_txn = types.RawTransaction(
+    raw_txn = types.RawUserTransaction(
         sender=sender.account_address,
         sequence_number=seq_num,
         payload=script,

examples/rotate_auth_key.py

@@ -10,7 +10,7 @@
 def rotate_key(cli: client.Client, account: local_account.LocalAccount, auth_key: auth_key.AuthKey):
     seq_num = cli.get_account_sequence(account.account_address)
     script = stdlib.encode_rotate_authentication_key_script(new_auth_key.data)
-    raw_txn = types.RawTransaction(
+    raw_txn = types.RawUserTransaction(
         sender=account.account_address,
         sequence_number=seq_num,
         payload=types.TransactionPayload__Script(script),

examples/swap_token.py

@@ -13,7 +13,7 @@ def send_txn(cli, sender, script_funtion):
     expiration_timestamp_secs = now_seconds + 43200
     seq_num = cli.get_account_sequence(
         "0x"+sender.account_address.bcs_serialize().hex())
-    raw_txn = RawTransaction(
+    raw_txn = RawUserTransaction(
         sender=sender.account_address,
         sequence_number=seq_num,
         payload=script_funtion,

setup.py

@@ -9,7 +9,7 @@
 
 setup(
     name="starcoin-sdk-python",
-    version="1.4.0",
+    version="1.4.1",
     description="The Python Client SDK for Starcoin",
     long_description=long_description,
     long_description_content_type='text/markdown',

starcoin/sdk/local_account.py

@@ -72,8 +72,8 @@ def private_key_hex(self) -> str:
     def compliance_public_key_bytes(self) -> bytes:
         return utils.public_key_bytes(self.compliance_key.public_key())
 
-    def sign(self, txn: starcoin_types.RawTransaction) -> starcoin_types.SignedUserTransaction:
-        """Create signed transaction for given raw transaction"""
+    def sign(self, txn: starcoin_types.RawUserTransaction) -> starcoin_types.SignedUserTransaction:
+        """Create signed transaction for given raw user transaction"""
         signature = self.private_key.sign(
             utils.raw_transaction_signing_msg(txn))
         return utils.create_signed_transaction(txn, self.public_key_bytes, signature)

starcoin/sdk/utils.py

@@ -97,12 +97,12 @@ def public_key_bytes(public_key: ed25519.Ed25519PublicKey) -> bytes:
 def currency_code(code: str) -> starcoin_types.TypeTag:
     """converts currency code string to starcoin_types.TypeTag"""
     if isinstance(code, str):
-        return starcoin_types.TypeTag__Struct(
+        return starcoin_types.TypeTag__struct(
             value=starcoin_types.StructTag(
                 address=account_address(CORE_CODE_ADDRESS),
                 module=starcoin_types.Identifier(code),
                 name=starcoin_types.Identifier(code),
-                type_params=[],
+                type_args=[],
             )
         )
 
@@ -112,12 +112,12 @@ def currency_code(code: str) -> starcoin_types.TypeTag:
 def currency_user_code(address: str, code: str) -> starcoin_types.TypeTag:
     """converts currency code string to starcoin_types.TypeTag"""
     if isinstance(code, str):
-        return starcoin_types.TypeTag__Struct(
+        return starcoin_types.TypeTag__struct(
             value=starcoin_types.StructTag(
                 address=account_address(address),
                 module=starcoin_types.Identifier(code),
                 name=starcoin_types.Identifier(code),
-                type_params=[],
+                type_args=[],
             )
         )
 
@@ -127,15 +127,15 @@ def currency_user_code(address: str, code: str) -> starcoin_types.TypeTag:
 def type_tag_to_str(code: starcoin_types.TypeTag) -> str:
     """converts currency code TypeTag into string"""
 
-    if isinstance(code, starcoin_types.TypeTag__Struct):
-        if isinstance(self, TypeTag__Struct):
+    if isinstance(code, starcoin_types.TypeTag__struct):
+        if isinstance(self, TypeTag__struct):
             return self.value.name.value
         raise TypeError(f"unknown currency code type: {self}")
     raise TypeError(f"unknown currency code type: {code}")
 
 
 def create_signed_transaction(
-    txn: starcoin_types.RawTransaction, public_key: bytes, signature: bytes
+    txn: starcoin_types.RawUserTransaction, public_key: bytes, signature: bytes
 ) -> starcoin_types.SignedUserTransaction:
     """create single signed `starcoin_types.SignedTransaction`"""
     return starcoin_types.SignedUserTransaction(
@@ -147,8 +147,8 @@ def create_signed_transaction(
     )
 
 
-def raw_transaction_signing_msg(txn: starcoin_types.RawTransaction) -> bytes:
-    """create signing message from given `starcoin_types.RawTransaction`"""
+def raw_transaction_signing_msg(txn: starcoin_types.RawUserTransaction) -> bytes:
+    """create signing message from given `starcoin_types.RawUserTransaction`"""
     return starcoin_hash_seed(b"RawUserTransaction") + txn.bcs_serialize()
 
 
@@ -188,7 +188,7 @@ def verify_signed_message(signed_message_hex: str) -> starcoin_types.SignedMessa
         public_key = signed_message.authenticator.public_key.value
         signature = signed_message.authenticator.signature.value
         data = starcoin_hash_seed(b"SigningMessage") + \
-            signed_message.signing_message.bcs_serialize()
+            signed_message.message.bcs_serialize()
         ed = ed25519.Ed25519PublicKey.from_public_bytes(public_key)
         ed.verify(signature, data)
     except Exception as e:

starcoin/starcoin_types/__init__.py

@@ -34,6 +34,11 @@ def bcs_deserialize(input: bytes) -> 'AccountAddress':
         if buffer:
             raise st.DeserializationError("Some input bytes were not read")
         return v
+    
+    @staticmethod
+    def from_hex(addr: str) -> 'AccountAddress':
+        """Create an account address from bytes."""
+        return AccountAddress(tuple(st.uint8(x) for x in bytes.fromhex(addr)))
 
 
 @dataclass(frozen=True)
@@ -280,7 +285,7 @@ def bcs_deserialize(input: bytes) -> 'Ed25519Signature':
 @dataclass(frozen=True)
 class EventHandle:
     count: st.uint64
-    key: "EventKey"
+    key: bytes
 
     def bcs_serialize(self) -> bytes:
         return bcs.serialize(self, EventHandle)
@@ -295,8 +300,9 @@ def bcs_deserialize(input: bytes) -> 'EventHandle':
 
 @dataclass(frozen=True)
 class EventKey:
-    value: bytes
-
+    salt: st.uint64
+    address: AccountAddress
+    
     def bcs_serialize(self) -> bytes:
         return bcs.serialize(self, EventKey)
 
@@ -969,3 +975,17 @@ def bcs_deserialize(input: bytes) -> 'WriteSetMut':
         if buffer:
             raise st.DeserializationError("Some input bytes were not read")
         return v
+    
+@dataclass(frozen=True)
+class BalanceResource:
+    token: st.uint128
+
+    def bcs_serialize(self) -> bytes:
+        return bcs.serialize(self, BalanceResource)
+
+    @staticmethod
+    def bcs_deserialize(input: bytes) -> 'BalanceResource':
+        v, buffer = bcs.deserialize(input, BalanceResource)
+        if buffer:
+            raise st.DeserializationError("Some input bytes were not read")
+        return v

tests/test_jsonrpc.py

@@ -17,8 +17,6 @@ def test_apis():
     assert auth_key == "0000000000000000000000000000000000000000000000000000000000000001"
     assert isinstance(cli.get_account_sequence(
         "0x00000000000000000000000000000001"), int) is True
-    assert cli.get_account_token(
-        "0x00000000000000000000000000000001", "STC", "STC") == 0
     tx = cli.get_transaction(
         "0xd15e5d2d306c898effe61ce9cddb976b8e5a5c24ef67fb5c3a02ca7f156b738b")
     payload = tx.get("user_transaction").get("raw_txn").get("payload")