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")