def __init__(self, asset_address, peer1, peer2, settle_timeout, # pylint: disable=too-many-arguments address=None): self.address = address or make_address() self.contract = NettingChannelContract( asset_address, self.address, peer1, peer2, settle_timeout, )
def __init__(self, blockchain, asset_address, peer1, peer2, settle_timeout, # pylint: disable=too-many-arguments address=None): self.address = address or make_address() self.blockchain = blockchain self.contract = NettingChannelContract( asset_address, self.address, peer1, peer2, settle_timeout, ) self.newbalance_filters = list() self.secretrevealed_filters = list() self.channelclose_filters = list() self.channelsettle_filters = list()
def __init__(self, asset_address, peer1, peer2, settle_timeout, address=None): # pylint: disable=too-many-arguments self.address = address or make_address() self.contract = NettingChannelContract( asset_address, self.address, peer1, peer2, settle_timeout, )
def new_netting_contract(self, asset_address, peer1, peer2): """ Creates a new netting contract between peer1 and peer2. Raises: ValueError: If peer1 or peer2 is not a valid address. """ if not isaddress(peer1): raise ValueError('The pee1 must be a valid address') if not isaddress(peer2): raise ValueError('The peer2 must be a valid address') netcontract_address = bytes(sha3(peer1 + peer2)[:20]) hash_channel = self.asset_hashchannel[asset_address] if netcontract_address in hash_channel: raise ValueError('netting contract already exists') channel = NettingChannelContract(asset_address, netcontract_address, peer1, peer2) hash_channel[netcontract_address] = channel return netcontract_address
class NettingChannelMock(object): def __init__(self, blockchain, asset_address, peer1, peer2, settle_timeout, # pylint: disable=too-many-arguments address=None): self.address = address or make_address() self.blockchain = blockchain self.contract = NettingChannelContract( asset_address, self.address, peer1, peer2, settle_timeout, ) self.newbalance_filters = list() self.secretrevealed_filters = list() self.channelclose_filters = list() self.channelsettle_filters = list() def asset_address(self): return self.contract.asset_address def settle_timeout(self): return self.contract.settle_timeout def isopen(self): return self.contract.isopen def partner(self, our_address): return self.contract.partner(our_address) def deposit(self, our_address, amount): self.contract.deposit(our_address, amount, self.blockchain.block_number()) def opened(self): return self.contract.opened def closed(self): return self.contract.closed def settled(self): return self.contract.settled def detail(self, our_address): partner_address = self.contract.partner(our_address) our_balance = self.contract.participants[our_address].deposit partner_balance = self.contract.participants[partner_address].deposit return { 'our_address': our_address, 'our_balance': our_balance, 'partner_address': partner_address, 'partner_balance': partner_balance, 'settle_timeout': self.contract.settle_timeout, } def close(self, our_address, first_transfer, second_transfer): ctx = { 'block_number': self.blockchain.block_number(), 'msg.sender': our_address, } first_encoded = None second_encoded = None if first_transfer is not None: first_encoded = first_transfer.encode() if second_transfer is not None: second_encoded = second_transfer.encode() self.contract.close( ctx, first_encoded, second_encoded, ) def update_transfer(self, our_address, transfer): ctx = { 'block_number': self.blockchain.block_number(), 'msg.sender': our_address, } if transfer is not None: self.contract.update_transfer( ctx, transfer.encode(), ) def unlock(self, our_address, unlocked_transfers): ctx = { 'block_number': self.blockchain.block_number(), 'msg.sender': our_address, } for merkle_proof, locked_encoded, secret in unlocked_transfers: if isinstance(locked_encoded, messages.Lock): raise ValueError('unlock must be called with a lock encoded `.as_bytes`') merkleproof_encoded = ''.join(merkle_proof) self.contract.unlock( ctx, locked_encoded, merkleproof_encoded, secret, ) def settle(self): ctx = { 'block_number': self.blockchain.block_number(), } self.contract.settle(ctx) def channelnewbalance_filter(self): filter_ = FilterMock(None, next(FILTER_ID_GENERATOR)) self.newbalance_filters.append(filter_) return filter_ def channelsecretrevealed_filter(self): filter_ = FilterMock(None, next(FILTER_ID_GENERATOR)) self.secretrevealed_filters.append(filter_) return filter_ def channelclosed_filter(self): filter_ = FilterMock(None, next(FILTER_ID_GENERATOR)) self.channelclose_filters.append(filter_) return filter_ def channelsettled_filter(self): filter_ = FilterMock(None, next(FILTER_ID_GENERATOR)) self.channelsettle_filters.append(filter_) return filter_
class NettingChannelMock(object): def __init__(self, asset_address, peer1, peer2, settle_timeout, address=None): # pylint: disable=too-many-arguments self.address = address or make_address() self.contract = NettingChannelContract( asset_address, self.address, peer1, peer2, settle_timeout, ) def asset_address(self): return self.contract.asset_address def settle_timeout(self): return self.contract.settle_timeout def isopen(self): return self.contract.isopen def partner(self, our_address): return self.contract.partner(our_address) def deposit(self, our_address, amount): self.contract.deposit( our_address, amount, BlockChainServiceMock.block_number(), ) our_data = self.contract.participants[our_address] data = { '_event_type': 'ChannelNewBalance', 'asset_address': self.contract.asset_address, 'participant': our_address, 'balance': our_data.deposit, 'block_number': BlockChainServiceMock.block_number(), } event = ethereum_event( CHANNELNEWBALANCE_EVENTID, CHANNELNEWBALANCE_EVENT, data, self.address, ) for filter_ in BlockChainServiceMock.filters[self.address]: filter_.event(event) def transferred_amount(self, participant_address): # TODO: Make this work if we don't drop support for the mock client raise RuntimeError('transferredAmount not implemented for mock client') return self.contract._get_transferred_amount(None, None) def opened(self): return self.contract.opened def closed(self): return self.contract.closed def settled(self): return self.contract.settled def detail(self, our_address): partner_address = self.contract.partner(our_address) our_balance = self.contract.participants[our_address].deposit partner_balance = self.contract.participants[partner_address].deposit return { 'our_address': our_address, 'our_balance': our_balance, 'partner_address': partner_address, 'partner_balance': partner_balance, 'settle_timeout': self.contract.settle_timeout, } def close(self, our_address, first_transfer, second_transfer): ctx = { 'block_number': BlockChainServiceMock.block_number(), 'msg.sender': our_address, } first_encoded = None second_encoded = None if first_transfer is not None: first_encoded = first_transfer.encode() if second_transfer is not None: second_encoded = second_transfer.encode() self.contract.close( ctx, first_encoded, second_encoded, ) data = { '_event_type': 'ChannelClosed', 'closing_address': our_address, 'block_number': BlockChainServiceMock.block_number(), } event = ethereum_event(CHANNELCLOSED_EVENTID, CHANNELCLOSED_EVENT, data, self.address) for filter_ in BlockChainServiceMock.filters[self.address]: filter_.event(event) def update_transfer(self, our_address, first_transfer, second_transfer=None): ctx = { 'block_number': BlockChainServiceMock.block_number(), 'msg.sender': our_address, } if first_transfer is not None: self.contract.update_transfer( ctx, first_transfer.encode(), second_transfer.encode() if second_transfer is not None else "" ) def unlock(self, our_address, unlock_proofs): ctx = { 'block_number': BlockChainServiceMock.block_number(), 'msg.sender': our_address, } for merkle_proof, locked_encoded, secret in unlock_proofs: if isinstance(locked_encoded, messages.Lock): raise ValueError('unlock must be called with a lock encoded `.as_bytes`') merkleproof_encoded = ''.join(merkle_proof) self.contract.unlock( ctx, locked_encoded, merkleproof_encoded, secret, ) data = { '_event_type': 'ChannelSecretRevealed', 'secret': secret, } event = ethereum_event( CHANNELSECRETREVEALED_EVENTID, CHANNELSECRETREVEALED_EVENT, data, self.address, ) for filter_ in BlockChainServiceMock.filters[self.address]: filter_.event(event) def settle(self): ctx = { 'block_number': BlockChainServiceMock.block_number(), } self.contract.settle(ctx) data = { '_event_type': 'ChannelSettled', 'block_number': BlockChainServiceMock.block_number(), } event = ethereum_event(CHANNELSETTLED_EVENTID, CHANNELSETTLED_EVENT, data, self.address) for filter_ in BlockChainServiceMock.filters[self.address]: filter_.event(event) def all_events_filter(self): topics = None filter_ = FilterMock(topics, next(FILTER_ID_GENERATOR)) BlockChainServiceMock.filters[self.address].append(filter_) return filter_
class NettingChannelMock(object): """Shared state implementation of a pure python netting channel. You should not call this instance directly, but instead instantiate a raiden.tests.utils.OwnedNettingChannel with a fixed address. """ def __init__(self, token_address, peer1, peer2, settle_timeout, address=None): # pylint: disable=too-many-arguments self.address = address or make_address() self.contract = NettingChannelContract( token_address, self.address, peer1, peer2, settle_timeout, ) def token_address(self): return self.contract.token_address def settle_timeout(self): return self.contract.settle_timeout def can_transfer(self, our_address): return (self.contract.opened > 0 and self.contract.closed == 0 and self.detail(our_address)['our_balance'] > 0) def deposit(self, our_address, amount): self.contract.deposit( our_address, amount, BlockChainServiceMock.block_number(), ) our_data = self.contract.participants[our_address] data = { '_event_type': 'ChannelNewBalance', 'token_address': self.contract.token_address, 'participant': our_address, 'balance': our_data.deposit, 'block_number': BlockChainServiceMock.block_number(), } event = ethereum_event( CHANNELNEWBALANCE_EVENTID, CHANNELNEWBALANCE_EVENT, data, self.address, ) for filter_ in BlockChainServiceMock.filters[self.address]: filter_.event(event) def opened(self): return self.contract.opened def closed(self): return self.contract.closed def closing_address(self): closing_address = self.contract.closingAddress assert len(closing_address) == 20, "Expected binary address" return closing_address def settled(self): return self.contract.settled def detail(self, our_address): our_balance = self.contract.participants[our_address].deposit partner_address = self.contract.partner(our_address) partner_balance = self.contract.participants[partner_address].deposit return { 'our_address': our_address, 'our_balance': our_balance, 'partner_address': partner_address, 'partner_balance': partner_balance, 'settle_timeout': self.contract.settle_timeout, } def close(self, our_address, their_transfer): ctx = { 'block_number': BlockChainServiceMock.block_number(), 'msg.sender': our_address, } their_encoded = None if their_transfer is not None: their_encoded = their_transfer.encode() self.contract.close( ctx, their_encoded, ) data = { '_event_type': 'ChannelClosed', 'closing_address': our_address, 'block_number': BlockChainServiceMock.block_number(), } event = ethereum_event(CHANNELCLOSED_EVENTID, CHANNELCLOSED_EVENT, data, self.address) for filter_ in BlockChainServiceMock.filters[self.address]: filter_.event(event) def update_transfer(self, our_address, first_transfer, second_transfer=None): ctx = { 'block_number': BlockChainServiceMock.block_number(), 'msg.sender': our_address, } if first_transfer is not None: self.contract.update_transfer( ctx, first_transfer.encode(), second_transfer.encode() if second_transfer is not None else "") def withdraw(self, our_address, unlock_proofs): ctx = { 'block_number': BlockChainServiceMock.block_number(), 'msg.sender': our_address, } for merkle_proof, locked_encoded, secret in unlock_proofs: if isinstance(locked_encoded, messages.Lock): raise ValueError( 'withdraw must be called with a lock encoded `.as_bytes`') merkleproof_encoded = ''.join(merkle_proof) self.contract.withdraw( ctx, locked_encoded, merkleproof_encoded, secret, ) data = { '_event_type': 'ChannelSecretRevealed', 'secret': secret, } event = ethereum_event( CHANNELSECRETREVEALED_EVENTID, CHANNELSECRETREVEALED_EVENT, data, self.address, ) for filter_ in BlockChainServiceMock.filters[self.address]: filter_.event(event) def settle(self): ctx = { 'block_number': BlockChainServiceMock.block_number(), } self.contract.settle(ctx) data = { '_event_type': 'ChannelSettled', 'block_number': BlockChainServiceMock.block_number(), } event = ethereum_event(CHANNELSETTLED_EVENTID, CHANNELSETTLED_EVENT, data, self.address) for filter_ in BlockChainServiceMock.filters[self.address]: filter_.event(event) def all_events_filter(self): topics = None filter_ = FilterMock(topics, next(FILTER_ID_GENERATOR)) BlockChainServiceMock.filters[self.address].append(filter_) return filter_
class NettingChannelMock(object): def __init__(self, asset_address, peer1, peer2, settle_timeout, address=None): # pylint: disable=too-many-arguments self.address = address or make_address() self.contract = NettingChannelContract( asset_address, self.address, peer1, peer2, settle_timeout, ) def asset_address(self): return self.contract.asset_address def settle_timeout(self): return self.contract.settle_timeout def isopen(self): return self.contract.isopen def partner(self, our_address): return self.contract.partner(our_address) def deposit(self, our_address, amount): self.contract.deposit( our_address, amount, BlockChainServiceMock.block_number(), ) our_data = self.contract.participants[our_address] data = { '_event_type': 'ChannelNewBalance', 'asset_address': self.contract.asset_address, 'participant': our_address, 'balance': our_data.deposit, 'block_number': BlockChainServiceMock.block_number(), } event = ethereum_event( CHANNELNEWBALANCE_EVENTID, CHANNELNEWBALANCE_EVENT, data, self.address, ) for filter_ in BlockChainServiceMock.filters[self.address]: filter_.event(event) def opened(self): return self.contract.opened def closed(self): return self.contract.closed def settled(self): return self.contract.settled def detail(self, our_address): partner_address = self.contract.partner(our_address) our_balance = self.contract.participants[our_address].deposit partner_balance = self.contract.participants[partner_address].deposit return { 'our_address': our_address, 'our_balance': our_balance, 'partner_address': partner_address, 'partner_balance': partner_balance, 'settle_timeout': self.contract.settle_timeout, } def close(self, our_address, first_transfer, second_transfer): ctx = { 'block_number': BlockChainServiceMock.block_number(), 'msg.sender': our_address, } first_encoded = None second_encoded = None if first_transfer is not None: first_encoded = first_transfer.encode() if second_transfer is not None: second_encoded = second_transfer.encode() self.contract.close( ctx, first_encoded, second_encoded, ) data = { '_event_type': 'ChannelClosed', 'closing_address': our_address, 'block_number': BlockChainServiceMock.block_number(), } event = ethereum_event(CHANNELCLOSED_EVENTID, CHANNELCLOSED_EVENT, data, self.address) for filter_ in BlockChainServiceMock.filters[self.address]: filter_.event(event) def update_transfer(self, our_address, transfer): ctx = { 'block_number': BlockChainServiceMock.block_number(), 'msg.sender': our_address, } if transfer is not None: self.contract.update_transfer( ctx, transfer.encode(), ) def unlock(self, our_address, unlock_proofs): ctx = { 'block_number': BlockChainServiceMock.block_number(), 'msg.sender': our_address, } for merkle_proof, locked_encoded, secret in unlock_proofs: if isinstance(locked_encoded, messages.Lock): raise ValueError('unlock must be called with a lock encoded `.as_bytes`') merkleproof_encoded = ''.join(merkle_proof) self.contract.unlock( ctx, locked_encoded, merkleproof_encoded, secret, ) data = { '_event_type': 'ChannelSecretRevealed', 'secret': secret, } event = ethereum_event( CHANNELSECRETREVEALED_EVENTID, CHANNELSECRETREVEALED_EVENT, data, self.address, ) for filter_ in BlockChainServiceMock.filters[self.address]: filter_.event(event) def settle(self): ctx = { 'block_number': BlockChainServiceMock.block_number(), } self.contract.settle(ctx) data = { '_event_type': 'ChannelSettled', 'block_number': BlockChainServiceMock.block_number(), } event = ethereum_event(CHANNELSETTLED_EVENTID, CHANNELSETTLED_EVENT, data, self.address) for filter_ in BlockChainServiceMock.filters[self.address]: filter_.event(event) def channelnewbalance_filter(self): topics = [CHANNELNEWBALANCE_EVENTID] filter_ = FilterMock(topics, next(FILTER_ID_GENERATOR)) BlockChainServiceMock.filters[self.address].append(filter_) return filter_ def channelsecretrevealed_filter(self): topics = [CHANNELSECRETREVEALED_EVENTID] filter_ = FilterMock(topics, next(FILTER_ID_GENERATOR)) BlockChainServiceMock.filters[self.address].append(filter_) return filter_ def channelclosed_filter(self): topics = [CHANNELCLOSED_EVENTID] filter_ = FilterMock(topics, next(FILTER_ID_GENERATOR)) BlockChainServiceMock.filters[self.address].append(filter_) return filter_ def channelsettled_filter(self): topics = [CHANNELSETTLED_EVENTID] filter_ = FilterMock(topics, next(FILTER_ID_GENERATOR)) BlockChainServiceMock.filters[self.address].append(filter_) return filter_