def get_mining_xmss(self):
if self._mining_xmss:
addr_state = self.state.get_address(self._mining_xmss.get_address())
if self.set_unused_ots_key(self._mining_xmss, addr_state, self._mining_xmss.get_index()):
if self.valid_mining_permission():
return self._mining_xmss
else:
self._mining_xmss = None
return None
if not self._mining_xmss:
self._master_address = self._slaves[0].encode()
unused_ots_found = False
for slave_seed in self._slaves[1]:
xmss = Wallet.get_new_address(seed=slave_seed).xmss
addr_state = self.state.get_address(xmss.get_address())
if self.set_unused_ots_key(xmss, addr_state): # Unused ots_key_found
self._mining_xmss = xmss
unused_ots_found = True
break
if not unused_ots_found: # Unused ots_key_found
logger.warning('No OTS-KEY left for mining')
return None
if self._master_address == self._mining_xmss.get_address():
return self._mining_xmss
if not self.valid_mining_permission():
return None
return self._mining_xmss
def get_mining_xmss(self):
if self._mining_xmss:
addr_state = self.state.get_address(self._mining_xmss.address)
if self.set_unused_ots_key(self._mining_xmss, addr_state,
self._mining_xmss.ots_index):
if self.valid_mining_permission():
return self._mining_xmss
else:
self._mining_xmss = None
return None
if not self._mining_xmss:
self._master_address = self._slaves[0]
unused_ots_found = False
for slave_seed in self._slaves[1]:
xmss = Wallet.get_new_address(signature_tree_height=None,
seed=slave_seed).xmss
addr_state = self.state.get_address(xmss.address)
if self.set_unused_ots_key(xmss,
addr_state): # Unused ots_key_found
self._mining_xmss = xmss
unused_ots_found = True
break
if not unused_ots_found: # Unused ots_key_found
logger.warning('No OTS-KEY left for mining')
return None
if self._master_address == self._mining_xmss.address:
return self._mining_xmss
if not self.valid_mining_permission():
return None
return self._mining_xmss
def test_getnewaddress(self):
with set_wallet_dir("test_wallet"):
wallet = Wallet()
S1 = hstr2bin(
'7bf1e7c1c84be2c820211572d990c0430e09401053ce2af489ee3e4d030c027464d9cac1fff449a2405b7f3fc63018a4'
)
address = wallet.get_new_address(seed=S1)
self.assertIsNotNone(address.address)
self.assertEqual(
b'Q56e5d6410a5716e548d89ca27b8f057122af9560ba3cd8aa99879f32758330267811af83',
address.address)
def mining_wallet_checks(args):
slaves_filename = os.path.join(config.user.wallet_dir, config.user.slaves_filename)
if args.randomizeSlaveXMSS:
addrBundle = Wallet.get_new_address()
slaves = [bin2hstr(addrBundle.xmss.address), [addrBundle.xmss.extended_seed], None]
write_slaves(slaves_filename, slaves)
try:
slaves = read_slaves(slaves_filename)
except FileNotFoundError:
logger.warning('No Slave Seeds found!!')
logger.warning('It is highly recommended to use the slave for mining')
try:
ans = input('Do you want to use main wallet for mining? (Y/N) ')
if ans == 'N':
quit(0)
seed = input('Enter hex or mnemonic seed of mining wallet ').encode()
except KeyboardInterrupt:
quit(0)
if len(seed) == 102: # hexseed
bin_seed = hstr2bin(seed.decode())
elif len(seed.split()) == 34:
bin_seed = mnemonic2bin(seed.decode())
else:
logger.warning('Invalid XMSS seed')
quit(1)
addrBundle = Wallet.get_new_address(signature_tree_height=None, seed=bin_seed)
slaves = [bin2hstr(addrBundle.xmss.address), [addrBundle.xmss.extended_seed], None]
write_slaves(slaves_filename, slaves)
slaves = read_slaves(slaves_filename)
except KeyboardInterrupt:
quit(1)
except Exception as e:
logger.error('Exception %s', e)
quit(1)
return slaves
def mining_wallet_checks(args):
slaves_filename = os.path.join(config.user.wallet_dir, config.user.slaves_filename)
if args.randomizeSlaveXMSS:
addrBundle = Wallet.get_new_address()
slaves = [addrBundle.xmss.get_address(), [addrBundle.xmss.get_seed()], None]
write_slaves(slaves_filename, slaves)
try:
slaves = read_slaves(slaves_filename)
except FileNotFoundError:
logger.warning('No Slave Seeds found!!')
logger.warning('It is highly recommended to use the slave for mining')
try:
ans = input('Do you want to use main wallet for mining? (Y/N) ')
if ans == 'N':
quit(0)
seed = input('Enter hex or mnemonic seed of mining wallet ').encode()
except KeyboardInterrupt:
quit(0)
if len(seed) == 96: # hexseed
bin_seed = hstr2bin(seed.decode())
elif len(seed.split()) == 32:
bin_seed = mnemonic2bin(seed.decode())
else:
logger.warning('Invalid XMSS seed')
quit(1)
addrBundle = Wallet.get_new_address(seed=bin_seed)
slaves = [addrBundle.xmss.get_address(), [addrBundle.xmss.get_seed()], None]
write_slaves(slaves_filename, slaves)
slaves = read_slaves(slaves_filename)
except KeyboardInterrupt:
quit(1)
except Exception as e:
logger.error('Exception %s', e)
quit(1)
return slaves
def wallet_add(ctx):
"""
Adds an address or generates a new wallet (working directory)
"""
if ctx.obj.remote:
click.echo('This command is unsupported for remote wallets')
return
config.user.wallet_path = ctx.obj.wallet_dir
wallet = Wallet()
wallet.append(wallet.get_new_address())
addresses = [a.address for a in wallet.address_bundle]
_print_addresses(ctx, addresses, config.user.wallet_path)
def wallet_add(ctx):
"""
Adds an address or generates a new wallet (working directory)
"""
if ctx.obj.remote:
click.echo('This command is unsupported for remote wallets')
return
config.user.wallet_dir = ctx.obj.wallet_dir
wallet = Wallet()
wallet.append(wallet.get_new_address())
addresses = [a.address for a in wallet.address_bundle]
_print_addresses(ctx, addresses, config.user.wallet_dir)
def wallet_recover(ctx, seed_type):
"""
Recovers a wallet from a hexseed or mnemonic (32 words)
"""
if ctx.obj.remote:
click.echo('This command is unsupported for remote wallets')
return
seed = click.prompt('Please enter your %s' % (seed_type, ))
seed = seed.lower().strip()
if seed_type == 'mnemonic':
words = seed.split()
if len(words) != 34:
print('You have entered %s words' % (len(words), ))
print('Mnemonic seed must contain only 34 words')
return
bin_seed = mnemonic2bin(seed)
else:
if len(seed) != 102:
print('You have entered hexseed of %s characters' % (len(seed), ))
print('Hexseed must be of only 102 characters.')
return
bin_seed = hstr2bin(seed)
config.user.wallet_dir = ctx.obj.wallet_dir
walletObj = Wallet()
addrBundle = walletObj.get_new_address(signature_tree_height=None,
seed=bin_seed)
print('Recovered Wallet Address : %s' % (addrBundle.address.decode(), ))
for addr in walletObj.address_bundle:
if addrBundle.address == addr.address:
print('Wallet Address is already in the wallet list')
return
if click.confirm('Do you want to save the recovered wallet?'):
walletObj.address_bundle.append(addrBundle)
click.echo('Saving...')
walletObj.save_wallet()
click.echo('Done')
def wallet_recover(ctx, seed_type):
"""
Recovers a wallet from a hexseed or mnemonic (32 words)
"""
if ctx.obj.remote:
click.echo('This command is unsupported for remote wallets')
return
seed = click.prompt('Please enter your %s' % (seed_type,))
seed = seed.lower().strip()
if seed_type == 'mnemonic':
words = seed.split()
if len(words) != 32:
print('You have entered %s words' % (len(words),))
print('Mnemonic seed must contain only 32 words')
return
bin_seed = mnemonic2bin(seed)
else:
if len(seed) != 96:
print('You have entered hexseed of %s characters' % (len(seed),))
print('Hexseed must be of only 96 characters.')
return
bin_seed = hstr2bin(seed)
config.user.wallet_dir = ctx.obj.wallet_dir
walletObj = Wallet()
addrBundle = walletObj.get_new_address(seed=bin_seed)
print('Recovered Wallet Address : %s' % (addrBundle.address.decode(),))
for addr in walletObj.address_bundle:
if addrBundle.address == addr.address:
print('Wallet Address is already in the wallet list')
return
if click.confirm('Do you want to save the recovered wallet?'):
walletObj.address_bundle.append(addrBundle)
click.echo('Saving...')
walletObj.save_wallet()
click.echo('Done')
def get_unused_payment_xmss(public_stub):
global payment_slaves
global payment_xmss
master_address = payment_slaves[0]
master_address_state = get_addr_state(master_address)
if payment_xmss:
addr_state = get_addr_state(payment_xmss.address)
if set_unused_ots_key(payment_xmss, addr_state,
payment_xmss.ots_index):
if valid_payment_permission(public_stub, master_address_state,
payment_xmss, payment_slaves[2]):
return payment_xmss
else:
payment_xmss = None
if not payment_xmss:
unused_ots_found = False
for slave_seed in payment_slaves[1]:
xmss = Wallet.get_new_address(signature_tree_height=None,
seed=slave_seed).xmss
addr_state = get_addr_state(xmss.address)
if set_unused_ots_key(xmss, addr_state): # Unused ots_key_found
payment_xmss = xmss
unused_ots_found = True
break
if not unused_ots_found: # Unused ots_key_found
return None
if not valid_payment_permission(public_stub, master_address_state,
payment_xmss, payment_slaves[2]):
return None
return payment_xmss
def create_block(self, last_block, mining_nonce, tx_pool, signing_xmss,
master_address) -> Optional[Block]:
# TODO: Persistence will move to rocksdb
# FIXME: Difference between this and create block?????????????
# FIXME: Break encapsulation
if not self._dummy_xmss:
self._dummy_xmss = Wallet.get_new_address(
signature_tree_height=signing_xmss.height)
dummy_block = Block.create(block_number=last_block.block_number + 1,
prevblock_headerhash=last_block.headerhash,
transactions=[],
signing_xmss=self._dummy_xmss.xmss,
master_address=master_address,
nonce=0)
dummy_block.set_mining_nonce(mining_nonce)
t_pool2 = copy.deepcopy(tx_pool.transaction_pool)
del tx_pool.transaction_pool[:]
######
# recreate the transaction pool as in the tx_hash_list, ordered by txhash..
total_txn = len(t_pool2)
txnum = 0
addresses_set = set()
while txnum < total_txn:
tx = t_pool2[txnum]
tx.set_effected_address(addresses_set)
txnum += 1
addresses_state = dict()
for address in addresses_set:
addresses_state[address] = self.state.get_address(address)
block_size = dummy_block.size
block_size_limit = self.state.get_block_size_limit(last_block)
txnum = 0
while txnum < total_txn:
tx = t_pool2[txnum]
# Skip Transactions for later, which doesn't fit into block
if block_size + tx.size + config.dev.tx_extra_overhead > block_size_limit:
txnum += 1
continue
addr_from_pk_state = addresses_state[tx.addr_from]
addr_from_pk = Transaction.get_slave(tx)
if addr_from_pk:
addr_from_pk_state = addresses_state[addr_from_pk]
if addr_from_pk_state.ots_key_reuse(tx.ots_key):
del t_pool2[txnum]
total_txn -= 1
continue
if isinstance(tx, TransferTransaction):
if addresses_state[
tx.addr_from].balance < tx.total_amount + tx.fee:
logger.warning('%s %s exceeds balance, invalid tx', tx,
tx.addr_from)
logger.warning('type: %s', tx.type)
logger.warning(
'Buffer State Balance: %s Transfer Amount %s',
addresses_state[tx.addr_from].balance, tx.total_amount)
del t_pool2[txnum]
total_txn -= 1
continue
if isinstance(tx, MessageTransaction):
if addresses_state[tx.addr_from].balance < tx.fee:
logger.warning('%s %s exceeds balance, invalid message tx',
tx, tx.addr_from)
logger.warning('type: %s', tx.type)
logger.warning('Buffer State Balance: %s Free %s',
addresses_state[tx.addr_from].balance,
tx.fee)
total_txn -= 1
continue
if isinstance(tx, TokenTransaction):
if addresses_state[tx.addr_from].balance < tx.fee:
logger.warning('%s %s exceeds balance, invalid tx', tx,
tx.addr_from)
logger.warning('type: %s', tx.type)
logger.warning('Buffer State Balance: %s Fee %s',
addresses_state[tx.addr_from].balance,
tx.fee)
del t_pool2[txnum]
total_txn -= 1
continue
if isinstance(tx, TransferTokenTransaction):
if addresses_state[tx.addr_from].balance < tx.fee:
logger.warning('%s %s exceeds balance, invalid tx', tx,
tx.addr_from)
logger.warning('type: %s', tx.type)
logger.warning(
'Buffer State Balance: %s Transfer Amount %s',
addresses_state[tx.addr_from].balance, tx.fee)
del t_pool2[txnum]
total_txn -= 1
continue
if bin2hstr(tx.token_txhash).encode() not in addresses_state[
tx.addr_from].tokens:
logger.warning(
'%s doesnt own any token with token_txnhash %s',
tx.addr_from,
bin2hstr(tx.token_txhash).encode())
del t_pool2[txnum]
total_txn -= 1
continue
if addresses_state[tx.addr_from].tokens[bin2hstr(
tx.token_txhash).encode()] < tx.total_amount:
logger.warning(
'Token Transfer amount exceeds available token')
logger.warning('Token Txhash %s',
bin2hstr(tx.token_txhash).encode())
logger.warning(
'Available Token Amount %s',
addresses_state[tx.addr_from].tokens[bin2hstr(
tx.token_txhash).encode()])
logger.warning('Transaction Amount %s', tx.total_amount)
del t_pool2[txnum]
total_txn -= 1
continue
if isinstance(tx, LatticePublicKey):
if addresses_state[tx.addr_from].balance < tx.fee:
logger.warning(
'Lattice TXN %s %s exceeds balance, invalid tx', tx,
tx.addr_from)
logger.warning('type: %s', tx.type)
logger.warning(
'Buffer State Balance: %s Transfer Amount %s',
addresses_state[tx.addr_from].balance, tx.fee)
del t_pool2[txnum]
total_txn -= 1
continue
if isinstance(tx, SlaveTransaction):
if addresses_state[tx.addr_from].balance < tx.fee:
logger.warning(
'Slave TXN %s %s exceeds balance, invalid tx', tx,
tx.addr_from)
logger.warning('type: %s', tx.type)
logger.warning(
'Buffer State Balance: %s Transfer Amount %s',
addresses_state[tx.addr_from].balance, tx.fee)
del t_pool2[txnum]
total_txn -= 1
continue
tx.apply_on_state(addresses_state)
tx_pool.add_tx_to_pool(tx)
tx._data.nonce = addresses_state[tx.addr_from].nonce
txnum += 1
block_size += tx.size + config.dev.tx_extra_overhead
coinbase_nonce = self.state.get_address(signing_xmss.address).nonce
if signing_xmss.address in addresses_state:
coinbase_nonce = addresses_state[signing_xmss.address].nonce + 1
block = Block.create(block_number=last_block.block_number + 1,
prevblock_headerhash=last_block.headerhash,
transactions=t_pool2,
signing_xmss=signing_xmss,
master_address=master_address,
nonce=coinbase_nonce)
return block
