status-im
/
status-go
mirror of https://github.com/status-im/status-go.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
status-go/services/wallet/router/router_v2_test.go

3297 lines
111 KiB
Go
Raw Normal View History

chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
package router
import (
"context"
"database/sql"
"math/big"
"testing"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/status-im/status-go/appdatabase"
"github.com/status-im/status-go/params"
"github.com/status-im/status-go/rpc"
walletCommon "github.com/status-im/status-go/services/wallet/common"
"github.com/status-im/status-go/services/wallet/router/pathprocessor"
"github.com/status-im/status-go/services/wallet/token"
"github.com/status-im/status-go/t/helpers"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
const (
testBaseFee = 50000000000
testGasPrice = 10000000000
testPriorityFeeLow = 1000000000
testPriorityFeeMedium = 2000000000
testPriorityFeeHigh = 3000000000
testBonderFeeETH = 150000000000000
testBonderFeeUSDC = 10000
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
testAmount0Point1ETHInWei = 100000000000000000
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
testAmount0Point2ETHInWei = 200000000000000000
testAmount0Point3ETHInWei = 300000000000000000
testAmount0Point4ETHInWei = 400000000000000000
testAmount0Point5ETHInWei = 500000000000000000
testAmount0Point6ETHInWei = 600000000000000000
testAmount0Point8ETHInWei = 800000000000000000
testAmount1ETHInWei = 1000000000000000000
testAmount2ETHInWei = 2000000000000000000
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
testAmount3ETHInWei = 3000000000000000000
testAmount5ETHInWei = 5000000000000000000
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
testAmount1USDC = 1000000
testAmount100USDC = 100000000
testApprovalGasEstimation = 1000
testApprovalL1Fee = 100000000000
)
var (
testEstimationMap = map[string]uint64{
pathprocessor.ProcessorTransferName: uint64(1000),
pathprocessor.ProcessorBridgeHopName: uint64(5000),
}
testBbonderFeeMap = map[string]*big.Int{
pathprocessor.EthSymbol: big.NewInt(testBonderFeeETH),
pathprocessor.UsdcSymbol: big.NewInt(testBonderFeeUSDC),
}
testTokenPrices = map[string]float64{
pathprocessor.EthSymbol: 2000,
pathprocessor.UsdcSymbol: 1,
}
testSuggestedFees = &SuggestedFees{
GasPrice: big.NewInt(testGasPrice),
BaseFee: big.NewInt(testBaseFee),
MaxPriorityFeePerGas: big.NewInt(testPriorityFeeLow),
MaxFeesLevels: &MaxFeesLevels{
feat_: new endpoint added for an async route/s calculation - `GetSuggestedRoutesV2Async` calculates the route/s based on input parameters and sends `wallet.suggested.routes` signal to notify a client.
2024-06-20 09:03:42 +00:00
Low: (*hexutil.Big)(big.NewInt(testPriorityFeeLow)),
Medium: (*hexutil.Big)(big.NewInt(testPriorityFeeMedium)),
High: (*hexutil.Big)(big.NewInt(testPriorityFeeHigh)),
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
},
EIP1559Enabled: false,
}
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
testBalanceMapPerChain = map[string]*big.Int{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
makeBalanceKey(walletCommon.EthereumMainnet, pathprocessor.EthSymbol): big.NewInt(testAmount2ETHInWei),
makeBalanceKey(walletCommon.EthereumMainnet, pathprocessor.UsdcSymbol): big.NewInt(testAmount100USDC),
makeBalanceKey(walletCommon.OptimismMainnet, pathprocessor.EthSymbol): big.NewInt(testAmount2ETHInWei),
makeBalanceKey(walletCommon.OptimismMainnet, pathprocessor.UsdcSymbol): big.NewInt(testAmount100USDC),
makeBalanceKey(walletCommon.ArbitrumMainnet, pathprocessor.EthSymbol): big.NewInt(testAmount2ETHInWei),
makeBalanceKey(walletCommon.ArbitrumMainnet, pathprocessor.UsdcSymbol): big.NewInt(testAmount100USDC),
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
}
)
var mainnet = params.Network{
ChainID: walletCommon.EthereumMainnet,
ChainName: "Mainnet",
RPCURL: "https://eth-archival.rpc.grove.city/v1/",
FallbackURL: "https://mainnet.infura.io/v3/",
BlockExplorerURL: "https://etherscan.io/",
IconURL: "network/Network=Ethereum",
ChainColor: "#627EEA",
ShortName: "eth",
NativeCurrencyName: "Ether",
NativeCurrencySymbol: "ETH",
NativeCurrencyDecimals: 18,
IsTest: false,
Layer: 1,
Enabled: true,
RelatedChainID: walletCommon.EthereumMainnet,
}
var sepolia = params.Network{
ChainID: walletCommon.EthereumSepolia,
ChainName: "Mainnet",
RPCURL: "https://sepolia-archival.rpc.grove.city/v1/",
FallbackURL: "https://sepolia.infura.io/v3/",
BlockExplorerURL: "https://sepolia.etherscan.io/",
IconURL: "network/Network=Ethereum",
ChainColor: "#627EEA",
ShortName: "eth",
NativeCurrencyName: "Ether",
NativeCurrencySymbol: "ETH",
NativeCurrencyDecimals: 18,
IsTest: true,
Layer: 1,
Enabled: true,
RelatedChainID: walletCommon.EthereumMainnet,
}
var optimism = params.Network{
ChainID: walletCommon.OptimismMainnet,
ChainName: "Optimism",
RPCURL: "https://optimism-mainnet.rpc.grove.city/v1/",
FallbackURL: "https://optimism-mainnet.infura.io/v3/",
BlockExplorerURL: "https://optimistic.etherscan.io",
IconURL: "network/Network=Optimism",
ChainColor: "#E90101",
ShortName: "oeth",
NativeCurrencyName: "Ether",
NativeCurrencySymbol: "ETH",
NativeCurrencyDecimals: 18,
IsTest: false,
Layer: 2,
Enabled: true,
RelatedChainID: walletCommon.OptimismMainnet,
}
var optimismSepolia = params.Network{
ChainID: walletCommon.OptimismSepolia,
ChainName: "Optimism",
RPCURL: "https://optimism-sepolia-archival.rpc.grove.city/v1/",
FallbackURL: "https://optimism-sepolia.infura.io/v3/",
BlockExplorerURL: "https://sepolia-optimism.etherscan.io/",
IconURL: "network/Network=Optimism",
ChainColor: "#E90101",
ShortName: "oeth",
NativeCurrencyName: "Ether",
NativeCurrencySymbol: "ETH",
NativeCurrencyDecimals: 18,
IsTest: true,
Layer: 2,
Enabled: false,
RelatedChainID: walletCommon.OptimismMainnet,
}
var arbitrum = params.Network{
ChainID: walletCommon.ArbitrumMainnet,
ChainName: "Arbitrum",
RPCURL: "https://arbitrum-one.rpc.grove.city/v1/",
FallbackURL: "https://arbitrum-mainnet.infura.io/v3/",
BlockExplorerURL: "https://arbiscan.io/",
IconURL: "network/Network=Arbitrum",
ChainColor: "#51D0F0",
ShortName: "arb1",
NativeCurrencyName: "Ether",
NativeCurrencySymbol: "ETH",
NativeCurrencyDecimals: 18,
IsTest: false,
Layer: 2,
Enabled: true,
RelatedChainID: walletCommon.ArbitrumMainnet,
}
var arbitrumSepolia = params.Network{
ChainID: walletCommon.ArbitrumSepolia,
ChainName: "Arbitrum",
RPCURL: "https://arbitrum-sepolia-archival.rpc.grove.city/v1/",
FallbackURL: "https://arbitrum-sepolia.infura.io/v3/",
BlockExplorerURL: "https://sepolia-explorer.arbitrum.io/",
IconURL: "network/Network=Arbitrum",
ChainColor: "#51D0F0",
ShortName: "arb1",
NativeCurrencyName: "Ether",
NativeCurrencySymbol: "ETH",
NativeCurrencyDecimals: 18,
IsTest: true,
Layer: 2,
Enabled: false,
RelatedChainID: walletCommon.ArbitrumMainnet,
}
var defaultNetworks = []params.Network{
mainnet,
sepolia,
optimism,
optimismSepolia,
arbitrum,
arbitrumSepolia,
}
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
func amountOptionEqual(a, b amountOption) bool {
return a.amount.Cmp(b.amount) == 0 && a.locked == b.locked
}
func contains(slice []amountOption, val amountOption) bool {
for _, item := range slice {
if amountOptionEqual(item, val) {
return true
}
}
return false
}
func amountOptionsMapsEqual(map1, map2 map[uint64][]amountOption) bool {
if len(map1) != len(map2) {
return false
}
for key, slice1 := range map1 {
slice2, ok := map2[key]
if !ok || len(slice1) != len(slice2) {
return false
}
for _, val1 := range slice1 {
if !contains(slice2, val1) {
return false
}
}
for _, val2 := range slice2 {
if !contains(slice1, val2) {
return false
}
}
}
return true
}
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
func setupTestNetworkDB(t *testing.T) (*sql.DB, func()) {
db, cleanup, err := helpers.SetupTestSQLDB(appdatabase.DbInitializer{}, "wallet-router-tests")
require.NoError(t, err)
return db, func() { require.NoError(t, cleanup()) }
}
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
func setupRouter(t *testing.T) (*Router, func()) {
db, cleanTmpDb := setupTestNetworkDB(t)
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
client, _ := rpc.NewClient(nil, 1, params.UpstreamRPCConfig{Enabled: false, URL: ""}, defaultNetworks, db)
router := NewRouter(client, nil, nil, nil, nil, nil, nil, nil)
transfer := pathprocessor.NewTransferProcessor(nil, nil)
router.AddPathProcessor(transfer)
erc721Transfer := pathprocessor.NewERC721Processor(nil, nil)
router.AddPathProcessor(erc721Transfer)
erc1155Transfer := pathprocessor.NewERC1155Processor(nil, nil)
router.AddPathProcessor(erc1155Transfer)
test(wallet)_: add unit tests for balance fetcher replace types with interfaces where necessary to allow mocking implement fake eth scanner and erc20 contracts
2024-06-27 21:27:09 +00:00
hop := pathprocessor.NewHopBridgeProcessor(nil, nil, nil, nil)
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
router.AddPathProcessor(hop)
paraswap := pathprocessor.NewSwapParaswapProcessor(nil, nil, nil)
router.AddPathProcessor(paraswap)
ensRegister := pathprocessor.NewENSReleaseProcessor(nil, nil, nil)
router.AddPathProcessor(ensRegister)
ensRelease := pathprocessor.NewENSReleaseProcessor(nil, nil, nil)
router.AddPathProcessor(ensRelease)
ensPublicKey := pathprocessor.NewENSPublicKeyProcessor(nil, nil, nil)
router.AddPathProcessor(ensPublicKey)
buyStickers := pathprocessor.NewStickersBuyProcessor(nil, nil, nil)
router.AddPathProcessor(buyStickers)
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
return router, cleanTmpDb
}
func TestRouterV2(t *testing.T) {
router, cleanTmpDb := setupRouter(t)
defer cleanTmpDb()
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
tests := []struct {
name string
input *RouteInputParams
expectedCandidates []*PathV2
expectedError error
}{
{
name: "ETH transfer - No Specific FromChain - No Specific ToChain",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
TokenID: pathprocessor.EthSymbol,
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
tokenPrices: testTokenPrices,
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &mainnet,
ToChain: &mainnet,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &optimism,
ToChain: &optimism,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &arbitrum,
ToChain: &arbitrum,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &optimism,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &arbitrum,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &mainnet,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &arbitrum,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &optimism,
ApprovalRequired: false,
},
},
},
{
name: "ETH transfer - No Specific FromChain - Specific Single ToChain",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
TokenID: pathprocessor.EthSymbol,
DisabledToChainIDs: []uint64{walletCommon.OptimismMainnet, walletCommon.ArbitrumMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &mainnet,
ToChain: &mainnet,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &mainnet,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
ApprovalRequired: false,
},
},
},
{
name: "ETH transfer - No Specific FromChain - Specific Multiple ToChain",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
TokenID: pathprocessor.EthSymbol,
DisabledToChainIDs: []uint64{walletCommon.EthereumMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &optimism,
ToChain: &optimism,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &arbitrum,
ToChain: &arbitrum,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &optimism,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &arbitrum,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &arbitrum,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &optimism,
ApprovalRequired: false,
},
},
},
{
name: "ETH transfer - Specific Single FromChain - No Specific ToChain",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
TokenID: pathprocessor.EthSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &arbitrum,
ToChain: &arbitrum,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &optimism,
ApprovalRequired: false,
},
},
},
{
name: "ETH transfer - Specific Multiple FromChain - No Specific ToChain",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
TokenID: pathprocessor.EthSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &optimism,
ToChain: &optimism,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &arbitrum,
ToChain: &arbitrum,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &mainnet,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &arbitrum,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &optimism,
ApprovalRequired: false,
},
},
},
{
name: "ETH transfer - Specific Single FromChain - Specific Single ToChain - Same Chains",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
TokenID: pathprocessor.EthSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet},
DisabledToChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &arbitrum,
ToChain: &arbitrum,
ApprovalRequired: false,
},
},
},
{
name: "ETH transfer - Specific Single FromChain - Specific Single ToChain - Different Chains",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
TokenID: pathprocessor.EthSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet},
DisabledToChainIDs: []uint64{walletCommon.OptimismMainnet, walletCommon.ArbitrumMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
ApprovalRequired: false,
},
},
},
{
name: "ETH transfer - Specific Multiple FromChain - Specific Multiple ToChain - Single Common Chain",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
TokenID: pathprocessor.EthSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet},
DisabledToChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &arbitrum,
ToChain: &arbitrum,
ApprovalRequired: false,
},
},
},
{
name: "ETH transfer - Specific Multiple FromChain - Specific Multiple ToChain - Multiple Common Chains",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
TokenID: pathprocessor.EthSymbol,
DisabledFromChainIDs: []uint64{walletCommon.OptimismMainnet},
DisabledToChainIDs: []uint64{walletCommon.OptimismMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &mainnet,
ToChain: &mainnet,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &arbitrum,
ToChain: &arbitrum,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &arbitrum,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
ApprovalRequired: false,
},
},
},
{
name: "ETH transfer - Specific Multiple FromChain - Specific Multiple ToChain - No Common Chains",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
TokenID: pathprocessor.EthSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet},
DisabledToChainIDs: []uint64{walletCommon.OptimismMainnet, walletCommon.ArbitrumMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
ApprovalRequired: false,
},
},
},
{
name: "ETH transfer - All FromChains Disabled - All ToChains Disabled",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
TokenID: pathprocessor.EthSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet, walletCommon.ArbitrumMainnet},
DisabledToChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet, walletCommon.ArbitrumMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{},
},
{
name: "ETH transfer - No Specific FromChain - No Specific ToChain - Single Chain LockedAmount",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
TokenID: pathprocessor.EthSymbol,
FromLockedAmount: map[uint64]*hexutil.Big{
walletCommon.EthereumMainnet: (*hexutil.Big)(big.NewInt(testAmount0Point2ETHInWei)),
},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &mainnet,
ToChain: &mainnet,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point2ETHInWei)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &optimism,
ToChain: &optimism,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point8ETHInWei)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &arbitrum,
ToChain: &arbitrum,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point8ETHInWei)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &optimism,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point2ETHInWei - testBonderFeeETH)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &arbitrum,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point2ETHInWei - testBonderFeeETH)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &mainnet,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point8ETHInWei - testBonderFeeETH)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &arbitrum,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point8ETHInWei - testBonderFeeETH)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point8ETHInWei - testBonderFeeETH)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &optimism,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point8ETHInWei - testBonderFeeETH)),
ApprovalRequired: false,
},
},
},
{
name: "ETH transfer - No Specific FromChain - Specific ToChain - Single Chain LockedAmount",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
TokenID: pathprocessor.EthSymbol,
DisabledToChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.ArbitrumMainnet},
FromLockedAmount: map[uint64]*hexutil.Big{
walletCommon.EthereumMainnet: (*hexutil.Big)(big.NewInt(testAmount0Point2ETHInWei)),
walletCommon.ArbitrumMainnet: (*hexutil.Big)(big.NewInt(testAmount0Point3ETHInWei)),
},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &optimism,
ToChain: &optimism,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei - testAmount0Point2ETHInWei - testAmount0Point3ETHInWei)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &optimism,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point2ETHInWei - testBonderFeeETH)), //(*hexutil.Big)(big.NewInt(testAmount0Point2ETHInWei)), //(big.NewInt(testAmount0Point2ETHInWei - testBonderFeeETH)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &optimism,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point3ETHInWei - testBonderFeeETH)), //(*hexutil.Big)(big.NewInt(testAmount0Point3ETHInWei)),
ApprovalRequired: false,
},
},
},
{
name: "ETH transfer - No Specific FromChain - No Specific ToChain - Multiple Chains LockedAmount",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
TokenID: pathprocessor.EthSymbol,
FromLockedAmount: map[uint64]*hexutil.Big{
walletCommon.EthereumMainnet: (*hexutil.Big)(big.NewInt(testAmount0Point2ETHInWei)),
walletCommon.OptimismMainnet: (*hexutil.Big)(big.NewInt(testAmount0Point3ETHInWei)),
},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &mainnet,
ToChain: &mainnet,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point2ETHInWei)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &optimism,
ToChain: &optimism,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point3ETHInWei)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &arbitrum,
ToChain: &arbitrum,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point5ETHInWei)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &optimism,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point2ETHInWei - testBonderFeeETH)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &arbitrum,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point2ETHInWei - testBonderFeeETH)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &mainnet,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point3ETHInWei - testBonderFeeETH)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &arbitrum,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point3ETHInWei - testBonderFeeETH)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point5ETHInWei - testBonderFeeETH)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &optimism,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point5ETHInWei - testBonderFeeETH)),
ApprovalRequired: false,
},
},
},
{
name: "ETH transfer - No Specific FromChain - No Specific ToChain - All Chains LockedAmount",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
TokenID: pathprocessor.EthSymbol,
FromLockedAmount: map[uint64]*hexutil.Big{
walletCommon.EthereumMainnet: (*hexutil.Big)(big.NewInt(testAmount0Point2ETHInWei)),
walletCommon.OptimismMainnet: (*hexutil.Big)(big.NewInt(testAmount0Point3ETHInWei)),
walletCommon.ArbitrumMainnet: (*hexutil.Big)(big.NewInt(testAmount0Point5ETHInWei)),
},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &mainnet,
ToChain: &mainnet,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point2ETHInWei)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &optimism,
ToChain: &optimism,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point3ETHInWei)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &arbitrum,
ToChain: &arbitrum,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point5ETHInWei)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &optimism,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point2ETHInWei - testBonderFeeETH)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &arbitrum,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point2ETHInWei - testBonderFeeETH)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &mainnet,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point3ETHInWei - testBonderFeeETH)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &arbitrum,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point3ETHInWei - testBonderFeeETH)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point5ETHInWei - testBonderFeeETH)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &optimism,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount0Point5ETHInWei - testBonderFeeETH)),
ApprovalRequired: false,
},
},
},
{
name: "ETH transfer - No Specific FromChain - No Specific ToChain - All Chains LockedAmount with insufficient amount",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
TokenID: pathprocessor.EthSymbol,
FromLockedAmount: map[uint64]*hexutil.Big{
walletCommon.EthereumMainnet: (*hexutil.Big)(big.NewInt(testAmount0Point2ETHInWei)),
walletCommon.OptimismMainnet: (*hexutil.Big)(big.NewInt(testAmount0Point3ETHInWei)),
walletCommon.ArbitrumMainnet: (*hexutil.Big)(big.NewInt(testAmount0Point4ETHInWei)),
},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedError: ErrLockedAmountLessThanSendAmountAllNetworks,
expectedCandidates: []*PathV2{},
},
{
name: "ETH transfer - No Specific FromChain - No Specific ToChain - LockedAmount exceeds sending amount",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
TokenID: pathprocessor.EthSymbol,
FromLockedAmount: map[uint64]*hexutil.Big{
walletCommon.OptimismMainnet: (*hexutil.Big)(big.NewInt(testAmount0Point3ETHInWei)),
walletCommon.ArbitrumMainnet: (*hexutil.Big)(big.NewInt(testAmount0Point8ETHInWei)),
},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedError: ErrLockedAmountExceedsTotalSendAmount,
expectedCandidates: []*PathV2{},
},
{
name: "ERC20 transfer - No Specific FromChain - No Specific ToChain",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1USDC)),
TokenID: pathprocessor.UsdcSymbol,
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &mainnet,
ToChain: &mainnet,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &optimism,
ToChain: &optimism,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &arbitrum,
ToChain: &arbitrum,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &optimism,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &arbitrum,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &mainnet,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &arbitrum,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &optimism,
ApprovalRequired: true,
},
},
},
{
name: "ERC20 transfer - No Specific FromChain - Specific Single ToChain",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1USDC)),
TokenID: pathprocessor.UsdcSymbol,
DisabledToChainIDs: []uint64{walletCommon.OptimismMainnet, walletCommon.ArbitrumMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &mainnet,
ToChain: &mainnet,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &mainnet,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
ApprovalRequired: true,
},
},
},
{
name: "ERC20 transfer - No Specific FromChain - Specific Multiple ToChain",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1USDC)),
TokenID: pathprocessor.UsdcSymbol,
DisabledToChainIDs: []uint64{walletCommon.EthereumMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &optimism,
ToChain: &optimism,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &arbitrum,
ToChain: &arbitrum,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &optimism,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &arbitrum,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &arbitrum,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &optimism,
ApprovalRequired: true,
},
},
},
{
name: "ERC20 transfer - Specific Single FromChain - No Specific ToChain",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1USDC)),
TokenID: pathprocessor.UsdcSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &arbitrum,
ToChain: &arbitrum,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &optimism,
ApprovalRequired: true,
},
},
},
{
name: "ERC20 transfer - Specific Multiple FromChain - No Specific ToChain",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1USDC)),
TokenID: pathprocessor.UsdcSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &optimism,
ToChain: &optimism,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &arbitrum,
ToChain: &arbitrum,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &mainnet,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &arbitrum,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &optimism,
ApprovalRequired: true,
},
},
},
{
name: "ERC20 transfer - Specific Single FromChain - Specific Single ToChain - Same Chains",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1USDC)),
TokenID: pathprocessor.UsdcSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet},
DisabledToChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &arbitrum,
ToChain: &arbitrum,
ApprovalRequired: false,
},
},
},
{
name: "ERC20 transfer - Specific Single FromChain - Specific Single ToChain - Different Chains",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1USDC)),
TokenID: pathprocessor.UsdcSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet},
DisabledToChainIDs: []uint64{walletCommon.OptimismMainnet, walletCommon.ArbitrumMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
ApprovalRequired: true,
},
},
},
{
name: "ERC20 transfer - Specific Multiple FromChain - Specific Multiple ToChain - Single Common Chain",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1USDC)),
TokenID: pathprocessor.UsdcSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet},
DisabledToChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &arbitrum,
ToChain: &arbitrum,
ApprovalRequired: false,
},
},
},
{
name: "ERC20 transfer - Specific Multiple FromChain - Specific Multiple ToChain - Multiple Common Chains",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1USDC)),
TokenID: pathprocessor.UsdcSymbol,
DisabledFromChainIDs: []uint64{walletCommon.OptimismMainnet},
DisabledToChainIDs: []uint64{walletCommon.OptimismMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &mainnet,
ToChain: &mainnet,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &arbitrum,
ToChain: &arbitrum,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &arbitrum,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
ApprovalRequired: true,
},
},
},
{
name: "ERC20 transfer - Specific Multiple FromChain - Specific Multiple ToChain - No Common Chains",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1USDC)),
TokenID: pathprocessor.UsdcSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet},
DisabledToChainIDs: []uint64{walletCommon.OptimismMainnet, walletCommon.ArbitrumMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
ApprovalRequired: true,
},
},
},
{
name: "ERC20 transfer - All FromChains Disabled - All ToChains Disabled",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1USDC)),
TokenID: pathprocessor.UsdcSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet, walletCommon.ArbitrumMainnet},
DisabledToChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet, walletCommon.ArbitrumMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{},
},
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
{
name: "ERC20 transfer - All FromChains - No Locked Amount - Enough Token Balance Across All Chains",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(2.5 * testAmount100USDC)),
TokenID: pathprocessor.UsdcSymbol,
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
balanceMap: testBalanceMapPerChain,
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &mainnet,
ToChain: &mainnet,
AmountOut: (*hexutil.Big)(big.NewInt(2.5 * testAmount100USDC)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &mainnet,
ToChain: &mainnet,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount100USDC)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &optimism,
AmountOut: (*hexutil.Big)(big.NewInt(2.5*testAmount100USDC - testBonderFeeUSDC)),
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &optimism,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount100USDC - testBonderFeeUSDC)),
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &arbitrum,
AmountOut: (*hexutil.Big)(big.NewInt(2.5*testAmount100USDC - testBonderFeeUSDC)),
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &arbitrum,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount100USDC - testBonderFeeUSDC)),
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &optimism,
ToChain: &optimism,
AmountOut: (*hexutil.Big)(big.NewInt(0.5 * testAmount100USDC)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &optimism,
ToChain: &optimism,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount100USDC)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &optimism,
ToChain: &optimism,
AmountOut: (*hexutil.Big)(big.NewInt(2.5 * testAmount100USDC)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &mainnet,
AmountOut: (*hexutil.Big)(big.NewInt(0.5*testAmount100USDC - testBonderFeeUSDC)),
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &mainnet,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount100USDC - testBonderFeeUSDC)),
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &mainnet,
AmountOut: (*hexutil.Big)(big.NewInt(2.5*testAmount100USDC - testBonderFeeUSDC)),
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &arbitrum,
AmountOut: (*hexutil.Big)(big.NewInt(0.5*testAmount100USDC - testBonderFeeUSDC)),
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &arbitrum,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount100USDC - testBonderFeeUSDC)),
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &arbitrum,
AmountOut: (*hexutil.Big)(big.NewInt(2.5*testAmount100USDC - testBonderFeeUSDC)),
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &arbitrum,
ToChain: &arbitrum,
AmountOut: (*hexutil.Big)(big.NewInt(0.5 * testAmount100USDC)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &arbitrum,
ToChain: &arbitrum,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount100USDC)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &arbitrum,
ToChain: &arbitrum,
AmountOut: (*hexutil.Big)(big.NewInt(2.5 * testAmount100USDC)),
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
AmountOut: (*hexutil.Big)(big.NewInt(0.5*testAmount100USDC - testBonderFeeUSDC)),
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount100USDC - testBonderFeeUSDC)),
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
AmountOut: (*hexutil.Big)(big.NewInt(2.5*testAmount100USDC - testBonderFeeUSDC)),
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &optimism,
AmountOut: (*hexutil.Big)(big.NewInt(0.5*testAmount100USDC - testBonderFeeUSDC)),
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &optimism,
AmountOut: (*hexutil.Big)(big.NewInt(testAmount100USDC - testBonderFeeUSDC)),
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &optimism,
AmountOut: (*hexutil.Big)(big.NewInt(2.5*testAmount100USDC - testBonderFeeUSDC)),
ApprovalRequired: true,
},
},
},
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
{
name: "Bridge - No Specific FromChain - No Specific ToChain",
input: &RouteInputParams{
testnetMode: false,
SendType: Bridge,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1USDC)),
TokenID: pathprocessor.UsdcSymbol,
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &optimism,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &arbitrum,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &mainnet,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &arbitrum,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &optimism,
ApprovalRequired: true,
},
},
},
{
name: "Bridge - No Specific FromChain - Specific Single ToChain",
input: &RouteInputParams{
testnetMode: false,
SendType: Bridge,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1USDC)),
TokenID: pathprocessor.UsdcSymbol,
DisabledToChainIDs: []uint64{walletCommon.OptimismMainnet, walletCommon.ArbitrumMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &mainnet,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
ApprovalRequired: true,
},
},
},
{
name: "Bridge - No Specific FromChain - Specific Multiple ToChain",
input: &RouteInputParams{
testnetMode: false,
SendType: Bridge,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1USDC)),
TokenID: pathprocessor.UsdcSymbol,
DisabledToChainIDs: []uint64{walletCommon.EthereumMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &optimism,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &arbitrum,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &arbitrum,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &optimism,
ApprovalRequired: true,
},
},
},
{
name: "Bridge - Specific Single FromChain - No Specific ToChain",
input: &RouteInputParams{
testnetMode: false,
SendType: Bridge,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1USDC)),
TokenID: pathprocessor.UsdcSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &optimism,
ApprovalRequired: true,
},
},
},
{
name: "Bridge - Specific Multiple FromChain - No Specific ToChain",
input: &RouteInputParams{
testnetMode: false,
SendType: Bridge,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1USDC)),
TokenID: pathprocessor.UsdcSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &mainnet,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &optimism,
ToChain: &arbitrum,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &optimism,
ApprovalRequired: true,
},
},
},
{
name: "Bridge - Specific Single FromChain - Specific Single ToChain - Same Chains",
input: &RouteInputParams{
testnetMode: false,
SendType: Bridge,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1USDC)),
TokenID: pathprocessor.UsdcSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet},
DisabledToChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{},
},
{
name: "Bridge - Specific Single FromChain - Specific Single ToChain - Different Chains",
input: &RouteInputParams{
testnetMode: false,
SendType: Bridge,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1USDC)),
TokenID: pathprocessor.UsdcSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet},
DisabledToChainIDs: []uint64{walletCommon.OptimismMainnet, walletCommon.ArbitrumMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
ApprovalRequired: true,
},
},
},
{
name: "Bridge - Specific Multiple FromChain - Specific Multiple ToChain - Single Common Chain",
input: &RouteInputParams{
testnetMode: false,
SendType: Bridge,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1USDC)),
TokenID: pathprocessor.UsdcSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet},
DisabledToChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{},
},
{
name: "Bridge - Specific Multiple FromChain - Specific Multiple ToChain - Multiple Common Chains",
input: &RouteInputParams{
testnetMode: false,
SendType: Bridge,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1USDC)),
TokenID: pathprocessor.UsdcSymbol,
DisabledFromChainIDs: []uint64{walletCommon.OptimismMainnet},
DisabledToChainIDs: []uint64{walletCommon.OptimismMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &arbitrum,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
ApprovalRequired: true,
},
},
},
{
name: "Bridge - Specific Multiple FromChain - Specific Multiple ToChain - No Common Chains",
input: &RouteInputParams{
testnetMode: false,
SendType: Bridge,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1USDC)),
TokenID: pathprocessor.UsdcSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet},
DisabledToChainIDs: []uint64{walletCommon.OptimismMainnet, walletCommon.ArbitrumMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &mainnet,
ApprovalRequired: true,
},
},
},
{
name: "Bridge - All FromChains Disabled - All ToChains Disabled",
input: &RouteInputParams{
testnetMode: false,
SendType: Bridge,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1USDC)),
TokenID: pathprocessor.UsdcSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet, walletCommon.ArbitrumMainnet},
DisabledToChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet, walletCommon.ArbitrumMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
baseFee: big.NewInt(testBaseFee),
suggestedFees: testSuggestedFees,
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
balanceMap: testBalanceMapPerChain,
chore_: tests for router candidates added
2024-06-18 10:31:23 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
routes, err := router.SuggestedRoutesV2(context.Background(), tt.input)
if tt.expectedError != nil {
assert.Error(t, err)
assert.Equal(t, tt.expectedError, err)
assert.Nil(t, routes)
} else {
assert.NoError(t, err)
assert.Equal(t, len(tt.expectedCandidates), len(routes.Candidates))
for _, c := range routes.Candidates {
found := false
for _, expC := range tt.expectedCandidates {
if c.ProcessorName == expC.ProcessorName &&
c.FromChain.ChainID == expC.FromChain.ChainID &&
c.ToChain.ChainID == expC.ToChain.ChainID &&
c.ApprovalRequired == expC.ApprovalRequired &&
(expC.AmountOut == nil || c.AmountOut.ToInt().Cmp(expC.AmountOut.ToInt()) == 0) {
found = true
break
}
}
assert.True(t, found)
}
}
})
}
}
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
func TestNoBalanceForTheBestRouteRouterV2(t *testing.T) {
router, cleanTmpDb := setupRouter(t)
defer cleanTmpDb()
tests := []struct {
name string
input *RouteInputParams
expectedCandidates []*PathV2
expectedBest []*PathV2
expectedError error
}{
{
name: "ERC20 transfer - Specific FromChain - Specific ToChain - Not Enough Token Balance",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount100USDC)),
TokenID: pathprocessor.UsdcSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.ArbitrumMainnet},
DisabledToChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.ArbitrumMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
tokenPrices: testTokenPrices,
suggestedFees: testSuggestedFees,
balanceMap: map[string]*big.Int{
makeBalanceKey(walletCommon.OptimismMainnet, pathprocessor.UsdcSymbol): big.NewInt(0),
},
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedError: ErrNotEnoughTokenBalance,
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &optimism,
ToChain: &optimism,
ApprovalRequired: false,
requiredTokenBalance: big.NewInt(testAmount100USDC),
requiredNativeBalance: big.NewInt((testBaseFee + testPriorityFeeLow) * testApprovalGasEstimation),
},
},
},
{
name: "ERC20 transfer - Specific FromChain - Specific ToChain - Not Enough Native Balance",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount100USDC)),
TokenID: pathprocessor.UsdcSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.ArbitrumMainnet},
DisabledToChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.ArbitrumMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
suggestedFees: testSuggestedFees,
balanceMap: map[string]*big.Int{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
makeBalanceKey(walletCommon.OptimismMainnet, pathprocessor.UsdcSymbol): big.NewInt(testAmount100USDC),
makeBalanceKey(walletCommon.OptimismMainnet, pathprocessor.EthSymbol): big.NewInt(0),
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
},
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedError: ErrNotEnoughNativeBalance,
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &optimism,
ToChain: &optimism,
ApprovalRequired: false,
requiredTokenBalance: big.NewInt(testAmount100USDC),
requiredNativeBalance: big.NewInt((testBaseFee + testPriorityFeeLow) * testApprovalGasEstimation),
},
},
},
{
name: "ERC20 transfer - No Specific FromChain - Specific ToChain - Not Enough Token Balance Across All Chains",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount100USDC)),
TokenID: pathprocessor.UsdcSymbol,
DisabledToChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.ArbitrumMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
tokenPrices: testTokenPrices,
suggestedFees: testSuggestedFees,
balanceMap: map[string]*big.Int{
makeBalanceKey(walletCommon.EthereumMainnet, pathprocessor.UsdcSymbol): big.NewInt(0),
makeBalanceKey(walletCommon.EthereumMainnet, pathprocessor.EthSymbol): big.NewInt(0),
makeBalanceKey(walletCommon.OptimismMainnet, pathprocessor.UsdcSymbol): big.NewInt(0),
makeBalanceKey(walletCommon.OptimismMainnet, pathprocessor.EthSymbol): big.NewInt(0),
makeBalanceKey(walletCommon.ArbitrumMainnet, pathprocessor.UsdcSymbol): big.NewInt(0),
makeBalanceKey(walletCommon.ArbitrumMainnet, pathprocessor.EthSymbol): big.NewInt(0),
},
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedError: ErrNotEnoughTokenBalance,
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &optimism,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &optimism,
ToChain: &optimism,
ApprovalRequired: false,
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &optimism,
ApprovalRequired: true,
},
},
},
{
name: "ERC20 transfer - No Specific FromChain - Specific ToChain - Enough Token Balance On Arbitrum Chain But Not Enough Native Balance",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount100USDC)),
TokenID: pathprocessor.UsdcSymbol,
DisabledToChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.ArbitrumMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
suggestedFees: testSuggestedFees,
balanceMap: map[string]*big.Int{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
makeBalanceKey(walletCommon.ArbitrumMainnet, pathprocessor.UsdcSymbol): big.NewInt(testAmount100USDC + testAmount100USDC),
makeBalanceKey(walletCommon.EthereumMainnet, pathprocessor.UsdcSymbol): big.NewInt(testAmount100USDC + testAmount100USDC),
makeBalanceKey(walletCommon.OptimismMainnet, pathprocessor.UsdcSymbol): big.NewInt(testAmount100USDC + testAmount100USDC),
makeBalanceKey(walletCommon.ArbitrumMainnet, pathprocessor.EthSymbol): big.NewInt(0),
makeBalanceKey(walletCommon.EthereumMainnet, pathprocessor.EthSymbol): big.NewInt(0),
makeBalanceKey(walletCommon.OptimismMainnet, pathprocessor.EthSymbol): big.NewInt(0),
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
},
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedError: ErrNotEnoughNativeBalance,
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &optimism,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &optimism,
ToChain: &optimism,
ApprovalRequired: false,
requiredTokenBalance: big.NewInt(testAmount100USDC),
requiredNativeBalance: big.NewInt((testBaseFee + testPriorityFeeLow) * testApprovalGasEstimation),
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &optimism,
ApprovalRequired: true,
},
},
},
{
name: "ERC20 transfer - No Specific FromChain - Specific ToChain - Enough Token Balance On Arbitrum Chain And Enough Native Balance On Arbitrum Chain",
input: &RouteInputParams{
testnetMode: false,
SendType: Transfer,
AddrFrom: common.HexToAddress("0x1"),
AddrTo: common.HexToAddress("0x2"),
AmountIn: (*hexutil.Big)(big.NewInt(testAmount100USDC)),
TokenID: pathprocessor.UsdcSymbol,
DisabledToChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.ArbitrumMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.UsdcSymbol,
Decimals: 6,
},
tokenPrices: testTokenPrices,
suggestedFees: testSuggestedFees,
balanceMap: map[string]*big.Int{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
makeBalanceKey(walletCommon.ArbitrumMainnet, pathprocessor.UsdcSymbol): big.NewInt(testAmount100USDC + testAmount100USDC),
makeBalanceKey(walletCommon.ArbitrumMainnet, pathprocessor.EthSymbol): big.NewInt(testAmount1ETHInWei),
feat_: the router returns route there is a balance on even that's not the cheapest route If there are multiple routes across multiple networks, but the user doesn't have a positive balance on the network which the router initially suggested as the best (cheapest) route, then we are not returning an error saying there are not enough balance, but instead try to suggest the route on the network where the user has a positive balance even that's not the cheapest route (it should be the second cheapest route, but if there are not enough balance on it we proceed with the third cheapest route and so on...).
2024-06-30 20:44:21 +00:00
},
estimationMap: testEstimationMap,
bonderFeeMap: testBbonderFeeMap,
approvalGasEstimation: testApprovalGasEstimation,
approvalL1Fee: testApprovalL1Fee,
},
},
expectedCandidates: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &mainnet,
ToChain: &optimism,
ApprovalRequired: true,
},
{
ProcessorName: pathprocessor.ProcessorTransferName,
FromChain: &optimism,
ToChain: &optimism,
ApprovalRequired: false,
requiredTokenBalance: big.NewInt(testAmount100USDC),
requiredNativeBalance: big.NewInt((testBaseFee + testPriorityFeeLow) * testApprovalGasEstimation),
},
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &optimism,
ApprovalRequired: true,
},
},
expectedBest: []*PathV2{
{
ProcessorName: pathprocessor.ProcessorBridgeHopName,
FromChain: &arbitrum,
ToChain: &optimism,
ApprovalRequired: true,
},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
routes, err := router.SuggestedRoutesV2(context.Background(), tt.input)
if tt.expectedError != nil {
assert.Error(t, err)
assert.Equal(t, tt.expectedError, err)
assert.NotNil(t, routes)
assert.Equal(t, len(tt.expectedCandidates), len(routes.Candidates))
} else {
assert.NoError(t, err)
assert.Equal(t, len(tt.expectedCandidates), len(routes.Candidates))
assert.Equal(t, len(tt.expectedBest), len(routes.Best))
for _, c := range routes.Candidates {
found := false
for _, expC := range tt.expectedCandidates {
if c.ProcessorName == expC.ProcessorName &&
c.FromChain.ChainID == expC.FromChain.ChainID &&
c.ToChain.ChainID == expC.ToChain.ChainID &&
c.ApprovalRequired == expC.ApprovalRequired &&
(expC.AmountOut == nil || c.AmountOut.ToInt().Cmp(expC.AmountOut.ToInt()) == 0) {
found = true
break
}
}
assert.True(t, found)
}
for _, c := range routes.Best {
found := false
for _, expC := range tt.expectedBest {
if c.ProcessorName == expC.ProcessorName &&
c.FromChain.ChainID == expC.FromChain.ChainID &&
c.ToChain.ChainID == expC.ToChain.ChainID &&
c.ApprovalRequired == expC.ApprovalRequired &&
(expC.AmountOut == nil || c.AmountOut.ToInt().Cmp(expC.AmountOut.ToInt()) == 0) {
found = true
break
}
}
assert.True(t, found)
}
}
})
}
}
test(router_validation)_: Added full test cases for validateInputData
2024-06-10 15:17:41 +00:00
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
func TestAmountOptions(t *testing.T) {
router, cleanTmpDb := setupRouter(t)
defer cleanTmpDb()
tests := []struct {
name string
input *RouteInputParams
expectedAmountOptions map[uint64][]amountOption
test(router_validation)_: Added full test cases for validateInputData
2024-06-10 15:17:41 +00:00
}{
{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
name: "Transfer - Single From Chain - No Locked Amount",
test(router_validation)_: blended my validation with latest develop
2024-07-03 09:30:17 +00:00
input: &RouteInputParams{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
testnetMode: false,
SendType: Transfer,
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
TokenID: pathprocessor.EthSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.ArbitrumMainnet},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
balanceMap: map[string]*big.Int{},
},
test(router_validation)_: blended my validation with latest develop
2024-07-03 09:30:17 +00:00
},
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
expectedAmountOptions: map[uint64][]amountOption{
walletCommon.OptimismMainnet: {
{
amount: big.NewInt(testAmount1ETHInWei),
locked: false,
},
},
test(router_validation)_: blended my validation with latest develop
2024-07-03 09:30:17 +00:00
},
},
{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
name: "Transfer - Single From Chain - Locked Amount To Single Chain Equal Total Amount",
test(router_validation)_: blended my validation with latest develop
2024-07-03 09:30:17 +00:00
input: &RouteInputParams{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
testnetMode: false,
SendType: Transfer,
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
TokenID: pathprocessor.EthSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.ArbitrumMainnet},
FromLockedAmount: map[uint64]*hexutil.Big{
walletCommon.OptimismMainnet: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
balanceMap: map[string]*big.Int{},
},
test(router_validation)_: blended my validation with latest develop
2024-07-03 09:30:17 +00:00
},
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
expectedAmountOptions: map[uint64][]amountOption{
walletCommon.OptimismMainnet: {
{
amount: big.NewInt(testAmount1ETHInWei),
locked: true,
},
},
test(router_validation)_: blended my validation with latest develop
2024-07-03 09:30:17 +00:00
},
},
test(router_validation)_: Added full test cases for validateInputData
2024-06-10 15:17:41 +00:00
{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
name: "Transfer - Multiple From Chains - Locked Amount To Single Chain Is Less Than Total Amount",
test(router_validation)_: Added full test cases for validateInputData
2024-06-10 15:17:41 +00:00
input: &RouteInputParams{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
testnetMode: false,
SendType: Transfer,
AmountIn: (*hexutil.Big)(big.NewInt(testAmount2ETHInWei)),
TokenID: pathprocessor.EthSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet},
test(router_validation)_: Added full test cases for validateInputData
2024-06-10 15:17:41 +00:00
FromLockedAmount: map[uint64]*hexutil.Big{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
walletCommon.OptimismMainnet: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
balanceMap: map[string]*big.Int{},
test(router_validation)_: Added full test cases for validateInputData
2024-06-10 15:17:41 +00:00
},
},
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
expectedAmountOptions: map[uint64][]amountOption{
walletCommon.OptimismMainnet: {
{
amount: big.NewInt(testAmount1ETHInWei),
locked: true,
},
},
walletCommon.ArbitrumMainnet: {
{
amount: big.NewInt(testAmount1ETHInWei),
locked: false,
},
test(router_validation)_: Added full test cases for validateInputData
2024-06-10 15:17:41 +00:00
},
},
},
{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
name: "Transfer - Multiple From Chains - Locked Amount To Multiple Chains",
test(router_validation)_: Added full test cases for validateInputData
2024-06-10 15:17:41 +00:00
input: &RouteInputParams{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
testnetMode: false,
SendType: Transfer,
AmountIn: (*hexutil.Big)(big.NewInt(testAmount2ETHInWei)),
TokenID: pathprocessor.EthSymbol,
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet},
test(router_validation)_: Added full test cases for validateInputData
2024-06-10 15:17:41 +00:00
FromLockedAmount: map[uint64]*hexutil.Big{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
walletCommon.OptimismMainnet: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
walletCommon.ArbitrumMainnet: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
balanceMap: map[string]*big.Int{},
test(router_validation)_: Added full test cases for validateInputData
2024-06-10 15:17:41 +00:00
},
},
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
expectedAmountOptions: map[uint64][]amountOption{
walletCommon.OptimismMainnet: {
{
amount: big.NewInt(testAmount1ETHInWei),
locked: true,
},
},
walletCommon.ArbitrumMainnet: {
{
amount: big.NewInt(testAmount1ETHInWei),
locked: true,
},
test(router_validation)_: Added full test cases for validateInputData
2024-06-10 15:17:41 +00:00
},
},
},
{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
name: "Transfer - All From Chains - Locked Amount To Multiple Chains Equal Total Amount",
test(router_validation)_: Added full test cases for validateInputData
2024-06-10 15:17:41 +00:00
input: &RouteInputParams{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
testnetMode: false,
SendType: Transfer,
AmountIn: (*hexutil.Big)(big.NewInt(testAmount2ETHInWei)),
TokenID: pathprocessor.EthSymbol,
test(router_validation)_: Added full test cases for validateInputData
2024-06-10 15:17:41 +00:00
FromLockedAmount: map[uint64]*hexutil.Big{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
walletCommon.OptimismMainnet: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
walletCommon.ArbitrumMainnet: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
balanceMap: map[string]*big.Int{},
test(router_validation)_: Added full test cases for validateInputData
2024-06-10 15:17:41 +00:00
},
},
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
expectedAmountOptions: map[uint64][]amountOption{
walletCommon.OptimismMainnet: {
{
amount: big.NewInt(testAmount1ETHInWei),
locked: true,
},
},
walletCommon.ArbitrumMainnet: {
{
amount: big.NewInt(testAmount1ETHInWei),
locked: true,
},
test(router_validation)_: Added full test cases for validateInputData
2024-06-10 15:17:41 +00:00
},
},
},
{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
name: "Transfer - All From Chains - Locked Amount To Multiple Chains Is Less Than Total Amount",
test(router_validation)_: Added full test cases for validateInputData
2024-06-10 15:17:41 +00:00
input: &RouteInputParams{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
testnetMode: false,
SendType: Transfer,
AmountIn: (*hexutil.Big)(big.NewInt(testAmount5ETHInWei)),
TokenID: pathprocessor.EthSymbol,
test(router_validation)_: Added full test cases for validateInputData
2024-06-10 15:17:41 +00:00
FromLockedAmount: map[uint64]*hexutil.Big{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
walletCommon.OptimismMainnet: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
walletCommon.ArbitrumMainnet: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
balanceMap: map[string]*big.Int{},
test(router_validation)_: Added full test cases for validateInputData
2024-06-10 15:17:41 +00:00
},
},
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
expectedAmountOptions: map[uint64][]amountOption{
walletCommon.OptimismMainnet: {
{
amount: big.NewInt(testAmount1ETHInWei),
locked: true,
},
},
walletCommon.ArbitrumMainnet: {
{
amount: big.NewInt(testAmount1ETHInWei),
locked: true,
},
},
walletCommon.EthereumMainnet: {
{
amount: big.NewInt(testAmount3ETHInWei),
locked: false,
},
test(router_validation)_: Added full test cases for validateInputData
2024-06-10 15:17:41 +00:00
},
},
},
{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
name: "Transfer - All From Chain - No Locked Amount - Enough Token Balance If All Chains Are Used",
test(router_validation)_: Added full test cases for validateInputData
2024-06-10 15:17:41 +00:00
input: &RouteInputParams{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
testnetMode: false,
SendType: Transfer,
AmountIn: (*hexutil.Big)(big.NewInt(testAmount3ETHInWei)),
TokenID: pathprocessor.EthSymbol,
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
balanceMap: map[string]*big.Int{
makeBalanceKey(walletCommon.EthereumMainnet, pathprocessor.EthSymbol): big.NewInt(testAmount1ETHInWei),
makeBalanceKey(walletCommon.OptimismMainnet, pathprocessor.EthSymbol): big.NewInt(testAmount1ETHInWei),
makeBalanceKey(walletCommon.ArbitrumMainnet, pathprocessor.EthSymbol): big.NewInt(testAmount1ETHInWei),
},
test(router_validation)_: Added full test cases for validateInputData
2024-06-10 15:17:41 +00:00
},
},
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
expectedAmountOptions: map[uint64][]amountOption{
walletCommon.OptimismMainnet: {
{
amount: big.NewInt(testAmount3ETHInWei),
locked: false,
},
{
amount: big.NewInt(testAmount1ETHInWei),
locked: false,
},
},
walletCommon.ArbitrumMainnet: {
{
amount: big.NewInt(testAmount3ETHInWei),
locked: false,
},
{
amount: big.NewInt(testAmount1ETHInWei),
locked: false,
},
},
walletCommon.EthereumMainnet: {
{
amount: big.NewInt(testAmount3ETHInWei),
locked: false,
},
{
amount: big.NewInt(testAmount1ETHInWei),
locked: false,
},
test(router_validation)_: Added full test cases for validateInputData
2024-06-10 15:17:41 +00:00
},
},
},
test(router_validation)_: blended my validation with latest develop
2024-07-03 09:30:17 +00:00
{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
name: "Transfer - All From Chain - Locked Amount To Single Chain - Enough Token Balance If All Chains Are Used",
test(router_validation)_: blended my validation with latest develop
2024-07-03 09:30:17 +00:00
input: &RouteInputParams{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
testnetMode: false,
SendType: Transfer,
AmountIn: (*hexutil.Big)(big.NewInt(testAmount3ETHInWei)),
TokenID: pathprocessor.EthSymbol,
test(router_validation)_: blended my validation with latest develop
2024-07-03 09:30:17 +00:00
FromLockedAmount: map[uint64]*hexutil.Big{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
walletCommon.OptimismMainnet: (*hexutil.Big)(big.NewInt(testAmount0Point5ETHInWei)),
},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
balanceMap: map[string]*big.Int{
makeBalanceKey(walletCommon.EthereumMainnet, pathprocessor.EthSymbol): big.NewInt(testAmount2ETHInWei),
makeBalanceKey(walletCommon.OptimismMainnet, pathprocessor.EthSymbol): big.NewInt(testAmount1ETHInWei),
makeBalanceKey(walletCommon.ArbitrumMainnet, pathprocessor.EthSymbol): big.NewInt(testAmount3ETHInWei),
},
test(router_validation)_: blended my validation with latest develop
2024-07-03 09:30:17 +00:00
},
},
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
expectedAmountOptions: map[uint64][]amountOption{
walletCommon.OptimismMainnet: {
{
amount: big.NewInt(testAmount0Point5ETHInWei),
locked: true,
},
},
walletCommon.ArbitrumMainnet: {
{
amount: big.NewInt(testAmount2ETHInWei + testAmount0Point5ETHInWei),
locked: false,
},
{
amount: big.NewInt(testAmount0Point5ETHInWei),
locked: false,
},
},
walletCommon.EthereumMainnet: {
{
amount: big.NewInt(testAmount2ETHInWei + testAmount0Point5ETHInWei),
locked: false,
},
{
amount: big.NewInt(testAmount2ETHInWei),
locked: false,
},
test(router_validation)_: blended my validation with latest develop
2024-07-03 09:30:17 +00:00
},
},
},
{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
name: "Transfer - All From Chain - Locked Amount To Multiple Chains - Enough Token Balance If All Chains Are Used",
test(router_validation)_: blended my validation with latest develop
2024-07-03 09:30:17 +00:00
input: &RouteInputParams{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
testnetMode: false,
SendType: Transfer,
AmountIn: (*hexutil.Big)(big.NewInt(testAmount3ETHInWei)),
TokenID: pathprocessor.EthSymbol,
FromLockedAmount: map[uint64]*hexutil.Big{
walletCommon.OptimismMainnet: (*hexutil.Big)(big.NewInt(testAmount0Point5ETHInWei)),
walletCommon.EthereumMainnet: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
},
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
balanceMap: map[string]*big.Int{
makeBalanceKey(walletCommon.EthereumMainnet, pathprocessor.EthSymbol): big.NewInt(testAmount2ETHInWei),
makeBalanceKey(walletCommon.OptimismMainnet, pathprocessor.EthSymbol): big.NewInt(testAmount1ETHInWei),
makeBalanceKey(walletCommon.ArbitrumMainnet, pathprocessor.EthSymbol): big.NewInt(testAmount3ETHInWei),
},
},
test(router_validation)_: blended my validation with latest develop
2024-07-03 09:30:17 +00:00
},
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
expectedAmountOptions: map[uint64][]amountOption{
walletCommon.OptimismMainnet: {
{
amount: big.NewInt(testAmount0Point5ETHInWei),
locked: true,
},
},
walletCommon.ArbitrumMainnet: {
{
amount: big.NewInt(testAmount1ETHInWei + testAmount0Point5ETHInWei),
locked: false,
},
},
walletCommon.EthereumMainnet: {
{
amount: big.NewInt(testAmount1ETHInWei),
locked: true,
},
},
test(router_validation)_: blended my validation with latest develop
2024-07-03 09:30:17 +00:00
},
},
{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
name: "Transfer - All From Chain - No Locked Amount - Not Enough Token Balance",
test(router_validation)_: blended my validation with latest develop
2024-07-03 09:30:17 +00:00
input: &RouteInputParams{
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
testnetMode: false,
SendType: Transfer,
AmountIn: (*hexutil.Big)(big.NewInt(testAmount5ETHInWei)),
TokenID: pathprocessor.EthSymbol,
testsMode: true,
testParams: &routerTestParams{
tokenFrom: &token.Token{
ChainID: 1,
Symbol: pathprocessor.EthSymbol,
Decimals: 18,
},
balanceMap: map[string]*big.Int{
makeBalanceKey(walletCommon.EthereumMainnet, pathprocessor.EthSymbol): big.NewInt(testAmount1ETHInWei),
makeBalanceKey(walletCommon.OptimismMainnet, pathprocessor.EthSymbol): big.NewInt(testAmount1ETHInWei),
makeBalanceKey(walletCommon.ArbitrumMainnet, pathprocessor.EthSymbol): big.NewInt(testAmount1ETHInWei),
},
},
test(router_validation)_: blended my validation with latest develop
2024-07-03 09:30:17 +00:00
},
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
expectedAmountOptions: map[uint64][]amountOption{
walletCommon.OptimismMainnet: {
{
amount: big.NewInt(testAmount5ETHInWei),
locked: false,
},
},
walletCommon.ArbitrumMainnet: {
{
amount: big.NewInt(testAmount5ETHInWei),
locked: false,
},
},
walletCommon.EthereumMainnet: {
{
amount: big.NewInt(testAmount5ETHInWei),
locked: false,
},
},
test(router_validation)_: blended my validation with latest develop
2024-07-03 09:30:17 +00:00
},
},
test(router_validation)_: Added full test cases for validateInputData
2024-06-10 15:17:41 +00:00
}
feat_: the router - add candidates, as potential paths, by taking the max amount on enabled chains
2024-07-04 10:48:14 +00:00
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
selectedFromChains, _, err := router.getSelectedChains(tt.input)
assert.NoError(t, err)
amountOptions, err := router.findOptionsForSendingAmount(tt.input, selectedFromChains, tt.input.testParams.balanceMap)
assert.NoError(t, err)
assert.Equal(t, len(tt.expectedAmountOptions), len(amountOptions))
assert.True(t, amountOptionsMapsEqual(tt.expectedAmountOptions, amountOptions))
test(router_validation)_: Added full test cases for validateInputData
2024-06-10 15:17:41 +00:00
})
}
}