temp

api/api.go

@@ -84,3 +84,8 @@ type SeedSignRequest struct {
 	Transaction types.Transaction `json:"transaction"`
 	Keys        []uint64          `json:"keys"`
 }
+
+type AddressBalanceResponse struct {
+	Siacoins types.Currency `json:"siacoins"`
+	Siafunds uint64         `json:"siafunds"`
+}

api/api_test.go

@@ -35,13 +35,13 @@ func testNetwork() (*consensus.Network, types.Block) {
 	return n, genesisBlock
 }
 
-func runServer(cm api.ChainManager, s api.Syncer, wm api.WalletManager) (*api.Client, func()) {
+func runServer(cm api.ChainManager, s api.Syncer, wm api.WalletManager, am api.AddressManager) (*api.Client, func()) {
 	l, err := net.Listen("tcp", ":0")
 	if err != nil {
 		panic(err)
 	}
 	go func() {
-		srv := api.NewServer(cm, s, wm)
+		srv := api.NewServer(cm, s, wm, am)
 		http.Serve(l, jape.BasicAuth("password")(srv))
 	}()
 	c := api.NewClient("http://"+l.Addr().String(), "password")
@@ -66,18 +66,18 @@ func TestWallet(t *testing.T) {
 	}
 	cm := chain.NewManager(dbstore, tipState)
 
-	ws, err := sqlite.OpenDatabase(filepath.Join(t.TempDir(), "wallets.db"), log.Named("sqlite3"))
+	store, err := sqlite.OpenDatabase(filepath.Join(t.TempDir(), "wallets.db"), sqlite.WithLogger(log.Named("sqlite3")))
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer ws.Close()
-	wm, err := wallet.NewManager(cm, ws, log.Named("wallet"))
+	defer store.Close()
+	wm, err := wallet.NewManager(cm, store, log.Named("wallet"))
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	sav := wallet.NewSeedAddressVault(wallet.NewSeed(), 0, 20)
-	c, shutdown := runServer(cm, nil, wm)
+	c, shutdown := runServer(cm, nil, wm, store)
 	defer shutdown()
 	if err := c.AddWallet("primary", nil); err != nil {
 		t.Fatal(err)
@@ -199,16 +199,16 @@ func TestV2(t *testing.T) {
 		t.Fatal(err)
 	}
 	cm := chain.NewManager(dbstore, tipState)
-	ws, err := sqlite.OpenDatabase(filepath.Join(t.TempDir(), "wallets.db"), log.Named("sqlite3"))
+	store, err := sqlite.OpenDatabase(filepath.Join(t.TempDir(), "wallets.db"), sqlite.WithLogger(log.Named("sqlite3")))
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer ws.Close()
-	wm, err := wallet.NewManager(cm, ws, log.Named("wallet"))
+	defer store.Close()
+	wm, err := wallet.NewManager(cm, store, log.Named("wallet"))
 	if err != nil {
 		t.Fatal(err)
 	}
-	c, shutdown := runServer(cm, nil, wm)
+	c, shutdown := runServer(cm, nil, wm, store)
 	defer shutdown()
 	if err := c.AddWallet("primary", nil); err != nil {
 		t.Fatal(err)
@@ -410,7 +410,7 @@ func TestP2P(t *testing.T) {
 	}
 	log1 := logger.Named("one")
 	cm1 := chain.NewManager(dbstore1, tipState)
-	store1, err := sqlite.OpenDatabase(filepath.Join(t.TempDir(), "wallets.db"), log1.Named("sqlite3"))
+	store1, err := sqlite.OpenDatabase(filepath.Join(t.TempDir(), "wallets.db"), sqlite.WithLogger(log1.Named("sqlite3")))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -430,7 +430,7 @@ func TestP2P(t *testing.T) {
 		NetAddress: l1.Addr().String(),
 	})
 	go s1.Run()
-	c1, shutdown := runServer(cm1, s1, wm1)
+	c1, shutdown := runServer(cm1, s1, wm1, store1)
 	defer shutdown()
 	if err := c1.AddWallet("primary", nil); err != nil {
 		t.Fatal(err)
@@ -449,7 +449,7 @@ func TestP2P(t *testing.T) {
 	}
 	log2 := logger.Named("two")
 	cm2 := chain.NewManager(dbstore2, tipState)
-	store2, err := sqlite.OpenDatabase(filepath.Join(t.TempDir(), "wallets.db"), log2.Named("sqlite3"))
+	store2, err := sqlite.OpenDatabase(filepath.Join(t.TempDir(), "wallets.db"), sqlite.WithLogger(log2.Named("sqlite3")))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -469,7 +469,7 @@ func TestP2P(t *testing.T) {
 		NetAddress: l2.Addr().String(),
 	}, syncer.WithLogger(zaptest.NewLogger(t)))
 	go s2.Run()
-	c2, shutdown2 := runServer(cm2, s2, wm2)
+	c2, shutdown2 := runServer(cm2, s2, wm2, store2)
 	defer shutdown2()
 	if err := c2.AddWallet("secondary", nil); err != nil {
 		t.Fatal(err)

api/server.go

@@ -61,14 +61,21 @@ type (
 		Annotate(name string, pool []types.Transaction) ([]wallet.PoolTransaction, error)
 
 		Reserve(ids []types.Hash256, duration time.Duration) error
+	}
+
+	// An AddressManager manages addresses
+	AddressManager interface {
 		AddressBalance(address types.Address) (sc types.Currency, sf uint64, err error)
+		AddressSiacoinUTXOs(address types.Address, offset, limit int) ([]types.SiacoinElement, error)
+		AddressSiafundUTXOs(address types.Address, offset, limit int) ([]types.SiafundElement, error)
 	}
 )
 
 type server struct {
 	cm ChainManager
 	s  Syncer
 	wm WalletManager
+	am AddressManager
 
 	// for walletsReserveHandler
 	mu   sync.Mutex
@@ -484,12 +491,36 @@ func (s *server) walletsFundSFHandler(jc jape.Context) {
 	})
 }
 
+func (s *server) addressBalanceHandler(jc jape.Context) {
+	var address types.Address
+	if jc.DecodeParam("address", &address) != nil {
+		return
+	}
+	siacoins, siafunds, err := s.am.AddressBalance(address)
+	if jc.Check("couldn't load address balance", err) != nil {
+		return
+	}
+	jc.Encode(AddressBalanceResponse{
+		Siacoins: siacoins,
+		Siafunds: siafunds,
+	})
+}
+
+func (s *server) addressUTXOsHandler(jc jape.Context) {
+
+}
+
+func (s *server) addressEventsHandler(jc jape.Context) {
+
+}
+
 // NewServer returns an HTTP handler that serves the walletd API.
-func NewServer(cm ChainManager, s Syncer, wm WalletManager) http.Handler {
+func NewServer(cm ChainManager, s Syncer, wm WalletManager, am AddressManager) http.Handler {
 	srv := server{
 		cm:   cm,
 		s:    s,
 		wm:   wm,
+		am:   am,
 		used: make(map[types.Hash256]bool),
 	}
 	return jape.Mux(map[string]jape.Handler{
@@ -507,6 +538,10 @@ func NewServer(cm ChainManager, s Syncer, wm WalletManager) http.Handler {
 
 		"POST   /resubscribe": srv.resubscribeHandler,
 
+		"GET /addresses/:address/balance": srv.addressBalanceHandler,
+		"GET /addresses/:address/utxos":   srv.addressUTXOsHandler,
+		"GET /addresses/:address/events":  srv.addressEventsHandler,
+
 		"GET    /wallets":                       srv.walletsHandler,
 		"PUT    /wallets/:name":                 srv.walletsNameHandlerPUT,
 		"DELETE /wallets/:name":                 srv.walletsNameHandlerDELETE,

cmd/walletd/main.go

@@ -183,7 +183,7 @@ func main() {
 		consoleEncoder := zapcore.NewConsoleEncoder(consoleCfg)
 
 		// only log info messages to console unless stdout logging is enabled
-		consoleCore := zapcore.NewCore(consoleEncoder, zapcore.Lock(os.Stdout), zap.NewAtomicLevelAt(zap.InfoLevel))
+		consoleCore := zapcore.NewCore(consoleEncoder, zapcore.Lock(os.Stdout), zap.NewAtomicLevelAt(zap.DebugLevel))
 		logger := zap.New(consoleCore, zap.AddCaller())
 		defer logger.Sync()
 		// redirect stdlib log to zap

cmd/walletd/node.go

@@ -161,7 +161,9 @@ func newNode(addr, dir string, chainNetwork string, useUPNP bool, log *zap.Logge
 		syncerAddr = net.JoinHostPort("127.0.0.1", port)
 	}
 
-	store, err := sqlite.OpenDatabase(filepath.Join(dir, "walletd.sqlite3"), log.Named("sqlite3"))
+	store, err := sqlite.OpenDatabase(filepath.Join(dir, "walletd.sqlite3"),
+		sqlite.WithFullIndex(),
+		sqlite.WithLogger(log.Named("sqlite3")))
 	if err != nil {
 		return nil, fmt.Errorf("failed to open wallet database: %w", err)
 	}

cmd/walletd/web.go

@@ -11,7 +11,7 @@ import (
 )
 
 func startWeb(l net.Listener, node *node, password string) error {
-	renter := api.NewServer(node.cm, node.s, node.wm)
+	renter := api.NewServer(node.cm, node.s, node.wm, node.store)
 	api := jape.BasicAuth(password)(renter)
 	web := walletd.Handler()
 	return http.Serve(l, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {