def test_init(self): config = storage.InRamConfigurationStore() key_store = storage.InRamPlainKeyStore(config=config) wallet = Wallet(key_store=key_store) # InRamStore does not come with a default key self.assertFalse(wallet.created()) self.assertTrue(bool(wallet.rpc)) self.assertEqual(wallet.prefix, "BTS") wif1 = PrivateKey() wif2 = PrivateKey() wallet.setKeys([ wif1, wif2 ]) self.assertIn( str(wif1.pubkey), wallet.store.getPublicKeys() ) self.assertIn( str(wif2.pubkey), wallet.store.getPublicKeys() ) self.assertEqual( wallet.getPrivateKeyForPublicKey( wif1.pubkey ), str(wif1) ) self.assertEqual( wallet.getPrivateKeyForPublicKey( wif2.pubkey ), str(wif2) ) # wallet.unlock("") # wallet.lock() # is unlocked because InRamKeyStore and not encrypted self.assertFalse(wallet.store.is_encrypted()) self.assertFalse(wallet.is_encrypted()) self.assertTrue(wallet.unlocked()) self.assertFalse(wallet.locked()) wif3 = PrivateKey() wallet.addPrivateKey(wif3) self.assertIn( str(wif3.pubkey), wallet.store.getPublicKeys() ) self.assertEqual( wallet.getPrivateKeyForPublicKey( wif3.pubkey ), str(wif3) ) wallet.removePrivateKeyFromPublicKey(wif3.pubkey) with self.assertRaises(KeyNotFound): wallet.getPrivateKeyForPublicKey( wif3.pubkey )
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_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 __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.bts = BitShares(nobroadcast=True, wif=[wif]) set_shared_bitshares_instance(self.bts) self.bts.set_default_account("init0") cache = ObjectCache(default_expiration=5, no_overwrite=True) init0 = { 'active': { 'account_auths': [], 'address_auths': [], 'key_auths': [[str(PrivateKey(wif).pubkey), 1]], 'weight_threshold': 1 }, 'active_special_authority': [0, {}], 'blacklisted_accounts': [], 'blacklisting_accounts': [], 'cashback_vb': '1.13.102', 'id': '1.2.90742', 'lifetime_referrer': '1.2.90742', 'lifetime_referrer_fee_percentage': 8000, 'membership_expiration_date': '1969-12-31T23:59:59', 'name': 'init0', 'network_fee_percentage': 2000, 'options': { 'extensions': [], 'memo_key': str(PrivateKey(wif).pubkey), 'num_committee': 0, 'num_witness': 0, 'votes': [], 'voting_account': '1.2.5' }, 'owner': { 'account_auths': [], 'address_auths': [], 'key_auths': [[str(PrivateKey(wif).pubkey), 1]], 'weight_threshold': 1 }, 'owner_special_authority': [0, {}], 'referrer': '1.2.90742', 'referrer_rewards_percentage': 0, 'registrar': '1.2.90742', 'statistics': '2.6.90742', 'top_n_control_flags': 0, 'whitelisted_accounts': [], 'whitelisting_accounts': [] } cache[init0["id"]] = init0 cache[init0["name"]] = init0 BlockchainObject._cache = cache
def compareConstructedTX(self): self.maxDiff = None self.op = operations.Call_order_update( **{ "fee": {"amount": 100, "asset_id": "1.3.0"}, "delta_debt": {"amount": 10000, "asset_id": "1.3.22"}, "delta_collateral": {"amount": 100000000, "asset_id": "1.3.0"}, "funding_account": "1.2.29", "extensions": {"target_collateral_ratio": 12345}, } ) ops = [Operation(self.op)] tx = Signed_Transaction( ref_block_num=ref_block_num, ref_block_prefix=ref_block_prefix, expiration=expiration, operations=ops, ) tx = tx.sign([wif], chain=prefix) tx.verify([PrivateKey(wif).pubkey], prefix) txWire = hexlify(bytes(tx)).decode("ascii") print("=" * 80) pprint(tx.json()) print("=" * 80) # Test against Bitshares backened self.cm = bitshares.rpc.get_transaction_hex(tx.json()) print("soll: %s" % self.cm[:-130]) print("ist: %s" % txWire[:-130]) print(txWire[:-130] == self.cm[:-130]) self.assertEqual(self.cm[:-130], txWire[:-130])
def validate_private_key_type(self, account, private_key): account = Account(account) pubkey = format(PrivateKey(private_key).pubkey, self.bitshares.prefix) key_type = self.bitshares.wallet.getKeyType(account, pubkey) if key_type != 'active': return False return True
def encrypt(self, memo): """ 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.bitshares.wallet.getPrivateKeyForPublicKey( self.from_account["options"]["memo_key"]) if not memo_wif: raise MissingKeyError("Memo key for %s missing!" % self.from_account["name"]) enc = BtsMemo.encode_memo( PrivateKey(memo_wif), PublicKey(self.to_account["options"]["memo_key"], prefix=self.bitshares.prefix), nonce, memo) return { "message": enc, "nonce": nonce, "from": self.from_account["options"]["memo_key"], "to": self.to_account["options"]["memo_key"] }
async def _encrypt_memo(self, to, memo): ''' 加密备注信息 ''' if not memo: return None # 生成nonce nonce = str(random.getrandbits(64)) if SysConfig().memo_key == None: raise MissingKeyError('Memo key {0} missing!'.format(SysConfig().account)) # 加密备注信息 prefix = self.client.chain_params['prefix'] to_account = await self.client.get_account_by_name(to) enc = BtsMemo.encode_memo( PrivateKey(SysConfig().memo_key, prefix=prefix), PublicKey( prefix=prefix, pk=to_account['options']['memo_key'] ), nonce, memo ) # 返回结构信息 memo_data = { 'nonce': nonce, 'message': enc, 'to': to_account['options']['memo_key'], 'from': self.account['options']['memo_key'] } return to_account['id'], memo_data
def compareConstructedTX(self): # def test_online(self): # self.maxDiff = None op = operations.Asset_reserve( **{ "fee": { "amount": 0, "asset_id": "1.3.0" }, "payer": "1.2.0", "amount_to_reserve": { "amount": 1234567890, "asset_id": "1.3.0" }, "extensions": [] }) ops = [Operation(op)] tx = Signed_Transaction(ref_block_num=ref_block_num, ref_block_prefix=ref_block_prefix, expiration=expiration, operations=ops) tx = tx.sign([wif], chain=prefix) tx.verify([PrivateKey(wif).pubkey], "BTS") txWire = hexlify(bytes(tx)).decode("ascii") print("=" * 80) pprint(tx.json()) print("=" * 80) from grapheneapi.grapheneapi import GrapheneAPI rpc = GrapheneAPI("localhost", 8092) compare = rpc.serialize_transaction(tx.json()) print(compare[:-130]) print(txWire[:-130]) print(txWire[:-130] == compare[:-130]) self.assertEqual(compare[:-130], txWire[:-130])
def test_override_transfer(self): s = { "fee": { "amount": 0, "asset_id": "1.3.0" }, "issuer": "1.2.29", "from": "1.2.104", "to": "1.2.29", "amount": { "amount": 100000, "asset_id": "1.3.105" }, "extensions": [] } op = operations.Override_transfer(**s) ops = [Operation(op)] tx = Signed_Transaction(ref_block_num=ref_block_num, ref_block_prefix=ref_block_prefix, expiration=expiration, operations=ops) tx = tx.sign([wif], chain=prefix) tx.verify([PrivateKey(wif).pubkey], "BTS") txWire = hexlify(bytes(tx)).decode("ascii") compare = ("f68585abf4dce7c8045701260000000000000000001d681da086" "01000000000069000000012030cc81722c3e67442d2f59deba18" "8f6079c8ba2d8318a642e6a70a125655515f20e2bd3adb2ea886" "cdbc7f6590c7f8c80818d9176d9085c176c736686ab6c9fd") self.assertEqual(compare[:-130], txWire[:-130])
async def append_signer(self, account, wifkey, prefix, permission): """ 添加签名 """ pubkey = PrivateKey(wifkey, prefix=prefix).pubkey required_treshold = account[permission]['weight_threshold'] async def fetchkeys(account, perm, level=0): r = [] if level > 2: return r for authority in account[perm]['key_auths']: if authority[0] == str(pubkey): r.append([wifkey, authority[1]]) if sum([x[1] for x in r]) < required_treshold: for authority in account[perm]['account_auths']: auth_account = await self.node_api.get_account_by_name(authority[0]) r.extend(fetchkeys(auth_account, perm, level + 1)) return r assert permission in ['active', 'owner'], 'Invalid permission' if account not in self.available_signers: keys = await fetchkeys(account, permission) if permission != 'owner': keys.extend(await fetchkeys(account, 'owner')) self.wifs.extend([x[0] for x in keys]) self.available_signers.append(account)
def compareConstructedTX(self): self.maxDiff = None self.op = operations.Committee_member_create(**{ "fee": { "amount": 0, "asset_id": "1.3.0" }, "committee_member_account": "1.2.0", "url": "foobar" }) ops = [Operation(self.op)] tx = Signed_Transaction( ref_block_num=ref_block_num, ref_block_prefix=ref_block_prefix, expiration=expiration, operations=ops ) tx = tx.sign([wif], chain=prefix) tx.verify([PrivateKey(wif).pubkey], prefix) txWire = hexlify(bytes(tx)).decode("ascii") print("=" * 80) pprint(tx.json()) print("=" * 80) from grapheneapi.grapheneapi import GrapheneAPI rpc = GrapheneAPI("localhost", 8092) self.cm = rpc.serialize_transaction(tx.json()) print("soll: %s" % self.cm[:-130]) print("ist: %s" % txWire[:-130]) print(txWire[:-130] == self.cm[:-130]) self.assertEqual(self.cm[:-130], txWire[:-130])
def validate_private_key(self, account, private_key): """ Check whether private key is associated with account :param str account: bitshares account name :param str private_key: private key """ wallet = self.bitshares.wallet if not private_key: # Check if the account is already in the database account_ids = wallet.getAccounts() accounts = [ Account(account_id, bitshares_instance=self.bitshares) for account_id in account_ids ] if any(account == account['name'] for account in accounts): return True return False try: pubkey = format( PrivateKey(private_key).pubkey, self.bitshares.prefix) except ValueError: return False # Load all accounts with corresponding public key from the blockchain account_ids = wallet.getAccountsFromPublicKey(pubkey) account_names = [ Account(account_id, bitshares_instance=self.bitshares).name for account_id in account_ids ] if account in account_names: return True else: return False
def compareConstructedTX(self): self.maxDiff = None self.op = operations.Custom( **{ "fee": { "amount": 0, "asset_id": "1.3.0" }, "payer": "1.2.0", "required_auths": ["1.2.100", "1.2.101"], "id": "35235", "data": hexlify(b"Foobar").decode("ascii") }) ops = [Operation(self.op)] tx = Signed_Transaction(ref_block_num=ref_block_num, ref_block_prefix=ref_block_prefix, expiration=expiration, operations=ops) tx = tx.sign([wif], chain=prefix) tx.verify([PrivateKey(wif).pubkey], prefix) txWire = hexlify(bytes(tx)).decode("ascii") print("=" * 80) pprint(tx.json()) print("=" * 80) # Test against Bitshares backened self.cm = bitshares.rpc.get_transaction_hex(tx.json()) print("soll: %s" % self.cm[:-130]) print("ist: %s" % txWire[:-130]) print(txWire[:-130] == self.cm[:-130]) self.assertEqual(self.cm[:-130], txWire[:-130])
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 try: memo_wif = self.blockchain.wallet.getPrivateKeyForPublicKey( memo["to"]) pubkey = memo["from"] except KeyNotFound: try: # if that failed, we assume that we have sent the memo memo_wif = self.blockchain.wallet.getPrivateKeyForPublicKey( memo["from"]) pubkey = memo["to"] except KeyNotFound: # if all fails, raise exception raise MissingKeyError( "Non of the required memo keys are installed!" "Need any of {}".format([memo["to"], memo["from"]])) if not hasattr(self, 'chain_prefix'): self.chain_prefix = self.blockchain.prefix return BtsMemo.decode_memo(PrivateKey(memo_wif), PublicKey(pubkey, prefix=self.chain_prefix), memo.get("nonce"), memo.get("message"))
def test_fee_pool(self): s = { "fee": { "amount": 10001, "asset_id": "1.3.0" }, "from_account": "1.2.282", "asset_id": "1.3.32", "amount": 15557238, "extensions": [] } op = operations.Asset_fund_fee_pool(**s) ops = [Operation(op)] tx = Signed_Transaction(ref_block_num=ref_block_num, ref_block_prefix=ref_block_prefix, expiration=expiration, operations=ops) tx = tx.sign([wif], chain=prefix) tx.verify([PrivateKey(wif).pubkey], "BTS") txWire = hexlify(bytes(tx)).decode("ascii") compare = ("f68585abf4dce7c8045701101127000000000000009a02207662" "ed00000000000000011f39f7dc7745076c9c7e612d40c68ee92d" "3f4b2696b1838037ce2a35ac259883ba6c6c49d91ad05a7e78d8" "0bb83482c273dbbc911587487bf468b85fb4f537da3d") self.assertEqual(compare[:-130], txWire[:-130])
def test_call_update(self): op = operations.Call_order_update( **{ 'fee': { 'amount': 100, 'asset_id': '1.3.0' }, 'delta_debt': { 'amount': 10000, 'asset_id': '1.3.22' }, 'delta_collateral': { 'amount': 100000000, 'asset_id': '1.3.0' }, 'funding_account': '1.2.29', 'extensions': [] }) ops = [Operation(op)] tx = Signed_Transaction(ref_block_num=ref_block_num, ref_block_prefix=ref_block_prefix, expiration=expiration, operations=ops) tx = tx.sign([wif], chain=prefix) tx.verify([PrivateKey(wif).pubkey], "BTS") txWire = hexlify(bytes(tx)).decode("ascii") compare = ("f68585abf4dce7c8045701036400000000000000001d00e1f" "50500000000001027000000000000160000011f2627efb5c5" "144440e06ff567f1a09928d699ac6f5122653cd7173362a1a" "e20205952c874ed14ccec050be1c86c1a300811763ef3b481" "e562e0933c09b40e31fb") self.assertEqual(compare[:-130], txWire[:-130])
def compareConstructedTX(self): self.maxDiff = None self.op = operations.Bid_collateral(**{ 'fee': {'amount': 100, 'asset_id': '1.3.0'}, 'additional_collateral': { 'amount': 10000, 'asset_id': '1.3.22'}, 'debt_covered': { 'amount': 100000000, 'asset_id': '1.3.0'}, 'bidder': '1.2.29', 'extensions': [] }) ops = [Operation(self.op)] tx = Signed_Transaction( ref_block_num=ref_block_num, ref_block_prefix=ref_block_prefix, expiration=expiration, operations=ops ) tx = tx.sign([wif], chain=prefix) tx.verify([PrivateKey(wif).pubkey], "BTS") txWire = hexlify(bytes(tx)).decode("ascii") print("=" * 80) pprint(tx.json()) print("=" * 80) from grapheneapi.grapheneapi import GrapheneAPI rpc = GrapheneAPI("localhost", 8092) self.cm = rpc.serialize_transaction(tx.json()) print("soll: %s" % self.cm[:-130]) print("ist: %s" % txWire[:-130]) print(txWire[:-130] == self.cm[:-130]) self.assertEqual(self.cm[:-130], txWire[:-130])
def test_worker_create(self): op = operations.Worker_create( **{ "fee": { "amount": 0, "asset_id": "1.3.0" }, "owner": "1.2.0", "work_begin_date": "1970-01-01T00:00:00", "work_end_date": "1970-01-01T00:00:00", "daily_pay": 0, "name": "Myname", "url": "myURL", "initializer": [1, { "pay_vesting_period_days": 125 }] }) ops = [Operation(op)] tx = Signed_Transaction(ref_block_num=ref_block_num, ref_block_prefix=ref_block_prefix, expiration=expiration, operations=ops) tx = tx.sign([wif], chain=prefix) tx.verify([PrivateKey(wif).pubkey], "BTS") txWire = hexlify(bytes(tx)).decode("ascii") compare = ("f68585abf4dce7c804570122000000000000000000000000000" "0000000000000000000000000064d796e616d65056d7955524c" "017d0000012049a1430c8045ce7e7a3c0882f537aa9d4547fca" "65a6c17967c5daf47aad383175e9f95d0187398da8b8f5b4c78" "561f4427b0fc8758e4a3a92afab9388f849f5a") self.assertEqual(compare[:-130], txWire[:-130])
def doit(self, printWire=False): ops = [Operation(self.op)] tx = Signed_Transaction( ref_block_num=ref_block_num, ref_block_prefix=ref_block_prefix, expiration=expiration, operations=ops, ) pprint(tx.json()) tx = tx.sign([wif], chain=prefix) tx.verify([PrivateKey(wif).pubkey], prefix) txWire = hexlify(bytes(tx)).decode("ascii") if printWire: print() print(txWire) print() # Test against Bitshares backened live = bitshares.rpc.get_transaction_hex(tx.json()) # Compare expected result with online backend self.assertEqual(live[:-130], self.cm[:-130]) # Compare expected result with online result self.assertEqual(live[:-130], txWire[:-130]) # Compare expected result with test unit self.assertEqual(self.cm[:-130], txWire[:-130])
def test_feed_producer_update(self): op = operations.Asset_update_feed_producers( **{ "fee": { "amount": 0, "asset_id": "1.3.0" }, "issuer": "1.2.214", "asset_to_update": "1.3.132", "new_feed_producers": ["1.2.214", "1.2.341", "1.2.2414"], "extensions": [] }) ops = [Operation(op)] tx = Signed_Transaction(ref_block_num=ref_block_num, ref_block_prefix=ref_block_prefix, expiration=expiration, operations=ops) tx = tx.sign([wif], chain=prefix) tx.verify([PrivateKey(wif).pubkey], "BTS") txWire = hexlify(bytes(tx)).decode("ascii") compare = ("f68585abf4dce7c80457010d000000000000000000d60184010" "3d601d502ee120000011f34dc3aafe350f3f8608cc3d0db3b64" "a8f40b60d3528c9fa9e88fc3185fc27f4922ef5612f657205ad" "6fc6fed68ec78c4776e1fd125278ab03c8477b37e4c569a") self.assertEqual(compare[:-130], txWire[:-130])
def test_asset_reserve(self): op = operations.Asset_reserve( **{ "fee": { "amount": 0, "asset_id": "1.3.0" }, "payer": "1.2.0", "amount_to_reserve": { "amount": 1234567890, "asset_id": "1.3.0" }, "extensions": [] }) ops = [Operation(op)] tx = Signed_Transaction(ref_block_num=ref_block_num, ref_block_prefix=ref_block_prefix, expiration=expiration, operations=ops) tx = tx.sign([wif], chain=prefix) tx.verify([PrivateKey(wif).pubkey], "BTS") txWire = hexlify(bytes(tx)).decode("ascii") compare = ("f68585abf4dce7c80457010f00000000000000000000d202964" "900000000000000011f75065cb1155bfcaabaf55d3357d69679" "c7c1fe589b6dc0919fe1dde1a305009c360823a40c28907299a" "40c241db9cad86e27369d0e5a76b5832d585505ff177d") self.assertEqual(compare[:-130], txWire[:-130])
def test_witness_update(self): op = operations.Witness_update( **{ "fee": { "amount": 0, "asset_id": "1.3.0" }, "prefix": "TEST", "witness": "1.6.63", "witness_account": "1.2.212", "new_url": "https://example.com", "new_signing_key": "BTS5vfCLKyXYb44znYjbrJXCyvvx3SuifhmvemnQsdbf61EtoR36z" }) ops = [Operation(op)] tx = Signed_Transaction(ref_block_num=ref_block_num, ref_block_prefix=ref_block_prefix, expiration=expiration, operations=ops) tx = tx.sign([wif], chain=prefix) tx.verify([PrivateKey(wif).pubkey], "BTS") txWire = hexlify(bytes(tx)).decode("ascii") compare = ("f68585abf4dce7c8045701150000000000000000003fd401011" "368747470733a2f2f6578616d706c652e636f6d0102889f66e3" "584423e86b615e3b07593ebec4b1ac0e08ad4a3748f0726dae7" "c874f0001205628a49ef823ab54f4b4c56304f5ac57bdc3768c" "62ac630a92de9858f5d90fad01c43bdc406293edad734d53dca" "a1c96546a50e3ec96d07cf1224ed329177af5") self.assertEqual(compare[:-130], txWire[:-130])
def test_vesting_withdraw(self): op = operations.Vesting_balance_withdraw( **{ "fee": { "amount": 0, "asset_id": "1.3.0" }, "vesting_balance": "1.13.0", "owner": "1.2.0", "amount": { "amount": 0, "asset_id": "1.3.0" }, "prefix": "TEST" }) ops = [Operation(op)] tx = transactions.Signed_Transaction(ref_block_num=ref_block_num, ref_block_prefix=ref_block_prefix, expiration=expiration, operations=ops) tx = tx.sign([wif], chain=prefix) tx.verify([PrivateKey(wif).pubkey], "BTS") txWire = hexlify(bytes(tx)).decode("ascii") compare = ("f68585abf4dce7c80457012100000000000000000000" "0000000000000000000000011f07ae9b0d1cb494e248" "6b99cccdf78ef8b785522af8f2233de364d4455c0626" "935d2d32414a2f7a6b9cdf3451730062965adeec8aa2" "03fca97f608411dce84309") self.assertEqual(compare[:-130], txWire[:-130])
def test_whitelist(self): op = operations.Account_whitelist( **{ "fee": { "amount": 0, "asset_id": "1.3.0" }, "authorizing_account": "1.2.0", "account_to_list": "1.2.1", "new_listing": 0x1, "extensions": [] }) ops = [Operation(op)] tx = transactions.Signed_Transaction(ref_block_num=ref_block_num, ref_block_prefix=ref_block_prefix, expiration=expiration, operations=ops) tx = tx.sign([wif], chain=prefix) tx.verify([PrivateKey(wif).pubkey], "BTS") txWire = hexlify(bytes(tx)).decode("ascii") compare = ("f68585abf4dce7c8045701070000000000000000000001010" "000011f14eef2978e40b369273907072dddf4b4043d9f3a08" "da125311c4e6b54b3e7c2a3606594fab7cf6ce381544eceda" "9945c8c9fccebd587cfa2d2f6a146b1639f8c") self.assertEqual(compare[:-130], txWire[:-130])
def test_limit_order_create(self): op = operations.Limit_order_create( **{ "fee": { "amount": 100, "asset_id": "1.3.0" }, "seller": "1.2.29", "amount_to_sell": { "amount": 100000, "asset_id": "1.3.0" }, "min_to_receive": { "amount": 10000, "asset_id": "1.3.105" }, "expiration": "2016-05-18T09:22:05", "fill_or_kill": False, "extensions": [] }) ops = [Operation(op)] tx = Signed_Transaction(ref_block_num=ref_block_num, ref_block_prefix=ref_block_prefix, expiration=expiration, operations=ops) tx = tx.sign([wif], chain=prefix) tx.verify([PrivateKey(wif).pubkey], "BTS") txWire = hexlify(bytes(tx)).decode("ascii") compare = ("f68585abf4dce7c8045701016400000000000000001da08601000" "0000000001027000000000000693d343c57000000011f75cbfd49" "ae8d9b04af76cc0a7de8b6e30b71167db7fe8e2197ef9d858df18" "77043493bc24ffdaaffe592357831c978fd8a296b913979f106de" "be940d60d77b50") self.assertEqual(compare[:-130], txWire[:-130])
def test_update_account(self): op = operations.Account_update( **{ "fee": { "amount": 1467634, "asset_id": "1.3.0" }, "account": "1.2.15", "owner": { "weight_threshold": 1, "account_auths": [["1.2.96086", 1]], 'key_auths': [[ 'BTS6pbVDAjRFiw6fkiKYCrkz7PFeL7XNAfefrsREwg8MKpJ9VYV9x', 1 ]], "address_auths": [] }, "active": { "weight_threshold": 1, "account_auths": [["1.2.96086", 1]], 'key_auths': [[ 'BTS8CemMDjdUWSV5wKotEimhK6c4dY7p2PdzC2qM1HpAP8aLtZfE7', 1 ]], "address_auths": [] }, "new_options": { "memo_key": "BTS5TPTziKkLexhVKsQKtSpo4bAv5RnB8oXcG4sMHEwCcTf3r7dqE", "voting_account": "1.2.5", "num_witness": 0, "num_committee": 0, "votes": [], "extensions": [] }, "extensions": {} }) ops = [Operation(op)] tx = Signed_Transaction(ref_block_num=ref_block_num, ref_block_prefix=ref_block_prefix, expiration=expiration, operations=ops) tx = tx.sign([wif], chain=prefix) tx.verify([PrivateKey(wif).pubkey], "BTS") txWire = hexlify(bytes(tx)).decode("ascii") compare = ("f68585abf4dce7c804570106f264160000000000000" "f010100000001d6ee0501000102fe8cc11cc8251de6" "977636b55c1ab8a9d12b0b26154ac78e56e7c4257d8" "bcf69010000010100000001d6ee0501000103b453f4" "6013fdbccb90b09ba169c388c34d84454a3b9fbec68" "d5a7819a734fca001000001024ab336b4b14ba6d881" "675d1c782912783c43dbbe31693aa710ac1896bd7c3" "d61050000000000000000011f78b989df5ab29697a3" "311f8d7fa8599c548a93809e173ab550b7d8c5051fa" "432699d8e24ea82399990c43528ddaf2b3cd8cd2500" "1c91f8094d66ae2620effc25") self.assertEqual(compare[:-130], txWire[:-130])
def appendWif(self, wif): """ Add a wif that should be used for signing of the transaction. """ if wif: try: PrivateKey(wif) self.wifs.append(wif) except: raise InvalidWifError
def test_decrypt_bugged_padding(self): for memo in not_enough_padding: dec = decode_memo( PrivateKey(memo["wif"]), PublicKey(memo["to"], prefix="GPH"), memo["nonce"], memo["message"], ) self.assertEqual(memo["plain"], dec)
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)