def buy_at_fixed_rate( self, amount: float, wallet: Wallet, max_OCEAN_amount: float, exchange_id: str = "", data_token: str = "", exchange_owner: str = "", ) -> bool: exchange, exchange_id = self.get_exchange_id_fallback_dt_and_owner( exchange_id, exchange_owner, data_token) amount_base = to_base_18(amount) max_OCEAN_amount_base = to_base_18(max_OCEAN_amount) # Figure out the amount of ocean tokens to approve before triggering the exchange function to do the swap ocean_amount_base = exchange.get_base_token_quote( exchange_id, amount_base) if ocean_amount_base > max_OCEAN_amount_base: raise ValidationError( f"Buying {amount} datatokens requires {from_base_18(ocean_amount_base)} OCEAN " f"tokens which exceeds the max_OCEAN_amount {max_OCEAN_amount}." ) ocean_token = DataToken(self.ocean_address) ocean_token.get_tx_receipt( ocean_token.approve(self._exchange_address, ocean_amount_base, wallet)) tx_id = exchange.buy_data_token(exchange_id, data_token_amount=amount_base, from_wallet=wallet) return bool(exchange.get_tx_receipt(tx_id).status)
def test_ERC20(alice_ocean, alice_wallet, alice_address, bob_wallet, bob_address): """Tests DataToken minting, allowance and transfer.""" token = alice_ocean.create_data_token( "DataToken1", "DT1", from_wallet=alice_wallet, blob="foo_blob" ) assert token.symbol()[:2] == "DT" assert token.decimals() == 18 assert token.balanceOf(alice_address) == 0 token.mint(alice_address, to_base_18(100.0), from_wallet=alice_wallet) assert from_base_18(token.balanceOf(alice_address)) == 100.0 assert token.allowance(alice_address, bob_address) == 0 token.approve(bob_address, to_base_18(1.0), from_wallet=alice_wallet) assert token.allowance(alice_address, bob_address) == int(1e18) token.transfer(bob_address, to_base_18(5.0), from_wallet=alice_wallet) assert from_base_18(token.balanceOf(alice_address)) == 95.0 assert from_base_18(token.balanceOf(bob_address)) == 5.0 token.transfer(alice_address, to_base_18(3.0), from_wallet=bob_wallet) assert from_base_18(token.balanceOf(alice_address)) == 98.0 assert from_base_18(token.balanceOf(bob_address)) == 2.0 # assert transfers were successful block = alice_ocean.web3.eth.blockNumber all_transfers = token.get_all_transfers_from_events(block - 1, block + 1, chunk=1) assert len(all_transfers[0]) == 2
def test_joinSwapExternAmountIn(network, T1, T2, alice_wallet, alice_address): init_T1balance = from_base_18(T1.balanceOf(alice_address)) T2balance = from_base_18(T2.balanceOf(alice_address)) pool = _createPoolWith2Tokens(network, T1, T2, alice_wallet, 90.0, 10.0, 9.0, 1.0) T1.approve(pool.address, to_base_18(100.0), from_wallet=alice_wallet) # pool's not public with pytest.raises(Exception): pool.swapExactAmountOut( tokenIn_address=T1.address, maxAmountIn_base=to_base_18(100.0), tokenOut_address=T2.address, tokenAmountOut_base=to_base_18(10.0), maxPrice_base=HUGEINT, from_wallet=alice_wallet, ) # pool's public pool.setPublicSwap(True, from_wallet=alice_wallet) pool.swapExactAmountOut( tokenIn_address=T1.address, maxAmountIn_base=to_base_18(100.0), tokenOut_address=T2.address, tokenAmountOut_base=to_base_18(1.0), maxPrice_base=HUGEINT, from_wallet=alice_wallet, ) new_balance = init_T1balance - 91.055 assert ( (new_balance - 0.005) <= from_base_18(T1.balanceOf(alice_address)) <= (new_balance + 0.005) ) assert from_base_18(T2.balanceOf(alice_address)) == (T2balance - 9.0)
def test_ERC20(network, alice_wallet, alice_address, bob_wallet, bob_address, OCEAN_address): """Tests an OCEAN token approval, allowance and transfers.""" token = BToken(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) > util.to_base_18(10.0) assert token.balanceOf(bob_address) > util.to_base_18(10.0) assert token.allowance(alice_address, bob_address) == 0 token.approve(bob_address, int(1e18), from_wallet=alice_wallet) assert token.allowance(alice_address, bob_address) == int(1e18) # 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 _deployAndMintToken(symbol: str, to_address: str) -> btoken.BToken: wallet = get_factory_deployer_wallet(_NETWORK) dt_address = DataToken.deploy( wallet.web3, wallet, None, "Template Contract", "TEMPLATE", wallet.address, to_base_18(1000), DTFactory.FIRST_BLOB, to_address, ) dt_factory = DTFactory( DTFactory.deploy(wallet.web3, wallet, None, dt_address, to_address) ) token_address = dt_factory.get_token_address( dt_factory.createToken( symbol, symbol, symbol, DataToken.DEFAULT_CAP_BASE, wallet ) ) token = DataToken(token_address) token.mint(to_address, to_base_18(1000), wallet) return btoken.BToken(token.address)
def buy_data_tokens(self, pool_address: str, amount: float, max_OCEAN_amount: float, from_wallet: Wallet) -> str: """ Buy data tokens from this pool, paying `max_OCEAN_amount_base` of OCEAN tokens. If total spent <= max_OCEAN_amount_base. - Caller is spending OCEAN tokens, and receiving `amount_base` DataTokens - OCEAN tokens are going into pool, DataTokens are going out of pool The transaction fails if total spent exceeds `max_OCEAN_amount_base`. :param pool_address: str address of pool contract :param amount: int number of data tokens to add to this pool in *base* :param max_OCEAN_amount: :param from_wallet: :return: str transaction id/hash """ ocean_tok = DataToken(self.ocean_address) ocean_tok.approve_tokens(pool_address, max_OCEAN_amount, from_wallet, wait=True) dtoken_address = self.get_token_address(pool_address) pool = BPool(pool_address) return pool.swapExactAmountOut( tokenIn_address=self.ocean_address, # entering pool maxAmountIn_base=to_base_18(max_OCEAN_amount), # "" tokenOut_address=dtoken_address, # leaving pool tokenAmountOut_base=to_base_18(amount), # "" maxPrice_base=2**255, # here we limit by max_num_OCEAN, not price from_wallet=from_wallet, )
def buy_at_fixed_rate(self, amount: float, wallet: Wallet, max_OCEAN_amount: float, exchange_id: str = '', data_token: str = '', exchange_owner: str = '') -> bool: exchange = self._exchange_contract() if not exchange_id: assert exchange_owner and data_token, f'exchange_owner and data_token are required when exchange_id is not given.' exchange_id = exchange.generateExchangeId(self.ocean_address, data_token, exchange_owner) amount_base = to_base_18(amount) max_OCEAN_amount_base = to_base_18(max_OCEAN_amount) # Figure out the amount of ocean tokens to approve before triggering the exchange function to do the swap ocean_amount_base = exchange.get_base_token_quote( exchange_id, amount_base) if ocean_amount_base > max_OCEAN_amount_base: raise AssertionError( f'Buying {amount} datatokens requires {from_base_18(ocean_amount_base)} OCEAN ' f'tokens which exceeds the max_OCEAN_amount {max_OCEAN_amount}.' ) ocean_token = DataToken(self.ocean_address) ocean_token.get_tx_receipt( ocean_token.approve(self._exchange_address, ocean_amount_base, wallet)) tx_id = exchange.buy_data_token(exchange_id, data_token_amount=amount_base, from_wallet=wallet) return bool(exchange.get_tx_receipt(tx_id).status)
def test_gulp(network, T1, alice_wallet): """Test pool gulp.""" pool = _deployBPool(network, alice_wallet) # bind T1 to the pool, with a balance of 2.0 T1.approve(pool.address, to_base_18(50.0), from_wallet=alice_wallet) pool.bind(T1.address, to_base_18(2.0), to_base_18(50.0), from_wallet=alice_wallet) # T1 is now pool's (a) ERC20 balance (b) _records[token].balance assert T1.balanceOf(pool.address) == to_base_18(2.0) # ERC20 balance assert pool.getBalance(T1.address) == to_base_18(2.0) # 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_base_18(5.0), from_wallet=alice_wallet) assert T1.balanceOf(pool.address) == to_base_18(2.0 + 5.0) # ERC20 bal assert pool.getBalance(T1.address) == to_base_18(2.0) # 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_base_18(2.0 + 5.0) # ERC20 assert pool.getBalance(T1.address) == to_base_18(2.0 + 5.0) # records[]
def test_ERC20(alice_ocean, alice_wallet, alice_address, bob_wallet, bob_address): """Tests DataToken minting, allowance and transfer.""" token = alice_ocean.create_data_token("DataToken1", "DT1", from_wallet=alice_wallet, blob="foo_blob") assert token.symbol()[:2] == "DT" assert token.decimals() == 18 assert token.balanceOf(alice_address) == 0 token.mint(alice_address, to_base_18(100.0), from_wallet=alice_wallet) assert from_base_18(token.balanceOf(alice_address)) == 100.0 assert token.allowance(alice_address, bob_address) == 0 token.approve(bob_address, to_base_18(1.0), from_wallet=alice_wallet) assert token.allowance(alice_address, bob_address) == int(1e18) token.transfer(bob_address, to_base_18(5.0), from_wallet=alice_wallet) assert from_base_18(token.balanceOf(alice_address)) == 95.0 assert from_base_18(token.balanceOf(bob_address)) == 5.0 token.transfer(alice_address, to_base_18(3.0), from_wallet=bob_wallet) assert from_base_18(token.balanceOf(alice_address)) == 98.0 assert from_base_18(token.balanceOf(bob_address)) == 2.0
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 = alice_ocean.web3.eth.blockNumber transfer_event = token.get_transfer_event(block, 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_base_18(100.0), from_wallet=alice_wallet) token.approve(bob_address, to_base_18(1.0), from_wallet=alice_wallet) token.transfer(bob_address, to_base_18(5.0), from_wallet=alice_wallet) block = alice_ocean.web3.eth.blockNumber transfer_event = token.get_transfer_event(block, 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)[0] assert transfer_event["args"]["from"] == alice_address assert transfer_event["args"]["to"] == bob_address
def test_ERC20(alice_ocean, alice_wallet, alice_address, bob_wallet, bob_address): token = alice_ocean.create_data_token('DataToken1', 'DT1', from_wallet=alice_wallet, blob='foo_blob') assert token.symbol()[:2] == 'DT' assert token.decimals() == 18 assert token.balanceOf(alice_address) == 0 token.mint(alice_address, to_base_18(100.0), from_wallet=alice_wallet) assert from_base_18(token.balanceOf(alice_address)) == 100.0 assert token.allowance(alice_address, bob_address) == 0 token.approve(bob_address, to_base_18(1.0), from_wallet=alice_wallet) assert token.allowance(alice_address, bob_address) == int(1e18) token.transfer(bob_address, to_base_18(5.0), from_wallet=alice_wallet) assert from_base_18(token.balanceOf(alice_address)) == 95.0 assert from_base_18(token.balanceOf(bob_address)) == 5.0 token.transfer(alice_address, to_base_18(3.0), from_wallet=bob_wallet) assert from_base_18(token.balanceOf(alice_address)) == 98.0 assert from_base_18(token.balanceOf(bob_address)) == 2.0
def test_calcSpotPrice_base(network, T1, T2, alice_address, alice_wallet): pool = _deployBPool(network, alice_wallet) x = pool.calcSpotPrice(tokenBalanceIn_base=to_base_18(10.0), tokenWeightIn_base=to_base_18(1.0), tokenBalanceOut_base=to_base_18(11.0), tokenWeightOut_base=to_base_18(1.0), swapFee_base=0) assert round(from_base_18(x), 3) == 0.909
def test_calcInGivenOut_base(network, alice_wallet): pool = _deployBPool(network, alice_wallet) x = pool.calcInGivenOut(tokenBalanceIn_base=to_base_18(10.0), tokenWeightIn_base=to_base_18(1.0), tokenBalanceOut_base=to_base_18(10.1), tokenWeightOut_base=to_base_18(1.0), tokenAmountOut_base=to_base_18(1.0), swapFee_base=0) assert round(from_base_18(x), 3) == 1.099
def test_calcSingleOutGivenPoolIn_base(network, alice_wallet): pool = _deployBPool(network, alice_wallet) x = pool.calcSingleOutGivenPoolIn(tokenBalanceOut_base=to_base_18(10.0), tokenWeightOut_base=to_base_18(1.0), poolSupply_base=to_base_18(120.0), totalWeight_base=to_base_18(2.0), poolAmountIn_base=to_base_18(10.0), swapFee_base=0) assert round(from_base_18(x), 3) == 1.597
def test_calcPoolInGivenSingleOut_base(network, alice_wallet): pool = _deployBPool(network, alice_wallet) x = pool.calcPoolInGivenSingleOut(tokenBalanceOut_base=to_base_18(1000.0), tokenWeightOut_base=to_base_18(5.0), poolSupply_base=to_base_18(100.0), totalWeight_base=to_base_18(10.0), tokenAmountOut_base=to_base_18(0.1), swapFee_base=0) assert round(from_base_18(x), 3) == 0.005
def test_get_token_minter(alice_wallet, dtfactory_address, alice_address): """Tests proper retrieval of token minter from DTFactory.""" dtfactory = DTFactory(dtfactory_address) dt_address = dtfactory.createToken( "foo_blob", "DT1", "DT1", to_base_18(1000.0), from_wallet=alice_wallet ) dt = DataToken(dtfactory.get_token_address(dt_address)) dt.mint(alice_address, to_base_18(10.0), from_wallet=alice_wallet) assert dtfactory.get_token_minter(dt.address) == alice_address
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_base_18(100.0), to_base_18(DataToken.OPF_FEE_PERCENTAGE)) assert from_base_18(fee) == 0.1
def test_setSwapFee_fails(network, alice_wallet, alice_address, bob_wallet, bob_address): factory = BFactory(get_bfactory_address(network)) pool_address = factory.newBPool(alice_wallet) pool = BPool(pool_address) with pytest.raises(Exception): pool.setSwapFee(to_base_18(0.011), from_wallet=bob_wallet) # not ok, bob isn't controller pool.setController(bob_address, from_wallet=alice_wallet) pool.setSwapFee(to_base_18(0.011), from_wallet=bob_wallet) # ok now
def test_calcPoolOutGivenSingleIn_base(network, alice_wallet): pool = _deployBPool(network, alice_wallet) x = pool.calcPoolOutGivenSingleIn( tokenBalanceIn_base=to_base_18(10.0), tokenWeightIn_base=to_base_18(1.0), poolSupply_base=to_base_18(120.0), totalWeight_base=to_base_18(2.0), tokenAmountIn_base=to_base_18(0.1), swapFee_base=0, ) assert round(from_base_18(x), 3) == 0.599
def test_calcSingleInGivenPoolOut_base(network, alice_wallet): """Tests pricing with calcSingleInGivenPoolOut.""" pool = _deployBPool(network, alice_wallet) x = pool.calcSingleInGivenPoolOut( tokenBalanceIn_base=to_base_18(10.0), tokenWeightIn_base=to_base_18(1.0), poolSupply_base=to_base_18(120.0), totalWeight_base=to_base_18(2.0), poolAmountOut_base=to_base_18(10.0), swapFee_base=0, ) assert round(from_base_18(x), 3) == 1.736
def test_calcOutGivenIn_base(network, alice_wallet): """Tests pricing with calcOutGivenIn.""" pool = _deployBPool(network, alice_wallet) x = pool.calcOutGivenIn( tokenBalanceIn_base=to_base_18(10.0), tokenWeightIn_base=to_base_18(1.0), tokenBalanceOut=to_base_18(10.1), tokenWeightOut_base=to_base_18(1.0), tokenAmountIn_base=to_base_18(1.0), swapFee_base=0, ) assert round(from_base_18(x), 3) == 0.918
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_base_18(10.0), from_wallet=alice_wallet) token.mint(bob_address, to_base_18(10.0), from_wallet=alice_wallet) with pytest.raises(Exception): token.mint(alice_address, to_base_18(10.0), 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_base_18(10.0), from_wallet=bob_wallet) with pytest.raises(Exception): token.mint(alice_address, to_base_18(10.0), from_wallet=alice_wallet) with pytest.raises(Exception): token.mint(bob_address, to_base_18(10.0), 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_base_18(10.0), from_wallet=alice_wallet) with pytest.raises(Exception): token.mint(alice_address, to_base_18(10.0), from_wallet=bob_wallet)
def test_setMinter(alice_ocean, alice_wallet, alice_address, bob_wallet, bob_address): 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_base_18(10.0), from_wallet=alice_wallet) token.mint(bob_address, to_base_18(10.0), from_wallet=alice_wallet) with pytest.raises(Exception): token.mint(alice_address, to_base_18(10.0), 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_base_18(10.0), from_wallet=bob_wallet) with pytest.raises(Exception): token.mint(alice_address, to_base_18(10.0), from_wallet=alice_wallet) with pytest.raises(Exception): token.mint(bob_address, to_base_18(10.0), 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_base_18(10.0), from_wallet=alice_wallet) with pytest.raises(Exception): token.mint(alice_address, to_base_18(10.0), from_wallet=bob_wallet)
def test_rebind_more_tokens(network, T1, T2, alice_wallet): pool = _createPoolWith2Tokens(network, T1, T2, alice_wallet, 90.0, 10.0, 9.0, 1.0) # insufficient allowance with pytest.raises(Exception): pool.rebind( T1.address, to_base_18(120.0), to_base_18(9.0), from_wallet=alice_wallet ) # sufficient allowance T1.approve(pool.address, to_base_18(30.0), from_wallet=alice_wallet) pool.rebind( T1.address, to_base_18(120.0), to_base_18(9.0), from_wallet=alice_wallet )
def test_exitswapExternAmountOut(network, T1, T2, alice_address, alice_wallet): T1balance = from_base_18(T1.balanceOf(alice_address)) pool = _createPoolWith2Tokens(network, T1, T2, alice_wallet, 90.0, 10.0, 9.0, 1.0) BPT = pool pool.finalize(from_wallet=alice_wallet) pool_balance = from_base_18(BPT.balanceOf(alice_address)) assert from_base_18(T1.balanceOf(alice_address)) == T1balance - 90 pool.exitswapExternAmountOut( tokenOut_address=T1.address, tokenAmountOut_base=to_base_18(2.0), # T1 wanted maxPoolAmountIn_base=to_base_18(10.0), # max BPT spent from_wallet=alice_wallet, ) assert from_base_18(T1.balanceOf(alice_address)) == (T1balance - 90 + 2.0) assert from_base_18(BPT.balanceOf(alice_address)) >= (pool_balance - 10.0)
def test_exitswapPoolAmountIn(network, T1, T2, alice_address, alice_wallet): T1balance = from_base_18(T1.balanceOf(alice_address)) pool = _createPoolWith2Tokens(network, T1, T2, alice_wallet, 90.0, 10.0, 9.0, 1.0) BPT = pool pool.finalize(from_wallet=alice_wallet) pool_balance = from_base_18(BPT.balanceOf(alice_address)) assert from_base_18(T1.balanceOf(alice_address)) == (T1balance - 90) pool.exitswapPoolAmountIn( tokenOut_address=T1.address, poolAmountIn_base=to_base_18(10.0), #BPT spent minAmountOut_base=to_base_18(1.0), #min T1 wanted from_wallet=alice_wallet) assert from_base_18(T1.balanceOf(alice_address)) >= (T1balance - 90 + 1.0) assert from_base_18(BPT.balanceOf(alice_address)) == (pool_balance - 10.0)
def get_info(self, web3, from_block, to_block, include_holders=False): contract = self.contract_concise minter = contract.minter() all_transfers, _ = self.get_all_transfers_from_events( from_block, to_block) order_logs = self.get_start_order_logs(web3, from_block=from_block, to_block=to_block) holders = [] if include_holders: a_to_balance = DataToken.calculate_balances(all_transfers) _min = to_base_18(0.000001) holders = sorted( [(a, from_base_18(b)) for a, b in a_to_balance.items() if b > _min], key=lambda x: x[1], reverse=True, ) return { "address": self.address, "name": contract.name(), "symbol": contract.symbol(), "decimals": contract.decimals(), "cap": from_base_18(contract.cap()), "totalSupply": from_base_18(contract.totalSupply()), "minter": minter, "minterBalance": self.token_balance(minter), "numHolders": len(holders), "holders": holders, "numOrders": len(order_logs), }
def create(self, data_token: str, exchange_rate: float, wallet: Wallet) -> str: assert exchange_rate > 0, "Invalid exchange rate, must be > 0" exchange = self._exchange_contract() exchange_rate_base = to_base_18(exchange_rate) tx_id = exchange.create(self.ocean_address, data_token, exchange_rate_base, from_wallet=wallet) # get tx receipt tx_receipt = exchange.get_tx_receipt(tx_id) # get event log from receipt logs = exchange.contract.events.ExchangeCreated().processReceipt( tx_receipt) if not logs: raise VerifyTxFailed( f"Create new datatoken exchange failed, transaction receipt for tx {tx_id} is not found." ) exchange_id = logs[0].args.exchangeId # get from event log args # compare exchange_id to generateExchangeId() value assert exchange_id == exchange.generateExchangeId( self.ocean_address, data_token, wallet.address) return exchange_id
def setRate( self, new_rate: float, wallet: Wallet, exchange_id: str = "", data_token: str = "", exchange_owner: str = "", ) -> bool: assert new_rate > 0, "Invalid exchange rate, must be > 0" exchange_rate_base = to_base_18(new_rate) exchange, exchange_id = self.get_exchange_id_fallback_dt_and_owner( exchange_id, exchange_owner, data_token) tx_id = exchange.setRate(exchange_id, exchange_rate_base, from_wallet=wallet) # get tx receipt tx_receipt = exchange.get_tx_receipt(tx_id) # get event log from receipt logs = exchange.contract.events.ExchangeRateChanged().processReceipt( tx_receipt) if not logs: raise VerifyTxFailed( f"Set rate for exchange_id {exchange_id} failed, transaction receipt for tx {tx_id} is not found." ) return True
def setup_all(): config = ExampleConfig.get_config() ConfigProvider.set_config(config) Web3Provider.init_web3( provider=get_web3_connection_provider(config.network_url)) ContractHandler.set_artifacts_path(config.artifacts_path) network = Web3Helper.get_network_name() wallet = get_ganache_wallet() if network in ["ganache", "development"] and wallet: print( f"sender: {wallet.key}, {wallet.address}, {wallet.password}, {wallet.keysStr()}" ) print( f"sender balance: {Web3Helper.from_wei(Web3Helper.get_ether_balance(wallet.address))}" ) assert Web3Helper.from_wei(Web3Helper.get_ether_balance( wallet.address)) > 10 from ocean_lib.models.data_token import DataToken OCEAN_token = DataToken(get_ocean_token_address(network)) amt_distribute = 1000 amt_distribute_base = to_base_18(float(amt_distribute)) for w in (get_publisher_wallet(), get_consumer_wallet()): if Web3Helper.from_wei(Web3Helper.get_ether_balance( w.address)) < 2: Web3Helper.send_ether(wallet, w.address, 4) if OCEAN_token.token_balance(w.address) < 100: OCEAN_token.transfer(w.address, amt_distribute_base, from_wallet=wallet)