def main(): # Setup the blockchain # settings.setup('./neo-python/protocol.coz.json') blockchain = LevelDBBlockchain(settings.LEVELDB_PATH) Blockchain.RegisterBlockchain(blockchain) dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks) dbloop.start(.1) NodeLeader.Instance().Start() # Disable smart contract events for external smart contracts settings.set_log_smart_contract_events(False) # Start a thread with custom code d = threading.Thread(target=log_block) d.setDaemon( True ) # daemonizing the thread will kill it when the main thread is quit d.start() # Run all the things (blocking call) logger.info("Everything setup and running. Waiting for events...") reactor.run() logger.info("Shutting down.")
def main(): # Use PrivateNet settings.setup_privnet() # Setup the blockchain blockchain = LevelDBBlockchain(settings.chain_leveldb_path) Blockchain.RegisterBlockchain(blockchain) dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks) dbloop.start(.1) NodeLeader.Instance().Start() # Disable smart contract events for external smart contracts settings.set_log_smart_contract_events(False) # Start a thread with custom code d = threading.Thread(target=custom_background_code) d.setDaemon(True) # daemonizing the thread will kill it when the main thread is quit d.start() # Run all the things (blocking call) logger.info("Everything setup and running. Waiting for events...") reactor.run() logger.info("Shutting down.")
def run(self): # Setup the blockchain self.blockchain = LevelDBBlockchain(settings.chain_leveldb_path) Blockchain.RegisterBlockchain(self.blockchain) NodeLeader.Instance().Start() dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks) dbloop.start(.1) Blockchain.Default().PersistBlocks() # Disable smart contract events for external smart contracts settings.set_log_smart_contract_events(False) # if the wallet was set up (by setting a path and loading the password), then open it! if self.wallet_path: self.wallet_open() # Start a thread with custom code d = threading.Thread(target=self.custom_background_code) d.setDaemon( True ) # daemonizing the thread will kill it when the main thread is quit d.start() # invoke any pre-start action that needs to occur before we start the reactor. # optional for subclasses to implement. self.pre_start() # Run all the things (blocking call) self.logger.info("Everything setup and running. Waiting for events...") reactor.run() self.logger.info("Shutting down") if self.wallet_path: self.wallet_close() Blockchain.Default().Dispose() NodeLeader.Instance().Shutdown() self.logger.info("Shut down.")
def main(): settings.setup_privnet(True) settings.set_log_smart_contract_events(True) # Instantiate the blockchain and subscribe to notifications blockchain = LevelDBBlockchain(settings.chain_leveldb_path) Blockchain.RegisterBlockchain(blockchain) args = sys.argv[1:] args += os.getenv('CONTRACT_FILE', '').split(' ') args += os.getenv('CONTRACT_ARGS', '').split(' ') args = list(filter(None, args)) if len(args) < 2: # must provide file name and arguments print("WARN! No smart contracts args... skip") return app = ImportSC(args, blockchain, reactor) loop = task.LoopingCall(blockchain.PersistBlocks) deferred = loop.start(.1) deferred.addErrback(app.on_loopError) # Try to set up a notification db if NotificationDB.instance(): NotificationDB.instance().start() NodeLeader.Instance().Start() NodeLeader.Instance().PeerCheckLoop() # PyAssumeType(twisted.internet.reactor, twisted.internet.selectreactor.SelectReactor) reactor.callInThread(app.worker) reactor.run() NotificationDB.close() Blockchain.Default().Dispose() NodeLeader.Instance().Shutdown()
class PromptInterface(object): go_on = True _walletdb_loop = None Wallet = None _known_things = [] commands = [ 'quit', 'help', 'block {index/hash} (tx)', 'header {index/hash}', 'tx {hash}', 'asset {assetId}', 'asset search {query}', 'contract {contract hash}', 'contract search {query}', 'notifications {block_number or address}', 'mem', 'nodes', 'state', 'config debug {on/off}', 'config sc-events {on/off}', 'build {path/to/file.py} (test {params} {returntype} {needs_storage} {needs_dynamic_invoke} {test_params})', 'load_run {path/to/file.avm} (test {params} {returntype} {needs_storage} {needs_dynamic_invoke} {test_params})', 'import wif {wif}', 'import nep2 {nep2_encrypted_key}', 'import contract {path/to/file.avm} {params} {returntype} {needs_storage} {needs_dynamic_invoke}', 'import contract_addr {contract_hash} {pubkey}', 'import watch_addr {address}', 'import token {token_contract_hash}', 'export wif {address}', 'export nep2 {address}', 'open wallet {path}', 'create wallet {path}', 'wallet {verbose}', 'wallet claim', 'wallet migrate', 'wallet rebuild {start block}', 'wallet delete_addr {addr}', 'wallet alias {addr} {title}', 'wallet tkn_send {token symbol} {address_from} {address to} {amount} ', 'wallet tkn_send_from {token symbol} {address_from} {address to} {amount}', 'wallet tkn_approve {token symbol} {address_from} {address to} {amount}', 'wallet tkn_allowance {token symbol} {address_from} {address to}', 'wallet tkn_mint {token symbol} {mint_to_addr} (--attach-neo={amount}, --attach-gas={amount})', 'wallet unspent', 'wallet close', 'withdraw_request {asset_name} {contract_hash} {to_addr} {amount}', 'withdraw holds # lists all current holds', 'withdraw completed # lists completed holds eligible for cleanup', 'withdraw cancel # cancels current holds', 'witdraw cleanup # cleans up completed holds', 'withdraw # withdraws the first hold availabe', 'withdraw all # withdraw all holds available', 'send {assetId or name} {address} {amount} (--from-addr={addr})', 'sign {transaction in JSON format}', 'testinvoke {contract hash} {params} (--attach-neo={amount}, --attach-gas={amount})', 'debugstorage {on/off/reset}' ] history = FileHistory(FILENAME_PROMPT_HISTORY) token_style = None start_height = None start_dt = None def __init__(self): self.input_parser = InputParser() self.start_height = Blockchain.Default().Height self.start_dt = datetime.datetime.utcnow() self.token_style = style_from_dict({ Token.Command: preferences.token_style['Command'], Token.Neo: preferences.token_style['Neo'], Token.Default: preferences.token_style['Default'], Token.Number: preferences.token_style['Number'], }) def get_bottom_toolbar(self, cli=None): out = [] try: out = [(Token.Command, '[%s] Progress: ' % settings.net_name), (Token.Number, str(Blockchain.Default().Height)), (Token.Neo, '/'), (Token.Number, str(Blockchain.Default().HeaderHeight))] except Exception as e: pass return out def get_completer(self): standard_completions = [ 'block', 'tx', 'header', 'mem', 'neo', 'gas', 'help', 'state', 'nodes', 'exit', 'quit', 'config', 'import', 'export', 'open', 'wallet', 'contract', 'asset', 'wif', 'watch_addr', 'contract_addr', 'testinvoke', 'tkn_send', 'tkn_mint', 'tkn_send_from', 'tkn_approve', 'tkn_allowance', 'build', 'notifications', ] if self.Wallet: for addr in self.Wallet.Addresses: if addr not in self._known_things: self._known_things.append(addr) for alias in self.Wallet.NamedAddr: if alias.Title not in self._known_things: self._known_things.append(alias.Title) for tkn in self.Wallet.GetTokens().values(): if tkn.symbol not in self._known_things: self._known_things.append(tkn.symbol) all_completions = standard_completions + self._known_things completer = WordCompleter(all_completions) return completer def quit(self): print('Shutting down. This may take a bit...') self.go_on = False self.do_close_wallet() reactor.stop() def help(self): tokens = [] for c in self.commands: tokens.append((Token.Command, "%s\n" % c)) print_tokens(tokens, self.token_style) def do_open(self, arguments): if self.Wallet: self.do_close_wallet() item = get_arg(arguments) if item and item == 'wallet': path = get_arg(arguments, 1) if path: if not os.path.exists(path): print("Wallet file not found") return passwd = prompt("[password]> ", is_password=True) password_key = to_aes_key(passwd) try: print(path) self.Wallet = UserWallet.Open(path, password_key) self._walletdb_loop = task.LoopingCall( self.Wallet.ProcessBlocks) self._walletdb_loop.start(1) print("Opened wallet at bleeepp blooop %s" % path) except Exception as e: print("Could not open wallet: %s" % e) else: print("Please specify a path") else: print("Please specify something to open") def do_create(self, arguments): item = get_arg(arguments) if item and item == 'wallet': path = get_arg(arguments, 1) if path: if os.path.exists(path): print("File already exists") return passwd1 = prompt("[password]> ", is_password=True) passwd2 = prompt("[password again]> ", is_password=True) if passwd1 != passwd2 or len(passwd1) < 10: print( "Please provide matching passwords that are at least 10 characters long" ) return password_key = to_aes_key(passwd1) try: self.Wallet = UserWallet.Create(path=path, password=password_key) contract = self.Wallet.GetDefaultContract() key = self.Wallet.GetKey(contract.PublicKeyHash) print("Wallet %s" % json.dumps(self.Wallet.ToJson(), indent=4)) print("Pubkey %s" % key.PublicKey.encode_point(True)) except Exception as e: print("Exception creating wallet: %s" % e) self.Wallet = None if os.path.isfile(path): try: os.remove(path) except Exception as e: print("Could not remove {}: {}".format(path, e)) return if self.Wallet: self._walletdb_loop = task.LoopingCall( self.Wallet.ProcessBlocks) self._walletdb_loop.start(1) else: print("Please specify a path") def do_close_wallet(self): if self.Wallet: path = self.Wallet._path self._walletdb_loop.stop() self._walletdb_loop = None self.Wallet.Close() self.Wallet = None print("Closed wallet %s" % path) def do_import(self, arguments): item = get_arg(arguments) if not item: print("Please specify something to import") return if item == 'wif': if not self.Wallet: print("Please open a wallet before importing WIF") return wif = get_arg(arguments, 1) if not wif: print("Please supply a valid WIF key") return try: prikey = KeyPair.PrivateKeyFromWIF(wif) key = self.Wallet.CreateKey(prikey) print("Imported key: %s" % wif) print("Pubkey: %s\n" % key.PublicKey.encode_point(True).hex()) print("Wallet: %s" % json.dumps(self.Wallet.ToJson(), indent=4)) except ValueError as e: print(str(e)) except Exception as e: print(str(e)) return elif item == 'nep2': if not self.Wallet: print("Please open a wallet before importing a NEP2 key") return nep2_key = get_arg(arguments, 1) if not nep2_key: print("Please supply a valid NEP2 encrypted private key") return nep2_passwd = prompt("[key password]> ", is_password=True) try: prikey = KeyPair.PrivateKeyFromNEP2(nep2_key, nep2_passwd) key = self.Wallet.CreateKey(prikey) print("Imported NEP2 key: %s" % nep2_key) print("Pubkey: %s\n" % key.PublicKey.encode_point(True).hex()) print("Wallet: %s" % json.dumps(self.Wallet.ToJson(), indent=4)) except ValueError as e: print(str(e)) except Exception as e: print(str(e)) return elif item == 'contract': return self.load_smart_contract(arguments) elif item == 'contract_addr': return ImportContractAddr(self.Wallet, arguments[1:]) elif item == 'watch_addr': return ImportWatchAddr(self.Wallet, get_arg(arguments, 1)) elif item == 'multisig_addr': return ImportMultiSigContractAddr(self.Wallet, arguments[1:]) elif item == 'token': return ImportToken(self.Wallet, get_arg(arguments, 1)) else: print("Import of '%s' not implemented" % item) def do_build(self, arguments): BuildAndRun(arguments, self.Wallet) def do_load_n_run(self, arguments): LoadAndRun(arguments, self.Wallet) def do_export(self, arguments): item = get_arg(arguments) if item == 'wif': if not self.Wallet: return print("Please open a wallet") address = get_arg(arguments, 1) if not address: return print("Please specify an address") passwd = prompt("[wallet password]> ", is_password=True) if not self.Wallet.ValidatePassword(passwd): return print("Incorrect password") keys = self.Wallet.GetKeys() for key in keys: if key.GetAddress() == address: export = key.Export() print("WIF key export: %s" % export) return elif item == 'nep2': if not self.Wallet: return print("Please open a wallet") address = get_arg(arguments, 1) if not address: return print("Please specify an address") passwd = prompt("[wallet password]> ", is_password=True) if not self.Wallet.ValidatePassword(passwd): return print("Incorrect password") nep2_passwd1 = prompt("[key password]> ", is_password=True) if len(nep2_passwd1) < 10: return print( "Please provide a password with at least 10 characters") nep2_passwd2 = prompt("[key password again]> ", is_password=True) if nep2_passwd1 != nep2_passwd2: return print("Passwords do not match") keys = self.Wallet.GetKeys() for key in keys: export = key.ExportNEP2(nep2_passwd1) print("NEP2 key export: %s" % export) return print("Command export %s not found" % item) def make_withdraw_request(self, arguments): if not self.Wallet: print("Please open a wallet") return if len(arguments) == 4: RequestWithdrawFrom(self.Wallet, arguments[0], arguments[1], arguments[2], arguments[3]) else: print( "Incorrect arg length. Use 'withdraw_request {asset_id} {contract_hash} {to_addr} {amount}'" ) def do_withdraw(self, arguments): if not self.Wallet: print("Please open a wallet") return item = get_arg(arguments, 0) if item: if item == 'holds': PrintHolds(self.Wallet) elif item == 'delete_holds': index_to_delete = -1 if get_arg(arguments, 1) and int(get_arg(arguments, 1)) > -1: index_to_delete = int(get_arg(arguments, 1)) DeleteHolds(self.Wallet, index_to_delete) elif item == 'cancel_holds': if len(arguments) > 1: CancelWithdrawalHolds(self.Wallet, get_arg(arguments, 1)) else: print("Please specify contract hash to cancel holds for") elif item == 'completed': ShowCompletedHolds(self.Wallet) elif item == 'cleanup': CleanupCompletedHolds(self.Wallet) elif item == 'all': WithdrawAll(self.Wallet) else: WithdrawOne(self.Wallet) def do_notifications(self, arguments): if NotificationDB.instance() is None: print("No notification DB Configured") return item = get_arg(arguments, 0) events = [] if len(item) == 34: addr = item events = NotificationDB.instance().get_by_addr(addr) else: try: block_height = int(item) if block_height < Blockchain.Default().Height: events = NotificationDB.instance().get_by_block( block_height) else: print("Block %s not found" % block_height) return except Exception as e: print("Could not parse block height %s" % e) return if len(events): [print(json.dumps(e.ToJson(), indent=4)) for e in events] else: print("No events found for %s" % item) def show_wallet(self, arguments): if not self.Wallet: print("Please open a wallet") return item = get_arg(arguments) if not item: print("Wallet %s " % json.dumps(self.Wallet.ToJson(), indent=4)) return if item in ['v', '--v', 'verbose']: print("Wallet %s " % json.dumps(self.Wallet.ToJson(verbose=True), indent=4)) return elif item == 'migrate' and self.Wallet is not None: self.Wallet.Migrate() print("Migrated wallet") elif item == 'delete_addr': addr_to_delete = get_arg(arguments, 1) DeleteAddress(self, self.Wallet, addr_to_delete) elif item == 'delete_token': token_to_delete = get_arg(arguments, 1) DeleteToken(self.Wallet, token_to_delete) elif item == 'close': self.do_close_wallet() elif item == 'claim': ClaimGas(self.Wallet, True, arguments[1:]) elif item == 'rebuild': self.Wallet.Rebuild() try: item2 = int(get_arg(arguments, 1)) if item2 and item2 > 0: print("Restarting at %s" % item2) self.Wallet._current_height = item2 except Exception as e: pass elif item == 'tkn_send': token_send(self.Wallet, arguments[1:]) elif item == 'tkn_send_from': token_send_from(self.Wallet, arguments[1:]) elif item == 'tkn_approve': token_approve_allowance(self.Wallet, arguments[1:]) elif item == 'tkn_allowance': token_get_allowance(self.Wallet, arguments[1:], verbose=True) elif item == 'tkn_mint': token_mint(self.Wallet, arguments[1:]) elif item == 'tkn_register': token_crowdsale_register(self.Wallet, arguments[1:]) elif item == 'unspent': ShowUnspentCoins(self.Wallet, arguments[1:]) elif item == 'alias': if len(arguments) == 3: AddAlias(self.Wallet, arguments[1], arguments[2]) else: print("Please supply an address and title") else: print("Wallet: '{}' is an invalid parameter".format(item)) def do_send(self, arguments): construct_and_send(self, self.Wallet, arguments) def do_sign(self, arguments): jsn = get_arg(arguments) parse_and_sign(self, self.Wallet, jsn) def show_state(self): height = Blockchain.Default().Height headers = Blockchain.Default().HeaderHeight diff = height - self.start_height now = datetime.datetime.utcnow() difftime = now - self.start_dt mins = difftime / datetime.timedelta(minutes=1) bpm = 0 if diff > 0 and mins > 0: bpm = diff / mins out = "Progress: %s / %s\n" % (height, headers) out += "Block-cache length %s\n" % Blockchain.Default().BlockCacheCount out += "Blocks since program start %s\n" % diff out += "Time elapsed %s mins\n" % mins out += "Blocks per min %s \n" % bpm tokens = [(Token.Number, out)] print_tokens(tokens, self.token_style) def show_nodes(self): if len(NodeLeader.Instance().Peers) > 0: out = "" for peer in NodeLeader.Instance().Peers: out += "Peer %s - IO: %s\n" % (peer.Name(), peer.IOStats()) print_tokens([(Token.Number, out)], self.token_style) else: print("Not connected yet\n") def show_block(self, args): item = get_arg(args) txarg = get_arg(args, 1) if item is not None: block = Blockchain.Default().GetBlock(item) if block is not None: bjson = json.dumps(block.ToJson(), indent=4) tokens = [(Token.Number, bjson)] print_tokens(tokens, self.token_style) print('\n') if txarg and 'tx' in txarg: for tx in block.FullTransactions: print(json.dumps(tx.ToJson(), indent=4)) else: print("Could not locate block %s" % item) else: print("please specify a block") def show_header(self, args): item = get_arg(args) if item is not None: header = Blockchain.Default().GetHeaderBy(item) if header is not None: print(json.dumps(header.ToJson(), indent=4)) else: print("Could not locate header %s\n" % item) else: print("Please specify a header") def show_tx(self, args): if len(args): try: txid = UInt256.ParseString(get_arg(args)) tx, height = Blockchain.Default().GetTransaction(txid) if height > -1: jsn = tx.ToJson() jsn['height'] = height jsn['unspents'] = [ uns.ToJson(tx.outputs.index(uns)) for uns in Blockchain.Default().GetAllUnspent(txid) ] tokens = [(Token.Command, json.dumps(jsn, indent=4))] print_tokens(tokens, self.token_style) print('\n') except Exception as e: print("Could not find transaction from args: %s (%s)" % (e, args)) else: print("Please specify a TX hash") def show_account_state(self, args): item = get_arg(args) if item is not None: account = Blockchain.Default().GetAccountState( item, print_all_accounts=True) if account is not None: bjson = json.dumps(account.ToJson(), indent=4) tokens = [(Token.Number, bjson)] print_tokens(tokens, self.token_style) print('\n') else: print("Account %s not found" % item) else: print("Please specify an account address") def show_asset_state(self, args): item = get_arg(args) if item is not None: if item == 'search': query = get_arg(args, 1) results = Blockchain.Default().SearchAssetState(query) print("Found %s results for %s" % (len(results), query)) for asset in results: bjson = json.dumps(asset.ToJson(), indent=4) tokens = [(Token.Number, bjson)] print_tokens(tokens, self.token_style) print('\n') return asset = Blockchain.Default().GetAssetState(item) if asset is not None: bjson = json.dumps(asset.ToJson(), indent=4) tokens = [(Token.Number, bjson)] print_tokens(tokens, self.token_style) print('\n') else: print("Asset %s not found" % item) else: print("Please specify an asset hash") def show_contract_state(self, args): item = get_arg(args) if item is not None: if item.lower() == 'all': contracts = Blockchain.Default().ShowAllContracts() print("Contracts: %s" % contracts) elif item.lower() == 'search': query = get_arg(args, 1) if query: contracts = Blockchain.Default().SearchContracts( query=query) print("Found %s results for %s" % (len(contracts), query)) for contract in contracts: bjson = json.dumps(contract.ToJson(), indent=4) tokens = [(Token.Number, bjson)] print_tokens(tokens, self.token_style) print('\n') else: print("Please specify a search query") else: contract = Blockchain.Default().GetContract(item) if contract is not None: contract.DetermineIsNEP5() jsn = contract.ToJson() bjson = json.dumps(jsn, indent=4) tokens = [(Token.Number, bjson)] print_tokens(tokens, self.token_style) print('\n') else: print("Please specify a contract") def test_invoke_contract(self, args): if not self.Wallet: print("Please open a wallet") return if args and len(args) > 0: tx, fee, results, num_ops = TestInvokeContract(self.Wallet, args) if tx is not None and results is not None: print( "\n-------------------------------------------------------------------------------------------------------------------------------------" ) print("Test invoke successful") print("Total operations: %s" % num_ops) print("Results %s" % [str(item) for item in results]) print("Invoke TX GAS cost: %s" % (tx.Gas.value / Fixed8.D)) print("Invoke TX fee: %s" % (fee.value / Fixed8.D)) print( "-------------------------------------------------------------------------------------------------------------------------------------\n" ) print( "Enter your password to continue and invoke on the network\n" ) passwd = prompt("[password]> ", is_password=True) if not self.Wallet.ValidatePassword(passwd): return print("Incorrect password") result = InvokeContract(self.Wallet, tx, fee) return else: print("Error testing contract invoke") return print("Please specify a contract to invoke") def load_smart_contract(self, args): if not self.Wallet: print("Please open a wallet") return function_code = LoadContract(args[1:]) if function_code: contract_script = GatherContractDetails(function_code, self) if contract_script is not None: tx, fee, results, num_ops = test_invoke( contract_script, self.Wallet, []) if tx is not None and results is not None: print( "\n-------------------------------------------------------------------------------------------------------------------------------------" ) print("Test deploy invoke successful") print("Total operations executed: %s" % num_ops) print("Results %s " % [str(item) for item in results]) print("Deploy Invoke TX GAS cost: %s" % (tx.Gas.value / Fixed8.D)) print("Deploy Invoke TX fee: %s" % (fee.value / Fixed8.D)) print( "-------------------------------------------------------------------------------------------------------------------------------------\n" ) print( "Enter your password to continue and deploy this contract" ) passwd = prompt("[password]> ", is_password=True) if not self.Wallet.ValidatePassword(passwd): return print("Incorrect password") result = InvokeContract(self.Wallet, tx, Fixed8.Zero()) return else: print("Test invoke failed") print("TX is %s, results are %s" % (tx, results)) return def show_mem(self): process = psutil.Process(os.getpid()) total = process.memory_info().rss totalmb = total / (1024 * 1024) out = "Total: %s MB\n" % totalmb out += "Total buffers: %s\n" % StreamManager.TotalBuffers() print_tokens([(Token.Number, out)], self.token_style) def handle_debug_storage(self, args): what = get_arg(args) if what == 'on': settings.USE_DEBUG_STORAGE = True print("Debug storage on") elif what == 'off': settings.USE_DEBUG_STORAGE = False print("Debug Storage off") elif what == 'reset': DebugStorage.instance().reset() print("Reset debug storage") else: print("Please specify on|off|reset") def configure(self, args): what = get_arg(args) if what == 'debug': c1 = get_arg(args, 1).lower() if c1 is not None: if c1 == 'on' or c1 == '1': print("Debug logging is now enabled") settings.set_loglevel(logging.DEBUG) if c1 == 'off' or c1 == '0': print("Debug logging is now disabled") settings.set_loglevel(logging.INFO) else: print("Cannot configure log. Please specify on|off") elif what == 'sc-events': c1 = get_arg(args, 1).lower() if c1 is not None: if c1 == 'on' or c1 == '1': print("Smart contract event logging is now enabled") settings.set_log_smart_contract_events(True) if c1 == 'off' or c1 == '0': print("Smart contract event logging is now disabled") settings.set_log_smart_contract_events(False) else: print("Cannot configure log. Please specify on|off") else: print( "Cannot configure %s try 'config sc-events on|off' or 'config debug on|off'", what) def run(self): dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks) dbloop.start(.1) Blockchain.Default().PersistBlocks() tokens = [(Token.Neo, 'NEO'), (Token.Default, ' cli. Type '), (Token.Command, '\'help\' '), (Token.Default, 'to get started')] print_tokens(tokens, self.token_style) print('\n') while self.go_on: try: result = prompt( "neo> ", completer=self.get_completer(), history=self.history, get_bottom_toolbar_tokens=self.get_bottom_toolbar, style=self.token_style, refresh_interval=3) except EOFError: # Control-D pressed: quit return self.quit() except KeyboardInterrupt: # Control-C pressed: do nothing continue try: command, arguments = self.input_parser.parse_input(result) if command is not None and len(command) > 0: command = command.lower() if command == 'quit' or command == 'exit': self.quit() elif command == 'help': self.help() elif command == 'create': self.do_create(arguments) elif command == 'open': self.do_open(arguments) elif command == 'build': self.do_build(arguments) elif command == 'load_run': self.do_load_n_run(arguments) elif command == 'import': self.do_import(arguments) elif command == 'export': self.do_export(arguments) elif command == 'wallet': self.show_wallet(arguments) elif command == 'send': self.do_send(arguments) elif command == 'sign': self.do_sign(arguments) elif command == 'block': self.show_block(arguments) elif command == 'tx': self.show_tx(arguments) elif command == 'header': self.show_header(arguments) elif command == 'account': self.show_account_state(arguments) elif command == 'asset': self.show_asset_state(arguments) elif command == 'contract': self.show_contract_state(arguments) elif command == 'testinvoke': self.test_invoke_contract(arguments) elif command == 'withdraw_request': self.make_withdraw_request(arguments) elif command == 'withdraw': self.do_withdraw(arguments) elif command == 'notifications': self.do_notifications(arguments) elif command == 'mem': self.show_mem() elif command == 'nodes' or command == 'node': self.show_nodes() elif command == 'state': self.show_state() elif command == 'debugstorage': self.handle_debug_storage(arguments) elif command == 'config': self.configure(arguments) elif command is None: print("Please specify a command") else: print("Command %s not found" % command) except Exception as e: print("Could not execute command: %s" % e) traceback.print_stack() traceback.print_exc() # Setup depending on command line arguments. By default, the testnet settings are already loaded. settings.setup_privnet() # Instantiate the blockchain and subscribe to notifications blockchain = LevelDBBlockchain(settings.LEVELDB_PATH) Blockchain.RegisterBlockchain(blockchain) # Try to set up a notification db if NotificationDB.instance(): NotificationDB.instance().start() # Start the prompt interface #cli = PromptInterface() # Run things #reactor.suggestThreadPoolSize(15) #reactor.callInThread(cli.run) NodeLeader.Instance().Start() while True: f = open("com.txt", "r") file_input = f.read() f.close() #test 020707 07 True False 2 key value25 if (file_input != ""): neo_args = file_input.split(';') print(neo_args) path = "privnet1" nargs = [ '/Users/jacksonroberts/Desktop/TicketChain/test/RegisterPart.py' ] nargs.extend(neo_args) #print(nargs) Wallet = UserWallet.Open(path, to_aes_key("123123123123")) tx, result, total_ops, engine = BuildAndRun(nargs, Wallet) print(str(result)) f = open("com.txt", "w") f.close() f = open("out.txt", "w") f.write(result) f.close() time.sleep(1) NotificationDB.close() Blockchain.Default().Dispose() NodeLeader.Instance().Shutdown()
def setUpClass(self): self._blockchain = LevelDBBlockchain(path=self.LEVELDB_TESTPATH, skip_version_check=True) Blockchain.RegisterBlockchain(self._blockchain) self._genesis = Blockchain.GenesisBlock()
class LevelDBTest(NeoTestCase): LEVELDB_TESTPATH = os.path.join(settings.DATA_DIR_PATH, 'UnitTestChain') _blockchain = None _genesis = None block_one_raw = b'00000000ef1f8f66a16fba100ed760f4ac6aa5a0d0bb8f4a0e92705b106761ef181718b3d0765298ceb5f57de7d2b0dab00ed25be4134706ada2d90adb8b7e3aba323a8e1abd125901000000d11f7a289214bdaff3812db982f3b0089a21a278988efeec6a027b2501fd450140884037dd265cb5f5a54802f53c2c8593b31d5b8a9c0bad4c7e366b153d878989d168080ac36b930036a9eb966b48c70bb41792e698fa021116f27c09643563b840e83ab14404d964a91dbac45f5460e88ad57196b1779478e3475334af8c1b49cd9f0213257895c60b5b92a4800eb32d785cbb39ae1f022528943909fd37deba63403677848bf98cc9dbd8fbfd7f2e4f34471866ea82ca6bffbf0f778b6931483700c17829b4bd066eb04983d3aac0bd46b9c8d03a73a8e714d3119de93cd9522e314054d16853b22014190063f77d9edf6fbccefcf71fffd1234f688823b4e429ae5fa639d0a664c842fbdfcb4d6e21f39d81c23563b92cffa09696d93c95bc4893a6401a43071d00d3e854f7f1f321afa7d5301d36f2195dc1e2643463f34ae637d2b02ae0eb11d4256c507a4f8304cea6396a7fce640f50acb301c2f6336d27717e84f155210209e7fd41dfb5c2f8dc72eb30358ac100ea8c72da18847befe06eade68cebfcb9210327da12b5c40200e9f65569476bbff2218da4f32548ff43b6387ec1416a231ee821034ff5ceeac41acf22cd5ed2da17a6df4dd8358fcb2bfb1a43208ad0feaab2746b21026ce35b29147ad09e4afe4ec4a7319095f08198fa8babbe3c56e970b143528d2221038dddc06ce687677a53d54f096d2591ba2302068cf123c1f2d75c2dddc542557921039dafd8571a641058ccc832c5e2111ea39b09c0bde36050914384f7a48bce9bf92102d02b1873a0863cd042cc717da31cea0d7cf9db32b74d4c72c01b0011503e2e2257ae010000d11f7a2800000000' block_one_hash = b'0012f8566567a9d7ddf25acb5cf98286c9703297de675d01ba73fbfe6bcb841c' @classmethod def setUpClass(self): self._blockchain = LevelDBBlockchain(path=self.LEVELDB_TESTPATH, skip_version_check=True) Blockchain.RegisterBlockchain(self._blockchain) self._genesis = Blockchain.GenesisBlock() @classmethod def tearDownClass(self): self._blockchain.Dispose() shutil.rmtree(self.LEVELDB_TESTPATH) def test__initial_state(self): self.assertEqual(self._blockchain.CurrentBlockHash, self._genesis.Hash.ToBytes()) self.assertEqual(self._blockchain.CurrentHeaderHash, self._genesis.Header.Hash.ToBytes()) self.assertEqual(self._blockchain.CurrentHeaderHash, self._genesis.Header.Hash.ToBytes()) self.assertEqual(self._blockchain.HeaderHeight, 0) self.assertEqual(self._blockchain.Height, 0) def test_add_header(self): hexdata = binascii.unhexlify(self.block_one_raw) block_one = Helper.AsSerializableWithType(hexdata, 'neo.Core.Block.Block') if settings.MAGIC == 1953787457: self.assertEqual( self._blockchain.CurrentHeaderHash, b'b3181718ef6167105b70920e4a8fbbd0a0a56aacf460d70e10ba6fa1668f1fef' ) else: self.assertEqual( self._blockchain.CurrentHeaderHash, b'd42561e3d30e15be6400b6df2f328e02d2bf6354c41dce433bc57687c82144bf' ) self.assertEqual(self._blockchain.HeaderHeight, 0) def test_sys_block_fees(self): block_num = 14103 fee_should_be = 435
def main(): parser = argparse.ArgumentParser() parser.add_argument("-m", "--mainnet", action="store_true", default=False, help="Use MainNet instead of the default TestNet") parser.add_argument("-p", "--privnet", action="store_true", default=False, help="Use PrivNet instead of the default TestNet") parser.add_argument("-c", "--config", action="store", help="Use a specific config file") parser.add_argument( "-t", "--set-default-theme", dest="theme", choices=["dark", "light"], help= "Set the default theme to be loaded from the config file. Default: 'dark'" ) parser.add_argument( "--version", action="version", version="neo-python v{version}".format(version=__version__)) args = parser.parse_args() if args.config and (args.mainnet or args.privnet): print( "Cannot use --config and --mainnet/--privnet together, please use only one" ) exit(1) if args.mainnet and args.privnet: print("Cannot use --mainnet and --privnet together") exit(1) # Setup depending on command line arguments. By default, the testnet settings are already loaded. if args.config: settings.setup(args.config) elif args.mainnet: settings.setup_mainnet() elif args.privnet: settings.setup_privnet() if args.theme: preferences.set_theme(args.theme) # Instantiate the blockchain and subscribe to notifications blockchain = LevelDBBlockchain(settings.LEVELDB_PATH) Blockchain.RegisterBlockchain(blockchain) # Try to set up a notification db if NotificationDB.instance(): NotificationDB.instance().start() # Start the prompt interface cli = PromptInterface() # Run reactor.suggestThreadPoolSize(15) reactor.callInThread(cli.run) NodeLeader.Instance().Start() reactor.run()
help="Minutes to wait for the NEO to generate GAS (default: %s)" % MINUTES_TO_WAIT_UNTIL_GAS_CLAIM, default=MINUTES_TO_WAIT_UNTIL_GAS_CLAIM) parser.add_argument("-w", "--save-privnet-wif", action="store", help="Filename to store created privnet wif key") args = parser.parse_args() if os.path.isfile(args.output): print("Error: Wallet file %s already exists" % args.output) exit(1) settings.setup_privnet() print("Blockchain DB path:", settings.chain_leveldb_path) if os.path.exists(settings.chain_leveldb_path): print( "Warning: Chain database already exists. If this is from a previous private network, you need to delete %s" % settings.chain_leveldb_path) blockchain = LevelDBBlockchain(settings.chain_leveldb_path) Blockchain.RegisterBlockchain(blockchain) reactor.suggestThreadPoolSize(15) NodeLeader.Instance().Start() pc = PrivnetClaimall(args.output, args.password, args.time, args.save_privnet_wif) reactor.callInThread(pc.run) reactor.run()
def main(): parser = argparse.ArgumentParser() parser.add_argument("-d", "--debug", action="store_true", default=False, help="Debug") parser.add_argument("-m", "--mainnet", action="store_true", default=False, help="Use MainNet instead of the default TestNet") parser.add_argument("-p", "--privnet", action="store_true", default=False, help="Use PrivNet instead of the default TestNet") parser.add_argument( "--coznet", action="store_true", default=False, help="Use the CoZ network instead of the default TestNet") parser.add_argument("-w", "--wallet", action="store", help="Wallet path") parser.add_argument("-pass", "--password", action="store", help="Wallet path") parser.add_argument("-pro", "--project", action="store", help="Project") parser.add_argument("-fs", "--funding_stage", action="store", help="Funding Stage") parser.add_argument("-ms", "--milestone", action="store", help="Milestone") parser.add_argument("-con", "--fr_config", action="store", help="Funding Roadmap config") parser.add_argument("-sum", "--summary", action="store_true", default=False, help="Get Summary of project") parser.add_argument("-to_addr", "--to_addr", action="store", help="To Addr") parser.add_argument("-from_addr", "--from_addr", action="store", help="From addr") parser.add_argument("-send", "--send_gas", action="store", help="Contribute to project") parser.add_argument("-cr", "--claim_refund", action="store_true", default=False, help="Claim refund") parser.add_argument("-cc", "--claim_contributions", action="store_true", default=False, help="Claim contributions") parser.add_argument("-kyc", "--kyc_status", action="store", help="Get kyc status") parser.add_argument("-kreg", "--kyc_register", action="store", help="Register KYC addr") parser.add_argument("-invoke", "--invoke", action="store", help="Invoke operation") parser.add_argument("-args", "--args", action="store", help="Valuss to input as list []") args = parser.parse_args() if args.mainnet and args.privnet: print("Cannot use both --mainnet and --privnet arguments") exit(1) # Setup depending on command line arguments. By default, the testnet settings are already loaded. if args.mainnet: settings.setup_mainnet() elif args.privnet: settings.setup_privnet() elif args.coznet: settings.setup_coznet() # Instantiate the blockchain and subscribe to notifications blockchain = LevelDBBlockchain(settings.LEVELDB_PATH) Blockchain.RegisterBlockchain(blockchain) # Try to set up a notification db if NotificationDB.instance(): NotificationDB.instance().start() cli = TheConstructInterface(input_args=args, debug=args.debug) # Run reactor.suggestThreadPoolSize(15) reactor.callInThread(cli.run) NodeLeader.Instance().Start() reactor.run()
def __init__(self, path, passwordKey, create): """ Args: path: (str) A path indicating where to create or open the wallet passwordKey: (str) A password to use in creating or opening the wallet create: (bool) Whether to create the wallet or simply open """ self.AddressVersion = settings.ADDRESS_VERSION self._path = path if create: self._iv = bytes(Random.get_random_bytes(16)) self._master_key = bytes(Random.get_random_bytes(32)) self._keys = {} self._contracts = {} self._coins = {} if Blockchain.Default() is None: self._indexedDB = LevelDBBlockchain(settings.LEVELDB_PATH) Blockchain.RegisterBlockchain(self._indexedDB) else: self._indexedDB = Blockchain.Default() self._current_height = 0 self.BuildDatabase() passwordHash = hashlib.sha256(passwordKey.encode('utf-8')).digest() master = AES.new(passwordHash, AES.MODE_CBC, self._iv) mk = master.encrypt(self._master_key) self.SaveStoredData('PasswordHash', passwordHash) self.SaveStoredData('IV', self._iv), self.SaveStoredData('MasterKey', mk) self.SaveStoredData('Height', self._current_height.to_bytes(4, 'little')) else: self.BuildDatabase() passwordHash = self.LoadStoredData('PasswordHash') if passwordHash is None: raise Exception("Password hash not found in database") hkey = hashlib.sha256(passwordKey.encode('utf-8')) if passwordHash is not None and passwordHash != hashlib.sha256( passwordKey.encode('utf-8')).digest(): raise Exception("Incorrect Password") self._iv = self.LoadStoredData('IV') master_stored = self.LoadStoredData('MasterKey') aes = AES.new(hkey.digest(), AES.MODE_CBC, self._iv) self._master_key = aes.decrypt(master_stored) self._keys = self.LoadKeyPairs() self._contracts = self.LoadContracts() self._watch_only = self.LoadWatchOnly() self._tokens = self.LoadNEP5Tokens() self._coins = self.LoadCoins() try: h = int(self.LoadStoredData('Height')) self._current_height = h except Exception as e: print("couldnt load height data %s " % e) self._current_height = 0 del passwordKey
def __init__(self, path, passwordKey, create): self._path = path if create: self._iv = bytes(Random.get_random_bytes(16)) self._master_key = bytes(Random.get_random_bytes(32)) self._keys = {} self._contracts = {} self._coins = {} if Blockchain.Default() is None: self._indexedDB = LevelDBBlockchain(Settings.LEVELDB_PATH) Blockchain.RegisterBlockchain(self._indexedDB) else: self._indexedDB = Blockchain.Default() #self._node = RemoteNode(url=TEST_NODE) self._current_height = 0 self.BuildDatabase() passwordHash = hashlib.sha256(passwordKey.encode('utf-8')).digest() master = AES.new(passwordHash, AES.MODE_CBC, self._iv) mk = master.encrypt(self._master_key) self.SaveStoredData('PasswordHash', passwordHash) self.SaveStoredData('IV', self._iv), self.SaveStoredData('MasterKey', mk) # self.SaveStoredData('Version') { Version.Major, Version.Minor, Version.Build, Version.Revision }.Select(p => BitConverter.GetBytes(p)).SelectMany(p => p).ToArray()); self.SaveStoredData('Height', self._current_height.to_bytes(4, 'little')) else: self.BuildDatabase() passwordHash = self.LoadStoredData('PasswordHash') if passwordHash is None: raise Exception("Password hash not found in database") hkey = hashlib.sha256(passwordKey.encode('utf-8')) if passwordHash is not None and passwordHash != hashlib.sha256( passwordKey.encode('utf-8')).digest(): raise Exception("Incorrect Password") self._iv = self.LoadStoredData('IV') master_stored = self.LoadStoredData('MasterKey') aes = AES.new(hkey.digest(), AES.MODE_CBC, self._iv) self._master_key = aes.decrypt(master_stored) self._keys = self.LoadKeyPairs() self._contracts = self.LoadContracts() self._watch_only = self.LoadWatchOnly() self._coins = self.LoadCoins() try: h = int(self.LoadStoredData('Height')) self._current_height = h except Exception as e: print("couldnt load height data %s " % e) self._current_height = 0 # self._current_height = 470000 del passwordKey
def main(): parser = argparse.ArgumentParser() group = parser.add_mutually_exclusive_group() group.add_argument("-m", "--mainnet", action="store_true", default=False, help="Use MainNet instead of the default TestNet") group.add_argument("-p", "--privnet", action="store_true", default=False, help="Use PrivNet instead of the default TestNet") group.add_argument( "--coznet", action="store_true", default=False, help="Use the CoZ network instead of the default TestNet") group.add_argument("-c", "--config", action="store", help="Use a specific config file") parser.add_argument( "-t", "--set-default-theme", dest="theme", choices=["dark", "light"], help= "Set the default theme to be loaded from the config file. Default: 'dark'" ) parser.add_argument( "--version", action="version", version="neo-python v{version}".format(version=__version__)) args = parser.parse_args() # Setup depending on command line arguments. By default, the testnet settings are already loaded. if args.config: settings.setup(args.config) elif args.mainnet: settings.setup_mainnet() elif args.privnet: settings.setup_privnet() elif args.coznet: settings.setup_coznet() if args.theme: preferences.set_theme(args.theme) # Instantiate the blockchain and subscribe to notifications blockchain = LevelDBBlockchain(settings.LEVELDB_PATH) Blockchain.RegisterBlockchain(blockchain) # Try to set up a notification db if NotificationDB.instance(): NotificationDB.instance().start() # Start the prompt interface cli = PromptInterface() # Run things reactor.suggestThreadPoolSize(15) reactor.callInThread(cli.run) NodeLeader.Instance().Start() # reactor.run() is blocking, until `quit()` is called which stops the reactor. reactor.run() # After the reactor is stopped, gracefully shutdown the database. NotificationDB.close() Blockchain.Default().Dispose() NodeLeader.Instance().Shutdown()
def main(): parser = argparse.ArgumentParser() parser.add_argument("-m", "--mainnet", action="store_true", default=False, help="use MainNet instead of the default TestNet") parser.add_argument("-c", "--config", action="store", help="Use a specific config file") # Where to store stuff parser.add_argument("--datadir", action="store", help="Absolute path to use for database directories") parser.add_argument("-i", "--input", help="Where the input file lives") parser.add_argument("-t", "--totalblocks", help="Total blocks to import", type=int) parser.add_argument("-l", "--logevents", help="Log Smart Contract Events", default=False, action="store_true") args = parser.parse_args() if args.mainnet and args.config: print( "Cannot use both --config and --mainnet parameters, please use only one." ) exit(1) # Setting the datadir must come before setting the network, else the wrong path is checked at net setup. if args.datadir: settings.set_data_dir(args.datadir) # Setup depending on command line arguments. By default, the testnet settings are already loaded. if args.config: settings.setup(args.config) elif args.mainnet: settings.setup_mainnet() if args.logevents: settings.log_smart_contract_events = True if not args.input: raise Exception("Please specify an input path") file_path = args.input with open(file_path, 'rb') as file: total_blocks = int.from_bytes(file.read(4), 'little') target_dir = os.path.join(settings.DATA_DIR_PATH, settings.LEVELDB_PATH) notif_target_dir = os.path.join(settings.DATA_DIR_PATH, settings.NOTIFICATION_DB_PATH) print("Will import %s blocks to %s" % (total_blocks, target_dir)) print( "This will overwrite any data currently in %s and %s.\nType 'confirm' to continue" % (target_dir, notif_target_dir)) confirm = prompt("[confirm]> ", is_password=False) if not confirm == 'confirm': print("Cancelled operation") return False try: if os.path.exists(target_dir): shutil.rmtree(target_dir) if os.path.exists(notif_target_dir): shutil.rmtree(notif_target_dir) except Exception as e: print("Could not remove existing data %s " % e) return False # Instantiate the blockchain and subscribe to notifications blockchain = LevelDBBlockchain(settings.chain_leveldb_path) Blockchain.RegisterBlockchain(blockchain) chain = Blockchain.Default() for index in trange(total_blocks, desc='Importing Blocks', unit=' Block'): block_len = int.from_bytes(file.read(4), 'little') stream = StreamManager.GetStream(file.read(block_len)) reader = BinaryReader(stream) block = Block() block.Deserialize(reader) StreamManager.ReleaseStream(stream) if block.Index > 0: chain.AddBlockDirectly(block) file.close() print("Imported %s blocks to %s " % (total_blocks, target_dir))
def main(): parser = argparse.ArgumentParser() group = parser.add_mutually_exclusive_group(required=True) group.add_argument("-m", "--mainnet", action="store_true", default=False, help="Use MainNet instead of the default TestNet") group.add_argument("-t", "--testnet", action="store_true", default=False, help="Use TestNet instead of the default TestNet") group.add_argument("-p", "--privnet", action="store_true", default=False, help="Use PrivNet instead of the default TestNet") group.add_argument( "--coznet", action="store_true", default=False, help="Use the CoZ network instead of the default TestNet") group.add_argument("-c", "--config", action="store", help="Use a specific config file") parser.add_argument("--port-rpc", type=int, help="port to use for the json-rpc api (eg. 10332)") parser.add_argument("--port-rest", type=int, help="port to use for the rest api (eg. 80)") args = parser.parse_args() if not args.port_rpc and not args.port_rest: print("Error: specify at least one of --port-rpc / --port-rest") parser.print_help() return if args.port_rpc == args.port_rest: print("Error: --port-rpc and --port-rest cannot be the same") parser.print_help() return # Setup depending on command line arguments. By default, the testnet settings are already loaded. if args.config: settings.setup(args.config) elif args.mainnet: settings.setup_mainnet() elif args.testnet: settings.setup_testnet() elif args.privnet: settings.setup_privnet() elif args.coznet: settings.setup_coznet() # Write a PID file to easily quit the service write_pid_file() # Setup the blockchain blockchain = LevelDBBlockchain(settings.LEVELDB_PATH) Blockchain.RegisterBlockchain(blockchain) dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks) dbloop.start(.1) NodeLeader.Instance().Start() # Disable smart contract events for external smart contracts settings.set_log_smart_contract_events(False) # Open a wallet otherwise exit. try: bcontract.start_db_loop() except Exception as e: logger.error( "Error starting the custom neo node. wallet file and correct password are necessary %s" % e) exit(1) # # Start a thread with custom code # d = threading.Thread(target=custom_background_code) d.setDaemon( True ) # daemonizing the thread will kill it when the main thread is quit d.start() host = "0.0.0.0" if args.port_rpc: logger.info("Starting json-rpc api server on http://%s:%s" % (host, args.port_rpc)) api_server_rpc = JsonRpcApi(args.port_rpc) endpoint_rpc = "tcp:port={0}:interface={1}".format(args.port_rpc, host) endpoints.serverFromString(reactor, endpoint_rpc).listen( Site(api_server_rpc.app.resource())) if args.port_rest: logger.info("Starting smartcontract api server on http://%s:%s" % (host, args.port_rest)) endpoint_description = "tcp:port={0}:interface={1}".format( args.port_rest, host) endpoint = endpoints.serverFromString(reactor, endpoint_description) endpoint.listen(Site(app.resource())) # app.run(host, 9999) # Run all the things (blocking call) logger.info("Everything is setup and running. Waiting for events...") reactor.run() logger.info("Shutting down.")
def main(): parser = argparse.ArgumentParser() # Network options group_network_container = parser.add_argument_group(title="Network options") group_network = group_network_container.add_mutually_exclusive_group(required=True) group_network.add_argument("--mainnet", action="store_true", default=False, help="Use MainNet") group_network.add_argument("--testnet", action="store_true", default=False, help="Use TestNet") group_network.add_argument("--privnet", action="store_true", default=False, help="Use PrivNet") group_network.add_argument("--coznet", action="store_true", default=False, help="Use CozNet") group_network.add_argument("--config", action="store", help="Use a specific config file") # Ports for RPC and REST api group_modes = parser.add_argument_group(title="Mode(s)") group_modes.add_argument("--port-rpc", type=int, help="port to use for the json-rpc api (eg. 10332)") group_modes.add_argument("--port-rest", type=int, help="port to use for the rest api (eg. 80)") # Advanced logging setup group_logging = parser.add_argument_group(title="Logging options") group_logging.add_argument("--logfile", action="store", type=str, help="Logfile") group_logging.add_argument("--syslog", action="store_true", help="Log to syslog instead of to log file ('user' is the default facility)") group_logging.add_argument("--syslog-local", action="store", type=int, choices=range(0, 7), metavar="[0-7]", help="Log to a local syslog facility instead of 'user'. Value must be between 0 and 7 (e.g. 0 for 'local0').") group_logging.add_argument("--disable-stderr", action="store_true", help="Disable stderr logger") # Where to store stuff parser.add_argument("--datadir", action="store", help="Absolute path to use for database directories") # peers parser.add_argument("--maxpeers", action="store", default=5, help="Max peers to use for P2P Joining") # If a wallet should be opened parser.add_argument("--wallet", action="store", help="Open wallet. Will allow you to use methods that require an open wallet") # host parser.add_argument("--host", action="store", type=str, help="Hostname ( for example 127.0.0.1)", default="0.0.0.0") # Now parse args = parser.parse_args() # print(args) if not args.port_rpc and not args.port_rest: print("Error: specify at least one of --port-rpc / --port-rest") parser.print_help() return if args.port_rpc == args.port_rest: print("Error: --port-rpc and --port-rest cannot be the same") parser.print_help() return if args.logfile and (args.syslog or args.syslog_local): print("Error: Cannot only use logfile or syslog at once") parser.print_help() return # Setting the datadir must come before setting the network, else the wrong path is checked at net setup. if args.datadir: settings.set_data_dir(args.datadir) # Network configuration depending on command line arguments. By default, the testnet settings are already loaded. if args.config: settings.setup(args.config) elif args.mainnet: settings.setup_mainnet() elif args.testnet: settings.setup_testnet() elif args.privnet: settings.setup_privnet() elif args.coznet: settings.setup_coznet() if args.maxpeers: try: settings.set_max_peers(args.maxpeers) print("Maxpeers set to ", args.maxpeers) except ValueError: print("Please supply a positive integer for maxpeers") return if args.syslog or args.syslog_local is not None: # Setup the syslog facility if args.syslog_local is not None: print("Logging to syslog local%s facility" % args.syslog_local) syslog_facility = SysLogHandler.LOG_LOCAL0 + args.syslog_local else: print("Logging to syslog user facility") syslog_facility = SysLogHandler.LOG_USER # Setup logzero to only use the syslog handler logzero.syslog(facility=syslog_facility) else: # Setup file logging if args.logfile: logfile = os.path.abspath(args.logfile) if args.disable_stderr: print("Logging to logfile: %s" % logfile) else: print("Logging to stderr and logfile: %s" % logfile) logzero.logfile(logfile, maxBytes=LOGFILE_MAX_BYTES, backupCount=LOGFILE_BACKUP_COUNT, disableStderrLogger=args.disable_stderr) else: print("Logging to stdout and stderr") if args.wallet: if not os.path.exists(args.wallet): print("Wallet file not found") return passwd = os.environ.get('NEO_PYTHON_JSONRPC_WALLET_PASSWORD', None) if not passwd: passwd = prompt("[password]> ", is_password=True) password_key = to_aes_key(passwd) try: wallet = UserWallet.Open(args.wallet, password_key) except Exception as e: print(f"Could not open wallet {e}") return else: wallet = None # Disable logging smart contract events settings.set_log_smart_contract_events(False) # Write a PID file to easily quit the service write_pid_file() # Setup Twisted and Klein logging to use the logzero setup observer = STDLibLogObserver(name=logzero.LOGZERO_DEFAULT_LOGGER) globalLogPublisher.addObserver(observer) def loopingCallErrorHandler(error): logger.info("Error in loop: %s " % error) # Instantiate the blockchain and subscribe to notifications blockchain = LevelDBBlockchain(settings.chain_leveldb_path) Blockchain.RegisterBlockchain(blockchain) start_block_persisting() # If a wallet is open, make sure it processes blocks if wallet: walletdb_loop = task.LoopingCall(wallet.ProcessBlocks) wallet_loop_deferred = walletdb_loop.start(1) wallet_loop_deferred.addErrback(loopingCallErrorHandler) # Setup twisted reactor, NodeLeader and start the NotificationDB reactor.suggestThreadPoolSize(15) NodeLeader.Instance().Start() NotificationDB.instance().start() # Start a thread with custom code d = threading.Thread(target=custom_background_code) d.setDaemon(True) # daemonizing the thread will kill it when the main thread is quit d.start() if args.port_rpc: logger.info("Starting json-rpc api server on http://%s:%s" % (args.host, args.port_rpc)) try: rpc_class = load_class_from_path(settings.RPC_SERVER) except ValueError as err: logger.error(err) sys.exit() api_server_rpc = rpc_class(args.port_rpc, wallet=wallet) endpoint_rpc = "tcp:port={0}:interface={1}".format(args.port_rpc, args.host) endpoints.serverFromString(reactor, endpoint_rpc).listen(Site(api_server_rpc.app.resource())) if args.port_rest: logger.info("Starting REST api server on http://%s:%s" % (args.host, args.port_rest)) try: rest_api = load_class_from_path(settings.REST_SERVER) except ValueError as err: logger.error(err) sys.exit() api_server_rest = rest_api() endpoint_rest = "tcp:port={0}:interface={1}".format(args.port_rest, args.host) endpoints.serverFromString(reactor, endpoint_rest).listen(Site(api_server_rest.app.resource())) reactor.addSystemEventTrigger('before', 'shutdown', stop_block_persisting) reactor.run() # After the reactor is stopped, gracefully shutdown the database. logger.info("Closing databases...") NotificationDB.close() Blockchain.Default().Dispose() NodeLeader.Instance().Shutdown() if wallet: wallet.Close()
def main(): parser = argparse.ArgumentParser() parser.add_argument("-m", "--mainnet", action="store_true", default=False, help="use MainNet instead of the default TestNet") parser.add_argument("-c", "--config", action="store", help="Use a specific config file") # Where to store stuff parser.add_argument("--datadir", action="store", help="Absolute path to use for database directories") parser.add_argument("-i", "--input", help="Where the input file lives") parser.add_argument("-t", "--totalblocks", help="Total blocks to import", type=int) parser.add_argument("-l", "--logevents", help="Log Smart Contract Events", default=False, action="store_true") parser.add_argument("-n", "--notifications", help="Persist Notifications to database", default=False, action="store_true") parser.add_argument("-a", "--append", action="store_true", default=False, help="Append to current Block database") args = parser.parse_args() if args.mainnet and args.config: print( "Cannot use both --config and --mainnet parameters, please use only one." ) exit(1) # Setting the datadir must come before setting the network, else the wrong path is checked at net setup. if args.datadir: settings.set_data_dir(args.datadir) # Setup depending on command line arguments. By default, the testnet settings are already loaded. if args.config: settings.setup(args.config) elif args.mainnet: settings.setup_mainnet() if args.logevents: settings.log_smart_contract_events = True if not args.input: raise Exception("Please specify an input path") file_path = args.input append = False store_notifications = False start_block = 0 if args.append: append = True if args.notifications: store_notifications = True header_hash_list = [] with open(file_path, 'rb') as file_input: total_blocks_available = int.from_bytes(file_input.read(4), 'little') if total_blocks_available == 0: total_blocks_available = int.from_bytes(file_input.read(4), 'little') total_blocks = total_blocks_available if args.totalblocks and args.totalblocks < total_blocks and args.totalblocks > 0: total_blocks = args.totalblocks target_dir = os.path.join(settings.DATA_DIR_PATH, settings.LEVELDB_PATH) notif_target_dir = os.path.join(settings.DATA_DIR_PATH, settings.NOTIFICATION_DB_PATH) if append: blockchain = LevelDBBlockchain(settings.chain_leveldb_path, skip_header_check=True) Blockchain.RegisterBlockchain(blockchain) start_block = Blockchain.Default().Height print("Starting import at %s " % start_block) else: print("Will import %s of %s blocks to %s" % (total_blocks, total_blocks_available, target_dir)) print( "This will overwrite any data currently in %s and %s.\nType 'confirm' to continue" % (target_dir, notif_target_dir)) try: confirm = prompt("[confirm]> ", is_password=False) except KeyboardInterrupt: confirm = False if not confirm == 'confirm': print("Cancelled operation") return False try: if os.path.exists(target_dir): shutil.rmtree(target_dir) if os.path.exists(notif_target_dir): shutil.rmtree(notif_target_dir) except Exception as e: print("Could not remove existing data %s " % e) return False # Instantiate the blockchain and subscribe to notifications blockchain = LevelDBBlockchain(settings.chain_leveldb_path) Blockchain.RegisterBlockchain(blockchain) chain = Blockchain.Default() if store_notifications: NotificationDB.instance().start() stream = MemoryStream() reader = BinaryReader(stream) block = Block() length_ba = bytearray(4) for index in trange(total_blocks, desc='Importing Blocks', unit=' Block'): # set stream data file_input.readinto(length_ba) block_len = int.from_bytes(length_ba, 'little') reader.stream.write(file_input.read(block_len)) reader.stream.seek(0) # get block block.DeserializeForImport(reader) header_hash_list.append(block.Hash.ToBytes()) # add if block.Index > start_block: chain.AddBlockDirectly(block, do_persist_complete=store_notifications) # reset blockheader block._header = None block.__hash = None # reset stream reader.stream.Cleanup() print("Wrote blocks. Now writing headers") chain = Blockchain.Default() # reset header hash list chain._db.delete(DBPrefix.IX_HeaderHashList) total = len(header_hash_list) chain._header_index = header_hash_list print("storing header hash list...") while total - 2000 >= chain._stored_header_count: ms = StreamManager.GetStream() w = BinaryWriter(ms) headers_to_write = chain._header_index[chain._stored_header_count:chain ._stored_header_count + 2000] w.Write2000256List(headers_to_write) out = ms.ToArray() StreamManager.ReleaseStream(ms) with chain._db.write_batch() as wb: wb.put( DBPrefix.IX_HeaderHashList + chain._stored_header_count.to_bytes(4, 'little'), out) chain._stored_header_count += 2000 last_index = len(header_hash_list) chain._db.put(DBPrefix.SYS_CurrentHeader, header_hash_list[-1] + last_index.to_bytes(4, 'little')) print("Imported %s blocks to %s " % (total_blocks, target_dir))
def main(): parser = argparse.ArgumentParser() # Network group group = parser.add_mutually_exclusive_group() group.add_argument("-m", "--mainnet", action="store_true", default=False, help="Use MainNet instead of the default TestNet") group.add_argument( "-p", "--privnet", nargs="?", metavar="host", const=True, default=False, help= "Use a private net instead of the default TestNet, optionally using a custom host (default: 127.0.0.1)" ) group.add_argument( "--coznet", action="store_true", default=False, help="Use the CoZ network instead of the default TestNet") group.add_argument("-c", "--config", action="store", help="Use a specific config file") # Theme parser.add_argument( "-t", "--set-default-theme", dest="theme", choices=["dark", "light"], help= "Set the default theme to be loaded from the config file. Default: 'dark'" ) # Verbose parser.add_argument("-v", "--verbose", action="store_true", default=False, help="Show smart-contract events by default") # Where to store stuff parser.add_argument("--datadir", action="store", help="Absolute path to use for database directories") # Show the neo-python version parser.add_argument( "--version", action="version", version="neo-python v{version}".format(version=__version__)) args = parser.parse_args() # Setup depending on command line arguments. By default, the testnet settings are already loaded. if args.config: settings.setup(args.config) elif args.mainnet: settings.setup_mainnet() elif args.privnet: try: settings.setup_privnet(args.privnet) except PrivnetConnectionError as e: logger.error(str(e)) return elif args.coznet: settings.setup_coznet() if args.theme: preferences.set_theme(args.theme) if args.verbose: settings.set_log_smart_contract_events(True) if args.datadir: settings.set_data_dir(args.datadir) # Instantiate the blockchain and subscribe to notifications blockchain = LevelDBBlockchain(settings.chain_leveldb_path) Blockchain.RegisterBlockchain(blockchain) # Try to set up a notification db if NotificationDB.instance(): NotificationDB.instance().start() # Start the prompt interface cli = PromptInterface() # Run things reactor.suggestThreadPoolSize(15) reactor.callInThread(cli.run) NodeLeader.Instance().Start() # reactor.run() is blocking, until `quit()` is called which stops the reactor. reactor.run() # After the reactor is stopped, gracefully shutdown the database. NotificationDB.close() Blockchain.Default().Dispose() NodeLeader.Instance().Shutdown()
from autologging import logged from prompt_toolkit import prompt from prompt_toolkit.styles import style_from_dict from prompt_toolkit.shortcuts import print_tokens from prompt_toolkit.token import Token from prompt_toolkit.contrib.completers import WordCompleter from prompt_toolkit.history import InMemoryHistory logname = 'prompt.log' logging.basicConfig(level=logging.DEBUG, filemode='a', filename=logname, format="%(levelname)s:%(name)s:%(funcName)s:%(message)s") blockchain = LevelDBBlockchain(Settings.LEVELDB_PATH) Blockchain.RegisterBlockchain(blockchain) example_style = style_from_dict({ # User input. Token: '#ff0066', # Prompt. Token.Username: '******', Token.At: '#00aa00', Token.Colon: '#00aa00', Token.Pound: '#00aa00', Token.Host: '#000088 bg:#aaaaff', Token.Path: '#884444 underline', })
def setUpClass(self): self._blockchain = LevelDBBlockchain(path=self.LEVELDB_TESTPATH) Blockchain.RegisterBlockchain(self._blockchain)
def main(): parser = argparse.ArgumentParser() # Network options group_network_container = parser.add_argument_group( title="Network options") group_network = group_network_container.add_mutually_exclusive_group( required=True) group_network.add_argument("--mainnet", action="store_true", default=False, help="Use MainNet") group_network.add_argument("--testnet", action="store_true", default=False, help="Use TestNet") group_network.add_argument("--privnet", action="store_true", default=False, help="Use PrivNet") group_network.add_argument("--coznet", action="store_true", default=False, help="Use CozNet") group_network.add_argument("--config", action="store", help="Use a specific config file") # Ports for RPC and REST api group_modes = parser.add_argument_group(title="Mode(s)") group_modes.add_argument( "--port-rpc", type=int, help="port to use for the json-rpc api (eg. 10332)") group_modes.add_argument("--port-rest", type=int, help="port to use for the rest api (eg. 80)") # Advanced logging setup group_logging = parser.add_argument_group(title="Logging options") group_logging.add_argument("--logfile", action="store", type=str, help="Logfile") group_logging.add_argument( "--syslog", action="store_true", help= "Log to syslog instead of to log file ('user' is the default facility)" ) group_logging.add_argument( "--syslog-local", action="store", type=int, choices=range(0, 7), metavar="[0-7]", help= "Log to a local syslog facility instead of 'user'. Value must be between 0 and 7 (e.g. 0 for 'local0')." ) group_logging.add_argument("--disable-stderr", action="store_true", help="Disable stderr logger") # Where to store stuff parser.add_argument("--datadir", action="store", help="Absolute path to use for database directories") # peers parser.add_argument("--maxpeers", action="store", default=5, help="Max peers to use for P2P Joining") # host parser.add_argument("--host", action="store", type=str, help="Hostname ( for example 127.0.0.1)", default="0.0.0.0") # Now parse args = parser.parse_args() # print(args) if not args.port_rpc and not args.port_rest: print("Error: specify at least one of --port-rpc / --port-rest") parser.print_help() return if args.port_rpc == args.port_rest: print("Error: --port-rpc and --port-rest cannot be the same") parser.print_help() return if args.logfile and (args.syslog or args.syslog_local): print("Error: Cannot only use logfile or syslog at once") parser.print_help() return # Setting the datadir must come before setting the network, else the wrong path is checked at net setup. if args.datadir: settings.set_data_dir(args.datadir) # Network configuration depending on command line arguments. By default, the testnet settings are already loaded. if args.config: settings.setup(args.config) elif args.mainnet: settings.setup_mainnet() elif args.testnet: settings.setup_testnet() elif args.privnet: settings.setup_privnet() elif args.coznet: settings.setup_coznet() if args.maxpeers: settings.set_max_peers(args.maxpeers) if args.syslog or args.syslog_local is not None: # Setup the syslog facility if args.syslog_local is not None: print("Logging to syslog local%s facility" % args.syslog_local) syslog_facility = SysLogHandler.LOG_LOCAL0 + args.syslog_local else: print("Logging to syslog user facility") syslog_facility = SysLogHandler.LOG_USER # Setup logzero to only use the syslog handler logzero.syslog(facility=syslog_facility) else: # Setup file logging if args.logfile: logfile = os.path.abspath(args.logfile) if args.disable_stderr: print("Logging to logfile: %s" % logfile) else: print("Logging to stderr and logfile: %s" % logfile) logzero.logfile(logfile, maxBytes=LOGFILE_MAX_BYTES, backupCount=LOGFILE_BACKUP_COUNT, disableStderrLogger=args.disable_stderr) else: print("Logging to stdout and stderr") # Disable logging smart contract events settings.set_log_smart_contract_events(False) # Write a PID file to easily quit the service write_pid_file() # Setup Twisted and Klein logging to use the logzero setup observer = STDLibLogObserver(name=logzero.LOGZERO_DEFAULT_LOGGER) globalLogPublisher.addObserver(observer) # Instantiate the blockchain and subscribe to notifications blockchain = LevelDBBlockchain(settings.chain_leveldb_path) Blockchain.RegisterBlockchain(blockchain) dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks) dbloop.start(.1) # Setup twisted reactor, NodeLeader and start the NotificationDB reactor.suggestThreadPoolSize(15) NodeLeader.Instance().Start() NotificationDB.instance().start() # Start a thread with custom code d = threading.Thread(target=custom_background_code) d.setDaemon( True ) # daemonizing the thread will kill it when the main thread is quit d.start() if args.port_rpc: logger.info("Starting json-rpc api server on http://%s:%s" % (args.host, args.port_rpc)) api_server_rpc = JsonRpcApi(args.port_rpc) endpoint_rpc = "tcp:port={0}:interface={1}".format( args.port_rpc, args.host) endpoints.serverFromString(reactor, endpoint_rpc).listen( Site(api_server_rpc.app.resource())) # reactor.listenTCP(int(args.port_rpc), server.Site(api_server_rpc)) # api_server_rpc.app.run(args.host, args.port_rpc) if args.port_rest: logger.info("Starting REST api server on http://%s:%s" % (args.host, args.port_rest)) api_server_rest = RestApi() endpoint_rest = "tcp:port={0}:interface={1}".format( args.port_rest, args.host) endpoints.serverFromString(reactor, endpoint_rest).listen( Site(api_server_rest.app.resource())) # api_server_rest.app.run(args.host, args.port_rest) reactor.run() # After the reactor is stopped, gracefully shutdown the database. logger.info("Closing databases...") NotificationDB.close() Blockchain.Default().Dispose() NodeLeader.Instance().Shutdown()
def setUpClass(self): os.makedirs(self.LEVELDB_TESTPATH, exist_ok=True) self._blockchain = LevelDBBlockchain(path=self.LEVELDB_TESTPATH) Blockchain.RegisterBlockchain(self._blockchain)
def main(): parser = argparse.ArgumentParser() parser.add_argument("-m", "--mainnet", action="store_true", default=False, help="Use MainNet instead of the default TestNet") parser.add_argument("-p", "--privnet", action="store_true", default=False, help="Use PrivNet instead of the default TestNet") parser.add_argument("-c", "--config", action="store", help="Use a specific config file") parser.add_argument( '--version', action='version', version='neo-python v{version}'.format(version=__version__)) args = parser.parse_args() if args.config and (args.mainnet or args.privnet): print( "Cannot use both --config and --mainnet/--privnet arguments, please use only one." ) exit(1) if args.mainnet and args.privnet: print("Cannot use both --mainnet and --privnet arguments") exit(1) # Setup depending on command line arguments. By default, the testnet settings are already loaded. if args.config: settings.setup(args.config) elif args.mainnet: settings.setup_mainnet() elif args.privnet: settings.setup_privnet() # Instantiate the blockchain and subscribe to notifications blockchain = LevelDBBlockchain(settings.LEVELDB_PATH) Blockchain.RegisterBlockchain(blockchain) dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks) dbloop.start(.1) settings.set_log_smart_contract_events(False) ndb = NotificationDB.instance() ndb.start() # Run reactor.suggestThreadPoolSize(15) NodeLeader.Instance().Start() host = "0.0.0.0" port = settings.RPC_PORT logger.info("Starting json-rpc api server on http://%s:%s" % (host, port)) api_server = JsonRpcApi(port) api_server.app.run(host, port)
def main(): parser = argparse.ArgumentParser() parser.add_argument("-m", "--mainnet", action="store_true", default=False, help="use MainNet instead of the default TestNet") parser.add_argument("-c", "--config", action="store", help="Use a specific config file") # Where to store stuff parser.add_argument("--datadir", action="store", help="Absolute path to use for database directories") parser.add_argument("-o", "--output", help="Where to save output file") parser.add_argument("-t", "--totalblocks", help="Total blocks to export", type=int) args = parser.parse_args() if args.mainnet and args.config: print( "Cannot use both --config and --mainnet parameters, please use only one." ) exit(1) # Setting the datadir must come before setting the network, else the wrong path is checked at net setup. if args.datadir: settings.set_data_dir(args.datadir) # Setup depending on command line arguments. By default, the testnet settings are already loaded. if args.config: settings.setup(args.config) elif args.mainnet: settings.setup_mainnet() if not args.output: raise Exception("Please specify an output path") file_path = args.output # Instantiate the blockchain and subscribe to notifications blockchain = LevelDBBlockchain(settings.chain_leveldb_path) Blockchain.RegisterBlockchain(blockchain) chain = Blockchain.Default() with open(file_path, 'wb') as file_out: total = Blockchain.Default().Height - 1 if args.totalblocks: total = args.totalblocks total_block_output = total.to_bytes(4, 'little') print("Using network %s " % settings.net_name) print("Will export %s blocks to %s " % (total, file_path)) file_out.write(total_block_output) for index in trange(total, desc='Exporting blocks:', unit=' Block'): block = chain.GetBlockByHeight(index) block.LoadTransactions() output = binascii.unhexlify(block.ToArray()) output_length = len(output).to_bytes(4, 'little') file_out.write(output_length) file_out.write(output) print("Exported %s blocks to %s " % (total, file_path))
def __init__(self, path, passwordKey, create): """ Args: path (str): A path indicating where to create or open the wallet. passwordKey (str): A password to use in creating or opening the wallet. create (bool): Whether to create the wallet or simply open. """ self.AddressVersion = settings.ADDRESS_VERSION self._path = path if create: self._iv = bytes(Random.get_random_bytes(16)) self._master_key = bytes(Random.get_random_bytes(32)) self._keys = {} self._contracts = {} self._coins = {} if Blockchain.Default() is None: self._indexedDB = LevelDBBlockchain(settings.LEVELDB_PATH) Blockchain.RegisterBlockchain(self._indexedDB) else: self._indexedDB = Blockchain.Default() self._current_height = 0 self.BuildDatabase() passwordHash = hashlib.sha256(passwordKey).digest() master = AES.new(passwordKey, AES.MODE_CBC, self._iv) mk = master.encrypt(self._master_key) self.SaveStoredData('PasswordHash', passwordHash) self.SaveStoredData('IV', self._iv) self.SaveStoredData('MasterKey', mk) self.SaveStoredData('MigrationState', '1') self.SaveStoredData('Height', self._current_height.to_bytes(4, 'little')) else: self.BuildDatabase() passwordHash = self.LoadStoredData('PasswordHash') if passwordHash is None: raise Exception("Password hash not found in database") hkey = hashlib.sha256(passwordKey).digest() if self.LoadStoredData('MigrationState') != '1': raise Exception("This wallet is currently vulnerable. Please " "execute the \"reencrypt_wallet.py\" script " "on this wallet before continuing") if passwordHash is not None and passwordHash != hkey: raise Exception("Incorrect Password") self._iv = self.LoadStoredData('IV') master_stored = self.LoadStoredData('MasterKey') aes = AES.new(passwordKey, AES.MODE_CBC, self._iv) self._master_key = aes.decrypt(master_stored) self._keys = self.LoadKeyPairs() self._contracts = self.LoadContracts() self._watch_only = self.LoadWatchOnly() self._tokens = self.LoadNEP5Tokens() self._coins = self.LoadCoins() try: h = int(self.LoadStoredData('Height')) self._current_height = h except Exception as e: logger.error("Could not load height data %s " % e) self._current_height = 0 del passwordKey
def main(): parser = argparse.ArgumentParser() group = parser.add_mutually_exclusive_group(required=True) group.add_argument("-m", "--mainnet", action="store_true", default=False, help="Use MainNet instead of the default TestNet") group.add_argument("-t", "--testnet", action="store_true", default=False, help="Use TestNett instead of the default TestNet") group.add_argument("-p", "--privnet", action="store_true", default=False, help="Use PrivNet instead of the default TestNet") group.add_argument("--coznet", action="store_true", default=False, help="Use the CoZ network instead of the default TestNet") group.add_argument("-c", "--config", action="store", help="Use a specific config file") parser.add_argument("--port-rpc", type=int, help="port to use for the json-rpc api (eg. 10332)") parser.add_argument("--port-rest", type=int, help="port to use for the rest api (eg. 80)") args = parser.parse_args() if not args.port_rpc and not args.port_rest: print("Error: specify at least one of --port-rpc / --port-rest") parser.print_help() return if args.port_rpc == args.port_rest: print("Error: --port-rpc and --port-rest cannot be the same") parser.print_help() return # Setup depending on command line arguments. By default, the testnet settings are already loaded. if args.config: settings.setup(args.config) elif args.mainnet: settings.setup_mainnet() elif args.testnet: settings.setup_testnet() elif args.privnet: settings.setup_privnet() elif args.coznet: settings.setup_coznet() # Write a PID file to easily quit the service write_pid_file() # Instantiate the blockchain and subscribe to notifications blockchain = LevelDBBlockchain(settings.LEVELDB_PATH) Blockchain.RegisterBlockchain(blockchain) dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks) dbloop.start(.1) # Disable logging smart contract events settings.set_log_smart_contract_events(False) # Start the notification db instance ndb = NotificationDB.instance() ndb.start() # Start a thread with custom code d = threading.Thread(target=custom_background_code) d.setDaemon(True) # daemonizing the thread will kill it when the main thread is quit d.start() # Run reactor.suggestThreadPoolSize(15) NodeLeader.Instance().Start() host = "0.0.0.0" if args.port_rpc: logger.info("Starting json-rpc api server on http://%s:%s" % (host, args.port_rpc)) api_server_rpc = JsonRpcApi(args.port_rpc) endpoint_rpc = "tcp:port={0}:interface={1}".format(args.port_rpc, host) endpoints.serverFromString(reactor, endpoint_rpc).listen(Site(api_server_rpc.app.resource())) if args.port_rest: logger.info("Starting notification api server on http://%s:%s" % (host, args.port_rest)) api_server_rest = NotificationRestApi() endpoint_rest = "tcp:port={0}:interface={1}".format(args.port_rest, host) endpoints.serverFromString(reactor, endpoint_rest).listen(Site(api_server_rest.app.resource())) app = Klein() app.run(host, 9999)
def main(): parser = argparse.ArgumentParser() parser.add_argument("-m", "--mainnet", action="store_true", default=False, help="Use MainNet instead of the default TestNet") parser.add_argument("-p", "--privnet", action="store_true", default=False, help="Use PrivNet instead of the default TestNet") parser.add_argument("-c", "--config", action="store", help="Use a specific config file") parser.add_argument( "-t", "--set-default-theme", dest="theme", choices=["dark", "light"], help= "Set the default theme to be loaded from the config file. Default: 'dark'" ) parser.add_argument( '--version', action='version', version='neo-python v{version}'.format(version=__version__)) args = parser.parse_args() if args.config and (args.mainnet or args.privnet): print( "Cannot use both --config and --mainnet/--privnet arguments, please use only one." ) exit(1) if args.mainnet and args.privnet: print("Cannot use both --mainnet and --privnet arguments") exit(1) # Setup depending on command line arguments. By default, the testnet settings are already loaded. if args.config: settings.setup(args.config) elif args.mainnet: settings.setup_mainnet() elif args.privnet: settings.setup_privnet() if args.theme: preferences.set_theme(args.theme) # Instantiate the blockchain and subscribe to notifications blockchain = LevelDBBlockchain(settings.LEVELDB_PATH) Blockchain.RegisterBlockchain(blockchain) dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks) dbloop.start(.1) ndb = NotificationDB.instance() ndb.start() notif_server = NotificationRestApi() # Run reactor.suggestThreadPoolSize(15) NodeLeader.Instance().Start() notif_server.app.run('0.0.0.0', 8000)
def main(): parser = argparse.ArgumentParser() parser.add_argument("-m", "--mainnet", action="store_true", default=False, help="Use MainNet instead of the default TestNet") parser.add_argument("-p", "--privnet", action="store_true", default=False, help="Use PrivNet instead of the default TestNet") parser.add_argument("-c", "--config", action="store", help="Use a specific config file") parser.add_argument( "-t", "--set-default-theme", dest="theme", choices=["dark", "light"], help= "Set the default theme to be loaded from the config file. Default: 'dark'" ) parser.add_argument( '--version', action='version', version='neo-python v{version}'.format(version=__version__)) parser.add_argument("-e", "--exec_command", action="store", help="Use a specific commands") args = parser.parse_args() if args.config and (args.mainnet or args.privnet): print( "Cannot use both --config and --mainnet/--privnet arguments, please use only one." ) exit(1) if args.mainnet and args.privnet: print("Cannot use both --mainnet and --privnet arguments") exit(1) # Setup depending on command line arguments. By default, the testnet settings are already loaded. if args.config: settings.setup(args.config) elif args.mainnet: settings.setup_mainnet() elif args.privnet: settings.setup_privnet() mycoms = [] mycoms2 = [] if args.exec_command: mycoms = args.exec_command.split( ',') #print("exec:"+args.exec_command) for k in mycoms: mycoms2.append(codecs.decode(k, "hex").decode()) if args.theme: preferences.set_theme(args.theme) # Instantiate the blockchain and subscribe to notifications blockchain = LevelDBBlockchain(settings.LEVELDB_PATH) Blockchain.RegisterBlockchain(blockchain) # Start the prompt interface cli = PromptInterface() cli.mycommands = mycoms2 #['oi', 'oi2'] # Run reactor.suggestThreadPoolSize(15) reactor.callInThread(cli.run) NodeLeader.Instance().Start() reactor.run()
def __init__(self): self._blockchain = LevelDBBlockchain(Settings.LEVELDB_PATH) Blockchain.RegisterBlockchain(self._blockchain) self._localnode = LocalNode() process = self._localnode.Start(20333, 20334)