def createAlias(self, alias, txFee=pywaves.DEFAULT_ALIAS_FEE, timestamp=0): aliasWithNetwork = b'\x02' + str(pywaves.CHAIN_ID) + struct.pack( ">H", len(alias)) + crypto.str2bytes(alias) if not self.privateKey: msg = 'Private key required' logging.error(msg) pywaves.throw_error(msg) else: if timestamp == 0: timestamp = int(time.time() * 1000) sData = b'\x0a' + \ base58.b58decode(self.publicKey) + \ struct.pack(">H", len(aliasWithNetwork)) + \ crypto.str2bytes(aliasWithNetwork) + \ struct.pack(">Q", txFee) + \ struct.pack(">Q", timestamp) signature = crypto.sign(self.privateKey, sData) data = json.dumps({ "alias": alias, "senderPublicKey": self.publicKey, "fee": txFee, "timestamp": timestamp, "signature": signature }) return pywaves.wrapper('/alias/broadcast/create', data)
def issue_asset_waves(params, address_from): pub = address_from['publicKey'] pk = address_from['privateKey'] txFee = pw.DEFAULT_ASSET_FEE timestamp = int(time.time() * 1000) sData = b'\3' + \ base58.b58decode(pub) + \ struct.pack(">H", len(params['name'])) + \ crypto.str2bytes(params['name']) + \ struct.pack(">H", len(params['description'])) + \ crypto.str2bytes(params['description']) + \ struct.pack(">Q", int(params['total_supply'])) + \ struct.pack(">B", int(params['decimals'])) + \ b'\0' + \ struct.pack(">Q", int(txFee)) + \ struct.pack(">Q", timestamp) signature = crypto.sign(pk, sData) data = json.dumps({ "senderPublicKey": pub.decode('utf-8'), "name": params['name'], "quantity": int(params['total_supply']), "timestamp": timestamp, "description": params['description'], "decimals": int(params['decimals']), "reissuable": False, "fee": txFee, "signature": signature.decode('utf-8') }) print('issue asset tx', data, flush=True) return pw.wrapper('/assets/broadcast/issue', data)
def sendWaves(self, recipient, amount, attachment='', txFee=pywaves.DEFAULT_TX_FEE, timestamp=0): if not self.privateKey: logging.error('Private key required') elif amount <= 0: logging.error('Amount must be > 0') elif not pywaves.OFFLINE and self.balance() < amount + txFee: logging.error('Insufficient Waves balance') else: if timestamp == 0: timestamp = int(time.time() * 1000) sData = b'\4' + \ base58.b58decode(self.publicKey) + \ b'\0\0' + \ struct.pack(">Q", timestamp) + \ struct.pack(">Q", amount) + \ struct.pack(">Q", txFee) + \ base58.b58decode(recipient.address) + \ struct.pack(">H", len(attachment)) + \ crypto.str2bytes(attachment) signature = crypto.sign(self.privateKey, sData) data = json.dumps({ "senderPublicKey": self.publicKey, "recipient": recipient.address, "amount": amount, "fee": txFee, "timestamp": timestamp, "attachment": base58.b58encode(crypto.str2bytes(attachment)), "signature": signature }) return pywaves.wrapper('/assets/broadcast/transfer', data)
def sendAsset(self, recipient, asset, amount, attachment='', feeAsset='', txFee=pywaves.DEFAULT_TX_FEE, timestamp=0): if not self.privateKey: msg = 'Asset not issued' logging.error(msg) pywaves.throw_error(msg) elif not pywaves.OFFLINE and asset and not asset.status(): msg = 'Asset not issued' logging.error(msg) pywaves.throw_error(msg) elif amount <= 0: msg = 'Amount must be > 0' logging.error(msg) pywaves.throw_error(msg) elif not pywaves.OFFLINE and asset and self.balance(asset.assetId) < amount: msg = 'Insufficient asset balance' logging.error(msg) pywaves.throw_error(msg) elif not pywaves.OFFLINE and not asset and self.balance() < amount: msg = 'Insufficient Waves balance' logging.error(msg) pywaves.throw_error(msg) elif not pywaves.OFFLINE and not feeAsset and self.balance() < txFee: msg = 'Insufficient Waves balance' logging.error(msg) pywaves.throw_error(msg) elif not pywaves.OFFLINE and feeAsset and self.balance(feeAsset.assetId) < txFee: msg = 'Insufficient asset balance' logging.error(msg) pywaves.throw_error(msg) else: if feeAsset: feeInfos = pywaves.wrapper('/assets/details/' + feeAsset.assetId) if feeInfos['minSponsoredAssetFee']: txFee = feeInfos['minSponsoredAssetFee'] if timestamp == 0: timestamp = int(time.time() * 1000) sData = b'\4' + \ base58.b58decode(self.publicKey) + \ (b'\1' + base58.b58decode(asset.assetId) if asset else b'\0') + \ (b'\1' + base58.b58decode(feeAsset.assetId) if feeAsset else b'\0') + \ struct.pack(">Q", timestamp) + \ struct.pack(">Q", amount) + \ struct.pack(">Q", txFee) + \ base58.b58decode(recipient.address) + \ struct.pack(">H", len(attachment)) + \ crypto.str2bytes(attachment) signature = crypto.sign(self.privateKey, sData) data = json.dumps({ "assetId": (asset.assetId if asset else ""), "feeAssetId": (feeAsset.assetId if feeAsset else ""), "senderPublicKey": self.publicKey, "recipient": recipient.address, "amount": amount, "fee": txFee, "timestamp": timestamp, "attachment": base58.b58encode(crypto.str2bytes(attachment)), "signature": signature }) return pywaves.wrapper('/assets/broadcast/transfer', data)
def issueAsset(self, name, description, quantity, decimals=0, reissuable=False, txFee=pywaves.DEFAULT_ASSET_FEE): if not self.privateKey: logging.error('Private key required') elif len(name) < 4 or len(name) > 16: logging.error('Asset name must be between 4 and 16 characters long') else: timestamp = int(time.time() * 1000) sData = b'\3' + \ base58.b58decode(self.publicKey) + \ struct.pack(">H", len(name)) + \ crypto.str2bytes(name) + \ struct.pack(">H", len(description)) + \ crypto.str2bytes(description) + \ struct.pack(">Q", quantity) + \ struct.pack(">B", decimals) + \ (b'\1' if reissuable else b'\0') + \ struct.pack(">Q", txFee) + \ struct.pack(">Q", timestamp) signature=crypto.sign(self.privateKey, sData) data = json.dumps({ "senderPublicKey": self.publicKey, "name": name, "quantity": quantity, "timestamp": timestamp, "description": description, "decimals": decimals, "reissuable": reissuable, "fee": txFee, "signature": signature }) req = pywaves.wrapper('/assets/broadcast/issue', data) if pywaves.OFFLINE: return req else: return pywaves.Asset(req['assetId'])
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 createAssetTransaction(recipient, assetId, amount, publicKey, privateKey, attachment='', txFee=100000): timestamp = int(time.time() * 1000) sData = b'\4' + \ b'\2' + \ base58.b58decode(publicKey) + \ b'\1' + base58.b58decode(assetId) + \ b'\0' + \ struct.pack(">Q", timestamp) + \ struct.pack(">Q", amount) + \ struct.pack(">Q", txFee) + \ base58.b58decode(recipient) + \ struct.pack(">H", len(attachment)) + \ crypto.str2bytes(attachment) signature = crypto.sign(privateKey, sData) data = { "type": 4, "version": 2, "assetId": assetId, "senderPublicKey": publicKey, "recipient": recipient, "amount": amount, "fee": txFee, "timestamp": timestamp, "attachment": base58.b58encode(crypto.str2bytes(attachment)), "proofs": [signature] } return data
def issue_asset_payload(address, pubkey, name, description, quantity, script=None, decimals=2, reissuable=True, fee=pywaves.DEFAULT_ASSET_FEE, timestamp=0): if not address.privateKey: msg = 'Private key required' logging.error(msg) pywaves.throw_error(msg) elif len(name) < 4 or len(name) > 16: msg = 'Asset name must be between 4 and 16 characters long' logging.error(msg) pywaves.throw_error(msg) else: # it looks like script can always be 'None' (might be a bug) if script: rawScript = base64.b64decode(script) scriptLength = len(rawScript) if timestamp == 0: timestamp = waves_timestamp() sData = b'\3' + \ b'\2' + \ crypto.str2bytes(str(pywaves.CHAIN_ID)) + \ base58.b58decode(pubkey) + \ struct.pack(">H", len(name)) + \ crypto.str2bytes(name) + \ struct.pack(">H", len(description)) + \ crypto.str2bytes(description) + \ struct.pack(">Q", quantity) + \ struct.pack(">B", decimals) + \ (b'\1' if reissuable else b'\0') + \ struct.pack(">Q", fee) + \ struct.pack(">Q", timestamp) + \ (b'\1' + struct.pack(">H", scriptLength) + rawScript if script else b'\0') signature = crypto.sign(address.privateKey, sData) data = json.dumps( { "type": 3, "version": 2, "senderPublicKey": pubkey, "name": name, "description": description, "quantity": quantity, "decimals": decimals, "reissuable": reissuable, "fee": fee, "timestamp": timestamp, "proofs": [signature] }, indent=4) return data
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 massTransferAssets(self, transfers, asset, attachment='', timestamp=0): txFee = 100000 + len(transfers) * 50000 totalAmount = 0 for i in range(0, len(transfers)): totalAmount += transfers[i]['amount'] if not self.privateKey: logging.error('Private key required') elif len(transfers) > 100: logging.error('Too many recipients') elif not pywaves.OFFLINE and self.balance() < totalAmount + txFee: logging.error('Insufficient Waves balance') else: if timestamp == 0: timestamp = int(time.time() * 1000) transfersData = b'' for i in range(0, len(transfers)): transfersData += base58.b58decode( transfers[i]['recipient']) + struct.pack( ">Q", transfers[i]['amount']) sData = b'\x0b' + \ b'\1' + \ base58.b58decode(self.publicKey) + \ b'\1' + \ base58.b58decode(asset.assetId) + \ struct.pack(">H", len(transfers)) + \ transfersData + \ struct.pack(">Q", timestamp) + \ struct.pack(">Q", txFee) + \ struct.pack(">H", len(attachment)) + \ crypto.str2bytes(attachment) signature = crypto.sign(self.privateKey, sData) data = json.dumps({ "type": 11, "assetId": asset.assetId, "senderPublicKey": self.publicKey, "fee": txFee, "timestamp": timestamp, "transfers": transfers, "attachment": base58.b58encode(crypto.str2bytes(attachment)), "signature": signature }) return pywaves.wrapper('/transactions/broadcast', data)
def issueSmartAsset(self, name, description, quantity, scriptSource, decimals=0, reissuable=False, txFee=pywaves.DEFAULT_ASSET_FEE): script = pywaves.wrapper('/utils/script/compile', scriptSource)['script'][7:] if not self.privateKey: msg = 'Private key required' logging.error(msg) pywaves.throw_error(msg) elif len(name) < 4 or len(name) > 16: msg = 'Asset name must be between 4 and 16 characters long' logging.error(msg) pywaves.throw_error(msg) else: compiledScript = base64.b64decode(script) scriptLength = len(compiledScript) timestamp = int(time.time() * 1000) sData = b'\3' + \ b'\2' + \ crypto.str2bytes(str(pywaves.CHAIN_ID)) + \ base58.b58decode(self.publicKey) + \ struct.pack(">H", len(name)) + \ crypto.str2bytes(name) + \ struct.pack(">H", len(description)) + \ crypto.str2bytes(description) + \ struct.pack(">Q", quantity) + \ struct.pack(">B", decimals) + \ (b'\1' if reissuable else b'\0') + \ struct.pack(">Q", txFee) + \ struct.pack(">Q", timestamp) + \ b'\1' + \ struct.pack(">H", scriptLength) + \ compiledScript signature = crypto.sign(self.privateKey, sData) data = json.dumps({ "type": 3, "senderPublicKey": self.publicKey, "name": name, "version": 2, "quantity": quantity, "timestamp": timestamp, "description": description, "decimals": decimals, "reissuable": reissuable, "fee": txFee, "proofs": [ signature ], "script": 'base64:' + script }) print(data) req = pywaves.wrapper('/transactions/broadcast', data) if pywaves.OFFLINE: return req else: return req
def setScript(self, scriptSource, txFee=pywaves.DEFAULT_SCRIPT_FEE, timestamp=0): script = pywaves.wrapper('/utils/script/compile', scriptSource)['script'][7:] if not self.privateKey: logging.error('Private key required') else: compiledScript = base64.b64decode(script) scriptLength = len(compiledScript) if timestamp == 0: timestamp = int(time.time() * 1000) sData = b'\x0d' + \ b'\1' + \ crypto.str2bytes(str(pywaves.CHAIN_ID)) + \ base58.b58decode(self.publicKey) + \ b'\1' + \ struct.pack(">H", scriptLength) + \ compiledScript + \ struct.pack(">Q", txFee) + \ struct.pack(">Q", timestamp) signature = crypto.sign(self.privateKey, sData) data = json.dumps({ "type": 13, "version": 1, "senderPublicKey": self.publicKey, "fee": txFee, "timestamp": timestamp, "script": 'base64:' + script, "proofs": [ signature ] }) return pywaves.wrapper('/transactions/broadcast', data)
def set_script_payload(address, pubkey, script, fee=DEFAULT_SCRIPT_FEE, timestamp=0): if script: rawScript = base64.b64decode(script) scriptLength = len(rawScript) if timestamp == 0: timestamp = waves_timestamp() sData = b'\x0d' + \ b'\1' + \ crypto.str2bytes(str(pywaves.CHAIN_ID)) + \ base58.b58decode(pubkey) + \ (b'\1' + struct.pack(">H", scriptLength) + rawScript if script else b'\0') + \ struct.pack(">Q", fee) + \ struct.pack(">Q", timestamp) signature = crypto.sign(address.privateKey, sData) data = json.dumps( { "type": 13, "version": 1, "senderPublicKey": pubkey, "fee": fee, "timestamp": timestamp, "script": ('base64:' + script if script else None), "proofs": [signature] }, indent=4) return data
def reissue_asset_payload(address, pubkey, assetid, quantity, reissuable=False, fee=pywaves.DEFAULT_TX_FEE, timestamp=0): if timestamp == 0: timestamp = waves_timestamp() sData = b'\5' + \ b'\2' + \ crypto.str2bytes(str(pywaves.CHAIN_ID)) + \ base58.b58decode(pubkey) + \ base58.b58decode(assetid) + \ struct.pack(">Q", quantity) + \ (b'\1' if reissuable else b'\0') + \ struct.pack(">Q",fee) + \ struct.pack(">Q", timestamp) signature = crypto.sign(address.privateKey, sData) data = json.dumps( { "type": 5, "version": 2, "senderPublicKey": pubkey, "assetId": assetid, "quantity": quantity, "timestamp": timestamp, "reissuable": reissuable, "fee": fee, "proofs": [signature] }, indent=4) return data
def transfer_asset_payload(address, pubkey, recipient, assetid, amount, attachment='', feeAsset='', fee=pywaves.DEFAULT_TX_FEE, timestamp=0): if amount <= 0: msg = 'Amount must be > 0' logging.error(msg) pywaves.throw_error(msg) else: if timestamp == 0: timestamp = waves_timestamp() sData = b'\4' + \ b'\2' + \ base58.b58decode(pubkey) + \ (b'\1' + base58.b58decode(assetid) if assetid else b'\0') + \ (b'\1' + base58.b58decode(feeAsset) if feeAsset else b'\0') + \ struct.pack(">Q", timestamp) + \ struct.pack(">Q", amount) + \ struct.pack(">Q", fee) + \ base58.b58decode(recipient) + \ struct.pack(">H", len(attachment)) + \ crypto.str2bytes(attachment) signature = crypto.sign(address.privateKey, sData) data = json.dumps( { "type": 4, "version": 2, "senderPublicKey": pubkey, "recipient": recipient, "assetId": (assetid if assetid else ""), "feeAssetId": (feeAsset if feeAsset else ""), "amount": amount, "fee": fee, "timestamp": timestamp, "attachment": base58.b58encode(crypto.str2bytes(attachment)), "proofs": [signature] }, indent=4) return data
def sign_send_waves(address_from, address_to, tx_amount): pub = address_from.publicKey pk = address_from.privateKey attachment = '' txFee = pw.DEFAULT_TX_FEE timestamp = int(time.time() * 1000) sData = b'\4' + \ b'\2' + \ base58.b58decode(pub) + \ b'\0\0' + \ struct.pack(">Q", timestamp) + \ struct.pack(">Q", tx_amount) + \ struct.pack(">Q", txFee) + \ base58.b58decode(address_to) + \ struct.pack(">H", len(attachment)) + \ crypto.str2bytes(attachment) signature = crypto.sign(pk, sData) data = json.dumps({ "type": 4, "version": 2, "senderPublicKey": pub.decode('utf-8'), "recipient": address_to.decode('utf-8'), "amount": tx_amount, "fee": txFee, "timestamp": timestamp, "attachment": base58.b58encode(crypto.str2bytes(attachment)).decode('utf-8'), "signature": signature.decode('utf-8'), "proofs": [signature.decode('utf-8')] }) print('signed tx', data, flush=True) return pw.wrapper('/transactions/broadcast', data)
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 build_transfer_bytes(publicKey, recipient, asset, amount, attachment='', feeAsset='', txFee=100000, timestamp=0, version = b'\2'): if timestamp == 0: timestamp = int(time.time() * 1000) sData = b'\4' + version + b'\4' if version == b'\2': sData += version sData += base58.b58decode(publicKey) + \ (b'\1' + base58.b58decode(asset.assetId) if asset else b'\0') + \ (b'\1' + base58.b58decode(feeAsset.assetId) if feeAsset else b'\0') + \ struct.pack(">Q", timestamp) + \ struct.pack(">Q", amount) + \ struct.pack(">Q", txFee) + \ base58.b58decode(recipient.address) + \ struct.pack(">H", len(attachment)) + \ pwcrypto.str2bytes(attachment) return sData
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 set_script_waves(script_source, address_from): compile_res = pw.wrapper('/utils/script/compile', script_source) print('compiling answer', compile_res, flush=True) script = compile_res['script'][7:] compiled_script = base64.b64decode(script) script_length = len(compiled_script) timestamp = int(time.time() * 1000) #txFee = pw.DEFAULT_SCRIPT_FEE txFee = 1000000 sData = b'\x0d' + \ b'\1' + \ crypto.str2bytes(str(pw.CHAIN_ID)) + \ base58.b58decode(address_from['publicKey']) + \ b'\1' + \ struct.pack(">H", script_length) + \ compiled_script + \ struct.pack(">Q", txFee) + \ struct.pack(">Q", timestamp) signature = crypto.sign(address_from['privateKey'], sData) data = json.dumps({ "type": 13, "version": 1, "senderPublicKey": address_from['publicKey'].decode('utf-8'), "fee": txFee, "timestamp": timestamp, "script": 'base64:' + script, "proofs": [signature.decode('utf-8')] }) return pw.wrapper('/transactions/broadcast', data)
def pubkey_to_address(pubkey): pubkey_bytes = base58.b58decode(pubkey) unhashed_address = chr(1) + str('L') + crypto.hashChain(pubkey_bytes)[0:20] address_hash = crypto.hashChain(crypto.str2bytes(unhashed_address))[0:4] return base58.b58encode(crypto.str2bytes(unhashed_address + address_hash))
def build_transfer_bytes(publicKey, recipient, asset, amount, attachment='', feeAsset='', txFee=100000, timestamp=0, version=b'\2'): if timestamp == 0: timestamp = int(time.time() * 1000) sData = b'\4' if version == b'\2': sData += version start_index = 31 start_len = len(sData) + start_index field = base58.b58decode(publicKey) sData += field end_len = start_len + len(field) print('public key [{} - {}]'.format(start_len, end_len)) start_len = len(sData) + start_index field = (b'\1' + base58.b58decode(asset.assetId) if asset else b'\0') sData += field end_len = start_len + len(field) print('asset [{} - {}]'.format(start_len, end_len)) start_len = len(sData) + start_index field = (b'\1' + base58.b58decode(feeAsset.assetId) if feeAsset else b'\0') sData += field end_len = start_len + len(field) print('fee asset [{} - {}]'.format(start_len, end_len)) start_len = len(sData) + start_index field = struct.pack(">Q", timestamp) sData += field end_len = start_len + len(field) print('timestamp [{} - {}]'.format(start_len, end_len)) start_len = len(sData) + start_index field = struct.pack(">Q", amount) sData += field end_len = start_len + len(field) print('amount [{} - {}]'.format(start_len, end_len)) start_len = len(sData) + start_index field = struct.pack(">Q", txFee) sData += field end_len = start_len + len(field) print('fee [{} - {}]'.format(start_len, end_len)) start_len = len(sData) + start_index field = base58.b58decode(recipient.address) sData += field end_len = start_len + len(field) print('recipient [{} - {}]'.format(start_len, end_len)) start_len = len(sData) + start_index field = struct.pack(">H", len(attachment)) sData += field end_len = start_len + len(field) print('attachment size [{} - {}]'.format(start_len, end_len)) start_len = len(sData) + start_index field = pwcrypto.str2bytes(attachment) sData += field end_len = start_len + len(field) print('attachment [{} - {}]'.format(start_len, end_len)) return sData
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)
#compute Public Key k_pub = curve.generatePublicKey(k_pr) #print('Computed Public Key:\n{}'.format(b58encode(k_pub))) # CHECK:print('Expected result:\nHBqhfdFASRQ5eBBpu2y6c6KKi1az6bMx8v1JxX4iW1Q8') #compute Address ver = bytes([1]) scheme = b'\x54' # \x57 for mainnet, \x54 for testnet k_pub_hash = SecureHash(k_pub)[:20] checksum = SecureHash(ver + scheme + k_pub_hash)[0:4] address = ver + scheme + k_pub_hash + checksum #print('Computed Address:\n{}\n'.format(b58encode(address))) unhashedAddress = chr(1) + str('T') + crypto.hashChain(k_pub)[0:20] addressHash = crypto.hashChain(crypto.str2bytes(unhashedAddress))[0:4] address2 = crypto.str2bytes(unhashedAddress + addressHash) pywaves.setNode(node='http://52.30.47.67:6869', chain='testnet') myAddress = pywaves.Address(seed=seed_str) #print(myAddress.balance()) #myAddress.sendWaves(recipient = pywaves.Address('3NBVqYXrapgJP9atQccdBPAgJPwHDKkh6A8'), amount = 300000000) #list of components in bytes to be assembled in transaction or block etc. comp = {} #constructing Tx comp = { 't_type': b'\x04',
import hashlib import time import pywaves # Config section, plase fill the variables with corresponding values aliceAddress = '' alicePrivateKey = '' alicePublicKey = '' bobsAddress = '' bobsPrivateKey = '' bobsPublicKey = '' secret = '' assetId = '' node = '' hashedSecret = hashlib.sha256(crypto.str2bytes(secret)).digest() base58.b58encode(hashedSecret) base58EncodedHashedSecret = base58.b58encode(crypto.str2bytes(hashedSecret)) # Method that sets the Atomic Swap smart contract for an account. IMPORTANT: remove the first case in production mode def setSmartContract(privateKeyForScriptAccount, firstPublicKey, secondPublicKey, lockheight): smartContract = "match tx {\n" + \ "case t : SetScriptTransaction => true\n" + \ "case _ => \n" + \ "let pubKeyUser1 = base58'" + firstPublicKey + "'\n" + \ "let pubKeyUser2 = base58'" + secondPublicKey + "'\n" + \ "let lockHeight = " + str(lockheight) + "\n" + \ "let hashedSecret = tx.proofs[1]\n" + \ "let preimage = tx.proofs[2]\n" + \