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 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 prevotes(
self,
validator: Optional[ValAddress] = None,
denom: Optional[str] = None
) -> Union[ApiResponse, List[ExchangeRatePrevote]]:
if validator is not None and denom is not None:
validator = validate_val_address(validator)
res = self._api_get(f"/oracle/denoms/{denom}/prevotes/{validator}")
elif validator:
validator = validate_val_address(validator)
res = self._api_get(f"/oracle/voters/{validator}/prevotes")
elif denom:
res = self._api_get(f"/oracle/denoms/{denom}/prevotes")
else:
raise ValueError(
"arguments validator and denom cannot both be None")
return project(
res, [ExchangeRatePrevote.deserialize(prevote) for prevote in res])
def rewards(
self,
validator: Optional[ValAddress] = None
) -> Union[ApiResponse, Dict[ValAddress, Coins], Coins]:
if validator:
validator = validate_val_address(validator)
res = self.terra.distribution.rewards_for(delegator=self.address)
rewards = res["rewards"]
return project(res, rewards[validator] if validator else rewards)
def val_rewards_for(
self,
validator: ValAddress,
key: Optional[str] = None
) -> Union[ApiResponse, Coins, Dict[str, Coins]]:
validator = validate_val_address(validator)
res = self._api_get(f"/distribution/validators/{validator}")
rewards = JiguBox({
"self_bond":
Coins.deserialize(res["self_bond_rewards"]),
"commission":
Coins.deserialize(res["val_commission"]),
})
return project(res, rewards[key] if key else rewards)
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.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 __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 val_info_for(self, validator: ValAddress) -> Union[ApiResponse, Validator]:
validator = validate_val_address(validator)
res = self._api_get(f"/staking/validators/{validator}")
return project(res, Validator.deserialize(res))
def validator(self, arg: ValAddress) -> ValidatorQuery:
arg = validate_val_address(arg)
return ValidatorQuery(self, arg)
def feeder_address_for(
self, validator: ValAddress) -> Union[ApiResponse, AccAddress]:
validator = validate_val_address(validator)
return self._api_get(f"/oracle/voters/{validator}/feeder")
def __post_init__(self):
self.operator = validate_val_address(self.operator)
self.delegate = validate_acc_address(self.delegate)
def __post_init__(self):
self.address = validate_val_address(self.address)
def __new__(cls, arg):
arg = validate_val_address(arg)
return str.__new__(cls, arg)
def __post_init__(self):
self.voter = validate_val_address(self.voter)
def __post_init__(self):
self.voter = validate_val_address(self.voter)
self.submit_block = int(self.submit_block)
def misses_for(self, validator: ValAddress) -> Union[ApiResponse, int]:
validator = validate_val_address(validator)
res = self._api_get(f"/oracle/voters/{validator}/miss")
return project(res, int(res))