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