def unbonding_delegations(
self,
delegator: Optional[AccAddress] = None,
validator: Optional[ValAddress] = None,
) -> Union[ApiResponse, List[UnbondingDelegation]]:
if delegator is not None and validator is not None:
delegator = validate_acc_address(delegator)
validator = validate_val_address(validator)
res = self._api_get(
f"/staking/delegators/{delegator}/unbonding_delegations/{validator}"
)
return project(res, [UnbondingDelegation.deserialize(res)])
elif delegator:
delegator = validate_acc_address(delegator)
res = self._api_get(
f"/staking/delegators/{delegator}/unbonding_delegations"
)
elif validator:
validator = validate_val_address(validator)
res = self._api_get(
f"/staking/validators/{validator}/unbonding_delegations"
)
else:
raise TypeError("arguments delegator and validator cannot both be None")
return project(res, [UnbondingDelegation.deserialize(delgn) for delgn in res])
def __post_init__(self):
self.feeder = validate_acc_address(self.feeder)
self.validator = validate_val_address(self.validator)
if not isinstance(self.exchange_rate, Coin):
self.exchange_rate = Coin(self.denom, self.exchange_rate)
else:
validate_same_denom(self.exchange_rate.denom, self.denom)
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 rewards_for(self, delegator: AccAddress) -> Union[ApiResponse, dict]:
"""Get an account's delegation rewards."""
delegator = validate_acc_address(delegator)
res = self._api_get(f"/distribution/delegators/{delegator}/rewards")
rewards = res["rewards"] or []
total = Coins.from_data(res["total"])
result = JiguBox({
"rewards": {
r["validator_address"]: Coins.deserialize(r["reward"])
for r in rewards
},
"total": total,
})
return project(res, result)
def acc_info_for(
self, address: AccAddress
) -> Union[ApiResponse, account_info_type]:
address = validate_acc_address(address)
info = self._api_get(f"/auth/accounts/{address}")
if info["type"] == "core/Account":
res = Account.from_data(info)
elif info["type"] == "core/LazyGradedVestingAccount":
res = LazyGradedVestingAccount.from_data(info)
else:
raise ValueError("could not deserialize account in auth.acc_info")
if res.address is None:
warnings.warn(
"Account was not found; perhaps wrong chain or account needs to first be sent funds.",
AccountNotFoundWarning,
)
return project(info, res)
def redelegations(
self,
delegator: Optional[AccAddress] = None,
validator_src: Optional[ValAddress] = None,
validator_dst: Optional[ValAddress] = None,
) -> Union[ApiResponse, List[Redelegation]]:
params = {}
if delegator:
delegator = validate_acc_address(delegator)
params["delegator"] = delegator
if validator_src:
validator_src = validate_val_address(validator_src)
params["validator_from"] = validator_src
if validator_dst:
validator_dst = validate_val_address(validator_dst)
params["validator_to"] = validator_dst
res = self._api_get(f"/staking/redelegations", params=params)
return project(res, [Redelegation.deserialize(rd) for rd in res])
def __post_init__(self):
self.operator = validate_val_address(self.operator)
self.delegate = validate_acc_address(self.delegate)
def balance_for(self, address: AccAddress) -> Union[ApiResponse, Coins]:
"""Get's the balance of an account by its address."""
address = validate_acc_address(address)
res = self._api_get(f"/bank/balances/{address}")
return project(res, Coins.deserialize(res))
def __post_init__(self):
self.depositor = validate_acc_address(self.depositor)
self.amount = Coins(self.amount)
def account(self, arg: AccAddress) -> AccountQuery:
arg = validate_acc_address(arg)
return AccountQuery(self, arg)
def __post_init__(self):
self.delegator_address = validate_acc_address(self.delegator_address)
self.validator_address = validate_val_address(self.validator_address)
validate_val_conspubkey(self.pubkey)
self.min_self_delegation = int(self.min_self_delegation)
def withdraw_address_for(
self, delegator: AccAddress) -> Union[ApiResponse, AccAddress]:
delegator = validate_acc_address(delegator)
return self._api_get(
f"/distribution/delegators/{delegator}/withdraw_address")
def __post_init__(self):
self.delegator_address = validate_acc_address(self.delegator_address)
self.withdraw_address = validate_acc_address(self.withdraw_address)
def __new__(cls, arg):
arg = validate_acc_address(arg)
return str.__new__(cls, arg)
def staking_txs_for(self, delegator: AccAddress) -> ApiResponse:
delegator = validate_acc_address(delegator)
return self._api_get(f"/staking/delegators/{delegator}/txs", unwrap=False)
def __init__(self, address: AccAddress, coins: Coins):
address = validate_acc_address(address)
self.address = address
self.coins = Coins(coins)
def __post_init__(self):
self.voter = validate_acc_address(self.voter)
def bonded_validators_for(
self, delegator: AccAddress
) -> Union[ApiResponse, List[Validator]]:
delegator = validate_acc_address(delegator)
vs = self._api_get(f"/staking/delegators/{delegator}/validators")
return [Validator.deserialize(v) for v in vs]
def __post_init__(self):
self.proposer = validate_acc_address(self.proposer)
self.initial_deposit = Coins(self.initial_deposit)
def __post_init__(self):
self.delegator_address = validate_acc_address(self.delegator_address)
self.validator_address = validate_val_address(self.validator_address)
def __post_init__(self):
self.from_address = validate_acc_address(self.from_address)
self.to_address = validate_acc_address(self.to_address)
self.amount = Coins(self.amount)