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
def createContractOutput(outScriptA, outScriptB, valueA, valueB): ''' PubScript=[TxOut(value=valueA,n=0,script_pubkey=P2pkhScript(pubkeyA))#outScriptA) or P2shScript(outScriptA)) #ToDo how to use OutScriptA, OutScriptB as pubkeys? ,TxOut(value=valueB,n=1,script_pubkey=P2pkhScript(pubkeyB))]#outScriptB)] or P2shScript(outScriptB))]# ToDO WORKS !!! ''' PubScript = [ TxOut(value=valueA, n=0, script_pubkey=outScriptA), TxOut(value=valueB, n=1, script_pubkey=outScriptB) ] # #print ("Funding Output Script:" , PubScript[0].to_json(),"\n",PubScript[1].to_json()) return PubScript
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 _get_signed_txn(self, wif_keys): """ :param wif_keys: list of wif keys corresponding with self.input_addresses addresses, in same order """ # NB: they are not guaranteed to be in order as there # may be more than one utxo associated with a single # address, but there will always be 1 solver associated # a private key unordered_solvers = [] unordered_tx_outs = [] unsigned = self._txn if self.is_signed: raise ValueError('cannot sign txn (already signed)') for key in wif_keys: # create btcpy PrivateKeys from input WIF format keys private_key = PrivateKey.from_wif(key) if self.is_segwit: pub_key = private_key.pub(compressed=True) s_solver = P2shSolver( P2wpkhV0Script(pub_key), P2wpkhV0Solver(private_key) ) unordered_solvers.append(s_solver) else: # create btcpy P2PKH Solvers from those PrivateKeys unordered_solvers.append(P2pkhSolver(private_key)) # a dict that matches the addresses (which are ordered the same as # their above WIF Keys) to their solvers addresses_solvers = dict(zip(self.input_addresses, unordered_solvers)) # from self._specific_utxo_data, take the output num, value and scriptPubKey # and create TxOuts representing the UTXO's that will be spent. # In a tuple with the address of the UTXO so the correct solver # can be found later for t in self._specific_utxo_data: unordered_tx_outs.append((t[2], TxOut(value=t[4], n=t[1], script_pubkey=Script.unhexlify(t[3])))) # unlike the lists defined at the top of the method, these are in # order i.e the solver in solvers[0] is the solver for the TxOut of # tx_outs[0]. this is required to pass them into the spend() method tx_outs = [] solvers = [] for t in unordered_tx_outs: address = t[0] tx_outs.append(t[1]) solvers.append(addresses_solvers[address]) signed = unsigned.spend(tx_outs, solvers) return signed
def find_parent_outputs(provider: Provider, utxo: TxIn) -> TxOut: '''due to design of the btcpy library, TxIn object must be converted to TxOut object before signing''' network_params = net_query(provider.network) index = utxo.txout # utxo index return TxOut.from_json(provider.getrawtransaction(utxo.txid, 1)['vout'][index], network=network_params)
def outputs(utxos, previous_transaction_indexes=None): outputs = list() for index, utxo in enumerate(utxos): if previous_transaction_indexes is None or index in previous_transaction_indexes: outputs.append( TxOut(value=utxo["amount"], n=utxo["output_index"], script_pubkey=Script.unhexlify(utxo["script"]))) return outputs
def tx_output(network: str, value: Decimal, n: int, script: ScriptSig) -> TxOut: '''create TxOut object''' network_params = net_query(network) return TxOut(network=network_params, value=int(value * network_params.to_unit), n=n, script_pubkey=script)
def from_json(cls, tx_json, network=PeercoinMainnet): return cls( version=tx_json['version'], ins=[TxIn.from_json(txin_json) for txin_json in tx_json['vin']], outs=[TxOut.from_json(txout_json) for txout_json in tx_json['vout']], locktime=Locktime(tx_json['locktime']), txid=tx_json['txid'], network=network, timestamp=tx_json['time'], )
def spendCb(fee, reward, objTx, outputs, cbSolver, dictIdToPub): """ create a single coinbase spend :param fee: fee :param reward: block reward in sat :param objTx: coinbase tx :param outputs: lst of channels (copies from originals) :param cbSolver: solver :param bPubMiner: pub of the miner :return: tx that spends coinbase """ outs = [] totVal = 0 chanIds = [] for o in outputs: v = int(o.value) bPubN1 = dictIdToPub[str(o.node1.nodeid)] bPubN2 = dictIdToPub[str(o.node2.nodeid)] if bPubN1.compressed < bPubN2.compressed: # lexicographical ordering multisig_script = MultisigScript(2, bPubN1, bPubN2, 2) else: multisig_script = MultisigScript(2, bPubN2, bPubN1, 2) p2wsh_multisig = P2wshV0Script(multisig_script) totVal += v outs += [TxOut(value=v, n=0, script_pubkey=p2wsh_multisig)] chanIds += [o.channelid] change = reward - totVal - fee outsWithChange = outs + [ TxOut(value=change, n=0, script_pubkey=objTx.outs[0].script_pubkey) ] unsignedCb = MutableTransaction(version=1, ins=[ TxIn(txid=objTx.txid, txout=0, script_sig=ScriptSig.empty(), sequence=Sequence.max()) ], outs=outsWithChange, locktime=Locktime(0)) cbTx = unsignedCb.spend([objTx.outs[0]], [cbSolver]) return cbTx, (cbTx.txid, chanIds)
def _get_unsigned_txn(self): # outputs_amounts is copied so any instance can be modified with change_fee, # and will still function correctly, i.e the change address won't already # be in the self._outputs_amounts dict self._modified_outputs_amounts = self.outputs_amounts.copy() # adding change address to outputs, if there is leftover balance that isn't dust if self._change_amount > 0: self._modified_outputs_amounts[self.change_address] = self._change_amount outputs = [] for i, (addr, amount) in enumerate(self._modified_outputs_amounts.items()): outputs.append(TxOut( value=amount, n=i, script_pubkey=self.get_script_pubkey(addr) )) inputs = [] for t in self._specific_utxo_data: # build inputs using the UTXO data in self._specific_utxo_data, # script_sig is empty as the transaction will be signed later inputs.append( TxIn(txid=t[0], txout=t[1], script_sig=ScriptSig.empty(), sequence=Sequence.max(), witness=Witness([StackData.zero()])) if self.is_segwit else None, ) if self.is_segwit: transaction = MutableSegWitTransaction( version=TX_VERSION, ins=inputs, outs=outputs, locktime=Locktime(self.locktime), ) else: transaction = MutableTransaction( version=TX_VERSION, ins=inputs, outs=outputs, locktime=Locktime(self.locktime) ) return transaction
def open_tx(committer, secret, commit_tx_hash): # 创建输入脚本 p2pkh_solver = P2pkhSolver(committer.privk) hasklock_solver = HashlockSolver(secret.encode(), p2pkh_solver) if_solver = IfElseSolver( Branch.IF, # branch selection hasklock_solver) # 创建输出脚本 script = P2pkhScript(committer.pubk) # 获取commit交易 to_spend_raw = get_raw_tx(commit_tx_hash, coin_symbol) to_spend = TransactionFactory.unhexlify(to_spend_raw) # 获取罚金数额 penalty = int(float(to_spend.to_json()['vout'][0]['value']) * (10**8)) # 估算挖矿费用 print('estimating mining fee...') mining_fee_per_kb = get_mining_fee_per_kb(coin_symbol, committer.api_key, condidence='high') estimated_tx_size = cal_tx_size_in_byte(inputs_num=1, outputs_num=1) mining_fee = int(mining_fee_per_kb * (estimated_tx_size / 1000)) * 2 # 创建交易 unsigned = MutableTransaction(version=2, ins=[ TxIn(txid=to_spend.txid, txout=0, script_sig=ScriptSig.empty(), sequence=Sequence.max()) ], outs=[ TxOut(value=penalty - mining_fee, n=0, script_pubkey=script), ], locktime=Locktime(0)) # 修改交易 signed = unsigned.spend([to_spend.outs[0]], [if_solver]) # 广播交易 print('open_tx_hex: ', signed.hexlify()) msg = pushtx(coin_symbol=coin_symbol, api_key=committer.api_key, tx_hex=signed.hexlify()) format_output(msg) return msg['tx']['hash']
def _build_outputs(utxos: list, previous_transaction_indexes: Optional[list] = None, only_dict: bool = False) -> list: outputs = [] for index, utxo in enumerate(utxos): if previous_transaction_indexes is None or index in previous_transaction_indexes: outputs.append( TxOut(value=utxo["value"], n=utxo["tx_output_n"], script_pubkey=Script.unhexlify( hex_string=utxo["script"])) if not only_dict else dict(value=utxo["value"], tx_output_n=utxo["tx_output_n"], script=utxo["script"])) return outputs
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 sign(self, solver): """ 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 >>> from swap.providers.bitcoin.solver import RefundSolver >>> from swap.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) <swap.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 sign(self, solver): """ Sign Bitcoin claim transaction. :param solver: Bitcoin claim solver. :type solver: bitcoin.solver.ClaimSolver :returns: ClaimTransaction -- Bitcoin claim transaction instance. >>> from swap.providers.bitcoin.transaction import ClaimTransaction >>> from swap.providers.bitcoin.solver import ClaimSolver >>> from swap.providers.bitcoin.wallet import Wallet >>> recipient_wallet = Wallet(network="testnet").from_passphrase("meherett") >>> claim_solver = ClaimSolver(recipient_wallet.private_key(), "Hello Meheret!", "3a26da82ead15a80533a02696656b14b5dbfd84eb14790f2e1be5e9e45820eeb", recipient_wallet.address(), "mphBPZf15cRFcL5tUq6mCbE84XobZ1vg7Q", 1000) >>> claim_transaction = ClaimTransaction(network="testnet") >>> claim_transaction.build_transaction("1006a6f537fcc4888c65f6ff4f91818a1c6e19bdd3130f59391c00212c552fbd", recipient_wallet, 10000) >>> claim_transaction.sign(solver=claim_solver) <swap.providers.bitcoin.transaction.ClaimTransaction object at 0x0409DAF0> """ # Checking parameter instances if not isinstance(solver, ClaimSolver): raise TypeError("invalid solver instance, only takes Bitcoin ClaimSolver 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_claim_signed" 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 fundingTxn(): Signer = ScriptSig.empty() outvalue = fundingInput_value(fundingTxIn, 0) - 400 MultiSigTx = MutableSegWitTransaction( version=1, #Publish to the Blockchain ins=[ TxIn(txid=fundingTxIn_id, txout=0, script_sig=Signer, sequence=Sequence.max()) ], outs=[TxOut(value=outvalue, n=0, script_pubkey=FundingScript) ], # todo must change this to access the contract script locktime=Locktime(0)) MultiSigTxSigned = MultiSigTx.spend( [fundingTxIn.outs[0]], [funding_sig]) # ToDo Failing here - spend attribute not found print("funding tx signed ", MultiSigTxSigned.hexlify()) # return MultiSigTx,p2sh_solver,MultiSigTxSigned.outs[0]; # TODo when to Return Signed MultiSigTransaction return MultiSigTxSigned.txid, MultiSigTxSigned.outs[0]
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 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 sweepTx(MultiSigTx, MultiSigTxOutput, MultiSigTxSolver, to_pubkey, to_index, to_value): to_spend = MultiSigTx unsigned = MutableSegWitTransaction( version=1, ins=[ TxIn( txid=to_spend, #.txid, txout=to_index, script_sig=ScriptSig.empty(), sequence=Sequence.max()) ], outs=[ TxOut(value=to_value - txFee, n=0, script_pubkey=P2pkhScript(to_pubkey)) ], # todo make funding_pubkey a parameter. This must sweep back tp A & B locktime=Locktime(0)) solver = MultiSigTxSolver signed = unsigned.spend( [MultiSigTxOutput], [solver]) #print ("Return tx signed ",signed.hexlify()) return signed.hexlify()
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 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()
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
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
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 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()
assert penalty + mining_fee <= balance, 'committer账户余额不足' # 创建交易 to_spend_raw = get_raw_tx(to_spend_hash, coin_symbol) to_spend = TransactionFactory.unhexlify(to_spend_raw) unsigned = MutableTransaction(version=2, ins=[ TxIn(txid=to_spend.txid, txout=0, script_sig=ScriptSig.empty(), sequence=Sequence.max()) ], outs=[ TxOut(value=penalty, n=0, script_pubkey=lock_time_script), TxOut(value=balance - penalty - mining_fee, n=1, script_pubkey=change_script) ], locktime=Locktime(0)) # 输入脚本 solver = P2pkhSolver(privk) # 修改交易 signed = unsigned.spend([to_spend.outs[0]], [solver]) print('commit_tx_hex: ', signed.hexlify()) # 发送交易 from blockcypher import pushtx