async def validator_rewards(self,
validator: ValAddress) -> ValidatorRewards:
"""Fetches the self-delegation reward data and available commission for a validator.
Args:
validator (ValAddress): validator operator address
Returns:
ValidatorRewards: validator rewards
"""
res = await self._c._get(f"/distribution/validators/{validator}")
operator_address = res["operator_address"]
if res["self_bond_rewards"]:
self_bond_rewards = Coins.from_data(res["self_bond_rewards"])
else:
self_bond_rewards = Coin.from_data({'denom': 'uakt', 'amount': 0})
if res["val_commission"]['commission']:
val_commission = Coins.from_data(
res["val_commission"]['commission'])
else:
val_commission = Coin.from_data({'denom': 'uakt', 'amount': 0})
return ValidatorRewards(self_bond_rewards, val_commission,
operator_address)
def from_data(cls, data: dict) -> MsgSend:
data = data["value"]
return cls(
from_address=data["from_address"],
to_address=data["to_address"],
amount=Coins.from_data(data["amount"]),
)
def from_data(cls, data: dict) -> MsgDeposit:
data = data["value"]
return cls(
proposal_id=data["proposal_id"],
depositor=data["depositor"],
amount=Coins.from_data(data["amount"]),
)
def from_data(cls, data: dict) -> PeriodicVestingAccount:
data = data["value"]
account = data["base_vesting_account"]
base_account = account["base_account"]
return cls(
address=base_account["address"],
public_key=PublicKey.from_data(base_account["public_key"]),
account_number=base_account["account_number"],
sequence=base_account["sequence"],
original_vesting=Coins.from_data(account["original_vesting"]),
delegated_free=Coins.from_data(account["delegated_free"]),
delegated_vesting=Coins.from_data(account["delegated_vesting"]),
end_time=account["end_time"],
start_time=data["start_time"],
vesting_periods=data["vesting_periods"],
)
async def community_pool(self) -> Coins:
"""Fetches the community pool.
Returns:
Coins: community pool
"""
res = await self._c._get("/distribution/community_pool")
return Coins.from_data(res)
def from_data(cls, data: dict) -> MsgSubmitProposal:
from terra_sdk.util.parse_content import parse_content
data = data["value"]
content = parse_content(data["content"])
return cls(
content=content,
initial_deposit=Coins.from_data(data["initial_deposit"]),
proposer=data["proposer"],
)
async def rewards(self, delegator: AccAddress) -> Rewards:
"""Fetches the staking reward data for a delegator.
Args:
delegator (AccAddress): delegator account address
Returns:
Rewards: delegator rewards
"""
res = await self._c._get(
f"/distribution/delegators/{delegator}/rewards")
return Rewards(
rewards={
item["validator_address"]: Coins.from_data(item["reward"]
or [])
for item in res["rewards"]
},
total=Coins.from_data(res["total"]),
)
def from_data(cls, data: dict) -> Proposal:
return cls(
id=data["id"],
content=data["content"], # Currently just return entire content as dict.
status=data["status"],
final_tally_result=data["final_tally_result"],
submit_time=data["submit_time"],
deposit_end_time=data["deposit_end_time"],
total_deposit=Coins.from_data(data["total_deposit"]),
voting_start_time=data["voting_start_time"],
voting_end_time=data["voting_end_time"],
)
async def balance(self, address: AccAddress) -> Coins:
"""Fetches an account's current balance.
Args:
address (AccAddress): account address
Returns:
Coin: balance of address in uakt
"""
res = await self._c._get(f"/bank/balances/{address}")
return Coins.from_data(res)
def from_data(cls, data: dict):
return cls(address=data["address"],
coins=Coins.from_data(data["coins"]))