def test_from_nonstd_scriptPubKey(self):
"""CBitcoinAddress.from_scriptPubKey() with non-standard scriptPubKeys"""
# Bad P2SH scriptPubKeys
# non-canonical pushdata
scriptPubKey = CScript(
x('a94c14000000000000000000000000000000000000000087'))
with self.assertRaises(CBitcoinAddressError):
CBitcoinAddress.from_scriptPubKey(scriptPubKey)
# Bad P2PKH scriptPubKeys
# Missing a byte
scriptPubKey = CScript(
x('76a914000000000000000000000000000000000000000088'))
with self.assertRaises(CBitcoinAddressError):
CBitcoinAddress.from_scriptPubKey(scriptPubKey)
# One extra byte
scriptPubKey = CScript(
x('76a914000000000000000000000000000000000000000088acac'))
with self.assertRaises(CBitcoinAddressError):
CBitcoinAddress.from_scriptPubKey(scriptPubKey)
# One byte changed
scriptPubKey = CScript(
x('76a914000000000000000000000000000000000000000088ad'))
with self.assertRaises(CBitcoinAddressError):
CBitcoinAddress.from_scriptPubKey(scriptPubKey)
def test_from_invalid_scriptPubKey(self):
"""CBitcoinAddress.from_scriptPubKey() with invalid scriptPubKeys"""
# We should raise a CBitcoinAddressError, not any other type of error
# Truncated P2SH
scriptPubKey = CScript(x('a91400000000000000000000000000000000000000'))
with self.assertRaises(CBitcoinAddressError):
CBitcoinAddress.from_scriptPubKey(scriptPubKey)
# Truncated P2PKH
scriptPubKey = CScript(
x('76a91400000000000000000000000000000000000000'))
with self.assertRaises(CBitcoinAddressError):
CBitcoinAddress.from_scriptPubKey(scriptPubKey)
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 T(hex_scriptpubkey, expected_str_address):
scriptPubKey = CScript(x(hex_scriptpubkey))
addr = P2PKHBitcoinAddress.from_scriptPubKey(scriptPubKey)
self.assertEqual(str(addr), expected_str_address)
# now test that CBitcoinAddressError is raised with accept_non_canonical_pushdata=False
with self.assertRaises(CBitcoinAddressError):
P2PKHBitcoinAddress.from_scriptPubKey(
scriptPubKey, accept_bare_checksig=False)
def payment_ack(serialized_Payment_message):
"""Generates a PaymentACK object, captures client refund address and returns a message"""
pao = o.PaymentACK()
pao.payment.ParseFromString(serialized_Payment_message)
pao.memo = 'String shown to user after payment confirmation'
refund_address = CBitcoinAddress.from_scriptPubKey(CScript(pao.payment.refund_to[0].script))
sds_pa = pao.SerializeToString()
open('sds_pa_blob', 'wb').write(sds_pa)
headers = {'Content-Type' : 'application/bitcoin-payment', 'Accept' : 'application/bitcoin-paymentack'}
http_response_object = urllib2.Request('file:sds_pa_blob', None, headers)
return http_response_object
def gettxout(self, outpoint, includemempool=True):
"""Return details about an unspent transaction output.
Raises IndexError if outpoint is not found or was spent.
includemempool - Include mempool txouts
"""
r = self._call('gettxout', b2lx(outpoint.hash), outpoint.n,
includemempool)
if r is None:
raise IndexError('%s.gettxout(): unspent txout %r not found' %
(self.__class__.__name__, outpoint))
r['txout'] = CTxOut(int(r['value'] * COIN),
CScript(unhexlify(r['scriptPubKey']['hex'])))
del r['value']
del r['scriptPubKey']
r['bestblock'] = lx(r['bestblock'])
return r
def T(hex_scriptpubkey, expected_str_address, expected_class):
scriptPubKey = CScript(x(hex_scriptpubkey))
addr = CBitcoinAddress.from_scriptPubKey(scriptPubKey)
self.assertEqual(str(addr), expected_str_address)
self.assertEqual(addr.__class__, expected_class)
def test_from_redeemScript(self):
addr = P2SHBitcoinAddress.from_redeemScript(CScript())
self.assertEqual(
str(addr),
'bitcoincash:pz689gnx6z7cnsfhq6jpxtx0k9hhcwulev5cpumfk0')
from bitcoincash import SelectParams
from bitcoincash.core import b2x, lx, COIN, COutPoint, CMutableTxOut, CMutableTxIn, CMutableTransaction, Hash160
from bitcoincash.core.script import CScript, OP_DUP, OP_HASH160, OP_EQUALVERIFY, OP_CHECKSIG, SignatureHash, SIGHASH_ALL
from bitcoincash.core.scripteval import VerifyScript, SCRIPT_VERIFY_P2SH
from bitcoincash.wallet import CBitcoinAddress, CBitcoinSecret
SelectParams('mainnet')
# Create the (in)famous correct brainwallet secret key.
h = hashlib.sha256(b'correct horse battery staple').digest()
seckey = CBitcoinSecret.from_secret_bytes(h)
# Create a redeemScript. Similar to a scriptPubKey the redeemScript must be
# satisfied for the funds to be spent.
txin_redeemScript = CScript([seckey.pub, OP_CHECKSIG])
print(b2x(txin_redeemScript))
# Create the magic P2SH scriptPubKey format from that redeemScript. You should
# look at the CScript.to_p2sh_scriptPubKey() function in bitcoincash.core.script to
# understand what's happening, as well as read BIP16:
# https://github.com/bitcoin/bips/blob/master/bip-0016.mediawiki
txin_scriptPubKey = txin_redeemScript.to_p2sh_scriptPubKey()
# Convert the P2SH scriptPubKey to a base58 Bitcoin address and print it.
# You'll need to send some funds to it to create a txout to spend.
txin_p2sh_address = CBitcoinAddress.from_scriptPubKey(txin_scriptPubKey)
print('Pay to:', str(txin_p2sh_address))
# Same as the txid:vout the createrawtransaction RPC call requires
#
# There's also a corresponding x() convenience function that takes big-endian
# hex and converts it to bytes.
txid = lx('7e195aa3de827814f172c362fcf838d92ba10e3f9fdd9c3ecaf79522b311b22d')
vout = 0
# Create the txin structure, which includes the outpoint. The scriptSig
# defaults to being empty.
txin = CMutableTxIn(COutPoint(txid, vout))
# We also need the scriptPubKey of the output we're spending because
# SignatureHash() replaces the transaction scriptSig's with it.
#
# Here we'll create that scriptPubKey from scratch using the pubkey that
# corresponds to the secret key we generated above.
txin_scriptPubKey = CScript(
[OP_DUP, OP_HASH160,
Hash160(seckey.pub), OP_EQUALVERIFY, OP_CHECKSIG])
# Create the txout. This time we create the scriptPubKey from a Bitcoin
# address.
txout = CMutableTxOut(
0.001 * COIN,
CBitcoinAddress('1C7zdTfnkzmr13HfA2vNm5SJYRK6nEKyq8').to_scriptPubKey())
# Create the unsigned transaction.
tx = CMutableTransaction([txin], [txout])
# Calculate the signature hash for that transaction.
sighash = SignatureHash(txin_scriptPubKey, tx, 0, SIGHASH_ALL)
# Now sign it. We have to append the type of signature we want to the end, in