implement query account balances

Author: anywhy

pkg/exchange/hyperliquid/exchange.go

@@ -93,24 +93,39 @@ func (e *Exchange) QueryAccount(ctx context.Context) (*types.Account, error) {
 		return e.queryFuturesAccount(ctx)
 	}
 
-	spotAccount, err := e.client.NewGetAccountBalanceRequest().User(e.client.UserAddress()).Do(ctx)
+	balances, err := e.querySpotAccountBalance(ctx)
 	if err != nil {
 		return nil, err
 	}
 
-	balances := toGlobalBalance(spotAccount)
 	account := types.NewAccount()
-	account.UpdateBalances(balances)
+	account.UpdateBalances(toGlobalBalance(balances))
 
 	return account, nil
 }
 
 func (e *Exchange) QueryAccountBalances(ctx context.Context) (types.BalanceMap, error) {
-	// TODO implement
-	return nil, fmt.Errorf("not implemented")
+	balances, err := e.querySpotAccountBalance(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return toGlobalBalance(balances), nil
+}
+
+func (e *Exchange) querySpotAccountBalance(ctx context.Context) (*hyperapi.Account, error) {
+	if err := restSharedLimiter.Wait(ctx); err != nil {
+		return nil, fmt.Errorf("account rate limiter wait error: %w", err)
+	}
+
+	return e.client.NewGetAccountBalanceRequest().User(e.client.UserAddress()).Do(ctx)
 }
 
 func (e *Exchange) SubmitOrder(ctx context.Context, order types.SubmitOrder) (createdOrder *types.Order, err error) {
+	if err := restSharedLimiter.Wait(ctx); err != nil {
+		return nil, fmt.Errorf("submit order rate limiter wait error: %w", err)
+	}
+
 	// TODO implement
 	return nil, fmt.Errorf("not implemented")
 }

pkg/exchange/hyperliquid/exchange_test.go

@@ -7,6 +7,7 @@ import (
 	"os"
 	"testing"
 
+	"github.com/c9s/bbgo/pkg/fixedpoint"
 	"github.com/c9s/bbgo/pkg/testing/httptesting"
 	"github.com/c9s/bbgo/pkg/types"
 	"github.com/ethereum/go-ethereum/crypto"
@@ -151,10 +152,10 @@ func TestQueryAccount(t *testing.T) {
 		futuresInfo := account.FuturesInfo
 
 		// Verify futures account summary fields
-		assert.Equal(t, 121968206.668798998, futuresInfo.TotalMarginBalance.Float64())
-		assert.Equal(t, 46255052.1990050003, futuresInfo.TotalInitialMargin.Float64())
-		assert.Equal(t, 12598833.5037019998, futuresInfo.TotalMaintMargin.Float64())
-		assert.Equal(t, 75713154.4697940052, futuresInfo.AvailableBalance.Float64())
+		assert.Equal(t, fixedpoint.NewFromFloat(121968206.668798998), futuresInfo.TotalMarginBalance)
+		assert.Equal(t, fixedpoint.NewFromFloat(46255052.1990050003), futuresInfo.TotalInitialMargin)
+		assert.Equal(t, fixedpoint.NewFromFloat(12598833.5037019998), futuresInfo.TotalMaintMargin)
+		assert.Equal(t, fixedpoint.NewFromFloat(75713154.4697940052), futuresInfo.AvailableBalance)
 
 		// Verify positions count
 		assert.Equal(t, 11, len(futuresInfo.Positions))
@@ -173,9 +174,9 @@ func TestQueryAccount(t *testing.T) {
 		assert.NotNil(t, btcPos.PositionRisk)
 		assert.Equal(t, "10", btcPos.PositionRisk.Leverage.String())
 		assert.Equal(t, "111616.8", btcPos.PositionRisk.EntryPrice.String())
-		assert.Equal(t, 191751.85621501, btcPos.PositionRisk.LiquidationPrice.Float64())
-		assert.Equal(t, 11962126.6084020007, btcPos.PositionRisk.UnrealizedPnL.Float64())
-		assert.Equal(t, 120498051.8718400002, btcPos.PositionRisk.Notional.Float64())
+		assert.Equal(t, fixedpoint.NewFromFloat(191751.8562150183), btcPos.PositionRisk.LiquidationPrice)
+		assert.Equal(t, fixedpoint.NewFromFloat(11962126.6084020007), btcPos.PositionRisk.UnrealizedPnL)
+		assert.Equal(t, fixedpoint.NewFromFloat(120498051.8718400002), btcPos.PositionRisk.Notional)
 
 		// Verify ETH short position
 		ethPosKey := types.NewPositionKey("ETHUSDC", types.PositionShort)
@@ -208,3 +209,61 @@ func TestQueryAccount(t *testing.T) {
 	})
 
 }
+
+func TestQueryAccountBalances(t *testing.T) {
+	t.Run("succeeds querying spot account balances", func(t *testing.T) {
+		privateKey, err := crypto.GenerateKey()
+		require.NoError(t, err)
+		ex := New(fmt.Sprintf("%x", crypto.FromECDSA(privateKey)), "")
+
+		transport := &httptesting.MockTransport{}
+		ex.client.HttpClient.Transport = transport
+
+		spotMeta, err := os.ReadFile("./testdata/spotClearinghouseState.json")
+		require.NoError(t, err)
+
+		transport.POST("/info", func(req *http.Request) (*http.Response, error) {
+			return httptesting.BuildResponseString(http.StatusOK, string(spotMeta)), nil
+		})
+
+		balances, err := ex.QueryAccountBalances(context.Background())
+		assert.NoError(t, err)
+		assert.NotNil(t, balances)
+		assert.Greater(t, len(balances), 0)
+
+		// Verify USDC balance
+		usdcBalance, exists := balances["USDC"]
+		assert.True(t, exists, "USDC balance should exist")
+		assert.Equal(t, "USDC", usdcBalance.Currency)
+		assert.Equal(t, "1808443.14193129", usdcBalance.NetAsset.String())
+		assert.Equal(t, "1808443.14193129", usdcBalance.Available.String())
+		assert.Equal(t, 0.0, usdcBalance.Locked.Float64())
+		assert.Equal(t, "1808443.14193129", usdcBalance.MaxWithdrawAmount.String())
+
+		// Verify HYPE balance
+		hypeBalance, exists := balances["HYPE"]
+		assert.True(t, exists, "HYPE balance should exist")
+		assert.Equal(t, "HYPE", hypeBalance.Currency)
+		assert.Equal(t, "503808.46025243", hypeBalance.NetAsset.String())
+		assert.Equal(t, "503778.46025243", hypeBalance.Available.String())
+		assert.Equal(t, 30.0, hypeBalance.Locked.Float64())
+		assert.Equal(t, "503778.46025243", hypeBalance.MaxWithdrawAmount.String())
+
+		// Verify LATINA balance
+		latinaBalance, exists := balances["LATINA"]
+		assert.True(t, exists, "LATINA balance should exist")
+		assert.Equal(t, "LATINA", latinaBalance.Currency)
+		assert.Equal(t, "45658.0657", latinaBalance.NetAsset.String())
+		assert.Equal(t, "45658.0657", latinaBalance.Available.String())
+		assert.Equal(t, 0.0, latinaBalance.Locked.Float64())
+
+		// Verify UBTC balance (zero balance)
+		ubtcBalance, exists := balances["UBTC"]
+		assert.True(t, exists, "UBTC balance should exist")
+		assert.Equal(t, "UBTC", ubtcBalance.Currency)
+		assert.Equal(t, "0", ubtcBalance.NetAsset.String())
+		assert.Equal(t, "0", ubtcBalance.Available.String())
+		assert.Equal(t, 0.0, ubtcBalance.Locked.Float64())
+	})
+
+}

pkg/exchange/hyperliquid/futures.go

@@ -2,6 +2,7 @@ package hyperliquid
 
 import (
 	"context"
+	"fmt"
 	"math"
 	"strconv"
 
@@ -42,6 +43,10 @@ func (e *Exchange) queryFuturesMarkets(ctx context.Context) (types.MarketMap, er
 }
 
 func (e *Exchange) queryFuturesAccount(ctx context.Context) (*types.Account, error) {
+	if err := restSharedLimiter.Wait(ctx); err != nil {
+		return nil, fmt.Errorf("account rate limiter wait error: %w", err)
+	}
+
 	futuresAccount, err := e.client.NewFuturesGetAccountBalanceRequest().User(e.client.UserAddress()).Do(ctx)
 	if err != nil {
 		return nil, err