services/explorer/backfill/chain_test.go
package backfill_test
import (
gosql "database/sql"
"fmt"
"math/big"
scribeTypes "github.com/synapsecns/sanguine/services/scribe/types"
"github.com/synapsecns/sanguine/ethergo/mocks"
"github.com/synapsecns/sanguine/services/explorer/consumer/fetcher/tokenprice"
"github.com/synapsecns/sanguine/services/explorer/consumer/parser/tokendata"
"github.com/synapsecns/sanguine/services/explorer/static"
messageBusTypes "github.com/synapsecns/sanguine/services/explorer/types/messagebus"
"github.com/brianvoe/gofakeit/v6"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/types"
. "github.com/stretchr/testify/assert"
"github.com/synapsecns/sanguine/core"
"github.com/synapsecns/sanguine/services/explorer/backfill"
indexerConfig "github.com/synapsecns/sanguine/services/explorer/config/indexer"
"github.com/synapsecns/sanguine/services/explorer/consumer/fetcher"
"github.com/synapsecns/sanguine/services/explorer/consumer/parser"
parserpkg "github.com/synapsecns/sanguine/services/explorer/consumer/parser"
"github.com/synapsecns/sanguine/services/explorer/db/sql"
"github.com/synapsecns/sanguine/services/explorer/testutil/testcontracts"
bridgeTypes "github.com/synapsecns/sanguine/services/explorer/types/bridge"
cctpTypes "github.com/synapsecns/sanguine/services/explorer/types/cctp"
rfqTypes "github.com/synapsecns/sanguine/services/explorer/types/fastbridge"
swapTypes "github.com/synapsecns/sanguine/services/explorer/types/swap"
)
func arrayToTokenIndexMap(input []*big.Int) map[uint8]string {
output := map[uint8]string{}
for i := range input {
output[uint8(i)] = input[i].String()
}
return output
}
//nolint:maintidx
func (b *BackfillSuite) TestBackfill() {
testChainID := b.testBackend.GetBigChainID()
bridgeContract, bridgeRef := b.testDeployManager.GetTestSynapseBridge(b.GetTestContext(), b.testBackend)
bridgeV1Contract, bridgeV1Ref := b.testDeployManager.GetTestSynapseBridgeV1(b.GetTestContext(), b.testBackend)
swapContractA, swapRefA := b.testDeployManager.GetTestSwapFlashLoan(b.GetTestContext(), b.testBackend)
metaSwapContract, metaSwapRef := b.testDeployManager.GetTestMetaSwap(b.GetTestContext(), b.testBackend)
messageBusContract, messageBusRef := b.testDeployManager.GetTestMessageBusUpgradeable(b.GetTestContext(), b.testBackend)
cctpContract, cctpRef := b.testDeployManager.GetTestCCTP(b.GetTestContext(), b.testBackend)
rfqContract, rfqRef := b.testDeployManager.GetTestRFQ(b.GetTestContext(), b.testBackend)
testDeployManagerB := testcontracts.NewDeployManager(b.T())
swapContractB, swapRefB := testDeployManagerB.GetTestSwapFlashLoan(b.GetTestContext(), b.testBackend)
lastBlock := uint64(12)
transactOpts := b.testBackend.GetTxContext(b.GetTestContext(), nil)
// Initialize testing config.
contractConfigBridge := indexerConfig.ContractConfig{
ContractType: "bridge",
Address: bridgeContract.Address().String(),
StartBlock: 0,
}
contractConfigBridgeV1 := indexerConfig.ContractConfig{
ContractType: "bridge",
Address: bridgeV1Contract.Address().String(),
StartBlock: 0,
}
contractConfigSwap1 := indexerConfig.ContractConfig{
ContractType: "swap",
Address: swapContractA.Address().String(),
StartBlock: 0,
}
contractConfigSwap2 := indexerConfig.ContractConfig{
ContractType: "swap",
Address: swapContractB.Address().String(),
StartBlock: 0,
}
contractConfigMetaSwap := indexerConfig.ContractConfig{
ContractType: "metaswap",
Address: metaSwapContract.Address().String(),
StartBlock: 0,
}
contractMessageBus := indexerConfig.ContractConfig{
ContractType: "messagebus",
Address: messageBusContract.Address().String(),
StartBlock: 0,
}
// CCTP config
contractCCTP := indexerConfig.ContractConfig{
ContractType: "cctp",
Address: cctpContract.Address().String(),
StartBlock: 0,
}
// RFQ config
contractRFQ := indexerConfig.ContractConfig{
ContractType: "rfq",
Address: rfqContract.Address().String(),
StartBlock: 0,
}
// Create the chain configs
chainConfigs := []indexerConfig.ChainConfig{
{
ChainID: uint32(testChainID.Uint64()),
RPCURL: gofakeit.URL(),
FetchBlockIncrement: 2,
MaxGoroutines: 2,
Contracts: []indexerConfig.ContractConfig{contractConfigBridge, contractConfigSwap1, contractConfigSwap2, contractMessageBus, contractConfigMetaSwap, contractCCTP, contractRFQ},
},
}
chainConfigsV1 := []indexerConfig.ChainConfig{
{
ChainID: uint32(testChainID.Uint64()),
RPCURL: gofakeit.URL(),
FetchBlockIncrement: 2,
MaxGoroutines: 2,
Contracts: []indexerConfig.ContractConfig{contractConfigBridgeV1, contractConfigSwap1, contractConfigSwap2, contractMessageBus, contractConfigMetaSwap},
},
}
// Store blocktimes for testing defillama and timestamp indexing.
for i := uint64(0); i < 13; i++ {
err := b.eventDB.StoreBlockTime(b.GetTestContext(), uint32(testChainID.Uint64()), i, i)
Nil(b.T(), err)
}
// Store every bridge event.
bridgeTx, err := bridgeRef.TestDeposit(transactOpts.TransactOpts, common.BigToAddress(big.NewInt(gofakeit.Int64())), big.NewInt(int64(gofakeit.Uint32())), common.HexToAddress(testTokens[0].TokenAddress), big.NewInt(int64(gofakeit.Uint32())))
Nil(b.T(), err)
b.storeEthTx(bridgeTx, testChainID, big.NewInt(int64(2)), 1)
depositLog, err := b.storeTestLog(bridgeTx, uint32(testChainID.Uint64()), 2)
Nil(b.T(), err)
bridgeTx, err = bridgeRef.TestRedeem(transactOpts.TransactOpts, common.BigToAddress(big.NewInt(int64(gofakeit.Uint32()))), big.NewInt(int64(gofakeit.Uint32())), common.HexToAddress(testTokens[0].TokenAddress), big.NewInt(int64(gofakeit.Uint32())))
Nil(b.T(), err)
b.storeEthTx(bridgeTx, testChainID, big.NewInt(int64(2)), 2)
redeemLog, err := b.storeTestLog(bridgeTx, uint32(testChainID.Uint64()), 2)
Nil(b.T(), err)
baseNum := gofakeit.Uint32()
bridgeTx, err = bridgeRef.TestWithdraw(transactOpts.TransactOpts, common.BigToAddress(big.NewInt(gofakeit.Int64())), common.HexToAddress(testTokens[0].TokenAddress), big.NewInt(int64(baseNum)), big.NewInt(int64(float64(baseNum)*0.01)), [32]byte{byte(gofakeit.Uint64())})
Nil(b.T(), err)
b.storeEthTx(bridgeTx, testChainID, big.NewInt(int64(2)), 3)
withdrawLog, err := b.storeTestLog(bridgeTx, uint32(testChainID.Uint64()), 2)
Nil(b.T(), err)
bridgeTx, err = bridgeRef.TestMint(transactOpts.TransactOpts, common.BigToAddress(big.NewInt(gofakeit.Int64())), common.HexToAddress(testTokens[0].TokenAddress), big.NewInt(int64(gofakeit.Uint32())), big.NewInt(int64(gofakeit.Uint32())), [32]byte{byte(gofakeit.Uint64())})
Nil(b.T(), err)
b.storeEthTx(bridgeTx, testChainID, big.NewInt(int64(3)), 1)
mintLog, err := b.storeTestLog(bridgeTx, uint32(testChainID.Uint64()), 3)
Nil(b.T(), err)
bridgeTx, err = bridgeRef.TestDepositAndSwap(transactOpts.TransactOpts, common.BigToAddress(big.NewInt(gofakeit.Int64())), big.NewInt(int64(gofakeit.Uint32())), common.HexToAddress(testTokens[0].TokenAddress), big.NewInt(int64(gofakeit.Uint32())), gofakeit.Uint8(), gofakeit.Uint8(), big.NewInt(int64(gofakeit.Uint32())), big.NewInt(int64(gofakeit.Uint32())))
Nil(b.T(), err)
b.storeEthTx(bridgeTx, testChainID, big.NewInt(int64(6)), 1)
depositAndSwapLog, err := b.storeTestLog(bridgeTx, uint32(testChainID.Uint64()), 6)
Nil(b.T(), err)
bridgeTx, err = bridgeRef.TestRedeemAndSwap(transactOpts.TransactOpts, common.BigToAddress(big.NewInt(gofakeit.Int64())), big.NewInt(int64(gofakeit.Uint32())), common.HexToAddress(testTokens[0].TokenAddress), big.NewInt(int64(gofakeit.Uint32())), gofakeit.Uint8(), gofakeit.Uint8(), big.NewInt(int64(gofakeit.Uint32())), big.NewInt(int64(gofakeit.Uint32())))
Nil(b.T(), err)
b.storeEthTx(bridgeTx, testChainID, big.NewInt(int64(7)), 1)
redeemAndSwapLog, err := b.storeTestLog(bridgeTx, uint32(testChainID.Uint64()), 7)
Nil(b.T(), err)
bridgeTx, err = bridgeRef.TestRedeemAndRemove(transactOpts.TransactOpts, common.BigToAddress(big.NewInt(gofakeit.Int64())), big.NewInt(int64(gofakeit.Uint32())), common.HexToAddress(testTokens[0].TokenAddress), big.NewInt(int64(gofakeit.Uint32())), gofakeit.Uint8(), big.NewInt(int64(gofakeit.Uint32())), big.NewInt(int64(gofakeit.Uint32())))
Nil(b.T(), err)
b.storeEthTx(bridgeTx, testChainID, big.NewInt(int64(8)), 1)
redeemAndRemoveLog, err := b.storeTestLog(bridgeTx, uint32(testChainID.Uint64()), 8)
Nil(b.T(), err)
bridgeTx, err = bridgeRef.TestMintAndSwap(transactOpts.TransactOpts, common.BigToAddress(big.NewInt(gofakeit.Int64())), common.HexToAddress(testTokens[0].TokenAddress), big.NewInt(int64(gofakeit.Uint32())), big.NewInt(int64(gofakeit.Uint32())), common.BigToAddress(big.NewInt(gofakeit.Int64())), gofakeit.Uint8(), gofakeit.Uint8(), big.NewInt(int64(gofakeit.Uint32())), big.NewInt(int64(gofakeit.Uint32())), [32]byte{byte(gofakeit.Uint64())})
Nil(b.T(), err)
b.storeEthTx(bridgeTx, testChainID, big.NewInt(int64(9)), 1)
mintAndSwapLog, err := b.storeTestLog(bridgeTx, uint32(testChainID.Uint64()), 9)
Nil(b.T(), err)
bridgeTx, err = bridgeRef.TestWithdrawAndRemove(transactOpts.TransactOpts, common.BigToAddress(big.NewInt(gofakeit.Int64())), common.HexToAddress(testTokens[0].TokenAddress), big.NewInt(int64(gofakeit.Uint32())), big.NewInt(int64(gofakeit.Uint32())), common.BigToAddress(big.NewInt(gofakeit.Int64())), gofakeit.Uint8(), big.NewInt(int64(gofakeit.Uint32())), big.NewInt(int64(gofakeit.Uint32())), [32]byte{byte(gofakeit.Uint64())})
Nil(b.T(), err)
b.storeEthTx(bridgeTx, testChainID, big.NewInt(int64(10)), 1)
withdrawAndRemoveLog, err := b.storeTestLog(bridgeTx, uint32(testChainID.Uint64()), 10)
Nil(b.T(), err)
bridgeTx, err = bridgeRef.TestRedeemV2(transactOpts.TransactOpts, [32]byte{byte(gofakeit.Uint64())}, big.NewInt(int64(gofakeit.Uint32())), common.HexToAddress(testTokens[0].TokenAddress), big.NewInt(int64(gofakeit.Uint32())))
Nil(b.T(), err)
b.storeEthTx(bridgeTx, testChainID, big.NewInt(int64(11)), 1)
redeemV2Log, err := b.storeTestLog(bridgeTx, uint32(testChainID.Uint64()), 12)
Nil(b.T(), err)
// Store every bridge event using the V1 contract.
bridgeTx, err = bridgeV1Ref.TestDeposit(transactOpts.TransactOpts, common.BigToAddress(big.NewInt(gofakeit.Int64())), big.NewInt(int64(gofakeit.Uint32())), common.HexToAddress(testTokens[0].TokenAddress), big.NewInt(int64(gofakeit.Uint32())))
Nil(b.T(), err)
b.storeEthTx(bridgeTx, testChainID, big.NewInt(int64(3)), 1)
depositV1Log, err := b.storeTestLog(bridgeTx, uint32(testChainID.Uint64()), 3)
Nil(b.T(), err)
bridgeTx, err = bridgeV1Ref.TestRedeem(transactOpts.TransactOpts, common.BigToAddress(big.NewInt(int64(gofakeit.Uint32()))), big.NewInt(int64(gofakeit.Uint32())), common.HexToAddress(testTokens[0].TokenAddress), big.NewInt(int64(gofakeit.Uint32())))
Nil(b.T(), err)
b.storeEthTx(bridgeTx, testChainID, big.NewInt(int64(3)), 2)
redeemV1Log, err := b.storeTestLog(bridgeTx, uint32(testChainID.Uint64()), 3)
Nil(b.T(), err)
bridgeTx, err = bridgeV1Ref.TestWithdraw(transactOpts.TransactOpts, common.BigToAddress(big.NewInt(gofakeit.Int64())), common.HexToAddress(testTokens[0].TokenAddress), big.NewInt(int64(baseNum)), big.NewInt(int64(float64(baseNum)*0.01)), [32]byte{byte(gofakeit.Uint64())})
Nil(b.T(), err)
b.storeEthTx(bridgeTx, testChainID, big.NewInt(int64(3)), 3)
withdrawV1Log, err := b.storeTestLog(bridgeTx, uint32(testChainID.Uint64()), 3)
Nil(b.T(), err)
bridgeTx, err = bridgeV1Ref.TestDepositAndSwap(transactOpts.TransactOpts, common.BigToAddress(big.NewInt(gofakeit.Int64())), big.NewInt(int64(gofakeit.Uint32())), common.HexToAddress(testTokens[0].TokenAddress), big.NewInt(int64(gofakeit.Uint32())), gofakeit.Uint8(), gofakeit.Uint8(), big.NewInt(int64(gofakeit.Uint32())), big.NewInt(int64(gofakeit.Uint32())))
Nil(b.T(), err)
b.storeEthTx(bridgeTx, testChainID, big.NewInt(int64(7)), 1)
depositAndSwapV1Log, err := b.storeTestLog(bridgeTx, uint32(testChainID.Uint64()), 7)
Nil(b.T(), err)
bridgeTx, err = bridgeV1Ref.TestRedeemAndSwap(transactOpts.TransactOpts, common.BigToAddress(big.NewInt(gofakeit.Int64())), big.NewInt(int64(gofakeit.Uint32())), common.HexToAddress(testTokens[0].TokenAddress), big.NewInt(int64(gofakeit.Uint32())), gofakeit.Uint8(), gofakeit.Uint8(), big.NewInt(int64(gofakeit.Uint32())), big.NewInt(int64(gofakeit.Uint32())))
Nil(b.T(), err)
b.storeEthTx(bridgeTx, testChainID, big.NewInt(int64(8)), 1)
redeemAndSwapV1Log, err := b.storeTestLog(bridgeTx, uint32(testChainID.Uint64()), 8)
Nil(b.T(), err)
bridgeTx, err = bridgeV1Ref.TestRedeemAndRemove(transactOpts.TransactOpts, common.BigToAddress(big.NewInt(gofakeit.Int64())), big.NewInt(int64(gofakeit.Uint32())), common.HexToAddress(testTokens[0].TokenAddress), big.NewInt(int64(gofakeit.Uint32())), gofakeit.Uint8(), big.NewInt(int64(gofakeit.Uint32())), big.NewInt(int64(gofakeit.Uint32())))
Nil(b.T(), err)
b.storeEthTx(bridgeTx, testChainID, big.NewInt(int64(9)), 1)
redeemAndRemoveV1Log, err := b.storeTestLog(bridgeTx, uint32(testChainID.Uint64()), 9)
Nil(b.T(), err)
// Store every swap event across two different swap contracts.
swapTx, err := swapRefA.TestSwap(transactOpts.TransactOpts, common.BigToAddress(big.NewInt(gofakeit.Int64())), big.NewInt(int64(gofakeit.Uint64())), big.NewInt(int64(gofakeit.Uint64())), big.NewInt(int64(gofakeit.Uint64())), big.NewInt(int64(gofakeit.Uint64())))
Nil(b.T(), err)
b.storeEthTx(swapTx, testChainID, big.NewInt(int64(4)), 1)
swapLog, err := b.storeTestLog(swapTx, uint32(testChainID.Uint64()), 4)
Nil(b.T(), err)
swapTx, err = swapRefB.TestAddLiquidity(transactOpts.TransactOpts, common.BigToAddress(big.NewInt(gofakeit.Int64())), []*big.Int{big.NewInt(int64(gofakeit.Uint64()))}, []*big.Int{big.NewInt(int64(gofakeit.Uint64()))}, big.NewInt(int64(gofakeit.Uint64())), big.NewInt(int64(gofakeit.Uint64())))
Nil(b.T(), err)
b.storeEthTx(swapTx, testChainID, big.NewInt(int64(4)), 2)
addLiquidityLog, err := b.storeTestLog(swapTx, uint32(testChainID.Uint64()), 4)
Nil(b.T(), err)
swapTx, err = swapRefB.TestRemoveLiquidity(transactOpts.TransactOpts, common.BigToAddress(big.NewInt(gofakeit.Int64())), []*big.Int{big.NewInt(int64(gofakeit.Uint64()))}, big.NewInt(int64(gofakeit.Uint64())))
Nil(b.T(), err)
b.storeEthTx(swapTx, testChainID, big.NewInt(int64(4)), 3)
removeLiquidityLog, err := b.storeTestLog(swapTx, uint32(testChainID.Uint64()), 4)
Nil(b.T(), err)
swapTx, err = swapRefA.TestRemoveLiquidityOne(transactOpts.TransactOpts, common.BigToAddress(big.NewInt(gofakeit.Int64())), big.NewInt(int64(gofakeit.Uint64())), big.NewInt(int64(gofakeit.Uint64())), big.NewInt(int64(gofakeit.Uint64())), big.NewInt(int64(gofakeit.Uint64())))
Nil(b.T(), err)
b.storeEthTx(swapTx, testChainID, big.NewInt(int64(5)), 1)
removeLiquidityOneLog, err := b.storeTestLog(swapTx, uint32(testChainID.Uint64()), 5)
Nil(b.T(), err)
swapTx, err = swapRefA.TestRemoveLiquidityImbalance(transactOpts.TransactOpts, common.BigToAddress(big.NewInt(gofakeit.Int64())), []*big.Int{big.NewInt(int64(gofakeit.Uint64()))}, []*big.Int{big.NewInt(int64(gofakeit.Uint64()))}, big.NewInt(int64(gofakeit.Uint64())), big.NewInt(int64(gofakeit.Uint64())))
Nil(b.T(), err)
b.storeEthTx(swapTx, testChainID, big.NewInt(int64(5)), 2)
removeLiquidityImbalanceLog, err := b.storeTestLog(swapTx, uint32(testChainID.Uint64()), 5)
Nil(b.T(), err)
swapTx, err = swapRefB.TestNewAdminFee(transactOpts.TransactOpts, big.NewInt(int64(gofakeit.Uint64())))
Nil(b.T(), err)
b.storeEthTx(swapTx, testChainID, big.NewInt(int64(6)), 1)
newAdminFeeLog, err := b.storeTestLog(swapTx, uint32(testChainID.Uint64()), 6)
Nil(b.T(), err)
swapTx, err = swapRefA.TestNewSwapFee(transactOpts.TransactOpts, big.NewInt(int64(gofakeit.Uint64())))
Nil(b.T(), err)
b.storeEthTx(swapTx, testChainID, big.NewInt(int64(7)), 1)
newSwapFeeLog, err := b.storeTestLog(swapTx, uint32(testChainID.Uint64()), 7)
Nil(b.T(), err)
swapTx, err = swapRefA.TestRampA(transactOpts.TransactOpts, big.NewInt(int64(gofakeit.Uint64())), big.NewInt(int64(gofakeit.Uint64())), big.NewInt(int64(gofakeit.Uint64())), big.NewInt(int64(gofakeit.Uint64())))
Nil(b.T(), err)
b.storeEthTx(swapTx, testChainID, big.NewInt(int64(8)), 1)
rampALog, err := b.storeTestLog(swapTx, uint32(testChainID.Uint64()), 8)
Nil(b.T(), err)
swapTx, err = swapRefB.TestStopRampA(transactOpts.TransactOpts, big.NewInt(int64(gofakeit.Uint64())), big.NewInt(int64(gofakeit.Uint64())))
Nil(b.T(), err)
b.storeEthTx(swapTx, testChainID, big.NewInt(int64(8)), 1)
stopRampALog, err := b.storeTestLog(swapTx, uint32(testChainID.Uint64()), 8)
Nil(b.T(), err)
swapTx, err = swapRefA.TestFlashLoan(transactOpts.TransactOpts, common.BigToAddress(big.NewInt(gofakeit.Int64())), gofakeit.Uint8(), big.NewInt(int64(gofakeit.Uint64())), big.NewInt(int64(gofakeit.Uint64())), big.NewInt(int64(gofakeit.Uint64())))
Nil(b.T(), err)
b.storeEthTx(swapTx, testChainID, big.NewInt(int64(12)), 1)
flashLoanLog, err := b.storeTestLog(swapTx, uint32(testChainID.Uint64()), 12)
Nil(b.T(), err)
// Store metaswap swap underlying event.
metaSwapTx, err := metaSwapRef.TestSwapUnderlying(transactOpts.TransactOpts, common.BigToAddress(big.NewInt(gofakeit.Int64())), big.NewInt(int64(gofakeit.Uint64())), big.NewInt(int64(gofakeit.Uint64())), big.NewInt(int64(gofakeit.Uint64())), big.NewInt(int64(gofakeit.Uint64())))
Nil(b.T(), err)
b.storeEthTx(metaSwapTx, testChainID, big.NewInt(int64(4)), 3)
metaSwapUnderlyingLog, err := b.storeTestLog(metaSwapTx, uint32(testChainID.Uint64()), 4)
Nil(b.T(), err)
// Store every message event.
messageTx, err := messageBusRef.TestExecuted(transactOpts.TransactOpts, [32]byte{byte(gofakeit.Uint64())}, uint8(gofakeit.Number(0, 2)), common.BigToAddress(big.NewInt(gofakeit.Int64())), gofakeit.Uint64(), gofakeit.Uint64())
Nil(b.T(), err)
executedLog, err := b.storeTestLog(messageTx, uint32(testChainID.Uint64()), 5)
Nil(b.T(), err)
messageTx, err = messageBusRef.TestMessageSent(transactOpts.TransactOpts, common.BigToAddress(big.NewInt(gofakeit.Int64())), big.NewInt(int64(gofakeit.Uint32())), [32]byte{byte(gofakeit.Uint64())}, big.NewInt(int64(gofakeit.Uint32())), []byte(gofakeit.Paragraph(2, 5, 30, " ")), gofakeit.Uint64(), []byte{byte(gofakeit.Uint64())}, big.NewInt(int64(gofakeit.Uint32())), [32]byte{byte(gofakeit.Uint64())})
Nil(b.T(), err)
messageSentLog, err := b.storeTestLog(messageTx, uint32(testChainID.Uint64()), 6)
Nil(b.T(), err)
messageTx, err = messageBusRef.TestCallReverted(transactOpts.TransactOpts, gofakeit.Paragraph(2, 4, 20, " "))
Nil(b.T(), err)
callRevertedLog, err := b.storeTestLog(messageTx, uint32(testChainID.Uint64()), 7)
Nil(b.T(), err)
// Store every cctp event.
var requestID [32]byte
requestIDBytes := common.Hex2Bytes(mocks.NewMockHash(b.T()).String())
copy(requestID[:], requestIDBytes)
requestSentTx, err := cctpRef.TestSendCircleToken(transactOpts.TransactOpts, testChainID, common.BigToAddress(big.NewInt(gofakeit.Int64())), 1, common.BigToAddress(big.NewInt(gofakeit.Int64())), big.NewInt(gofakeit.Int64()), 1, []byte(gofakeit.Paragraph(2, 5, 30, " ")), requestID)
Nil(b.T(), err)
b.storeEthTx(requestSentTx, testChainID, big.NewInt(int64(5)), 5)
requestSentLog, err := b.storeTestLog(requestSentTx, uint32(testChainID.Uint64()), 5)
Nil(b.T(), err)
requestFulfilledTx, err := cctpRef.TestReceiveCircleToken(transactOpts.TransactOpts, uint32(testChainID.Int64()), common.BigToAddress(big.NewInt(gofakeit.Int64())), common.BigToAddress(big.NewInt(gofakeit.Int64())), big.NewInt(gofakeit.Int64()), common.BigToAddress(big.NewInt(gofakeit.Int64())), big.NewInt(gofakeit.Int64()), requestID)
Nil(b.T(), err)
b.storeEthTx(requestFulfilledTx, testChainID, big.NewInt(int64(6)), 6)
requestFulfilledLog, err := b.storeTestLog(requestFulfilledTx, uint32(testChainID.Uint64()), 6)
Nil(b.T(), err)
// Store every rfq event
var transactionID [32]byte
transactionIDBytes := common.Hex2Bytes(mocks.NewMockHash(b.T()).String()) // Replace "your_hex_value_here" with an actual hex value if needed
copy(transactionID[:], transactionIDBytes)
bridgeRequestedTx, err := rfqRef.TestBridge(transactOpts.TransactOpts, uint32(testChainID.Uint64()), common.BigToAddress(big.NewInt(gofakeit.Int64())), common.BigToAddress(big.NewInt(gofakeit.Int64())), common.BigToAddress(big.NewInt(gofakeit.Int64())), common.BigToAddress(big.NewInt(gofakeit.Int64())), big.NewInt(gofakeit.Int64()), big.NewInt(gofakeit.Int64()), gofakeit.Bool())
Nil(b.T(), err)
b.storeEthTx(bridgeRequestedTx, testChainID, big.NewInt(int64(5)), 5)
bridgeRequestedLog, err := b.storeTestLog(bridgeRequestedTx, uint32(testChainID.Uint64()), 5)
Nil(b.T(), err)
bridgeRelayedTx, err := rfqRef.TestRelay(transactOpts.TransactOpts, transactionID, common.BigToAddress(big.NewInt(gofakeit.Int64())), common.BigToAddress(big.NewInt(gofakeit.Int64())), uint32(testChainID.Uint64()), common.BigToAddress(big.NewInt(gofakeit.Int64())), common.BigToAddress(big.NewInt(gofakeit.Int64())), big.NewInt(gofakeit.Int64()), big.NewInt(gofakeit.Int64()), big.NewInt(gofakeit.Int64()))
Nil(b.T(), err)
b.storeEthTx(bridgeRelayedTx, testChainID, big.NewInt(int64(5)), 5)
bridgeRelayedLog, err := b.storeTestLog(bridgeRelayedTx, uint32(testChainID.Uint64()), 5)
Nil(b.T(), err)
// Go through each contract and save the end height in scribe
for i := range chainConfigs[0].Contracts {
// the last block store per contract
err = b.eventDB.StoreLastIndexed(b.GetTestContext(), common.HexToAddress(chainConfigs[0].Contracts[i].Address), uint32(testChainID.Uint64()), lastBlock, scribeTypes.IndexingConfirmed)
Nil(b.T(), err)
}
for i := range chainConfigsV1[0].Contracts {
// the last block store per contract
err = b.eventDB.StoreLastIndexed(b.GetTestContext(), common.HexToAddress(chainConfigsV1[0].Contracts[i].Address), uint32(testChainID.Uint64()), lastBlock, scribeTypes.IndexingConfirmed)
Nil(b.T(), err)
}
// Set up a ChainBackfiller
bcf, err := fetcher.NewBridgeConfigFetcher(b.bridgeConfigContract.Address(), b.bridgeConfigContract)
Nil(b.T(), err)
tokenSymbolToIDs, err := parser.ParseYaml(static.GetTokenSymbolToTokenIDConfig())
Nil(b.T(), err)
tokenDataService, err := tokendata.NewTokenDataService(bcf, tokenSymbolToIDs)
Nil(b.T(), err)
tokenPriceService, err := tokenprice.NewPriceDataService()
Nil(b.T(), err)
bp, err := parser.NewBridgeParser(b.db, bridgeContract.Address(), tokenDataService, b.consumerFetcher, tokenPriceService, false)
Nil(b.T(), err)
bpv1, err := parser.NewBridgeParser(b.db, bridgeV1Contract.Address(), tokenDataService, b.consumerFetcher, tokenPriceService, false)
Nil(b.T(), err)
// srB is the swap ref for getting token data
srA, err := fetcher.NewSwapFetcher(swapContractA.Address(), b.testBackend, false)
Nil(b.T(), err)
spA, err := parser.NewSwapParser(b.db, swapContractA.Address(), false, b.consumerFetcher, srA, tokenDataService, tokenPriceService)
Nil(b.T(), err)
// srB is the swap ref for getting token data
srB, err := fetcher.NewSwapFetcher(swapContractB.Address(), b.testBackend, false)
Nil(b.T(), err)
spB, err := parser.NewSwapParser(b.db, swapContractB.Address(), false, b.consumerFetcher, srB, tokenDataService, tokenPriceService)
Nil(b.T(), err)
// msr is the meta swap ref for getting token data
msr, err := fetcher.NewSwapFetcher(metaSwapContract.Address(), b.testBackend, true)
Nil(b.T(), err)
msp, err := parser.NewSwapParser(b.db, metaSwapContract.Address(), true, b.consumerFetcher, msr, tokenDataService, tokenPriceService)
Nil(b.T(), err)
// cr is the cctp ref for getting token data
cr, err := fetcher.NewCCTPFetcher(cctpRef.Address(), b.testBackend)
Nil(b.T(), err)
cp, err := parser.NewCCTPParser(b.db, cctpRef.Address(), b.consumerFetcher, cr, tokenDataService, tokenPriceService, false)
Nil(b.T(), err)
// pr is the rfq ref for getting token data
pr, err := fetcher.NewRFQFetcher(rfqRef.Address(), b.testBackend)
Nil(b.T(), err)
pp, err := parser.NewRFQParser(b.db, rfqRef.Address(), b.consumerFetcher, pr, tokenDataService, tokenPriceService, false)
Nil(b.T(), err)
spMap := map[common.Address]*parser.SwapParser{}
spMap[swapContractA.Address()] = spA
spMap[swapContractB.Address()] = spB
spMap[metaSwapContract.Address()] = msp
f := fetcher.NewFetcher(b.gqlClient, b.metrics)
// Set up message bus parser
mbp, err := parser.NewMessageBusParser(b.db, messageBusContract.Address(), b.consumerFetcher, tokenPriceService)
Nil(b.T(), err)
// Test the first chain in the config file
chainBackfiller := backfill.NewChainBackfiller(b.db, bp, spMap, mbp, cp, pp, f, chainConfigs[0])
chainBackfillerV1 := backfill.NewChainBackfiller(b.db, bpv1, spMap, mbp, cp, pp, f, chainConfigsV1[0])
// Backfill the blocks
var count int64
err = chainBackfiller.Backfill(b.GetTestContext(), false, 1)
Nil(b.T(), err)
swapEvents := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Find(&sql.SwapEvent{}).Count(&count)
Nil(b.T(), swapEvents.Error)
Equal(b.T(), int64(11), count)
bridgeEvents := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Find(&sql.BridgeEvent{}).Count(&count)
Nil(b.T(), bridgeEvents.Error)
Equal(b.T(), int64(14), count) // 10 + 2 cctp events + 2 rfq events
messageEvents := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Find(&sql.MessageBusEvent{}).Count(&count)
Nil(b.T(), messageEvents.Error)
Equal(b.T(), int64(3), count)
cctpEvents := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Find(&sql.CCTPEvent{}).Count(&count)
Nil(b.T(), cctpEvents.Error)
Equal(b.T(), int64(2), count)
rfqEvents := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Find(&sql.RFQEvent{}).Count(&count)
Nil(b.T(), rfqEvents.Error)
Equal(b.T(), int64(2), count)
// Test cctp parity
err = b.sendCircleTokenParity(requestSentLog, cp)
Nil(b.T(), err)
err = b.receiveCircleTokenParity(requestFulfilledLog, cp)
Nil(b.T(), err)
// Test rfq parity
err = b.rfqRequestedTokenParity(bridgeRequestedLog, pp)
Nil(b.T(), err)
err = b.rfqRelayedTokenParity(bridgeRelayedLog, pp)
Nil(b.T(), err)
// Test bridge parity
err = b.depositParity(depositLog, bp, uint32(testChainID.Uint64()), false)
Nil(b.T(), err)
err = b.redeemParity(redeemLog, bp, uint32(testChainID.Uint64()), false)
Nil(b.T(), err)
err = b.withdrawParity(withdrawLog, bp, uint32(testChainID.Uint64()), false)
Nil(b.T(), err)
err = b.mintParity(mintLog, bp, uint32(testChainID.Uint64()), false)
Nil(b.T(), err)
err = b.depositAndSwapParity(depositAndSwapLog, bp, uint32(testChainID.Uint64()), false)
Nil(b.T(), err)
err = b.redeemAndSwapParity(redeemAndSwapLog, bp, uint32(testChainID.Uint64()), false)
Nil(b.T(), err)
err = b.redeemAndRemoveParity(redeemAndRemoveLog, bp, uint32(testChainID.Uint64()), false)
Nil(b.T(), err)
err = b.mintAndSwapParity(mintAndSwapLog, bp, uint32(testChainID.Uint64()), false)
Nil(b.T(), err)
err = b.withdrawAndRemoveParity(withdrawAndRemoveLog, bp, uint32(testChainID.Uint64()), false)
Nil(b.T(), err)
err = b.redeemV2Parity(redeemV2Log, bp, uint32(testChainID.Uint64()))
Nil(b.T(), err)
// Test swap parity
err = b.swapParity(swapLog, spA, uint32(testChainID.Uint64()))
Nil(b.T(), err)
err = b.addLiquidityParity(addLiquidityLog, spB, uint32(testChainID.Uint64()))
Nil(b.T(), err)
err = b.removeLiquidityParity(removeLiquidityLog, spB, uint32(testChainID.Uint64()))
Nil(b.T(), err)
err = b.removeLiquidityOneParity(removeLiquidityOneLog, spA, uint32(testChainID.Uint64()))
Nil(b.T(), err)
err = b.removeLiquidityImbalanceParity(removeLiquidityImbalanceLog, spA, uint32(testChainID.Uint64()))
Nil(b.T(), err)
err = b.newAdminFeeParity(newAdminFeeLog, spB, uint32(testChainID.Uint64()))
Nil(b.T(), err)
err = b.newSwapFeeParity(newSwapFeeLog, spA, uint32(testChainID.Uint64()))
Nil(b.T(), err)
err = b.rampAParity(rampALog, spA, uint32(testChainID.Uint64()))
Nil(b.T(), err)
err = b.stopRampAParity(stopRampALog, spB, uint32(testChainID.Uint64()))
Nil(b.T(), err)
err = b.flashLoanParity(flashLoanLog, spA, uint32(testChainID.Uint64()))
Nil(b.T(), err)
// Test meta swap parity
err = b.metaSwapUnderlyingParity(metaSwapUnderlyingLog, msp, uint32(testChainID.Uint64()))
Nil(b.T(), err)
// Test message parity
err = b.executedParity(executedLog, mbp, uint32(testChainID.Uint64()))
Nil(b.T(), err)
err = b.messageSentParity(messageSentLog, mbp, uint32(testChainID.Uint64()))
Nil(b.T(), err)
err = b.callRevertedParity(callRevertedLog, mbp, uint32(testChainID.Uint64()))
Nil(b.T(), err)
// Test bridge v1 parity
err = chainBackfillerV1.Backfill(b.GetTestContext(), false, 1)
Nil(b.T(), err)
err = b.depositParity(depositV1Log, bpv1, uint32(testChainID.Uint64()), true)
Nil(b.T(), err)
err = b.redeemParity(redeemV1Log, bpv1, uint32(testChainID.Uint64()), true)
Nil(b.T(), err)
err = b.withdrawParity(withdrawV1Log, bpv1, uint32(testChainID.Uint64()), true)
Nil(b.T(), err)
err = b.depositAndSwapParity(depositAndSwapV1Log, bpv1, uint32(testChainID.Uint64()), true)
Nil(b.T(), err)
err = b.redeemAndSwapParity(redeemAndSwapV1Log, bpv1, uint32(testChainID.Uint64()), true)
Nil(b.T(), err)
err = b.redeemAndRemoveParity(redeemAndRemoveV1Log, bpv1, uint32(testChainID.Uint64()), true)
Nil(b.T(), err)
bridgeEvents = b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Find(&sql.BridgeEvent{}).Count(&count)
Nil(b.T(), bridgeEvents.Error)
Equal(b.T(), int64(20), count) // 16 + 2 cctp events + 2 rfq events
lastBlockStored, err := b.db.GetLastStoredBlock(b.GetTestContext(), uint32(testChainID.Uint64()), chainConfigsV1[0].Contracts[0].Address)
Nil(b.T(), err)
Equal(b.T(), lastBlock, lastBlockStored)
}
// storeTestLogs stores the test logs in the database.
func (b *BackfillSuite) storeTestLog(tx *types.Transaction, chainID uint32, blockNumber uint64) (*types.Log, error) {
b.testBackend.WaitForConfirmation(b.GetTestContext(), tx)
receipt, err := b.testBackend.TransactionReceipt(b.GetTestContext(), tx.Hash())
if err != nil {
return nil, fmt.Errorf("failed to get receipt for transaction %s: %w", tx.Hash().String(), err)
}
receipt.Logs[0].BlockNumber = blockNumber
err = b.eventDB.StoreLogs(b.GetTestContext(), chainID, *receipt.Logs[0])
if err != nil {
return nil, fmt.Errorf("error storing swap log: %w", err)
}
return receipt.Logs[0], nil
}
//nolint:dupl
func (b *BackfillSuite) sendCircleTokenParity(log *types.Log, parser *parser.CCTPParser) error {
// parse the log
parsedLog, err := parser.Filterer.ParseCircleRequestSent(*log)
_ = parsedLog
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
var count int64
sender := gosql.NullString{
String: parsedLog.Sender.String(),
Valid: true,
}
nonce := gosql.NullInt64{
Int64: int64(parsedLog.Nonce),
Valid: true,
}
requestVersion := gosql.NullInt32{
Int32: int32(parsedLog.RequestVersion),
Valid: true,
}
formattedRequest := gosql.NullString{
String: common.Bytes2Hex(parsedLog.FormattedRequest),
Valid: true,
}
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.CCTPEvent{}).
Where(&sql.CCTPEvent{
ContractAddress: log.Address.String(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
EventType: cctpTypes.CircleRequestSentEvent.Int(),
RequestID: common.Bytes2Hex(parsedLog.RequestID[:]),
DestinationChainID: parsedLog.ChainId,
Sender: sender,
Nonce: nonce,
Token: parsedLog.Token.String(),
Amount: parsedLog.Amount,
RequestVersion: requestVersion,
FormattedRequest: formattedRequest,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
//nolint:dupl
func (b *BackfillSuite) receiveCircleTokenParity(log *types.Log, parser *parser.CCTPParser) error {
// parse the log
parsedLog, err := parser.Filterer.ParseCircleRequestFulfilled(*log)
_ = parsedLog
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
var count int64
mintToken := gosql.NullString{
String: parsedLog.MintToken.String(),
Valid: true,
}
recipient := gosql.NullString{
String: parsedLog.Recipient.String(),
Valid: true,
}
domainToChain := []int64{1, 43114, 10, 42161}
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.CCTPEvent{}).
Where(&sql.CCTPEvent{
ContractAddress: log.Address.String(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
EventType: cctpTypes.CircleRequestFulfilledEvent.Int(),
RequestID: common.Bytes2Hex(parsedLog.RequestID[:]),
OriginChainID: big.NewInt(domainToChain[parsedLog.OriginDomain]),
MintToken: mintToken,
Amount: parsedLog.Amount,
Recipient: recipient,
Fee: parsedLog.Fee,
Token: parsedLog.Token.String(),
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
//nolint:dupl
func (b *BackfillSuite) rfqRequestedTokenParity(log *types.Log, parser *parser.RFQParser) error {
// parse the log
parsedLog, err := parser.Filterer.ParseBridgeRequested(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
var count int64
requester := gosql.NullString{
String: parsedLog.Sender.String(),
Valid: true,
}
// Hot fix for chainGas.
var chainGas uint8
if parsedLog.SendChainGas {
chainGas = 1
} else {
chainGas = 0
}
// Assuming other relevant fields from the parsed log
// and constructing the query accordingly
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.RFQEvent{}).
Where(&sql.RFQEvent{
ContractAddress: log.Address.String(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
EventType: rfqTypes.BridgeRequestedEvent.Int(),
TransactionID: common.Bytes2Hex(parsedLog.TransactionId[:]),
DestinationChainID: big.NewInt(int64(parsedLog.DestChainId)),
OriginToken: parsedLog.OriginToken.String(),
DestinationToken: parsedLog.DestToken.String(),
OriginAmount: parsedLog.OriginAmount,
DestinationAmount: parsedLog.DestAmount,
ChainGas: chainGas,
Sender: requester,
// Add other fields from parsedLog as needed
}).Count(&count)
query := b.db.UNSAFE_DB().Dialector.Explain(events.Statement.SQL.String(), events.Statement.Vars...)
fmt.Printf("send query: %v\n", query)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
//nolint:dupl
func (b *BackfillSuite) rfqRelayedTokenParity(log *types.Log, parser *parser.RFQParser) error {
// parse the log
parsedLog, err := parser.Filterer.ParseBridgeRelayed(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
var count int64
relayer := gosql.NullString{
String: parsedLog.Relayer.String(),
Valid: true,
}
recipient := gosql.NullString{
String: parsedLog.To.String(),
Valid: true,
}
// Assuming other relevant fields from the parsed log
// and constructing the query accordingly
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.RFQEvent{}).
Where(&sql.RFQEvent{
ContractAddress: log.Address.String(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
EventType: rfqTypes.BridgeRelayedEvent.Int(),
TransactionID: common.Bytes2Hex(parsedLog.TransactionId[:]),
Relayer: relayer,
Recipient: recipient,
OriginChainID: big.NewInt(int64(parsedLog.OriginChainId)),
OriginToken: parsedLog.OriginToken.String(),
DestinationToken: parsedLog.DestToken.String(),
OriginAmount: parsedLog.OriginAmount,
DestinationAmount: parsedLog.DestAmount,
ChainGasAmount: parsedLog.ChainGasAmount,
// Add other fields from parsedLog as needed
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
//nolint:dupl
func (b *BackfillSuite) depositParity(log *types.Log, parser *parser.BridgeParser, chainID uint32, useV1 bool) error {
// parse the log
if useV1 {
parsedLog, err := parser.FiltererV1.ParseTokenDeposit(*log)
_ = parsedLog
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
recipient := gosql.NullString{
String: parsedLog.To.String(),
Valid: true,
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.BridgeEvent{}).
Where(&sql.BridgeEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: bridgeTypes.DepositEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Token: parsedLog.Token.String(),
Amount: parsedLog.Amount,
Recipient: recipient,
DestinationChainID: parsedLog.ChainId,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
parsedLog, err := parser.Filterer.ParseTokenDeposit(*log)
_ = parsedLog
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
recipient := gosql.NullString{
String: parsedLog.To.String(),
Valid: true,
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.BridgeEvent{}).
Where(&sql.BridgeEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: bridgeTypes.DepositEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Token: parsedLog.Token.String(),
Amount: parsedLog.Amount,
Recipient: recipient,
DestinationChainID: parsedLog.ChainId,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
//nolint:dupl
func (b *BackfillSuite) redeemParity(log *types.Log, parser *parser.BridgeParser, chainID uint32, useV1 bool) error {
// parse the log
if useV1 {
parsedLog, err := parser.FiltererV1.ParseTokenRedeem(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
recipient := gosql.NullString{
String: parsedLog.To.String(),
Valid: true,
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.BridgeEvent{}).
Where(&sql.BridgeEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: bridgeTypes.RedeemEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Token: parsedLog.Token.String(),
Amount: parsedLog.Amount,
Recipient: recipient,
DestinationChainID: parsedLog.ChainId,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
parsedLog, err := parser.Filterer.ParseTokenRedeem(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
recipient := gosql.NullString{
String: parsedLog.To.String(),
Valid: true,
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.BridgeEvent{}).
Where(&sql.BridgeEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: bridgeTypes.RedeemEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Token: parsedLog.Token.String(),
Amount: parsedLog.Amount,
Recipient: recipient,
DestinationChainID: parsedLog.ChainId,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
//nolint:dupl
func (b *BackfillSuite) withdrawParity(log *types.Log, parser *parser.BridgeParser, chainID uint32, useV1 bool) error {
// parse the log
if useV1 {
parsedLog, err := parser.FiltererV1.ParseTokenWithdraw(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
recipient := gosql.NullString{
String: parsedLog.To.String(),
Valid: true,
}
kappa := gosql.NullString{
String: common.Bytes2Hex(parsedLog.Kappa[:]),
Valid: true,
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.BridgeEvent{}).
Where(&sql.BridgeEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: bridgeTypes.WithdrawEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Token: parsedLog.Token.String(),
Amount: new(big.Int).Sub(parsedLog.Amount, parsedLog.Fee),
Recipient: recipient,
Fee: parsedLog.Fee,
Kappa: kappa,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
parsedLog, err := parser.Filterer.ParseTokenWithdraw(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
recipient := gosql.NullString{
String: parsedLog.To.String(),
Valid: true,
}
kappa := gosql.NullString{
String: common.Bytes2Hex(parsedLog.Kappa[:]),
Valid: true,
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.BridgeEvent{}).
Where(&sql.BridgeEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: bridgeTypes.WithdrawEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Token: parsedLog.Token.String(),
Amount: new(big.Int).Sub(parsedLog.Amount, parsedLog.Fee),
Recipient: recipient,
Fee: parsedLog.Fee,
Kappa: kappa,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
//nolint:dupl
func (b *BackfillSuite) mintParity(log *types.Log, parser *parser.BridgeParser, chainID uint32, useV1 bool) error {
// parse the log
if useV1 {
parsedLog, err := parser.Filterer.ParseTokenMint(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
recipient := gosql.NullString{
String: parsedLog.To.String(),
Valid: true,
}
kappa := gosql.NullString{
String: common.Bytes2Hex(parsedLog.Kappa[:]),
Valid: true,
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.BridgeEvent{}).
Where(&sql.BridgeEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: bridgeTypes.MintEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Token: parsedLog.Token.String(),
Amount: parsedLog.Amount,
Recipient: recipient,
Fee: parsedLog.Fee,
Kappa: kappa,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
parsedLog, err := parser.Filterer.ParseTokenMint(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
recipient := gosql.NullString{
String: parsedLog.To.String(),
Valid: true,
}
kappa := gosql.NullString{
String: common.Bytes2Hex(parsedLog.Kappa[:]),
Valid: true,
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.BridgeEvent{}).
Where(&sql.BridgeEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: bridgeTypes.MintEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Token: parsedLog.Token.String(),
Amount: parsedLog.Amount,
Recipient: recipient,
Fee: parsedLog.Fee,
Kappa: kappa,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
//nolint:dupl
func (b *BackfillSuite) depositAndSwapParity(log *types.Log, parser *parser.BridgeParser, chainID uint32, useV1 bool) error {
// parse the log
if useV1 {
parsedLog, err := parser.Filterer.ParseTokenDepositAndSwap(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
recipient := gosql.NullString{
String: parsedLog.To.String(),
Valid: true,
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.BridgeEvent{}).
Where(&sql.BridgeEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: bridgeTypes.DepositAndSwapEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Token: parsedLog.Token.String(),
Amount: parsedLog.Amount,
Recipient: recipient,
TokenIndexFrom: big.NewInt(int64(parsedLog.TokenIndexFrom)),
TokenIndexTo: big.NewInt(int64(parsedLog.TokenIndexTo)),
MinDy: parsedLog.MinDy,
Deadline: parsedLog.Deadline,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
parsedLog, err := parser.Filterer.ParseTokenDepositAndSwap(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
recipient := gosql.NullString{
String: parsedLog.To.String(),
Valid: true,
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.BridgeEvent{}).
Where(&sql.BridgeEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: bridgeTypes.DepositAndSwapEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Token: parsedLog.Token.String(),
Amount: parsedLog.Amount,
Recipient: recipient,
TokenIndexFrom: big.NewInt(int64(parsedLog.TokenIndexFrom)),
TokenIndexTo: big.NewInt(int64(parsedLog.TokenIndexTo)),
MinDy: parsedLog.MinDy,
Deadline: parsedLog.Deadline,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
//nolint:dupl
func (b *BackfillSuite) redeemAndSwapParity(log *types.Log, parser *parser.BridgeParser, chainID uint32, useV1 bool) error {
// parse the log
if useV1 {
parsedLog, err := parser.Filterer.ParseTokenRedeemAndSwap(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
recipient := gosql.NullString{
String: parsedLog.To.String(),
Valid: true,
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.BridgeEvent{}).
Where(&sql.BridgeEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: bridgeTypes.RedeemAndSwapEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Token: parsedLog.Token.String(),
Amount: parsedLog.Amount,
Recipient: recipient,
TokenIndexFrom: big.NewInt(int64(parsedLog.TokenIndexFrom)),
TokenIndexTo: big.NewInt(int64(parsedLog.TokenIndexTo)),
MinDy: parsedLog.MinDy,
Deadline: parsedLog.Deadline,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
parsedLog, err := parser.Filterer.ParseTokenRedeemAndSwap(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
recipient := gosql.NullString{
String: parsedLog.To.String(),
Valid: true,
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.BridgeEvent{}).
Where(&sql.BridgeEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: bridgeTypes.RedeemAndSwapEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Token: parsedLog.Token.String(),
Amount: parsedLog.Amount,
Recipient: recipient,
TokenIndexFrom: big.NewInt(int64(parsedLog.TokenIndexFrom)),
TokenIndexTo: big.NewInt(int64(parsedLog.TokenIndexTo)),
MinDy: parsedLog.MinDy,
Deadline: parsedLog.Deadline,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
//nolint:dupl
func (b *BackfillSuite) redeemAndRemoveParity(log *types.Log, parser *parser.BridgeParser, chainID uint32, useV1 bool) error {
// parse the log
if useV1 {
parsedLog, err := parser.Filterer.ParseTokenRedeemAndRemove(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
recipient := gosql.NullString{
String: parsedLog.To.String(),
Valid: true,
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.BridgeEvent{}).
Where(&sql.BridgeEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: bridgeTypes.RedeemAndRemoveEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Token: parsedLog.Token.String(),
Amount: parsedLog.Amount,
Recipient: recipient,
SwapTokenIndex: big.NewInt(int64(parsedLog.SwapTokenIndex)),
SwapMinAmount: parsedLog.SwapMinAmount,
SwapDeadline: parsedLog.SwapDeadline,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
parsedLog, err := parser.Filterer.ParseTokenRedeemAndRemove(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
recipient := gosql.NullString{
String: parsedLog.To.String(),
Valid: true,
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.BridgeEvent{}).
Where(&sql.BridgeEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: bridgeTypes.RedeemAndRemoveEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Token: parsedLog.Token.String(),
Amount: parsedLog.Amount,
Recipient: recipient,
SwapTokenIndex: big.NewInt(int64(parsedLog.SwapTokenIndex)),
SwapMinAmount: parsedLog.SwapMinAmount,
SwapDeadline: parsedLog.SwapDeadline,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
//nolint:dupl
func (b *BackfillSuite) mintAndSwapParity(log *types.Log, parser *parser.BridgeParser, chainID uint32, useV1 bool) error {
// parse the log
if useV1 {
parsedLog, err := parser.Filterer.ParseTokenMintAndSwap(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
recipient := gosql.NullString{
String: parsedLog.To.String(),
Valid: true,
}
kappa := gosql.NullString{
String: common.Bytes2Hex(parsedLog.Kappa[:]),
Valid: true,
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.BridgeEvent{}).
Where(&sql.BridgeEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: bridgeTypes.MintAndSwapEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Token: parsedLog.Token.String(),
Amount: parsedLog.Amount,
Recipient: recipient,
Fee: parsedLog.Fee,
TokenIndexFrom: big.NewInt(int64(parsedLog.TokenIndexFrom)),
TokenIndexTo: big.NewInt(int64(parsedLog.TokenIndexTo)),
MinDy: parsedLog.MinDy,
Deadline: parsedLog.Deadline,
SwapSuccess: big.NewInt(int64(*parserpkg.BoolToUint8(&parsedLog.SwapSuccess))),
Kappa: kappa,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
parsedLog, err := parser.Filterer.ParseTokenMintAndSwap(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
recipient := gosql.NullString{
String: parsedLog.To.String(),
Valid: true,
}
kappa := gosql.NullString{
String: common.Bytes2Hex(parsedLog.Kappa[:]),
Valid: true,
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.BridgeEvent{}).
Where(&sql.BridgeEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: bridgeTypes.MintAndSwapEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Token: parsedLog.Token.String(),
Amount: parsedLog.Amount,
Recipient: recipient,
Fee: parsedLog.Fee,
TokenIndexFrom: big.NewInt(int64(parsedLog.TokenIndexFrom)),
TokenIndexTo: big.NewInt(int64(parsedLog.TokenIndexTo)),
MinDy: parsedLog.MinDy,
Deadline: parsedLog.Deadline,
SwapSuccess: big.NewInt(int64(*parserpkg.BoolToUint8(&parsedLog.SwapSuccess))),
Kappa: kappa,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
//nolint:dupl
func (b *BackfillSuite) withdrawAndRemoveParity(log *types.Log, parser *parser.BridgeParser, chainID uint32, useV1 bool) error {
// parse the log
if useV1 {
parsedLog, err := parser.Filterer.ParseTokenWithdrawAndRemove(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
recipient := gosql.NullString{
String: parsedLog.To.String(),
Valid: true,
}
kappa := gosql.NullString{
String: common.Bytes2Hex(parsedLog.Kappa[:]),
Valid: true,
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.BridgeEvent{}).
Where(&sql.BridgeEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: bridgeTypes.WithdrawAndRemoveEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Token: parsedLog.Token.String(),
Amount: parsedLog.Amount,
Recipient: recipient,
SwapTokenIndex: big.NewInt(int64(parsedLog.SwapTokenIndex)),
SwapMinAmount: parsedLog.SwapMinAmount,
SwapDeadline: parsedLog.SwapDeadline,
SwapSuccess: big.NewInt(int64(*parserpkg.BoolToUint8(&parsedLog.SwapSuccess))),
Kappa: kappa,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
parsedLog, err := parser.Filterer.ParseTokenWithdrawAndRemove(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
recipient := gosql.NullString{
String: parsedLog.To.String(),
Valid: true,
}
kappa := gosql.NullString{
String: common.Bytes2Hex(parsedLog.Kappa[:]),
Valid: true,
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.BridgeEvent{}).
Where(&sql.BridgeEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: bridgeTypes.WithdrawAndRemoveEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Token: parsedLog.Token.String(),
Amount: parsedLog.Amount,
Recipient: recipient,
SwapTokenIndex: big.NewInt(int64(parsedLog.SwapTokenIndex)),
SwapMinAmount: parsedLog.SwapMinAmount,
SwapDeadline: parsedLog.SwapDeadline,
SwapSuccess: big.NewInt(int64(*parserpkg.BoolToUint8(&parsedLog.SwapSuccess))),
Kappa: kappa,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
//nolint:dupl
func (b *BackfillSuite) redeemV2Parity(log *types.Log, parser *parser.BridgeParser, chainID uint32) error {
// parse the log
parsedLog, err := parser.Filterer.ParseTokenRedeemV2(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
recipientBytes := gosql.NullString{
String: common.Bytes2Hex(parsedLog.To[:]),
Valid: true,
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.BridgeEvent{}).
Where(&sql.BridgeEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: bridgeTypes.RedeemV2Event.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Token: parsedLog.Token.String(),
Amount: parsedLog.Amount,
RecipientBytes: recipientBytes,
DestinationChainID: parsedLog.ChainId,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
//nolint:dupl
func (b *BackfillSuite) swapParity(log *types.Log, parser *parser.SwapParser, chainID uint32) error {
// parse the log
parsedLog, err := parser.Filterer.ParseTokenSwap(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
buyer := gosql.NullString{
String: parsedLog.Buyer.String(),
Valid: true,
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.SwapEvent{}).
Where(&sql.SwapEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: swapTypes.TokenSwapEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Buyer: buyer,
TokensSold: parsedLog.TokensSold,
TokensBought: parsedLog.TokensBought,
SoldID: parsedLog.SoldId,
BoughtID: parsedLog.BoughtId,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
//nolint:dupl
func (b *BackfillSuite) addLiquidityParity(log *types.Log, parser *parser.SwapParser, chainID uint32) error {
// parse the log
parsedLog, err := parser.Filterer.ParseAddLiquidity(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
provider := gosql.NullString{
String: parsedLog.Provider.String(),
Valid: true,
}
var storedLog sql.SwapEvent
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.SwapEvent{}).
Where(&sql.SwapEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: swapTypes.AddLiquidityEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Provider: provider,
Invariant: parsedLog.Invariant,
LPTokenSupply: parsedLog.LpTokenSupply,
}).
Find(&storedLog).
Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
Equal(b.T(), arrayToTokenIndexMap(parsedLog.TokenAmounts), storedLog.Amount)
Equal(b.T(), arrayToTokenIndexMap(parsedLog.Fees), storedLog.Fee)
return nil
}
//nolint:dupl
func (b *BackfillSuite) removeLiquidityParity(log *types.Log, parser *parser.SwapParser, chainID uint32) error {
// parse the log
parsedLog, err := parser.Filterer.ParseRemoveLiquidity(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
provider := gosql.NullString{
String: parsedLog.Provider.String(),
Valid: true,
}
arrayToTokenIndexMap(parsedLog.TokenAmounts)
var storedLog sql.SwapEvent
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.SwapEvent{}).
Where(&sql.SwapEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: swapTypes.RemoveLiquidityEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Provider: provider,
LPTokenSupply: parsedLog.LpTokenSupply,
}).
Find(&storedLog).
Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
Equal(b.T(), arrayToTokenIndexMap(parsedLog.TokenAmounts), storedLog.Amount)
return nil
}
//nolint:dupl
func (b *BackfillSuite) removeLiquidityOneParity(log *types.Log, parser *parser.SwapParser, chainID uint32) error {
// parse the log
parsedLog, err := parser.Filterer.ParseRemoveLiquidityOne(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
provider := gosql.NullString{
String: parsedLog.Provider.String(),
Valid: true,
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.SwapEvent{}).
Where(&sql.SwapEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: swapTypes.RemoveLiquidityOneEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Provider: provider,
LPTokenAmount: parsedLog.LpTokenAmount,
LPTokenSupply: parsedLog.LpTokenSupply,
BoughtID: parsedLog.BoughtId,
TokensBought: parsedLog.TokensBought,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
//nolint:dupl
func (b *BackfillSuite) removeLiquidityImbalanceParity(log *types.Log, parser *parser.SwapParser, chainID uint32) error {
// parse the log
parsedLog, err := parser.Filterer.ParseRemoveLiquidityImbalance(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
provider := gosql.NullString{
String: parsedLog.Provider.String(),
Valid: true,
}
var storedLog sql.SwapEvent
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.SwapEvent{}).
Where(&sql.SwapEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: swapTypes.RemoveLiquidityImbalanceEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Provider: provider,
Invariant: parsedLog.Invariant,
LPTokenSupply: parsedLog.LpTokenSupply,
}).
Find(&storedLog).
Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
Equal(b.T(), arrayToTokenIndexMap(parsedLog.TokenAmounts), storedLog.Amount)
Equal(b.T(), arrayToTokenIndexMap(parsedLog.Fees), storedLog.Fee)
return nil
}
//nolint:dupl
func (b *BackfillSuite) newAdminFeeParity(log *types.Log, parser *parser.SwapParser, chainID uint32) error {
// parse the log
parsedLog, err := parser.Filterer.ParseNewAdminFee(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.SwapEvent{}).
Where(&sql.SwapEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: swapTypes.NewAdminFeeEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
NewAdminFee: parsedLog.NewAdminFee,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
//nolint:dupl
func (b *BackfillSuite) newSwapFeeParity(log *types.Log, parser *parser.SwapParser, chainID uint32) error {
// parse the log
parsedLog, err := parser.Filterer.ParseNewSwapFee(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.SwapEvent{}).
Where(&sql.SwapEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: swapTypes.NewSwapFeeEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
NewSwapFee: parsedLog.NewSwapFee,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
//nolint:dupl
func (b *BackfillSuite) rampAParity(log *types.Log, parser *parser.SwapParser, chainID uint32) error {
// parse the log
parsedLog, err := parser.Filterer.ParseRampA(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.SwapEvent{}).
Where(&sql.SwapEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: swapTypes.RampAEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
OldA: parsedLog.OldA,
NewA: parsedLog.NewA,
InitialTime: parsedLog.InitialTime,
FutureTime: parsedLog.FutureTime,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
//nolint:dupl
func (b *BackfillSuite) stopRampAParity(log *types.Log, parser *parser.SwapParser, chainID uint32) error {
// parse the log
parsedLog, err := parser.Filterer.ParseStopRampA(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.SwapEvent{}).
Where(&sql.SwapEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: swapTypes.StopRampAEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
CurrentA: parsedLog.CurrentA,
Time: parsedLog.Time,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
//nolint:dupl
func (b *BackfillSuite) flashLoanParity(log *types.Log, parser *parser.SwapParser, chainID uint32) error {
// parse the log
parsedLog, err := parser.Filterer.ParseFlashLoan(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
receiver := gosql.NullString{
String: parsedLog.Receiver.String(),
Valid: true,
}
amountArray := map[uint8]string{parsedLog.TokenIndex: core.CopyBigInt(parsedLog.Amount).String()}
feeArray := map[uint8]string{parsedLog.TokenIndex: core.CopyBigInt(parsedLog.AmountFee).String()}
var storedLog sql.SwapEvent
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.SwapEvent{}).
Where(&sql.SwapEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: swapTypes.FlashLoanEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Receiver: receiver,
ProtocolFee: parsedLog.ProtocolFee,
}).
Find(&storedLog).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
Equal(b.T(), amountArray, storedLog.Amount)
Equal(b.T(), feeArray, storedLog.Fee)
return nil
}
// storeEthTx stores the eth transaction so the get sender functionality can be tested.
func (b *BackfillSuite) storeEthTx(tx *types.Transaction, chainID *big.Int, blockNumber *big.Int, index int) {
err := b.eventDB.StoreEthTx(b.GetTestContext(), tx, uint32(chainID.Uint64()), common.BigToHash(blockNumber), blockNumber.Uint64(), uint64(index))
Nil(b.T(), err)
}
//nolint:dupl
func (b *BackfillSuite) executedParity(log *types.Log, parser *parser.MessageBusParser, chainID uint32) error {
// parse the log
parsedLog, err := parser.Filterer.ParseExecuted(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
var storedLog sql.MessageBusEvent
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.MessageBusEvent{}).
Where(&sql.MessageBusEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: messageBusTypes.ExecutedEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
MessageID: gosql.NullString{String: common.Bytes2Hex(parsedLog.MessageId[:]), Valid: true},
SourceChainID: big.NewInt(int64(parsedLog.SrcChainId)),
}).
Find(&storedLog).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
Equal(b.T(), big.NewInt(int64(parsedLog.SrcNonce)), storedLog.Nonce)
Equal(b.T(), parsedLog.DstAddress.String(), storedLog.DestinationAddress.String)
return nil
}
//nolint:dupl
func (b *BackfillSuite) metaSwapUnderlyingParity(log *types.Log, parser *parser.SwapParser, chainID uint32) error {
// parse the log
parsedLog, err := parser.FiltererMetaSwap.ParseTokenSwapUnderlying(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
buyer := gosql.NullString{
String: parsedLog.Buyer.String(),
Valid: true,
}
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.SwapEvent{}).
Where(&sql.SwapEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: swapTypes.TokenSwapEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
Buyer: buyer,
TokensSold: parsedLog.TokensSold,
TokensBought: parsedLog.TokensBought,
SoldID: parsedLog.SoldId,
BoughtID: parsedLog.BoughtId,
}).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
return nil
}
//nolint:dupl
func (b *BackfillSuite) messageSentParity(log *types.Log, parser *parser.MessageBusParser, chainID uint32) error {
// parse the log
parsedLog, err := parser.Filterer.ParseMessageSent(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
var storedLog sql.MessageBusEvent
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.MessageBusEvent{}).
Where(&sql.MessageBusEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: messageBusTypes.MessageSentEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
MessageID: gosql.NullString{String: common.Bytes2Hex(parsedLog.MessageId[:]), Valid: true},
SourceChainID: parsedLog.SrcChainID,
}).
Find(&storedLog).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
Equal(b.T(), common.Bytes2Hex(parsedLog.Message), storedLog.Message.String)
Equal(b.T(), parsedLog.Fee, storedLog.Fee)
Equal(b.T(), common.Bytes2Hex(parsedLog.Receiver[:]), storedLog.Receiver.String)
return nil
}
//nolint:dupl
func (b *BackfillSuite) callRevertedParity(log *types.Log, parser *parser.MessageBusParser, chainID uint32) error {
// parse the log
parsedLog, err := parser.Filterer.ParseCallReverted(*log)
if err != nil {
return fmt.Errorf("error parsing log: %w", err)
}
var storedLog sql.MessageBusEvent
var count int64
events := b.db.UNSAFE_DB().WithContext(b.GetTestContext()).Model(&sql.MessageBusEvent{}).
Where(&sql.MessageBusEvent{
ContractAddress: log.Address.String(),
ChainID: chainID,
EventType: messageBusTypes.CallRevertedEvent.Int(),
BlockNumber: log.BlockNumber,
TxHash: log.TxHash.String(),
}).
Find(&storedLog).Count(&count)
if events.Error != nil {
return fmt.Errorf("error querying for event: %w", events.Error)
}
Equal(b.T(), int64(1), count)
Equal(b.T(), parsedLog.Reason, storedLog.RevertedReason.String)
return nil
}