def __init__(self,
wallet: Wallet,
ip_string: str,
ctx: zmq.asyncio.Context,
router: router.Router,
pepper: str = PEPPER):
self.wallet = wallet
self.ctx = ctx
self.peers = {self.wallet.verifying_key: ip_string}
# Add processors to router to accept and process networking messages
self.ip = ip_string
self.vk = self.wallet.verifying_key
self.join_processor = JoinProcessor(ctx=self.ctx,
peers=self.peers,
wallet=self.wallet)
self.identity_processor = IdentityProcessor(wallet=self.wallet,
ip_string=ip_string,
pepper=pepper)
self.peer_processor = PeerProcessor(peers=self.peers)
self.log = get_logger('Peers')
router.add_service(JOIN_SERVICE, self.join_processor)
router.add_service(IDENTITY_SERVICE, self.identity_processor)
router.add_service(PEER_SERVICE, self.peer_processor)
self.join_msg = {'ip': ip_string, 'vk': self.wallet.verifying_key}
def __init__(self, expected_subblocks=4, debug=True):
self.q = []
self.expected_subblocks = expected_subblocks
self.log = get_logger('Subblock Gatherer')
self.log.propagate = debug
self.block_q = []
def __init__(self, client: ContractingClient, ctx: zmq.asyncio.Context, bootnodes: dict={},
loop=asyncio.get_event_loop(), domain='*', cert_dir=CERT_DIR, debug=False):
# Create the directory if it doesn't exist
self.client = client
self.cert_dir = pathlib.Path.home() / cert_dir
self.cert_dir.mkdir(parents=True, exist_ok=True)
self.ctx = ctx
self.domain = domain
self.loop = loop
self.log = get_logger('zmq.auth')
self.log.propagate = debug
self.bootnodes = bootnodes
# This should throw an exception if the socket already exist
try:
self.authenticator = AsyncioAuthenticator(context=self.ctx, loop=self.loop)
self.authenticator.start()
except ZMQBaseError:
self.log.error('Error starting ZMQ Authenticator. Is it already running?')
finally:
for node in bootnodes.keys():
self.add_verifying_key(node)
self.authenticator.configure_curve(domain=self.domain, location=self.cert_dir)
def __init__(self, driver, expected_subblocks=4, seconds_to_timeout=6, debug=True):
self.expected_subblocks = expected_subblocks
self.sbc_inbox = SBCInbox(
expected_subblocks=self.expected_subblocks,
)
self.driver = driver
self.seconds_to_timeout = seconds_to_timeout
self.log = get_logger('AGG')
self.log.propagate = debug
def __init__(self, client: ContractingClient, nonces: storage.NonceStorage, debug=True, expired_batch=5,
tx_timeout=5):
self.new_work = defaultdict(list)
self.log = get_logger('Work Inbox')
self.log.propagate = debug
self.masters = []
self.expired_batch = expired_batch
self.tx_timeout = tx_timeout
self.client = client
self.nonces = nonces
def __init__(self, input_hash, index, total_contacts, required_consensus=0.66, adequate_consensus=0.50):
self.input_hash = input_hash
self.index = index
self.potential_solutions = {}
self.best_solution = None
self.total_responses = 0
self.total_contacts = total_contacts
self.required_consensus = required_consensus
self.adequate_consensus = adequate_consensus
self.log = get_logger('SBC')
def __init__(self, total_contacts, total_subblocks, required_consensus=0.66, acceptable_consensus=0.5):
self.total_contacts = total_contacts
self.total_subblocks = total_subblocks
self.required_consensus = required_consensus
# Acceptable consensus forces a block to complete. Anything below this will fail.
self.acceptable_consensus = acceptable_consensus
# Create an empty list to store the contenders as they come in
self.subblock_contenders = [None for _ in range(self.total_subblocks)]
self.log = get_logger('Aggregator')
self.received = defaultdict(set)
def __init__(self, parallelism=4, *args, **kwargs):
super().__init__(*args, **kwargs)
# Number of core / processes we push to
self.parallelism = parallelism
self.executor = Executor(driver=self.driver)
self.transaction_executor = execution.SerialExecutor(executor=self.executor)
self.work_processor = WorkProcessor(client=self.client, nonces=self.nonces)
self.router.add_service(WORK_SERVICE, self.work_processor)
self.upgrade_manager.node_type = 'delegate'
self.log = get_logger(f'Delegate {self.wallet.vk_pretty[4:12]}')
def __init__(self, num_of_masternodes, num_of_delegates, ctx):
self.masternodes = []
self.delegates = []
self.log = get_logger('MOCKNET')
self.ctx = ctx
for i in range(0, num_of_masternodes):
self.build_masternode(i)
for i in range(num_of_masternodes, num_of_delegates + num_of_masternodes):
self.build_delegate(i)
self.constitution = None
self.bootnodes = None
self.prepare_nodes_to_start()
from bson.codec_options import TypeCodec, TypeEncoder, TypeDecoder
from bson.codec_options import TypeRegistry
from bson.codec_options import CodecOptions
from decimal import Decimal
import lamden
from lamden.logger.base import get_logger
from contracting.stdlib.bridge.decimal import ContractingDecimal
BLOCK_HASH_KEY = '_current_block_hash'
BLOCK_NUM_HEIGHT = '_current_block_height'
NONCE_KEY = '__n'
PENDING_NONCE_KEY = '__pn'
log = get_logger('STATE')
class DecimalEncoder(TypeEncoder):
python_type = Decimal # the Python type acted upon by this type codec
def transform_python(self, value):
d = Decimal(str(value))
return Decimal128(d)
class ContractingDecimalEncoder(TypeEncoder):
python_type = ContractingDecimal # the Python type acted upon by this type codec
def transform_python(self, value):
d = Decimal(str(value._d))
import asyncio
from lamden.crypto.wallet import Wallet
import zmq
import zmq.asyncio
from contracting.db.encoder import encode, decode
from zmq.error import ZMQBaseError
from zmq.auth.certs import load_certificate
from lamden.logger.base import get_logger
import pathlib
import os
CERT_DIR = 'cilsocks'
DEFAULT_DIR = pathlib.Path.home() / CERT_DIR
logger = get_logger('Router')
OK = {
'response': 'ok'
}
def build_message(service, message):
return {
'service': service,
'msg': message
}
class Processor:
async def process_message(self, msg):
raise NotImplementedError
def __init__(self, debug=True, *args, **kwargs):
super().__init__(*args, **kwargs)
self.services = {}
self.log = get_logger(self.address)
self.log.propagate = debug
from contracting.db.encoder import encode
from collections import defaultdict
from lamden import router
from lamden.crypto.canonical import merklize, block_from_subblocks
from lamden.crypto.wallet import verify
from lamden.logger.base import get_logger
from lamden import storage
import asyncio
import time
log = get_logger('Contender')
class SBCInbox(router.Processor):
def __init__(self, expected_subblocks=4, debug=True):
self.q = []
self.expected_subblocks = expected_subblocks
self.log = get_logger('Subblock Gatherer')
self.log.propagate = debug
self.block_q = []
async def process_message(self, msg):
# Ignore bad message types
# Ignore if not enough subblocks
# Make sure all the contenders are valid
if len(msg) != self.expected_subblocks:
self.log.error('Contender does not have enough subblocks!')
return
for i in range(len(msg)):
def __init__(self,
socket_base,
ctx: zmq.asyncio.Context,
wallet,
constitution: dict,
bootnodes={},
blocks=storage.BlockStorage(),
driver=ContractDriver(),
debug=True,
store=False,
seed=None,
bypass_catchup=False,
node_type=None,
genesis_path=lamden.contracts.__path__[0],
reward_manager=rewards.RewardManager(),
nonces=storage.NonceStorage()):
self.driver = driver
self.nonces = nonces
self.store = store
self.seed = seed
self.blocks = blocks
self.event_writer = EventWriter()
self.log = get_logger('Base')
self.log.propagate = debug
self.socket_base = socket_base
self.wallet = wallet
self.ctx = ctx
self.genesis_path = genesis_path
self.client = ContractingClient(driver=self.driver,
submission_filename=genesis_path +
'/submission.s.py')
self.bootnodes = bootnodes
self.constitution = constitution
self.seed_genesis_contracts()
self.socket_authenticator = authentication.SocketAuthenticator(
bootnodes=self.bootnodes, ctx=self.ctx, client=self.client)
self.upgrade_manager = upgrade.UpgradeManager(client=self.client,
wallet=self.wallet,
node_type=node_type)
self.router = router.Router(socket_id=socket_base,
ctx=self.ctx,
wallet=wallet,
secure=True)
self.network = network.Network(wallet=wallet,
ip_string=socket_base,
ctx=self.ctx,
router=self.router)
self.new_block_processor = NewBlock(driver=self.driver)
self.router.add_service(
NEW_BLOCK_SERVICE,
self.new_block_processor) # Add this after catch up?
self.running = False
self.upgrade = False
self.reward_manager = reward_manager
self.current_height = storage.get_latest_block_height(self.driver)
self.current_hash = storage.get_latest_block_hash(self.driver)
self.bypass_catchup = bypass_catchup
def __init__(self, driver: ContractDriver):
self.q = []
self.driver = driver
self.log = get_logger('NBN')
from contracting.execution.executor import Executor
from contracting.stdlib.bridge.time import Datetime
from contracting.db.encoder import encode, safe_repr
from lamden.crypto.canonical import tx_hash_from_tx, format_dictionary, merklize
from lamden.logger.base import get_logger
from datetime import datetime
import multiprocessing as mp
import copy
from time import time, sleep
import queue
log = get_logger('EXE')
log.propagate = False
__N_WORKER_PER_DELEGATES__ = 4
__N_DELEGATES__ = 2
__N_WORKER__ = __N_WORKER_PER_DELEGATES__ * __N_DELEGATES__
PoolExecutor = None
stop_cmd = None
pool = []
busy_pool = []
N_TEST = 8
WORKER_SLEEP = 0.0001
RESULT_SLEEP = 0.01
POOL_WAIT_SLEEP = 0.01
TX_RERUN_SLEEP = 1
from collections import defaultdict
from contracting.stdlib.bridge.decimal import ContractingDecimal
from contracting.client import ContractingClient
from lamden.logger.base import get_logger
decimal.getcontext().rounding = decimal.ROUND_DOWN
REQUIRED_CONTRACTS = [
'stamp_cost', 'rewards', 'currency', 'election_house', 'foundation',
'masternodes', 'delegates'
]
DUST_EXPONENT = 8
log = get_logger('Rewards')
class RewardManager:
@staticmethod
def contract_exists(name: str, client: ContractingClient):
return client.get_contract(name) is not None
@staticmethod
def is_setup(client: ContractingClient):
for contract in REQUIRED_CONTRACTS:
if not RewardManager.contract_exists(contract, client):
log.error('Reward contracts not setup.')
return False
return True
import json
from copy import deepcopy
import hashlib
from contracting.db.encoder import encode
from lamden.logger.base import get_logger
log = get_logger('CANON')
GENESIS_HASH = b'\x00' * 32
def format_dictionary(d: dict) -> dict:
for k, v in d.items():
assert type(k) == str, 'Non-string key types not allowed.'
if type(v) == list:
for i in range(len(v)):
if isinstance(v[i], dict):
v[i] = format_dictionary(v[i])
elif isinstance(v, dict):
d[k] = format_dictionary(v)
return {k: v for k, v in sorted(d.items())}
def tx_hash_from_tx(tx):
h = hashlib.sha3_256()
tx_dict = format_dictionary(tx)
encoded_tx = encode(tx_dict).encode()
h.update(encoded_tx)
from lamden.crypto.transaction import TransactionException
from lamden.crypto.wallet import Wallet
import decimal
from contracting.stdlib.bridge.decimal import ContractingDecimal
from lamden.nodes.base import FileQueue
import ssl
import asyncio
from lamden.crypto import transaction
import decimal
# Instantiate the parser
import argparse
log = get_logger("MN-WebServer")
class ByteEncoder(_json.JSONEncoder):
def default(self, o, *args, **kwargs):
if isinstance(o, bytes):
return o.hex()
if isinstance(o, ContractingDecimal):
if int(o._d) == o._d:
return int(o._d)
else:
return {'__fixed__': str(o._d)}
if isinstance(o, decimal.Decimal):
if int(o) == o:
import asyncio
import hashlib
import time
from lamden import router
from lamden.crypto.wallet import Wallet
from lamden.storage import BlockStorage, get_latest_block_height
from lamden.nodes.masternode import contender, webserver
from lamden.nodes.base import FileQueue
from lamden.formatting import primatives
from lamden.nodes import base
from contracting.db.driver import ContractDriver
from contracting.db.encoder import decode
import copy
from lamden.logger.base import get_logger
mn_logger = get_logger('Masternode')
BLOCK_SERVICE = 'service'
class BlockService(router.Processor):
def __init__(self, blocks: BlockStorage=None, driver=ContractDriver()):
self.blocks = blocks
self.driver = driver
async def process_message(self, msg):
response = None
mn_logger.debug('Got a msg')
mn_logger.debug(msg)
if primatives.dict_has_keys(msg, keys={'name', 'arg'}):
if msg['name'] == base.GET_BLOCK:
import time
import hashlib
import asyncio
import os
import zmq.asyncio
from contracting.db.encoder import encode
from lamden.formatting import rules, primatives
from lamden.crypto.wallet import Wallet, verify
from lamden import router
from lamden.logger.base import get_logger
PROOF_EXPIRY = 15
PEPPER = 'cilantroV1'
LOGGER = get_logger('Network')
JOIN_SERVICE = 'join' # Unsecured
IDENTITY_SERVICE = 'identity' # Unsecured
PEER_SERVICE = 'peers'
def verify_proof(proof, pepper):
# Proofs expire after a minute
if not primatives.check_format(proof, rules.PROOF_MESSAGE_RULES):
return False
if int(time.time()) - proof['timestamp'] > PROOF_EXPIRY:
return False
message = [pepper, proof['ip'], proof['timestamp']]
message_bytes = encode(message).encode()
