package stickers import ( "context" "math/big" "time" "github.com/zenthangplus/goccm" "olympos.io/encoding/edn" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/log" "github.com/status-im/status-go/account" "github.com/status-im/status-go/contracts" "github.com/status-im/status-go/contracts/stickers" "github.com/status-im/status-go/eth-node/types" "github.com/status-im/status-go/ipfs" "github.com/status-im/status-go/multiaccounts/accounts" "github.com/status-im/status-go/rpc" "github.com/status-im/status-go/server" "github.com/status-im/status-go/services/wallet/bigint" "github.com/status-im/status-go/transactions" ) const maxConcurrentRequests = 3 const requestTimeout = time.Duration(5) * time.Second // ConnectionType constants type stickerStatus int const ( statusAvailable stickerStatus = iota statusInstalled statusPending statusPurchased ) type API struct { contractMaker *contracts.ContractMaker accountsManager *account.GethManager accountsDB *accounts.Database pendingTracker *transactions.PendingTxTracker keyStoreDir string downloader *ipfs.Downloader httpServer *server.MediaServer ctx context.Context } type Sticker struct { PackID *bigint.BigInt `json:"packID,omitempty"` URL string `json:"url,omitempty"` Hash string `json:"hash,omitempty"` } type StickerPack struct { ID *bigint.BigInt `json:"id"` Name string `json:"name"` Author string `json:"author"` Owner common.Address `json:"owner,omitempty"` Price *bigint.BigInt `json:"price"` Preview string `json:"preview"` Thumbnail string `json:"thumbnail"` Stickers []Sticker `json:"stickers"` Status stickerStatus `json:"status"` } type StickerPackCollection map[uint]StickerPack type ednSticker struct { Hash string } type ednStickerPack struct { Name string Author string Thumbnail string Preview string Stickers []ednSticker } type ednStickerPackInfo struct { Meta ednStickerPack } func NewAPI(ctx context.Context, acc *accounts.Database, rpcClient *rpc.Client, accountsManager *account.GethManager, pendingTracker *transactions.PendingTxTracker, keyStoreDir string, downloader *ipfs.Downloader, httpServer *server.MediaServer) *API { result := &API{ contractMaker: &contracts.ContractMaker{ RPCClient: rpcClient, }, accountsManager: accountsManager, accountsDB: acc, pendingTracker: pendingTracker, keyStoreDir: keyStoreDir, downloader: downloader, ctx: ctx, httpServer: httpServer, } return result } func (api *API) Market(chainID uint64) ([]StickerPack, error) { // TODO: eventually this should be changed to include pagination accs, err := api.accountsDB.GetActiveAccounts() if err != nil { return nil, err } allStickerPacks, err := api.getContractPacks(chainID) if err != nil { return nil, err } purchasedPacks := make(map[uint]struct{}) purchasedPackChan := make(chan *big.Int) errChan := make(chan error) doneChan := make(chan struct{}, 1) go api.getAccountsPurchasedPack(chainID, accs, purchasedPackChan, errChan, doneChan) for { select { case err := <-errChan: if err != nil { return nil, err } case packID := <-purchasedPackChan: if packID != nil { purchasedPacks[uint(packID.Uint64())] = struct{}{} } case <-doneChan: var result []StickerPack for _, pack := range allStickerPacks { packID := uint(pack.ID.Uint64()) _, isPurchased := purchasedPacks[packID] if isPurchased { pack.Status = statusPurchased } else { pack.Status = statusAvailable } result = append(result, pack) } return result, nil } } } func (api *API) execTokenPackID(chainID uint64, tokenIDs []*big.Int, resultChan chan<- *big.Int, errChan chan<- error, doneChan chan<- struct{}) { defer close(doneChan) defer close(errChan) defer close(resultChan) stickerPack, err := api.contractMaker.NewStickerPack(chainID) if err != nil { errChan <- err return } if len(tokenIDs) == 0 { return } callOpts := &bind.CallOpts{Context: api.ctx, Pending: false} c := goccm.New(maxConcurrentRequests) for _, tokenID := range tokenIDs { c.Wait() go func(tokenID *big.Int) { defer c.Done() packID, err := stickerPack.TokenPackId(callOpts, tokenID) if err != nil { errChan <- err return } resultChan <- packID }(tokenID) } c.WaitAllDone() } func (api *API) getTokenPackIDs(chainID uint64, tokenIDs []*big.Int) ([]*big.Int, error) { tokenPackIDChan := make(chan *big.Int) errChan := make(chan error) doneChan := make(chan struct{}, 1) go api.execTokenPackID(chainID, tokenIDs, tokenPackIDChan, errChan, doneChan) var tokenPackIDs []*big.Int for { select { case <-doneChan: return tokenPackIDs, nil case err := <-errChan: if err != nil { return nil, err } case t := <-tokenPackIDChan: if t != nil { tokenPackIDs = append(tokenPackIDs, t) } } } } func (api *API) getPurchasedPackIDs(chainID uint64, account types.Address) ([]*big.Int, error) { // TODO: this should be replaced in the future by something like TheGraph to reduce the number of requests to infura stickerPack, err := api.contractMaker.NewStickerPack(chainID) if err != nil { return nil, err } callOpts := &bind.CallOpts{Context: api.ctx, Pending: false} balance, err := stickerPack.BalanceOf(callOpts, common.Address(account)) if err != nil { return nil, err } tokenIDs, err := api.getTokenOwnerOfIndex(chainID, account, balance) if err != nil { return nil, err } return api.getTokenPackIDs(chainID, tokenIDs) } func (api *API) fetchStickerPacks(chainID uint64, resultChan chan<- *StickerPack, errChan chan<- error, doneChan chan<- struct{}) { defer close(doneChan) defer close(errChan) defer close(resultChan) installedPacks, err := api.Installed() if err != nil { errChan <- err return } pendingPacks, err := api.pendingStickerPacks() if err != nil { errChan <- err return } stickerType, err := api.contractMaker.NewStickerType(chainID) if err != nil { errChan <- err return } callOpts := &bind.CallOpts{Context: api.ctx, Pending: false} numPacks, err := stickerType.PackCount(callOpts) if err != nil { errChan <- err return } if numPacks.Uint64() == 0 { return } c := goccm.New(maxConcurrentRequests) for i := uint64(0); i < numPacks.Uint64(); i++ { c.Wait() go func(i uint64) { defer c.Done() packID := new(big.Int).SetUint64(i) _, exists := installedPacks[uint(i)] if exists { return // We already have the sticker pack data, no need to query it } _, exists = pendingPacks[uint(i)] if exists { return // We already have the sticker pack data, no need to query it } stickerPack, err := api.fetchPackData(stickerType, packID, true) if err != nil { log.Warn("Could not retrieve stickerpack data", "packID", packID, "error", err) errChan <- err return } resultChan <- stickerPack }(i) } c.WaitAllDone() } func (api *API) fetchPackData(stickerType *stickers.StickerType, packID *big.Int, translateHashes bool) (*StickerPack, error) { timeoutContext, timeoutCancel := context.WithTimeout(api.ctx, requestTimeout) defer timeoutCancel() callOpts := &bind.CallOpts{Context: timeoutContext, Pending: false} packData, err := stickerType.GetPackData(callOpts, packID) if err != nil { return nil, err } stickerPack := &StickerPack{ ID: &bigint.BigInt{Int: packID}, Owner: packData.Owner, Price: &bigint.BigInt{Int: packData.Price}, } err = api.downloadPackData(stickerPack, packData.Contenthash, translateHashes) if err != nil { return nil, err } return stickerPack, nil } func (api *API) downloadPackData(stickerPack *StickerPack, contentHash []byte, translateHashes bool) error { fileContent, err := api.downloader.Get(hexutil.Encode(contentHash)[2:], true) if err != nil { return err } return api.populateStickerPackAttributes(stickerPack, fileContent, translateHashes) } func (api *API) hashToURL(hash string) string { return api.httpServer.MakeStickerURL(hash) } func (api *API) populateStickerPackAttributes(stickerPack *StickerPack, ednSource []byte, translateHashes bool) error { var stickerpackIPFSInfo ednStickerPackInfo err := edn.Unmarshal(ednSource, &stickerpackIPFSInfo) if err != nil { return err } stickerPack.Author = stickerpackIPFSInfo.Meta.Author stickerPack.Name = stickerpackIPFSInfo.Meta.Name if translateHashes { stickerPack.Preview = api.hashToURL(stickerpackIPFSInfo.Meta.Preview) stickerPack.Thumbnail = api.hashToURL(stickerpackIPFSInfo.Meta.Thumbnail) } else { stickerPack.Preview = stickerpackIPFSInfo.Meta.Preview stickerPack.Thumbnail = stickerpackIPFSInfo.Meta.Thumbnail } for _, s := range stickerpackIPFSInfo.Meta.Stickers { url := "" if translateHashes { url = api.hashToURL(s.Hash) } stickerPack.Stickers = append(stickerPack.Stickers, Sticker{ PackID: stickerPack.ID, URL: url, Hash: s.Hash, }) } return nil } func (api *API) getContractPacks(chainID uint64) ([]StickerPack, error) { stickerPackChan := make(chan *StickerPack) errChan := make(chan error) doneChan := make(chan struct{}, 1) go api.fetchStickerPacks(chainID, stickerPackChan, errChan, doneChan) var packs []StickerPack for { select { case <-doneChan: return packs, nil case err := <-errChan: if err != nil { return nil, err } case pack := <-stickerPackChan: if pack != nil { packs = append(packs, *pack) } } } } func (api *API) getAccountsPurchasedPack(chainID uint64, accs []*accounts.Account, resultChan chan<- *big.Int, errChan chan<- error, doneChan chan<- struct{}) { defer close(doneChan) defer close(errChan) defer close(resultChan) if len(accs) == 0 { return } c := goccm.New(maxConcurrentRequests) for _, account := range accs { c.Wait() go func(acc *accounts.Account) { defer c.Done() packs, err := api.getPurchasedPackIDs(chainID, acc.Address) if err != nil { errChan <- err return } for _, p := range packs { resultChan <- p } }(account) } c.WaitAllDone() } func (api *API) execTokenOwnerOfIndex(chainID uint64, account types.Address, balance *big.Int, resultChan chan<- *big.Int, errChan chan<- error, doneChan chan<- struct{}) { defer close(doneChan) defer close(errChan) defer close(resultChan) stickerPack, err := api.contractMaker.NewStickerPack(chainID) if err != nil { errChan <- err return } if balance.Int64() == 0 { return } callOpts := &bind.CallOpts{Context: api.ctx, Pending: false} c := goccm.New(maxConcurrentRequests) for i := uint64(0); i < balance.Uint64(); i++ { c.Wait() go func(i uint64) { defer c.Done() tokenID, err := stickerPack.TokenOfOwnerByIndex(callOpts, common.Address(account), new(big.Int).SetUint64(i)) if err != nil { errChan <- err return } resultChan <- tokenID }(i) } c.WaitAllDone() } func (api *API) getTokenOwnerOfIndex(chainID uint64, account types.Address, balance *big.Int) ([]*big.Int, error) { tokenIDChan := make(chan *big.Int) errChan := make(chan error) doneChan := make(chan struct{}, 1) go api.execTokenOwnerOfIndex(chainID, account, balance, tokenIDChan, errChan, doneChan) var tokenIDs []*big.Int for { select { case <-doneChan: return tokenIDs, nil case err := <-errChan: if err != nil { return nil, err } case tokenID := <-tokenIDChan: if tokenID != nil { tokenIDs = append(tokenIDs, tokenID) } } } }