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 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 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