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())