def modify_multisig(self, tx_dict):
self._common_header(tx_dict)
self.binary += len(tx_dict['modifications']).to_bytes(4, "little") # cosign num
is_mainnet = tx_dict['version'] == 1744830464
cosigners = {
get_address(e['cosignatoryAccount'], main_net=is_mainnet):
(e['modificationType'], e['cosignatoryAccount'])
for e in tx_dict['modifications']}
for account in sorted(cosigners, reverse=False):
co_type = cosigners[account][0]
pubkey = cosigners[account][1]
self.binary += self.const4bytes_address # const 0x28000000
self.binary += co_type.to_bytes(4, "little") # cosig type
self.binary += self.const4bytes_signer # const 0x20000000
self.binary += unhexlify(pubkey.encode('utf8')) # pubkey
if tx_dict['minCosignatories']['relativeChange'] < 0:
self.binary += int(4).to_bytes(4, "little")
self.binary += tx_dict['minCosignatories']['relativeChange'].to_bytes(4, "little", signed=True)
elif tx_dict['minCosignatories']['relativeChange'] > 0:
self.binary += int(4).to_bytes(4, "little")
self.binary += tx_dict['minCosignatories']['relativeChange'].to_bytes(4, "little")
return
def _single_generate(index, **kwargs):
sk_hex = secret_key()
sk = unhexlify(sk_hex.encode())
if kwargs['encrypt_key']:
sk = AESCipher.encrypt(key=kwargs['encrypt_key'], raw=sk)
pk_hex = public_key(sk_hex)
pk = unhexlify(pk_hex.encode())
ck = get_address(pk=pk_hex, prefix=kwargs['prefix'])
t = int(time.time() - kwargs['genesis_time'])
return sk, pk, ck, C.ANT_RESERVED, t
def test():
PUB = '80d2ae0d784d28db38b5b85fd77e190981cea6f4328235ec173a90c2853c0761'
PRI = '6a858fb93e0202fa62f894e591478caa23b06f90471e7976c30fb95efda4b312'
MSG = "how silent! the cicada's voice soaks into the rocks. " \
"Up here, a stillness the sound of the cicadas seeps into the crags.".encode()
address = get_address(pk=PUB, main_net=True)
print(address)
sign_raw = sign(msg=MSG, sk=PRI, pk=PUB)
print(sign_raw)
# raised ValueError if verification filed
verify(msg=MSG, sign=sign_raw, pk=PUB)
PUB2 = '28e8469422106f406051a24f2ea6402bac6f1977cf7e02eb3bf8c11d4070157a'
PRI2 = '3c60f29c84b63c76ca8e3f1068ad328285ae8d5af2a95aa99ceb83d327dfb97e'
print("pub2 address", get_address(pk=PUB2, main_net=True))
enc = encrypt(sk=PRI, pk=PUB2, msg=MSG)
print(enc)
dec = decrypt(sk=PRI2, pk=PUB, enc=enc)
print(dec)
def _verify(pubkey, signature, txhash, tx_b, prefix):
try:
verify(msg=tx_b, sign=signature, pk=pubkey)
address = get_address(pk=pubkey, prefix=prefix)
return pubkey, signature, txhash, address
except ValueError:
error = "Failed verify tx {}".format(hexlify(txhash).decode())
logging.debug(error)
except BaseException as e:
error = 'Signature verification error. "{}"'.format(e)
logging.error(error)
return pubkey, signature, txhash, error
def _process(que, number, request, main_net, prefix):
count = 0
while True:
count += 1
sk = secret_key()
pk = public_key(sk)
ck = get_address(pk, main_net, prefix)
if request in ck:
que.put((True, sk, pk, ck))
exit(1)
elif count % 100 == 0:
que.put((False, number, count))
count = 0
def __init__(self, nem, pk, sk=None, main_net=True):
super().__init__(name='Account', daemon=True)
assert isinstance(pk, str), 'pk is string format'
self.f_ok = False
self.nem = nem
self.sk = sk
self.pk = pk
self.main_net = main_net
self.ck = get_address(pk, main_net=main_net)
dir_name = 'nem_python' + ('' if main_net else '_test')
# data and tmp dir settings
self.data_dir = os.path.join(os.path.expanduser('~'), dir_name)
if not os.path.exists(self.data_dir):
os.makedirs(self.data_dir)
self.tmp_dir = os.path.join(gettempdir(), dir_name)
if not os.path.exists(self.tmp_dir):
os.makedirs(self.tmp_dir)
# DB related settings
self.transaction = fasteners.InterProcessLock(os.path.join(self.tmp_dir, 'account.%s.lock' % self.ck))
self.db_path = os.path.join(self.data_dir, 'account.%s.db' % self.ck)
self.iso_level = "IMMEDIATE" # Write時のみLock
self._check_new_creation()
self.db = self.create_connect()
def pk2ck(self, pk):
return get_address(pk, main_net=self.main_net)
def change_mintcoin(mint_id,
cur,
amount=0,
message=None,
additional_issue=None,
image=None,
sender=C.ANT_UNKNOWN):
mint_old = get_mintcoin(mint_id)
assert mint_old, 'Not defined MintCoin {}'.format(mint_id)
mint_new = MintCoinObject(None)
mint_new.version = mint_old.version + 1
mint_new.coin_id = mint_id
mint_new.amount = amount
mint_new.additional_issue = additional_issue
mint_address = get_address(mint_old.owner, prefix=V.BLOCK_PREFIX)
uuid, sk, pk = read_address2keypair(mint_address, cur)
mint_new.owner = pk
mint_new.image = image
mint_new.message = message
# マージチェック
mint_new.marge(mint_old)
# Message内署名
mint_new.generate_sign(sk)
mint_new.serialize()
mint_new.check_param()
mint_new.check_sign()
logging.info("New Mintcoin skeleton created coin_id={}".format(
mint_new.coin_id))
# movement
movements = UserCoins()
minting_coins = CoinObject(mint_id, amount)
movements[sender] += minting_coins
movements[C.ANT_OUTSIDE] -= minting_coins
# TXを作成する
base_coin_id = 0
now = int(time.time()) - V.BLOCK_GENESIS_TIME
tx = TX(
tx={
'version':
__chain_version__,
'type':
C.TX_MINT_COIN,
'time':
now,
'deadline':
now + 10800,
'inputs':
list(),
'outputs': [(MINTCOIN_DUMMY_ADDRESS, base_coin_id,
amount)] if 0 < amount else list(),
'gas_price':
V.COIN_MINIMUM_PRICE,
'gas_amount':
1,
'message_type':
C.MSG_BYTE,
'message':
mint_new.binary
})
tx.gas_amount = tx.getsize() + 96 + C.MINTCOIN_FEE
tx.serialize()
fee_coin_id = 0
input_address = fill_inputs_outputs(tx, cur, fee_coin_id, C.MINTCOIN_FEE)
fee_coins = CoinObject(fee_coin_id, tx.gas_price * tx.gas_amount)
# check amount
check_enough_amount(sender, CoinObject(base_coin_id, amount), fee_coins)
# replace dummy address
replace_redeem_dummy_address(tx, cur)
# replace dummy mint_id
if amount > 0:
replace_mint_dummy_address(tx, mint_address, mint_id)
# setup signature
tx.serialize()
setup_signature(tx, input_address)
movements[sender] -= fee_coins
movements[C.ANT_OUTSIDE] += fee_coins
insert_log(movements, cur, tx.type, tx.time, tx.hash)
return mint_new, tx
def pk2ck(pk, prefix=None):
return key.get_address(pk, prefix)
import time
b32alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'
request = 'NAMU'
main_net = True
prefix = None
for i in list(request):
if i not in b32alphabet:
raise ValueError('\"%s\" is not include base32 strings.' % i)
count = 0
start = time.time()
print("Prefix={}, mainnet={}, Find \"{}\"".format(prefix, main_net, request))
while True:
count += 1
sk = secret_key()
pk = public_key(sk)
ck = get_address(pk, main_net, prefix)
if request in ck:
print("Secret", sk)
print("Public", pk)
print("Compressed", ck)
print("finished")
exit(0)
elif count % 100 == 0:
print("{}processed, {}mS/cycle".format(count, (time.time() - start) *
1000 // count))
else:
continue
#!/user/env python3
# -*- coding: utf-8 -*-
from nem_ed25519.key import secret_key, public_key, get_address, convert_address
result = list()
for i in range(255):
sk = secret_key()
pk = public_key(sk)
ck = get_address(pk, prefix=i.to_bytes(1, 'big'))
result.append("{:10}{}".format(str(i.to_bytes(1, 'big')), ck))
print("\n".join(result))
import time
from nem_ed25519.key import secret_key, public_key, get_address, is_address
start = time.time()
result = list()
COUNT = 10
for i in range(COUNT):
sk = secret_key()
pk = public_key(sk)
ck = get_address(pk)
if not is_address(ck):
raise Exception('not correct key')
result.append((sk, pk, ck))
print((time.time() - start) * 1000 // COUNT, "mS/create_pair")
print("\ntry check")
sk = '78f8932df54d22319a16dc4940c269205ae0946f98d38ef30aea488a47426153'
pk = '77041bfb4b6afebc31aaab7b02d68e577fe069524b3c661c804b42ef381f717b'
ck = 'NBOGOGSENUPBFMAPTGHVI4UIAQPVSNKJLWUVHBED'
assert pk == public_key(sk), 'Not correct sk'
assert ck == get_address(pk), 'Not correct pk'
print("all ok.")
