From 766dbe5070867d7aa098e7413c00ab12f6aebc97 Mon Sep 17 00:00:00 2001
From: Donald Adu-Poku <donald.adu@gmail.com>
Date: Tue, 6 Aug 2019 11:10:01 +0000
Subject: [PATCH 1/3] udb: add script storage testdata.

---
 wallet/udb/testdata/v12.db.go | 116 ++++++++++++++++++++++++++++++++++
 wallet/udb/testdata/v12.db.gz | Bin 0 -> 3346 bytes
 2 files changed, 116 insertions(+)
 create mode 100644 wallet/udb/testdata/v12.db.go
 create mode 100644 wallet/udb/testdata/v12.db.gz

diff --git a/wallet/udb/testdata/v12.db.go b/wallet/udb/testdata/v12.db.go
new file mode 100644
index 000000000..ab995ee10
--- /dev/null
+++ b/wallet/udb/testdata/v12.db.go
@@ -0,0 +1,116 @@
+// Copyright (c) 2019 The Decred developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+// This file should compiled from the commit the file was introduced, otherwise
+// it may not compile due to API changes, or may not create the database with
+// the correct old version.  This file should not be updated for API changes.
+
+package main
+
+import (
+	"compress/gzip"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/decred/dcrd/chaincfg/v2"
+	"github.com/decred/dcrd/hdkeychain/v2"
+	_ "github.com/decred/dcrwallet/wallet/v3/drivers/bdb"
+	"github.com/decred/dcrwallet/wallet/v3/udb"
+	"github.com/decred/dcrwallet/wallet/v3/walletdb"
+	"github.com/decred/dcrwallet/walletseed"
+)
+
+const dbname = "v12.db"
+
+var (
+	pubPass  = []byte("public")
+	privPass = []byte("private")
+)
+
+func main() {
+	err := setup()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "setup: %v\n", err)
+		os.Exit(1)
+	}
+	err = compress()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "compress: %v\n", err)
+		os.Exit(1)
+	}
+}
+
+func hexToBytes(origHex string) []byte {
+	buf, err := hex.DecodeString(origHex)
+	if err != nil {
+		panic(err)
+	}
+	return buf
+}
+
+func setup() error {
+	db, err := walletdb.Create("bdb", dbname)
+	if err != nil {
+		return err
+	}
+	defer db.Close()
+	seed, err := walletseed.GenerateRandomSeed(hdkeychain.RecommendedSeedLen)
+	if err != nil {
+		return err
+	}
+
+	params := chaincfg.TestNet3Params()
+	err = udb.Initialize(db, params, seed, pubPass, privPass)
+	if err != nil {
+		return err
+	}
+
+	amgr, txStore, _, err := udb.Open(db, params, pubPass)
+	if err != nil {
+		return err
+	}
+
+	err = walletdb.Update(db, func(tx walletdb.ReadWriteTx) error {
+		amgrns := tx.ReadWriteBucket([]byte("waddrmgr"))
+		txmgrns := tx.ReadWriteBucket([]byte("wtxmgr"))
+
+		if err := amgr.Unlock(amgrns, privPass); err != nil {
+			return err
+		}
+
+		script := hexToBytes("51210373c717acda38b5aa4c00c33932e059cdbc" +
+			"11deceb5f00490a9101704cc444c5151ae")
+
+		_, err := amgr.ImportScript(amgrns, script)
+		if err != nil {
+			return err
+		}
+
+		return txStore.InsertTxScript(txmgrns, script)
+	})
+
+	return err
+}
+
+func compress() error {
+	db, err := os.Open(dbname)
+	if err != nil {
+		return err
+	}
+	defer os.Remove(dbname)
+	defer db.Close()
+	dbgz, err := os.Create(dbname + ".gz")
+	if err != nil {
+		return err
+	}
+	defer dbgz.Close()
+	gz := gzip.NewWriter(dbgz)
+	_, err = io.Copy(gz, db)
+	if err != nil {
+		return err
+	}
+	return gz.Close()
+}
diff --git a/wallet/udb/testdata/v12.db.gz b/wallet/udb/testdata/v12.db.gz
new file mode 100644
index 0000000000000000000000000000000000000000..c60c43e47021d1d7a6826da3fb83509de0f1ef2d
GIT binary patch
literal 3346
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

literal 0
HcmV?d00001


From 622790199d5d3e9e4ada6bfc0ec7d3eeca70e15d Mon Sep 17 00:00:00 2001
From: Donald Adu-Poku <donald.adu@gmail.com>
Date: Thu, 8 Aug 2019 16:03:06 +0000
Subject: [PATCH 2/3] multi: store unencrypted scripts in address mgr.

This allows storing unencrypted script addresses
 in the address manager. This behaviour will become
default after the wallet is upgraded.
---
 wallet/udb/addressdb.go      | 66 +++++++++++++++++------------
 wallet/udb/addressmanager.go | 56 ++++++++++---------------
 wallet/udb/upgrades.go       | 80 +++++++++++++++++++++++++++++++++++-
 wallet/udb/upgrades_test.go  | 33 +++++++++++++++
 4 files changed, 174 insertions(+), 61 deletions(-)

diff --git a/wallet/udb/addressdb.go b/wallet/udb/addressdb.go
index da323b4b1..48a161868 100644
--- a/wallet/udb/addressdb.go
+++ b/wallet/udb/addressdb.go
@@ -108,8 +108,9 @@ type dbImportedAddressRow struct {
 // address in the database.
 type dbScriptAddressRow struct {
 	dbAddressRow
-	encryptedHash   []byte
-	encryptedScript []byte
+	hash      []byte
+	script    []byte
+	encrypted bool
 }
 
 // Key names for various database fields.
@@ -968,15 +969,16 @@ func serializeImportedAddress(encryptedPubKey, encryptedPrivKey []byte) []byte {
 // row as a script address.
 func deserializeScriptAddress(row *dbAddressRow) (*dbScriptAddressRow, error) {
 	// The serialized script address raw data format is:
-	//   <encscripthashlen><encscripthash><encscriptlen><encscript>
+	//   <scripthashlen><scripthash><scriptlen><script><encryptedbool>
 	//
-	// 4 bytes encrypted script hash len + encrypted script hash + 4 bytes
-	// encrypted script len + encrypted script
+	// 4 bytes script hash len + script hash + 4 bytes script len + script +
+	// 2 bytes encrypted boolean
 
 	// Given the above, the length of the entry must be at a minimum
 	// the constant value sizes.
-	if len(row.rawData) < 8 {
-		return nil, errors.E(errors.IO, errors.Errorf("bad script address len %d", len(row.rawData)))
+	if len(row.rawData) < 10 {
+		return nil, errors.E(errors.IO,
+			errors.Errorf("bad script address len %d", len(row.rawData)))
 	}
 
 	retRow := dbScriptAddressRow{
@@ -984,35 +986,49 @@ func deserializeScriptAddress(row *dbAddressRow) (*dbScriptAddressRow, error) {
 	}
 
 	hashLen := binary.LittleEndian.Uint32(row.rawData[0:4])
-	retRow.encryptedHash = make([]byte, hashLen)
-	copy(retRow.encryptedHash, row.rawData[4:4+hashLen])
+	retRow.hash = make([]byte, hashLen)
+	copy(retRow.hash, row.rawData[4:4+hashLen])
 	offset := 4 + hashLen
 	scriptLen := binary.LittleEndian.Uint32(row.rawData[offset : offset+4])
 	offset += 4
-	retRow.encryptedScript = make([]byte, scriptLen)
-	copy(retRow.encryptedScript, row.rawData[offset:offset+scriptLen])
+	retRow.script = make([]byte, scriptLen)
+	copy(retRow.script, row.rawData[offset:offset+scriptLen])
+	offset += scriptLen
+
+	encrypted := binary.LittleEndian.Uint16(row.rawData[offset : offset+2])
+	if encrypted == 1 {
+		retRow.encrypted = true
+	}
 
 	return &retRow, nil
 }
 
 // serializeScriptAddress returns the serialization of the raw data field for
 // a script address.
-func serializeScriptAddress(encryptedHash, encryptedScript []byte) []byte {
+func serializeScriptAddress(hash, script []byte, encrypted bool) []byte {
 	// The serialized script address raw data format is:
-	//   <encscripthashlen><encscripthash><encscriptlen><encscript>
+	//   <scripthashlen><scripthash><scriptlen><script><encryptedbool>
 	//
-	// 4 bytes encrypted script hash len + encrypted script hash + 4 bytes
-	// encrypted script len + encrypted script
+	// 4 bytes script hash len + script hash + 4 bytes script len + script +
+	// 2 bytes encrypted boolean
 
-	hashLen := uint32(len(encryptedHash))
-	scriptLen := uint32(len(encryptedScript))
-	rawData := make([]byte, 8+hashLen+scriptLen)
+	hashLen := uint32(len(hash))
+	scriptLen := uint32(len(script))
+	rawData := make([]byte, 8+hashLen+scriptLen+2)
 	binary.LittleEndian.PutUint32(rawData[0:4], hashLen)
-	copy(rawData[4:4+hashLen], encryptedHash)
+	copy(rawData[4:4+hashLen], hash)
 	offset := 4 + hashLen
 	binary.LittleEndian.PutUint32(rawData[offset:offset+4], scriptLen)
 	offset += 4
-	copy(rawData[offset:offset+scriptLen], encryptedScript)
+	copy(rawData[offset:offset+scriptLen], script)
+	offset += scriptLen
+
+	if encrypted {
+		binary.LittleEndian.PutUint16(rawData[offset:2+offset], uint16(1))
+	} else {
+		binary.LittleEndian.PutUint16(rawData[offset:2+offset], uint16(0))
+	}
+
 	return rawData
 }
 
@@ -1111,9 +1127,9 @@ func putImportedAddress(ns walletdb.ReadWriteBucket, addressID []byte, account u
 // putScriptAddress stores the provided script address information to the
 // database.
 func putScriptAddress(ns walletdb.ReadWriteBucket, addressID []byte, account uint32,
-	status syncStatus, encryptedHash, encryptedScript []byte) error {
+	status syncStatus, hash, script []byte, encrypted bool) error {
 
-	rawData := serializeScriptAddress(encryptedHash, encryptedScript)
+	rawData := serializeScriptAddress(hash, script, encrypted)
 	addrRow := dbAddressRow{
 		addrType:   adtScript,
 		account:    account,
@@ -1316,8 +1332,7 @@ func deletePrivateKeys(ns walletdb.ReadWriteBucket, dbVersion uint32) error {
 
 		// Reserialize the imported address without the private
 		// key and store it.
-		row.rawData = serializeImportedAddress(
-			irow.encryptedPubKey, nil)
+		row.rawData = serializeImportedAddress(irow.encryptedPubKey, nil)
 		err = bucket.Put([]byte(k), serializeAddressRow(row))
 		if err != nil {
 			return errors.E(errors.IO, err)
@@ -1332,8 +1347,7 @@ func deletePrivateKeys(ns walletdb.ReadWriteBucket, dbVersion uint32) error {
 
 		// Reserialize the script address without the script
 		// and store it.
-		row.rawData = serializeScriptAddress(srow.encryptedHash,
-			nil)
+		row.rawData = serializeScriptAddress(srow.hash, nil, srow.encrypted)
 		err = bucket.Put([]byte(k), serializeAddressRow(row))
 		if err != nil {
 			return errors.E(errors.IO, err)
diff --git a/wallet/udb/addressmanager.go b/wallet/udb/addressmanager.go
index e43a18f7f..dfec398c0 100644
--- a/wallet/udb/addressmanager.go
+++ b/wallet/udb/addressmanager.go
@@ -855,13 +855,17 @@ func (m *Manager) importedAddressRowToManaged(row *dbImportedAddressRow) (Manage
 // scriptAddressRowToManaged returns a new managed address based on script
 // address data loaded from the database.
 func (m *Manager) scriptAddressRowToManaged(row *dbScriptAddressRow) (ManagedAddress, error) {
-	// Use the crypto public key to decrypt the imported script hash.
-	scriptHash, err := m.cryptoKeyPub.Decrypt(row.encryptedHash)
-	if err != nil {
-		return nil, errors.E(errors.Crypto, errors.Errorf("decrypt imported P2SH address: %v", err))
+	if row.encrypted {
+		// Use the crypto public key to decrypt the imported script hash.
+		scriptHash, err := m.cryptoKeyPub.Decrypt(row.hash)
+		if err != nil {
+			return nil, errors.E(errors.Crypto, errors.Errorf("decrypt imported P2SH address: %v", err))
+		}
+
+		return newScriptAddress(m, row.account, scriptHash)
 	}
 
-	return newScriptAddress(m, row.account, scriptHash)
+	return newScriptAddress(m, row.account, row.hash)
 }
 
 // rowInterfaceToManaged returns a new managed address based on the given
@@ -1245,32 +1249,10 @@ func (m *Manager) ImportScript(ns walletdb.ReadWriteBucket, script []byte) (Mana
 		return nil, errors.E(errors.Exist, "script already exists")
 	}
 
-	// The manager must be unlocked to encrypt the imported script.
-	if !m.watchingOnly && m.locked {
-		return nil, errors.E(errors.Locked)
-	}
-
-	// Encrypt the script hash using the crypto public key so it is
-	// accessible when the address manager is locked or watching-only.
-	encryptedHash, err := m.cryptoKeyPub.Encrypt(scriptHash)
-	if err != nil {
-		return nil, errors.E(errors.Crypto, errors.Errorf("encrypt script hash: %v", err))
-	}
-
-	// Encrypt the script for storage in database using the crypto script
-	// key when not a watching-only address manager.
-	var encryptedScript []byte
-	if !m.watchingOnly {
-		encryptedScript, err = m.cryptoKeyScript.Encrypt(script)
-		if err != nil {
-			return nil, errors.E(errors.Crypto, errors.Errorf("encrypt script: %v", err))
-		}
-	}
-
 	// Save the new imported address to the db and update start block (if
 	// needed) in a single transaction.
-	err = putScriptAddress(ns, scriptHash, ImportedAddrAccount,
-		ssNone, encryptedHash, encryptedScript)
+	err := putScriptAddress(ns, scriptHash, ImportedAddrAccount, ssNone,
+		scriptHash, script, false)
 	if err != nil {
 		return nil, err
 	}
@@ -1994,16 +1976,22 @@ func (m *Manager) RedeemScript(ns walletdb.ReadBucket, addr dcrutil.Address) (sc
 	}
 	switch a := addrInterface.(type) {
 	case *dbScriptAddressRow:
-		script, err = m.cryptoKeyScript.Decrypt(a.encryptedScript)
-		if err != nil {
-			return nil, nil, errors.E(errors.Crypto, errors.Errorf("decrypt imported script: %v", err))
+		script = a.script
+		if a.encrypted {
+			script, err = m.cryptoKeyScript.Decrypt(a.script)
+			if err != nil {
+				return nil, nil, errors.E(errors.Crypto,
+					errors.Errorf("decrypt imported script: %v", err))
+			}
 		}
 
 	case *dbChainAddressRow, *dbImportedAddressRow:
-		return nil, nil, errors.E(errors.Invalid, "redeem script lookup requires P2SH address")
+		return nil, nil, errors.E(errors.Invalid,
+			"redeem script lookup requires P2SH address")
 
 	default:
-		return nil, nil, errors.E(errors.Invalid, errors.Errorf("address row type %T", addrInterface))
+		return nil, nil, errors.E(errors.Invalid,
+			errors.Errorf("address row type %T", addrInterface))
 	}
 
 	// Lock the RWMutex for reads for the caller and prepare to return the
diff --git a/wallet/udb/upgrades.go b/wallet/udb/upgrades.go
index 986aa8bda..27a0e53be 100644
--- a/wallet/udb/upgrades.go
+++ b/wallet/udb/upgrades.go
@@ -6,6 +6,7 @@ package udb
 
 import (
 	"crypto/sha256"
+	"encoding/binary"
 
 	"github.com/decred/dcrd/blockchain/stake/v2"
 	"github.com/decred/dcrd/chaincfg/chainhash"
@@ -110,10 +111,15 @@ const (
 	// accounting of total locked funds.
 	ticketCommitmentsVersion = 12
 
+	// scriptStorageVersion is the thirteenth version of the database. It
+	// updates the serialization semantics of the address row data and
+	// allows storing raw scripts in the address manager.
+	scriptStorageVersion = 13
+
 	// DBVersion is the latest version of the database that is understood by the
 	// program.  Databases with recorded versions higher than this will fail to
 	// open (meaning any upgrades prevent reverting to older software).
-	DBVersion = ticketCommitmentsVersion
+	DBVersion = scriptStorageVersion
 )
 
 // upgrades maps between old database versions and the upgrade function to
@@ -131,6 +137,7 @@ var upgrades = [...]func(walletdb.ReadWriteTx, []byte, *chaincfg.Params) error{
 	cfVersion - 1:                    cfUpgrade,
 	lastProcessedTxsBlockVersion - 1: lastProcessedTxsBlockUpgrade,
 	ticketCommitmentsVersion - 1:     ticketCommitmentsUpgrade,
+	scriptStorageVersion - 1:         scriptStorageUpgrade,
 }
 
 func lastUsedAddressIndexUpgrade(tx walletdb.ReadWriteTx, publicPassphrase []byte, params *chaincfg.Params) error {
@@ -994,6 +1001,77 @@ func ticketCommitmentsUpgrade(tx walletdb.ReadWriteTx, publicPassphrase []byte,
 	return unifiedDBMetadata{}.putVersion(metadataBucket, newVersion)
 }
 
+func scriptStorageUpgrade(tx walletdb.ReadWriteTx, publicPassphrase []byte, params *chaincfg.Params) error {
+	const oldVersion = 12
+	const newVersion = 13
+
+	metadataBucket := tx.ReadWriteBucket(unifiedDBMetadata{}.rootBucketKey())
+	addrmgrBucket := tx.ReadWriteBucket(waddrmgrBucketKey)
+
+	// Assert that this function is only called on version 12 databases.
+	dbVersion, err := unifiedDBMetadata{}.getVersion(metadataBucket)
+	if err != nil {
+		return err
+	}
+	if dbVersion != oldVersion {
+		return errors.E(errors.Invalid, "scriptStorageUpgrade inappropriately called")
+	}
+
+	addrbkt := addrmgrBucket.NestedReadBucket(addrBucketName)
+	toUpdate := make(map[string]*dbScriptAddressRow, 0)
+	cursor := addrbkt.ReadCursor()
+	for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
+		row, err := deserializeAddressRow(v)
+		if err != nil {
+			return err
+		}
+
+		switch row.addrType {
+		case adtScript:
+			// deserialize the address row.
+			hashLen := binary.LittleEndian.Uint32(row.rawData[0:4])
+			encryptedHash := make([]byte, hashLen)
+			copy(encryptedHash, row.rawData[4:4+hashLen])
+			offset := 4 + hashLen
+			scriptLen := binary.LittleEndian.Uint32(row.rawData[offset : offset+4])
+			offset += 4
+			encryptedScript := make([]byte, scriptLen)
+			copy(encryptedScript, row.rawData[offset:offset+scriptLen])
+
+			// reconstruct the address row.
+			row := &dbScriptAddressRow{
+				dbAddressRow: *row,
+				hash:         encryptedHash,
+				script:       encryptedScript,
+				encrypted:    true,
+			}
+
+			toUpdate[string(k)] = row
+		}
+	}
+
+	// persist reserialized address rows.
+	abkt := addrmgrBucket.NestedReadWriteBucket(addrBucketName)
+	for k, row := range toUpdate {
+		rawData := serializeScriptAddress(row.hash, row.script, row.encrypted)
+		addrRow := &dbAddressRow{
+			addrType:   adtScript,
+			account:    row.account,
+			addTime:    row.addTime,
+			syncStatus: row.syncStatus,
+			rawData:    rawData,
+		}
+
+		err := abkt.Put([]byte(k), serializeAddressRow(addrRow))
+		if err != nil {
+			return errors.E(errors.IO, err)
+		}
+	}
+
+	// Write the new database version.
+	return unifiedDBMetadata{}.putVersion(metadataBucket, newVersion)
+}
+
 // Upgrade checks whether the any upgrades are necessary before the database is
 // ready for application usage.  If any are, they are performed.
 func Upgrade(db walletdb.DB, publicPassphrase []byte, params *chaincfg.Params) error {
diff --git a/wallet/udb/upgrades_test.go b/wallet/udb/upgrades_test.go
index af3eee6da..8f6eb4ce2 100644
--- a/wallet/udb/upgrades_test.go
+++ b/wallet/udb/upgrades_test.go
@@ -37,6 +37,7 @@ var dbUpgradeTests = [...]struct {
 	// No upgrade test for V9, it is a fix for V8 and the previous test still applies
 	// TODO: V10 upgrade test
 	{verifyV12Upgrade, "v11.db.gz"},
+	{verifyV13Upgrade, "v12.db.gz"},
 }
 
 var pubPass = []byte("public")
@@ -531,3 +532,35 @@ func verifyV12Upgrade(t *testing.T, db walletdb.DB) {
 		t.Error(err)
 	}
 }
+
+func verifyV13Upgrade(t *testing.T, db walletdb.DB) {
+	err := walletdb.View(db, func(tx walletdb.ReadTx) error {
+		amgrns := tx.ReadBucket(waddrmgrBucketKey)
+		addrbkt := amgrns.NestedReadBucket(addrBucketName)
+		err := addrbkt.ForEach(func(k []byte, v []byte) error {
+			row, err := deserializeAddressRow(v)
+			if err != nil {
+				return fmt.Errorf("unable to deserialize address row: %v", err)
+			}
+
+			switch row.addrType {
+			case adtScript:
+				scrAddr, err := deserializeScriptAddress(row)
+				if err != nil {
+					return fmt.Errorf("unable to deserialize script address: %v", err)
+				}
+
+				if !scrAddr.encrypted {
+					return fmt.Errorf("expected an encrypted script address for %v", scrAddr.hash)
+				}
+			}
+
+			return nil
+		})
+
+		return err
+	})
+	if err != nil {
+		t.Error(err)
+	}
+}

From f10ffdea7d9b9a7c8939215e567223ebc9eeccc1 Mon Sep 17 00:00:00 2001
From: Donald Adu-Poku <donald.adu@gmail.com>
Date: Tue, 27 Aug 2019 14:57:53 +0000
Subject: [PATCH 3/3] multi: implement removeimported rpc.

---
 internal/rpchelp/helpdescs_en_US.go |   4 +
 internal/rpchelp/methods.go         |   1 +
 rpc/jsonrpc/methods.go              |  41 ++++++++-
 rpc/jsonrpc/rpcserverhelp.go        |   3 +-
 rpc/jsonrpc/types/methods.go        |   6 ++
 wallet/udb/addressdb.go             |  41 +++++++++
 wallet/udb/addressmanager.go        |   5 ++
 wallet/udb/txdb.go                  | 132 ++++++++++++++++++++++++++++
 wallet/udb/txmined.go               |   5 ++
 wallet/wallet.go                    |  53 ++++++++++-
 10 files changed, 287 insertions(+), 4 deletions(-)

diff --git a/internal/rpchelp/helpdescs_en_US.go b/internal/rpchelp/helpdescs_en_US.go
index ec32bcb2c..14195a460 100644
--- a/internal/rpchelp/helpdescs_en_US.go
+++ b/internal/rpchelp/helpdescs_en_US.go
@@ -594,6 +594,10 @@ var helpDescsEnUS = map[string]string{
 	"redeemmultisigouts-toaddress":      "Address to look for (if not internal addresses).",
 	"redeemmultisigouts-fromscraddress": "Input script hash address.",
 
+	// RemoveImported help.
+	"removeimported--synopsis": "Removes the provided imported script or private key from the wallet.",
+	"removeimported-data":      "The imported script or private key to remove.",
+
 	// RescanWallet help.
 	"rescanwallet--synopsis":   "Rescan the block chain for wallet data, blocking until the rescan completes or exits with an error",
 	"rescanwallet-beginheight": "The height of the first block to begin the rescan from",
diff --git a/internal/rpchelp/methods.go b/internal/rpchelp/methods.go
index 17bfd7fe4..ae89575cf 100644
--- a/internal/rpchelp/methods.go
+++ b/internal/rpchelp/methods.go
@@ -77,6 +77,7 @@ var Methods = []struct {
 	{"redeemmultisigout", []interface{}{(*types.RedeemMultiSigOutResult)(nil)}},
 	{"redeemmultisigouts", []interface{}{(*types.RedeemMultiSigOutResult)(nil)}},
 	{"renameaccount", nil},
+	{"removeimported", nil},
 	{"rescanwallet", nil},
 	{"revoketickets", nil},
 	{"sendfrom", returnsString},
diff --git a/rpc/jsonrpc/methods.go b/rpc/jsonrpc/methods.go
index 35aaee8f7..21a3f0072 100644
--- a/rpc/jsonrpc/methods.go
+++ b/rpc/jsonrpc/methods.go
@@ -41,9 +41,9 @@ import (
 
 // API version constants
 const (
-	jsonrpcSemverString = "6.2.0"
+	jsonrpcSemverString = "6.3.0"
 	jsonrpcSemverMajor  = 6
-	jsonrpcSemverMinor  = 2
+	jsonrpcSemverMinor  = 3
 	jsonrpcSemverPatch  = 0
 )
 
@@ -119,6 +119,7 @@ var handlers = map[string]handler{
 	"sweepaccount":            {fn: (*Server).sweepAccount},
 	"redeemmultisigout":       {fn: (*Server).redeemMultiSigOut},
 	"redeemmultisigouts":      {fn: (*Server).redeemMultiSigOuts},
+	"removeimported":          {fn: (*Server).removeImported},
 	"stakepooluserinfo":       {fn: (*Server).stakePoolUserInfo},
 	"ticketsforaddress":       {fn: (*Server).ticketsForAddress},
 	"validateaddress":         {fn: (*Server).validateAddress},
@@ -2426,6 +2427,42 @@ func (s *Server) redeemMultiSigOuts(ctx context.Context, icmd interface{}) (inte
 	return types.RedeemMultiSigOutsResult{Results: rmsoResults}, nil
 }
 
+// removeImported purges the provided imported script or private key from the wallet.
+func (s *Server) removeImported(ctx context.Context, icmd interface{}) (interface{}, error) {
+	cmd := icmd.(*types.RemoveImportedCmd)
+	w, ok := s.walletLoader.LoadedWallet()
+	if !ok {
+		return nil, errUnloadedWallet
+	}
+
+	// Parse the imported entity as a private key and remove the associated address.
+	wif, wErr := dcrutil.DecodeWIF(cmd.Data, w.ChainParams().PrivateKeyID)
+	if wErr == nil {
+		serializedPubKey := wif.SerializePubKey()
+		pubKeyHash := dcrutil.Hash160(serializedPubKey)
+		addr, err := dcrutil.NewAddressPubKeyHash(pubKeyHash, w.ChainParams(),
+			dcrec.STEcdsaSecp256k1)
+		if err != nil {
+			return nil,
+				rpcErrorf(dcrjson.ErrRPCInvalidAddressOrKey,
+					"unable to generate address from pubkey hash: %v", err)
+		}
+
+		err = w.RemoveAddress(addr)
+		return nil, err
+	}
+
+	// Parse the imported entity as a script and remove the associated address.
+	addr, err := dcrutil.NewAddressScriptHash([]byte(cmd.Data), w.ChainParams())
+	if err != nil {
+		return nil, rpcErrorf(dcrjson.ErrRPCInvalidParameter,
+			"invalid private key or script provided")
+	}
+
+	err = w.RemoveAddress(addr)
+	return nil, err
+}
+
 // rescanWallet initiates a rescan of the block chain for wallet data, blocking
 // until the rescan completes or exits with an error.
 func (s *Server) rescanWallet(ctx context.Context, icmd interface{}) (interface{}, error) {
diff --git a/rpc/jsonrpc/rpcserverhelp.go b/rpc/jsonrpc/rpcserverhelp.go
index 050555e22..93969a437 100644
--- a/rpc/jsonrpc/rpcserverhelp.go
+++ b/rpc/jsonrpc/rpcserverhelp.go
@@ -54,6 +54,7 @@ func helpDescsEnUS() map[string]string {
 		"redeemmultisigout":       "redeemmultisigout \"hash\" index tree (\"address\")\n\nTakes the input and constructs a P2PKH paying to the specified address.\n\nArguments:\n1. hash    (string, required)  Hash of the input transaction\n2. index   (numeric, required) Idx of the input transaction\n3. tree    (numeric, required) Tree the transaction is on.\n4. address (string, optional)  Address to pay to.\n\nResult:\n{\n \"hex\": \"value\",         (string)          Resulting hash.\n \"complete\": true|false, (boolean)         Shows if opperation was completed.\n \"errors\": [{            (array of object) Any errors generated.\n  \"txid\": \"value\",       (string)          The transaction hash of the referenced previous output\n  \"vout\": n,             (numeric)         The output index of the referenced previous output\n  \"scriptSig\": \"value\",  (string)          The hex-encoded signature script\n  \"sequence\": n,         (numeric)         Script sequence number\n  \"error\": \"value\",      (string)          Verification or signing error related to the input\n },...],                                   \n}                        \n",
 		"redeemmultisigouts":      "redeemmultisigouts \"fromscraddress\" (\"toaddress\" number)\n\nTakes a hash, looks up all unspent outpoints and generates list artially signed transactions spending to either an address specified or internal addresses\n\nArguments:\n1. fromscraddress (string, required)  Input script hash address.\n2. toaddress      (string, optional)  Address to look for (if not internal addresses).\n3. number         (numeric, optional) Number of outpoints found.\n\nResult:\n{\n \"hex\": \"value\",         (string)          Resulting hash.\n \"complete\": true|false, (boolean)         Shows if opperation was completed.\n \"errors\": [{            (array of object) Any errors generated.\n  \"txid\": \"value\",       (string)          The transaction hash of the referenced previous output\n  \"vout\": n,             (numeric)         The output index of the referenced previous output\n  \"scriptSig\": \"value\",  (string)          The hex-encoded signature script\n  \"sequence\": n,         (numeric)         Script sequence number\n  \"error\": \"value\",      (string)          Verification or signing error related to the input\n },...],                                   \n}                        \n",
 		"renameaccount":           "renameaccount \"oldaccount\" \"newaccount\"\n\nRenames an account.\n\nArguments:\n1. oldaccount (string, required) The old account name to rename\n2. newaccount (string, required) The new name for the account\n\nResult:\nNothing\n",
+		"removeimported":          "removeimported \"data\"\n\nRemoves the provided imported script or private key from the wallet.\n\nArguments:\n1. data (string, required) The imported script or private key to remove.\n\nResult:\nNothing\n",
 		"rescanwallet":            "rescanwallet (beginheight=0)\n\nRescan the block chain for wallet data, blocking until the rescan completes or exits with an error\n\nArguments:\n1. beginheight (numeric, optional, default=0) The height of the first block to begin the rescan from\n\nResult:\nNothing\n",
 		"revoketickets":           "revoketickets\n\nRequests the wallet create revovactions for any previously missed tickets.  Wallet must be unlocked.\n\nArguments:\nNone\n\nResult:\nNothing\n",
 		"sendfrom":                "sendfrom \"fromaccount\" \"toaddress\" amount (minconf=1 \"comment\" \"commentto\")\n\nDEPRECATED -- Authors, signs, and sends a transaction that outputs some amount to a payment address.\nA change output is automatically included to send extra output value back to the original account.\n\nArguments:\n1. fromaccount (string, required)             Account to pick unspent outputs from\n2. toaddress   (string, required)             Address to pay\n3. amount      (numeric, required)            Amount to send to the payment address valued in decred\n4. minconf     (numeric, optional, default=1) Minimum number of block confirmations required before a transaction output is eligible to be spent\n5. comment     (string, optional)             Unused\n6. commentto   (string, optional)             Unused\n\nResult:\n\"value\" (string) The transaction hash of the sent transaction\n",
@@ -84,4 +85,4 @@ var localeHelpDescs = map[string]func() map[string]string{
 	"en_US": helpDescsEnUS,
 }
 
-var requestUsages = "abandontransaction \"hash\"\naccountaddressindex \"account\" branch\naccountsyncaddressindex \"account\" branch index\naddmultisigaddress nrequired [\"key\",...] (\"account\")\naddticket \"tickethex\"\nconsolidate inputs (\"account\" \"address\")\ncreatemultisig nrequired [\"key\",...]\ncreatenewaccount \"account\"\ndumpprivkey \"address\"\ngeneratevote \"blockhash\" height \"tickethash\" votebits \"votebitsext\"\ngetaccountaddress \"account\"\ngetaccount \"address\"\ngetaddressesbyaccount \"account\"\ngetbalance (\"account\" minconf=1)\ngetbestblockhash\ngetbestblock\ngetblockcount\ngetblockhash index\ngetinfo\ngetmasterpubkey (\"account\")\ngetmultisigoutinfo \"hash\" index\ngetnewaddress (\"account\" \"gappolicy\")\ngetrawchangeaddress (\"account\")\ngetreceivedbyaccount \"account\" (minconf=1)\ngetreceivedbyaddress \"address\" (minconf=1)\ngetstakeinfo\ngetticketfee\ngettickets includeimmature\ngettransaction \"txid\" (includewatchonly=false)\ngetunconfirmedbalance (\"account\")\ngetvotechoices\ngetwalletfee\nhelp (\"command\")\nimportprivkey \"privkey\" (\"label\" rescan=true scanfrom)\nimportscript \"hex\" (rescan=true scanfrom)\nlistaccounts (minconf=1)\nlistaddresstransactions [\"address\",...] (\"account\")\nlistalltransactions (\"account\")\nlistlockunspent\nlistreceivedbyaccount (minconf=1 includeempty=false includewatchonly=false)\nlistreceivedbyaddress (minconf=1 includeempty=false includewatchonly=false)\nlistscripts\nlistsinceblock (\"blockhash\" targetconfirmations=1 includewatchonly=false)\nlisttransactions (\"account\" count=10 from=0 includewatchonly=false)\nlistunspent (minconf=1 maxconf=9999999 [\"address\",...])\nlockunspent unlock [{\"amount\":n.nnn,\"txid\":\"value\",\"vout\":n,\"tree\":n},...]\npurchaseticket \"fromaccount\" spendlimit (minconf=1 \"ticketaddress\" numtickets \"pooladdress\" poolfees expiry \"comment\" ticketfee)\nredeemmultisigout \"hash\" index tree (\"address\")\nredeemmultisigouts \"fromscraddress\" (\"toaddress\" number)\nrenameaccount \"oldaccount\" \"newaccount\"\nrescanwallet (beginheight=0)\nrevoketickets\nsendfrom \"fromaccount\" \"toaddress\" amount (minconf=1 \"comment\" \"commentto\")\nsendmany \"fromaccount\" {\"address\":amount,...} (minconf=1 \"comment\")\nsendtoaddress \"address\" amount (\"comment\" \"commentto\")\nsendtomultisig \"fromaccount\" amount [\"pubkey\",...] (nrequired=1 minconf=1 \"comment\")\nsetticketfee fee\nsettxfee amount\nsetvotechoice \"agendaid\" \"choiceid\"\nsignmessage \"address\" \"message\"\nsignrawtransaction \"rawtx\" ([{\"txid\":\"value\",\"vout\":n,\"tree\":n,\"scriptpubkey\":\"value\",\"redeemscript\":\"value\"},...] [\"privkey\",...] flags=\"ALL\")\nsignrawtransactions [\"rawtx\",...] (send=true)\nstakepooluserinfo \"user\"\nsweepaccount \"sourceaccount\" \"destinationaddress\" (requiredconfirmations feeperkb)\nticketsforaddress \"address\"\nvalidateaddress \"address\"\nverifymessage \"address\" \"signature\" \"message\"\nversion\nwalletinfo\nwalletislocked\nwalletlock\nwalletpassphrasechange \"oldpassphrase\" \"newpassphrase\"\nwalletpassphrase \"passphrase\" timeout"
+var requestUsages = "abandontransaction \"hash\"\naccountaddressindex \"account\" branch\naccountsyncaddressindex \"account\" branch index\naddmultisigaddress nrequired [\"key\",...] (\"account\")\naddticket \"tickethex\"\nconsolidate inputs (\"account\" \"address\")\ncreatemultisig nrequired [\"key\",...]\ncreatenewaccount \"account\"\ndumpprivkey \"address\"\ngeneratevote \"blockhash\" height \"tickethash\" votebits \"votebitsext\"\ngetaccountaddress \"account\"\ngetaccount \"address\"\ngetaddressesbyaccount \"account\"\ngetbalance (\"account\" minconf=1)\ngetbestblockhash\ngetbestblock\ngetblockcount\ngetblockhash index\ngetinfo\ngetmasterpubkey (\"account\")\ngetmultisigoutinfo \"hash\" index\ngetnewaddress (\"account\" \"gappolicy\")\ngetrawchangeaddress (\"account\")\ngetreceivedbyaccount \"account\" (minconf=1)\ngetreceivedbyaddress \"address\" (minconf=1)\ngetstakeinfo\ngetticketfee\ngettickets includeimmature\ngettransaction \"txid\" (includewatchonly=false)\ngetunconfirmedbalance (\"account\")\ngetvotechoices\ngetwalletfee\nhelp (\"command\")\nimportprivkey \"privkey\" (\"label\" rescan=true scanfrom)\nimportscript \"hex\" (rescan=true scanfrom)\nlistaccounts (minconf=1)\nlistaddresstransactions [\"address\",...] (\"account\")\nlistalltransactions (\"account\")\nlistlockunspent\nlistreceivedbyaccount (minconf=1 includeempty=false includewatchonly=false)\nlistreceivedbyaddress (minconf=1 includeempty=false includewatchonly=false)\nlistscripts\nlistsinceblock (\"blockhash\" targetconfirmations=1 includewatchonly=false)\nlisttransactions (\"account\" count=10 from=0 includewatchonly=false)\nlistunspent (minconf=1 maxconf=9999999 [\"address\",...])\nlockunspent unlock [{\"amount\":n.nnn,\"txid\":\"value\",\"vout\":n,\"tree\":n},...]\npurchaseticket \"fromaccount\" spendlimit (minconf=1 \"ticketaddress\" numtickets \"pooladdress\" poolfees expiry \"comment\" ticketfee)\nredeemmultisigout \"hash\" index tree (\"address\")\nredeemmultisigouts \"fromscraddress\" (\"toaddress\" number)\nrenameaccount \"oldaccount\" \"newaccount\"\nremoveimported \"data\"\nrescanwallet (beginheight=0)\nrevoketickets\nsendfrom \"fromaccount\" \"toaddress\" amount (minconf=1 \"comment\" \"commentto\")\nsendmany \"fromaccount\" {\"address\":amount,...} (minconf=1 \"comment\")\nsendtoaddress \"address\" amount (\"comment\" \"commentto\")\nsendtomultisig \"fromaccount\" amount [\"pubkey\",...] (nrequired=1 minconf=1 \"comment\")\nsetticketfee fee\nsettxfee amount\nsetvotechoice \"agendaid\" \"choiceid\"\nsignmessage \"address\" \"message\"\nsignrawtransaction \"rawtx\" ([{\"txid\":\"value\",\"vout\":n,\"tree\":n,\"scriptpubkey\":\"value\",\"redeemscript\":\"value\"},...] [\"privkey\",...] flags=\"ALL\")\nsignrawtransactions [\"rawtx\",...] (send=true)\nstakepooluserinfo \"user\"\nsweepaccount \"sourceaccount\" \"destinationaddress\" (requiredconfirmations feeperkb)\nticketsforaddress \"address\"\nvalidateaddress \"address\"\nverifymessage \"address\" \"signature\" \"message\"\nversion\nwalletinfo\nwalletislocked\nwalletlock\nwalletpassphrasechange \"oldpassphrase\" \"newpassphrase\"\nwalletpassphrase \"passphrase\" timeout"
diff --git a/rpc/jsonrpc/types/methods.go b/rpc/jsonrpc/types/methods.go
index 9912d4039..7353646ba 100644
--- a/rpc/jsonrpc/types/methods.go
+++ b/rpc/jsonrpc/types/methods.go
@@ -899,6 +899,11 @@ func NewRenameAccountCmd(oldAccount, newAccount string) *RenameAccountCmd {
 	}
 }
 
+// RemoveImportedCmd defines the removeimported JSON-RPC command.
+type RemoveImportedCmd struct {
+	Data string
+}
+
 // RescanWalletCmd describes the rescanwallet JSON-RPC request and parameters.
 type RescanWalletCmd struct {
 	BeginHeight *int `jsonrpcdefault:"0"`
@@ -1326,6 +1331,7 @@ func init() {
 		{"redeemmultisigout", (*RedeemMultiSigOutCmd)(nil)},
 		{"redeemmultisigouts", (*RedeemMultiSigOutsCmd)(nil)},
 		{"renameaccount", (*RenameAccountCmd)(nil)},
+		{"removeimported", (*RemoveImportedCmd)(nil)},
 		{"rescanwallet", (*RescanWalletCmd)(nil)},
 		{"revoketickets", (*RevokeTicketsCmd)(nil)},
 		{"sendfrom", (*SendFromCmd)(nil)},
diff --git a/wallet/udb/addressdb.go b/wallet/udb/addressdb.go
index 48a161868..c1ac090bb 100644
--- a/wallet/udb/addressdb.go
+++ b/wallet/udb/addressdb.go
@@ -8,6 +8,7 @@ package udb
 import (
 	"crypto/sha256"
 	"encoding/binary"
+	"fmt"
 	"time"
 
 	"github.com/decred/dcrwallet/errors"
@@ -796,6 +797,34 @@ func putAddrAccountIndex(ns walletdb.ReadWriteBucket, account uint32, addrHash [
 	return nil
 }
 
+// removeAddrAccountIndex removes the provided key to the address account index of the database.
+func removeAddrAccountIndex(ns walletdb.ReadWriteBucket, addrHash []byte) error {
+	bucket := ns.NestedReadWriteBucket(addrAcctIdxBucketName)
+	accountB := bucket.Get(addrHash)
+
+	if accountB != nil {
+		msg := fmt.Sprintf("no account value found for address hash %x", addrHash)
+		return errors.E(errors.IO, msg)
+	}
+
+	err := bucket.Delete(addrHash)
+	if err != nil {
+		return errors.E(errors.IO, err)
+	}
+
+	abkt := bucket.NestedReadWriteBucket(accountB)
+	if err != nil {
+		return errors.E(errors.IO, err)
+	}
+
+	err = abkt.Delete(addrHash)
+	if err != nil {
+		return errors.E(errors.IO, err)
+	}
+
+	return nil
+}
+
 // putAccountRow stores the provided account information to the database.  This
 // is used a common base for storing the various account types.
 func putAccountRow(ns walletdb.ReadWriteBucket, account uint32, row *dbAccountRow) error {
@@ -1093,6 +1122,18 @@ func putAddress(ns walletdb.ReadWriteBucket, addressID []byte, row *dbAddressRow
 	return putAddrAccountIndex(ns, row.account, addrHash[:])
 }
 
+// removeAddress removes the provided address id.
+func removeAddress(ns walletdb.ReadWriteBucket, addressID []byte) error {
+	bucket := ns.NestedReadWriteBucket(addrBucketName)
+	addrHash := sha256.Sum256(addressID)
+	err := bucket.Delete(addrHash[:])
+	if err != nil {
+		return errors.E(errors.IO, err)
+	}
+
+	return removeAddrAccountIndex(ns, addrHash[:])
+}
+
 // putChainedAddress stores the provided chained address information to the
 // database.
 func putChainedAddress(ns walletdb.ReadWriteBucket, addressID []byte, account uint32,
diff --git a/wallet/udb/addressmanager.go b/wallet/udb/addressmanager.go
index dfec398c0..32aa6a52c 100644
--- a/wallet/udb/addressmanager.go
+++ b/wallet/udb/addressmanager.go
@@ -1261,6 +1261,11 @@ func (m *Manager) ImportScript(ns walletdb.ReadWriteBucket, script []byte) (Mana
 	return newScriptAddress(m, ImportedAddrAccount, scriptHash)
 }
 
+// RemoveAddress removes the provided address from the manager.
+func (m *Manager) RemoveAddress(ns walletdb.ReadWriteBucket, addressID []byte) error {
+	return removeAddress(ns, addressID)
+}
+
 // IsLocked returns whether or not the address managed is locked.  When it is
 // unlocked, the decryption key needed to decrypt private keys used for signing
 // is in memory.
diff --git a/wallet/udb/txdb.go b/wallet/udb/txdb.go
index 27785eacf..7a52785ad 100644
--- a/wallet/udb/txdb.go
+++ b/wallet/udb/txdb.go
@@ -1359,6 +1359,19 @@ func extractRawUnminedTx(v []byte) []byte {
 	return v[8:]
 }
 
+func fetchRawUnminedTxRecordPkScript(v []byte, index uint32, scrLoc uint32, scrLen uint32) ([]byte, error) {
+	scrLocInt := int(scrLoc)
+	scrLenInt := int(scrLen)
+	if scrLocInt > len(v)-1 || scrLocInt+scrLenInt > len(v) {
+		return nil, errors.E(errors.IO, errors.Errorf(
+			"invalid script offset %d for unmined tx", scrLocInt))
+	}
+
+	pkScript := make([]byte, scrLenInt)
+	copy(pkScript, v[scrLocInt:scrLocInt+scrLenInt])
+	return pkScript, nil
+}
+
 // Unmined transaction credits use the canonical serialization format:
 //
 //  [0:32]   Transaction hash (32 bytes)
@@ -1704,6 +1717,15 @@ func putTxScript(ns walletdb.ReadWriteBucket, script []byte) error {
 	return nil
 }
 
+func deleteTxScript(ns walletdb.ReadWriteBucket, script []byte) error {
+	k := keyTxScript(script)
+	err := ns.NestedReadWriteBucket(bucketScripts).Delete(k)
+	if err != nil {
+		return errors.E(errors.IO, err)
+	}
+	return nil
+}
+
 func existsTxScript(ns walletdb.ReadBucket, hash []byte) []byte {
 	vOrig := ns.NestedReadBucket(bucketScripts).Get(hash)
 	if vOrig == nil {
@@ -2390,3 +2412,113 @@ func upgradeToVersion3(ns walletdb.ReadWriteBucket, chainParams *chaincfg.Params
 
 	return nil
 }
+
+// RemovePkScriptCreditsAndDebits removes all credits associated with the
+// provided pkScript as well as debits that spend those credits.
+func RemovePkScriptCreditsAndDebits(ns walletdb.ReadWriteBucket, pkScript []byte) error {
+	// Fetch all mined credits associated with the provided script.
+	credits := make(map[string]dcrutil.Amount, 0)
+	cc := ns.NestedReadBucket(bucketCredits).ReadCursor()
+	for k, v := cc.First(); k != nil; k, v = cc.Next() {
+		recK := extractRawCreditTxRecordKey(k)
+		recV := existsRawTxRecord(ns, recK)
+		index := extractRawCreditIndex(k)
+		scrLoc := fetchRawCreditScriptOffset(v)
+		scrLen := fetchRawCreditScriptLength(v)
+		scr, err := fetchRawTxRecordPkScript(recK, recV, index, scrLoc, scrLen)
+		if err != nil {
+			return err
+		}
+
+		if !bytes.Equal(scr, pkScript) {
+			continue
+		}
+
+		amount, err := fetchRawCreditAmount(v)
+		if err != nil {
+			return err
+		}
+
+		credits[string(k)] = amount
+	}
+
+	// Fetch and delete debits that spend credits associated with the
+	// provided script.
+	debits := make([][]byte, 0)
+	dc := ns.NestedReadBucket(bucketDebits).ReadCursor()
+	for k, v := dc.First(); k != nil; k, v = dc.Next() {
+		ck := extractRawDebitCreditKey(v)
+		for key, _ := range credits {
+			if !bytes.Equal(ck, []byte(key)) {
+				continue
+			}
+
+			debits = append(debits, k)
+		}
+	}
+
+	for _, k := range debits {
+		err := ns.NestedReadWriteBucket(bucketDebits).Delete(k)
+		if err != nil {
+			return err
+		}
+	}
+
+	// Delete all credits associated with the provided script and update the
+	// mined wallet balance.
+	bal, err := fetchMinedBalance(ns)
+	if err != nil {
+		return err
+	}
+
+	for k, amt := range credits {
+		bal -= amt
+		err := ns.NestedReadWriteBucket(bucketCredits).Delete([]byte(k))
+		if err != nil {
+			return err
+		}
+	}
+
+	return putMinedBalance(ns, bal)
+}
+
+// RemovePkScriptUnminedCredits removes all unmined credits associated with
+// the provided pkScript.
+func RemovePkScriptUnminedCredits(tx walletdb.ReadWriteTx, pkScript []byte) error {
+	// Fetch all unmined credits associated with the provided script.
+	unminedCredits := make([][]byte, 0)
+	ns := tx.ReadWriteBucket(wtxmgrBucketKey)
+	uc := ns.NestedReadBucket(bucketUnminedCredits).ReadCursor()
+	for k, v := uc.First(); k != nil; k, v = uc.Next() {
+		hash := extractRawUnminedCreditTxHash(k)
+		unmined := existsRawUnmined(ns, hash)
+		unminedV := extractRawUnminedTx(unmined)
+		index, err := fetchRawUnminedCreditIndex(k)
+		if err != nil {
+			return err
+		}
+
+		scrLoc := fetchRawUnminedCreditScriptOffset(v)
+		scrLen := fetchRawUnminedCreditScriptLength(v)
+		scr, err := fetchRawUnminedTxRecordPkScript(unminedV, index, scrLoc, scrLen)
+		if err != nil {
+			return err
+		}
+
+		if !bytes.Equal(scr, pkScript) {
+			continue
+		}
+
+		unminedCredits = append(unminedCredits, k)
+	}
+
+	// Delete all unmined credits associated with the provided script.
+	for _, k := range unminedCredits {
+		err := ns.NestedReadWriteBucket(bucketUnminedCredits).Delete(k)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
diff --git a/wallet/udb/txmined.go b/wallet/udb/txmined.go
index dcacc377e..cde08f347 100644
--- a/wallet/udb/txmined.go
+++ b/wallet/udb/txmined.go
@@ -3600,6 +3600,11 @@ func (s *Store) InsertTxScript(ns walletdb.ReadWriteBucket, script []byte) error
 	return putTxScript(ns, script)
 }
 
+// DeleteTxScript purges a transaction script from the database.
+func (s *Store) DeleteTxScript(ns walletdb.ReadWriteBucket, script []byte) error {
+	return deleteTxScript(ns, script)
+}
+
 // GetTxScript fetches a transaction script from the database using
 // the RIPEMD160 hash as a key.
 func (s *Store) GetTxScript(ns walletdb.ReadBucket, hash []byte) ([]byte, error) {
diff --git a/wallet/wallet.go b/wallet/wallet.go
index ce70cc920..b4bb9d5c0 100644
--- a/wallet/wallet.go
+++ b/wallet/wallet.go
@@ -3163,7 +3163,58 @@ func (w *Wallet) ImportScript(ctx context.Context, rs []byte) error {
 	return nil
 }
 
-// RedeemScriptCopy returns a copy of a redeem script to redeem outputs paid to
+// RemoveAddress removes the provided address from the wallet.
+func (w *Wallet) RemoveAddress(addr dcrutil.Address) error {
+	const op errors.Op = "wallet.RemoveAddress"
+	err := walletdb.Update(w.db, func(tx walletdb.ReadWriteTx) error {
+		addrmgrNs := tx.ReadWriteBucket(waddrmgrNamespaceKey)
+		txmgrNs := tx.ReadWriteBucket(wtxmgrNamespaceKey)
+
+		maddr, err := w.Manager.Address(addrmgrNs, addr)
+		if err != nil {
+			return errors.E(op, err)
+		}
+
+		if !maddr.Imported() {
+			return errors.E(op, fmt.Sprintf("cannot remove unimported "+
+				"address %s from wallet", maddr.Address().String()))
+		}
+
+		// Remove associated credits and debits of the address.
+		pkScript, err := txscript.PayToAddrScript(addr)
+		if err != nil {
+			return errors.E(op, err)
+		}
+
+		err = udb.RemovePkScriptCreditsAndDebits(txmgrNs, pkScript)
+		if err != nil {
+			return errors.E(op, err)
+		}
+
+		err = udb.RemovePkScriptUnminedCredits(tx, pkScript)
+		if err != nil {
+			return errors.E(op, err)
+		}
+
+		addrID := addr.ScriptAddress()
+
+		switch addr.(type) {
+		case *dcrutil.AddressScriptHash:
+			err = w.TxStore.DeleteTxScript(txmgrNs, addrID)
+			if err != nil {
+				return err
+			}
+		}
+
+		return w.Manager.RemoveAddress(addrmgrNs, addrID)
+	})
+	if err != nil {
+		return errors.E(op, err)
+	}
+	return nil
+}
+
+// RedeemScriptCopy returns a copy of a redeem script0 to redeem outputs paid to
 // a P2SH address.
 func (w *Wallet) RedeemScriptCopy(addr dcrutil.Address) ([]byte, error) {
 	const op errors.Op = "wallet.RedeemScriptCopy"