def open_wallet(self, path, pwd):
try:
self.Wallet = UserWallet.Open(path, pwd)
self._walletdb_loop = task.LoopingCall(self.Wallet.ProcessBlocks)
self._walletdb_loop.start(1)
print("Wallet %s is opened successfully!" % path)
except Exception as e:
print("Could not open wallet: %s" % e)
sys.exit(1)
def GetWallet1(cls, recreate=False):
if cls._wallet1 is None or recreate:
shutil.copyfile(cls.wallet_1_path(), cls.wallet_1_dest())
cls._wallet1 = UserWallet.Open(
UserWalletTestCase.wallet_1_dest(),
to_aes_key(UserWalletTestCase.wallet_1_pass()))
return cls._wallet1
def wallet_open(self):
self.wallet = UserWallet.Open(self.wallet_path, self.wallet_passwd_key)
# bl: there is some side effect happening here that allows the wallet to be fully/properly initialized.
# without this, there are errors when sending NEP5 tokens (same goes in prompt.py).
# don't have time to investigate right now, so doing this as a hack to get things working properly
self.wallet.ToJson()
# _walletdb_loop = task.LoopingCall(wallet.ProcessBlocks)
# _walletdb_loop.start(1)
self.logger.info("Opened wallet at %s", self.wallet_path)
def run(self):
dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks)
dbloop.start(.1)
Blockchain.Default().PersistBlocks()
while Blockchain.Default().Height < 2:
print("Waiting for chain to sync...")
time.sleep(1)
# Claim initial NEO
address = "AK2nJJpJr6o664CWJKi1QRXjqeic2zRp8y"
self.claim_initial_neo(address)
# Open wallet again
print("Opening wallet %s" % self.wallet_fn)
self.wallet = UserWallet.Open(self.wallet_fn, to_aes_key("coz"))
self.wallet.ProcessBlocks()
self._walletdb_loop = task.LoopingCall(self.wallet.ProcessBlocks)
self._walletdb_loop.start(1)
# self.wallet.Rebuild()
# print("\nOpened wallet. Rebuilding...")
# time.sleep(10)
print("\nWait %s min before claiming GAS." % self.min_wait)
time.sleep(60 * self.min_wait)
print("\nSending NEO to own wallet...")
with patch('neo.Prompt.Commands.Send.prompt', side_effect=["coz"]):
framework = construct_send_basic(self.wallet, ["neo", address, "100000000"])
tx = process_transaction(self.wallet, contract_tx=framework[0], scripthash_from=framework[1], fee=framework[2], owners=framework[3], user_tx_attributes=framework[4])
if not tx:
print("Something went wrong, no tx.")
return
# Wait until transaction is on blockchain
self.wait_for_tx(tx)
print("Claiming the GAS...")
claim_tx, relayed = ClaimGas(self.wallet, require_password=False)
self.wait_for_tx(claim_tx)
# Finally, need to rebuild the wallet
self.wallet.Rebuild()
print("\nAll done!")
print("- Wallet file: %s" % self.wallet_fn)
print("- Wallet pwd: %s" % self.wallet_pwd)
if self.wif_fn:
with open(self.wif_fn, "w") as f:
f.write("KxDgvEKzgSBPPfuVfw67oPQBSjidEiqTHURKSDL1R7yGaGYAeYnr")
self.quit()
def test_getwalletheight(self):
self.app.wallet = UserWallet.Open(
os.path.join(ROOT_INSTALL_PATH,
"neo/data/neo-privnet.sample.wallet"),
to_aes_key("coz"))
req = self._gen_rpc_req("getwalletheight", params=[])
mock_req = mock_request(json.dumps(req).encode("utf-8"))
res = json.loads(self.app.home(mock_req))
self.assertEqual(1, res.get('result'))
def run(self):
dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks)
dbloop.start(.1)
Blockchain.Default().PersistBlocks()
while Blockchain.Default().Height < 2:
print("Waiting for chain to sync...")
time.sleep(1)
# Claim initial MFF
address = "AK2nJJpJr6o664CWJKi1QRXjqeic2zRp8y"
self.claim_initial_neo(address)
# Open wallet again
print("Opening wallet %s" % self.wallet_fn)
self.wallet = UserWallet.Open(self.wallet_fn, to_aes_key("coz"))
self.wallet.ProcessBlocks()
self._walletdb_loop = task.LoopingCall(self.wallet.ProcessBlocks)
self._walletdb_loop.start(1)
# self.wallet.Rebuild()
# print("\nOpened wallet. Rebuilding...")
# time.sleep(10)
print("\nWait %s min before claiming GAS." % self.min_wait)
time.sleep(60 * self.min_wait)
print("\nSending MFF to own wallet...")
tx = construct_and_send(None,
self.wallet, ["neo", address, "100000000"],
prompt_password=False)
if not tx:
print("Something went wrong, no tx.")
return
# Wait until transaction is on blockchain
self.wait_for_tx(tx)
print("Claiming the GAS...")
claim_tx, relayed = ClaimGas(self.wallet, require_password=False)
self.wait_for_tx(claim_tx)
# Finally, need to rebuild the wallet
self.wallet.Rebuild()
print("\nAll done!")
print("- Wallet file: %s" % self.wallet_fn)
print("- Wallet pwd: %s" % self.wallet_pwd)
if self.wif_fn:
with open(self.wif_fn, "w") as f:
f.write("KxDgvEKzgSBPPfuVfw67oPQBSjidEiqTHURKSDL1R7yGaGYAeYnr")
self.quit()
def open_wallet(self, path, password):
if not os.path.exists(path):
print("Wallet file not found")
return
try:
self.Wallet = UserWallet.Open(path, password)
self._walletdb_loop = task.LoopingCall(self.Wallet.ProcessBlocks)
self._walletdb_loop.start(1)
print("Opened wallet at %s" % path)
except Exception as e:
print("Could not open wallet: %s" % e)
def run(self):
dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks)
dbloop.start(.1)
Blockchain.Default().PersistBlocks()
while Blockchain.Default().Height < 2:
print("Waiting for chain to sync...")
time.sleep(1)
# Open wallet again
print("Opening wallet %s" % self.wallet_fn)
self.wallet = UserWallet.Open(self.wallet_fn, to_aes_key("coz"))
self.wallet.ProcessBlocks()
self._walletdb_loop = task.LoopingCall(self.wallet.ProcessBlocks)
self._walletdb_loop.start(1)
print("\nWait %s min before claiming GAS." % self.min_wait)
time.sleep(60 * self.min_wait)
self.wallet.Rebuild()
print("\nRebuilding wallet...")
time.sleep(20)
print("\nSending NEO to own wallet...")
address = "AK2nJJpJr6o664CWJKi1QRXjqeic2zRp8y"
with patch('neo.Prompt.Commands.Send.prompt', side_effect=["coz"]):
framework = construct_send_basic(self.wallet,
["neo", address, "100000000"])
tx = process_transaction(self.wallet,
contract_tx=framework[0],
scripthash_from=framework[1],
fee=framework[2],
owners=framework[3],
user_tx_attributes=framework[4])
if not tx:
print("Something went wrong, no tx.")
return
# Wait until transaction is on blockchain
self.wait_for_tx(tx)
print("Claiming the GAS...")
claim_tx, relayed = ClaimGas(self.wallet, require_password=False)
self.wait_for_tx(claim_tx)
# Finally, need to rebuild the wallet
# self.wallet.Rebuild()
self.quit()
def do_open_wallet(self):
passwd = self._gathered_passwords[0]
path = self._wallet_create_path
self._wallet_create_path = None
self._gathered_passwords = None
self._gather_password_action = None
try:
self.Wallet = UserWallet.Open(path, passwd)
dbloop = task.LoopingCall(self.Wallet.ProcessBlocks)
dbloop.start(1)
print("Opened wallet at %s" % path)
except Exception as e:
print("could not open wallet: %s " % e)
def __init__(self, contract_hash, wallet_file_path, wallet_password):
logger.info("Initializes a BContract Instance")
self.contract_hash = contract_hash
self.wallet_file_path = wallet_file_path
self.wallet_password = wallet_password
if not os.path.exists(self.wallet_file_path):
logger.error("Wallet file not found.")
raise RuntimeError('Wallet File Not found')
password_key = to_aes_key(self.wallet_password)
try:
self.Wallet = UserWallet.Open(self.wallet_file_path, password_key)
logger.info("Opened wallet at %s" % self.wallet_file_path)
except Exception as e:
logger.error("Could not open wallet: %s" % e)
raise RuntimeError("Could not open wallet: %s" % e)
def wallethandler():
try:
global walletinfo
global _walletdb_loop
_walletdb_loop = None
walletinfo = PromptInterface()
wallet_path = '/home/ubuntu/nosforallneeds'
passwd = 'nosforallneeds'
password_key = to_aes_key(passwd)
walletinfo.Wallet = UserWallet.Open(wallet_path, password_key)
_walletdb_loop = task.LoopingCall(walletinfo.Wallet.ProcessBlocks)
_walletdb_loop.start(1)
except Exception as e:
print('Exception opening wallet: %s' % e)
return 'Exception opening wallet.Please try manual deploying your SC. Also please share issue with me @sharedmocha in Discord App.'
def custom_background_code():
wallet = UserWallet.Open(path, to_aes_key(password))
# wallet.Rebuild()
# start_wallet_loop(wallet)
# print("Opened wallet at %s" % path)
print(wallet.ToJson()['percent_synced'])
multisig_addr = make_multisig(targetkey, wallet)
args = ['GAS', 'AK5q8peiC4QKwuZHWX5Dkqhmar1TAGvZBS', '1'] #testing
while wallet._current_height != Blockchain.Default().Height:
print("Wallet %s / Blockchain %s" %
(str(wallet._current_height), str(Blockchain.Default().Height)))
sleep(15)
construct_and_send('', wallet, args)
print("sent")
def createWallet(self):
# Creating wallet instance
self.Wallet = UserWallet.Open(path=self.walletpath,
password=self.walletpass)
print("AddressVersion: ", self.Wallet.AddressVersion)
self._walletdb_loop = task.LoopingCall(self.Wallet.ProcessBlocks)
self._walletdb_loop.start(1)
self.wallet_sh = self.Wallet.GetStandardAddress()
self.wallet_addr = Crypto.ToAddress(self.wallet_sh)
for addr in self.Wallet.ToJson()['public_keys']:
if addr['Address'] == self.wallet_addr:
self.wallet_pub = addr['Public Key']
print('Wallet SH', self.wallet_sh)
print('Wallet Addr', self.wallet_addr)
print('Wallet Pub', self.wallet_pub)
def __init__(self):
wallet_path = os.environ.get('FAUCET_WALLET_PATH', '')
passwd = os.environ.get('FAUCET_WALLET_PASSWORD', '')
if len(passwd) < 1 or len(wallet_path) < 1:
raise Exception(
"Please set FAUCET_WALLET_PASSWORD and FAUCET_WALLET_PATH in your ENV vars"
)
self.wallet = UserWallet.Open(path=wallet_path, password=passwd)
dbloop = task.LoopingCall(self.wallet.ProcessBlocks)
dbloop.start(.1)
self.wallet.Rebuild()
print("created wallet: %s " % self.wallet)
def __init__(self, args=None, chain=None, twist=None):
self.chain = chain
self.twist = twist
self.start_height = self.chain.Height
self.start_dt = datetime.datetime.utcnow()
self.args = args
self.scPath = args[0]
password = to_aes_key("coz")
self.wallet = UserWallet.Open("/neo-python/neo-privnet.wallet",
password)
self.wallet.Rebuild()
loop = task.LoopingCall(self.wallet.ProcessBlocks)
self.deferred = loop.start(1)
self.deferred.addErrback(self.on_loopError)
def __init__(self):
self._build_run_db()
wallet_path = os.environ.get('FAUCET_WALLET_PATH','')
passwd = os.environ.get('FAUCET_WALLET_PASSWORD', '')
passwd = to_aes_key(passwd)
if len(passwd) < 1 or len(wallet_path) < 1:
raise Exception("Please set FAUCET_WALLET_PASSWORD and FAUCET_WALLET_PATH in your ENV vars")
self.wallet = UserWallet.Open(path=wallet_path, password=passwd)
dbloop = task.LoopingCall(self.wallet.ProcessBlocks) # huh?
dbloop.start(.1) # huh?
self.wallet.Rebuild() # make sure the wallet is up to date
self.wallet._current_height = 100000 # why set the wallet at that height?
print("created wallet: %s " % self.wallet)
def run(self):
dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks)
dbloop.start(.1)
Blockchain.Default().PersistBlocks()
while Blockchain.Default().Height < 2:
print("Waiting for chain to sync...")
time.sleep(1)
# Open wallet again
print("Opening wallet %s" % self.wallet_fn)
self.wallet = UserWallet.Open(self.wallet_fn, to_aes_key("coz"))
self.wallet.ProcessBlocks()
self._walletdb_loop = task.LoopingCall(self.wallet.ProcessBlocks)
self._walletdb_loop.start(1)
print("\nWait %s min before claiming GAS." % self.min_wait)
time.sleep(60 * self.min_wait)
self.wallet.Rebuild()
print("\nRebuilding wallet...")
time.sleep(20)
print("\nSending MFF to own wallet...")
address = "AK2nJJpJr6o664CWJKi1QRXjqeic2zRp8y"
tx = construct_and_send(None,
self.wallet, ["neo", address, "100000000"],
prompt_password=False)
if not tx:
print("Something went wrong, no tx.")
return
# Wait until transaction is on blockchain
self.wait_for_tx(tx)
print("Claiming the GAS...")
claim_tx, relayed = ClaimGas(self.wallet, require_password=False)
self.wait_for_tx(claim_tx)
# Finally, need to rebuild the wallet
# self.wallet.Rebuild()
self.quit()
def test_send_to_address_simple(self):
test_wallet_path = shutil.copyfile(
WalletFixtureTestCase.wallet_1_path(),
WalletFixtureTestCase.wallet_1_dest())
self.app.wallet = UserWallet.Open(
test_wallet_path,
to_aes_key(WalletFixtureTestCase.wallet_1_pass()))
address = 'AXjaFSP23Jkbe6Pk9pPGT6NBDs1HVdqaXK'
req = self._gen_rpc_req("sendtoaddress", params=['gas', address, 1])
mock_req = mock_request(json.dumps(req).encode("utf-8"))
res = json.loads(self.app.home(mock_req))
self.assertEqual(res.get('jsonrpc', None), '2.0')
self.assertIn('txid', res.get('result', {}).keys())
self.assertIn('vin', res.get('result', {}).keys())
self.app.wallet.Close()
self.app.wallet = None
os.remove(WalletFixtureTestCase.wallet_1_dest())
def test_send_to_address_insufficient_funds(self):
test_wallet_path = shutil.copyfile(
WalletFixtureTestCase.wallet_1_path(),
WalletFixtureTestCase.wallet_1_dest())
self.app.wallet = UserWallet.Open(
test_wallet_path,
to_aes_key(WalletFixtureTestCase.wallet_1_pass()))
address = 'AXjaFSP23Jkbe6Pk9pPGT6NBDs1HVdqaXK'
req = self._gen_rpc_req("sendtoaddress", params=['gas', address, 51])
mock_req = mock_request(json.dumps(req).encode("utf-8"))
res = json.loads(self.app.home(mock_req))
error = res.get('error', {})
self.assertEqual(error.get('code', None), -300)
self.assertEqual(error.get('message', None), "Insufficient funds")
self.app.wallet.Close()
self.app.wallet = None
os.remove(WalletFixtureTestCase.wallet_1_dest())
def __init__(self):
"""
initializes the database by calling the create_tables method; redeclares the contract hash (for redundancy);
initializes variables that are needed to get the faucet instance running as well as pass data to the smart
contract; sets up the wallet; checks the height of the blockchain and compares it to the block height of the
wallet, if they are not equivalent, it processes new blocks until they are
"""
self._create_tables()
self.params = []
self.invoke_args = []
self.sent_tx = None
self.token_name = os.environ.get('TOKEN_NAME')
self.token_symbol = os.environ.get('TOKEN_SYMBOL')
self.token_script_hash = os.environ.get('TOKEN_SCRIPT_HASH')
if self.token_name is None or self.token_symbol is None or self.token_script_hash is None:
raise Exception(
'Please set TOKEN_NAME, TOKEN_SYMBOL, and TOKEN_SCRIPT_HASH in ./config/nep5-token.json'
)
wallet_path = os.environ.get('FAUCET_WALLET_PATH')
wallet_pwd = to_aes_key(os.environ.get('FAUCET_WALLET_PASSWORD'))
self.faucet_wallet_addr = os.environ.get('FAUCET_WALLET_ADDRESS')
if wallet_pwd is None or wallet_path is None or self.faucet_wallet_addr is None:
raise Exception(
'Please set FAUCET_WALLET_PATH, FAUCET_WALLET_PASSWORD, and FAUCET_WALLET_ADDRESS '
'in ./config/environment.json')
self.wallet = UserWallet.Open(path=wallet_path, password=wallet_pwd)
dbloop = task.LoopingCall(
self.wallet.ProcessBlocks) # specifies what function to call
dbloop.start(
.1
) # every 0.1 seconds, self.wallet.ProcessBlocks function is called
self.wallet.Rebuild()
self.wallet._current_height = 100000 # is this arbitrary or is there a specific reason to set at this height?
logger.info(f'created wallet: {self.wallet.ToJson()}')
def test_send_to_address_fails_to_sign_tx(self):
with patch('neo.api.JSONRPC.JsonRpcApi.Wallet.Sign',
return_value='False'):
test_wallet_path = shutil.copyfile(
WalletFixtureTestCase.wallet_1_path(),
WalletFixtureTestCase.wallet_1_dest())
self.app.wallet = UserWallet.Open(
test_wallet_path,
to_aes_key(WalletFixtureTestCase.wallet_1_pass()))
address = 'AXjaFSP23Jkbe6Pk9pPGT6NBDs1HVdqaXK'
req = self._gen_rpc_req("sendtoaddress",
params=['gas', address, 1])
mock_req = mock_request(json.dumps(req).encode("utf-8"))
res = json.loads(self.app.home(mock_req))
self.assertEqual(res.get('jsonrpc', None), '2.0')
self.assertIn('type', res.get('result', {}).keys())
self.assertIn('hex', res.get('result', {}).keys())
self.app.wallet.Close()
self.app.wallet = None
os.remove(WalletFixtureTestCase.wallet_1_dest())
def test_gettxhistory(self):
test_wallet_path = shutil.copyfile(
WalletFixtureTestCase.wallet_1_path(),
WalletFixtureTestCase.wallet_1_dest()
)
self.app.wallet = UserWallet.Open(
test_wallet_path,
to_aes_key(WalletFixtureTestCase.wallet_1_pass())
)
req = self._gen_rpc_req("gettxhistory")
mock_req = mock_request(json.dumps(req).encode("utf-8"))
res = json.loads(self.app.home(mock_req))
for tx in res['result']:
self.assertIn('txid', tx.keys())
self.assertIsNotNone(tx['txid'])
self.assertIn('block_index', tx.keys())
self.assertIsNotNone(tx['block_index'])
self.assertIn('blocktime', tx.keys())
self.assertIsNotNone(tx['blocktime'])
self.assertEqual(len(res['result']), 9)
self.app.wallet.Close()
self.app.wallet = None
os.remove(WalletFixtureTestCase.wallet_1_dest())
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 = ""
if path == "w1.wallet":
passwd = 'coz'
else:
passwd = prompt("[Password]> ", is_password=True)
try:
self.Wallet = UserWallet.Open(path, passwd)
self._walletdb_loop = task.LoopingCall(self.Wallet.ProcessBlocks)
self._walletdb_loop.start(1)
print("Opened wallet at %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 GetWallet1(cls, recreate=False):
if cls._wallet1 is None or recreate:
cls._wallet1 = UserWallet.Open(
LeaderTestCase.wallet_1_dest(),
to_aes_key(LeaderTestCase.wallet_1_pass()))
return cls._wallet1
class TestContract(BoaFixtureTest):
dispatched_events = []
dispatched_logs = []
now_in_test = 1510235265
WHITELIST_SALE_RATE = 4666 * 100000000
WHITELIST_SALE_UPPER_RATE = 5000 * 100000000
PRESALE_RATE = 4333 * 100000000
CROWDSALE_WEEK1_RATE = 4000 * 100000000
CROWDSALE_WEEK2_RATE = 3833 * 100000000
CROWDSALE_WEEK3_RATE = 3666 * 100000000
CROWDSALE_WEEK4_RATE = 3500 * 100000000
WHITELIST_SALE_PERSONAL_CAP = 500 * 100000000 # 500 NEO
PRESALE_PERSONAL_CAP = 250 * 100000000 # 250 NEO
CROWDSALE_PERSONAL_CAP = 500 * 100000000 # 500 NEO
wallet = {
'ECOSYSTEM_RESERVE_ADDRESS':
UserWallet.Open('./fixtures/testwallet8.db3', to_aes_key('testwallet'))
}
@classmethod
def tearDownClass(cls):
super(BoaFixtureTest, cls).tearDownClass()
try:
if os.path.exists(settings.DEBUG_STORAGE_PATH):
shutil.rmtree(settings.DEBUG_STORAGE_PATH)
except Exception as e:
print("couldn't remove debug storage %s " % e)
@classmethod
def setUpClass(cls):
super(TestContract, cls).setUpClass()
cls.dirname = '/'.join(os.path.abspath(__file__).split('/')[:-2])
def on_notif(evt):
print(evt)
cls.dispatched_events.append(evt)
print("dispatched events %s " % cls.dispatched_events)
def on_log(evt):
print(evt)
cls.dispatched_logs.append(evt)
events.on(SmartContractEvent.RUNTIME_NOTIFY, on_notif)
events.on(SmartContractEvent.RUNTIME_LOG, on_log)
def test_ICOTemplate_1(self):
output = Compiler.instance().load('%s/ico_template.py' %
TestContract.dirname).default
out = output.write()
tx, results, total_ops, engine = TestBuild(out, ['totalSupply', '[]'],
self.GetWallet1(), '0705',
'05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(), TOKEN_TOTAL_SUPPLY)
tx, results, total_ops, engine = TestBuild(out, [
'set_config',
parse_param(['WHITELIST_SALE_OPEN', self.now_in_test])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), True)
tx, results, total_ops, engine = TestBuild(out, [
'set_config',
parse_param(['WHITELIST_SALE_CLOSE', self.now_in_test + 86400])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), True)
tx, results, total_ops, engine = TestBuild(out, [
'set_config',
parse_param(['WHITELIST_SALE_RATE', self.WHITELIST_SALE_RATE])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), True)
tx, results, total_ops, engine = TestBuild(out, [
'set_config',
parse_param(
['WHITELIST_SALE_UPPER_RATE', self.WHITELIST_SALE_UPPER_RATE])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), True)
tx, results, total_ops, engine = TestBuild(out, [
'set_config',
parse_param([
'WHITELIST_SALE_PERSONAL_CAP', self.WHITELIST_SALE_PERSONAL_CAP
])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), True)
tx, results, total_ops, engine = TestBuild(out, [
'set_config',
parse_param(['PRESALE_OPEN', self.now_in_test + 86400 * 2])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), True)
tx, results, total_ops, engine = TestBuild(out, [
'set_config',
parse_param(['PRESALE_CLOSE', self.now_in_test + 86400 * 3])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), True)
tx, results, total_ops, engine = TestBuild(
out,
['set_config',
parse_param(['PRESALE_RATE', self.PRESALE_RATE])],
self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), True)
tx, results, total_ops, engine = TestBuild(out, [
'set_config',
parse_param(['PRESALE_PERSONAL_CAP', self.PRESALE_PERSONAL_CAP])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), True)
tx, results, total_ops, engine = TestBuild(out, [
'set_config',
parse_param(['CROWDSALE_OPEN', self.now_in_test + 86400 * 4])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), True)
tx, results, total_ops, engine = TestBuild(out, [
'set_config',
parse_param(['CROWDSALE_WEEK1_RATE', self.CROWDSALE_WEEK1_RATE])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), True)
tx, results, total_ops, engine = TestBuild(out, [
'set_config',
parse_param(['CROWDSALE_WEEK2_RATE', self.CROWDSALE_WEEK2_RATE])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), True)
tx, results, total_ops, engine = TestBuild(out, [
'set_config',
parse_param(['CROWDSALE_WEEK3_RATE', self.CROWDSALE_WEEK3_RATE])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), True)
tx, results, total_ops, engine = TestBuild(out, [
'set_config',
parse_param(['CROWDSALE_WEEK4_RATE', self.CROWDSALE_WEEK4_RATE])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), True)
tx, results, total_ops, engine = TestBuild(
out,
['get_config', parse_param(['CROWDSALE_WEEK4_RATE'])],
self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(), self.CROWDSALE_WEEK4_RATE)
tx, results, total_ops, engine = TestBuild(out, [
'set_config',
parse_param(
['CROWDSALE_PERSONAL_CAP', self.CROWDSALE_PERSONAL_CAP])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), True)
def test_ICOTemplate_2_exchangeable(self):
output = Compiler.instance().load('%s/ico_template.py' %
TestContract.dirname).default
out = output.write()
# before whitelist
tx, results, total_ops, engine = TestBuild(out, [
'get_exchangeable_amount',
parse_param([
self.wallet_3_script_hash.Data, 10 * 100000000,
self.now_in_test - 1
])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(), 0)
# check whitelist rate
tx, results, total_ops, engine = TestBuild(out, [
'get_exchangeable_amount',
parse_param([
self.wallet_3_script_hash.Data, 10 * 100000000,
self.now_in_test
])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(),
10 * self.WHITELIST_SALE_RATE)
# check with upper rate
tx, results, total_ops, engine = TestBuild(out, [
'get_exchangeable_amount',
parse_param([
self.wallet_3_script_hash.Data, 450 * 100000000,
self.now_in_test
])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(
results[0].GetBigInteger(), 400 * self.WHITELIST_SALE_RATE +
50 * self.WHITELIST_SALE_UPPER_RATE)
# check presale rate
tx, results, total_ops, engine = TestBuild(out, [
'get_exchangeable_amount',
parse_param([
self.wallet_3_script_hash.Data, 10 * 100000000,
self.now_in_test + 86400 * 2
])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(), 10 * self.PRESALE_RATE)
# check crowdsale rate
tx, results, total_ops, engine = TestBuild(out, [
'get_exchangeable_amount',
parse_param([
self.wallet_3_script_hash.Data, 10 * 100000000,
self.now_in_test + 86400 * 4
])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(),
10 * self.CROWDSALE_WEEK1_RATE)
tx, results, total_ops, engine = TestBuild(out, [
'get_exchangeable_amount',
parse_param([
self.wallet_3_script_hash.Data, 10 * 100000000,
self.now_in_test + 86400 * 4 + 86400 * 7
])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(),
10 * self.CROWDSALE_WEEK2_RATE)
tx, results, total_ops, engine = TestBuild(out, [
'get_exchangeable_amount',
parse_param([
self.wallet_3_script_hash.Data, 10 * 100000000,
self.now_in_test + 86400 * 4 + 86400 * 7 * 2
])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(),
10 * self.CROWDSALE_WEEK3_RATE)
tx, results, total_ops, engine = TestBuild(out, [
'get_exchangeable_amount',
parse_param([
self.wallet_3_script_hash.Data, 10 * 100000000,
self.now_in_test + 86400 * 4 + 86400 * 7 * 3
])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(),
10 * self.CROWDSALE_WEEK4_RATE)
# after crowdsale
tx, results, total_ops, engine = TestBuild(out, [
'get_exchangeable_amount',
parse_param([
self.wallet_3_script_hash.Data, 10 * 100000000,
self.now_in_test + 86400 * 4 + 86400 * 7 * 4 + 1
])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(), 0)
def test_ICOTemplate_3_personal_cap(self):
output = Compiler.instance().load('%s/ico_template.py' %
TestContract.dirname).default
out = output.write()
# check whitelist cap
tx, results, total_ops, engine = TestBuild(out, [
'get_exchangeable_amount',
parse_param([
self.wallet_3_script_hash.Data,
self.WHITELIST_SALE_PERSONAL_CAP + 1, self.now_in_test
])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(), 0)
# check presale cap
tx, results, total_ops, engine = TestBuild(out, [
'get_exchangeable_amount',
parse_param([
self.wallet_3_script_hash.Data, self.PRESALE_PERSONAL_CAP + 1,
self.now_in_test + 86400 * 2
])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(), 0)
# check crowdsale cap
tx, results, total_ops, engine = TestBuild(out, [
'get_exchangeable_amount',
parse_param([
self.wallet_3_script_hash.Data,
self.CROWDSALE_PERSONAL_CAP + 1, self.now_in_test + 86400 * 4
])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(), 0)
def test_ICOTemplate_4_locked_until(self):
output = Compiler.instance().load('%s/ico_template.py' %
TestContract.dirname).default
out = output.write()
tx, results, total_ops, engine = TestBuild(out, [
'get_locked_until',
parse_param([bytearray(ECOSYSTEM_RESERVE_ADDRESS)])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(),
self.now_in_test + 3 * 30 * 86400)
# cannot transfer to locked account
test_transfer_amount = 2400000001
tx, results, total_ops, engine = TestBuild(out, [
'transfer',
parse_param([
bytearray(TOKEN_OWNER),
bytearray(ECOSYSTEM_RESERVE_ADDRESS), test_transfer_amount
])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), False)
# cannot transfer from locked account
tx, results, total_ops, engine = TestBuild(
out, [
'transfer',
parse_param([
bytearray(ECOSYSTEM_RESERVE_ADDRESS),
bytearray(TOKEN_OWNER), test_transfer_amount
])
], self.wallet['ECOSYSTEM_RESERVE_ADDRESS'], '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), False)
def test_ICOTemplate_5_affiliate(self):
output = Compiler.instance().load('%s/ico_template.py' %
TestContract.dirname).default
out = output.write()
# reconfig to presale
tx, results, total_ops, engine = TestBuild(
out, ['set_config',
parse_param(['WHITELIST_SALE_OPEN', 0])], self.GetWallet1(),
'0705', '05')
tx, results, total_ops, engine = TestBuild(
out, ['set_config',
parse_param(['WHITELIST_SALE_CLOSE', 0])], self.GetWallet1(),
'0705', '05')
tx, results, total_ops, engine = TestBuild(
out,
['set_config',
parse_param(['PRESALE_OPEN', self.now_in_test])],
self.GetWallet1(), '0705', '05')
tx, results, total_ops, engine = TestBuild(out, [
'set_config',
parse_param(['PRESALE_CLOSE', self.now_in_test + 86400])
], self.GetWallet1(), '0705', '05')
# set referer
tx, results, total_ops, engine = TestBuild(out, [
'set_referrer',
parse_param([
self.wallet_3_script_hash.Data,
bytearray(ADVISOR_FUNDS_ADDRESS)
])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), True)
# get referer
tx, results, total_ops, engine = TestBuild(
out,
['get_referrer',
parse_param([self.wallet_3_script_hash.Data])], self.GetWallet1(),
'0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetByteArray(),
bytearray(ADVISOR_FUNDS_ADDRESS))
# test mint tokens, this should return true
tx, results, total_ops, engine = TestBuild(
out, ['mintTokens', '[]', '--attach-neo=10'], self.GetWallet3(),
'0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), True)
# balance of address
tx, results, total_ops, engine = TestBuild(
out, ['balanceOf',
parse_param([self.wallet_3_script_hash.Data])],
self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(), 10 * self.PRESALE_RATE)
# sale balance
tx, results, total_ops, engine = TestBuild(
out, ['balanceOf',
parse_param([bytearray(SALE_FUNDS_ADDRESS)])],
self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(),
TOKEN_SALE_AMOUNT - 10 * self.PRESALE_RATE)
# minted_token
tx, results, total_ops, engine = TestBuild(
out, ['get_minted_tokens',
parse_param([IS_PRESALE])], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(), 10 * self.PRESALE_RATE)
# contributed_neo
tx, results, total_ops, engine = TestBuild(out, [
'get_contributed_neo',
parse_param([IS_PRESALE, self.wallet_3_script_hash.Data])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(), 10 * 100000000)
tx, results, total_ops, engine = TestBuild(out, [
'get_contributed_neo',
parse_param([IS_CROWDSALE, self.wallet_3_script_hash.Data])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(), 0)
# circulation
tx, results, total_ops, engine = TestBuild(
out, ['circulation', parse_param([])], self.GetWallet1(), '0705',
'05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(), TOKEN_TOTAL_SUPPLY)
# referer not kyc
tx, results, total_ops, engine = TestBuild(
out,
['balanceOf',
parse_param([bytearray(ADVISOR_FUNDS_ADDRESS)])],
self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(), TOKEN_ADVISOR_AMOUNT)
tx, results, total_ops, engine = TestBuild(
out,
['balanceOf',
parse_param([bytearray(AFFILIATE_FUNDS_ADDRESS)])],
self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(), TOKEN_AFFILIATE_AMOUNT)
# referer kyc registered
tx, results, total_ops, engine = TestBuild(
out,
['kyc_register',
parse_param([bytearray(ADVISOR_FUNDS_ADDRESS)])],
self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(), 1)
tx, results, total_ops, engine = TestBuild(
out, ['mintTokens', '[]', '--attach-neo=10'], self.GetWallet3(),
'0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), True)
tx, results, total_ops, engine = TestBuild(
out,
['balanceOf',
parse_param([bytearray(ADVISOR_FUNDS_ADDRESS)])],
self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(
results[0].GetBigInteger(),
10 * self.PRESALE_RATE * 25 / 1000 + TOKEN_ADVISOR_AMOUNT)
tx, results, total_ops, engine = TestBuild(
out,
['balanceOf',
parse_param([bytearray(AFFILIATE_FUNDS_ADDRESS)])],
self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(
results[0].GetBigInteger(),
TOKEN_AFFILIATE_AMOUNT - 10 * self.PRESALE_RATE * 25 / 1000)
# total affiliate
tx, results, total_ops, engine = TestBuild(
out,
['get_affiliated_tokens', parse_param([])], self.GetWallet1(),
'0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(),
10 * self.PRESALE_RATE * 25 / 1000)
# revert config
self.test_ICOTemplate_1()
def test_ICOTemplate_5_sale_and_kyc(self):
output = Compiler.instance().load('%s/ico_template.py' %
TestContract.dirname).default
out = output.write()
# kyc registered in whitelistsale, ok
tx, results, total_ops, engine = TestBuild(
out, ['mintTokens', '[]', '--attach-neo=10'], self.GetWallet3(),
'0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), True)
# reject kyc
tx, results, total_ops, engine = TestBuild(
out, ['kyc_reject',
parse_param([self.wallet_3_script_hash.Data])],
self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(), 1)
# kyc rejected, fail
tx, results, total_ops, engine = TestBuild(
out, ['mintTokens', '[]', '--attach-neo=10'], self.GetWallet3(),
'0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), False)
# reconfig to presale
tx, results, total_ops, engine = TestBuild(
out, ['set_config',
parse_param(['WHITELIST_SALE_OPEN', 0])], self.GetWallet1(),
'0705', '05')
tx, results, total_ops, engine = TestBuild(
out, ['set_config',
parse_param(['WHITELIST_SALE_CLOSE', 0])], self.GetWallet1(),
'0705', '05')
tx, results, total_ops, engine = TestBuild(
out,
['set_config',
parse_param(['PRESALE_OPEN', self.now_in_test])],
self.GetWallet1(), '0705', '05')
tx, results, total_ops, engine = TestBuild(out, [
'set_config',
parse_param(['PRESALE_CLOSE', self.now_in_test + 86400])
], self.GetWallet1(), '0705', '05')
# kyc rejected, fail
tx, results, total_ops, engine = TestBuild(
out, ['mintTokens', '[]', '--attach-neo=10'], self.GetWallet3(),
'0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), False)
# reconfig to presale
tx, results, total_ops, engine = TestBuild(
out, ['set_config', parse_param(['PRESALE_OPEN', 0])],
self.GetWallet1(), '0705', '05')
tx, results, total_ops, engine = TestBuild(
out,
['set_config', parse_param(['PRESALE_CLOSE', 0])],
self.GetWallet1(), '0705', '05')
tx, results, total_ops, engine = TestBuild(
out,
['set_config',
parse_param(['CROWDSALE_OPEN', self.now_in_test])],
self.GetWallet1(), '0705', '05')
# crowdsale not require kyc, success
tx, results, total_ops, engine = TestBuild(
out, ['mintTokens', '[]', '--attach-neo=10'], self.GetWallet3(),
'0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), True)
# revert kyc
tx, results, total_ops, engine = TestBuild(
out,
['kyc_register',
parse_param([self.wallet_3_script_hash.Data])], self.GetWallet1(),
'0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(), 1)
# revert config
self.test_ICOTemplate_1()
def test_ICOTemplate_6_sale_cap(self):
output = Compiler.instance().load('%s/ico_template.py' %
TestContract.dirname).default
out = output.write()
tx, results, total_ops, engine = TestBuild(out, [
'set_config',
parse_param(
['WHITELIST_SALE_PERSONAL_CAP', 2 * 70000000 * 100000000])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), True)
tx, results, total_ops, engine = TestBuild(out, [
'set_config',
parse_param(['PRESALE_PERSONAL_CAP', 2 * 65000000 * 100000000])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), True)
tx, results, total_ops, engine = TestBuild(out, [
'set_config',
parse_param(['CROWDSALE_PERSONAL_CAP', 2 * 480000000 * 100000000])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBoolean(), True)
# check whitelist cap
tx, results, total_ops, engine = TestBuild(out, [
'get_exchangeable_amount',
parse_param([
self.wallet_3_script_hash.Data, 70000000 * 100000000 /
self.WHITELIST_SALE_RATE * 100000000, self.now_in_test
])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(), 0)
# # check presale cap
tx, results, total_ops, engine = TestBuild(out, [
'get_exchangeable_amount',
parse_param([
self.wallet_3_script_hash.Data, 65000000 * 100000000 /
self.PRESALE_RATE * 100000000, self.now_in_test + 86400 * 2
])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(), 0)
# # check crowdsale cap
tx, results, total_ops, engine = TestBuild(out, [
'get_exchangeable_amount',
parse_param([
self.wallet_3_script_hash.Data,
480000000 * 100000000 / self.CROWDSALE_WEEK1_RATE * 100000000,
self.now_in_test + 86400 * 4
])
], self.GetWallet1(), '0705', '05')
self.assertEqual(len(results), 1)
self.assertEqual(results[0].GetBigInteger(), 0)
# revert config
self.test_ICOTemplate_1()
def run(self):
dbloop = task.LoopingCall(Blockchain.Default().PersistBlocks)
dbloop.start(.1)
Blockchain.Default().PersistBlocks()
while Blockchain.Default().Height < 2:
print("Waiting for wallet to sync...")
time.sleep(1)
print("Creating Wallet...")
self.wallet = UserWallet.Create(path=self.wallet_fn,
password=self.wallet_pwd)
self.wallet.ProcessBlocks()
# Extract infos from wallet
contract = self.wallet.GetDefaultContract()
key = self.wallet.GetKey(contract.PublicKeyHash)
address = key.GetAddress()
wif = key.Export()
print("- Address:", address)
print("- WIF key:", wif)
self.wallet = None
# Claim initial NEO
self.claim_initial_neo(address)
# Open wallet again
self.wallet = UserWallet.Open(self.wallet_fn, self.wallet_pwd)
self._walletdb_loop = task.LoopingCall(self.wallet.ProcessBlocks)
self._walletdb_loop.start(1)
print("\nWait %s min before claiming GAS." % self.min_wait)
time.sleep(60 * self.min_wait)
print("\nSending NEO to own wallet...")
tx = construct_and_send(None,
self.wallet, ["neo", address, "100000000"],
prompt_password=False)
if not tx:
print("Something went wrong, no tx.")
return
# Wait until transaction is on blockchain
self.wait_for_tx(tx)
print("Claiming the GAS...")
claim_tx, relayed = ClaimGas(self.wallet, require_password=False)
self.wait_for_tx(claim_tx)
# Finally, need to rebuild the wallet
self.wallet.Rebuild()
print("\nAll done!")
print("- WIF key: %s" % wif)
print("- Wallet file: %s" % self.wallet_fn)
print("- Wallet pwd: %s" % self.wallet_pwd)
if self.wif_fn:
with open(self.wif_fn, "w") as f:
f.write(wif)
self.quit()
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 test_privnet_wallet(self):
""" Simple test if we can open the privnet wallet """
wallet = UserWallet.Open(
os.path.join(ROOT_INSTALL_PATH,
"neo/data/neo-privnet.sample.wallet"),
to_aes_key("coz"))
def test_gather_param(self):
with mock.patch('neo.Prompt.Utils.get_input_prompt',
return_value='hello') as fake_prompt:
result, abort = Utils.gather_param(0, ContractParameterType.String)
self.assertEqual(result, 'hello')
with mock.patch('neo.Prompt.Utils.get_input_prompt',
return_value=1) as fake_prompt:
result, abort = Utils.gather_param(0,
ContractParameterType.Integer)
self.assertEqual(result, 1)
with mock.patch('neo.Prompt.Utils.get_input_prompt',
return_value='1') as fake_prompt:
result, abort = Utils.gather_param(0,
ContractParameterType.Integer)
self.assertEqual(result, 1)
with mock.patch('neo.Prompt.Utils.get_input_prompt',
return_value=1.03) as fake_prompt:
result, abort = Utils.gather_param(0,
ContractParameterType.Integer)
self.assertEqual(result, 1)
with mock.patch('neo.Prompt.Utils.get_input_prompt',
return_value="bytearray(b'abc')") as fake_prompt:
result, abort = Utils.gather_param(0,
ContractParameterType.ByteArray)
self.assertEqual(result, bytearray(b'abc'))
with mock.patch('neo.Prompt.Utils.get_input_prompt',
return_value="b'abc'") as fake_prompt:
result, abort = Utils.gather_param(0,
ContractParameterType.ByteArray)
self.assertEqual(result, bytearray(b'abc'))
with mock.patch('neo.Prompt.Utils.get_input_prompt',
return_value="abc") as fake_prompt:
result, abort = Utils.gather_param(0,
ContractParameterType.Boolean)
self.assertEqual(result, True)
with mock.patch('neo.Prompt.Utils.get_input_prompt',
return_value=0) as fake_prompt:
result, abort = Utils.gather_param(0,
ContractParameterType.Boolean)
self.assertEqual(result, False)
# test ContractParameterType.ByteArray for address input
with mock.patch('neo.Prompt.Utils.get_input_prompt',
return_value='AeV59NyZtgj5AMQ7vY6yhr2MRvcfFeLWSb'
) as fake_prompt:
result, abort = Utils.gather_param(0,
ContractParameterType.ByteArray)
self.assertEqual(
result,
bytearray(
b'\xf9\x1dkp\x85\xdb|Z\xaf\t\xf1\x9e\xee\xc1\xca<\r\xb2\xc6\xec'
))
with mock.patch('neo.Prompt.Utils.get_input_prompt',
return_value='["a","b","c"]') as fake_prompt:
result, abort = Utils.gather_param(0, ContractParameterType.Array)
self.assertEqual(result, ['a', 'b', 'c'])
with mock.patch(
'neo.Prompt.Utils.get_input_prompt',
return_value='["a","b","c", [1, 3, 4], "e"]') as fake_prompt:
result, abort = Utils.gather_param(0, ContractParameterType.Array)
self.assertEqual(result, ['a', 'b', 'c', [1, 3, 4], 'e'])
# test ContractParameterType.Array without a closed list
with mock.patch(
'neo.Prompt.Utils.get_input_prompt',
return_value='["a","b","c", [1, 3, 4], "e"') as fake_prompt:
result, abort = Utils.gather_param(0,
ContractParameterType.Array,
do_continue=False)
self.assertEqual(result, None)
self.assertEqual(abort, True)
# test ContractParameterType.Array with no list
with mock.patch('neo.Prompt.Utils.get_input_prompt',
return_value="b'abc'") as fake_prompt:
result, abort = Utils.gather_param(0,
ContractParameterType.Array,
do_continue=False)
self.assertRaises(Exception, "Please provide a list")
self.assertEqual(result, None)
self.assertEqual(abort, True)
# test ContractParameterType.PublicKey
with mock.patch(
'neo.Prompt.Utils.get_input_prompt',
return_value=
"03cbb45da6072c14761c9da545749d9cfd863f860c351066d16df480602a2024c6"
) as fake_prompt:
test_wallet_path = shutil.copyfile(
WalletFixtureTestCase.wallet_1_path(),
WalletFixtureTestCase.wallet_1_dest())
wallet = UserWallet.Open(
test_wallet_path,
to_aes_key(WalletFixtureTestCase.wallet_1_pass()))
addr_scripthash = wallet.GetStandardAddress()
result, abort = Utils.gather_param(0,
ContractParameterType.PublicKey)
script = b'21' + result.encode_point(True) + b'ac'
pk_script_hash = Crypto.ToScriptHash(script)
self.assertEqual(
addr_scripthash, pk_script_hash
) # verifies the functionality of ContractParameterType.PublicKey
wallet.Close()
wallet = None
os.remove(WalletFixtureTestCase.wallet_1_dest())
# test ContractParameterType.PublicKey with bad public key
with mock.patch('neo.Prompt.Utils.get_input_prompt',
return_value="blah") as fake_prompt:
result, abort = Utils.gather_param(0,
ContractParameterType.PublicKey)
self.assertIsNone(result)
self.assertTrue(abort)
# test unknown ContractParameterType
with mock.patch('neo.Prompt.Utils.get_input_prompt',
return_value="9698b1cac6ce9cbe8517e490778525b929e01903"
) as fake_prompt:
result, abort = Utils.gather_param(0,
ContractParameterType.Hash160,
do_continue=False)
self.assertRaises(Exception, "Unknown param type Hash160")
self.assertEqual(result, None)
self.assertEqual(abort, True)
# test Exception
with mock.patch('sys.stdout', new=StringIO()) as mock_print:
with mock.patch(
'neo.Prompt.Utils.get_input_prompt') as fake_prompt:
fake_prompt.side_effect = [
Exception(-32602, "Invalid params"), KeyboardInterrupt
]
result, abort = Utils.gather_param(
0, ContractParameterType.String)
self.assertEqual(result, None)
self.assertEqual(abort, True)
self.assertIn("Invalid params", mock_print.getvalue())
# test KeyboardInterrupt
with mock.patch('sys.stdout', new=StringIO()) as mock_print:
with mock.patch(
'neo.Prompt.Utils.get_input_prompt') as fake_prompt:
fake_prompt.side_effect = [KeyboardInterrupt]
result, abort = Utils.gather_param(
0, ContractParameterType.String)
self.assertEqual(result, None)
self.assertEqual(abort, True)
self.assertIn("Input cancelled", mock_print.getvalue())
def main():
parser = argparse.ArgumentParser(
description=
'A utility for signing messages. Example usage: "np-sign mymessage --wallet_file path/to/my/wallet" or use an NEP2 key/passphrase like "np-sign mymessage -n"'
)
parser.add_argument('message',
type=str,
help='The message in string format to be signed')
parser.add_argument(
'-w',
'--wallet_file',
type=str,
default=None,
help='If using a wallet file, the path to the wallet file')
parser.add_argument(
'-a',
'--address',
type=str,
default=False,
help=
'If using a wallet file with more than 1 address, the address you would like to use. Otherwise the default address will be used'
)
parser.add_argument(
'-n',
'--nep2',
action='store_true',
help="Whether to use an NEP2 passhrase rather than a wallet")
parser.add_argument('--wif',
type=str,
default=None,
help='If using a wif pass in the wif')
args = parser.parse_args()
try:
if args.wallet_file:
passwd = prompt('[Wallet password]> ', is_password=True)
wallet = UserWallet.Open(args.wallet_file, to_aes_key(passwd))
contract = wallet.GetDefaultContract()
if args.address:
addr = args.address
script_hash = Helper.AddrStrToScriptHash(addr)
contract = wallet.GetContract(script_hash)
if contract is None:
raise Exception('Address %s not found in wallet %s ' %
(addr, args.wallet_file))
print("Signing With Address %s " % contract.Address)
signature, pubkey = wallet.SignMessage(args.message,
contract.ScriptHash)
pubkey = pubkey.encode_point().decode('utf-8')
signature = signature.hex()
print("pubkey, sig: %s %s " % (pubkey, signature))
elif args.nep2:
nep2_key = prompt('[nep2 key]> ', is_password=True)
nep2_passwd = prompt("[nep2 key password]> ", is_password=True)
prikey = KeyPair.PrivateKeyFromNEP2(nep2_key, nep2_passwd)
keypair = KeyPair(priv_key=prikey)
contract = Contract.CreateSignatureContract(keypair.PublicKey)
print("Signing With Address %s " % contract.Address)
signature = Crypto.Sign(args.message, prikey)
pubkey = keypair.PublicKey.encode_point().decode('utf-8')
signature = signature.hex()
print("pubkey, sig: %s %s " % (pubkey, signature))
elif args.wif:
prikey = KeyPair.PrivateKeyFromWIF(args.wif)
keypair = KeyPair(priv_key=prikey)
contract = Contract.CreateSignatureContract(keypair.PublicKey)
print("Signing With Address %s " % contract.Address)
signature = Crypto.Sign(args.message, prikey)
pubkey = keypair.PublicKey.encode_point().decode('utf-8')
signature = signature.hex()
print("pubkey, sig: %s %s " % (pubkey, signature))
except Exception as e:
print("Could not sign: %s " % e)
