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
}