synapsecns/sanguine

package client_test

import (
    "os"
    "time"

    "github.com/ethereum/go-ethereum/core/types"
    "github.com/lmittmann/w3/module/eth"
    "github.com/lmittmann/w3/w3types"
    . "github.com/stretchr/testify/assert"
    "github.com/synapsecns/sanguine/ethergo/backends/geth"
    "github.com/synapsecns/sanguine/ethergo/backends/preset"
    "github.com/synapsecns/sanguine/ethergo/chain/client"
    "github.com/synapsecns/sanguine/ethergo/mocks"
    "go.uber.org/atomic"
)

// TestAttemptReconnect tests the rehupping process. You may notice that in the below test, if the first connection
// had broken no new blocks would come in on the subcription. This is expected and PoolClient works around this
// we're specifically testing if our rehup process breaks any existing subscriptions if the connection didn't break
// this stands in for all other types of one off requests.
func (c *ClientSuite) TestAttemptReconnect() {
    if os.Getenv("ATTEMPT_CONNECT_ENABLED") != "" {
        c.T().Skip("deprecated")
    }
    testBackend := preset.GetSepolia().Geth(c.GetTestContext(), c.T())

    // make sure the client doesn't reset on us during the test
    client.SetResetTimeout(time.Hour)

    // create a subscription before rehupping to make sure we don't panic/break the original subscription
    testClient, err := client.NewTestClient(c.GetTestContext(), c.T(), testBackend.WSEndpoint())
    Nil(c.T(), err)

    ogSubscription := c.maxHeightSubscription(testClient)

    // reconnect to see if ogSubscription breaks
    err = testClient.AttemptReconnect()
    Nil(c.T(), err)

    postRehupSubscription := c.maxHeightSubscription(testClient)
    Nil(c.T(), err)

    // mock some blocks to make sure our subscription gets updated
    mocks.MockBlocksOnBackend(c.GetTestContext(), c.T(), testBackend, 10)

    c.Eventually(func() bool {
        return ogSubscription.MaxHeight() == postRehupSubscription.MaxHeight()
    })
}

// maxHeightTracker fetches the max height from haed.
type maxHeightTracker struct {
    maxHeight atomic.Uint64
}

// MaxHeight gets the current max height in a thread safe manner.
func (m *maxHeightTracker) MaxHeight() uint64 {
    return m.maxHeight.Load()
}

func (c *ClientSuite) maxHeightSubscription(testClient client.TestClient) *maxHeightTracker {
    tracker := maxHeightTracker{}

    // headerChan is a channel containing headerChan from the subscription on the client
    headerChan := make(chan *types.Header)
    sub, err := testClient.SubscribeNewHead(c.GetTestContext(), headerChan)
    Nil(c.T(), err)

    // start a goroutine that updates the max height
    go func() {
        for {
            select {
            case <-c.GetTestContext().Done():
                return
            case err := <-sub.Err():
                // should not error because of a broken client
                Nil(c.T(), err)
            case header := <-headerChan:
                tracker.maxHeight.Store(header.Number.Uint64())
            }
        }
    }()
    return &tracker
}

func (c *ClientSuite) TestBatch() {
    backend := geth.NewEmbeddedBackend(c.GetTestContext(), c.T())

    caller, err := client.NewClient(c.GetTestContext(), backend.RPCAddress())
    Nil(c.T(), err)

    const callCount = 10

    calls := make([]w3types.Caller, callCount)
    res := make([]uint64, callCount)

    for i := 0; i < callCount; i++ {
        calls[i] = eth.ChainID().Returns(&res[i])
    }

    err = caller.BatchContext(c.GetTestContext(), calls...)
    Nil(c.T(), err)

    for _, chainID := range res {
        Equal(c.T(), chainID, uint64(backend.GetChainID()))
    }
}