def from_data(cls, data: Dict[str, str]) -> Delegation: return cls( delegator_address=data["delegator_address"], validator_address=data["validator_address"], shares=Coin(uLuna, data["shares"]), balance=Coin(uLuna, data["balance"]), )
def from_data(cls, data: Dict[str, str]) -> UnbondingEntry: return cls( initial_balance=Coin(uLuna, data["initial_balance"]), balance=Coin(uLuna, data["balance"]), creation_height=int(data["creation_height"]), completion_time=Timestamp.from_data(data["completion_time"]), )
def test_make_coin(self, d1): coin = Coin(d1, "13929") assert coin.denom == d1 assert coin.amount == 13929 coin = Coin(d1, "0.006250000000000000") assert coin.denom == d1 assert coin.amount == Dec("0.00625")
def from_data(cls, data: dict) -> RedelegationEntry: return cls( initial_balance=Coin(uLuna, data["initial_balance"]), balance=Coin(uLuna, data["balance"]), shares_dst=Coin(uLuna, data["shares_dst"]), creation_height=int(data["creation_height"]), completion_time=Timestamp.from_data(data["completion_time"]), )
def test_add_coins(self, t): """Coins can be added, which merges the collections of Coins and groups together the sum amount for Coins of a similar denom.""" A = t([Coin("uluna", 2000)]) B = t([Coin("ukrw", 1000)]) C = t([Coin("uluna", 1000), Coin("ukrw", 250), Coin("uusd", 2000)]) assert A + B == Coins([Coin("uluna", 2000), Coin("ukrw", 1000)]) assert A + B + C == Coins( [Coin("uluna", 3000), Coin("ukrw", 1250), Coin("uusd", 2000)] )
def test_contains_denom(self): """The `in` operator in Python should allow a user to query whether a Coin of a specified denom exists in the sdk.Coins object.""" haystack = Coins( [Coin("A", 1000), Coin("B", 500), Coin("needle", 250), Coin("C", 125)] ) assert "needle" in haystack assert "B" in haystack assert "D" not in haystack
def test_coin_sub(self, d1, d2, x, y): coin = Coin(d1, x) coin2 = Coin(d1, y) coin3 = Coin(d1, x - y) coindiff = coin - coin2 assert isinstance(coindiff.amount, int) or isinstance( coindiff.amount, Dec) assert coin3 == coindiff with pytest.raises(DenomIncompatibleError): Coin(d1, x) - Coin(d2, x)
def test_coin_add(self, d1, d2, x, y): coin = Coin(d1, x) coin2 = Coin(d1, y) coin3 = Coin(d1, x + y) coinsum = coin + coin2 assert isinstance(coinsum.amount, int) or isinstance( coinsum.amount, Dec) assert coin3 == coinsum with pytest.raises(DenomIncompatibleError): Coin(d1, x) + Coin(d2, x)
def pool( self, key: Optional[str] = None ) -> Union[ApiResponse, Coin, JiguBox[str, Coin]]: res = self._api_get("/staking/pool") pool = JiguBox( { "bonded": Coin(uLuna, res["bonded_tokens"]), "not_bonded": Coin(uLuna, res["not_bonded_tokens"]), } ) return project(res, pool[key] if key else pool)
def from_data(cls, data: dict) -> Validator: return cls( operator_address=data["operator_address"], consensus_pubkey=data["consensus_pubkey"], jailed=data["jailed"], status_code=data["status"], tokens=Coin(uLuna, data["tokens"]), delegator_shares=Coin(uLuna, data["delegator_shares"]), description=Description.from_data(data["description"]), unbonding_height=int(data["unbonding_height"]), unbonding_time=Timestamp.from_data(data["unbonding_time"]), commission=Commission.from_data(data["commission"]), min_self_delegation=int(data["min_self_delegation"]), )
def test_coin_compare(self, d1, d2, x, y): assume(x < y) coin = Coin(d1, x) coin2 = Coin(d1, y) coin3 = Coin(d2, x) coin_dup = Coin(d1, x) assert coin < coin2 assert coin2 > coin assert coin >= coin_dup assert coin <= coin_dup with pytest.raises(DenomIncompatibleError): coin < coin3
def default_tax_policy(): return PolicyConstraints( rate_min=Dec.with_prec(5, 4), rate_max=Dec.with_prec(1, 2), cap=Coin("usdr", 1), change_max=Dec.with_prec(25, 5), )
def from_data(cls, data: dict) -> MsgDelegate: data = data["value"] return cls( delegator_address=data["delegator_address"], validator_address=data["validator_address"], amount=Coin.from_data(data["amount"]), )
def from_data(cls, data: dict) -> MsgSwap: data = data["value"] return cls( trader=data["trader"], offer_coin=Coin.from_data(data["offer_coin"]), ask_denom=data["ask_denom"], )
def test_broadcast_txcodespacerror(self, wallet, fee, mnemonics): """Tests that a that it captures the correct txcodespace error.""" fail_swap = MsgSwap( trader=wallet.address, offer_coin=Coin("uluna", 1), ask_denom="bebo" ) fail_vote = MsgExchangeRateVote( exchange_rate="603.899000000000000000", salt="0dff", denom="umnt", feeder=wallet.address, validator="terravaloper1vqnhgc6d0jyggtytzqrnsc40r4zez6tx99382w", ) send = MsgSend( from_address=wallet.address, to_address=mnemonics[1]["address"], amount=Coins(uluna=1), ) tx1 = wallet.create_and_sign_tx(send, send, fail_swap, send, fail_vote, fee=fee) with pytest.raises(TxCodespaceError) as excinfo: wallet.broadcast(tx1) err = excinfo.value assert err.codespace == "market" tx2 = wallet.create_and_sign_tx( send, fail_vote, send, send, fail_swap, fail_swap, fee=fee ) with pytest.raises(TxCodespaceError) as excinfo: wallet.broadcast(tx2) err = excinfo.value assert err.codespace == "oracle"
def test_broadcast(self, wallet, fee): swap = MsgSwap( trader=wallet.address, offer_coin=Coin("uluna", 1), ask_denom="umnt" ) tx = wallet.create_and_sign_tx(swap, fee=fee) res = wallet.broadcast(tx) assert res.msgs is not None
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 from_data(cls, data: dict) -> PolicyConstraints: return cls( rate_min=Dec(data["rate_min"]), rate_max=Dec(data["rate_max"]), cap=Coin.from_data(data["cap"]), change_max=Dec(data["change_max"]), )
def tally_for(self, proposal_id: str) -> Union[ApiResponse, Dict[str, Coin]]: res = self._api_get(f"/gov/proposals/{proposal_id}/tally") denoms = res or [] tally = JiguBox({}) for denom in denoms: tally[denom] = Coin(uLuna, int(res[denom])) return project(res, JiguBox(tally))
def from_data(cls, data: dict) -> MsgExchangeRateVote: data = data["value"] xr = Coin(data["denom"], data["exchange_rate"]) return cls( exchange_rate=xr, salt=data["salt"], denom=xr.denom, feeder=data["feeder"], validator=data["validator"], )
def from_data(cls, data: dict) -> MsgCreateValidator: data = data["value"] return cls( description=Description.from_data(data["description"]), commission=CommissionRates.from_data(data["commission"]), min_self_delegation=int(data["min_self_delegation"]), delegator_address=data["delegator_address"], validator_address=data["validator_address"], pubkey=data["pubkey"], value=Coin.from_data(data["value"]), )
def test_uses_correct_internal_amount(self, d1): examples = [ (500, int), ("4.2", Dec), ("0", int), ("0.0", Dec), (-100000000000, int), ("-0.00000000000001", Dec), ] for x in examples: coin = Coin(d1, x[0]) assert isinstance(coin.amount, x[1])
def test_constructor_copy(self): """sdk.Coins object should copy another sdk.Coins object when passed into constructor, rather than maintaining original references.""" A = Coin("A", 1000) C1 = Coins([A]) C2 = Coins(C1) assert C1 == C2 assert list(C1) == list(C2) assert C1 is not C2 assert C1.coins[0] is not A # should be a new coin assert C2.coins[0] is not C1.coins[0] # should be a new coin
def swap_rate(self, offer_coin: Coin, ask_denom: str) -> Union[ApiResponse, Coin]: if type(offer_coin.amount) != int: warnings.warn( f"Coin's amount will be converted to integer: {int(offer_coin.amount)} {offer_coin.denom}", SyntaxWarning, ) params = { "offer_coin": f"{int(offer_coin.amount)}{offer_coin.denom}", "ask_denom": ask_denom, } res = self._api_get(f"/market/swap", params=params) return project(res, Coin.deserialize(res))
def test_multisend(master_key2): """This test highlights how Jigu is flexible to accomodate many input styles.""" multisend = MsgMultiSend( inputs=[ Input( address=master_key2.acc_address, coins=[ Coin("uluna", 1_000_000), Coin(denom="usdr", amount="1000000") ], ) ], outputs=[ Output("terra12dazwl3yq6nwrce052ah3fudkarglsgvacyvl9", [Coin("uluna", 500000)]), { "address": "terra1ptdx6akgk7wwemlk5j73artt5t6j8am08ql3qv", "coins": Coins() + Coin("uluna", 500000) + Coin("usdr", 1000000), }, ], ) unsigned = StdSignMsg( account_number=47, sequence=0, chain_id="columbus-3-testnet", msgs=[multisend], fee=StdFee.make(100_000, uluna=1500, usdr=1000), memo="1234", ) tx = master_key2.sign_tx(unsigned) assert ( tx.signatures[0].signature == "YA/ToXLxuuAOQlpm5trbIUu2zv5NfBmeHz2jmXgNrt8jP+odukerfri3DUXAJuhETAMHVVV78t7Q4xC0j+CVkA==" )
def test_sign_tx(master_key): unsigned = StdSignMsg( msgs=[ MsgSend( from_address=master_key.acc_address, to_address="terra1wg2mlrxdmnnkkykgqg4znky86nyrtc45q336yv", amount=[Coin("uluna", 100_000_000)], ) ], sequence=0, account_number=45, chain_id="columbus-3-testnet", fee=StdFee(gas=46_467, amount=[Coin("uluna", 698)]), )
def test_getitem(self): """sdk.Coins object should act like a dict, and indexable by denom as key.""" X = Coins([Coin("A", 1000), Coin("B", 2000), Coin("C", 3000)]) assert all(isinstance(X[i], Coin) for i in ["A", "B", "C"]) assert X["A"] == Coin("A", 1000) assert X["B"] == Coin("B", 2000) assert X["C"] == Coin("C", 3000) with pytest.raises(KeyError): X["D"]
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"]), )
def test_coin_eq(self, x, y, d1, d2): """Tests Coin equality against another Coin.""" assume(x != y) coin = Coin(d1, x) coin2 = Coin(d1, x) assert coin == coin2 # denoms different coin3 = Coin(d1, x) coin4 = Coin(d2, x) assert coin3 != coin4 # amount different coin5 = Coin(d1, x) coin6 = Coin(d1, y) assert coin5 != coin6 # amount type different coin7 = Coin(d1, 4) coin8 = Coin(d1, "4.2") coin9 = Coin(d1, 4.2) assert coin7 != coin8 assert coin8 == coin9
def from_data(cls, data) -> ExchangeRateVote: xr = Coin(data["denom"], data["exchange_rate"]) return cls(exchange_rate=xr, denom=xr.denom, voter=data["voter"])