Add events type

Author: sanlee42

starcoin/starcoin_types/__init__.py

@@ -5,6 +5,21 @@
 from starcoin import bcs
 
 
+@dataclass(frozen=True)
+class AcceptTokenEvent:
+    token_code: "TokenCode"
+
+    def bcs_serialize(self) -> bytes:
+        return bcs.serialize(self, AcceptTokenEvent)
+
+    @staticmethod
+    def bcs_deserialize(input: bytes) -> 'AcceptTokenEvent':
+        v, buffer = bcs.deserialize(input, AcceptTokenEvent)
+        if buffer:
+            raise st.DeserializationError("Some input bytes were not read")
+        return v
+
+
 @dataclass(frozen=True)
 class AccessPath:
     address: "AccountAddress"
@@ -19,7 +34,7 @@ def bcs_deserialize(input: bytes) -> 'AccessPath':
         if buffer:
             raise st.DeserializationError("Some input bytes were not read")
         return v
-
+    
 
 @dataclass(frozen=True)
 class AccountAddress:
@@ -41,7 +56,6 @@ 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)
 class AccountResource:
     authentication_key: bytes
@@ -98,6 +112,40 @@ def bcs_deserialize(input: bytes) -> 'BlockMetadata':
         return v
 
 
+@dataclass(frozen=True)
+class BlockRewardEvent:
+    block_number: st.uint64
+    block_reward: st.uint128
+    gas_fees: st.uint128
+    miner: "AccountAddress"
+
+    def bcs_serialize(self) -> bytes:
+        return bcs.serialize(self, BlockRewardEvent)
+
+    @staticmethod
+    def bcs_deserialize(input: bytes) -> 'BlockRewardEvent':
+        v, buffer = bcs.deserialize(input, BlockRewardEvent)
+        if buffer:
+            raise st.DeserializationError("Some input bytes were not read")
+        return v
+
+
+@dataclass(frozen=True)
+class BurnEvent:
+    amount: st.uint128
+    token_code: "TokenCode"
+
+    def bcs_serialize(self) -> bytes:
+        return bcs.serialize(self, BurnEvent)
+
+    @staticmethod
+    def bcs_deserialize(input: bytes) -> 'BurnEvent':
+        v, buffer = bcs.deserialize(input, BurnEvent)
+        if buffer:
+            raise st.DeserializationError("Some input bytes were not read")
+        return v
+
+
 @dataclass(frozen=True)
 class ChainId:
     value: st.uint8
@@ -204,6 +252,23 @@ class DataPath__Resource(DataPath):
 ]
 
 
+@dataclass(frozen=True)
+class DepositEvent:
+    amount: st.uint128
+    token_code: "TokenCode"
+    metadata: typing.Sequence[st.uint8]
+
+    def bcs_serialize(self) -> bytes:
+        return bcs.serialize(self, DepositEvent)
+
+    @staticmethod
+    def bcs_deserialize(input: bytes) -> 'DepositEvent':
+        v, buffer = bcs.deserialize(input, DepositEvent)
+        if buffer:
+            raise st.DeserializationError("Some input bytes were not read")
+        return v
+
+
 @dataclass(frozen=True)
 class Ed25519PublicKey:
     value: bytes
@@ -462,6 +527,22 @@ class Metadata__UnstructuredBytesMetadata(Metadata):
 ]
 
 
+@dataclass(frozen=True)
+class MintEvent:
+    amount: st.uint128
+    token_code: "TokenCode"
+
+    def bcs_serialize(self) -> bytes:
+        return bcs.serialize(self, MintEvent)
+
+    @staticmethod
+    def bcs_deserialize(input: bytes) -> 'MintEvent':
+        v, buffer = bcs.deserialize(input, MintEvent)
+        if buffer:
+            raise st.DeserializationError("Some input bytes were not read")
+        return v
+
+
 @dataclass(frozen=True)
 class Module:
     code: bytes
@@ -523,6 +604,24 @@ def bcs_deserialize(input: bytes) -> 'MultiEd25519Signature':
         return v
 
 
+@dataclass(frozen=True)
+class NewBlockEvent:
+    number: st.uint64
+    author: "AccountAddress"
+    timestamp: st.uint64
+    uncles: st.uint64
+
+    def bcs_serialize(self) -> bytes:
+        return bcs.serialize(self, NewBlockEvent)
+
+    @staticmethod
+    def bcs_deserialize(input: bytes) -> 'NewBlockEvent':
+        v, buffer = bcs.deserialize(input, NewBlockEvent)
+        if buffer:
+            raise st.DeserializationError("Some input bytes were not read")
+        return v
+
+
 @dataclass(frozen=True)
 class Package:
     package_address: "AccountAddress"
@@ -540,6 +639,22 @@ def bcs_deserialize(input: bytes) -> 'Package':
         return v
 
 
+@dataclass(frozen=True)
+class ProposalCreatedEvent:
+    proposal_id: st.uint64
+    proposer: "AccountAddress"
+
+    def bcs_serialize(self) -> bytes:
+        return bcs.serialize(self, ProposalCreatedEvent)
+
+    @staticmethod
+    def bcs_deserialize(input: bytes) -> 'ProposalCreatedEvent':
+        v, buffer = bcs.deserialize(input, ProposalCreatedEvent)
+        if buffer:
+            raise st.DeserializationError("Some input bytes were not read")
+        return v
+
+
 @dataclass(frozen=True)
 class RawTransaction:
     sender: "AccountAddress"
@@ -631,6 +746,23 @@ def bcs_deserialize(input: bytes) -> 'StructTag':
         return v
 
 
+@dataclass(frozen=True)
+class TokenCode:
+    address: "AccountAddress"
+    module: str
+    name: str
+
+    def bcs_serialize(self) -> bytes:
+        return bcs.serialize(self, TokenCode)
+
+    @staticmethod
+    def bcs_deserialize(input: bytes) -> 'TokenCode':
+        v, buffer = bcs.deserialize(input, TokenCode)
+        if buffer:
+            raise st.DeserializationError("Some input bytes were not read")
+        return v
+
+
 class Transaction:
     VARIANTS = []  # type: typing.Sequence[typing.Type[Transaction]]
 
@@ -925,6 +1057,25 @@ def bcs_deserialize(input: bytes) -> 'UnstructuredBytesMetadata':
         return v
 
 
+@dataclass(frozen=True)
+class VoteChangedEvent:
+    proposal_id: st.uint64
+    proposer: "AccountAddress"
+    voter: "AccountAddress"
+    agree: bool
+    vote: st.uint128
+
+    def bcs_serialize(self) -> bytes:
+        return bcs.serialize(self, VoteChangedEvent)
+
+    @staticmethod
+    def bcs_deserialize(input: bytes) -> 'VoteChangedEvent':
+        v, buffer = bcs.deserialize(input, VoteChangedEvent)
+        if buffer:
+            raise st.DeserializationError("Some input bytes were not read")
+        return v
+
+
 @dataclass(frozen=True)
 class WithdrawCapabilityResource:
     account_address: "AccountAddress"
@@ -940,6 +1091,23 @@ def bcs_deserialize(input: bytes) -> 'WithdrawCapabilityResource':
         return v
 
 
+@dataclass(frozen=True)
+class WithdrawEvent:
+    amount: st.uint128
+    token_code: "TokenCode"
+    metadata: typing.Sequence[st.uint8]
+
+    def bcs_serialize(self) -> bytes:
+        return bcs.serialize(self, WithdrawEvent)
+
+    @staticmethod
+    def bcs_deserialize(input: bytes) -> 'WithdrawEvent':
+        v, buffer = bcs.deserialize(input, WithdrawEvent)
+        if buffer:
+            raise st.DeserializationError("Some input bytes were not read")
+        return v
+
+
 class WriteOp:
     VARIANTS = []  # type: typing.Sequence[typing.Type[WriteOp]]
 
@@ -1033,21 +1201,3 @@ class WriteSetPayload__Script(WriteSetPayload):
     WriteSetPayload__Direct,
     WriteSetPayload__Script,
 ]
-
-
-@dataclass
-class BlockRewardEvent:
-    block_number: st.uint64
-    block_reward: st.uint128
-    gas_fees: st.uint128
-    miner: "AccountAddress"
-
-    def bcs_serialize(self) -> bytes:
-        return bcs.serialize(self, BlockRewardEvent)
-
-    @staticmethod
-    def bcs_deserialize(input: bytes) -> 'BlockMetadata':
-        v, buffer = bcs.deserialize(input, BlockRewardEvent)
-        if buffer:
-            raise ValueError("Some input bytes were not read")
-        return v