rpc

type CancelRequest struct {
	OfferID types.Hash `json:"offerID" validate:"required"`
}

type CancelResponse struct {
	Status types.Status `json:"status" validate:"required"`
}

type ClearOffersRequest struct {
	OfferIDs []types.Hash `json:"offerIDs" validate:"dive,required"`
}

type Codec struct{}

type CodecRequest struct {
	*json2.CodecRequest
}

type Config struct {
	Ctx             context.Context
	Env             common.Environment
	Address         string // "IP:port"
	Net             Net
	XMRTaker        XMRTaker        // nil on bootnodes
	XMRMaker        XMRMaker        // nil on bootnodes
	ProtocolBackend ProtocolBackend // nil on bootnodes
	RecoveryDB      RecoveryDB      // nil on bootnodes
	Namespaces      map[string]struct{}
}

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

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

type GetContractSwapInfoRequest struct {
	OfferID types.Hash `json:"offerID" validate:"required"`
}

type GetContractSwapInfoResponse struct {
	StartNumber     *big.Int                   `json:"startBlockNumber" validate:"required"`
	SwapID          types.Hash                 `json:"swapID" validate:"required"`
	Swap            *contracts.SwapCreatorSwap `json:"swap" validate:"required"`
	SwapCreatorAddr ethcommon.Address          `json:"swapCreatorAddr" validate:"required"`
}

type GetOffersResponse struct {
	PeerID peer.ID        `json:"peerID" validate:"required"`
	Offers []*types.Offer `json:"offers" validate:"dive,required"`
}

type GetOngoingRequest struct {
	OfferID *types.Hash `json:"offerID,omitempty"`
}

type GetOngoingResponse struct {
	Swaps []*OngoingSwap `json:"swaps" validate:"dive,required"`
}

type GetPastRequest struct {
	OfferID *types.Hash `json:"offerID,omitempty"`
}

type GetPastResponse struct {
	Swaps []*PastSwap `json:"swaps" validate:"dive,required"`
}

type GetStatusRequest struct {
	ID types.Hash `json:"id" validate:"required"`
}

type GetStatusResponse struct {
	Status      types.Status `json:"status" validate:"required"`
	Description string       `json:"info" validate:"required"`
	StartTime   time.Time    `json:"startTime" validate:"required"`
}

type GetSwapSecretRequest struct {
	OfferID types.Hash `json:"offerID" validate:"required"`
}

type GetSwapSecretResponse struct {
	Secret *mcrypto.PrivateSpendKey `json:"secret" validate:"required"`
}

type GetSwapTimeoutResponse struct {
	Timeout uint64 `json:"timeout"` // timeout in seconds
}

type ManualTransactionRequest struct {
	OfferID types.Hash `json:"offerID" validate:"required"`
}

type ManualTransactionResponse struct {
	TxHash types.Hash `json:"txHash" validate:"required"`
}

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

type Net interface {
	PeerID() peer.ID
	ConnectedPeers() []string
	Addresses() []ma.Multiaddr
	Discover(provides string, searchTime time.Duration) ([]peer.ID, error)
	Query(who peer.ID) (*message.QueryResponse, error)
	Initiate(who peer.AddrInfo, sendKeysMessage common.Message, s common.SwapStateNet) error
	CloseProtocolStream(types.Hash)
}

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

type OngoingSwap struct {
	ID                        types.Hash          `json:"id" validate:"required"`
	Provided                  coins.ProvidesCoin  `json:"provided" validate:"required"`
	EthAsset                  types.EthAsset      `json:"ethAsset"`
	ProvidedAmount            *apd.Decimal        `json:"providedAmount" validate:"required"`
	ExpectedAmount            *apd.Decimal        `json:"expectedAmount" validate:"required"`
	ExchangeRate              *coins.ExchangeRate `json:"exchangeRate" validate:"required"`
	Status                    types.Status        `json:"status" validate:"required"`
	LastStatusUpdateTime      time.Time           `json:"lastStatusUpdateTime" validate:"required"`
	StartTime                 time.Time           `json:"startTime" validate:"required"`
	Timeout1                  *time.Time          `json:"timeout1"`
	Timeout2                  *time.Time          `json:"timeout2"`
	EstimatedTimeToCompletion time.Duration       `json:"estimatedTimeToCompletion" validate:"required"`
}

type PastSwap struct {
	ID             types.Hash          `json:"id" validate:"required"`
	Provided       coins.ProvidesCoin  `json:"provided" validate:"required"`
	EthAsset       types.EthAsset      `json:"ethAsset"`
	ProvidedAmount *apd.Decimal        `json:"providedAmount" validate:"required"`
	ExpectedAmount *apd.Decimal        `json:"expectedAmount" validate:"required"`
	RelayerFee     *apd.Decimal        `json:"relayerFee"`
	ExchangeRate   *coins.ExchangeRate `json:"exchangeRate" validate:"required"`
	Status         types.Status        `json:"status" validate:"required"`
	StartTime      time.Time           `json:"startTime" validate:"required"`
	EndTime        *time.Time          `json:"endTime"`
}

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

type Protocol interface {
	Provides() coins.ProvidesCoin
	GetOngoingSwapState(types.Hash) common.SwapState
}

type ProtocolBackend interface {
	Ctx() context.Context
	Env() common.Environment
	SetSwapTimeout(timeout time.Duration)
	SwapTimeout() time.Duration
	SwapManager() swap.Manager
	SwapCreatorAddr() ethcommon.Address
	SetXMRDepositAddress(*mcrypto.Address, types.Hash)
	ClearXMRDepositAddress(types.Hash)
	ETHClient() extethclient.EthClient
	TransferXMR(to *mcrypto.Address, amount *coins.PiconeroAmount) (string, error)
	SweepXMR(to *mcrypto.Address) ([]string, error)
	TransferETH(to ethcommon.Address, amount *coins.WeiAmount, gasLimit *uint64) (*ethtypes.Receipt, error)
	SweepETH(to ethcommon.Address) (*ethtypes.Receipt, error)
}

type RecoveryDB interface {
	GetContractSwapInfo(id types.Hash) (*db.EthereumSwapInfo, error)
	GetSwapPrivateKey(id types.Hash) (*mcrypto.PrivateSpendKey, error)
	GetCounterpartySwapPrivateKey(id types.Hash) (*mcrypto.PrivateSpendKey, error)
}

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

type SetGasPriceRequest struct {
	GasPrice uint64 `json:"gasPrice" validate:"required"`
}

type SetSwapTimeoutRequest struct {
	Timeout uint64 `json:"timeout" validate:"required"` // timeout in seconds
}

type SuggestedExchangeRateResponse struct {
	ETHUpdatedAt time.Time           `json:"ethUpdatedAt" validate:"required"`
	ETHPrice     *apd.Decimal        `json:"ethPrice" validate:"required"`
	XMRUpdatedAt time.Time           `json:"xmrUpdatedAt" validate:"required"`
	XMRPrice     *apd.Decimal        `json:"xmrPrice" validate:"required"`
	ExchangeRate *coins.ExchangeRate `json:"exchangeRate" validate:"required"`
}

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

type SweepETHRequest struct {
	To ethcommon.Address `json:"to" validate:"required"`
}

type SweepETHResponse struct {
	TxHash ethcommon.Hash `json:"txHash"` // Hash of sweep transfer transaction
}

type SweepXMRRequest struct {
	To *mcrypto.Address `json:"to" validate:"required"`
}

type SweepXMRResponse struct {
	TxIDs []string `json:"txIds"`
}

type TransferETHRequest struct {
	To       ethcommon.Address `json:"to" validate:"required"`
	Amount   *apd.Decimal      `json:"amount" validate:"required"`
	GasLimit *uint64           `json:"gasLimit,omitempty"`
}

type TransferETHResponse struct {
	TxHash   ethcommon.Hash `json:"txHash"`
	GasLimit *uint64        `json:"gasLimit,omitempty"`
}

type TransferXMRRequest struct {
	To     *mcrypto.Address `json:"to" validate:"required"`
	Amount *apd.Decimal     `json:"amount" validate:"required"`
}

type TransferXMRResponse struct {
	TxID string `json:"txID"`
}

type VersionResponse struct {
	SwapdVersion    string             `json:"swapdVersion" validate:"required"`
	P2PVersion      string             `json:"p2pVersion" validate:"required"`
	Env             common.Environment `json:"env" validate:"required"`
	SwapCreatorAddr *ethcommon.Address `json:"swapCreatorAddress,omitempty"`
}

type XMRMaker interface {
	Protocol
	MakeOffer(offer *types.Offer, useRelayer bool) (*types.OfferExtra, error)
	GetOffers() []*types.Offer
	ClearOffers([]types.Hash) error
	GetMoneroBalance() (*mcrypto.Address, *wallet.GetBalanceResponse, error)
}

type XMRTaker interface {
	Protocol
	InitiateProtocol(peerID peer.ID, providesAmount *apd.Decimal, offer *types.Offer) (common.SwapState, error)
	ExternalSender(offerID types.Hash) (*txsender.ExternalSender, error)
}