multi: add support for enabling/disabling a dex account

client/core/account.go

@@ -14,9 +14,9 @@ import (
  "github.com/decred/dcrd/dcrec/secp256k1/v4"
 )
 
-// disconnectDEX unsubscribes from the dex's orderbooks, ends the connection
-// with the dex, and removes it from the connection map.
-func (c *Core) disconnectDEX(dc *dexConnection) {
+// stopDEXConnection unsubscribes from the dex's orderbooks and ends the
+// connection with the dex. The dexConnection will still remain in c.conns map.
+func (c *Core) stopDEXConnection(dc *dexConnection) {
  // Stop dexConnection books.
  dc.cfgMtx.RLock()
  if dc.cfg != nil {
@@ -34,42 +34,68 @@ func (c *Core) disconnectDEX(dc *dexConnection) {
  }
  }
  dc.cfgMtx.RUnlock()
+ dc.connMaster.Disconnect() // disconnect
+}
+
+// disconnectDEX disconnects a dex and removes it from the connection map.
+func (c *Core) disconnectDEX(dc *dexConnection) {
  // Disconnect and delete connection from map.
- dc.connMaster.Disconnect()
+ c.stopDEXConnection(dc)
  c.connMtx.Lock()
  delete(c.conns, dc.acct.host)
  c.connMtx.Unlock()
 }
 
-// AccountDisable is used to disable an account by given host and application
-// password.
-func (c *Core) AccountDisable(pw []byte, addr string) error {
+// ToggleAccountStatus is used to disable or enable an account by given host and
+// application password.
+func (c *Core) ToggleAccountStatus(pw []byte, host string, disable bool) error {
  // Validate password.
- _, err := c.encryptionKey(pw)
+ crypter, err := c.encryptionKey(pw)
  if err != nil {
  return codedError(passwordErr, err)
  }
 
- // Get dex connection by host.
- dc, _, err := c.dex(addr)
+ // Get dex connection by host. All exchange servers (enabled or not) are loaded as
+ // dexConnections but disabled servers are not connected.
+ dc, _, err := c.dex(host)
  if err != nil {
  return newError(unknownDEXErr, "error retrieving dex conn: %w", err)
  }
 
- // Check active orders or bonds.
- if dc.hasActiveOrders() {
- return fmt.Errorf("cannot disable account with active orders")
+ if dc.acct.isDisabled() == disable {
+ return nil // no-op
  }
- if dc.hasUnspentBond() {
- return fmt.Errorf("cannot disable account with unspent bonds")
+
+ if disable {
+ // Check active orders or bonds.
+ if dc.hasActiveOrders() {
+ return fmt.Errorf("cannot disable account with active orders")
+ }
+
+ if dc.hasUnspentBond() {
+ c.log.Info("Disabling dex server with unspent bonds. Bonds will be refunded when expired.")
+ }
  }
 
- err = c.db.DisableAccount(dc.acct.host)
+ err = c.db.ToggleAccountStatus(host, disable)
  if err != nil {
- return newError(accountDisableErr, "error disabling account: %w", err)
+ return newError(accountStatusUpdateErr, "error updating account status: %w", err)
  }
 
- c.disconnectDEX(dc)
+ if disable {
+ dc.acct.toggleAccountStatus(true)
+ c.stopDEXConnection(dc)
+ } else {
+ acctInfo, err := c.db.Account(host)
+ if err != nil {
+ return err
+ }
+ dc, connected := c.connectAccount(acctInfo)
+ if !connected {
+ return fmt.Errorf("failed to connected re-enabled account: %w", err)
+ }
+ c.initializeDEXConnection(dc, crypter)
+ }
 
  return nil
 }
@@ -188,7 +214,7 @@ func (c *Core) AccountImport(pw []byte, acct *Account, bonds []*db.Bond) error {
  return err
  }
  c.addDexConnection(dc)
- c.initializeDEXConnections(crypter)
+ c.initializeDEXConnection(dc, crypter)
  return nil
  }
 
@@ -255,7 +281,7 @@ func (c *Core) AccountImport(pw []byte, acct *Account, bonds []*db.Bond) error {
  return err
  }
  c.addDexConnection(dc)
- c.initializeDEXConnections(crypter)
+ c.initializeDEXConnection(dc, crypter)
  return nil
 }
 
@@ -368,9 +394,9 @@ func (c *Core) UpdateDEXHost(oldHost, newHost string, appPW []byte, certI any) (
  }
  }
 
- err = c.db.DisableAccount(oldDc.acct.host)
+ err = c.db.ToggleAccountStatus(oldDc.acct.host, true)
  if err != nil {
- return nil, newError(accountDisableErr, "error disabling account: %w", err)
+ return nil, newError(accountStatusUpdateErr, "error updating account status: %w", err)
  }
 
  updatedHost = true

client/core/account_test.go

@@ -59,51 +59,61 @@ func TestAccountExport(t *testing.T) {
 }
 */
 
-func TestAccountDisable(t *testing.T) {
+func TestToggleAccountStatus(t *testing.T) {
  activeTrades := map[order.OrderID]*trackedTrade{
  {}: {metaData: &db.OrderMetaData{Status: order.OrderStatusBooked}},
  }
 
  tests := []struct {
- name, host string
- recryptErr, acctErr, disableAcctErr error
- wantErr, wantErrCode, loseConns  bool
- activeTrades map[order.OrderID]*trackedTrade
- errCode int
+ name, host  string
+ recryptErr, acctErr, disableAcctErr  error
+ wantErr, wantErrCode, loseConns, wantDisable bool
+ activeTrades  map[order.OrderID]*trackedTrade
+ errCode  int
  }{{
- name: "ok",
- host: tDexHost,
+ name: "ok: disable account",
+ host: tDexHost,
+ wantDisable: true,
  }, {
- name: "password error",
- host: tDexHost,
- recryptErr: tErr,
- wantErr: true,
- errCode: passwordErr,
+ name: "ok: enable account",
+ host: tDexHost,
+ wantDisable: false,
+ }, {
+ name: "password error",
+ host: tDexHost,
+ recryptErr: tErr,
+ wantErr: true,
+ errCode: passwordErr,
+ wantDisable: true,
  }, {
  name: "host error",
  host: ":bad:",
  wantErr: true,
  wantErrCode: true,
  errCode: unknownDEXErr,
+ wantDisable: true,
  }, {
  name: "dex not in conns",
  host: tDexHost,
  loseConns: true,
  wantErr: true,
  wantErrCode: true,
  errCode: unknownDEXErr,
+ wantDisable: true,
  }, {
  name: "has active orders",
  host: tDexHost,
  activeTrades: activeTrades,
  wantErr: true,
+ wantDisable: true,
  }, {
  name: "disable account error",
  host: tDexHost,
  disableAcctErr: errors.New(""),
  wantErr: true,
  wantErrCode: true,
- errCode: accountDisableErr,
+ errCode: accountStatusUpdateErr,
+ wantDisable: true,
  }}
 
  for _, test := range tests {
@@ -122,7 +132,7 @@ func TestAccountDisable(t *testing.T) {
  }
  tCore.connMtx.Unlock()
 
- err := tCore.AccountDisable(tPW, test.host)
+ err := tCore.ToggleAccountStatus(tPW, test.host, test.wantDisable)
  if test.wantErr {
  if err == nil {
  t.Fatalf("expected error for test %v", test.name)
@@ -135,15 +145,21 @@ func TestAccountDisable(t *testing.T) {
  if err != nil {
  t.Fatalf("unexpected error for test %v: %v", test.name, err)
  }
- if _, found := tCore.conns[test.host]; found {
- t.Fatal("found disabled account dex connection")
- }
- if rig.db.disabledHost == nil {
- t.Fatal("expected execution of db.DisableAccount")
- }
- if *rig.db.disabledHost != test.host {
- t.Fatalf("expected db disabled account to match test host, want: %v"+
- " got: %v", test.host, *rig.db.disabledHost)
+ if test.wantDisable {
+ if dc, found := tCore.conns[test.host]; found && !dc.acct.isDisabled() {
+ t.Fatal("expected disabled dex account")
+ }
+ if rig.db.disabledHost == nil {
+ t.Fatal("expected a disable dex server host")
+ }
+ if *rig.db.disabledHost != test.host {
+ t.Fatalf("expected db account to match test host, want: %v"+
+ " got: %v", test.host, *rig.db.disabledHost)
+ }
+ } else {
+ if dc, found := tCore.conns[test.host]; found && dc.acct.isDisabled() {
+ t.Fatal("expected enabled dex account")
+ }
  }
  }
 }

client/core/bond.go

@@ -510,6 +510,13 @@ func (c *Core) refundExpiredBonds(ctx context.Context, acct *dexAccount, cfg *de
  //
  // TODO: if mustPost > 0 { wallet.RenewBond(...) }
 
+ // Ensure wallet is unlocked for use below.
+ _, err = wallet.refreshUnlock()
+ if err != nil {
+ c.log.Errorf("failed to unlock bond asset wallet %v: %v", unbip(state.BondAssetID), err)
+ continue
+ }
+
  // Generate a refund tx paying to an address from the currently
  // connected wallet, using bond.KeyIndex to create the signed
  // transaction. The RefundTx is really a backup.
@@ -705,16 +712,14 @@ func (c *Core) rotateBonds(ctx context.Context) {
  // locked. However, we must refund bonds regardless.
 
  bondCfg := c.dexBondConfig(dc, now)
- if len(bondCfg.bondAssets) == 0 {
+ if len(bondCfg.bondAssets) == 0 && !dc.acct.isDisabled() {
  if !dc.IsDown() && dc.config() != nil {
  dc.log.Meter("no-bond-assets", time.Minute*10).Warnf("Zero bond assets reported for apparently connected DCRDEX server")
  }
  continue
  }
  acctBondState := c.bondStateOfDEX(dc, bondCfg)
 
- c.repostPendingBonds(dc, bondCfg, acctBondState, unlocked)
-
  refundedAssets, expiredStrength, err := c.refundExpiredBonds(ctx, dc.acct, bondCfg, acctBondState, now)
  if err != nil {
  c.log.Errorf("Failed to refund expired bonds for %v: %v", dc.acct.host, err)
@@ -724,6 +729,12 @@ func (c *Core) rotateBonds(ctx context.Context) {
  c.updateAssetBalance(assetID)
  }
 
+ if dc.acct.isDisabled() {
+ continue // For disabled account, we should only bother about unspent bonds that might have been refunded by refundExpiredBonds above.
+ }
+
+ c.repostPendingBonds(dc, bondCfg, acctBondState, unlocked)
+
  bondAsset := bondCfg.bondAssets[acctBondState.BondAssetID]
  if bondAsset == nil {
  if acctBondState.TargetTier > 0 {