def test1(network, alice_wallet):
bfactory_address = get_bfactory_address(network)
bfactory = BFactory(bfactory_address)
pool_address = bfactory.newBPool(from_wallet=alice_wallet)
pool = BPool(pool_address)
assert isinstance(pool, BPool)
def test_bpool_creation(web3, config, alice_wallet):
"""Test the creation of a Balancer Pool from BFactory (happy flow)."""
bfactory_address = get_bfactory_address(config.address_file, web3=web3)
bfactory = BFactory(web3, bfactory_address)
pool_address = bfactory.newBPool(from_wallet=alice_wallet)
pool = BPool(web3, pool_address)
assert isinstance(pool, BPool)
def test_bpool_creation(network, alice_wallet):
"""Test the creation of a Balancer Pool from BFactory (happy flow)."""
bfactory_address = get_bfactory_address(network)
bfactory = BFactory(bfactory_address)
pool_address = bfactory.newBPool(from_wallet=alice_wallet)
pool = BPool(pool_address)
assert isinstance(pool, BPool)
def _deployBPool(network: str, from_wallet: Wallet) -> BPool:
"""Helper function to deploy a pool."""
factory_address = get_bfactory_address(network)
factory = BFactory(factory_address)
pool_address = factory.newBPool(from_wallet=from_wallet)
pool = BPool(pool_address)
return pool
def _deployBPool(web3: Web3, address_file: str, network: str,
from_wallet: Wallet) -> BPool:
"""Helper function to deploy a pool."""
factory_address = get_bfactory_address(address_file, network)
factory = BFactory(web3, factory_address)
pool_address = factory.newBPool(from_wallet=from_wallet)
pool = BPool(web3, pool_address)
return pool
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_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 test1(network, OCEAN_address, alice_wallet, alice_ocean, alice_address,
bob_wallet):
bfactory_address = get_bfactory_address(network)
# ===============================================================
# 1. Alice publishes a dataset (= publishes a datatoken)
# For now, you're Alice:) Let's proceed.
DT = alice_ocean.create_data_token("DataToken1",
"DT1",
alice_wallet,
blob="localhost:8030")
DT_address = DT.address
# ===============================================================
# 2. Alice hosts the dataset
# Do from console:
# >> touch /var/mydata/myFolder1/file
# >> ENV DT="{'0x1234':'/var/mydata/myFolder1'}"
# >> docker run @oceanprotocol/provider-py -e CONFIG=DT
# ===============================================================
# 3. Alice mints DTs
DT.mint(alice_address, to_base_18(1000.0), alice_wallet)
# ===============================================================
# 4. Alice creates an OCEAN-DT pool (=a Balancer Pool)
bfactory = BFactory(bfactory_address)
pool_address = bfactory.newBPool(from_wallet=alice_wallet)
pool = BPool(pool_address)
pool.setPublicSwap(True, from_wallet=alice_wallet)
pool.setSwapFee(to_base_18(0.1), from_wallet=alice_wallet) # set 10% fee
DT.approve(pool_address, to_base_18(90.0), from_wallet=alice_wallet)
pool.bind(
DT_address,
to_base_18(90.0),
balancer_constants.INIT_WEIGHT_DT_BASE,
from_wallet=alice_wallet,
)
OCEAN_token = BToken(OCEAN_address)
txid = OCEAN_token.approve(pool_address,
to_base_18(10.0),
from_wallet=alice_wallet)
r = OCEAN_token.get_tx_receipt(txid)
assert r and r.status == 1, f"approve failed, receipt={r}"
pool.bind(
OCEAN_address,
to_base_18(10.0),
balancer_constants.INIT_WEIGHT_OCEAN_BASE,
from_wallet=alice_wallet,
)
# ===============================================================
# 5. Alice adds liquidity to pool
DT.approve(pool_address, to_base_18(9.0), from_wallet=alice_wallet)
pool.rebind(
DT_address,
to_base_18(90.0 + 9.0),
balancer_constants.INIT_WEIGHT_DT_BASE,
from_wallet=alice_wallet,
)
OCEAN_token.approve(pool_address,
to_base_18(1.0),
from_wallet=alice_wallet)
pool.rebind(
OCEAN_address,
to_base_18(10.0 + 1.0),
to_base_18(balancer_constants.INIT_WEIGHT_OCEAN),
from_wallet=alice_wallet,
)
# 6. Bob buys a DT from pool
OCEAN_token.approve(pool_address, to_base_18(2.0), from_wallet=bob_wallet)
pool.swapExactAmountOut(
tokenIn_address=OCEAN_address,
maxAmountIn_base=to_base_18(2.0),
tokenOut_address=DT_address,
tokenAmountOut_base=to_base_18(1.0),
maxPrice_base=2**255,
from_wallet=bob_wallet,
)
# ===============================================================
# 7. Bob consumes dataset
# <don't need to show here>
# ===============================================================
# 8. Alice removes liquidity
pool.rebind(
DT_address,
to_base_18(90.0 + 9.0 - 2.0),
balancer_constants.INIT_WEIGHT_DT_BASE,
from_wallet=alice_wallet,
)
pool.rebind(
OCEAN_address,
to_base_18(10.0 + 1.0 - 3.0),
balancer_constants.INIT_WEIGHT_OCEAN_BASE,
from_wallet=alice_wallet,
)
# ===============================================================
# 9. Alice sells data tokens
DT.approve(pool_address, to_base_18(1.0), from_wallet=alice_wallet)
pool.swapExactAmountIn(
tokenIn_address=DT_address,
tokenAmountIn_base=to_base_18(1.0),
tokenOut_address=OCEAN_address,
minAmountOut_base=to_base_18(0.0001),
maxPrice_base=2**255,
from_wallet=alice_wallet,
)
# ===============================================================
# 10. Alice finalizes pool. Now others can add liquidity.
pool.finalize(from_wallet=alice_wallet)
# ===============================================================
# 11. Bob adds liquidity
DT.approve(pool_address, to_base_18(1.0), from_wallet=bob_wallet)
OCEAN_token.approve(pool_address, to_base_18(1.0), from_wallet=bob_wallet)
pool.joinPool(to_base_18(0.1),
[to_base_18(1.0), to_base_18(1.0)],
from_wallet=bob_wallet)
# ===============================================================
# 12. Bob adds liquidity AGAIN
DT.approve(pool_address, to_base_18(1.0), from_wallet=bob_wallet)
OCEAN_token.approve(pool_address, to_base_18(1.0), from_wallet=bob_wallet)
pool.joinPool(to_base_18(0.1),
[to_base_18(1.0), to_base_18(1.0)],
from_wallet=bob_wallet)
def create(self,
data_token_address: str,
data_token_amount: float,
OCEAN_amount: float,
from_wallet: Wallet,
data_token_weight: float = balancer_constants.INIT_WEIGHT_DT,
swap_fee: float = balancer_constants.DEFAULT_SWAP_FEE) -> BPool:
"""
Create a new pool with bound datatoken and OCEAN token then finalize it.
The pool will have publicSwap enabled and swap fee is set
to `balancer_constants.DEFAULT_SWAP_FEE`.
Balances of both data tokens and OCEAN tokens must be sufficient in the
`from_wallet`, otherwise this will fail.
:param data_token_address: str address of the DataToken contract
:param data_token_amount: float amount of initial liquidity of data tokens
:param OCEAN_amount: float amount of initial liquidity of OCEAN tokens
:param from_wallet: Wallet instance of pool owner
:param data_token_weight: float weight of the data token to be set in the new pool must be >= 1 & <= 9
:param swap_fee: float the fee taken by the pool on each swap transaction
:return: BPool instance
"""
bfactory = BFactory(self.bfactory_address)
pool_address = bfactory.newBPool(from_wallet)
pool = BPool(pool_address)
logger.debug(f'pool created with address {pool_address}.')
assert 1 <= data_token_weight <= 9
base_weight = 10.0 - data_token_weight
# Must approve datatoken and Ocean tokens to the new pool as spender
dt = DataToken(data_token_address)
tx_id = dt.approve_tokens(pool_address,
data_token_amount,
from_wallet,
wait=True)
if dt.get_tx_receipt(tx_id).status != 1:
raise AssertionError(
f'Approve datatokens failed, pool was created at {pool_address}'
)
ot = DataToken(self.ocean_address)
tx_id = ot.approve_tokens(pool_address,
OCEAN_amount,
from_wallet,
wait=True)
if ot.get_tx_receipt(tx_id).status != 1:
raise AssertionError(
f'Approve OCEAN tokens failed, pool was created at {pool_address}'
)
tx_id = pool.setup(data_token_address, to_base_18(data_token_amount),
to_base_18(data_token_weight), self.ocean_address,
to_base_18(OCEAN_amount), to_base_18(base_weight),
to_base_18(swap_fee), from_wallet)
if pool.get_tx_receipt(tx_id).status != 1:
raise AssertionError(
f'pool.setup failed: txId={tx_id}, receipt={pool.get_tx_receipt(tx_id)}'
)
logger.debug(
f'create pool completed: poolAddress={pool_address}, pool setup TxId={tx_id}'
)
return pool
def _deployBPool(network: str, from_wallet: Wallet) -> BPool:
factory_address = get_bfactory_address(network)
factory = BFactory(factory_address)
pool_address = factory.newBPool(from_wallet=from_wallet)
pool = BPool(pool_address)
return pool
def create(
self,
data_token_address: str,
data_token_amount: int,
OCEAN_amount: int,
from_wallet: Wallet,
data_token_weight: int = balancer_constants.INIT_WEIGHT_DT,
swap_fee: int = balancer_constants.DEFAULT_SWAP_FEE,
) -> BPool:
"""
Create a new pool with bound datatoken and OCEAN token then finalize it.
The pool will have publicSwap enabled and swap fee is set
to `balancer_constants.DEFAULT_SWAP_FEE`.
Balances of both data tokens and OCEAN tokens must be sufficient in the
`from_wallet`, otherwise this will fail.
:param data_token_address: str address of the DataToken contract
:param data_token_amount: int amount of initial liquidity of data tokens
:param OCEAN_amount: int amount of initial liquidity of OCEAN tokens
:param from_wallet: Wallet instance of pool owner
:param data_token_weight: int weight of the data token to be set in the new pool must be >= 1 & <= 9
:param swap_fee: int the fee taken by the pool on each swap transaction
:return: BPool instance
"""
bfactory = BFactory(self.web3, self.bfactory_address)
pool_address = bfactory.newBPool(from_wallet)
pool = BPool(self.web3, pool_address)
logger.debug(f"pool created with address {pool_address}.")
assert to_wei("1") <= data_token_weight <= to_wei("9")
base_weight = to_wei(10) - data_token_weight
# Must approve datatoken and Ocean tokens to the new pool as spender
dt = DataToken(self.web3, data_token_address)
if dt.balanceOf(from_wallet.address) < data_token_amount:
raise InsufficientBalance(
"Insufficient datatoken balance for pool creation!"
)
if dt.allowance(from_wallet.address, pool_address) < data_token_amount:
tx_id = dt.approve(pool_address, data_token_amount, from_wallet)
if dt.get_tx_receipt(self.web3, tx_id).status != 1:
raise VerifyTxFailed(
f"Approve datatokens failed, pool was created at {pool_address}"
)
ot = DataToken(self.web3, self.ocean_address)
if ot.balanceOf(from_wallet.address) < OCEAN_amount:
raise InsufficientBalance("Insufficient OCEAN balance for pool creation!")
if ot.allowance(from_wallet.address, pool_address) < OCEAN_amount:
tx_id = ot.approve(pool_address, OCEAN_amount, from_wallet)
if ot.get_tx_receipt(self.web3, tx_id).status != 1:
raise VerifyTxFailed(
f"Approve OCEAN tokens failed, pool was created at {pool_address}"
)
tx_id = pool.setup(
data_token_address,
data_token_amount,
data_token_weight,
self.ocean_address,
OCEAN_amount,
base_weight,
swap_fee,
from_wallet,
)
if pool.get_tx_receipt(self.web3, tx_id).status != 1:
raise VerifyTxFailed(
f"pool.setup failed: txId={tx_id}, receipt={pool.get_tx_receipt(self.web3, tx_id)}"
)
logger.debug(
f"create pool completed: poolAddress={pool_address}, pool setup TxId={tx_id}"
)
return pool
