def optionCheck(option):
if option == '1':
print(
"Here's is your account information (WRITE THESE INFORMATION DOWN!!!): \n"
)
print(generateWallet())
if option == '2':
seed = input("Please enter your seed (space between words): ")
recipient = input("\n Enter the recepient address: ")
amount = int(input("\n Enther the amount: "))
attachment = input("\n Enter the attachment: ")
pw.Address(seed=seed).sendWaves(recipient,
amount,
attachment=attachment,
timestamp=0)
if option == '3':
seed = input("Please enter your seed (space between words): ")
recipient = input("\n Enter the recepient address: ")
asset = pw.Asset(input("\n Enter the asset ID: "))
amount = int(input("\n Enther the amount: "))
attachment = input("\n Enter the attachment: ")
pw.Address(seed=seed).sendAsset(recipient,
asset,
amount,
attachment=attachment,
timestamp=0)
if option == '4':
seed = input("\nPlease enter your seed (space between words): ")
print("\nSend waves or other tokens to the address below: \n")
print(pw.Address(seed=seed).address)
if option == '5':
sys.exit(0)
def sweep_run(args):
pw.setOnline()
# check recipient is a valid address
if not pw.validateAddress(args.recipient):
print(f"ERROR: {args.recipient} is not a valid address")
sys.exit(EXIT_INVALID_RECIPIENT)
recipient = pw.Address(args.recipient)
# sweep expired foils
asset = pw.Asset(args.assetid)
asset_fee = get_asset_fee(args.assetid)
date = time.time()
foils = Foil.get_batches_between(db_session, args.batch_start, args.batch_end)
for foil in foils:
if args.ignore_expiry or foil.expiry and date >= foil.expiry:
addr = pw.Address(seed=foil.seed)
balance = addr.balance(assetId=args.assetid)
if balance == 0:
print(f"Skipping {foil.batch} {addr.address}, balance is 0")
continue
result = addr.sendAsset(recipient, asset, balance - asset_fee, \
feeAsset=asset, txFee=asset_fee)
print(result)
print(f"Swept {foil.batch} {addr.address}, txid {result['id']}")
else:
print(f"Skipping {foil.batch} {addr.address}, not yet expired")
def VerifyWallet(self,WavesAddress):
# con = lite.connect('test.db')
# with con:
# cur = con.cursor()
# # cur.execute("CREATE TABLE IF NOT EXISTS addresses(WavesAddress TEXT , serializedWallet TEXT , BTCaddress TEXT)")
# cur.execute("""SELECT WavesAddress , serializedWallet , BTCaddress
# FROM addresses WHERE WavesAddress=:adr""", {"adr": WavesAddress})
# con.commit()
con = lite.connect('test.db')
with con:
cur = con.cursor()
cur.execute("""SELECT id FROM addressid WHERE WavesAddress=:adr""", {"adr": WavesAddress})
con.commit()
row = cur.fetchone()
if row :
print('row[0] : ',row[0])
_wallet = get_wallet_addresses(wallet_name='Noay'+ str(row[0]), api_key=self.APIKEY , coin_symbol=self.coin_symbol)
print('_wallet',_wallet)
txrefs = []
details = get_address_details(_wallet['addresses'][0], coin_symbol=self.coin_symbol)
print(details)
txrefs = details['txrefs']
print(len(txrefs))
if len(txrefs) == 0 :
return {"result" : "not exist any transaction"}
else :
tx_hash = txrefs[0]['tx_hash'] #TODO should be check transaction time
transaction_details = get_transaction_details(tx_hash , coin_symbol=self.coin_symbol)
print('transaction_details' , transaction_details)
receive_count = transaction_details['outputs'][-1]['value'] * (10** ((-1) * 8))
# print(tx_hash)
pywaves.setNode(node = self.TESTNET_NODE , chain = self.CHAIN)
print("getNode(): ",pywaves.getNode())
recipient = pywaves.Address(address=WavesAddress)
BTC = pywaves.Asset('DWgwcZTMhSvnyYCoWLRUXXSH1RSkzThXLJhww9gwkqdn') #todo i dnk?
WAVES = pywaves.Address(address=self.WAVES_address , privateKey=self.WAVES_privateKey)
res = WAVES.sendAsset(recipient,BTC,receive_count) #todo what response
#todo dont read serialized? ://
con = lite.connect('test.db')
with con:
cur = con.cursor()
# cur.execute("CREATE TABLE IF NOT EXISTS btcRemind(BTCaddress TEXT , Inventory REAL ")
# cur.execute("""INSERT INTO btcRemind VALUES(?,?)""", (BTCWallet['addresses'][0], receive_count))
cur.execute(""" UPDATE addresses SET Inventory = ? WHERE WavesAddress = ? """, ( receive_count , WavesAddress ))
con.commit()
return res
return None
def send_001_waves(handler):
key = urllib.unquote(handler.path[14:])
#key = "'" + key + "'"
Account1 = pw.Address(
seed=
'Seed of your token wallet that will be funded with tokens for the bridge'
)
Account1.sendWaves(recipient=pw.Address(key), amount=100000)
return key
def getBalance(address):
if (len(address) == 35): # Address
address = pw.Address(address)
balance = address.balance(assetId='', confirmations=0)
return balance
elif (len(address) == 44): # Private Key
address = pw.Address(privateKey=address)
balance = address.balance(assetId='', confirmations=0)
return balance
def create_wallet(self, seed=""):
"""
Initializes the pywaves wallet for the User object.
If seed is provided, the wallet is initialized from the seed,
otherwise a wallet is generated from a new seed.
"""
if (len(seed)):
self.wallet = pywaves.Address(seed=seed)
else:
self.wallet = pywaves.Address()
def send_doge_back(handler):
key = urllib.unquote(handler.path[13:])
Account1 = pw.Address(privateKey=key)
amounttosend = Account1.balance(
'DvpmDF45bmo9xDb6rSte8uPPWWeh6EGzoATwxMStWQKT')
myToken = pw.Asset('DvpmDF45bmo9xDb6rSte8uPPWWeh6EGzoATwxMStWQKT')
Account1.sendAsset(
recipient=pw.Address('WavesWalletAddressUsedForExchange'),
asset=myToken,
amount=amounttosend)
return amounttosend
def darf_waves(self):
import pywaves as pw
from models import darf_addr
myAddress = pw.Address(privateKey='CtMQWJZqfc7PRzSWiMKaGmWFm4q2VN5fMcYyKDBPDx6S')
otherAddress = pw.Address('3PNTcNiUzppQXDL9RZrK3BcftbujiFqrAfM')
myAddress.sendWaves(otherAddress, 10000000)
myToken = myAddress.issueAsset('Token1', 'My Token', 1000, 0)
while not myToken.status():
pass
myAddress.sendAsset(otherAddress, myToken, 50)
def initialiseWallets():
wallets.append(
py.Address(
seed=
'marble cram defense virus deal hurry bread theme anchor plate brief chicken head more apple'
))
wallets.append(
py.Address(
seed=
'defy high smart genre abstract biology fantasy seat bread umbrella frost suffer manual sort three'
))
wallets.append(
py.Address(
seed=
'spray wall equip trophy awful clean write jealous tribe flash timber drum depend alone coral'
))
wallets.append(
py.Address(
seed=
'protect public thing guard describe fan once summer dignity media boil day notice harbor stay'
))
wallets.append(
py.Address(
seed=
'main cart invest soldier enact pill eight fame shallow say level scrap drift charge direct'
))
wallets.append(
py.Address(
seed=
'bundle employ mesh region vibrant broccoli armed rubber sing danger snake casual ability page twist'
))
wallets.append(
py.Address(
seed=
'only decade fine upset skull thought weasel cause miss cheese side build blur manage proof'
))
wallets.append(
py.Address(
seed=
'plunge draw hedgehog chief jeans narrow flight abuse isolate amazing mirror advance bone crucial educate'
))
wallets.append(
py.Address(
seed=
'bean tool all make clap disagree food buyer forward toy find miracle sick sauce slide'
))
wallets.append(
py.Address(
seed=
'fresh return verb source radio response broom space appear way energy owner polar electric lock'
))
def deploy(seed1):
print(seed1)
pw.setNode(NODE, CHAIN)
a1 = pw.Address(seed=seed1)
balance = a1.balance()
print(balance)
if balance < 4 * 10**6:
raise ("Top up the account balance using Waves Faucet")
accs = [create_account() for n in range(3)]
sponsor_amount = 10**6
print(accs)
for a in accs:
a1.sendWaves(pw.Address(a["address"]),
sponsor_amount,
attachment="setting DAO",
txFee=500000)
scripts = read_scripts(a1.address)
a1.setScript(scripts["mem"], txFee=1400000)
print("script #1 set")
pw.Address(seed=accs[0]["seed"]).setScript(scripts["dis"], txFee=1000000)
print("script #1 set")
pw.Address(seed=accs[1]["seed"]).setScript(scripts["web"], txFee=1000000)
print("script #2 set")
pw.Address(seed=accs[2]["seed"]).setScript(scripts["int"], txFee=1000000)
print("script #3 set")
out = "membership;{};{}".format(a1.address, a1.seed) + \
"\ndisruptive grants;{};{}".format(accs[0]["address"], accs[0]["seed"]) + \
"\nweb 3.0 grants;{};{}".format(accs[1]["address"], accs[1]["seed"]) + \
"\ninterhack grants;{};{}".format(
accs[2]["address"], accs[2]["seed"])
with open("credentials.csv", "w", encoding="utf-8") as f:
f.write(out)
print(out)
def start_leasing():
data = json.loads(request.data.decode())
amount = float(data['amount']) * (10**8)
recipient = data['addr']
alias = json.loads(active_alias(recipient))
if 'address' not in alias:
send = current_user.wallet.lease(py.Address(address=recipient),
int(amount),
txFee=FEE)
else:
send = current_user.wallet.lease(py.Address(address=alias['address']),
int(amount),
txFee=FEE)
return jsonify(send)
def confirm(update, context):
user = update.message.from_user
id = user.id
mydb = connectMeToDB()
mycursor = mydb.cursor()
mycursor.execute("SELECT * FROM payments where user="******""
if len(myresult) == 0:
message = "\U00002714 All payments was complete!"
update.message.reply_text(message)
return
data = myresult[0];
address = data[2]
amount = data[3]
mycursor.execute("SELECT * FROM wallets where user="******"\U000023F3 Trying send WAVES..."
update.message.reply_text(message)
try:
result = myAddress.sendWaves(recipient = pw.Address(address), amount = int(amount))
message = "\U00002714 Success!\nTX=" + result['id'] + "\ncompleted!"
update.message.reply_text(message)
success = 1
except Exception as e:
update.message.reply_text(str(e))
#remove all past payments
if success == 1:
sql = "DELETE FROM payments WHERE user = " + str(id)
mycursor.execute(sql)
mydb.commit()
mycursor.close()
mydb.close()
def send_doge_user(handler):
key = urllib.unquote(handler.path[13:])
Account1 = pw.Address(
seed=
'Seed of your token wallet that will be funded with tokens for the bridge'
)
dogeToken = pw.Asset('DvpmDF45bmo9xDb6rSte8uPPWWeh6EGzoATwxMStWQKT')
jsondata = accounts[key]
recipientaddress = jsondata['address']
intamounttosend = round(float(jsondata['amount']), 0)
amounttosendtouser = int(intamounttosend)
Account1.sendAsset(recipient=pw.Address(recipientaddress),
asset=dogeToken,
amount=amounttosendtouser)
return amounttosendtouser
def get_account_balance_doge(handler):
key = urllib.unquote(handler.path[19:])
account_to_get_balance = accounts[key] if key in accounts else None
#data = json.loads(str(account_to_get_balance))
balance = pw.Address(account_to_get_balance["address"]).balance(
'DvpmDF45bmo9xDb6rSte8uPPWWeh6EGzoATwxMStWQKT')
return balance
def _create_transaction(recipient, amount, attachment):
# get fee
path = f"assets/details/{cfg.asset_id}"
response = requests.get(cfg.node_http_base_url + path)
if response.ok:
asset_fee = response.json()["minSponsoredAssetFee"]
else:
short_msg = "failed to get asset info"
logger.error(f"{short_msg}: ({response.status_code}, {response.request.method} {response.url}):\n\t{response.text}")
err = OtherError(short_msg, ERR_FAILED_TO_GET_ASSET_INFO)
err.data = response.text
raise err
if not recipient:
short_msg = "recipient is null or an empty string"
logger.error(short_msg)
err = OtherError(short_msg, ERR_EMPTY_ADDRESS)
raise err
if not utils.is_address(recipient):
short_msg = "recipient is not a valid address"
logger.error(short_msg)
err = OtherError(short_msg, ERR_EMPTY_ADDRESS)
raise err
recipient = pywaves.Address(recipient)
asset = pywaves.Asset(cfg.asset_id)
address_data = pw_address.sendAsset(recipient, asset, amount, attachment, feeAsset=asset, txFee=asset_fee)
signed_tx = json.loads(address_data["api-data"])
# calc txid properly
txid = transfer_asset_txid(signed_tx)
# store tx in db
dbtx = CreatedTransaction(txid, CTX_CREATED, signed_tx["amount"], address_data["api-data"])
return dbtx
def get_waves_balance(handler):
Account1 = pw.Address(
seed=
'Seed of your token wallet that will be funded with tokens for the bridge'
)
balance = Account1.balance(confirmations=20)
return balance
def get_dogetoken_balance(handler):
Account1 = pw.Address(
seed=
'Seed of your token wallet that will be funded with tokens for the bridge'
)
balance = Account1.balance('DvpmDF45bmo9xDb6rSte8uPPWWeh6EGzoATwxMStWQKT')
return balance
def takeColat():
debts = repo.getAllDebt()
for debt in debts:
collateral_amount = takeOne(
waves_api.getDappData('borrow_' + debt['debtId'] +
'_collateralAmount')) / 10**8
borrow_amount = takeOne(
waves_api.getDappData('borrow_' + debt['debtId'] +
'_borrowAmount')) / 10**6
borrow_start_time = takeOne(
waves_api.getDappData('borrow_' + debt['debtId'] +
'_startTime')) / 10**3
usdn_to_waves_price = takeOne(
waves_api.getAddressData(getenv('NUTRINO_CONTROL_DAPP_ADDRESS'),
{'key': 'price'})) / 10**6
collateral_worth = usdn_to_waves_price * collateral_amount
interest = borrow_amount * \
(BASE_INTEREST + (TIME_FACTOR *
(time.time() - borrow_start_time) // 600) + SELLING_THRESHOLD)
if borrow_amount + interest >= collateral_worth:
account = pw.Address(privateKey=getenv('ADMIN_PRIVATE_KEY'))
tx = account.invokeScript(getenv('DAPP_ADDRESS'), 'takeCollateral',
[{
'type': 'string',
'value': debt['debtId']
}], [])
if 'error' in tx:
print(tx)
else:
repo.deleteOneDebt(debt['debtId'])
def VerifyWallet(self, WavesAddress):
con = lite.connect('test.db')
with con:
cur = con.cursor()
# cur.execute("CREATE TABLE IF NOT EXISTS addresses(WavesAddress TEXT , serializedWallet TEXT , BTCaddress TEXT)")
cur.execute(
"""SELECT WavesAddress , serializedWallet , BTCaddress
FROM addresses WHERE WavesAddress=:adr""", {"adr": WavesAddress})
con.commit()
row = cur.fetchone()
if row:
_wallet = get_wallet_addresses(wallet_name=WavesAddress,
api_key=self.APIKEY)
details = get_address_details(_wallet['addresses'][0])
# print(details)
txrefs = details['txrefs']
# print(len(txrefs))
if len(txrefs) == 0:
return {"result": "not exist any transaction"}
else:
tx_hash = txrefs[0][
'tx_hash'] #TODO should be check transaction time
transaction_details = get_transaction_details(tx_hash)
receive_count = transaction_details['receive_count']
# print(tx_hash)
recipient = pywaves.Address(address=WavesAddress)
BTC = pywaves.Asset(
'8LQW8f7P5d5PZM7GtZEBgaqRPGSzS3DfPuiXrURJ4AJS')
res = self.WAVES.sendAsset(recipient, BTC, receive_count)
return res
return None
def fill_missing_fund_data_run(args):
two_months = 60 * 60 * 24 * 30 * 2
foils = Foil.get_batches_between(db_session, args.batch_start, args.batch_end)
for foil in foils:
if not foil.funding_txid:
addr = pw.Address(seed=foil.seed)
print(f":: b{foil.batch}, addr: {addr.address} - no funding tx ::")
api = f"/transactions/address/{addr.address}/limit/100"
txs = pw.wrapper(api)[0]
if len(txs) >= 100:
print("ERROR: too many txs")
sys.exit(EXIT_TOO_MANY_TXS)
tx = txs[len(txs)-1]
if tx["type"] != 4:
print("ERROR: tx not 'transfer asset' type")
sys.exit(EXIT_NOT_TRANSFER_ASSET)
if not tx["assetId"] in (MAINNET_ASSETID, TESTNET_ASSETID):
print("ERROR: unrecognised asset id")
sys.exit(EXIT_UNRECOGNISED_ASSET_ID)
if tx["recipient"] != addr.address:
print("ERROR: wrong recipeint")
sys.exit(EXIT_WRONG_RECIPIENT)
funding_txid = tx["id"]
funding_date = int(tx["timestamp"] / 1000)
expiry = funding_date + two_months
amount = tx["amount"]
print(f" found funding: {amount} ZAP CENTS")
print(f" setting expiry: {expiry}, funding_txid: {funding_txid}")
foil.expiry = expiry
foil.funding_date = funding_date
foil.funding_txid = funding_txid
foil.amount = amount
db_session.commit()
def generate(self):
pw.setOffline()
addr = pw.Address()
address = addr.address.decode("utf-8")
private_key = addr.privateKey.decode("utf-8")
seed = addr.seed
return CryptoCoin(address, private_key, seed)
def send_reward(self, address, amount):
if amount > self.remaining_waves:
raise Exception('Insufficient funds')
recipient = pw.Address(address)
self.remaining_waves -= amount
logger.info(f'{self.remaining_waves} WAVES left')
self.address.sendWaves(recipient, int(amount * 10**8))
def balance(update, context):
user = update.message.from_user
id = user.id
mydb = connectMeToDB()
mycursor = mydb.cursor()
mycursor.execute("SELECT * FROM wallets where user="******""
if len(myresult) == 0:
message = "\U0001F6D1 Use command /wallet to create new address"
else:
data = myresult[0];
privateKey = data[3]
myAddress = pw.Address(privateKey=privateKey)
message = "\U0001F4B0 Balance is " + str(myAddress.balance()/(100000000)) + " WAVES"
update.message.reply_text(message)
mycursor.close()
mydb.close()
def __init__(self):
# main
self.node = config.NODE
self.chain = config.NETWORK
self.matcher = config.MATCHER
self.order_fee = config.ORDER_FEE
self.order_lifetime = config.ORDER_LIFETIME
# account
self.private_key = config.PRIVATE_KEY
self.wallet = pw.Address(privateKey=self.private_key)
# assets
self.amount_asset_id = config.AMOUNT_ASSET
self.price_asset_id = config.PRICE_ASSET
self.asset_pair = pw.AssetPair(pw.Asset(self.amount_asset_id),
pw.Asset(self.price_asset_id))
# grid
self.base_price = 0
self.interval = 0.01
self.grid_levels = 20
self.base_level = 10
self.last_level = 10
self.grid = ["-"] * self.grid_levels
self.tranche_size = 150000000 # 1.5 WAVES
def _create_transaction_waves(recipient, amount, attachment):
# get fee
path = f"/assets/details/{ASSET_ID}"
response = requests.get(NODE_BASE_URL + path)
if response.ok:
asset_fee = response.json()["minSponsoredAssetFee"]
else:
short_msg = "failed to get asset info"
logger.error("%s: (%d, %s, %s):\n\t%s", short_msg, response.status_code, response.request.method, response.url, response.text)
err = OtherError(short_msg, tx_utils.ERR_FAILED_TO_GET_ASSET_INFO)
err.data = response.text
raise err
if not recipient:
short_msg = "recipient is null or an empty string"
logger.error(short_msg)
err = OtherError(short_msg, tx_utils.ERR_EMPTY_ADDRESS)
raise err
if not utils.is_address(recipient):
short_msg = "recipient is not a valid address"
logger.error(short_msg)
err = OtherError(short_msg, tx_utils.ERR_EMPTY_ADDRESS)
raise err
recipient = pywaves.Address(recipient)
asset = pywaves.Asset(ASSET_ID)
address_data = PW_ADDRESS.sendAsset(recipient, asset, amount, attachment, feeAsset=asset, txFee=asset_fee)
signed_tx = json.loads(address_data["api-data"])
signed_tx["type"] = 4 # sendAsset does not include "type" - https://github.com/PyWaves/PyWaves/issues/131
# calc txid properly
txid = tx_utils.tx_to_txid(signed_tx)
# store tx in db
dbtx = WavesTx(txid, "transfer", tx_utils.CTX_CREATED, signed_tx["amount"], True, json.dumps(signed_tx))
return dbtx
def invoke_remote_script(funcName, args, price, privateKey):
address = pw.Address(privateKey=privateKey)
tx = address.invokeScript(DAPPADDRESS, funcName, args, [{
"amount": price,
"assetId": None
}])
print(tx)
return tx
def get_waves_balance_address(handler):
address = urllib.unquote(handler.path[24:])
try:
Account = pw.Address(address)
balance = Account.balance(confirmations=20)
return balance
except:
return "error"
def get_newaccount(handler):
newaccount = pw.Address()
newaccountaddress = newaccount.address
newaccountprivatekey = newaccount.privateKey
accountdata = {}
accountdata['address'] = newaccountaddress
accountdata['privatekey'] = newaccountprivatekey
return accountdata
def payForSocket(senderKey, value):
senderAddress = pw.Address(privateKey=senderKey)
#print(senderKey)
#print(value)
#print(socketAddress)
#print(senderAddress)
senderAddress.sendWaves(socketAddress, value)
return True
def __init__(self, Node_, Seed_):
self.Node = Node_
logging.info("Using node %s", Node_)
self.Seed = Seed_
logging.info("The given seed: %s", Seed_)
pywaves.setNode(node=self.Node, chain='testnet')
self.Account = pywaves.Address(seed=self.Seed)
