def test_json_roundtrip(self):
VALUES = [
42,
0,
-42,
2100000000000000,
-2100000000000000,
"basic string",
"\u1111Unicode",
"\U00010000Wide Unicode",
"\x00\n\t\r\nEscape codes",
"\"'\"Quotes",
"",
None,
b"\x00\x01\xFFBinary data",
b"",
CBase58Data.from_bytes(b'\x00\x01\xFF', 42),
P2SHBitcoinAddress.from_bytes(b'\x00\x01\xFF'),
P2PKHBitcoinAddress.from_bytes(b'\x00\x01\xFF'),
CMutableTxIn(COutPoint(b'\x00' * 16 + b'\xFF' * 16, 42),
CScript(b'\x00\x01\xFF'), 42),
CMutableTxOut(42, CScript(b'\x00\x01\xFF')),
CMutableTransaction([
CMutableTxIn(COutPoint(b'\x00' * 32, 42),
CScript(b'\x00\x01\xFF'), 42),
CMutableTxIn(COutPoint(b'\xFF' * 32, 42),
CScript(b'\xFF\x01\x00'), 43)
], [
CMutableTxOut(42, CScript(b'\x00\x01\xFF')),
CMutableTxOut(43, CScript(b'\xFF\x01\x00'))
], 42, 3),
[
1,
b'\x00\x01\xFF',
"List Test",
],
{
'a': 1,
'key': b'\xFF\x01\x00',
1: 'Dictionary Test'
},
[
{
3: [
0,
1,
2,
],
},
[
[
b'\xFFRecursion Test',
],
],
],
]
for value in VALUES:
self.assertEqual(from_json(to_json(value)), value)
def test_repr(self):
def T(outpoint, expected):
actual = repr(outpoint)
self.assertEqual(actual, expected)
T(COutPoint(), 'COutPoint()')
T(
COutPoint(
lx('4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b'
), 0),
"COutPoint(lx('4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b'), 0)"
)
def mock_listunspent_mainnet(self, addrs):
output1 = {
'outpoint':
COutPoint(
lx('34eb81bc0d1a822369f75174fd4916b1ec490d8fbcba33168e820cc78a52f608'
), 0),
'confirmations':
123,
'address':
P2PKHBitcoinAddress('13yNf3azc8sUrjf6UFjUCRZx4B6JnQ4XeJ'),
'spendable':
False,
'amount':
6342,
'solvable':
False,
'scriptPubKey':
CScript([
OP_DUP, OP_HASH160,
x('cc0a909c4c83068be8b45d69b60a6f09c2be0fda'), OP_EQUALVERIFY,
OP_CHECKSIG
]),
'account':
''
}
output2 = {
'address':
P2PKHBitcoinAddress('13yNf3azc8sUrjf6UFjUCRZx4B6JnQ4XeJ'),
'amount':
2750,
'account':
'',
'spendable':
False,
'solvable':
False,
'confirmations':
456,
'outpoint':
COutPoint(
lx('6773785b4dc5d2cced67d26fc0820329307a8e10dfaef50d506924984387bf0b'
), 1),
'scriptPubKey':
CScript([
OP_DUP, OP_HASH160,
x('cc0a909c4c83068be8b45d69b60a6f09c2be0fda'), OP_EQUALVERIFY,
OP_CHECKSIG
])
}
unspent_outputs = [output1, output2]
return unspent_outputs
def native(self):
tx_hex = self.output.transaction_hash
# Convert a little-endian hex string to bytes
txid = lx(tx_hex)
vout = self.output.index
outpoint = COutPoint(txid, vout)
return CTxIn(outpoint)
def listunspent(self, minconf=0, maxconf=9999999, addrs=None):
"""Return unspent transaction outputs in wallet
Outputs will have between minconf and maxconf (inclusive)
confirmations, optionally filtered to only include txouts paid to
addresses in addrs.
"""
r = None
if addrs is None:
r = self._call('listunspent', minconf, maxconf)
else:
addrs = [str(addr) for addr in addrs]
r = self._call('listunspent', minconf, maxconf, addrs)
r2 = []
for unspent in r:
unspent['outpoint'] = COutPoint(lx(unspent['txid']), unspent['vout'])
del unspent['txid']
del unspent['vout']
unspent['address'] = CBitcoinAddress(unspent['address'])
unspent['scriptPubKey'] = CScript(unhexlify(unspent['scriptPubKey']))
unspent['amount'] = int(unspent['amount'] * COIN)
r2.append(unspent)
return r2
def open_channel(address, mymoney, theirmoney, fees, their_coins, their_change,
their_pubkey, their_out_addr): # pylint: disable=too-many-arguments, line-too-long
"""Open a payment channel."""
# Get inputs and change output
coins, change = select_coins(mymoney + 2 * fees)
# Make the anchor script
anchor_output_script = anchor_script(get_pubkey(), their_pubkey)
# Construct the anchor utxo
payment = CMutableTxOut(mymoney + theirmoney + 2 * fees,
anchor_output_script.to_p2sh_scriptPubKey())
# Anchor tx
transaction = CMutableTransaction(their_coins + coins,
[payment, change, their_change])
# Half-sign
transaction = g.bit.signrawtransaction(transaction)['tx']
# Create channel in DB
our_addr = g.bit.getnewaddress()
channel = Channel(
address=address,
anchor_point=COutPoint(transaction.GetHash(), 0),
anchor_index=0,
their_sig=b'',
anchor_redeem=anchor_output_script,
our_balance=mymoney,
our_addr=our_addr,
their_balance=theirmoney,
their_addr=their_out_addr,
)
database.session.add(channel)
database.session.commit()
# Event: channel opened
CHANNEL_OPENED.send('channel', address=address)
return (transaction, anchor_output_script, our_addr)
def fundrawtransaction(self, given_transaction, *args, **kwargs):
"""
Make up some inputs for the given transaction.
"""
# just use any txid here
vintxid = lx("99264749804159db1e342a0c8aa3279f6ef4031872051a1e52fb302e51061bef")
if isinstance(given_transaction, str):
given_bytes = x(given_transaction)
elif isinstance(given_transaction, CMutableTransaction):
given_bytes = given_transaction.serialize()
else:
raise FakeBitcoinProxyException("Wrong type passed to fundrawtransaction.")
# this is also a clever way to not cause a side-effect in this function
transaction = CMutableTransaction.deserialize(given_bytes)
for vout_counter in range(0, self._num_fundrawtransaction_inputs):
txin = CMutableTxIn(COutPoint(vintxid, vout_counter))
transaction.vin.append(txin)
# also allocate a single output (for change)
txout = make_txout()
transaction.vout.append(txout)
transaction_hex = b2x(transaction.serialize())
return {"hex": transaction_hex, "fee": 5000000}
def partial_spend_p2sh_mediator(redeemScript,
rein,
mediator_address,
mediator_sig=False):
txin_redeemScript = CScript(x(redeemScript))
txin_scriptPubKey = txin_redeemScript.to_p2sh_scriptPubKey()
txin_p2sh_address = CBitcoinAddress.from_scriptPubKey(txin_scriptPubKey)
(txins, total_value) = unspent_txins(txin_p2sh_address, rein.testnet)
if len(txins) == 0:
raise ValueError('No unspent txins found')
txins_str = ""
txins_obj = []
for txid, vout in txins:
txins_str += " " + txid + "-" + str(vout)
txins_obj.append(CMutableTxIn(COutPoint(lx(txid), vout)))
fee = 0.00025
amount = round(total_value - fee, 8)
if amount <= 0:
raise ValueError('Not enough value in the inputs')
if mediator_sig:
txout = CMutableTxOut(
amount * COIN,
CBitcoinAddress(mediator_address).to_scriptPubKey())
tx = CMutableTransaction(txins_obj, [txout])
seckey = CBitcoinSecret(rein.user.dkey)
ntxins = len(txins_obj)
sig = ""
for i in range(0, ntxins):
sighash = SignatureHash(txin_redeemScript, tx, i, SIGHASH_ALL)
sig += " " + b2x(seckey.sign(sighash) + x("01"))
return (txins_str[1:], "{:.8f}".format(amount), str(mediator_address),
sig[1:])
return (txins_str[1:], "{:.8f}".format(amount), str(mediator_address))
def scan_tx(self, tx, block_hash=None):
tx_hash = tx.get_hash()
#logging.debug('Checking tx %s for transactions' % b2lx(tx_hash))
num_found = 0
# Remove spent
for txin in tx.vin:
try:
del self.unspent_txouts[txin.prevout]
except KeyError:
continue
logging.info('Outpoint %r spent' % txin.prevout)
# Add unspent
for (i, txout) in enumerate(tx.vout):
if txout.scriptPubKey in self.keypairs:
outpoint = COutPoint(tx_hash, i)
if block_hash is not None:
block_txout_set = self.outpoints_by_block.setdefault(block_hash, set())
block_txout_set.add((outpoint, txout))
self.unspent_txouts[outpoint] = txout
logging.info('Found txout: %r -> %r' % (outpoint, txout))
num_found += 1
return num_found
def create_transaction_input(input_):
"""
transform the unsigned transaction input
:param input_: unsigned transaction input
:return: input formatted as transaction hex code
"""
return CMutableTxIn(COutPoint(lx(input_['txid']), input_['index']))
def add_input(self,
serial_id: int,
prevtx: str,
prevtx_vout: int,
script_sig: str,
sequence: int,
privkey: str = None) -> None:
# the dummy runner sends empty info, skip
if len(prevtx) == 0:
return
# Find the txid of the transaction
prev_tx = CTransaction.deserialize(bytes.fromhex(prevtx))
txin = CTxIn(COutPoint(prev_tx.GetTxid(), prevtx_vout),
nSequence=sequence)
# Get the previous output for its outscript + value
prev_vout = prev_tx.vout[prevtx_vout]
self.inputs.append({'input': txin,
'serial_id': serial_id,
'sats': prev_vout.nValue,
'prev_outscript': prev_vout.scriptPubKey.hex(),
'redeemscript': script_sig,
'privkey': privkey,
})
def close_tx(self, fee: int, privkey_dest: str) -> str:
"""Create a (mutual) close tx"""
txin = CTxIn(COutPoint(bytes.fromhex(self.txid), self.output_index))
out_privkey = privkey_expand(privkey_dest)
txout = CTxOut(self.amount - fee,
CScript([script.OP_0,
Hash160(coincurve.PublicKey.from_secret(out_privkey.secret).format())]))
tx = CMutableTransaction(vin=[txin], vout=[txout])
sighash = script.SignatureHash(self.redeemscript(), tx, inIdx=0,
hashtype=script.SIGHASH_ALL,
amount=self.amount,
sigversion=script.SIGVERSION_WITNESS_V0)
sigs = [key.sign(sighash, hasher=None) for key in self.funding_privkeys_for_tx()]
# BOLT #3:
# ## Closing Transaction
# ...
# * `txin[0]` witness: `0 <signature_for_pubkey1> <signature_for_pubkey2>`
witness = CScriptWitness([bytes(),
sigs[0] + bytes([script.SIGHASH_ALL]),
sigs[1] + bytes([script.SIGHASH_ALL]),
self.redeemscript()])
tx.wit = CTxWitness([CTxInWitness(witness)])
return tx.serialize().hex()
def spend_p2sh_mediator(redeemScript, txins_str, amounts, daddrs, sig, rein):
txin_redeemScript = CScript(x(redeemScript))
txin_scriptPubKey = txin_redeemScript.to_p2sh_scriptPubKey()
txins_obj = []
for txin_str in txins_str.split():
txin_list = txin_str.split("-")
txins_obj.append(
CMutableTxIn(COutPoint(lx(txin_list[0]), int(txin_list[1]))))
txouts = []
len_amounts = len(amounts)
for i in range(0, len_amounts):
txouts.append(
CMutableTxOut(
round(amounts[i], 8) * COIN,
CBitcoinAddress(daddrs[i]).to_scriptPubKey()))
tx = CMutableTransaction(txins_obj, txouts)
seckey = CBitcoinSecret(rein.user.dkey)
ntxins = len(txins_obj)
sig_list = []
for s in sig.split():
sig_list.append(x(s))
sig2_str = ""
for i in range(0, ntxins):
sighash = SignatureHash(txin_redeemScript, tx, i, SIGHASH_ALL)
sig2 = seckey.sign(sighash) + x("01")
sig2_str += " " + b2x(sig2)
txins_obj[i].scriptSig = CScript(
[OP_0, sig2, sig_list[i], txin_redeemScript])
VerifyScript(txins_obj[i].scriptSig, txin_scriptPubKey, tx, i,
(SCRIPT_VERIFY_P2SH, ))
tx_bytes = tx.serialize()
hash = sha256(sha256(tx_bytes).digest()).digest()
txid = b2x(hash[::-1])
txid_causeway = broadcast_tx(b2x(tx_bytes), rein)
return (txid, sig2_str[1:])
def build_bounce_tx(self, txid_hex):
#Generate p2sh script pub key.
redeem_script = self.fund_redeem_script(self.my)
redeem_script_hash160 = self.hash160_script(redeem_script)
txin_script_pub_key = CScript(
[OP_HASH160, redeem_script_hash160["bin"], OP_EQUAL])
#Generate address to receive bounce.
if "bounce" not in self.key_pairs:
self.key_pairs["bounce"] = self.key_pair_from_address(
self.jsonrpc[self.my].getnewaddress(), self.my)
#Setup tx inputs and outputs.
txid = lx(txid_hex)
vout = 0
txin = CTxIn(COutPoint(txid, vout), CScript(), 0) #Sequence number 0.
txout = CTxOut(
(self.send_amount -
decimal.Decimal(coinbend.config["mining_fee"]["standard"])) *
COIN,
CBitcoinAddress(
self.key_pairs["bounce"]["addr"]["base58"]).to_scriptPubKey())
#Locktime is unsigned int 4, unix timestamp in little endian format.
#(Conversion to little endian is handled by the library already.)
nlock_time = datetime.datetime.now() + datetime.timedelta(
seconds=self.future_minutes * 60)
nlock_time = int(nlock_time.strftime("%s"))
#Create unsigned transaction.
tx = CTransaction([txin], [txout], nlock_time)
return b2x(tx.serialize())
def creates_add_input(bitcoind, tx):
"""Creates and add an input to a CMutableTransaction, SIGHASH_ALL.
:returns: The txid of the first stage fee bumping tx (for convenience)
"""
# First we get some coins
privkey = CKey(os.urandom(32))
scriptPubKey = CScript([OP_0, Hash160(privkey.pub)])
address = CBitcoinAddress.from_scriptPubKey(scriptPubKey)
# Let's say we want to increase the fees by 5000 sats
amount = 5000
# Bitcoind is nice and will create the first stage transaction
first_txid = bitcoind.rpc.sendtoaddress(str(address), amount / COIN)
vout_index = get_output_index(
bitcoind.rpc.getrawtransaction(first_txid, 1), amount)
# === We don't generate a block yet ! ===
tx.vin.append(
CTxIn(COutPoint(lx(first_txid), vout_index), nSequence=0xfffffffe))
# Sign the new input with ALL
tx_hash = SignatureHash(address.to_redeemScript(), tx, 1, SIGHASH_ALL,
amount, SIGVERSION_WITNESS_V0)
sig = privkey.sign(tx_hash) + bytes([SIGHASH_ALL])
tx.wit.vtxinwit.append(CTxInWitness(CScriptWitness([sig, privkey.pub])))
return first_txid
def add_input(self,
serial_id: int,
prevtx: str,
prevtx_vout: int,
max_witness_len: int,
script: str,
sequence: int,
privkey: str = None) -> None:
# Find the txid of the transaction
prev_tx = CTransaction.deserialize(bytes.fromhex(prevtx))
txin = CTxIn(COutPoint(prev_tx.GetTxid(), prevtx_vout),
nSequence=sequence)
# Get the previous output for its outscript + value
prev_vout = prev_tx.vout[prevtx_vout]
self.inputs.append({
'input': txin,
'serial_id': serial_id,
'sats': prev_vout.nValue,
'prev_outscript': prev_vout.scriptPubKey.hex(),
'redeemscript': script,
'max_witness_len': max_witness_len,
'privkey': privkey,
})
def test_emergency_txout(bitcoind):
"""Test mostly the emergency tx locktime"""
amount = Decimal("50") - Decimal("500") / Decimal(COIN)
privkeys = [CKey(os.urandom(32)) for _ in range(4)]
pubkeys = [k.pub for k in privkeys]
txo = emergency_txout(pubkeys, COIN * amount)
addr = str(CBitcoinAddress.from_scriptPubKey(txo.scriptPubKey))
# This makes a transaction with only one vout
txid = bitcoind.pay_to(addr, amount)
new_amount = amount - Decimal("500") / Decimal(COIN)
addr = bitcoind.getnewaddress()
txin = CTxIn(COutPoint(lx(txid), 0), nSequence=4464)
txout = CTxOut(new_amount * COIN, CBitcoinAddress(addr).to_scriptPubKey())
tx = CMutableTransaction([txin], [txout], nVersion=2)
tx_hash = SignatureHash(emergency_script(pubkeys), tx, 0, SIGHASH_ALL,
int(amount * COIN), SIGVERSION_WITNESS_V0)
sigs = [k.sign(tx_hash) + bytes([SIGHASH_ALL]) for k in privkeys]
witness_script = [bytes(0), *sigs, emergency_script(pubkeys)]
tx.wit = CTxWitness([CTxInWitness(CScriptWitness(witness_script))])
# 1 month of locktime
bitcoind.generate_block(4464 - 2)
with pytest.raises(VerifyRejectedError, match="non-BIP68-final"):
bitcoind.send_tx(tx.serialize().hex())
bitcoind.generate_block(1)
bitcoind.send_tx(tx.serialize().hex())
assert bitcoind.has_utxo(addr)
def listunspent(self, minconf=0, maxconf=9999999, addrs=None):
"""Return unspent transaction outputs in wallet
Outputs will have between minconf and maxconf (inclusive)
confirmations, optionally filtered to only include txouts paid to
addresses in addrs.
"""
r = None
if addrs is None:
r = self._call('listunspent', minconf, maxconf)
else:
addrs = [str(addr) for addr in addrs]
r = self._call('listunspent', minconf, maxconf, addrs)
r2 = []
for unspent in r:
unspent['outpoint'] = COutPoint(lx(unspent['txid']),
unspent['vout'])
del unspent['txid']
del unspent['vout']
# address isn't always available as Bitcoin Core allows scripts w/o
# an address type to be imported into the wallet, e.g. non-p2sh
# segwit
try:
unspent['address'] = CBitcoinAddress(unspent['address'])
except KeyError:
pass
unspent['scriptPubKey'] = CScript(
unhexlify(unspent['scriptPubKey']))
unspent['amount'] = int(unspent['amount'] * COIN)
r2.append(unspent)
return r2
def create_trx(op_return_val, issuing_transaction_fee, issuing_address,
tx_outs, tx_inputs):
"""
:param op_return_val:
:param issuing_transaction_fee:
:param issuing_address:
:param tx_outs:
:param tx_input:
:return:
"""
cert_out = CMutableTxOut(0, CScript([OP_RETURN, op_return_val]))
tx_ins = []
value_in = 0
for tx_input in tx_inputs:
tx_ins.append(CTxIn(COutPoint(tx_input.tx_hash,
tx_input.tx_out_index)))
value_in += tx_input.coin_value
# send change back to our address
amount = value_in - issuing_transaction_fee
if amount > 0:
change_out = create_transaction_output(issuing_address, amount)
tx_outs = tx_outs + [change_out]
tx_outs = tx_outs + [cert_out]
transaction = CMutableTransaction(tx_ins, tx_outs)
return transaction
def update_anchor(address, new_anchor, their_sig):
"""Update the anchor txid after both have signed."""
channel = Channel.query.get(address)
channel.anchor_point = COutPoint(new_anchor, channel.anchor_point.n)
channel.their_sig = their_sig
database.session.commit()
return channel.signature(channel.commitment())
def spend_command(args):
args.addr = CBitcoinAddress(args.addr)
redeemScript = hodl_redeemScript(args.privkey, args.nLockTime)
scriptPubKey = redeemScript.to_p2sh_scriptPubKey()
proxy = bitcoin.rpc.Proxy()
prevouts = []
for prevout in args.prevouts:
try:
txid, n = prevout.split(':')
txid = lx(txid)
n = int(n)
outpoint = COutPoint(txid, n)
except ValueError:
args.parser.error('Invalid output: %s' % prevout)
try:
prevout = proxy.gettxout(outpoint)
except IndexError:
args.parser.error('Outpoint %s not found' % outpoint)
prevout = prevout['txout']
if prevout.scriptPubKey != scriptPubKey:
args.parser.error('Outpoint not correct scriptPubKey')
prevouts.append((outpoint, prevout))
sum_in = sum(prev_txout.nValue for outpoint, prev_txout in prevouts)
tx_size = (
4 + # version field
2 + # # of txins
len(prevouts) * 153 + # txins, including sigs
1 + # # of txouts
34 + # txout
4 # nLockTime field
)
feerate = int(proxy._call('estimatefee', 1) * COIN) # satoshi's per KB
if feerate <= 0:
feerate = 10000
fees = int(tx_size / 1000 * feerate)
unsigned_tx = CTransaction(
[CTxIn(outpoint, nSequence=0) for outpoint, prevout in prevouts],
[CTxOut(sum_in - fees, args.addr.to_scriptPubKey())], args.nLockTime)
signed_tx = CTransaction([
CTxIn(txin.prevout,
spend_hodl_redeemScript(args.privkey, args.nLockTime,
unsigned_tx, i),
nSequence=0) for i, txin in enumerate(unsigned_tx.vin)
], unsigned_tx.vout, unsigned_tx.nLockTime)
print(b2x(signed_tx.serialize()))
def withdrawfromvault(self, fromvaultaddress, toaddress, amount):
vault = self.getvault(fromvaultaddress)
received = self.chaindb.listreceivedbyvault(fromvaultaddress)
received = received.values()[0]
if received['value'] < amount + 2 * utils.calculate_fees(None):
self.logger.warning("Insufficient funds in vault, exiting, return")
return
# create transaction
tx = CTransaction()
# to the receiver
txout = CTxOut()
txout.nValue = amount
txout.scriptPubKey = utils.address_to_pay_to_pubkey_hash(toaddress)
tx.vout.append(txout)
# from the sender
nValueIn = 0
nValueOut = amount
txin = CTxIn()
txin.prevout = COutPoint()
txin.prevout.hash = received['txhash']
txin.prevout.n = received['n']
txin.scriptSig = received['scriptPubKey']
tx.vin.append(txin)
# calculate nValueIn
nValueIn = received['value']
# calculate the total excess amount
excessAmount = nValueIn - nValueOut
# calculate the fees
fees = 2 * utils.calculate_fees(tx)
# create change transaction, if there is any change left
if excessAmount > fees:
change_txout = CTxOut()
change_txout.nValue = excessAmount - fees
account = self.getaccount()
changeaddress = fromvaultaddress
self.logger.debug("Change address: %s" % changeaddress)
change_txout.scriptPubKey = \
utils.vault_address_to_pay_to_vault_script(changeaddress)
tx.vout.append(change_txout)
# calculate txhash
tx.calc_sha256()
txhash = str(tx.sha256)
key = CKey()
key.set_pubkey(vault['public_key'])
key.set_privkey(vault['private_key'])
signature = key.sign(txhash)
vaultscript = utils.create_vault_script(vault['address'], \
vault['master_address'], vault['timeout'], vault['maxfees'])
scriptSig = chr(OP_VAULT_WITHDRAW) + chr(len(signature)) + signature + \
chr(len(vaultscript)) + vaultscript
self.logger.debug("Adding signature: %s" % binascii.hexlify(scriptSig))
txin.scriptSig = scriptSig
return tx
def get_tx(self,
redeem_script,
address,
amount,
funding_tx,
lock_time=0,
vout=0):
'''
Returns a raw transaction and it's signature hash
that pays to address from funding_tx
Options:
vout -> which vout of funding_tx
nLockTime -> set's transaction locktime
'''
# Set P2SH funding tx in little-endian
fx = lx(funding_tx)
if lock_time > 0:
nlock_time = lock_time
else:
nlock_time = 0
# nSequence must be any number less than 0xffffffff to enable nLockTime
if (nlock_time != 0):
txin = CMutableTxIn(COutPoint(fx, vout), nSequence=0)
else:
txin = CMutableTxIn(COutPoint(fx, vout))
# Convert amount to Satoshi's
amount *= COIN
# Create the txout to address
script_pubkey = CBitcoinAddress(address).to_scriptPubKey()
txout = CMutableTxOut(amount, script_pubkey)
# Create the unsigned transaction.
tx = CMutableTransaction([txin], [txout], nLockTime=nlock_time)
# Calculte TX sig hash
sighash = SignatureHash(CScript(redeem_script), tx, 0, SIGHASH_ALL)
self.logger.info("get_tx: TX SIGHASH is %s", b2x(sighash))
return (tx.serialize(), sighash)
async def get_listunspent_for_addr(self, addr, confirmations=1):
res = await self.post('listunspent', confirmations, 9999999, [addr])
for unspent in res:
coutpoint = COutPoint(lx(unspent['txid']), unspent['vout'])
cscript = CScript(unhexlify(unspent['scriptPubKey']))
unspent['outpoint'] = coutpoint
unspent['address'] = CBitcoinAddress(unspent['address'])
unspent['scriptPubKey'] = cscript
unspent['amount'] = int(D(str(unspent['amount'])) * COIN)
return res
def test_create_transaction_object_2(inputs_2, outputs_2):
r = PaymentService.create_transaction_object(inputs=inputs_2, outputs=outputs_2)
tx_in: List[CMutableTxIn] = [
CMutableTxIn(COutPoint(lx('4521418569de2f78d5d2d3c535567ac9c48c95314c53a67788d4dcdc9a8d915b'), 0)),
CMutableTxIn(COutPoint(lx('0bb4abea99101197cf2ddf43a2af1e73f868887d5f4a3619241cbb67413a34e7'), 0)),
]
pk1 = CBitcoinAddress('34s7MXyL5sEbgsto6SRdvV3YYUu8XVs4xg').to_scriptPubKey()
pk2 = CBitcoinAddress('16moGJwkzWhNC1pfnfJptKj9G1ogQz16xd').to_scriptPubKey()
pk3 = CBitcoinAddress('17A16QmavnUfCW11DAApiJxp7ARnxN5pGX').to_scriptPubKey()
tx_out: List[CMutableTxOut] = [
CMutableTxOut(100000, pk1),
CMutableTxOut(2000, pk2),
CMutableTxOut(20000000, pk3),
]
expected = CMutableTransaction(tx_in, tx_out)
assert b2x(r.serialize()) == b2x(expected.serialize())
def overridevaulttx(self, fromvaultaddress, toaddress):
vault = self.getvault(fromvaultaddress)
# select the input addresses
received = self.chaindb.listallreceivedbyvault(fromvaultaddress)
if not received:
self.logger.warning("Empty vault, exiting, return")
return None, None
received = received.values()[0]
if received['value'] < 2 * utils.calculate_fees(None):
self.logger.warning("Insufficient funds in vault, exiting, return")
return None, None
# calculate remaining amount
amount = received['value'] - 2 * utils.calculate_fees(None)
# create transaction
tx = CTransaction()
# to the receiver
txout = CTxOut()
txout.nValue = amount
txout.scriptPubKey = utils.address_to_pay_to_pubkey_hash(toaddress)
tx.vout.append(txout)
# from the sender
nValueIn = 0
nValueOut = amount
txin = CTxIn()
txin.prevout = COutPoint()
txin.prevout.hash = received['txhash']
txin.prevout.n = received['n']
txin.scriptSig = received['scriptPubKey']
tx.vin.append(txin)
# calculate nValueIn
nValueIn = received['value']
# calculate the total excess amount
excessAmount = nValueIn - nValueOut
# calculate the fees
fees = utils.calculate_fees(tx)
# calculate txhash
tx.calc_sha256()
txhash = str(tx.sha256)
key = CKey()
key.set_pubkey(vault['public_key'])
key.set_privkey(vault['private_key'])
signature = key.sign(txhash)
# get the script
vaultscript = utils.create_vault_script(vault['address'], \
vault['master_address'], vault['timeout'], vault['maxfees'])
scriptSig = chr(OP_VAULT_OVERRIDE) + chr(len(vault['master_public_key'])) + \
vault['master_public_key'] + chr(len(signature)) + signature + \
chr(len(vaultscript)) + vaultscript
self.logger.debug("Adding signature: %s" % binascii.hexlify(scriptSig))
txin.scriptSig = scriptSig
return amount, tx
def generate_tx(self):
tx_chain = self.get_next_tx_chain()
txid = lx(tx_chain.current_unspent_tx)
txins = [
CMutableTxIn(COutPoint(txid, 0)),
CMutableTxIn(COutPoint(txid, 1))
]
txin_seckeys = [tx_chain.seckey, self._spent_to.seckey]
amount_in = tx_chain.amount
tx_chain.amount -= int(config.transaction_fee / 2)
txout1 = CMutableTxOut(
tx_chain.amount,
CBitcoinAddress(tx_chain.address).to_scriptPubKey())
txout2 = CMutableTxOut(
tx_chain.amount,
CBitcoinAddress(self._spent_to.address).to_scriptPubKey())
tx = CMutableTransaction(txins, [txout1, txout2], nVersion=2)
for i, txin in enumerate(txins):
txin_scriptPubKey = CScript([
OP_DUP, OP_HASH160,
Hash160(txin_seckeys[i].pub), OP_EQUALVERIFY, OP_CHECKSIG
])
sighash = SignatureHash(txin_scriptPubKey, tx, i, SIGHASH_ALL)
sig = txin_seckeys[i].sign(sighash) + bytes([SIGHASH_ALL])
txin.scriptSig = CScript([sig, txin_seckeys[i].pub])
tx_serialized = tx.serialize()
logging.debug('{} trying to sendrawtransaction'
' (in=2x{} out=2x{} fee={} bytes={})'
' using tx_chain number={}'.format(
self._name, amount_in, txout1.nValue,
(amount_in * 2) - (txout1.nValue * 2),
len(tx_serialized), self._current_tx_chain_index))
tx_hash = self.execute_rpc('sendrawtransaction', b2x(tx_serialized))
tx_chain.current_unspent_tx = tx_hash
logging.info(
'{} sendrawtransaction was successful; tx got hash={}'.format(
self._name, tx_hash))
def mock_listunspent(self, addrs):
output1 = {'outpoint': COutPoint(lx('34eb81bc0d1a822369f75174fd4916b1ec490d8fbcba33168e820cc78a52f608'), 0),
'confirmations': 62952, 'address': P2PKHBitcoinAddress('mz7poFND7hVGRtPWjiZizcCnjf6wEDWjjT'),
'spendable': False, 'amount': 49000000, 'solvable': False, 'scriptPubKey': CScript(
[OP_DUP, OP_HASH160, x('cc0a909c4c83068be8b45d69b60a6f09c2be0fda'), OP_EQUALVERIFY, OP_CHECKSIG]),
'account': ''}
output2 = {'address': P2PKHBitcoinAddress('mz7poFND7hVGRtPWjiZizcCnjf6wEDWjjT'), 'amount': 2750, 'account': '',
'spendable': False, 'solvable': False, 'confirmations': 62932,
'outpoint': COutPoint(lx('6773785b4dc5d2cced67d26fc0820329307a8e10dfaef50d506924984387bf0b'), 1),
'scriptPubKey': CScript(
[OP_DUP, OP_HASH160, x('cc0a909c4c83068be8b45d69b60a6f09c2be0fda'), OP_EQUALVERIFY,
OP_CHECKSIG])}
output3 = {'address': P2PKHBitcoinAddress('mz7poFND7hVGRtPWjiZizcCnjf6wEDWjjT'), 'amount': 2750, 'account': '',
'spendable': False, 'solvable': False, 'confirmations': 62932,
'outpoint': COutPoint(lx('6773785b4dc5d2cced67d26fc0820329307a8e10dfaef50d506924984387bf0b'), 5),
'scriptPubKey': CScript(
[OP_DUP, OP_HASH160, x('cc0a909c4c83068be8b45d69b60a6f09c2be0fda'), OP_EQUALVERIFY,
OP_CHECKSIG])}
unspent_outputs = [output1, output2, output3]
return unspent_outputs
def test_create_transaction_object_1(inputs_1, outputs_1):
r = PaymentService.create_transaction_object(inputs=inputs_1, outputs=outputs_1)
tx_in: List[CMutableTxIn] = [
CMutableTxIn(COutPoint(lx('4521418569de2f78d5d2d3c535567ac9c48c95314c53a67788d4dcdc9a8d915b'), 0))]
pk = CBitcoinAddress('16moGJwkzWhNC1pfnfJptKj9G1ogQz16xd').to_scriptPubKey()
tx_out: List[CMutableTxOut] = [CMutableTxOut(100000, pk)]
expected = CMutableTransaction(tx_in, tx_out)
assert b2x(r.serialize()) == b2x(expected.serialize())
def get_inputs(self):
vin = []
for i in range(self.model.rowCount()):
prev_hash, prev_vout = str(self.model.item(i, 0).text()).split(':')
in_script = str(self.model.item(i, 1).data(RawRole).toString())
sequence = int(self.model.item(i, 2).text())
outpoint = COutPoint(lx(prev_hash), int(prev_vout))
i_input = CTxIn(outpoint, in_script.decode('hex'), sequence)
vin.append(i_input)
return vin
import binascii
import hashlib
from bitcoin.key import CKey
from bitcoin.core import COutPoint, CTxIn, CTxOut, CTransaction
# from utils
def myhash(s):
return hashlib.sha256(hashlib.sha256(s).digest()).digest()
previous = COutPoint()
txin = CTxIn()
txout = CTxOut()
tx = CTransaction()
# get the outpoint from which we want to spend
previous.hash = 0xeccf7e3034189b851985d871f91384b8ee357cd47c3024736e5676eb2debb3f2
previous.n = 0x01000000
txin.prevout = previous
txin.scriptSig = binascii.unhexlify("76a914010966776006953d5567439e5e39f86a0d273bee88ac")
# create output transaction
txout.nValue = 0x605af40500000000
txout.scriptPubKey = binascii.unhexlify("76a914097072524438d003d23a2f23edb65aae1bb3e46988ac")
# set inputs and outputs
tx.vin.append(txin)
tx.vout.append(txout)
sertx = tx.serialize() + binascii.unhexlify("01000000")
def ctx_deserialize(cls, ctx):
serialized_outpoint = ctx.read_bytes('outpoint', 36)
return COutPoint.deserialize(serialized_outpoint)
#!/usr/bin/env python import binascii from bitcoin.core import COutPoint, CTxIn, CTxOut, CTransaction, CBlock coinbase = "04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73" scriptPubKeyHex = "4104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac" # construct previous out point previousOut = COutPoint() previousOut.hash = 0 previousOut.n = 4294967295 # construct txin txin = CTxIn() txin.coinbase = binascii.unhexlify(coinbase) txin.scriptSig = binascii.unhexlify(coinbase) txin.prevout = previousOut # construct txout txout = CTxOut() txout.nValue = 5000000000 txout.scriptPubKey = binascii.unhexlify(scriptPubKeyHex) # create transaction tx = CTransaction() tx.vin.append(txin) tx.vout.append(txout) tx.calc_sha256()
