From 8b8bad955857bb659a1c05cc26b5b4ff8d52ec93 Mon Sep 17 00:00:00 2001 From: Kirill Ivanov Date: Wed, 4 Sep 2024 12:50:46 +0300 Subject: [PATCH] feat: changed to filterTransferAccount --- mocks/service/mockService.go | 204 ++++++++++++++++++++++++++++++++-- perpsv3.go | 2 +- services/accounts.go | 12 +- services/accounts_test.go | 12 +- services/luquidations_test.go | 10 +- services/marketData_test.go | 28 +++-- services/orders_test.go | 12 +- services/positions_test.go | 7 +- services/service.go | 5 + services/trades_test.go | 10 +- 10 files changed, 259 insertions(+), 43 deletions(-) diff --git a/mocks/service/mockService.go b/mocks/service/mockService.go index 490a40a..549bed9 100644 --- a/mocks/service/mockService.go +++ b/mocks/service/mockService.go @@ -81,6 +81,21 @@ func (mr *MockIServiceMockRecorder) FormatAccounts() *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FormatAccounts", reflect.TypeOf((*MockIService)(nil).FormatAccounts)) } +// FormatAccountsCore mocks base method. +func (m *MockIService) FormatAccountsCore(fromBlock, toBlock, limit uint64) ([]*models.Account, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FormatAccountsCore", fromBlock, toBlock, limit) + ret0, _ := ret[0].([]*models.Account) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// FormatAccountsCore indicates an expected call of FormatAccountsCore. +func (mr *MockIServiceMockRecorder) FormatAccountsCore(fromBlock, toBlock, limit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FormatAccountsCore", reflect.TypeOf((*MockIService)(nil).FormatAccountsCore), fromBlock, toBlock, limit) +} + // FormatAccountsCoreLimit mocks base method. func (m *MockIService) FormatAccountsCoreLimit(limit uint64) ([]*models.Account, error) { m.ctrl.T.Helper() @@ -458,6 +473,21 @@ func (mr *MockIServiceMockRecorder) RetrieveAccountLiquidationsLimit(limit inter return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveAccountLiquidationsLimit", reflect.TypeOf((*MockIService)(nil).RetrieveAccountLiquidationsLimit), limit) } +// RetrieveChangeOwner mocks base method. +func (m *MockIService) RetrieveChangeOwner(fromBlock, toBlock, limit uint64) ([]*models.AccountTransfer, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RetrieveChangeOwner", fromBlock, toBlock, limit) + ret0, _ := ret[0].([]*models.AccountTransfer) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RetrieveChangeOwner indicates an expected call of RetrieveChangeOwner. +func (mr *MockIServiceMockRecorder) RetrieveChangeOwner(fromBlock, toBlock, limit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveChangeOwner", reflect.TypeOf((*MockIService)(nil).RetrieveChangeOwner), fromBlock, toBlock, limit) +} + // RetrieveCollateralDeposited mocks base method. func (m *MockIService) RetrieveCollateralDeposited(fromBlock, toBlock, limit uint64) ([]*models.CollateralDeposited, error) { m.ctrl.T.Helper() @@ -564,18 +594,33 @@ func (mr *MockIServiceMockRecorder) RetrieveLiquidations(fromBlock, toBLock inte } // RetrieveLiquidationsCore mocks base method. -func (m *MockIService) RetrieveLiquidationsCore(limit uint64) ([]*models.CoreLiquidation, error) { +func (m *MockIService) RetrieveLiquidationsCore(fromBlock, toBlock, limit uint64) ([]*models.CoreLiquidation, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RetrieveLiquidationsCore", limit) + ret := m.ctrl.Call(m, "RetrieveLiquidationsCore", fromBlock, toBlock, limit) ret0, _ := ret[0].([]*models.CoreLiquidation) ret1, _ := ret[1].(error) return ret0, ret1 } // RetrieveLiquidationsCore indicates an expected call of RetrieveLiquidationsCore. -func (mr *MockIServiceMockRecorder) RetrieveLiquidationsCore(limit interface{}) *gomock.Call { +func (mr *MockIServiceMockRecorder) RetrieveLiquidationsCore(fromBlock, toBlock, limit interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveLiquidationsCore", reflect.TypeOf((*MockIService)(nil).RetrieveLiquidationsCore), limit) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveLiquidationsCore", reflect.TypeOf((*MockIService)(nil).RetrieveLiquidationsCore), fromBlock, toBlock, limit) +} + +// RetrieveLiquidationsCoreLimit mocks base method. +func (m *MockIService) RetrieveLiquidationsCoreLimit(limit uint64) ([]*models.CoreLiquidation, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RetrieveLiquidationsCoreLimit", limit) + ret0, _ := ret[0].([]*models.CoreLiquidation) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RetrieveLiquidationsCoreLimit indicates an expected call of RetrieveLiquidationsCoreLimit. +func (mr *MockIServiceMockRecorder) RetrieveLiquidationsCoreLimit(limit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveLiquidationsCoreLimit", reflect.TypeOf((*MockIService)(nil).RetrieveLiquidationsCoreLimit), limit) } // RetrieveLiquidationsLimit mocks base method. @@ -608,6 +653,21 @@ func (mr *MockIServiceMockRecorder) RetrieveMarketRegistered(limit interface{}) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveMarketRegistered", reflect.TypeOf((*MockIService)(nil).RetrieveMarketRegistered), limit) } +// RetrieveMarketRegisteredOpts mocks base method. +func (m *MockIService) RetrieveMarketRegisteredOpts(fromBlock, toBlock, limit uint64) ([]*models.MarketRegistered, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RetrieveMarketRegisteredOpts", fromBlock, toBlock, limit) + ret0, _ := ret[0].([]*models.MarketRegistered) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RetrieveMarketRegisteredOpts indicates an expected call of RetrieveMarketRegisteredOpts. +func (mr *MockIServiceMockRecorder) RetrieveMarketRegisteredOpts(fromBlock, toBlock, limit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveMarketRegisteredOpts", reflect.TypeOf((*MockIService)(nil).RetrieveMarketRegisteredOpts), fromBlock, toBlock, limit) +} + // RetrieveMarketUSDDepositedLimit mocks base method. func (m *MockIService) RetrieveMarketUSDDepositedLimit(limit uint64) ([]*models.MarketUSDDeposited, error) { m.ctrl.T.Helper() @@ -728,19 +788,79 @@ func (mr *MockIServiceMockRecorder) RetrieveOrdersLimit(limit interface{}) *gomo return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveOrdersLimit", reflect.TypeOf((*MockIService)(nil).RetrieveOrdersLimit), limit) } +// RetrievePermissionGranted mocks base method. +func (m *MockIService) RetrievePermissionGranted(fromBlock, toBlock, limit uint64) ([]*models.PermissionChanged, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RetrievePermissionGranted", fromBlock, toBlock, limit) + ret0, _ := ret[0].([]*models.PermissionChanged) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RetrievePermissionGranted indicates an expected call of RetrievePermissionGranted. +func (mr *MockIServiceMockRecorder) RetrievePermissionGranted(fromBlock, toBlock, limit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrievePermissionGranted", reflect.TypeOf((*MockIService)(nil).RetrievePermissionGranted), fromBlock, toBlock, limit) +} + +// RetrievePermissionRevoked mocks base method. +func (m *MockIService) RetrievePermissionRevoked(fromBlock, toBlock, limit uint64) ([]*models.PermissionChanged, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RetrievePermissionRevoked", fromBlock, toBlock, limit) + ret0, _ := ret[0].([]*models.PermissionChanged) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RetrievePermissionRevoked indicates an expected call of RetrievePermissionRevoked. +func (mr *MockIServiceMockRecorder) RetrievePermissionRevoked(fromBlock, toBlock, limit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrievePermissionRevoked", reflect.TypeOf((*MockIService)(nil).RetrievePermissionRevoked), fromBlock, toBlock, limit) +} + // RetrievePoolCreated mocks base method. -func (m *MockIService) RetrievePoolCreated(limit uint64) ([]*models.PoolCreated, error) { +func (m *MockIService) RetrievePoolCreated(fromBlock, toBlock, limit uint64) ([]*models.PoolCreated, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RetrievePoolCreated", limit) + ret := m.ctrl.Call(m, "RetrievePoolCreated", fromBlock, toBlock, limit) ret0, _ := ret[0].([]*models.PoolCreated) ret1, _ := ret[1].(error) return ret0, ret1 } // RetrievePoolCreated indicates an expected call of RetrievePoolCreated. -func (mr *MockIServiceMockRecorder) RetrievePoolCreated(limit interface{}) *gomock.Call { +func (mr *MockIServiceMockRecorder) RetrievePoolCreated(fromBlock, toBlock, limit interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrievePoolCreated", reflect.TypeOf((*MockIService)(nil).RetrievePoolCreated), limit) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrievePoolCreated", reflect.TypeOf((*MockIService)(nil).RetrievePoolCreated), fromBlock, toBlock, limit) +} + +// RetrievePoolCreatedLimit mocks base method. +func (m *MockIService) RetrievePoolCreatedLimit(limit uint64) ([]*models.PoolCreated, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RetrievePoolCreatedLimit", limit) + ret0, _ := ret[0].([]*models.PoolCreated) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RetrievePoolCreatedLimit indicates an expected call of RetrievePoolCreatedLimit. +func (mr *MockIServiceMockRecorder) RetrievePoolCreatedLimit(limit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrievePoolCreatedLimit", reflect.TypeOf((*MockIService)(nil).RetrievePoolCreatedLimit), limit) +} + +// RetrieveRewardClaimed mocks base method. +func (m *MockIService) RetrieveRewardClaimed(fromBlock, toBlock, limit uint64) ([]*models.RewardClaimed, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RetrieveRewardClaimed", fromBlock, toBlock, limit) + ret0, _ := ret[0].([]*models.RewardClaimed) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RetrieveRewardClaimed indicates an expected call of RetrieveRewardClaimed. +func (mr *MockIServiceMockRecorder) RetrieveRewardClaimed(fromBlock, toBlock, limit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveRewardClaimed", reflect.TypeOf((*MockIService)(nil).RetrieveRewardClaimed), fromBlock, toBlock, limit) } // RetrieveRewardClaimedLimit mocks base method. @@ -758,6 +878,21 @@ func (mr *MockIServiceMockRecorder) RetrieveRewardClaimedLimit(limit interface{} return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveRewardClaimedLimit", reflect.TypeOf((*MockIService)(nil).RetrieveRewardClaimedLimit), limit) } +// RetrieveRewardDistributed mocks base method. +func (m *MockIService) RetrieveRewardDistributed(fromBlock, toBlock, limit uint64) ([]*models.RewardDistributed, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RetrieveRewardDistributed", fromBlock, toBlock, limit) + ret0, _ := ret[0].([]*models.RewardDistributed) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RetrieveRewardDistributed indicates an expected call of RetrieveRewardDistributed. +func (mr *MockIServiceMockRecorder) RetrieveRewardDistributed(fromBlock, toBlock, limit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveRewardDistributed", reflect.TypeOf((*MockIService)(nil).RetrieveRewardDistributed), fromBlock, toBlock, limit) +} + // RetrieveRewardDistributedLimit mocks base method. func (m *MockIService) RetrieveRewardDistributedLimit(limit uint64) ([]*models.RewardDistributed, error) { m.ctrl.T.Helper() @@ -803,6 +938,21 @@ func (mr *MockIServiceMockRecorder) RetrieveTradesLimit(limit interface{}) *gomo return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveTradesLimit", reflect.TypeOf((*MockIService)(nil).RetrieveTradesLimit), limit) } +// RetrieveUSDBurned mocks base method. +func (m *MockIService) RetrieveUSDBurned(fromBlock, toBlock, limit uint64) ([]*models.USDBurned, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RetrieveUSDBurned", fromBlock, toBlock, limit) + ret0, _ := ret[0].([]*models.USDBurned) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RetrieveUSDBurned indicates an expected call of RetrieveUSDBurned. +func (mr *MockIServiceMockRecorder) RetrieveUSDBurned(fromBlock, toBlock, limit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveUSDBurned", reflect.TypeOf((*MockIService)(nil).RetrieveUSDBurned), fromBlock, toBlock, limit) +} + // RetrieveUSDBurnedLimit mocks base method. func (m *MockIService) RetrieveUSDBurnedLimit(limit uint64) ([]*models.USDBurned, error) { m.ctrl.T.Helper() @@ -818,6 +968,21 @@ func (mr *MockIServiceMockRecorder) RetrieveUSDBurnedLimit(limit interface{}) *g return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveUSDBurnedLimit", reflect.TypeOf((*MockIService)(nil).RetrieveUSDBurnedLimit), limit) } +// RetrieveUSDMinted mocks base method. +func (m *MockIService) RetrieveUSDMinted(fromBlock, toBlock, limit uint64) ([]*models.USDMinted, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RetrieveUSDMinted", fromBlock, toBlock, limit) + ret0, _ := ret[0].([]*models.USDMinted) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RetrieveUSDMinted indicates an expected call of RetrieveUSDMinted. +func (mr *MockIServiceMockRecorder) RetrieveUSDMinted(fromBlock, toBlock, limit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveUSDMinted", reflect.TypeOf((*MockIService)(nil).RetrieveUSDMinted), fromBlock, toBlock, limit) +} + // RetrieveUSDMintedLimit mocks base method. func (m *MockIService) RetrieveUSDMintedLimit(limit uint64) ([]*models.USDMinted, error) { m.ctrl.T.Helper() @@ -834,16 +999,31 @@ func (mr *MockIServiceMockRecorder) RetrieveUSDMintedLimit(limit interface{}) *g } // RetrieveVaultLiquidationsCore mocks base method. -func (m *MockIService) RetrieveVaultLiquidationsCore(limit uint64) ([]*models.CoreVaultLiquidation, error) { +func (m *MockIService) RetrieveVaultLiquidationsCore(fromBlock, toBlock, limit uint64) ([]*models.CoreVaultLiquidation, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RetrieveVaultLiquidationsCore", limit) + ret := m.ctrl.Call(m, "RetrieveVaultLiquidationsCore", fromBlock, toBlock, limit) ret0, _ := ret[0].([]*models.CoreVaultLiquidation) ret1, _ := ret[1].(error) return ret0, ret1 } // RetrieveVaultLiquidationsCore indicates an expected call of RetrieveVaultLiquidationsCore. -func (mr *MockIServiceMockRecorder) RetrieveVaultLiquidationsCore(limit interface{}) *gomock.Call { +func (mr *MockIServiceMockRecorder) RetrieveVaultLiquidationsCore(fromBlock, toBlock, limit interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveVaultLiquidationsCore", reflect.TypeOf((*MockIService)(nil).RetrieveVaultLiquidationsCore), fromBlock, toBlock, limit) +} + +// RetrieveVaultLiquidationsCoreLimit mocks base method. +func (m *MockIService) RetrieveVaultLiquidationsCoreLimit(limit uint64) ([]*models.CoreVaultLiquidation, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RetrieveVaultLiquidationsCoreLimit", limit) + ret0, _ := ret[0].([]*models.CoreVaultLiquidation) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RetrieveVaultLiquidationsCoreLimit indicates an expected call of RetrieveVaultLiquidationsCoreLimit. +func (mr *MockIServiceMockRecorder) RetrieveVaultLiquidationsCoreLimit(limit interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveVaultLiquidationsCore", reflect.TypeOf((*MockIService)(nil).RetrieveVaultLiquidationsCore), limit) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetrieveVaultLiquidationsCoreLimit", reflect.TypeOf((*MockIService)(nil).RetrieveVaultLiquidationsCoreLimit), limit) } diff --git a/perpsv3.go b/perpsv3.go index db8be37..7e78463 100644 --- a/perpsv3.go +++ b/perpsv3.go @@ -814,7 +814,7 @@ func (p *Perpsv3) init() error { return err } - srv, err := services.NewService(rpcClient, p.config, coreContact, perpsMarketContract) + srv, err := services.NewService(rpcClient, p.config, coreContact, perpsMarketContract, accountContract) if err != nil { return err } diff --git a/services/accounts.go b/services/accounts.go index f733096..8aebfb5 100644 --- a/services/accounts.go +++ b/services/accounts.go @@ -11,6 +11,7 @@ import ( "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/gateway-fm/perpsv3-Go/config" + "github.com/gateway-fm/perpsv3-Go/contracts/Account" "github.com/gateway-fm/perpsv3-Go/contracts/core" "github.com/gateway-fm/perpsv3-Go/contracts/forwarder" "github.com/gateway-fm/perpsv3-Go/errors" @@ -798,7 +799,7 @@ func (s *Service) RetrieveChangeOwner(fromBlock, toBlock, limit uint64) ([]*mode opts := s.getFilterOptsCore(startBlockOfIteration, &endBlockOfIteration) - iterator, err := s.core.FilterOwnerChanged(opts) + iterator, err := s.accountContract.FilterTransfer(opts, nil, nil, nil) if err != nil { return nil, err } @@ -854,17 +855,16 @@ func permissionGrantedToPermissionChanged(revoked *core.CorePermissionGranted) ( }, nil } -func (s *Service) toOwnerTransfered(changed *core.CoreOwnerChanged) (*models.AccountTransfer, error) { +func (s *Service) toOwnerTransfered(changed *Account.AccountTransfer) (*models.AccountTransfer, error) { block, err := s.rpcClient.BlockByHash(context.Background(), changed.Raw.BlockHash) if err != nil { return nil, err } return &models.AccountTransfer{ - From: changed.OldOwner, - To: changed.NewOwner, + From: changed.From, + To: changed.To, BlockNumber: changed.Raw.BlockNumber, BlockTimestamp: block.Time(), - //! We don't have account address in here - //! So we know from and to but do not know what + TokenID: changed.TokenId, }, nil } diff --git a/services/accounts_test.go b/services/accounts_test.go index 5fe1cd7..7f15971 100644 --- a/services/accounts_test.go +++ b/services/accounts_test.go @@ -1,16 +1,18 @@ package services import ( - "github.com/gateway-fm/perpsv3-Go/config" "log" "math/big" "os" "testing" + "github.com/gateway-fm/perpsv3-Go/config" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/ethclient" "github.com/stretchr/testify/require" + "github.com/gateway-fm/perpsv3-Go/contracts/Account" "github.com/gateway-fm/perpsv3-Go/contracts/core" "github.com/gateway-fm/perpsv3-Go/contracts/perpsMarket" "github.com/gateway-fm/perpsv3-Go/models" @@ -29,6 +31,8 @@ func TestService_FormatAccount_OnChain(t *testing.T) { coreC, _ := core.NewCore(common.HexToAddress("0x76490713314fCEC173f44e99346F54c6e92a8E42"), rpcClient) perps, _ := perpsMarket.NewPerpsMarket(common.HexToAddress("0xf272382cB3BE898A8CdB1A23BE056fA2Fcf4513b"), rpcClient) + acc, _ := Account.NewAccount(common.HexToAddress("0x63f4Dd0434BEB5baeCD27F3778a909278d8cf5b8"), rpcClient) + idPer := new(big.Int) idPer.SetString("170141183460469231731687303715884105754", 10) @@ -59,7 +63,7 @@ func TestService_FormatAccount_OnChain(t *testing.T) { } for _, tt := range testCases { t.Run(tt.name, func(t *testing.T) { - s, _ := NewService(rpcClient, conf, coreC, perps) + s, _ := NewService(rpcClient, conf, coreC, perps, acc) res, err := s.FormatAccount(tt.id) @@ -85,8 +89,10 @@ func TestService_FormatAccounts_OnChain_Limit(t *testing.T) { coreC, _ := core.NewCore(common.HexToAddress("0x76490713314fCEC173f44e99346F54c6e92a8E42"), rpcClient) perps, _ := perpsMarket.NewPerpsMarket(common.HexToAddress("0xf272382cB3BE898A8CdB1A23BE056fA2Fcf4513b"), rpcClient) + acc, _ := Account.NewAccount(common.HexToAddress("0x63f4Dd0434BEB5baeCD27F3778a909278d8cf5b8"), rpcClient) + - s, _ := NewService(rpcClient, conf, coreC, perps) + s, _ := NewService(rpcClient, conf, coreC, perps, acc) _, err := s.FormatAccountsLimit(20000) diff --git a/services/luquidations_test.go b/services/luquidations_test.go index 655f09f..d1e49f1 100644 --- a/services/luquidations_test.go +++ b/services/luquidations_test.go @@ -1,16 +1,18 @@ package services import ( - "github.com/gateway-fm/perpsv3-Go/config" "log" "math/big" "os" "testing" + "github.com/gateway-fm/perpsv3-Go/config" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/ethclient" "github.com/stretchr/testify/require" + "github.com/gateway-fm/perpsv3-Go/contracts/Account" "github.com/gateway-fm/perpsv3-Go/contracts/core" "github.com/gateway-fm/perpsv3-Go/contracts/perpsMarket" "github.com/gateway-fm/perpsv3-Go/models" @@ -28,8 +30,9 @@ func TestService_RetrieveLiquidations_OnChain_Limit(t *testing.T) { coreC, _ := core.NewCore(common.HexToAddress("0x76490713314fCEC173f44e99346F54c6e92a8E42"), rpcClient) perps, _ := perpsMarket.NewPerpsMarket(common.HexToAddress("0xf272382cB3BE898A8CdB1A23BE056fA2Fcf4513b"), rpcClient) + acc, _ := Account.NewAccount(common.HexToAddress("0x63f4Dd0434BEB5baeCD27F3778a909278d8cf5b8"), rpcClient) - s, _ := NewService(rpcClient, conf, coreC, perps) + s, _ := NewService(rpcClient, conf, coreC, perps, acc) _, err := s.RetrieveLiquidationsLimit(20000) @@ -48,6 +51,7 @@ func TestService_RetrieveLiquidations_OnChain(t *testing.T) { coreC, _ := core.NewCore(common.HexToAddress("0x76490713314fCEC173f44e99346F54c6e92a8E42"), rpcClient) perps, _ := perpsMarket.NewPerpsMarket(common.HexToAddress("0xf272382cB3BE898A8CdB1A23BE056fA2Fcf4513b"), rpcClient) + acc, _ := Account.NewAccount(common.HexToAddress("0x63f4Dd0434BEB5baeCD27F3778a909278d8cf5b8"), rpcClient) id := new(big.Int) id.SetString("170141183460469231731687303715884105753", 10) @@ -84,7 +88,7 @@ func TestService_RetrieveLiquidations_OnChain(t *testing.T) { } for _, tt := range testCases { t.Run(tt.name, func(t *testing.T) { - s, _ := NewService(rpcClient, conf, coreC, perps) + s, _ := NewService(rpcClient, conf, coreC, perps, acc) res, err := s.RetrieveLiquidations(tt.startBlock, &tt.endBlock) if err != nil { diff --git a/services/marketData_test.go b/services/marketData_test.go index 834f37f..115c36a 100644 --- a/services/marketData_test.go +++ b/services/marketData_test.go @@ -1,16 +1,18 @@ package services import ( - "github.com/gateway-fm/perpsv3-Go/config" "log" "math/big" "os" "testing" + "github.com/gateway-fm/perpsv3-Go/config" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/ethclient" "github.com/stretchr/testify/require" + "github.com/gateway-fm/perpsv3-Go/contracts/Account" "github.com/gateway-fm/perpsv3-Go/contracts/core" "github.com/gateway-fm/perpsv3-Go/contracts/perpsMarket" "github.com/gateway-fm/perpsv3-Go/errors" @@ -29,6 +31,7 @@ func TestService_RetrieveMarketUpdates_OnChain(t *testing.T) { coreC, _ := core.NewCore(common.HexToAddress("0x76490713314fCEC173f44e99346F54c6e92a8E42"), rpcClient) perps, _ := perpsMarket.NewPerpsMarket(common.HexToAddress("0xf272382cB3BE898A8CdB1A23BE056fA2Fcf4513b"), rpcClient) + acc, _ := Account.NewAccount(common.HexToAddress("0x63f4Dd0434BEB5baeCD27F3778a909278d8cf5b8"), rpcClient) want := &models.MarketUpdate{ MarketID: 200, @@ -66,7 +69,7 @@ func TestService_RetrieveMarketUpdates_OnChain(t *testing.T) { } for _, tt := range testCases { t.Run(tt.name, func(t *testing.T) { - s, _ := NewService(rpcClient, conf, coreC, perps) + s, _ := NewService(rpcClient, conf, coreC, perps, acc) res, err := s.RetrieveMarketUpdates(tt.startBlock, &tt.endBlock) require.NoError(t, err) @@ -95,6 +98,7 @@ func TestService_RetrieveMarketUpdatesBig_OnChain(t *testing.T) { coreC, _ := core.NewCore(common.HexToAddress("0x76490713314fCEC173f44e99346F54c6e92a8E42"), rpcClient) perps, _ := perpsMarket.NewPerpsMarket(common.HexToAddress("0xf272382cB3BE898A8CdB1A23BE056fA2Fcf4513b"), rpcClient) + acc, _ := Account.NewAccount(common.HexToAddress("0x63f4Dd0434BEB5baeCD27F3778a909278d8cf5b8"), rpcClient) price := new(big.Int) price.SetString("26050583159510000000000", 10) @@ -135,7 +139,7 @@ func TestService_RetrieveMarketUpdatesBig_OnChain(t *testing.T) { } for _, tt := range testCases { t.Run(tt.name, func(t *testing.T) { - s, _ := NewService(rpcClient, conf, coreC, perps) + s, _ := NewService(rpcClient, conf, coreC, perps, acc) res, err := s.RetrieveMarketUpdatesBig(tt.startBlock, &tt.endBlock) require.NoError(t, err) @@ -164,8 +168,9 @@ func TestService_RetrieveMarketUpdates_OnChain_Limit(t *testing.T) { coreC, _ := core.NewCore(common.HexToAddress("0x76490713314fCEC173f44e99346F54c6e92a8E42"), rpcClient) perps, _ := perpsMarket.NewPerpsMarket(common.HexToAddress("0xf272382cB3BE898A8CdB1A23BE056fA2Fcf4513b"), rpcClient) + acc, _ := Account.NewAccount(common.HexToAddress("0x63f4Dd0434BEB5baeCD27F3778a909278d8cf5b8"), rpcClient) - s, _ := NewService(rpcClient, conf, coreC, perps) + s, _ := NewService(rpcClient, conf, coreC, perps, acc) _, err := s.RetrieveMarketUpdatesLimit(20000) @@ -184,8 +189,9 @@ func TestService_RetrieveMarketUpdatesBig_OnChain_Limit(t *testing.T) { coreC, _ := core.NewCore(common.HexToAddress("0x76490713314fCEC173f44e99346F54c6e92a8E42"), rpcClient) perps, _ := perpsMarket.NewPerpsMarket(common.HexToAddress("0xf272382cB3BE898A8CdB1A23BE056fA2Fcf4513b"), rpcClient) + acc, _ := Account.NewAccount(common.HexToAddress("0x63f4Dd0434BEB5baeCD27F3778a909278d8cf5b8"), rpcClient) - s, _ := NewService(rpcClient, conf, coreC, perps) + s, _ := NewService(rpcClient, conf, coreC, perps, acc) _, err := s.RetrieveMarketUpdatesBigLimit(20000) @@ -204,6 +210,7 @@ func TestService_GetMarketMetadata_OnChain(t *testing.T) { coreC, _ := core.NewCore(common.HexToAddress("0x76490713314fCEC173f44e99346F54c6e92a8E42"), rpcClient) perps, _ := perpsMarket.NewPerpsMarket(common.HexToAddress("0xf272382cB3BE898A8CdB1A23BE056fA2Fcf4513b"), rpcClient) + acc, _ := Account.NewAccount(common.HexToAddress("0x63f4Dd0434BEB5baeCD27F3778a909278d8cf5b8"), rpcClient) testCases := []struct { name string @@ -241,7 +248,7 @@ func TestService_GetMarketMetadata_OnChain(t *testing.T) { } for _, tt := range testCases { t.Run(tt.name, func(t *testing.T) { - s, _ := NewService(rpcClient, conf, coreC, perps) + s, _ := NewService(rpcClient, conf, coreC, perps, acc) res, err := s.GetMarketMetadata(tt.marketID) @@ -268,6 +275,7 @@ func TestService_GetMarketSummary(t *testing.T) { coreC, _ := core.NewCore(common.HexToAddress("0x76490713314fCEC173f44e99346F54c6e92a8E42"), rpcClient) perps, _ := perpsMarket.NewPerpsMarket(common.HexToAddress("0xf272382cB3BE898A8CdB1A23BE056fA2Fcf4513b"), rpcClient) + acc, _ := Account.NewAccount(common.HexToAddress("0x63f4Dd0434BEB5baeCD27F3778a909278d8cf5b8"), rpcClient) testCases := []struct { name string @@ -294,7 +302,7 @@ func TestService_GetMarketSummary(t *testing.T) { } for _, tt := range testCases { t.Run(tt.name, func(t *testing.T) { - s, _ := NewService(rpcClient, conf, coreC, perps) + s, _ := NewService(rpcClient, conf, coreC, perps, acc) res, err := s.GetMarketSummary(tt.marketID) @@ -328,6 +336,7 @@ func TestService_GetMarketIDs(t *testing.T) { coreC, _ := core.NewCore(common.HexToAddress("0x76490713314fCEC173f44e99346F54c6e92a8E42"), rpcClient) perps, _ := perpsMarket.NewPerpsMarket(common.HexToAddress("0xf272382cB3BE898A8CdB1A23BE056fA2Fcf4513b"), rpcClient) + acc, _ := Account.NewAccount(common.HexToAddress("0x63f4Dd0434BEB5baeCD27F3778a909278d8cf5b8"), rpcClient) testCases := []struct { name string @@ -341,7 +350,7 @@ func TestService_GetMarketIDs(t *testing.T) { } for _, tt := range testCases { t.Run(tt.name, func(t *testing.T) { - s, _ := NewService(rpcClient, conf, coreC, perps) + s, _ := NewService(rpcClient, conf, coreC, perps, acc) res, err := s.GetMarketIDs() @@ -367,6 +376,7 @@ func TestService_GetFoundingRate(t *testing.T) { coreC, _ := core.NewCore(common.HexToAddress("0x76490713314fCEC173f44e99346F54c6e92a8E42"), rpcClient) perps, _ := perpsMarket.NewPerpsMarket(common.HexToAddress("0xf272382cB3BE898A8CdB1A23BE056fA2Fcf4513b"), rpcClient) + acc, _ := Account.NewAccount(common.HexToAddress("0x63f4Dd0434BEB5baeCD27F3778a909278d8cf5b8"), rpcClient) testCases := []struct { name string @@ -384,7 +394,7 @@ func TestService_GetFoundingRate(t *testing.T) { } for _, tt := range testCases { t.Run(tt.name, func(t *testing.T) { - s, _ := NewService(rpcClient, conf, coreC, perps) + s, _ := NewService(rpcClient, conf, coreC, perps, acc) res, err := s.GetFoundingRate(tt.id) diff --git a/services/orders_test.go b/services/orders_test.go index f4a3d9d..97e4087 100644 --- a/services/orders_test.go +++ b/services/orders_test.go @@ -1,16 +1,18 @@ package services import ( - "github.com/gateway-fm/perpsv3-Go/config" "log" "math/big" "os" "testing" + "github.com/gateway-fm/perpsv3-Go/config" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/ethclient" "github.com/stretchr/testify/require" + "github.com/gateway-fm/perpsv3-Go/contracts/Account" "github.com/gateway-fm/perpsv3-Go/contracts/core" "github.com/gateway-fm/perpsv3-Go/contracts/perpsMarket" "github.com/gateway-fm/perpsv3-Go/models" @@ -28,6 +30,7 @@ func TestService_RetrieveOrders_OnChain(t *testing.T) { coreC, _ := core.NewCore(common.HexToAddress("0x76490713314fCEC173f44e99346F54c6e92a8E42"), rpcClient) perps, _ := perpsMarket.NewPerpsMarket(common.HexToAddress("0xf272382cB3BE898A8CdB1A23BE056fA2Fcf4513b"), rpcClient) + acc, _ := Account.NewAccount(common.HexToAddress("0x63f4Dd0434BEB5baeCD27F3778a909278d8cf5b8"), rpcClient) sizeDelta := new(big.Int) sizeDelta.SetString("-500000000000000000", 10) @@ -72,7 +75,7 @@ func TestService_RetrieveOrders_OnChain(t *testing.T) { } for _, tt := range testCases { t.Run(tt.name, func(t *testing.T) { - s, _ := NewService(rpcClient, conf, coreC, perps) + s, _ := NewService(rpcClient, conf, coreC, perps, acc) res, err := s.RetrieveOrders(tt.startBlock, &tt.endBlock) if err != nil { @@ -106,8 +109,9 @@ func TestService_RetrieveOrders_OnChain_Limit(t *testing.T) { coreC, _ := core.NewCore(common.HexToAddress("0x76490713314fCEC173f44e99346F54c6e92a8E42"), rpcClient) perps, _ := perpsMarket.NewPerpsMarket(common.HexToAddress("0xf272382cB3BE898A8CdB1A23BE056fA2Fcf4513b"), rpcClient) - - s, _ := NewService(rpcClient, conf, coreC, perps) + acc, _ := Account.NewAccount(common.HexToAddress("0x63f4Dd0434BEB5baeCD27F3778a909278d8cf5b8"), rpcClient) + + s, _ := NewService(rpcClient, conf, coreC, perps, acc) _, err := s.RetrieveOrdersLimit(20000) diff --git a/services/positions_test.go b/services/positions_test.go index 275ac89..1df0f26 100644 --- a/services/positions_test.go +++ b/services/positions_test.go @@ -2,16 +2,18 @@ package services import ( "fmt" - "github.com/gateway-fm/perpsv3-Go/config" "log" "math/big" "os" "testing" + "github.com/gateway-fm/perpsv3-Go/config" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/ethclient" "github.com/stretchr/testify/require" + "github.com/gateway-fm/perpsv3-Go/contracts/Account" "github.com/gateway-fm/perpsv3-Go/contracts/core" "github.com/gateway-fm/perpsv3-Go/contracts/perpsMarket" "github.com/gateway-fm/perpsv3-Go/errors" @@ -29,6 +31,7 @@ func TestService_GetPosition_OnChain(t *testing.T) { coreC, _ := core.NewCore(common.HexToAddress("0x76490713314fCEC173f44e99346F54c6e92a8E42"), rpcClient) perps, _ := perpsMarket.NewPerpsMarket(common.HexToAddress("0xf272382cB3BE898A8CdB1A23BE056fA2Fcf4513b"), rpcClient) + acc, _ := Account.NewAccount(common.HexToAddress("0x63f4Dd0434BEB5baeCD27F3778a909278d8cf5b8"), rpcClient) testCases := []struct { name string @@ -55,7 +58,7 @@ func TestService_GetPosition_OnChain(t *testing.T) { } for _, tt := range testCases { t.Run(tt.name, func(t *testing.T) { - s, _ := NewService(rpcClient, conf, coreC, perps) + s, _ := NewService(rpcClient, conf, coreC, perps, acc) res, err := s.GetPosition(tt.accountID, tt.marketID) diff --git a/services/service.go b/services/service.go index 9bba884..21ccdf8 100644 --- a/services/service.go +++ b/services/service.go @@ -11,6 +11,7 @@ import ( "github.com/ethereum/go-ethereum/ethclient" "github.com/gateway-fm/perpsv3-Go/config" + "github.com/gateway-fm/perpsv3-Go/contracts/Account" "github.com/gateway-fm/perpsv3-Go/contracts/core" "github.com/gateway-fm/perpsv3-Go/contracts/perpsMarket" "github.com/gateway-fm/perpsv3-Go/errors" @@ -285,6 +286,8 @@ type Service struct { rawERC7412 rawContracts.IRawERC7412Contract rawForwarder rawContracts.IRawForwarderContract rawCore rawContracts.IRawCoreContract + + accountContract *Account.Account } // NewService is used to get instance of Service @@ -293,6 +296,7 @@ func NewService( conf *config.PerpsvConfig, core *core.Core, perps *perpsMarket.PerpsMarket, + accountContract *Account.Account, ) (IService, error) { s := &Service{ chainID: conf.ChainID, @@ -305,6 +309,7 @@ func NewService( perpsMarket: perps, perpsMarketFirstBlock: conf.FirstContractBlocks.PerpsMarket, + accountContract: accountContract, } rawPerpsContract, err := rawContracts.NewPerps(common.HexToAddress(conf.ContractAddresses.PerpsMarket), rpc) diff --git a/services/trades_test.go b/services/trades_test.go index 2e4e95e..549f5a0 100644 --- a/services/trades_test.go +++ b/services/trades_test.go @@ -1,16 +1,18 @@ package services import ( - "github.com/gateway-fm/perpsv3-Go/config" "log" "math/big" "os" "testing" + "github.com/gateway-fm/perpsv3-Go/config" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/ethclient" "github.com/stretchr/testify/require" + "github.com/gateway-fm/perpsv3-Go/contracts/Account" "github.com/gateway-fm/perpsv3-Go/contracts/core" "github.com/gateway-fm/perpsv3-Go/contracts/perpsMarket" "github.com/gateway-fm/perpsv3-Go/models" @@ -28,6 +30,7 @@ func TestService_RetrieveTrades_OnChain(t *testing.T) { coreC, _ := core.NewCore(common.HexToAddress("0x76490713314fCEC173f44e99346F54c6e92a8E42"), rpcClient) perps, _ := perpsMarket.NewPerpsMarket(common.HexToAddress("0xf272382cB3BE898A8CdB1A23BE056fA2Fcf4513b"), rpcClient) + acc, _ := Account.NewAccount(common.HexToAddress("0x63f4Dd0434BEB5baeCD27F3778a909278d8cf5b8"), rpcClient) fillPrice := new(big.Int) fillPrice.SetString("26050753699652653732215", 10) @@ -89,7 +92,7 @@ func TestService_RetrieveTrades_OnChain(t *testing.T) { } for _, tt := range testCases { t.Run(tt.name, func(t *testing.T) { - s, _ := NewService(rpcClient, conf, coreC, perps) + s, _ := NewService(rpcClient, conf, coreC, perps, acc) res, err := s.RetrieveTrades(tt.startBlock, &tt.endBlock) require.NoError(t, err) @@ -133,8 +136,9 @@ func TestService_RetrieveTrades_OnChain_Limit(t *testing.T) { coreC, _ := core.NewCore(common.HexToAddress("0x76490713314fCEC173f44e99346F54c6e92a8E42"), rpcClient) perps, _ := perpsMarket.NewPerpsMarket(common.HexToAddress("0xf272382cB3BE898A8CdB1A23BE056fA2Fcf4513b"), rpcClient) + acc, _ := Account.NewAccount(common.HexToAddress("0x63f4Dd0434BEB5baeCD27F3778a909278d8cf5b8"), rpcClient) - s, _ := NewService(rpcClient, conf, coreC, perps) + s, _ := NewService(rpcClient, conf, coreC, perps, acc) res, err := s.RetrieveTradesLimit(20000)