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 constructTx(self): """ Construct the actual transaction and store it in the class's dict store """ if self.bitshares.proposer: ops = [operations.Op_wrapper(op=o) for o in list(self.ops)] proposer = Account(self.bitshares.proposer, bitshares_instance=self.bitshares) ops = operations.Proposal_create( **{ "fee": { "amount": 0, "asset_id": "1.3.0" }, "fee_paying_account": proposer["id"], "expiration_time": transactions.formatTimeFromNow( self.bitshares.proposal_expiration), "proposed_ops": [o.json() for o in ops], "extensions": [] }) ops = [Operation(ops)] else: ops = [Operation(o) for o in list(self.ops)] ops = transactions.addRequiredFees(self.bitshares.rpc, ops) expiration = transactions.formatTimeFromNow(self.bitshares.expiration) ref_block_num, ref_block_prefix = transactions.getBlockParams( self.bitshares.rpc) tx = Signed_Transaction(ref_block_num=ref_block_num, ref_block_prefix=ref_block_prefix, expiration=expiration, operations=ops) super(TransactionBuilder, self).__init__(tx.json())
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_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 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 constructTx(self): """ Construct the actual transaction and store it in the class's dict store """ ops = list() for op in self.ops: if isinstance(op, ProposalBuilder): # This operation is a proposal an needs to be deal with # differently proposals = op.get_raw() if proposals: ops.append(proposals) else: # otherwise, we simply wrap ops into Operations ops.extend([Operation(op)]) # We no wrap everything into an actual transaction ops = transactions.addRequiredFees(self.bitshares.rpc, ops) expiration = transactions.formatTimeFromNow(self.bitshares.expiration) ref_block_num, ref_block_prefix = transactions.getBlockParams( self.bitshares.rpc) self.tx = Signed_Transaction(ref_block_num=ref_block_num, ref_block_prefix=ref_block_prefix, expiration=expiration, operations=ops) super(TransactionBuilder, self).__init__(self.tx.json()) self._unset_require_reconstruction()
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 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_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])
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 test_asset_update(self): op = operations.Asset_update( **{ "fee": { "amount": 0, "asset_id": "1.3.0" }, "issuer": "1.2.0", "asset_to_update": "1.3.0", "new_options": { "max_supply": "1000000000000000", "market_fee_percent": 0, "max_market_fee": "1000000000000000", "issuer_permissions": 79, "flags": 0, "core_exchange_rate": { "base": { "amount": 0, "asset_id": "1.3.0" }, "quote": { "amount": 0, "asset_id": "1.3.0" } }, "whitelist_authorities": ["1.2.12", "1.2.13"], "blacklist_authorities": ["1.2.10", "1.2.11"], "whitelist_markets": ["1.3.10", "1.3.11"], "blacklist_markets": ["1.3.12", "1.3.13"], "description": "Foobar", "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 = ("f68585abf4dce7c80457010b00000000000000000000000000" "80c6a47e8d030000000080c6a47e8d03004f00000000000000" "0000000000000000000000000000020c0d020a0b020a0b020c" "0d06466f6f626172000000011f5bd6a206d210d1d78eb423e0" "c2362013aa80830a8e61e5df2570eac05f1c57a4165c99099f" "c2e97ecbf2b46014c96a6f99cff8d20f55a6042929136055e5" "ad10") self.assertEqual(compare[:-130], txWire[:-130])
async def __construct_tx(self, fee_asset_id, expiration): """ 构造转账操作 """ ops = [Operation(o) for o in list(self.ops)] expiration = transactions.formatTimeFromNow(expiration) ops = await transactions.add_required_fees(self.node_api, ops, fee_asset_id) ref_block_num, ref_block_prefix = await transactions.get_block_params(self.node_api) tx = Signed_Transaction( ref_block_num=ref_block_num, ref_block_prefix=ref_block_prefix, expiration=expiration, operations=ops ) super(Builder, self).__init__(tx.json())
def test_Transfer(self): pub = format(account.PrivateKey(wif).pubkey, prefix) from_account_id = "1.2.0" to_account_id = "1.2.1" amount = 1000000 asset_id = "1.3.4" message = "abcdefgABCDEFG0123456789" nonce = "5862723643998573708" fee = objects.Asset(amount=0, asset_id="1.3.0") amount = objects.Asset(amount=int(amount), asset_id=asset_id) encrypted_memo = memo.encode_memo( account.PrivateKey(wif), account.PublicKey(pub, prefix=prefix), nonce, message) memoStruct = { "from": pub, "to": pub, "nonce": nonce, "message": encrypted_memo, "chain": prefix } memoObj = objects.Memo(**memoStruct) op = operations.Transfer( **{ "fee": fee, "from": from_account_id, "to": to_account_id, "amount": amount, "memo": memoObj }) 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 = ("f68585abf4dce7c804570100000000000000000000000140420" "f0000000000040102c0ded2bc1f1305fb0faac5e6c03ee3a192" "4234985427b6167ca569d13df435cf02c0ded2bc1f1305fb0fa" "ac5e6c03ee3a1924234985427b6167ca569d13df435cf8c94d1" "9817945c5120fa5b6e83079a878e499e2e52a76a7739e9de409" "86a8e3bd8a68ce316cee50b210000011f39e3fa7071b795491e" "3b6851d61e7c959be92cc7deb5d8491cf1c3c8c99a1eb44553c" "348fb8f5001a78b18233ac66727e32fc776d48e92d9639d64f6" "8e641948") self.assertEqual(compare[:-130], txWire[:-130])
async def sign(self, fee_asset_id, expiration=30): """ 执行签名 """ await self.__construct_tx(fee_asset_id, expiration) operations.default_prefix = self.node_api.chain_params['prefix'] try: signedtx = Signed_Transaction(**self.json()) except: raise ValueError('Invalid TransactionBuilder Format') if not any(self.wifs): raise MissingKeyError signedtx.sign(self.wifs, chain=self.node_api.chain_params) self['signatures'].extend(signedtx.json().get('signatures'))
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 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 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 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 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 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])
async def _get_transaction_id(self, transaction): ''' 获取交易ID ''' try: tx = Signed_Transaction(**transaction) return tx.id except Exception as e: logging.warn('Failed to get transaction id, %s', str(e)) return None
def test_create_proposal(self): op = operations.Proposal_create( **{ "fee": { "amount": 0, "asset_id": "1.3.0" }, "fee_paying_account": "1.2.0", "expiration_time": "1970-01-01T00:00:00", "proposed_ops": [{ "op": [ 0, { "fee": { "amount": 0, "asset_id": "1.3.0" }, "from": "1.2.0", "to": "1.2.0", "amount": { "amount": 0, "asset_id": "1.3.0" }, "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 = ("f68585abf4dce7c80457011600000000000000000000000000" "00010000000000000000000000000000000000000000000000" "00000001204baf7f11a7ff12337fc097ac6e82e7b68f82f02c" "c7e24231637c88a91ae5716674acec8a1a305073165c65e520" "a64769f5f62c0301ce21ab4f7c67a6801b4266") self.assertEqual(compare[:-130], txWire[:-130])
def getSerializedTxBytes(tx_json): tx = json.loads(tx_json) # from json to dict st = Signed_Transaction( ref_block_num = tx['ref_block_num'], ref_block_prefix = tx['ref_block_prefix'], expiration = tx['expiration'], operations = tx['operations'], ) serialized = encodeTlvTx(binascii.unhexlify(blockchain.rpc.chain_params['chain_id']), st) return serialized
def sign(self): """ Sign a provided transaction with the provided key(s) :param dict tx: The transaction to be signed and returned :param string wifs: One or many wif keys to use for signing a transaction. If not present, the keys will be loaded from the wallet as defined in "missing_signatures" key of the transactions. """ self.constructTx() if "operations" not in self or not self["operations"]: return # Legacy compatibility! # If we are doing a proposal, obtain the account from the proposer_id if self.blockchain.proposer: proposer = Account(self.blockchain.proposer, blockchain_instance=self.blockchain) self.wifs = set() self.signing_accounts = list() self.appendSigner(proposer["id"], "active") # We need to set the default prefix, otherwise pubkeys are # presented wrongly! if self.blockchain.rpc: operations.default_prefix = ( self.blockchain.rpc.chain_params["prefix"]) elif "blockchain" in self: operations.default_prefix = self["blockchain"]["prefix"] try: signedtx = Signed_Transaction(**self.json()) except: raise ValueError("Invalid TransactionBuilder Format") if not any(self.wifs): raise MissingKeyError signedtx.sign(self.wifs, chain=self.blockchain.rpc.chain_params) self["signatures"].extend(signedtx.json().get("signatures")) return signedtx
def get_tx_id(transaction): """ This method is used as a *getter* that is handed over as lambda function so we don't need to derive transaction ids for every transaction but instead only obtain the transaction id on those transactions that contain operations that we are interested in. """ if self.bitshares.prefix != "BTS": transaction["operations"][0][1].update({"prefix": self.bitshares.prefix}) tx = Signed_Transaction(**transaction) return tx.id
def test_proposal_update(self): op = operations.Proposal_update( **{ 'fee_paying_account': "1.2.1", 'proposal': "1.10.90", 'active_approvals_to_add': ["1.2.5"], "fee": objects.Asset(amount=12512, asset_id="1.3.0"), }) 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 = ("f68585abf4dce7c804570117e03000000000000000015a01050000000" "000000001203255378db6dc19443e74421c954ad7fdcf23f4ea45fe4f" "e5a1b078a0f94fb529594819c9799d68efa5cfb5b271a9333a2f516ca" "4fb5093226275f48a42d9e8cf") self.assertEqual(compare[:-130], txWire[:-130])
def test_pricefeed(self): feed = objects.PriceFeed( **{ "settlement_price": objects.Price( base=objects.Asset(amount=214211, asset_id="1.3.0"), quote=objects.Asset(amount=1241, asset_id="1.3.14"), ), "core_exchange_rate": objects.Price( base=objects.Asset(amount=1241, asset_id="1.3.0"), quote=objects.Asset(amount=6231, asset_id="1.3.14"), ), "maximum_short_squeeze_ratio": 1100, "maintenance_collateral_ratio": 1750, }) op = operations.Asset_publish_feed(fee=objects.Asset(amount=100, asset_id="1.3.0"), publisher="1.2.0", asset_id="1.3.3", feed=feed) 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 = ("f68585abf4dce7c8045701136400000000000000000003c344030" "00000000000d9040000000000000ed6064c04d904000000000000" "0057180000000000000e0000012009e13f9066fedc3c8c1eb2ac3" "3b15dc67ecebf708890d0f8ab62ec8283d1636002315a189f1f5a" "a8497b41b8e6bb7c4dc66044510fae25d8f6aebb02c7cdef10") self.assertEqual(compare[:-130], txWire[:-130])
async def get_tx_hash_from_op(op: dict, cfg: Config = None) -> str: cfg = Config() if not cfg else cfg op_block = await Block(op["block_num"]) related_txs = [] for tx in op_block["transactions"]: if len(tx["operations"]) > 1: continue # Gateway newer broadcast more than one operation in one transaction. # At least, not in this implementation for op_in_tx in tx["operations"]: if op_in_tx[0] != 0: continue if op["op"][1]["amount"]["amount"] != op_in_tx[1]["amount"][ "amount"]: continue if op["op"][1]["amount"]["asset_id"] != op_in_tx[1]["amount"][ "asset_id"]: continue if op["op"][1]["from"] != op_in_tx[1]["from"]: continue if op["op"][1]["to"] != op_in_tx[1]["to"]: continue # TODO memo compare """this is prevent bug in python-bitshares when Block['transaction'] from testnet returning with mainnet prefix "BTS"(should be "TEST") """ tx["operations"][0][1]["prefix"] = cfg.core_asset related_txs.append(Signed_Transaction(tx).id) if len(related_txs) == 1: return related_txs[0] # Can not find transaction with op elif len(related_txs) == 0: raise TransactionNotFound( message= f"Op {op['id']}: unable to find transaction that contains such operations in block {op['block_num']}" ) else: raise OperationsCollision( message= f"Op {op['id']}: during confirm found {len(related_txs)} transactions: {[i for i in related_txs]}" )
def test_limit_order_cancel(self): op = operations.Limit_order_cancel( **{ "fee": { "amount": 0, "asset_id": "1.3.0" }, "fee_paying_account": "1.2.104", "order": "1.7.51840", "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 = ("f68585abf4dce7c8045701020000000000000000006880950300000" "11f3fb754814f3910c1a8845486b86057d2b4588ae559b4c3810828" "c0d4cbec0e5b23517937cd7e0cc5ee8999d0777af7fe56d3c4b2e58" "7421bfb7400d4efdae97a") self.assertEqual(compare[:-130], txWire[:-130])