def test_PubKey(self):
self.assertEqual([
format(
PublicKey(
"ONE6UtYWWs3rkZGV8JA86qrgkG6tyFksgECefKE1MiH4HkLD8PFGL",
prefix="ONE").address, "ONE"),
format(
PublicKey(
"ONE8YAMLtNcnqGNd3fx28NP3WoyuqNtzxXpwXTkZjbfe9scBmSyGT",
prefix="ONE").address, "ONE"),
format(
PublicKey(
"ONE7HUo6bm7Gfoi3RqAtzwZ83BFCwiCZ4tp37oZjtWxGEBJVzVVGw",
prefix="ONE").address, "ONE"),
format(
PublicKey(
"ONE6676cZ9qmqPnWMrm4McjCuHcnt6QW5d8oRJ4t8EDH8DdCjvh4V",
prefix="ONE").address, "ONE"),
format(
PublicKey(
"ONE7u8m6zUNuzPNK1tPPLtnipxgqV9mVmTzrFNJ9GvovvSTCkVUra",
prefix="ONE").address, "ONE")
], [
"ONE66FCjYKzMwLbE3a59YpmFqA9bwporT4L3",
"ONEKNpRuPX8KhTBsJoFp1JXd7eQEsnCpRw3k",
"ONE838ENJargbUrxXWuE2xD9HKjQaS17GdCd",
"ONENsrLFWTziSZASnNJjWafFtGBfSu8VG8KU",
"ONEDjAGuXzk3WXabBEgKKc8NsuQM412boBdR"
])
def __init__(self, *args, **kwargs) :
# Allow for overwrite of prefix
prefix = kwargs.pop("prefix", default_prefix)
if isArgsThisClass(self, args):
self.data = args[0].data
else:
if len(args) == 1 and len(kwargs) == 0:
kwargs = args[0]
# Sort keys (FIXME: ideally, the sorting is part of Public
# Key and not located here)
kwargs["key_auths"] = sorted(
kwargs["key_auths"],
key=lambda x: repr(PublicKey(x[0], prefix=prefix).address),
reverse=False,
)
accountAuths = Map([
[String(e[0]), Uint16(e[1])]
for e in kwargs["account_auths"]
])
keyAuths = Map([
[PublicKey(e[0], prefix=prefix), Uint16(e[1])]
for e in kwargs["key_auths"]
])
super().__init__(OrderedDict([
('weight_threshold', Uint32(int(kwargs["weight_threshold"]))),
('account_auths' , accountAuths),
('key_auths' , keyAuths),
('extensions' , Set([])),
]))
def test_PublicKey(self):
self.assertEqual([
str(
PublicKey(
"ONE6UtYWWs3rkZGV8JA86qrgkG6tyFksgECefKE1MiH4HkLD8PFGL",
prefix="ONE")),
str(
PublicKey(
"ONE8YAMLtNcnqGNd3fx28NP3WoyuqNtzxXpwXTkZjbfe9scBmSyGT",
prefix="ONE")),
str(
PublicKey(
"ONE7HUo6bm7Gfoi3RqAtzwZ83BFCwiCZ4tp37oZjtWxGEBJVzVVGw",
prefix="ONE")),
str(
PublicKey(
"ONE6676cZ9qmqPnWMrm4McjCuHcnt6QW5d8oRJ4t8EDH8DdCjvh4V",
prefix="ONE")),
str(
PublicKey(
"ONE7u8m6zUNuzPNK1tPPLtnipxgqV9mVmTzrFNJ9GvovvSTCkVUra",
prefix="ONE"))
], [
"ONE6UtYWWs3rkZGV8JA86qrgkG6tyFksgECefKE1MiH4HkLD8PFGL",
"ONE8YAMLtNcnqGNd3fx28NP3WoyuqNtzxXpwXTkZjbfe9scBmSyGT",
"ONE7HUo6bm7Gfoi3RqAtzwZ83BFCwiCZ4tp37oZjtWxGEBJVzVVGw",
"ONE6676cZ9qmqPnWMrm4McjCuHcnt6QW5d8oRJ4t8EDH8DdCjvh4V",
"ONE7u8m6zUNuzPNK1tPPLtnipxgqV9mVmTzrFNJ9GvovvSTCkVUra"
])
def __init__(self, *args, **kwargs) :
if isArgsThisClass(self, args):
self.data = args[0].data
else:
if len(args) == 1 and len(kwargs) == 0:
kwargs = args[0]
for o in ['active_approvals_to_add',
'active_approvals_to_remove',
'owner_approvals_to_add',
'owner_approvals_to_remove',
'key_approvals_to_add',
'key_approvals_to_remove']:
if o not in kwargs:
kwargs[o] = []
super().__init__(OrderedDict([
('fee' , Asset(kwargs["fee"])),
('fee_paying_account', ObjectId(kwargs["fee_paying_account"], "account")),
('proposal', ObjectId(kwargs["proposal"], "proposal")),
('active_approvals_to_add',
Array([ObjectId(o, "account") for o in kwargs["active_approvals_to_add"]])),
('active_approvals_to_remove',
Array([ObjectId(o, "account") for o in kwargs["active_approvals_to_remove"]])),
('owner_approvals_to_add',
Array([ObjectId(o, "account") for o in kwargs["owner_approvals_to_add"]])),
('owner_approvals_to_remove',
Array([ObjectId(o, "account") for o in kwargs["owner_approvals_to_remove"]])),
('key_approvals_to_add',
Array([PublicKey(o) for o in kwargs["key_approvals_to_add"]])),
('key_approvals_to_remove',
Array([PublicKey(o) for o in kwargs["key_approvals_to_remove"]])),
('extensions', Set([])),
]))
def account_create_operation(creator: str, fee: Amount, name: str, owner: str,
active: str, posting: str, memo, json_meta,
additional_owner_accounts,
additional_active_accounts,
additional_posting_accounts,
additional_owner_keys, additional_active_keys,
additional_posting_keys):
creation_fee = str(fee)
owner_pubkey = owner if type(owner) is PublicKey else PublicKey(owner)
active_pubkey = active if type(active) is PublicKey else PublicKey(active)
posting_pubkey = posting if type(posting) is PublicKey else PublicKey(
posting)
memo_pubkey = memo if type(memo) is PublicKey else PublicKey(memo)
owner_key_authority = [[str(owner_pubkey), 1]]
active_key_authority = [[str(active_pubkey), 1]]
posting_key_authority = [[str(posting_pubkey), 1]]
owner_accounts_authority = []
active_accounts_authority = []
posting_accounts_authority = []
for k in additional_owner_keys:
owner_key_authority.append([k, 1])
for k in additional_active_keys:
active_key_authority.append([k, 1])
for k in additional_posting_keys:
posting_key_authority.append([k, 1])
for k in additional_owner_accounts:
owner_accounts_authority.append([k, 1])
for k in additional_active_accounts:
active_accounts_authority.append([k, 1])
for k in additional_posting_accounts:
posting_accounts_authority.append([k, 1])
return operations.AccountCreate(
**{
'fee': creation_fee,
'creator': creator,
'new_account_name': name,
'owner': {
'account_auths': owner_accounts_authority,
'key_auths': owner_key_authority,
'weight_threshold': 1
},
'active': {
'account_auths': active_accounts_authority,
'key_auths': active_key_authority,
'weight_threshold': 1
},
'posting': {
'account_auths': posting_accounts_authority,
'key_auths': posting_key_authority,
'weight_threshold': 1
},
'memo_key': str(memo_pubkey),
'json_metadata': json_meta
})
def test_PubKey(self):
self.assertEqual([format(PublicKey("BTS6UtYWWs3rkZGV8JA86qrgkG6tyFksgECefKE1MiH4HkLD8PFGL", prefix="BTS").address, "BTS"),
format(PublicKey("BTS8YAMLtNcnqGNd3fx28NP3WoyuqNtzxXpwXTkZjbfe9scBmSyGT", prefix="BTS").address, "BTS"),
format(PublicKey("BTS7HUo6bm7Gfoi3RqAtzwZ83BFCwiCZ4tp37oZjtWxGEBJVzVVGw", prefix="BTS").address, "BTS"),
format(PublicKey("BTS6676cZ9qmqPnWMrm4McjCuHcnt6QW5d8oRJ4t8EDH8DdCjvh4V", prefix="BTS").address, "BTS"),
format(PublicKey("BTS7u8m6zUNuzPNK1tPPLtnipxgqV9mVmTzrFNJ9GvovvSTCkVUra", prefix="BTS").address, "BTS")
], [
'BTSDXi9tQ6Pjf1SEv3m4jn2U5M2YgMPpHy2V',
'BTSQ1AEncFQ9ddRU1jfrieomX8RgTnSGgUwj',
'BTSBkT8dGRrbbYpqCXovCBoZDNiVq3XXMyLG',
'BTS3U2ok8z392o6BXYu75PGxohEH9boCx3dy',
'BTSCpkigUBxSLfK2Ldgah9QpoLFftL11k8wW'])
def __init__(self, *args, **kwargs):
if isArgsThisClass(self, args):
self.data = args[0].data
else:
if len(args) == 1 and len(kwargs) == 0:
kwargs = args[0]
super().__init__(OrderedDict([
('from', PublicKey(kwargs["from"], prefix=prefix)),
('to', PublicKey(kwargs["to"], prefix=prefix)),
('nonce', Uint64(int(kwargs["nonce"]))),
('check', Uint32(int(kwargs["check"]))),
('encrypted', Bytes(kwargs["encrypted"])),
]))
def __init__(self, *args, **kwargs):
if isArgsThisClass(self, args):
self.data = args[0].data
else:
if len(args) == 1 and len(kwargs) == 0:
kwargs = args[0]
prefix = kwargs.pop("prefix", default_prefix)
assert len(kwargs["new_account_name"]
) <= 16, "Account name must be at most 16 chars long"
meta = ""
if "json_metadata" in kwargs and kwargs["json_metadata"]:
if isinstance(kwargs["json_metadata"], dict):
meta = json.dumps(kwargs["json_metadata"])
else:
meta = kwargs["json_metadata"]
super().__init__(
OrderedDict([
('fee', Amount(kwargs["fee"])),
('creator', String(kwargs["creator"])),
('new_account_name', String(kwargs["new_account_name"])),
('owner', Permission(kwargs["owner"], prefix=prefix)),
('active', Permission(kwargs["active"], prefix=prefix)),
('posting', Permission(kwargs["posting"], prefix=prefix)),
('memo_key', PublicKey(kwargs["memo_key"], prefix=prefix)),
('json_metadata', String(meta)),
]))
def __init__(self, *args, **kwargs):
if isArgsThisClass(self, args):
self.data = args[0].data
else:
if len(args) == 1 and len(kwargs) == 0:
kwargs = args[0]
prefix = kwargs.pop("prefix", default_prefix)
meta = ""
if "json_metadata" in kwargs and kwargs["json_metadata"]:
if isinstance(kwargs["json_metadata"], dict):
meta = json.dumps(kwargs["json_metadata"])
else:
meta = kwargs["json_metadata"]
owner = Permission(kwargs["owner"],
prefix=prefix) if "owner" in kwargs else None
active = Permission(kwargs["active"],
prefix=prefix) if "active" in kwargs else None
posting = Permission(
kwargs["posting"],
prefix=prefix) if "posting" in kwargs else None
super().__init__(
OrderedDict([
('account', String(kwargs["account"])),
('owner', Optional(owner)),
('active', Optional(active)),
('posting', Optional(posting)),
('memo_key', PublicKey(kwargs["memo_key"], prefix=prefix)),
('json_metadata', String(meta)),
]))
def __init__(self, *args, **kwargs):
if isArgsThisClass(self, args):
self.data = args[0].data
else:
if len(args) == 1 and len(kwargs) == 0:
kwargs = args[0]
prefix = kwargs.pop("prefix", default_prefix)
assert len(kwargs["new_account_name"]
) <= 16, "Account name must be at most 16 chars long"
meta = ""
if "json_metadata" in kwargs and kwargs["json_metadata"]:
if isinstance(kwargs["json_metadata"], dict):
meta = json.dumps(kwargs["json_metadata"])
else:
meta = kwargs["json_metadata"]
# HF 18 requires liquid steem to be multiplied by 30 for creation
# f = Amount(kwargs["fee"])
# fee = '{} STEEM'.format(f.amount * 30)
# print(fee)
super().__init__(
OrderedDict([
('fee', Amount(kwargs['fee'])),
('delegation', Amount(kwargs["delegation"])),
('creator', String(kwargs["creator"])),
('new_account_name', String(kwargs["new_account_name"])),
('owner', Permission(kwargs["owner"], prefix=prefix)),
('active', Permission(kwargs["active"], prefix=prefix)),
('posting', Permission(kwargs["posting"], prefix=prefix)),
('memo_key', PublicKey(kwargs["memo_key"], prefix=prefix)),
('json_metadata', String(meta)),
('extensions', Array([])),
]))
def test_Adress(self):
address1 = format(PrivateKey("5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3").address, "ONE")
address2 = format(PublicKey("ONE6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV", prefix="ONE").address, "ONE")
tempAddress = format(Address("BTSFN9r6VYzBK8EKtMewfNbfiGCr56pHDBFi", prefix="BTS"), "BTS")
tempAddress = format(Address("ONEFAbAx7yuxt725qSZvfwWqkdCwp9ZnUama", prefix="ONE"), "ONE")
result = address2 == tempAddress
ret = 0
def test_sign_message():
signature = sign_message(
"text text text",
"5JCvGL2GVVpjDrKzbKWPHEvuwFs5HdEGwr4brp8RQiwrpEFcZNP")
# assert(hexlify(signature) == b'2075625adc5f0a025fa5125e1f1a6493c2ad9798ec18afb49d4a1d9f741ccac16'
# b'441cb10d240046e5cf3b7f10694b62c608047ec037b2ddaec053bdd1f5107c927')
k = verify_message("text text text", signature)
p = PublicKey(hexlify(k).decode('ascii'))
assert (str(p) == "SCR5bgzuweaHx231escVuPVxgudSyUWdKAH7fKgxZfp3nKSirzFRa")
def verify_tx(d):
sig = d['signature']
name = d['account']
account = cybex.account.Account(name , cybex_instance = inst)
del d['signature']
op = Tx(**d)
message = bytes(op)
p = verify_message(message, unhexlify(sig))
pkey = PublicKey(hexlify(p).decode('ascii'), prefix = 'CYB')
print(str(pkey))
_pubkey = account['active']['key_auths'][0][0]
if str(pkey) == _pubkey:
return True
return False
def __init__(self, *args, **kwargs):
if isArgsThisClass(self, args):
self.data = args[0].data
else:
if len(args) == 1 and len(kwargs) == 0:
kwargs = args[0]
if not kwargs["block_signing_key"]:
kwargs["block_signing_key"] = "STM1111111111111111111111111111111114T1Anm"
super().__init__(OrderedDict([
('owner', String(kwargs["owner"])),
('url', String(kwargs["url"])),
('block_signing_key', PublicKey(kwargs["block_signing_key"], prefix=prefix)),
('props', Witness_props(kwargs["props"])),
('fee', Amount(kwargs["fee"])),
]))
def __init__(self, *args, **kwargs) :
# Allow for overwrite of prefix
prefix = kwargs.pop("prefix", default_prefix)
if isArgsThisClass(self, args):
self.data = args[0].data
else:
if len(args) == 1 and len(kwargs) == 0:
kwargs = args[0]
super().__init__(OrderedDict([
('memo_key' , PublicKey(kwargs["memo_key"], prefix=prefix)),
('voting_account' , ObjectId(kwargs["voting_account"], "account")),
('num_witness' , Uint16(kwargs["num_witness"])),
('num_committee' , Uint16(kwargs["num_committee"])),
('votes' , Array([VoteId(o) for o in kwargs["votes"]])),
('extensions' , Set([])),
]))
def verify_tx(d):
sig = d['signature']
name = d['account']
try:
account = cybex.account.Account(name , cybex_instance = inst)
except:
logger.error('account [%s] not found from chain'%(name))
return False
del d['signature']
message = name
try:
p = verify_message(message, unhexlify(sig))
except:
logger.error('verify_message failed')
return False
pkey = PublicKey(hexlify(p).decode('ascii'), prefix = 'CYB')
# return str(pkey)
_pubkey = account['active']['key_auths'][0][0]
if str(pkey) == _pubkey:
return True
return False
def test_signed_transaction():
chain_id = "95e4b20f5e669fab5fdaa2fc9f691192118f72900f9906f13b1883e2fb57aa43"
op = operations.Transfer(**{
"from": "alice",
"to": "bob",
"amount": '0.001 SCR',
"memo": "for food"
})
tx = SignedTransaction(ref_block_num=11105,
ref_block_prefix=4052692508,
expiration="2018-01-29T08:37:12",
operations=[op])
tx.sign(["5JCvGL2GVVpjDrKzbKWPHEvuwFs5HdEGwr4brp8RQiwrpEFcZNP"], chain_id)
public_keys = tx.verify(
["SCR5bgzuweaHx231escVuPVxgudSyUWdKAH7fKgxZfp3nKSirzFRa"], chain_id)
assert (len(public_keys) == 1)
p = PublicKey(public_keys[0])
assert (str(p) == "SCR5bgzuweaHx231escVuPVxgudSyUWdKAH7fKgxZfp3nKSirzFRa")
def test_shared_secret(self):
for s in test_shared_secrets:
priv = PrivateKey(s[0])
pub = PublicKey(s[1], prefix="GPH")
shared_secret = get_shared_secret(priv, pub)
self.assertEqual(s[2], shared_secret)
def test_encrypt(self):
for memo in test_cases:
enc = encode_memo(PrivateKey(memo["wif"]),
PublicKey(memo["to"], prefix="GPH"),
memo["nonce"], memo["plain"])
self.assertEqual(memo["message"], enc)
raw = (pad(raw))
## Encryption
return hexlify(aes.encrypt(raw)).decode('ascii')
def decode_memo(priv, pub, nonce, message):
shared_secret = get_shared_secret(priv, pub)
aes = init_aes(shared_secret, nonce)
## Encryption
raw = bytes(message, 'ascii')
cleartext = aes.decrypt(unhexlify(raw))
# TODO, verify checksum
message = cleartext[4:]
try:
return message.decode('utf8').strip()
except:
raise Exception(message)
if __name__ == '__main__':
memo = {
"from": "GPH6Co3ctgs6BSsGkti3iVcArMKywbwhnzKDAgmkb6J3Cad7ykDYX",
"to": "GPH7gU4pHJ9rTUfVA6q6dEgCxgMGVLmq1YM3HRAKpj1VnTzJhrAn2",
"nonce": "9729217759611568577",
"message": "aac432f92a8bf52828ac1fda8a3bf6e3"
}
priv = PrivateKey("WIF-KEY")
pub = PublicKey("OTHERS-PUBKEY", prefix="GPH")
dec = decode_memo(priv, pub, memo["nonce"], memo["message"])
print(dec)
from graphenebase.account import PublicKey
pub = PublicKey("BTS8Xniy3FX61zsUu5RPRePBpREzvroiqHgLtL4qF6wGZJviqqViP", prefix="BTS")
print(format(pub.address,"BTS"))
def main() :
global args
global rpc
config = Configuration()
if "node" not in config or not config["node"]:
config["node"] = "wss://bitshares.openledger.info/ws"
parser = argparse.ArgumentParser(
formatter_class=argparse.RawDescriptionHelpFormatter,
description="Command line tool to interact with the BitShares network"
)
"""
Default settings for all tools
"""
parser.add_argument(
'--node',
type=str,
default=config["node"],
help='Websocket URL for public BitShares API (default: "wss://bitshares.openledger.info/ws")'
)
parser.add_argument(
'--rpcuser',
type=str,
default=config["rpcuser"],
help='Websocket user if authentication is required'
)
parser.add_argument(
'--rpcpassword',
type=str,
default=config["rpcpassword"],
help='Websocket password if authentication is required'
)
parser.add_argument(
'--nobroadcast',
action='store_true',
help='Do not broadcast anything'
)
subparsers = parser.add_subparsers(help='sub-command help')
parser.set_defaults(command=None)
"""
Command "set"
"""
setconfig = subparsers.add_parser('set', help='Set configuration')
setconfig.add_argument(
'key',
type=str,
choices=["node",
"rpcuser",
"rpcpassword",
"account"
],
help='Configuration key'
)
setconfig.add_argument(
'value',
type=str,
help='Configuration value'
)
setconfig.set_defaults(command="set")
"""
Command "addkey"
"""
addkey = subparsers.add_parser('addkey', help='Add a new key to the wallet')
addkey.add_argument(
'wifkeys',
nargs='*',
type=str,
help='the private key in wallet import format (wif)'
)
addkey.set_defaults(command="addkey")
"""
Command "listkeys"
"""
listkeys = subparsers.add_parser('listkeys', help='List available keys in your wallet')
listkeys.set_defaults(command="listkeys")
"""
Command "listaccounts"
"""
listaccounts = subparsers.add_parser('listaccounts', help='List available accounts in your wallet')
listaccounts.set_defaults(command="listaccounts")
"""
Command "getbalance"
"""
getbalance = subparsers.add_parser('getbalance', help='Get balances of available account(s)')
getbalance.set_defaults(command="getbalance")
getbalance.add_argument(
'account',
type=str,
nargs="*",
default=[config["account"]],
help='Accounts for which to retrieve the balance',
)
"""
Command "transfer"
"""
transfer = subparsers.add_parser('transfer', help='Transfer funds from your wallet to someone else')
transfer.set_defaults(command="transfer")
transfer.add_argument(
'--from',
type=str,
help='Transfer from this account',
default=config["account"],
)
transfer.add_argument(
'--to',
type=str,
help='Transfer to this account',
required=True,
)
transfer.add_argument(
'--amount',
type=str,
help='Transfer this amount (format: "amount SYMBOL")',
action="append",
required=True,
)
transfer.add_argument(
'--memo',
default='',
type=str,
help='Memo',
)
"""
Command "approve"
"""
approve = subparsers.add_parser('approve', help='approve funds from your wallet to someone else')
approve.set_defaults(command="approve")
approve.add_argument(
'--account',
type=str,
help='Approve with this account',
default=config["account"],
)
approve.add_argument(
'proposal',
type=str,
help='Proposal to approve',
)
"""
Parse Arguments
"""
args = parser.parse_args()
rpc_not_required = ["set", ""]
if args.command not in rpc_not_required and args.command:
rpc = GrapheneWebsocketRPC(args.node, args.rpcuser, args.rpcpassword)
if args.command == "set":
config[args.key] = args.value
elif args.command == "addkey":
wallet = Wallet(rpc)
if len(args.wifkeys):
for wifkey in args.wifkeys:
pub = (wallet.addPrivateKey(wifkey))
if pub:
print(pub)
else:
import getpass
wifkey = ""
while True:
wifkey = getpass.getpass('Private Key (wif) [Enter to quit]:')
if not wifkey:
break
pub = (wallet.addPrivateKey(wifkey))
if pub:
print(pub)
elif args.command == "listkeys":
t = PrettyTable(["Available Key"])
t.align = "l"
for key in Wallet(rpc).getPublicKeys():
t.add_row([key])
print(t)
elif args.command == "listaccounts":
t = PrettyTable(["Name", "Available Key"])
t.align = "l"
for account in Wallet(rpc).getAccounts():
t.add_row(account)
print(t)
elif args.command == "getbalance":
if args.account:
accounts = [a for a in args.account]
else:
accounts = [a[0] for a in Wallet(rpc).getAccounts()]
for account_name in accounts:
account = rpc.get_account(account_name)
t = PrettyTable(["Amount", "Asset"])
t.align = "l"
balances = rpc.get_account_balances(account["id"], [])
if not balances:
continue
print(account["name"] + ":")
for balance in balances:
asset = rpc.get_objects([balance["asset_id"]])[0]
amount = int(balance["amount"]) / 10 ** asset["precision"]
if amount:
t.add_row([amount, asset["symbol"]])
print(t)
elif args.command == "transfer":
wallet = Wallet(rpc)
ops = []
for amountStr in args.amount:
amount, symbol = amountStr.split(" ")
amount = float(amount)
asset = rpc.get_asset(symbol)
from_account = rpc.get_account(getattr(args, "from"))
to_account = rpc.get_account(getattr(args, "to"))
transferObj = {
"fee": {"amount": 0,
"asset_id": "1.3.0"
},
"from": from_account["id"],
"to": to_account["id"],
"amount": {"amount": int(amount * 10 ** asset["precision"]),
"asset_id": asset["id"]
}
}
if args.memo:
memo_key = wallet.getMemoKeyForAccount(getattr(args, "from"))
if not memo_key:
print("Missing memo private key!")
return
import random
nonce = str(random.getrandbits(64))
encrypted_memo = memo.encode_memo(PrivateKey(memo_key),
PublicKey(to_account["options"]["memo_key"]),
nonce,
args.memo)
memoStruct = {"from": from_account["options"]["memo_key"],
"to": to_account["options"]["memo_key"],
"nonce": nonce,
"message": encrypted_memo,
"chain": "BTS"}
transferObj["memo"] = transactions.Memo(**memoStruct)
transfer = transactions.Transfer(**transferObj)
ops.append(transactions.Operation(transfer))
wif = wallet.getActiveKeyForAccount(getattr(args, "from"))
executeOps(ops, [wif])
elif args.command == "approve":
wallet = Wallet(rpc)
account = rpc.get_account(args.account)
s = {'fee_paying_account': account["id"],
'proposal': args.proposal,
'active_approvals_to_add': [account["id"]],
"fee": transactions.Asset(amount=0, asset_id="1.3.0"),
}
op = transactions.Proposal_update(**s)
wif = wallet.getActiveKeyForAccount(args.account)
executeOps([transactions.Operation(op)], [wif])
else:
print("No valid command given")
