def setup_method(self):
self.web3 = Web3(HTTPProvider("http://localhost:8555"))
self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
self.our_address = Address(self.web3.eth.defaultAccount)
self.zrx_token = ERC20Token(web3=self.web3,
address=deploy_contract(
self.web3, 'ZRXToken'))
self.asset_proxy = deploy_contract(self.web3, 'ExchangeV2-ERC20Proxy')
self.exchange = ZrxExchangeV2.deploy(
self.web3,
None) #"0xf47261b0" + self.zrx_token.address.address - unused yet
self.exchange._contract.transact().registerAssetProxy(
self.asset_proxy.address)
asset_proxy_contract = self.web3.eth.contract(abi=json.loads(
pkg_resources.resource_string('pymaker.deployment',
f'abi/ExchangeV2-ERC20Proxy.abi')))(
address=self.asset_proxy.address)
asset_proxy_contract.transact().addAuthorizedAddress(
self.exchange.address.address)
self.token1 = DSToken.deploy(self.web3, 'AAA')
self.token1.mint(Wad.from_number(100)).transact()
self.token2 = DSToken.deploy(self.web3, 'BBB')
self.token2.mint(Wad.from_number(100)).transact()
def test_cancel_order(self):
# given
token1 = DSToken.deploy(self.web3, 'AAA')
token1.mint(Wad.from_number(100)).transact()
# and
token2 = DSToken.deploy(self.web3, 'BBB')
token2.mint(Wad.from_number(100)).transact()
# and
self.exchange.approve([token1, token2], directly())
# when
order = self.exchange.create_order(pay_token=token1.address,
pay_amount=Wad.from_number(10),
buy_token=token2.address,
buy_amount=Wad.from_number(4),
expiration=1763920792)
# and
signed_order = self.exchange.sign_order(order)
# then
assert self.exchange.get_unavailable_buy_amount(signed_order) == Wad(0)
# when
self.exchange.cancel_order(signed_order).transact()
# then
assert self.exchange.get_unavailable_buy_amount(
signed_order) == Wad.from_number(4)
def setup_method(self):
# Use Ganache docker container
self.web3 = Web3(HTTPProvider("http://0.0.0.0:8555"))
self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
self.our_address = Address(self.web3.eth.defaultAccount)
self.zrx_token = ERC20Token(web3=self.web3,
address=deploy_contract(
self.web3, 'ZRXToken'))
self.token_transfer_proxy_address = deploy_contract(
self.web3, 'TokenTransferProxy')
self.exchange = ZrxExchange.deploy(self.web3, self.zrx_token.address,
self.token_transfer_proxy_address)
self.web3.eth.contract(abi=json.loads(
pkg_resources.resource_string(
'pymaker.deployment', f'abi/TokenTransferProxy.abi')))(
address=self.token_transfer_proxy_address.address
).functions.addAuthorizedAddress(
self.exchange.address.address).transact()
self.zrx_api = ZrxApi(self.exchange)
self.dgx = DSToken.deploy(self.web3, 'DGX')
self.dai = DSToken.deploy(self.web3, 'DAI')
self.pair = Pair(self.dgx.address, 9, self.dai.address, 18)
def setup_method(self):
# Use Ganache docker container
self.web3 = Web3(HTTPProvider("http://0.0.0.0:8555"))
self.web3.eth.defaultAccount = Web3.toChecksumAddress("0x9596C16D7bF9323265C2F2E22f43e6c80eB3d943")
register_private_key(self.web3, "0x91cf2cc3671a365fcbf38010ff97ee31a5b7e674842663c56769e41600696ead")
self.our_address = Address(self.web3.eth.defaultAccount)
self.weth_address = self._deploy(self.web3, self.weth_abi, self.weth_bin, [])
self.factory_address = self._deploy(self.web3, self.factory_abi, self.factory_bin, [self.our_address.address])
self.router_address = self._deploy(self.web3, self.router_abi, self.router_bin, [self.factory_address.address, self.weth_address.address])
self._weth_contract = self._get_contract(self.web3, self.weth_abi, self.weth_address)
self.ds_dai = DSToken.deploy(self.web3, 'DAI')
self.ds_usdc = DSToken.deploy(self.web3, 'USDC')
self.token_dai = Token("DAI", self.ds_dai.address, 18)
self.token_usdc = Token("USDC", self.ds_usdc.address, 6)
self.token_weth = Token("WETH", self.weth_address, 18)
self.dai_usdc_uniswap = UniswapV2(self.web3, self.token_dai, self.token_usdc, self.our_address, self.router_address, self.factory_address)
self.dai_eth_uniswap = UniswapV2(self.web3, self.token_dai, self.token_weth, self.our_address, self.router_address, self.factory_address)
## Useful for debugging failing transactions
logger = logging.getLogger('eth')
logger.setLevel(8)
def setup_method(self):
py_evm_main.GENESIS_GAS_LIMIT = 10000000
self.web3 = Web3(EthereumTesterProvider(EthereumTester(
PyEVMBackend())))
self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
self.our_address = Address(self.web3.eth.defaultAccount)
self.zrx_token = ERC20Token(web3=self.web3,
address=deploy_contract(
self.web3, 'ZRXToken'))
self.token_transfer_proxy_address = deploy_contract(
self.web3, 'TokenTransferProxy')
self.exchange = ZrxExchange.deploy(self.web3, self.zrx_token.address,
self.token_transfer_proxy_address)
self.web3.eth.contract(abi=json.loads(
pkg_resources.resource_string(
'pymaker.deployment', f'abi/TokenTransferProxy.abi')))(
address=self.token_transfer_proxy_address.address
).functions.addAuthorizedAddress(
self.exchange.address.address).transact()
self.zrx_api = ZrxApi(self.exchange)
self.dgx = DSToken.deploy(self.web3, 'DGX')
self.dai = DSToken.deploy(self.web3, 'DAI')
self.pair = Pair(self.dgx.address, 9, self.dai.address, 18)
def setup_method(self):
self.web3 = Web3(HTTPProvider("http://localhost:8555"))
self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
self.our_address = Address(self.web3.eth.defaultAccount)
self.dai = DSToken.deploy(self.web3, 'DAI')
self.gem = DSToken.deploy(self.web3, 'MKR')
self.flapper = Flapper.deploy(self.web3, self.dai.address, self.gem.address)
def setup_method(self):
self.web3 = Web3(EthereumTesterProvider())
self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
self.our_address = Address(self.web3.eth.defaultAccount)
self.token1 = DSToken.deploy(self.web3, 'AAA')
self.token1.mint(Wad.from_number(10000)).transact()
self.token2 = DSToken.deploy(self.web3, 'BBB')
self.token2.mint(Wad.from_number(10000)).transact()
self.otc = None
def setup_class(self):
self.web3 = Web3(HTTPProvider("http://0.0.0.0:8555", request_kwargs={'timeout': 10}))
self.web3.eth.defaultAccount = Web3.toChecksumAddress("0x9596C16D7bF9323265C2F2E22f43e6c80eB3d943")
register_private_key(self.web3, "0x91cf2cc3671a365fcbf38010ff97ee31a5b7e674842663c56769e41600696ead")
self.our_address = Address(self.web3.eth.defaultAccount)
# reset ganache EVM state to genesis
session = requests.Session()
method = 'evm_revert'
params = [1]
payload = {"jsonrpc": "2.0",
"method": method,
"params": params,
"id": 1}
headers = {'Content-type': 'application/json'}
response = session.post('http://0.0.0.0:8555', json=payload, headers=headers)
print("revert response: ", response)
# constructor args for SwapRouter
self.factory_address: Address = self._deploy(self.web3, self.UniswapV3Factory_abi, self.UniswapV3Factory_bin, [])
self.weth_address: Address = self._deploy(self.web3, self.weth_abi, self.weth_bin, [])
self.token_descriptor_address: Address = self._deploy(self.web3, self.NFTDescriptor_abi, self.NFTDescriptor_bin, [])
self.swap_router_address = self._deploy(self.web3, self.SwapRouter_abi, self.SwapRouter_bin, [self.factory_address.address, self.weth_address.address])
self.nonfungiblePositionManager_address = self._deploy(self.web3, self.NonfungiblePositionManager_abi, self.NonfungiblePositionManager_bin, [self.factory_address.address, self.weth_address.address, self.token_descriptor_address.address])
self.tick_lens_address = self._deploy(self.web3, self.UniswapV3TickLens_abi, self.UniswapV3TickLens_bin, [])
self.quoter_address = self._deploy(self.web3, self.Quoter_abi, self.Quoter_bin, [self.factory_address.address, self.weth_address.address])
self.position_manager = PositionManager(self.web3, self.nonfungiblePositionManager_address, self.factory_address, self.tick_lens_address, self.weth_address)
self.swap_router = SwapRouter(self.web3, self.swap_router_address, self.quoter_address)
## Useful for debugging failing transactions
logger = logging.getLogger('eth')
logger.setLevel(8)
# Transact.gas_estimate_for_bad_txs = 210000
self.ds_dai = DSToken.deploy(self.web3, 'DAI')
self.ds_usdc = DSToken.deploy(self.web3, 'USDC')
self.token_dai = Token("DAI", self.ds_dai.address, 18)
self.token_usdc = Token("USDC", self.ds_usdc.address, 6)
self.token_weth = Token("WETH", self.weth_address, 18)
self.position_manager.approve(self.token_dai)
self.position_manager.approve(self.token_usdc)
self.position_manager.approve(self.token_weth)
self.swap_router.approve(self.token_dai)
self.swap_router.approve(self.token_usdc)
self.swap_router.approve(self.token_weth)
# TODO: normalize amounts for decimals
dai_balance = Wad.from_number(9000000000000000)
usdc_balance = Wad.from_number(900000000000000)
self.ds_dai.mint(dai_balance).transact(from_address=self.our_address)
self.ds_usdc.mint(self.token_usdc.unnormalize_amount(usdc_balance)).transact(from_address=self.our_address)
def setup_method(self):
self.web3 = Web3(HTTPProvider("http://localhost:8555"))
self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
self.our_address = Address(self.web3.eth.defaultAccount)
self.other_address = Address(self.web3.eth.accounts[1])
self.tx = TxManager.deploy(self.web3)
self.token1 = DSToken.deploy(self.web3, 'ABC')
self.token1.mint(Wad.from_number(1000000)).transact()
self.token2 = DSToken.deploy(self.web3, 'DEF')
self.token2.mint(Wad.from_number(1000000)).transact()
def test_equals(self):
# given
token1 = DSToken.deploy(self.web3, 'ABC')
token2 = DSToken.deploy(self.web3, 'DEF')
token2b = ERC20Token(web3=self.web3, address=token2.address)
# expect
assert token1 == token1
assert token2 == token2b
assert not token1 == token2
assert not token1 == token2b
def setup_method(self):
self.web3 = Web3(HTTPProvider("http://localhost:8555"))
self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
self.our_address = Address(self.web3.eth.defaultAccount)
self.token1 = DSToken.deploy(self.web3, 'AAA')
self.token1.mint(Wad.from_number(10000)).transact()
self.token2 = DSToken.deploy(self.web3, 'BBB')
self.token2.mint(Wad.from_number(10000)).transact()
self.token3 = DSToken.deploy(self.web3, 'CCC')
self.token3.mint(Wad.from_number(10000)).transact()
self.otc = None
def setup_method(self):
self.web3 = Web3(HTTPProvider("http://localhost:8555"))
self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
self.our_address = Address(self.web3.eth.defaultAccount)
self.dai = DSToken.deploy(self.web3, 'DAI')
self.gem = DSToken.deploy(self.web3, 'MKR')
self.flopper = Flopper.deploy(self.web3, self.dai.address, self.gem.address)
# so the Flopper can mint MKR
dad = DSGuard.deploy(self.web3)
dad.permit(self.flopper.address, self.gem.address, DSGuard.ANY).transact()
self.gem.set_authority(dad.address).transact()
def setup_method(self):
self.web3 = Web3(EthereumTesterProvider())
self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
self.our_address = Address(self.web3.eth.defaultAccount)
self.zrx_token = ERC20Token(web3=self.web3, address=deploy_contract(self.web3, 'ZRXToken'))
self.token_transfer_proxy_address = deploy_contract(self.web3, 'TokenTransferProxy')
self.exchange = ZrxExchange.deploy(self.web3, self.zrx_token.address, self.token_transfer_proxy_address)
self.web3.eth.contract(abi=json.loads(pkg_resources.resource_string('pymaker.deployment', f'abi/TokenTransferProxy.abi')))(address=self.token_transfer_proxy_address.address).transact().addAuthorizedAddress(self.exchange.address.address)
self.token1 = DSToken.deploy(self.web3, 'AAA')
self.token1.mint(Wad.from_number(100)).transact()
self.token2 = DSToken.deploy(self.web3, 'BBB')
self.token2.mint(Wad.from_number(100)).transact()
def deploy_tokens(self):
self.ds_dai = DSToken.deploy(self.web3, 'DAI')
self.ds_keep = DSToken.deploy(self.web3, 'KEEP')
self.ds_lev = DSToken.deploy(self.web3, 'LEV')
self.ds_usdc = DSToken.deploy(self.web3, 'USDC')
self.ds_wbtc = DSToken.deploy(self.web3, 'WBTC')
self.token_dai = Token("DAI", self.ds_dai.address, 18)
self.token_keep = Token("KEEP", self.ds_keep.address, 18)
self.token_lev = Token("LEV", self.ds_lev.address, 9)
self.token_usdc = Token("USDC", self.ds_usdc.address, 6)
self.token_wbtc = Token("WBTC", self.ds_wbtc.address, 8)
self.token_weth = Token("WETH", self.weth_address, 18)
def setup_method(self):
self.web3 = Web3(EthereumTesterProvider())
self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
self.our_address = Address(self.web3.eth.defaultAccount)
self.token1 = DSToken.deploy(self.web3, 'AAA')
self.token1.mint(Wad.from_number(10000)).transact()
self.token2 = DSToken.deploy(self.web3, 'BBB')
self.token2.mint(Wad.from_number(10000)).transact()
self.otc = MatchingMarket.deploy(self.web3, 2500000000)
self.otc.add_token_pair_whitelist(self.token1.address, self.token2.address).transact()
self.otc.approve([self.token1, self.token2], directly())
for amount in [11,55,44,34,36,21,45,51,15]:
self.otc.make(pay_token=self.token1.address, pay_amount=Wad.from_number(1),
buy_token=self.token2.address, buy_amount=Wad.from_number(amount)).transact()
def setup_method(self):
self.web3 = Web3(EthereumTesterProvider())
self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
self.our_address = Address(self.web3.eth.defaultAccount)
self.etherdelta = EtherDelta.deploy(self.web3,
admin=Address('0x1111100000999998888877777666665555544444'),
fee_account=Address('0x8888877777666665555544444111110000099999'),
account_levels_addr=Address('0x0000000000000000000000000000000000000000'),
fee_make=Wad.from_number(0.01),
fee_take=Wad.from_number(0.02),
fee_rebate=Wad.from_number(0.03))
self.token1 = DSToken.deploy(self.web3, 'AAA')
self.token1.mint(Wad.from_number(100)).transact()
self.token2 = DSToken.deploy(self.web3, 'BBB')
self.token2.mint(Wad.from_number(100)).transact()
def test_local_accounts_register_key():
# given
# [that address is not recognized by ganache, this way we can be sure it's the local account being used for signing]
web3 = Web3(HTTPProvider("http://localhost:8555"))
web3.eth.defaultAccount = Address(
'0x13314e21cd6d343ceb857073f3f6d9368919d1ef').address
# and
keyfile_path = pkg_resources.resource_filename(
__name__, "accounts/4_0x13314e21cd6d343ceb857073f3f6d9368919d1ef.json")
passfile_path = pkg_resources.resource_filename(__name__, "accounts/pass")
register_key(web3, f"key_file={keyfile_path},pass_file={passfile_path}")
# and
# [as ganache does not know this address, we need to send some ETH to it first]
eth_transfer(web3, Address(web3.eth.defaultAccount), Wad.from_number(100)) \
.transact(from_address=Address(web3.eth.accounts[0]))
# when
# [we deploy some test contract and mint some tokens]
token = DSToken.deploy(web3, 'XYZ')
token.mint(Wad.from_number(150000)).transact()
# then
# [these operations were successful]
assert token.balance_of(Address(
web3.eth.defaultAccount)) == Wad.from_number(150000)
def setup_method(self):
self.web3 = Web3(EthereumTesterProvider())
self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
self.our_address = Address(self.web3.eth.defaultAccount)
self.second_address = Address(self.web3.eth.accounts[1])
self.token = DSToken.deploy(self.web3, 'ABC')
self.token.mint(Wad(1000000)).transact()
def setup_method(self):
self.web3 = Web3(HTTPProvider("http://localhost:8555"))
self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
self.our_address = Address(self.web3.eth.defaultAccount)
self.second_address = Address(self.web3.eth.accounts[1])
self.third_address = Address(self.web3.eth.accounts[2])
self.token = DSToken.deploy(self.web3, 'ABC')
self.token.mint(Wad(1000000)).transact()
def setup_method(self):
self.web3 = Web3(HTTPProvider("http://localhost:8555"))
self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
self.our_address = Address(self.web3.eth.defaultAccount)
self.token1 = DSToken.deploy(self.web3, 'AAA')
self.token1.mint(Wad.from_number(10000)).transact()
self.token1_tokenclass = Token('AAA', self.token1.address, 18)
self.token2 = DSToken.deploy(self.web3, 'BBB')
self.token2.mint(Wad.from_number(10000)).transact()
self.token2_tokenclass = Token('BBB', self.token2.address, 18)
price_oracle = OasisMockPriceOracle.deploy(self.web3)
self.otc = MatchingMarket.deploy(self.web3, self.token1.address, Wad(0), price_oracle.address)
self.otc.add_token_pair_whitelist(self.token1.address, self.token2.address).transact()
self.otc.approve([self.token1, self.token2], directly())
for amount in [11,55,44,34,36,21,45,51,15]:
self.otc.make(p_token=self.token1_tokenclass, pay_amount=Wad.from_number(1),
b_token=self.token2_tokenclass, buy_amount=Wad.from_number(amount)).transact()
def setup_method(self):
self.web3 = Web3(EthereumTesterProvider())
self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
self.our_address = Address(self.web3.eth.defaultAccount)
self.idex = IDEX.deploy(self.web3, self.our_address)
self.idex._contract.transact().setInactivityReleasePeriod(0)
self.token = DSToken.deploy(self.web3, 'AAA')
self.token.mint(Wad.from_number(100)).transact()
def setup_method(self):
# Use Ganache docker container
self.web3 = Web3(HTTPProvider("http://0.0.0.0:8555"))
self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
self.our_address = Address(self.web3.eth.defaultAccount)
self.idex = IDEX.deploy(self.web3, self.our_address)
self.idex._contract.functions.setInactivityReleasePeriod(0).transact()
self.token = DSToken.deploy(self.web3, 'AAA')
self.token.mint(Wad.from_number(100)).transact()
def setup_method(self):
self.web3 = Web3(HTTPProvider("http://localhost:8555"))
self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
self.our_address = Address(self.web3.eth.defaultAccount)
self.token1 = DSToken.deploy(self.web3, 'AAA')
self.token1_tokenclass = Token('AAA', self.token1.address, 18)
self.token1.mint(Wad.from_number(10000)).transact()
self.token2 = DSToken.deploy(self.web3, 'BBB')
self.token2_tokenclass = Token('BBB', self.token2.address, 6)
self.token2.mint(Wad.from_number(10000)).transact()
support_abi = Contract._load_abi(__name__, '../pymaker/abi/MakerOtcSupportMethods.abi')
support_bin = Contract._load_bin(__name__, '../pymaker/abi/MakerOtcSupportMethods.bin')
support_address = Contract._deploy(self.web3, support_abi, support_bin, [])
price_oracle = OasisMockPriceOracle.deploy(self.web3)
self.otc = MatchingMarket.deploy(self.web3, self.token1.address, Wad(0), price_oracle.address, support_address)
self.otc.add_token_pair_whitelist(self.token1.address, self.token2.address).transact()
self.otc.approve([self.token1, self.token2], directly())
def setup_method(self):
self.ds_dai = DSToken.deploy(self.web3, 'DAI')
self.ds_usdc = DSToken.deploy(self.web3, 'USDC')
self.token_dai = Token("DAI", self.ds_dai.address, 18)
self.token_usdc = Token("USDC", self.ds_usdc.address, 6)
self.token_weth = Token("WETH", self.weth_address, 18)
self.position_manager.approve(self.token_dai)
self.position_manager.approve(self.token_usdc)
self.position_manager.approve(self.token_weth)
self.swap_router.approve(self.token_dai)
self.swap_router.approve(self.token_usdc)
self.swap_router.approve(self.token_weth)
dai_balance = Wad.from_number(10000000)
usdc_balance = Wad.from_number(10000000)
self.ds_dai.mint(dai_balance).transact(from_address=self.our_address)
self.ds_usdc.mint(
self.token_usdc.unnormalize_amount(usdc_balance)).transact(
from_address=self.our_address)
def deploy(web3: Web3, name: str, vat: Vat):
collateral = Collateral(Ilk(name))
collateral.gem = DSToken.deploy(web3=web3, symbol=name)
collateral.adapter = GemAdapter.deploy(web3=web3,
vat=vat.address,
ilk=collateral.ilk,
gem=collateral.gem.address)
collateral.mover = GemVat.deploy(web3=web3,
vat=vat.address,
ilk=collateral.ilk,
gem=collateral.gem.address)
return collateral
def setup_method(self):
# reduce logspew
logging.getLogger("web3").setLevel(logging.INFO)
logging.getLogger("urllib3").setLevel(logging.INFO)
logging.getLogger("asyncio").setLevel(logging.INFO)
self.web3 = Web3(HTTPProvider("http://localhost:8555"))
self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
self.our_address = Address(self.web3.eth.defaultAccount)
self.price_oracle = OasisMockPriceOracle.deploy(self.web3)
self.price_oracle.set_price(Wad.from_number(10))
self.token1 = DSToken.deploy(self.web3, 'AAA')
self.token1_tokenclass = Token('AAA', self.token1.address, 18)
self.token1.mint(Wad.from_number(10000)).transact()
self.token2 = DSToken.deploy(self.web3, 'BBB')
self.token2_tokenclass = Token('BBB', self.token2.address, 18)
self.token2.mint(Wad.from_number(10000)).transact()
self.token3 = DSToken.deploy(self.web3, 'CCC')
self.token3_tokenclass = Token('CCC', self.token3.address, 18)
self.token3.mint(Wad.from_number(10000)).transact()
self.otc = None
def setup_method(self):
self.web3 = Web3(HTTPProvider("http://localhost:8555"))
self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
self.keeper_address = Address(self.web3.eth.defaultAccount)
self.gal_address = Address(self.web3.eth.accounts[1])
self.other_address = Address(self.web3.eth.accounts[2])
self.dai = DSToken.deploy(self.web3, 'DAI')
self.mkr = DSToken.deploy(self.web3, 'MKR')
self.flapper = Flapper.deploy(self.web3, self.dai.address,
self.mkr.address)
self.keeper = AuctionKeeper(args=args(
f"--eth-from {self.keeper_address} "
f"--flapper {self.flapper.address} "
f"--model ./bogus-model.sh"),
web3=self.web3)
self.keeper.approve()
# So that `gal_address` can kick auctions, it must have some DAI in its account
# and also Flapper must be approved to access it
self.dai.mint(Wad.from_number(5000000)).transact()
self.dai.transfer(self.gal_address,
Wad.from_number(5000000)).transact()
self.dai.approve(
self.flapper.address).transact(from_address=self.gal_address)
# So that `keeper_address` and `other_address` can bid in auctions,
# they both need to have MKR in their accounts.
self.mkr.mint(Wad.from_number(10000000)).transact()
self.mkr.transfer(self.other_address,
Wad.from_number(5000000)).transact()
self.model = MagicMock()
self.model.get_stance = MagicMock(return_value=None)
self.model_factory = self.keeper.auctions.model_factory
self.model_factory.create_model = MagicMock(return_value=self.model)
def test_approval(self):
# given
token1 = DSToken.deploy(self.web3, 'AAA')
token1.mint(Wad.from_number(100)).transact()
# and
assert token1.allowance_of(self.our_address,
self.token_transfer_proxy_address) == Wad(0)
assert self.zrx_token.allowance_of(
self.our_address, self.token_transfer_proxy_address) == Wad(0)
# when
self.exchange.approve([token1], directly())
# then
assert token1.allowance_of(self.our_address,
self.token_transfer_proxy_address) > Wad(0)
assert self.zrx_token.allowance_of(
self.our_address, self.token_transfer_proxy_address) > Wad(0)
def test_multiple_local_accounts():
# given
local_account_1 = Address('0x13314e21cd6d343ceb857073f3f6d9368919d1ef')
local_account_2 = Address('0x176087fea5c41fc370fabbd850521bc4451690ca')
# and
# [that address is not recognized by ganache, this way we can be sure it's the local account being used for signing]
web3 = Web3(HTTPProvider("http://localhost:8555"))
web3.eth.defaultAccount = local_account_1.address
# and
keyfile_path = pkg_resources.resource_filename(
__name__, "accounts/4_0x13314e21cd6d343ceb857073f3f6d9368919d1ef.json")
passfile_path = pkg_resources.resource_filename(__name__, "accounts/pass")
register_key_file(web3, keyfile_path, passfile_path)
# and
keyfile_path = pkg_resources.resource_filename(
__name__, "accounts/5_0x176087fea5c41fc370fabbd850521bc4451690ca.json")
passfile_path = pkg_resources.resource_filename(__name__, "accounts/pass")
register_key_file(web3, keyfile_path, passfile_path)
# and
# [as ganache does not know these addresses, we need to send some ETH to it first]
eth_transfer(web3, local_account_1, Wad.from_number(100)).transact(
from_address=Address(web3.eth.accounts[0]))
eth_transfer(web3, local_account_2, Wad.from_number(100)).transact(
from_address=Address(web3.eth.accounts[0]))
# when
# [we execute some test scenario involving two addresses]
token = DSToken.deploy(web3, 'XYZ')
token.mint(Wad.from_number(150000)).transact()
token.transfer(local_account_2, Wad.from_number(60000)).transact()
token.transfer(
local_account_1,
Wad.from_number(10000)).transact(from_address=local_account_2)
# then
# [these operations were successful]
assert token.balance_of(local_account_1) == Wad.from_number(100000)
assert token.balance_of(local_account_2) == Wad.from_number(50000)
def setup_method(self):
self.web3 = Web3(HTTPProvider("http://localhost:8555"))
self.web3.eth.defaultAccount = self.web3.eth.accounts[0]
self.our_address = Address(self.web3.eth.defaultAccount)
self.other_address_1 = Address(self.web3.eth.accounts[1])
self.other_address_2 = Address(self.web3.eth.accounts[2])
self.dai = DSToken.deploy(self.web3, 'DAI')
# we need a GemLike version of DSToken with push(bytes32, uint function)
self.gem_addr = Contract._deploy(self.web3, Contract._load_abi(__name__, 'abi/GemMock.abi'), Contract._load_bin(__name__, 'abi/GemMock.bin'), [b'ABC'])
self.gem = DSToken(web3=self.web3, address=self.gem_addr)
self.flipper = Flipper.deploy(self.web3, self.dai.address, self.gem.address)
# Set allowance to allow flipper to move dai and gem
# With full deployment kick is only done by Cat via flip() which take care of allowance via gem.hope()
self.gem.approve(self.flipper.address).transact()
self.gem.approve(self.flipper.address).transact(from_address=self.other_address_1)
self.dai.approve(self.flipper.address).transact()
