class MyCommunity(TunnelCommunity):
master_peer = Peer(
"307e301006072a8648ce3d020106052b81040024036a00040112bc352a3f40dd5b6b34f28c82636b3614855179338a1c2f9ac87af17f5af3084955c4f58d9a48d35f6216aac27d68e04cb6c200025046155983a3ae1378320d93e3d865c6ab63b3f11a6c74fc510fa67b2b5f448de756b4114f765c80069e9faa51476604d9d4"
.decode('HEX'))
def __init__(self, my_peer, endpoint, network):
super(MyCommunity, self).__init__(my_peer, endpoint, network)
self.settings = TunnelSettings()
self.settings.become_exitnode = True
print self.settings.become_exitnode
def started(self):
def print_peers():
print "I am:", self.my_peer, "\nI know:", [
str(p) for p in self.get_peers()
]
print self.settings.become_exitnode
print "relay_session_keys", self.relay_session_keys
for p in self.get_peers():
print("any node",
[c.peer.address
for c in self.circuits.values()], "exit node",
[c.address for c in self.exit_candidates.values()])
# We register a Twisted task with this overlay.
# This makes sure that the task ends when this overlay is unloaded.
# We call the 'print_peers' function every 5.0 seconds, starting now.
self.register_task("print_peers", LoopingCall(print_peers)).start(
5.0, True).addErrback(log.err)
def create_community(ipv8, country, state, city, street, number):
property_details = {
"country": country,
"state": state,
"city": city,
"street": street,
"number": number
}
community_key = ECCrypto().generate_key(u"medium")
community_key_hash = hashlib.sha224(
json.dumps(property_details)).hexdigest()
community_peer = Peer(community_key)
community = BOBChainCommunity(community_peer, ipv8.endpoint, ipv8.network,
**property_details)
ipv8.overlays.append(community)
for walker in [{
'strategy': "EdgeWalk",
'peers': 20,
'init': {
'edge_length': 4,
'neighborhood_size': 6,
'edge_timeout': 3.0
}
}]:
strategy_class = _WALKERS.get(
walker['strategy'],
community.get_available_strategies().get(walker['strategy']))
args = walker['init']
target_peers = walker['peers']
ipv8.strategies.append((strategy_class(community,
**args), target_peers))
for config in [('started', )]:
reactor.callWhenRunning(getattr(community, config[0]), *config[1:])
class DAppCrowdTrustchainCommunity(TrustChainCommunity):
master_peer = Peer(
unhexlify(
'3081a7301006072a8648ce3d020106052b81040027038192000404267964a5be4a43ee1e59397c6765'
'8db0dadc276a89163a3b1f7dec3fdb4cecd94dd80968c9983bfffcd2cd58e8ec7ada6dded7ff3b389b'
'85f691ee0e7981326b4b4deb80ad536801d781795a335f501b80c00b479f076f0384fa7fa3bd940f76'
'82840dae77d46f938f49743acb5d2ab723046982608d60f2398853f9898d97e4e3b35fa19eb92f0ba2'
'c1570a31ae72'))
DB_CLASS = DAppCrowdTrustChainDatabase
def __init__(self, *args, **kwargs):
super(DAppCrowdTrustchainCommunity, self).__init__(*args, **kwargs)
self.persistence.my_peer = self.my_peer
def get_github_profile(self, username):
"""
Get the GitHub profile for a given username.
"""
return requests.get("https://api.github.com/users/%s" %
username).json()
def import_github_profile(self, username):
"""
Import your GitHub profile.
"""
profile_info = self.get_github_profile(username)
#mid = self.my_peer.mid.encode('hex')
#if not profile_info['bio'] or mid not in profile_info['bio']:
# return fail(RuntimeError("your member ID (%s) should be in the GitHub bio!" % mid))
# Challenge successful, create TrustChain block
tx = {
'platform': 'github',
'info': {
'username': username,
'followers': profile_info['followers']
}
}
return self.create_source_block(block_type='devid_connection',
transaction=tx)
def add_skill(self, name):
"""
Add a skill to your developer portfolio.
"""
tx = {'name': name}
return self.create_source_block(block_type='devid_skill',
transaction=tx)
def endorse_skill(self, public_key, block_num):
"""
Endorse a specific skill of another user, identified by a public key and block number
"""
source_block = self.persistence.get(public_key, block_num)
return self.create_link(source_block)
def get_peer_from_public_key(self, public_key):
if type(public_key) == bytes:
b = public_key
key = default_eccrypto.key_from_public_bin(public_key)
else:
b = public_key.key_to_bin()
key = public_key
for peer in self.get_peers():
if peer.public_key.key_to_bin() == b:
return peer
return Peer(key)
class MyCommunity(Community):
master_peer = Peer(ECCrypto().generate_key(u"medium"))
def started(self):
async def print_peers():
print("I am:", self.my_peer, "\nI know:",
[str(p) for p in self.get_peers()])
# We register a asyncio task with this overlay.
# This makes sure that the task ends when this overlay is unloaded.
# We call the 'print_peers' function every 5.0 seconds, starting now.
self.register_task("print_peers", print_peers, interval=5.0, delay=0)
class TrustClient(TrustChainCommunity):
master_peer = Peer(
"307e301006072a8648ce3d020106052b81040024036a000401142bae9f90e77434a6ddda16c9bc913a3440366b9eedc9e57a660789e10aa3f470c1f7ae769083a3494be79ad78165caed85da009a7e897bd51e531e9fd90465c038993d2bbe6646b592872cb432c818ce9fa6e3ae0382a76d39ef982fb85801279def1409a86a"
.decode('HEX'))
DB_NAME = 'trustchain_client'
def __init__(self, my_peer, endpoint, network):
super(TrustClient, self).__init__(my_peer, endpoint, network)
# self.add_listener(TestBlockListener(), ['test'])
self.count = 0
self.his_key = ''
self.my_key = self.my_peer.public_key.key_to_bin()
self._balance = 0
def started(self):
def print_peers():
print "I am:", self.my_peer, "\nI know:", [
str(p) for p in self.get_peers()
]
for p in self.get_peers():
self.his_node = p
self.his_pubkey = p.public_key.key_to_bin()
self.send_sign()
self.check_db(self.count)
self.count += 1
self.register_task("print_peers", LoopingCall(print_peers)).start(5.0, True) \
.addErrback(log.err)
def check_db(self, count):
print "persistence", count, self.persistence.get(self.his_key, count)
# print "persistence", self.persistence._getall(u"", ())
def send_sign(self):
transaction = self.create_transaction()
print transaction
self.sign_block(self.his_node,
public_key=self.his_pubkey,
block_type='test',
transaction=transaction)
def create_transaction(self):
debit = 0
credit = 1
self._balance += debit - credit
bill = {
'identity': 'client->',
'debit': debit,
'credit': credit,
'balance': self._balance
}
return bill
class MyCommunity(Community):
# master_peer = Peer(ECCrypto().generate_key(u"medium"))
master_peer = Peer(
"307e301006072a8648ce3d020106052b81040024036a00040112bc352a3f40dd5b6b34f28c82636b3614855179338a1c2f9ac87af17f5af3084955c4f58d9a48d35f6216aac27d68e04cb6c200025046155983a3ae1378320d93e3d865c6ab63b3f11a6c74fc510fa67b2b5f448de756b4114f765c80069e9faa51476604d9d4"
.decode('HEX'))
def started(self):
def print_peers():
print "I am:", self.my_peer, "\nI know:", [str(p) for p in self.get_peers()]
# We register a Twisted task with this overlay.
# This makes sure that the task ends when this overlay is unloaded.
# We call the 'print_peers' function every 5.0 seconds, starting now.
self.register_task("print_peers", LoopingCall(print_peers)).start(5.0, True)
class TrustServer(TrustChainCommunity):
master_peer = Peer(
"307e301006072a8648ce3d020106052b81040024036a000401142bae9f90e77434a6ddda16c9bc913a3440366b9eedc9e57a660789e10aa3f470c1f7ae769083a3494be79ad78165caed85da009a7e897bd51e531e9fd90465c038993d2bbe6646b592872cb432c818ce9fa6e3ae0382a76d39ef982fb85801279def1409a86a"
.decode('HEX'))
DB_NAME = 'trustchain_server'
def __init__(self, my_peer, endpoint, network):
super(TrustServer, self).__init__(my_peer, endpoint, network)
# self.add_listener(TestBlockListener(), ['test'])
# self.my_key = self.my_peer.public_key.key_to_bin()
self.his_pubkey = ''
self.count = 0
self._balance = 0
def started(self):
def start_communication():
for p in self.get_peers():
print "New host {} join the network".format(p)
self.my_key = self.my_peer.public_key.key_to_bin()
self.his_node = p
self.his_pubkey = p.public_key.key_to_bin()
self.send_sign()
self.check_db(self.count)
self.register_task("start_communication", LoopingCall(start_communication)).start(5.0, True) \
.addErrback(log.err)
def send_sign(self):
transaction = self.create_transaction()
print transaction
self.sign_block(self.his_node,
public_key=self.his_pubkey,
block_type='test',
transaction=transaction)
def create_transaction(self):
debit = 1
credit = 0
self._balance += debit - credit
bill = {
'identity': 'server->',
"debit": debit,
"credit": credit,
"balance": self._balance
}
return bill
def check_db(self, count):
print "from persistence", count, self.persistence.get(
self.my_key, count)
class MyCommunity(TunnelCommunity):
master_peer = Peer(
"307e301006072a8648ce3d020106052b81040024036a00040112bc352a3f40dd5b6b34f28c82636b3614855179338a1c2f9ac87af17f5af3084955c4f58d9a48d35f6216aac27d68e04cb6c200025046155983a3ae1378320d93e3d865c6ab63b3f11a6c74fc510fa67b2b5f448de756b4114f765c80069e9faa51476604d9d4"
.decode('HEX'))
def __init__(self, my_peer, endpoint, network):
super(MyCommunity, self).__init__(my_peer, endpoint, network)
self.settings = TunnelSettings()
self.settings.become_exitnode = False
self.nodes = {}
# self.build_tunnels(1)
@inlineCallbacks
def build_conn(self):
yield self.introduce_nodes()
self.nodes[0].overlay.build_tunnels(1)
@inlineCallbacks
def introduce_nodes(self):
for node in self.nodes:
for other in self.nodes:
if other != node:
print(other.endpoint.get_address())
node.overlay.walk_to(other.endpoint.wan_address)
# I know: ['Peer<145.94.160.220:8092, xDPZmlsmAw/fGvdp+fTH0e9Ra78=>', 'Peer<145.94.160.220:8090, 4uQM2VNhSL0gbBHiVcEzxQJLI50=>']
# yield self.deliver_messages()
def started(self):
def print_peers():
print "I am:", self.my_peer, "\nI know:", [
str(p) for p in self.get_peers()
]
print "relay_session_keys", self.relay_session_keys
for p in self.get_peers():
print("any node",
[c.peer.address
for c in self.circuits.values()], "exit node",
[c.address for c in self.exit_candidates.values()])
if p not in self.nodes:
self.nodes[p] = None
# We register a Twisted task with this overlay.
# This makes sure that the task ends when this overlay is unloaded.
# We call the 'print_peers' function every 5.0 seconds, starting now.
self.register_task("print_peers",
LoopingCall(print_peers)).start(5.0, True)
def create_community(self, country, state, city, street, number):
property_details = {"country": country,
"state": state,
"city": city,
"street": street,
"number": number}
community_key = ECCrypto().generate_key(u"medium")
community_peer = Peer(community_key)
print "Community peer %s ...." % community_peer
community = BOBChainCommunity(community_peer, self.ipv8.endpoint, self.ipv8.network, **property_details)
self.ipv8.overlays.append(community)
for walker in [{
'strategy': "EdgeWalk",
'peers': 20,
'init': {
'edge_length': 4,
'neighborhood_size': 6,
'edge_timeout': 3.0
}
}]:
strategy_class = _WALKERS.get(walker['strategy'],
community.get_available_strategies().get(walker['strategy']))
args = walker['init']
target_peers = walker['peers']
self.ipv8.strategies.append((strategy_class(community, **args), target_peers))
for config in [('started',)]:
reactor.callWhenRunning(getattr(community, config[0]), *config[1:])
communities[country][state][city][street][number] = community
community_key_hash = hashlib.sha224(json.dumps(property_details)).hexdigest()
with open("keys\\" + str(community_key_hash) + ".pem", 'w') as f:
f.write(community_key.key_to_bin())
with open('property_to_key_mappings.json', 'w') as file:
l = []
for country, states in communities.items():
for state, cities in states.items():
for city, streets in cities.items():
for street, numbers in streets.items():
for number in numbers:
l.append([{
"country": country,
"state": state,
"city": city,
"street": street,
"number": number,
}, community_key_hash])
json.dump(l, file)
class MyCommunity(Community):
master_peer = Peer(
"307e301006072a8648ce3d020106052b81040024036a00040112bc352a3f40dd5b6b34f28c82636b3614855179338a1c2f9ac87af17f5af3084955c4f58d9a48d35f6216aac27d68e04cb6c200025046155983a3ae1378320d93e3d865c6ab63b3f11a6c74fc510fa67b2b5f448de756b4114f765c80069e9faa51476604d9d4"
.decode('HEX'))
# master_peer = Peer(
# "307e301006072a8648ce3d020106052b81040024036a000400d6911c823cfddc8842131e0306795ba9e652f8f0ecfe627b70d5469b30de14d3289b2899ffb655bc8e01631c9a7fbfecd5db42017718bdcd0e5acf218494e4085277e048ecb34e30218d0f3131c45627b345789753109b570d987c679ecb99a9a85c072de67bc6"
# .decode('HEX'))
def started(self):
def print_peers():
print "I am:", self.endpoint.get_address(), repr(self.my_peer.mid), "\nI know:", [str(p) for p in self.get_peers()]
# print self.network.services_per_peer
# print "address", self.network._all_addresses
# print "blacklist", self.network.blacklist, self.network.blacklist_mids
# We register a Twisted task with this overlay.
# This makes sure that the task ends when this overlay is unloaded.
# We call the 'print_peers' function every 5.0 seconds, starting now.
self.register_task("print_peers", LoopingCall(print_peers)).start(5.0, True).addErrback(log.err)
class MyCommunity(Community):
master_peer = Peer(
"307e301006072a8648ce3d020106052b81040024036a000400d6911c823cfddc8842131e0306795ba9e652f8f0ecfe627b70d5469b30de14d3289b2899ffb655bc8e01631c9a7fbfecd5db42017718bdcd0e5acf218494e4085277e048ecb34e30218d0f3131c45627b345789753109b570d987c679ecb99a9a85c072de67bc6"
.decode('HEX'))
def started(self):
def print_peers():
print "I am:", self.endpoint.get_address(), repr(
self.my_peer.mid), "\nI know:", [
str(p) for p in self.get_peers()
]
print "address", self.network._all_addresses
print "blacklist", self.network.blacklist, self.network.blacklist_mids
# We register a Twisted task with this overlay.
# This makes sure that the task ends when this overlay is unloaded.
# We call the 'print_peers' function every 5.0 seconds, starting now.
self.register_task("print_peers", LoopingCall(print_peers)).start(
5.0, True).addErrback(log.err)
class MyCommunity(Community):
master_peer = Peer(
"307e301006072a8648ce3d020106052b81040024036a00040112bc352a3f40dd5b6b34f28c82636b3614855179338a1c2f9ac87af17f5af3084955c4f58d9a48d35f6216aac27d68e04cb6c200025046155983a3ae1378320d93e3d865c6ab63b3f11a6c74fc510fa67b2b5f448de756b4114f765c80069e9faa51476604d9d4"
.decode('HEX'))
def started(self):
def print_peers():
print "walk to .."
self.walk_to(('127.0.0.1', 8090))
print "I am:", self.endpoint.get_address(), repr(
self.my_peer.mid), "\nI know:", [
str(p) for p in self.get_peers()
]
# print "address", self.network._all_addresses
# We register a Twisted task with this overlay.
# This makes sure that the task ends when this overlay is unloaded.
# We call the 'print_peers' function every 5.0 seconds, starting now.
self.register_task("print_peers", LoopingCall(print_peers)).start(
5.0, True).addErrback(log.err)
from socks5_ipv8.Message import Message
from pyipv8.ipv8_service import IPv8, _COMMUNITIES
from pyipv8.ipv8.configuration import get_default_configuration
from pyipv8.ipv8.messaging.anonymization.community import TunnelCommunity, TunnelSettings, CIRCUIT_STATE_READY
# master_peer_init = Peer(
# "307e301006072a8648ce3d020106052b81040024036a00040112bc352a3f40dd5b6b34f28c82636b3614855179338a1c2f9ac87af17f5af3084955c4f58d9a48d35f6216aac27d68e04cb6c200025046155983a3ae1378320d93e3d865c6ab63b3f11a6c74fc510fa67b2b5f448de756b4114f765c80069e9faa51476604d9d4"
# .decode('HEX'))
#
# master_peer_init = Peer(
# "307e301006072a8648ce3d020106052b81040024036a0004017dc7230411163214d17a4a1c3b2ec63c4ce5e56509041bcebb8f8e55c1befea14101e2499d8dbd0d9d1412fade2e8079fa171000fea5c0ad4ace791b6cb1708e46ccb6709afe90a18f303ad6f50afb9fcb64bf929419b00ba87ed81ca6b2e7100b75f53937ffe4"
# .decode('HEX'))
master_peer_init = Peer(
"307e301006072a8648ce3d020106052b81040024036a000401487c28074a4594a1089cb2efa6788678c1053cc42d07284a70dd06d8210ef8d433c98728a24f8ccca1634e62c0d986b2af97620167d013d284574b7095ae3029fd5b679d59f1283815d575c66c95f996ccef2173fd652893b13a23c8209c8eb39a0a10985b8f4d"
.decode('Hex'))
# master_peer_init = Peer(
# "307e301006072a8648ce3d020106052b81040024036a000400e0ba96c684c264342852cf25a75868524589dfbf81454074ea6ea379d1c3a6f9b85e3007d970916e18aeca17d6e99ce52c4a24013bf8ee92ee291d92cdc34ce0f59f1b98027e979f0f6157a8f5579356791fa7a88bd6a697d8ba3bce81d6547e46e4f76e135922"
# .decode('Hex')
# )
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s %(levelname)-8s %(message)s',
datefmt='%Y-%m-%d %H:%M:%S',
filemode='a+')
# IPv8 node
# ----------------------------------------------------------------------------------------------------------------------
import logging
import time
import random
# from socks5_udp.database import ProxyDatabase
# from socks5_udp.payload import IdentityRequestPayload, IdentityResponsePayload, TargetAddressPayload, Message, \
# ACKPayload
key1 = ECCrypto().generate_key(u"medium")
# master_peer_init = Peer(key1)
logging.info(key1.pub().key_to_bin().encode('HEX'))
# master_peer_init = Peer(key1.pub().key_to_bin().encode('HEX').decode('HEX'))
print key1.pub().key_to_bin().encode('HEX')
master_peer_init = Peer(
"307e301006072a8648ce3d020106052b81040024036a00040112bc352a3f40dd5b6b34f28c82636b3614855179338a1c2f9ac87af17f5af3084955c4f58d9a48d35f6216aac27d68e04cb6c200025046155983a3ae1378320d93e3d865c6ab63b3f11a6c74fc510fa67b2b5f448de756b4114f765c80069e9faa51476604d9d4"
.decode('HEX'))
class Server(Community):
master_peer = master_peer_init
DB_NAME = 'trustchain_server'
def __init__(self, my_peer, endpoint, network):
super(Server, self).__init__(my_peer, endpoint, network)
self.host_dict = {}
self.client_dict = {}
self.state = 'ADDRESS_FROM_SOCKS5'
self.remote_protocol = None
self.remote_factory = None
self.buffer = None
from twisted.internet import protocol
from twisted.internet.task import LoopingCall
from twisted.internet.protocol import Factory, ClientFactory
from pyipv8.ipv8.peer import Peer
from socks5_ipv8.Message import Message
from pyipv8.ipv8_service import IPv8, _COMMUNITIES
from pyipv8.ipv8.configuration import get_default_configuration
from pyipv8.ipv8.messaging.anonymization.community import TunnelCommunity, TunnelSettings, CIRCUIT_STATE_READY
# master_peer_init = Peer(
# "307e301006072a8648ce3d020106052b81040024036a00040112bc352a3f40dd5b6b34f28c82636b3614855179338a1c2f9ac87af17f5af3084955c4f58d9a48d35f6216aac27d68e04cb6c200025046155983a3ae1378320d93e3d865c6ab63b3f11a6c74fc510fa67b2b5f448de756b4114f765c80069e9faa51476604d9d4"
# .decode('HEX'))
master_peer_init = Peer(
"307e301006072a8648ce3d020106052b81040024036a0004017dc7230411163214d17a4a1c3b2ec63c4ce5e56509041bcebb8f8e55c1befea14101e2499d8dbd0d9d1412fade2e8079fa171000fea5c0ad4ace791b6cb1708e46ccb6709afe90a18f303ad6f50afb9fcb64bf929419b00ba87ed81ca6b2e7100b75f53937ffe4"
.decode('HEX'))
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s %(levelname)-8s %(message)s',
datefmt='%Y-%m-%d %H:%M:%S',
filemode='a+')
# IPv8 node
# ----------------------------------------------------------------------------------------------------------------------
# For peer discovery ...
class MultiProxy(TunnelCommunity):
master_peer = master_peer_init
def __init__(self, my_peer, endpoint, network):
class DAppCrowdCommunity(Community, BlockListener):
master_peer = Peer(
unhexlify(
'3081a7301006072a8648ce3d020106052b81040027038192000406297d96eafe1f25408ecc44062310'
'67d4d644bf837e051d64fee582788544b360d30f21004eeb7f3425331423c7d5c9cc56ad7358558a43'
'6fd46ac53dc9f25575f4b28a512c8ca002aaab6d820800634f009a8d509e600a9c7f9a171e9d0c3a66'
'd2a823a5f6d6d2bfb5d96c1725163b03242a1e6b7d51ae110d5666d696640f4e3633bd9da346397dcd'
'0dd47bd6fe29'))
def __init__(self, *args, **kwargs):
working_directory = kwargs.pop('working_directory', '')
self.trustchain = kwargs.pop('trustchain')
self.ipfs_api = kwargs.pop('ipfs_api')
super(DAppCrowdCommunity, self).__init__(*args, **kwargs)
self.persistence = DAppCrowdDatabase(working_directory, 'dappcrowd',
self.ipfs_api,
self.trustchain.persistence)
self.persistence.my_peer = self.my_peer
self.trustchain.add_listener(
self,
['dappcoder_project', 'dappcoder_submission', 'dappcoder_review'])
def should_sign(self, block):
if block.type == 'dappcrowd_review_request':
return False # We counter-sign this one manually
return True
def received_block(self, block):
if block.type == 'dappcoder_project' and not self.persistence.has_project(
block.public_key, block.transaction['id']):
self.persistence.add_project(block)
if block.type == 'dappcoder_submission' and not self.persistence.has_submission(
block.public_key, block.transaction['id']):
self.persistence.add_submission(block)
if block.type == 'dappcoder_review' and not self.persistence.has_review(
block.public_key, block.transaction['id']):
self.persistence.add_review(block)
def create_project(self, name, specifications, deadline, reward, currency,
min_reviews):
"""
Create a new project.
"""
# Add specifications to IPFS
pointer = self.ipfs_api.add_json({"specifications": specifications})
tx = {
'id':
self.persistence.get_next_project_id(
self.trustchain.my_peer.public_key.key_to_bin()),
'name':
name,
'specifications':
pointer,
'deadline':
deadline,
'reward':
reward,
'currency':
currency,
'min_reviews':
min_reviews,
'notary_signature':
'a' * 64,
}
return self.trustchain.create_source_block(
block_type='dappcoder_project', transaction=tx)
def create_submission(self, project_public_key, project_id, submission):
"""
Create a submission for a given project.
"""
if not self.persistence.has_project(project_public_key, project_id):
raise RuntimeError("This project does not exist.")
# TODO check deadline expiration!
# Add submission to IPFS
pointer = self.ipfs_api.add_json({"submission": submission})
tx = {
'project_pk':
project_public_key,
'project_id':
project_id,
'id':
self.persistence.get_next_submission_id(
self.trustchain.my_peer.public_key.key_to_bin()),
'submission':
pointer
}
return self.trustchain.create_source_block(
block_type='dappcoder_submission', transaction=tx)
def create_review(self, submission_public_key, submission_id, review):
"""
Create a review for a given submission.
"""
# Add review to IPFS
pointer = self.ipfs_api.add_json({"review": review})
tx = {
'submission_pk':
submission_public_key,
'submission_id':
submission_id,
'id':
self.persistence.get_next_review_id(
self.trustchain.my_peer.public_key.key_to_bin()),
'review':
pointer
}
return self.trustchain.create_source_block(
block_type='dappcoder_review', transaction=tx)
def request_review(self, submission_id, requester_pub_key):
"""
Request a review for a submission from another peer.
"""
tx = {'submission_id': submission_id}
peer = self.network.get_verified_by_public_key_bin(requester_pub_key)
self.trustchain.sign_block(peer,
requester_pub_key,
block_type='dappcrowd_review_request',
transaction=tx)
def respond_to_review_request(self, block_hash, accept):
"""
Accept/reject a review request for a given block hash
"""
block = self.trustchain.persistence.get_block_with_hash(block_hash)
peer = self.network.get_verified_by_public_key_bin(block.public_key)
self.trustchain.sign_block(peer,
linked=block,
additional_info={'accept': accept})
def unload(self):
super(DAppCrowdCommunity, self).unload()
# Close the persistence layer
self.persistence.close()
# master_peer_init = Peer(
# "307e301006072a8648ce3d020106052b81040024036a00040112bc352a3f40dd5b6b34f28c82636b3614855179338a1c2f9ac87af17f5af3084955c4f58d9a48d35f6216aac27d68e04cb6c200025046155983a3ae1378320d93e3d865c6ab63b3f11a6c74fc510fa67b2b5f448de756b4114f765c80069e9faa51476604d9d4"
# .decode('HEX'))
#
# master_peer_init = Peer(
# "307e301006072a8648ce3d020106052b81040024036a0004017dc7230411163214d17a4a1c3b2ec63c4ce5e56509041bcebb8f8e55c1befea14101e2499d8dbd0d9d1412fade2e8079fa171000fea5c0ad4ace791b6cb1708e46ccb6709afe90a18f303ad6f50afb9fcb64bf929419b00ba87ed81ca6b2e7100b75f53937ffe4"
# .decode('HEX'))
# master_peer_init = Peer(
# "307e301006072a8648ce3d020106052b81040024036a000401487c28074a4594a1089cb2efa6788678c1053cc42d07284a70dd06d8210ef8d433c98728a24f8ccca1634e62c0d986b2af97620167d013d284574b7095ae3029fd5b679d59f1283815d575c66c95f996ccef2173fd652893b13a23c8209c8eb39a0a10985b8f4d"
# .decode('Hex')
# )
master_peer_init = Peer(
"307e301006072a8648ce3d020106052b81040024036a000400e0ba96c684c264342852cf25a75868524589dfbf81454074ea6ea379d1c3a6f9b85e3007d970916e18aeca17d6e99ce52c4a24013bf8ee92ee291d92cdc34ce0f59f1b98027e979f0f6157a8f5579356791fa7a88bd6a697d8ba3bce81d6547e46e4f76e135922"
.decode('Hex')
)
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(levelname)-8s %(message)s',
datefmt='%Y-%m-%d %H:%M:%S', filemode='a+')
# IPv8 node
# ----------------------------------------------------------------------------------------------------------------------
# For peer discovery ...
class MultiProxy(TunnelCommunity):
master_peer = master_peer_init
def __init__(self, my_peer, endpoint, network):
super(MultiProxy, self).__init__(my_peer, endpoint, network)
self.message = message
def to_pack_list(self):
return [('raw', self.message)]
@classmethod
def from_unpack_list(cls, message):
return cls(message)
key1 = ECCrypto().generate_key(u"medium")
# master_peer_init = Peer(key1)
logging.info(key1.pub().key_to_bin().encode('HEX'))
# master_peer_init = Peer(key1.pub().key_to_bin().encode('HEX').decode('HEX'))
master_peer_init = Peer(
"307e301006072a8648ce3d020106052b81040024036a00040046d529db97b697d56b33d7935cd9213df309a7c3eb96a15c494ee72697f1d192c649d0666e903977de4a412649a28c970af0940155bfe7d7e0abd13e0bf7673b65f087a976deac412464c4959da06cc36945eee5017ec2007cca71841c6cddce8a84e525e64c88"
.decode('HEX'))
class MyServer(Community):
master_peer = master_peer_init
def __init__(self, my_peer, endpoint, network):
super(MyServer, self).__init__(my_peer, endpoint, network)
self.decode_map[chr(1)] = self.on_message
self.addr_set = set()
self.conn_socks = {}
def started(self):
def start_communication():
for p in self.get_peers():