mirror of https://github.com/nucypher/nucypher.git
149 lines
4.9 KiB
Python
149 lines
4.9 KiB
Python
from decimal import InvalidOperation, Decimal
|
|
|
|
import pytest
|
|
from web3 import Web3
|
|
|
|
from nucypher.blockchain.economics import StandardTokenEconomics, StandardTokenEconomics
|
|
from nucypher.blockchain.eth.token import NU, Stake
|
|
from nucypher.utilities.sandbox.constants import INSECURE_DEVELOPMENT_PASSWORD
|
|
|
|
|
|
def test_NU(token_economics):
|
|
|
|
# Starting Small
|
|
min_allowed_locked = NU(token_economics.minimum_allowed_locked, 'NuNit')
|
|
assert token_economics.minimum_allowed_locked == int(min_allowed_locked.to_nunits())
|
|
|
|
min_NU_locked = int(str(token_economics.minimum_allowed_locked)[0:-18])
|
|
expected = NU(min_NU_locked, 'NU')
|
|
assert min_allowed_locked == expected
|
|
|
|
# Starting Big
|
|
min_allowed_locked = NU(min_NU_locked, 'NU')
|
|
assert token_economics.minimum_allowed_locked == int(min_allowed_locked)
|
|
assert token_economics.minimum_allowed_locked == int(min_allowed_locked.to_nunits())
|
|
assert str(min_allowed_locked) == '15000 NU'
|
|
|
|
# Alternate construction
|
|
assert NU(1, 'NU') == NU('1.0', 'NU') == NU(1.0, 'NU')
|
|
|
|
# Arithmetic
|
|
|
|
# NUs
|
|
one_nu = NU(1, 'NU')
|
|
zero_nu = NU(0, 'NU')
|
|
one_hundred_nu = NU(100, 'NU')
|
|
two_hundred_nu = NU(200, 'NU')
|
|
three_hundred_nu = NU(300, 'NU')
|
|
|
|
# Nits
|
|
one_nu_wei = NU(1, 'NuNit')
|
|
three_nu_wei = NU(3, 'NuNit')
|
|
assert three_nu_wei.to_tokens() == Decimal('3E-18')
|
|
assert one_nu_wei.to_tokens() == Decimal('1E-18')
|
|
|
|
# Base Operations
|
|
assert one_hundred_nu < two_hundred_nu < three_hundred_nu
|
|
assert one_hundred_nu <= two_hundred_nu <= three_hundred_nu
|
|
|
|
assert three_hundred_nu > two_hundred_nu > one_hundred_nu
|
|
assert three_hundred_nu >= two_hundred_nu >= one_hundred_nu
|
|
|
|
assert (one_hundred_nu + two_hundred_nu) == three_hundred_nu
|
|
assert (three_hundred_nu - two_hundred_nu) == one_hundred_nu
|
|
|
|
difference = one_nu - one_nu_wei
|
|
assert not difference == zero_nu
|
|
|
|
actual = float(difference.to_tokens())
|
|
expected = 0.999999999999999999
|
|
assert actual == expected
|
|
|
|
# 3.14 NU is 3_140_000_000_000_000_000 NuNit
|
|
pi_nuweis = NU(3.14, 'NU')
|
|
assert NU('3.14', 'NU') == pi_nuweis.to_nunits() == NU(3_140_000_000_000_000_000, 'NuNit')
|
|
|
|
# Mixed type operations
|
|
difference = NU('3.14159265', 'NU') - NU(1.1, 'NU')
|
|
assert difference == NU('2.04159265', 'NU')
|
|
|
|
result = difference + one_nu_wei
|
|
assert result == NU(2041592650000000001, 'NuNit')
|
|
|
|
# Similar to stake read + metadata operations in Staker
|
|
collection = [one_hundred_nu, two_hundred_nu, three_hundred_nu]
|
|
assert sum(collection) == NU('600', 'NU') == NU(600, 'NU') == NU(600.0, 'NU') == NU(600e+18, 'NuNit')
|
|
|
|
#
|
|
# Fractional Inputs
|
|
#
|
|
|
|
# A decimal amount of NuNit (i.e., a fraction of a NuNit)
|
|
pi_nuweis = NU('3.14', 'NuNit')
|
|
assert pi_nuweis == three_nu_wei # Floor
|
|
|
|
# A decimal amount of NU, which amounts to NuNit with decimals
|
|
pi_nus = NU('3.14159265358979323846', 'NU')
|
|
assert pi_nus == NU(3141592653589793238, 'NuNit') # Floor
|
|
|
|
# Positive Infinity
|
|
with pytest.raises(NU.InvalidAmount):
|
|
_inf = NU(float('infinity'), 'NU')
|
|
|
|
# Negative Infinity
|
|
with pytest.raises(NU.InvalidAmount):
|
|
_neg_inf = NU(float('-infinity'), 'NU')
|
|
|
|
# Not a Number
|
|
with pytest.raises(InvalidOperation):
|
|
_nan = NU(float('NaN'), 'NU')
|
|
|
|
# Rounding NUs
|
|
assert round(pi_nus, 2) == NU("3.14", "NU")
|
|
assert round(pi_nus, 1) == NU("3.1", "NU")
|
|
assert round(pi_nus, 0) == round(pi_nus) == NU("3", "NU")
|
|
|
|
|
|
def test_stake(testerchain, token_economics, agency):
|
|
token_agent, staking_agent, _policy_agent = agency
|
|
|
|
class FakeUrsula:
|
|
token_agent, staking_agent, _policy_agent = agency
|
|
|
|
burner_wallet = Web3().eth.account.create(INSECURE_DEVELOPMENT_PASSWORD)
|
|
checksum_address = burner_wallet.address
|
|
staking_agent = staking_agent
|
|
token_agent = token_agent
|
|
blockchain = testerchain
|
|
|
|
ursula = FakeUrsula()
|
|
stake = Stake(checksum_address=ursula.checksum_address,
|
|
first_locked_period=1,
|
|
final_locked_period=100,
|
|
value=NU(100, 'NU'),
|
|
index=0,
|
|
staking_agent=staking_agent,
|
|
economics=token_economics)
|
|
|
|
assert stake.value, 'NU' == NU(100, 'NU')
|
|
|
|
assert isinstance(stake.time_remaining(), int) # seconds
|
|
slang_remaining = stake.time_remaining(slang=True) # words
|
|
assert isinstance(slang_remaining, str)
|
|
|
|
|
|
def test_stake_integration(stakers):
|
|
staker = list(stakers)[1]
|
|
stakes = staker.stakes
|
|
assert stakes
|
|
|
|
stake = stakes[0]
|
|
stake.sync()
|
|
|
|
blockchain_stakes = staker.staking_agent.get_all_stakes(staker_address=staker.checksum_address)
|
|
|
|
stake_info = (stake.first_locked_period, stake.final_locked_period, int(stake.value))
|
|
published_stake_info = list(blockchain_stakes)[0]
|
|
assert stake_info == published_stake_info
|
|
assert stake_info == stake.to_stake_info()
|