feat: implement net_pairs (#495)

cmd/swapcli/main.go

@@ -76,6 +76,20 @@ func cliApp() *cli.App {
  swapdPortFlag,
  },
  },
+ {
+ Name: "pairs",
+ Aliases: []string{"p"},
+ Usage: "List active pairs",
+ Action: runPairs,
+ Flags: []cli.Flag{
+ swapdPortFlag,
+ &cli.Uint64Flag{
+ Name: flagSearchTime,
+ Usage: "Duration of time to search for, in seconds",
+ Value: defaultDiscoverSearchTimeSecs,
+ },
+ },
+ },
  {
  Name: "balances",
  Aliases: []string{"b"},
@@ -536,6 +550,39 @@ func runPeers(ctx *cli.Context) error {
  return nil
 }
 
+func runPairs(ctx *cli.Context) error {
+ searchTime := ctx.Uint64(flagSearchTime)
+
+ c := newClient(ctx)
+ resp, err := c.Pairs(searchTime)
+ if err != nil {
+ return err
+ }
+
+ for i, a := range resp.Pairs {
+ var verified string
+ if a.Verified {
+ verified = "Yes"
+ } else {
+ verified = "No"
+ }
+
+ fmt.Printf("Pair %d:\n", i+1)
+ fmt.Printf(" Name: %s\n", a.Token.Symbol)
+ fmt.Printf(" Token: %s\n", a.Token.Address)
+ fmt.Printf(" Verified: %s\n", verified)
+ fmt.Printf(" Offers: %d\n", a.Offers)
+ fmt.Printf(" Reported Liquidity XMR: %f\n", a.ReportedLiquidityXMR)
+ fmt.Println()
+ }
+
+ if len(resp.Pairs) == 0 {
+ fmt.Println("[none]")
+ }
+
+ return nil
+}
+
 func runBalances(ctx *cli.Context) error {
  c := newClient(ctx)
 

common/rpctypes/types.go

@@ -147,3 +147,13 @@ type AddressesResponse struct {
 type PeersResponse struct {
  Addrs []string `json:"addresses" validate:"dive,required"`
 }
+
+// PairsRequest ...
+type PairsRequest struct {
+ SearchTime uint64 `json:"searchTime"` // in seconds
+}
+
+// PairsResponse ...
+type PairsResponse struct {
+ Pairs []*types.Pair
+}

common/types/pairs.go

@@ -0,0 +1,44 @@
+// Copyright 2023 The AthanorLabs/atomic-swap Authors
+// SPDX-License-Identifier: LGPL-3.0-only
+
+package types
+
+import (
+ "github.com/cockroachdb/apd/v3"
+
+ "github.com/athanorlabs/atomic-swap/coins"
+)
+
+// Pair represents a pair (Such as ETH / XMR)
+type Pair struct {
+ ReportedLiquidityXMR *apd.Decimal `json:"reportedLiquidityXmr" validate:"required"`
+ EthAsset EthAsset `json:"ethAsset" validate:"required"`
+ Token coins.ERC20TokenInfo `json:"token" validate:"required"`
+ Offers uint64 `json:"offers" validate:"required"`
+ Verified bool `json:"verified" valdate:"required"`
+}
+
+// NewPair creates and returns a Pair
+func NewPair(EthAsset EthAsset) *Pair {
+ pair := &Pair{
+ ReportedLiquidityXMR: apd.New(0, 0),
+ EthAsset: EthAsset,
+
+ // Always set to false for now until the verified-list
+ // is implemented
+ Verified: false,
+ }
+ return pair
+}
+
+// AddOffer adds an offer to a pair
+func (pair *Pair) AddOffer(o *Offer) error {
+ _, err := coins.DecimalCtx().Add(pair.ReportedLiquidityXMR, pair.ReportedLiquidityXMR, o.MaxAmount)
+ if err != nil {
+ return err
+ }
+
+ pair.Offers++
+
+ return nil
+}

rpc/net.go

@@ -4,6 +4,7 @@
 package rpc
 
 import (
+ "context"
  "fmt"
  "net/http"
  "time"
@@ -18,6 +19,8 @@ import (
  "github.com/athanorlabs/atomic-swap/common/types"
  "github.com/athanorlabs/atomic-swap/net/message"
  "github.com/athanorlabs/atomic-swap/protocol/swap"
+
+ ethcommon "github.com/ethereum/go-ethereum/common"
 )
 
 const defaultSearchTime = time.Second * 12
@@ -35,19 +38,31 @@ type Net interface {
 
 // NetService is the RPC service prefixed by net_.
 type NetService struct {
+ ctx context.Context
  net Net
  xmrtaker XMRTaker
  xmrmaker XMRMaker
+ pb ProtocolBackend
  sm swap.Manager
  isBootnode bool
 }
 
 // NewNetService ...
-func NewNetService(net Net, xmrtaker XMRTaker, xmrmaker XMRMaker, sm swap.Manager, isBootnode bool) *NetService {
+func NewNetService(
+ ctx context.Context,
+ net Net,
+ xmrtaker XMRTaker,
+ xmrmaker XMRMaker,
+ pb ProtocolBackend,
+ sm swap.Manager,
+ isBootnode bool,
+) *NetService {
  return &NetService{
+ ctx: ctx,
  net: net,
  xmrtaker: xmrtaker,
  xmrmaker: xmrmaker,
+ pb: pb,
  sm: sm,
  isBootnode: isBootnode,
  }
@@ -73,6 +88,75 @@ func (s *NetService) Peers(_ *http.Request, _ *interface{}, resp *rpctypes.Peers
  return nil
 }
 
+// Pairs returns all currently available pairs from offers of all peers
+func (s *NetService) Pairs(_ *http.Request, req *rpctypes.PairsRequest, resp *rpctypes.PairsResponse) error {
+ if s.isBootnode {
+ return errUnsupportedForBootnode
+ }
+
+ peerIDs, err := s.discover(&rpctypes.DiscoverRequest{
+ Provides: "",
+ SearchTime: req.SearchTime,
+ })
+ if err != nil {
+ return err
+ }
+
+ pairs := make(map[ethcommon.Address]*types.Pair)
+
+ for _, p := range peerIDs {
+ msg, err := s.net.Query(p)
+ if err != nil {
+ log.Debugf("Failed to query peer ID %s", p)
+ continue
+ }
+
+ if len(msg.Offers) == 0 {
+ continue
+ }
+
+ for _, o := range msg.Offers {
+ address := o.EthAsset.Address()
+ pair, exists := pairs[address]
+
+ if !exists {
+ pair = types.NewPair(o.EthAsset)
+ if pair.EthAsset.IsToken() {
+ tokenInfo, tokenInfoErr := s.pb.ETHClient().ERC20Info(s.ctx, address)
+ if tokenInfoErr != nil {
+ log.Debugf("Error while reading token info: %s", tokenInfoErr)
+ continue
+ }
+ pair.Token = *tokenInfo
+ } else {
+ pair.Token.Name = "Ether"
+ pair.Token.Symbol = "ETH"
+ pair.Token.NumDecimals = 18
+ pair.Verified = true
+ }
+ pairs[address] = pair
+ }
+
+ err = pair.AddOffer(o)
+ if err != nil {
+ return err
+ }
+ }
+ }
+
+ pairsArray := make([]*types.Pair, 0, len(pairs))
+ for _, pair := range pairs {
+ if pair.EthAsset.IsETH() {
+ pairsArray = append([]*types.Pair{pair}, pairsArray...)
+ } else {
+ pairsArray = append(pairsArray, pair)
+ }
+ }
+
+ resp.Pairs = pairsArray
+ return nil
+}
+
 // QueryAll discovers peers who provide a certain coin and queries all of them for their current offers.
 func (s *NetService) QueryAll(_ *http.Request, req *rpctypes.QueryAllRequest, resp *rpctypes.QueryAllResponse) error {
  if s.isBootnode {

rpc/server.go

@@ -107,7 +107,15 @@ func NewServer(cfg *Config) (*Server, error) {
  case DatabaseNamespace:
  err = rpcServer.RegisterService(NewDatabaseService(cfg.RecoveryDB), DatabaseNamespace)
  case NetNamespace:
- netService = NewNetService(cfg.Net, cfg.XMRTaker, cfg.XMRMaker, swapManager, isBootnode)
+ netService = NewNetService(
+ serverCtx,
+ cfg.Net,
+ cfg.XMRTaker,
+ cfg.XMRMaker,
+ cfg.ProtocolBackend,
+ swapManager,
+ isBootnode,
+ )
  err = rpcServer.RegisterService(netService, NetNamespace)
  case PersonalName:
  err = rpcServer.RegisterService(NewPersonalService(serverCtx, cfg.XMRMaker, cfg.ProtocolBackend), PersonalName)

rpcclient/net_test.go

@@ -4,6 +4,7 @@
 package rpcclient
 
 import (
+ "context"
  "testing"
 
  "github.com/cockroachdb/apd/v3"
@@ -15,7 +16,12 @@ import (
 )
 
 func TestNet_Discover(t *testing.T) {
- ns := rpc.NewNetService(new(mockNet), new(mockXMRTaker), nil, mockSwapManager(t), false)
+ ctx, cancel := context.WithCancel(context.Background())
+ t.Cleanup(func() {
+ cancel()
+ })
+
+ ns := rpc.NewNetService(ctx, new(mockNet), new(mockXMRTaker), nil, new(mockProtocolBackend), mockSwapManager(t), false)
 
  req := &rpctypes.DiscoverRequest{
  Provides: "",
@@ -29,7 +35,12 @@ func TestNet_Discover(t *testing.T) {
 }
 
 func TestNet_Query(t *testing.T) {
- ns := rpc.NewNetService(new(mockNet), new(mockXMRTaker), nil, mockSwapManager(t), false)
+ ctx, cancel := context.WithCancel(context.Background())
+ t.Cleanup(func() {
+ cancel()
+ })
+
+ ns := rpc.NewNetService(ctx, new(mockNet), new(mockXMRTaker), nil, new(mockProtocolBackend), mockSwapManager(t), false)
 
  req := &rpctypes.QueryPeerRequest{
  PeerID: "12D3KooWDqCzbjexHEa8Rut7bzxHFpRMZyDRW1L6TGkL1KY24JH5",
@@ -43,7 +54,12 @@ func TestNet_Query(t *testing.T) {
 }
 
 func TestNet_TakeOffer(t *testing.T) {
- ns := rpc.NewNetService(new(mockNet), new(mockXMRTaker), nil, mockSwapManager(t), false)
+ ctx, cancel := context.WithCancel(context.Background())
+ t.Cleanup(func() {
+ cancel()
+ })
+
+ ns := rpc.NewNetService(ctx, new(mockNet), new(mockXMRTaker), nil, new(mockProtocolBackend), mockSwapManager(t), false)
 
  req := &rpctypes.TakeOfferRequest{
  PeerID: "12D3KooWDqCzbjexHEa8Rut7bzxHFpRMZyDRW1L6TGkL1KY24JH5",

rpcclient/pairs.go

@@ -0,0 +1,27 @@
+// Copyright 2023 The AthanorLabs/atomic-swap Authors
+// SPDX-License-Identifier: LGPL-3.0-only
+
+package rpcclient
+
+import (
+ "github.com/athanorlabs/atomic-swap/common/rpctypes"
+)
+
+// Pairs calls net_pairs to get pairs from all offers.
+func (c *Client) Pairs(searchTime uint64) (*rpctypes.PairsResponse, error) {
+ const (
+ method = "net_pairs"
+ )
+
+ req := &rpctypes.PairsRequest{
+ SearchTime: searchTime,
+ }
+
+ res := &rpctypes.PairsResponse{}
+
+ if err := c.post(method, req, res); err != nil {
+ return nil, err
+ }
+
+ return res, nil
+}

tests/integration_test.go

@@ -129,6 +129,54 @@ func (s *IntegrationTestSuite) TestXMRMaker_Discover() {
  require.Equal(s.T(), 0, len(peerIDs))
 }
 
+func (s *IntegrationTestSuite) TestXMRMaker_Pairs() {
+ ctx := context.Background()
+ bc := rpcclient.NewClient(ctx, defaultXMRMakerSwapdPort)
+
+ _, err := bc.MakeOffer(
+ coins.StrToDecimal("1"),
+ coins.StrToDecimal("2"),
+ coins.StrToExchangeRate("200"),
+ s.testToken,
+ false)
+
+ require.NoError(s.T(), err)
+
+ _, err = bc.MakeOffer(
+ coins.StrToDecimal("1"),
+ coins.StrToDecimal("2"),
+ coins.StrToExchangeRate("200"),
+ types.EthAssetETH,
+ false)
+
+ require.NoError(s.T(), err)
+
+ _, err = bc.MakeOffer(
+ coins.StrToDecimal("1"),
+ coins.StrToDecimal("2"),
+ coins.StrToExchangeRate("200"),
+ types.EthAssetETH,
+ false)
+
+ require.NoError(s.T(), err)
+
+ // Give offer advertisement time to propagate
+ require.NoError(s.T(), common.SleepWithContext(ctx, time.Second))
+
+ ac := rpcclient.NewClient(ctx, defaultXMRTakerSwapdPort)
+ pairs, err := ac.Pairs(3)
+
+ require.Equal(s.T(), len(pairs.Pairs), 2)
+
+ p1 := pairs.Pairs[0]
+ p2 := pairs.Pairs[1]
+
+ require.Equal(s.T(), p1.Offers, uint64(2))
+ require.Equal(s.T(), p2.Offers, uint64(1))
+
+ require.NoError(s.T(), err)
+}
+
 func (s *IntegrationTestSuite) TestXMRTaker_Query() {
  s.testXMRTakerQuery(types.EthAssetETH)
 }