def _generate(self, privateKey='', seed=''):
self.seed = seed
if not privateKey and not seed:
wordCount = 2048
words = []
for i in range(5):
r = crypto.bytes2str(os.urandom(4))
x = (ord(r[3])) + (ord(r[2]) << 8) + (ord(r[1]) << 16) + (
ord(r[0]) << 24)
w1 = x % wordCount
w2 = ((int(x / wordCount) >> 0) + w1) % wordCount
w3 = ((int((int(x / wordCount) >> 0) / wordCount) >> 0) +
w2) % wordCount
words.append(wordList[w1])
words.append(wordList[w2])
words.append(wordList[w3])
self.seed = ' '.join(words)
seedHash = crypto.hashChain(('\0\0\0\0' + self.seed).encode('utf-8'))
accountSeedHash = crypto.sha256(seedHash)
if not privateKey:
privKey = curve.generatePrivateKey(accountSeedHash)
else:
privKey = base58.b58decode(privateKey)
pubKey = curve.generatePublicKey(privKey)
unhashedAddress = chr(1) + str(
pywaves.CHAIN_ID) + crypto.hashChain(pubKey)[0:20]
addressHash = crypto.hashChain(crypto.str2bytes(unhashedAddress))[0:4]
self.address = base58.b58encode(
crypto.str2bytes(unhashedAddress + addressHash))
self.publicKey = base58.b58encode(pubKey)
self.privateKey = base58.b58encode(privKey)
def dataTransaction(self, data, timestamp=0):
if not self.privateKey:
logging.error('Private key required')
else:
if timestamp == 0:
timestamp = int(time.time() * 1000)
dataObject = {
"type": 12,
"version": 1,
"senderPublicKey": self.publicKey,
"data": data,
"fee": 0,
"timestamp": timestamp,
"proofs": ['']
}
dataBinary = b''
for i in range(0, len(data)):
d = data[i]
keyBytes = crypto.str2bytes(d['key'])
dataBinary += struct.pack(">H", len(keyBytes))
dataBinary += keyBytes
if d['type'] == 'binary':
dataBinary += b'\2'
valueAsBytes = d['value']
dataBinary += struct.pack(">H", len(valueAsBytes))
dataBinary += crypto.str2bytes(valueAsBytes)
elif d['type'] == 'boolean':
if d['value']:
dataBinary += b'\1\1'
else:
dataBinary += b'\1\0'
elif d['type'] == 'integer':
dataBinary += b'\0'
dataBinary += struct.pack(">Q", d['value'])
elif d['type'] == 'string':
dataBinary += b'\3'
dataBinary += struct.pack(">H", len(d['value']))
dataBinary += crypto.str2bytes(d['value'])
# check: https://stackoverflow.com/questions/2356501/how-do-you-round-up-a-number-in-python
txFee = (int(( (len(crypto.str2bytes(json.dumps(data))) + 2 + 64 )) / 1000.0) + 1 ) * 100000
dataObject['fee'] = txFee
sData = b'\x0c' + \
b'\1' + \
base58.b58decode(self.publicKey) + \
struct.pack(">H", len(data)) + \
dataBinary + \
struct.pack(">Q", timestamp) + \
struct.pack(">Q", txFee)
dataObject['proofs'] = [ crypto.sign(self.privateKey, sData) ]
for entry in dataObject['data']:
if entry['type'] == 'binary':
base64Encoded = base64.b64encode(crypto.str2bytes(entry['value']))
entry['value'] = 'base64:' + crypto.bytes2str(base64Encoded)
dataObjectJSON = json.dumps(dataObject)
return pywaves.wrapper('/transactions/broadcast', dataObjectJSON)
def burnAsset(self, Asset, quantity, txFee=pywaves.DEFAULT_TX_FEE):
timestamp = int(time.time() * 1000)
sData = '\6' + \
crypto.bytes2str(base58.b58decode(self.publicKey)) + \
crypto.bytes2str(base58.b58decode(Asset.assetId)) + \
crypto.bytes2str(struct.pack(">Q", quantity)) + \
crypto.bytes2str(struct.pack(">Q", txFee)) + \
crypto.bytes2str(struct.pack(">Q", timestamp))
signature = crypto.sign(self.privateKey, crypto.str2bytes(sData))
data = json.dumps({
"senderPublicKey": self.publicKey,
"assetId": Asset.assetId,
"quantity": quantity,
"timestamp": timestamp,
"fee": txFee,
"signature": signature
})
req = pywaves.wrapper('/assets/broadcast/burn', data)
if pywaves.OFFLINE:
return req
else:
return req.get('id', 'ERROR')
def create_waves_privkey(publicKey='', privateKey='', seed='', nonce=0):
if not publicKey and not privateKey and not seed:
wordCount = 2048
words = []
for i in range(5):
r = crypto.bytes2str(os.urandom(4))
x = (ord(r[3])) + (ord(r[2]) << 8) + (ord(r[1]) << 16) + (
ord(r[0]) << 24)
w1 = x % wordCount
w2 = ((int(x / wordCount) >> 0) + w1) % wordCount
w3 = ((int(
(int(x / wordCount) >> 0) / wordCount) >> 0) + w2) % wordCount
words.append(pw.address.wordList[w1])
words.append(pw.address.wordList[w2])
words.append(pw.address.wordList[w3])
seed = ' '.join(words)
if publicKey:
pubKey = base58.b58decode(publicKey)
privKey = ""
else:
seedHash = crypto.hashChain(
struct.pack(">L", nonce) + crypto.str2bytes(seed))
accountSeedHash = crypto.sha256(seedHash)
if not privateKey:
privKey = curve.generatePrivateKey(accountSeedHash)
else:
privKey = base58.b58decode(privateKey)
pubKey = curve.generatePublicKey(privKey)
unhashedAddress = chr(1) + str(
pw.CHAIN_ID) + crypto.hashChain(pubKey)[0:20]
addressHash = crypto.hashChain(crypto.str2bytes(unhashedAddress))[0:4]
address = base58.b58encode(crypto.str2bytes(unhashedAddress + addressHash))
publicKey = base58.b58encode(pubKey)
if privKey != "":
privateKey = base58.b58encode(privKey)
return publicKey, privateKey, address
def index():
form = indexForm()
if form.validate_on_submit():
try:
direction = form.direction.data
node = nodeH if direction == "fromHtoU" else nodeU
chain_id = 'H' if direction == "fromHtoU" else "U"
tokenPortAddress = tokenPortAddressH if direction == "fromHtoU" else tokenPortAddressU
pw.setNode(node, "", chain_id)
myAddress = pw.Address(seed=form.seed.data)
recepientInOtherChain = pw.Address(form.recepient.data)
recepient = pw.Address(tokenPortAddress)
amount = int(form.amount.data)
atch = crypto.bytes2str(
base58.b58decode(recepientInOtherChain.address))
print(atch)
tx = myAddress.sendWaves(recepient, amount, attachment=atch)
flash('txId= {}'.format(tx))
#return redirect('/index')
except:
tb = traceback.format_exc()
flash(tb)
return render_template('index.html', title='Bridge', form=form)
def smartify(enc_age):
# pw.setChain('testnet')
pw.setNode('https://testnode1.wavesnodes.com', 'testnet')
alice = pw.Address(privateKey=g.account_priv_key)
kyc = pw.Address(privateKey=g.kyc_provider_priv_key)
kyc_public_key = alice.publicKey
kyc_private_key = alice.privateKey
try:
data = [{'type': 'string', 'key': 'encAge', 'value': enc_age}]
timestamp = int(time.time() * 1000)
data_object = {
"type": 12,
"version": 1,
"senderPublicKey": alice.publicKey,
"data": data,
"fee": 500000,
"timestamp": timestamp,
"proofs": ['']
}
data_binary = b''
for i in range(0, len(data)):
d = data[i]
key_bytes = crypto.str2bytes(d['key'])
data_binary += struct.pack(">H", len(key_bytes))
data_binary += key_bytes
if d['type'] == 'binary':
data_binary += b'\2'
value_as_bytes = d['value']
data_binary += struct.pack(">H", len(value_as_bytes))
data_binary += crypto.str2bytes(value_as_bytes)
elif d['type'] == 'boolean':
if d['value']:
data_binary += b'\1\1'
else:
data_binary += b'\1\0'
elif d['type'] == 'integer':
data_binary += b'\0'
data_binary += struct.pack(">Q", d['value'])
elif d['type'] == 'string':
data_binary += b'\3'
data_binary += struct.pack(">H", len(d['value']))
data_binary += crypto.str2bytes(d['value'])
tx_fee = (int(
(len(crypto.str2bytes(json.dumps(data))) + 2 + 64) / 1000.0) +
1) * 500000
data_object['fee'] = tx_fee
s_data = b'\x0c' + \
b'\1' + \
base58.b58decode(kyc_public_key) + \
struct.pack(">H", len(data)) + \
data_binary + \
struct.pack(">Q", timestamp) + \
struct.pack(">Q", tx_fee)
data_object['proofs'] = [crypto.sign(kyc_private_key, s_data)]
for entry in data_object['data']:
if entry['type'] == 'binary':
base_64_encoded = base64.b64encode(
crypto.str2bytes(entry['value']))
entry['value'] = 'base64:' + crypto.bytes2str(base_64_encoded)
data_object_json = json.dumps(data_object)
return pw.wrapper('/transactions/broadcast', data_object_json)
except Exception, error:
print 'ERROR: ', error
return bad_request(error)
def SecureHash(seed):
#set BLAKE hashing parameters and hash
h = blake2b(digest_size=32)
h.update(seed)
seed = h.digest()
#Keccak256 from PyWaves (crypto)
h = crypto.KeccakHash()
seed = h.digest(seed).encode('latin-1')
return seed
seed = b'prosper primary borrow coil tissue yard mix train velvet regret avoid inherit argue stumble cruel'
seed_str = crypto.bytes2str(seed)
seed = b'\x00\x00\x00\x00' + seed
seed_hashed = SecureHash(seed)
#sha256
h = hashlib.sha256()
h.update(seed_hashed)
seed = h.digest()
#compute Keys
k_pr = curve.generatePrivateKey(seed)
k_pub = curve.generatePublicKey(k_pr)
#compute Address
ver = bytes([1])
scheme = b'\x54' # \x57 for mainnet, \x54 for testnet
