rfqmm

type AmountCalculator interface {
	CalRecvAmt(tokenIn, tokenOut *common.Token, amountIn, baseFee *big.Int, isLightMM bool) (recvAmt, releaseAmt, fee *big.Int, err error)
	CalSendAmt(tokenIn, tokenOut *common.Token, amountOut *big.Int) (sendAmt, releaseAmt, fee *big.Int, err error)
}

type Chain struct {
	*ethclient.Client
	ChainId       uint64
	BlockDelay    uint64
	NativeWrap    *common.Token
	RfqContract   *rfq.Rfq
	RfqAddress    eth.Addr
	IWETH         *iweth.Iweth
	MsgFee        *big.Int
	TxOptions     []ethutils.TxOption
	GasPriceCache *dataCache
}

type ChainManager struct {
	// contains filtered or unexported fields
}

type ChainOverride struct {
	SrcChainId, DstChainId uint64
	Perc                   uint32
}

type ChainQuerier interface {
	GetRfqContract(chainId uint64) (eth.Addr, error)
	GetRfqFee(srcChainId, dstChainId uint64, amount *big.Int) (*big.Int, error)
	GetMsgFee(chainId uint64) (*big.Int, error)
	GetGasPrice(chainId uint64) (*big.Int, error)
	GetNativeWrap(chainId uint64) (*common.Token, error)
	GetERC20Balance(chainId uint64, token, account eth.Addr) (*big.Int, error)
	GetNativeBalance(chainId uint64, accoun eth.Addr) (*big.Int, error)
	GetQuoteStatus(chainId uint64, quoteHash eth.Hash) (uint8, error)
	VerifyRfqEvent(chainId uint64, tx eth.Hash, evName string) (bool, error)
}

type Client struct {
	proto.ApiClient
	// contains filtered or unexported fields
}

type DefaultAmtCalculator struct {
	// fixed cost related fields
	DstGasCost uint64
	SrcGasCost uint64
	GasPrice   map[uint64]uint64

	// personalized fee related fieds
	// 100% = 1000000
	FeePercGlobal        uint32
	PerChainPairOverride map[uint64]map[uint64]uint32
	PerTokenPairOverride map[string]map[string]uint32

	// helper
	Querier       ChainQuerier
	PriceProvider PriceProvider
}

type DefaultLiquidityProvider struct {
	// contains filtered or unexported fields
}

type DefaultRequestSigner struct {
	Signer  ethutils.Signer
	Address eth.Addr
}

type FeeConfig struct {
	DstGasCost     uint64
	SrcGasCost     uint64
	PercGlobal     uint32
	ChainOverrides []*ChainOverride
	TokenOverrides []*TokenOverride
	GasPrices      []*GasPrice
}

type GasPrice struct {
	ChainId uint64
	Price   uint64
}

type LPConfig struct {
	ChainId       uint64
	Address       string
	Keystore      string
	Passphrase    string
	Liqs          []*LiquidityConfig
	ReleaseNative bool
}

type LiqManager struct {
	LPs map[uint64]*LiqProvider
}

type LiqOpDetail struct {
	Type   int
	Until  int64
	Token  string
	Amount *big.Int
	Hash   eth.Hash
}

type LiqProvider struct {
	// contains filtered or unexported fields
}

type Liquidity struct {
	// contains filtered or unexported fields
}

type LiquidityConfig struct {
	Address    string
	Symbol     string
	Amount     string
	Approve    string
	Decimals   int32
	FreezeTime int64
}

type LiquidityProvider interface {
	// IsPaused returns whether the LiquidityProvider is paused or not
	IsPaused() bool
	// GetTokens returns a list of all supported tokens
	GetTokens() []*common.Token
	// SetupTokenPairs sets up supported token pairs based on a given policy list.
	SetupTokenPairs(policies []string)
	// HasTokenPair check if a given token pair is supported
	HasTokenPair(srcToken, dstToken *common.Token) bool
	// GetLiquidityProviderAddr returns the address of liquidity provider on specified chain
	GetLiquidityProviderAddr(chainId uint64) (eth.Addr, error)
	// AskForFreezing checks if there is sufficient liquidity for specified token on specified chain and returns freeze time
	AskForFreezing(chainId uint64, token eth.Addr, amount *big.Int, isNative bool) (int64, error)
	// FreezeLiquidity will freeze a certain liquidity for specified amount until specified timestamp with an index of hash.
	FreezeLiquidity(chainId uint64, token eth.Addr, amount *big.Int, until int64, hash eth.Hash, isNative bool) error
	// UnfreezeLiquidity will try to unfreeze a certain liquidity with specified hash.
	UnfreezeLiquidity(chainId uint64, hash eth.Hash) error
	// DstTransfer should send tx on dstChain to transfer dstToken to user
	DstTransfer(transferNative bool, _quote rfq.RFQQuote, opts ...ethutils.TxOption) (eth.Hash, error)
	// SrcRelease should send tx on srcChain to release srcToken to mm
	SrcRelease(_quote rfq.RFQQuote, _execMsgCallData []byte, opts ...ethutils.TxOption) (eth.Hash, error)
}

type PriceProvider interface {
	GetPrice(token *common.Token) (float64, error)
}

type RequestSigner interface {
	Sign(data []byte) ([]byte, error)
	Verify(data, sig []byte) bool
}

type RequestSignerConfig struct {
	ChainId    uint64
	Keystore   string
	Passphrase string
}

type RfqMmChainConfig struct {
	ChainId                                             uint64
	Name, Gateway                                       string
	BlkInterval, BlkDelay, MaxBlkDelta, ForwardBlkDelay uint64
	GasLimit                                            uint64
	AddGasEstimateRatio                                 float64
	// Legacy gas price flags
	AddGasGwei   uint64
	MinGasGwei   uint64
	MaxGasGwei   uint64
	ForceGasGwei string
	// EIP-1559 gas price flags
	MaxFeePerGasGwei         uint64
	MaxPriorityFeePerGasGwei uint64
	// if ProxyPort > 0, a proxy with this port will be created to support some special chain such as harmony, celo.
	// chainID will be used to determined which type proxy to create, so make sure the chainID is supported in the "endpoint-proxy"
	// create a proxy to the Gateway, and eth-client will be created to "127.0.0.1:ProxyPort"
	// more detail, https://github.com/celer-network/endpoint-proxy
	ProxyPort int

	Rfq    string
	Native *common.Token
}

type Server struct {
	Ctl               chan bool
	RfqClient         *rfqserver.Client
	Config            *ServerConfig
	ChainCaller       ChainQuerier
	LiquidityProvider LiquidityProvider
	AmountCalculator  AmountCalculator
	RequestSigner     RequestSigner
}

type ServerConfig struct {
	// the period for retrying report supported tokens to rfq server
	ReportRetryPeriod int64
	// the period for processing pending orders
	ProcessPeriod int64
	// indicates the period for a price to be valid
	PriceValidPeriod int64
	// minimum dst transfer period, in order to give mm enough time for dst transfer
	DstTransferPeriod int64
	// token pair policy list
	TPPolicyList []string
	// port num that mm grpc service would listen on
	GrpcPort int64
	// port num that mm restful api would listen on
	GrpcGatewayPort int64
	// light mm, which needs a relayer to interact with rfq server
	LightMM bool
	// if not set, will use localhost
	Host string
}

type TokenOverride struct {
	SrcChainId, DstChainId uint64
	SrcToken, DstToken     string
	Perc                   uint32
}

type Update struct {
	Hash   eth.Hash
	Status rfqproto.OrderStatus
}