Merge remote-tracking branch 'origin/master'

pkg/addressbook/addressbook.go

@@ -222,8 +222,6 @@ func NewAddressBook(logger *zap.Logger, addressPath, jettonPath, collectionPath
 func (b *Book) refresh(logger *zap.Logger, addressPath, jettonPath, collectionPath string) {
 	go b.refreshAddresses(logger, addressPath)
 	go b.refreshJettons(logger, jettonPath)
-	go b.refreshStonfiJettons(logger)
-	go b.refreshMegatonJettons(logger)
 	go b.refreshCollections(logger, collectionPath)
 	go b.refreshTfPools(logger)
 }
@@ -264,38 +262,6 @@ func (b *Book) refreshJettons(logger *zap.Logger, jettonPath string) {
 	}
 }
 
-func (b *Book) refreshMegatonJettons(logger *zap.Logger) {
-	jettons, err := getMegatonJettons()
-	if err != nil {
-		logger.Info("failed to load megaton jettons")
-		return
-	}
-	b.mu.Lock()
-	defer b.mu.Unlock()
-	for _, jetton := range jettons {
-		_, ok := b.jettons[tongo.MustParseAccountID(jetton.Address)]
-		if !ok {
-			b.jettons[tongo.MustParseAccountID(jetton.Address)] = jetton
-		}
-	}
-}
-
-func (b *Book) refreshStonfiJettons(logger *zap.Logger) {
-	jettons, err := getStonfiJettons()
-	if err != nil {
-		logger.Info("failed to load stonfi jettons")
-		return
-	}
-	b.mu.Lock()
-	defer b.mu.Unlock()
-	for _, jetton := range jettons {
-		_, ok := b.jettons[tongo.MustParseAccountID(jetton.Address)]
-		if !ok {
-			b.jettons[tongo.MustParseAccountID(jetton.Address)] = jetton
-		}
-	}
-}
-
 func unique(approvers []oas.NftItemApprovedByItem) []oas.NftItemApprovedByItem {
 	sort.Slice(approvers, func(i, j int) bool {
 		return approvers[i] < approvers[j]
@@ -427,55 +393,3 @@ func _getGGWhitelist(client *graphql.Client) ([]tongo.AccountID, error) {
 	}
 	return addr, nil
 }
-
-func getMegatonJettons() ([]KnownJetton, error) {
-	response, err := http.Get("https://megaton.fi/api/token/infoList")
-	if err != nil {
-		return nil, err
-	}
-	defer response.Body.Close()
-	if response.StatusCode >= 300 {
-		return nil, fmt.Errorf("invalid status code %v", response.StatusCode)
-	}
-	var respBody []KnownJetton
-	if err = json.NewDecoder(response.Body).Decode(&respBody); err != nil {
-		return nil, err
-	}
-	for idx, jetton := range respBody {
-		address, err := tongo.ParseAccountID(jetton.Address)
-		if err != nil {
-			continue
-		}
-		jetton.Address = address.ToRaw()
-		respBody[idx] = jetton
-	}
-	return respBody, nil
-}
-
-func getStonfiJettons() ([]KnownJetton, error) {
-	response, err := http.Get("https://api.ston.fi/v1/pools")
-	if err != nil {
-		return nil, err
-	}
-	defer response.Body.Close()
-	if response.StatusCode >= 300 {
-		return nil, fmt.Errorf("invalid status code %v", response.StatusCode)
-	}
-	var respBody struct {
-		PoolList []struct {
-			Address string `json:"address"`
-		} `json:"pool_list"`
-	}
-	if err = json.NewDecoder(response.Body).Decode(&respBody); err != nil {
-		return nil, err
-	}
-	var jettons []KnownJetton
-	for _, jetton := range respBody.PoolList {
-		address, err := tongo.ParseAccountID(jetton.Address)
-		if err != nil {
-			continue
-		}
-		jettons = append(jettons, KnownJetton{Address: address.ToRaw()})
-	}
-	return jettons, nil
-}

pkg/rates/sources.go

@@ -13,6 +13,7 @@ import (
 	"github.com/tonkeeper/opentonapi/pkg/references"
 	"github.com/tonkeeper/tongo"
 	"github.com/tonkeeper/tongo/tep64"
+	"github.com/tonkeeper/tongo/ton"
 )
 
 type storage interface {
@@ -160,16 +161,23 @@ func (m *Mock) getDedustPool() map[string]float64 {
 		go func(pool Pool) {
 			defer wg.Done()
 
-			if pool.TotalSupply < "1000000000" || len(pool.Assets) != 2 {
+			if len(pool.Assets) != 2 || len(pool.Reserves) != 2 {
 				return
 			}
 
 			firstAsset, secondAsset := pool.Assets[0], pool.Assets[1]
 			if firstAsset.Metadata == nil || firstAsset.Metadata.Symbol != "TON" {
 				return
 			}
-			firstReserve, secondReserve := pool.Reserves[0], pool.Reserves[1]
-			if firstReserve == "0" || secondReserve == "0" {
+
+			var firstReserve, secondReserve float64
+			if firstReserve, err = strconv.ParseFloat(pool.Reserves[0], 64); err != nil {
+				return
+			}
+			if secondReserve, err = strconv.ParseFloat(pool.Reserves[1], 64); err != nil {
+				return
+			}
+			if firstReserve < float64(100*ton.OneTON) || secondReserve < float64(100*ton.OneTON) {
 				return
 			}
 
@@ -185,10 +193,7 @@ func (m *Mock) getDedustPool() map[string]float64 {
 				}
 			}
 
-			firstReserveConverted, _ := strconv.ParseFloat(firstReserve, 64)
-			secondReserveConverted, _ := strconv.ParseFloat(secondReserve, 64)
-
-			price := 1 / ((secondReserveConverted / math.Pow(10, secondReserveDecimals)) / (firstReserveConverted / math.Pow(10, 9)))
+			price := 1 / ((secondReserve / math.Pow(10, secondReserveDecimals)) / (firstReserve / math.Pow(10, 9)))
 			chanMapOfPool <- map[string]float64{secondAsset.Address: price}
 		}(pool)
 	}