synapsecns/sanguine

package relapi_test

import (
    "context"
    "fmt"
    "math/big"

    "github.com/ethereum/go-ethereum/accounts/abi/bind"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/common/hexutil"
    "github.com/synapsecns/sanguine/core/retry"
    submitterdb "github.com/synapsecns/sanguine/ethergo/submitter/db"
    "github.com/synapsecns/sanguine/services/rfq/relayer/relapi"
    "github.com/synapsecns/sanguine/services/rfq/relayer/reldb"
    "github.com/synapsecns/sanguine/services/rfq/util"
)

func (c *RelayerClientSuite) TestHealth() {
    ok, err := c.Client.Health(c.GetTestContext())
    c.NoError(err)
    c.True(ok)
}

func (c *RelayerClientSuite) TestGetQuoteRequestStatusByTxHash() {
    testReq := c.underlying.getTestQuoteRequest(reldb.Seen)
    err := c.underlying.database.StoreQuoteRequest(c.GetTestContext(), testReq)
    c.Require().NoError(err)

    resp, err := c.Client.GetQuoteRequestByTxHash(c.GetTestContext(), testReq.OriginTxHash.String())
    c.Require().NoError(err)

    c.Equal(resp.Status, testReq.Status.String())
    c.Equal(resp.TxID, hexutil.Encode(testReq.TransactionID[:]))
    c.Equal(resp.DestTxHash, testReq.DestTxHash.String())
    c.Equal(resp.OriginTxHash, testReq.OriginTxHash.String())
}

func (c *RelayerClientSuite) TestGetQuoteRequestStatusByTxID() {
    testReq := c.underlying.getTestQuoteRequest(reldb.Seen)
    err := c.underlying.database.StoreQuoteRequest(c.GetTestContext(), testReq)
    c.Require().NoError(err)

    resp, err := c.Client.GetQuoteRequestByTXID(c.GetTestContext(), hexutil.Encode(testReq.TransactionID[:]))
    c.Require().NoError(err)

    c.Equal(resp.Status, testReq.Status.String())
    c.Equal(resp.TxID, hexutil.Encode(testReq.TransactionID[:]))
    c.Equal(resp.DestTxHash, testReq.DestTxHash.String())
    c.Equal(resp.OriginTxHash, testReq.OriginTxHash.String())
}

func (c *RelayerClientSuite) TestRetryTransaction() {
    testReq := c.underlying.getTestQuoteRequest(reldb.Seen)
    err := c.underlying.database.StoreQuoteRequest(c.GetTestContext(), testReq)
    c.Require().NoError(err)

    resp, err := c.Client.RetryTransaction(c.GetTestContext(), testReq.OriginTxHash.String())
    c.Require().NoError(err)

    c.Equal(resp.TxID, hexutil.Encode(testReq.TransactionID[:]))
}

func (c *RelayerClientSuite) TestEthWithdraw() {
    backend := c.underlying.testBackends[uint64(c.underlying.originChainID)]

    startBalance, err := backend.BalanceAt(c.GetTestContext(), testWithdrawalAddress, nil)
    c.Require().NoError(err)

    withdrawalAmount := big.NewInt(50)

    _, err = c.Client.Withdraw(c.GetTestContext(), &relapi.WithdrawRequest{
        ChainID:      uint32(backend.GetChainID()),
        To:           testWithdrawalAddress,
        Amount:       withdrawalAmount.String(),
        TokenAddress: util.EthAddress,
    })
    c.Require().NoError(err)

    // Wait for the transaction to be mined
    err = retry.WithBackoff(c.GetTestContext(), func(ctx context.Context) error {
        balance, err := backend.BalanceAt(ctx, testWithdrawalAddress, nil)
        if err != nil {
            return fmt.Errorf("could not fetch balance %w", err)
        }

        expectedBalance := new(big.Int).Add(startBalance, withdrawalAmount)

        if balance.Cmp(expectedBalance) != 0 {
            return fmt.Errorf("balance not updated")
        }

        return nil
    })
    c.Require().NoError(err)
}

func (c *RelayerClientSuite) TestERC20Withdraw() {
    backend := c.underlying.testBackends[uint64(c.underlying.originChainID)]

    _, erc20 := c.underlying.deployManager.GetMockERC20(c.GetTestContext(), backend)

    startBalance, err := erc20.BalanceOf(&bind.CallOpts{Context: c.GetTestContext()}, testWithdrawalAddress)
    c.Require().NoError(err)

    withdrawalAmount := big.NewInt(50)

    _, err = c.Client.Withdraw(c.GetTestContext(), &relapi.WithdrawRequest{
        ChainID:      uint32(backend.GetChainID()),
        To:           testWithdrawalAddress,
        Amount:       withdrawalAmount.String(),
        TokenAddress: erc20.Address(),
    })
    c.Require().NoError(err)

    // Wait for the transaction to be mined
    err = retry.WithBackoff(c.GetTestContext(), func(ctx context.Context) error {
        balance, err := erc20.BalanceOf(&bind.CallOpts{Context: ctx}, testWithdrawalAddress)
        if err != nil {
            return fmt.Errorf("could not get balance %w", err)
        }

        expectedBalance := new(big.Int).Add(startBalance, withdrawalAmount)

        if balance.Cmp(expectedBalance) != 0 {
            return fmt.Errorf("balance not updated")
        }

        return nil
    })
    c.Require().NoError(err)
}

func (c *RelayerClientSuite) TestGetTxHash() {
    backend := c.underlying.testBackends[uint64(c.underlying.originChainID)]

    _, erc20 := c.underlying.deployManager.GetMockERC20(c.GetTestContext(), backend)

    withdrawalAmount := big.NewInt(50)

    withdrawRes, err := c.Client.Withdraw(c.GetTestContext(), &relapi.WithdrawRequest{
        ChainID:      uint32(backend.GetChainID()),
        To:           testWithdrawalAddress,
        Amount:       withdrawalAmount.String(),
        TokenAddress: erc20.Address(),
    })
    c.Require().NoError(err)

    var txHashRes *relapi.TxHashByNonceResponse

    // Wait for the transaction to be mined
    err = retry.WithBackoff(c.GetTestContext(), func(ctx context.Context) error {
        txHashRes, err = c.Client.GetTxHashByNonce(
            c.GetTestContext(),
            &relapi.GetTxByNonceRequest{
                ChainID: uint32(backend.GetChainID()),
                Nonce:   withdrawRes.Nonce,
            },
        )
        if err != nil {
            return fmt.Errorf("could not get hash %w", err)
        }
        return nil
    })

    c.Require().NoError(err)
    c.Require().NotEmpty(txHashRes.Hash)
}

func (c *RelayerClientSuite) TestEthWithdrawCLI() {
    res, err := c.Client.Withdraw(c.GetTestContext(), &relapi.WithdrawRequest{
        ChainID:      c.underlying.originChainID,
        To:           common.HexToAddress(testWithdrawalAddress.String()),
        Amount:       "1000000000000000000",
        TokenAddress: util.EthAddress,
    })
    c.Require().NoError(err)

    // Wait for the transaction to be mined
    err = retry.WithBackoff(c.GetTestContext(), func(ctx context.Context) error {
        status, err := c.underlying.database.SubmitterDB().
            GetNonceStatus(
                ctx,
                c.underlying.wallet.Address(),
                big.NewInt(int64(c.underlying.originChainID)),
                res.Nonce,
            )
        if err != nil {
            return fmt.Errorf("could not get status %w", err)
        }

        if status != submitterdb.Stored {
            return fmt.Errorf("transaction not mined")
        }

        return nil
    })
    c.Require().NoError(err)
    c.Require().NotNil(res)
}

func (c *RelayerClientSuite) TestERC20WithdrawCLI() {
    backend := c.underlying.testBackends[uint64(c.underlying.originChainID)]

    _, erc20 := c.underlying.deployManager.GetMockERC20(c.GetTestContext(), backend)

    startBalance, err := erc20.BalanceOf(&bind.CallOpts{Context: c.GetTestContext()}, testWithdrawalAddress)
    c.Require().NoError(err)

    withdrawalAmount := big.NewInt(1000000000000000000)

    res, err := c.Client.Withdraw(c.GetTestContext(), &relapi.WithdrawRequest{
        ChainID:      c.underlying.originChainID,
        To:           common.HexToAddress(testWithdrawalAddress.String()),
        Amount:       withdrawalAmount.String(),
        TokenAddress: erc20.Address(),
    })
    c.Require().NoError(err)

    // Wait for the transaction to be mined
    err = retry.WithBackoff(c.GetTestContext(), func(ctx context.Context) error {
        balance, err := erc20.BalanceOf(&bind.CallOpts{Context: ctx}, testWithdrawalAddress)
        if err != nil {
            return fmt.Errorf("could not fetch balance %w", err)
        }

        expectedBalance := new(big.Int).Add(startBalance, withdrawalAmount)

        if balance.Cmp(expectedBalance) != 0 {
            return fmt.Errorf("balance not updated")
        }

        return nil
    })

    c.Require().NoError(err)
    c.Require().NotNil(res)
}

func (c *RelayerClientSuite) TestGetQuoteByTxID() {
    testReq := c.underlying.getTestQuoteRequest(reldb.Seen)
    err := c.underlying.database.StoreQuoteRequest(c.GetTestContext(), testReq)
    c.Require().NoError(err)

    resp, err := c.Client.GetQuoteRequestByTXID(c.GetTestContext(), hexutil.Encode(testReq.TransactionID[:]))
    c.Require().NoError(err)

    c.Equal(len(common.Hex2Bytes(resp.QuoteRequestRaw)), len(testReq.RawRequest))
}

func (c *RelayerClientSuite) TestGetQuoteByTxHash() {
    testReq := c.underlying.getTestQuoteRequest(reldb.Seen)
    err := c.underlying.database.StoreQuoteRequest(c.GetTestContext(), testReq)
    c.Require().NoError(err)

    resp, err := c.Client.GetQuoteRequestByTxHash(c.GetTestContext(), testReq.OriginTxHash.String())
    c.Require().NoError(err)

    c.Equal(len(common.Hex2Bytes(resp.QuoteRequestRaw)), len(testReq.RawRequest))
}