func compute(count *big.Int) (keys [ResultsPerPage]Key, length int) { var padded [32]byte var i int for i = 0; i < ResultsPerPage; i++ { // Increment our counter count.Add(count, one) // Check to make sure we're not out of range if count.Cmp(total) > 0 { break } // Copy count value's bytes to padded slice copy(padded[32-len(count.Bytes()):], count.Bytes()) // Get private and public keys privKey, public := btcec.PrivKeyFromBytes(btcec.S256(), padded[:]) // Get compressed and uncompressed addresses for public key caddr, _ := btcutil.NewAddressPubKey(public.SerializeCompressed(), &btcnet.MainNetParams) uaddr, _ := btcutil.NewAddressPubKey(public.SerializeUncompressed(), &btcnet.MainNetParams) // Encode addresses wif, _ := btcutil.NewWIF(privKey, &btcnet.MainNetParams, false) keys[i].private = wif.String() keys[i].number = count.String() keys[i].compressed = caddr.EncodeAddress() keys[i].uncompressed = uaddr.EncodeAddress() } return keys, i }
// ExportPrivKey returns the private key associated with the address in Wallet // Import Format (WIF). // // This is part of the ManagedPubKeyAddress interface implementation. func (a *managedAddress) ExportPrivKey() (*btcutil.WIF, error) { pk, err := a.PrivKey() if err != nil { return nil, err } return btcutil.NewWIF(pk, a.manager.chainParams, a.compressed) }
// convertLegacyKeystore converts all of the addresses in the passed legacy // key store to the new waddrmgr.Manager format. Both the legacy keystore and // the new manager must be unlocked. func convertLegacyKeystore(legacyKeyStore *keystore.Store, manager *waddrmgr.Manager) error { netParams := legacyKeyStore.Net() blockStamp := waddrmgr.BlockStamp{ Height: 0, Hash: *netParams.GenesisHash, } for _, walletAddr := range legacyKeyStore.ActiveAddresses() { switch addr := walletAddr.(type) { case keystore.PubKeyAddress: privKey, err := addr.PrivKey() if err != nil { fmt.Printf("WARN: Failed to obtain private key "+ "for address %v: %v\n", addr.Address(), err) continue } wif, err := btcutil.NewWIF((*btcec.PrivateKey)(privKey), netParams, addr.Compressed()) if err != nil { fmt.Printf("WARN: Failed to create wallet "+ "import format for address %v: %v\n", addr.Address(), err) continue } _, err = manager.ImportPrivateKey(wif, &blockStamp) if err != nil { fmt.Printf("WARN: Failed to import private "+ "key for address %v: %v\n", addr.Address(), err) continue } case keystore.ScriptAddress: _, err := manager.ImportScript(addr.Script(), &blockStamp) if err != nil { fmt.Printf("WARN: Failed to import "+ "pay-to-script-hash script for "+ "address %v: %v\n", addr.Address(), err) continue } default: fmt.Printf("WARN: Skipping unrecognized legacy "+ "keystore type: %T\n", addr) continue } } return nil }
func RedirectRequest(w http.ResponseWriter, r *http.Request) { key := r.URL.Path[36:] wif, err := btcutil.DecodeWIF(key) if err != nil { w.WriteHeader(http.StatusNotFound) return } page, _ := new(big.Int).DivMod(new(big.Int).SetBytes(wif.PrivKey.D.Bytes()), big.NewInt(ResultsPerPage), big.NewInt(ResultsPerPage)) page.Add(page, one) fragment, _ := btcutil.NewWIF(wif.PrivKey, &btcnet.MainNetParams, false) http.Redirect(w, r, "/"+page.String()+"#"+fragment.String(), http.StatusTemporaryRedirect) }
func loadTestCredits(w *LightningWallet, numOutputs, btcPerOutput int) error { // Import the priv key (converting to WIF) above that controls all our // available outputs. privKey, _ := btcec.PrivKeyFromBytes(btcec.S256(), testWalletPrivKey) if err := w.Unlock(privPass, time.Duration(0)); err != nil { return err } bs := &waddrmgr.BlockStamp{Hash: *genBlockHash(1), Height: 1} wif, err := btcutil.NewWIF(privKey, ActiveNetParams, true) if err != nil { return err } if _, err := w.ImportPrivateKey(wif, bs, false); err != nil { return nil } if err := w.Manager.SetSyncedTo(&waddrmgr.BlockStamp{int32(1), *genBlockHash(1)}); err != nil { return err } blk := wtxmgr.BlockMeta{wtxmgr.Block{Hash: *genBlockHash(2), Height: 2}, time.Now()} // Create a simple P2PKH pubkey script spendable by Alice. For simplicity // all of Alice's spendable funds will reside in this output. satosihPerOutput := int64(btcPerOutput * 1e8) walletAddr, err := btcutil.NewAddressPubKey(privKey.PubKey().SerializeCompressed(), ActiveNetParams) if err != nil { return err } walletScriptCredit, err := txscript.PayToAddrScript(walletAddr.AddressPubKeyHash()) if err != nil { return err } // Create numOutputs outputs spendable by our wallet each holding btcPerOutput // in satoshis. tx := wire.NewMsgTx() prevOut := wire.NewOutPoint(genBlockHash(999), 1) txIn := wire.NewTxIn(prevOut, []byte{txscript.OP_0, txscript.OP_0}) tx.AddTxIn(txIn) for i := 0; i < numOutputs; i++ { tx.AddTxOut(wire.NewTxOut(satosihPerOutput, walletScriptCredit)) } txCredit, err := wtxmgr.NewTxRecordFromMsgTx(tx, time.Now()) if err != nil { return err } if err := addTestTx(w, txCredit, &blk); err != nil { return err } if err := w.Manager.SetSyncedTo(&waddrmgr.BlockStamp{int32(2), *genBlockHash(2)}); err != nil { return err } // Make the wallet think it's been synced to block 10. This way the // outputs we added above will have sufficient confirmations // (hard coded to 6 atm). for i := 3; i < 10; i++ { sha := *genBlockHash(i) if err := w.Manager.SetSyncedTo(&waddrmgr.BlockStamp{int32(i), sha}); err != nil { return err } } return nil }
func TestImportPrivateKey(t *testing.T) { createHeight := int32(100) createdAt := makeBS(createHeight) w, err := New(dummyDir, "A wallet for testing.", []byte("banana"), tstNetParams, createdAt) 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 := btcec.NewPrivateKey(btcec.S256()) 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.SyncedTo(); 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 := makeBS(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.SyncedTo(); 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(Store) _, 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.SyncedTo(); 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.SyncedTo(); 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(Store) _, err = w3.ReadFrom(buf) if err != nil { t.Errorf("Cannot read wallet: %v", err) return } // Test correct partial height after serialization. if _, h := w3.SyncedTo(); 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.SyncedTo(); 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.SyncedTo(); 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 TestWatchingWalletExport(t *testing.T) { createdAt := makeBS(0) w, err := New(dummyDir, "A wallet for testing.", []byte("banana"), tstNetParams, createdAt) 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{}{} // 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 addresses are chained with privkeys. if err := w.Unlock([]byte("banana")); err != nil { t.Errorf("Unlocking original wallet failed: %v", err) } // Test that ExtendActiveAddresses for the watching wallet match // manually requested addresses of the original wallet. var newAddrs []btcutil.Address for i := 0; i < 10; i++ { addr, err := w.NextChainedAddress(createdAt) if err != nil { t.Errorf("Cannot get next chained address for original wallet: %v", err) return } newAddrs = append(newAddrs, addr) } newWWAddrs, err := ww.ExtendActiveAddresses(10) 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 = nil for i := 0; i < 10; i++ { addr, err := ww.NextChainedAddress(createdAt) if err != nil { t.Errorf("Cannot get next chained address for watching wallet: %v", err) return } newWWAddrs = append(newWWAddrs, addr) } newAddrs, err = w.ExtendActiveAddresses(10) 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(Store) _, 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 != ErrWatchingOnly { t.Errorf("Nonsensical func Lock returned no or incorrect error: %v", err) return } if err := ww.Unlock([]byte("banana")); err != ErrWatchingOnly { 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 != ErrWatchingOnly { t.Errorf("Nonsensical func AddressKey returned no or incorrect error: %v", err) return } if _, err := ww.ExportWatchingWallet(); err != ErrWatchingOnly { 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 != ErrWatchingOnly { t.Errorf("Nonsensical func ImportPrivateKey returned no or incorrect error: %v", err) return } }
func (w *LibbitcoinWallet) Spend(amount int64, addr btc.Address, feeLevel bitcoin.FeeLevel) error { // Check for dust script, _ := txscript.PayToAddrScript(addr) if txrules.IsDustAmount(btc.Amount(amount), len(script), txrules.DefaultRelayFeePerKb) { return errors.New("Amount is below dust threshold") } var additionalPrevScripts map[wire.OutPoint][]byte var additionalKeysByAddress map[string]*btc.WIF // Create input source coinMap := w.gatherCoins() coins := make([]coinset.Coin, 0, len(coinMap)) for k := range coinMap { coins = append(coins, k) } inputSource := func(target btc.Amount) (total btc.Amount, inputs []*wire.TxIn, scripts [][]byte, err error) { // TODO: maybe change the coin selection algorithm? We're using min coins right now because // TODO: we don't know the number of confirmations on each coin without querying the libbitcoin server. coinSelector := coinset.MinNumberCoinSelector{MaxInputs: 10000, MinChangeAmount: btc.Amount(10000)} coins, err := coinSelector.CoinSelect(target, coins) if err != nil { return total, inputs, scripts, errors.New("insuffient funds") } additionalPrevScripts = make(map[wire.OutPoint][]byte) additionalKeysByAddress = make(map[string]*btc.WIF) for _, c := range coins.Coins() { total += c.Value() outpoint := wire.NewOutPoint(c.Hash(), c.Index()) in := wire.NewTxIn(outpoint, []byte{}) in.Sequence = 0 // Opt-in RBF so we can bump fees inputs = append(inputs, in) additionalPrevScripts[*outpoint] = c.PkScript() key := coinMap[c] addr, _ := btc.NewAddressPubKey(key.PublicKey().Key, w.params) pk, _ := btcec.PrivKeyFromBytes(btcec.S256(), key.Key) wif, _ := btc.NewWIF(pk, w.params, true) additionalKeysByAddress[addr.AddressPubKeyHash().EncodeAddress()] = wif } return total, inputs, scripts, nil } // Get the fee per kilobyte feePerKB := int64(w.getFeePerByte(feeLevel)) * 1000 // outputs out := wire.NewTxOut(amount, script) // Create change source changeSource := func() ([]byte, error) { addr := w.GetCurrentAddress(bitcoin.CHANGE) script, err := txscript.PayToAddrScript(addr) if err != nil { return []byte{}, err } return script, nil } authoredTx, err := txauthor.NewUnsignedTransaction([]*wire.TxOut{out}, btc.Amount(feePerKB), inputSource, changeSource) if err != nil { return err } // BIP 69 sorting txsort.InPlaceSort(authoredTx.Tx) // Sign tx getKey := txscript.KeyClosure(func(addr btc.Address) ( *btcec.PrivateKey, bool, error) { addrStr := addr.EncodeAddress() wif := additionalKeysByAddress[addrStr] return wif.PrivKey, wif.CompressPubKey, nil }) getScript := txscript.ScriptClosure(func( addr btc.Address) ([]byte, error) { return []byte{}, nil }) for i, txIn := range authoredTx.Tx.TxIn { prevOutScript := additionalPrevScripts[txIn.PreviousOutPoint] script, err := txscript.SignTxOutput(w.params, authoredTx.Tx, i, prevOutScript, txscript.SigHashAll, getKey, getScript, txIn.SignatureScript) if err != nil { return errors.New("Failed to sign transaction") } txIn.SignatureScript = script } // Broadcast tx to bitcoin network serializedTx := new(bytes.Buffer) authoredTx.Tx.Serialize(serializedTx) w.Client.Broadcast(serializedTx.Bytes(), func(i interface{}, err error) { if err == nil { log.Infof("Broadcast tx %s to bitcoin network\n", authoredTx.Tx.TxSha().String()) } else { log.Errorf("Failed to broadcast tx, reason: %s\n", err) } }) // Update the db w.ProcessTransaction(btc.NewTx(authoredTx.Tx), 0) return nil }