def setUp(self):
yield super(TestTrustchainStatsEndpoint, self).setUp()
self.mock_ipv8 = MockIPv8(
u"low",
TrustChainCommunity,
working_directory=self.session.config.get_state_dir())
self.session.lm.trustchain_community = self.mock_ipv8.overlay
self.session.lm.wallets['MB'] = TrustchainWallet(
self.session.lm.trustchain_community)
def create_node(self):
mock_ipv8 = MockIPv8(u"curve25519", TriblerTunnelCommunity, socks_listen_ports=[])
mock_ipv8.overlay.settings.max_circuits = 1
# Load the TrustChain community
overlay = TrustChainCommunity(mock_ipv8.my_peer, mock_ipv8.endpoint, mock_ipv8.network,
working_directory=u":memory:")
mock_ipv8.overlay.bandwidth_wallet = TrustchainWallet(overlay)
mock_ipv8.overlay.dht_provider = MockDHTProvider(mock_ipv8.endpoint.wan_address)
return mock_ipv8
def create_node(self):
mock_ipv8 = MockIPv8(u"curve25519", TriblerTunnelCommunity, socks_listen_ports=[],
exitnode_cache=join(mkdtemp(suffix="_tribler_test_cache"), 'cache.dat'))
mock_ipv8.overlay.settings.max_circuits = 1
# Load the TrustChain community
mock_ipv8.trustchain = TrustChainCommunity(mock_ipv8.my_peer, mock_ipv8.endpoint, mock_ipv8.network,
working_directory=u":memory:")
mock_ipv8.overlay.bandwidth_wallet = TrustchainWallet(mock_ipv8.trustchain)
mock_ipv8.overlay.dht_provider = MockDHTProvider(mock_ipv8.endpoint.wan_address)
return mock_ipv8
def create_node(self):
dum1_wallet = DummyWallet1()
dum2_wallet = DummyWallet2()
dum1_wallet.MONITOR_DELAY = 0
dum2_wallet.MONITOR_DELAY = 0
wallets = {'DUM1': dum1_wallet, 'DUM2': dum2_wallet}
mock_ipv8 = MockIPv8(u"curve25519", MarketCommunity, create_trustchain=True, create_dht=True,
is_matchmaker=True, wallets=wallets, use_database=False, working_directory=u":memory:")
tc_wallet = TrustchainWallet(mock_ipv8.trustchain)
mock_ipv8.overlay.wallets['MB'] = tc_wallet
return mock_ipv8
def load_ipv8_overlays(self):
# Discovery Community
with open(self.session.config.get_permid_keypair_filename(),
'r') as key_file:
content = key_file.read()
content = content[31:-30].replace('\n', '').decode("BASE64")
peer = Peer(M2CryptoSK(keystring=content))
discovery_community = DiscoveryCommunity(peer, self.ipv8.endpoint,
self.ipv8.network)
discovery_community.resolve_dns_bootstrap_addresses()
self.ipv8.overlays.append(discovery_community)
self.ipv8.strategies.append((RandomChurn(discovery_community), -1))
if not self.session.config.get_dispersy_enabled():
self.ipv8.strategies.append((RandomWalk(discovery_community), 20))
if self.session.config.get_testnet():
peer = Peer(self.session.trustchain_keypair)
else:
peer = Peer(self.session.trustchain_testnet_keypair)
# TrustChain Community
if self.session.config.get_trustchain_enabled():
from Tribler.pyipv8.ipv8.attestation.trustchain.community import TrustChainCommunity, \
TrustChainTestnetCommunity
community_cls = TrustChainTestnetCommunity if self.session.config.get_testnet(
) else TrustChainCommunity
self.trustchain_community = community_cls(
peer,
self.ipv8.endpoint,
self.ipv8.network,
working_directory=self.session.config.get_state_dir())
self.ipv8.overlays.append(self.trustchain_community)
self.ipv8.strategies.append(
(EdgeWalk(self.trustchain_community), 20))
tc_wallet = TrustchainWallet(self.trustchain_community)
self.wallets[tc_wallet.get_identifier()] = tc_wallet
# Tunnel Community
if self.session.config.get_tunnel_community_enabled():
from Tribler.community.triblertunnel.community import TriblerTunnelCommunity, TriblerTunnelTestnetCommunity
community_cls = TriblerTunnelTestnetCommunity if self.session.config.get_testnet() else \
TriblerTunnelCommunity
self.tunnel_community = community_cls(
peer,
self.ipv8.endpoint,
self.ipv8.network,
tribler_session=self.session,
dht_provider=MainlineDHTProvider(
self.mainline_dht,
self.session.config.get_dispersy_port()),
bandwidth_wallet=self.wallets["MB"])
self.ipv8.overlays.append(self.tunnel_community)
self.ipv8.strategies.append(
(RandomWalk(self.tunnel_community), 20))
# Market Community
if self.session.config.get_market_community_enabled():
from Tribler.community.market.community import MarketCommunity, MarketTestnetCommunity
community_cls = MarketTestnetCommunity if self.session.config.get_testnet(
) else MarketCommunity
self.market_community = community_cls(
peer,
self.ipv8.endpoint,
self.ipv8.network,
tribler_session=self.session,
trustchain=self.trustchain_community,
wallets=self.wallets,
working_directory=self.session.config.get_state_dir())
self.ipv8.overlays.append(self.market_community)
self.ipv8.strategies.append(
(RandomWalk(self.market_community), 20))
# Popular Community
if self.session.config.get_popularity_community_enabled():
from Tribler.community.popularity.community import PopularityCommunity
self.popularity_community = PopularityCommunity(
peer,
self.ipv8.endpoint,
self.ipv8.network,
torrent_db=self.session.lm.torrent_db,
session=self.session)
self.ipv8.overlays.append(self.popularity_community)
self.ipv8.strategies.append(
(RandomWalk(self.popularity_community), 20))
self.popularity_community.start()
def load_ipv8_overlays(self):
# Discovery Community
with open(self.session.config.get_permid_keypair_filename(), 'r') as key_file:
content = key_file.read()
content = content[31:-30].replace('\n', '').decode("BASE64")
peer = Peer(M2CryptoSK(keystring=content))
discovery_community = DiscoveryCommunity(peer, self.ipv8.endpoint, self.ipv8.network)
discovery_community.resolve_dns_bootstrap_addresses()
self.ipv8.overlays.append(discovery_community)
self.ipv8.strategies.append((RandomChurn(discovery_community), -1))
if not self.session.config.get_dispersy_enabled():
self.ipv8.strategies.append((RandomWalk(discovery_community), 20))
if self.session.config.get_testnet():
peer = Peer(self.session.trustchain_testnet_keypair)
else:
peer = Peer(self.session.trustchain_keypair)
# TrustChain Community
if self.session.config.get_trustchain_enabled():
from Tribler.pyipv8.ipv8.attestation.trustchain.community import TrustChainCommunity, \
TrustChainTestnetCommunity
community_cls = TrustChainTestnetCommunity if self.session.config.get_testnet() else TrustChainCommunity
self.trustchain_community = community_cls(peer, self.ipv8.endpoint,
self.ipv8.network,
working_directory=self.session.config.get_state_dir())
self.ipv8.overlays.append(self.trustchain_community)
self.ipv8.strategies.append((EdgeWalk(self.trustchain_community), 20))
tc_wallet = TrustchainWallet(self.trustchain_community)
self.wallets[tc_wallet.get_identifier()] = tc_wallet
# DHT Community
if self.session.config.get_dht_enabled():
from Tribler.pyipv8.ipv8.dht.discovery import DHTDiscoveryCommunity
self.dht_community = DHTDiscoveryCommunity(peer, self.ipv8.endpoint, self.ipv8.network)
self.ipv8.overlays.append(self.dht_community)
self.ipv8.strategies.append((RandomWalk(self.dht_community), 20))
# Tunnel Community
if self.session.config.get_tunnel_community_enabled():
from Tribler.community.triblertunnel.community import TriblerTunnelCommunity, TriblerTunnelTestnetCommunity
community_cls = TriblerTunnelTestnetCommunity if self.session.config.get_testnet() else \
TriblerTunnelCommunity
if self.mainline_dht:
dht_provider = MainlineDHTProvider(self.mainline_dht, self.session.config.get_dispersy_port())
else:
dht_provider = DHTCommunityProvider(self.dht_community, self.session.config.get_dispersy_port())
self.tunnel_community = community_cls(peer, self.ipv8.endpoint, self.ipv8.network,
tribler_session=self.session,
dht_provider=dht_provider,
bandwidth_wallet=self.wallets["MB"])
self.ipv8.overlays.append(self.tunnel_community)
self.ipv8.strategies.append((RandomWalk(self.tunnel_community), 20))
# Market Community
if self.session.config.get_market_community_enabled() and self.session.config.get_dht_enabled():
from Tribler.community.market.community import MarketCommunity, MarketTestnetCommunity
community_cls = MarketTestnetCommunity if self.session.config.get_testnet() else MarketCommunity
self.market_community = community_cls(peer, self.ipv8.endpoint, self.ipv8.network,
tribler_session=self.session,
trustchain=self.trustchain_community,
dht=self.dht_community,
wallets=self.wallets,
working_directory=self.session.config.get_state_dir())
self.ipv8.overlays.append(self.market_community)
self.ipv8.strategies.append((RandomWalk(self.market_community), 20))
# Popular Community
if self.session.config.get_popularity_community_enabled():
from Tribler.community.popularity.community import PopularityCommunity
self.popularity_community = PopularityCommunity(peer, self.ipv8.endpoint, self.ipv8.network,
torrent_db=self.session.lm.torrent_db, session=self.session)
self.ipv8.overlays.append(self.popularity_community)
self.ipv8.strategies.append((RandomWalk(self.popularity_community), 20))
self.popularity_community.start()
def setUp(self):
super(TestTrustchainWallet, self).setUp()
self.initialize(TrustChainCommunity, 2)
self.tc_wallet = TrustchainWallet(self.nodes[0].overlay)
self.tc_wallet.MONITOR_DELAY = 0.01
self.tc_wallet.check_negative_balance = True
class TestTrustchainWallet(TestBase):
def setUp(self):
super(TestTrustchainWallet, self).setUp()
self.initialize(TrustChainCommunity, 2)
self.tc_wallet = TrustchainWallet(self.nodes[0].overlay)
self.tc_wallet.MONITOR_DELAY = 0.01
self.tc_wallet.check_negative_balance = True
def create_node(self):
return MockIPv8(u"curve25519",
TrustChainCommunity,
working_directory=u":memory:")
def test_get_mc_wallet_name(self):
"""
Test the identifier of the Trustchain wallet
"""
self.assertEqual(self.tc_wallet.get_name(), 'Tokens (MB)')
def test_get_mc_wallet_id(self):
"""
Test the identifier of a Trustchain wallet
"""
self.assertEqual(self.tc_wallet.get_identifier(), 'MB')
@trial_timeout(2)
@inlineCallbacks
def test_get_balance(self):
"""
Test the balance retrieval of a Trustchain wallet
"""
yield self.introduce_nodes()
balance = yield self.tc_wallet.get_balance()
self.assertEqual(balance['available'], 0)
his_pubkey = self.nodes[0].network.verified_peers[
0].public_key.key_to_bin()
tx = {
'up': 20 * 1024 * 1024,
'down': 5 * 1024 * 1024,
'total_up': 20 * 1024 * 1024,
'total_down': 5 * 1024 * 1024
}
self.nodes[0].overlay.sign_block(
self.nodes[0].network.verified_peers[0],
public_key=his_pubkey,
block_type='tribler_bandwidth',
transaction=tx)
yield self.deliver_messages()
balance = yield self.tc_wallet.get_balance()
self.assertEqual(balance['available'], 15)
def test_create_wallet(self):
"""
Test whether creating a Trustchain wallet raises an error
"""
self.assertRaises(RuntimeError, self.tc_wallet.create_wallet)
@inlineCallbacks
def test_transfer_invalid(self):
"""
Test the transfer method of a Trustchain wallet
"""
test_deferred = Deferred()
def on_error(failure):
self.assertIsInstance(failure.value, InsufficientFunds)
test_deferred.callback(None)
self.tc_wallet.transfer(200, None).addErrback(on_error)
yield test_deferred
@inlineCallbacks
def test_monitor_transaction(self):
"""
Test the monitoring of a transaction in a Trustchain wallet
"""
his_pubkey = self.nodes[0].overlay.my_peer.public_key.key_to_bin()
tx_deferred = self.tc_wallet.monitor_transaction(
'%s.1' % his_pubkey.encode('hex'))
# Now create the transaction
transaction = {
'up': 20 * 1024 * 1024,
'down': 5 * 1024 * 1024,
'total_up': 20 * 1024 * 1024,
'total_down': 5 * 1024 * 1024
}
self.nodes[1].overlay.sign_block(
self.nodes[1].network.verified_peers[0],
public_key=his_pubkey,
block_type='tribler_bandwidth',
transaction=transaction)
yield tx_deferred
@trial_timeout(2)
@inlineCallbacks
def test_monitor_tx_existing(self):
"""
Test monitoring a transaction that already exists
"""
transaction = {
'up': 20 * 1024 * 1024,
'down': 5 * 1024 * 1024,
'total_up': 20 * 1024 * 1024,
'total_down': 5 * 1024 * 1024
}
his_pubkey = self.nodes[0].overlay.my_peer.public_key.key_to_bin()
yield self.nodes[1].overlay.sign_block(
self.nodes[1].network.verified_peers[0],
public_key=his_pubkey,
block_type='tribler_bandwidth',
transaction=transaction)
yield self.tc_wallet.monitor_transaction('%s.1' %
his_pubkey.encode('hex'))
def test_address(self):
"""
Test the address of a Trustchain wallet
"""
self.assertIsInstance(self.tc_wallet.get_address(), str)
@inlineCallbacks
def test_get_transaction(self):
"""
Test the retrieval of transactions of a Trustchain wallet
"""
def on_transactions(transactions):
self.assertIsInstance(transactions, list)
yield self.tc_wallet.get_transactions().addCallback(on_transactions)
def test_min_unit(self):
"""
Test the minimum unit of a Trustchain wallet
"""
self.assertEqual(self.tc_wallet.min_unit(), 1)
@inlineCallbacks
def test_get_statistics(self):
"""
Test fetching statistics from a Trustchain wallet
"""
self.tc_wallet.check_negative_balance = False
res = self.tc_wallet.get_statistics()
self.assertEqual(res["total_blocks"], 0)
yield self.tc_wallet.transfer(5, self.nodes[1].overlay.my_peer)
res = self.tc_wallet.get_statistics()
self.assertTrue(res["latest_block"])
def __init__(self, trustchain, dht):
self.logger = logging.getLogger(self.__class__.__name__)
self.bandwidth_wallet = TrustchainWallet(trustchain)
self.dht = dht
self.tribler_peers = {}
def setUp(self):
super(TestTrustchainWallet, self).setUp()
self.initialize(TrustChainCommunity, 2)
self.tc_wallet = TrustchainWallet(self.nodes[0].overlay)
self.tc_wallet.MONITOR_DELAY = 0.01
self.tc_wallet.check_negative_balance = True
class TestTrustchainWallet(TestBase):
def setUp(self):
super(TestTrustchainWallet, self).setUp()
self.initialize(TrustChainCommunity, 2)
self.tc_wallet = TrustchainWallet(self.nodes[0].overlay)
self.tc_wallet.MONITOR_DELAY = 0.01
self.tc_wallet.check_negative_balance = True
def create_node(self):
return MockIPv8(u"curve25519", TrustChainCommunity, working_directory=u":memory:")
def test_get_mc_wallet_name(self):
"""
Test the identifier of the Trustchain wallet
"""
self.assertEqual(self.tc_wallet.get_name(), 'Tokens (MB)')
def test_get_mc_wallet_id(self):
"""
Test the identifier of a Trustchain wallet
"""
self.assertEqual(self.tc_wallet.get_identifier(), 'MB')
@trial_timeout(2)
@inlineCallbacks
def test_get_balance(self):
"""
Test the balance retrieval of a Trustchain wallet
"""
yield self.introduce_nodes()
balance = yield self.tc_wallet.get_balance()
self.assertEqual(balance['available'], 0)
his_pubkey = self.nodes[0].network.verified_peers[0].public_key.key_to_bin()
tx = {
'up': 20 * 1024 * 1024,
'down': 5 * 1024 * 1024,
'total_up': 20 * 1024 * 1024,
'total_down': 5 * 1024 * 1024
}
self.nodes[0].overlay.sign_block(self.nodes[0].network.verified_peers[0], public_key=his_pubkey,
block_type=b'tribler_bandwidth', transaction=tx)
yield self.deliver_messages()
balance = yield self.tc_wallet.get_balance()
self.assertEqual(balance['available'], 15)
def test_create_wallet(self):
"""
Test whether creating a Trustchain wallet raises an error
"""
self.assertRaises(RuntimeError, self.tc_wallet.create_wallet)
@inlineCallbacks
def test_transfer_invalid(self):
"""
Test the transfer method of a Trustchain wallet
"""
test_deferred = Deferred()
def on_error(failure):
self.assertIsInstance(failure.value, InsufficientFunds)
test_deferred.callback(None)
self.tc_wallet.transfer(200, None).addErrback(on_error)
yield test_deferred
@inlineCallbacks
def test_monitor_transaction(self):
"""
Test the monitoring of a transaction in a Trustchain wallet
"""
his_pubkey = self.nodes[0].overlay.my_peer.public_key.key_to_bin()
tx_deferred = self.tc_wallet.monitor_transaction(b'%s.1' % hexlify(his_pubkey))
# Now create the transaction
transaction = {
'up': 20 * 1024 * 1024,
'down': 5 * 1024 * 1024,
'total_up': 20 * 1024 * 1024,
'total_down': 5 * 1024 * 1024
}
self.nodes[1].overlay.sign_block(self.nodes[1].network.verified_peers[0], public_key=his_pubkey,
block_type=b'tribler_bandwidth', transaction=transaction)
yield tx_deferred
@trial_timeout(2)
@inlineCallbacks
def test_monitor_tx_existing(self):
"""
Test monitoring a transaction that already exists
"""
transaction = {
'up': 20 * 1024 * 1024,
'down': 5 * 1024 * 1024,
'total_up': 20 * 1024 * 1024,
'total_down': 5 * 1024 * 1024
}
his_pubkey = self.nodes[0].overlay.my_peer.public_key.key_to_bin()
yield self.nodes[1].overlay.sign_block(self.nodes[1].network.verified_peers[0], public_key=his_pubkey,
block_type=b'tribler_bandwidth', transaction=transaction)
yield self.tc_wallet.monitor_transaction(b'%s.1' % hexlify(his_pubkey))
def test_address(self):
"""
Test the address of a Trustchain wallet
"""
self.assertTrue(self.tc_wallet.get_address())
@inlineCallbacks
def test_get_transaction(self):
"""
Test the retrieval of transactions of a Trustchain wallet
"""
def on_transactions(transactions):
self.assertIsInstance(transactions, list)
yield self.tc_wallet.get_transactions().addCallback(on_transactions)
def test_min_unit(self):
"""
Test the minimum unit of a Trustchain wallet
"""
self.assertEqual(self.tc_wallet.min_unit(), 1)
@inlineCallbacks
def test_get_statistics(self):
"""
Test fetching statistics from a Trustchain wallet
"""
self.tc_wallet.check_negative_balance = False
res = self.tc_wallet.get_statistics()
self.assertEqual(res["total_blocks"], 0)
yield self.tc_wallet.transfer(5, self.nodes[1].overlay.my_peer)
res = self.tc_wallet.get_statistics()
self.assertTrue(res["latest_block"])
def load_ipv8_overlays(self):
if self.session.config.get_testnet():
peer = Peer(self.session.trustchain_testnet_keypair)
else:
peer = Peer(self.session.trustchain_keypair)
discovery_community = DiscoveryCommunity(peer, self.ipv8.endpoint,
self.ipv8.network)
discovery_community.resolve_dns_bootstrap_addresses()
self.ipv8.overlays.append(discovery_community)
self.ipv8.strategies.append((RandomChurn(discovery_community), -1))
self.ipv8.strategies.append(
(PeriodicSimilarity(discovery_community), -1))
self.ipv8.strategies.append((RandomWalk(discovery_community), 20))
# TrustChain Community
if self.session.config.get_trustchain_enabled():
from Tribler.pyipv8.ipv8.attestation.trustchain.community import TrustChainCommunity, \
TrustChainTestnetCommunity
community_cls = TrustChainTestnetCommunity if self.session.config.get_testnet(
) else TrustChainCommunity
self.trustchain_community = community_cls(
peer,
self.ipv8.endpoint,
self.ipv8.network,
working_directory=self.session.config.get_state_dir())
self.ipv8.overlays.append(self.trustchain_community)
self.ipv8.strategies.append(
(EdgeWalk(self.trustchain_community), 20))
tc_wallet = TrustchainWallet(self.trustchain_community)
self.wallets[tc_wallet.get_identifier()] = tc_wallet
# DHT Community
if self.session.config.get_dht_enabled():
from Tribler.pyipv8.ipv8.dht.discovery import DHTDiscoveryCommunity
self.dht_community = DHTDiscoveryCommunity(peer,
self.ipv8.endpoint,
self.ipv8.network)
self.ipv8.overlays.append(self.dht_community)
self.ipv8.strategies.append((RandomWalk(self.dht_community), 20))
# Tunnel Community
if self.session.config.get_tunnel_community_enabled():
from Tribler.community.triblertunnel.community import TriblerTunnelCommunity, TriblerTunnelTestnetCommunity
from Tribler.community.triblertunnel.discovery import GoldenRatioStrategy
community_cls = TriblerTunnelTestnetCommunity if self.session.config.get_testnet() else \
TriblerTunnelCommunity
random_slots = self.session.config.get_tunnel_community_random_slots(
)
competing_slots = self.session.config.get_tunnel_community_competing_slots(
)
dht_provider = DHTCommunityProvider(
self.dht_community, self.session.config.get_ipv8_port())
settings = TunnelSettings()
settings.min_circuits = 3
settings.max_circuits = 10
self.tunnel_community = community_cls(
peer,
self.ipv8.endpoint,
self.ipv8.network,
tribler_session=self.session,
dht_provider=dht_provider,
bandwidth_wallet=self.wallets["MB"],
random_slots=random_slots,
competing_slots=competing_slots,
settings=settings)
self.ipv8.overlays.append(self.tunnel_community)
self.ipv8.strategies.append(
(RandomWalk(self.tunnel_community), 20))
self.ipv8.strategies.append(
(GoldenRatioStrategy(self.tunnel_community), -1))
# Market Community
if self.session.config.get_market_community_enabled(
) and self.session.config.get_dht_enabled():
from Tribler.community.market.community import MarketCommunity, MarketTestnetCommunity
community_cls = MarketTestnetCommunity if self.session.config.get_testnet(
) else MarketCommunity
self.market_community = community_cls(
peer,
self.ipv8.endpoint,
self.ipv8.network,
tribler_session=self.session,
trustchain=self.trustchain_community,
dht=self.dht_community,
wallets=self.wallets,
working_directory=self.session.config.get_state_dir(),
record_transactions=self.session.config.
get_record_transactions())
self.ipv8.overlays.append(self.market_community)
self.ipv8.strategies.append(
(RandomWalk(self.market_community), 20))
# Popular Community
if self.session.config.get_popularity_community_enabled():
from Tribler.community.popularity.community import PopularityCommunity
self.popularity_community = PopularityCommunity(
peer,
self.ipv8.endpoint,
self.ipv8.network,
metadata_store=self.session.lm.mds,
session=self.session)
self.ipv8.overlays.append(self.popularity_community)
self.ipv8.strategies.append(
(RandomWalk(self.popularity_community), 20))
self.popularity_community.start()
# Gigachannel Community
if self.session.config.get_chant_enabled():
from Tribler.community.gigachannel.community import GigaChannelCommunity, GigaChannelTestnetCommunity
from Tribler.community.gigachannel.sync_strategy import SyncChannels
community_cls = GigaChannelTestnetCommunity if self.session.config.get_testnet(
) else GigaChannelCommunity
self.gigachannel_community = community_cls(
peer,
self.ipv8.endpoint,
self.ipv8.network,
self.mds,
notifier=self.session.notifier)
self.ipv8.overlays.append(self.gigachannel_community)
self.ipv8.strategies.append(
(RandomWalk(self.gigachannel_community), 20))
self.ipv8.strategies.append(
(SyncChannels(self.gigachannel_community), 20))
