github.com/status-im/status-go@v1.1.0/services/wallet/router/pathprocessor/processor_ens_public_key.go (about)

     1  package pathprocessor
     2  
     3  import (
     4  	"context"
     5  	"math/big"
     6  	"strings"
     7  
     8  	"github.com/ethereum/go-ethereum"
     9  	"github.com/ethereum/go-ethereum/accounts/abi"
    10  	"github.com/ethereum/go-ethereum/common"
    11  	ethTypes "github.com/ethereum/go-ethereum/core/types"
    12  	"github.com/status-im/status-go/account"
    13  	"github.com/status-im/status-go/contracts"
    14  	"github.com/status-im/status-go/contracts/resolver"
    15  	"github.com/status-im/status-go/eth-node/types"
    16  	"github.com/status-im/status-go/rpc"
    17  	"github.com/status-im/status-go/services/ens"
    18  	walletCommon "github.com/status-im/status-go/services/wallet/common"
    19  	"github.com/status-im/status-go/transactions"
    20  )
    21  
    22  type ENSPublicKeyProcessor struct {
    23  	contractMaker *contracts.ContractMaker
    24  	transactor    transactions.TransactorIface
    25  	ensService    *ens.Service
    26  }
    27  
    28  func NewENSPublicKeyProcessor(rpcClient *rpc.Client, transactor transactions.TransactorIface, ensService *ens.Service) *ENSPublicKeyProcessor {
    29  	return &ENSPublicKeyProcessor{
    30  		contractMaker: &contracts.ContractMaker{
    31  			RPCClient: rpcClient,
    32  		},
    33  		transactor: transactor,
    34  		ensService: ensService,
    35  	}
    36  }
    37  
    38  func createENSPublicKeyErrorResponse(err error) error {
    39  	return createErrorResponse(ProcessorENSPublicKeyName, err)
    40  }
    41  
    42  func (s *ENSPublicKeyProcessor) Name() string {
    43  	return ProcessorENSPublicKeyName
    44  }
    45  
    46  func (s *ENSPublicKeyProcessor) AvailableFor(params ProcessorInputParams) (bool, error) {
    47  	return params.FromChain.ChainID == walletCommon.EthereumMainnet || params.FromChain.ChainID == walletCommon.EthereumSepolia, nil
    48  }
    49  
    50  func (s *ENSPublicKeyProcessor) CalculateFees(params ProcessorInputParams) (*big.Int, *big.Int, error) {
    51  	return ZeroBigIntValue, ZeroBigIntValue, nil
    52  }
    53  
    54  func (s *ENSPublicKeyProcessor) PackTxInputData(params ProcessorInputParams) ([]byte, error) {
    55  	resolverABI, err := abi.JSON(strings.NewReader(resolver.PublicResolverABI))
    56  	if err != nil {
    57  		return []byte{}, createENSPublicKeyErrorResponse(err)
    58  	}
    59  
    60  	x, y := ens.ExtractCoordinates(params.PublicKey)
    61  	return resolverABI.Pack("setPubkey", ens.NameHash(params.Username), x, y)
    62  }
    63  
    64  func (s *ENSPublicKeyProcessor) EstimateGas(params ProcessorInputParams) (uint64, error) {
    65  	if params.TestsMode {
    66  		if params.TestEstimationMap != nil {
    67  			if val, ok := params.TestEstimationMap[s.Name()]; ok {
    68  				return val.Value, val.Err
    69  			}
    70  		}
    71  		return 0, ErrNoEstimationFound
    72  	}
    73  
    74  	contractAddress, err := s.GetContractAddress(params)
    75  	if err != nil {
    76  		return 0, createENSPublicKeyErrorResponse(err)
    77  	}
    78  
    79  	input, err := s.PackTxInputData(params)
    80  	if err != nil {
    81  		return 0, createENSPublicKeyErrorResponse(err)
    82  	}
    83  
    84  	ethClient, err := s.contractMaker.RPCClient.EthClient(params.FromChain.ChainID)
    85  	if err != nil {
    86  		return 0, err
    87  	}
    88  
    89  	msg := ethereum.CallMsg{
    90  		From:  params.FromAddr,
    91  		To:    &contractAddress,
    92  		Value: ZeroBigIntValue,
    93  		Data:  input,
    94  	}
    95  
    96  	estimation, err := ethClient.EstimateGas(context.Background(), msg)
    97  	if err != nil {
    98  		return 0, createENSPublicKeyErrorResponse(err)
    99  	}
   100  
   101  	increasedEstimation := float64(estimation) * IncreaseEstimatedGasFactor
   102  
   103  	return uint64(increasedEstimation), nil
   104  }
   105  
   106  func (s *ENSPublicKeyProcessor) Send(sendArgs *MultipathProcessorTxArgs, lastUsedNonce int64, verifiedAccount *account.SelectedExtKey) (hash types.Hash, usedNonce uint64, err error) {
   107  	return s.transactor.SendTransactionWithChainID(sendArgs.ChainID, *sendArgs.TransferTx, lastUsedNonce, verifiedAccount)
   108  }
   109  
   110  func (s *ENSPublicKeyProcessor) BuildTransaction(sendArgs *MultipathProcessorTxArgs, lastUsedNonce int64) (*ethTypes.Transaction, uint64, error) {
   111  	return s.transactor.ValidateAndBuildTransaction(sendArgs.ChainID, *sendArgs.TransferTx, lastUsedNonce)
   112  }
   113  
   114  func (s *ENSPublicKeyProcessor) CalculateAmountOut(params ProcessorInputParams) (*big.Int, error) {
   115  	return params.AmountIn, nil
   116  }
   117  
   118  func (s *ENSPublicKeyProcessor) GetContractAddress(params ProcessorInputParams) (common.Address, error) {
   119  	addr, err := s.ensService.API().Resolver(context.Background(), params.FromChain.ChainID, params.Username)
   120  	if err != nil {
   121  		return common.Address{}, createENSPublicKeyErrorResponse(err)
   122  	}
   123  	if *addr == ZeroAddress {
   124  		return common.Address{}, ErrENSResolverNotFound
   125  	}
   126  	return *addr, nil
   127  }