client: Return RegisterResult from Register.

In order to pass the fee's txid and number of needed confirmations
needed onto the callers of the register route, return a new
RegisterResult that holds that information.

client/core/core.go

@@ -980,32 +980,32 @@ func (c *Core) GetFee(dexAddr, cert string) (uint64, error) {
 // A thread will be started to wait for the requisite confirmations and send
 // the fee notification to the server. Any error returned from that thread is
 // sent as a notification.
-func (c *Core) Register(form *RegisterForm) error {
+func (c *Core) Register(form *RegisterForm) (*RegisterResult, error) {
 	// Check the app password.
 	crypter, err := c.encryptionKey(form.AppPass)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	if form.Addr == "" {
-		return fmt.Errorf("no dex address specified")
+		return nil, fmt.Errorf("no dex address specified")
 	}
 	host := addrHost(form.Addr)
 	if c.isRegistered(host) {
-		return fmt.Errorf("already registered at %s", form.Addr)
+		return nil, fmt.Errorf("already registered at %s", form.Addr)
 	}
 
 	regFeeAssetID, _ := dex.BipSymbolID(regFeeAssetSymbol)
 	wallet, err := c.connectedWallet(regFeeAssetID)
 	if err != nil {
-		return fmt.Errorf("cannot connect to %s wallet to pay fee: %v", regFeeAssetSymbol, err)
+		return nil, fmt.Errorf("cannot connect to %s wallet to pay fee: %v", regFeeAssetSymbol, err)
 	}
 
 	dc, err := c.connectDEX(&db.AccountInfo{
 		Host: host,
 		Cert: []byte(form.Cert),
 	})
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	// close the connection to the dex server if the registration fails.
@@ -1018,12 +1018,12 @@ func (c *Core) Register(form *RegisterForm) error {
 
 	regAsset, found := dc.assets[regFeeAssetID]
 	if !found {
-		return fmt.Errorf("dex server does not support %s asset", regFeeAssetSymbol)
+		return nil, fmt.Errorf("dex server does not support %s asset", regFeeAssetSymbol)
 	}
 
 	privKey, err := dc.acct.setupEncryption(crypter)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	// Prepare and sign the registration payload.
@@ -1035,33 +1035,33 @@ func (c *Core) Register(form *RegisterForm) error {
 	regRes := new(msgjson.RegisterResult)
 	err = dc.signAndRequest(dexReg, msgjson.RegisterRoute, regRes)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	// Check the DEX server's signature.
 	msg := regRes.Serialize()
 	dexPubKey, err := checkSigS256(msg, regRes.DEXPubKey, regRes.Sig)
 	if err != nil {
-		return fmt.Errorf("DEX signature validation error: %v", err)
+		return nil, fmt.Errorf("DEX signature validation error: %v", err)
 	}
 
 	// Check that the fee is non-zero.
 	if regRes.Fee == 0 {
-		return fmt.Errorf("zero registration fees not allowed")
+		return nil, fmt.Errorf("zero registration fees not allowed")
 	}
 	if regRes.Fee != dc.cfg.Fee {
-		return fmt.Errorf("DEX 'register' result fee doesn't match the 'config' value. %d != %d", regRes.Fee, dc.cfg.Fee)
+		return nil, fmt.Errorf("DEX 'register' result fee doesn't match the 'config' value. %d != %d", regRes.Fee, dc.cfg.Fee)
 	}
 	if regRes.Fee != form.Fee {
-		return fmt.Errorf("registration fee provided to Register does not match the DEX registration fee. %d != %d", form.Fee, regRes.Fee)
+		return nil, fmt.Errorf("registration fee provided to Register does not match the DEX registration fee. %d != %d", form.Fee, regRes.Fee)
 	}
 
 	// Pay the registration fee.
 	log.Infof("Attempting registration fee payment for %s of %d units of %s", regRes.Address,
 		regRes.Fee, regAsset.Symbol)
 	coin, err := wallet.PayFee(regRes.Address, regRes.Fee, regAsset)
 	if err != nil {
-		return fmt.Errorf("error paying registration fee: %v", err)
+		return nil, fmt.Errorf("error paying registration fee: %v", err)
 	}
 
 	// Registration complete.
@@ -1087,7 +1087,8 @@ func (c *Core) Register(form *RegisterForm) error {
 	// Set up the coin waiter.
 	c.verifyRegistrationFee(wallet, dc, coin.ID(), regFeeAssetID)
 	c.refreshUser()
-	return nil
+	res := &RegisterResult{FeeID: coin.String(), ReqConfirms: dc.cfg.RegFeeConfirms}
+	return res, nil
 }
 
 // verifyRegistrationFee waits the required amount of confirmations for the

client/core/core_test.go

@@ -1094,7 +1094,7 @@ func TestRegister(t *testing.T) {
 		tCore.connMtx.Unlock()
 
 		tWallet.setConfs(tDCR.FundConf)
-		err = tCore.Register(form)
+		_, err = tCore.Register(form)
 	}
 
 	getNotification := func(tag string) interface{} {

client/core/types.go

@@ -458,6 +458,12 @@ type LoginResult struct {
 	DEXes         []*DEXBrief        `json:"dexes"`
 }
 
+// RegisterResult holds data returned from Register.
+type RegisterResult struct {
+	FeeID       string `json:"feeID"`
+	ReqConfirms uint16 `json:"reqConfirms"`
+}
+
 // assetCounter tracks a count for a series of assets and provides methods for
 // adding to the count and combining assetCounters. Methods return the receiver
 // for convenience.

client/rpcserver/handlers.go

@@ -33,7 +33,6 @@ const (
 
 const (
 	initializedStr    = "app initialized"
-	feePaidStr        = "the DEX fee of %v has been paid"
 	walletCreatedStr  = "%s wallet created and unlocked"
 	walletLockedStr   = "%s wallet locked"
 	walletUnlockedStr = "%s wallet unlocked"
@@ -260,15 +259,13 @@ func handleRegister(s *RPCServer, params *RawParams) *msgjson.ResponsePayload {
 		resErr := msgjson.NewError(msgjson.RPCRegisterError, errMsg)
 		return createResponse(registerRoute, nil, resErr)
 	}
-	err = s.core.Register(form)
+	res, err := s.core.Register(form)
 	if err != nil {
 		resErr := &msgjson.Error{Code: msgjson.RPCRegisterError, Message: err.Error()}
 		return createResponse(registerRoute, nil, resErr)
 	}
 
-	resp := fmt.Sprintf(feePaidStr, form.Fee)
-
-	return createResponse(registerRoute, &resp, nil)
+	return createResponse(registerRoute, res, nil)
 }
 
 // handleExchanges handles requests for exchangess. It takes no arguments and
@@ -601,7 +598,10 @@ Registration is complete after the fee transaction has been confirmed.`,
     fee (int): The DEX fee.
     cert (string): Optional. The TLS certificate path.`,
 		returns: `Returns:
-    string: The message "` + fmt.Sprintf(feePaidStr, "[fee]") + `"`,
+    {
+      "feeID" (string): The fee transactions's txid and output index.
+      "reqConfirms" (int): The number of confirmations required to start trading.
+    }`,
 	},
 	exchangesRoute: {
 		pwArgsShort: ``,
@@ -661,10 +661,10 @@ Registration is complete after the fee transaction has been confirmed.`,
 	      can be traded.
           },...
 		},
-        "confsrequired": (int) The number of confirmations needed for the 
-        registration fee payment
+        "confsrequired": (int) The number of confirmations needed for the
+          registration fee payment
         "confs" (int): The current number of confirmations for the registration
-        fee payment. This is only present during the registration process.
+          fee payment. This is only present during the registration process.
       },...
     }`,
 	},

client/rpcserver/handlers_test.go

@@ -436,8 +436,8 @@ func TestHandleRegister(t *testing.T) {
 		}
 		r := &RPCServer{core: tc}
 		payload := handleRegister(r, test.params)
-		res := ""
-		if err := verifyResponse(payload, &res, test.wantErrCode); err != nil {
+		res := new(core.RegisterResult)
+		if err := verifyResponse(payload, res, test.wantErrCode); err != nil {
 			t.Fatal(err)
 		}
 	}

client/rpcserver/rpcserver.go

@@ -61,8 +61,8 @@ type ClientCore interface {
 	Login(appPass []byte) (*core.LoginResult, error)
 	OpenWallet(assetID uint32, appPass []byte) error
 	GetFee(addr, cert string) (fee uint64, err error)
-	Register(form *core.RegisterForm) error
-	Sync(host string, base, quote uint32) (*core.OrderBook, *core.BookFeed, error)
+	Register(form *core.RegisterForm) (*core.RegisterResult, error)
+	Sync(dex string, base, quote uint32) (*core.OrderBook, *core.BookFeed, error)
 	Trade(appPass []byte, form *core.TradeForm) (order *core.Order, err error)
 	WalletState(assetID uint32) (walletState *core.WalletState)
 	Wallets() (walletsStates []*core.WalletState)

client/rpcserver/rpcserver_test.go

@@ -48,6 +48,7 @@ type TCore struct {
 	closeWalletErr      error
 	wallets             []*core.WalletState
 	initializeClientErr error
+	registerResult      *core.RegisterResult
 	registerErr         error
 	exchanges           map[string]*core.Exchange
 	loginErr            error
@@ -88,8 +89,8 @@ func (c *TCore) OpenWallet(assetID uint32, pw []byte) error {
 func (c *TCore) GetFee(url, cert string) (uint64, error) {
 	return c.regFee, c.getFeeErr
 }
-func (c *TCore) Register(*core.RegisterForm) error {
-	return c.registerErr
+func (c *TCore) Register(*core.RegisterForm) (*core.RegisterResult, error) {
+	return c.registerResult, c.registerErr
 }
 func (c *TCore) Sync(dex string, base, quote uint32) (*core.OrderBook, *core.BookFeed, error) {
 	return nil, core.NewBookFeed(func(*core.BookFeed) {}), c.syncErr

client/webserver/api.go

@@ -56,7 +56,7 @@ func (s *WebServer) apiRegister(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	err := s.core.Register(&core.RegisterForm{
+	_, err := s.core.Register(&core.RegisterForm{
 		Addr:    reg.Addr,
 		Cert:    reg.Cert,
 		AppPass: reg.Password,

client/webserver/live_test.go

@@ -306,10 +306,10 @@ func (c *TCore) GetFee(host, cert string) (uint64, error) {
 	return 1e8, nil
 }
 
-func (c *TCore) Register(r *core.RegisterForm) error {
+func (c *TCore) Register(r *core.RegisterForm) (*core.RegisterResult, error) {
 	randomDelay()
 	c.reg = r
-	return nil
+	return nil, nil
 }
 func (c *TCore) Login([]byte) (*core.LoginResult, error) { return &core.LoginResult{}, nil }
 func (c *TCore) Logout() error                           { return nil }

client/webserver/webserver.go

@@ -61,7 +61,7 @@ var (
 // clientCore is satisfied by core.Core.
 type clientCore interface {
 	Exchanges() map[string]*core.Exchange
-	Register(*core.RegisterForm) error
+	Register(*core.RegisterForm) (*core.RegisterResult, error)
 	Login(pw []byte) (*core.LoginResult, error)
 	InitializeClient(pw []byte) error
 	Sync(dex string, base, quote uint32) (*core.OrderBook, *core.BookFeed, error)

client/webserver/webserver_test.go

@@ -74,11 +74,11 @@ type TCore struct {
 	notOpen         bool
 }
 
-func (c *TCore) Exchanges() map[string]*core.Exchange       { return nil }
-func (c *TCore) GetFee(string, string) (uint64, error)      { return 1e8, c.getFeeErr }
-func (c *TCore) Register(r *core.RegisterForm) error        { return c.regErr }
-func (c *TCore) InitializeClient(pw []byte) error           { return c.initErr }
-func (c *TCore) Login(pw []byte) (*core.LoginResult, error) { return &core.LoginResult{}, c.loginErr }
+func (c *TCore) Exchanges() map[string]*core.Exchange                        { return nil }
+func (c *TCore) GetFee(string, string) (uint64, error)                       { return 1e8, c.getFeeErr }
+func (c *TCore) Register(r *core.RegisterForm) (*core.RegisterResult, error) { return nil, c.regErr }
+func (c *TCore) InitializeClient(pw []byte) error                            { return c.initErr }
+func (c *TCore) Login(pw []byte) (*core.LoginResult, error)                  { return &core.LoginResult{}, c.loginErr }
 func (c *TCore) Sync(dex string, base, quote uint32) (*core.OrderBook, *core.BookFeed, error) {
 	return c.syncBook, c.syncFeed, c.syncErr
 }