Node http api routes: wallet node alias

Makefile

@@ -88,11 +88,11 @@ build-retransmitter-windows:
 release-retransmitter: ver build-retransmitter-linux build-retransmitter-darwin build-retransmitter-windows
 
 build-node-linux:
-	@GOOS=linux GOARCH=amd64 go build -o build/bin/linux-amd64/node ./cmd/node
+	@GOOS=linux GOARCH=amd64 go build -ldflags "-X main.buildVersion=$(VERSION)" -o build/bin/linux-amd64/node ./cmd/node
 build-node-darwin:
-	@GOOS=darwin GOARCH=amd64 go build -o build/bin/darwin-amd64/node ./cmd/node
+	@GOOS=darwin GOARCH=amd64 go build -ldflags "-X main.buildVersion=$(VERSION)" -o build/bin/darwin-amd64/node ./cmd/node
 build-node-windows:
-	@GOOS=windows GOARCH=amd64 go build -o build/bin/windows-amd64/node.exe ./cmd/node
+	@GOOS=windows GOARCH=amd64 go build -ldflags "-X main.buildVersion=$(VERSION)" -o build/bin/windows-amd64/node.exe ./cmd/node
 
 release-node: ver build-node-linux build-node-darwin build-node-windows
 
@@ -103,11 +103,11 @@ dist-node: release-node build-node-mainnet-deb-package build-node-testnet-deb-pa
 	@cd ./build/bin/darwin-amd64/; tar pzcvf ../../dist/node_$(VERSION)_macOS-64bit.tar.gz ./node*
 
 build-custom-linux:
-	@CGO_ENABLE=0 GOOS=linux GOARCH=amd64 go build -o build/bin/linux-amd64/custom ./cmd/custom
+	@CGO_ENABLE=0 GOOS=linux GOARCH=amd64 go build -ldflags "-X main.buildVersion=$(VERSION)" -o build/bin/linux-amd64/custom ./cmd/custom
 build-custom-darwin:
-	@CGO_ENABLE=0 GOOS=darwin GOARCH=amd64 go build -o build/bin/darwin-amd64/custom ./cmd/custom
+	@CGO_ENABLE=0 GOOS=darwin GOARCH=amd64 go build -ldflags "-X main.buildVersion=$(VERSION)" -o build/bin/darwin-amd64/custom ./cmd/custom
 build-custom-windows:
-	@CGO_ENABLE=0 GOOS=windows GOARCH=amd64 go build -o build/bin/windows-amd64/custom.exe ./cmd/custom
+	@CGO_ENABLE=0 GOOS=windows GOARCH=amd64 go build -ldflags "-X main.buildVersion=$(VERSION)" -o build/bin/windows-amd64/custom.exe ./cmd/custom
 
 build-custom: ver build-custom-linux build-custom-darwin build-custom-windows
 

cmd/custom/node.go

@@ -46,7 +46,7 @@ var (
 	apiAddr           = flag.String("api-address", "", "Address for REST API")
 	grpcAddr          = flag.String("grpc-address", "127.0.0.1:7475", "Address for gRPC API")
 	cfgPath           = flag.String("cfg-path", "", "Path to configuration JSON file. No default value.")
-	enableGrpcApi     = flag.Bool("enable-grpc-api", true, "Enables/disables gRPC API")
+	enableGrpcApi     = flag.Bool("enable-grpc-api", false, "Enables/disables gRPC API")
 	buildExtendedApi  = flag.Bool("build-extended-api", false, "Builds extended API. Note that state must be re-imported in case it wasn't imported with similar flag set")
 	serveExtendedApi  = flag.Bool("serve-extended-api", false, "Serves extended API requests since the very beginning. The default behavior is to import until first block close to current time, and start serving at this point")
 	buildStateHashes  = flag.Bool("build-state-hashes", false, "Calculate and store state hashes for each block height.")
@@ -60,6 +60,11 @@ var (
 	dropPeers         = flag.Bool("drop-peers", false, "Drop peers storage before node start.")
 )
 
+// nickeskov: compile time constants with defaults
+var (
+	buildVersion = "(not specified)"
+)
+
 func init() {
 	common.SetupLogger(*logLevel)
 }
@@ -209,7 +214,7 @@ func main() {
 		zap.S().Info("Successfully dropped peers storage")
 	}
 
-	peerManager := peer_manager.NewPeerManager(peerSpawnerImpl, peerStorage, int(limitConnections), version)
+	peerManager := peer_manager.NewPeerManager(peerSpawnerImpl, peerStorage, int(limitConnections), version, conf.WavesNetwork)
 	go peerManager.Run(ctx)
 
 	scheduler := scheduler2.NewScheduler(
@@ -267,8 +272,12 @@ func main() {
 		}
 	}
 
+	apiConfig := api.AppConfig{
+		BlockchainType: "",
+		BuildVersion:   buildVersion,
+	}
 	// TODO hardcore
-	app, err := api.NewApp("integration-test-rest-api", scheduler, nodeServices)
+	app, err := api.NewApp("integration-test-rest-api", scheduler, nodeServices, apiConfig)
 	if err != nil {
 		zap.S().Error(err)
 		cancel()

cmd/node/node.go

@@ -58,7 +58,7 @@ var (
 	apiAddr                               = flag.String("api-address", "", "Address for REST API")
 	apiKey                                = flag.String("api-key", "", "Api key")
 	grpcAddr                              = flag.String("grpc-address", "127.0.0.1:7475", "Address for gRPC API")
-	enableGrpcApi                         = flag.Bool("enable-grpc-api", true, "Enables/disables gRPC API")
+	enableGrpcApi                         = flag.Bool("enable-grpc-api", false, "Enables/disables gRPC API")
 	buildExtendedApi                      = flag.Bool("build-extended-api", false, "Builds extended API. Note that state must be re-imported in case it wasn't imported with similar flag set")
 	serveExtendedApi                      = flag.Bool("serve-extended-api", false, "Serves extended API requests since the very beginning. The default behavior is to import until first block close to current time, and start serving at this point")
 	buildStateHashes                      = flag.Bool("build-state-hashes", false, "Calculate and store state hashes for each block height.")
@@ -92,6 +92,11 @@ var defaultPeers = map[string]string{
 	"stagenet": "88.99.185.128:6868,49.12.15.166:6868,95.216.205.3:6868,88.198.179.16:6868",
 }
 
+// nickeskov: compile time constants with defaults
+var (
+	buildVersion = "(not specified)"
+)
+
 type Scheduler interface {
 	Mine() chan scheduler.Emit
 	types.Scheduler
@@ -319,6 +324,7 @@ func main() {
 		peerStorage,
 		int(limitConnections),
 		version,
+		conf.WavesNetwork,
 	)
 	go peerManager.Run(ctx)
 
@@ -378,7 +384,12 @@ func main() {
 		}
 	}
 
-	app, err := api.NewApp(*apiKey, minerScheduler, svs)
+	apiConfig := api.AppConfig{
+		BlockchainType: *blockchainType,
+		BuildVersion:   buildVersion,
+	}
+
+	app, err := api.NewApp(*apiKey, minerScheduler, svs, apiConfig)
 	if err != nil {
 		zap.S().Error(err)
 		cancel()

cmd/wmd/internal/state/accounts.go

@@ -394,7 +394,8 @@ func putAccounts(bs *blockState, batch *leveldb.Batch, height uint32, accountCha
 					return errors.Wrapf(err, "failed to get the sponsorship for '%s'", u.Asset.String())
 				}
 				if !ok {
-					return errors.Errorf("no asset info for an asset '%s'", u.Asset.String())
+					zap.S().Warnf("Transaction sponsored with asset '%s' issued by Invoke", u.Asset.String())
+					return nil //TODO: errors.Errorf("no asset info for an asset '%s'", u.Asset.String())
 				}
 				if a.sponsored {
 					err := updateBalanceAndHistory(bs, batch, height, a.issuer, u.Asset, u.In, u.Out)

cmd/wmd/internal/state/meta.go

@@ -2,11 +2,12 @@ package state
 
 import (
 	"encoding/binary"
+	"math"
+
 	"github.com/pkg/errors"
 	"github.com/syndtr/goleveldb/leveldb"
 	"github.com/syndtr/goleveldb/leveldb/util"
 	"github.com/wavesplatform/gowaves/pkg/proto"
-	"math"
 )
 
 var heightKeyBytes = []byte{heightKeyPrefix}
@@ -62,7 +63,7 @@ func block(snapshot *leveldb.Snapshot, height uint32) (proto.BlockID, bool, erro
 	}
 	bid, err := proto.NewBlockIDFromBytes(b)
 	if err != nil {
-		return proto.BlockID{}, false, nil
+		return proto.BlockID{}, false, wrapError(err)
 	}
 	return bid, true, nil
 }

cmd/wmd/internal/synchronizer.go

@@ -1,6 +1,7 @@
 package internal
 
 import (
+	"bytes"
 	"context"
 	"strings"
 	"time"
@@ -275,7 +276,7 @@ func (s *Synchronizer) equalIDs(height int) (bool, error) {
 	if err != nil {
 		return false, err
 	}
-	return rbs == lbs, nil
+	return bytes.Equal(rbs.Bytes(), lbs.Bytes()), nil
 }
 
 func (s *Synchronizer) extractTransactions(txs []proto.Transaction, miner crypto.PublicKey) ([]data.Trade, []data.IssueChange, []data.AssetChange, []data.AccountChange, []data.AliasBind, error) {

pkg/api/app.go

@@ -3,6 +3,7 @@ package api
 import (
 	"context"
 	"encoding/json"
+	"github.com/mr-tron/base58"
 	"time"
 
 	"github.com/pkg/errors"
@@ -34,9 +35,24 @@ type App struct {
 	peers         peer_manager.PeerManager
 	sync          types.StateSync
 	services      services.Services
+	config        AppConfig
 }
 
-func NewApp(apiKey string, scheduler SchedulerEmits, services services.Services) (*App, error) {
+type AppConfig struct {
+	BlockchainType string
+	BuildVersion   string
+}
+
+func (ac *AppConfig) Validate() error {
+	// TODO(nickeskov): implement me
+	return nil
+}
+
+func NewApp(apiKey string, scheduler SchedulerEmits, services services.Services, config AppConfig) (*App, error) {
+	if err := config.Validate(); err != nil {
+		return nil, err
+	}
+
 	digest, err := crypto.SecureHash([]byte(apiKey))
 	if err != nil {
 		return nil, err
@@ -50,9 +66,14 @@ func NewApp(apiKey string, scheduler SchedulerEmits, services services.Services)
 		utx:           services.UtxPool,
 		peers:         services.Peers,
 		services:      services,
+		config:        config,
 	}, nil
 }
 
+func (a *App) Config() *AppConfig {
+	return &a.config
+}
+
 func (a *App) TransactionsBroadcast(ctx context.Context, b []byte) error {
 	tt := proto.TransactionTypeVersion{}
 	err := json.Unmarshal(b, &tt)
@@ -96,6 +117,18 @@ func (a *App) LoadKeys(apiKey string, password []byte) error {
 	return a.services.Wallet.Load(password)
 }
 
+// WalletSeeds returns wallet seeds in base58 encoding.
+func (a *App) WalletSeeds() []string {
+	seeds := a.services.Wallet.Seeds()
+
+	seeds58 := make([]string, 0, len(seeds))
+	for _, seed := range seeds {
+		seed58 := base58.Encode(seed)
+		seeds58 = append(seeds58, seed58)
+	}
+	return seeds58
+}
+
 func (a *App) Accounts() ([]account, error) {
 	seeds := a.services.Wallet.Seeds()
 

pkg/api/app_alias.go

@@ -0,0 +1,23 @@
+package api
+
+import (
+	"github.com/pkg/errors"
+	"github.com/wavesplatform/gowaves/pkg/proto"
+	"github.com/wavesplatform/gowaves/pkg/state"
+)
+
+func (a *App) AddrByAlias(alias proto.Alias) (proto.Address, error) {
+	addr, err := a.state.AddrByAlias(alias)
+	if err != nil {
+		if state.IsNotFound(err) {
+			return proto.Address{}, err
+		}
+		return proto.Address{}, errors.Wrapf(err, "failed to find addr by alias %q", alias.String())
+	}
+	return addr, nil
+}
+
+func (a *App) AliasesOfAddr(addr proto.Address) ([]proto.Alias, error) {
+	// TODO(nickeskov): implement me
+	panic("AliasesOfAddr: NOT IMPLEMENTED")
+}

pkg/api/app_blocks_test.go

@@ -24,7 +24,7 @@ func TestApp_BlocksFirst(t *testing.T) {
 	s := mock.NewMockState(ctrl)
 	s.EXPECT().BlockByHeight(proto.Height(1)).Return(g, nil)
 
-	app, err := NewApp("api-key", nil, services.Services{State: s})
+	app, err := NewApp("api-key", nil, services.Services{State: s}, AppConfig{})
 	require.NoError(t, err)
 	first, err := app.BlocksFirst()
 	require.NoError(t, err)
@@ -40,7 +40,7 @@ func TestApp_BlocksLast(t *testing.T) {
 	s.EXPECT().Height().Return(proto.Height(1), nil)
 	s.EXPECT().BlockByHeight(proto.Height(1)).Return(g, nil)
 
-	app, err := NewApp("api-key", nil, services.Services{State: s})
+	app, err := NewApp("api-key", nil, services.Services{State: s}, AppConfig{})
 	require.NoError(t, err)
 	first, err := app.BlocksLast()
 	require.NoError(t, err)

pkg/api/app_peers_test.go

@@ -22,7 +22,7 @@ func TestApp_PeersKnown(t *testing.T) {
 	addr := proto.NewTCPAddr(net.ParseIP("127.0.0.1"), 6868).ToIpPort()
 	peerManager.EXPECT().KnownPeers().Return([]storage.KnownPeer{storage.KnownPeer(addr)})
 
-	app, err := NewApp("key", nil, services.Services{Peers: peerManager})
+	app, err := NewApp("key", nil, services.Services{Peers: peerManager}, AppConfig{})
 	require.NoError(t, err)
 
 	rs2, err := app.PeersKnown()
@@ -56,7 +56,7 @@ func TestApp_PeersSuspended(t *testing.T) {
 
 	peerManager.EXPECT().Suspended().Return(testData)
 
-	app, err := NewApp("key", nil, services.Services{Peers: peerManager})
+	app, err := NewApp("key", nil, services.Services{Peers: peerManager}, AppConfig{})
 	require.NoError(t, err)
 
 	suspended := app.PeersSuspended()

pkg/api/app_test.go

@@ -8,7 +8,7 @@ import (
 )
 
 func TestAppAuth(t *testing.T) {
-	app, _ := NewApp("apiKey", nil, services.Services{})
+	app, _ := NewApp("apiKey", nil, services.Services{}, AppConfig{})
 	require.Error(t, app.checkAuth("bla"))
 	require.NoError(t, app.checkAuth("apiKey"))
 }

pkg/api/errors/validation.go

@@ -2,6 +2,7 @@ package errors
 
 import (
 	"encoding/json"
+	"fmt"
 	"github.com/pkg/errors"
 	"net/http"
 )
@@ -152,3 +153,23 @@ var (
 		},
 	}
 )
+
+func NewCustomValidationError(msg string) *CustomValidationError {
+	return &CustomValidationError{
+		genericError: genericError{
+			ID:       CustomValidationErrorErrorID,
+			HttpCode: http.StatusBadRequest,
+			Message:  msg,
+		},
+	}
+}
+
+func NewAliasDoesNotExistError(aliasFull string) *AliasDoesNotExistError {
+	return &AliasDoesNotExistError{
+		genericError: genericError{
+			ID:       AliasDoesNotExistErrorID,
+			HttpCode: http.StatusNotFound,
+			Message:  fmt.Sprintf("alias '%s' doesn't exist", aliasFull),
+		},
+	}
+}

pkg/api/helpers.go

@@ -1,7 +1,36 @@
 package api
 
-import "time"
+import (
+	"encoding/json"
+	"github.com/pkg/errors"
+	"io"
+	"time"
+)
 
 func unixMillis(t time.Time) int64 {
 	return t.UnixNano() / 1_000_000
 }
+
+func fromUnixMillis(timestampMillis int64) time.Time {
+	sec := timestampMillis / 1_000
+	nsec := (timestampMillis % 1_000) * 1_000_000
+	return time.Unix(sec, nsec)
+}
+
+// tryParseJson receives reader and out params. out MUST be a pointer
+func tryParseJson(r io.Reader, out interface{}) error {
+	// TODO(nickeskov): check empty reader
+	err := json.NewDecoder(r).Decode(out)
+	if err != nil {
+		return errors.Wrapf(err, "Failed to unmarshal %T as JSON into %T", r, out)
+	}
+	return nil
+}
+
+func trySendJson(w io.Writer, v interface{}) error {
+	err := json.NewEncoder(w).Encode(v)
+	if err != nil {
+		return errors.Wrapf(err, "Failed to marshal %T to JSON and write it to %T", v, w)
+	}
+	return nil
+}