def test_all(self): global keys priv = ExtendedPrivateKey.decode(keys[0][1]).key pk = priv.pub() addr_string = str(pk.to_address()) utxo = [] for i in range(3): # create 3 tx to add to UTXO txid = regtest.send_rpc_cmd(['sendtoaddress', addr_string, '100'], 0) to_spend = Transaction.unhexlify( regtest.send_rpc_cmd(['getrawtransaction', txid, '0'], 0)) txout = None for out in to_spend.outs: if str(out.script_pubkey.address()) == addr_string: txout = out break assert txout is not None utxo.append({ 'txid': txid, 'txout': txout, 'solver': P2pkhSolver(priv), 'next_seq': Sequence.max(), 'next_locktime': Locktime(0) }) regtest.send_rpc_cmd(['generate', '100'], 0) generate = False next_locktime = Locktime(0) next_sequence = Sequence.max() i = 0 while i < len(self.all) - 2: print('{:04d}\r'.format(i), end='', flush=True) ins = [ MutableTxIn(unspent['txid'], unspent['txout'].n, ScriptSig.empty(), unspent['next_seq']) for unspent in utxo ] outs = [] prev_types = [] for j, (unspent, script) in enumerate(zip(utxo, self.all[i:i + 3])): outs.append( TxOut(unspent['txout'].value - 1000000, j, script[0])) prev_types.append(script[2]) tx = MutableTransaction( 2, ins, outs, min_locktime(unspent['next_locktime'] for unspent in utxo)) mutable = copy.deepcopy(tx) tx = tx.spend([unspent['txout'] for unspent in utxo], [unspent['solver'] for unspent in utxo]) # print('====================') # print('txid: {}'.format(tx.txid)) # print() # print(tx) # print() # print('raw: {}'.format(tx.hexlify())) # print('prev_scripts, amounts, solvers:') print('TX: {}'.format(i)) regtest.send_rpc_cmd(['sendrawtransaction', tx.hexlify()], 0) print('Mempool size: {}'.format( len(regtest.send_rpc_cmd(['getrawmempool'], 0)))) if cmdline_args.dumpfile is not None: with open(cmdline_args.dumpfile, 'a') as out: for j, unspent in enumerate(utxo): json.dump( self.json_dump(unspent, tx.ins[j], j, copy.deepcopy(mutable).to_segwit()), out) out.write('\n') utxo = [] for j, (output, prev_type) in enumerate(zip(tx.outs, prev_types)): if 'time' in prev_type: if 'absolute' in prev_type: next_locktime = Locktime(100) next_sequence = Sequence(0xfffffffe) if 'relative' in prev_type: next_sequence = Sequence(3) generate = True else: next_locktime = Locktime(0) next_sequence = Sequence.max() utxo.append({ 'txid': tx.txid, 'txout': output, 'solver': self.all[i + j][1][0], # solver 'next_seq': next_sequence, 'next_locktime': next_locktime }) if generate: regtest.send_rpc_cmd(['generate', '4'], 0) generate = False if not i % 10: print('generating 2') regtest.send_rpc_cmd(['generate', '2'], 0) i += 1 ins = [ MutableTxIn(unspent['txid'], unspent['txout'].n, ScriptSig.empty(), unspent['next_seq']) for unspent in utxo ] tx = MutableTransaction( 2, ins, [ TxOut( sum(unspent['txout'].value for unspent in utxo) - 1000000, 0, self.final['script']) ], min_locktime(unspent['next_locktime'] for unspent in utxo)) tx = tx.spend([unspent['txout'] for unspent in utxo], [unspent['solver'] for unspent in utxo]) # print('====================') # print('txid: {}'.format(tx.txid)) # print() # print(tx) # print() # print('raw: {}'.format(tx.hexlify())) # print('prev_scripts, amounts, solvers:') # for unspent in utxo: # print(unspent['txout'].script_pubkey, unspent['txout'].value, unspent['solver'].__class__.__name__) regtest.send_rpc_cmd(['sendrawtransaction', tx.hexlify()], 0) regtest.teardown()
class RefundTransaction(Transaction): """ Bitcoin RefundTransaction class. :param version: Bitcoin transaction version, defaults to 2. :type version: int :param network: Bitcoin network, defaults to testnet. :type network: str :returns: Transaction -- Bitcoin transaction instance. .. warning:: Do not forget to build transaction after initialize refund transaction. """ # Initialization claim transaction def __init__(self, version=2, network="testnet"): super().__init__(version=version, network=network) # Initialization transaction_id, sender wallet and amount self.transaction_id, self.wallet, \ self.amount = None, None, None # Get transaction detail self.transaction_detail = None # Transaction detail outputs (HTLC and Sender account) self.htlc_detail, self.sender_detail = None, None # Building transaction def build_transaction(self, transaction_id, wallet, amount, locktime=0): """ Build Bitcoin refund transaction. :param transaction_id: Bitcoin fund transaction id to redeem. :type transaction_id: str :param wallet: Bitcoin sender wallet. :type wallet: bitcoin.wallet.Wallet :param amount: Bitcoin amount to withdraw. :type amount: int :param locktime: Bitcoin transaction lock time, defaults to 0. :type locktime: int :returns: RefundTransaction -- Bitcoin refund transaction instance. >>> from shuttle.providers.bitcoin.transaction import RefundTransaction >>> from shuttle.providers.bitcoin.wallet import Wallet >>> sender_wallet = Wallet(network="testnet").from_passphrase("meherett") >>> refund_transaction = RefundTransaction(network="testnet") >>> refund_transaction.build_transaction(transaction_id="1006a6f537fcc4888c65f6ff4f91818a1c6e19bdd3130f59391c00212c552fbd", wallet=sender_wallet, amount=10000) <shuttle.providers.bitcoin.transaction.RefundTransaction object at 0x0409DAF0> """ # Checking parameter instances if not isinstance(transaction_id, str): raise TypeError("invalid amount instance, only takes string type") if not isinstance(wallet, Wallet): raise TypeError( "invalid wallet instance, only takes Bitcoin Wallet class") # Setting transaction_id and wallet self.transaction_id, self.wallet = transaction_id, wallet # Getting transaction detail by id self.transaction_detail = get_transaction_detail(self.transaction_id) # Getting Hash time lock contract output detail self.htlc_detail = self.transaction_detail["outputs"][0] # Getting HTLC funded amount balance htlc_amount = self.htlc_detail["value"] # Calculating fee self._fee = fee_calculator(1, 1) if amount < self._fee: raise BalanceError("insufficient spend utxos") elif not htlc_amount >= (amount - self._fee): raise BalanceError("insufficient spend utxos", f"maximum you can withdraw {htlc_amount}") # Building mutable Bitcoin transaction self.transaction = MutableTransaction( version=self.version, ins=[ TxIn(txid=self.transaction_id, txout=0, script_sig=ScriptSig.empty(), sequence=Sequence.max()) ], outs=[ TxOut(value=(amount - self._fee), n=0, script_pubkey=P2pkhScript.unhexlify( hex_string=self.wallet.p2pkh())) ], locktime=Locktime(locktime)) self._type = "bitcoin_refund_unsigned" return self # Signing refund transaction def sign(self, solver): """ Sign Bitcoin refund transaction. :param solver: Bitcoin refund solver. :type solver: bitcoin.solver.RefundSolver :returns: RefundTransaction -- Bitcoin refund transaction instance. >>> from shuttle.providers.bitcoin.transaction import RefundTransaction >>> from shuttle.providers.bitcoin.solver import RefundSolver >>> from shuttle.providers.bitcoin.wallet import Wallet >>> sender_wallet = Wallet(network="testnet").from_passphrase("meherett1234") >>> refund_solver = RefundSolver(sender_wallet.private_key(), "3a26da82ead15a80533a02696656b14b5dbfd84eb14790f2e1be5e9e45820eeb", "muTnffLDR5LtFeLR2i3WsKVfdyvzfyPnVB", sender_wallet.address(), 1000) >>> refund_transaction = RefundTransaction(network="testnet") >>> refund_transaction.build_transaction("1006a6f537fcc4888c65f6ff4f91818a1c6e19bdd3130f59391c00212c552fbd", sender_wallet, 10000) >>> refund_transaction.sign(solver=refund_solver) <shuttle.providers.bitcoin.transaction.RefundTransaction object at 0x0409DAF0> """ # Checking parameter instances if not isinstance(solver, RefundSolver): raise TypeError( "invalid solver instance, only takes Bitcoin RefundSolver class" ) if self.transaction is None: raise ValueError( "transaction script is none, build transaction first") self.transaction.spend([ TxOut(value=self.htlc_detail["value"], n=0, script_pubkey=P2shScript.unhexlify( hex_string=self.htlc_detail["script"])) ], [ P2shSolver(redeem_script=solver.witness(network=self.network), redeem_script_solver=solver.solve()) ]) self._type = "bitcoin_refund_signed" return self def unsigned_raw(self): """ Get Bitcoin unsigned refund transaction raw. :returns: str -- Bitcoin unsigned refund transaction raw. >>> from shuttle.providers.bitcoin.transaction import RefundTransaction >>> from shuttle.providers.bitcoin.wallet import Wallet >>> sender_wallet = Wallet(network="testnet").from_passphrase("meherett1234") >>> refund_transaction = RefundTransaction(network="testnet") >>> refund_transaction.build_transaction("1006a6f537fcc4888c65f6ff4f91818a1c6e19bdd3130f59391c00212c552fbd", sender_wallet, 10000) >>> refund_transaction.unsigned_raw() "eyJmZWUiOiA2NzgsICJyYXciOiAiMDIwMDAwMDAwMTJjMzkyMjE3NDgzOTA2ZjkwMmU3M2M0YmMxMzI4NjRkZTU4MTUzNzcyZDc5MjY4OTYwOTk4MTYyMjY2NjM0YmUwMTAwMDAwMDAwZmZmZmZmZmYwMmU4MDMwMDAwMDAwMDAwMDAxN2E5MTQ5NzE4OTRjNThkODU5ODFjMTZjMjA1OWQ0MjJiY2RlMGIxNTZkMDQ0ODdhNjI5MDAwMDAwMDAwMDAwMTk3NmE5MTQ2YmNlNjVlNThhNTBiOTc5ODk5MzBlOWE0ZmYxYWMxYTc3NTE1ZWYxODhhYzAwMDAwMDAwIiwgIm91dHB1dHMiOiBbeyJhbW91bnQiOiAxMjM0MCwgIm4iOiAxLCAic2NyaXB0IjogIjc2YTkxNDZiY2U2NWU1OGE1MGI5Nzk4OTkzMGU5YTRmZjFhYzFhNzc1MTVlZjE4OGFjIn1dLCAidHlwZSI6ICJiaXRjb2luX2Z1bmRfdW5zaWduZWQifQ" """ # Checking transaction if self.transaction is None: raise ValueError( "transaction script is none, build transaction first") # Encoding refund transaction raw return b64encode( str( json.dumps( dict(fee=self._fee, raw=self.transaction.hexlify(), outputs=dict( value=self.htlc_detail["value"], n=0, script_pubkey=self.htlc_detail["script"]), network=self.network, type="bitcoin_refund_unsigned"))).encode()).decode()
def test_all(self): global keys priv = PrivateKey.from_bip32(keys[0][1]) pk = priv.pub() addr_string = str(pk.to_address()) utxo = [] for i in range(3): # create 3 tx to add to UTXO txid = regtest.send_rpc_cmd(['sendtoaddress', addr_string, '100'], 0) to_spend = Transaction.unhexlify( regtest.send_rpc_cmd(['getrawtransaction', txid, '0'], 0)) txout = None for out in to_spend.outs: if str(out.script_pubkey.address()) == addr_string: txout = out break assert txout is not None utxo.append({ 'txid': txid, 'txout': txout, 'solver': P2pkhSolver(priv), 'next_seq': Sequence.max(), 'next_locktime': Locktime(0) }) regtest.send_rpc_cmd(['generate', '100'], 0) generate = False next_locktime = Locktime(0) next_sequence = Sequence.max() i = 0 # 1785 # 382 # 2376 # 1180 # while i < len(self.all) - 2: print('{:04d}\r'.format(i), end='') ins = [ MutableTxIn(unspent['txid'], unspent['txout'].n, ScriptSig.empty(), unspent['next_seq']) for unspent in utxo ] outs = [] prev_types = [] for j, (unspent, script) in enumerate(zip(utxo, self.all[i:i + 3])): outs.append( TxOut(unspent['txout'].value - 1000000, j, script[0])) prev_types.append(script[2]) tx = MutableTransaction( 2, ins, outs, min_locktime(unspent['next_locktime'] for unspent in utxo)) tx = tx.spend([unspent['txout'] for unspent in utxo], [unspent['solver'] for unspent in utxo]) # print('====================') # print('txid: {}'.format(tx.txid)) # print() # print(tx) # print() # print('raw: {}'.format(tx.hexlify())) # print('prev_scripts, amounts, solvers:') for unspent in utxo: if isinstance(unspent['solver'], P2shSolver): if isinstance(unspent['solver'].redeem_script_solver, P2wshV0Solver): prev = unspent[ 'solver'].redeem_script_solver.witness_script else: prev = unspent['solver'].redeem_script elif isinstance(unspent['solver'], P2wshV0Solver): prev = unspent['solver'].witness_script else: prev = unspent['txout'].script_pubkey print(prev, unspent['txout'].value, unspent['solver'].__class__.__name__) regtest.send_rpc_cmd(['sendrawtransaction', tx.hexlify()], 0) utxo = [] for j, (output, prev_type) in enumerate(zip(tx.outs, prev_types)): if 'time' in prev_type: if 'absolute' in prev_type: next_locktime = Locktime(100) next_sequence = Sequence(0xfffffffe) if 'relative' in prev_type: next_sequence = Sequence(3) generate = True else: next_locktime = Locktime(0) next_sequence = Sequence.max() utxo.append({ 'txid': tx.txid, 'txout': output, 'solver': self.all[i + j][1][0], # solver 'next_seq': next_sequence, 'next_locktime': next_locktime }) if generate: regtest.send_rpc_cmd(['generate', '4'], 0) generate = False if not i % 10: regtest.send_rpc_cmd(['generate', '2'], 0) i += 1 ins = [ MutableTxIn(unspent['txid'], unspent['txout'].n, ScriptSig.empty(), unspent['next_seq']) for unspent in utxo ] tx = MutableTransaction( 2, ins, [ TxOut( sum(unspent['txout'].value for unspent in utxo) - 1000000, 0, self.final['script']) ], min_locktime(unspent['next_locktime'] for unspent in utxo)) tx = tx.spend([unspent['txout'] for unspent in utxo], [unspent['solver'] for unspent in utxo]) # print('====================') # print('txid: {}'.format(tx.txid)) # print() # print(tx) # print() # print('raw: {}'.format(tx.hexlify())) # print('prev_scripts, amounts, solvers:') for unspent in utxo: print(unspent['txout'].script_pubkey, unspent['txout'].value, unspent['solver'].__class__.__name__) regtest.send_rpc_cmd(['sendrawtransaction', tx.hexlify()], 0) regtest.teardown()
class RefundTransaction(Transaction): """ Bitcoin Refund transaction. :param network: Bitcoin network, defaults to ``mainnet``. :type network: str :param version: Bitcoin transaction version, defaults to ``2``. :type version: int :returns: RefundTransaction -- Bitcoin refund transaction instance. .. warning:: Do not forget to build transaction after initialize refund transaction. """ def __init__(self, network: str = config["network"], version: int = config["version"]): super().__init__(network=network, version=version) self._transaction_hash: Optional[str] = None self._transaction_detail: Optional[dict] = None self._htlc_utxo: Optional[dict] = None self._interest: Optional[int] = None def build_transaction( self, address: str, transaction_hash: str, locktime: int = config["locktime"]) -> "RefundTransaction": """ Build Bitcoin refund transaction. :param address: Bitcoin sender address. :type address: str :param transaction_hash: Bitcoin funded transaction hash/id. :type transaction_hash: str :param locktime: Bitcoin transaction lock time, defaults to ``0``. :type locktime: int :returns: RefundTransaction -- Bitcoin refund transaction instance. >>> from swap.providers.bitcoin.transaction import RefundTransaction >>> refund_transaction: RefundTransaction = RefundTransaction("testnet") >>> refund_transaction.build_transaction(address="n1wgm6kkzMcNfAtJmes8YhpvtDzdNhDY5a", transaction_hash="a211d21110756b266925fee2fbf2dc81529beef5e410311b38578dc3a076fb31") <swap.providers.bitcoin.transaction.RefundTransaction object at 0x0409DAF0> """ # Check parameter instances if not is_address(address, self._network): raise AddressError( f"Invalid Bitcoin sender '{address}' {self._network} address.") # Set address and transaction_hash self._address, self._transaction_hash, = address, transaction_hash # Get transaction self._transaction_detail = get_transaction( transaction_hash=self._transaction_hash, network=self._network) # Find HTLC UTXO self._htlc_utxo = find_p2sh_utxo(transaction=self._transaction_detail) if self._htlc_utxo is None: raise ValueError( "Invalid transaction id, there is no pay to script hash (P2SH) address." ) self._amount = self._htlc_utxo["value"] # Calculate the fee self._fee = fee_calculator(1, 1) outputs: list = [ TxOut(value=(self._amount - self._fee), n=0, script_pubkey=get_address_hash(address=self._address, script=True)) ] # Build mutable transaction self._transaction = MutableTransaction( version=self._version, ins=[ TxIn(txid=self._transaction_hash, txout=self._htlc_utxo["position"], script_sig=ScriptSig.empty(), sequence=Sequence.max()) ], outs=outputs, locktime=Locktime(locktime)) # Set transaction type self._type = "bitcoin_refund_unsigned" return self def sign(self, solver: RefundSolver) -> "RefundTransaction": """ Sign Bitcoin refund transaction. :param solver: Bitcoin refund solver. :type solver: bitcoin.solver.RefundSolver :returns: RefundTransaction -- Bitcoin refund transaction instance. >>> from swap.providers.bitcoin.transaction import RefundTransaction >>> refund_transaction: RefundTransaction = RefundTransaction("testnet") >>> refund_transaction.build_transaction(address="n1wgm6kkzMcNfAtJmes8YhpvtDzdNhDY5a", transaction_hash="a211d21110756b266925fee2fbf2dc81529beef5e410311b38578dc3a076fb31") >>> bytecode: str = "63aa20821124b554d13f247b1e5d10b84e44fb1296f18f38bbaa1bea34a12c843e01588876a9140a0a6590e6ba4b48118d21b86812615219ece76b88ac67040ec4d660b17576a914e00ff2a640b7ce2d336860739169487a57f84b1588ac68" >>> refund_solver: RefundSolver = RefundSolver(xprivate_key="tprv8ZgxMBicQKsPeMHMJAc6uWGYiGqi1MVM2ybmzXL2TAoDpQe85uyDpdT7mv7Nhdu5rTCBEKLZsd9KyP2LQZJzZTvgVQvENArgU8e6DoYBiXf", bytecode=bytecode, endtime=1624687630) >>> refund_transaction.sign(solver=refund_solver) <swap.providers.bitcoin.transaction.RefundTransaction object at 0x0409DAF0> """ # Check parameter instances if not isinstance(solver, RefundSolver): raise TypeError( f"Solver must be Bitcoin RefundSolver, not {type(solver).__name__} type." ) if self._transaction is None: raise ValueError("Transaction is none, build transaction first.") self._transaction.spend([ TxOut(value=self._htlc_utxo["value"], n=0, script_pubkey=P2shScript.unhexlify( hex_string=self._htlc_utxo["script"])) ], [ P2shSolver( redeem_script=solver.witness(network=self._network), redeem_script_solver=solver.solve(network=self._network)) ]) # Set transaction type self._type = "bitcoin_refund_signed" return self def transaction_raw(self) -> str: """ Get Bitcoin refund transaction raw. :returns: str -- Bitcoin refund transaction raw. >>> from swap.providers.bitcoin.transaction import RefundTransaction >>> refund_transaction: RefundTransaction = RefundTransaction("testnet") >>> refund_transaction.build_transaction(address="n1wgm6kkzMcNfAtJmes8YhpvtDzdNhDY5a", transaction_hash="a211d21110756b266925fee2fbf2dc81529beef5e410311b38578dc3a076fb31") >>> refund_transaction.transaction_raw() "eyJmZWUiOiA1NzYsICJyYXciOiAiMDIwMDAwMDAwMTMxZmI3NmEwYzM4ZDU3MzgxYjMxMTBlNGY1ZWU5YjUyODFkY2YyZmJlMmZlMjU2OTI2NmI3NTEwMTFkMjExYTIwMDAwMDAwMDAwZmZmZmZmZmYwMTYwODQwMTAwMDAwMDAwMDAxOTc2YTkxNGUwMGZmMmE2NDBiN2NlMmQzMzY4NjA3MzkxNjk0ODdhNTdmODRiMTU4OGFjMDAwMDAwMDAiLCAib3V0cHV0cyI6IHsidmFsdWUiOiAxMDAwMDAsICJ0eF9vdXRwdXRfbiI6IDAsICJzY3JpcHQiOiAiYTkxNGM4Yzc3YTliNDNlZTJiZGYxYTA3YzQ4Njk5ODMzZDc2NjhiZjI2NGM4NyJ9LCAibmV0d29yayI6ICJ0ZXN0bmV0IiwgInR5cGUiOiAiYml0Y29pbl9yZWZ1bmRfdW5zaWduZWQifQ==" """ # Check transaction if self._transaction is None: raise ValueError("Transaction is none, build transaction first.") # Encode refund transaction raw if self._type == "bitcoin_refund_signed": return clean_transaction_raw( b64encode( str( json.dumps( dict( raw=self._transaction.hexlify(), fee=self._fee, network=self._network, type=self._type, ))).encode()).decode()) return clean_transaction_raw( b64encode( str( json.dumps( dict( fee=self._fee, raw=self._transaction.hexlify(), outputs=dict(value=self._htlc_utxo["value"], tx_output_n=0, script=self._htlc_utxo["script"]), network=self._network, type=self._type, ))).encode()).decode())
class FundTransaction(Transaction): """ Bitcoin FundTransaction class. :param version: Bitcoin transaction version, defaults to 2. :type version: int :param network: Bitcoin network, defaults to testnet. :type network: str :returns: FundTransaction -- Bitcoin fund transaction instance. .. warning:: Do not forget to build transaction after initialize fund transaction. """ # Initialization fund transaction def __init__(self, version=2, network="testnet"): super().__init__(version=version, network=network) # Initialization wallet, htlc, amount and unspent self.wallet, self.htlc, self.amount, self.unspent = None, None, None, None # Getting previous transaction indexes using funding amount self.previous_transaction_indexes = None # Building transaction def build_transaction(self, wallet, htlc, amount, locktime=0): """ Build Bitcoin fund transaction. :param wallet: Bitcoin sender wallet. :type wallet: bitcoin.wallet.Wallet :param htlc: Bitcoin hash time lock contract (HTLC). :type htlc: bitcoin.htlc.HTLC :param amount: Bitcoin amount to fund. :type amount: int :param locktime: Bitcoin transaction lock time, defaults to 0. :type locktime: int :returns: FundTransaction -- Bitcoin fund transaction instance. >>> from shuttle.providers.bitcoin.htlc import HTLC >>> from shuttle.providers.bitcoin.transaction import FundTransaction >>> from shuttle.providers.bitcoin.wallet import Wallet >>> htlc = HTLC(network="testnet").init("821124b554d13f247b1e5d10b84e44fb1296f18f38bbaa1bea34a12c843e0158", "muTnffLDR5LtFeLR2i3WsKVfdyvzfyPnVB", "mphBPZf15cRFcL5tUq6mCbE84XobZ1vg7Q", 1000) >>> sender_wallet = Wallet(network="testnet").from_passphrase("meherett") >>> fund_transaction = FundTransaction(network="testnet") >>> fund_transaction.build_transaction(wallet=sender_wallet, htlc=htlc, amount=10000) <shuttle.providers.bitcoin.transaction.FundTransaction object at 0x0409DAF0> """ # Checking parameter instances if not isinstance(wallet, Wallet): raise TypeError( "invalid wallet instance, only takes Bitcoin Wallet class") if not isinstance(htlc, HTLC): raise TypeError( "invalid htlc instance, only takes Bitcoin HTLC class") if not isinstance(amount, int): raise TypeError("invalid amount instance, only takes integer type") # Setting wallet, htlc, amount and unspent self.wallet, self.htlc, self.amount = wallet, htlc, amount # Getting unspent transaction output self.unspent = self.wallet.unspent() # Setting previous transaction indexes self.previous_transaction_indexes = \ self.get_previous_transaction_indexes(amount=self.amount) # Getting transaction inputs and amount inputs, amount = self.inputs( utxos=self.unspent, previous_transaction_indexes=self.previous_transaction_indexes) # Calculating Bitcoin fee self._fee = fee_calculator(len(inputs), 2) if amount < (self.amount + self._fee): raise BalanceError("insufficient spend utxos") # Building mutable Bitcoin transaction self.transaction = MutableTransaction( version=self.version, ins=inputs, outs=[ # Funding into hash time lock contract script hash TxOut(value=self.amount, n=0, script_pubkey=P2shScript.unhexlify( hex_string=self.htlc.hash())), # Controlling amounts when we are funding on htlc script TxOut(value=(amount - (self._fee + self.amount)), n=1, script_pubkey=P2pkhScript.unhexlify( hex_string=self.wallet.p2pkh())) ], locktime=Locktime(locktime)) self._type = "bitcoin_fund_unsigned" return self # Signing fund transaction def sign(self, solver): """ Sign Bitcoin fund transaction. :param solver: Bitcoin fund solver. :type solver: bitcoin.solver.FundSolver :returns: FundTransaction -- Bitcoin fund transaction instance. >>> from shuttle.providers.bitcoin.htlc import HTLC >>> from shuttle.providers.bitcoin.transaction import FundTransaction >>> from shuttle.providers.bitcoin.solver import FundSolver >>> from shuttle.providers.bitcoin.wallet import Wallet >>> htlc = HTLC(network="testnet").init("821124b554d13f247b1e5d10b84e44fb1296f18f38bbaa1bea34a12c843e0158", "muTnffLDR5LtFeLR2i3WsKVfdyvzfyPnVB", "mphBPZf15cRFcL5tUq6mCbE84XobZ1vg7Q", 1000) >>> sender_wallet = Wallet(network="testnet").from_passphrase("meherett") >>> fund_solver = FundSolver("92cbbc5990cb5090326a76feeb321cad01048635afe5756523bbf9f7a75bf38b") >>> fund_transaction = FundTransaction(network="testnet") >>> fund_transaction.build_transaction(sender_wallet, htlc, 10000) >>> fund_transaction.sign(solver=fund_solver) <shuttle.providers.bitcoin.transaction.FundTransaction object at 0x0409DAF0> """ # Checking parameter instances if not isinstance(solver, FundSolver): raise TypeError( "invalid solver instance, only takes Bitcoin FundSolver class") if not self.unspent or not self.previous_transaction_indexes or not self.transaction: raise ValueError( "transaction script or unspent is none, build transaction first" ) # Organizing outputs outputs = self.outputs(self.unspent, self.previous_transaction_indexes) # Signing fund transaction self.transaction.spend(outputs, [solver.solve() for _ in outputs]) self._type = "bitcoin_fund_signed" return self # Automatically analysis previous transaction indexes using fund amount def get_previous_transaction_indexes(self, amount=None): if amount is None: amount = self.amount temp_amount = int() previous_transaction_indexes = list() for index, unspent in enumerate(self.unspent): temp_amount += unspent["amount"] if temp_amount > (amount + fee_calculator((index + 1), 2)): previous_transaction_indexes.append(index) break previous_transaction_indexes.append(index) return previous_transaction_indexes def unsigned_raw(self): """ Get Bitcoin unsigned fund transaction raw. :returns: str -- Bitcoin unsigned fund transaction raw. >>> from shuttle.providers.bitcoin.htlc import HTLC >>> from shuttle.providers.bitcoin.transaction import FundTransaction >>> from shuttle.providers.bitcoin.wallet import Wallet >>> htlc = HTLC(network="testnet").init("821124b554d13f247b1e5d10b84e44fb1296f18f38bbaa1bea34a12c843e0158", "muTnffLDR5LtFeLR2i3WsKVfdyvzfyPnVB", "mphBPZf15cRFcL5tUq6mCbE84XobZ1vg7Q", 1000) >>> sender_wallet = Wallet(network="testnet").from_passphrase("meherett") >>> fund_transaction = FundTransaction(network="testnet") >>> fund_transaction.build_transaction(sender_wallet, htlc, 10000) >>> fund_transaction.unsigned_raw() "eyJmZWUiOiA2NzgsICJyYXciOiAiMDIwMDAwMDAwMTJjMzkyMjE3NDgzOTA2ZjkwMmU3M2M0YmMxMzI4NjRkZTU4MTUzNzcyZDc5MjY4OTYwOTk4MTYyMjY2NjM0YmUwMTAwMDAwMDAwZmZmZmZmZmYwMmU4MDMwMDAwMDAwMDAwMDAxN2E5MTQ5NzE4OTRjNThkODU5ODFjMTZjMjA1OWQ0MjJiY2RlMGIxNTZkMDQ0ODdhNjI5MDAwMDAwMDAwMDAwMTk3NmE5MTQ2YmNlNjVlNThhNTBiOTc5ODk5MzBlOWE0ZmYxYWMxYTc3NTE1ZWYxODhhYzAwMDAwMDAwIiwgIm91dHB1dHMiOiBbeyJhbW91bnQiOiAxMjM0MCwgIm4iOiAxLCAic2NyaXB0IjogIjc2YTkxNDZiY2U2NWU1OGE1MGI5Nzk4OTkzMGU5YTRmZjFhYzFhNzc1MTVlZjE4OGFjIn1dLCAidHlwZSI6ICJiaXRjb2luX2Z1bmRfdW5zaWduZWQifQ" """ # Checking transaction and UTXO if not self.transaction or not self.unspent: raise ValueError( "transaction script or unspent is none, build transaction first" ) outputs = [] for index, utxo in enumerate(self.unspent): if self.previous_transaction_indexes is None or \ index in self.previous_transaction_indexes: outputs.append( dict(amount=utxo["amount"], n=utxo["output_index"], script=utxo["script"])) # Encoding fund transaction raw return b64encode( str( json.dumps( dict(fee=self._fee, raw=self.transaction.hexlify(), outputs=outputs, network=self.network, type="bitcoin_fund_unsigned"))).encode()).decode()
class WithdrawTransaction(Transaction): """ Bitcoin Withdraw transaction. :param network: Bitcoin network, defaults to ``mainnet``. :type network: str :param version: Bitcoin transaction version, defaults to ``2``. :type version: int :returns: WithdrawTransaction -- Bitcoin withdraw transaction instance. .. warning:: Do not forget to build transaction after initialize withdraw transaction. """ def __init__(self, network: str = config["network"], version: int = config["version"]): super().__init__(network=network, version=version) self._transaction_hash: Optional[str] = None self._transaction_detail: Optional[dict] = None self._htlc_utxo: Optional[dict] = None self._interest: Optional[int] = None def build_transaction( self, address: str, transaction_hash: str, locktime: int = config["locktime"]) -> "WithdrawTransaction": """ Build Bitcoin withdraw transaction. :param address: Bitcoin recipient address. :type address: str :param transaction_hash: Bitcoin funded transaction hash/id. :type transaction_hash: str :param locktime: Bitcoin transaction lock time, defaults to ``0``. :type locktime: int :returns: WithdrawTransaction -- Bitcoin withdraw transaction instance. >>> from swap.providers.bitcoin.transaction import WithdrawTransaction >>> withdraw_transaction: WithdrawTransaction = WithdrawTransaction("testnet") >>> withdraw_transaction.build_transaction(address="mgS3WMHp9nvdUPeDJxr5iCF2P5HuFZSR3V", transaction_hash="a211d21110756b266925fee2fbf2dc81529beef5e410311b38578dc3a076fb31") <swap.providers.bitcoin.transaction.WithdrawTransaction object at 0x0409DAF0> """ # Check parameter instances if not is_address(address, self._network): raise AddressError( f"Invalid Bitcoin recipient '{address}' {self._network} address." ) # Set address and transaction hash self._address, self._transaction_hash, = address, transaction_hash # Get transaction self._transaction_detail = get_transaction( transaction_hash=self._transaction_hash, network=self._network) # Find HTLC UTXO self._htlc_utxo = find_p2sh_utxo(transaction=self._transaction_detail) if self._htlc_utxo is None: raise ValueError( "Invalid transaction hash, there is no pay to script hash (P2SH) address." ) self._amount = self._htlc_utxo["value"] # Calculate the fee self._fee = fee_calculator(1, 1) outputs: list = [ TxOut(value=(self._amount - self._fee), n=0, script_pubkey=get_address_hash(address=self._address, script=True)) ] # Build mutable transaction self._transaction = MutableTransaction( version=self._version, ins=[ TxIn(txid=self._transaction_hash, txout=self._htlc_utxo["position"], script_sig=ScriptSig.empty(), sequence=Sequence.max()) ], outs=outputs, locktime=Locktime(locktime)) # Set transaction type self._type = "bitcoin_withdraw_unsigned" return self def sign(self, solver: WithdrawSolver) -> "WithdrawTransaction": """ Sign Bitcoin withdraw transaction. :param solver: Bitcoin withdraw solver. :type solver: bitcoin.solver.WithdrawSolver :returns: WithdrawTransaction -- Bitcoin withdraw transaction instance. >>> from swap.providers.bitcoin.transaction import WithdrawTransaction >>> from swap.providers.bitcoin.solver import WithdrawSolver >>> withdraw_transaction: WithdrawTransaction = WithdrawTransaction("testnet") >>> withdraw_transaction.build_transaction(address="mgS3WMHp9nvdUPeDJxr5iCF2P5HuFZSR3V", transaction_hash="a211d21110756b266925fee2fbf2dc81529beef5e410311b38578dc3a076fb31") >>> bytecode: str = "63aa20821124b554d13f247b1e5d10b84e44fb1296f18f38bbaa1bea34a12c843e01588876a9140a0a6590e6ba4b48118d21b86812615219ece76b88ac67040ec4d660b17576a914e00ff2a640b7ce2d336860739169487a57f84b1588ac68" >>> withdraw_solver: WithdrawSolver = WithdrawSolver(xprivate_key="tprv8ZgxMBicQKsPf949JcuVFLXPJ5m4VKe33gVX3FYVZYVHr2dChU8K66aEQcPdHpUgACq5GQu81Z4e3QN1vxCrV4pxcUcXHoRTamXBRaPdJhW", secret_key="Hello Meheret!", bytecode=bytecode) >>> withdraw_transaction.sign(solver=withdraw_solver) <swap.providers.bitcoin.transaction.WithdrawTransaction object at 0x0409DAF0> """ # Check parameter instances if not isinstance(solver, WithdrawSolver): raise TypeError( f"Solver must be Bitcoin WithdrawSolver, not {type(solver).__name__} type." ) if self._transaction is None: raise ValueError("Transaction is none, build transaction first.") self._transaction.spend([ TxOut(value=self._htlc_utxo["value"], n=0, script_pubkey=P2shScript.unhexlify( hex_string=self._htlc_utxo["script"])) ], [ P2shSolver( redeem_script=solver.witness(network=self._network), redeem_script_solver=solver.solve(network=self._network)) ]) # Set transaction type self._type = "bitcoin_withdraw_signed" return self def transaction_raw(self) -> str: """ Get Bitcoin withdraw transaction raw. :returns: str -- Bitcoin withdraw transaction raw. >>> from swap.providers.bitcoin.transaction import WithdrawTransaction >>> withdraw_transaction: WithdrawTransaction = WithdrawTransaction("testnet") >>> withdraw_transaction.build_transaction(address="mgS3WMHp9nvdUPeDJxr5iCF2P5HuFZSR3V", transaction_hash="a211d21110756b266925fee2fbf2dc81529beef5e410311b38578dc3a076fb31") >>> withdraw_transaction.transaction_raw() "eyJmZWUiOiA1NzYsICJyYXciOiAiMDIwMDAwMDAwMTMxZmI3NmEwYzM4ZDU3MzgxYjMxMTBlNGY1ZWU5YjUyODFkY2YyZmJlMmZlMjU2OTI2NmI3NTEwMTFkMjExYTIwMDAwMDAwMDAwZmZmZmZmZmYwMTYwODQwMTAwMDAwMDAwMDAxOTc2YTkxNDBhMGE2NTkwZTZiYTRiNDgxMThkMjFiODY4MTI2MTUyMTllY2U3NmI4OGFjMDAwMDAwMDAiLCAib3V0cHV0cyI6IHsidmFsdWUiOiAxMDAwMDAsICJ0eF9vdXRwdXRfbiI6IDAsICJzY3JpcHQiOiAiYTkxNGM4Yzc3YTliNDNlZTJiZGYxYTA3YzQ4Njk5ODMzZDc2NjhiZjI2NGM4NyJ9LCAibmV0d29yayI6ICJ0ZXN0bmV0IiwgInR5cGUiOiAiYml0Y29pbl93aXRoZHJhd191bnNpZ25lZCJ9" """ # Check transaction if self._transaction is None: raise ValueError("Transaction is none, build transaction first.") # Encode withdraw transaction raw if self._type == "bitcoin_withdraw_signed": return clean_transaction_raw( b64encode( str( json.dumps( dict( raw=self._transaction.hexlify(), fee=self._fee, network=self._network, type=self._type, ))).encode()).decode()) return clean_transaction_raw( b64encode( str( json.dumps( dict( fee=self._fee, raw=self._transaction.hexlify(), outputs=dict(value=self._htlc_utxo["value"], tx_output_n=0, script=self._htlc_utxo["script"]), network=self._network, type=self._type, ))).encode()).decode())
class FundTransaction(Transaction): """ Bitcoin Fund transaction. :param network: Bitcoin network, defaults to ``mainnet``. :type network: str :param version: Bitcoin transaction version, defaults to ``2``. :type version: int :returns: FundTransaction -- Bitcoin fund transaction instance. .. warning:: Do not forget to build transaction after initialize fund transaction. """ def __init__(self, network: str = config["network"], version: int = config["version"]): super().__init__(network=network, version=version) self._htlc: Optional[HTLC] = None self._utxos: Optional[list] = None self._previous_transaction_indexes: Optional[list] = None self._interest: Optional[int] = None def build_transaction( self, address: str, htlc: HTLC, amount: Optional[Union[int, float]], unit: str = config["unit"], locktime: int = config["locktime"]) -> "FundTransaction": """ Build Bitcoin fund transaction. :param address: Bitcoin sender address. :type address: str :param htlc: Bitcoin HTLC instance. :type htlc: bitcoin.htlc.HTLC :param amount: Bitcoin amount, default to ``None``. :type amount: int, float :param unit: Bitcoin unit, default to ``Satoshi``. :type unit: str :param locktime: Bitcoin transaction lock time, defaults to ``0``. :type locktime: int :returns: FundTransaction -- Bitcoin fund transaction instance. >>> from swap.providers.bitcoin.htlc import HTLC >>> from swap.providers.bitcoin.transaction import FundTransaction >>> from swap.utils import sha256 >>> htlc: HTLC = HTLC(network="testnet") >>> htlc.build_htlc(secret_hash=sha256("Hello Meheret!"), recipient_address="mgS3WMHp9nvdUPeDJxr5iCF2P5HuFZSR3V", sender_address="n1wgm6kkzMcNfAtJmes8YhpvtDzdNhDY5a", endtime=1624687630) >>> fund_transaction: FundTransaction = FundTransaction(network="testnet") >>> fund_transaction.build_transaction(address="n1wgm6kkzMcNfAtJmes8YhpvtDzdNhDY5a", htlc=htlc, amount=0.001, unit="BTC") <swap.providers.bitcoin.transaction.FundTransaction object at 0x0409DAF0> """ # Check parameter instances if not is_address(address, self._network): raise AddressError( f"Invalid Bitcoin sender '{address}' {self._network} address.") if not isinstance(htlc, HTLC): raise TypeError( "Invalid Bitcoin HTLC instance, only takes xinfin HTLC class") if htlc.agreements and address != htlc.agreements["sender_address"]: raise AddressError( f"Wrong Bitcoin sender '{address}' address", "address must be equal with HTLC agreements sender address.") if unit not in ["BTC", "mBTC", "Satoshi"]: raise UnitError( "Invalid Bitcoin unit, choose only 'BTC', 'mBTC' or 'Satoshi' units." ) self._address, outputs, self._htlc, self._amount = ( address, [], htlc, (amount if unit == "Satoshi" else amount_unit_converter( amount=amount, unit_from=f"{unit}2Satoshi"))) # Get Sender UTXO's self._utxos = get_utxos(address=self._address, network=self._network) # Outputs action outputs.append( TxOut(value=self._amount, n=0, script_pubkey=get_address_hash( address=self._htlc.contract_address(), script=True))) # Get previous transaction indexes self._previous_transaction_indexes, max_amount = _get_previous_transaction_indexes( utxos=self._utxos, amount=self._amount, transaction_output=2) # Build transaction inputs inputs, amount = _build_inputs( utxos=self._utxos, previous_transaction_indexes=self._previous_transaction_indexes) # Calculate the fee self._fee = fee_calculator(len(inputs), 2) if amount < self._amount: raise BalanceError("Insufficient spend UTXO's", "you don't have enough amount.") elif amount < (self._amount + self._fee): raise BalanceError( f"You don't have enough amount to pay '{self._fee}' Satoshi fee", f"you can spend maximum '{amount - self._fee}' Satoshi amount." ) return_amount: int = int(amount - (self._amount + self._fee)) if return_amount != 0: outputs.append( TxOut(value=return_amount, n=len(outputs), script_pubkey=get_address_hash(address=self._address, script=True))) # Build mutable transaction self._transaction = MutableTransaction(version=self._version, ins=inputs, outs=outputs, locktime=Locktime(locktime)) # Set transaction type self._type = "bitcoin_fund_unsigned" return self def sign(self, solver: FundSolver) -> "FundTransaction": """ Sign Bitcoin fund transaction. :param solver: Bitcoin fund solver. :type solver: bitcoin.solver.FundSolver :returns: FundTransaction -- Bitcoin fund transaction instance. >>> from swap.providers.bitcoin.htlc import HTLC >>> from swap.providers.bitcoin.transaction import FundTransaction >>> from swap.providers.bitcoin.solver import FundSolver >>> from swap.utils import sha256 >>> htlc: HTLC = HTLC(network="testnet") >>> htlc.build_htlc(secret_hash=sha256("Hello Meheret!"), recipient_address="mgS3WMHp9nvdUPeDJxr5iCF2P5HuFZSR3V", sender_address="n1wgm6kkzMcNfAtJmes8YhpvtDzdNhDY5a", endtime=1624687630) >>> fund_transaction: FundTransaction = FundTransaction(network="testnet") >>> fund_transaction.build_transaction(address="n1wgm6kkzMcNfAtJmes8YhpvtDzdNhDY5a", htlc=htlc, amount=0.001, unit="BTC") >>> fund_solver: FundSolver = FundSolver(xprivate_key="tprv8ZgxMBicQKsPeMHMJAc6uWGYiGqi1MVM2ybmzXL2TAoDpQe85uyDpdT7mv7Nhdu5rTCBEKLZsd9KyP2LQZJzZTvgVQvENArgU8e6DoYBiXf") >>> fund_transaction.sign(solver=fund_solver) <swap.providers.bitcoin.transaction.FundTransaction object at 0x0409DAF0> """ # Check parameter instances if not isinstance(solver, FundSolver): raise TypeError( f"Solver must be Bitcoin FundSolver, not {type(solver).__name__} type." ) if self._transaction is None: raise ValueError("Transaction is none, build transaction first.") # Organize outputs outputs = _build_outputs( utxos=self._utxos, previous_transaction_indexes=self._previous_transaction_indexes) # Sign fund transaction self._transaction.spend( txouts=outputs, solvers=[solver.solve(network=self._network) for _ in outputs]) # Set transaction type self._type = "bitcoin_fund_signed" return self def transaction_raw(self) -> str: """ Get Bitcoin fund transaction raw. :returns: str -- Bitcoin fund transaction raw. >>> from swap.providers.bitcoin.htlc import HTLC >>> from swap.providers.bitcoin.transaction import FundTransaction >>> from swap.utils import sha256 >>> htlc: HTLC = HTLC(network="testnet") >>> htlc.build_htlc(secret_hash=sha256("Hello Meheret!"), recipient_address="mgS3WMHp9nvdUPeDJxr5iCF2P5HuFZSR3V", sender_address="n1wgm6kkzMcNfAtJmes8YhpvtDzdNhDY5a", endtime=1624687630) >>> fund_transaction: FundTransaction = FundTransaction(network="testnet") >>> fund_transaction.build_transaction(address="n1wgm6kkzMcNfAtJmes8YhpvtDzdNhDY5a", htlc=htlc, amount=0.001, unit="BTC") >>> fund_transaction.transaction_raw() "eyJmZWUiOiAxMTIyLCAicmF3IjogIjAyMDAwMDAwMDIzMWZiNzZhMGMzOGQ1NzM4MWIzMTEwZTRmNWVlOWI1MjgxZGNmMmZiZTJmZTI1NjkyNjZiNzUxMDExZDIxMWEyMDEwMDAwMDAwMGZmZmZmZmZmMDgwYjgyZWVjMzMyOTk2YTQyMmFlNGYwODBmNzRlNTNmZDJjYTRmMDcwMTFkNDdjNTkwODUzZTFlMzA1ZmUxMTAxMDAwMDAwMDBmZmZmZmZmZjAyYTA4NjAxMDAwMDAwMDAwMDE3YTkxNGM4Yzc3YTliNDNlZTJiZGYxYTA3YzQ4Njk5ODMzZDc2NjhiZjI2NGM4NzMyOWMwZDAwMDAwMDAwMDAxOTc2YTkxNGUwMGZmMmE2NDBiN2NlMmQzMzY4NjA3MzkxNjk0ODdhNTdmODRiMTU4OGFjMDAwMDAwMDAiLCAib3V0cHV0cyI6IFt7InZhbHVlIjogOTQzMzAsICJ0eF9vdXRwdXRfbiI6IDEsICJzY3JpcHQiOiAiNzZhOTE0ZTAwZmYyYTY0MGI3Y2UyZDMzNjg2MDczOTE2OTQ4N2E1N2Y4NGIxNTg4YWMifSwgeyJ2YWx1ZSI6IDg5ODc0NiwgInR4X291dHB1dF9uIjogMSwgInNjcmlwdCI6ICI3NmE5MTRlMDBmZjJhNjQwYjdjZTJkMzM2ODYwNzM5MTY5NDg3YTU3Zjg0YjE1ODhhYyJ9XSwgIm5ldHdvcmsiOiAidGVzdG5ldCIsICJ0eXBlIjogImJpdGNvaW5fZnVuZF91bnNpZ25lZCJ9" """ # Check parameter instances if self._transaction is None: raise ValueError("Transaction is none, build transaction first.") # Encode fund transaction raw if self._type == "bitcoin_fund_signed": return clean_transaction_raw( b64encode( str( json.dumps( dict( raw=self._transaction.hexlify(), fee=self._fee, network=self._network, type=self._type, ))).encode()).decode()) return clean_transaction_raw( b64encode( str( json.dumps( dict( fee=self._fee, raw=self._transaction.hexlify(), outputs=_build_outputs( utxos=self._utxos, previous_transaction_indexes=self. _previous_transaction_indexes, only_dict=True), network=self._network, type=self._type, ))).encode()).decode())
class NormalTransaction(Transaction): """ Bitcoin Normal transaction. :param network: Bitcoin network, defaults to ``mainnet``. :type network: str :param version: Bitcoin transaction version, defaults to ``2``. :type version: int :returns: NormalTransaction -- Bitcoin normal transaction instance. .. warning:: Do not forget to build transaction after initialize normal transaction. """ def __init__(self, network: str = config["network"], version: int = config["version"]): super().__init__(network=network, version=version) self._utxos: Optional[list] = None self._previous_transaction_indexes: Optional[list] = None self._interest: Optional[int] = None def build_transaction( self, address: str, recipients: dict, unit: str = config["unit"], locktime: int = config["locktime"]) -> "NormalTransaction": """ Build Bitcoin normal transaction. :param address: Bitcoin sender address. :type address: str :param recipients: Recipients Bitcoin address and amount. :type recipients: dict :param unit: Bitcoin unit, default to ``Satoshi``. :type unit: str :param locktime: Bitcoin transaction lock time, defaults to ``0``. :type locktime: int :returns: NormalTransaction -- Bitcoin normal transaction instance. >>> from swap.providers.bitcoin.transaction import NormalTransaction >>> normal_transaction: NormalTransaction = NormalTransaction(network="testnet") >>> normal_transaction.build_transaction(address="mkFWGt4hT11XS8dJKzzRFsTrqjjAwZfQAC", recipients={"2N6kHwQy6Ph5EdKNgzGrcW2WhGHKGfmP5ae": 10000000}, locktime=0) <swap.providers.bitcoin.transaction.NormalTransaction object at 0x0409DAF0> """ # Check parameter instances if not is_address(address, self._network): raise AddressError( f"Invalid Bitcoin sender '{address}' {self._network} address.") if unit not in ["BTC", "mBTC", "Satoshi"]: raise UnitError( "Invalid Bitcoin unit, choose only 'BTC', 'mBTC' or 'Satoshi' units." ) self._address, outputs, self._amount = (address, [], ( sum(recipients.values()) if unit == "Satoshi" else amount_unit_converter( amount=sum(recipients.values()), unit_from=f"{unit}2Satoshi"))) # Get Sender UTXO's self._utxos = get_utxos(address=self._address, network=self._network) # Outputs action for _address, _amount in recipients.items(): if not is_address(_address, self._network): raise AddressError( f"Invalid Bitcoin recipients '{_address}' {self._network} address." ) outputs.append( TxOut(value=int(_amount), n=len(outputs), script_pubkey=get_address_hash(address=_address, script=True))) # Get previous transaction indexes self._previous_transaction_indexes, max_amount = _get_previous_transaction_indexes( utxos=self._utxos, amount=self._amount, transaction_output=len(outputs)) # Build transaction inputs inputs, amount = _build_inputs( utxos=self._utxos, previous_transaction_indexes=self._previous_transaction_indexes) # Calculate the fee self._fee = fee_calculator(len(inputs), len(outputs)) if amount < self._amount: raise BalanceError("Insufficient spend UTXO's", "you don't have enough amount.") elif amount < (self._amount + self._fee): raise BalanceError( f"You don't have enough amount to pay '{self._fee}' Satoshi fee", f"you can spend maximum '{amount - self._fee}' Satoshi amount." ) return_amount: int = int(amount - (self._amount + self._fee)) if return_amount != 0: outputs.append( TxOut(value=return_amount, n=len(outputs), script_pubkey=get_address_hash(address=self._address, script=True))) # Build mutable transaction self._transaction = MutableTransaction(version=self._version, ins=inputs, outs=outputs, locktime=Locktime(locktime)) # Set transaction type self._type = "bitcoin_normal_unsigned" return self def sign(self, solver: NormalSolver) -> "NormalTransaction": """ Sign Bitcoin normal transaction. :param solver: Bitcoin normal solver. :type solver: bitcoin.solver.NormalSolver :returns: NormalTransaction -- Bitcoin normal transaction instance. >>> from swap.providers.bitcoin.transaction import NormalTransaction >>> from swap.providers.bitcoin.solver import NormalSolver >>> from swap.providers.bitcoin.wallet import Wallet, DEFAULT_PATH >>> sender_wallet: Wallet = Wallet(network="testnet").from_entropy(entropy="72fee73846f2d1a5807dc8c953bf79f1").from_path(path=DEFAULT_PATH) >>> normal_solver: NormalSolver = NormalSolver(xprivate_key=sender_wallet.root_xprivate_key()) >>> normal_transaction: NormalTransaction = NormalTransaction(network="testnet").build_transaction(address=sender_wallet.address(), recipients={"2N6kHwQy6Ph5EdKNgzGrcW2WhGHKGfmP5ae": 10000000}) >>> normal_transaction.sign(solver=normal_solver) <swap.providers.bitcoin.transaction.NormalTransaction object at 0x0409DAF0> """ # Check parameter instances if not isinstance(solver, NormalSolver): raise TypeError( f"Solver must be Bitcoin NormalSolver, not {type(solver).__name__} type." ) if self._transaction is None: raise ValueError("Transaction is none, build transaction first.") # Organize outputs outputs = _build_outputs( utxos=self._utxos, previous_transaction_indexes=self._previous_transaction_indexes) # Sign normal transaction self._transaction.spend( txouts=outputs, solvers=[solver.solve(network=self._network) for _ in outputs]) # Set transaction type self._type = "bitcoin_normal_signed" return self def transaction_raw(self) -> str: """ Get Bitcoin normal transaction raw. :returns: str -- Bitcoin normal transaction raw. >>> from swap.providers.bitcoin.transaction import NormalTransaction >>> normal_transaction: NormalTransaction = NormalTransaction(network="testnet") >>> normal_transaction.build_transaction(address="mkFWGt4hT11XS8dJKzzRFsTrqjjAwZfQAC", recipients={"2N6kHwQy6Ph5EdKNgzGrcW2WhGHKGfmP5ae": 10000000}) >>> normal_transaction.transaction_raw() "eyJmZWUiOiA2NzgsICJyYXciOiAiMDIwMDAwMDAwMTJjMzkyMjE3NDgzOTA2ZjkwMmU3M2M0YmMxMzI4NjRkZTU4MTUzNzcyZDc5MjY4OTYwOTk4MTYyMjY2NjM0YmUwMTAwMDAwMDAwZmZmZmZmZmYwMmU4MDMwMDAwMDAwMDAwMDAxN2E5MTQ5NzE4OTRjNThkODU5ODFjMTZjMjA1OWQ0MjJiY2RlMGIxNTZkMDQ0ODdhNjI5MDAwMDAwMDAwMDAwMTk3NmE5MTQ2YmNlNjVlNThhNTBiOTc5ODk5MzBlOWE0ZmYxYWMxYTc3NTE1ZWYxODhhYzAwMDAwMDAwIiwgIm91dHB1dHMiOiBbeyJhbW91bnQiOiAxMjM0MCwgIm4iOiAxLCAic2NyaXB0IjogIjc2YTkxNDZiY2U2NWU1OGE1MGI5Nzk4OTkzMGU5YTRmZjFhYzFhNzc1MTVlZjE4OGFjIn1dLCAidHlwZSI6ICJiaXRjb2luX2Z1bmRfdW5zaWduZWQifQ" """ # Check parameter instances if self._transaction is None: raise ValueError("Transaction is none, build transaction first.") # Encode normal transaction raw if self._type == "bitcoin_normal_signed": return clean_transaction_raw( b64encode( str( json.dumps( dict(raw=self._transaction.hexlify(), fee=self._fee, network=self._network, type=self._type))).encode()).decode()) return clean_transaction_raw( b64encode( str( json.dumps( dict(fee=self._fee, raw=self._transaction.hexlify(), outputs=_build_outputs( utxos=self._utxos, previous_transaction_indexes=self. _previous_transaction_indexes, only_dict=True), network=self._network, type=self._type))).encode()).decode())
class RefundTransaction(Transaction): """ Bitcoin RefundTransaction class. :param version: bitcoin transaction version, defaults to 2. :type version: int :param network: bitcoin network, defaults to testnet. :type network: str :returns: Transaction -- bitcoin transaction instance. .. warning:: Do not forget to build transaction after initialize refund transaction. :fee: Get bitcoin refund transaction fee. >>> refund_transaction.fee 675 """ # Initialization claim transaction def __init__(self, version=2, network="testnet"): super().__init__(version=version, network=network) # Initialization transaction_id, wallet and amount self.transaction_id, self.wallet, self.amount, self.secret = \ None, None, None, None # Getting transaction detail by id self.transaction_detail = None # Transaction detail outputs (HTLC and Sender account) self.htlc = None self.sender_account = None # Building transaction def build_transaction(self, transaction_id, wallet, amount, secret=None, locktime=0): """ Build bitcoin refund transaction. :param transaction_id: bitcoin fund transaction id to redeem. :type transaction_id: str :param wallet: bitcoin sender wallet. :type wallet: bitcoin.wallet.Wallet :param amount: bitcoin amount to withdraw. :type amount: int :param secret: secret passphrase. :type secret: str :param locktime: bitcoin transaction lock time, defaults to 0. :type locktime: int :returns: RefundTransaction -- bitcoin refund transaction instance. >>> from shuttle.providers.bitcoin.transaction import RefundTransaction >>> refund_transaction = RefundTransaction(network="testnet") >>> refund_transaction.build_transaction(fund_transaction_id, sender_wallet, 10000) <shuttle.providers.bitcoin.transaction.RefundTransaction object at 0x0409DAF0> """ # Checking build transaction arguments instance if not isinstance(transaction_id, str): raise TypeError("invalid amount instance, only takes string type") if not isinstance(wallet, Wallet): raise TypeError( "invalid wallet instance, only takes bitcoin Wallet class") if secret is not None and not isinstance(secret, str): raise TypeError("invalid secret instance, only takes string type") # Setting transaction_id and wallet self.transaction_id, self.wallet, self.secret = transaction_id, wallet, secret # Getting transaction detail by id self.transaction_detail = get_transaction_detail(self.transaction_id) # Checking transaction outputs if "outputs" not in self.transaction_detail: raise NotFoundError("not found htlc in this %s hash" % self.transaction_id) # Hash time lock contract output self.htlc = self.transaction_detail["outputs"][0] # Sender account output sender_address = P2pkhScript.unhexlify( self.transaction_detail["outputs"][1]["script"]).address( mainnet=self.mainnet) self.sender_account = Wallet(network=self.network).from_address( str(sender_address)) # HTLC info's htlc_amount = self.htlc["value"] htlc_script = P2shScript.unhexlify(self.htlc["script"]) # Calculating fee self.fee = fee_calculator(1, 1) if amount < self.fee: raise BalanceError("insufficient spend utxos") elif not htlc_amount >= (amount - self.fee): raise BalanceError("insufficient spend utxos", "maximum withdraw %d" % htlc_amount) # Building mutable bitcoin transaction self.transaction = MutableTransaction( version=self.version, ins=[ TxIn(txid=self.transaction_id, txout=0, script_sig=ScriptSig.empty(), sequence=Sequence.max()) ], outs=[ TxOut(value=(amount - self.fee), n=0, script_pubkey=P2pkhScript.unhexlify( self.sender_account.p2pkh())) ], locktime=Locktime(locktime)) return self # Signing transaction using private keys def sign(self, solver): """ Sign bitcoin refund transaction. :param solver: bitcoin refund solver. :type solver: bitcoin.solver.RefundSolver :returns: RefundTransaction -- bitcoin refund transaction instance. >>> from shuttle.providers.bitcoin.transaction import RefundTransaction >>> refund_transaction = RefundTransaction(network="testnet") >>> refund_transaction.build_transaction(fund_transaction_id, sender_wallet, 10000) >>> refund_transaction.sign(refund_solver) <shuttle.providers.bitcoin.transaction.RefundTransaction object at 0x0409DAF0> """ if not isinstance(solver, RefundSolver): raise TypeError( "invalid solver instance, only takes bitcoin RefundSolver class" ) if self.transaction is None: raise ValueError( "transaction script is none, build transaction first") htlc = HTLC(self.network).init( secret_hash=sha256(solver.secret).hex(), recipient_address=str(self.wallet.address()), sender_address=str(self.sender_account.address()), sequence=solver.sequence) self.transaction.spend([ TxOut(value=self.htlc["value"], n=0, script_pubkey=P2shScript.unhexlify(self.htlc["script"])) ], [P2shSolver(htlc.script, solver.solve())]) return self def unsigned_raw(self): """ Get bitcoin unsigned refund transaction raw. :returns: str -- bitcoin unsigned refund transaction raw. >>> from shuttle.providers.bitcoin.transaction import RefundTransaction >>> refund_transaction = RefundTransaction(network="testnet") >>> refund_transaction.build_transaction(fund_transaction_id, sender_wallet, 10000) >>> refund_transaction.unsigned_raw() "eyJmZWUiOiA2NzgsICJyYXciOiAiMDIwMDAwMDAwMTJjMzkyMjE3NDgzOTA2ZjkwMmU3M2M0YmMxMzI4NjRkZTU4MTUzNzcyZDc5MjY4OTYwOTk4MTYyMjY2NjM0YmUwMTAwMDAwMDAwZmZmZmZmZmYwMmU4MDMwMDAwMDAwMDAwMDAxN2E5MTQ5NzE4OTRjNThkODU5ODFjMTZjMjA1OWQ0MjJiY2RlMGIxNTZkMDQ0ODdhNjI5MDAwMDAwMDAwMDAwMTk3NmE5MTQ2YmNlNjVlNThhNTBiOTc5ODk5MzBlOWE0ZmYxYWMxYTc3NTE1ZWYxODhhYzAwMDAwMDAwIiwgIm91dHB1dHMiOiBbeyJhbW91bnQiOiAxMjM0MCwgIm4iOiAxLCAic2NyaXB0IjogIjc2YTkxNDZiY2U2NWU1OGE1MGI5Nzk4OTkzMGU5YTRmZjFhYzFhNzc1MTVlZjE4OGFjIn1dLCAidHlwZSI6ICJiaXRjb2luX2Z1bmRfdW5zaWduZWQifQ" """ if self.transaction is None: raise ValueError( "transaction script is none, build transaction first") outputs = [ dict(amount=self.htlc["value"], n=0, script=self.htlc["script"]) ] return b64encode( str( json.dumps( dict(fee=self.fee, raw=self.transaction.hexlify(), outputs=outputs, recipient_address=str(self.wallet.address()), sender_address=str(self.sender_account.address()), secret=self.secret, network=self.network, type="bitcoin_refund_unsigned"))).encode()).decode()
class FundTransaction(Transaction): """ Bitcoin FundTransaction class. :param version: bitcoin transaction version, defaults to 2. :type version: int :param network: bitcoin network, defaults to testnet. :type network: str :returns: FundTransaction -- bitcoin fund transaction instance. .. warning:: Do not forget to build transaction after initialize fund transaction. :fee: Get bitcoin fund transaction fee. >>> fund_transaction.fee 675 """ # Initialization fund transaction def __init__(self, version=2, network="testnet"): super().__init__(version=version, network=network) # Initialization wallet, htlc, amount and unspent self.wallet, self.htlc, self.amount, self.unspent = None, None, None, None # Getting previous transaction indexes using funding amount self.previous_transaction_indexes = None # Building transaction def build_transaction(self, wallet, htlc, amount, locktime=0): """ Build bitcoin fund transaction. :param wallet: bitcoin sender wallet. :type wallet: bitcoin.wallet.Wallet :param htlc: bitcoin hash time lock contract (HTLC). :type htlc: bitcoin.htlc.HTLC :param amount: bitcoin amount to fund. :type amount: int :param locktime: bitcoin transaction lock time, defaults to 0. :type locktime: int :returns: FundTransaction -- bitcoin fund transaction instance. >>> from shuttle.providers.bitcoin.transaction import FundTransaction >>> fund_transaction = FundTransaction(network="testnet") >>> fund_transaction.build_transaction(sender_wallet, htlc, 10000) <shuttle.providers.bitcoin.transaction.FundTransaction object at 0x0409DAF0> """ # Checking build transaction arguments instance if not isinstance(wallet, Wallet): raise TypeError( "invalid wallet instance, only takes bitcoin Wallet class") if not isinstance(htlc, HTLC): raise TypeError( "invalid htlc instance, only takes bitcoin HTLC class") if not isinstance(amount, int): raise TypeError("invalid amount instance, only takes integer type") # Setting wallet, htlc, amount and unspent self.wallet, self.htlc, self.amount = wallet, htlc, amount # Getting unspent transaction output self.unspent = self.wallet.unspent() # Setting previous transaction indexes self.previous_transaction_indexes = \ self.get_previous_transaction_indexes(amount=self.amount) # Getting transaction inputs and amount inputs, amount = self.inputs(self.unspent, self.previous_transaction_indexes) # Calculating bitcoin fee self.fee = fee_calculator(len(inputs), 2) if amount < (self.amount + self.fee): raise BalanceError("insufficient spend utxos") # Building mutable bitcoin transaction self.transaction = MutableTransaction( version=self.version, ins=inputs, outs=[ # Funding into hash time lock contract script hash TxOut(value=self.amount, n=0, script_pubkey=P2shScript.unhexlify(self.htlc.hash())), # Controlling amounts when we are funding on htlc script. TxOut(value=amount - (self.fee + self.amount), n=1, script_pubkey=P2pkhScript.unhexlify(self.wallet.p2pkh())) ], locktime=Locktime(locktime)) return self # Signing transaction using fund solver def sign(self, solver): """ Sign bitcoin fund transaction. :param solver: bitcoin fund solver. :type solver: bitcoin.solver.FundSolver :returns: FundTransaction -- bitcoin fund transaction instance. >>> from shuttle.providers.bitcoin.transaction import FundTransaction >>> fund_transaction = FundTransaction(network="testnet") >>> fund_transaction.build_transaction(sender_wallet, htlc, 10000) >>> fund_transaction.sign(fund_solver) <shuttle.providers.bitcoin.transaction.FundTransaction object at 0x0409DAF0> """ if not isinstance(solver, FundSolver): raise TypeError( "invalid solver instance, only takes bitcoin FundSolver class") if not self.unspent or not self.previous_transaction_indexes or not self.transaction: raise ValueError( "transaction script or unspent is none, build transaction first" ) outputs = self.outputs(self.unspent, self.previous_transaction_indexes) self.transaction.spend(outputs, [solver.solve() for _ in outputs]) return self # Automatically analysis previous transaction indexes using fund amount def get_previous_transaction_indexes(self, amount=None): if amount is None: amount = self.amount temp_amount = int() previous_transaction_indexes = list() for index, unspent in enumerate(self.unspent): temp_amount += unspent["amount"] if temp_amount > (amount + fee_calculator((index + 1), 2)): previous_transaction_indexes.append(index) break previous_transaction_indexes.append(index) return previous_transaction_indexes def unsigned_raw(self): """ Get bitcoin unsigned fund transaction raw. :returns: str -- bitcoin unsigned fund transaction raw. >>> from shuttle.providers.bitcoin.transaction import FundTransaction >>> fund_transaction = FundTransaction(network="testnet") >>> fund_transaction.build_transaction(sender_wallet, htlc, 10000) >>> fund_transaction.unsigned_raw() "eyJmZWUiOiA2NzgsICJyYXciOiAiMDIwMDAwMDAwMTJjMzkyMjE3NDgzOTA2ZjkwMmU3M2M0YmMxMzI4NjRkZTU4MTUzNzcyZDc5MjY4OTYwOTk4MTYyMjY2NjM0YmUwMTAwMDAwMDAwZmZmZmZmZmYwMmU4MDMwMDAwMDAwMDAwMDAxN2E5MTQ5NzE4OTRjNThkODU5ODFjMTZjMjA1OWQ0MjJiY2RlMGIxNTZkMDQ0ODdhNjI5MDAwMDAwMDAwMDAwMTk3NmE5MTQ2YmNlNjVlNThhNTBiOTc5ODk5MzBlOWE0ZmYxYWMxYTc3NTE1ZWYxODhhYzAwMDAwMDAwIiwgIm91dHB1dHMiOiBbeyJhbW91bnQiOiAxMjM0MCwgIm4iOiAxLCAic2NyaXB0IjogIjc2YTkxNDZiY2U2NWU1OGE1MGI5Nzk4OTkzMGU5YTRmZjFhYzFhNzc1MTVlZjE4OGFjIn1dLCAidHlwZSI6ICJiaXRjb2luX2Z1bmRfdW5zaWduZWQifQ" """ outputs = list() if not self.transaction or not self.unspent: raise ValueError( "transaction script or unspent is none, build transaction first" ) for index, utxo in enumerate(self.unspent): if self.previous_transaction_indexes is None or index in self.previous_transaction_indexes: outputs.append( dict(amount=utxo["amount"], n=utxo["output_index"], script=utxo["script"])) return b64encode( str( json.dumps( dict(fee=self.fee, raw=self.transaction.hexlify(), outputs=outputs, network=self.network, type="bitcoin_fund_unsigned"))).encode()).decode()