def transferOCEAN(self, dst_wallet, amt: float) -> None:
assert isinstance(dst_wallet, AgentWallet) or \
isinstance(dst_wallet, BurnWallet)
dst_address = dst_wallet._address
amt_base = toBase18(amt)
assert amt_base >= 0
if amt_base == 0:
return
OCEAN_base = self._OCEAN_base()
if OCEAN_base == 0:
raise ValueError("no funds to transfer from")
tol = 1e-12
if (1.0 - tol) <= amt / fromBase18(OCEAN_base) <= (1.0 + tol):
amt_base = OCEAN_base
if amt_base > OCEAN_base:
raise ValueError("transfer amt (%s) exceeds OCEAN holdings (%s)" %
(fromBase18(amt_base), fromBase18(OCEAN_base)))
globaltokens.OCEANtoken().transfer(dst_address, amt_base,
self._web3wallet)
dst_wallet._total_OCEAN_in += amt
self.resetCachedInfo()
dst_wallet.resetCachedInfo()
def _datatokenAddress(self):
addrs = self._pool.getCurrentTokens()
assert len(addrs) == 2
OCEAN_addr = globaltokens.OCEANtoken().address
for addr in addrs:
if addr != OCEAN_addr:
return addr
raise AssertionError("should never get here")
def stakeOCEAN(self, OCEAN_stake: float, pool: bpool.BPool):
OCEAN = globaltokens.OCEANtoken()
OCEAN.approve(pool.address,
toBase18(OCEAN_stake),
from_wallet=self._web3wallet)
pool.joinswapExternAmountIn(
tokenIn_address=globaltokens.OCEAN_address(),
tokenAmountIn_base=toBase18(OCEAN_stake),
minPoolAmountOut_base=toBase18(0.0),
from_wallet=self._web3wallet)
self.resetCachedInfo()
def test_OCEAN():
wallet = web3wallet.randomWeb3Wallet()
OCEAN_base = web3util.toBase18(3.0)
globaltokens.mintOCEAN(address=wallet.address, value_base=OCEAN_base)
OCEAN_token = globaltokens.OCEANtoken()
assert isinstance(OCEAN_token, datatoken.Datatoken)
assert OCEAN_token.symbol() == 'OCEAN'
assert OCEAN_token.balanceOf_base(wallet.address) == OCEAN_base
globaltokens.mintOCEAN(address=wallet.address, value_base=OCEAN_base)
assert OCEAN_token.balanceOf_base(wallet.address) == OCEAN_base * 2
def _createPool(DT:datatoken.Datatoken, web3_w:web3wallet.Web3Wallet):
OCEAN = globaltokens.OCEANtoken()
#Create OCEAN-DT pool
p_address = bfactory.BFactory().newBPool(from_wallet=web3_w)
pool = bpool.BPool(p_address)
DT.approve(pool.address, toBase18(_DT_STAKE), from_wallet=web3_w)
OCEAN.approve(pool.address, toBase18(_OCEAN_STAKE),from_wallet=web3_w)
pool.bind(DT.address, toBase18(_DT_STAKE),
toBase18(POOL_WEIGHT_DT), from_wallet=web3_w)
pool.bind(OCEAN.address, toBase18(_OCEAN_STAKE),
toBase18(POOL_WEIGHT_OCEAN), from_wallet=web3_w)
pool.finalize(from_wallet=web3_w)
return pool
def _createPoolAgent(self, state) -> PoolAgent:
assert self.OCEAN() > 0.0, "should not call if no OCEAN"
wallet = self._wallet._web3wallet
OCEAN = globaltokens.OCEANtoken()
#name
pool_i = len(state.agents.filterToPool())
dt_name = f'DT{pool_i}'
pool_agent_name = f'pool{pool_i}'
#new DT
DT = self._createDatatoken(dt_name, mint_amt=1000.0) #magic number
#new pool
pool_address = bfactory.BFactory().newBPool(from_wallet=wallet)
pool = bpool.BPool(pool_address)
#bind tokens & add initial liquidity
OCEAN_bind_amt = self.OCEAN() #magic number: use all the OCEAN
DT_bind_amt = 20.0 #magic number
DT.approve(pool.address, toBase18(DT_bind_amt), from_wallet=wallet)
OCEAN.approve(pool.address,
toBase18(OCEAN_bind_amt),
from_wallet=wallet)
pool.bind(DT.address,
toBase18(DT_bind_amt),
toBase18(POOL_WEIGHT_DT),
from_wallet=wallet)
pool.bind(OCEAN.address,
toBase18(OCEAN_bind_amt),
toBase18(POOL_WEIGHT_OCEAN),
from_wallet=wallet)
pool.finalize(from_wallet=wallet)
#create agent
pool_agent = PoolAgent(pool_agent_name, pool)
state.addAgent(pool_agent)
self._wallet.resetCachedInfo()
return pool_agent
def _OCEAN_base(self) -> int:
if self._cached_OCEAN_base is None:
self._cached_OCEAN_base = globaltokens.OCEANtoken().balanceOf_base(
self._address)
return self._cached_OCEAN_base
