def dex_withdraw():
# undeveloped definition for withdrawals
from bitshares import BitShares
bitshares = BitShares()
bitshares.wallet.unlock("wallet-passphrase")
bitshares.transfer(to=send_to,
amount=send_amount,
asset=BTS,
memo=None,
account=account)
def play_game(account, amountBet, userRoll):
memo = Memo('bts-dice-game', account)
nodeForConnections = 'wss://api.bitsharesdex.com'
blockchain = Blockchain(node=nodeForConnections, mode='head')
bitshares = BitShares(
node=nodeForConnections,
nobroadcast=False,
)
blockNum = blockchain.get_current_block_num()
userGuess = userRoll
seed(blockNum * (userGuess + 1))
diceRatios = btsDiceRatios
winRatio = diceRatios.get_ratio(userGuess)
value = randint(1, 100)
correctGuess = value < int(userGuess)
bitshares.wallet.unlock('superSecretPassword')
if winRatio is None:
print('You submitted something not correct to this contract.')
elif correctGuess:
winningAmount = winRatio * amountBet
winningString = "Correct! You guessed {0} and rolled {1}. You won {2:.5f} BTS.".format(
userRoll, value, winningAmount)
bitshares.transfer(account,
winningAmount,
'BTS',
winningString,
account='bts-dice-game')
print(winningString)
else:
losingString = "Incorrect. You guessed {0} and rolled {1}.".format(
userRoll, value)
bitshares.transfer(account,
0.00001,
'BTS',
losingString,
account='bts-dice-game')
print(
'You guessed incorrectly. Your guess was {a} and you rolled {b}.'.
format(a=userRoll, b=value))
def transfer_asset():
cybex_config(node_rpc_endpoint=NODE_WS_ENDPOINT, chain_id=CHAIN_ID)
net = BitShares(node=NODE_WS_ENDPOINT, **{'prefix': 'cyb'})
unlock(net)
try:
net.wallet.addPrivateKey(FROM_ACCOUNT_ACTIVE_PRIVATE_KEY)
except Exception as e:
pass
net.wallet.unlock(WALLET_PASSWD)
acc = Account(FROM_ACCOUNT, bitshares_instance=net)
net.transfer(TO_ACCOUNT,
ASSET_AMOUNT,
ASSET_NAME,
'memo string',
account=acc)
class Testcases(unittest.TestCase):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.bts = BitShares(
nobroadcast=True,
# We want to bundle many operations into a single transaction
bundle=True,
# Overwrite wallet to use this list of wifs only
wif=[wif]
)
set_shared_blockchain_instance(self.bts)
self.bts.set_default_account("init0")
def test_fee_on_transfer(self):
tx = self.bts.transfer("init1", 1, "1.3.0", account="init0", fee_asset="1.3.121")
op = tx["operations"][0][1]
self.assertEqual(op["fee"]["asset_id"], "1.3.121")
account = "alfredo-worker"
proposer = "oxarbitrage.a699"
vesting_id = "1.13.1608"
bitshares = BitShares(
nobroadcast=False,
bundle=True,
proposer=proposer,
proposal_expiration=60 * 60 * 24 * 2,
)
set_shared_bitshares_instance(bitshares)
market = Market("USD:BTS")
price = market.ticker()["quoteSettlement_price"]
bitshares.wallet.unlock(getpass())
vesting = Vesting(vesting_id)
print("Claiming Vesting Balance: %s" % vesting.claimable)
bitshares.vesting_balance_withdraw(vesting["id"],
amount=vesting.claimable,
account=account)
print("Buying as much bitUSD at price up to %s or %s" %
(price * 0.90, (price * 0.90).copy().invert()))
market.buy(price * 0.9, Amount(3200, "USD"), killfill=True, account=account)
print("Worker alfredo payment - 15 days")
bitshares.transfer("oxarbitrage.a699", 3200, "USD", account=account)
pprint(bitshares.broadcast())
testnet.transfer(acc_name, init_supply, "ZGV", account=source_account)
#create the required number of accounts
for i in range(accs_count):
acc_name = get_name(i)
create_account(acc_name)
#make the required number of transactions
random.seed(dt.datetime.now())
for i in range(tran_count):
#sender is picked random
sender = get_name(random.randint(0, accs_count - 1))
#receiver is picked random until it is different from sender
receiver = sender
while receiver == sender:
receiver = get_name(random.randint(0, accs_count - 1))
#transaction amount is the random part of the sender's balance
sender_acc = Account(sender, bitshares_instance=testnet)
sender_balance = sender_acc.balances[0].amount
amount = sender_balance * random.random()
try:
print("transfer " + str(amount) + " from " + sender + " to " +
receiver)
testnet.transfer(receiver, amount, "ZGV", account=sender_acc)
except Exception as e:
print(traceback.format_exc())
class Testcases(unittest.TestCase):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.bts = BitShares(
"wss://node.testnet.bitshares.eu",
nobroadcast=True,
keys={"active": wif},
)
# from getpass import getpass
# self.bts.wallet.unlock(getpass())
set_shared_bitshares_instance(self.bts)
self.bts.set_default_account("init0")
def test_finalizeOps_proposal(self):
bts = self.bts
# proposal = bts.new_proposal(bts.tx())
proposal = bts.proposal()
self.bts.transfer("init1", 1, "TEST", append_to=proposal)
tx = bts.tx().json() # default tx buffer
ops = tx["operations"]
self.assertEqual(len(ops), 1)
self.assertEqual(getOperationNameForId(ops[0][0]), "proposal_create")
prop = ops[0][1]
self.assertEqual(len(prop["proposed_ops"]), 1)
self.assertEqual(
getOperationNameForId(prop["proposed_ops"][0]["op"][0]),
"transfer")
def test_finalizeOps_proposal2(self):
bts = self.bts
proposal = bts.new_proposal()
# proposal = bts.proposal()
self.bts.transfer("init1", 1, "TEST", append_to=proposal)
tx = bts.tx().json() # default tx buffer
ops = tx["operations"]
self.assertEqual(len(ops), 1)
self.assertEqual(getOperationNameForId(ops[0][0]), "proposal_create")
prop = ops[0][1]
self.assertEqual(len(prop["proposed_ops"]), 1)
self.assertEqual(
getOperationNameForId(prop["proposed_ops"][0]["op"][0]),
"transfer")
def test_finalizeOps_combined_proposal(self):
bts = self.bts
parent = bts.new_tx()
proposal = bts.new_proposal(parent)
self.bts.transfer("init1", 1, "TEST", append_to=proposal)
self.bts.transfer("init1", 1, "TEST", append_to=parent)
tx = parent.json()
ops = tx["operations"]
self.assertEqual(len(ops), 2)
self.assertEqual(getOperationNameForId(ops[0][0]), "proposal_create")
self.assertEqual(getOperationNameForId(ops[1][0]), "transfer")
prop = ops[0][1]
self.assertEqual(len(prop["proposed_ops"]), 1)
self.assertEqual(
getOperationNameForId(prop["proposed_ops"][0]["op"][0]),
"transfer")
def test_finalizeOps_changeproposer_new(self):
bts = self.bts
proposal = bts.proposal(proposer="init5")
bts.transfer("init1", 1, "TEST", append_to=proposal)
tx = bts.tx().json()
ops = tx["operations"]
self.assertEqual(len(ops), 1)
self.assertEqual(getOperationNameForId(ops[0][0]), "proposal_create")
prop = ops[0][1]
self.assertEqual(len(prop["proposed_ops"]), 1)
self.assertEqual(prop["fee_paying_account"], "1.2.11")
self.assertEqual(
getOperationNameForId(prop["proposed_ops"][0]["op"][0]),
"transfer")
"""
def test_finalizeOps_changeproposer_legacy(self):
bts = self.bts
bts.proposer = "init5"
tx = bts.transfer("init1", 1, "TEST")
ops = tx["operations"]
self.assertEqual(len(ops), 1)
self.assertEqual(
getOperationNameForId(ops[0][0]),
"proposal_create")
prop = ops[0][1]
self.assertEqual(len(prop["proposed_ops"]), 1)
self.assertEqual(prop["fee_paying_account"], "1.2.11")
self.assertEqual(
getOperationNameForId(prop["proposed_ops"][0]["op"][0]),
"transfer")
"""
def test_new_proposals(self):
bts = self.bts
p1 = bts.new_proposal()
p2 = bts.new_proposal()
self.assertIsNotNone(id(p1), id(p2))
def test_new_txs(self):
bts = self.bts
p1 = bts.new_tx()
p2 = bts.new_tx()
self.assertIsNotNone(id(p1), id(p2))
acc = create_acc(acc_num)
acc_list.append(acc)
turn_counter = 0
while True:
sender = max(acc_list, key=lambda x: x["balance"])
random.seed(datetime.now())
acc_count = len(acc_list)
receiver = acc_list[random.randint(0, acc_count - 1)]
if sender["name"] == receiver["name"]:
continue
sender_acc = Account(sender["name"], bitshares_instance=testnet)
receiver_acc = Account(receiver["name"], bitshares_instance=testnet)
try:
testnet.transfer(receiver["name"],
sender["balance"] - 20,
"ZGV",
account=sender_acc)
except:
print(traceback.format_exc())
print("%d transaction %s %s %d" %
(turn_counter, sender["name"], receiver["name"],
sender["balance"] - 20))
sender_acc = Account(sender["name"], bitshares_instance=testnet)
receiver_acc = Account(receiver["name"], bitshares_instance=testnet)
sender["balance"] = sender_acc.balances[0].amount
receiver["balance"] = receiver_acc.balances[0].amount
turn_counter = turn_counter + 1
# if turn_counter % 100 == 99:
# acc = create_acc(len(acc_list))
# acc_list.append(acc)
def transfert(acc_from, acc_to, asset, amount):
bitshares = BitShares(btsNode, acc_from.name, acc_from.pwd)
bitshares.wallet.unlock("supersecret")
bitshares.transfer(acc_to.name, float(amount), asset, account=acc_from.name)
bitshares.wallet.lock()
password="******",
additional_owner_keys=[],
additional_active_keys=[],
additional_owner_accounts=["vel-ma", "oatrick1995"],
additional_active_accounts=[],
proxy_account="proxy-to-self",
storekeys=True))
testnet.broadcast()
##allow - change threashold
foreign_account = format(
PasswordKey("mutual-insurance-fund-993", "somethingstupid",
"active").get_public(), "TEST")
print_tx(
testnet.allow(
foreign_account,
weight=1,
account="vel-ma",
permission="active",
threshold=2,
))
##transfer funds
print_tx(
testnet.transfer("mutual-insurance-fund-993", 5, "TEST", account=account))
##proposal - claim
##vote - vote
testnet.broadcast()
class Testcases(unittest.TestCase):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.bts = BitShares(
"wss://node.testnet.bitshares.eu",
nobroadcast=True,
keys={"active": wif, "owner": wif, "memo": wif},
)
# from getpass import getpass
# self.bts.wallet.unlock(getpass())
set_shared_bitshares_instance(self.bts)
self.bts.set_default_account("init0")
def test_connect(self):
self.bts.connect()
def test_set_default_account(self):
self.bts.set_default_account("init0")
def test_info(self):
info = self.bts.info()
for key in ['current_witness',
'head_block_id',
'head_block_number',
'id',
'last_irreversible_block_num',
'next_maintenance_time',
'recently_missed_count',
'time']:
self.assertTrue(key in info)
def test_finalizeOps(self):
bts = self.bts
tx1 = bts.new_tx()
tx2 = bts.new_tx()
self.bts.transfer("init1", 1, core_unit, append_to=tx1)
self.bts.transfer("init1", 2, core_unit, append_to=tx2)
self.bts.transfer("init1", 3, core_unit, append_to=tx1)
tx1 = tx1.json()
tx2 = tx2.json()
ops1 = tx1["operations"]
ops2 = tx2["operations"]
self.assertEqual(len(ops1), 2)
self.assertEqual(len(ops2), 1)
def test_transfer(self):
bts = self.bts
tx = bts.transfer(
"1.2.8", 1.33, core_unit, memo="Foobar", account="1.2.7")
self.assertEqual(
getOperationNameForId(tx["operations"][0][0]),
"transfer"
)
op = tx["operations"][0][1]
self.assertIn("memo", op)
self.assertEqual(op["from"], "1.2.7")
self.assertEqual(op["to"], "1.2.8")
amount = Amount(op["amount"])
self.assertEqual(float(amount), 1.33)
def test_create_account(self):
bts = self.bts
name = ''.join(random.choice(string.ascii_lowercase) for _ in range(12))
key1 = PrivateKey()
key2 = PrivateKey()
key3 = PrivateKey()
key4 = PrivateKey()
tx = bts.create_account(
name,
registrar="init0", # 1.2.7
referrer="init1", # 1.2.8
referrer_percent=33,
owner_key=format(key1.pubkey, core_unit),
active_key=format(key2.pubkey, core_unit),
memo_key=format(key3.pubkey, core_unit),
additional_owner_keys=[format(key4.pubkey, core_unit)],
additional_active_keys=[format(key4.pubkey, core_unit)],
additional_owner_accounts=["committee-account"], # 1.2.0
additional_active_accounts=["committee-account"],
proxy_account="init0",
storekeys=False
)
self.assertEqual(
getOperationNameForId(tx["operations"][0][0]),
"account_create"
)
op = tx["operations"][0][1]
role = "active"
self.assertIn(
format(key4.pubkey, core_unit),
[x[0] for x in op[role]["key_auths"]])
self.assertIn(
format(key4.pubkey, core_unit),
[x[0] for x in op[role]["key_auths"]])
self.assertIn(
"1.2.0",
[x[0] for x in op[role]["account_auths"]])
role = "owner"
self.assertIn(
format(key4.pubkey, core_unit),
[x[0] for x in op[role]["key_auths"]])
self.assertIn(
format(key4.pubkey, core_unit),
[x[0] for x in op[role]["key_auths"]])
self.assertIn(
"1.2.0",
[x[0] for x in op[role]["account_auths"]])
self.assertEqual(
op["options"]["voting_account"],
"1.2.6")
self.assertEqual(
op["registrar"],
"1.2.6")
self.assertEqual(
op["referrer"],
"1.2.7")
self.assertEqual(
op["referrer_percent"],
33 * 100)
def test_weight_threshold(self):
bts = self.bts
auth = {'account_auths': [['1.2.0', '1']],
'extensions': [],
'key_auths': [
['TEST55VCzsb47NZwWe5F3qyQKedX9iHBHMVVFSc96PDvV7wuj7W86n', 1],
['TEST7GM9YXcsoAJAgKbqW2oVj7bnNXFNL4pk9NugqKWPmuhoEDbkDv', 1]],
'weight_threshold': 3} # threshold fine
bts._test_weights_treshold(auth)
auth = {'account_auths': [['1.2.0', '1']],
'extensions': [],
'key_auths': [
['TEST55VCzsb47NZwWe5F3qyQKedX9iHBHMVVFSc96PDvV7wuj7W86n', 1],
['TEST7GM9YXcsoAJAgKbqW2oVj7bnNXFNL4pk9NugqKWPmuhoEDbkDv', 1]],
'weight_threshold': 4} # too high
with self.assertRaises(ValueError):
bts._test_weights_treshold(auth)
def test_allow(self):
bts = self.bts
tx = bts.allow(
"TEST55VCzsb47NZwWe5F3qyQKedX9iHBHMVVFSc96PDvV7wuj7W86n",
weight=1,
threshold=1,
permission="owner"
)
self.assertEqual(
getOperationNameForId(tx["operations"][0][0]),
"account_update"
)
op = tx["operations"][0][1]
self.assertIn("owner", op)
self.assertIn(
["TEST55VCzsb47NZwWe5F3qyQKedX9iHBHMVVFSc96PDvV7wuj7W86n", '1'],
op["owner"]["key_auths"])
self.assertEqual(op["owner"]["weight_threshold"], 1)
def test_disallow(self):
bts = self.bts
with self.assertRaisesRegex(ValueError, ".*Changes nothing.*"):
bts.disallow(
"TEST55VCzsb47NZwWe5F3qyQKedX9iHBHMVVFSc96PDvV7wuj7W86n",
weight=1,
threshold=1,
permission="owner"
)
with self.assertRaisesRegex(ValueError, ".*Changes nothing!.*"):
bts.disallow(
"TEST6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV",
weight=1,
threshold=1,
permission="owner"
)
def test_update_memo_key(self):
bts = self.bts
tx = bts.update_memo_key("TEST55VCzsb47NZwWe5F3qyQKedX9iHBHMVVFSc96PDvV7wuj7W86n")
self.assertEqual(
getOperationNameForId(tx["operations"][0][0]),
"account_update"
)
op = tx["operations"][0][1]
self.assertEqual(
op["new_options"]["memo_key"],
"TEST55VCzsb47NZwWe5F3qyQKedX9iHBHMVVFSc96PDvV7wuj7W86n")
def test_approvewitness(self):
bts = self.bts
tx = bts.approvewitness("init0")
self.assertEqual(
getOperationNameForId(tx["operations"][0][0]),
"account_update"
)
op = tx["operations"][0][1]
self.assertIn(
"1:0",
op["new_options"]["votes"])
def test_approvecommittee(self):
bts = self.bts
tx = bts.approvecommittee("init0")
self.assertEqual(
getOperationNameForId(tx["operations"][0][0]),
"account_update"
)
op = tx["operations"][0][1]
self.assertIn(
"0:11",
op["new_options"]["votes"])
def test_sign_message(self):
def new_refresh(self):
dict.__init__(
self, {"name": "init0",
"options": {
"memo_key": "TEST6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV"
}})
with mock.patch(
"bitshares.account.Account.refresh",
new=new_refresh
):
p = Message("message foobar").sign()
Message(p).verify()
def tapbasic(referrer):
# test is request has 'account' key
if not request.json or 'account' not in request.json:
abort(400)
account = request.json.get('account', {})
# make sure all keys are present
if any([
key not in account
for key in ["active_key", "memo_key", "owner_key", "name"]
]):
abort(400)
if len(models.Accounts.query.options().all()
) >= config.registrations_limit:
return api_error("Registration limit achieved")
# prevent massive account registration
if request.args.get("ip") != "127.0.0.1" and models.Accounts.exists(
request.args.get("ip")):
return api_error("Only one account per IP")
# Check if account name is cheap name
if (not re.search(r"[0-9-]", account["name"])
and re.search(r"[aeiouy]", account["name"])):
return api_error("Only cheap names allowed!")
# This is not really needed but added to keep API-compatibility with Rails Faucet
account.update({"id": None})
bitshares = BitShares(config.witness_url,
nobroadcast=config.nobroadcast,
keys=[config.wif],
prefix=config.prefix)
try:
Account(account["name"], bitshares_instance=bitshares)
return api_error("Account exists")
except:
pass
# Registrar
registrar = account.get("registrar", config.registrar) or config.registrar
try:
registrar = Account(registrar, bitshares_instance=bitshares)
except:
return api_error("Unknown registrar: %s" % registrar)
# Referrer
referrer = account.get("referrer",
config.default_referrer) or config.default_referrer
try:
referrer = Account(referrer, bitshares_instance=bitshares)
except:
return api_error("Unknown referrer: %s" % referrer)
referrer_percent = account.get("referrer_percent", config.referrer_percent)
# Create new account
try:
bitshares.create_account(
account["name"],
registrar=registrar["id"],
referrer=referrer["id"],
referrer_percent=referrer_percent,
owner_key=account["owner_key"],
active_key=account["active_key"],
memo_key=account["memo_key"],
proxy_account=config.get("proxy", None),
additional_owner_accounts=config.get("additional_owner_accounts",
[]),
additional_active_accounts=config.get("additional_active_accounts",
[]),
additional_owner_keys=config.get("additional_owner_keys", []),
additional_active_keys=config.get("additional_active_keys", []),
)
except Exception as e:
log.error(traceback.format_exc())
return api_error(str(e))
models.Accounts(account["name"], request.args.get("ip"))
regestree = Account(account["name"], bitshares_instance=bitshares)
try:
bitshares.transfer(account["name"],
config["donation_amount"],
config["donation_asset"],
memo="AirDrop",
account=registrar)
except Exception as e:
log.error(str(e))
pass
balance = registrar.balance(config.core_asset)
if balance and balance.amount < config.balance_mailthreshold:
log.critical(
"The faucet's balances is below {}".format(
config.balance_mailthreshold), )
return jsonify({
"account": {
"name": account["name"],
"owner_key": account["owner_key"],
"active_key": account["active_key"],
"memo_key": account["memo_key"],
"referrer": referrer["name"]
}
})
from pprint import pprint
from getpass import getpass
from datetime import datetime, timedelta
from bitshares import BitShares
from bitshares.amount import Amount
from bitshares.asset import Asset
bitshares = BitShares(nobroadcast=False)
bitshares.wallet.unlock(getpass())
proposal = bitshares.new_proposal(
proposer="xeroc",
proposal_expiration=timedelta(days=3).seconds,
proposal_review=3600,
)
bitshares.transfer(
"gibbs-from-ncis",
4631.34999,
"BTS",
account="onboarding.bitshares.foundation",
append_to=proposal,
)
test = Asset("TEST")
test.change_issuer("committee-issuer", append_to=proposal)
pprint(bitshares.broadcast())
tran_count = tran_count + 1
print(tran_count)
print(tran)
rt_delay = (tran["time"] - package_start).total_seconds() / time_scale
rt_time = rt_start + dt.timedelta(seconds=rt_delay)
if rt_time > dt.datetime.now():
sleep_time = rt_time - dt.datetime.now()
print("sleep for " + str(sleep_time))
time.sleep(sleep_time.total_seconds())
try:
run_transaction(tran)
except Exception as e:
print(traceback.format_exc())
#retreive all distributed money back
csv = package["transaction_sets"][0]["csv_files"][0]
print(csv)
with open(data_dir + '/' + csv) as f:
for line in f:
tran = parse_line(line)
if tran["to"] == source_name:
continue
acc_to = Account(tran["to"], bitshares_instance=testnet)
if not acc_to.balances:
continue
balance = acc_to.balances[0].amount
if balance > transaction_fee:
testnet.transfer(source_name, balance - transaction_fee, "ZGV", account=acc_to)
