def test_spot_price(network, config, web3, T1, T2, alice_wallet): """Test calculation of prices on spot.""" (price, price_sans_fee) = _spotPrices(network, config, web3, T1, T2, alice_wallet, 1, 1, 1, 1) assert price_sans_fee == to_wei(1) assert price == to_wei("1.000001000001000001") (price, price_sans_fee) = _spotPrices(network, config, web3, T1, T2, alice_wallet, 90, 10, 9, 1) assert price_sans_fee == to_wei(1) assert price == to_wei("1.000001000001000001") (price, price_sans_fee) = _spotPrices(network, config, web3, T1, T2, alice_wallet, 1, 2, 1, 1) assert price_sans_fee == to_wei("0.5") assert price == to_wei("0.500000500000500001") (price, price_sans_fee) = _spotPrices(network, config, web3, T1, T2, alice_wallet, 2, 1, 1, 1) assert price_sans_fee == to_wei(2) assert price == to_wei("2.000002000002000002") (price, price_sans_fee) = _spotPrices(network, config, web3, T1, T2, alice_wallet, 9, 10, 9, 1) assert price_sans_fee == to_wei("0.1") assert price == to_wei("0.100000100000100000")
def test_ERC20( network, web3, alice_wallet, alice_address, bob_wallet, bob_address, OCEAN_address ): """Tests an OCEAN token approval, allowance and transfers.""" token = BToken(web3, OCEAN_address) token.approve(bob_address, 0, from_wallet=alice_wallet) # generating ERC20 Tokens, so the symbol is irrelevant assert token.symbol() == "DTT" assert token.decimals() == 18 assert token.balanceOf(alice_address) > to_wei(10) assert token.balanceOf(bob_address) > to_wei(10) assert token.allowance(alice_address, bob_address) == 0 token.approve(bob_address, to_wei(1), from_wallet=alice_wallet) assert token.allowance(alice_address, bob_address) == to_wei(1) # alice sends all her OCEAN to Bob, then Bob sends it back alice_OCEAN = token.balanceOf(alice_address) bob_OCEAN = token.balanceOf(bob_address) token.transfer(bob_address, alice_OCEAN, from_wallet=alice_wallet) assert token.balanceOf(alice_address) == 0 assert token.balanceOf(bob_address) == (alice_OCEAN + bob_OCEAN) token.transfer(alice_address, alice_OCEAN, from_wallet=bob_wallet) assert token.balanceOf(alice_address) == alice_OCEAN assert token.balanceOf(bob_address) == bob_OCEAN
def test_ocean_balancer_helpers(OCEAN_address, alice_ocean, alice_wallet, alice_address, bob_ocean): DT = alice_ocean.create_data_token("DataToken1", "DT1", alice_wallet, blob="foo") DT.mint(alice_address, to_wei(1000), alice_wallet) with pytest.raises(Exception): # not enough liquidity pool = alice_ocean.pool.create(DT.address, data_token_amount=0, OCEAN_amount=0, from_wallet=alice_wallet) pool = alice_ocean.pool.create( DT.address, data_token_amount=to_wei(90), OCEAN_amount=to_wei(10), from_wallet=alice_wallet, ) pool_address = pool.address assert alice_ocean.pool.ocean_address == OCEAN_address assert alice_ocean.pool.get_token_address(pool.address) == DT.address assert alice_ocean.pool.get(alice_ocean.web3, pool_address).address == pool_address assert bob_ocean.pool.get(alice_ocean.web3, pool_address).address == pool_address DT_price = bob_ocean.pool.get_token_price(pool_address) assert DT_price > 0
def sell_data( ocean, private_key, data_token, amount, fixed_price=True, ): """Sell a dataset on the Ocean market. Mint the datatokens. In the create() step below, ganache OCEAN is needed. Finally, Approve the datatoken for sale. Args: ocean (): wallet (): data_token (): amount (): fixed_price (bool): Whether or not to sell the data at a fixed price. Returns: (bool): Returns True if successful. """ wallet = Wallet(ocean.web3, private_key, ocean.config.block_confirmations) data_token.mint(wallet.address, to_wei(amount), wallet) OCEAN_token = BToken(ocean.web3, ocean.OCEAN_address) assert OCEAN_token.balanceOf(wallet.address) > 0, 'need OCEAN' data_token.approve(ocean.exchange._exchange_address, to_wei(amount), wallet) return True
def buy_data( ocean, private_key, token_address, seller_wallet, min_amount, max_amount, ): """Buy a dataset on the market. Define wallet, verify that there is enough ganache ETH and OCEAN. Create an exchange_id for a new exchange. Args: ocean (): private_key (str): token_address (str): seller_wallet (Wallet): min_amount (float): max_amount (float): Returns: """ wallet = Wallet(ocean.web3, private_key, ocean.config.block_confirmations) assert ocean.web3.eth.get_balance(wallet.address) > 0, 'need ganache ETH' OCEAN_token = BToken(ocean.web3, ocean.OCEAN_address) assert OCEAN_token.balanceOf(wallet.address) > 0, 'need ganache OCEAN' exchange_id = ocean.exchange.create(token_address, to_wei(min_amount), seller_wallet) tx_result = ocean.exchange.buy_at_fixed_rate(to_wei(min_amount), wallet, to_wei(max_amount), exchange_id, token_address, seller_wallet.address) assert tx_result, 'failed buying data tokens at fixed rate.'
def test_transfer_event(alice_ocean, alice_wallet, alice_address, bob_wallet, bob_address): """Tests that a transfer event is registered.""" token = alice_ocean.create_data_token("DataToken1", "DT1", from_wallet=alice_wallet, blob="foo_blob") block_confirmations = alice_ocean.config.block_confirmations.value block = alice_ocean.web3.eth.block_number transfer_event = token.get_transfer_event( block - (block_confirmations + 1), alice_address, bob_address) # different way of retrieving transfer_events = token.get_event_logs("Transfer", None, block, block) assert transfer_events == () token.mint(alice_address, to_wei(100), from_wallet=alice_wallet) token.approve(bob_address, to_wei(1), from_wallet=alice_wallet) token.transfer(bob_address, to_wei(5), from_wallet=alice_wallet) block = alice_ocean.web3.eth.block_number transfer_event = token.get_transfer_event( block - (block_confirmations + 1), alice_address, bob_address) assert transfer_event["args"]["from"] == alice_address assert transfer_event["args"]["to"] == bob_address # same transfer event, different way of retrieving transfer_event = token.get_event_logs("Transfer", None, block - (block_confirmations + 1), block)[0] assert transfer_event["args"]["from"] == alice_address assert transfer_event["args"]["to"] == bob_address
def make_info(name, private_key_name): # assume that this account has ETH with gas. class _Info: pass info = _Info() web3 = get_web3() config = ExampleConfig.get_config() info.web3 = web3 info.private_key = os.environ.get(private_key_name) info.wallet = Wallet( web3, private_key=info.private_key, block_confirmations=config.block_confirmations, transaction_timeout=config.transaction_timeout, ) info.address = info.wallet.address wallet = get_ganache_wallet() if wallet: assert get_ether_balance( web3, wallet.address) >= to_wei(4), "Ether balance less than 4." if get_ether_balance(web3, info.address) < to_wei(2): send_ether(wallet, info.address, to_wei(4)) from ocean_lib.ocean.ocean import Ocean info.ocean = Ocean(config) info.T1 = _deployAndMintToken(web3, "TOK1", info.address) info.T2 = _deployAndMintToken(web3, "TOK2", info.address) return info
def test_calculateFee(alice_ocean, alice_wallet): """Tests the DataToken calculateFee method.""" token = alice_ocean.create_data_token("DataToken1", "DT1", from_wallet=alice_wallet, blob="foo_blob") fee = token.calculateFee(to_wei(100), DataToken.OPF_FEE_PER_TOKEN) assert fee == to_wei("0.1")
def test_get_token_minter(web3, alice_wallet, dtfactory_address, alice_address): """Tests proper retrieval of token minter from DTFactory.""" dtfactory = DTFactory(web3, dtfactory_address) dt_address = dtfactory.createToken( "foo_blob", "DT1", "DT1", to_wei(1000), from_wallet=alice_wallet ) dt = DataToken(web3, dtfactory.get_token_address(dt_address)) dt.mint(alice_address, to_wei(10), from_wallet=alice_wallet) assert dtfactory.get_token_minter(dt.address) == alice_address
def test_setSwapFee_fails(network, config, web3, alice_wallet, alice_address, bob_wallet, bob_address): """Tests that someone who isn't a controller can not set the swap fee.""" factory = BFactory(web3, get_bfactory_address(config.address_file, network)) pool_address = factory.newBPool(alice_wallet) pool = BPool(web3, pool_address) with pytest.raises(Exception): pool.setSwapFee(to_wei("0.011"), from_wallet=bob_wallet) # not ok, bob isn't controller pool.setController(bob_address, from_wallet=alice_wallet) pool.setSwapFee(to_wei("0.011"), from_wallet=bob_wallet) # ok now
def test_calculate_token_holders(alice_ocean, alice_wallet, alice_address): """Test the calculate_token_holders methods.""" token = alice_ocean.create_data_token("DataToken1", "DT1", from_wallet=alice_wallet, blob="foo_blob") token.mint(alice_address, to_wei(100), from_wallet=alice_wallet) block = alice_ocean.web3.eth.block_number block_confirmations = alice_ocean.config.block_confirmations.value token_holders = token.calculate_token_holders( block - (block_confirmations + 1), block, to_wei(1)) assert len(token_holders) == 1
def test_calcSpotPrice(network, config, web3, T1, T2, alice_address, alice_wallet): """Tests pricing with calcSpotPrice.""" pool = _deployBPool(web3, config.address_file, network, alice_wallet) x = pool.calcSpotPrice( tokenBalanceIn=to_wei(10), tokenWeightIn=to_wei(1), tokenBalanceOut=to_wei(11), tokenWeightOut=to_wei(1), swapFee=0, ) assert x == to_wei("0.909090909090909091")
def test_setMinter(alice_ocean, alice_wallet, alice_address, bob_wallet, bob_address): """Tests that a minter can be assigned for a Datatoken.""" ocean = alice_ocean token = ocean.create_data_token("DataToken1", "DT1", from_wallet=alice_wallet, blob="foo_blob") # alice is the minter token.mint(alice_address, to_wei(10), from_wallet=alice_wallet) token.mint(bob_address, to_wei(10), from_wallet=alice_wallet) with pytest.raises(Exception): token.mint(alice_address, to_wei(10), from_wallet=bob_wallet) # switch minter to bob token.proposeMinter(bob_address, from_wallet=alice_wallet) time.sleep(5) token.approveMinter(from_wallet=bob_wallet) token.mint(alice_address, to_wei(10), from_wallet=bob_wallet) with pytest.raises(Exception): token.mint(alice_address, to_wei(10), from_wallet=alice_wallet) with pytest.raises(Exception): token.mint(bob_address, to_wei(10), from_wallet=alice_wallet) # switch minter back to alice token.proposeMinter(alice_address, from_wallet=bob_wallet) time.sleep(5) token.approveMinter(from_wallet=alice_wallet) token.mint(alice_address, to_wei(10), from_wallet=alice_wallet) with pytest.raises(Exception): token.mint(alice_address, to_wei(10), from_wallet=bob_wallet)
def test_rebind_more_tokens(network, config, web3, T1, T2, alice_wallet): """Tests that we can rebind more tokens on a pool.""" pool = _createPoolWith2Tokens(network, config, web3, T1, T2, alice_wallet, 90, 10, 9, 1) # insufficient allowance with pytest.raises(Exception): pool.rebind(T1.address, to_wei(120), to_wei(9), from_wallet=alice_wallet) # sufficient allowance T1.approve(pool.address, to_wei(30), from_wallet=alice_wallet) pool.rebind(T1.address, to_wei(120), to_wei(9), from_wallet=alice_wallet)
def verify_supply(mint_amount=to_wei(50)): supply = dtc.contract.caller.totalSupply() if supply <= 0: _tx_id = dtc.mint(receiver_address, mint_amount, minter_wallet) dtc.get_tx_receipt(dtc.web3, _tx_id) supply = dtc.contract.caller.totalSupply() return supply
def test_status_functions(alice_ocean, alice_wallet, alice_address): """Tests various status functions of the DataToken class.""" token = alice_ocean.create_data_token("DataToken1", "DT1", from_wallet=alice_wallet, blob="foo_blob") token.mint(alice_address, to_wei(100), from_wallet=alice_wallet) assert token.balanceOf(alice_address) == to_wei(100) assert token.totalSupply() == 100_000_000_000_000_000_000 assert token.cap() == 1_000_000_000_000_000_000_000 assert token.datatoken_name() == "DataToken1" assert token.minter() == alice_address assert token.isMinter(alice_address) with pytest.raises(ValueError): token.get_event_signature("not a registered event")
def test_chain_id_send_ether(alice_wallet, bob_address): """Tests if the chainId has the right value for send ether transactions.""" receipt = send_ether(alice_wallet, bob_address, to_wei(1)) assert receipt, "Send ether was unsuccessful." tx = alice_wallet.web3.eth.get_transaction(receipt["transactionHash"]) # Formula: v = CHAIN_ID * 2 + 35 or v = CHAIN_ID * 2 + 36 chain_ids = [(tx["v"] - 35) / 2, (tx["v"] - 36) / 2] result = True if alice_wallet.web3.eth.chain_id in chain_ids else False assert result, "The chain ID is not the right one."
def mint_fake_OCEAN(config: Config) -> None: """ Does the following: 1. Mints tokens 2. Distributes tokens to TEST_PRIVATE_KEY1 and TEST_PRIVATE_KEY2 """ addresses_file = config.address_file with open(addresses_file) as f: network_addresses = json.load(f) web3 = get_web3(config.network_url) deployer_wallet = Wallet( web3, private_key=os.environ.get("FACTORY_DEPLOYER_PRIVATE_KEY"), block_confirmations=config.block_confirmations, transaction_timeout=config.transaction_timeout, ) OCEAN_token = DataToken(web3, address=network_addresses["development"]["Ocean"]) amt_distribute = to_wei(1000) OCEAN_token.mint( deployer_wallet.address, 2 * amt_distribute, from_wallet=deployer_wallet ) for key_label in ["TEST_PRIVATE_KEY1", "TEST_PRIVATE_KEY2"]: key = os.environ.get(key_label) if not key: continue w = Wallet( web3, private_key=key, block_confirmations=config.block_confirmations, transaction_timeout=config.transaction_timeout, ) if OCEAN_token.balanceOf(w.address) < amt_distribute: OCEAN_token.transfer(w.address, amt_distribute, from_wallet=deployer_wallet) if get_ether_balance(web3, w.address) < to_wei(2): send_ether(deployer_wallet, w.address, to_wei(4))
def test_unbind(network, config, web3, T1, T2, alice_wallet): """Tests that a pool can be unbound.""" pool = _createPoolWith2Tokens(network, config, web3, T1, T2, alice_wallet, 1, 1, 1, 1) pool.unbind(T1.address, from_wallet=alice_wallet) assert pool.getNumTokens() == 1 assert pool.getCurrentTokens() == [T2.address] assert pool.getBalance(T2.address) == to_wei(1)
def get_order_requirements( did: str, service_endpoint: str, consumer_address: str, service_id: Union[str, int], service_type: str, token_address: str, userdata: Optional[Dict] = None, ) -> Optional[OrderRequirements]: """ :param did: :param service_endpoint: :param consumer_address: hex str the ethereum account address of the consumer :param service_id: :param service_type: :param token_address: :return: OrderRequirements instance -- named tuple (amount, data_token_address, receiver_address, nonce), """ req = PreparedRequest() params = { "documentId": did, "serviceId": service_id, "serviceType": service_type, "dataToken": token_address, "consumerAddress": consumer_address, } if userdata: userdata = json.dumps(userdata) params["userdata"] = userdata req.prepare_url(service_endpoint, params) initialize_url = req.url logger.info(f"invoke the initialize endpoint with this url: {initialize_url}") response = DataServiceProvider._http_method("get", initialize_url) # The returned json should contain information about the required number of tokens # to consume `service_id`. If service is not available there will be an error or # the returned json is empty. if response.status_code != 200: return None order = dict(response.json()) return OrderRequirements( to_wei( Decimal(order["numTokens"]) ), # comes as float, needs to be converted order["dataToken"], order["to"], int(order["nonce"]), order.get("computeAddress"), )
def test_data_token_creation(web3, alice_wallet, dtfactory_address): """Tests that a data token can be created using a DTFactory object.""" dtfactory = DTFactory(web3, dtfactory_address) dt_address = dtfactory.createToken( "foo_blob", "DT1", "DT1", to_wei(1000), from_wallet=alice_wallet ) dt = DataToken(web3, dtfactory.get_token_address(dt_address)) assert isinstance(dt, DataToken) assert dt.blob() == "foo_blob" assert dtfactory.verify_data_token(dt.address)
def _createPoolWith2Tokens( network: str, config: Config, web3: Web3, T1: BToken, T2: BToken, wallet: Wallet, bal1: Union[Decimal, str, int], bal2: Union[Decimal, str, int], w1: Union[Decimal, str, int], w2: Union[Decimal, str, int], ): """Helper function to create a basic pool containing 2 tokens.""" pool = _deployBPool(web3, config.address_file, network, wallet) T1.get_tx_receipt( web3, T1.approve(pool.address, to_wei(bal1), from_wallet=wallet)) T2.get_tx_receipt( web3, T2.approve(pool.address, to_wei(bal2), from_wallet=wallet)) if pool.isBound(T1.address): pool.unbind(T1.address, wallet) if pool.isBound(T2.address): pool.unbind(T2.address, wallet) pool.bind(T1.address, to_wei(bal1), to_wei(w1), from_wallet=wallet) pool.bind(T2.address, to_wei(bal2), to_wei(w2), from_wallet=wallet) return pool
def test_verify_order_tx(alice_address, bob_address, alice_ocean, alice_wallet): """Tests verify_order_tx function.""" token = alice_ocean.create_data_token("DataToken1", "DT1", from_wallet=alice_wallet, blob="foo_blob") token.mint(alice_address, to_wei(100), from_wallet=alice_wallet) token.approve(bob_address, to_wei(1), from_wallet=alice_wallet) transfer_tx_id = token.transfer(bob_address, to_wei(5), from_wallet=alice_wallet) with pytest.raises(TimeExhausted): with patch("ocean_lib.models.data_token.DataToken.get_tx_receipt" ) as mock: # dummy tx id which is not found in the chain # catches TimeExhausted exception from web3 mock.side_effect = TimeExhausted() token.verify_order_tx("0x0", "some_did", "some_index", "some_amount", alice_address) transfer_tx_id = token.transfer(bob_address, to_wei(5), from_wallet=alice_wallet) with pytest.raises(AssertionError): # tx id is from transfer, not order token.verify_order_tx(transfer_tx_id, "some_did", "some_index", "some_amount", alice_address) sample_ddo_path = get_resource_path("ddo", "ddo_sa_sample.json") asset = V3Asset(json_filename=sample_ddo_path) order_tx_id = token.startOrder(alice_address, to_wei(1), 1, ZERO_ADDRESS, alice_wallet) with pytest.raises(AssertionError): # the wrong asset did, this is a sample token.verify_order_tx(order_tx_id, asset.did, "some_index", "some_amount", alice_address)
def test_finalize(network, config, web3, T1, T2, alice_address, alice_wallet): """Tests that a pool containing tokens can be finalized.""" pool = _createPoolWith2Tokens(network, config, web3, T1, T2, alice_wallet, 90, 10, 9, 1) assert not pool.isPublicSwap() assert not pool.isFinalized() assert pool.totalSupply() == 0 assert pool.balanceOf(alice_address) == 0 assert pool.allowance(alice_address, pool.address) == 0 pool.finalize(from_wallet=alice_wallet) assert str(pool) != "" assert pool.isPublicSwap() assert pool.isFinalized() assert pool.totalSupply() == to_wei(100) assert pool.balanceOf(alice_address) == to_wei(100) assert pool.allowance(alice_address, pool.address) == 0 assert pool.getFinalTokens() == [T1.address, T2.address] assert pool.getCurrentTokens() == [T1.address, T2.address]
def _deployAndMintToken(web3: Web3, symbol: str, to_address: str) -> btoken.BToken: wallet = get_factory_deployer_wallet(_NETWORK) dt_address = DataToken.deploy( web3, wallet, "Template Contract", "TEMPLATE", wallet.address, to_wei(1000), DTFactory.FIRST_BLOB, to_address, ) dt_factory = DTFactory( web3, DTFactory.deploy(web3, wallet, dt_address, to_address)) token_address = dt_factory.get_token_address( dt_factory.createToken(symbol, symbol, symbol, DataToken.DEFAULT_CAP, wallet)) token = DataToken(web3, token_address) token.mint(to_address, to_wei(1000), wallet) return btoken.BToken(web3, token.address)
def setup_all(request, config, web3): # a test can skip setup_all() via decorator "@pytest.mark.nosetup_all" if "nosetup_all" in request.keywords: return wallet = get_ganache_wallet() if not wallet: return addresses_file = config.address_file if not os.path.exists(addresses_file): return with open(addresses_file) as f: network_addresses = json.load(f) print(f"sender: {wallet.key}, {wallet.address}, {wallet.keys_str()}") print( f"sender balance: {from_wei(get_ether_balance(web3, wallet.address))}") assert get_ether_balance( web3, wallet.address) >= to_wei(10), "Ether balance less than 10." from ocean_lib.models.data_token import DataToken OCEAN_token = DataToken(web3, address=network_addresses["development"]["Ocean"]) amt_distribute = to_wei(1000) for w in (get_publisher_wallet(), get_consumer_wallet()): if get_ether_balance(web3, w.address) < to_wei(2): send_ether(wallet, w.address, to_wei(4)) if OCEAN_token.balanceOf(w.address) < to_wei(100): OCEAN_token.mint(wallet.address, amt_distribute, from_wallet=wallet) OCEAN_token.transfer(w.address, amt_distribute, from_wallet=wallet)
def test_joinSwapExternAmountIn(network, config, web3, T1, T2, alice_wallet, alice_address): """Tests adding an external amount inside a pool. When the pool is not public, assert that an Exception is thrown. When the pool is public, assert that the swap is made and the correct balance remains. """ init_T1balance = T1.balanceOf(alice_address) T2balance = T2.balanceOf(alice_address) pool = _createPoolWith2Tokens(network, config, web3, T1, T2, alice_wallet, 90, 10, 9, 1) T1.approve(pool.address, to_wei(100), from_wallet=alice_wallet) # pool's not public with pytest.raises(Exception): pool.swapExactAmountOut( tokenIn_address=T1.address, maxAmountIn=to_wei(100), tokenOut_address=T2.address, tokenAmountOut=to_wei(10), maxPrice=HUGEINT, from_wallet=alice_wallet, ) # pool's public pool.setPublicSwap(True, from_wallet=alice_wallet) pool.swapExactAmountOut( tokenIn_address=T1.address, maxAmountIn=to_wei(100), tokenOut_address=T2.address, tokenAmountOut=to_wei(1), maxPrice=HUGEINT, from_wallet=alice_wallet, ) new_balance = init_T1balance - to_wei("91.055") assert (new_balance - to_wei("0.005") <= T1.balanceOf(alice_address) <= new_balance + to_wei("0.005")) assert T2.balanceOf(alice_address) == T2balance - to_wei(9) block = web3.eth.block_number block_confirmations = config.block_confirmations.value swap_log = pool.get_swap_logs(block - (block_confirmations + 1), block)[0] assert swap_log["args"]["tokenIn"] == T1.address
def test_verify_transfer_tx(alice_address, bob_address, alice_ocean, alice_wallet): """Tests verify_transfer_tx function.""" token = alice_ocean.create_data_token("DataToken1", "DT1", from_wallet=alice_wallet, blob="foo_blob") with pytest.raises(TransactionNotFound): # dummy tx id which is not found in the chain # need to catch TransactionNotFound exception from web3 token.verify_transfer_tx("0x0", alice_address, bob_address) # an actual transfer does happen token.mint(alice_address, to_wei(100), from_wallet=alice_wallet) token.approve(bob_address, to_wei(1), from_wallet=alice_wallet) tx_id = token.transfer(bob_address, to_wei(5), from_wallet=alice_wallet) assert len(token.verify_transfer_tx(tx_id, alice_address, bob_address)) == 2 with pytest.raises(AssertionError): token.verify_transfer_tx(tx_id, "0x0", bob_address)
def test_gulp(network, config, web3, T1, alice_wallet): """Test pool gulp.""" pool = _deployBPool(web3, config.address_file, network, alice_wallet) # bind T1 to the pool, with a balance of 2.0 T1.approve(pool.address, to_wei(50), from_wallet=alice_wallet) pool.bind(T1.address, to_wei(2), to_wei(50), from_wallet=alice_wallet) # T1 is now pool's (a) ERC20 balance (b) _records[token].balance assert T1.balanceOf(pool.address) == to_wei(2) # ERC20 balance assert pool.getBalance(T1.address) == to_wei(2) # records[] # but then some joker accidentally sends 5.0 tokens to the pool's address # rather than binding / rebinding. So it's in ERC20 bal but not records[] T1.transfer(pool.address, to_wei(5), from_wallet=alice_wallet) assert T1.balanceOf(pool.address) == to_wei(2 + 5) # ERC20 bal assert pool.getBalance(T1.address) == to_wei(2) # records[] # so, 'gulp' gets the pool to absorb the tokens into its balances. # i.e. to update _records[token].balance to be in sync with ERC20 balance pool.gulp(T1.address, from_wallet=alice_wallet) assert T1.balanceOf(pool.address) == to_wei(2 + 5) # ERC20 assert pool.getBalance(T1.address) == to_wei(2 + 5) # records[]
def test_transfer_event_filter(alice_ocean, alice_wallet, alice_address, bob_address): token = alice_ocean.create_data_token("DataToken1", "DT1", from_wallet=alice_wallet, blob="foo_blob") token.mint(alice_address, to_wei(100), from_wallet=alice_wallet) token.approve(bob_address, to_wei(1), from_wallet=alice_wallet) token.transfer(bob_address, to_wei(5), from_wallet=alice_wallet) block = alice_ocean.web3.eth.block_number event_filter = EventFilter(token.events.Transfer(), from_block=block, to_block=block) assert event_filter.filter_id, "Event filter ID is None." event_filter.uninstall() event_filter.recreate_filter() assert (event_filter.get_new_entries() == [] ), "There are new entries for EventFilter."