def _get_config_key(self, config_key, is_key=False, ask_to_stdin=True): # check config file if config_key in self.config: logger.info(f"Got the {config_key} in the config file.") if is_key: return PrivateKey(self.config.get(config_key)) else: return self.config.get(config_key) # check the environment vars config_val = os.getenv(ENV_KEYS[config_key]) if config_val: logger.info(f"Got the {config_key} in the environment vars.") if is_key: return PrivateKey(config_val) return config_val if not ask_to_stdin: return None if is_key: config_val = PrivateKey(getpass.getpass(f"{config_key}:\n")) else: config_val = input(f"{config_key}:\n") return config_val
def test_btsprivkey(self): self.assertEqual([ format( PrivateKey( "5HqUkGuo62BfcJU5vNhTXKJRXuUi9QSE6jp8C3uBJ2BVHtB8WSd"). address, "BTS"), format( PrivateKey( "5JWcdkhL3w4RkVPcZMdJsjos22yB5cSkPExerktvKnRNZR5gx1S"). address, "BTS"), format( PrivateKey( "5HvVz6XMx84aC5KaaBbwYrRLvWE46cH6zVnv4827SBPLorg76oq"). address, "BTS"), format( PrivateKey( "5Jete5oFNjjk3aUMkKuxgAXsp7ZyhgJbYNiNjHLvq5xzXkiqw7R"). address, "BTS"), format( PrivateKey( "5KDT58ksNsVKjYShG4Ls5ZtredybSxzmKec8juj7CojZj6LPRF7"). address, "BTS") ], [ "BTSFN9r6VYzBK8EKtMewfNbfiGCr56pHDBFi", "BTSdXrrTXimLb6TEt3nHnePwFmBT6Cck112", "BTSJQUAt4gz4civ8gSs5srTK4r82F7HvpChk", "BTSFPXXHXXGbyTBwdKoJaAPXRnhFNtTRS4EL", "BTS3qXyZnjJneeAddgNDYNYXbF7ARZrRv5dr", ])
def test_wallet_keys(self): stm = self.bts stm.wallet.unlock("123") priv_key = stm.wallet.getPrivateKeyForPublicKey( str(PrivateKey(self.posting_key, prefix=stm.prefix).pubkey)) self.assertEqual(str(priv_key), self.posting_key) priv_key = stm.wallet.getKeyForAccount("beem", "active") self.assertEqual(str(priv_key), self.active_key) priv_key = stm.wallet.getKeyForAccount("beem1", "posting") self.assertEqual(str(priv_key), self.posting_key1) priv_key = stm.wallet.getPrivateKeyForPublicKey( str( PrivateKey(self.active_private_key_of_beem4, prefix=stm.prefix).pubkey)) self.assertEqual(str(priv_key), self.active_private_key_of_beem4) priv_key = stm.wallet.getKeyForAccount("beem4", "active") self.assertEqual(str(priv_key), self.active_private_key_of_beem4) priv_key = stm.wallet.getPrivateKeyForPublicKey( str( PrivateKey(self.active_private_key_of_beem5, prefix=stm.prefix).pubkey)) self.assertEqual(str(priv_key), self.active_private_key_of_beem5) priv_key = stm.wallet.getKeyForAccount("beem5", "active") self.assertEqual(str(priv_key), self.active_private_key_of_beem5)
def encrypt(self, memo, bts_encrypt=False, return_enc_memo_only=False, nonce=None): """ Encrypt a memo :param str memo: clear text memo message :param bool return_enc_memo_only: When True, only the encoded memo is returned :param str nonce: when not set, a random string is generated and used :returns: encrypted memo :rtype: dict """ if not memo: return None if nonce is None: nonce = str(random.getrandbits(64)) if isinstance(self.from_account, Account): memo_wif = self.blockchain.wallet.getPrivateKeyForPublicKey( self.from_account["memo_key"]) memo_wif = PrivateKey(memo_wif) else: memo_wif = self.from_account if isinstance(self.to_account, Account): pubkey = self.to_account["memo_key"] else: pubkey = self.to_account if not memo_wif: raise MissingKeyError("Memo key for %s missing!" % self.from_account["name"]) if not hasattr(self, 'chain_prefix'): self.chain_prefix = self.blockchain.prefix if bts_encrypt: enc = BtsMemo.encode_memo_bts( PrivateKey(memo_wif), PublicKey(pubkey, prefix=self.chain_prefix), nonce, memo) return { "message": enc, "nonce": nonce, "from": str(PrivateKey(memo_wif).pubkey), "to": str(pubkey) } else: enc = BtsMemo.encode_memo(PrivateKey(memo_wif), PublicKey(pubkey, prefix=self.chain_prefix), nonce, memo, prefix=self.chain_prefix) if return_enc_memo_only: return enc return { "message": enc, "from": str(PrivateKey(memo_wif).pubkey), "to": str(pubkey) }
def decrypt(self, memo): """ Decrypt a memo :param str memo: encrypted memo message :returns: encrypted memo :rtype: str """ if not memo: return None # We first try to decode assuming we received the memo if isinstance(memo, dict) and "to" in memo and "from" in memo and "memo" in memo: memo_to = Account(memo["to"], steem_instance=self.steem) memo_from = Account(memo["from"], steem_instance=self.steem) message = memo["memo"] else: memo_to = self.to_account memo_from = self.from_account message = memo if isinstance(memo, dict) and "nonce" in memo: nonce = memo.get("nonce") else: nonce = "" try: memo_wif = self.steem.wallet.getPrivateKeyForPublicKey( memo_to["memo_key"] ) pubkey = memo_from["memo_key"] except MissingKeyError: try: # if that failed, we assume that we have sent the memo memo_wif = self.steem.wallet.getPrivateKeyForPublicKey( memo_from["memo_key"] ) pubkey = memo_to["memo_key"] except MissingKeyError: # if all fails, raise exception raise MissingKeyError( "Non of the required memo keys are installed!" "Need any of {}".format( [memo_to["name"], memo_from["name"]])) if not hasattr(self, 'chain_prefix'): self.chain_prefix = self.steem.prefix if message[0] == '#': return BtsMemo.decode_memo( PrivateKey(memo_wif), message ) else: return BtsMemo.decode_memo_bts( PrivateKey(memo_wif), PublicKey(pubkey, prefix=self.chain_prefix), nonce, message )
def test_btcprivkeystr(self): self.assertEqual([str(BitcoinAddress.from_pubkey(PrivateKey("5HvVz6XMx84aC5KaaBbwYrRLvWE46cH6zVnv4827SBPLorg76oq").pubkey)), str(BitcoinAddress.from_pubkey(PrivateKey("5Jete5oFNjjk3aUMkKuxgAXsp7ZyhgJbYNiNjHLvq5xzXkiqw7R").pubkey, compressed=True)), str(BitcoinAddress.from_pubkey(PrivateKey("5KDT58ksNsVKjYShG4Ls5ZtredybSxzmKec8juj7CojZj6LPRF7").pubkey, compressed=False)), ], ["1G7qw8FiVfHEFrSt3tDi6YgfAdrDrEM44Z", "1E2jXCkSmLxirL31gHwi1UWTjUBxCgS7pq", "1Gu5191CVHmaoU3Zz3prept87jjnpFDrXL", ])
def test_btcprivkey(self): self.assertEqual([format(PrivateKey("5HvVz6XMx84aC5KaaBbwYrRLvWE46cH6zVnv4827SBPLorg76oq").uncompressed.address, "BTC"), format(PrivateKey("5Jete5oFNjjk3aUMkKuxgAXsp7ZyhgJbYNiNjHLvq5xzXkiqw7R").uncompressed.address, "BTC"), format(PrivateKey("5KDT58ksNsVKjYShG4Ls5ZtredybSxzmKec8juj7CojZj6LPRF7").uncompressed.address, "BTC"), ], ["1G7qw8FiVfHEFrSt3tDi6YgfAdrDrEM44Z", "12c7KAAZfpREaQZuvjC5EhpoN6si9vekqK", "1Gu5191CVHmaoU3Zz3prept87jjnpFDrXL", ])
def test_gphprivkeystr(self): self.assertEqual([str(Address.from_pubkey(PrivateKey("5HvVz6XMx84aC5KaaBbwYrRLvWE46cH6zVnv4827SBPLorg76oq").pubkey)), str(Address.from_pubkey(PrivateKey("5Jete5oFNjjk3aUMkKuxgAXsp7ZyhgJbYNiNjHLvq5xzXkiqw7R").pubkey, compressed=True)), str(Address.from_pubkey(PrivateKey("5KDT58ksNsVKjYShG4Ls5ZtredybSxzmKec8juj7CojZj6LPRF7").pubkey, compressed=False, prefix="BTS")), ], ["STMBXqRucGm7nRkk6jm7BNspTJTWRtNcx7k5", "STM5tTDDR6M3mkcyVv16edsw8dGUyNQZrvKU", "BTS4XPkBqYw882fH5aR5S8mMKXCaZ1yVA76f", ])
def test_create_account(self): bts = Hive(node=self.nodelist.get_hive_nodes(), nobroadcast=True, unsigned=True, data_refresh_time_seconds=900, keys={ "active": wif, "owner": wif, "memo": wif }, num_retries=10) core_unit = "STM" name = ''.join( random.choice(string.ascii_lowercase) for _ in range(12)) key1 = PrivateKey() key2 = PrivateKey() key3 = PrivateKey() key4 = PrivateKey() key5 = PrivateKey() bts.txbuffer.clear() tx = bts.create_account( name, creator="test", # 1.2.7 owner_key=format(key1.pubkey, core_unit), active_key=format(key2.pubkey, core_unit), posting_key=format(key3.pubkey, core_unit), memo_key=format(key4.pubkey, core_unit), additional_owner_keys=[format(key5.pubkey, core_unit)], additional_active_keys=[format(key5.pubkey, core_unit)], additional_posting_keys=[format(key5.pubkey, core_unit)], additional_owner_accounts=["test1"], # 1.2.0 additional_active_accounts=["test2"], additional_posting_accounts=["test3"], storekeys=False, ) self.assertEqual(tx["operations"][0][0], "account_create") op = tx["operations"][0][1] role = "active" self.assertIn(format(key5.pubkey, core_unit), [x[0] for x in op[role]["key_auths"]]) self.assertIn(format(key5.pubkey, core_unit), [x[0] for x in op[role]["key_auths"]]) self.assertIn("test2", [x[0] for x in op[role]["account_auths"]]) role = "posting" self.assertIn(format(key5.pubkey, core_unit), [x[0] for x in op[role]["key_auths"]]) self.assertIn(format(key5.pubkey, core_unit), [x[0] for x in op[role]["key_auths"]]) self.assertIn("test3", [x[0] for x in op[role]["account_auths"]]) role = "owner" self.assertIn(format(key5.pubkey, core_unit), [x[0] for x in op[role]["key_auths"]]) self.assertIn(format(key5.pubkey, core_unit), [x[0] for x in op[role]["key_auths"]]) self.assertIn("test1", [x[0] for x in op[role]["account_auths"]]) self.assertEqual(op["creator"], "test")
def test_derive_child(self): # NOTE: this key + offset pair is particularly nasty, as # the resulting derived value is less then 64 bytes long. # Thus, this test also tests for proper padding. p = PrivateKey("5K6hMUtQB2xwjuz3SRR6uM5HNERWgBqcK7gPPZ31XtAyBNoATZd") p2 = p.child( b"\xaf\x8f: \xf6T?V\x0bM\xd8\x16 \xfd\xde\xe9\xb9\xac\x03\r\xba\xb2\x8d\x868-\xc2\x90\x80\xe8\x1b\xce" ) self.assertEqual( repr(p2), "0c5fae344a513a4cfab312b24c08df2b2d6afa25c0ead0d3d1d0d3e76794109b" )
def encrypt(self, memo, bts_encrypt=False): """ Encrypt a memo :param str memo: clear text memo message :returns: encrypted memo :rtype: str """ if not memo: return None nonce = str(random.getrandbits(64)) memo_wif = self.steem.wallet.getPrivateKeyForPublicKey( self.from_account["memo_key"] ) if not memo_wif: raise MissingKeyError("Memo key for %s missing!" % self.from_account["name"]) if not hasattr(self, 'chain_prefix'): self.chain_prefix = self.steem.prefix if bts_encrypt: enc = BtsMemo.encode_memo_bts( PrivateKey(memo_wif), PublicKey( self.to_account["memo_key"], prefix=self.chain_prefix ), nonce, memo ) return { "message": enc, "nonce": nonce, "from": self.from_account["memo_key"], "to": self.to_account["memo_key"] } else: enc = BtsMemo.encode_memo( PrivateKey(memo_wif), PublicKey( self.to_account["memo_key"], prefix=self.chain_prefix ), nonce, memo, prefix=self.chain_prefix ) return { "message": enc, "from": self.from_account["memo_key"], "to": self.to_account["memo_key"] }
def test_Privatekey_derive(self): p1 = PrivateKey("5HvVz6XMx84aC5KaaBbwYrRLvWE46cH6zVnv4827SBPLorg76oq") p2 = PrivateKey("5Jete5oFNjjk3aUMkKuxgAXsp7ZyhgJbYNiNjHLvq5xzXkiqw7R") self.assertEqual([format(p1.child(p2.get_secret()), "STM"), format(p2.child(p1.get_secret()), "STM"), format(p1.derive_private_key(0), "STM"), format(p2.derive_private_key(56), "STM")], ["STMZiwJpC7MUmc9gn3vii3XS36nUceYEfKvFC1NLSrjB7ZRQJ7gt", "STM24hzNSDZYgm9C85yxJqyk32DwjXg8pCgkGVzB77hvP2XxGDdvr", "STM2e99iqVQUFij7Dk2nWVNC1dL8M86q37Nj4KwPHKBu1Yy49HkwA", "STMgqaH9RdvUtVk7NFnx4BZJRrNS7Lj35qaueAeYJ3tKEqPaLwa4"])
def test_shared_secrets_equal(self): wifs = cycle([x[0] for x in test_shared_secrets]) for i in range(len(test_shared_secrets)): sender_private_key = PrivateKey(next(wifs)) sender_public_key = sender_private_key.pubkey receiver_private_key = PrivateKey(next(wifs)) receiver_public_key = receiver_private_key.pubkey self.assertEqual( get_shared_secret(sender_private_key, receiver_public_key), get_shared_secret(receiver_private_key, sender_public_key))
def test_Privatekey_pubkey(self): self.assertEqual([ format( PrivateKey( "5HvVz6XMx84aC5KaaBbwYrRLvWE46cH6zVnv4827SBPLorg76oq"). pubkey, "STX"), str( PrivateKey( "5HvVz6XMx84aC5KaaBbwYrRLvWE46cH6zVnv4827SBPLorg76oq", prefix="STX").pubkey) ], [ "STX7W5qsanXHgRAZPijbrLMDwX6VmHqUdL2s8PZiYKD5h1R7JaqRJ", "STX7W5qsanXHgRAZPijbrLMDwX6VmHqUdL2s8PZiYKD5h1R7JaqRJ" ])
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() key5 = PrivateKey() tx = bts.create_account( name, creator="beem", owner_key=format(key1.pubkey, core_unit), active_key=format(key2.pubkey, core_unit), posting_key=format(key3.pubkey, core_unit), memo_key=format(key4.pubkey, core_unit), additional_owner_keys=[format(key5.pubkey, core_unit)], additional_active_keys=[format(key5.pubkey, core_unit)], additional_owner_accounts=["beem1"], # 1.2.0 additional_active_accounts=["beem1"], storekeys=False ) self.assertEqual( tx["operations"][0][0], "account_create" ) op = tx["operations"][0][1] role = "active" self.assertIn( format(key5.pubkey, core_unit), [x[0] for x in op[role]["key_auths"]]) self.assertIn( format(key5.pubkey, core_unit), [x[0] for x in op[role]["key_auths"]]) self.assertIn( "beem1", [x[0] for x in op[role]["account_auths"]]) role = "owner" self.assertIn( format(key5.pubkey, core_unit), [x[0] for x in op[role]["key_auths"]]) self.assertIn( format(key5.pubkey, core_unit), [x[0] for x in op[role]["key_auths"]]) self.assertIn( "beem1", [x[0] for x in op[role]["account_auths"]]) self.assertEqual( op["creator"], "beem")
def checkkey(username, password, role): listOfValidRoles = ['owner' , 'active', 'posting', 'memo'] if role not in listOfValidRoles: print(role + " NOT found in List : " , listOfValidRoles) sys.exit("Wrong role " + role) try: account = Account(username, steem_instance=stmf) except: sys.exit("Wrong username " + username) try: publickey = str(PrivateKey(password, prefix="EUR").pubkey) except: sys.exit("Wrong password syntax " + password) blk_auths_public = {} if role == "memo": blk_auths_public[role] = str(account.json()["memo_key"]) else: blk_auths_public[role] = str(account.json()[role]["key_auths"][0][0]) if publickey == blk_auths_public[role]: return True else: return False
def __init__( self, from_account=None, to_account=None, blockchain_instance=None, **kwargs ): if blockchain_instance is None: if kwargs.get("steem_instance"): blockchain_instance = kwargs["steem_instance"] elif kwargs.get("hive_instance"): blockchain_instance = kwargs["hive_instance"] self.blockchain = blockchain_instance or shared_blockchain_instance() if to_account and len(to_account) < 51: self.to_account = Account(to_account, blockchain_instance=self.blockchain) elif to_account and len(to_account) >= 51: self.to_account = PublicKey(to_account) else: self.to_account = None if from_account and len(from_account) < 51: self.from_account = Account(from_account, blockchain_instance=self.blockchain) elif from_account and len(from_account) >= 51: self.from_account = PrivateKey(from_account) else: self.from_account = None
def encrypt_wif(self, wif): """ Encrypt a wif key """ if self.locked(): raise AssertionError() return format( bip38.encrypt(PrivateKey(wif, prefix=self.prefix), self.masterpassword), "encwif")
def encrypt_binary(self, infile, outfile, buffer_size=2048, nonce=None): """ Encrypt a binary file :param str infile: input file name :param str outfile: output file name :param int buffer_size: write buffer size :param str nonce: when not set, a random string is generated and used """ if not os.path.exists(infile): raise ValueError("%s does not exists!" % infile) if nonce is None: nonce = str(random.getrandbits(64)) if isinstance(self.from_account, Account): memo_wif = self.blockchain.wallet.getPrivateKeyForPublicKey( self.from_account["memo_key"] ) else: memo_wif = self.from_account if isinstance(self.to_account, Account): pubkey = self.to_account["memo_key"] else: pubkey = self.to_account if not memo_wif: raise MissingKeyError("Memo key for %s missing!" % self.from_account["name"]) if not hasattr(self, 'chain_prefix'): self.chain_prefix = self.blockchain.prefix file_size = os.path.getsize(infile) priv = PrivateKey(memo_wif) pub = PublicKey( pubkey, prefix=self.chain_prefix ) enc = BtsMemo.encode_memo( priv, pub, nonce, "beem/%s" % __version__, prefix=self.chain_prefix ) enc = unhexlify(base58decode(enc[1:])) shared_secret = BtsMemo.get_shared_secret(priv, pub) aes, check = BtsMemo.init_aes(shared_secret, nonce) with open(outfile, 'wb') as fout: fout.write(struct.pack('<Q', len(enc))) fout.write(enc) fout.write(struct.pack('<Q', file_size)) with open(infile, 'rb') as fin: while True: data = fin.read(buffer_size) n = len(data) if n == 0: break elif n % 16 != 0: data += b' ' * (16 - n % 16) # <- padded with spaces encd = aes.encrypt(data) fout.write(encd)
def test_encrypt(self): for memo in test_cases: enc = encode_memo(PrivateKey(memo["wif"]), PublicKey(memo["to"], prefix="GPH"), memo["nonce"], memo["plain"], prefix="GPH") self.assertEqual(memo["message"], enc)
def test_create_account_password(self): bts = Hive(node=get_hive_nodes(), nobroadcast=True, unsigned=True, data_refresh_time_seconds=900, keys={"active": wif, "owner": wif2, "memo": wif3}, num_retries=10) core_unit = "STM" name = ''.join(random.choice(string.ascii_lowercase) for _ in range(12)) key5 = PrivateKey() bts.txbuffer.clear() tx = bts.create_account( name, creator="test", # 1.2.7 password="******", additional_owner_keys=[format(key5.pubkey, core_unit)], additional_active_keys=[format(key5.pubkey, core_unit)], additional_posting_keys=[format(key5.pubkey, core_unit)], additional_owner_accounts=["test1"], # 1.2.0 additional_active_accounts=["test1"], storekeys=False, ) if isinstance(tx["operations"][0], list): self.assertEqual( tx["operations"][0][0], "account_create" ) op = tx["operations"][0][1] else: self.assertEqual( tx["operations"][0]["type"], "account_create_operation" ) op = tx["operations"][0]["value"] role = "active" self.assertIn( format(key5.pubkey, core_unit), [x[0] for x in op[role]["key_auths"]]) self.assertIn( format(key5.pubkey, core_unit), [x[0] for x in op[role]["key_auths"]]) self.assertIn( "test1", [x[0] for x in op[role]["account_auths"]]) role = "owner" self.assertIn( format(key5.pubkey, core_unit), [x[0] for x in op[role]["key_auths"]]) self.assertIn( format(key5.pubkey, core_unit), [x[0] for x in op[role]["key_auths"]]) self.assertIn( "test1", [x[0] for x in op[role]["account_auths"]]) self.assertEqual( op["creator"], "test")
def test_decrypt_bugged_padding_bts(self): for memo in not_enough_padding: dec = decode_memo_bts( PrivateKey(memo["wif"]), PublicKey(memo["to"], prefix="GPH"), memo["nonce"], memo["message_bts"], ) self.assertEqual(memo["plain"], dec)
def test_decrypt_bts(self): for memo in test_cases: dec = decode_memo_bts( PrivateKey(memo["wif"]), PublicKey(memo["to"], prefix="GPH"), memo["nonce"], memo["message_bts"], ) self.assertEqual(memo["plain"], dec)
def doit(self, printWire=False, ops=None): if ops is None: ops = [Operation(self.op)] tx = Signed_Transaction(ref_block_num=self.ref_block_num, ref_block_prefix=self.ref_block_prefix, expiration=self.expiration, operations=ops) tx = tx.sign([self.wif], chain=self.prefix) tx.verify([PrivateKey(self.wif, prefix=u"STM").pubkey], self.prefix) txWire = hexlify(py23_bytes(tx)).decode("ascii")
def __init__(self, config_file, action=None, signing_key=None, active_key=None, witness_account=None, url=None, markets=None, peg_multiplier=None): self.config = self.get_config(config_file) self.steem = self.get_steem_instance(self.config, keys=None) # Private signing key if signing_key: self.signing_key = PrivateKey(signing_key) logger.info(f"Got the SIGNING_KEY in the parameters.") else: self.signing_key = self._get_config_key('SIGNING_KEY', is_key=True) # Convert the witness account string into beem.Witness if witness_account: self.witness_account = witness_account logger.info("Got the WITNESS_ACCOUNT in the parameters.") else: self.witness_account = self._get_config_key('WITNESS_ACCOUNT') self.witness_account = Witness(self.witness_account, steem_instance=self.steem) if action != "publish_feed": # register the witness URL if url: logger.info("Got the URL in the parameters.") self.url = url else: self.url = self._get_config_key('URL') # register the active key if it's passed by CLI. self.active_key = active_key # market list to publish price feeds self.markets = markets if action == "publish_feed" and not markets: self.markets = self._get_config_key('MARKETS', ask_to_stdin=False) if not self.markets: self.markets = DEFAULT_MARKETS if not is_marketlist_valid(self.markets): logger.error("Invalid market list") sys.exit(0) if self.markets and not isinstance(self.markets, list): # convert comma separated string into list self.markets = list( map(lambda x: x.strip(), self.markets.split(","))) self.peg_multiplier = peg_multiplier or 1
def test_create_account_password(self, node_param): if node_param == "non_appbase": bts = Steem(node=self.nodelist.get_nodes(appbase=False), nobroadcast=True, unsigned=True, data_refresh_time_seconds=900, keys={ "active": wif, "owner": wif, "memo": wif }, num_retries=10) elif node_param == "appbase": bts = Steem(node=self.nodelist.get_nodes(normal=False, appbase=True), nobroadcast=True, unsigned=True, data_refresh_time_seconds=900, keys={ "active": wif, "owner": wif, "memo": wif }, num_retries=10) name = ''.join( random.choice(string.ascii_lowercase) for _ in range(12)) key5 = PrivateKey() bts.txbuffer.clear() tx = bts.create_account( name, creator="test", # 1.2.7 password="******", additional_owner_keys=[format(key5.pubkey, core_unit)], additional_active_keys=[format(key5.pubkey, core_unit)], additional_posting_keys=[format(key5.pubkey, core_unit)], additional_owner_accounts=["test1"], # 1.2.0 additional_active_accounts=["test1"], storekeys=False, delegation_fee_steem="0 STEEM") self.assertEqual(tx["operations"][0][0], "account_create") op = tx["operations"][0][1] role = "active" self.assertIn(format(key5.pubkey, core_unit), [x[0] for x in op[role]["key_auths"]]) self.assertIn(format(key5.pubkey, core_unit), [x[0] for x in op[role]["key_auths"]]) self.assertIn("test1", [x[0] for x in op[role]["account_auths"]]) role = "owner" self.assertIn(format(key5.pubkey, core_unit), [x[0] for x in op[role]["key_auths"]]) self.assertIn(format(key5.pubkey, core_unit), [x[0] for x in op[role]["key_auths"]]) self.assertIn("test1", [x[0] for x in op[role]["account_auths"]]) self.assertEqual(op["creator"], "test")
def appendWif(self, wif): """ Add a wif that should be used for signing of the transaction. :param string wif: One wif key to use for signing a transaction. """ if wif: try: PrivateKey(wif, prefix=self.steem.prefix) self.wifs.add(wif) except: raise InvalidWifError
def _get_pub_from_wif(self, wif): """ Get the pubkey as string, from the wif key as string """ # it could be either graphenebase or steem so we can't check # the type directly if isinstance(wif, PrivateKey): wif = str(wif) try: return format(PrivateKey(wif).pubkey, self.prefix) except: raise InvalidWifError( "Invalid Private Key Format. Please use WIF!")
def decrypt_wif(self, encwif): """ decrypt a wif key """ try: # Try to decode as wif PrivateKey(encwif, prefix=self.prefix) return encwif except (ValueError, AssertionError): pass if self.locked(): raise AssertionError() return format(bip38.decrypt(encwif, self.masterpassword), "wif")
def doit(self, printWire=False, ops=None): ops = [Operation(ops)] tx = Signed_Transaction(ref_block_num=self.ref_block_num, ref_block_prefix=self.ref_block_prefix, expiration=self.expiration, operations=ops) start = timer() tx = tx.sign([self.wif], chain=self.prefix) end1 = timer() tx.verify([PrivateKey(self.wif, prefix=u"STM").pubkey], self.prefix) end2 = timer() return end2 - end1, end1 - start