kopia lustrzana https://github.com/bugout-dev/dao
1395 wiersze
56 KiB
Python
1395 wiersze
56 KiB
Python
from re import I
|
|
from typing import List
|
|
import unittest
|
|
|
|
from brownie import accounts
|
|
from brownie.exceptions import VirtualMachineError
|
|
|
|
from . import ERC20Facet, TerminusFacet, TerminusInitializer
|
|
from .core import facet_cut
|
|
from .test_core import MoonstreamDAOSingleContractTestCase, TerminusTestCase
|
|
|
|
|
|
class TestDeployment(MoonstreamDAOSingleContractTestCase):
|
|
def test_add_and_replace(self):
|
|
initializer = TerminusInitializer.TerminusInitializer(None)
|
|
initializer.deploy({"from": accounts[0]})
|
|
|
|
terminus_facet = TerminusFacet.TerminusFacet(None)
|
|
terminus_facet.deploy({"from": accounts[0]})
|
|
|
|
diamond_address = self.contracts["Diamond"]
|
|
facet_cut(
|
|
diamond_address,
|
|
"TerminusFacet",
|
|
terminus_facet.address,
|
|
"add",
|
|
{"from": accounts[0]},
|
|
initializer.address,
|
|
)
|
|
|
|
diamond_terminus = TerminusFacet.TerminusFacet(diamond_address)
|
|
|
|
controller = diamond_terminus.terminus_controller()
|
|
self.assertEqual(controller, accounts[0].address)
|
|
|
|
|
|
class TestController(TerminusTestCase):
|
|
def test_set_controller_fails_when_not_called_by_controller(self):
|
|
terminus_diamond_address = self.terminus_contracts["Diamond"]
|
|
diamond_terminus = TerminusFacet.TerminusFacet(terminus_diamond_address)
|
|
|
|
with self.assertRaises(VirtualMachineError):
|
|
diamond_terminus.set_controller(accounts[1].address, {"from": accounts[1]})
|
|
|
|
def test_set_controller_fails_when_not_called_by_controller_even_if_they_change_to_existing_controller(
|
|
self,
|
|
):
|
|
terminus_diamond_address = self.terminus_contracts["Diamond"]
|
|
diamond_terminus = TerminusFacet.TerminusFacet(terminus_diamond_address)
|
|
|
|
with self.assertRaises(VirtualMachineError):
|
|
diamond_terminus.set_controller(accounts[0].address, {"from": accounts[1]})
|
|
|
|
def test_set_controller(self):
|
|
terminus_diamond_address = self.terminus_contracts["Diamond"]
|
|
diamond_terminus = TerminusFacet.TerminusFacet(terminus_diamond_address)
|
|
|
|
self.assertEqual(diamond_terminus.terminus_controller(), accounts[0].address)
|
|
diamond_terminus.set_controller(accounts[3].address, {"from": accounts[0]})
|
|
self.assertEqual(diamond_terminus.terminus_controller(), accounts[3].address)
|
|
diamond_terminus.set_controller(accounts[0].address, {"from": accounts[3]})
|
|
self.assertEqual(diamond_terminus.terminus_controller(), accounts[0].address)
|
|
|
|
|
|
class TestContractURI(TerminusTestCase):
|
|
def test_contract_uri(self):
|
|
terminus_diamond_address = self.terminus_contracts["Diamond"]
|
|
diamond_terminus = TerminusFacet.TerminusFacet(terminus_diamond_address)
|
|
|
|
contract_uri = diamond_terminus.contract_uri()
|
|
self.assertEqual(contract_uri, "")
|
|
|
|
diamond_terminus.set_contract_uri("https://example.com", {"from": accounts[0]})
|
|
|
|
contract_uri = diamond_terminus.contract_uri()
|
|
self.assertEqual(contract_uri, "https://example.com")
|
|
|
|
|
|
class TestPoolCreation(TerminusTestCase):
|
|
def test_create_simple_pool(self):
|
|
moonstream_diamond_address = self.contracts["Diamond"]
|
|
diamond_moonstream = ERC20Facet.ERC20Facet(moonstream_diamond_address)
|
|
|
|
terminus_diamond_address = self.terminus_contracts["Diamond"]
|
|
diamond_terminus = TerminusFacet.TerminusFacet(terminus_diamond_address)
|
|
|
|
diamond_terminus.set_payment_token(
|
|
moonstream_diamond_address, {"from": accounts[0]}
|
|
)
|
|
payment_token = diamond_terminus.payment_token()
|
|
self.assertEqual(payment_token, moonstream_diamond_address)
|
|
|
|
diamond_terminus.set_pool_base_price(1000, {"from": accounts[0]})
|
|
pool_base_price = diamond_terminus.pool_base_price()
|
|
self.assertEqual(pool_base_price, 1000)
|
|
|
|
diamond_terminus.set_controller(accounts[1].address, {"from": accounts[0]})
|
|
|
|
diamond_moonstream.mint(accounts[1], 1000, {"from": accounts[0]})
|
|
initial_payer_balance = diamond_moonstream.balance_of(accounts[1].address)
|
|
initial_terminus_balance = diamond_moonstream.balance_of(
|
|
terminus_diamond_address
|
|
)
|
|
initial_controller_balance = diamond_moonstream.balance_of(accounts[1].address)
|
|
|
|
diamond_moonstream.approve(
|
|
terminus_diamond_address, 1000, {"from": accounts[1]}
|
|
)
|
|
|
|
initial_total_pools = diamond_terminus.total_pools()
|
|
|
|
diamond_terminus.create_simple_pool(10, {"from": accounts[1]})
|
|
|
|
final_total_pools = diamond_terminus.total_pools()
|
|
self.assertEqual(final_total_pools, initial_total_pools + 1)
|
|
|
|
final_payer_balance = diamond_moonstream.balance_of(accounts[1].address)
|
|
intermediate_terminus_balance = diamond_moonstream.balance_of(
|
|
terminus_diamond_address
|
|
)
|
|
intermediate_controller_balance = diamond_moonstream.balance_of(
|
|
accounts[1].address
|
|
)
|
|
self.assertEqual(final_payer_balance, initial_payer_balance - 1000)
|
|
self.assertEqual(intermediate_terminus_balance, initial_terminus_balance + 1000)
|
|
self.assertEqual(
|
|
intermediate_controller_balance, initial_controller_balance - 1000
|
|
)
|
|
|
|
with self.assertRaises(Exception):
|
|
diamond_terminus.withdraw_payments(
|
|
accounts[0].address, 1000, {"from": accounts[0]}
|
|
)
|
|
|
|
with self.assertRaises(Exception):
|
|
diamond_terminus.withdraw_payments(
|
|
accounts[1].address, 1000, {"from": accounts[0]}
|
|
)
|
|
|
|
with self.assertRaises(Exception):
|
|
diamond_terminus.withdraw_payments(
|
|
accounts[0].address, 1000, {"from": accounts[1]}
|
|
)
|
|
|
|
diamond_terminus.withdraw_payments(
|
|
accounts[1].address, 1000, {"from": accounts[1]}
|
|
)
|
|
|
|
final_terminus_balance = diamond_moonstream.balance_of(terminus_diamond_address)
|
|
final_controller_balance = diamond_moonstream.balance_of(accounts[1].address)
|
|
self.assertEqual(final_terminus_balance, intermediate_terminus_balance - 1000)
|
|
self.assertEqual(
|
|
final_controller_balance, intermediate_controller_balance + 1000
|
|
)
|
|
|
|
with self.assertRaises(Exception):
|
|
diamond_terminus.withdraw_payments(
|
|
accounts[0].address,
|
|
final_terminus_balance + 1000,
|
|
{"from": accounts[0]},
|
|
)
|
|
|
|
pool_controller = diamond_terminus.terminus_pool_controller(final_total_pools)
|
|
self.assertEqual(pool_controller, accounts[1].address)
|
|
|
|
pool_capacity = diamond_terminus.terminus_pool_capacity(final_total_pools)
|
|
self.assertEqual(pool_capacity, 10)
|
|
|
|
|
|
class TestPoolOperations(TerminusTestCase):
|
|
@classmethod
|
|
def setUpClass(cls) -> None:
|
|
super().setUpClass()
|
|
moonstream_diamond_address = cls.contracts["Diamond"]
|
|
diamond_moonstream = ERC20Facet.ERC20Facet(moonstream_diamond_address)
|
|
terminus_diamond_address = cls.terminus_contracts["Diamond"]
|
|
diamond_terminus = TerminusFacet.TerminusFacet(terminus_diamond_address)
|
|
diamond_terminus.set_payment_token(
|
|
moonstream_diamond_address, {"from": accounts[0]}
|
|
)
|
|
diamond_terminus.set_pool_base_price(1000, {"from": accounts[0]})
|
|
diamond_moonstream.mint(accounts[1], 1000000, {"from": accounts[0]})
|
|
diamond_moonstream.approve(
|
|
terminus_diamond_address, 1000000, {"from": accounts[1]}
|
|
)
|
|
cls.diamond_terminus = diamond_terminus
|
|
cls.diamond_moonstream = diamond_moonstream
|
|
|
|
cls.diamond_terminus.set_controller(accounts[1].address, {"from": accounts[0]})
|
|
|
|
def setUp(self) -> None:
|
|
self.diamond_terminus.create_simple_pool(10, {"from": accounts[1]})
|
|
|
|
def test_set_pool_controller(self):
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
old_controller = accounts[1]
|
|
new_controller = accounts[2]
|
|
|
|
current_controller_address = self.diamond_terminus.terminus_pool_controller(
|
|
pool_id
|
|
)
|
|
self.assertEqual(current_controller_address, old_controller.address)
|
|
|
|
with self.assertRaises(Exception):
|
|
self.diamond_terminus.set_pool_controller(
|
|
pool_id, new_controller.address, {"from": new_controller}
|
|
)
|
|
current_controller_address = self.diamond_terminus.terminus_pool_controller(
|
|
pool_id
|
|
)
|
|
self.assertEqual(current_controller_address, old_controller.address)
|
|
|
|
self.diamond_terminus.set_pool_controller(
|
|
pool_id, new_controller.address, {"from": old_controller}
|
|
)
|
|
current_controller_address = self.diamond_terminus.terminus_pool_controller(
|
|
pool_id
|
|
)
|
|
self.assertEqual(current_controller_address, new_controller.address)
|
|
|
|
with self.assertRaises(Exception):
|
|
self.diamond_terminus.set_pool_controller(
|
|
pool_id, old_controller.address, {"from": old_controller}
|
|
)
|
|
current_controller_address = self.diamond_terminus.terminus_pool_controller(
|
|
pool_id
|
|
)
|
|
self.assertEqual(current_controller_address, new_controller.address)
|
|
|
|
self.diamond_terminus.set_pool_controller(
|
|
pool_id, old_controller.address, {"from": new_controller}
|
|
)
|
|
current_controller_address = self.diamond_terminus.terminus_pool_controller(
|
|
pool_id
|
|
)
|
|
self.assertEqual(current_controller_address, old_controller.address)
|
|
|
|
def test_mint(self):
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
self.diamond_terminus.mint(accounts[2], pool_id, 1, b"", {"from": accounts[1]})
|
|
|
|
balance = self.diamond_terminus.balance_of(accounts[2].address, pool_id)
|
|
self.assertEqual(balance, 1)
|
|
|
|
supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
self.assertEqual(supply, 1)
|
|
|
|
def test_mint_fails_if_it_exceeds_capacity(self):
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
with self.assertRaises(Exception):
|
|
self.diamond_terminus.mint(
|
|
accounts[2], pool_id, 11, b"", {"from": accounts[1]}
|
|
)
|
|
|
|
balance = self.diamond_terminus.balance_of(accounts[2].address, pool_id)
|
|
self.assertEqual(balance, 0)
|
|
|
|
supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
self.assertEqual(supply, 0)
|
|
|
|
def test_mint_batch(self):
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
self.diamond_terminus.mint_batch(
|
|
accounts[2].address,
|
|
pool_i_ds=[pool_id],
|
|
amounts=[1],
|
|
data=b"",
|
|
transaction_config={"from": accounts[1]},
|
|
)
|
|
|
|
balance = self.diamond_terminus.balance_of(accounts[2].address, pool_id)
|
|
self.assertEqual(balance, 1)
|
|
|
|
supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
self.assertEqual(supply, 1)
|
|
|
|
def test_mint_batch_with_approval(self):
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
|
|
self.assertFalse(
|
|
self.diamond_terminus.is_approved_for_pool(pool_id, accounts[3])
|
|
)
|
|
self.assertFalse(
|
|
self.diamond_terminus.is_approved_for_pool(pool_id - 1, accounts[3])
|
|
)
|
|
balances_before = [
|
|
self.diamond_terminus.balance_of(accounts[2].address, pool_id),
|
|
self.diamond_terminus.balance_of(accounts[2].address, pool_id - 1),
|
|
]
|
|
supply_before = [
|
|
self.diamond_terminus.terminus_pool_supply(pool_id),
|
|
self.diamond_terminus.terminus_pool_supply(pool_id - 1),
|
|
]
|
|
self.diamond_terminus.approve_for_pool(
|
|
pool_id, accounts[3], {"from": accounts[1]}
|
|
)
|
|
with self.assertRaises(Exception):
|
|
self.diamond_terminus.mint_batch(
|
|
accounts[2].address,
|
|
pool_i_ds=[pool_id, pool_id - 1],
|
|
amounts=[1, 1],
|
|
data=b"",
|
|
transaction_config={"from": accounts[3]},
|
|
)
|
|
|
|
self.diamond_terminus.approve_for_pool(
|
|
pool_id - 1, accounts[3], {"from": accounts[1]}
|
|
)
|
|
|
|
self.diamond_terminus.mint_batch(
|
|
accounts[2].address,
|
|
pool_i_ds=[pool_id, pool_id - 1],
|
|
amounts=[1, 1],
|
|
data=b"",
|
|
transaction_config={"from": accounts[3]},
|
|
)
|
|
|
|
self.assertEqual(
|
|
self.diamond_terminus.balance_of(accounts[2].address, pool_id),
|
|
balances_before[0] + 1,
|
|
)
|
|
self.assertEqual(
|
|
self.diamond_terminus.balance_of(accounts[2].address, pool_id - 1),
|
|
balances_before[1] + 1,
|
|
)
|
|
|
|
self.assertEqual(
|
|
self.diamond_terminus.terminus_pool_supply(pool_id), supply_before[0] + 1
|
|
)
|
|
self.assertEqual(
|
|
self.diamond_terminus.terminus_pool_supply(pool_id - 1),
|
|
supply_before[1] + 1,
|
|
)
|
|
|
|
def test_mint_batch_fails_if_it_exceeds_capacity(self):
|
|
capacity = 10
|
|
self.diamond_terminus.create_pool_v1(
|
|
capacity, True, True, {"from": accounts[1]}
|
|
)
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
with self.assertRaises(Exception):
|
|
self.diamond_terminus.mint_batch(
|
|
accounts[2].address,
|
|
pool_i_ds=[pool_id, pool_id],
|
|
amounts=[int(capacity / 2) + 1, int(capacity / 2) + 1],
|
|
data=b"",
|
|
transaction_config={"from": accounts[1]},
|
|
)
|
|
|
|
balance = self.diamond_terminus.balance_of(accounts[2].address, pool_id)
|
|
self.assertEqual(balance, 0)
|
|
|
|
supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
self.assertEqual(supply, 0)
|
|
|
|
def test_mint_batch_fails_if_it_exceeds_capacity_one_at_a_time(self):
|
|
capacity = 10
|
|
self.diamond_terminus.create_pool_v1(
|
|
capacity, True, True, {"from": accounts[1]}
|
|
)
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
with self.assertRaises(Exception):
|
|
self.diamond_terminus.mint_batch(
|
|
accounts[2].address,
|
|
pool_i_ds=[pool_id for _ in range(capacity + 1)],
|
|
amounts=[1 for _ in range(capacity + 1)],
|
|
data=b"",
|
|
transaction_config={"from": accounts[1]},
|
|
)
|
|
|
|
balance = self.diamond_terminus.balance_of(accounts[2].address, pool_id)
|
|
self.assertEqual(balance, 0)
|
|
|
|
supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
self.assertEqual(supply, 0)
|
|
|
|
def test_pool_mint_batch(self):
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
target_accounts = [account.address for account in accounts[:5]]
|
|
target_amounts = [1 for _ in accounts[:5]]
|
|
num_accounts = len(accounts[:5])
|
|
initial_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
initial_balances: List[int] = []
|
|
for account in accounts[:5]:
|
|
initial_balances.append(
|
|
self.diamond_terminus.balance_of(account.address, pool_id)
|
|
)
|
|
self.diamond_terminus.pool_mint_batch(
|
|
pool_id, target_accounts, target_amounts, {"from": accounts[1]}
|
|
)
|
|
final_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
self.assertEqual(final_pool_supply, initial_pool_supply + num_accounts)
|
|
for i, account in enumerate(accounts[:5]):
|
|
final_balance = self.diamond_terminus.balance_of(account.address, pool_id)
|
|
self.assertEqual(final_balance, initial_balances[i] + 1)
|
|
|
|
def test_pool_mint_batch_as_contract_controller_not_pool_controller(self):
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
target_accounts = [account.address for account in accounts[:5]]
|
|
target_amounts = [1 for _ in accounts[:5]]
|
|
initial_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
initial_balances: List[int] = []
|
|
for account in accounts[:5]:
|
|
initial_balances.append(
|
|
self.diamond_terminus.balance_of(account.address, pool_id)
|
|
)
|
|
with self.assertRaises(Exception):
|
|
self.diamond_terminus.pool_mint_batch(
|
|
pool_id, target_accounts, target_amounts, {"from": accounts[0]}
|
|
)
|
|
final_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
self.assertEqual(final_pool_supply, initial_pool_supply)
|
|
for i, account in enumerate(accounts[:5]):
|
|
final_balance = self.diamond_terminus.balance_of(account.address, pool_id)
|
|
self.assertEqual(final_balance, initial_balances[i])
|
|
|
|
def test_pool_mint_batch_as_unauthorized_third_party(self):
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
target_accounts = [account.address for account in accounts[:5]]
|
|
target_amounts = [1 for _ in accounts[:5]]
|
|
initial_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
initial_balances: List[int] = []
|
|
for account in accounts[:5]:
|
|
initial_balances.append(
|
|
self.diamond_terminus.balance_of(account.address, pool_id)
|
|
)
|
|
with self.assertRaises(Exception):
|
|
self.diamond_terminus.pool_mint_batch(
|
|
pool_id, target_accounts, target_amounts, {"from": accounts[2]}
|
|
)
|
|
final_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
self.assertEqual(final_pool_supply, initial_pool_supply)
|
|
for i, account in enumerate(accounts[:5]):
|
|
final_balance = self.diamond_terminus.balance_of(account.address, pool_id)
|
|
self.assertEqual(final_balance, initial_balances[i])
|
|
|
|
def test_pool_mint_with_pool_approval(self):
|
|
self.diamond_terminus.create_pool_v1(10, False, False, {"from": accounts[1]})
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
|
|
self.assertFalse(
|
|
self.diamond_terminus.is_approved_for_pool(pool_id, accounts[2].address)
|
|
)
|
|
with self.assertRaises(Exception):
|
|
self.diamond_terminus.mint(
|
|
accounts[2].address, pool_id, 1, b"", {"from": accounts[2]}
|
|
)
|
|
|
|
self.diamond_terminus.approve_for_pool(
|
|
pool_id, accounts[2].address, {"from": accounts[1]}
|
|
)
|
|
supply_0 = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
balance_0 = self.diamond_terminus.balance_of(accounts[2].address, pool_id)
|
|
self.diamond_terminus.mint(
|
|
accounts[2].address, pool_id, 1, b"", {"from": accounts[1]}
|
|
)
|
|
balance_1 = self.diamond_terminus.balance_of(accounts[2].address, pool_id)
|
|
supply_1 = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
|
|
self.assertEqual(balance_1, balance_0 + 1)
|
|
self.assertEqual(supply_0 + 1, supply_1)
|
|
|
|
def test_pool_mint_batch_with_approval(self):
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
target_accounts = [account.address for account in accounts[:5]]
|
|
target_amounts = [1 for _ in accounts[:5]]
|
|
num_accounts = len(accounts[:5])
|
|
initial_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
initial_balances: List[int] = []
|
|
for account in accounts[:5]:
|
|
initial_balances.append(
|
|
self.diamond_terminus.balance_of(account.address, pool_id)
|
|
)
|
|
|
|
self.assertFalse(
|
|
self.diamond_terminus.is_approved_for_pool(pool_id, accounts[2].address)
|
|
)
|
|
with self.assertRaises(Exception):
|
|
self.diamond_terminus.pool_mint_batch(
|
|
pool_id, target_accounts, target_amounts, {"from": accounts[2]}
|
|
)
|
|
self.diamond_terminus.approve_for_pool(
|
|
pool_id, accounts[2].address, {"from": accounts[1]}
|
|
)
|
|
self.diamond_terminus.pool_mint_batch(
|
|
pool_id, target_accounts, target_amounts, {"from": accounts[2]}
|
|
)
|
|
|
|
final_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
self.assertEqual(final_pool_supply, initial_pool_supply + num_accounts)
|
|
for i, account in enumerate(accounts[:5]):
|
|
final_balance = self.diamond_terminus.balance_of(account.address, pool_id)
|
|
self.assertEqual(final_balance, initial_balances[i] + 1)
|
|
|
|
def test_transfer(self):
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
self.diamond_terminus.mint(accounts[2], pool_id, 1, b"", {"from": accounts[1]})
|
|
|
|
initial_sender_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
initial_receiver_balance = self.diamond_terminus.balance_of(
|
|
accounts[3].address, pool_id
|
|
)
|
|
|
|
self.diamond_terminus.safe_transfer_from(
|
|
accounts[2].address,
|
|
accounts[3].address,
|
|
pool_id,
|
|
1,
|
|
b"",
|
|
{"from": accounts[2]},
|
|
)
|
|
|
|
final_sender_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
final_receiver_balance = self.diamond_terminus.balance_of(
|
|
accounts[3].address, pool_id
|
|
)
|
|
|
|
self.assertEqual(final_sender_balance, initial_sender_balance - 1)
|
|
self.assertEqual(final_receiver_balance, initial_receiver_balance + 1)
|
|
|
|
def test_transfer_as_pool_controller(self):
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
self.diamond_terminus.mint(accounts[2], pool_id, 1, b"", {"from": accounts[1]})
|
|
|
|
initial_sender_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
initial_receiver_balance = self.diamond_terminus.balance_of(
|
|
accounts[3].address, pool_id
|
|
)
|
|
|
|
self.diamond_terminus.safe_transfer_from(
|
|
accounts[2].address,
|
|
accounts[3].address,
|
|
pool_id,
|
|
1,
|
|
b"",
|
|
{"from": accounts[1]},
|
|
)
|
|
|
|
final_sender_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
final_receiver_balance = self.diamond_terminus.balance_of(
|
|
accounts[3].address, pool_id
|
|
)
|
|
|
|
self.assertEqual(final_sender_balance, initial_sender_balance - 1)
|
|
self.assertEqual(final_receiver_balance, initial_receiver_balance + 1)
|
|
|
|
def test_transfer_fails_as_controller_of_another_pool_with_no_approval(self):
|
|
"""
|
|
Hacken.io auditors claimed that an address that controlled *some* pool could effect transfers
|
|
on *any* pool.
|
|
|
|
This test shows that this is not true.
|
|
|
|
Exercises:
|
|
- safeTransferFrom
|
|
"""
|
|
# Ensure that accounts[1] is pool controller of *some* pool.
|
|
self.diamond_terminus.create_pool_v1(100, True, True, {"from": accounts[1]})
|
|
controlled_pool_id = self.diamond_terminus.total_pools()
|
|
self.assertEqual(
|
|
self.diamond_terminus.terminus_pool_controller(controlled_pool_id),
|
|
accounts[1].address,
|
|
)
|
|
|
|
self.diamond_terminus.create_pool_v1(100, True, True, {"from": accounts[1]})
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
self.diamond_terminus.mint(accounts[2], pool_id, 1, b"", {"from": accounts[1]})
|
|
|
|
# Remove pool control from accounts[1]
|
|
self.diamond_terminus.set_pool_controller(
|
|
pool_id, accounts[4].address, {"from": accounts[1]}
|
|
)
|
|
|
|
initial_sender_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
initial_receiver_balance = self.diamond_terminus.balance_of(
|
|
accounts[3].address, pool_id
|
|
)
|
|
|
|
with self.assertRaises(VirtualMachineError):
|
|
self.diamond_terminus.safe_transfer_from(
|
|
accounts[2].address,
|
|
accounts[3].address,
|
|
pool_id,
|
|
1,
|
|
b"",
|
|
{"from": accounts[1]},
|
|
)
|
|
|
|
final_sender_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
final_receiver_balance = self.diamond_terminus.balance_of(
|
|
accounts[3].address, pool_id
|
|
)
|
|
|
|
self.assertEqual(final_sender_balance, initial_sender_balance)
|
|
self.assertEqual(final_receiver_balance, initial_receiver_balance)
|
|
|
|
def test_transfer_fails_as_terminus_controller_with_no_approval(self):
|
|
"""
|
|
Tests that neither Terminus controller *nor* pool controller can transfer a token on behalf of
|
|
another address without explicit approval (using safeTransferFrom).
|
|
|
|
Exercises:
|
|
- safeTransferFrom
|
|
"""
|
|
self.assertEqual(
|
|
self.diamond_terminus.terminus_controller(), accounts[1].address
|
|
)
|
|
self.diamond_terminus.create_pool_v1(100, True, True, {"from": accounts[1]})
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
self.diamond_terminus.mint(accounts[2], pool_id, 1, b"", {"from": accounts[1]})
|
|
|
|
# Remove pool control from accounts[1]
|
|
self.diamond_terminus.set_pool_controller(
|
|
pool_id, accounts[4].address, {"from": accounts[1]}
|
|
)
|
|
|
|
initial_sender_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
initial_receiver_balance = self.diamond_terminus.balance_of(
|
|
accounts[3].address, pool_id
|
|
)
|
|
|
|
with self.assertRaises(VirtualMachineError):
|
|
self.diamond_terminus.safe_transfer_from(
|
|
accounts[2].address,
|
|
accounts[3].address,
|
|
pool_id,
|
|
1,
|
|
b"",
|
|
{"from": accounts[1]},
|
|
)
|
|
|
|
final_sender_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
final_receiver_balance = self.diamond_terminus.balance_of(
|
|
accounts[3].address, pool_id
|
|
)
|
|
|
|
self.assertEqual(final_sender_balance, initial_sender_balance)
|
|
self.assertEqual(final_receiver_balance, initial_receiver_balance)
|
|
|
|
def test_transfer_as_unauthorized_recipient(self):
|
|
self.diamond_terminus.create_pool_v1(
|
|
2**256 - 1, True, True, {"from": accounts[1]}
|
|
)
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
self.diamond_terminus.mint(accounts[2], pool_id, 1, b"", {"from": accounts[1]})
|
|
|
|
initial_sender_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
initial_receiver_balance = self.diamond_terminus.balance_of(
|
|
accounts[3].address, pool_id
|
|
)
|
|
|
|
with self.assertRaises(Exception):
|
|
self.diamond_terminus.safe_transfer_from(
|
|
accounts[2].address,
|
|
accounts[3].address,
|
|
pool_id,
|
|
1,
|
|
b"",
|
|
{"from": accounts[3]},
|
|
)
|
|
|
|
final_sender_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
final_receiver_balance = self.diamond_terminus.balance_of(
|
|
accounts[3].address, pool_id
|
|
)
|
|
|
|
self.assertEqual(final_sender_balance, initial_sender_balance)
|
|
self.assertEqual(final_receiver_balance, initial_receiver_balance)
|
|
|
|
def test_transfer_as_authorized_recipient(self):
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
self.diamond_terminus.mint(accounts[2], pool_id, 1, b"", {"from": accounts[1]})
|
|
|
|
initial_sender_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
initial_receiver_balance = self.diamond_terminus.balance_of(
|
|
accounts[3].address, pool_id
|
|
)
|
|
|
|
self.diamond_terminus.approve_for_pool(
|
|
pool_id, accounts[3].address, {"from": accounts[1]}
|
|
)
|
|
self.diamond_terminus.safe_transfer_from(
|
|
accounts[2].address,
|
|
accounts[3].address,
|
|
pool_id,
|
|
1,
|
|
b"",
|
|
{"from": accounts[3]},
|
|
)
|
|
|
|
final_sender_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
final_receiver_balance = self.diamond_terminus.balance_of(
|
|
accounts[3].address, pool_id
|
|
)
|
|
|
|
self.assertEqual(final_sender_balance, initial_sender_balance - 1)
|
|
self.assertEqual(final_receiver_balance, initial_receiver_balance + 1)
|
|
|
|
def test_transfer_as_approved_operator(self):
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
self.diamond_terminus.mint(accounts[2], pool_id, 1, b"", {"from": accounts[1]})
|
|
|
|
initial_sender_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
initial_receiver_balance = self.diamond_terminus.balance_of(
|
|
accounts[3].address, pool_id
|
|
)
|
|
|
|
# It is very important to revoke this approval from accounts[3] as accounts[3] tries to initiate
|
|
# transfers from accounts[2] in other tests.
|
|
self.diamond_terminus.set_approval_for_all(
|
|
accounts[3].address, True, {"from": accounts[2]}
|
|
)
|
|
|
|
try:
|
|
self.diamond_terminus.safe_transfer_from(
|
|
accounts[2].address,
|
|
accounts[3].address,
|
|
pool_id,
|
|
1,
|
|
b"",
|
|
{"from": accounts[3]},
|
|
)
|
|
finally:
|
|
self.diamond_terminus.set_approval_for_all(
|
|
accounts[3].address, False, {"from": accounts[2]}
|
|
)
|
|
|
|
final_sender_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
final_receiver_balance = self.diamond_terminus.balance_of(
|
|
accounts[3].address, pool_id
|
|
)
|
|
|
|
self.assertEqual(final_sender_balance, initial_sender_balance - 1)
|
|
self.assertEqual(final_receiver_balance, initial_receiver_balance + 1)
|
|
|
|
# Check that accounts[3] is no longer approved for all pools by accounts[2] (for other tests to)
|
|
# run correctly.
|
|
self.assertFalse(
|
|
self.diamond_terminus.is_approved_for_all(
|
|
accounts[2].address, accounts[3].address
|
|
)
|
|
)
|
|
|
|
def test_transfer_as_unauthorized_unrelated_party(self):
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
self.diamond_terminus.mint(accounts[2], pool_id, 1, b"", {"from": accounts[1]})
|
|
|
|
initial_sender_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
initial_receiver_balance = self.diamond_terminus.balance_of(
|
|
accounts[3].address, pool_id
|
|
)
|
|
|
|
with self.assertRaises(Exception):
|
|
self.diamond_terminus.safe_transfer_from(
|
|
accounts[2].address,
|
|
accounts[3].address,
|
|
pool_id,
|
|
1,
|
|
b"",
|
|
{"from": accounts[4]},
|
|
)
|
|
|
|
final_sender_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
final_receiver_balance = self.diamond_terminus.balance_of(
|
|
accounts[3].address, pool_id
|
|
)
|
|
|
|
self.assertEqual(final_sender_balance, initial_sender_balance)
|
|
self.assertEqual(final_receiver_balance, initial_receiver_balance)
|
|
|
|
def test_transfer_as_authorized_unrelated_party(self):
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
self.diamond_terminus.mint(accounts[2], pool_id, 1, b"", {"from": accounts[1]})
|
|
|
|
initial_sender_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
initial_receiver_balance = self.diamond_terminus.balance_of(
|
|
accounts[3].address, pool_id
|
|
)
|
|
|
|
self.diamond_terminus.approve_for_pool(
|
|
pool_id, accounts[4].address, {"from": accounts[1]}
|
|
)
|
|
self.diamond_terminus.safe_transfer_from(
|
|
accounts[2].address,
|
|
accounts[3].address,
|
|
pool_id,
|
|
1,
|
|
b"",
|
|
{"from": accounts[4]},
|
|
)
|
|
|
|
final_sender_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
final_receiver_balance = self.diamond_terminus.balance_of(
|
|
accounts[3].address, pool_id
|
|
)
|
|
|
|
self.assertEqual(final_sender_balance, initial_sender_balance - 1)
|
|
self.assertEqual(final_receiver_balance, initial_receiver_balance + 1)
|
|
|
|
def test_burn_fails_as_token_owner(self):
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
self.diamond_terminus.mint(accounts[2], pool_id, 1, b"", {"from": accounts[1]})
|
|
|
|
initial_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
initial_owner_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
with self.assertRaises(Exception):
|
|
self.diamond_terminus.burn(
|
|
accounts[2].address, pool_id, 1, {"from": accounts[2]}
|
|
)
|
|
|
|
final_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
final_owner_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
self.assertEqual(final_pool_supply, initial_pool_supply)
|
|
self.assertEqual(final_owner_balance, initial_owner_balance)
|
|
|
|
def test_burn_fails_as_pool_controller(self):
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
self.diamond_terminus.mint(accounts[2], pool_id, 1, b"", {"from": accounts[1]})
|
|
|
|
initial_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
initial_owner_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
with self.assertRaises(Exception):
|
|
self.diamond_terminus.burn(
|
|
accounts[2].address, pool_id, 1, {"from": accounts[1]}
|
|
)
|
|
|
|
final_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
final_owner_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
self.assertEqual(final_pool_supply, initial_pool_supply)
|
|
self.assertEqual(final_owner_balance, initial_owner_balance)
|
|
|
|
def test_burn_fails_as_third_party(self):
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
self.diamond_terminus.mint(accounts[2], pool_id, 1, b"", {"from": accounts[1]})
|
|
|
|
initial_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
initial_owner_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
with self.assertRaises(Exception):
|
|
self.diamond_terminus.burn(
|
|
accounts[2].address, pool_id, 1, {"from": accounts[3]}
|
|
)
|
|
|
|
final_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
final_owner_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
self.assertEqual(final_pool_supply, initial_pool_supply)
|
|
self.assertEqual(final_owner_balance, initial_owner_balance)
|
|
|
|
def test_burn_fails_as_authorized_third_party(self):
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
self.diamond_terminus.mint(accounts[2], pool_id, 1, b"", {"from": accounts[1]})
|
|
|
|
initial_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
initial_owner_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
self.diamond_terminus.approve_for_pool(
|
|
pool_id, accounts[3].address, {"from": accounts[1]}
|
|
)
|
|
with self.assertRaises(Exception):
|
|
self.diamond_terminus.burn(
|
|
accounts[2].address, pool_id, 1, {"from": accounts[3]}
|
|
)
|
|
|
|
final_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
final_owner_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
self.assertEqual(final_pool_supply, initial_pool_supply)
|
|
self.assertEqual(final_owner_balance, initial_owner_balance)
|
|
|
|
def test_pool_approval(self):
|
|
controller = accounts[1]
|
|
operator = accounts[2]
|
|
user = accounts[3]
|
|
|
|
# TODO(zomglings): We should test the Terminus controller permissions on the same contract.
|
|
# Currently, controller is both pool controller AND Terminus controller. In a more proper test,
|
|
# these would be different accounts.
|
|
|
|
# TODO(zomglings): Tested manually that changing burnable below from True to False results in
|
|
# the right reversion when we try to burn these tokens on-chain. This should be a separate
|
|
# test case that runs *automatically*.
|
|
self.diamond_terminus.create_pool_v1(100, True, True, {"from": controller})
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
self.diamond_terminus.mint(
|
|
controller.address, pool_id, 5, "", {"from": controller}
|
|
)
|
|
self.diamond_terminus.mint(
|
|
operator.address, pool_id, 5, "", {"from": controller}
|
|
)
|
|
self.diamond_terminus.mint(user.address, pool_id, 5, "", {"from": controller})
|
|
|
|
controller_balance_0 = self.diamond_terminus.balance_of(
|
|
controller.address, pool_id
|
|
)
|
|
operator_balance_0 = self.diamond_terminus.balance_of(operator.address, pool_id)
|
|
user_balance_0 = self.diamond_terminus.balance_of(user.address, pool_id)
|
|
|
|
self.assertFalse(
|
|
self.diamond_terminus.is_approved_for_pool(pool_id, operator.address)
|
|
)
|
|
|
|
with self.assertRaises(VirtualMachineError):
|
|
self.diamond_terminus.mint(
|
|
controller.address, pool_id, 1, "", {"from": operator}
|
|
)
|
|
|
|
with self.assertRaises(VirtualMachineError):
|
|
self.diamond_terminus.mint(
|
|
operator.address, pool_id, 1, "", {"from": operator}
|
|
)
|
|
|
|
with self.assertRaises(VirtualMachineError):
|
|
self.diamond_terminus.mint(user.address, pool_id, 1, "", {"from": operator})
|
|
|
|
controller_balance_1 = self.diamond_terminus.balance_of(
|
|
controller.address, pool_id
|
|
)
|
|
operator_balance_1 = self.diamond_terminus.balance_of(operator.address, pool_id)
|
|
user_balance_1 = self.diamond_terminus.balance_of(user.address, pool_id)
|
|
|
|
self.assertEqual(controller_balance_1, controller_balance_0)
|
|
self.assertEqual(operator_balance_1, operator_balance_0)
|
|
self.assertEqual(user_balance_1, user_balance_0)
|
|
|
|
with self.assertRaises(VirtualMachineError):
|
|
self.diamond_terminus.burn(
|
|
controller.address, pool_id, 1, {"from": operator}
|
|
)
|
|
|
|
self.diamond_terminus.burn(operator.address, pool_id, 1, {"from": operator})
|
|
|
|
with self.assertRaises(VirtualMachineError):
|
|
self.diamond_terminus.burn(user.address, pool_id, 1, {"from": operator})
|
|
|
|
controller_balance_2 = self.diamond_terminus.balance_of(
|
|
controller.address, pool_id
|
|
)
|
|
operator_balance_2 = self.diamond_terminus.balance_of(operator.address, pool_id)
|
|
user_balance_2 = self.diamond_terminus.balance_of(user.address, pool_id)
|
|
|
|
self.assertEqual(controller_balance_2, controller_balance_1)
|
|
self.assertEqual(operator_balance_2, operator_balance_1 - 1)
|
|
self.assertEqual(user_balance_2, user_balance_1)
|
|
|
|
with self.assertRaises(VirtualMachineError):
|
|
self.diamond_terminus.approve_for_pool(
|
|
pool_id, operator, {"from": operator}
|
|
)
|
|
|
|
self.diamond_terminus.approve_for_pool(pool_id, operator, {"from": accounts[1]})
|
|
|
|
self.assertTrue(
|
|
self.diamond_terminus.is_approved_for_pool(pool_id, operator.address)
|
|
)
|
|
|
|
self.diamond_terminus.mint(
|
|
controller.address, pool_id, 1, "", {"from": operator}
|
|
)
|
|
self.diamond_terminus.mint(operator.address, pool_id, 1, "", {"from": operator})
|
|
self.diamond_terminus.mint(user.address, pool_id, 1, "", {"from": operator})
|
|
|
|
controller_balance_3 = self.diamond_terminus.balance_of(
|
|
controller.address, pool_id
|
|
)
|
|
operator_balance_3 = self.diamond_terminus.balance_of(operator.address, pool_id)
|
|
user_balance_3 = self.diamond_terminus.balance_of(user.address, pool_id)
|
|
|
|
self.assertEqual(controller_balance_3, controller_balance_2 + 1)
|
|
self.assertEqual(operator_balance_3, operator_balance_2 + 1)
|
|
self.assertEqual(user_balance_3, user_balance_2 + 1)
|
|
|
|
self.diamond_terminus.burn(controller.address, pool_id, 1, {"from": operator})
|
|
self.diamond_terminus.burn(operator.address, pool_id, 1, {"from": operator})
|
|
self.diamond_terminus.burn(user.address, pool_id, 1, {"from": operator})
|
|
|
|
controller_balance_4 = self.diamond_terminus.balance_of(
|
|
controller.address, pool_id
|
|
)
|
|
operator_balance_4 = self.diamond_terminus.balance_of(operator.address, pool_id)
|
|
user_balance_4 = self.diamond_terminus.balance_of(user.address, pool_id)
|
|
|
|
self.assertEqual(controller_balance_4, controller_balance_3 - 1)
|
|
self.assertEqual(operator_balance_4, operator_balance_3 - 1)
|
|
self.assertEqual(user_balance_4, user_balance_3 - 1)
|
|
|
|
with self.assertRaises(VirtualMachineError):
|
|
self.diamond_terminus.unapprove_for_pool(
|
|
pool_id, operator, {"from": operator}
|
|
)
|
|
|
|
self.assertTrue(
|
|
self.diamond_terminus.is_approved_for_pool(pool_id, operator.address)
|
|
)
|
|
|
|
self.diamond_terminus.unapprove_for_pool(
|
|
pool_id, operator, {"from": controller}
|
|
)
|
|
|
|
self.assertFalse(
|
|
self.diamond_terminus.is_approved_for_pool(pool_id, operator.address)
|
|
)
|
|
|
|
with self.assertRaises(VirtualMachineError):
|
|
self.diamond_terminus.mint(
|
|
controller.address, pool_id, 1, "", {"from": operator}
|
|
)
|
|
|
|
with self.assertRaises(VirtualMachineError):
|
|
self.diamond_terminus.mint(
|
|
operator.address, pool_id, 1, "", {"from": operator}
|
|
)
|
|
|
|
with self.assertRaises(VirtualMachineError):
|
|
self.diamond_terminus.mint(user.address, pool_id, 1, "", {"from": operator})
|
|
|
|
controller_balance_5 = self.diamond_terminus.balance_of(
|
|
controller.address, pool_id
|
|
)
|
|
operator_balance_5 = self.diamond_terminus.balance_of(operator.address, pool_id)
|
|
user_balance_5 = self.diamond_terminus.balance_of(user.address, pool_id)
|
|
|
|
self.assertEqual(controller_balance_5, controller_balance_4)
|
|
self.assertEqual(operator_balance_5, operator_balance_4)
|
|
self.assertEqual(user_balance_5, user_balance_4)
|
|
|
|
with self.assertRaises(VirtualMachineError):
|
|
self.diamond_terminus.burn(
|
|
controller.address, pool_id, 1, {"from": operator}
|
|
)
|
|
|
|
self.diamond_terminus.burn(operator.address, pool_id, 1, {"from": operator})
|
|
|
|
with self.assertRaises(VirtualMachineError):
|
|
self.diamond_terminus.burn(user.address, pool_id, 1, {"from": operator})
|
|
|
|
controller_balance_6 = self.diamond_terminus.balance_of(
|
|
controller.address, pool_id
|
|
)
|
|
operator_balance_6 = self.diamond_terminus.balance_of(operator.address, pool_id)
|
|
user_balance_6 = self.diamond_terminus.balance_of(user.address, pool_id)
|
|
|
|
self.assertEqual(controller_balance_6, controller_balance_5)
|
|
self.assertEqual(operator_balance_6, operator_balance_5 - 1)
|
|
self.assertEqual(user_balance_6, user_balance_5)
|
|
|
|
|
|
class TestPoolCreation(TestPoolOperations):
|
|
def setUp(self):
|
|
self.diamond_terminus.create_pool_v1(10, True, False, {"from": accounts[1]})
|
|
|
|
def test_nontransferable_pool(self):
|
|
self.diamond_terminus.create_pool_v1(10, False, False, {"from": accounts[1]})
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
self.diamond_terminus.mint(accounts[2], pool_id, 1, b"", {"from": accounts[1]})
|
|
|
|
initial_sender_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
initial_receiver_balance = self.diamond_terminus.balance_of(
|
|
accounts[3].address, pool_id
|
|
)
|
|
|
|
with self.assertRaises(Exception):
|
|
self.diamond_terminus.safe_transfer_from(
|
|
accounts[2].address,
|
|
accounts[3].address,
|
|
pool_id,
|
|
1,
|
|
b"",
|
|
{"from": accounts[2]},
|
|
)
|
|
|
|
final_sender_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
final_receiver_balance = self.diamond_terminus.balance_of(
|
|
accounts[3].address, pool_id
|
|
)
|
|
|
|
self.assertEqual(final_sender_balance, initial_sender_balance)
|
|
self.assertEqual(final_receiver_balance, initial_receiver_balance)
|
|
|
|
def test_pool_state_view_methods(self):
|
|
nontransferable_nonburnable_pool_uri = "https://example.com/ff.json"
|
|
self.diamond_terminus.create_pool_v2(
|
|
10,
|
|
False,
|
|
False,
|
|
nontransferable_nonburnable_pool_uri,
|
|
{"from": accounts[1]},
|
|
)
|
|
nontransferable_nonburnable_pool_id = self.diamond_terminus.total_pools()
|
|
self.assertFalse(
|
|
self.diamond_terminus.pool_is_transferable(
|
|
nontransferable_nonburnable_pool_id
|
|
)
|
|
)
|
|
self.assertFalse(
|
|
self.diamond_terminus.pool_is_burnable(nontransferable_nonburnable_pool_id)
|
|
)
|
|
self.assertEqual(
|
|
self.diamond_terminus.uri(nontransferable_nonburnable_pool_id),
|
|
nontransferable_nonburnable_pool_uri,
|
|
)
|
|
|
|
transferable_nonburnable_pool_uri = "https://example.com/tf.json"
|
|
self.diamond_terminus.create_pool_v2(
|
|
10, True, False, transferable_nonburnable_pool_uri, {"from": accounts[1]}
|
|
)
|
|
transferable_nonburnable_pool_id = self.diamond_terminus.total_pools()
|
|
self.assertTrue(
|
|
self.diamond_terminus.pool_is_transferable(transferable_nonburnable_pool_id)
|
|
)
|
|
self.assertFalse(
|
|
self.diamond_terminus.pool_is_burnable(transferable_nonburnable_pool_id)
|
|
)
|
|
self.assertEqual(
|
|
self.diamond_terminus.uri(transferable_nonburnable_pool_id),
|
|
transferable_nonburnable_pool_uri,
|
|
)
|
|
|
|
transferable_burnable_pool_uri = "https://example.com/tt.json"
|
|
self.diamond_terminus.create_pool_v2(
|
|
10, True, True, transferable_burnable_pool_uri, {"from": accounts[1]}
|
|
)
|
|
transferable_burnable_pool_id = self.diamond_terminus.total_pools()
|
|
self.assertTrue(
|
|
self.diamond_terminus.pool_is_transferable(transferable_burnable_pool_id)
|
|
)
|
|
self.assertTrue(
|
|
self.diamond_terminus.pool_is_burnable(transferable_burnable_pool_id)
|
|
)
|
|
self.assertEqual(
|
|
self.diamond_terminus.uri(transferable_burnable_pool_id),
|
|
transferable_burnable_pool_uri,
|
|
)
|
|
|
|
nontransferable_burnable_pool_uri = "https://example.com/ft.json"
|
|
self.diamond_terminus.create_pool_v2(
|
|
10, False, True, nontransferable_burnable_pool_uri, {"from": accounts[1]}
|
|
)
|
|
nontransferable_burnable_pool_id = self.diamond_terminus.total_pools()
|
|
self.assertFalse(
|
|
self.diamond_terminus.pool_is_transferable(nontransferable_burnable_pool_id)
|
|
)
|
|
self.assertTrue(
|
|
self.diamond_terminus.pool_is_burnable(nontransferable_burnable_pool_id)
|
|
)
|
|
self.assertEqual(
|
|
self.diamond_terminus.uri(nontransferable_burnable_pool_id),
|
|
nontransferable_burnable_pool_uri,
|
|
)
|
|
|
|
def test_pool_state_setters(self):
|
|
self.diamond_terminus.create_pool_v1(10, False, False, {"from": accounts[1]})
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
self.assertEqual(
|
|
self.diamond_terminus.terminus_pool_controller(pool_id), accounts[1].address
|
|
)
|
|
|
|
self.assertFalse(self.diamond_terminus.pool_is_transferable(pool_id))
|
|
self.assertFalse(self.diamond_terminus.pool_is_burnable(pool_id))
|
|
|
|
self.diamond_terminus.set_pool_transferable(
|
|
pool_id, True, {"from": accounts[1]}
|
|
)
|
|
self.assertTrue(self.diamond_terminus.pool_is_transferable(pool_id))
|
|
self.assertFalse(self.diamond_terminus.pool_is_burnable(pool_id))
|
|
|
|
self.diamond_terminus.set_pool_burnable(pool_id, True, {"from": accounts[1]})
|
|
self.assertTrue(self.diamond_terminus.pool_is_transferable(pool_id))
|
|
self.assertTrue(self.diamond_terminus.pool_is_burnable(pool_id))
|
|
|
|
self.diamond_terminus.set_pool_transferable(
|
|
pool_id, False, {"from": accounts[1]}
|
|
)
|
|
self.assertFalse(self.diamond_terminus.pool_is_transferable(pool_id))
|
|
self.assertTrue(self.diamond_terminus.pool_is_burnable(pool_id))
|
|
|
|
self.diamond_terminus.set_pool_burnable(pool_id, False, {"from": accounts[1]})
|
|
self.assertFalse(self.diamond_terminus.pool_is_transferable(pool_id))
|
|
self.assertFalse(self.diamond_terminus.pool_is_burnable(pool_id))
|
|
|
|
def test_pool_state_setters_do_not_allow_noncontroller_to_set_parameters(self):
|
|
self.diamond_terminus.create_pool_v1(10, False, False, {"from": accounts[1]})
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
self.assertEqual(
|
|
self.diamond_terminus.terminus_pool_controller(pool_id), accounts[1].address
|
|
)
|
|
|
|
self.assertFalse(self.diamond_terminus.pool_is_transferable(pool_id))
|
|
self.assertFalse(self.diamond_terminus.pool_is_burnable(pool_id))
|
|
|
|
with self.assertRaises(VirtualMachineError):
|
|
self.diamond_terminus.set_pool_transferable(
|
|
pool_id, True, {"from": accounts[2]}
|
|
)
|
|
|
|
with self.assertRaises(VirtualMachineError):
|
|
self.diamond_terminus.set_pool_burnable(
|
|
pool_id, True, {"from": accounts[2]}
|
|
)
|
|
|
|
self.assertFalse(self.diamond_terminus.pool_is_transferable(pool_id))
|
|
self.assertFalse(self.diamond_terminus.pool_is_burnable(pool_id))
|
|
|
|
def test_burnable_pool_burn_as_token_owner(self):
|
|
self.diamond_terminus.create_pool_v1(10, True, True, {"from": accounts[1]})
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
self.diamond_terminus.mint(accounts[2], pool_id, 1, b"", {"from": accounts[1]})
|
|
|
|
initial_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
initial_owner_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
self.diamond_terminus.burn(
|
|
accounts[2].address, pool_id, 1, {"from": accounts[2]}
|
|
)
|
|
|
|
final_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
final_owner_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
self.assertEqual(final_pool_supply, initial_pool_supply - 1)
|
|
self.assertEqual(final_owner_balance, initial_owner_balance - 1)
|
|
|
|
def test_burnable_pool_burn_as_pool_controller(self):
|
|
self.diamond_terminus.create_pool_v1(10, True, True, {"from": accounts[1]})
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
self.diamond_terminus.mint(accounts[2], pool_id, 1, b"", {"from": accounts[1]})
|
|
|
|
initial_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
initial_owner_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
self.diamond_terminus.burn(
|
|
accounts[2].address, pool_id, 1, {"from": accounts[1]}
|
|
)
|
|
|
|
final_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
final_owner_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
self.assertEqual(final_pool_supply, initial_pool_supply - 1)
|
|
self.assertEqual(final_owner_balance, initial_owner_balance - 1)
|
|
|
|
def test_burnable_pool_burn_as_authorized_third_party(self):
|
|
self.diamond_terminus.create_pool_v1(10, True, True, {"from": accounts[1]})
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
self.diamond_terminus.mint(accounts[2], pool_id, 1, b"", {"from": accounts[1]})
|
|
|
|
initial_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
initial_owner_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
self.diamond_terminus.approve_for_pool(
|
|
pool_id, accounts[3].address, {"from": accounts[1]}
|
|
)
|
|
self.diamond_terminus.burn(
|
|
accounts[2].address, pool_id, 1, {"from": accounts[3]}
|
|
)
|
|
|
|
final_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
final_owner_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
self.assertEqual(final_pool_supply, initial_pool_supply - 1)
|
|
self.assertEqual(final_owner_balance, initial_owner_balance - 1)
|
|
|
|
def test_burnable_pool_burn_as_unauthorized_third_party(self):
|
|
self.diamond_terminus.create_pool_v1(10, True, True, {"from": accounts[1]})
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
self.diamond_terminus.mint(accounts[2], pool_id, 1, b"", {"from": accounts[1]})
|
|
|
|
initial_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
initial_owner_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
with self.assertRaises(Exception):
|
|
self.diamond_terminus.burn(
|
|
accounts[2].address, pool_id, 1, {"from": accounts[3]}
|
|
)
|
|
|
|
final_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
final_owner_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
self.assertEqual(final_pool_supply, initial_pool_supply)
|
|
self.assertEqual(final_owner_balance, initial_owner_balance)
|
|
|
|
def test_nontransferable_pool_safe_transfer_from(self):
|
|
self.diamond_terminus.create_pool_v1(10, False, False, {"from": accounts[1]})
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
self.diamond_terminus.mint(accounts[2], pool_id, 1, b"", {"from": accounts[1]})
|
|
|
|
initial_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
initial_owner_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
with self.assertRaises(Exception):
|
|
self.diamond_terminus.safe_transfer_from(
|
|
accounts[2].address,
|
|
accounts[3].address,
|
|
pool_id,
|
|
1,
|
|
b"",
|
|
{"from": accounts[2]},
|
|
)
|
|
|
|
final_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
final_owner_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
self.assertEqual(final_pool_supply, initial_pool_supply)
|
|
self.assertEqual(final_owner_balance, initial_owner_balance)
|
|
|
|
def test_nontransferable_pool_safe_batch_transfer_from(self):
|
|
self.diamond_terminus.create_pool_v1(10, False, False, {"from": accounts[1]})
|
|
pool_id = self.diamond_terminus.total_pools()
|
|
self.diamond_terminus.mint(accounts[2], pool_id, 1, b"", {"from": accounts[1]})
|
|
|
|
initial_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
initial_owner_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
with self.assertRaises(Exception):
|
|
self.diamond_terminus.safe_batch_transfer_from(
|
|
accounts[2].address,
|
|
accounts[3].address,
|
|
[pool_id],
|
|
[1],
|
|
b"",
|
|
{"from": accounts[2]},
|
|
)
|
|
|
|
final_pool_supply = self.diamond_terminus.terminus_pool_supply(pool_id)
|
|
final_owner_balance = self.diamond_terminus.balance_of(
|
|
accounts[2].address, pool_id
|
|
)
|
|
self.assertEqual(final_pool_supply, initial_pool_supply)
|
|
self.assertEqual(final_owner_balance, initial_owner_balance)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|