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)