func main() {
var (
dataDir = flag.String("datadir", filepath.Join(btcutil.AppDataDir("btcd", false), "data"), "BTCD: Data directory")
dbType = flag.String("dbtype", "leveldb", "BTCD: Database backend")
)
flag.Parse()
db, err := btcdbSetup(*dataDir, *dbType)
if err != nil {
log.Println("btcdbSetup error:", err)
return
}
defer db.Close()
var jsonFile = flag.String("json", "blockchainr.json", "blockchainr output")
flag.Parse()
blockchainrFile, err := ioutil.ReadFile(*jsonFile)
if err != nil {
log.Println("failed to read blockchainr.json:", err)
return
}
results := make(map[string][]*inData)
err = json.Unmarshal(blockchainrFile, &results)
if err != nil {
log.Println("Unmarshal error:", err)
return
}
fmt.Println("blkH\tblkSha\tblkTime\ttxIndex\ttxSha\ttxInIndex\tprevBlkH\tprevBlkSha\tprevBlkTime\tr\taddr\twif")
targets := make(map[[2]string][]*rData)
for r, inDataList := range results {
for _, in := range inDataList {
rd := &rData{r: r, in: in}
if err := fetch(db, rd); err != nil {
log.Println("Skipping at fetch:", err)
printLine(rd)
continue
}
switch t := btcscript.GetScriptClass(rd.txPrevOut.PkScript); t {
case btcscript.PubKeyHashTy:
if err := processPubKeyHash(db, rd); err != nil {
log.Println("Skipping at opCheckSig:", err)
printLine(rd)
continue
}
default:
log.Println("Unsupported pkScript type:",
btcscript.ScriptClassToName[t], rd.in)
printLine(rd)
continue
}
// TODO: group compressed and uncompressed together
key := [...]string{rd.address, rd.r}
targets[key] = append(targets[key], rd)
}
}
// Do the magic!
for _, target := range targets {
if len(target) < 2 {
// The r value was reused across different addresses
// TODO: also this information would be interesting to graph
for _, rd := range target {
printLine(rd)
}
continue
}
a := target[0]
b := target[1]
log.Printf("[%v]\n", a.address)
log.Printf("Repeated r value: %v (%v times)\n", a.r, len(target))
privKey := recoverKey(a.signature, b.signature, a.hash, b.hash, a.pubKey)
if privKey == nil {
log.Print("recoverKey error\n\n")
continue
}
wif, err := btcutil.NewWIF(privKey, &btcnet.MainNetParams, a.compressed)
if err != nil {
log.Printf("NewWIF error: %v\n\n", err)
continue
}
for _, rd := range target {
rd.wif = wif
printLine(rd)
}
log.Printf("%v\n\n", wif.String())
}
}
func TestWatchingWalletExport(t *testing.T) {
const keypoolSize = 10
createdAt := &BlockStamp{}
w, err := NewWallet("banana wallet", "A wallet for testing.",
[]byte("banana"), tstNetParams, createdAt, keypoolSize)
if err != nil {
t.Error("Error creating new wallet: " + err.Error())
return
}
// Maintain a set of the active addresses in the wallet.
activeAddrs := make(map[addressKey]struct{})
// Add root address.
activeAddrs[getAddressKey(w.LastChainedAddress())] = struct{}{}
// Get as many new active addresses as necessary to deplete the keypool.
// This is done as we will want to test that new addresses created by
// the watching wallet do not pull from previous public keys in the
// original keypool.
for i := 0; i < keypoolSize; i++ {
apkh, err := w.NextChainedAddress(createdAt, keypoolSize)
if err != nil {
t.Errorf("unable to get next address: %v", err)
return
}
activeAddrs[getAddressKey(apkh)] = struct{}{}
}
// Create watching wallet from w.
ww, err := w.ExportWatchingWallet()
if err != nil {
t.Errorf("Could not create watching wallet: %v", err)
return
}
// Verify correctness of wallet flags.
if ww.flags.useEncryption {
t.Errorf("Watching wallet marked as using encryption (but nothing to encrypt).")
return
}
if !ww.flags.watchingOnly {
t.Errorf("Wallet should be watching-only but is not marked so.")
return
}
// Verify that all flags are set as expected.
if ww.keyGenerator.flags.encrypted {
t.Errorf("Watching root address should not be encrypted (nothing to encrypt)")
return
}
if ww.keyGenerator.flags.hasPrivKey {
t.Errorf("Watching root address marked as having a private key.")
return
}
if !ww.keyGenerator.flags.hasPubKey {
t.Errorf("Watching root address marked as missing a public key.")
return
}
if ww.keyGenerator.flags.createPrivKeyNextUnlock {
t.Errorf("Watching root address marked as needing a private key to be generated later.")
return
}
for apkh, waddr := range ww.addrMap {
switch addr := waddr.(type) {
case *btcAddress:
if addr.flags.encrypted {
t.Errorf("Chained address should not be encrypted (nothing to encrypt)")
return
}
if addr.flags.hasPrivKey {
t.Errorf("Chained address marked as having a private key.")
return
}
if !addr.flags.hasPubKey {
t.Errorf("Chained address marked as missing a public key.")
return
}
if addr.flags.createPrivKeyNextUnlock {
t.Errorf("Chained address marked as needing a private key to be generated later.")
return
}
case *scriptAddress:
t.Errorf("Chained address was a script!")
return
default:
t.Errorf("Chained address unknown type!")
return
}
if _, ok := activeAddrs[apkh]; !ok {
t.Errorf("Address from watching wallet not found in original wallet.")
return
}
delete(activeAddrs, apkh)
}
if len(activeAddrs) != 0 {
t.Errorf("%v address(es) were not exported to watching wallet.", len(activeAddrs))
return
}
// Check that the new addresses created by each wallet match. The
// original wallet is unlocked so the keypool is refilled and chained
// addresses use the previous' privkey, not pubkey.
if err := w.Unlock([]byte("banana")); err != nil {
t.Errorf("Unlocking original wallet failed: %v", err)
}
for i := 0; i < keypoolSize; i++ {
addr, err := w.NextChainedAddress(createdAt, keypoolSize)
if err != nil {
t.Errorf("Cannot get next chained address for original wallet: %v", err)
return
}
waddr, err := ww.NextChainedAddress(createdAt, keypoolSize)
if err != nil {
t.Errorf("Cannot get next chained address for watching wallet: %v", err)
return
}
if addr.EncodeAddress() != waddr.EncodeAddress() {
t.Errorf("Next addresses for each wallet do not match eachother.")
return
}
}
// Test that ExtendActiveAddresses for the watching wallet match
// manually requested addresses of the original wallet.
newAddrs := make([]btcutil.Address, 0, keypoolSize)
for i := 0; i < keypoolSize; i++ {
addr, err := w.NextChainedAddress(createdAt, keypoolSize)
if err != nil {
t.Errorf("Cannot get next chained address for original wallet: %v", err)
return
}
newAddrs = append(newAddrs, addr)
}
newWWAddrs, err := ww.ExtendActiveAddresses(keypoolSize, keypoolSize)
if err != nil {
t.Errorf("Cannot extend active addresses for watching wallet: %v", err)
return
}
for i := range newAddrs {
if newAddrs[i].EncodeAddress() != newWWAddrs[i].EncodeAddress() {
t.Errorf("Extended active addresses do not match manually requested addresses.")
return
}
}
// Test ExtendActiveAddresses for the original wallet after manually
// requesting addresses for the watching wallet.
newWWAddrs = make([]btcutil.Address, 0, keypoolSize)
for i := 0; i < keypoolSize; i++ {
addr, err := ww.NextChainedAddress(createdAt, keypoolSize)
if err != nil {
t.Errorf("Cannot get next chained address for watching wallet: %v", err)
return
}
newWWAddrs = append(newWWAddrs, addr)
}
newAddrs, err = w.ExtendActiveAddresses(keypoolSize, keypoolSize)
if err != nil {
t.Errorf("Cannot extend active addresses for original wallet: %v", err)
return
}
for i := range newAddrs {
if newAddrs[i].EncodeAddress() != newWWAddrs[i].EncodeAddress() {
t.Errorf("Extended active addresses do not match manually requested addresses.")
return
}
}
// Test (de)serialization of watching wallet.
buf := new(bytes.Buffer)
_, err = ww.WriteTo(buf)
if err != nil {
t.Errorf("Cannot write watching wallet: %v", err)
return
}
ww2 := new(Wallet)
_, err = ww2.ReadFrom(buf)
if err != nil {
t.Errorf("Cannot read watching wallet: %v", err)
return
}
// Check that (de)serialized watching wallet matches the exported wallet.
if !reflect.DeepEqual(ww, ww2) {
t.Error("Exported and read-in watching wallets do not match.")
return
}
// Verify that nonsensical functions fail with correct error.
if err := ww.Lock(); err != ErrWalletIsWatchingOnly {
t.Errorf("Nonsensical func Lock returned no or incorrect error: %v", err)
return
}
if err := ww.Unlock([]byte("banana")); err != ErrWalletIsWatchingOnly {
t.Errorf("Nonsensical func Unlock returned no or incorrect error: %v", err)
return
}
generator, err := ww.Address(w.keyGenerator.Address())
if err != nil {
t.Errorf("generator isnt' present in wallet")
}
gpk := generator.(PubKeyAddress)
if _, err := gpk.PrivKey(); err != ErrWalletIsWatchingOnly {
t.Errorf("Nonsensical func AddressKey returned no or incorrect error: %v", err)
return
}
if _, err := ww.ExportWatchingWallet(); err != ErrWalletIsWatchingOnly {
t.Errorf("Nonsensical func ExportWatchingWallet returned no or incorrect error: %v", err)
return
}
pk, _ := btcec.PrivKeyFromBytes(btcec.S256(), make([]byte, 32))
wif, err := btcutil.NewWIF(pk, tstNetParams, true)
if err != nil {
t.Fatal(err)
}
if _, err := ww.ImportPrivateKey(wif, createdAt); err != ErrWalletIsWatchingOnly {
t.Errorf("Nonsensical func ImportPrivateKey returned no or incorrect error: %v", err)
return
}
}
func TestImportPrivateKey(t *testing.T) {
const keypoolSize = 10
createHeight := int32(100)
createdAt := &BlockStamp{Height: createHeight}
w, err := NewWallet("banana wallet", "A wallet for testing.",
[]byte("banana"), tstNetParams, createdAt, keypoolSize)
if err != nil {
t.Error("Error creating new wallet: " + err.Error())
return
}
if err = w.Unlock([]byte("banana")); err != nil {
t.Errorf("Can't unlock original wallet: %v", err)
return
}
pk, err := ecdsa.GenerateKey(btcec.S256(), rand.Reader)
if err != nil {
t.Error("Error generating private key: " + err.Error())
return
}
// verify that the entire wallet's sync height matches the
// expected createHeight.
if h := w.SyncHeight(); h != createHeight {
t.Errorf("Initial sync height %v does not match expected %v.", h, createHeight)
return
}
// import priv key
wif, err := btcutil.NewWIF((*btcec.PrivateKey)(pk), tstNetParams, false)
if err != nil {
t.Fatal(err)
}
importHeight := int32(50)
importedAt := &BlockStamp{Height: importHeight}
address, err := w.ImportPrivateKey(wif, importedAt)
if err != nil {
t.Error("importing private key: " + err.Error())
return
}
addr, err := w.Address(address)
if err != nil {
t.Error("privkey just imported missing: " + err.Error())
return
}
pka := addr.(PubKeyAddress)
// lookup address
pk2, err := pka.PrivKey()
if err != nil {
t.Error("error looking up key: " + err.Error())
}
if !reflect.DeepEqual(pk, pk2) {
t.Error("original and looked-up private keys do not match.")
return
}
// verify that the sync height now match the (smaller) import height.
if h := w.SyncHeight(); h != importHeight {
t.Errorf("After import sync height %v does not match expected %v.", h, importHeight)
return
}
// serialise and deseralise and check still there.
// Test (de)serialization of wallet.
buf := new(bytes.Buffer)
_, err = w.WriteTo(buf)
if err != nil {
t.Errorf("Cannot write wallet: %v", err)
return
}
w2 := new(Wallet)
_, err = w2.ReadFrom(buf)
if err != nil {
t.Errorf("Cannot read wallet: %v", err)
return
}
// Verify that the sync height match expected after the reserialization.
if h := w2.SyncHeight(); h != importHeight {
t.Errorf("After reserialization sync height %v does not match expected %v.", h, importHeight)
return
}
// Mark imported address as partially synced with a block somewhere inbetween
// the import height and the chain height.
partialHeight := (createHeight-importHeight)/2 + importHeight
if err := w2.SetSyncStatus(address, PartialSync(partialHeight)); err != nil {
t.Errorf("Cannot mark address partially synced: %v", err)
return
}
if h := w2.SyncHeight(); h != partialHeight {
t.Errorf("After address partial sync, sync height %v does not match expected %v.", h, partialHeight)
return
}
// Test serialization with the partial sync.
buf.Reset()
_, err = w2.WriteTo(buf)
if err != nil {
t.Errorf("Cannot write wallet: %v", err)
return
}
w3 := new(Wallet)
_, err = w3.ReadFrom(buf)
if err != nil {
t.Errorf("Cannot read wallet: %v", err)
return
}
// Test correct partial height after serialization.
if h := w3.SyncHeight(); h != partialHeight {
t.Errorf("After address partial sync and reserialization, sync height %v does not match expected %v.",
h, partialHeight)
return
}
// Mark imported address as not synced at all, and verify sync height is now
// the import height.
if err := w3.SetSyncStatus(address, Unsynced(0)); err != nil {
t.Errorf("Cannot mark address synced: %v", err)
return
}
if h := w3.SyncHeight(); h != importHeight {
t.Errorf("After address unsync, sync height %v does not match expected %v.", h, importHeight)
return
}
// Mark imported address as synced with the recently-seen blocks, and verify
// that the sync height now equals the most recent block (the one at wallet
// creation).
if err := w3.SetSyncStatus(address, FullSync{}); err != nil {
t.Errorf("Cannot mark address synced: %v", err)
return
}
if h := w3.SyncHeight(); h != createHeight {
t.Errorf("After address sync, sync height %v does not match expected %v.", h, createHeight)
return
}
if err = w3.Unlock([]byte("banana")); err != nil {
t.Errorf("Can't unlock deserialised wallet: %v", err)
return
}
addr3, err := w3.Address(address)
if err != nil {
t.Error("privkey in deserialised wallet missing : " +
err.Error())
return
}
pka3 := addr3.(PubKeyAddress)
// lookup address
pk2, err = pka3.PrivKey()
if err != nil {
t.Error("error looking up key in deserialized wallet: " + err.Error())
}
if !reflect.DeepEqual(pk, pk2) {
t.Error("original and deserialized private keys do not match.")
return
}
}
func newWifKeyPair(net *btcnet.Params) *btcutil.WIF {
curve := elliptic.P256()
priv, _ := ecdsa.GenerateKey(curve, rand.Reader)
wif, _ := btcutil.NewWIF((*btcec.PrivateKey)(priv), net, true)
return wif
}
