def test_GetHash(self):
"""CMutableOutPoint.GetHash() is not cached"""
outpoint = CMutableOutPoint()
h1 = outpoint.GetHash()
outpoint.n = 1
self.assertNotEqual(h1, outpoint.GetHash())
def test_repr(self):
def T(outpoint, expected):
actual = repr(outpoint)
self.assertEqual(actual, expected)
T(CMutableOutPoint(), 'CBitcoinMutableOutPoint()')
T(
CMutableOutPoint(
lx('4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b'
), 0),
"CBitcoinMutableOutPoint(lx('4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b'), 0)"
)
def mktx(ins, outs, version=1, locktime=0):
""" Given a list of input tuples (txid(bytes), n(int)),
and a list of outputs which are dicts with
keys "address" (value should be *str* not CCoinAddress) (
or alternately "script" (for nonstandard outputs, value
should be CScript)),
"value" (value should be integer satoshis), outputs a
CMutableTransaction object.
Tx version and locktime are optionally set, for non-default
locktimes, inputs are given nSequence as per below comment.
"""
vin = []
vout = []
# This does NOT trigger rbf and mimics Core's standard behaviour as of
# Jan 2019.
# Tx creators wishing to use rbf will need to set it explicitly outside
# of this function.
if locktime != 0:
sequence = 0xffffffff - 1
else:
sequence = 0xffffffff
for i in ins:
outpoint = CMutableOutPoint((i[0][::-1]), i[1])
inp = CMutableTxIn(prevout=outpoint, nSequence=sequence)
vin.append(inp)
for o in outs:
if "script" in o:
sPK = o["script"]
else:
# note the to_scriptPubKey method is only available for standard
# address types
sPK = CCoinAddress(o["address"]).to_scriptPubKey()
out = CMutableTxOut(o["value"], sPK)
vout.append(out)
return CMutableTransaction(vin, vout, nLockTime=locktime, nVersion=version)
def test_immutable_tx_creation_with_mutable_parts_specified(self):
tx = CTransaction(
vin=[CMutableTxIn(prevout=COutPoint(hash=b'a' * 32, n=0))],
vout=[CMutableTxOut(nValue=1)],
witness=CMutableTxWitness(
[CMutableTxInWitness(CScriptWitness([CScript([0])]))]))
def check_immutable_parts(tx):
self.assertTrue(tx.vin[0].is_immutable())
self.assertTrue(tx.vin[0].is_immutable())
self.assertTrue(tx.vout[0].is_immutable())
self.assertTrue(tx.wit.is_immutable())
self.assertTrue(tx.wit.vtxinwit[0].is_immutable())
check_immutable_parts(tx)
# Test that if we deserialize with CTransaction,
# all the parts are immutable
tx = CTransaction.deserialize(tx.serialize())
check_immutable_parts(tx)
# Test some parts separately, because when created via
# CMutableTransaction instantiation, they are created with from_*
# methods, and not directly
txin = CTxIn(prevout=CMutableOutPoint(hash=b'a' * 32, n=0))
self.assertTrue(txin.prevout.is_immutable())
wit = CTxWitness((CMutableTxInWitness(), ))
self.assertTrue(wit.vtxinwit[0].is_immutable())
def test_clone(self):
outpoint = CMutableOutPoint(
lx('4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b'
), 0)
self.assertEqual(outpoint.serialize(), outpoint.clone().serialize())