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

chore_: `Bridge` interface renamed to `PathProcessor` interface and necessary changes applied due to that change

This commit is contained in:
Sale Djenic 2024-06-06 22:08:25 +02:00 committed by saledjenic
parent fe21fd9e97
commit 07cf6cd52d
37 changed files with 586 additions and 595 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -338,7 +338,7 @@ mock: ##@other Regenerate mocks
mockgen -package=status -destination=services/status/account_mock.go -source=services/status/service.go
mockgen -package=peer -destination=services/peer/discoverer_mock.go -source=services/peer/service.go
mockgen -package=mock_transactor -destination=transactions/mock_transactor/transactor.go -source=transactions/transactor.go
mockgen -package=mock_bridge -destination=services/wallet/bridge/mock_bridge/bridge.go -source=services/wallet/bridge/bridge.go
mockgen -package=mock_pathprocessor -destination=services/wallet/router/pathprocessor/mock_pathprocessor/processor.go -source=services/wallet/router/pathprocessor/processor.go
docker-test: ##@tests Run tests in a docker container with golang.
docker run --privileged --rm -it -v "$(PWD):$(DOCKER_TEST_WORKDIR)" -w "$(DOCKER_TEST_WORKDIR)" $(DOCKER_TEST_IMAGE) go test ${ARGS}

48
services/ens/api.go
View File

@ -124,7 +124,7 @@ func (api *API) GetRegistrarAddress(ctx context.Context, chainID uint64) (common
}
func (api *API) Resolver(ctx context.Context, chainID uint64, username string) (*common.Address, error) {
err := validateENSUsername(username)
err := ValidateENSUsername(username)
if err != nil {
return nil, err
}
@ -135,7 +135,7 @@ func (api *API) Resolver(ctx context.Context, chainID uint64, username string) (
}
callOpts := &bind.CallOpts{Context: ctx, Pending: false}
resolver, err := registry.Resolver(callOpts, nameHash(username))
resolver, err := registry.Resolver(callOpts, NameHash(username))
if err != nil {
return nil, err
}
@ -152,7 +152,7 @@ func (api *API) GetName(ctx context.Context, chainID uint64, address common.Addr
}
func (api *API) OwnerOf(ctx context.Context, chainID uint64, username string) (*common.Address, error) {
err := validateENSUsername(username)
err := ValidateENSUsername(username)
if err != nil {
return nil, err
}
@ -163,7 +163,7 @@ func (api *API) OwnerOf(ctx context.Context, chainID uint64, username string) (*
}
callOpts := &bind.CallOpts{Context: ctx, Pending: false}
owner, err := registry.Owner(callOpts, nameHash(username))
owner, err := registry.Owner(callOpts, NameHash(username))
if err != nil {
return nil, err
}
@ -172,7 +172,7 @@ func (api *API) OwnerOf(ctx context.Context, chainID uint64, username string) (*
}
func (api *API) ContentHash(ctx context.Context, chainID uint64, username string) ([]byte, error) {
err := validateENSUsername(username)
err := ValidateENSUsername(username)
if err != nil {
return nil, err
}
@ -188,7 +188,7 @@ func (api *API) ContentHash(ctx context.Context, chainID uint64, username string
}
callOpts := &bind.CallOpts{Context: ctx, Pending: false}
contentHash, err := resolver.Contenthash(callOpts, nameHash(username))
contentHash, err := resolver.Contenthash(callOpts, NameHash(username))
if err != nil {
return nil, nil
}
@ -197,7 +197,7 @@ func (api *API) ContentHash(ctx context.Context, chainID uint64, username string
}
func (api *API) PublicKeyOf(ctx context.Context, chainID uint64, username string) (string, error) {
err := validateENSUsername(username)
err := ValidateENSUsername(username)
if err != nil {
return "", err
}
@ -213,7 +213,7 @@ func (api *API) PublicKeyOf(ctx context.Context, chainID uint64, username string
}
callOpts := &bind.CallOpts{Context: ctx, Pending: false}
pubKey, err := resolver.Pubkey(callOpts, nameHash(username))
pubKey, err := resolver.Pubkey(callOpts, NameHash(username))
if err != nil {
return "", err
}
@ -221,7 +221,7 @@ func (api *API) PublicKeyOf(ctx context.Context, chainID uint64, username string
}
func (api *API) AddressOf(ctx context.Context, chainID uint64, username string) (*common.Address, error) {
err := validateENSUsername(username)
err := ValidateENSUsername(username)
if err != nil {
return nil, err
}
@ -237,7 +237,7 @@ func (api *API) AddressOf(ctx context.Context, chainID uint64, username string)
}
callOpts := &bind.CallOpts{Context: ctx, Pending: false}
addr, err := resolver.Addr(callOpts, nameHash(username))
addr, err := resolver.Addr(callOpts, NameHash(username))
if err != nil {
return nil, err
}
@ -308,7 +308,7 @@ func (api *API) ExpireAt(ctx context.Context, chainID uint64, username string) (
}
callOpts := &bind.CallOpts{Context: ctx, Pending: false}
expTime, err := registrar.GetExpirationTime(callOpts, usernameToLabel(username))
expTime, err := registrar.GetExpirationTime(callOpts, UsernameToLabel(username))
if err != nil {
return "", err
}
@ -348,7 +348,7 @@ func (api *API) Release(ctx context.Context, chainID uint64, txArgs transactions
}
txOpts := txArgs.ToTransactOpts(utils.GetSigner(chainID, api.accountsManager, api.config.KeyStoreDir, txArgs.From, password))
tx, err := registrar.Release(txOpts, usernameToLabel(username))
tx, err := registrar.Release(txOpts, UsernameToLabel(username))
if err != nil {
return "", err
}
@ -382,7 +382,7 @@ func (api *API) ReleasePrepareTxCallMsg(ctx context.Context, chainID uint64, txA
return ethereum.CallMsg{}, err
}
data, err := registrarABI.Pack("release", usernameToLabel(username))
data, err := registrarABI.Pack("release", UsernameToLabel(username))
if err != nil {
return ethereum.CallMsg{}, err
}
@ -414,7 +414,7 @@ func (api *API) ReleaseEstimate(ctx context.Context, chainID uint64, txArgs tran
return 0, err
}
data, err := registrarABI.Pack("release", usernameToLabel(username))
data, err := registrarABI.Pack("release", UsernameToLabel(username))
if err != nil {
return 0, err
}
@ -459,8 +459,8 @@ func (api *API) Register(ctx context.Context, chainID uint64, txArgs transaction
return "", err
}
x, y := extractCoordinates(pubkey)
extraData, err := registrarABI.Pack("register", usernameToLabel(username), common.Address(txArgs.From), x, y)
x, y := ExtractCoordinates(pubkey)
extraData, err := registrarABI.Pack("register", UsernameToLabel(username), common.Address(txArgs.From), x, y)
if err != nil {
return "", err
}
@ -517,8 +517,8 @@ func (api *API) RegisterPrepareTxCallMsg(ctx context.Context, chainID uint64, tx
return ethereum.CallMsg{}, err
}
x, y := extractCoordinates(pubkey)
extraData, err := registrarABI.Pack("register", usernameToLabel(username), common.Address(txArgs.From), x, y)
x, y := ExtractCoordinates(pubkey)
extraData, err := registrarABI.Pack("register", UsernameToLabel(username), common.Address(txArgs.From), x, y)
if err != nil {
return ethereum.CallMsg{}, err
}
@ -578,7 +578,7 @@ func (api *API) RegisterEstimate(ctx context.Context, chainID uint64, txArgs tra
}
func (api *API) SetPubKey(ctx context.Context, chainID uint64, txArgs transactions.SendTxArgs, password string, username string, pubkey string) (string, error) {
err := validateENSUsername(username)
err := ValidateENSUsername(username)
if err != nil {
return "", err
}
@ -593,9 +593,9 @@ func (api *API) SetPubKey(ctx context.Context, chainID uint64, txArgs transactio
return "", err
}
x, y := extractCoordinates(pubkey)
x, y := ExtractCoordinates(pubkey)
txOpts := txArgs.ToTransactOpts(utils.GetSigner(chainID, api.accountsManager, api.config.KeyStoreDir, txArgs.From, password))
tx, err := resolver.SetPubkey(txOpts, nameHash(username), x, y)
tx, err := resolver.SetPubkey(txOpts, NameHash(username), x, y)
if err != nil {
return "", err
}
@ -624,18 +624,18 @@ func (api *API) SetPubKey(ctx context.Context, chainID uint64, txArgs transactio
}
func (api *API) SetPubKeyPrepareTxCallMsg(ctx context.Context, chainID uint64, txArgs transactions.SendTxArgs, username string, pubkey string) (ethereum.CallMsg, error) {
err := validateENSUsername(username)
err := ValidateENSUsername(username)
if err != nil {
return ethereum.CallMsg{}, err
}
x, y := extractCoordinates(pubkey)
x, y := ExtractCoordinates(pubkey)
resolverABI, err := abi.JSON(strings.NewReader(resolver.PublicResolverABI))
if err != nil {
return ethereum.CallMsg{}, err
}
data, err := resolverABI.Pack("setPubkey", nameHash(username), x, y)
data, err := resolverABI.Pack("setPubkey", NameHash(username), x, y)
if err != nil {
return ethereum.CallMsg{}, err
}

8
services/ens/strings.go
View File

@ -9,7 +9,7 @@ import (
"github.com/ethereum/go-ethereum/crypto"
)
func nameHash(name string) common.Hash {
func NameHash(name string) common.Hash {
node := common.Hash{}
if len(name) > 0 {
@ -24,7 +24,7 @@ func nameHash(name string) common.Hash {
return node
}
func validateENSUsername(username string) error {
func ValidateENSUsername(username string) error {
if !strings.HasSuffix(username, ".eth") {
return fmt.Errorf("username must end with .eth")
}
@ -32,7 +32,7 @@ func validateENSUsername(username string) error {
return nil
}
func usernameToLabel(username string) [32]byte {
func UsernameToLabel(username string) [32]byte {
usernameHashed := crypto.Keccak256([]byte(username))
var label [32]byte
copy(label[:], usernameHashed)
@ -40,7 +40,7 @@ func usernameToLabel(username string) [32]byte {
return label
}
func extractCoordinates(pubkey string) ([32]byte, [32]byte) {
func ExtractCoordinates(pubkey string) ([32]byte, [32]byte) {
x, _ := hex.DecodeString(pubkey[4:68])
y, _ := hex.DecodeString(pubkey[68:132])

8
services/wallet/api.go
View File

@ -25,7 +25,7 @@ import (
"github.com/status-im/status-go/services/wallet/history"
"github.com/status-im/status-go/services/wallet/onramp"
"github.com/status-im/status-go/services/wallet/router"
"github.com/status-im/status-go/services/wallet/router/bridge"
"github.com/status-im/status-go/services/wallet/router/pathprocessor"
"github.com/status-im/status-go/services/wallet/thirdparty"
"github.com/status-im/status-go/services/wallet/token"
"github.com/status-im/status-go/services/wallet/transfer"
@ -576,7 +576,7 @@ func (api *API) SendTransactionWithSignature(ctx context.Context, chainID uint64
return api.s.transactionManager.SendTransactionWithSignature(chainID, params, sig)
}
func (api *API) CreateMultiTransaction(ctx context.Context, multiTransactionCommand *transfer.MultiTransactionCommand, data []*bridge.TransactionBridge, password string) (*transfer.MultiTransactionCommandResult, error) {
func (api *API) CreateMultiTransaction(ctx context.Context, multiTransactionCommand *transfer.MultiTransactionCommand, data []*pathprocessor.MultipathProcessorTxArgs, password string) (*transfer.MultiTransactionCommandResult, error) {
log.Debug("[WalletAPI:: CreateMultiTransaction] create multi transaction")
cmd, err := api.s.transactionManager.CreateMultiTransactionFromCommand(multiTransactionCommand, data)
@ -590,7 +590,7 @@ func (api *API) CreateMultiTransaction(ctx context.Context, multiTransactionComm
return nil, err
}
cmdRes, err := api.s.transactionManager.SendTransactions(ctx, cmd, data, api.router.GetBridges(), selectedAccount)
cmdRes, err := api.s.transactionManager.SendTransactions(ctx, cmd, data, api.router.GetPathProcessors(), selectedAccount)
if err != nil {
return nil, err
}
@ -603,7 +603,7 @@ func (api *API) CreateMultiTransaction(ctx context.Context, multiTransactionComm
return cmdRes, nil
}
return nil, api.s.transactionManager.SendTransactionForSigningToKeycard(ctx, cmd, data, api.router.GetBridges())
return nil, api.s.transactionManager.SendTransactionForSigningToKeycard(ctx, cmd, data, api.router.GetPathProcessors())
}
func (api *API) ProceedWithTransactionsSignatures(ctx context.Context, signatures map[string]transfer.SignatureDetails) (*transfer.MultiTransactionCommandResult, error) {

200
services/wallet/router/bridge/bridge.go
View File

@ -1,200 +0,0 @@
package bridge
import (
"encoding/hex"
"fmt"
"math/big"
"strings"
ethTypes "github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/accounts/abi/bind"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/crypto"
"github.com/status-im/status-go/account"
"github.com/status-im/status-go/eth-node/types"
"github.com/status-im/status-go/params"
"github.com/status-im/status-go/services/wallet/token"
"github.com/status-im/status-go/transactions"
)
var (
ZeroAddress = common.Address{}
ZeroBigIntValue = big.NewInt(0)
)
const (
IncreaseEstimatedGasFactor = 1.1
EthSymbol = "ETH"
SntSymbol = "SNT"
SttSymbol = "STT"
TransferName = "Transfer"
HopName = "Hop"
CBridgeName = "CBridge"
SwapParaswapName = "Paraswap"
ERC721TransferName = "ERC721Transfer"
ERC1155TransferName = "ERC1155Transfer"
ENSRegisterName = "ENSRegister"
ENSReleaseName = "ENSRelease"
ENSPublicKeyName = "ENSPublicKey"
)
func getSigner(chainID uint64, from types.Address, verifiedAccount *account.SelectedExtKey) bind.SignerFn {
return func(addr common.Address, tx *ethTypes.Transaction) (*ethTypes.Transaction, error) {
s := ethTypes.NewLondonSigner(new(big.Int).SetUint64(chainID))
return ethTypes.SignTx(tx, s, verifiedAccount.AccountKey.PrivateKey)
}
}
type TransactionBridge struct {
BridgeName string
ChainID uint64
TransferTx *transactions.SendTxArgs
HopTx *HopTxArgs
CbridgeTx *CBridgeTxArgs
ERC721TransferTx *ERC721TransferTxArgs
ERC1155TransferTx *ERC1155TransferTxArgs
SwapTx *SwapTxArgs
}
func (t *TransactionBridge) Value() *big.Int {
if t.TransferTx != nil && t.TransferTx.To != nil {
return t.TransferTx.Value.ToInt()
} else if t.HopTx != nil {
return t.HopTx.Amount.ToInt()
} else if t.CbridgeTx != nil {
return t.CbridgeTx.Amount.ToInt()
} else if t.ERC721TransferTx != nil {
return big.NewInt(1)
} else if t.ERC1155TransferTx != nil {
return t.ERC1155TransferTx.Amount.ToInt()
}
return big.NewInt(0)
}
func (t *TransactionBridge) From() types.Address {
if t.TransferTx != nil && t.TransferTx.To != nil {
return t.TransferTx.From
} else if t.HopTx != nil {
return t.HopTx.From
} else if t.CbridgeTx != nil {
return t.CbridgeTx.From
} else if t.ERC721TransferTx != nil {
return t.ERC721TransferTx.From
} else if t.ERC1155TransferTx != nil {
return t.ERC1155TransferTx.From
}
return types.HexToAddress("0x0")
}
func (t *TransactionBridge) To() types.Address {
if t.TransferTx != nil && t.TransferTx.To != nil {
return *t.TransferTx.To
} else if t.HopTx != nil {
return types.Address(t.HopTx.Recipient)
} else if t.CbridgeTx != nil {
return types.Address(t.HopTx.Recipient)
} else if t.ERC721TransferTx != nil {
return types.Address(t.ERC721TransferTx.Recipient)
} else if t.ERC1155TransferTx != nil {
return types.Address(t.ERC1155TransferTx.Recipient)
}
return types.HexToAddress("0x0")
}
func (t *TransactionBridge) Data() types.HexBytes {
if t.TransferTx != nil && t.TransferTx.To != nil {
return t.TransferTx.Data
} else if t.HopTx != nil {
return types.HexBytes("")
} else if t.CbridgeTx != nil {
return types.HexBytes("")
} else if t.ERC721TransferTx != nil {
return types.HexBytes("")
} else if t.ERC1155TransferTx != nil {
return types.HexBytes("")
}
return types.HexBytes("")
}
type BridgeParams struct {
FromChain *params.Network
ToChain *params.Network
FromAddr common.Address
ToAddr common.Address
FromToken *token.Token
ToToken *token.Token
AmountIn *big.Int
// extra params
BonderFee *big.Int
Username string
PublicKey string
}
type Bridge interface {
// returns the name of the bridge
Name() string
// checks if the bridge is available for the given networks/tokens
AvailableFor(params BridgeParams) (bool, error)
// calculates the fees for the bridge and returns the amount BonderFee and TokenFee (used for bridges)
CalculateFees(params BridgeParams) (*big.Int, *big.Int, error)
// Pack the method for sending tx and method call's data
PackTxInputData(params BridgeParams, contractType string) ([]byte, error)
EstimateGas(params BridgeParams) (uint64, error)
CalculateAmountOut(params BridgeParams) (*big.Int, error)
Send(sendArgs *TransactionBridge, verifiedAccount *account.SelectedExtKey) (types.Hash, error)
GetContractAddress(params BridgeParams) (common.Address, error)
BuildTransaction(sendArgs *TransactionBridge) (*ethTypes.Transaction, error)
BuildTx(params BridgeParams) (*ethTypes.Transaction, error)
}
func ValidateENSUsername(username string) error {
if !strings.HasSuffix(username, ".eth") {
return fmt.Errorf("username must end with .eth")
}
return nil
}
func extractCoordinates(pubkey string) ([32]byte, [32]byte) {
x, _ := hex.DecodeString(pubkey[4:68])
y, _ := hex.DecodeString(pubkey[68:132])
var xByte [32]byte
copy(xByte[:], x)
var yByte [32]byte
copy(yByte[:], y)
return xByte, yByte
}
func usernameToLabel(username string) [32]byte {
usernameHashed := crypto.Keccak256([]byte(username))
var label [32]byte
copy(label[:], usernameHashed)
return label
}
func nameHash(name string) common.Hash {
node := common.Hash{}
if len(name) > 0 {
labels := strings.Split(name, ".")
for i := len(labels) - 1; i >= 0; i-- {
labelSha := crypto.Keccak256Hash([]byte(labels[i]))
node = crypto.Keccak256Hash(node.Bytes(), labelSha.Bytes())
}
}
return node
}

2
services/wallet/router/bridge/mock_bridge/README.md
View File

@ -1,2 +0,0 @@
# To generate mocks, from status-go root directory:
mockgen -source=services/wallet/bridge/bridge.go -destination=services/wallet/bridge/mock_bridge/bridge.go -package=mock_bridge

4
services/wallet/router/filter.go
View File

@ -4,7 +4,7 @@ import (
"math/big"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/status-im/status-go/services/wallet/router/bridge"
"github.com/status-im/status-go/services/wallet/router/pathprocessor"
"go.uber.org/zap"
)
@ -89,7 +89,7 @@ func setupRouteValidationMapsV2(fromLockedAmount map[uint64]*hexutil.Big) (map[u
fromExcluded := make(map[uint64]bool)
for chainID, amount := range fromLockedAmount {
if amount.ToInt().Cmp(bridge.ZeroBigIntValue) <= 0 {
if amount.ToInt().Cmp(pathprocessor.ZeroBigIntValue) <= 0 {
fromExcluded[chainID] = false
} else {
fromIncluded[chainID] = false

12
services/wallet/router/filter_test.go
View File

@ -7,7 +7,7 @@ import (
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/status-im/status-go/params"
"github.com/status-im/status-go/services/wallet/router/bridge"
"github.com/status-im/status-go/services/wallet/router/pathprocessor"
"github.com/stretchr/testify/assert"
)
@ -84,9 +84,9 @@ func TestSetupRouteValidationMapsV2(t *testing.T) {
{
name: "Mixed zero and non-zero amounts",
fromLockedAmount: map[uint64]*hexutil.Big{
1: (*hexutil.Big)(bridge.ZeroBigIntValue),
1: (*hexutil.Big)(pathprocessor.ZeroBigIntValue),
2: (*hexutil.Big)(big.NewInt(200)),
3: (*hexutil.Big)(bridge.ZeroBigIntValue),
3: (*hexutil.Big)(pathprocessor.ZeroBigIntValue),
4: (*hexutil.Big)(big.NewInt(400)),
},
expectedIncluded: map[uint64]bool{
@ -113,8 +113,8 @@ func TestSetupRouteValidationMapsV2(t *testing.T) {
{
name: "All zero amounts",
fromLockedAmount: map[uint64]*hexutil.Big{
1: (*hexutil.Big)(bridge.ZeroBigIntValue),
2: (*hexutil.Big)(bridge.ZeroBigIntValue),
1: (*hexutil.Big)(pathprocessor.ZeroBigIntValue),
2: (*hexutil.Big)(pathprocessor.ZeroBigIntValue),
},
expectedIncluded: map[uint64]bool{},
expectedExcluded: map[uint64]bool{
@ -135,7 +135,7 @@ func TestSetupRouteValidationMapsV2(t *testing.T) {
{
name: "Single zero amount",
fromLockedAmount: map[uint64]*hexutil.Big{
1: (*hexutil.Big)(bridge.ZeroBigIntValue),
1: (*hexutil.Big)(pathprocessor.ZeroBigIntValue),
},
expectedIncluded: map[uint64]bool{},
expectedExcluded: map[uint64]bool{

0
services/wallet/router/bridge/cbridge/cbridge.pb.go → services/wallet/router/pathprocessor/cbridge/cbridge.pb.go
View File

0
services/wallet/router/bridge/cbridge/gateway.pb.go → services/wallet/router/pathprocessor/cbridge/gateway.pb.go
View File

0
services/wallet/router/bridge/cbridge/query.pb.go → services/wallet/router/pathprocessor/cbridge/query.pb.go
View File

19
services/wallet/router/pathprocessor/common.go Normal file
View File

@ -0,0 +1,19 @@
package pathprocessor
import (
"math/big"
ethTypes "github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/accounts/abi/bind"
"github.com/ethereum/go-ethereum/common"
"github.com/status-im/status-go/account"
"github.com/status-im/status-go/eth-node/types"
)
func getSigner(chainID uint64, from types.Address, verifiedAccount *account.SelectedExtKey) bind.SignerFn {
return func(addr common.Address, tx *ethTypes.Transaction) (*ethTypes.Transaction, error) {
s := ethTypes.NewLondonSigner(new(big.Int).SetUint64(chainID))
return ethTypes.SignTx(tx, s, verifiedAccount.AccountKey.PrivateKey)
}
}

30
services/wallet/router/pathprocessor/constants.go Normal file
View File

@ -0,0 +1,30 @@
package pathprocessor
import (
"math/big"
"github.com/ethereum/go-ethereum/common"
)
var (
ZeroAddress = common.Address{}
ZeroBigIntValue = big.NewInt(0)
)
const (
IncreaseEstimatedGasFactor = 1.1
EthSymbol = "ETH"
SntSymbol = "SNT"
SttSymbol = "STT"
ProcessorTransferName = "Transfer"
ProcessorBridgeHopName = "Hop"
ProcessorBridgeCelerName = "CBridge"
ProcessorSwapParaswapName = "Paraswap"
ProcessorERC721Name = "ERC721Transfer"
ProcessorERC1155Name = "ERC1155Transfer"
ProcessorENSRegisterName = "ENSRegister"
ProcessorENSReleaseName = "ENSRelease"
ProcessorENSPublicKeyName = "ENSPublicKey"
)

93
services/wallet/router/bridge/mock_bridge/bridge.go → services/wallet/router/pathprocessor/mock_pathprocessor/processor.go
View File

@ -1,47 +1,46 @@
// Code generated by MockGen. DO NOT EDIT.
// Source: services/wallet/bridge/bridge.go
// Source: services/wallet/router/pathprocessor/processor.go
// Package mock_bridge is a generated GoMock package.
package mock_bridge
// Package mock_pathprocessor is a generated GoMock package.
package mock_pathprocessor
import (
big "math/big"
reflect "reflect"
gomock "github.com/golang/mock/gomock"
common "github.com/ethereum/go-ethereum/common"
types "github.com/ethereum/go-ethereum/core/types"
gomock "github.com/golang/mock/gomock"
account "github.com/status-im/status-go/account"
types0 "github.com/status-im/status-go/eth-node/types"
bridge "github.com/status-im/status-go/services/wallet/router/bridge"
pathprocessor "github.com/status-im/status-go/services/wallet/router/pathprocessor"
)
// MockBridge is a mock of Bridge interface.
type MockBridge struct {
// MockPathProcessor is a mock of PathProcessor interface.
type MockPathProcessor struct {
ctrl *gomock.Controller
recorder *MockBridgeMockRecorder
recorder *MockPathProcessorMockRecorder
}
// MockBridgeMockRecorder is the mock recorder for MockBridge.
type MockBridgeMockRecorder struct {
mock *MockBridge
// MockPathProcessorMockRecorder is the mock recorder for MockPathProcessor.
type MockPathProcessorMockRecorder struct {
mock *MockPathProcessor
}
// NewMockBridge creates a new mock instance.
func NewMockBridge(ctrl *gomock.Controller) *MockBridge {
mock := &MockBridge{ctrl: ctrl}
mock.recorder = &MockBridgeMockRecorder{mock}
// NewMockPathProcessor creates a new mock instance.
func NewMockPathProcessor(ctrl *gomock.Controller) *MockPathProcessor {
mock := &MockPathProcessor{ctrl: ctrl}
mock.recorder = &MockPathProcessorMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockBridge) EXPECT() *MockBridgeMockRecorder {
func (m *MockPathProcessor) EXPECT() *MockPathProcessorMockRecorder {
return m.recorder
}
// AvailableFor mocks base method.
func (m *MockBridge) AvailableFor(params bridge.BridgeParams) (bool, error) {
func (m *MockPathProcessor) AvailableFor(params pathprocessor.ProcessorInputParams) (bool, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AvailableFor", params)
ret0, _ := ret[0].(bool)
@ -50,13 +49,13 @@ func (m *MockBridge) AvailableFor(params bridge.BridgeParams) (bool, error) {
}
// AvailableFor indicates an expected call of AvailableFor.
func (mr *MockBridgeMockRecorder) AvailableFor(params interface{}) *gomock.Call {
func (mr *MockPathProcessorMockRecorder) AvailableFor(params interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AvailableFor", reflect.TypeOf((*MockBridge)(nil).AvailableFor), params)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AvailableFor", reflect.TypeOf((*MockPathProcessor)(nil).AvailableFor), params)
}
// BuildTransaction mocks base method.
func (m *MockBridge) BuildTransaction(sendArgs *bridge.TransactionBridge) (*types.Transaction, error) {
func (m *MockPathProcessor) BuildTransaction(sendArgs *pathprocessor.MultipathProcessorTxArgs) (*types.Transaction, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "BuildTransaction", sendArgs)
ret0, _ := ret[0].(*types.Transaction)
@ -65,13 +64,13 @@ func (m *MockBridge) BuildTransaction(sendArgs *bridge.TransactionBridge) (*type
}
// BuildTransaction indicates an expected call of BuildTransaction.
func (mr *MockBridgeMockRecorder) BuildTransaction(sendArgs interface{}) *gomock.Call {
func (mr *MockPathProcessorMockRecorder) BuildTransaction(sendArgs interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildTransaction", reflect.TypeOf((*MockBridge)(nil).BuildTransaction), sendArgs)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildTransaction", reflect.TypeOf((*MockPathProcessor)(nil).BuildTransaction), sendArgs)
}
// BuildTx mocks base method.
func (m *MockBridge) BuildTx(params bridge.BridgeParams) (*types.Transaction, error) {
func (m *MockPathProcessor) BuildTx(params pathprocessor.ProcessorInputParams) (*types.Transaction, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "BuildTx", params)
ret0, _ := ret[0].(*types.Transaction)
@ -80,13 +79,13 @@ func (m *MockBridge) BuildTx(params bridge.BridgeParams) (*types.Transaction, er
}
// BuildTx indicates an expected call of BuildTx.
func (mr *MockBridgeMockRecorder) BuildTx(params interface{}) *gomock.Call {
func (mr *MockPathProcessorMockRecorder) BuildTx(params interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildTx", reflect.TypeOf((*MockBridge)(nil).BuildTx), params)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildTx", reflect.TypeOf((*MockPathProcessor)(nil).BuildTx), params)
}
// CalculateAmountOut mocks base method.
func (m *MockBridge) CalculateAmountOut(params bridge.BridgeParams) (*big.Int, error) {
func (m *MockPathProcessor) CalculateAmountOut(params pathprocessor.ProcessorInputParams) (*big.Int, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CalculateAmountOut", params)
ret0, _ := ret[0].(*big.Int)
@ -95,13 +94,13 @@ func (m *MockBridge) CalculateAmountOut(params bridge.BridgeParams) (*big.Int, e
}
// CalculateAmountOut indicates an expected call of CalculateAmountOut.
func (mr *MockBridgeMockRecorder) CalculateAmountOut(params interface{}) *gomock.Call {
func (mr *MockPathProcessorMockRecorder) CalculateAmountOut(params interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalculateAmountOut", reflect.TypeOf((*MockBridge)(nil).CalculateAmountOut), params)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalculateAmountOut", reflect.TypeOf((*MockPathProcessor)(nil).CalculateAmountOut), params)
}
// CalculateFees mocks base method.
func (m *MockBridge) CalculateFees(params bridge.BridgeParams) (*big.Int, *big.Int, error) {
func (m *MockPathProcessor) CalculateFees(params pathprocessor.ProcessorInputParams) (*big.Int, *big.Int, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CalculateFees", params)
ret0, _ := ret[0].(*big.Int)
@ -111,13 +110,13 @@ func (m *MockBridge) CalculateFees(params bridge.BridgeParams) (*big.Int, *big.I
}
// CalculateFees indicates an expected call of CalculateFees.
func (mr *MockBridgeMockRecorder) CalculateFees(params interface{}) *gomock.Call {
func (mr *MockPathProcessorMockRecorder) CalculateFees(params interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalculateFees", reflect.TypeOf((*MockBridge)(nil).CalculateFees), params)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalculateFees", reflect.TypeOf((*MockPathProcessor)(nil).CalculateFees), params)
}
// EstimateGas mocks base method.
func (m *MockBridge) EstimateGas(params bridge.BridgeParams) (uint64, error) {
func (m *MockPathProcessor) EstimateGas(params pathprocessor.ProcessorInputParams) (uint64, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "EstimateGas", params)
ret0, _ := ret[0].(uint64)
@ -126,13 +125,13 @@ func (m *MockBridge) EstimateGas(params bridge.BridgeParams) (uint64, error) {
}
// EstimateGas indicates an expected call of EstimateGas.
func (mr *MockBridgeMockRecorder) EstimateGas(params interface{}) *gomock.Call {
func (mr *MockPathProcessorMockRecorder) EstimateGas(params interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimateGas", reflect.TypeOf((*MockBridge)(nil).EstimateGas), params)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimateGas", reflect.TypeOf((*MockPathProcessor)(nil).EstimateGas), params)
}
// GetContractAddress mocks base method.
func (m *MockBridge) GetContractAddress(params bridge.BridgeParams) (common.Address, error) {
func (m *MockPathProcessor) GetContractAddress(params pathprocessor.ProcessorInputParams) (common.Address, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetContractAddress", params)
ret0, _ := ret[0].(common.Address)
@ -141,13 +140,13 @@ func (m *MockBridge) GetContractAddress(params bridge.BridgeParams) (common.Addr
}
// GetContractAddress indicates an expected call of GetContractAddress.
func (mr *MockBridgeMockRecorder) GetContractAddress(params interface{}) *gomock.Call {
func (mr *MockPathProcessorMockRecorder) GetContractAddress(params interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContractAddress", reflect.TypeOf((*MockBridge)(nil).GetContractAddress), params)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContractAddress", reflect.TypeOf((*MockPathProcessor)(nil).GetContractAddress), params)
}
// Name mocks base method.
func (m *MockBridge) Name() string {
func (m *MockPathProcessor) Name() string {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Name")
ret0, _ := ret[0].(string)
@ -155,13 +154,13 @@ func (m *MockBridge) Name() string {
}
// Name indicates an expected call of Name.
func (mr *MockBridgeMockRecorder) Name() *gomock.Call {
func (mr *MockPathProcessorMockRecorder) Name() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockBridge)(nil).Name))
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockPathProcessor)(nil).Name))
}
// PackTxInputData mocks base method.
func (m *MockBridge) PackTxInputData(params bridge.BridgeParams, contractType string) ([]byte, error) {
func (m *MockPathProcessor) PackTxInputData(params pathprocessor.ProcessorInputParams, contractType string) ([]byte, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PackTxInputData", params, contractType)
ret0, _ := ret[0].([]byte)
@ -170,13 +169,13 @@ func (m *MockBridge) PackTxInputData(params bridge.BridgeParams, contractType st
}
// PackTxInputData indicates an expected call of PackTxInputData.
func (mr *MockBridgeMockRecorder) PackTxInputData(params, contractType interface{}) *gomock.Call {
func (mr *MockPathProcessorMockRecorder) PackTxInputData(params, contractType interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PackTxInputData", reflect.TypeOf((*MockBridge)(nil).PackTxInputData), params, contractType)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PackTxInputData", reflect.TypeOf((*MockPathProcessor)(nil).PackTxInputData), params, contractType)
}
// Send mocks base method.
func (m *MockBridge) Send(sendArgs *bridge.TransactionBridge, verifiedAccount *account.SelectedExtKey) (types0.Hash, error) {
func (m *MockPathProcessor) Send(sendArgs *pathprocessor.MultipathProcessorTxArgs, verifiedAccount *account.SelectedExtKey) (types0.Hash, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Send", sendArgs, verifiedAccount)
ret0, _ := ret[0].(types0.Hash)
@ -185,7 +184,7 @@ func (m *MockBridge) Send(sendArgs *bridge.TransactionBridge, verifiedAccount *a
}
// Send indicates an expected call of Send.
func (mr *MockBridgeMockRecorder) Send(sendArgs, verifiedAccount interface{}) *gomock.Call {
func (mr *MockPathProcessorMockRecorder) Send(sendArgs, verifiedAccount interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockBridge)(nil).Send), sendArgs, verifiedAccount)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockPathProcessor)(nil).Send), sendArgs, verifiedAccount)
}

83
services/wallet/router/pathprocessor/multipath_processor.go Normal file
View File

@ -0,0 +1,83 @@
package pathprocessor
import (
"math/big"
"github.com/status-im/status-go/eth-node/types"
"github.com/status-im/status-go/transactions"
)
type MultipathProcessorTxArgs struct {
Name string
ChainID uint64
TransferTx *transactions.SendTxArgs
HopTx *HopBridgeTxArgs
CbridgeTx *CelerBridgeTxArgs
ERC721TransferTx *ERC721TxArgs
ERC1155TransferTx *ERC1155TxArgs
SwapTx *SwapParaswapTxArgs
}
func (t *MultipathProcessorTxArgs) Value() *big.Int {
if t.TransferTx != nil && t.TransferTx.To != nil {
return t.TransferTx.Value.ToInt()
} else if t.HopTx != nil {
return t.HopTx.Amount.ToInt()
} else if t.CbridgeTx != nil {
return t.CbridgeTx.Amount.ToInt()
} else if t.ERC721TransferTx != nil {
return big.NewInt(1)
} else if t.ERC1155TransferTx != nil {
return t.ERC1155TransferTx.Amount.ToInt()
}
return ZeroBigIntValue
}
func (t *MultipathProcessorTxArgs) From() types.Address {
if t.TransferTx != nil && t.TransferTx.To != nil {
return t.TransferTx.From
} else if t.HopTx != nil {
return t.HopTx.From
} else if t.CbridgeTx != nil {
return t.CbridgeTx.From
} else if t.ERC721TransferTx != nil {
return t.ERC721TransferTx.From
} else if t.ERC1155TransferTx != nil {
return t.ERC1155TransferTx.From
}
return types.HexToAddress("0x0")
}
func (t *MultipathProcessorTxArgs) To() types.Address {
if t.TransferTx != nil && t.TransferTx.To != nil {
return *t.TransferTx.To
} else if t.HopTx != nil {
return types.Address(t.HopTx.Recipient)
} else if t.CbridgeTx != nil {
return types.Address(t.HopTx.Recipient)
} else if t.ERC721TransferTx != nil {
return types.Address(t.ERC721TransferTx.Recipient)
} else if t.ERC1155TransferTx != nil {
return types.Address(t.ERC1155TransferTx.Recipient)
}
return types.HexToAddress("0x0")
}
func (t *MultipathProcessorTxArgs) Data() types.HexBytes {
if t.TransferTx != nil && t.TransferTx.To != nil {
return t.TransferTx.Data
} else if t.HopTx != nil {
return types.HexBytes("")
} else if t.CbridgeTx != nil {
return types.HexBytes("")
} else if t.ERC721TransferTx != nil {
return types.HexBytes("")
} else if t.ERC1155TransferTx != nil {
return types.HexBytes("")
}
return types.HexBytes("")
}

45
services/wallet/router/pathprocessor/processor.go Normal file
View File

@ -0,0 +1,45 @@
package pathprocessor
import (
"math/big"
ethTypes "github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/common"
"github.com/status-im/status-go/account"
"github.com/status-im/status-go/eth-node/types"
"github.com/status-im/status-go/params"
"github.com/status-im/status-go/services/wallet/token"
)
type PathProcessor interface {
// returns the name of the bridge
Name() string
// checks if the bridge is available for the given networks/tokens
AvailableFor(params ProcessorInputParams) (bool, error)
// calculates the fees for the bridge and returns the amount BonderFee and TokenFee (used for bridges)
CalculateFees(params ProcessorInputParams) (*big.Int, *big.Int, error)
// Pack the method for sending tx and method call's data
PackTxInputData(params ProcessorInputParams, contractType string) ([]byte, error)
EstimateGas(params ProcessorInputParams) (uint64, error)
CalculateAmountOut(params ProcessorInputParams) (*big.Int, error)
Send(sendArgs *MultipathProcessorTxArgs, verifiedAccount *account.SelectedExtKey) (types.Hash, error)
GetContractAddress(params ProcessorInputParams) (common.Address, error)
BuildTransaction(sendArgs *MultipathProcessorTxArgs) (*ethTypes.Transaction, error)
BuildTx(params ProcessorInputParams) (*ethTypes.Transaction, error)
}
type ProcessorInputParams struct {
FromChain *params.Network
ToChain *params.Network
FromAddr common.Address
ToAddr common.Address
FromToken *token.Token
ToToken *token.Token
AmountIn *big.Int
// extra params
BonderFee *big.Int
Username string
PublicKey string
}

48
services/wallet/router/bridge/cbridge.go → services/wallet/router/pathprocessor/processor_bridge_celar.go
View File

@ -1,4 +1,4 @@
package bridge
package pathprocessor
import (
"context"
@ -23,7 +23,7 @@ import (
"github.com/status-im/status-go/rpc"
"github.com/status-im/status-go/params"
"github.com/status-im/status-go/services/wallet/router/bridge/cbridge"
"github.com/status-im/status-go/services/wallet/router/pathprocessor/cbridge"
"github.com/status-im/status-go/services/wallet/thirdparty"
"github.com/status-im/status-go/services/wallet/token"
"github.com/status-im/status-go/transactions"
@ -36,7 +36,7 @@ const (
maxSlippage = uint32(1000)
)
type CBridgeTxArgs struct {
type CelerBridgeTxArgs struct {
transactions.SendTxArgs
ChainID uint64 `json:"chainId"`
Symbol string `json:"symbol"`
@ -44,7 +44,7 @@ type CBridgeTxArgs struct {
Amount *hexutil.Big `json:"amount"`
}
type CBridge struct {
type CelerBridgeProcessor struct {
rpcClient *rpc.Client
httpClient *thirdparty.HTTPClient
transactor transactions.TransactorIface
@ -53,8 +53,8 @@ type CBridge struct {
testTransferConfig *cbridge.GetTransferConfigsResponse
}
func NewCbridge(rpcClient *rpc.Client, transactor transactions.TransactorIface, tokenManager *token.Manager) *CBridge {
return &CBridge{
func NewCelerBridgeProcessor(rpcClient *rpc.Client, transactor transactions.TransactorIface, tokenManager *token.Manager) *CelerBridgeProcessor {
return &CelerBridgeProcessor{
rpcClient: rpcClient,
httpClient: thirdparty.NewHTTPClient(),
transactor: transactor,
@ -62,11 +62,11 @@ func NewCbridge(rpcClient *rpc.Client, transactor transactions.TransactorIface,
}
}
func (s *CBridge) Name() string {
return CBridgeName
func (s *CelerBridgeProcessor) Name() string {
return ProcessorBridgeCelerName
}
func (s *CBridge) estimateAmt(from, to *params.Network, amountIn *big.Int, symbol string) (*cbridge.EstimateAmtResponse, error) {
func (s *CelerBridgeProcessor) estimateAmt(from, to *params.Network, amountIn *big.Int, symbol string) (*cbridge.EstimateAmtResponse, error) {
base := baseURL
if from.IsTest {
base = testBaseURL
@ -94,7 +94,7 @@ func (s *CBridge) estimateAmt(from, to *params.Network, amountIn *big.Int, symbo
return &res, nil
}
func (s *CBridge) getTransferConfig(isTest bool) (*cbridge.GetTransferConfigsResponse, error) {
func (s *CelerBridgeProcessor) getTransferConfig(isTest bool) (*cbridge.GetTransferConfigsResponse, error) {
if !isTest && s.prodTransferConfig != nil {
return s.prodTransferConfig, nil
}
@ -126,7 +126,7 @@ func (s *CBridge) getTransferConfig(isTest bool) (*cbridge.GetTransferConfigsRes
return &res, nil
}
func (s *CBridge) AvailableFor(params BridgeParams) (bool, error) {
func (s *CelerBridgeProcessor) AvailableFor(params ProcessorInputParams) (bool, error) {
if params.FromChain.ChainID == params.ToChain.ChainID || params.ToToken != nil {
return false, nil
}
@ -185,7 +185,7 @@ func (s *CBridge) AvailableFor(params BridgeParams) (bool, error) {
return true, nil
}
func (s *CBridge) CalculateFees(params BridgeParams) (*big.Int, *big.Int, error) {
func (s *CelerBridgeProcessor) CalculateFees(params ProcessorInputParams) (*big.Int, *big.Int, error) {
amt, err := s.estimateAmt(params.FromChain, params.ToChain, params.AmountIn, params.FromToken.Symbol)
if err != nil {
return nil, nil, err
@ -199,10 +199,10 @@ func (s *CBridge) CalculateFees(params BridgeParams) (*big.Int, *big.Int, error)
return nil, nil, errors.New("failed to parse percentage fee")
}
return big.NewInt(0), new(big.Int).Add(baseFee, percFee), nil
return ZeroBigIntValue, new(big.Int).Add(baseFee, percFee), nil
}
func (c *CBridge) PackTxInputData(params BridgeParams, contractType string) ([]byte, error) {
func (c *CelerBridgeProcessor) PackTxInputData(params ProcessorInputParams, contractType string) ([]byte, error) {
abi, err := abi.JSON(strings.NewReader(celer.CelerABI))
if err != nil {
return []byte{}, err
@ -228,7 +228,7 @@ func (c *CBridge) PackTxInputData(params BridgeParams, contractType string) ([]b
}
}
func (s *CBridge) EstimateGas(params BridgeParams) (uint64, error) {
func (s *CelerBridgeProcessor) EstimateGas(params ProcessorInputParams) (uint64, error) {
value := new(big.Int)
input, err := s.PackTxInputData(params, "")
@ -270,10 +270,10 @@ func (s *CBridge) EstimateGas(params BridgeParams) (uint64, error) {
return uint64(increasedEstimation), nil
}
func (s *CBridge) BuildTx(params BridgeParams) (*ethTypes.Transaction, error) {
func (s *CelerBridgeProcessor) BuildTx(params ProcessorInputParams) (*ethTypes.Transaction, error) {
toAddr := types.Address(params.ToAddr)
sendArgs := &TransactionBridge{
CbridgeTx: &CBridgeTxArgs{
sendArgs := &MultipathProcessorTxArgs{
CbridgeTx: &CelerBridgeTxArgs{
SendTxArgs: transactions.SendTxArgs{
From: types.Address(params.FromAddr),
To: &toAddr,
@ -291,7 +291,7 @@ func (s *CBridge) BuildTx(params BridgeParams) (*ethTypes.Transaction, error) {
return s.BuildTransaction(sendArgs)
}
func (s *CBridge) GetContractAddress(params BridgeParams) (common.Address, error) {
func (s *CelerBridgeProcessor) GetContractAddress(params ProcessorInputParams) (common.Address, error) {
transferConfig, err := s.getTransferConfig(params.FromChain.IsTest)
if err != nil {
return common.Address{}, err
@ -309,7 +309,7 @@ func (s *CBridge) GetContractAddress(params BridgeParams) (common.Address, error
return common.Address{}, errors.New("contract not found")
}
func (s *CBridge) sendOrBuild(sendArgs *TransactionBridge, signerFn bind.SignerFn) (*ethTypes.Transaction, error) {
func (s *CelerBridgeProcessor) sendOrBuild(sendArgs *MultipathProcessorTxArgs, signerFn bind.SignerFn) (*ethTypes.Transaction, error) {
fromChain := s.rpcClient.NetworkManager.Find(sendArgs.ChainID)
if fromChain == nil {
return nil, errors.New("network not found")
@ -318,7 +318,7 @@ func (s *CBridge) sendOrBuild(sendArgs *TransactionBridge, signerFn bind.SignerF
if token == nil {
return nil, errors.New("token not found")
}
addrs, err := s.GetContractAddress(BridgeParams{
addrs, err := s.GetContractAddress(ProcessorInputParams{
FromChain: fromChain,
})
if err != nil {
@ -357,7 +357,7 @@ func (s *CBridge) sendOrBuild(sendArgs *TransactionBridge, signerFn bind.SignerF
)
}
func (s *CBridge) Send(sendArgs *TransactionBridge, verifiedAccount *account.SelectedExtKey) (types.Hash, error) {
func (s *CelerBridgeProcessor) Send(sendArgs *MultipathProcessorTxArgs, verifiedAccount *account.SelectedExtKey) (types.Hash, error) {
tx, err := s.sendOrBuild(sendArgs, getSigner(sendArgs.ChainID, sendArgs.CbridgeTx.From, verifiedAccount))
if err != nil {
return types.HexToHash(""), err
@ -366,11 +366,11 @@ func (s *CBridge) Send(sendArgs *TransactionBridge, verifiedAccount *account.Sel
return types.Hash(tx.Hash()), nil
}
func (s *CBridge) BuildTransaction(sendArgs *TransactionBridge) (*ethTypes.Transaction, error) {
func (s *CelerBridgeProcessor) BuildTransaction(sendArgs *MultipathProcessorTxArgs) (*ethTypes.Transaction, error) {
return s.sendOrBuild(sendArgs, nil)
}
func (s *CBridge) CalculateAmountOut(params BridgeParams) (*big.Int, error) {
func (s *CelerBridgeProcessor) CalculateAmountOut(params ProcessorInputParams) (*big.Int, error) {
amt, err := s.estimateAmt(params.FromChain, params.ToChain, params.AmountIn, params.FromToken.Symbol)
if err != nil {
return nil, err

70
services/wallet/router/bridge/hop.go → services/wallet/router/pathprocessor/processor_bridge_hop.go
View File

@ -1,4 +1,4 @@
package bridge
package pathprocessor
import (
"context"
@ -41,7 +41,7 @@ const (
hopSymbol = "HOP"
)
type HopTxArgs struct {
type HopBridgeTxArgs struct {
transactions.SendTxArgs
ChainID uint64 `json:"chainId"`
Symbol string `json:"symbol"`
@ -105,7 +105,7 @@ func (bf *BonderFee) UnmarshalJSON(data []byte) error {
return nil
}
type HopBridge struct {
type HopBridgeProcessor struct {
transactor transactions.TransactorIface
httpClient *thirdparty.HTTPClient
tokenManager *token.Manager
@ -113,8 +113,8 @@ type HopBridge struct {
bonderFee *BonderFee
}
func NewHopBridge(rpcClient *rpc.Client, transactor transactions.TransactorIface, tokenManager *token.Manager) *HopBridge {
return &HopBridge{
func NewHopBridgeProcessor(rpcClient *rpc.Client, transactor transactions.TransactorIface, tokenManager *token.Manager) *HopBridgeProcessor {
return &HopBridgeProcessor{
contractMaker: &contracts.ContractMaker{RPCClient: rpcClient},
httpClient: thirdparty.NewHTTPClient(),
transactor: transactor,
@ -122,18 +122,18 @@ func NewHopBridge(rpcClient *rpc.Client, transactor transactions.TransactorIface
}
}
func (h *HopBridge) Name() string {
return HopName
func (h *HopBridgeProcessor) Name() string {
return ProcessorBridgeHopName
}
func (h *HopBridge) AvailableFor(params BridgeParams) (bool, error) {
func (h *HopBridgeProcessor) AvailableFor(params ProcessorInputParams) (bool, error) {
// We chcek if the contract is available on the network for the token
_, err := h.GetContractAddress(params)
// toToken is not nil only if the send type is Swap
return err == nil && params.ToToken == nil, nil
}
func (c *HopBridge) getAppropriateABI(contractType string, chainID uint64, token *token.Token) (abi.ABI, error) {
func (c *HopBridgeProcessor) getAppropriateABI(contractType string, chainID uint64, token *token.Token) (abi.ABI, error) {
switch contractType {
case hop.CctpL1Bridge:
return abi.JSON(strings.NewReader(hopL1CctpImplementation.HopL1CctpImplementationABI))
@ -163,7 +163,7 @@ func (c *HopBridge) getAppropriateABI(contractType string, chainID uint64, token
return abi.ABI{}, errors.New("not available for contract type")
}
func (h *HopBridge) PackTxInputData(params BridgeParams, contractType string) ([]byte, error) {
func (h *HopBridgeProcessor) PackTxInputData(params ProcessorInputParams, contractType string) ([]byte, error) {
abi, err := h.getAppropriateABI(contractType, params.FromChain.ChainID, params.FromToken)
if err != nil {
return []byte{}, err
@ -185,7 +185,7 @@ func (h *HopBridge) PackTxInputData(params BridgeParams, contractType string) ([
return []byte{}, errors.New("contract type not supported yet")
}
func (h *HopBridge) EstimateGas(params BridgeParams) (uint64, error) {
func (h *HopBridgeProcessor) EstimateGas(params ProcessorInputParams) (uint64, error) {
value := big.NewInt(0)
if params.FromToken.IsNative() {
value = params.AmountIn
@ -229,10 +229,10 @@ func (h *HopBridge) EstimateGas(params BridgeParams) (uint64, error) {
return uint64(increasedEstimation), nil
}
func (h *HopBridge) BuildTx(params BridgeParams) (*ethTypes.Transaction, error) {
func (h *HopBridgeProcessor) BuildTx(params ProcessorInputParams) (*ethTypes.Transaction, error) {
toAddr := types.Address(params.ToAddr)
sendArgs := &TransactionBridge{
HopTx: &HopTxArgs{
sendArgs := &MultipathProcessorTxArgs{
HopTx: &HopBridgeTxArgs{
SendTxArgs: transactions.SendTxArgs{
From: types.Address(params.FromAddr),
To: &toAddr,
@ -251,12 +251,12 @@ func (h *HopBridge) BuildTx(params BridgeParams) (*ethTypes.Transaction, error)
return h.BuildTransaction(sendArgs)
}
func (h *HopBridge) GetContractAddress(params BridgeParams) (common.Address, error) {
func (h *HopBridgeProcessor) GetContractAddress(params ProcessorInputParams) (common.Address, error) {
address, _, err := hop.GetContractAddress(params.FromChain.ChainID, params.FromToken.Symbol)
return address, err
}
func (h *HopBridge) sendOrBuild(sendArgs *TransactionBridge, signerFn bind.SignerFn) (tx *ethTypes.Transaction, err error) {
func (h *HopBridgeProcessor) sendOrBuild(sendArgs *MultipathProcessorTxArgs, signerFn bind.SignerFn) (tx *ethTypes.Transaction, err error) {
fromChain := h.contractMaker.RPCClient.NetworkManager.Find(sendArgs.ChainID)
if fromChain == nil {
return tx, fmt.Errorf("ChainID not supported %d", sendArgs.ChainID)
@ -303,7 +303,7 @@ func (h *HopBridge) sendOrBuild(sendArgs *TransactionBridge, signerFn bind.Signe
return tx, err
}
func (h *HopBridge) Send(sendArgs *TransactionBridge, verifiedAccount *account.SelectedExtKey) (hash types.Hash, err error) {
func (h *HopBridgeProcessor) Send(sendArgs *MultipathProcessorTxArgs, verifiedAccount *account.SelectedExtKey) (hash types.Hash, err error) {
tx, err := h.sendOrBuild(sendArgs, getSigner(sendArgs.ChainID, sendArgs.HopTx.From, verifiedAccount))
if err != nil {
return types.Hash{}, err
@ -311,11 +311,11 @@ func (h *HopBridge) Send(sendArgs *TransactionBridge, verifiedAccount *account.S
return types.Hash(tx.Hash()), nil
}
func (h *HopBridge) BuildTransaction(sendArgs *TransactionBridge) (*ethTypes.Transaction, error) {
func (h *HopBridgeProcessor) BuildTransaction(sendArgs *MultipathProcessorTxArgs) (*ethTypes.Transaction, error) {
return h.sendOrBuild(sendArgs, nil)
}
func (h *HopBridge) CalculateFees(params BridgeParams) (*big.Int, *big.Int, error) {
func (h *HopBridgeProcessor) CalculateFees(params ProcessorInputParams) (*big.Int, *big.Int, error) {
hopChainsMap := map[uint64]string{
walletCommon.EthereumMainnet: "ethereum",
walletCommon.OptimismMainnet: "optimism",
@ -354,16 +354,16 @@ func (h *HopBridge) CalculateFees(params BridgeParams) (*big.Int, *big.Int, erro
// Remove token fee from bonder fee as said here:
// https://docs.hop.exchange/v/developer-docs/api/api#get-v1-quote
// `bonderFee` - The suggested bonder fee for the amount in. The bonder fee also includes the cost of the destination transaction fee.
tokenFee := big.NewInt(0) //new(big.Int).Sub(h.bonderFee.AmountIn.Int, h.bonderFee.EstimatedRecieved.Int)
tokenFee := ZeroBigIntValue //new(big.Int).Sub(h.bonderFee.AmountIn.Int, h.bonderFee.EstimatedRecieved.Int)
return h.bonderFee.BonderFee.Int, tokenFee, nil
}
func (h *HopBridge) CalculateAmountOut(params BridgeParams) (*big.Int, error) {
func (h *HopBridgeProcessor) CalculateAmountOut(params ProcessorInputParams) (*big.Int, error) {
return h.bonderFee.EstimatedRecieved.Int, nil
}
func (h *HopBridge) packCctpL1BridgeTx(abi abi.ABI, toChainID uint64, to common.Address) ([]byte, error) {
func (h *HopBridgeProcessor) packCctpL1BridgeTx(abi abi.ABI, toChainID uint64, to common.Address) ([]byte, error) {
return abi.Pack("send",
big.NewInt(int64(toChainID)),
to,
@ -371,7 +371,7 @@ func (h *HopBridge) packCctpL1BridgeTx(abi abi.ABI, toChainID uint64, to common.
h.bonderFee.BonderFee.Int)
}
func (h *HopBridge) sendCctpL1BridgeTx(contractAddress common.Address, ethClient chain.ClientInterface, toChainID uint64, to common.Address, txOpts *bind.TransactOpts) (tx *ethTypes.Transaction, err error) {
func (h *HopBridgeProcessor) sendCctpL1BridgeTx(contractAddress common.Address, ethClient chain.ClientInterface, toChainID uint64, to common.Address, txOpts *bind.TransactOpts) (tx *ethTypes.Transaction, err error) {
contractInstance, err := hopL1CctpImplementation.NewHopL1CctpImplementation(
contractAddress,
ethClient,
@ -388,7 +388,7 @@ func (h *HopBridge) sendCctpL1BridgeTx(contractAddress common.Address, ethClient
h.bonderFee.BonderFee.Int)
}
func (h *HopBridge) packL1BridgeTx(abi abi.ABI, toChainID uint64, to common.Address) ([]byte, error) {
func (h *HopBridgeProcessor) packL1BridgeTx(abi abi.ABI, toChainID uint64, to common.Address) ([]byte, error) {
return abi.Pack("sendToL2",
big.NewInt(int64(toChainID)),
to,
@ -396,10 +396,10 @@ func (h *HopBridge) packL1BridgeTx(abi abi.ABI, toChainID uint64, to common.Addr
h.bonderFee.AmountOutMin.Int,
big.NewInt(h.bonderFee.Deadline),
common.Address{},
big.NewInt(0))
ZeroBigIntValue)
}
func (h *HopBridge) sendL1BridgeTx(contractAddress common.Address, ethClient chain.ClientInterface, toChainID uint64, to common.Address, txOpts *bind.TransactOpts, token *token.Token) (tx *ethTypes.Transaction, err error) {
func (h *HopBridgeProcessor) sendL1BridgeTx(contractAddress common.Address, ethClient chain.ClientInterface, toChainID uint64, to common.Address, txOpts *bind.TransactOpts, token *token.Token) (tx *ethTypes.Transaction, err error) {
if token.IsNative() {
contractInstance, err := hopL1EthBridge.NewHopL1EthBridge(
contractAddress,
@ -417,7 +417,7 @@ func (h *HopBridge) sendL1BridgeTx(contractAddress common.Address, ethClient cha
h.bonderFee.AmountOutMin.Int,
big.NewInt(h.bonderFee.Deadline),
common.Address{},
big.NewInt(0))
ZeroBigIntValue)
}
if token.Symbol == hopSymbol {
@ -437,7 +437,7 @@ func (h *HopBridge) sendL1BridgeTx(contractAddress common.Address, ethClient cha
h.bonderFee.AmountOutMin.Int,
big.NewInt(h.bonderFee.Deadline),
common.Address{},
big.NewInt(0))
ZeroBigIntValue)
}
contractInstance, err := hopL1Erc20Bridge.NewHopL1Erc20Bridge(
@ -456,11 +456,11 @@ func (h *HopBridge) sendL1BridgeTx(contractAddress common.Address, ethClient cha
h.bonderFee.AmountOutMin.Int,
big.NewInt(h.bonderFee.Deadline),
common.Address{},
big.NewInt(0))
ZeroBigIntValue)
}
func (h *HopBridge) packCctpL2BridgeTx(abi abi.ABI, toChainID uint64, to common.Address) ([]byte, error) {
func (h *HopBridgeProcessor) packCctpL2BridgeTx(abi abi.ABI, toChainID uint64, to common.Address) ([]byte, error) {
return abi.Pack("send",
big.NewInt(int64(toChainID)),
to,
@ -468,7 +468,7 @@ func (h *HopBridge) packCctpL2BridgeTx(abi abi.ABI, toChainID uint64, to common.
h.bonderFee.BonderFee.Int)
}
func (h *HopBridge) sendCctpL2BridgeTx(contractAddress common.Address, ethClient chain.ClientInterface, toChainID uint64, to common.Address, txOpts *bind.TransactOpts) (tx *ethTypes.Transaction, err error) {
func (h *HopBridgeProcessor) sendCctpL2BridgeTx(contractAddress common.Address, ethClient chain.ClientInterface, toChainID uint64, to common.Address, txOpts *bind.TransactOpts) (tx *ethTypes.Transaction, err error) {
contractInstance, err := hopL2CctpImplementation.NewHopL2CctpImplementation(
contractAddress,
ethClient,
@ -486,7 +486,7 @@ func (h *HopBridge) sendCctpL2BridgeTx(contractAddress common.Address, ethClient
)
}
func (h *HopBridge) packL2AmmWrapperTx(abi abi.ABI, toChainID uint64, to common.Address) ([]byte, error) {
func (h *HopBridgeProcessor) packL2AmmWrapperTx(abi abi.ABI, toChainID uint64, to common.Address) ([]byte, error) {
return abi.Pack("swapAndSend",
big.NewInt(int64(toChainID)),
to,
@ -498,7 +498,7 @@ func (h *HopBridge) packL2AmmWrapperTx(abi abi.ABI, toChainID uint64, to common.
big.NewInt(h.bonderFee.DestinationDeadline))
}
func (h *HopBridge) sendL2AmmWrapperTx(contractAddress common.Address, ethClient chain.ClientInterface, toChainID uint64, to common.Address, txOpts *bind.TransactOpts) (tx *ethTypes.Transaction, err error) {
func (h *HopBridgeProcessor) sendL2AmmWrapperTx(contractAddress common.Address, ethClient chain.ClientInterface, toChainID uint64, to common.Address, txOpts *bind.TransactOpts) (tx *ethTypes.Transaction, err error) {
contractInstance, err := hopL2AmmWrapper.NewHopL2AmmWrapper(
contractAddress,
ethClient,
@ -519,7 +519,7 @@ func (h *HopBridge) sendL2AmmWrapperTx(contractAddress common.Address, ethClient
big.NewInt(h.bonderFee.DestinationDeadline))
}
func (h *HopBridge) packL2BridgeTx(abi abi.ABI, toChainID uint64, to common.Address) ([]byte, error) {
func (h *HopBridgeProcessor) packL2BridgeTx(abi abi.ABI, toChainID uint64, to common.Address) ([]byte, error) {
return abi.Pack("send",
big.NewInt(int64(toChainID)),
to,
@ -529,7 +529,7 @@ func (h *HopBridge) packL2BridgeTx(abi abi.ABI, toChainID uint64, to common.Addr
big.NewInt(h.bonderFee.Deadline))
}
func (h *HopBridge) sendL2BridgeTx(contractAddress common.Address, ethClient chain.ClientInterface, toChainID uint64, to common.Address, txOpts *bind.TransactOpts) (tx *ethTypes.Transaction, err error) {
func (h *HopBridgeProcessor) sendL2BridgeTx(contractAddress common.Address, ethClient chain.ClientInterface, toChainID uint64, to common.Address, txOpts *bind.TransactOpts) (tx *ethTypes.Transaction, err error) {
fromChainID := ethClient.NetworkID()
if fromChainID == walletCommon.OptimismMainnet ||
fromChainID == walletCommon.OptimismSepolia {

36
services/wallet/router/bridge/ens_public_key.go → services/wallet/router/pathprocessor/processor_ens_public_key.go
View File

@ -1,4 +1,4 @@
package bridge
package pathprocessor
import (
"context"
@ -21,14 +21,14 @@ import (
"github.com/status-im/status-go/transactions"
)
type ENSPublicKeyBridge struct {
type ENSPublicKeyProcessor struct {
contractMaker *contracts.ContractMaker
transactor transactions.TransactorIface
ensService *ens.Service
}
func NewENSPublicKeyBridge(rpcClient *rpc.Client, transactor transactions.TransactorIface, ensService *ens.Service) *ENSPublicKeyBridge {
return &ENSPublicKeyBridge{
func NewENSPublicKeyProcessor(rpcClient *rpc.Client, transactor transactions.TransactorIface, ensService *ens.Service) *ENSPublicKeyProcessor {
return &ENSPublicKeyProcessor{
contractMaker: &contracts.ContractMaker{
RPCClient: rpcClient,
},
@ -37,29 +37,29 @@ func NewENSPublicKeyBridge(rpcClient *rpc.Client, transactor transactions.Transa
}
}
func (s *ENSPublicKeyBridge) Name() string {
return ENSPublicKeyName
func (s *ENSPublicKeyProcessor) Name() string {
return ProcessorENSPublicKeyName
}
func (s *ENSPublicKeyBridge) AvailableFor(params BridgeParams) (bool, error) {
func (s *ENSPublicKeyProcessor) AvailableFor(params ProcessorInputParams) (bool, error) {
return params.FromChain.ChainID == walletCommon.EthereumMainnet || params.FromChain.ChainID == walletCommon.EthereumSepolia, nil
}
func (s *ENSPublicKeyBridge) CalculateFees(params BridgeParams) (*big.Int, *big.Int, error) {
func (s *ENSPublicKeyProcessor) CalculateFees(params ProcessorInputParams) (*big.Int, *big.Int, error) {
return ZeroBigIntValue, ZeroBigIntValue, nil
}
func (s *ENSPublicKeyBridge) PackTxInputData(params BridgeParams, contractType string) ([]byte, error) {
func (s *ENSPublicKeyProcessor) PackTxInputData(params ProcessorInputParams, contractType string) ([]byte, error) {
resolverABI, err := abi.JSON(strings.NewReader(resolver.PublicResolverABI))
if err != nil {
return []byte{}, err
}
x, y := extractCoordinates(params.PublicKey)
return resolverABI.Pack("setPubkey", nameHash(params.Username), x, y)
x, y := ens.ExtractCoordinates(params.PublicKey)
return resolverABI.Pack("setPubkey", ens.NameHash(params.Username), x, y)
}
func (s *ENSPublicKeyBridge) EstimateGas(params BridgeParams) (uint64, error) {
func (s *ENSPublicKeyProcessor) EstimateGas(params ProcessorInputParams) (uint64, error) {
contractAddress, err := s.GetContractAddress(params)
if err != nil {
return 0, err
@ -92,14 +92,14 @@ func (s *ENSPublicKeyBridge) EstimateGas(params BridgeParams) (uint64, error) {
return uint64(increasedEstimation), nil
}
func (s *ENSPublicKeyBridge) BuildTx(params BridgeParams) (*ethTypes.Transaction, error) {
func (s *ENSPublicKeyProcessor) BuildTx(params ProcessorInputParams) (*ethTypes.Transaction, error) {
toAddr := types.Address(params.ToAddr)
inputData, err := s.PackTxInputData(params, "")
if err != nil {
return nil, err
}
sendArgs := &TransactionBridge{
sendArgs := &MultipathProcessorTxArgs{
TransferTx: &transactions.SendTxArgs{
From: types.Address(params.FromAddr),
To: &toAddr,
@ -112,19 +112,19 @@ func (s *ENSPublicKeyBridge) BuildTx(params BridgeParams) (*ethTypes.Transaction
return s.BuildTransaction(sendArgs)
}
func (s *ENSPublicKeyBridge) Send(sendArgs *TransactionBridge, verifiedAccount *account.SelectedExtKey) (hash types.Hash, err error) {
func (s *ENSPublicKeyProcessor) Send(sendArgs *MultipathProcessorTxArgs, verifiedAccount *account.SelectedExtKey) (hash types.Hash, err error) {
return s.transactor.SendTransactionWithChainID(sendArgs.ChainID, *sendArgs.TransferTx, verifiedAccount)
}
func (s *ENSPublicKeyBridge) BuildTransaction(sendArgs *TransactionBridge) (*ethTypes.Transaction, error) {
func (s *ENSPublicKeyProcessor) BuildTransaction(sendArgs *MultipathProcessorTxArgs) (*ethTypes.Transaction, error) {
return s.transactor.ValidateAndBuildTransaction(sendArgs.ChainID, *sendArgs.TransferTx)
}
func (s *ENSPublicKeyBridge) CalculateAmountOut(params BridgeParams) (*big.Int, error) {
func (s *ENSPublicKeyProcessor) CalculateAmountOut(params ProcessorInputParams) (*big.Int, error) {
return params.AmountIn, nil
}
func (s *ENSPublicKeyBridge) GetContractAddress(params BridgeParams) (common.Address, error) {
func (s *ENSPublicKeyProcessor) GetContractAddress(params ProcessorInputParams) (common.Address, error) {
addr, err := s.ensService.API().Resolver(context.Background(), params.FromChain.ChainID, params.Username)
if err != nil {
return common.Address{}, err

42
services/wallet/router/bridge/ens_register.go → services/wallet/router/pathprocessor/processor_ens_register.go
View File

@ -1,4 +1,4 @@
package bridge
package pathprocessor
import (
"context"
@ -22,14 +22,14 @@ import (
"github.com/status-im/status-go/transactions"
)
type ENSRegisterBridge struct {
type ENSRegisterProcessor struct {
contractMaker *contracts.ContractMaker
transactor transactions.TransactorIface
ensService *ens.Service
}
func NewENSRegisterBridge(rpcClient *rpc.Client, transactor transactions.TransactorIface, ensService *ens.Service) *ENSRegisterBridge {
return &ENSRegisterBridge{
func NewENSRegisterProcessor(rpcClient *rpc.Client, transactor transactions.TransactorIface, ensService *ens.Service) *ENSRegisterProcessor {
return &ENSRegisterProcessor{
contractMaker: &contracts.ContractMaker{
RPCClient: rpcClient,
},
@ -39,11 +39,11 @@ func NewENSRegisterBridge(rpcClient *rpc.Client, transactor transactions.Transac
}
}
func (s *ENSRegisterBridge) Name() string {
return ENSRegisterName
func (s *ENSRegisterProcessor) Name() string {
return ProcessorENSRegisterName
}
func (s *ENSRegisterBridge) GetPriceForRegisteringEnsName(chainID uint64) (*big.Int, error) {
func (s *ENSRegisterProcessor) GetPriceForRegisteringEnsName(chainID uint64) (*big.Int, error) {
registryAddr, err := s.ensService.API().GetRegistrarAddress(context.Background(), chainID)
if err != nil {
return nil, err
@ -57,15 +57,15 @@ func (s *ENSRegisterBridge) GetPriceForRegisteringEnsName(chainID uint64) (*big.
return registrar.GetPrice(callOpts)
}
func (s *ENSRegisterBridge) AvailableFor(params BridgeParams) (bool, error) {
func (s *ENSRegisterProcessor) AvailableFor(params ProcessorInputParams) (bool, error) {
return params.FromChain.ChainID == walletCommon.EthereumMainnet || params.FromChain.ChainID == walletCommon.EthereumSepolia, nil
}
func (s *ENSRegisterBridge) CalculateFees(params BridgeParams) (*big.Int, *big.Int, error) {
return big.NewInt(0), big.NewInt(0), nil
func (s *ENSRegisterProcessor) CalculateFees(params ProcessorInputParams) (*big.Int, *big.Int, error) {
return ZeroBigIntValue, ZeroBigIntValue, nil
}
func (s *ENSRegisterBridge) PackTxInputData(params BridgeParams, contractType string) ([]byte, error) {
func (s *ENSRegisterProcessor) PackTxInputData(params ProcessorInputParams, contractType string) ([]byte, error) {
price, err := s.GetPriceForRegisteringEnsName(params.FromChain.ChainID)
if err != nil {
return []byte{}, err
@ -76,8 +76,8 @@ func (s *ENSRegisterBridge) PackTxInputData(params BridgeParams, contractType st
return []byte{}, err
}
x, y := extractCoordinates(params.PublicKey)
extraData, err := registrarABI.Pack("register", usernameToLabel(params.Username), params.FromAddr, x, y)
x, y := ens.ExtractCoordinates(params.PublicKey)
extraData, err := registrarABI.Pack("register", ens.UsernameToLabel(params.Username), params.FromAddr, x, y)
if err != nil {
return []byte{}, err
}
@ -95,7 +95,7 @@ func (s *ENSRegisterBridge) PackTxInputData(params BridgeParams, contractType st
return sntABI.Pack("approveAndCall", registryAddr, price, extraData)
}
func (s *ENSRegisterBridge) EstimateGas(params BridgeParams) (uint64, error) {
func (s *ENSRegisterProcessor) EstimateGas(params ProcessorInputParams) (uint64, error) {
contractAddress, err := s.GetContractAddress(params)
if err != nil {
return 0, err
@ -114,7 +114,7 @@ func (s *ENSRegisterBridge) EstimateGas(params BridgeParams) (uint64, error) {
msg := ethereum.CallMsg{
From: params.FromAddr,
To: &contractAddress,
Value: big.NewInt(0),
Value: ZeroBigIntValue,
Data: input,
}
@ -128,14 +128,14 @@ func (s *ENSRegisterBridge) EstimateGas(params BridgeParams) (uint64, error) {
return uint64(increasedEstimation), nil
}
func (s *ENSRegisterBridge) BuildTx(params BridgeParams) (*ethTypes.Transaction, error) {
func (s *ENSRegisterProcessor) BuildTx(params ProcessorInputParams) (*ethTypes.Transaction, error) {
toAddr := types.Address(params.ToAddr)
inputData, err := s.PackTxInputData(params, "")
if err != nil {
return nil, err
}
sendArgs := &TransactionBridge{
sendArgs := &MultipathProcessorTxArgs{
TransferTx: &transactions.SendTxArgs{
From: types.Address(params.FromAddr),
To: &toAddr,
@ -148,18 +148,18 @@ func (s *ENSRegisterBridge) BuildTx(params BridgeParams) (*ethTypes.Transaction,
return s.BuildTransaction(sendArgs)
}
func (s *ENSRegisterBridge) Send(sendArgs *TransactionBridge, verifiedAccount *account.SelectedExtKey) (hash types.Hash, err error) {
func (s *ENSRegisterProcessor) Send(sendArgs *MultipathProcessorTxArgs, verifiedAccount *account.SelectedExtKey) (hash types.Hash, err error) {
return s.transactor.SendTransactionWithChainID(sendArgs.ChainID, *sendArgs.TransferTx, verifiedAccount)
}
func (s *ENSRegisterBridge) BuildTransaction(sendArgs *TransactionBridge) (*ethTypes.Transaction, error) {
func (s *ENSRegisterProcessor) BuildTransaction(sendArgs *MultipathProcessorTxArgs) (*ethTypes.Transaction, error) {
return s.transactor.ValidateAndBuildTransaction(sendArgs.ChainID, *sendArgs.TransferTx)
}
func (s *ENSRegisterBridge) CalculateAmountOut(params BridgeParams) (*big.Int, error) {
func (s *ENSRegisterProcessor) CalculateAmountOut(params ProcessorInputParams) (*big.Int, error) {
return params.AmountIn, nil
}
func (s *ENSRegisterBridge) GetContractAddress(params BridgeParams) (common.Address, error) {
func (s *ENSRegisterProcessor) GetContractAddress(params ProcessorInputParams) (common.Address, error) {
return snt.ContractAddress(params.FromChain.ChainID)
}

44
services/wallet/router/bridge/ens_release.go → services/wallet/router/pathprocessor/processor_ens_release.go
View File

@ -1,7 +1,8 @@
package bridge
package pathprocessor
import (
"context"
"errors"
"math/big"
"strings"
@ -20,14 +21,14 @@ import (
"github.com/status-im/status-go/transactions"
)
type ENSReleaseBridge struct {
type ENSReleaseProcessor struct {
contractMaker *contracts.ContractMaker
transactor transactions.TransactorIface
ensService *ens.Service
}
func NewENSReleaseBridge(rpcClient *rpc.Client, transactor transactions.TransactorIface, ensService *ens.Service) *ENSReleaseBridge {
return &ENSReleaseBridge{
func NewENSReleaseProcessor(rpcClient *rpc.Client, transactor transactions.TransactorIface, ensService *ens.Service) *ENSReleaseProcessor {
return &ENSReleaseProcessor{
contractMaker: &contracts.ContractMaker{
RPCClient: rpcClient,
},
@ -36,28 +37,28 @@ func NewENSReleaseBridge(rpcClient *rpc.Client, transactor transactions.Transact
}
}
func (s *ENSReleaseBridge) Name() string {
return ENSReleaseName
func (s *ENSReleaseProcessor) Name() string {
return ProcessorENSReleaseName
}
func (s *ENSReleaseBridge) AvailableFor(params BridgeParams) (bool, error) {
func (s *ENSReleaseProcessor) AvailableFor(params ProcessorInputParams) (bool, error) {
return params.FromChain.ChainID == walletCommon.EthereumMainnet || params.FromChain.ChainID == walletCommon.EthereumSepolia, nil
}
func (s *ENSReleaseBridge) CalculateFees(params BridgeParams) (*big.Int, *big.Int, error) {
func (s *ENSReleaseProcessor) CalculateFees(params ProcessorInputParams) (*big.Int, *big.Int, error) {
return ZeroBigIntValue, ZeroBigIntValue, nil
}
func (s *ENSReleaseBridge) PackTxInputData(params BridgeParams, contractType string) ([]byte, error) {
func (s *ENSReleaseProcessor) PackTxInputData(params ProcessorInputParams, contractType string) ([]byte, error) {
registrarABI, err := abi.JSON(strings.NewReader(registrar.UsernameRegistrarABI))
if err != nil {
return []byte{}, err
}
return registrarABI.Pack("release", usernameToLabel(params.Username))
return registrarABI.Pack("release", ens.UsernameToLabel(params.Username))
}
func (s *ENSReleaseBridge) EstimateGas(params BridgeParams) (uint64, error) {
func (s *ENSReleaseProcessor) EstimateGas(params ProcessorInputParams) (uint64, error) {
contractAddress, err := s.GetContractAddress(params)
if err != nil {
return 0, err
@ -90,14 +91,14 @@ func (s *ENSReleaseBridge) EstimateGas(params BridgeParams) (uint64, error) {
return uint64(increasedEstimation), nil
}
func (s *ENSReleaseBridge) BuildTx(params BridgeParams) (*ethTypes.Transaction, error) {
func (s *ENSReleaseProcessor) BuildTx(params ProcessorInputParams) (*ethTypes.Transaction, error) {
toAddr := types.Address(params.ToAddr)
inputData, err := s.PackTxInputData(params, "")
if err != nil {
return nil, err
}
sendArgs := &TransactionBridge{
sendArgs := &MultipathProcessorTxArgs{
TransferTx: &transactions.SendTxArgs{
From: types.Address(params.FromAddr),
To: &toAddr,
@ -110,18 +111,25 @@ func (s *ENSReleaseBridge) BuildTx(params BridgeParams) (*ethTypes.Transaction,
return s.BuildTransaction(sendArgs)
}
func (s *ENSReleaseBridge) Send(sendArgs *TransactionBridge, verifiedAccount *account.SelectedExtKey) (hash types.Hash, err error) {
func (s *ENSReleaseProcessor) Send(sendArgs *MultipathProcessorTxArgs, verifiedAccount *account.SelectedExtKey) (hash types.Hash, err error) {
return s.transactor.SendTransactionWithChainID(sendArgs.ChainID, *sendArgs.TransferTx, verifiedAccount)
}
func (s *ENSReleaseBridge) BuildTransaction(sendArgs *TransactionBridge) (*ethTypes.Transaction, error) {
func (s *ENSReleaseProcessor) BuildTransaction(sendArgs *MultipathProcessorTxArgs) (*ethTypes.Transaction, error) {
return s.transactor.ValidateAndBuildTransaction(sendArgs.ChainID, *sendArgs.TransferTx)
}
func (s *ENSReleaseBridge) CalculateAmountOut(params BridgeParams) (*big.Int, error) {
func (s *ENSReleaseProcessor) CalculateAmountOut(params ProcessorInputParams) (*big.Int, error) {
return params.AmountIn, nil
}
func (s *ENSReleaseBridge) GetContractAddress(params BridgeParams) (common.Address, error) {
return s.ensService.API().GetRegistrarAddress(context.Background(), params.FromChain.ChainID)
func (s *ENSReleaseProcessor) GetContractAddress(params ProcessorInputParams) (common.Address, error) {
addr, err := s.ensService.API().GetRegistrarAddress(context.Background(), params.FromChain.ChainID)
if err != nil {
return common.Address{}, err
}
if addr == ZeroAddress {
return common.Address{}, errors.New("ENS registar not found")
}
return addr, nil
}

40
services/wallet/router/bridge/erc1155_transfer.go → services/wallet/router/pathprocessor/processor_erc1155.go
View File

@ -1,4 +1,4 @@
package bridge
package pathprocessor
import (
"context"
@ -19,35 +19,35 @@ import (
"github.com/status-im/status-go/transactions"
)
type ERC1155TransferTxArgs struct {
type ERC1155TxArgs struct {
transactions.SendTxArgs
TokenID *hexutil.Big `json:"tokenId"`
Recipient common.Address `json:"recipient"`
Amount *hexutil.Big `json:"amount"`
}
type ERC1155TransferBridge struct {
type ERC1155Processor struct {
rpcClient *rpc.Client
transactor transactions.TransactorIface
}
func NewERC1155TransferBridge(rpcClient *rpc.Client, transactor transactions.TransactorIface) *ERC1155TransferBridge {
return &ERC1155TransferBridge{rpcClient: rpcClient, transactor: transactor}
func NewERC1155Processor(rpcClient *rpc.Client, transactor transactions.TransactorIface) *ERC1155Processor {
return &ERC1155Processor{rpcClient: rpcClient, transactor: transactor}
}
func (s *ERC1155TransferBridge) Name() string {
return ERC1155TransferName
func (s *ERC1155Processor) Name() string {
return ProcessorERC1155Name
}
func (s *ERC1155TransferBridge) AvailableFor(params BridgeParams) (bool, error) {
func (s *ERC1155Processor) AvailableFor(params ProcessorInputParams) (bool, error) {
return params.FromChain.ChainID == params.ToChain.ChainID && params.ToToken == nil, nil
}
func (s *ERC1155TransferBridge) CalculateFees(params BridgeParams) (*big.Int, *big.Int, error) {
return big.NewInt(0), big.NewInt(0), nil
func (s *ERC1155Processor) CalculateFees(params ProcessorInputParams) (*big.Int, *big.Int, error) {
return ZeroBigIntValue, ZeroBigIntValue, nil
}
func (s *ERC1155TransferBridge) PackTxInputData(params BridgeParams, contractType string) ([]byte, error) {
func (s *ERC1155Processor) PackTxInputData(params ProcessorInputParams, contractType string) ([]byte, error) {
abi, err := abi.JSON(strings.NewReader(ierc1155.Ierc1155ABI))
if err != nil {
return []byte{}, err
@ -67,7 +67,7 @@ func (s *ERC1155TransferBridge) PackTxInputData(params BridgeParams, contractTyp
)
}
func (s *ERC1155TransferBridge) EstimateGas(params BridgeParams) (uint64, error) {
func (s *ERC1155Processor) EstimateGas(params ProcessorInputParams) (uint64, error) {
ethClient, err := s.rpcClient.EthClient(params.FromChain.ChainID)
if err != nil {
return 0, err
@ -95,7 +95,7 @@ func (s *ERC1155TransferBridge) EstimateGas(params BridgeParams) (uint64, error)
return uint64(increasedEstimation), nil
}
func (s *ERC1155TransferBridge) BuildTx(params BridgeParams) (*ethTypes.Transaction, error) {
func (s *ERC1155Processor) BuildTx(params ProcessorInputParams) (*ethTypes.Transaction, error) {
contractAddress := types.Address(params.FromToken.Address)
// We store ERC1155 Token ID using big.Int.String() in token.Symbol
@ -104,8 +104,8 @@ func (s *ERC1155TransferBridge) BuildTx(params BridgeParams) (*ethTypes.Transact
return nil, fmt.Errorf("failed to convert ERC1155's Symbol %s to big.Int", params.FromToken.Symbol)
}
sendArgs := &TransactionBridge{
ERC1155TransferTx: &ERC1155TransferTxArgs{
sendArgs := &MultipathProcessorTxArgs{
ERC1155TransferTx: &ERC1155TxArgs{
SendTxArgs: transactions.SendTxArgs{
From: types.Address(params.FromAddr),
To: &contractAddress,
@ -122,7 +122,7 @@ func (s *ERC1155TransferBridge) BuildTx(params BridgeParams) (*ethTypes.Transact
return s.BuildTransaction(sendArgs)
}
func (s *ERC1155TransferBridge) sendOrBuild(sendArgs *TransactionBridge, signerFn bind.SignerFn) (tx *ethTypes.Transaction, err error) {
func (s *ERC1155Processor) sendOrBuild(sendArgs *MultipathProcessorTxArgs, signerFn bind.SignerFn) (tx *ethTypes.Transaction, err error) {
ethClient, err := s.rpcClient.EthClient(sendArgs.ChainID)
if err != nil {
return tx, err
@ -151,7 +151,7 @@ func (s *ERC1155TransferBridge) sendOrBuild(sendArgs *TransactionBridge, signerF
return tx, err
}
func (s *ERC1155TransferBridge) Send(sendArgs *TransactionBridge, verifiedAccount *account.SelectedExtKey) (hash types.Hash, err error) {
func (s *ERC1155Processor) Send(sendArgs *MultipathProcessorTxArgs, verifiedAccount *account.SelectedExtKey) (hash types.Hash, err error) {
tx, err := s.sendOrBuild(sendArgs, getSigner(sendArgs.ChainID, sendArgs.ERC1155TransferTx.From, verifiedAccount))
if err != nil {
return hash, err
@ -159,14 +159,14 @@ func (s *ERC1155TransferBridge) Send(sendArgs *TransactionBridge, verifiedAccoun
return types.Hash(tx.Hash()), nil
}
func (s *ERC1155TransferBridge) BuildTransaction(sendArgs *TransactionBridge) (*ethTypes.Transaction, error) {
func (s *ERC1155Processor) BuildTransaction(sendArgs *MultipathProcessorTxArgs) (*ethTypes.Transaction, error) {
return s.sendOrBuild(sendArgs, nil)
}
func (s *ERC1155TransferBridge) CalculateAmountOut(params BridgeParams) (*big.Int, error) {
func (s *ERC1155Processor) CalculateAmountOut(params ProcessorInputParams) (*big.Int, error) {
return params.AmountIn, nil
}
func (s *ERC1155TransferBridge) GetContractAddress(params BridgeParams) (common.Address, error) {
func (s *ERC1155Processor) GetContractAddress(params ProcessorInputParams) (common.Address, error) {
return params.FromToken.Address, nil
}

40
services/wallet/router/bridge/erc721_transfer.go → services/wallet/router/pathprocessor/processor_erc721.go
View File

@ -1,4 +1,4 @@
package bridge
package pathprocessor
import (
"context"
@ -19,34 +19,34 @@ import (
"github.com/status-im/status-go/transactions"
)
type ERC721TransferTxArgs struct {
type ERC721TxArgs struct {
transactions.SendTxArgs
TokenID *hexutil.Big `json:"tokenId"`
Recipient common.Address `json:"recipient"`
}
type ERC721TransferBridge struct {
type ERC721Processor struct {
rpcClient *rpc.Client
transactor transactions.TransactorIface
}
func NewERC721TransferBridge(rpcClient *rpc.Client, transactor transactions.TransactorIface) *ERC721TransferBridge {
return &ERC721TransferBridge{rpcClient: rpcClient, transactor: transactor}
func NewERC721Processor(rpcClient *rpc.Client, transactor transactions.TransactorIface) *ERC721Processor {
return &ERC721Processor{rpcClient: rpcClient, transactor: transactor}
}
func (s *ERC721TransferBridge) Name() string {
return ERC721TransferName
func (s *ERC721Processor) Name() string {
return ProcessorERC721Name
}
func (s *ERC721TransferBridge) AvailableFor(params BridgeParams) (bool, error) {
func (s *ERC721Processor) AvailableFor(params ProcessorInputParams) (bool, error) {
return params.FromChain.ChainID == params.ToChain.ChainID && params.ToToken == nil, nil
}
func (s *ERC721TransferBridge) CalculateFees(params BridgeParams) (*big.Int, *big.Int, error) {
return big.NewInt(0), big.NewInt(0), nil
func (s *ERC721Processor) CalculateFees(params ProcessorInputParams) (*big.Int, *big.Int, error) {
return ZeroBigIntValue, ZeroBigIntValue, nil
}
func (s *ERC721TransferBridge) PackTxInputData(params BridgeParams, contractType string) ([]byte, error) {
func (s *ERC721Processor) PackTxInputData(params ProcessorInputParams, contractType string) ([]byte, error) {
abi, err := abi.JSON(strings.NewReader(collectibles.CollectiblesMetaData.ABI))
if err != nil {
return []byte{}, err
@ -64,7 +64,7 @@ func (s *ERC721TransferBridge) PackTxInputData(params BridgeParams, contractType
)
}
func (s *ERC721TransferBridge) EstimateGas(params BridgeParams) (uint64, error) {
func (s *ERC721Processor) EstimateGas(params ProcessorInputParams) (uint64, error) {
ethClient, err := s.rpcClient.EthClient(params.FromChain.ChainID)
if err != nil {
return 0, err
@ -93,7 +93,7 @@ func (s *ERC721TransferBridge) EstimateGas(params BridgeParams) (uint64, error)
return uint64(increasedEstimation), nil
}
func (s *ERC721TransferBridge) BuildTx(params BridgeParams) (*ethTypes.Transaction, error) {
func (s *ERC721Processor) BuildTx(params ProcessorInputParams) (*ethTypes.Transaction, error) {
contractAddress := types.Address(params.FromToken.Address)
// We store ERC721 Token ID using big.Int.String() in token.Symbol
@ -102,8 +102,8 @@ func (s *ERC721TransferBridge) BuildTx(params BridgeParams) (*ethTypes.Transacti
return nil, fmt.Errorf("failed to convert ERC721's Symbol %s to big.Int", params.FromToken.Symbol)
}
sendArgs := &TransactionBridge{
ERC721TransferTx: &ERC721TransferTxArgs{
sendArgs := &MultipathProcessorTxArgs{
ERC721TransferTx: &ERC721TxArgs{
SendTxArgs: transactions.SendTxArgs{
From: types.Address(params.FromAddr),
To: &contractAddress,
@ -119,7 +119,7 @@ func (s *ERC721TransferBridge) BuildTx(params BridgeParams) (*ethTypes.Transacti
return s.BuildTransaction(sendArgs)
}
func (s *ERC721TransferBridge) sendOrBuild(sendArgs *TransactionBridge, signerFn bind.SignerFn) (tx *ethTypes.Transaction, err error) {
func (s *ERC721Processor) sendOrBuild(sendArgs *MultipathProcessorTxArgs, signerFn bind.SignerFn) (tx *ethTypes.Transaction, err error) {
ethClient, err := s.rpcClient.EthClient(sendArgs.ChainID)
if err != nil {
return tx, err
@ -145,7 +145,7 @@ func (s *ERC721TransferBridge) sendOrBuild(sendArgs *TransactionBridge, signerFn
return tx, err
}
func (s *ERC721TransferBridge) Send(sendArgs *TransactionBridge, verifiedAccount *account.SelectedExtKey) (hash types.Hash, err error) {
func (s *ERC721Processor) Send(sendArgs *MultipathProcessorTxArgs, verifiedAccount *account.SelectedExtKey) (hash types.Hash, err error) {
tx, err := s.sendOrBuild(sendArgs, getSigner(sendArgs.ChainID, sendArgs.ERC721TransferTx.From, verifiedAccount))
if err != nil {
return hash, err
@ -153,14 +153,14 @@ func (s *ERC721TransferBridge) Send(sendArgs *TransactionBridge, verifiedAccount
return types.Hash(tx.Hash()), nil
}
func (s *ERC721TransferBridge) BuildTransaction(sendArgs *TransactionBridge) (*ethTypes.Transaction, error) {
func (s *ERC721Processor) BuildTransaction(sendArgs *MultipathProcessorTxArgs) (*ethTypes.Transaction, error) {
return s.sendOrBuild(sendArgs, nil)
}
func (s *ERC721TransferBridge) CalculateAmountOut(params BridgeParams) (*big.Int, error) {
func (s *ERC721Processor) CalculateAmountOut(params ProcessorInputParams) (*big.Int, error) {
return params.AmountIn, nil
}
func (s *ERC721TransferBridge) GetContractAddress(params BridgeParams) (common.Address, error) {
func (s *ERC721Processor) GetContractAddress(params ProcessorInputParams) (common.Address, error) {
return params.FromToken.Address, nil
}

44
services/wallet/router/bridge/swap_paraswap.go → services/wallet/router/pathprocessor/processor_swap_paraswap.go
View File

@ -1,4 +1,4 @@
package bridge
package pathprocessor
import (
"context"
@ -18,29 +18,29 @@ import (
"github.com/status-im/status-go/transactions"
)
type SwapTxArgs struct {
type SwapParaswapTxArgs struct {
transactions.SendTxArgs
ChainID uint64 `json:"chainId"`
}
type SwapParaswap struct {
type SwapParaswapProcessor struct {
paraswapClient *paraswap.ClientV5
priceRoute paraswap.Route
transactor transactions.TransactorIface
}
func NewSwapParaswap(rpcClient *rpc.Client, transactor transactions.TransactorIface, tokenManager *walletToken.Manager) *SwapParaswap {
return &SwapParaswap{
func NewSwapParaswapProcessor(rpcClient *rpc.Client, transactor transactions.TransactorIface, tokenManager *walletToken.Manager) *SwapParaswapProcessor {
return &SwapParaswapProcessor{
paraswapClient: paraswap.NewClientV5(walletCommon.EthereumMainnet),
transactor: transactor,
}
}
func (s *SwapParaswap) Name() string {
return SwapParaswapName
func (s *SwapParaswapProcessor) Name() string {
return ProcessorSwapParaswapName
}
func (s *SwapParaswap) AvailableFor(params BridgeParams) (bool, error) {
func (s *SwapParaswapProcessor) AvailableFor(params ProcessorInputParams) (bool, error) {
if params.FromToken == nil || params.ToToken == nil {
return false, errors.New("token and toToken cannot be nil")
}
@ -85,16 +85,16 @@ func (s *SwapParaswap) AvailableFor(params BridgeParams) (bool, error) {
return true, nil
}
func (s *SwapParaswap) CalculateFees(params BridgeParams) (*big.Int, *big.Int, error) {
return big.NewInt(0), big.NewInt(0), nil
func (s *SwapParaswapProcessor) CalculateFees(params ProcessorInputParams) (*big.Int, *big.Int, error) {
return ZeroBigIntValue, ZeroBigIntValue, nil
}
func (s *SwapParaswap) PackTxInputData(params BridgeParams, contractType string) ([]byte, error) {
func (s *SwapParaswapProcessor) PackTxInputData(params ProcessorInputParams, contractType string) ([]byte, error) {
// not sure what we can do here since we're using the api to build the transaction
return []byte{}, nil
}
func (s *SwapParaswap) EstimateGas(params BridgeParams) (uint64, error) {
func (s *SwapParaswapProcessor) EstimateGas(params ProcessorInputParams) (uint64, error) {
priceRoute, err := s.paraswapClient.FetchPriceRoute(context.Background(), params.FromToken.Address, params.FromToken.Decimals,
params.ToToken.Address, params.ToToken.Decimals, params.AmountIn, params.FromAddr, params.ToAddr)
if err != nil {
@ -106,7 +106,7 @@ func (s *SwapParaswap) EstimateGas(params BridgeParams) (uint64, error) {
return priceRoute.GasCost.Uint64(), nil
}
func (s *SwapParaswap) GetContractAddress(params BridgeParams) (address common.Address, err error) {
func (s *SwapParaswapProcessor) GetContractAddress(params ProcessorInputParams) (address common.Address, err error) {
if params.FromChain.ChainID == walletCommon.EthereumMainnet {
address = common.HexToAddress("0x216b4b4ba9f3e719726886d34a177484278bfcae")
} else if params.FromChain.ChainID == walletCommon.ArbitrumMainnet {
@ -119,10 +119,10 @@ func (s *SwapParaswap) GetContractAddress(params BridgeParams) (address common.A
return
}
func (s *SwapParaswap) BuildTx(params BridgeParams) (*ethTypes.Transaction, error) {
func (s *SwapParaswapProcessor) BuildTx(params ProcessorInputParams) (*ethTypes.Transaction, error) {
toAddr := types.Address(params.ToAddr)
sendArgs := &TransactionBridge{
SwapTx: &SwapTxArgs{
sendArgs := &MultipathProcessorTxArgs{
SwapTx: &SwapParaswapTxArgs{
SendTxArgs: transactions.SendTxArgs{
From: types.Address(params.FromAddr),
To: &toAddr,
@ -137,7 +137,7 @@ func (s *SwapParaswap) BuildTx(params BridgeParams) (*ethTypes.Transaction, erro
return s.BuildTransaction(sendArgs)
}
func (s *SwapParaswap) prepareTransaction(sendArgs *TransactionBridge) error {
func (s *SwapParaswapProcessor) prepareTransaction(sendArgs *MultipathProcessorTxArgs) error {
tx, err := s.paraswapClient.BuildTransaction(context.Background(), s.priceRoute.SrcTokenAddress, s.priceRoute.SrcTokenDecimals, s.priceRoute.SrcAmount.Int,
s.priceRoute.DestTokenAddress, s.priceRoute.DestTokenDecimals, s.priceRoute.DestAmount.Int, common.Address(sendArgs.SwapTx.From), common.Address(*sendArgs.SwapTx.To), s.priceRoute.RawPriceRoute)
if err != nil {
@ -172,7 +172,7 @@ func (s *SwapParaswap) prepareTransaction(sendArgs *TransactionBridge) error {
return nil
}
func (s *SwapParaswap) BuildTransaction(sendArgs *TransactionBridge) (*ethTypes.Transaction, error) {
func (s *SwapParaswapProcessor) BuildTransaction(sendArgs *MultipathProcessorTxArgs) (*ethTypes.Transaction, error) {
err := s.prepareTransaction(sendArgs)
if err != nil {
return nil, err
@ -180,10 +180,10 @@ func (s *SwapParaswap) BuildTransaction(sendArgs *TransactionBridge) (*ethTypes.
return s.transactor.ValidateAndBuildTransaction(sendArgs.ChainID, sendArgs.SwapTx.SendTxArgs)
}
func (s *SwapParaswap) Send(sendArgs *TransactionBridge, verifiedAccount *account.SelectedExtKey) (types.Hash, error) {
func (s *SwapParaswapProcessor) Send(sendArgs *MultipathProcessorTxArgs, verifiedAccount *account.SelectedExtKey) (types.Hash, error) {
txBridgeArgs := &TransactionBridge{
SwapTx: &SwapTxArgs{
txBridgeArgs := &MultipathProcessorTxArgs{
SwapTx: &SwapParaswapTxArgs{
SendTxArgs: transactions.SendTxArgs{
From: sendArgs.SwapTx.From,
To: sendArgs.SwapTx.To,
@ -201,6 +201,6 @@ func (s *SwapParaswap) Send(sendArgs *TransactionBridge, verifiedAccount *accoun
return s.transactor.SendTransactionWithChainID(txBridgeArgs.ChainID, txBridgeArgs.SwapTx.SendTxArgs, verifiedAccount)
}
func (s *SwapParaswap) CalculateAmountOut(params BridgeParams) (*big.Int, error) {
func (s *SwapParaswapProcessor) CalculateAmountOut(params ProcessorInputParams) (*big.Int, error) {
return s.priceRoute.DestAmount.Int, nil
}

38
services/wallet/router/bridge/transfer.go → services/wallet/router/pathprocessor/processor_transfer.go
View File

@ -1,4 +1,4 @@
package bridge
package pathprocessor
import (
"context"
@ -17,28 +17,28 @@ import (
"github.com/status-im/status-go/transactions"
)
type TransferBridge struct {
type TransferProcessor struct {
rpcClient *rpc.Client
transactor transactions.TransactorIface
}
func NewTransferBridge(rpcClient *rpc.Client, transactor transactions.TransactorIface) *TransferBridge {
return &TransferBridge{rpcClient: rpcClient, transactor: transactor}
func NewTransferProcessor(rpcClient *rpc.Client, transactor transactions.TransactorIface) *TransferProcessor {
return &TransferProcessor{rpcClient: rpcClient, transactor: transactor}
}
func (s *TransferBridge) Name() string {
return TransferName
func (s *TransferProcessor) Name() string {
return ProcessorTransferName
}
func (s *TransferBridge) AvailableFor(params BridgeParams) (bool, error) {
func (s *TransferProcessor) AvailableFor(params ProcessorInputParams) (bool, error) {
return params.FromChain.ChainID == params.ToChain.ChainID && params.FromToken != nil && params.ToToken == nil, nil
}
func (s *TransferBridge) CalculateFees(params BridgeParams) (*big.Int, *big.Int, error) {
return big.NewInt(0), big.NewInt(0), nil
func (s *TransferProcessor) CalculateFees(params ProcessorInputParams) (*big.Int, *big.Int, error) {
return ZeroBigIntValue, ZeroBigIntValue, nil
}
func (s *TransferBridge) PackTxInputData(params BridgeParams, contractType string) ([]byte, error) {
func (s *TransferProcessor) PackTxInputData(params ProcessorInputParams, contractType string) ([]byte, error) {
if params.FromToken.IsNative() {
return []byte("eth_sendRawTransaction"), nil
} else {
@ -53,7 +53,7 @@ func (s *TransferBridge) PackTxInputData(params BridgeParams, contractType strin
}
}
func (s *TransferBridge) EstimateGas(params BridgeParams) (uint64, error) {
func (s *TransferProcessor) EstimateGas(params ProcessorInputParams) (uint64, error) {
estimation := uint64(0)
var err error
@ -92,10 +92,10 @@ func (s *TransferBridge) EstimateGas(params BridgeParams) (uint64, error) {
return uint64(increasedEstimation), nil
}
func (s *TransferBridge) BuildTx(params BridgeParams) (*ethTypes.Transaction, error) {
func (s *TransferProcessor) BuildTx(params ProcessorInputParams) (*ethTypes.Transaction, error) {
toAddr := types.Address(params.ToAddr)
if params.FromToken.IsNative() {
sendArgs := &TransactionBridge{
sendArgs := &MultipathProcessorTxArgs{
TransferTx: &transactions.SendTxArgs{
From: types.Address(params.FromAddr),
To: &toAddr,
@ -118,11 +118,11 @@ func (s *TransferBridge) BuildTx(params BridgeParams) (*ethTypes.Transaction, er
if err != nil {
return nil, err
}
sendArgs := &TransactionBridge{
sendArgs := &MultipathProcessorTxArgs{
TransferTx: &transactions.SendTxArgs{
From: types.Address(params.FromAddr),
To: &toAddr,
Value: (*hexutil.Big)(big.NewInt(0)),
Value: (*hexutil.Big)(ZeroBigIntValue),
Data: input,
},
ChainID: params.FromChain.ChainID,
@ -131,18 +131,18 @@ func (s *TransferBridge) BuildTx(params BridgeParams) (*ethTypes.Transaction, er
return s.BuildTransaction(sendArgs)
}
func (s *TransferBridge) Send(sendArgs *TransactionBridge, verifiedAccount *account.SelectedExtKey) (types.Hash, error) {
func (s *TransferProcessor) Send(sendArgs *MultipathProcessorTxArgs, verifiedAccount *account.SelectedExtKey) (types.Hash, error) {
return s.transactor.SendTransactionWithChainID(sendArgs.ChainID, *sendArgs.TransferTx, verifiedAccount)
}
func (s *TransferBridge) BuildTransaction(sendArgs *TransactionBridge) (*ethTypes.Transaction, error) {
func (s *TransferProcessor) BuildTransaction(sendArgs *MultipathProcessorTxArgs) (*ethTypes.Transaction, error) {
return s.transactor.ValidateAndBuildTransaction(sendArgs.ChainID, *sendArgs.TransferTx)
}
func (s *TransferBridge) CalculateAmountOut(params BridgeParams) (*big.Int, error) {
func (s *TransferProcessor) CalculateAmountOut(params ProcessorInputParams) (*big.Int, error) {
return params.AmountIn, nil
}
func (s *TransferBridge) GetContractAddress(params BridgeParams) (common.Address, error) {
func (s *TransferProcessor) GetContractAddress(params ProcessorInputParams) (common.Address, error) {
return common.Address{}, nil
}

0
services/wallet/router/bridge/proto_cbridge/cbridge.proto → services/wallet/router/pathprocessor/proto_cbridge/cbridge.proto
View File

0
services/wallet/router/bridge/proto_cbridge/gateway.proto → services/wallet/router/pathprocessor/proto_cbridge/gateway.proto
View File

0
services/wallet/router/bridge/proto_cbridge/generate.go → services/wallet/router/pathprocessor/proto_cbridge/generate.go
View File

0
services/wallet/router/bridge/proto_cbridge/query.proto → services/wallet/router/pathprocessor/proto_cbridge/query.proto
View File

92
services/wallet/router/router.go
View File

@ -26,7 +26,7 @@ import (
"github.com/status-im/status-go/services/wallet/collectibles"
walletCommon "github.com/status-im/status-go/services/wallet/common"
"github.com/status-im/status-go/services/wallet/market"
"github.com/status-im/status-go/services/wallet/router/bridge"
"github.com/status-im/status-go/services/wallet/router/pathprocessor"
"github.com/status-im/status-go/services/wallet/token"
walletToken "github.com/status-im/status-go/services/wallet/token"
"github.com/status-im/status-go/transactions"
@ -148,7 +148,7 @@ func filterRoutes(routes [][]*Path, amountIn *big.Int, fromLockedAmount map[uint
fromIncluded := make(map[uint64]bool)
fromExcluded := make(map[uint64]bool)
for chainID, amount := range fromLockedAmount {
if amount.ToInt().Cmp(bridge.ZeroBigIntValue) == 0 {
if amount.ToInt().Cmp(pathprocessor.ZeroBigIntValue) == 0 {
fromExcluded[chainID] = false
} else {
fromIncluded[chainID] = false
@ -259,7 +259,7 @@ func newSuggestedRoutes(
rest := new(big.Int).Set(amountIn)
for _, path := range best {
diff := new(big.Int).Sub(rest, path.MaxAmountIn.ToInt())
if diff.Cmp(bridge.ZeroBigIntValue) >= 0 {
if diff.Cmp(pathprocessor.ZeroBigIntValue) >= 0 {
path.AmountIn = (*hexutil.Big)(path.MaxAmountIn.ToInt())
} else {
path.AmountIn = (*hexutil.Big)(new(big.Int).Set(rest))
@ -276,26 +276,26 @@ func newSuggestedRoutes(
func NewRouter(rpcClient *rpc.Client, transactor *transactions.Transactor, tokenManager *token.Manager, marketManager *market.Manager,
collectibles *collectibles.Service, collectiblesManager *collectibles.Manager, ensService *ens.Service, stickersService *stickers.Service) *Router {
bridges := make(map[string]bridge.Bridge)
transfer := bridge.NewTransferBridge(rpcClient, transactor)
erc721Transfer := bridge.NewERC721TransferBridge(rpcClient, transactor)
erc1155Transfer := bridge.NewERC1155TransferBridge(rpcClient, transactor)
cbridge := bridge.NewCbridge(rpcClient, transactor, tokenManager)
hop := bridge.NewHopBridge(rpcClient, transactor, tokenManager)
paraswap := bridge.NewSwapParaswap(rpcClient, transactor, tokenManager)
ensRegister := bridge.NewENSRegisterBridge(rpcClient, transactor, ensService)
ensRelease := bridge.NewENSReleaseBridge(rpcClient, transactor, ensService)
ensPublicKey := bridge.NewENSPublicKeyBridge(rpcClient, transactor, ensService)
processors := make(map[string]pathprocessor.PathProcessor)
transfer := pathprocessor.NewTransferProcessor(rpcClient, transactor)
erc721Transfer := pathprocessor.NewERC721Processor(rpcClient, transactor)
erc1155Transfer := pathprocessor.NewERC1155Processor(rpcClient, transactor)
cbridge := pathprocessor.NewCelerBridgeProcessor(rpcClient, transactor, tokenManager)
hop := pathprocessor.NewHopBridgeProcessor(rpcClient, transactor, tokenManager)
paraswap := pathprocessor.NewSwapParaswapProcessor(rpcClient, transactor, tokenManager)
ensRegister := pathprocessor.NewENSRegisterProcessor(rpcClient, transactor, ensService)
ensRelease := pathprocessor.NewENSReleaseProcessor(rpcClient, transactor, ensService)
ensPublicKey := pathprocessor.NewENSPublicKeyProcessor(rpcClient, transactor, ensService)
bridges[transfer.Name()] = transfer
bridges[erc721Transfer.Name()] = erc721Transfer
bridges[hop.Name()] = hop
bridges[cbridge.Name()] = cbridge
bridges[erc1155Transfer.Name()] = erc1155Transfer
bridges[paraswap.Name()] = paraswap
bridges[ensRegister.Name()] = ensRegister
bridges[ensRelease.Name()] = ensRelease
bridges[ensPublicKey.Name()] = ensPublicKey
processors[transfer.Name()] = transfer
processors[erc721Transfer.Name()] = erc721Transfer
processors[hop.Name()] = hop
processors[cbridge.Name()] = cbridge
processors[erc1155Transfer.Name()] = erc1155Transfer
processors[paraswap.Name()] = paraswap
processors[ensRegister.Name()] = ensRegister
processors[ensRelease.Name()] = ensRelease
processors[ensPublicKey.Name()] = ensPublicKey
return &Router{
rpcClient: rpcClient,
@ -306,7 +306,7 @@ func NewRouter(rpcClient *rpc.Client, transactor *transactions.Transactor, token
ensService: ensService,
stickersService: stickersService,
feesManager: &FeeManager{rpcClient},
bridges: bridges,
pathProcessors: processors,
}
}
@ -314,8 +314,8 @@ func (r *Router) GetFeesManager() *FeeManager {
return r.feesManager
}
func (r *Router) GetBridges() map[string]bridge.Bridge {
return r.bridges
func (r *Router) GetPathProcessors() map[string]pathprocessor.PathProcessor {
return r.pathProcessors
}
func containsNetworkChainID(network *params.Network, chainIDs []uint64) bool {
@ -337,7 +337,7 @@ type Router struct {
ensService *ens.Service
stickersService *stickers.Service
feesManager *FeeManager
bridges map[string]bridge.Bridge
pathProcessors map[string]pathprocessor.PathProcessor
}
func (r *Router) requireApproval(ctx context.Context, sendType SendType, approvalContractAddress *common.Address, account common.Address, network *params.Network, token *token.Token, amountIn *big.Int) (
@ -359,7 +359,7 @@ func (r *Router) requireApproval(ctx context.Context, sendType SendType, approva
return false, nil, 0, 0, err
}
if approvalContractAddress == nil || *approvalContractAddress == bridge.ZeroAddress {
if approvalContractAddress == nil || *approvalContractAddress == pathprocessor.ZeroAddress {
return false, nil, 0, 0, nil
}
@ -393,7 +393,7 @@ func (r *Router) requireApproval(ctx context.Context, sendType SendType, approva
estimate, err := ethClient.EstimateGas(context.Background(), ethereum.CallMsg{
From: account,
To: &token.Address,
Value: big.NewInt(0),
Value: pathprocessor.ZeroBigIntValue,
Data: data,
})
if err != nil {
@ -546,13 +546,15 @@ func (r *Router) SuggestedRoutes(
maxFees := gasFees.feeFor(gasFeeMode)
estimatedTime := r.feesManager.TransactionEstimatedTime(ctx, network.ChainID, maxFees)
for _, brdg := range r.bridges {
// Skip bridges that are added because of the Router V2, to not break the current functionality
if brdg.Name() == bridge.ENSRegisterName || brdg.Name() == bridge.ENSReleaseName || brdg.Name() == bridge.ENSPublicKeyName {
for _, pProcessor := range r.pathProcessors {
// Skip processors that are added because of the Router V2, to not break the current functionality
if pProcessor.Name() == pathprocessor.ProcessorENSRegisterName ||
pProcessor.Name() == pathprocessor.ProcessorENSReleaseName ||
pProcessor.Name() == pathprocessor.ProcessorENSPublicKeyName {
continue
}
if !sendType.canUseBridge(brdg) {
if !sendType.canUseProcessor(pProcessor) {
continue
}
@ -576,7 +578,7 @@ func (r *Router) SuggestedRoutes(
continue
}
bridgeParams := bridge.BridgeParams{
ProcessorInputParams := pathprocessor.ProcessorInputParams{
FromChain: network,
ToChain: dest,
FromToken: token,
@ -586,19 +588,19 @@ func (r *Router) SuggestedRoutes(
AmountIn: amountIn,
}
can, err := brdg.AvailableFor(bridgeParams)
can, err := pProcessor.AvailableFor(ProcessorInputParams)
if err != nil || !can {
continue
}
if maxAmountIn.ToInt().Cmp(big.NewInt(0)) == 0 {
if maxAmountIn.ToInt().Cmp(pathprocessor.ZeroBigIntValue) == 0 {
continue
}
bonderFees, tokenFees, err := brdg.CalculateFees(bridgeParams)
bonderFees, tokenFees, err := pProcessor.CalculateFees(ProcessorInputParams)
if err != nil {
continue
}
if bonderFees.Cmp(bridge.ZeroBigIntValue) != 0 {
if bonderFees.Cmp(pathprocessor.ZeroBigIntValue) != 0 {
if maxAmountIn.ToInt().Cmp(amountIn) >= 0 {
if bonderFees.Cmp(amountIn) >= 0 {
continue
@ -611,7 +613,7 @@ func (r *Router) SuggestedRoutes(
}
gasLimit := uint64(0)
if sendType.isTransfer(false) {
gasLimit, err = brdg.EstimateGas(bridgeParams)
gasLimit, err = pProcessor.EstimateGas(ProcessorInputParams)
if err != nil {
continue
}
@ -619,7 +621,7 @@ func (r *Router) SuggestedRoutes(
gasLimit = sendType.EstimateGas(r.ensService, r.stickersService, network, addrFrom, tokenID)
}
approvalContractAddress, err := brdg.GetContractAddress(bridgeParams)
approvalContractAddress, err := pProcessor.GetContractAddress(ProcessorInputParams)
if err != nil {
continue
}
@ -630,7 +632,7 @@ func (r *Router) SuggestedRoutes(
var l1GasFeeWei uint64
if sendType.needL1Fee() {
txInputData, err := brdg.PackTxInputData(bridgeParams, "")
txInputData, err := pProcessor.PackTxInputData(ProcessorInputParams, "")
if err != nil {
continue
}
@ -680,12 +682,12 @@ func (r *Router) SuggestedRoutes(
cost.Add(cost, l1GasCost)
mu.Lock()
candidates = append(candidates, &Path{
BridgeName: brdg.Name(),
BridgeName: pProcessor.Name(),
From: network,
To: dest,
MaxAmountIn: maxAmountIn,
AmountIn: (*hexutil.Big)(bridge.ZeroBigIntValue),
AmountOut: (*hexutil.Big)(bridge.ZeroBigIntValue),
AmountIn: (*hexutil.Big)(pathprocessor.ZeroBigIntValue),
AmountOut: (*hexutil.Big)(pathprocessor.ZeroBigIntValue),
GasAmount: gasLimit,
GasFees: gasFees,
BonderFees: (*hexutil.Big)(bonderFees),
@ -710,7 +712,7 @@ func (r *Router) SuggestedRoutes(
suggestedRoutes.TokenPrice = prices[tokenID]
suggestedRoutes.NativeChainTokenPrice = prices["ETH"]
for _, path := range suggestedRoutes.Best {
bridgeParams := bridge.BridgeParams{
ProcessorInputParams := pathprocessor.ProcessorInputParams{
FromChain: path.From,
ToChain: path.To,
AmountIn: path.AmountIn.ToInt(),
@ -719,7 +721,7 @@ func (r *Router) SuggestedRoutes(
},
}
amountOut, err := r.bridges[path.BridgeName].CalculateAmountOut(bridgeParams)
amountOut, err := r.pathProcessors[path.BridgeName].CalculateAmountOut(ProcessorInputParams)
if err != nil {
continue
}

18
services/wallet/router/router_send_type.go
View File

@ -16,7 +16,7 @@ import (
"github.com/status-im/status-go/services/wallet/collectibles"
walletCommon "github.com/status-im/status-go/services/wallet/common"
"github.com/status-im/status-go/services/wallet/market"
"github.com/status-im/status-go/services/wallet/router/bridge"
"github.com/status-im/status-go/services/wallet/router/pathprocessor"
"github.com/status-im/status-go/services/wallet/token"
"github.com/status-im/status-go/transactions"
)
@ -99,19 +99,19 @@ func (s SendType) needL1Fee() bool {
return s != ENSRegister && s != ENSRelease && s != ENSSetPubKey && s != StickersBuy
}
func (s SendType) canUseBridge(b bridge.Bridge) bool {
bridgeName := b.Name()
func (s SendType) canUseProcessor(p pathprocessor.PathProcessor) bool {
pathProcessorName := p.Name()
switch s {
case ERC721Transfer:
return bridgeName == bridge.ERC721TransferName
return pathProcessorName == pathprocessor.ProcessorERC721Name
case ERC1155Transfer:
return bridgeName == bridge.ERC1155TransferName
return pathProcessorName == pathprocessor.ProcessorERC1155Name
case ENSRegister:
return bridgeName == bridge.ENSRegisterName
return pathProcessorName == pathprocessor.ProcessorENSRegisterName
case ENSRelease:
return bridgeName == bridge.ENSReleaseName
return pathProcessorName == pathprocessor.ProcessorENSReleaseName
case ENSSetPubKey:
return bridgeName == bridge.ENSPublicKeyName
return pathProcessorName == pathprocessor.ProcessorENSPublicKeyName
default:
return true
}
@ -169,7 +169,7 @@ func (s SendType) isAvailableFor(network *params.Network) bool {
func (s SendType) EstimateGas(ensService *ens.Service, stickersService *stickers.Service, network *params.Network, from common.Address, tokenID string) uint64 {
tx := transactions.SendTxArgs{
From: (types.Address)(from),
Value: (*hexutil.Big)(bridge.ZeroBigIntValue),
Value: (*hexutil.Big)(pathprocessor.ZeroBigIntValue),
}
switch s {
case ENSRegister:

45
services/wallet/router/router_v2.go
View File

@ -11,9 +11,10 @@ import (
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/status-im/status-go/params"
"github.com/status-im/status-go/services/ens"
"github.com/status-im/status-go/services/wallet/async"
walletCommon "github.com/status-im/status-go/services/wallet/common"
"github.com/status-im/status-go/services/wallet/router/bridge"
"github.com/status-im/status-go/services/wallet/router/pathprocessor"
walletToken "github.com/status-im/status-go/services/wallet/token"
)
@ -51,7 +52,7 @@ type RouteInputParams struct {
}
type PathV2 struct {
BridgeName string
ProcessorName string
FromChain *params.Network // Source chain
ToChain *params.Network // Destination chain
FromToken *walletToken.Token // Token on the source chain
@ -132,7 +133,7 @@ func newSuggestedRoutesV2(
rest := new(big.Int).Set(amountIn)
for _, path := range best {
diff := new(big.Int).Sub(rest, path.AmountIn.ToInt())
if diff.Cmp(bridge.ZeroBigIntValue) >= 0 {
if diff.Cmp(pathprocessor.ZeroBigIntValue) >= 0 {
path.AmountIn = (*hexutil.Big)(path.AmountIn.ToInt())
} else {
path.AmountIn = (*hexutil.Big)(new(big.Int).Set(rest))
@ -234,7 +235,7 @@ func findBestV2(routes [][]*PathV2, tokenPrice float64, nativeChainTokenPrice fl
pathCost = new(big.Float).Mul(txFeeInEth, nativeTokenPrice)
}
if path.TxBonderFees != nil && path.TxBonderFees.ToInt().Cmp(bridge.ZeroBigIntValue) > 0 {
if path.TxBonderFees != nil && path.TxBonderFees.ToInt().Cmp(pathprocessor.ZeroBigIntValue) > 0 {
path.requiredTokenBalance.Add(path.requiredTokenBalance, path.TxBonderFees.ToInt())
pathCost.Add(pathCost, new(big.Float).Mul(
new(big.Float).Quo(new(big.Float).SetInt(path.TxBonderFees.ToInt()), tokenDenominator),
@ -242,7 +243,7 @@ func findBestV2(routes [][]*PathV2, tokenPrice float64, nativeChainTokenPrice fl
}
if path.TxL1Fee != nil && path.TxL1Fee.ToInt().Cmp(bridge.ZeroBigIntValue) > 0 {
if path.TxL1Fee != nil && path.TxL1Fee.ToInt().Cmp(pathprocessor.ZeroBigIntValue) > 0 {
l1FeeInWei := path.TxL1Fee.ToInt()
l1FeeInEth := gweiToEth(weiToGwei(l1FeeInWei))
@ -250,7 +251,7 @@ func findBestV2(routes [][]*PathV2, tokenPrice float64, nativeChainTokenPrice fl
pathCost.Add(pathCost, new(big.Float).Mul(l1FeeInEth, nativeTokenPrice))
}
if path.TxTokenFees != nil && path.TxTokenFees.ToInt().Cmp(bridge.ZeroBigIntValue) > 0 && path.FromToken != nil {
if path.TxTokenFees != nil && path.TxTokenFees.ToInt().Cmp(pathprocessor.ZeroBigIntValue) > 0 && path.FromToken != nil {
path.requiredTokenBalance.Add(path.requiredTokenBalance, path.TxTokenFees.ToInt())
pathCost.Add(pathCost, new(big.Float).Mul(
new(big.Float).Quo(new(big.Float).SetInt(path.TxTokenFees.ToInt()), tokenDenominator),
@ -294,11 +295,11 @@ func validateInputData(input *RouteInputParams) error {
return errors.New("username and public key are required for ENSRegister")
}
if input.TestnetMode {
if input.TokenID != bridge.SttSymbol {
if input.TokenID != pathprocessor.SttSymbol {
return errors.New("only STT is supported for ENSRegister on testnet")
}
} else {
if input.TokenID != bridge.SntSymbol {
if input.TokenID != pathprocessor.SntSymbol {
return errors.New("only SNT is supported for ENSRegister")
}
}
@ -311,6 +312,12 @@ func validateInputData(input *RouteInputParams) error {
}
}
if input.SendType == ENSSetPubKey {
if input.Username == "" || input.PublicKey == "" || ens.ValidateENSUsername(input.Username) != nil {
return errors.New("username and public key are required for ENSSetPubKey")
}
}
if input.FromLockedAmount != nil && len(input.FromLockedAmount) > 0 {
for chainID, amount := range input.FromLockedAmount {
if input.TestnetMode {
@ -398,8 +405,8 @@ func (r *Router) SuggestedRoutesV2(ctx context.Context, input *RouteInputParams)
return err
}
for _, brdg := range r.bridges {
if !input.SendType.canUseBridge(brdg) {
for _, pProcessor := range r.pathProcessors {
if !input.SendType.canUseProcessor(pProcessor) {
continue
}
@ -424,7 +431,7 @@ func (r *Router) SuggestedRoutesV2(ctx context.Context, input *RouteInputParams)
continue
}
bridgeParams := bridge.BridgeParams{
ProcessorInputParams := pathprocessor.ProcessorInputParams{
FromChain: network,
ToChain: dest,
FromToken: token,
@ -437,22 +444,22 @@ func (r *Router) SuggestedRoutesV2(ctx context.Context, input *RouteInputParams)
PublicKey: input.PublicKey,
}
can, err := brdg.AvailableFor(bridgeParams)
can, err := pProcessor.AvailableFor(ProcessorInputParams)
if err != nil || !can {
continue
}
bonderFees, tokenFees, err := brdg.CalculateFees(bridgeParams)
bonderFees, tokenFees, err := pProcessor.CalculateFees(ProcessorInputParams)
if err != nil {
continue
}
gasLimit, err := brdg.EstimateGas(bridgeParams)
gasLimit, err := pProcessor.EstimateGas(ProcessorInputParams)
if err != nil {
continue
}
approvalContractAddress, err := brdg.GetContractAddress(bridgeParams)
approvalContractAddress, err := pProcessor.GetContractAddress(ProcessorInputParams)
if err != nil {
continue
}
@ -464,7 +471,7 @@ func (r *Router) SuggestedRoutesV2(ctx context.Context, input *RouteInputParams)
var l1FeeWei uint64
if input.SendType.needL1Fee() {
txInputData, err := brdg.PackTxInputData(bridgeParams, "")
txInputData, err := pProcessor.PackTxInputData(ProcessorInputParams, "")
if err != nil {
continue
}
@ -488,7 +495,7 @@ func (r *Router) SuggestedRoutesV2(ctx context.Context, input *RouteInputParams)
selctedPriorityFee = priorityFees.Low
}
amountOut, err := brdg.CalculateAmountOut(bridgeParams)
amountOut, err := pProcessor.CalculateAmountOut(ProcessorInputParams)
if err != nil {
continue
}
@ -502,7 +509,7 @@ func (r *Router) SuggestedRoutesV2(ctx context.Context, input *RouteInputParams)
mu.Lock()
candidates = append(candidates, &PathV2{
BridgeName: brdg.Name(),
ProcessorName: pProcessor.Name(),
FromChain: network,
ToChain: network,
FromToken: token,
@ -549,7 +556,7 @@ func (r *Router) SuggestedRoutesV2(ctx context.Context, input *RouteInputParams)
// check the best route for the required balances
for _, path := range suggestedRoutes.Best {
if path.requiredTokenBalance != nil && path.requiredTokenBalance.Cmp(big.NewInt(0)) > 0 {
if path.requiredTokenBalance != nil && path.requiredTokenBalance.Cmp(pathprocessor.ZeroBigIntValue) > 0 {
tokenBalance := big.NewInt(1)
if input.SendType == ERC1155Transfer {
tokenBalance, err = r.getERC1155Balance(ctx, path.FromChain, path.FromToken, input.AddrFrom)

8
services/wallet/transfer/helpers.go
View File

@ -15,7 +15,7 @@ import (
"github.com/status-im/status-go/eth-node/crypto"
"github.com/status-im/status-go/eth-node/types"
wallet_common "github.com/status-im/status-go/services/wallet/common"
"github.com/status-im/status-go/services/wallet/router/bridge"
"github.com/status-im/status-go/services/wallet/router/pathprocessor"
)
func rowsToMultiTransactions(rows *sql.Rows) ([]*MultiTransaction, error) {
@ -121,7 +121,7 @@ func multiTransactionFromCommand(command *MultiTransactionCommand) *MultiTransac
return multiTransaction
}
func updateDataFromMultiTx(data []*bridge.TransactionBridge, multiTransaction *MultiTransaction) {
func updateDataFromMultiTx(data []*pathprocessor.MultipathProcessorTxArgs, multiTransaction *MultiTransaction) {
for _, tx := range data {
if tx.TransferTx != nil {
tx.TransferTx.MultiTransactionID = multiTransaction.ID
@ -150,12 +150,12 @@ func updateDataFromMultiTx(data []*bridge.TransactionBridge, multiTransaction *M
}
}
func sendTransactions(data []*bridge.TransactionBridge, bridges map[string]bridge.Bridge, account *account.SelectedExtKey) (
func sendTransactions(data []*pathprocessor.MultipathProcessorTxArgs, pathProcessors map[string]pathprocessor.PathProcessor, account *account.SelectedExtKey) (
map[uint64][]types.Hash, error) {
hashes := make(map[uint64][]types.Hash)
for _, tx := range data {
hash, err := bridges[tx.BridgeName].Send(tx, account)
hash, err := pathProcessors[tx.Name].Send(tx, account)
if err != nil {
return nil, err // TODO: One of transfers within transaction could have been sent. Need to notify user about it
}

4
services/wallet/transfer/transaction_manager.go
View File

@ -16,7 +16,7 @@ import (
"github.com/status-im/status-go/multiaccounts/accounts"
"github.com/status-im/status-go/params"
wallet_common "github.com/status-im/status-go/services/wallet/common"
"github.com/status-im/status-go/services/wallet/router/bridge"
"github.com/status-im/status-go/services/wallet/router/pathprocessor"
"github.com/status-im/status-go/transactions"
)
@ -43,7 +43,7 @@ type TransactionManager struct {
eventFeed *event.Feed
multiTransactionForKeycardSigning *MultiTransaction
transactionsBridgeData []*bridge.TransactionBridge
multipathTransactionsData []*pathprocessor.MultipathProcessorTxArgs
transactionsForKeycardSigning map[common.Hash]*TransactionDescription
}

8
services/wallet/transfer/transaction_manager_internal.go
View File

@ -5,14 +5,14 @@ import (
"github.com/ethereum/go-ethereum/common"
ethTypes "github.com/ethereum/go-ethereum/core/types"
"github.com/status-im/status-go/services/wallet/router/bridge"
"github.com/status-im/status-go/services/wallet/router/pathprocessor"
)
func (tm *TransactionManager) buildTransactions(bridges map[string]bridge.Bridge) ([]string, error) {
func (tm *TransactionManager) buildTransactions(pathProcessors map[string]pathprocessor.PathProcessor) ([]string, error) {
tm.transactionsForKeycardSigning = make(map[common.Hash]*TransactionDescription)
var hashes []string
for _, bridgeTx := range tm.transactionsBridgeData {
builtTx, err := bridges[bridgeTx.BridgeName].BuildTransaction(bridgeTx)
for _, bridgeTx := range tm.multipathTransactionsData {
builtTx, err := pathProcessors[bridgeTx.Name].BuildTransaction(bridgeTx)
if err != nil {
return hashes, err
}

14
services/wallet/transfer/transaction_manager_multitransaction.go
View File

@ -13,7 +13,7 @@ import (
"github.com/status-im/status-go/account"
"github.com/status-im/status-go/eth-node/types"
wallet_common "github.com/status-im/status-go/services/wallet/common"
"github.com/status-im/status-go/services/wallet/router/bridge"
"github.com/status-im/status-go/services/wallet/router/pathprocessor"
"github.com/status-im/status-go/services/wallet/walletevent"
"github.com/status-im/status-go/signal"
"github.com/status-im/status-go/transactions"
@ -35,7 +35,7 @@ func (tm *TransactionManager) UpdateMultiTransaction(multiTransaction *MultiTran
}
func (tm *TransactionManager) CreateMultiTransactionFromCommand(command *MultiTransactionCommand,
data []*bridge.TransactionBridge) (*MultiTransaction, error) {
data []*pathprocessor.MultipathProcessorTxArgs) (*MultiTransaction, error) {
multiTransaction := multiTransactionFromCommand(command)
@ -46,7 +46,7 @@ func (tm *TransactionManager) CreateMultiTransactionFromCommand(command *MultiTr
return multiTransaction, nil
}
func (tm *TransactionManager) SendTransactionForSigningToKeycard(ctx context.Context, multiTransaction *MultiTransaction, data []*bridge.TransactionBridge, bridges map[string]bridge.Bridge) error {
func (tm *TransactionManager) SendTransactionForSigningToKeycard(ctx context.Context, multiTransaction *MultiTransaction, data []*pathprocessor.MultipathProcessorTxArgs, pathProcessors map[string]pathprocessor.PathProcessor) error {
acc, err := tm.accountsDB.GetAccountByAddress(types.Address(multiTransaction.FromAddress))
if err != nil {
return err
@ -62,8 +62,8 @@ func (tm *TransactionManager) SendTransactionForSigningToKeycard(ctx context.Con
}
tm.multiTransactionForKeycardSigning = multiTransaction
tm.transactionsBridgeData = data
hashes, err := tm.buildTransactions(bridges)
tm.multipathTransactionsData = data
hashes, err := tm.buildTransactions(pathProcessors)
if err != nil {
return err
}
@ -73,9 +73,9 @@ func (tm *TransactionManager) SendTransactionForSigningToKeycard(ctx context.Con
return nil
}
func (tm *TransactionManager) SendTransactions(ctx context.Context, multiTransaction *MultiTransaction, data []*bridge.TransactionBridge, bridges map[string]bridge.Bridge, account *account.SelectedExtKey) (*MultiTransactionCommandResult, error) {
func (tm *TransactionManager) SendTransactions(ctx context.Context, multiTransaction *MultiTransaction, data []*pathprocessor.MultipathProcessorTxArgs, pathProcessors map[string]pathprocessor.PathProcessor, account *account.SelectedExtKey) (*MultiTransactionCommandResult, error) {
updateDataFromMultiTx(data, multiTransaction)
hashes, err := sendTransactions(data, bridges, account)
hashes, err := sendTransactions(data, pathProcessors, account)
if err != nil {
return nil, err
}

36
services/wallet/transfer/transaction_manager_multitransaction_test.go
View File

@ -17,8 +17,8 @@ import (
"github.com/status-im/status-go/eth-node/types"
"github.com/status-im/status-go/rpc"
wallet_common "github.com/status-im/status-go/services/wallet/common"
"github.com/status-im/status-go/services/wallet/router/bridge"
"github.com/status-im/status-go/services/wallet/router/bridge/mock_bridge"
"github.com/status-im/status-go/services/wallet/router/pathprocessor"
"github.com/status-im/status-go/services/wallet/router/pathprocessor/mock_pathprocessor"
"github.com/status-im/status-go/services/wallet/walletevent"
"github.com/status-im/status-go/t/helpers"
"github.com/status-im/status-go/transactions"
@ -35,9 +35,9 @@ func deepCopy(tx *transactions.SendTxArgs) *transactions.SendTxArgs {
}
}
func deepCopyTransactionBridgeWithTransferTx(tx *bridge.TransactionBridge) *bridge.TransactionBridge {
return &bridge.TransactionBridge{
BridgeName: tx.BridgeName,
func deepCopyTransactionBridgeWithTransferTx(tx *pathprocessor.MultipathProcessorTxArgs) *pathprocessor.MultipathProcessorTxArgs {
return &pathprocessor.MultipathProcessorTxArgs{
Name: tx.Name,
ChainID: tx.ChainID,
TransferTx: deepCopy(tx.TransferTx),
HopTx: tx.HopTx,
@ -68,7 +68,7 @@ func setupAccount(_ *testing.T, address common.Address) *account.SelectedExtKey
}
}
func setupTransactionData(_ *testing.T, transactor transactions.TransactorIface) (*MultiTransaction, []*bridge.TransactionBridge, map[string]bridge.Bridge, []*bridge.TransactionBridge) {
func setupTransactionData(_ *testing.T, transactor transactions.TransactorIface) (*MultiTransaction, []*pathprocessor.MultipathProcessorTxArgs, map[string]pathprocessor.PathProcessor, []*pathprocessor.MultipathProcessorTxArgs) {
SetMultiTransactionIDGenerator(StaticIDCounter())
// Create mock data for the test
@ -77,14 +77,14 @@ func setupTransactionData(_ *testing.T, transactor transactions.TransactorIface)
// Initialize the bridges
var rpcClient *rpc.Client = nil
bridges := make(map[string]bridge.Bridge)
transferBridge := bridge.NewTransferBridge(rpcClient, transactor)
bridges := make(map[string]pathprocessor.PathProcessor)
transferBridge := pathprocessor.NewTransferProcessor(rpcClient, transactor)
bridges[transferBridge.Name()] = transferBridge
data := []*bridge.TransactionBridge{
data := []*pathprocessor.MultipathProcessorTxArgs{
{
ChainID: 1,
BridgeName: transferBridge.Name(),
ChainID: 1,
Name: transferBridge.Name(),
TransferTx: &transactions.SendTxArgs{
From: types.Address(ethTransfer.From),
To: (*types.Address)(&ethTransfer.To),
@ -95,8 +95,8 @@ func setupTransactionData(_ *testing.T, transactor transactions.TransactorIface)
},
},
{
ChainID: 420,
BridgeName: transferBridge.Name(),
ChainID: 420,
Name: transferBridge.Name(),
TransferTx: &transactions.SendTxArgs{
From: types.Address(ethTransfer.From),
To: (*types.Address)(&ethTransfer.To),
@ -108,10 +108,10 @@ func setupTransactionData(_ *testing.T, transactor transactions.TransactorIface)
},
}
expectedData := make([]*bridge.TransactionBridge, 0)
expectedData := make([]*pathprocessor.MultipathProcessorTxArgs, 0)
for _, tx := range data {
txCopy := deepCopyTransactionBridgeWithTransferTx(tx)
updateDataFromMultiTx([]*bridge.TransactionBridge{txCopy}, &multiTransaction)
updateDataFromMultiTx([]*pathprocessor.MultipathProcessorTxArgs{txCopy}, &multiTransaction)
expectedData = append(expectedData, txCopy)
}
@ -140,11 +140,11 @@ func TestSendTransactionsETHFailOnBridge(t *testing.T) {
multiTransaction, data, _, _ := setupTransactionData(t, transactor)
// Initialize the bridges
bridges := make(map[string]bridge.Bridge)
transferBridge := mock_bridge.NewMockBridge(ctrl)
bridges := make(map[string]pathprocessor.PathProcessor)
transferBridge := mock_pathprocessor.NewMockPathProcessor(ctrl)
// Set bridge name for the mock to the one used in data
transferBridge.EXPECT().Name().Return(data[0].BridgeName).AnyTimes()
transferBridge.EXPECT().Name().Return(data[0].Name).AnyTimes()
bridges[transferBridge.Name()] = transferBridge
expectedErr := transactions.ErrInvalidTxSender // Any error to verify