def __init__(self, pubkey, privkey):
"""The address object consists of the public key and
private key.
"""
# validate that the keys correspond to the correct network
if a2b_base58(pubkey)[0] != self.PUBLIC_KEY_PREFIX:
raise InvalidAddressError("%s is not a public key for %s" %
(pubkey, self.__class__.__name__))
elif a2b_base58(privkey)[0] != self.PRIVATE_KEY_PREFIX:
raise InvalidAddressError("%s is not a private key for %s" %
(privkey, self.__class__.__name__))
else:
self.pubkey = pubkey
self.privkey = privkey
def rawPubkey(self):
"""Returns the raw public key associated with this address.
This is a raw 32-byte string with no checksums
"""
# note the first byte determines what type of address
# and the last four are checksums
return a2b_base58(self.pubkey)[1:-4]
def __init__(self, address):
super().__init__()
self.address = address if type(address) is bytes else a2b_base58(address)
self._extra_bytes = self.address
self._args = [self.address]
validate_address(self.address)
def __init__(self, votes, address):
super().__init__()
self.address = _to_bytes(lambda a: a2b_base58(a), address)
self.votes = _to_bytes(lambda v: int(v).to_bytes(4, ENDIAN), votes)
self._extra_bytes = self.votes + self.address
self._args = [self.votes, self.address_pretty()]
validate_address(self.address)
def __init__(self, address, categories):
super().__init__()
self.address = _to_bytes(lambda a: a2b_base58(a), address)
self.categories = _to_bytes(lambda c: int(c).to_bytes(1, ENDIAN), categories)
self._extra_bytes = self.categories + self.address
self._args = [self.categories, self.address_pretty()]
validate_address(self.address)
def test_transfer(self):
enable_transfer_encoded = b'NVB' + transfer.EnableTransfer.OP_CODE + b'\x00\x0c\x9b\nJ\xf3[\xc1(\x1a\xf3\xd5\x13z\x1c\x90\xdc\x11\x17\xb3\x10\x82y\xe0\xf3'
assert enable_transfer_encoded == transfer.EnableTransfer(a2b_base58('129eqgh8CNi7LibSmJtbDEnZFTmKA6H3HU')).to_bytes()
disable_transfer_encoded = b'NVB' + transfer.DisableTransfer.OP_CODE
assert disable_transfer_encoded == transfer.DisableTransfer().to_bytes()
transfer_encoded = b'NVB' + transfer.TransferIdentity.OP_CODE
assert transfer_encoded == transfer.TransferIdentity().to_bytes()
def apply(op, nulldata):
self.session.commit() # commit to begin with so we know there's nothing in the transaction as we'll be rolling back
try:
op_type = type(op)
if self.network_settings is None and op_type == CreateNetwork:
print(network_name, op.name, admin_address, a2b_base58(nulldata.address))
self._assert(op.name == network_name, 'network name must match during creation')
self._assert(a2b_base58(nulldata.address) == admin_address, 'admin address must match during creation')
self.session.add(NetworkSettings(admin_address=nulldata.address, network_name=network_name))
self.session.commit()
self.reset_network_settings()
self._assert(self.network_settings is not None, 'Network settings sanity check failed')
elif self.network_settings is not None and op_type != CreateNetwork:
resolve_if_earlier_than(nulldata.timestamp, commit=False) # resolve any resolutions that are in the past an unresolved, do not commit as if this tx is not valid the resolution should not be processed!
# this is the main operation centre
if op_type == CastVote:
self.op_cast_vote(op, nulldata)
elif op_type == EmpowerVote:
self.op_empower_vote(op, nulldata)
elif op_type == DelegateVote:
self.op_delegate_vote(op, nulldata)
elif op_type == ModResolution:
self.op_mod_resolution(op, nulldata)
elif op_type == EnableTransfer:
self.op_enable_transfer(op, nulldata)
elif op_type == DisableTransfer:
self.op_disable_transfer(op, nulldata)
elif op_type == TransferIdentity:
self.op_transfer(op, nulldata)
else:
raise Exception('Wrong time for instruction')
self.session.commit() # if we get to the end commit
print('Success:', op.decode(), 'committed')
except Exception as e:
print('Failed:', op.decode(), e.__class__, e)
finally:
# if something is wrong do not commit, if we already commit()'d this does nothing
self.session.rollback()
def validate_bitcoin_address(self, address):
bcbytes = a2b_base58(str(address))
return bcbytes[-4:] == sha256(sha256(
bcbytes[:-4]).digest()).digest()[:4]
def do_test(as_text, as_bin):
self.assertEqual(as_bin, encoding.a2b_base58(as_text))
self.assertEqual(as_text, encoding.b2a_base58(as_bin))
def do_test(as_text, as_bin):
self.assertEqual(as_bin, encoding.a2b_base58(as_text))
self.assertEqual(as_text, encoding.b2a_base58(as_bin))
from sqlalchemy import desc
from pycoin.encoding import a2b_base58
from nvblib import instruction_lookup, op_code_lookup, get_op
from nvblib import CreateNetwork, CastVote, DelegateVote, EmpowerVote, ModResolution, EnableTransfer, DisableTransfer, TransferIdentity
from nvblib.constants import ENDIAN
from .models import engine, Nulldata, FilteredNulldata, RawVote, Vote, ProcessedVote, Resolution, ValidVoter, NetworkSettings, Delegate, TransferEnabled, Transfers, tally_tables
import logging
logging.basicConfig()
logging.getLogger('sqlalchemy.engine').setLevel(logging.ERROR)
admin_default = a2b_base58('13MRso7BA6AxEye7PrfT6TdzVHXLZ2DCD5')
name_default = b'\x04test'
class Tallier:
def __init__(self):
self.Session = sessionmaker(bind=engine)
self.session = self.Session()
self.network_settings = None
self.reset_network_settings()
def reset_db(self):
for table in tally_tables:
engine.execute("DROP TABLE %s" % table.__tablename__)
print("Dropping %s" % table.__tablename__)
def doit(num_ins, num_outs, master_xpub=None, subpath="0/%d", fee=10000,
invals=None, outvals=None, segwit_in=False, outstyles=['p2pkh'], psbt_hacker=None,
change_outputs=[], capture_scripts=None, add_xpub=None):
psbt = BasicPSBT()
txn = Tx(2,[],[])
master_xpub = master_xpub or simulator_fixed_xprv
# we have a key; use it to provide "plausible" value inputs
mk = BIP32Node.from_wallet_key(master_xpub)
xfp = mk.fingerprint()
psbt.inputs = [BasicPSBTInput(idx=i) for i in range(num_ins)]
psbt.outputs = [BasicPSBTOutput(idx=i) for i in range(num_outs)]
for i in range(num_ins):
# make a fake txn to supply each of the inputs
# - each input is 1BTC
# addr where the fake money will be stored.
subkey = mk.subkey_for_path(subpath % i)
sec = subkey.sec()
assert len(sec) == 33, "expect compressed"
assert subpath[0:2] == '0/'
psbt.inputs[i].bip32_paths[sec] = xfp + pack('<II', 0, i)
# UTXO that provides the funding for to-be-signed txn
supply = Tx(2,[TxIn(pack('4Q', 0xdead, 0xbeef, 0, 0), 73)],[])
scr = bytes([0x76, 0xa9, 0x14]) + subkey.hash160() + bytes([0x88, 0xac])
supply.txs_out.append(TxOut(1E8 if not invals else invals[i], scr))
with BytesIO() as fd:
if not segwit_in:
supply.stream(fd)
psbt.inputs[i].utxo = fd.getvalue()
else:
supply.txs_out[-1].stream(fd)
psbt.inputs[i].witness_utxo = fd.getvalue()
spendable = TxIn(supply.hash(), 0)
txn.txs_in.append(spendable)
for i in range(num_outs):
# random P2PKH
if not outstyles:
style = ADDR_STYLES[i % len(ADDR_STYLES)]
else:
style = outstyles[i % len(outstyles)]
if i in change_outputs:
scr, act_scr, isw, pubkey, sp = make_change_addr(mk, style)
psbt.outputs[i].bip32_paths[pubkey] = sp
else:
scr = act_scr = fake_dest_addr(style)
isw = ('w' in style)
assert scr
act_scr = act_scr or scr
if isw:
psbt.outputs[i].witness_script = scr
elif style.endswith('sh'):
psbt.outputs[i].redeem_script = scr
if not outvals:
h = TxOut(round(((1E8*num_ins)-fee) / num_outs, 4), act_scr)
else:
h = TxOut(outvals[i], act_scr)
if capture_scripts is not None:
capture_scripts.append( act_scr )
txn.txs_out.append(h)
with BytesIO() as b:
txn.stream(b)
psbt.txn = b.getvalue()
if add_xpub:
# some people want extra xpub data in their PSBTs
from pycoin.encoding import a2b_base58
psbt.xpubs = [ (a2b_base58(master_xpub), xfp) ]
# last minute chance to mod PSBT object
if psbt_hacker:
psbt_hacker(psbt)
rv = BytesIO()
psbt.serialize(rv)
assert rv.tell() <= MAX_TXN_LEN, 'too fat'
return rv.getvalue()
pubkey_hashed, address_prefix=my_pubaddr_prefix)
assert (addr_uncompressed == pubkey_addr)
print("Bitcoin Address: ", addr_compressed)
print(" uncompressed: ", addr_uncompressed)
assert (encoding.is_valid_bitcoin_address(
addr_compressed, allowable_prefixes=my_pubaddr_prefix))
assert (encoding.is_valid_bitcoin_address(
addr_uncompressed, allowable_prefixes=my_pubaddr_prefix))
print()
## Uncompressed public key
pubkey_bytes = encoding.public_pair_to_sec(pubkey_pair, False)
# uncompressed
pubkey_b58 = encoding.b2a_base58(pubkey_bytes)
assert (pubkey_bytes == encoding.a2b_base58(pubkey_b58))
btc_addr = CBitcoinAddress.from_bytes(
pubkey_bytes, bitcoin.params.BASE58_PREFIXES['PUBKEY_ADDR'])
assert (b2h(cec_key.get_pubkey()) == b2h(btc_addr.to_bytes()))
assert (hexlify(cec_key.get_pubkey()) == hexlify(pubkey_bytes))
#print("Uncompressed public key")
c_pubkey = CPubKey(pubkey_bytes)
#print("Is public key valid? ", c_pubkey.is_valid, ", compressed? ", c_pubkey.is_compressed)
assert (c_pubkey.is_compressed == False)
assert (c_pubkey.is_valid == True)
#print("Public Key base58:", pubkey_b58)
#print(" hashed:", encoding.b2a_hashed_base58(pubkey_bytes))
def validate_bitcoin_address(self, address):
bcbytes = a2b_base58(str(address))
return bcbytes[-4:] == sha256(sha256(bcbytes[:-4]).digest()).digest()[:4]
longest_match = 0
for i1 in '4': # sure
for i2 in '2': # sure
for i3 in '6': # sure
for i4 in '123456789': # NOT sure
for i6 in '123456789': # NOT sure
for i7 in '123456789': # NOT sure
# make candidate private key
key = k1 + i1 + k2 + i2 + k3 + i3 + k4 + i4 + k5 + i3 + k6 + i6 + k7 + i7 + k8
print('Trying {}...\t'.format(key), end='')
# the private key encoded in base58 contains also a checksum at the end to check validity
# when a candidate key is made by concatenation as above it will most likely not be valid
# so we correct the checksum and compression byte of the candidate key
data = a2b_base58(key)
data, the_hash = data[:-4], data[-4:]
data = data[:-1] + b'\01'
fixed_key = b2a_base58(data + double_sha256(data)[:4])
# calculate the P2SH SegWit address for this private key
k = Key.from_text(fixed_key)
p2sh = p2sh_address(k)
print('{}\t'.format(p2sh), end='')
# compare with the published public key
if p2sh[0:7] == '37CSnmm':
print('Bingo!')
exit(0)
else:
i = 0
