3315 lines
116 KiB
Go
3315 lines
116 KiB
Go
package router
|
|
|
|
import (
|
|
"fmt"
|
|
"math/big"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/common/hexutil"
|
|
|
|
"github.com/google/uuid"
|
|
|
|
"github.com/status-im/status-go/errors"
|
|
"github.com/status-im/status-go/params"
|
|
walletCommon "github.com/status-im/status-go/services/wallet/common"
|
|
"github.com/status-im/status-go/services/wallet/requests"
|
|
"github.com/status-im/status-go/services/wallet/router/fees"
|
|
"github.com/status-im/status-go/services/wallet/router/pathprocessor"
|
|
"github.com/status-im/status-go/services/wallet/router/routes"
|
|
"github.com/status-im/status-go/services/wallet/router/sendtype"
|
|
"github.com/status-im/status-go/services/wallet/token"
|
|
)
|
|
|
|
const (
|
|
testBaseFee = 50000000000
|
|
testGasPrice = 10000000000
|
|
testPriorityFeeLow = 1000000000
|
|
testPriorityFeeMedium = 2000000000
|
|
testPriorityFeeHigh = 3000000000
|
|
testBonderFeeETH = 150000000000000
|
|
testBonderFeeUSDC = 10000
|
|
|
|
testAmount0Point1ETHInWei = 100000000000000000
|
|
testAmount0Point2ETHInWei = 200000000000000000
|
|
testAmount0Point3ETHInWei = 300000000000000000
|
|
testAmount0Point4ETHInWei = 400000000000000000
|
|
testAmount0Point5ETHInWei = 500000000000000000
|
|
testAmount0Point6ETHInWei = 600000000000000000
|
|
testAmount0Point8ETHInWei = 800000000000000000
|
|
testAmount1ETHInWei = 1000000000000000000
|
|
testAmount2ETHInWei = 2000000000000000000
|
|
testAmount3ETHInWei = 3000000000000000000
|
|
testAmount5ETHInWei = 5000000000000000000
|
|
|
|
testAmount1USDC = 1000000
|
|
testAmount100USDC = 100000000
|
|
|
|
testApprovalGasEstimation = 1000
|
|
testApprovalL1Fee = 100000000000
|
|
|
|
stageName = "test"
|
|
)
|
|
|
|
var (
|
|
testEstimationMap = map[string]pathprocessor.Estimation{
|
|
pathprocessor.ProcessorTransferName: {Value: uint64(1000), Err: nil},
|
|
pathprocessor.ProcessorBridgeHopName: {Value: uint64(5000), Err: nil},
|
|
}
|
|
|
|
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 = &fees.SuggestedFees{
|
|
GasPrice: big.NewInt(testGasPrice),
|
|
BaseFee: big.NewInt(testBaseFee),
|
|
MaxPriorityFeePerGas: big.NewInt(testPriorityFeeLow),
|
|
MaxFeesLevels: &fees.MaxFeesLevels{
|
|
Low: (*hexutil.Big)(big.NewInt(testPriorityFeeLow)),
|
|
Medium: (*hexutil.Big)(big.NewInt(testPriorityFeeMedium)),
|
|
High: (*hexutil.Big)(big.NewInt(testPriorityFeeHigh)),
|
|
},
|
|
EIP1559Enabled: false,
|
|
}
|
|
|
|
testBalanceMapPerChain = map[string]*big.Int{
|
|
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),
|
|
}
|
|
)
|
|
|
|
var mainnet = params.Network{
|
|
ChainID: walletCommon.EthereumMainnet,
|
|
ChainName: "Mainnet",
|
|
DefaultRPCURL: fmt.Sprintf("https://%s.api.status.im/nodefleet/ethereum/mainnet/", stageName),
|
|
DefaultFallbackURL: fmt.Sprintf("https://%s.api.status.im/infura/ethereum/mainnet/", stageName),
|
|
DefaultFallbackURL2: "https://mainnet.infura.io/v3/",
|
|
RPCURL: fmt.Sprintf("https://%s.api.status.im/grove/ethereum/mainnet/", stageName),
|
|
FallbackURL: "https://eth-archival.rpc.grove.city/v1/",
|
|
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 optimism = params.Network{
|
|
ChainID: walletCommon.OptimismMainnet,
|
|
ChainName: "Optimism",
|
|
DefaultRPCURL: fmt.Sprintf("https://%s.api.status.im/nodefleet/optimism/mainnet/", stageName),
|
|
DefaultFallbackURL: fmt.Sprintf("https://%s.api.status.im/infura/optimism/mainnet/", stageName),
|
|
DefaultFallbackURL2: "https://optimism-mainnet.infura.io/v3/",
|
|
RPCURL: fmt.Sprintf("https://%s.api.status.im/grove/optimism/mainnet/", stageName),
|
|
FallbackURL: "https://optimism-archival.rpc.grove.city/v1/",
|
|
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 arbitrum = params.Network{
|
|
ChainID: walletCommon.ArbitrumMainnet,
|
|
ChainName: "Arbitrum",
|
|
DefaultRPCURL: fmt.Sprintf("https://%s.api.status.im/nodefleet/arbitrum/mainnet/", stageName),
|
|
DefaultFallbackURL: fmt.Sprintf("https://%s.api.status.im/infura/arbitrum/mainnet/", stageName),
|
|
DefaultFallbackURL2: "https://arbitrum-mainnet.infura.io/v3/",
|
|
RPCURL: fmt.Sprintf("https://%s.api.status.im/grove/arbitrum/mainnet/", stageName),
|
|
FallbackURL: "https://arbitrum-one.rpc.grove.city/v1/",
|
|
IconURL: "network/Network=Arbitrum",
|
|
ChainColor: "#51D0F0",
|
|
ShortName: "arb1",
|
|
NativeCurrencyName: "Ether",
|
|
NativeCurrencySymbol: "ETH",
|
|
NativeCurrencyDecimals: 18,
|
|
IsTest: false,
|
|
Layer: 2,
|
|
Enabled: true,
|
|
RelatedChainID: walletCommon.ArbitrumMainnet,
|
|
}
|
|
|
|
var defaultNetworks = []params.Network{
|
|
mainnet,
|
|
optimism,
|
|
arbitrum,
|
|
}
|
|
|
|
type normalTestParams struct {
|
|
name string
|
|
input *requests.RouteInputParams
|
|
expectedCandidates routes.Route
|
|
expectedError *errors.ErrorResponse
|
|
}
|
|
|
|
func getNormalTestParamsList() []normalTestParams {
|
|
return []normalTestParams{
|
|
{
|
|
name: "ETH transfer - Insufficient Funds",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: sendtype.Transfer,
|
|
AddrFrom: common.HexToAddress("0x1"),
|
|
AddrTo: common.HexToAddress("0x2"),
|
|
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
|
|
TokenID: pathprocessor.EthSymbol,
|
|
DisabledFromChainIDs: []uint64{walletCommon.OptimismMainnet, walletCommon.ArbitrumMainnet},
|
|
DisabledToChainIDs: []uint64{walletCommon.OptimismMainnet, walletCommon.ArbitrumMainnet},
|
|
|
|
TestsMode: true,
|
|
TestParams: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
TokenPrices: testTokenPrices,
|
|
SuggestedFees: testSuggestedFees,
|
|
BalanceMap: testBalanceMapPerChain,
|
|
EstimationMap: map[string]pathprocessor.Estimation{
|
|
pathprocessor.ProcessorTransferName: {
|
|
Value: uint64(0),
|
|
Err: fmt.Errorf("failed with 50000000 gas: insufficient funds for gas * price + value: address %s have 68251537427723 want 100000000000000", common.HexToAddress("0x1")),
|
|
},
|
|
},
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedError: &errors.ErrorResponse{
|
|
Code: errors.GenericErrorCode,
|
|
Details: fmt.Sprintf("failed with 50000000 gas: insufficient funds for gas * price + value: address %s", common.HexToAddress("0x1")),
|
|
},
|
|
expectedCandidates: routes.Route{},
|
|
},
|
|
{
|
|
name: "ETH transfer - No Specific FromChain - No Specific ToChain - 0 AmountIn",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: sendtype.Transfer,
|
|
AddrFrom: common.HexToAddress("0x1"),
|
|
AddrTo: common.HexToAddress("0x2"),
|
|
AmountIn: (*hexutil.Big)(big.NewInt(0)),
|
|
TokenID: pathprocessor.EthSymbol,
|
|
|
|
TestsMode: true,
|
|
TestParams: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
TokenPrices: testTokenPrices,
|
|
SuggestedFees: testSuggestedFees,
|
|
BalanceMap: testBalanceMapPerChain,
|
|
EstimationMap: testEstimationMap,
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedCandidates: routes.Route{
|
|
{
|
|
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,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "ETH transfer - No Specific FromChain - No Specific ToChain",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: sendtype.Transfer,
|
|
AddrFrom: common.HexToAddress("0x1"),
|
|
AddrTo: common.HexToAddress("0x2"),
|
|
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
|
|
TokenID: pathprocessor.EthSymbol,
|
|
|
|
TestsMode: true,
|
|
TestParams: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
TokenPrices: testTokenPrices,
|
|
SuggestedFees: testSuggestedFees,
|
|
BalanceMap: testBalanceMapPerChain,
|
|
EstimationMap: testEstimationMap,
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedCandidates: routes.Route{
|
|
{
|
|
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: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
TokenPrices: testTokenPrices,
|
|
BaseFee: big.NewInt(testBaseFee),
|
|
SuggestedFees: testSuggestedFees,
|
|
BalanceMap: testBalanceMapPerChain,
|
|
EstimationMap: testEstimationMap,
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedCandidates: routes.Route{
|
|
{
|
|
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: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
TokenPrices: testTokenPrices,
|
|
BaseFee: big.NewInt(testBaseFee),
|
|
SuggestedFees: testSuggestedFees,
|
|
BalanceMap: testBalanceMapPerChain,
|
|
EstimationMap: testEstimationMap,
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedCandidates: routes.Route{
|
|
{
|
|
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: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
TokenPrices: testTokenPrices,
|
|
BaseFee: big.NewInt(testBaseFee),
|
|
SuggestedFees: testSuggestedFees,
|
|
BalanceMap: testBalanceMapPerChain,
|
|
|
|
EstimationMap: testEstimationMap,
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedCandidates: routes.Route{
|
|
{
|
|
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: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
TokenPrices: testTokenPrices,
|
|
BaseFee: big.NewInt(testBaseFee),
|
|
SuggestedFees: testSuggestedFees,
|
|
BalanceMap: testBalanceMapPerChain,
|
|
EstimationMap: testEstimationMap,
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedCandidates: routes.Route{
|
|
{
|
|
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: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
TokenPrices: testTokenPrices,
|
|
BaseFee: big.NewInt(testBaseFee),
|
|
SuggestedFees: testSuggestedFees,
|
|
BalanceMap: testBalanceMapPerChain,
|
|
EstimationMap: testEstimationMap,
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedCandidates: routes.Route{
|
|
{
|
|
ProcessorName: pathprocessor.ProcessorTransferName,
|
|
FromChain: &arbitrum,
|
|
ToChain: &arbitrum,
|
|
ApprovalRequired: false,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "ETH transfer - Specific Single FromChain - Specific Single ToChain - Different Chains",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
TokenPrices: testTokenPrices,
|
|
BaseFee: big.NewInt(testBaseFee),
|
|
SuggestedFees: testSuggestedFees,
|
|
BalanceMap: testBalanceMapPerChain,
|
|
EstimationMap: testEstimationMap,
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedCandidates: routes.Route{
|
|
{
|
|
ProcessorName: pathprocessor.ProcessorBridgeHopName,
|
|
FromChain: &arbitrum,
|
|
ToChain: &mainnet,
|
|
ApprovalRequired: false,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "ETH transfer - Specific Multiple FromChain - Specific Multiple ToChain - Single Common Chain",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
TokenPrices: testTokenPrices,
|
|
BaseFee: big.NewInt(testBaseFee),
|
|
SuggestedFees: testSuggestedFees,
|
|
BalanceMap: testBalanceMapPerChain,
|
|
EstimationMap: testEstimationMap,
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedCandidates: routes.Route{
|
|
{
|
|
ProcessorName: pathprocessor.ProcessorTransferName,
|
|
FromChain: &arbitrum,
|
|
ToChain: &arbitrum,
|
|
ApprovalRequired: false,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "ETH transfer - Specific Multiple FromChain - Specific Multiple ToChain - Multiple Common Chains",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
TokenPrices: testTokenPrices,
|
|
BaseFee: big.NewInt(testBaseFee),
|
|
SuggestedFees: testSuggestedFees,
|
|
BalanceMap: testBalanceMapPerChain,
|
|
EstimationMap: testEstimationMap,
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedCandidates: routes.Route{
|
|
{
|
|
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: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
TokenPrices: testTokenPrices,
|
|
BaseFee: big.NewInt(testBaseFee),
|
|
SuggestedFees: testSuggestedFees,
|
|
BalanceMap: testBalanceMapPerChain,
|
|
EstimationMap: testEstimationMap,
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedCandidates: routes.Route{
|
|
{
|
|
ProcessorName: pathprocessor.ProcessorBridgeHopName,
|
|
FromChain: &arbitrum,
|
|
ToChain: &mainnet,
|
|
ApprovalRequired: false,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "ETH transfer - All FromChains Disabled - All ToChains Disabled",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
TokenPrices: testTokenPrices,
|
|
BaseFee: big.NewInt(testBaseFee),
|
|
SuggestedFees: testSuggestedFees,
|
|
BalanceMap: testBalanceMapPerChain,
|
|
|
|
EstimationMap: testEstimationMap,
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedError: ErrNoBestRouteFound,
|
|
expectedCandidates: routes.Route{},
|
|
},
|
|
{
|
|
name: "ETH transfer - No Specific FromChain - No Specific ToChain - Single Chain LockedAmount",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
TokenPrices: testTokenPrices,
|
|
BaseFee: big.NewInt(testBaseFee),
|
|
SuggestedFees: testSuggestedFees,
|
|
BalanceMap: testBalanceMapPerChain,
|
|
EstimationMap: testEstimationMap,
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedCandidates: routes.Route{
|
|
{
|
|
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: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
TokenPrices: testTokenPrices,
|
|
BaseFee: big.NewInt(testBaseFee),
|
|
SuggestedFees: testSuggestedFees,
|
|
BalanceMap: testBalanceMapPerChain,
|
|
EstimationMap: testEstimationMap,
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedCandidates: routes.Route{
|
|
{
|
|
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: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
TokenPrices: testTokenPrices,
|
|
BaseFee: big.NewInt(testBaseFee),
|
|
SuggestedFees: testSuggestedFees,
|
|
BalanceMap: testBalanceMapPerChain,
|
|
EstimationMap: testEstimationMap,
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedCandidates: routes.Route{
|
|
{
|
|
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: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
TokenPrices: testTokenPrices,
|
|
BaseFee: big.NewInt(testBaseFee),
|
|
SuggestedFees: testSuggestedFees,
|
|
BalanceMap: testBalanceMapPerChain,
|
|
EstimationMap: testEstimationMap,
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedCandidates: routes.Route{
|
|
{
|
|
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: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
TokenPrices: testTokenPrices,
|
|
BaseFee: big.NewInt(testBaseFee),
|
|
SuggestedFees: testSuggestedFees,
|
|
BalanceMap: testBalanceMapPerChain,
|
|
EstimationMap: testEstimationMap,
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedError: requests.ErrLockedAmountLessThanSendAmountAllNetworks,
|
|
expectedCandidates: routes.Route{},
|
|
},
|
|
{
|
|
name: "ETH transfer - No Specific FromChain - No Specific ToChain - LockedAmount exceeds sending amount",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
TokenPrices: testTokenPrices,
|
|
BaseFee: big.NewInt(testBaseFee),
|
|
SuggestedFees: testSuggestedFees,
|
|
BalanceMap: testBalanceMapPerChain,
|
|
EstimationMap: testEstimationMap,
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedError: requests.ErrLockedAmountExceedsTotalSendAmount,
|
|
expectedCandidates: routes.Route{},
|
|
},
|
|
{
|
|
name: "ERC20 transfer - No Specific FromChain - No Specific ToChain",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: sendtype.Transfer,
|
|
AddrFrom: common.HexToAddress("0x1"),
|
|
AddrTo: common.HexToAddress("0x2"),
|
|
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1USDC)),
|
|
TokenID: pathprocessor.UsdcSymbol,
|
|
|
|
TestsMode: true,
|
|
TestParams: &requests.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: routes.Route{
|
|
{
|
|
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: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.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: routes.Route{
|
|
{
|
|
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: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.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: routes.Route{
|
|
{
|
|
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: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.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: routes.Route{
|
|
{
|
|
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: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.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: routes.Route{
|
|
{
|
|
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: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.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: routes.Route{
|
|
{
|
|
ProcessorName: pathprocessor.ProcessorTransferName,
|
|
FromChain: &arbitrum,
|
|
ToChain: &arbitrum,
|
|
ApprovalRequired: false,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "ERC20 transfer - Specific Single FromChain - Specific Single ToChain - Different Chains",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.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: routes.Route{
|
|
{
|
|
ProcessorName: pathprocessor.ProcessorBridgeHopName,
|
|
FromChain: &arbitrum,
|
|
ToChain: &mainnet,
|
|
ApprovalRequired: true,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "ERC20 transfer - Specific Multiple FromChain - Specific Multiple ToChain - Single Common Chain",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.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: routes.Route{
|
|
{
|
|
ProcessorName: pathprocessor.ProcessorTransferName,
|
|
FromChain: &arbitrum,
|
|
ToChain: &arbitrum,
|
|
ApprovalRequired: false,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "ERC20 transfer - Specific Multiple FromChain - Specific Multiple ToChain - Multiple Common Chains",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.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: routes.Route{
|
|
{
|
|
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: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.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: routes.Route{
|
|
{
|
|
ProcessorName: pathprocessor.ProcessorBridgeHopName,
|
|
FromChain: &arbitrum,
|
|
ToChain: &mainnet,
|
|
ApprovalRequired: true,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "ERC20 transfer - All FromChains Disabled - All ToChains Disabled",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.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,
|
|
},
|
|
},
|
|
expectedError: ErrNoBestRouteFound,
|
|
expectedCandidates: routes.Route{},
|
|
},
|
|
{
|
|
name: "ERC20 transfer - All FromChains - No Locked Amount - Enough Token Balance Across All Chains",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: sendtype.Transfer,
|
|
AddrFrom: common.HexToAddress("0x1"),
|
|
AddrTo: common.HexToAddress("0x2"),
|
|
AmountIn: (*hexutil.Big)(big.NewInt(2.5 * testAmount100USDC)),
|
|
TokenID: pathprocessor.UsdcSymbol,
|
|
|
|
TestsMode: true,
|
|
TestParams: &requests.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: routes.Route{
|
|
{
|
|
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,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "Bridge - No Specific FromChain - No Specific ToChain",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: sendtype.Bridge,
|
|
AddrFrom: common.HexToAddress("0x1"),
|
|
AddrTo: common.HexToAddress("0x2"),
|
|
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1USDC)),
|
|
TokenID: pathprocessor.UsdcSymbol,
|
|
|
|
TestsMode: true,
|
|
TestParams: &requests.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: routes.Route{
|
|
{
|
|
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: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.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: routes.Route{
|
|
{
|
|
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: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.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: routes.Route{
|
|
{
|
|
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: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.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: routes.Route{
|
|
{
|
|
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: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.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: routes.Route{
|
|
{
|
|
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: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.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,
|
|
},
|
|
},
|
|
expectedError: ErrNoBestRouteFound,
|
|
expectedCandidates: routes.Route{},
|
|
},
|
|
{
|
|
name: "Bridge - Specific Single FromChain - Specific Single ToChain - Different Chains",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.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: routes.Route{
|
|
{
|
|
ProcessorName: pathprocessor.ProcessorBridgeHopName,
|
|
FromChain: &arbitrum,
|
|
ToChain: &mainnet,
|
|
ApprovalRequired: true,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "Bridge - Specific Multiple FromChain - Specific Multiple ToChain - Single Common Chain",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.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,
|
|
},
|
|
},
|
|
expectedError: ErrNoBestRouteFound,
|
|
expectedCandidates: routes.Route{},
|
|
},
|
|
{
|
|
name: "Bridge - Specific Multiple FromChain - Specific Multiple ToChain - Multiple Common Chains",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.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: routes.Route{
|
|
{
|
|
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: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.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: routes.Route{
|
|
{
|
|
ProcessorName: pathprocessor.ProcessorBridgeHopName,
|
|
FromChain: &arbitrum,
|
|
ToChain: &mainnet,
|
|
ApprovalRequired: true,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "Bridge - All FromChains Disabled - All ToChains Disabled",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.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,
|
|
},
|
|
},
|
|
expectedError: ErrNoBestRouteFound,
|
|
expectedCandidates: routes.Route{},
|
|
},
|
|
{
|
|
name: "ETH transfer - Not Enough Native Balance",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: sendtype.Transfer,
|
|
AddrFrom: common.HexToAddress("0x1"),
|
|
AddrTo: common.HexToAddress("0x2"),
|
|
AmountIn: (*hexutil.Big)(big.NewInt(testAmount3ETHInWei)),
|
|
TokenID: pathprocessor.EthSymbol,
|
|
DisabledFromChainIDs: []uint64{walletCommon.OptimismMainnet, walletCommon.ArbitrumMainnet},
|
|
DisabledToChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.ArbitrumMainnet},
|
|
|
|
TestsMode: true,
|
|
TestParams: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
TokenPrices: testTokenPrices,
|
|
SuggestedFees: testSuggestedFees,
|
|
BalanceMap: testBalanceMapPerChain,
|
|
EstimationMap: testEstimationMap,
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedError: &errors.ErrorResponse{
|
|
Code: ErrNotEnoughNativeBalance.Code,
|
|
Details: fmt.Sprintf(ErrNotEnoughNativeBalance.Details, pathprocessor.EthSymbol, walletCommon.EthereumMainnet),
|
|
},
|
|
expectedCandidates: routes.Route{
|
|
{
|
|
ProcessorName: pathprocessor.ProcessorBridgeHopName,
|
|
FromChain: &mainnet,
|
|
ToChain: &optimism,
|
|
ApprovalRequired: false,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "ETH transfer - Not Enough Native Balance",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: sendtype.Transfer,
|
|
AddrFrom: common.HexToAddress("0x1"),
|
|
AddrTo: common.HexToAddress("0x2"),
|
|
AmountIn: (*hexutil.Big)(big.NewInt(5 * testAmount100USDC)),
|
|
TokenID: pathprocessor.UsdcSymbol,
|
|
DisabledFromChainIDs: []uint64{walletCommon.OptimismMainnet, walletCommon.ArbitrumMainnet},
|
|
DisabledToChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.ArbitrumMainnet},
|
|
|
|
TestsMode: true,
|
|
TestParams: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.UsdcSymbol,
|
|
Decimals: 6,
|
|
},
|
|
TokenPrices: testTokenPrices,
|
|
SuggestedFees: testSuggestedFees,
|
|
BalanceMap: testBalanceMapPerChain,
|
|
EstimationMap: testEstimationMap,
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedError: &errors.ErrorResponse{
|
|
Code: ErrNotEnoughTokenBalance.Code,
|
|
Details: fmt.Sprintf(ErrNotEnoughTokenBalance.Details, pathprocessor.UsdcSymbol, walletCommon.EthereumMainnet),
|
|
},
|
|
expectedCandidates: routes.Route{
|
|
{
|
|
ProcessorName: pathprocessor.ProcessorBridgeHopName,
|
|
FromChain: &mainnet,
|
|
ToChain: &optimism,
|
|
ApprovalRequired: true,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "Bridge - Specific Single FromChain - Specific Single ToChain - Sending Small Amount",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: sendtype.Bridge,
|
|
AddrFrom: common.HexToAddress("0x1"),
|
|
AddrTo: common.HexToAddress("0x2"),
|
|
AmountIn: (*hexutil.Big)(big.NewInt(0.01 * testAmount1USDC)),
|
|
TokenID: pathprocessor.UsdcSymbol,
|
|
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.OptimismMainnet},
|
|
DisabledToChainIDs: []uint64{walletCommon.OptimismMainnet, walletCommon.ArbitrumMainnet},
|
|
|
|
TestsMode: true,
|
|
TestParams: &requests.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,
|
|
},
|
|
},
|
|
expectedError: ErrLowAmountInForHopBridge,
|
|
expectedCandidates: routes.Route{
|
|
{
|
|
ProcessorName: pathprocessor.ProcessorBridgeHopName,
|
|
FromChain: &arbitrum,
|
|
ToChain: &mainnet,
|
|
ApprovalRequired: true,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
type noBalanceTestParams struct {
|
|
name string
|
|
input *requests.RouteInputParams
|
|
expectedCandidates routes.Route
|
|
expectedBest routes.Route
|
|
expectedError *errors.ErrorResponse
|
|
}
|
|
|
|
func getNoBalanceTestParamsList() []noBalanceTestParams {
|
|
return []noBalanceTestParams{
|
|
{
|
|
name: "ERC20 transfer - Specific FromChain - Specific ToChain - Not Enough Token Balance",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.UsdcSymbol,
|
|
Decimals: 6,
|
|
},
|
|
TokenPrices: testTokenPrices,
|
|
SuggestedFees: testSuggestedFees,
|
|
BalanceMap: map[string]*big.Int{
|
|
makeBalanceKey(walletCommon.OptimismMainnet, pathprocessor.UsdcSymbol): big.NewInt(0),
|
|
},
|
|
EstimationMap: testEstimationMap,
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedError: ErrNoPositiveBalance,
|
|
},
|
|
{
|
|
name: "ERC20 transfer - Specific FromChain - Specific ToChain - Not Enough Native Balance",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.UsdcSymbol,
|
|
Decimals: 6,
|
|
},
|
|
TokenPrices: testTokenPrices,
|
|
SuggestedFees: testSuggestedFees,
|
|
BalanceMap: map[string]*big.Int{
|
|
makeBalanceKey(walletCommon.OptimismMainnet, pathprocessor.UsdcSymbol): big.NewInt(testAmount100USDC),
|
|
makeBalanceKey(walletCommon.OptimismMainnet, pathprocessor.EthSymbol): big.NewInt(0),
|
|
},
|
|
EstimationMap: testEstimationMap,
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedError: &errors.ErrorResponse{
|
|
Code: ErrNotEnoughNativeBalance.Code,
|
|
Details: fmt.Sprintf(ErrNotEnoughNativeBalance.Details, pathprocessor.EthSymbol, walletCommon.OptimismMainnet),
|
|
},
|
|
expectedCandidates: routes.Route{
|
|
{
|
|
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: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.UsdcSymbol,
|
|
Decimals: 6,
|
|
},
|
|
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),
|
|
},
|
|
EstimationMap: testEstimationMap,
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedError: ErrNoPositiveBalance,
|
|
},
|
|
{
|
|
name: "ERC20 transfer - No Specific FromChain - Specific ToChain - Enough Token Balance On Arbitrum Chain But Not Enough Native Balance",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.UsdcSymbol,
|
|
Decimals: 6,
|
|
},
|
|
TokenPrices: testTokenPrices,
|
|
SuggestedFees: testSuggestedFees,
|
|
BalanceMap: map[string]*big.Int{
|
|
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),
|
|
},
|
|
EstimationMap: testEstimationMap,
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedError: &errors.ErrorResponse{
|
|
Code: ErrNotEnoughNativeBalance.Code,
|
|
Details: fmt.Sprintf(ErrNotEnoughNativeBalance.Details, pathprocessor.EthSymbol, walletCommon.ArbitrumMainnet),
|
|
},
|
|
expectedCandidates: routes.Route{
|
|
{
|
|
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: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.UsdcSymbol,
|
|
Decimals: 6,
|
|
},
|
|
TokenPrices: testTokenPrices,
|
|
SuggestedFees: testSuggestedFees,
|
|
BalanceMap: map[string]*big.Int{
|
|
makeBalanceKey(walletCommon.ArbitrumMainnet, pathprocessor.UsdcSymbol): big.NewInt(testAmount100USDC + testAmount100USDC),
|
|
makeBalanceKey(walletCommon.ArbitrumMainnet, pathprocessor.EthSymbol): big.NewInt(testAmount1ETHInWei),
|
|
},
|
|
EstimationMap: testEstimationMap,
|
|
BonderFeeMap: testBBonderFeeMap,
|
|
ApprovalGasEstimation: testApprovalGasEstimation,
|
|
ApprovalL1Fee: testApprovalL1Fee,
|
|
},
|
|
},
|
|
expectedCandidates: routes.Route{
|
|
{
|
|
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: routes.Route{
|
|
{
|
|
ProcessorName: pathprocessor.ProcessorBridgeHopName,
|
|
FromChain: &arbitrum,
|
|
ToChain: &optimism,
|
|
ApprovalRequired: true,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
type amountOptionsTestParams struct {
|
|
name string
|
|
input *requests.RouteInputParams
|
|
expectedAmountOptions map[uint64][]amountOption
|
|
}
|
|
|
|
func getAmountOptionsTestParamsList() []amountOptionsTestParams {
|
|
return []amountOptionsTestParams{
|
|
{
|
|
name: "Transfer - Single From Chain - No Locked Amount",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: sendtype.Transfer,
|
|
AmountIn: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
|
|
TokenID: pathprocessor.EthSymbol,
|
|
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet, walletCommon.ArbitrumMainnet},
|
|
|
|
TestsMode: true,
|
|
TestParams: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
BalanceMap: map[string]*big.Int{},
|
|
},
|
|
},
|
|
expectedAmountOptions: map[uint64][]amountOption{
|
|
walletCommon.OptimismMainnet: {
|
|
{
|
|
amount: big.NewInt(testAmount1ETHInWei),
|
|
locked: false,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "Transfer - Single From Chain - Locked Amount To Single Chain Equal Total Amount",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
BalanceMap: map[string]*big.Int{},
|
|
},
|
|
},
|
|
expectedAmountOptions: map[uint64][]amountOption{
|
|
walletCommon.OptimismMainnet: {
|
|
{
|
|
amount: big.NewInt(testAmount1ETHInWei),
|
|
locked: true,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "Transfer - Multiple From Chains - Locked Amount To Single Chain Is Less Than Total Amount",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: sendtype.Transfer,
|
|
AmountIn: (*hexutil.Big)(big.NewInt(testAmount2ETHInWei)),
|
|
TokenID: pathprocessor.EthSymbol,
|
|
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet},
|
|
FromLockedAmount: map[uint64]*hexutil.Big{
|
|
walletCommon.OptimismMainnet: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
|
|
},
|
|
|
|
TestsMode: true,
|
|
TestParams: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
BalanceMap: map[string]*big.Int{},
|
|
},
|
|
},
|
|
expectedAmountOptions: map[uint64][]amountOption{
|
|
walletCommon.OptimismMainnet: {
|
|
{
|
|
amount: big.NewInt(testAmount1ETHInWei),
|
|
locked: true,
|
|
},
|
|
},
|
|
walletCommon.ArbitrumMainnet: {
|
|
{
|
|
amount: big.NewInt(testAmount1ETHInWei),
|
|
locked: false,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "Transfer - Multiple From Chains - Locked Amount To Multiple Chains",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: sendtype.Transfer,
|
|
AmountIn: (*hexutil.Big)(big.NewInt(testAmount2ETHInWei)),
|
|
TokenID: pathprocessor.EthSymbol,
|
|
DisabledFromChainIDs: []uint64{walletCommon.EthereumMainnet},
|
|
FromLockedAmount: map[uint64]*hexutil.Big{
|
|
walletCommon.OptimismMainnet: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
|
|
walletCommon.ArbitrumMainnet: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
|
|
},
|
|
|
|
TestsMode: true,
|
|
TestParams: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
BalanceMap: map[string]*big.Int{},
|
|
},
|
|
},
|
|
expectedAmountOptions: map[uint64][]amountOption{
|
|
walletCommon.OptimismMainnet: {
|
|
{
|
|
amount: big.NewInt(testAmount1ETHInWei),
|
|
locked: true,
|
|
},
|
|
},
|
|
walletCommon.ArbitrumMainnet: {
|
|
{
|
|
amount: big.NewInt(testAmount1ETHInWei),
|
|
locked: true,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "Transfer - All From Chains - Locked Amount To Multiple Chains Equal Total Amount",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: sendtype.Transfer,
|
|
AmountIn: (*hexutil.Big)(big.NewInt(testAmount2ETHInWei)),
|
|
TokenID: pathprocessor.EthSymbol,
|
|
FromLockedAmount: map[uint64]*hexutil.Big{
|
|
walletCommon.OptimismMainnet: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
|
|
walletCommon.ArbitrumMainnet: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
|
|
},
|
|
|
|
TestsMode: true,
|
|
TestParams: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
BalanceMap: map[string]*big.Int{},
|
|
},
|
|
},
|
|
expectedAmountOptions: map[uint64][]amountOption{
|
|
walletCommon.OptimismMainnet: {
|
|
{
|
|
amount: big.NewInt(testAmount1ETHInWei),
|
|
locked: true,
|
|
},
|
|
},
|
|
walletCommon.ArbitrumMainnet: {
|
|
{
|
|
amount: big.NewInt(testAmount1ETHInWei),
|
|
locked: true,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "Transfer - All From Chains - Locked Amount To Multiple Chains Is Less Than Total Amount",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: sendtype.Transfer,
|
|
AmountIn: (*hexutil.Big)(big.NewInt(testAmount5ETHInWei)),
|
|
TokenID: pathprocessor.EthSymbol,
|
|
FromLockedAmount: map[uint64]*hexutil.Big{
|
|
walletCommon.OptimismMainnet: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
|
|
walletCommon.ArbitrumMainnet: (*hexutil.Big)(big.NewInt(testAmount1ETHInWei)),
|
|
},
|
|
|
|
TestsMode: true,
|
|
TestParams: &requests.RouterTestParams{
|
|
TokenFrom: &token.Token{
|
|
ChainID: 1,
|
|
Symbol: pathprocessor.EthSymbol,
|
|
Decimals: 18,
|
|
},
|
|
BalanceMap: map[string]*big.Int{},
|
|
},
|
|
},
|
|
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,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "Transfer - All From Chain - No Locked Amount - Enough Token Balance If All Chains Are Used",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: sendtype.Transfer,
|
|
AmountIn: (*hexutil.Big)(big.NewInt(testAmount3ETHInWei)),
|
|
TokenID: pathprocessor.EthSymbol,
|
|
|
|
TestsMode: true,
|
|
TestParams: &requests.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),
|
|
},
|
|
},
|
|
},
|
|
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,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "Transfer - All From Chain - Locked Amount To Single Chain - Enough Token Balance If All Chains Are Used",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: sendtype.Transfer,
|
|
AmountIn: (*hexutil.Big)(big.NewInt(testAmount3ETHInWei)),
|
|
TokenID: pathprocessor.EthSymbol,
|
|
FromLockedAmount: map[uint64]*hexutil.Big{
|
|
walletCommon.OptimismMainnet: (*hexutil.Big)(big.NewInt(testAmount0Point5ETHInWei)),
|
|
},
|
|
|
|
TestsMode: true,
|
|
TestParams: &requests.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),
|
|
},
|
|
},
|
|
},
|
|
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,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "Transfer - All From Chain - Locked Amount To Multiple Chains - Enough Token Balance If All Chains Are Used",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: 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: &requests.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),
|
|
},
|
|
},
|
|
},
|
|
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,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "Transfer - All From Chain - No Locked Amount - Not Enough Token Balance",
|
|
input: &requests.RouteInputParams{
|
|
TestnetMode: false,
|
|
Uuid: uuid.NewString(),
|
|
SendType: sendtype.Transfer,
|
|
AmountIn: (*hexutil.Big)(big.NewInt(testAmount5ETHInWei)),
|
|
TokenID: pathprocessor.EthSymbol,
|
|
|
|
TestsMode: true,
|
|
TestParams: &requests.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),
|
|
},
|
|
},
|
|
},
|
|
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,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
}
|