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 lease(self,
recipient,
amount,
txFee=pywaves.DEFAULT_LEASE_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'\x08' + \
base58.b58decode(self.publicKey) + \
base58.b58decode(recipient.address) + \
struct.pack(">Q", amount) + \
struct.pack(">Q", txFee) + \
struct.pack(">Q", timestamp)
signature = crypto.sign(self.privateKey, sData)
data = json.dumps({
"senderPublicKey": self.publicKey,
"recipient": recipient.address,
"amount": amount,
"fee": txFee,
"timestamp": timestamp,
"signature": signature
})
req = pywaves.wrapper('/leasing/broadcast/lease', data)
if pywaves.OFFLINE:
return req
else:
return req['id']
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 sponsorAsset(self, assetId, minimalFeeInAssets, txFee=pywaves.DEFAULT_SPONSOR_FEE, timestamp=0):
if not self.privateKey:
logging.error('Private key required')
else:
if timestamp == 0:
timestamp = int(time.time() * 1000)
sData = b'\x0e' + \
b'\1' + \
base58.b58decode(self.publicKey) + \
base58.b58decode(assetId) + \
struct.pack(">Q", minimalFeeInAssets) + \
struct.pack(">Q", txFee) + \
struct.pack(">Q", timestamp)
signature = crypto.sign(self.privateKey, sData)
data = json.dumps({
"type": 14,
"version": 1,
"senderPublicKey": self.publicKey,
"assetId": assetId,
"fee": txFee,
"timestamp": timestamp,
"minSponsoredAssetFee": minimalFeeInAssets,
"proofs": [
signature
]
})
return pywaves.wrapper('/transactions/broadcast', 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 leaseCancel(self,
leaseId,
txFee=pywaves.DEFAULT_LEASE_FEE,
timestamp=0):
if not self.privateKey:
logging.error('Private key required')
elif not pywaves.OFFLINE and self.balance() < txFee:
logging.error('Insufficient Waves balance')
else:
if timestamp == 0:
timestamp = int(time.time() * 1000)
sData = b'\x09' + \
base58.b58decode(self.publicKey) + \
struct.pack(">Q", txFee) + \
struct.pack(">Q", timestamp) + \
base58.b58decode(leaseId)
signature = crypto.sign(self.privateKey, sData)
data = json.dumps({
"senderPublicKey": self.publicKey,
"txId": leaseId,
"fee": txFee,
"timestamp": timestamp,
"signature": signature
})
req = pywaves.wrapper('/leasing/broadcast/cancel', data)
if pywaves.OFFLINE:
return req
elif 'leaseId' in req:
return req['leaseId']
def cancelOrder(self, assetPair, order):
if not pywaves.OFFLINE:
if order.status() == 'Filled':
logging.error("Order already filled")
elif not order.status():
logging.error("Order not found")
sData = base58.b58decode(self.publicKey) + \
base58.b58decode(order.orderId)
signature = crypto.sign(self.privateKey, sData)
data = json.dumps({
"sender": self.publicKey,
"orderId": order.orderId,
"signature": signature
})
req = pywaves.wrapper(
'/matcher/orderbook/%s/%s/cancel' %
('WAVES' if assetPair.asset1.assetId == '' else
assetPair.asset1.assetId, 'WAVES'
if assetPair.asset2.assetId == '' else assetPair.asset2.assetId),
data,
host=pywaves.MATCHER)
if pywaves.OFFLINE:
return req
else:
id = -1
if req['status'] == 'OrderCanceled':
id = req['orderId']
logging.info('Order Cancelled - ID: %s' % id)
return id
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 reissueAsset(self,
Asset,
quantity,
reissuable=False,
txFee=pywaves.DEFAULT_TX_FEE):
timestamp = int(time.time() * 1000)
sData = b'\5' + \
base58.b58decode(self.publicKey) + \
base58.b58decode(Asset.assetId) + \
struct.pack(">Q", quantity) + \
(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,
"assetId": Asset.assetId,
"quantity": quantity,
"timestamp": timestamp,
"reissuable": reissuable,
"fee": txFee,
"signature": signature
})
req = pywaves.wrapper('/assets/broadcast/reissue', data)
if pywaves.OFFLINE:
return req
else:
return req.get('id', 'ERROR')
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 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 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 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 _postOrder(self,
amountAsset,
priceAsset,
orderType,
amount,
price,
maxLifetime=30 * 86400,
matcherFee=pywaves.DEFAULT_MATCHER_FEE,
timestamp=0):
if timestamp == 0:
timestamp = int(time.time() * 1000)
expiration = timestamp + maxLifetime * 1000
asset1 = b'\0' if amountAsset.assetId == '' else b'\1' + base58.b58decode(
amountAsset.assetId)
asset2 = b'\0' if priceAsset.assetId == '' else b'\1' + base58.b58decode(
priceAsset.assetId)
sData = base58.b58decode(self.publicKey) + \
base58.b58decode(pywaves.MATCHER_PUBLICKEY) + \
asset1 + \
asset2 + \
orderType + \
struct.pack(">Q", price) + \
struct.pack(">Q", amount) + \
struct.pack(">Q", timestamp) + \
struct.pack(">Q", expiration) + \
struct.pack(">Q", matcherFee)
signature = crypto.sign(self.privateKey, sData)
otype = "buy" if orderType == b'\0' else "sell"
data = json.dumps({
"senderPublicKey": self.publicKey,
"matcherPublicKey": pywaves.MATCHER_PUBLICKEY,
"assetPair": {
"amountAsset": amountAsset.assetId,
"priceAsset": priceAsset.assetId,
},
"orderType": otype,
"price": price,
"amount": amount,
"timestamp": timestamp,
"expiration": expiration,
"matcherFee": matcherFee,
"signature": signature
})
req = pywaves.wrapper('/matcher/orderbook', data, host=pywaves.MATCHER)
id = -1
if 'status' in req:
if req['status'] == 'OrderRejected':
msg = 'Order Rejected - %s' % req['message']
logging.error(msg)
pywaves.throw_error(msg)
elif req['status'] == 'OrderAccepted':
id = req['message']['id']
logging.info('Order Accepted - ID: %s' % id)
elif not pywaves.OFFLINE:
logging.error(req)
pywaves.throw_error(req)
else:
return req
return id
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 getOrderHistory(self, assetPair, timestamp=0):
if timestamp == 0:
timestamp = int(time.time() * 1000)
sData = base58.b58decode(self.publicKey) + \
struct.pack(">Q", timestamp)
signature = crypto.sign(self.privateKey, sData)
data = {
"Accept": "application/json",
"Timestamp": str(timestamp),
"Signature": signature
}
req = pywaves.wrapper('/matcher/orderbook/%s/%s/publicKey/%s' % ('WAVES' if assetPair.asset1.assetId=='' else assetPair.asset1.assetId, 'WAVES' if assetPair.asset2.assetId=='' else assetPair.asset2.assetId, self.publicKey), headers=data, host=pywaves.MATCHER)
return req
def deleteOrderHistory(self, assetPair):
orders = self.getOrderHistory(assetPair)
for order in orders:
orderId = order['id']
sData = base58.b58decode(self.publicKey) + \
base58.b58decode(orderId)
signature = crypto.sign(self.privateKey, sData)
data = json.dumps({
"sender": self.publicKey,
"orderId": orderId,
"signature": signature
})
pywaves.wrapper('/matcher/orderbook/%s/%s/delete' % ('WAVES' if assetPair.asset1.assetId == '' else assetPair.asset1.assetId, 'WAVES' if assetPair.asset2.assetId == '' else assetPair.asset2.assetId), data, host=pywaves.MATCHER)
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 cancelOpenOrders(self, assetPair):
orders = self.getOrderHistory(assetPair)
for order in orders:
status = order['status']
orderId = order['id']
if status=='Accepted' or status=='PartiallyFilled':
sData = base58.b58decode(self.publicKey) + \
base58.b58decode(orderId)
signature = crypto.sign(self.privateKey, sData)
data = json.dumps({
"sender": self.publicKey,
"orderId": orderId,
"signature": signature
})
pywaves.wrapper('/matcher/orderbook/%s/%s/cancel' % ('WAVES' if assetPair.asset1.assetId == '' else assetPair.asset1.assetId, 'WAVES' if assetPair.asset2.assetId == '' else assetPair.asset2.assetId), data, host=pywaves.MATCHER)
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 burnAsset(self, Asset, quantity, txFee=pywaves.DEFAULT_ASSET_FEE):
timestamp = int(time.time() * 1000)
sData = '\6' + \
base58.b58decode(self.publicKey) + \
base58.b58decode(Asset.assetId) + \
struct.pack(">Q", quantity) + \
struct.pack(">Q", txFee) + \
struct.pack(">Q", timestamp)
signature = crypto.sign(self.privateKey, sData)
data = json.dumps({
"senderPublicKey": self.publicKey,
"assetId": Asset.assetId,
"quantity": quantity,
"timestamp": timestamp,
"fee": txFee,
"signature": signature
})
return pywaves.wrapper('/assets/broadcast/burn', 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 cancelOrderByID(self, assetPair, orderId):
sData = base58.b58decode(self.publicKey) + \
base58.b58decode(orderId)
signature = crypto.sign(self.privateKey, sData)
data = json.dumps({
"sender": self.publicKey,
"orderId": orderId,
"signature": signature
})
req = pywaves.wrapper(
'/matcher/orderbook/%s/%s/cancel' %
('WAVES' if assetPair.asset1.assetId == '' else
assetPair.asset1.assetId, 'WAVES'
if assetPair.asset2.assetId == '' else assetPair.asset2.assetId),
data,
host=pywaves.MATCHER)
id = -1
if req['status'] == 'OrderCanceled':
id = req['orderId']
logging.info('Order Cancelled - ID: %s' % id)
return id
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 sponsor_payload(address,
pubkey,
assetId,
minimalFeeInAssets,
fee=pywaves.DEFAULT_SPONSOR_FEE,
timestamp=0):
if not address.privateKey:
msg = 'Private key required'
logging.error(msg)
pywaves.throw_error(msg)
else:
if timestamp == 0:
timestamp = int(time.time() * 1000)
sData = b'\x0e' + \
b'\1' + \
base58.b58decode(pubkey) + \
base58.b58decode(assetId) + \
struct.pack(">Q", minimalFeeInAssets) + \
struct.pack(">Q", fee) + \
struct.pack(">Q", timestamp)
signature = crypto.sign(address.privateKey, sData)
data = json.dumps(
{
"type": 14,
"version": 1,
"senderPublicKey": pubkey,
"assetId": assetId,
"fee": fee,
"timestamp": timestamp,
"minSponsoredAssetFee": minimalFeeInAssets,
"proofs": [signature]
},
indent=4)
return data
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)
