def setUpClass(cls):
super(TestNotifyDebugEvents, cls).setUpClass()
output = Compiler.instance().load('%s/sc_debug_events.py' %
os.path.dirname(__file__)).default
cls.script = output.write()
settings.set_log_smart_contract_events(False)
def __init__(self, contract_hash, wallet_path, wallet_pass):
super(ImuSmartContract, self).__init__()
self.daemon = True
self.contract_hash = contract_hash
self.wallet_path = wallet_path
self.wallet_pass = wallet_pass
self.smart_contract = SmartContract(contract_hash)
self.invoke_queue = Queue()
# Setup redis cache
self.redis_cache = redis.StrictRedis(host='localhost', port=6379, db=0)
self.tx_in_progress = None
self.wallet = None
settings.set_log_smart_contract_events(False)
# Setup handler for smart contract Runtime.Notify event
#
# Here only listen to 'imuBalance' and save it to redis
@self.smart_contract.on_notify
def sc_notify(event):
""" This method catches Runtime.Notify calls, and updates the balances cache """
logger.info("sc_notify event: %s", str(event))
if event.event_payload[0].decode("utf-8") == "imuBalance":
address = event.event_payload[1].decode("utf-8")
amount = int(event.event_payload[2])
logger.info("- setting balance of %s to %s", address, amount)
self.redis_cache.set("balance:%s" % address, amount)
self.redis_cache.set("balanceUpdatedAt:%s" % address,
int(time.time()))
def main():
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
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)
app = ImportSC(args, blockchain, reactor)
# Try to set up a notification db
if NotificationDB.instance():
NotificationDB.instance().start()
reactor.callInThread(app.worker)
NodeLeader.Instance().Start()
reactor.run()
NotificationDB.close()
Blockchain.Default().Dispose()
NodeLeader.Instance().Shutdown()
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 or 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 or off")
else:
print("cannot configure %s " % what)
print("Try 'config log on/off'")
def main():
settings.setup('protocol.coz.json')
# 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)
global Wallet
Wallet = UserWallet.Open(path="infinitewallet", password="******")
logger.info("Created the Wallet")
logger.info(Wallet.AddressVersion)
walletdb_loop = task.LoopingCall(Wallet.ProcessBlocks)
walletdb_loop.start(1)
#Wallet.CreateKey(KeyPair.PrivateKeyFromWIF(wif))
# 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 main():
# Use TestNet
settings.setup_testnet()
# 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 __init__(self, contract_hash, wallet_path, wallet_pass):
super(MilestoneSmartContract, self).__init__()
self.daemon = True
self.contract_hash = contract_hash
self.wallet_path = wallet_path
self.wallet_pass = wallet_pass
self.smart_contract = SmartContract(contract_hash)
self.invoke_queue = Queue()
# Setup redis
self.rds = Redis(host='redis', port=6379, db=0)
self.tx_in_progress = None
self.wallet = None
settings.set_log_smart_contract_events(False)
# Setup handler for smart contract Runtime.Notify event
#
@self.smart_contract.on_notify
def sc_notify(event):
""" This method catches Runtime.Notify calls, and add them to Redis """
logger.info("sc_notify event: %s", str(event))
# Make sure that the event payload list has at least one element.
if not len(event.event_payload):
return
# The event payload list has at least one element. As developer of the smart contract
# you should know what data-type is in the bytes, and how to decode it. In this example,
# it's just a string, so we decode it with utf-8:
msg = event.event_payload[0].decode("utf-8")
self.rds.publish('neo-event', msg)
def main():
# 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()
# Hook up Klein API to Twisted reactor.
endpoint_description = "tcp:port=%s:interface=localhost" % API_PORT
# If you want to make this service externally available (not only at localhost),
# then remove the `interface=localhost` part:
# endpoint_description = "tcp:port=%s" % API_PORT
endpoint = endpoints.serverFromString(reactor, endpoint_description)
endpoint.listen(Site(app.resource()))
# Run all the things (blocking call)
logger.info("Everything setup and running. Waiting for events...")
reactor.run()
logger.info("Shutting down.")
def main():
# Use TestNet
settings.setup_testnet()
# 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()
# Hook up Klein API to Twisted reactor.
endpoint_description = "tcp:port=%s:interface=localhost" % API_PORT
# If you want to make this service externally available (not only at localhost),
# then remove the `interface=localhost` part:
# endpoint_description = "tcp:port=%s" % API_PORT
endpoint = endpoints.serverFromString(reactor, endpoint_description)
endpoint.listen(Site(app.resource()))
# Run all the things (blocking call)
logger.info("Everything setup and running. Waiting for events...")
reactor.run()
logger.info("Shutting down.")
def __init__(self, contract_hash, wallet_path, wallet_pass):
super(SurTokenContract, self).__init__()
self.daemon = True
self.contract_hash = contract_hash
self.wallet_path = wallet_path
self.wallet_pass = to_aes_key(wallet_pass)
self.smart_contract = SmartContract(contract_hash)
self.invoke_queue = Queue()
self.tx_in_progress = None
self.wallet = None
settings.set_log_smart_contract_events(False)
@self.smart_contract.on_notify
def sc_notify(event):
logger.info("SmartContract Runtime.Notify event: %s", event)
# Make sure that the event payload list has at least one element.
if not len(event.event_payload):
return
# The event payload list has at least one element. As developer of the smart contract
# you should know what data-type is in the bytes, and how to decode it. In this example,
# it's just a string, so we decode it with utf-8:
logger.info("- payload part 1: %s",
event.event_payload[0].decode("utf-8"))
def main():
""" """
# check to see if the chains already exist
if not os.path.isdir(f'{Path.home()}/.neopython/Chains/SC234'):
subprocess.call(['expect', './config/np-setup.exp'])
# Setup the blockchain with logging smart contract events turned on
settings.set_log_smart_contract_events(
True) # uncomment if you want to be spammed with notifications
# initialize environment, nep5-token, and testnet protocol
init_environ('./config/environment.json', './config/nep5-token.json',
'./src/neo-python/neo/data/protocol.testnet.json')
settings.setup('./src/neo-python/neo/data/protocol.testnet.json'
) # use testnet protocol file
# Instantiate the blockchain and subscribe to notifications
blockchain = LevelDBBlockchain(settings.LEVELDB_PATH)
Blockchain.RegisterBlockchain(blockchain)
# add blocks to the blockchain every 0.1 seconds
dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks)
dbloop.start(.1)
NodeLeader.Instance().Start()
# configure and run faucet web app on the specified host and port
host = os.environ.get('FAUCET_HOST', 'localhost')
port = os.environ.get('FAUCET_PORT', 80)
store = ItemStore()
store.app.run(host=host, port=port)
logger.info('Shutting down.')
def main():
parser = argparse.ArgumentParser()
parser.add_argument("-c", "--config", action="store", help="Config file (default. %s)" % PROTOCOL_CONFIG,
default=PROTOCOL_CONFIG)
args = parser.parse_args()
settings.setup(args.config)
logger.info("Starting api.py")
logger.info("Config: %s", args.config)
logger.info("Network: %s", settings.net_name)
# 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)
# 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.")
async def setup_and_start(loop):
# Use TestNet
settings.setup_privnet()
# Setup the blockchain
blockchain = LevelDBBlockchain(settings.chain_leveldb_path)
Blockchain.RegisterBlockchain(blockchain)
p2p = NetworkService()
loop.create_task(p2p.start())
bg_task = loop.create_task(custom_background_code())
# Disable smart contract events for external smart contracts
settings.set_log_smart_contract_events(False)
app = web.Application()
app.add_routes([
web.route('*', '/', home_route),
web.get("/echo-get/{msg}", echo_msg),
web.post("/echo-post/", echo_post),
])
runner = web.AppRunner(app)
await runner.setup()
site = web.TCPSite(runner, "0.0.0.0", API_PORT)
await site.start()
# Run all the things (blocking call)
logger.info("Everything setup and running. Waiting for events...")
return site
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")
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()
# Setup the blockchain
blockchain = LevelDBBlockchain(settings.LEVELDB_PATH)
# logger.info(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(True)
logger.info("Using network: %s" % settings.net_name)
# 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()
# Start SurTokenContract thread
surTokenContract.start()
# Hook up Klein API to Twisted reactor
endpoint_description = "tcp:port=%s" % API_PORT
endpoint = endpoints.serverFromString(reactor, endpoint_description)
endpoint.listen(Site(app.resource()))
# Run all the things (blocking call)
logger.info("Everything setup and running. Waiting for events...")
reactor.run()
logger.info("Shutting down.")
def execute(self, arguments):
if len(arguments) == 0:
print("Please specify the required parameter")
return False
try:
flag = bool(util.strtobool(arguments[0]))
settings.set_log_smart_contract_events(flag)
except ValueError:
print("Invalid option")
return False
if flag:
print("Smart contract event logging is now enabled")
return True
else:
print("Smart contract event logging is now disabled")
return True
async def setup_and_start(loop):
# Use TestNet
settings.setup_testnet()
# Setup the blockchain
blockchain = LevelDBBlockchain(settings.chain_leveldb_path)
Blockchain.RegisterBlockchain(blockchain)
p2p = NetworkService()
loop.create_task(p2p.start())
bg_task = loop.create_task(custom_background_code())
# Disable smart contract events for external smart contracts
settings.set_log_smart_contract_events(False)
# Run all the things (blocking call)
logger.info("Everything setup and running. Waiting for events...")
return bg_task
def main():
# 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):
# bl: changing to 8 as recommended in the 8-10 range by localhuman (previously had this at 150)
settings.set_max_peers(8)
# 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.whitelist_addresses)
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():
# 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():
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()
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
# 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()
if args.datadir:
settings.set_data_dir(args.datadir)
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 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()
# 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(cls):
super(TestNotifyDebugEvents, cls).setUpClass()
output = Compiler.instance().load('%s/sc_debug_events.py' % os.path.dirname(__file__)).default
cls.script = output.write()
settings.set_log_smart_contract_events(False)
def __init__(self, input_args=None, debug=False):
self.input_parser = InputParser()
self.input_args = input_args
self.start_height = Blockchain.Default().Height
self.start_dt = datetime.datetime.utcnow()
settings.set_log_smart_contract_events(False)
self.notify = NotificationDB.instance()
# if debug:
# settings.set_log_smart_contract_events(True)
# EVENTS
@events.on(SmartContractEvent.RUNTIME_NOTIFY)
@events.on(SmartContractEvent.RUNTIME_LOG)
@events.on(SmartContractEvent.EXECUTION_SUCCESS)
@events.on(SmartContractEvent.EXECUTION_FAIL)
@events.on(SmartContractEvent.STORAGE)
def on_sc_event(sc_event):
if sc_event.test_mode:
self.active_color = colors.WARNING
else:
self.active_color = colors.GREEN
if str(sc_event.contract_hash) == str(self.SC_hash):
et = sc_event.event_type
results = sc_event.event_payload
if not debug and sc_event.test_mode:
return
# Inding the invoked op
if et == SmartContractEvent.RUNTIME_LOG and sc_event.test_mode:
try:
decoded_result = results[0].decode("utf-8")
if ':' in decoded_result:
self.invoked_operation = decoded_result.split(
':')[-1]
except:
pass
if et == SmartContractEvent.EXECUTION_SUCCESS or et == SmartContractEvent.RUNTIME_NOTIFY:
print(
self.active_color +
'\n|-------- T H E C O N S T R U C T --------|' +
colors.ENDC)
for result in results:
if self.invoked_operation in [
'fs_attribute', 'get_active_index',
'update_active_ms_progress', 'get_ms_progess'
]:
result = int.from_bytes(result,
byteorder='little',
signed=False)
print('\033[1m Output:\033[0m \t\t\t', result)
if sc_event.test_mode:
print('\n \033[1mSuccessfully Sent Request:\033[0m\t',
self.invoked_operation)
print('\n Please wait for block to process.. ')
else:
print(
'\n \033[1mSuccessfully Executed Request:\033[0m\t',
self.invoked_operation)
self.invoking = False
self.invoked_operation = ''
self.op_output = results
print(self.active_color +
'|-----------------------------------------------|' +
colors.ENDC)
print('\n')
elif debug:
print(
self.active_color +
'\n|-------- T H E C O N S T R U C T --------|' +
colors.ENDC)
print(' Event Type: ', et)
for result in results:
print(' \033[1mOutput:\033[0m \t\t\t', result)
print('\n')
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")
# peers
parser.add_argument("--maxpeers", action="store", default=5,
help="Max peers to use for P2P Joining")
# 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)
if args.maxpeers:
settings.set_max_peers(args.maxpeers)
# 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()
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")
elif what == 'sc-debug-notify':
c1 = get_arg(args, 1).lower()
if c1 is not None:
if c1 == 'on' or c1 == '1':
print("Smart contract emit Notify events on execution failure is now enabled")
settings.set_emit_notify_events_on_sc_execution_error(True)
if c1 == 'off' or c1 == '0':
print("Smart contract emit Notify events on execution failure is now disabled")
settings.set_emit_notify_events_on_sc_execution_error(False)
else:
print("Cannot configure log. Please specify on|off")
elif what == 'vm-log':
c1 = get_arg(args, 1).lower()
if c1 is not None:
if c1 == 'on' or c1 == '1':
print("VM instruction execution logging is now enabled")
settings.set_log_vm_instruction(True)
if c1 == 'off' or c1 == '0':
print("VM instruction execution logging is now disabled")
settings.set_log_vm_instruction(False)
else:
print("Cannot configure VM instruction logging. Please specify on|off")
elif what == 'maxpeers':
try:
c1 = int(get_arg(args, 1).lower())
num_peers = int(c1)
if num_peers > 0:
old_max_peers = settings.CONNECTED_PEER_MAX
settings.set_max_peers(num_peers)
NodeLeader.Instance().OnUpdatedMaxPeers(old_max_peers, num_peers)
print("set max peers to %s " % num_peers)
else:
print("Please specify integer greater than zero")
except Exception as e:
print("Cannot configure max peers. Please specify an integer greater than 0")
else:
print(
"Cannot configure %s try 'config sc-events on|off', 'config debug on|off', 'config sc-debug-notify on|off' or 'config vm-log on|off'" % what)
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")
elif what == 'sc-debug-notify':
c1 = get_arg(args, 1).lower()
if c1 is not None:
if c1 == 'on' or c1 == '1':
print(
"Smart contract emit Notify events on execution failure is now enabled"
)
settings.set_emit_notify_events_on_sc_execution_error(True)
if c1 == 'off' or c1 == '0':
print(
"Smart contract emit Notify events on execution failure is now disabled"
)
settings.set_emit_notify_events_on_sc_execution_error(
False)
else:
print("Cannot configure log. Please specify on|off")
elif what == 'vm-log':
c1 = get_arg(args, 1).lower()
if c1 is not None:
if c1 == 'on' or c1 == '1':
print("VM instruction execution logging is now enabled")
settings.set_log_vm_instruction(True)
if c1 == 'off' or c1 == '0':
print("VM instruction execution logging is now disabled")
settings.set_log_vm_instruction(False)
else:
print(
"Cannot configure VM instruction logging. Please specify on|off"
)
else:
print(
"Cannot configure %s try 'config sc-events on|off', 'config debug on|off', 'config sc-debug-notify on|off' or 'config vm-log on|off'"
% what)
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()
def __init__(self, contract_hash, wallet_path, wallet_pass):
super(LootMarketsSmartContract, self).__init__()
self.daemon = True
self.contract_hash = contract_hash
self.wallet_path = wallet_path
self.wallet_pass = wallet_pass
self.smart_contract = SmartContract(contract_hash)
self.invoke_queue = Queue()
# Setup redis cache.
self.redis_cache = redis.StrictRedis(host='localhost', port=6379, db=0)
self.calling_transaction = None
self.tx_in_progress = None
self.wallet = None
settings.set_log_smart_contract_events(False)
# Setup handler for smart contract Runtime.Notify event.
# Here we listen to all notify events.
@self.smart_contract.on_notify
def sc_notify(event):
""" This method catches Runtime.Notify calls, and updates the relevant cache. """
# Log the received smart contract event.
logger.info("- SmartContract Event: %s", str(event))
event_name = event.event_payload[0].decode("utf-8")
# ==== General Events ====
# Smart contract events that are not specific to a marketplace.
# Event: balance_of
if event_name == "balance_of":
# Convert the given script hash to an address.
script_hash = event.event_payload[1]
sh = UInt160.UInt160(data=script_hash)
address = Crypto.ToAddress(sh)
balance = int.from_bytes(event.event_payload[2], 'little')
# Save the balance to the cache.
logger.info("- Balance of %s updated to %s LOOT", address,
balance)
self.redis_cache.set("balance:%s" % address, int(balance))
return
# Event: get_marketplace_owner
if event_name == "get_marketplace_owner":
marketplace = event.event_payload[1].decode("utf-8")
script_hash = event.event_payload[2]
sh = UInt160.UInt160(data=script_hash)
address = Crypto.ToAddress(sh)
logger.info("- Owner of %s: %s", marketplace, address)
self.redis_cache.set("owner:%s" % marketplace, address)
return
# ==== Marketplace Events ====
# Events that are specific to a marketplace.
# Get the name of the marketplace, if it is none this is not a marketplace operation, return.
marketplace = event.event_payload[1]
if marketplace is not None:
marketplace = marketplace.decode("utf-8")
else:
return
# Ignore smart contract events that are not on our marketplace being used.
if marketplace != self.marketplace:
return
# Event: get_inventory
if event_name == "get_inventory":
# Convert the script hash to an address.
script_hash = event.event_payload[2]
sh = UInt160.UInt160(data=script_hash)
address = Crypto.ToAddress(sh)
# After being converted from a byte to an int, append each element to the list.
inventory = []
for i in event.event_payload[3]:
item_id = int.from_bytes(i, 'little')
inventory.append(item_id)
# Update the inventory in the redis cache.
logger.info("- Setting inventory of %s to %s", address,
inventory)
self.redis_cache.set("inventory:%s" % address, inventory)
self.redis_cache.set("inventoryUpdatedAt:%s" % address,
int(time.time()))
# Event: get_all_offers
if event_name == "get_all_offers":
retrieved_offers = event.event_payload[2]
# Decode all the offers given in the payload.
offers = []
for i in retrieved_offers:
# Offer is received like 'offer\x03' so we convert to 'offer3'.
# We don't want to show the cached offers to the players.
i = i.decode("utf-8")
index = ord(i.split('offer')[1])
offer_id = 'offer' + str(index)
if offer_id not in self.cached_offers:
offers.append(offer_id)
# Log the information and save to the cache.
logger.info("-Setting offers in marketplace: %s", offers)
self.redis_cache.set("offers", offers)
self.redis_cache.set("timeOffersUpdated", str(datetime.now()))
# Event: get_offer
if event_name == "get_offer":
print("Event: get_offer")
# Get all the relevant information about the offer.
offer = event.event_payload[2]
address = offer[0]
offer_id_encoded = offer[1]
# If the offer is empty, return.
if not offer:
return
# We receive the offer index sent from contract in format e.g. "offer\x03", convert to "offer3".
index = ord(offer_id_encoded.decode().split('offer')[1])
offer_id = 'offer' + str(index)
# Decode the bytes into integers.
item_id = int.from_bytes(offer[2], 'little')
price = int.from_bytes(offer[3], 'little')
# Convert the script hash to an address.
script_hash = address
sh = UInt160.UInt160(data=script_hash)
address = Crypto.ToAddress(sh)
# Put the offer information in a list and save it to the redis cache with the offer id as the key.
offer_information = [address, offer_id, item_id, price]
logger.info("-Setting offer:%s to %s", offer_id,
offer_information)
self.redis_cache.set(offer_id, offer_information)
# Event: Market/Item operation
# The game/operator must know if these operations were successfully completed within the smart contract.
# All of these notify events are sent in the same format.
if event_name in ("cancel_offer", "buy_offer", "put_offer",
"give_items", "remove_item"):
# Convert the script hash to address.
script_hash = event.event_payload[2]
sh = UInt160.UInt160(data=script_hash)
address = Crypto.ToAddress(sh)
# Check if the operation was successfully completed within the smart contract.
operation_successful = event.event_payload[3]
# Save the address, and result to the cache with the event_name used as a key.
self.redis_cache.set(event_name + "%s" % address,
operation_successful)
logger.info(
"-" + event_name + " of address %s was completed: %s",
address, operation_successful)
def configure(self, args):
what = get_arg(args)
if what == 'debug':
c1 = get_arg(args, 1)
if c1 is not None:
c1 = c1.lower()
if c1 == 'on' or c1 == '1':
print("Debug logging is now enabled")
settings.set_loglevel(logging.DEBUG)
elif 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")
else:
print("Cannot configure log. Please specify on|off")
elif what == 'sc-events':
c1 = get_arg(args, 1)
if c1 is not None:
c1 = c1.lower()
if c1 == 'on' or c1 == '1':
print("Smart contract event logging is now enabled")
settings.set_log_smart_contract_events(True)
elif 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 log. Please specify on|off")
elif what == 'sc-debug-notify':
c1 = get_arg(args, 1)
if c1 is not None:
c1 = c1.lower()
if c1 == 'on' or c1 == '1':
print(
"Smart contract emit Notify events on execution failure is now enabled"
)
settings.set_emit_notify_events_on_sc_execution_error(True)
elif c1 == 'off' or c1 == '0':
print(
"Smart contract emit Notify events on execution failure is now disabled"
)
settings.set_emit_notify_events_on_sc_execution_error(
False)
else:
print("Cannot configure log. Please specify on|off")
else:
print("Cannot configure log. Please specify on|off")
elif what == 'vm-log':
c1 = get_arg(args, 1)
if c1 is not None:
c1 = c1.lower()
if c1 == 'on' or c1 == '1':
print("VM instruction execution logging is now enabled")
settings.set_log_vm_instruction(True)
elif c1 == 'off' or c1 == '0':
print("VM instruction execution logging is now disabled")
settings.set_log_vm_instruction(False)
else:
print(
"Cannot configure VM instruction logging. Please specify on|off"
)
else:
print(
"Cannot configure VM instruction logging. Please specify on|off"
)
elif what == 'node-requests':
if len(args) in [2, 3]:
if len(args) == 3:
NodeLeader.Instance().setBlockReqSizeAndMax(
int(args[1]), int(args[2]))
elif len(args) == 2:
NodeLeader.Instance().setBlockReqSizeByName(args[1])
else:
print("Invalid number of arguments")
elif what == 'maxpeers':
c1 = get_arg(args, 1)
if c1 is not None:
print("Maxpeers set to ", c1)
settings.set_max_peers(c1)
else:
print("Maintaining current number of maxpeers")
elif what == 'compiler-nep8':
c1 = get_arg(args, 1)
if c1 is not None:
c1 = c1.lower()
if c1 == 'on' or c1 == '1':
print("Compiler NEP8 instructions on")
settings.COMPILER_NEP_8 = True
elif c1 == 'off' or c1 == '0':
print("Compiler NEP8 instructions off")
settings.COMPILER_NEP_8 = False
else:
print(
"Cannot configure compiler NEP8 instructions. Please specify on|off"
)
else:
print(
"Cannot configure compiler NEP8 instructions. Please specify on|off"
)
else:
print(
"Cannot configure %s try 'config sc-events on|off', 'config debug on|off', 'config sc-debug-notify on|off', 'config vm-log on|off', config compiler-nep8 on|off, or 'config maxpeers {num_peers}'"
% what)
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")
elif what == 'sc-debug-notify':
c1 = get_arg(args, 1).lower()
if c1 is not None:
if c1 == 'on' or c1 == '1':
print(
"Smart contract emit Notify events on execution failure is now enabled"
)
settings.set_emit_notify_events_on_sc_execution_error(True)
if c1 == 'off' or c1 == '0':
print(
"Smart contract emit Notify events on execution failure is now disabled"
)
settings.set_emit_notify_events_on_sc_execution_error(
False)
else:
print("Cannot configure log. Please specify on|off")
elif what == 'vm-log':
c1 = get_arg(args, 1).lower()
if c1 is not None:
if c1 == 'on' or c1 == '1':
print("VM instruction execution logging is now enabled")
settings.set_log_vm_instruction(True)
if c1 == 'off' or c1 == '0':
print("VM instruction execution logging is now disabled")
settings.set_log_vm_instruction(False)
else:
print(
"Cannot configure VM instruction logging. Please specify on|off"
)
elif what == 'maxpeers':
try:
c1 = int(get_arg(args, 1).lower())
num_peers = int(c1)
if num_peers > 0:
old_max_peers = settings.CONNECTED_PEER_MAX
settings.set_max_peers(num_peers)
NodeLeader.Instance().OnUpdatedMaxPeers(
old_max_peers, num_peers)
print("set max peers to %s " % num_peers)
else:
print("Please specify integer greater than zero")
except Exception as e:
print(
"Cannot configure max peers. Please specify an integer greater than 0"
)
else:
print(
"Cannot configure %s try 'config sc-events on|off', 'config debug on|off', 'config sc-debug-notify on|off' or 'config vm-log on|off'"
% what)
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()
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.")
async def setup_and_start(loop):
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 + 1),
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("--minpeers",
action="store",
type=int,
choices=range(1, 10 + 1),
metavar="[1-10]",
help="Min peers to use for P2P Joining")
parser.add_argument("--maxpeers",
action="store",
type=int,
choices=range(1, 10 + 1),
metavar="[1-10]",
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()
raise SystemExit
if args.port_rpc == args.port_rest:
print("Error: --port-rpc and --port-rest cannot be the same")
parser.print_help()
raise SystemExit
if args.logfile and (args.syslog or args.syslog_local):
print("Error: Cannot only use logfile or syslog at once")
parser.print_help()
raise SystemExit
# 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()
def set_min_peers(num_peers) -> bool:
try:
settings.set_min_peers(num_peers)
print("Minpeers set to ", num_peers)
return True
except ValueError:
print("Please supply a positive integer for minpeers")
return False
def set_max_peers(num_peers) -> bool:
try:
settings.set_max_peers(num_peers)
print("Maxpeers set to ", num_peers)
return True
except ValueError:
print("Please supply a positive integer for maxpeers")
return False
minpeers = args.minpeers
maxpeers = args.maxpeers
if minpeers and maxpeers:
if minpeers > maxpeers:
print("minpeers setting cannot be bigger than maxpeers setting")
return
if not set_min_peers(minpeers) or not set_max_peers(maxpeers):
return
elif minpeers:
if not set_min_peers(minpeers):
return
if minpeers > settings.CONNECTED_PEER_MAX:
if not set_max_peers(minpeers):
return
elif maxpeers:
if not set_max_peers(maxpeers):
return
if maxpeers < settings.CONNECTED_PEER_MIN:
if not set_min_peers(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:
try:
passwd = prompt("[password]> ", is_password=True)
except KeyboardInterrupt:
print("Wallet opening cancelled")
return
password_key = to_aes_key(passwd)
try:
wallet = UserWallet.Open(args.wallet, password_key)
asyncio.create_task(
wallet.sync_wallet(start_block=wallet._current_height))
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()
# Instantiate the blockchain and subscribe to notifications
blockchain = Blockchain(getBlockchainDB())
Blockchain.RegisterBlockchain(blockchain)
p2p = NetworkService()
p2p_task = loop.create_task(p2p.start())
loop.create_task(custom_background_code())
NotificationDB.instance().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(wallet=wallet)
runner = web.AppRunner(api_server_rpc.app)
await runner.setup()
site = web.TCPSite(runner, args.host, args.port_rpc)
await site.start()
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()
runner = web.AppRunner(api_server_rest.app)
await runner.setup()
site = web.TCPSite(runner, args.host, args.port_rpc)
await site.start()
return wallet
def run(self):
# bl: changing to 15 so that we can get connections with a high number to improve transaction relayability
settings.set_max_peers(15)
loop = asyncio.get_event_loop()
# because a KeyboardInterrupt is so violent it can shutdown the DB in an unpredictable state.
loop.add_signal_handler(SIGINT, quit)
loop.add_signal_handler(SIGHUP, quit)
loop.add_signal_handler(SIGTERM, quit)
# Disable smart contract events for external smart contracts
settings.set_log_smart_contract_events(False)
# Instantiate the blockchain and subscribe to notifications
blockchain = Blockchain(
DBFactory.getBlockchainDB(settings.chain_leveldb_path))
Blockchain.RegisterBlockchain(blockchain)
# Try to set up a notification db
if NotificationDB.instance():
NotificationDB.instance().start()
# if the wallet was set up (by setting a path and loading the password), then open it!
if self.wallet_path:
self.wallet_open()
# invoke any pre-start action that needs to occur before we start the loop.
# optional for subclasses to implement.
self.pre_start()
blockchain_main_task = loop.create_task(self.run_loop())
p2p = NetworkService()
loop.create_task(p2p.start())
async def shutdown():
all_tasks = asyncio.all_tasks()
for task in all_tasks:
task.cancel()
with suppress(asyncio.CancelledError):
await task
try:
loop.run_forever()
except (SystemExit, KeyboardInterrupt):
with suppress((SystemExit, Exception)):
blockchain_main_task.exception()
loop.run_until_complete(p2p.shutdown())
loop.run_until_complete(shutdown())
loop.run_until_complete(loop.shutdown_asyncgens())
loop.stop()
finally:
loop.close()
# Run things
if self.wallet_path:
logger.info("Closing wallet file %s" % self.wallet_path)
asyncio.run(self.wallet_close())
# After the reactor is stopped, gracefully shutdown the database.
logger.info("Closing databases...")
NotificationDB.close()
Blockchain.Default().Dispose()
