// ExportWatchingWallet returns a watching-only version of the wallet serialized
// database as a base64-encoded string.
func (w *Wallet) ExportWatchingWallet(pubPass string) (string, error) {
tmpDir, err := ioutil.TempDir("", "btcwallet")
if err != nil {
return "", err
}
defer os.RemoveAll(tmpDir)
// Create a new file and write a copy of the current database into it.
woDbPath := filepath.Join(tmpDir, walletDbWatchingOnlyName)
fi, err := os.OpenFile(woDbPath, os.O_CREATE|os.O_RDWR, 0600)
if err != nil {
return "", err
}
if err := w.db.Copy(fi); err != nil {
fi.Close()
return "", err
}
fi.Close()
defer os.Remove(woDbPath)
// Open the new database, get the address manager namespace, and open
// it.
woDb, err := walletdb.Open("bdb", woDbPath)
if err != nil {
_ = os.Remove(woDbPath)
return "", err
}
defer woDb.Close()
namespace, err := woDb.Namespace(waddrmgrNamespaceKey)
if err != nil {
return "", err
}
woMgr, err := waddrmgr.Open(namespace, []byte(pubPass),
w.chainParams, nil)
if err != nil {
return "", err
}
defer woMgr.Close()
// Convert the namespace to watching only if needed.
if err := woMgr.ConvertToWatchingOnly(); err != nil {
// Only return the error is it's not because it's already
// watching-only. When it is already watching-only, the code
// just falls through to the export below.
if !waddrmgr.IsError(err, waddrmgr.ErrWatchingOnly) {
return "", err
}
}
// Export the watching only wallet's serialized data.
woWallet := *w
woWallet.db = woDb
woWallet.Manager = woMgr
return woWallet.exportBase64()
}
// openDb opens and returns a walletdb.DB (boltdb here) given the directory and
// dbname
func openDb(directory string, dbname string) (walletdb.DB, error) {
dbPath := filepath.Join(directory, dbname)
// Ensure that the network directory exists.
if err := checkCreateDir(directory); err != nil {
return nil, err
}
// Open the database using the boltdb backend.
return walletdb.Open("bdb", dbPath)
}
// openDbNamespace opens wallet database at the provided path and returns it
// along with the address manager namespace.
func openDbNamespace(dbPath string) (walletdb.DB, walletdb.Namespace, error) {
db, err := walletdb.Open("bdb", dbPath)
if err != nil {
return nil, nil, err
}
namespace, err := db.Namespace(waddrmgrNamespaceKey)
if err != nil {
db.Close()
return nil, nil, err
}
return db, namespace, nil
}
func mainInt() int {
fmt.Println("Database path:", opts.DbPath)
_, err := os.Stat(opts.DbPath)
if os.IsNotExist(err) {
fmt.Println("Database file does not exist")
return 1
}
for !opts.Force {
fmt.Print("Drop all btcwallet transaction history? [y/N] ")
scanner := bufio.NewScanner(bufio.NewReader(os.Stdin))
if !scanner.Scan() {
// Exit on EOF.
return 0
}
err := scanner.Err()
if err != nil {
fmt.Println()
fmt.Println(err)
return 1
}
resp := scanner.Text()
if yes(resp) {
break
}
if no(resp) || resp == "" {
return 0
}
fmt.Println("Enter yes or no.")
}
db, err := walletdb.Open("bdb", opts.DbPath)
if err != nil {
fmt.Println("Failed to open database:", err)
return 1
}
defer db.Close()
fmt.Println("Dropping wtxmgr namespace")
err = db.DeleteNamespace(wtxmgrNamespace)
if err != nil && err != walletdb.ErrBucketNotFound {
fmt.Println("Failed to drop namespace:", err)
return 1
}
return 0
}
// TestCreateOpenUnsupported ensures that attempting to create or open an
// unsupported database type is handled properly.
func TestCreateOpenUnsupported(t *testing.T) {
// Ensure creating a database with an unsupported type fails with the
// expected error.
dbType := "unsupported"
_, err := walletdb.Create(dbType)
if err != walletdb.ErrDbUnknownType {
t.Errorf("expected error not received - got: %v, want %v", err,
walletdb.ErrDbUnknownType)
return
}
// Ensure opening a database with the an unsupported type fails with the
// expected error.
_, err = walletdb.Open(dbType)
if err != walletdb.ErrDbUnknownType {
t.Errorf("expected error not received - got: %v, want %v", err,
walletdb.ErrDbUnknownType)
return
}
}
// TestCreateOpenFail ensures that errors which occur while opening or closing
// a database are handled properly.
func TestCreateOpenFail(t *testing.T) {
// bogusCreateDB is a function which acts as a bogus create and open
// driver function that intentionally returns a failure which can be
// detected.
dbType := "createopenfail"
openError := fmt.Errorf("failed to create or open database for "+
"database type [%v]", dbType)
bogusCreateDB := func(args ...interface{}) (walletdb.DB, error) {
return nil, openError
}
// Create and add driver that intentionally fails when created or opened
// to ensure errors on database open and create are handled properly.
driver := walletdb.Driver{
DbType: dbType,
Create: bogusCreateDB,
Open: bogusCreateDB,
}
walletdb.RegisterDriver(driver)
// Ensure creating a database with the new type fails with the expected
// error.
_, err := walletdb.Create(dbType)
if err != openError {
t.Errorf("expected error not received - got: %v, want %v", err,
openError)
return
}
// Ensure opening a database with the new type fails with the expected
// error.
_, err = walletdb.Open(dbType)
if err != openError {
t.Errorf("expected error not received - got: %v, want %v", err,
openError)
return
}
}
// TestCreateOpenFail ensures that errors related to creating and opening a
// database are handled properly.
func TestCreateOpenFail(t *testing.T) {
// Ensure that attempting to open a database that doesn't exist returns
// the expected error.
wantErr := walletdb.ErrDbDoesNotExist
if _, err := walletdb.Open(dbType, "noexist.db"); err != wantErr {
t.Errorf("Open: did not receive expected error - got %v, "+
"want %v", err, wantErr)
return
}
// Ensure that attempting to open a database with the wrong number of
// parameters returns the expected error.
wantErr = fmt.Errorf("invalid arguments to %s.Open -- expected "+
"database path", dbType)
if _, err := walletdb.Open(dbType, 1, 2, 3); err.Error() != wantErr.Error() {
t.Errorf("Open: did not receive expected error - got %v, "+
"want %v", err, wantErr)
return
}
// Ensure that attempting to open a database with an invalid type for
// the first parameter returns the expected error.
wantErr = fmt.Errorf("first argument to %s.Open is invalid -- "+
"expected database path string", dbType)
if _, err := walletdb.Open(dbType, 1); err.Error() != wantErr.Error() {
t.Errorf("Open: did not receive expected error - got %v, "+
"want %v", err, wantErr)
return
}
// Ensure that attempting to create a database with the wrong number of
// parameters returns the expected error.
wantErr = fmt.Errorf("invalid arguments to %s.Create -- expected "+
"database path", dbType)
if _, err := walletdb.Create(dbType, 1, 2, 3); err.Error() != wantErr.Error() {
t.Errorf("Create: did not receive expected error - got %v, "+
"want %v", err, wantErr)
return
}
// Ensure that attempting to open a database with an invalid type for
// the first parameter returns the expected error.
wantErr = fmt.Errorf("first argument to %s.Create is invalid -- "+
"expected database path string", dbType)
if _, err := walletdb.Create(dbType, 1); err.Error() != wantErr.Error() {
t.Errorf("Create: did not receive expected error - got %v, "+
"want %v", err, wantErr)
return
}
// Ensure operations against a closed database return the expected
// error.
dbPath := "createfail.db"
db, err := walletdb.Create(dbType, dbPath)
if err != nil {
t.Errorf("Create: unexpected error: %v", err)
return
}
defer os.Remove(dbPath)
db.Close()
wantErr = walletdb.ErrDbNotOpen
if _, err := db.Namespace([]byte("ns1")); err != wantErr {
t.Errorf("Namespace: did not receive expected error - got %v, "+
"want %v", err, wantErr)
return
}
}
// TestPersistence ensures that values stored are still valid after closing and
// reopening the database.
func TestPersistence(t *testing.T) {
// Create a new database to run tests against.
dbPath := "persistencetest.db"
db, err := walletdb.Create(dbType, dbPath)
if err != nil {
t.Errorf("Failed to create test database (%s) %v", dbType, err)
return
}
defer os.Remove(dbPath)
defer db.Close()
// Create a namespace and put some values into it so they can be tested
// for existence on re-open.
storeValues := map[string]string{
"ns1key1": "foo1",
"ns1key2": "foo2",
"ns1key3": "foo3",
}
ns1Key := []byte("ns1")
ns1, err := db.Namespace(ns1Key)
if err != nil {
t.Errorf("Namespace: unexpected error: %v", err)
return
}
err = ns1.Update(func(tx walletdb.Tx) error {
rootBucket := tx.RootBucket()
if rootBucket == nil {
return fmt.Errorf("RootBucket: unexpected nil root bucket")
}
for k, v := range storeValues {
if err := rootBucket.Put([]byte(k), []byte(v)); err != nil {
return fmt.Errorf("Put: unexpected error: %v", err)
}
}
return nil
})
if err != nil {
t.Errorf("ns1 Update: unexpected error: %v", err)
return
}
// Close and reopen the database to ensure the values persist.
db.Close()
db, err = walletdb.Open(dbType, dbPath)
if err != nil {
t.Errorf("Failed to open test database (%s) %v", dbType, err)
return
}
defer db.Close()
// Ensure the values previously stored in the 3rd namespace still exist
// and are correct.
ns1, err = db.Namespace(ns1Key)
if err != nil {
t.Errorf("Namespace: unexpected error: %v", err)
return
}
err = ns1.View(func(tx walletdb.Tx) error {
rootBucket := tx.RootBucket()
if rootBucket == nil {
return fmt.Errorf("RootBucket: unexpected nil root bucket")
}
for k, v := range storeValues {
gotVal := rootBucket.Get([]byte(k))
if !reflect.DeepEqual(gotVal, []byte(v)) {
return fmt.Errorf("Get: key '%s' does not "+
"match expected value - got %s, want %s",
k, gotVal, v)
}
}
return nil
})
if err != nil {
t.Errorf("ns1 View: unexpected error: %v", err)
return
}
}
