class Block(BlockHeader, JsonDeserializable):
__schema__ = S.OBJECT(
block_meta=BlockHeader.__schema__,
block=S.OBJECT(
data=S.OBJECT(txs=S.OPTIONAL(S.ARRAY(S.STRING))),
evidence={},
last_commit={},
),
)
evidence: JiguBox # TODO: improve and document
last_commit: JiguBox # TODO: improve and document
txs: List[
Union[str, StdTx, TxInfo,
TxInfosQuery]] # ordered last for convenience of pretty printing
@classmethod
def from_data(cls, data: dict) -> Block:
header = BlockHeader.from_data(data["block_meta"])
txs = (data["block"]["data"]["txs"]
or []) # these will be Amino-encoded tx strings
evidence = JiguBox(data["block"].get("evidence"))
last_commit = JiguBox(data["block"].get("last_commit"))
return cls(txs=txs,
evidence=evidence,
last_commit=last_commit,
**header.__dict__)
class MsgEditValidator(StdMsg):
type = "staking/MsgEditValidator"
action = "edit_validator"
__schema__ = S.OBJECT(
type=S.STRING_WITH_PATTERN(r"^staking/MsgEditValidator\Z"),
value=S.OBJECT(
Description=Description.__schema__,
address=S.VAL_ADDRESS,
commission_rate=S.OPTIONAL(Dec.__schema__),
min_self_delegation=S.OPTIONAL(S.STRING_INTEGER),
),
)
Description: Description
address: ValAddress
commission_rate: Optional[Dec] = None
min_self_delegation: Optional[int] = None
def __post_init__(self):
if self.commission_rate is not None:
self.commission_rate = Dec(self.commission_rate)
if self.min_self_delegation is not None:
self.min_self_delegation = int(self.min_self_delegation)
self.address = validate_val_address(self.address)
def msg_value(self) -> dict:
d = dict(self.__dict__)
msd = self.min_self_delegation
if msd is not None:
msd = str(msd)
d["min_self_delegation"] = msd
return d
@classmethod
def from_data(cls, data: dict) -> MsgEditValidator:
data = data["value"]
msd = int(data["min_self_delegation"]) if data["min_self_delegation"] else None
cr = Dec(data["commission_rate"]) if data["commission_rate"] else None
return cls(
Description=data["Description"],
address=data["address"],
commission_rate=cr,
min_self_delegation=msd,
)
class Account(JsonSerializable, JsonDeserializable):
__schema__ = S.OBJECT(
type=S.STRING_WITH_PATTERN(r"^core/Account\Z"),
value=S.OBJECT(
address=S.ACC_ADDRESS,
coins=Coins.__schema__,
public_key=S.OPTIONAL(PublicKey.__schema__),
account_number=S.STRING_INTEGER,
sequence=S.STRING_INTEGER,
),
)
address: str
coins: Coins
public_key: Optional[PublicKey]
account_number: int
sequence: int
def __post_init__(self):
if self.address:
self.address = validate_acc_address(self.address)
if self.coins:
self.coins = Coins(self.coins)
self.account_number = int(self.account_number)
self.sequence = int(self.sequence)
def to_data(self) -> dict:
d = dict(self.__dict__)
d["account_number"] = str(self.account_number)
d["sequence"] = str(self.sequence)
return {"type": "core/Account", "value": d}
@classmethod
def from_data(cls, data: dict) -> Account:
if "type" in data:
data = data["value"]
pk = data["public_key"]
if pk is not None:
pk = PublicKey.deserialize(data["public_key"])
return cls(
address=data["address"],
coins=Coins.from_data(data["coins"]),
public_key=pk,
account_number=data["account_number"],
sequence=data["sequence"],
)
class Proposal(JsonSerializable, JsonDeserializable):
__schema__ = S.OBJECT(
content=Content.__schema__,
id=S.STRING_INTEGER,
proposal_status=S.STRING,
final_tally_result=S.OPTIONAL(
S.OBJECT( # this gets marshalled into Coin
yes=S.STRING_INTEGER,
abstain=S.STRING_INTEGER,
no=S.STRING_INTEGER,
no_with_veto=S.STRING_INTEGER,
)
),
submit_time=Timestamp.__schema__,
deposit_end_time=Timestamp.__schema__,
total_deposit=Coins.__schema__,
voting_start_time=Timestamp.__schema__,
voting_end_time=Timestamp.__schema__,
)
content: Type[Content]
id: int
proposal_status: str
final_tally_result: JiguBox[str, Coin]
submit_time: Timestamp
deposit_end_time: Timestamp
total_deposit: Coins
voting_start_time: Timestamp
voting_end_time: Timestamp
def to_data(self) -> dict:
d = JiguBox(self.__dict__)
d.id = str(d.id)
for x in d.final_tally_result:
d.final_tally_result[x] = d.final_tally_result[x].amount
return d
@property
def pretty_data(self):
d = dict(self.__dict__)
proposal_id = d.pop("id")
content = d.pop("content")
ix = [
("id", proposal_id),
("type", content.type),
*list(content.pretty_data),
*list(d.items()),
]
return ix
@classmethod
def from_data(cls, data: dict) -> Proposal:
final_tally_result = data["final_tally_result"]
for key in final_tally_result:
final_tally_result[key] = Coin(uLuna, int(final_tally_result[key]))
p_type = PROPOSAL_TYPES[data["content"]["type"]]
content = p_type.from_data(data["content"])
return cls(
content=content,
id=int(data["id"]),
proposal_status=ProposalStatus(data["proposal_status"]),
final_tally_result=JiguBox(final_tally_result),
submit_time=Timestamp.from_data(data["submit_time"]),
deposit_end_time=Timestamp.from_data(data["deposit_end_time"]),
total_deposit=Coins.from_data(data["total_deposit"]),
voting_start_time=Timestamp.from_data(data["voting_start_time"]),
voting_end_time=Timestamp.from_data(data["voting_end_time"]),
)
