status-im/status-go

package history

import (
    "context"
    "math/big"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/event"
    "github.com/ethereum/go-ethereum/log"
    "github.com/status-im/status-go/services/wallet/async"
    "github.com/status-im/status-go/services/wallet/transfer"
    "github.com/status-im/status-go/services/wallet/walletevent"
)

type TransfersLoadedCb func(chainID uint64, addresses []common.Address, block *big.Int)

// Watcher executes a given callback whenever an account gets added/removed
type Watcher struct {
    feed     *event.Feed
    group    *async.Group
    callback TransfersLoadedCb
}

func NewWatcher(feed *event.Feed, callback TransfersLoadedCb) *Watcher {
    return &Watcher{
        feed:     feed,
        callback: callback,
    }
}

func (w *Watcher) Start() {
    if w.group != nil {
        return
    }

    w.group = async.NewGroup(context.Background())
    w.group.Add(func(ctx context.Context) error {
        return watch(ctx, w.feed, w.callback)
    })
}

func (w *Watcher) Stop() {
    if w.group != nil {
        w.group.Stop()
        w.group.Wait()
        w.group = nil
    }
}

func onTransfersLoaded(callback TransfersLoadedCb, chainID uint64, addresses []common.Address, blockNum *big.Int) {
    if callback != nil {
        callback(chainID, addresses, blockNum)
    }
}

func watch(ctx context.Context, feed *event.Feed, callback TransfersLoadedCb) error {
    ch := make(chan walletevent.Event, 100)
    sub := feed.Subscribe(ch)
    defer sub.Unsubscribe()

    for {
        select {
        case <-ctx.Done():
            return nil
        case err := <-sub.Err():
            if err != nil {
                log.Error("history: transfers watcher subscription failed", "error", err)
            }
        case ev := <-ch:
            if ev.Type == transfer.EventNewTransfers {
                onTransfersLoaded(callback, ev.ChainID, ev.Accounts, ev.BlockNumber)
            }
        }
    }
}