remove append usage from lcd, fix address order test issue in lcd

client/lcd/lcd_test.go

@@ -319,8 +319,18 @@ func TestTxs(t *testing.T) {
 func TestValidatorsQuery(t *testing.T) {
 	validators := getValidators(t)
 	assert.Equal(t, len(validators), 2)
-	assert.Equal(t, hex.EncodeToString(validators[0].Owner), validatorAddr1)
+
-	assert.Equal(t, hex.EncodeToString(validators[1].Owner), validatorAddr2)
+	// make sure all the validators were found (order unknown because sorted by owner addr)
+	foundVal1, foundVal2 := false, false
+	res1, res2 := hex.EncodeToString(validators[0].Owner), hex.EncodeToString(validators[1].Owner)
+	if res1 == validatorAddr1 || res2 == validatorAddr1 {
+		foundVal1 = true
+	}
+	if res1 == validatorAddr2 || res2 == validatorAddr2 {
+		foundVal2 = true
+	}
+	assert.True(t, foundVal1, "validatorAddr1 %v, res1 %v, res2 %v", validatorAddr1, res1, res2)
+	assert.True(t, foundVal2, "validatorAddr2 %v, res1 %v, res2 %v", validatorAddr2, res1, res2)
 }
 
 func TestBond(t *testing.T) {

x/stake/client/rest/query.go

@@ -100,8 +100,8 @@ func validatorsHandlerFn(ctx context.CoreContext, storeName string, cdc *wire.Co
 		}
 
 		// parse out the validators
-		var validators []stake.Validator
+		validators := make([]stake.Validator, len(kvs))
-		for _, kv := range kvs {
+		for i, kv := range kvs {
 			var validator stake.Validator
 			err = cdc.UnmarshalBinary(kv.Value, &validator)
 			if err != nil {
@@ -109,7 +109,7 @@ func validatorsHandlerFn(ctx context.CoreContext, storeName string, cdc *wire.Co
 				w.Write([]byte(fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error())))
 				return
 			}
-			validators = append(validators, validator)
+			validators[i] = validator
 		}
 
 		output, err := cdc.MarshalJSON(validators)

x/stake/client/rest/tx.go

@@ -56,14 +56,16 @@ func editDelegationsRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx conte
 		}
 
 		// build messages
-		messages := make([]sdk.Msg, 0, len(m.Delegate)+len(m.Unbond))
+		messages := make([]sdk.Msg, len(m.Delegate)+len(m.Unbond))
+		i := 0
 		for _, msg := range m.Delegate {
 			if !bytes.Equal(info.Address(), msg.DelegatorAddr) {
 				w.WriteHeader(http.StatusUnauthorized)
 				w.Write([]byte("Must use own delegator address"))
 				return
 			}
-			messages = append(messages, msg)
+			messages[i] = msg
+			i++
 		}
 		for _, msg := range m.Unbond {
 			if !bytes.Equal(info.Address(), msg.DelegatorAddr) {
@@ -71,12 +73,13 @@ func editDelegationsRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx conte
 				w.Write([]byte("Must use own delegator address"))
 				return
 			}
-			messages = append(messages, msg)
+			messages[i] = msg
+			i++
 		}
 
 		// sign messages
-		signedTxs := make([][]byte, 0, len(messages))
+		signedTxs := make([][]byte, len(messages[:]))
-		for _, msg := range messages {
+		for i, msg := range messages {
 			// increment sequence for each message
 			ctx = ctx.WithSequence(m.Sequence)
 			m.Sequence++
@@ -88,24 +91,24 @@ func editDelegationsRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx conte
 				return
 			}
 
-			signedTxs = append(signedTxs, txBytes)
+			signedTxs[i] = txBytes
 		}
 
 		// send
 		// XXX the operation might not be atomic if a tx fails
 		//     should we have a sdk.MultiMsg type to make sending atomic?
-		results := make([]*ctypes.ResultBroadcastTxCommit, 0, len(signedTxs))
+		results := make([]*ctypes.ResultBroadcastTxCommit, len(signedTxs[:]))
-		for _, txBytes := range signedTxs {
+		for i, txBytes := range signedTxs {
 			res, err := ctx.BroadcastTx(txBytes)
 			if err != nil {
 				w.WriteHeader(http.StatusInternalServerError)
 				w.Write([]byte(err.Error()))
 				return
 			}
-			results = append(results, res)
+			results[i] = res
 		}
 
-		output, err := json.MarshalIndent(results, "", "  ")
+		output, err := json.MarshalIndent(results[:], "", "  ")
 		if err != nil {
 			w.WriteHeader(http.StatusInternalServerError)
 			w.Write([]byte(err.Error()))