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 get_offer(self, offer_id: int) -> Optional[OfferInfo]:
"""Get the offer details.
Args:
offer_id: The id of the offer to get the details of.
Returns:
An instance of `OfferInfo` if the offer is still active, or `None` if the offer has been
already completely taken.
"""
# if an offer is None, it won't become not-None again for the same OTC instance
if offer_id in self._none_offers:
return None
array = self._contract.call().offers(offer_id)
if array[5] is not True:
self._none_offers.add(offer_id)
return None
else:
return OfferInfo(offer_id=offer_id,
sell_how_much=Wad(array[0]),
sell_which_token=Address(array[1]),
buy_how_much=Wad(array[2]),
buy_which_token=Address(array[3]),
owner=Address(array[4]),
timestamp=array[6])
def test_token_registry(self):
# given
ERC20Token.register_token(
Address('0x0100000000000000000000000000000000000000'), 'ABC')
ERC20Token.register_token(
Address('0x0200000000000000000000000000000000000000'), 'DEF')
ERC20Token.register_token(
Address('0x0300000000000000000000000000000000000000'), 'GHI')
# expect
assert ERC20Token.token_name_by_address(
Address('0x0100000000000000000000000000000000000000')) == 'ABC'
assert ERC20Token.token_name_by_address(
Address('0x0200000000000000000000000000000000000000')) == 'DEF'
assert ERC20Token.token_name_by_address(
Address('0x0300000000000000000000000000000000000000')) == 'GHI'
with pytest.raises(Exception):
assert ERC20Token.token_name_by_address(
Address('0x0400000000000000000000000000000000000000'))
# and
assert ERC20Token.token_address_by_name('ABC') == Address(
'0x0100000000000000000000000000000000000000')
assert ERC20Token.token_address_by_name('DEF') == Address(
'0x0200000000000000000000000000000000000000')
assert ERC20Token.token_address_by_name('GHI') == Address(
'0x0300000000000000000000000000000000000000')
with pytest.raises(Exception):
ERC20Token.token_address_by_name('XXX')
def __init__(self, args):
self.id = bytes_to_int(args['id'])
self.maker = Address(args['maker'])
self.pay_token = Address(args['pay_gem'])
self.pay_amount = Wad(args['pay_amt'])
self.buy_token = Address(args['buy_gem'])
self.buy_amount = Wad(args['buy_amt'])
self.timestamp = args['timestamp']
def __init__(self, args):
self.id = bytes_to_int(args['id'])
self.maker = Address(args['maker'])
self.have_token = Address(args['haveToken'])
self.have_amount = Wad(args['haveAmount'])
self.want_token = Address(args['wantToken'])
self.want_amount = Wad(args['wantAmount'])
self.timestamp = args['timestamp']
def __init__(self, args):
self.token_get = Address(args['tokenGet'])
self.amount_get = Wad(args['amountGet'])
self.token_give = Address(args['tokenGive'])
self.amount_give = Wad(args['amountGive'])
self.expires = args['expires']
self.nonce = args['nonce']
self.user = Address(args['user'])
def test_should_fail_creation_from_invalid_representation(self):
# expect
with pytest.raises(Exception):
Address('0x000000000011111111110000000000111111111') # too short
# expect
with pytest.raises(Exception):
Address('0x00000000001111111111000000000011111111111') # too long
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.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')
def __init__(self, web3: Web3, address: Address):
self.web3 = web3
self.address = address
self._contractTub = self._get_contract(web3, self.abiTub, address)
self._contractTip = self._get_contract(
web3, self.abiTip, Address(self._contractTub.call().tip()))
self._contractJar = self._get_contract(
web3, self.abiJar, Address(self._contractTub.call().jar()))
self._contractJug = self._get_contract(
web3, self.abiJug, Address(self._contractTub.call().jug()))
def test_equality(self):
# given
address1a = Address('0x0000011111000001111100000111110000011111')
address1b = Address('0x0000011111000001111100000111110000011111')
address2 = Address('0x0000011111000001111100000111110000022222')
# expect
assert address1a == address1b
assert address1a != address2
assert address1b != address2
def test_equality(self):
# given
transfer1a = Transfer(
token_address=Address(
'0x0000011111222223333344444555556666677777'),
from_address=Address('0x0000000000111111111100000000001111111111'),
to_address=Address('0x1111111111000000000011111111110000000000'),
value=Wad.from_number(20))
transfer1b = Transfer(
token_address=Address(
'0x0000011111222223333344444555556666677777'),
from_address=Address('0x0000000000111111111100000000001111111111'),
to_address=Address('0x1111111111000000000011111111110000000000'),
value=Wad.from_number(20))
transfer2 = Transfer(
token_address=Address(
'0x0000011111222223333344444555556666677777'),
from_address=Address('0x0000000000111111111100000000001111111111'),
to_address=Address('0x1111111111000000000011111111112222222222'),
value=Wad.from_number(20))
# expect
assert transfer1a == transfer1b
assert transfer1b == transfer1a
assert transfer1a != transfer2
assert transfer1b != transfer2
assert transfer2 != transfer1a
assert transfer2 != transfer1b
def test_give(self, sai: SaiDeployment):
# given
sai.tub.open().transact()
# when
sai.tub.give(
1,
Address('0x0101010101020202020203030303030404040404')).transact()
# then
assert sai.tub.lad(1) == Address(
'0x0101010101020202020203030303030404040404')
def from_json(data: dict):
assert(isinstance(data, dict))
return OffChainOrder(token_get=Address(data['tokenGet']),
amount_get=Wad(int(data['amountGet'])),
token_give=Address(data['tokenGive']),
amount_give=Wad(int(data['amountGive'])),
expires=int(data['expires']),
nonce=int(data['nonce']),
v=int(data['v']),
r=hexstring_to_bytes(data['r']),
s=hexstring_to_bytes(data['s']),
user=Address(data['user']))
def test_parsing_receipt(self, receipt_success):
# given
receipt = Receipt(receipt_success)
# expect
assert receipt.transaction_hash == '0x8b6851e40d017b2004a54eae3e9e47614398b54bbbaae150eaa889ec36470ec8'
assert receipt.gas_used == 57192
assert len(receipt.transfers) == 1
assert receipt.transfers[0] == Transfer(
token_address=Address(
'0x53eccc9246c1e537d79199d0c7231e425a40f896'),
from_address=Address('0x375d52588c3f39ee7710290237a95c691d8432e7'),
to_address=Address('0x0046f01ad360270605e0e5d693484ec3bfe43ba8'),
value=Wad.from_number(1))
def __init__(self, auction_manager, auction_id, auction_info):
self._auction_manager = auction_manager
self.auction_id = auction_id
self.creator = Address(auction_info[0])
self.selling = ERC20Token(web3=auction_manager.web3,
address=Address(auction_info[1]))
self.buying = ERC20Token(web3=auction_manager.web3,
address=Address(auction_info[2]))
self.start_bid = Wad(auction_info[3])
self.min_increase = auction_info[4]
self.min_decrease = auction_info[5]
self.sell_amount = Wad(auction_info[6])
self.ttl = auction_info[7]
self.reversed = auction_info[8]
self.unsold = auction_info[9]
def test_ordering(self):
# given
address1 = Address('0x0000011111000001111100000111110000011111')
address2 = Address('0x0000011111000001111100000111110000022222')
address3 = Address('0x0000011111000001111100000111110000033333')
# expect
assert address1 < address2
assert not address1 > address2
assert address2 > address1
assert not address2 < address1
assert address1 <= address2
assert address2 >= address1
assert address1 < address3
assert address1 <= address3
def pot(self) -> Address:
"""Get the good debt vault.
Returns:
The address of the `DSVault` holding the good debt.
"""
return Address(self._contractTub.call().pot())
def __init__(self):
super().__init__()
self.offchain = self.arguments.offchain
self.order_age = self.arguments.order_age
self.max_eth_amount = Wad.from_number(self.arguments.max_eth_amount)
self.min_eth_amount = Wad.from_number(self.arguments.min_eth_amount)
self.max_sai_amount = Wad.from_number(self.arguments.max_sai_amount)
self.min_sai_amount = Wad.from_number(self.arguments.min_sai_amount)
self.eth_reserve = Wad.from_number(self.arguments.eth_reserve)
self.min_margin = self.arguments.min_margin
self.avg_margin = self.arguments.avg_margin
self.max_margin = self.arguments.max_margin
self.etherdelta_address = Address(
self.config.get_config()["etherDelta"]["contract"])
self.etherdelta_api_server = self.config.get_config()["etherDelta"]["apiServer"][1] \
if "apiServer" in self.config.get_config()["etherDelta"] \
else None
self.etherdelta = EtherDelta(web3=self.web3,
address=self.etherdelta_address,
api_server=self.etherdelta_api_server)
if self.offchain and not self.etherdelta.supports_offchain_orders():
raise Exception(
"Off-chain EtherDelta orders not supported on this chain")
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('0x6666655555444441111188888777770000099999'),
fee_make=Wad.from_number(0.01),
fee_take=Wad.from_number(0.02),
fee_rebate=Wad.from_number(0.03),
api_server=None)
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 lps(self) -> Address:
"""Get the LPS token (liquidity provider shares).
Returns:
The address of the LPS token.
"""
return Address(self._contract.call().lps())
def authority(self) -> Address:
"""Return the current `authority` of a `DSAuth`-ed contract.
Returns:
The address of the current `authority`.
"""
return Address(self._contract.call().authority())
def alt(self) -> Address:
"""Get the alt token.
Returns:
The address of the alt token.
"""
return Address(self._contract.call().alt())
def tip(self) -> Address:
"""Get the target price engine.
Returns:
The address of the target price engine. It is an internal component of Sai.
"""
return Address(self._contract.call().tip())
def jug(self) -> Address:
"""Get the SAI/SIN tracker.
Returns:
The address of the SAI/SIN tracker token.
"""
return Address(self._contractTub.call().jug())
def ref(self) -> Address:
"""Get the ref token.
Returns:
The address of the ref token.
"""
return Address(self._contract.call().ref())
def pip(self) -> Address:
"""Get the GEM price feed.
Returns:
The address of the GEM price feed, which could be a `DSValue`, a `DSCache`, a `Mednianizer` etc.
"""
return Address(self._contractJar.call().pip())
def gem(self) -> Address:
"""Get the collateral token (eg. W-ETH).
Returns:
The address of the collateral token.
"""
return Address(self._contractTub.call().gem())
def skr(self) -> Address:
"""Get the SKR token.
Returns:
The address of the SKR token.
"""
return Address(self._contractTub.call().skr())
def jar(self) -> Address:
"""Get the collateral vault.
Returns:
The address of the `SaiJar` vault. It is an internal component of Sai.
"""
return Address(self._contractTub.call().jar())
def pit(self) -> Address:
"""Get the liquidator vault.
Returns:
The address of the `DSVault` holding the bad debt.
"""
return Address(self._contractTub.call().pit())
