def decode_transaction_raw(transaction_raw): """ Decode Bitcoin transaction raw. :param transaction_raw: Bitcoin transaction raw. :type transaction_raw: str :returns: dict -- decoded Bitcoin transaction. >>> from swap.providers.bitcoin.utils import decode_transaction_raw >>> transaction_raw = "eyJmZWUiOiA2NzgsICJyYXciOiAiMDIwMDAwMDAwMTg4OGJlN2VjMDY1MDk3ZDk1NjY0NzYzZjI3NmQ0MjU1NTJkNzM1ZmIxZDk3NGFlNzhiZjcyMTA2ZGNhMGYzOTEwMTAwMDAwMDAwZmZmZmZmZmYwMjEwMjcwMDAwMDAwMDAwMDAxN2E5MTQyYmIwMTNjM2U0YmViMDg0MjFkZWRjZjgxNWNiNjVhNWMzODgxNzhiODdiY2RkMGUwMDAwMDAwMDAwMTk3NmE5MTQ2NGE4MzkwYjBiMTY4NWZjYmYyZDRiNDU3MTE4ZGM4ZGE5MmQ1NTM0ODhhYzAwMDAwMDAwIiwgIm91dHB1dHMiOiBbeyJhbW91bnQiOiA5ODQ5NDYsICJuIjogMSwgInNjcmlwdCI6ICI3NmE5MTQ2NGE4MzkwYjBiMTY4NWZjYmYyZDRiNDU3MTE4ZGM4ZGE5MmQ1NTM0ODhhYyJ9XSwgIm5ldHdvcmsiOiAidGVzdG5ldCIsICJ0eXBlIjogImJpdGNvaW5fZnVuZF91bnNpZ25lZCJ9" >>> decode_transaction_raw(transaction_raw) {'fee': 678, 'type': 'bitcoin_fund_unsigned', 'tx': {'hex': '0200000001888be7ec065097d95664763f276d425552d735fb1d974ae78bf72106dca0f3910100000000ffffffff02102700000000000017a9142bb013c3e4beb08421dedcf815cb65a5c388178b87bcdd0e00000000001976a91464a8390b0b1685fcbf2d4b457118dc8da92d553488ac00000000', 'txid': 'abc70fd3466aec9478ea3115200a84f993204ad1f614fe08e92ecc5997a0d3ba', 'hash': 'abc70fd3466aec9478ea3115200a84f993204ad1f614fe08e92ecc5997a0d3ba', 'size': 117, 'vsize': 117, 'version': 2, 'locktime': 0, 'vin': [{'txid': '91f3a0dc0621f78be74a971dfb35d75255426d273f766456d9975006ece78b88', 'vout': 1, 'scriptSig': {'asm': '', 'hex': ''}, 'sequence': '4294967295'}], 'vout': [{'value': '0.00010000', 'n': 0, 'scriptPubKey': {'asm': 'OP_HASH160 2bb013c3e4beb08421dedcf815cb65a5c388178b OP_EQUAL', 'hex': 'a9142bb013c3e4beb08421dedcf815cb65a5c388178b87', 'type': 'p2sh', 'address': '2MwEDybGC34949zgzWX4M9FHmE3crDSUydP'}}, {'value': '0.00974268', 'n': 1, 'scriptPubKey': {'asm': 'OP_DUP OP_HASH160 64a8390b0b1685fcbf2d4b457118dc8da92d5534 OP_EQUALVERIFY OP_CHECKSIG', 'hex': '76a91464a8390b0b1685fcbf2d4b457118dc8da92d553488ac', 'type': 'p2pkh', 'address': 'mphBPZf15cRFcL5tUq6mCbE84XobZ1vg7Q'}}]}, 'network': 'testnet'} """ transaction_raw = str(transaction_raw + "=" * (-len(transaction_raw) % 4)) try: decoded_transaction_raw = json.loads( b64decode(str(transaction_raw).encode()).decode()) except (binascii.Error, json.decoder.JSONDecodeError) as _error: raise ValueError("invalid Bitcoin transaction raw") if "type" not in decoded_transaction_raw or not str( decoded_transaction_raw["type"]).startswith("bitcoin"): raise ValueError("invalid Bitcoin transaction raw") # Setting testnet stp(decoded_transaction_raw["network"], strict=True) tx = MutableTransaction.unhexlify(decoded_transaction_raw["raw"]) return dict(fee=decoded_transaction_raw["fee"], type=decoded_transaction_raw["type"], tx=tx.to_json(), network=decoded_transaction_raw["network"])
def decode_transaction_raw(transaction_raw): """ Decode Bitcoin transaction raw. :param transaction_raw: Bitcoin transaction raw. :type transaction_raw: str :returns: dict -- decoded Bitcoin transaction. >>> from shuttle.providers.bitcoin.utils import decode_transaction_raw >>> decode_transaction_raw(transaction_raw) {...} """ transaction_raw = str(transaction_raw + "=" * (-len(transaction_raw) % 4)) try: decoded_transaction_raw = json.loads(b64decode(str(transaction_raw).encode()).decode()) except (binascii.Error, json.decoder.JSONDecodeError) as _error: raise ValueError("invalid Bitcoin transaction raw") if "type" not in decoded_transaction_raw or not str(decoded_transaction_raw["type"]).startswith("bitcoin"): raise ValueError("invalid Bitcoin transaction raw") # Setting testnet stp(decoded_transaction_raw["network"], strict=True) tx = MutableTransaction.unhexlify(decoded_transaction_raw["raw"]) return dict( fee=decoded_transaction_raw["fee"], type=decoded_transaction_raw["type"], tx=tx.to_json(), network=decoded_transaction_raw["network"] )
def decode_transaction_raw(transaction_raw: str, offline: bool = True, headers: dict = config["headers"], timeout: int = config["timeout"]) -> dict: """ Decode Bitcoin transaction raw. :param transaction_raw: Bitcoin transaction raw. :type transaction_raw: str :param offline: Offline decode, defaults to True. :type offline: bool :param headers: Request headers, default to common headers. :type headers: dict :param timeout: Request timeout, default to 60. :type timeout: int :returns: dict -- Decoded Bitcoin transaction raw. >>> from swap.providers.bitcoin.utils import decode_transaction_raw >>> transaction_raw = "eyJmZWUiOiA2NzgsICJyYXciOiAiMDIwMDAwMDAwMTg4OGJlN2VjMDY1MDk3ZDk1NjY0NzYzZjI3NmQ0MjU1NTJkNzM1ZmIxZDk3NGFlNzhiZjcyMTA2ZGNhMGYzOTEwMTAwMDAwMDAwZmZmZmZmZmYwMjEwMjcwMDAwMDAwMDAwMDAxN2E5MTQyYmIwMTNjM2U0YmViMDg0MjFkZWRjZjgxNWNiNjVhNWMzODgxNzhiODdiY2RkMGUwMDAwMDAwMDAwMTk3NmE5MTQ2NGE4MzkwYjBiMTY4NWZjYmYyZDRiNDU3MTE4ZGM4ZGE5MmQ1NTM0ODhhYzAwMDAwMDAwIiwgIm91dHB1dHMiOiBbeyJhbW91bnQiOiA5ODQ5NDYsICJuIjogMSwgInNjcmlwdCI6ICI3NmE5MTQ2NGE4MzkwYjBiMTY4NWZjYmYyZDRiNDU3MTE4ZGM4ZGE5MmQ1NTM0ODhhYyJ9XSwgIm5ldHdvcmsiOiAidGVzdG5ldCIsICJ0eXBlIjogImJpdGNvaW5fZnVuZF91bnNpZ25lZCJ9" >>> decode_transaction_raw(transaction_raw=transaction_raw) {'fee': 678, 'type': 'bitcoin_fund_unsigned', 'tx': {'hex': '0200000001888be7ec065097d95664763f276d425552d735fb1d974ae78bf72106dca0f3910100000000ffffffff02102700000000000017a9142bb013c3e4beb08421dedcf815cb65a5c388178b87bcdd0e00000000001976a91464a8390b0b1685fcbf2d4b457118dc8da92d553488ac00000000', 'txid': 'abc70fd3466aec9478ea3115200a84f993204ad1f614fe08e92ecc5997a0d3ba', 'hash': 'abc70fd3466aec9478ea3115200a84f993204ad1f614fe08e92ecc5997a0d3ba', 'size': 117, 'vsize': 117, 'version': 2, 'locktime': 0, 'vin': [{'txid': '91f3a0dc0621f78be74a971dfb35d75255426d273f766456d9975006ece78b88', 'vout': 1, 'scriptSig': {'asm': '', 'hex': ''}, 'sequence': '4294967295'}], 'vout': [{'value': '0.00010000', 'n': 0, 'scriptPubKey': {'asm': 'OP_HASH160 2bb013c3e4beb08421dedcf815cb65a5c388178b OP_EQUAL', 'hex': 'a9142bb013c3e4beb08421dedcf815cb65a5c388178b87', 'type': 'p2sh', 'address': '2MwEDybGC34949zgzWX4M9FHmE3crDSUydP'}}, {'value': '0.00974268', 'n': 1, 'scriptPubKey': {'asm': 'OP_DUP OP_HASH160 64a8390b0b1685fcbf2d4b457118dc8da92d5534 OP_EQUALVERIFY OP_CHECKSIG', 'hex': '76a91464a8390b0b1685fcbf2d4b457118dc8da92d553488ac', 'type': 'p2pkh', 'address': 'mphBPZf15cRFcL5tUq6mCbE84XobZ1vg7Q'}}]}, 'network': 'testnet'} """ if not is_transaction_raw(transaction_raw=transaction_raw): raise TransactionRawError("Invalid Bitcoin transaction raw.") transaction_raw = clean_transaction_raw(transaction_raw) decoded_transaction_raw = b64decode(transaction_raw.encode()) loaded_transaction_raw = json.loads(decoded_transaction_raw.decode()) decoded_transaction: Optional[dict] = None if offline: stp(loaded_transaction_raw["network"], strict=True, force=True) tx = MutableTransaction.unhexlify(loaded_transaction_raw["raw"]) decoded_transaction = tx.to_json() else: url = f"{config[loaded_transaction_raw['network']]['blockcypher']['url']}/txs/decode" parameter = dict(token=config[loaded_transaction_raw["network"]] ["blockcypher"]["token"]) data = dict(tx=loaded_transaction_raw["raw"]) response = requests.post(url=url, data=json.dumps(data), params=parameter, headers=headers, timeout=timeout) decoded_transaction = response.json() return dict(fee=loaded_transaction_raw["fee"], type=loaded_transaction_raw["type"], tx=decoded_transaction, network=loaded_transaction_raw["network"])
def sign(self, unsigned_raw, solver): """ Sign unsigned refund transaction raw. :param unsigned_raw: bitcoin unsigned refund transaction raw. :type unsigned_raw: str :param solver: bitcoin refund solver. :type solver: bitcoin.solver.RefundSolver :returns: RefundSignature -- bitcoin refund signature instance. >>> from shuttle.providers.bitcoin.signature import RefundSignature >>> refund_signature = RefundSignature() >>> refund_signature.sign(bitcoin_refund_unsigned, refund_solver) <shuttle.providers.bitcoin.signature.RefundSignature object at 0x0409DAF0> """ tx_raw = json.loads(b64decode(str(unsigned_raw).encode()).decode()) if "raw" not in tx_raw or "outputs" not in tx_raw or "type" not in tx_raw or \ "recipient_address" not in tx_raw or "sender_address" not in tx_raw or "fee" not in tx_raw: raise ValueError("invalid unsigned refund transaction raw") self.fee = tx_raw["fee"] self.type = tx_raw["type"] if not self.type == "bitcoin_refund_unsigned": raise TypeError("can't sign this %s transaction using RefundSignature" % tx_raw["type"]) if not isinstance(solver, RefundSolver): raise Exception("invalid solver error, only refund solver") htlc = HTLC(network=self.network).init( secret_hash=sha256(solver.secret).hex(), recipient_address=tx_raw["recipient_address"], sender_address=tx_raw["sender_address"], sequence=solver.sequence ) output = TxOut(value=tx_raw["outputs"][0]["amount"], n=tx_raw["outputs"][0]["n"], script_pubkey=P2shScript.unhexlify(tx_raw["outputs"][0]["script"])) self.transaction = MutableTransaction.unhexlify(tx_raw["raw"]) self.transaction.spend([output], [ P2shSolver(htlc.script, solver.solve()) ]) self.signed = b64encode(str(json.dumps(dict( raw=self.transaction.hexlify(), fee=tx_raw["fee"], network=tx_raw["network"], type="bitcoin_refund_signed" ))).encode()).decode() return self
def decode_raw(raw: str, network: str = config["network"], offline: bool = True, headers: dict = config["headers"], timeout: int = config["timeout"]) -> dict: """ Decode original Bitcoin raw. :param raw: Bitcoin transaction raw. :type raw: str :param network: Bitcoin network, defaults to mainnet. :type network: str :param offline: Offline decode, defaults to True. :type offline: bool :param headers: Request headers, default to common headers. :type headers: dict :param timeout: Request timeout, default to 60. :type timeout: int :returns: dict -- Bitcoin decoded transaction raw. >>> from swap.providers.bitcoin.rpc import decode_raw >>> decode_raw(raw="02000000011823f39a8c5f6f27845dd13a65e03fe2ef5108d235e7a36edb6eb267b0459c5a010000006a47304402207018b7fd1ba6624fe9bb0f16cd65fa243d202e32fdff452699f56465b61ab648022009f0dc1a0a63109246c45e120fc0d34b40e789dfc4d05e64f269602c7d67d9210121027f0dc0894bd690635412af782d05e4f79d3d40bf568978c650f3f1ca1a96cf36ffffffff02102700000000000017a9149418feed4647e156d6663db3e0cef7c050d038678734330100000000001976a91433ecab3d67f0e2bde43e52f41ec1ecbdc73f11f888ac00000000", network="testnet") {'hex': '02000000011823f39a8c5f6f27845dd13a65e03fe2ef5108d235e7a36edb6eb267b0459c5a010000006a47304402207018b7fd1ba6624fe9bb0f16cd65fa243d202e32fdff452699f56465b61ab648022009f0dc1a0a63109246c45e120fc0d34b40e789dfc4d05e64f269602c7d67d9210121027f0dc0894bd690635412af782d05e4f79d3d40bf568978c650f3f1ca1a96cf36ffffffff02102700000000000017a9149418feed4647e156d6663db3e0cef7c050d038678734330100000000001976a91433ecab3d67f0e2bde43e52f41ec1ecbdc73f11f888ac00000000', 'txid': '6e5c80f600f45acda3c3101128bb3075bf2cf7af4bab0d99c9d856ebfb4b0953', 'hash': '6e5c80f600f45acda3c3101128bb3075bf2cf7af4bab0d99c9d856ebfb4b0953', 'size': 223, 'vsize': 223, 'version': 2, 'locktime': 0, 'vin': [{'txid': '5a9c45b067b26edb6ea3e735d20851efe23fe0653ad15d84276f5f8c9af32318', 'vout': 1, 'scriptSig': {'asm': '304402207018b7fd1ba6624fe9bb0f16cd65fa243d202e32fdff452699f56465b61ab648022009f0dc1a0a63109246c45e120fc0d34b40e789dfc4d05e64f269602c7d67d92101 027f0dc0894bd690635412af782d05e4f79d3d40bf568978c650f3f1ca1a96cf36', 'hex': '47304402207018b7fd1ba6624fe9bb0f16cd65fa243d202e32fdff452699f56465b61ab648022009f0dc1a0a63109246c45e120fc0d34b40e789dfc4d05e64f269602c7d67d9210121027f0dc0894bd690635412af782d05e4f79d3d40bf568978c650f3f1ca1a96cf36'}, 'sequence': '4294967295'}], 'vout': [{'value': '0.00010000', 'n': 0, 'scriptPubKey': {'asm': 'OP_HASH160 9418feed4647e156d6663db3e0cef7c050d03867 OP_EQUAL', 'hex': 'a9149418feed4647e156d6663db3e0cef7c050d0386787', 'type': 'p2sh', 'address': '2N6kHwQy6Ph5EdKNgzGrcW2WhGHKGfmP5ae'}}, {'value': '0.00078644', 'n': 1, 'scriptPubKey': {'asm': 'OP_DUP OP_HASH160 33ecab3d67f0e2bde43e52f41ec1ecbdc73f11f8 OP_EQUALVERIFY OP_CHECKSIG', 'hex': '76a91433ecab3d67f0e2bde43e52f41ec1ecbdc73f11f888ac', 'type': 'p2pkh', 'address': 'mkFWGt4hT11XS8dJKzzRFsTrqjjAwZfQAC'}}]} """ if not is_network(network=network): raise NetworkError(f"Invalid Bitcoin '{network}' network", "choose only 'mainnet' or 'testnet' networks.") if offline: stp(network, strict=True, force=True) tx = MutableTransaction.unhexlify(raw) return tx.to_json() url = f"{config[network]['blockcypher']['url']}/txs/decode" parameter = dict(token=config[network]["blockcypher"]["token"]) data = dict(tx=raw) response = requests.post( url=url, data=json.dumps(data), params=parameter, headers=headers, timeout=timeout ) response_json = response.json() return response_json
def sign(self, unsigned_raw, solver): """ Sign unsigned fund transaction raw. :param unsigned_raw: bitcoin unsigned fund transaction raw. :type unsigned_raw: str :param solver: bitcoin fund solver. :type solver: bitcoin.solver.FundSolver :returns: FundSignature -- bitcoin fund signature instance. >>> from shuttle.providers.bitcoin.signature import FundSignature >>> fund_signature = FundSignature() >>> fund_signature.sign(bitcoin_fund_unsigned, fund_solver) <shuttle.providers.bitcoin.signature.FundSignature object at 0x0409DAF0> """ tx_raw = json.loads(b64decode(str(unsigned_raw).encode()).decode()) if "raw" not in tx_raw or "outputs" not in tx_raw or "type" not in tx_raw or "fee" not in tx_raw: raise ValueError("invalid unsigned fund transaction raw") self.fee = tx_raw["fee"] self.type = tx_raw["type"] if not self.type == "bitcoin_fund_unsigned": raise TypeError("can't sign this %s transaction using FundSignature" % tx_raw["type"]) if not isinstance(solver, FundSolver): raise TypeError("invalid solver instance, only takes bitcoin FundSolver class") self.transaction = MutableTransaction.unhexlify(tx_raw["raw"]) outputs = list() for output in tx_raw["outputs"]: outputs.append( TxOut(value=output["amount"], n=output["n"], script_pubkey=Script.unhexlify(output["script"]))) self.transaction.spend(outputs, [solver.solve() for _ in outputs]) self.signed = b64encode(str(json.dumps(dict( raw=self.transaction.hexlify(), fee=tx_raw["fee"], network=tx_raw["network"], type="bitcoin_fund_signed" ))).encode()).decode() return self
def sign(self, unsigned_raw, solver): """ Sign unsigned refund transaction raw. :param unsigned_raw: Bitcoin unsigned refund transaction raw. :type unsigned_raw: str :param solver: Bitcoin refund solver. :type solver: bitcoin.solver.RefundSolver :returns: RefundSignature -- Bitcoin refund signature instance. >>> from shuttle.providers.bitcoin.signature import RefundSignature >>> from shuttle.providers.bitcoin.solver import RefundSolver >>> bitcoin_refund_unsigned_raw = "eyJmZWUiOiA1NzYsICJyYXciOiAiMDIwMDAwMDAwMTUyYzIzZGM2NDU2N2IxY2ZhZjRkNzc2NjBjNzFjNzUxZjkwZTliYTVjMzc0N2ZhYzFkMDA1MTgwOGVhMGQ2NTEwMDAwMDAwMDAwZmZmZmZmZmYwMTQ4MTEwMDAwMDAwMDAwMDAxOTc2YTkxNDY0YTgzOTBiMGIxNjg1ZmNiZjJkNGI0NTcxMThkYzhkYTkyZDU1MzQ4OGFjMDAwMDAwMDAiLCAib3V0cHV0cyI6IHsidmFsdWUiOiA1MDAwLCAibiI6IDAsICJzY3JpcHRfcHVia2V5IjogImE5MTQ0MzNlOGVkNTliOWE2N2YwZjE4N2M2M2ViNDUwYjBkNTZlMjU2ZWMyODcifSwgIm5ldHdvcmsiOiAidGVzdG5ldCIsICJ0eXBlIjogImJpdGNvaW5fcmVmdW5kX3Vuc2lnbmVkIn0" >>> refund_solver = RefundSolver("92cbbc5990cb5090326a76feeb321cad01048635afe5756523bbf9f7a75bf38b", "3a26da82ead15a80533a02696656b14b5dbfd84eb14790f2e1be5e9e45820eeb", "muTnffLDR5LtFeLR2i3WsKVfdyvzfyPnVB", "mphBPZf15cRFcL5tUq6mCbE84XobZ1vg7Q", 1000) >>> refund_signature = RefundSignature(network="testnet") >>> refund_signature.sign(unsigned_raw=bitcoin_refund_unsigned_raw, solver=refund_solver) <shuttle.providers.bitcoin.signature.RefundSignature object at 0x0409DAF0> """ # Decoding and loading refund transaction refund_transaction = json.loads( b64decode( str(unsigned_raw + "=" * (-len(unsigned_raw) % 4)).encode()).decode()) # Checking refund transaction keys for key in ["raw", "outputs", "type", "fee", "network"]: if key not in refund_transaction: raise ValueError( "invalid Bitcoin unsigned refund transaction raw") if not refund_transaction["type"] == "bitcoin_refund_unsigned": raise TypeError( f"invalid Bitcoin refund unsigned transaction type, " f"you can't sign this {refund_transaction['type']} type by using RefundSignature" ) if not isinstance(solver, RefundSolver): raise TypeError( "invalid Bitcoin solver, it's only takes Bitcoin RefundSolver class" ) # Setting transaction fee, type, network and transaction self._fee, self._type, self.network, self.transaction = ( refund_transaction["fee"], refund_transaction["type"], refund_transaction["network"], MutableTransaction.unhexlify(refund_transaction["raw"])) # Signing refund transaction self.transaction.spend([ TxOut( value=refund_transaction["outputs"]["value"], n=refund_transaction["outputs"]["n"], script_pubkey=P2shScript.unhexlify( hex_string=refund_transaction["outputs"]["script_pubkey"])) ], [ P2shSolver(redeem_script=solver.witness( network=refund_transaction["network"]), redeem_script_solver=solver.solve()) ]) # Encoding refund transaction raw self._type = "bitcoin_refund_signed" self._signed_raw = b64encode( str( json.dumps( dict(raw=self.transaction.hexlify(), fee=refund_transaction["fee"], network=refund_transaction["network"], type=self._type))).encode()).decode() return self
def sign(self, unsigned_raw, solver): """ Sign unsigned fund transaction raw. :param unsigned_raw: Bitcoin unsigned fund transaction raw. :type unsigned_raw: str :param solver: Bitcoin fund solver. :type solver: bitcoin.solver.FundSolver :returns: FundSignature -- Bitcoin fund signature instance. >>> from shuttle.providers.bitcoin.signature import FundSignature >>> from shuttle.providers.bitcoin.solver import FundSolver >>> bitcoin_fund_unsigned_raw = "eyJmZWUiOiA2NzgsICJyYXciOiAiMDIwMDAwMDAwMTg4OGJlN2VjMDY1MDk3ZDk1NjY0NzYzZjI3NmQ0MjU1NTJkNzM1ZmIxZDk3NGFlNzhiZjcyMTA2ZGNhMGYzOTEwMTAwMDAwMDAwZmZmZmZmZmYwMjEwMjcwMDAwMDAwMDAwMDAxN2E5MTQyYmIwMTNjM2U0YmViMDg0MjFkZWRjZjgxNWNiNjVhNWMzODgxNzhiODdiY2RkMGUwMDAwMDAwMDAwMTk3NmE5MTQ2NGE4MzkwYjBiMTY4NWZjYmYyZDRiNDU3MTE4ZGM4ZGE5MmQ1NTM0ODhhYzAwMDAwMDAwIiwgIm91dHB1dHMiOiBbeyJhbW91bnQiOiA5ODQ5NDYsICJuIjogMSwgInNjcmlwdCI6ICI3NmE5MTQ2NGE4MzkwYjBiMTY4NWZjYmYyZDRiNDU3MTE4ZGM4ZGE5MmQ1NTM0ODhhYyJ9XSwgIm5ldHdvcmsiOiAidGVzdG5ldCIsICJ0eXBlIjogImJpdGNvaW5fZnVuZF91bnNpZ25lZCJ9" >>> fund_solver = FundSolver("92cbbc5990cb5090326a76feeb321cad01048635afe5756523bbf9f7a75bf38b") >>> fund_signature = FundSignature(network="testnet") >>> fund_signature.sign(bitcoin_fund_unsigned_raw, fund_solver) <shuttle.providers.bitcoin.signature.FundSignature object at 0x0409DAF0> """ # Decoding and loading refund transaction fund_transaction = json.loads( b64decode( str(unsigned_raw + "=" * (-len(unsigned_raw) % 4)).encode()).decode()) # Checking refund transaction keys for key in ["raw", "outputs", "type", "fee", "network"]: if key not in fund_transaction: raise ValueError( "invalid Bitcoin unsigned fund transaction raw") if not fund_transaction["type"] == "bitcoin_fund_unsigned": raise TypeError( f"invalid Bitcoin fund unsigned transaction type, " f"you can't sign this {fund_transaction['type']} type by using FundSignature" ) if not isinstance(solver, FundSolver): raise TypeError( "invalid Bitcoin solver, it's only takes Bitcoin FundSolver class" ) # Setting transaction fee, type, network and transaction self._fee, self._type, self.network, self.transaction = ( fund_transaction["fee"], fund_transaction["type"], fund_transaction["network"], MutableTransaction.unhexlify(fund_transaction["raw"])) # Organizing outputs outputs = [] for output in fund_transaction["outputs"]: outputs.append( TxOut(value=output["amount"], n=output["n"], script_pubkey=Script.unhexlify( hex_string=output["script"]))) # Signing fund transaction self.transaction.spend(outputs, [solver.solve() for _ in outputs]) # Encoding fund transaction raw self._type = "bitcoin_fund_signed" self._signed_raw = b64encode( str( json.dumps( dict(raw=self.transaction.hexlify(), fee=fund_transaction["fee"], network=fund_transaction["network"], type=self._type))).encode()).decode() return self
def sign(self, transaction_raw: str, solver: RefundSolver) -> "RefundSignature": """ Sign unsigned refund transaction raw. :param transaction_raw: Bitcoin unsigned refund transaction raw. :type transaction_raw: str :param solver: Bitcoin refund solver. :type solver: bitcoin.solver.RefundSolver :returns: RefundSignature -- Bitcoin refund signature instance. >>> from swap.providers.bitcoin.signature import Signature >>> from swap.providers.bitcoin.solver import RefundSolver >>> unsigned_refund_transaction_raw: str = "eyJmZWUiOiA1NzYsICJyYXciOiAiMDIwMDAwMDAwMTMxZmI3NmEwYzM4ZDU3MzgxYjMxMTBlNGY1ZWU5YjUyODFkY2YyZmJlMmZlMjU2OTI2NmI3NTEwMTFkMjExYTIwMDAwMDAwMDAwZmZmZmZmZmYwMTYwODQwMTAwMDAwMDAwMDAxOTc2YTkxNGUwMGZmMmE2NDBiN2NlMmQzMzY4NjA3MzkxNjk0ODdhNTdmODRiMTU4OGFjMDAwMDAwMDAiLCAib3V0cHV0cyI6IHsidmFsdWUiOiAxMDAwMDAsICJ0eF9vdXRwdXRfbiI6IDAsICJzY3JpcHQiOiAiYTkxNGM4Yzc3YTliNDNlZTJiZGYxYTA3YzQ4Njk5ODMzZDc2NjhiZjI2NGM4NyJ9LCAibmV0d29yayI6ICJ0ZXN0bmV0IiwgInR5cGUiOiAiYml0Y29pbl9yZWZ1bmRfdW5zaWduZWQifQ" >>> bytecode: str = "63aa20821124b554d13f247b1e5d10b84e44fb1296f18f38bbaa1bea34a12c843e01588876a9140a0a6590e6ba4b48118d21b86812615219ece76b88ac67040ec4d660b17576a914e00ff2a640b7ce2d336860739169487a57f84b1588ac68" >>> refund_solver: RefundSolver = RefundSolver(xprivate_key="tprv8ZgxMBicQKsPeMHMJAc6uWGYiGqi1MVM2ybmzXL2TAoDpQe85uyDpdT7mv7Nhdu5rTCBEKLZsd9KyP2LQZJzZTvgVQvENArgU8e6DoYBiXf", bytecode=bytecode, endtime=1624687630) >>> refund_signature: RefundSignature = RefundSignature(network="testnet") >>> refund_signature.sign(transaction_raw=unsigned_refund_transaction_raw, solver=refund_solver) <swap.providers.bitcoin.signature.RefundSignature object at 0x0409DAF0> """ if not is_transaction_raw(transaction_raw=transaction_raw): raise TransactionRawError("Invalid Bitcoin unsigned transaction raw.") transaction_raw = clean_transaction_raw(transaction_raw) decoded_transaction_raw = b64decode(transaction_raw.encode()) loaded_transaction_raw = json.loads(decoded_transaction_raw.decode()) if not loaded_transaction_raw["type"] == "bitcoin_refund_unsigned": raise TypeError(f"Invalid Bitcoin refund unsigned transaction raw type, " f"you can't sign {loaded_transaction_raw['type']} type by using refund signature.") # Check parameter instances if not isinstance(solver, RefundSolver): raise TypeError(f"Solver must be Bitcoin RefundSolver, not {type(solver).__name__} type.") # Set transaction fee, type, network and transaction self._fee, self._type, self._network, self._transaction = ( loaded_transaction_raw["fee"], loaded_transaction_raw["type"], loaded_transaction_raw["network"], MutableTransaction.unhexlify(loaded_transaction_raw["raw"]) ) # Sign refund transaction self._transaction.spend([TxOut( value=loaded_transaction_raw["outputs"]["value"], n=loaded_transaction_raw["outputs"]["tx_output_n"], script_pubkey=P2shScript.unhexlify( hex_string=loaded_transaction_raw["outputs"]["script"] ) )], [P2shSolver( redeem_script=solver.witness( network=self._network ), redeem_script_solver=solver.solve( network=self._network ) )]) # Encode refund transaction raw self._type = "bitcoin_refund_signed" self._signed_raw = b64encode(str(json.dumps(dict( raw=self._transaction.hexlify(), fee=self._fee, network=self._network, type=self._type, ))).encode()).decode() return self
def sign(self, transaction_raw: str, solver: WithdrawSolver) -> "WithdrawSignature": """ Sign unsigned withdraw transaction raw. :param transaction_raw: Bitcoin unsigned withdraw transaction raw. :type transaction_raw: str :param solver: Bitcoin withdraw solver. :type solver: bitcoin.solver.WithdrawSolver :returns: WithdrawSignature -- Bitcoin withdraw signature instance. >>> from swap.providers.bitcoin.signature import WithdrawSignature >>> from swap.providers.bitcoin.solver import WithdrawSolver >>> unsigned_withdraw_transaction_raw: str = "eyJmZWUiOiA1NzYsICJyYXciOiAiMDIwMDAwMDAwMTMxZmI3NmEwYzM4ZDU3MzgxYjMxMTBlNGY1ZWU5YjUyODFkY2YyZmJlMmZlMjU2OTI2NmI3NTEwMTFkMjExYTIwMDAwMDAwMDAwZmZmZmZmZmYwMTYwODQwMTAwMDAwMDAwMDAxOTc2YTkxNDBhMGE2NTkwZTZiYTRiNDgxMThkMjFiODY4MTI2MTUyMTllY2U3NmI4OGFjMDAwMDAwMDAiLCAib3V0cHV0cyI6IHsidmFsdWUiOiAxMDAwMDAsICJ0eF9vdXRwdXRfbiI6IDAsICJzY3JpcHQiOiAiYTkxNGM4Yzc3YTliNDNlZTJiZGYxYTA3YzQ4Njk5ODMzZDc2NjhiZjI2NGM4NyJ9LCAibmV0d29yayI6ICJ0ZXN0bmV0IiwgInR5cGUiOiAiYml0Y29pbl93aXRoZHJhd191bnNpZ25lZCJ9" >>> bytecode: str = "63aa20821124b554d13f247b1e5d10b84e44fb1296f18f38bbaa1bea34a12c843e01588876a9140a0a6590e6ba4b48118d21b86812615219ece76b88ac67040ec4d660b17576a914e00ff2a640b7ce2d336860739169487a57f84b1588ac68" >>> withdraw_solver: WithdrawSolver = WithdrawSolver(xprivate_key="tprv8ZgxMBicQKsPf949JcuVFLXPJ5m4VKe33gVX3FYVZYVHr2dChU8K66aEQcPdHpUgACq5GQu81Z4e3QN1vxCrV4pxcUcXHoRTamXBRaPdJhW", secret_key="Hello Meheret!", bytecode=bytecode) >>> withdraw_signature: WithdrawSignature = WithdrawSignature(network="testnet") >>> withdraw_signature.sign(transaction_raw=unsigned_withdraw_transaction_raw, solver=withdraw_solver) <swap.providers.bitcoin.signature.WithdrawSignature object at 0x0409DAF0> """ if not is_transaction_raw(transaction_raw=transaction_raw): raise TransactionRawError("Invalid Bitcoin unsigned transaction raw.") transaction_raw = clean_transaction_raw(transaction_raw) decoded_transaction_raw = b64decode(transaction_raw.encode()) loaded_transaction_raw = json.loads(decoded_transaction_raw.decode()) if not loaded_transaction_raw["type"] == "bitcoin_withdraw_unsigned": raise TypeError(f"Invalid Bitcoin withdraw unsigned transaction raw type, " f"you can't sign {loaded_transaction_raw['type']} type by using withdraw signature.") # Check parameter instances if not isinstance(solver, WithdrawSolver): raise TypeError(f"Solver must be Bitcoin WithdrawSolver, not {type(solver).__name__} type.") # Set transaction fee, type, network and transaction self._fee, self._type, self._network, self._transaction = ( loaded_transaction_raw["fee"], loaded_transaction_raw["type"], loaded_transaction_raw["network"], MutableTransaction.unhexlify(loaded_transaction_raw["raw"]) ) # Sign withdraw transaction self._transaction.spend([TxOut( value=loaded_transaction_raw["outputs"]["value"], n=loaded_transaction_raw["outputs"]["tx_output_n"], script_pubkey=P2shScript.unhexlify( hex_string=loaded_transaction_raw["outputs"]["script"] ) )], [P2shSolver( redeem_script=solver.witness( network=self._network ), redeem_script_solver=solver.solve( network=self._network ) )]) # Encode withdraw transaction raw self._type = "bitcoin_withdraw_signed" self._signed_raw = b64encode(str(json.dumps(dict( raw=self._transaction.hexlify(), fee=self._fee, network=self._network, type=self._type, ))).encode()).decode() return self
def sign(self, transaction_raw: str, solver: FundSolver) -> "FundSignature": """ Sign unsigned fund transaction raw. :param transaction_raw: Bitcoin unsigned fund transaction raw. :type transaction_raw: str :param solver: Bitcoin fund solver. :type solver: bitcoin.solver.FundSolver :returns: FundSignature -- Bitcoin fund signature instance. >>> from swap.providers.bitcoin.signature import FundSignature >>> from swap.providers.bitcoin.solver import FundSolver >>> unsigned_fund_transaction_raw: str = "eyJmZWUiOiAxMTIyLCAicmF3IjogIjAyMDAwMDAwMDIzMWZiNzZhMGMzOGQ1NzM4MWIzMTEwZTRmNWVlOWI1MjgxZGNmMmZiZTJmZTI1NjkyNjZiNzUxMDExZDIxMWEyMDEwMDAwMDAwMGZmZmZmZmZmMDgwYjgyZWVjMzMyOTk2YTQyMmFlNGYwODBmNzRlNTNmZDJjYTRmMDcwMTFkNDdjNTkwODUzZTFlMzA1ZmUxMTAxMDAwMDAwMDBmZmZmZmZmZjAyYTA4NjAxMDAwMDAwMDAwMDE3YTkxNGM4Yzc3YTliNDNlZTJiZGYxYTA3YzQ4Njk5ODMzZDc2NjhiZjI2NGM4NzMyOWMwZDAwMDAwMDAwMDAxOTc2YTkxNGUwMGZmMmE2NDBiN2NlMmQzMzY4NjA3MzkxNjk0ODdhNTdmODRiMTU4OGFjMDAwMDAwMDAiLCAib3V0cHV0cyI6IFt7InZhbHVlIjogOTQzMzAsICJ0eF9vdXRwdXRfbiI6IDEsICJzY3JpcHQiOiAiNzZhOTE0ZTAwZmYyYTY0MGI3Y2UyZDMzNjg2MDczOTE2OTQ4N2E1N2Y4NGIxNTg4YWMifSwgeyJ2YWx1ZSI6IDg5ODc0NiwgInR4X291dHB1dF9uIjogMSwgInNjcmlwdCI6ICI3NmE5MTRlMDBmZjJhNjQwYjdjZTJkMzM2ODYwNzM5MTY5NDg3YTU3Zjg0YjE1ODhhYyJ9XSwgIm5ldHdvcmsiOiAidGVzdG5ldCIsICJ0eXBlIjogImJpdGNvaW5fZnVuZF91bnNpZ25lZCJ9" >>> fund_solver: FundSolver = FundSolver(xprivate_key="tprv8ZgxMBicQKsPeMHMJAc6uWGYiGqi1MVM2ybmzXL2TAoDpQe85uyDpdT7mv7Nhdu5rTCBEKLZsd9KyP2LQZJzZTvgVQvENArgU8e6DoYBiXf") >>> fund_signature: FundSignature = FundSignature(network="testnet") >>> fund_signature.sign(transaction_raw=unsigned_fund_transaction_raw, solver=fund_solver) <swap.providers.bitcoin.signature.FundSignature object at 0x0409DAF0> """ if not is_transaction_raw(transaction_raw=transaction_raw): raise TransactionRawError("Invalid Bitcoin unsigned transaction raw.") transaction_raw = clean_transaction_raw(transaction_raw) decoded_transaction_raw = b64decode(transaction_raw.encode()) loaded_transaction_raw = json.loads(decoded_transaction_raw.decode()) if not loaded_transaction_raw["type"] == "bitcoin_fund_unsigned": raise TypeError(f"Invalid Bitcoin fund unsigned transaction raw type, " f"you can't sign {loaded_transaction_raw['type']} type by using fund signature.") # Check parameter instances if not isinstance(solver, FundSolver): raise TypeError(f"Solver must be Bitcoin FundSolver, not {type(solver).__name__} type.") # Set transaction fee, type, network and transaction self._fee, self._type, self._network, self._transaction = ( loaded_transaction_raw["fee"], loaded_transaction_raw["type"], loaded_transaction_raw["network"], MutableTransaction.unhexlify(loaded_transaction_raw["raw"]) ) # Organize outputs outputs = [] for output in loaded_transaction_raw["outputs"]: outputs.append(TxOut( value=output["value"], n=output["tx_output_n"], script_pubkey=Script.unhexlify( hex_string=output["script"] ) )) # Sign fund transaction self._transaction.spend( txouts=outputs, solvers=[solver.solve(network=self._network) for _ in outputs] ) # Encode fund transaction raw self._type = "bitcoin_fund_signed" self._signed_raw = b64encode(str(json.dumps(dict( raw=self._transaction.hexlify(), fee=self._fee, network=self._network, type=self._type ))).encode()).decode() return self
def sign(self, transaction_raw: str, solver: NormalSolver) -> "NormalSignature": """ Sign unsigned normal transaction raw. :param transaction_raw: Bitcoin unsigned normal transaction raw. :type transaction_raw: str :param solver: Bitcoin normal solver. :type solver: bitcoin.solver.NormalSolver :returns: NormalSignature -- Bitcoin normal signature instance. >>> from swap.providers.bitcoin.signature import NormalSignature >>> from swap.providers.bitcoin.solver import NormalSolver >>> unsigned_normal_transaction_raw = "eyJmZWUiOiA2NzgsICJyYXciOiAiMDIwMDAwMDAwMTA4MjVlMDBiYTU5NmFiMTExMjZjZDg5MjAzYjg4MmJjZTYwYTdkYjAxOWU1MTIxNzA1NmM0NzFmNTEwY2ZkODUwMDAwMDAwMDAwZmZmZmZmZmYwMjEwMjcwMDAwMDAwMDAwMDAxN2E5MTQ0Njk1MTI3YjFkMTdjNDU0ZjRiYWU5YzQxY2I4ZTNjZGI1ZTg5ZDI0ODdlYTVjMDEwMDAwMDAwMDAwMTk3NmE5MTQzM2VjYWIzZDY3ZjBlMmJkZTQzZTUyZjQxZWMxZWNiZGM3M2YxMWY4ODhhYzAwMDAwMDAwIiwgIm91dHB1dHMiOiBbeyJ2YWx1ZSI6IDEwMDAwMCwgInR4X291dHB1dF9uIjogMCwgInNjcmlwdCI6ICI3NmE5MTQzM2VjYWIzZDY3ZjBlMmJkZTQzZTUyZjQxZWMxZWNiZGM3M2YxMWY4ODhhYyJ9XSwgIm5ldHdvcmsiOiAidGVzdG5ldCIsICJ0eXBlIjogImJpdGNvaW5fZnVuZF91bnNpZ25lZCJ9" >>> normal_solver: NormalSolver = NormalSolver(xprivate_key="tprv8ZgxMBicQKsPeMHMJAc6uWGYiGqi1MVM2ybmzXL2TAoDpQe85uyDpdT7mv7Nhdu5rTCBEKLZsd9KyP2LQZJzZTvgVQvENArgU8e6DoYBiXf") >>> normal_signature: NormalSignature = NormalSignature(network="testnet") >>> normal_signature.sign(transaction_raw=unsigned_normal_transaction_raw, solver=normal_solver) <swap.providers.bitcoin.signature.NormalSignature object at 0x0409DAF0> """ if not is_transaction_raw(transaction_raw=transaction_raw): raise TransactionRawError( "Invalid Bitcoin unsigned transaction raw.") transaction_raw = clean_transaction_raw(transaction_raw) decoded_transaction_raw = b64decode(transaction_raw.encode()) loaded_transaction_raw = json.loads(decoded_transaction_raw.decode()) if not loaded_transaction_raw["type"] == "bitcoin_normal_unsigned": raise TypeError( f"Invalid Bitcoin normal unsigned transaction raw type, " f"you can't sign {loaded_transaction_raw['type']} type by using normal signature." ) # Check parameter instances if not isinstance(solver, NormalSolver): raise TypeError( f"Solver must be Bitcoin NormalSolver, not {type(solver).__name__} type." ) # Set transaction fee, type, network and transaction self._fee, self._type, self._network, self._transaction = ( loaded_transaction_raw["fee"], loaded_transaction_raw["type"], loaded_transaction_raw["network"], MutableTransaction.unhexlify(loaded_transaction_raw["raw"])) # Organize outputs outputs = [] for output in loaded_transaction_raw["outputs"]: outputs.append( TxOut(value=output["value"], n=output["tx_output_n"], script_pubkey=Script.unhexlify( hex_string=output["script"]))) # Sign normal transaction self._transaction.spend( txouts=outputs, solvers=[solver.solve(network=self._network) for _ in outputs]) # Encode normal transaction raw self._type = "bitcoin_normal_signed" self._signed_raw = b64encode( str( json.dumps( dict(raw=self._transaction.hexlify(), fee=self._fee, network=self._network, type=self._type))).encode()).decode() return self
def sign(self, transaction_raw: str, solver: RefundSolver) -> "RefundSignature": """ Sign unsigned refund transaction raw. :param transaction_raw: Bitcoin unsigned refund transaction raw. :type transaction_raw: str :param solver: Bitcoin refund solver. :type solver: bitcoin.solver.RefundSolver :returns: RefundSignature -- Bitcoin refund signature instance. >>> from swap.providers.bitcoin.signature import RefundSignature >>> from swap.providers.bitcoin.solver import RefundSolver >>> unsigned_refund_transaction_raw = "eyJmZWUiOiA1NzYsICJyYXciOiAiMDIwMDAwMDAwMTE4MjNmMzlhOGM1ZjZmMjc4NDVkZDEzYTY1ZTAzZmUyZWY1MTA4ZDIzNWU3YTM2ZWRiNmViMjY3YjA0NTljNWEwMDAwMDAwMDAwZmZmZmZmZmYwMWQwMjQwMDAwMDAwMDAwMDAxOTc2YTkxNDMzZWNhYjNkNjdmMGUyYmRlNDNlNTJmNDFlYzFlY2JkYzczZjExZjg4OGFjMDAwMDAwMDAiLCAib3V0cHV0cyI6IHsidmFsdWUiOiAxMDAwMCwgInR4X291dHB1dF9uIjogMCwgInNjcmlwdCI6ICJhOTE0OTQxOGZlZWQ0NjQ3ZTE1NmQ2NjYzZGIzZTBjZWY3YzA1MGQwMzg2Nzg3In0sICJuZXR3b3JrIjogInRlc3RuZXQiLCAidHlwZSI6ICJiaXRjb2luX3JlZnVuZF91bnNpZ25lZCJ9" >>> sender_root_xprivate_key = "xprv9s21ZrQH143K3XihXQBN8Uar2WBtrjSzK2oRDEGQ25pA2kKAADoQXaiiVXht163ZTrdtTXfM4GqNRE9gWQHky25BpvBQuuhNCM3SKwWTPNJ" >>> bytecode = "63aa20821124b554d13f247b1e5d10b84e44fb1296f18f38bbaa1bea34a12c843e01588876a9140e259e08f2ec9fc99a92b6f66fdfcb3c7914fd6888ac6702e803b27576a91433ecab3d67f0e2bde43e52f41ec1ecbdc73f11f888ac68" >>> refund_solver = RefundSolver(sender_root_xprivate_key, bytecode, 1000) >>> refund_signature = RefundSignature("testnet") >>> refund_signature.sign(transaction_raw=unsigned_refund_transaction_raw, solver=refund_solver) <swap.providers.bitcoin.signature.RefundSignature object at 0x0409DAF0> """ if not is_transaction_raw(transaction_raw=transaction_raw): raise TransactionRawError("Invalid Bitcoin unsigned transaction raw.") transaction_raw = clean_transaction_raw(transaction_raw) decoded_transaction_raw = b64decode(transaction_raw.encode()) loaded_transaction_raw = json.loads(decoded_transaction_raw.decode()) if not loaded_transaction_raw["type"] == "bitcoin_refund_unsigned": raise TypeError(f"Invalid Bitcoin refund unsigned transaction raw type, " f"you can't sign {loaded_transaction_raw['type']} type by using refund signature.") # Check parameter instances if not isinstance(solver, RefundSolver): raise TypeError(f"Solver must be Bitcoin RefundSolver, not {type(solver).__name__} type.") # Set transaction fee, type, network and transaction self._fee, self._type, self._datas, self._network, self._transaction = ( loaded_transaction_raw["fee"], loaded_transaction_raw["type"], loaded_transaction_raw["datas"], loaded_transaction_raw["network"], MutableTransaction.unhexlify(loaded_transaction_raw["raw"]) ) # Sign refund transaction self._transaction.spend([TxOut( value=loaded_transaction_raw["outputs"]["value"], n=loaded_transaction_raw["outputs"]["tx_output_n"], script_pubkey=P2shScript.unhexlify( hex_string=loaded_transaction_raw["outputs"]["script"] ) )], [P2shSolver( redeem_script=solver.witness( network=self._network ), redeem_script_solver=solver.solve( network=self._network ) )]) # Encode refund transaction raw self._type = "bitcoin_refund_signed" self._signed_raw = b64encode(str(json.dumps(dict( raw=self._transaction.hexlify(), fee=self._fee, network=self._network, type=self._type, datas=self._datas ))).encode()).decode() return self
def sign(self, transaction_raw: str, solver: ClaimSolver) -> "ClaimSignature": """ Sign unsigned claim transaction raw. :param transaction_raw: Bitcoin unsigned claim transaction raw. :type transaction_raw: str :param solver: Bitcoin claim solver. :type solver: bitcoin.solver.ClaimSolver :returns: ClaimSignature -- Bitcoin claim signature instance. >>> from swap.providers.bitcoin.signature import ClaimSignature >>> from swap.providers.bitcoin.solver import ClaimSolver >>> unsigned_claim_transaction_raw = "eyJmZWUiOiA1NzYsICJyYXciOiAiMDIwMDAwMDAwMTE4MjNmMzlhOGM1ZjZmMjc4NDVkZDEzYTY1ZTAzZmUyZWY1MTA4ZDIzNWU3YTM2ZWRiNmViMjY3YjA0NTljNWEwMDAwMDAwMDAwZmZmZmZmZmYwMWQwMjQwMDAwMDAwMDAwMDAxOTc2YTkxNDBlMjU5ZTA4ZjJlYzlmYzk5YTkyYjZmNjZmZGZjYjNjNzkxNGZkNjg4OGFjMDAwMDAwMDAiLCAib3V0cHV0cyI6IHsidmFsdWUiOiAxMDAwMCwgInR4X291dHB1dF9uIjogMCwgInNjcmlwdCI6ICJhOTE0OTQxOGZlZWQ0NjQ3ZTE1NmQ2NjYzZGIzZTBjZWY3YzA1MGQwMzg2Nzg3In0sICJuZXR3b3JrIjogInRlc3RuZXQiLCAidHlwZSI6ICJiaXRjb2luX2NsYWltX3Vuc2lnbmVkIn0" >>> recipient_root_xprivate_key = "xprv9s21ZrQH143K4Kpce43z5guPyxLrFoc2i8aQAq835Zzp4Rt7i6nZaMCnVSDyHT6MnmJJGKHMrCUqaYpGojrug1ZN5qQDdShQffmkyv5xyUR" >>> bytecode = "63aa20821124b554d13f247b1e5d10b84e44fb1296f18f38bbaa1bea34a12c843e01588876a9140e259e08f2ec9fc99a92b6f66fdfcb3c7914fd6888ac6702e803b27576a91433ecab3d67f0e2bde43e52f41ec1ecbdc73f11f888ac68" >>> claim_solver = ClaimSolver(recipient_root_xprivate_key, "Hello Meheret!", bytecode) >>> claim_signature = ClaimSignature("testnet") >>> claim_signature.sign(transaction_raw=unsigned_claim_transaction_raw, solver=claim_solver) <swap.providers.bitcoin.signature.ClaimSignature object at 0x0409DAF0> """ if not is_transaction_raw(transaction_raw=transaction_raw): raise TransactionRawError("Invalid Bitcoin unsigned transaction raw.") transaction_raw = clean_transaction_raw(transaction_raw) decoded_transaction_raw = b64decode(transaction_raw.encode()) loaded_transaction_raw = json.loads(decoded_transaction_raw.decode()) if not loaded_transaction_raw["type"] == "bitcoin_claim_unsigned": raise TypeError(f"Invalid Bitcoin claim unsigned transaction raw type, " f"you can't sign {loaded_transaction_raw['type']} type by using claim signature.") # Check parameter instances if not isinstance(solver, ClaimSolver): raise TypeError(f"Solver must be Bitcoin ClaimSolver, not {type(solver).__name__} type.") # Set transaction fee, type, network and transaction self._fee, self._type, self._datas, self._network, self._transaction = ( loaded_transaction_raw["fee"], loaded_transaction_raw["type"], loaded_transaction_raw["datas"], loaded_transaction_raw["network"], MutableTransaction.unhexlify(loaded_transaction_raw["raw"]) ) # Sign claim transaction self._transaction.spend([TxOut( value=loaded_transaction_raw["outputs"]["value"], n=loaded_transaction_raw["outputs"]["tx_output_n"], script_pubkey=P2shScript.unhexlify( hex_string=loaded_transaction_raw["outputs"]["script"] ) )], [P2shSolver( redeem_script=solver.witness( network=self._network ), redeem_script_solver=solver.solve( network=self._network ) )]) # Encode claim transaction raw self._type = "bitcoin_claim_signed" self._signed_raw = b64encode(str(json.dumps(dict( raw=self._transaction.hexlify(), fee=self._fee, network=self._network, type=self._type, datas=self._datas ))).encode()).decode() return self
def sign(self, transaction_raw: str, solver: FundSolver) -> "FundSignature": """ Sign unsigned fund transaction raw. :param transaction_raw: Bitcoin unsigned fund transaction raw. :type transaction_raw: str :param solver: Bitcoin fund solver. :type solver: bitcoin.solver.FundSolver :returns: FundSignature -- Bitcoin fund signature instance. >>> from swap.providers.bitcoin.signature import Signature >>> from swap.providers.bitcoin.solver import FundSolver >>> unsigned_fund_transaction_raw = "eyJmZWUiOiA2NzgsICJyYXciOiAiMDIwMDAwMDAwMTA4MjVlMDBiYTU5NmFiMTExMjZjZDg5MjAzYjg4MmJjZTYwYTdkYjAxOWU1MTIxNzA1NmM0NzFmNTEwY2ZkODUwMDAwMDAwMDAwZmZmZmZmZmYwMjEwMjcwMDAwMDAwMDAwMDAxN2E5MTQ0Njk1MTI3YjFkMTdjNDU0ZjRiYWU5YzQxY2I4ZTNjZGI1ZTg5ZDI0ODdlYTVjMDEwMDAwMDAwMDAwMTk3NmE5MTQzM2VjYWIzZDY3ZjBlMmJkZTQzZTUyZjQxZWMxZWNiZGM3M2YxMWY4ODhhYzAwMDAwMDAwIiwgIm91dHB1dHMiOiBbeyJ2YWx1ZSI6IDEwMDAwMCwgInR4X291dHB1dF9uIjogMCwgInNjcmlwdCI6ICI3NmE5MTQzM2VjYWIzZDY3ZjBlMmJkZTQzZTUyZjQxZWMxZWNiZGM3M2YxMWY4ODhhYyJ9XSwgIm5ldHdvcmsiOiAidGVzdG5ldCIsICJ0eXBlIjogImJpdGNvaW5fZnVuZF91bnNpZ25lZCJ9" >>> sender_root_xprivate_key = "xprv9s21ZrQH143K3XihXQBN8Uar2WBtrjSzK2oRDEGQ25pA2kKAADoQXaiiVXht163ZTrdtTXfM4GqNRE9gWQHky25BpvBQuuhNCM3SKwWTPNJ" >>> fund_solver = FundSolver(sender_root_xprivate_key) >>> fund_signature = FundSignature("testnet") >>> fund_signature.sign(unsigned_fund_transaction_raw, fund_solver) <swap.providers.bitcoin.signature.FundSignature object at 0x0409DAF0> """ if not is_transaction_raw(transaction_raw=transaction_raw): raise TransactionRawError("Invalid Bitcoin unsigned transaction raw.") transaction_raw = clean_transaction_raw(transaction_raw) decoded_transaction_raw = b64decode(transaction_raw.encode()) loaded_transaction_raw = json.loads(decoded_transaction_raw.decode()) if not loaded_transaction_raw["type"] == "bitcoin_fund_unsigned": raise TypeError(f"Invalid Bitcoin fund unsigned transaction raw type, " f"you can't sign {loaded_transaction_raw['type']} type by using fund signature.") # Check parameter instances if not isinstance(solver, FundSolver): raise TypeError(f"Solver must be Bitcoin FundSolver, not {type(solver).__name__} type.") # Set transaction fee, type, network and transaction self._fee, self._type, self._datas, self._network, self._transaction = ( loaded_transaction_raw["fee"], loaded_transaction_raw["type"], loaded_transaction_raw["datas"], loaded_transaction_raw["network"], MutableTransaction.unhexlify(loaded_transaction_raw["raw"]) ) # Organize outputs outputs = [] for output in loaded_transaction_raw["outputs"]: outputs.append(TxOut( value=output["value"], n=output["tx_output_n"], script_pubkey=Script.unhexlify( hex_string=output["script"] ) )) # Sign fund transaction self._transaction.spend( txouts=outputs, solvers=[solver.solve(network=self._network) for _ in outputs] ) # Encode fund transaction raw self._type = "bitcoin_fund_signed" self._signed_raw = b64encode(str(json.dumps(dict( raw=self._transaction.hexlify(), fee=self._fee, network=self._network, type=self._type, datas=self._datas ))).encode()).decode() return self