remove hard coded volume in vwap

main/main.go

@@ -1,8 +1,8 @@
 package main
 
 import (
+ "fmt"
  "log"
- "sort"
  "time"
 
  "github.com/gnoswap-labs/vwap"
@@ -11,33 +11,24 @@ import (
 // testing purposes
 
 func main() {
- interval := time.Minute
- ticker := time.NewTicker(interval)
+ start := time.Now().Unix()
+ ticker := time.NewTicker(5 * time.Second)
  defer ticker.Stop()
 
- calculateAndPrintVWAP()
-
  for range ticker.C {
- calculateAndPrintVWAP()
- }
-}
-
-func calculateAndPrintVWAP() {
- vwapResults, err := vwap.FetchAndCalculateVWAP()
- if err != nil {
- log.Printf("Error fetching and calculating VWAP: %v\n", err)
- return
- }
-
- var tokens []string
- for token := range vwapResults {
- tokens = append(tokens, token)
- }
- sort.Strings(tokens)
-
- log.Println("VWAP results updated at", time.Now().Format("15:04:05"))
-
- for _, token := range tokens {
- log.Printf("Token: %s, VWAP: %.4f\n", token, vwapResults[token])
+ <-ticker.C
+ vwapResults, err := vwap.VWAP()
+ if err != nil {
+ log.Printf("Failed to calculate VWAP: %v", err)
+ continue
+ }
+
+ fmt.Println("VWAP Results:")
+ for token, vwap := range vwapResults {
+ fmt.Printf("%s: %.8f\n", token, vwap)
+ }
+
+ fmt.Println(time.Now().Unix() - start)
+ fmt.Println("--------------------")
  }
 }

price.go

@@ -5,13 +5,13 @@ import (
  "encoding/json"
  "fmt"
  "log"
- "math"
- "math/big"
  "net/http"
  "strconv"
  "time"
 )
 
+const priceEndpoint = "http://dev.api.gnoswap.io/v1/tokens/prices"
+
 type TokenPrice struct {
  Path string `json:"path"`
  USD string `json:"usd"`
@@ -46,9 +46,8 @@ type APIResponse struct {
 }
 
 func fetchTokenPrices(endpoint string) ([]TokenPrice, error) {
- client := &http.Client{} // Timeout is managed by context
+ client := &http.Client{}
 
- // Create a context with a 30-second timeout
  ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
  defer cancel()
 
@@ -77,73 +76,24 @@ func fetchTokenPrices(endpoint string) ([]TokenPrice, error) {
  return nil, fmt.Errorf("received non-OK status code: %d", resp.StatusCode)
 }
 
-// calculateVolume calculates the total volume in the USD for each token.
-func calculateVolume(prices []TokenPrice) map[string]float64 {
- volumeByToken := make(map[string]float64)
-
- for _, price := range prices {
- volume, err := strconv.ParseFloat(price.VolumeUSD24h, 64)
- if err != nil {
- fmt.Printf("failed to parse volume for token %s: %v\n", price.Path, err)
- }
-
- volumeByToken[price.Path] = volume
- }
-
- return volumeByToken
-}
-
-// calculateTokenUSDPrices calculates the USD price based on a base token (wugnot) price and token ratios.
-func calculateTokenUSDPrices(tokenData *TokenData, baseTokenPrice float64) map[string]float64 {
- tokenPrices := make(map[string]float64)
- baseRatio := new(big.Float)
-
- // fund the base token ratio
- for _, token := range tokenData.TokenRatio {
- if token.TokenName == string(WUGNOT) {
- ratio, _ := new(big.Float).SetString(token.Ratio)
- baseRatio.Quo(ratio, big.NewFloat(math.Pow(2, 96)))
- break
- }
- }
-
- // calculate token prices based on the base token price and ratios.
- for _, token := range tokenData.TokenRatio {
- if token.TokenName != string(WUGNOT) {
- ratio, _ := new(big.Float).SetString(token.Ratio)
- tokenRatio := new(big.Float).Quo(ratio, big.NewFloat(math.Pow(2, 96)))
- tokenPrice := new(big.Float).Quo(baseRatio, tokenRatio)
-
- price, _ := tokenPrice.Float64()
- tokenPrices[token.TokenName] = price * baseTokenPrice
- }
- }
-
- return tokenPrices
-}
-
-func extractTrades(prices []TokenPrice) map[string][]TradeData {
+func extractTrades(prices []TokenPrice, volumeByToken map[string]float64) map[string][]TradeData {
  trades := make(map[string][]TradeData)
  for _, price := range prices {
- // calculatedVolume, err := strconv.ParseFloat(price.VolumeUSD24h, 64)
- // if err != nil {
- // fmt.Printf("Failed to parse volume for token %s: %v\n", price.Path, err)
- // continue
- // }
  usd, err := strconv.ParseFloat(price.USD, 64)
  if err != nil {
  fmt.Printf("failed to parse USD price for token %s: %v\n", price.Path, err)
  continue
  }
 
+ volume, ok := volumeByToken[price.Path]
+ if !ok {
+ fmt.Printf("volume not found for token %s\n", price.Path)
+ continue
+ }
+
  trades[price.Path] = append(trades[price.Path], TradeData{
  TokenName: price.Path,
- // Volume: calculatedVolume,
-
- // hard coded because current calculated volume always be 0.
- // therefore, we can't calculate the VWAP correctly.
- // TODO: remove this hard coded value and use `calculatedVolume` instead.
- Volume: 100,
+ Volume: volume,
  Ratio: usd,
  Timestamp: int(time.Now().Unix()),
  })

price_test.go

@@ -121,74 +121,3 @@ func TestFetchTokenPricesLive(t *testing.T) {
  }
  }
 }
-
-func TestCalculateVolume(t *testing.T) {
- t.Parallel()
- mockTokenPrices := []TokenPrice{
- {
- Path: "token1",
- VolumeUSD24h: "1000.50",
- },
- {
- Path: "token2",
- VolumeUSD24h: "2500.75",
- },
- {
- Path: "token3",
- VolumeUSD24h: "500.25",
- },
- }
-
- volumes := calculateVolume(mockTokenPrices)
-
- assert.Equal(t, 3, len(volumes))
- assert.InDelta(t, 1000.50, volumes["token1"], 0.001)
- assert.InDelta(t, 2500.75, volumes["token2"], 0.001)
- assert.InDelta(t, 500.25, volumes["token3"], 0.001)
-}
-
-func TestCalculateTokenPrices(t *testing.T) {
- t.Parallel()
- mockTokenData := &TokenData{
- Status: struct {
- Height int `json:"height"`
- Timestamp int `json:"timestamp"`
- }{
- Height: 61946,
- Timestamp: 1715064552,
- },
- TokenRatio: []struct {
- TokenName string `json:"token"`
- Ratio string `json:"ratio"`
- }{
- {
- TokenName: "gno.land/r/demo/wugnot",
- Ratio: "79228162514264337593543950336",
- },
- {
- TokenName: "gno.land/r/demo/qux",
- Ratio: "60536002769587966558221762891",
- },
- {
- TokenName: "gno.land/r/demo/foo",
- Ratio: "121074204438706762251182081654",
- },
- {
- TokenName: "gno.land/r/demo/gns",
- Ratio: "236174327852992866806677676716",
- },
- },
- }
-
- baseTokenPrice := 1.0
- tokenPrices := calculateTokenUSDPrices(mockTokenData, baseTokenPrice)
-
- // 1 wugnot = 1.0 USD (base token)
- // 1 qux = 1.308 USD
- // 1 foo = 0.654 USD
- // 1 gns = 0.335 USD
-
- assert.InDelta(t, 1.3087775685458196, tokenPrices["gno.land/r/demo/qux"], 1e-5)
- assert.InDelta(t, 0.6543768995349725, tokenPrices["gno.land/r/demo/foo"], 1e-5)
- assert.InDelta(t, 0.3354647528142011, tokenPrices["gno.land/r/demo/gns"], 1e-5)
-}

store_test.go

@@ -13,7 +13,7 @@ func TestVWAPStorage(t *testing.T) {
  trades := generateMockTrades()
 
  for _, trade := range trades {
- VWAP([]TradeData{trade})
+ calculateVWAP([]TradeData{trade})
  }
 
  expectedVWAPData := map[string][]VWAPData{

volume.go

@@ -0,0 +1,22 @@
+package vwap
+
+import (
+ "fmt"
+ "strconv"
+)
+
+// calculateVolume calculates the total volume in the USD for each token.
+func calculateVolume(prices []TokenPrice) map[string]float64 {
+ volumeByToken := make(map[string]float64)
+
+ for _, price := range prices {
+ volume, err := strconv.ParseFloat(price.VolumeUSD24h, 64)
+ if err != nil {
+ fmt.Printf("failed to parse volume for token %s: %v\n", price.Path, err)
+ }
+
+ volumeByToken[price.Path] = volume
+ }
+
+ return volumeByToken
+}

volume_test.go

@@ -0,0 +1,25 @@
+package vwap
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+)
+
+func TestCalculateVolume(t *testing.T) {
+ // Test case 1: Valid token prices
+ prices := []TokenPrice{
+ {Path: "TOKEN1", VolumeUSD24h: "1000.50"},
+ {Path: "TOKEN2", VolumeUSD24h: "500.25"},
+ }
+ volumeByToken := calculateVolume(prices)
+ assert.Equal(t, 1000.50, volumeByToken["TOKEN1"])
+ assert.Equal(t, 500.25, volumeByToken["TOKEN2"])
+
+ // Test case 2: Invalid volume format
+ prices = []TokenPrice{
+ {Path: "TOKEN3", VolumeUSD24h: "invalid"},
+ }
+ volumeByToken = calculateVolume(prices)
+ assert.Equal(t, 0.0, volumeByToken["TOKEN3"])
+}

vwap.go

@@ -1,8 +1,8 @@
 package vwap
 
-import "fmt"
-
-const priceEndpoint = "http://dev.api.gnoswap.io/v1/tokens/prices"
+import (
+ "fmt"
+)
 
 // Token name
 type TokenIdentifier string
@@ -32,9 +32,30 @@ func init() {
  lastPrices = make(map[string]float64)
 }
 
-// VWAP calculates the Volume Weighted Average Price (VWAP) for the given set of trades.
+func VWAP() (map[string]float64, error) {
+ prices, err := fetchTokenPrices(priceEndpoint)
+ if err != nil {
+ return nil, err
+ }
+
+ volumeByToken := calculateVolume(prices)
+ trades := extractTrades(prices, volumeByToken)
+ vwapResults := make(map[string]float64)
+
+ for tokenName, tradeData := range trades {
+ vwap, err := calculateVWAP(tradeData)
+ if err != nil {
+ return nil, err
+ }
+ vwapResults[tokenName] = vwap
+ }
+
+ return vwapResults, nil
+}
+
+// calculateVWAP calculates the Volume Weighted Average Price (calculateVWAP) for the given set of trades.
 // It returns the last price if there are no trades.
-func VWAP(trades []TradeData) (float64, error) {
+func calculateVWAP(trades []TradeData) (float64, error) {
  var numerator, denominator float64
 
  if len(trades) == 0 {
@@ -50,7 +71,7 @@ func VWAP(trades []TradeData) (float64, error) {
  if denominator == 0 {
  lastPrice, ok := lastPrices[trades[0].TokenName]
  if !ok {
- return 0, fmt.Errorf("no last price available for token %s", trades[0].TokenName)
+ return 0, nil
  }
  return lastPrice, nil
  }
@@ -62,23 +83,3 @@ func VWAP(trades []TradeData) (float64, error) {
 
  return vwap, nil
 }
-
-func FetchAndCalculateVWAP() (map[string]float64, error) {
- prices, err := fetchTokenPrices(priceEndpoint)
- if err != nil {
- return nil, err
- }
-
- trades := extractTrades(prices)
- vwapResults := make(map[string]float64)
-
- for tokenName, tradeData := range trades {
- vwap, err := VWAP(tradeData)
- if err != nil {
- return nil, err
- }
- vwapResults[tokenName] = vwap
- }
-
- return vwapResults, nil
-}