swap

type Action interface {
	Execute(services *SwapServices, swap *SwapData) EventType
}

type AwaitCsvAction struct{}

type AwaitFeeInvoicePayment struct{}

type AwaitPaymentOrCsvAction struct{}

type AwaitTxConfirmationAction struct{}

type CancelAction struct{}

type CancelMessage struct {
	// SwapId is the unique identifier of the swap.
	SwapId *SwapId `json:"swap_id"`
	// Message is a hint to why the swap was canceled.
	Message string `json:"message"`
}

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

type ClaimParams struct {
	Preimage     string
	Signer       Signer
	OpeningTxHex string

	// blinded tx stuff
	BlindingSeed              []byte
	OutputAssetBlindingFactor []byte
	EphemeralKey              *btcec.PrivateKey
}

type ClaimSwapTransactionCoop struct{}

type ClaimSwapTransactionWithCsv struct{}

type ClaimSwapTransactionWithPreimageAction struct{}

type ClaimType int

type CoopCloseMessage struct {
	// SwapId is the unique identifier of the swap.
	SwapId *SwapId `json:"swap_id"`
	// Message is a hint to why the swap was canceled.
	Message string `json:"message"`
	// privkey is the private key to the pubkey that is used to build the opening_transaction.
	Privkey string `json:"privkey"`
}

type CreateAndBroadcastOpeningTransaction struct{}

type CreateSwapOutFromRequestAction struct{}

type CreateSwapRequestAction struct{}

type ErrMinimumSwapSize uint64

type ErrUnknownSwapMessageType string

type EventContext interface {
	ApplyToSwapData(data *SwapData) error
	Validate(data *SwapData) error
}

type EventType string

type Events map[EventType]StateType

type InvoiceType int

type JsonAssetRequest struct {
	TotalAmountSat uint64 `json:"total_amount_sat"`
	NRequests      uint64 `json:"n_requests"`
}

type JsonEnty struct {
	NodeId   string                                  `json:"node_id"`
	Requests map[string]map[string]*JsonAssetRequest `json:"requests"`
}

type LightningClient interface {
	DecodePayreq(payreq string) (paymentHash string, amountMsat uint64, expiry int64, err error)
	PayInvoice(payreq string) (preImage string, err error)
	GetPayreq(msatAmount uint64, preimage string, swapId string, memo string, invoiceType InvoiceType, expirySeconds, expiryCltv uint64) (string, error)
	PayInvoiceViaChannel(payreq string, channel string) (preimage string, err error)
	AddPaymentCallback(f func(swapId string, invoiceType InvoiceType))
	AddPaymentNotifier(swapId string, payreq string, invoiceType InvoiceType)
	RebalancePayment(payreq string, channel string) (preimage string, err error)
}

type Messenger interface {
	SendMessage(peerId string, message []byte, messageType int) error
	AddMessageHandler(func(peerId string, msgType string, payload []byte) error)
}

type MessengerManager interface {
	AddSender(id string, messenger messages.StoppableMessenger) error
	RemoveSender(id string)
}

type NoOpAction struct{}

type NoOpDoneAction struct{}

type OpeningParams struct {
	TakerPubkey      string
	MakerPubkey      string
	ClaimPaymentHash string
	Amount           uint64
	BlindingKey      *btcec.PrivateKey
	OpeningAddress   string
}

type OpeningTxBroadcastedMessage struct {
	// SwapId is the unique identifier of the swap.
	SwapId *SwapId `json:"swap_id"`
	// Payreq is the invoice as described in BOLT#11 that the responder is
	// requested to pay.
	Payreq string `json:"payreq"`
	// TxId is the transaction id of the opening_transaction broadcasted by the
	// initiator.
	TxId string `json:"tx_id"`
	// ScriptOut is the transaction output that contains the opening_transaction
	// output script for the swap.
	ScriptOut uint32 `json:"script_out"`
	// BlindingKey:
	// Bitcoin: Blank.
	// Liquid BitcoinNetwork: Is the 32 byte blinding key to un-blind the outputs of
	//the opening_transaction.
	BlindingKey string `json:"blinding_key"`
}

type PayFeeInvoiceAction struct{}

type PeerIsSuspiciousError string

type PeerMessage interface {
	MessageType() messages.MessageType
}

type PeerNotAllowedError string

type Policy interface {
	IsPeerAllowed(peer string) bool
	IsPeerSuspicious(peer string) bool
	GetReserveOnchainMsat() uint64
	GetMinSwapAmountMsat() uint64
	NewSwapsAllowed() bool
}

type RequestedSwap struct {
	Asset           string   `json:"asset"`
	AmountSat       uint64   `json:"amount_sat"`
	Type            SwapType `json:"swap_type"`
	RejectionReason string   `json:"rejection_reason"`
}

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

type RequestedSwapsStore interface {
	Add(id string, reqswap RequestedSwap) error
	Get(id string) ([]RequestedSwap, error)
	GetAll() (map[string][]RequestedSwap, error)
}

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

type SendCancelAction struct{}

type SendMessageAction struct{}

type SendMessageWithRetryAction struct{}

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

type SetStartingBlockHeightAction struct{}

type Signer interface {
	Sign(hash []byte) (*btecdsa.Signature, error)
}

type State struct {
	Action        Action
	Events        Events
	FailOnrecover bool
}

type StateType string

type States map[StateType]State

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

type Store interface {
	UpdateData(data *SwapStateMachine) error
	GetData(id string) (*SwapStateMachine, error)
	ListAll() ([]*SwapStateMachine, error)
	ListAllByPeer(peer string) ([]*SwapStateMachine, error)
}

type SwapData struct {
	// Swap In
	SwapInRequest   *SwapInRequestMessage   `json:"swap_in_request"`
	SwapInAgreement *SwapInAgreementMessage `json:"swap_in_agreement"`

	// Swap Out
	SwapOutRequest   *SwapOutRequestMessage   `json:"swap_out_request"`
	SwapOutAgreement *SwapOutAgreementMessage `json:"swap_out_agreement"`

	// TxOpened
	OpeningTxBroadcasted *OpeningTxBroadcastedMessage `json:"opening_tx_broadcasted"`

	// CoopClose
	CoopClose *CoopCloseMessage `json:"coop_close_message"`

	// Cancel
	Cancel *CancelMessage `json:"cancel_message_obj"`

	// cancel message
	CancelMessage string `json:"cancel_message"`

	PeerNodeId          string    `json:"peer_node_id"`
	InitiatorNodeId     string    `json:"initiator_node_id"`
	CreatedAt           int64     `json:"created_at"`
	Role                SwapRole  `json:"role"`
	FSMState            StateType `json:"fsm_state"`
	PrivkeyBytes        []byte    `json:"private_key"`
	FeePreimage         string    `json:"fee_preimage"`
	OpeningTxFee        uint64    `json:"opening_tx_fee"`
	OpeningTxHex        string    `json:"opening_tx_hex"`
	StartingBlockHeight uint32    `json:"opening_block_height"`
	ClaimTxId           string    `json:"claim_tx_id"`
	ClaimPaymentHash    string    `json:"claim_payment_hash"`
	ClaimPreimage       string    `json:"claim_preimage"`

	BlindingKeyHex string `json:"blinding_key"`

	LastMessage EventContext `json:"last_message"`

	NextMessage     []byte `json:"next_message"`
	NextMessageType int    `json:"next_message_type"`

	LastErr       error  `json:"-"`
	LastErrString string `json:"last_err,omitempty"`
	// contains filtered or unexported fields
}

type SwapErrorContext struct {
	Err      error
	SendPeer bool
}

type SwapId [32]byte

type SwapInAgreementMessage struct {
	// ProtocolVersion is the version of the PeerSwap peer protocol the sending
	// node uses.
	ProtocolVersion uint8 `json:"protocol_version"`
	// SwapId is a randomly generated 32 byte string that must be kept the same
	// through the whole process of a swap and serves as an identifier for a
	// specific swap.
	SwapId *SwapId `json:"swap_id"`
	// Pubkey is a 33 byte compressed public key used for the spending paths in
	// the opening_transaction.
	Pubkey string `json:"pubkey"`
	// Premium is a compensation in Sats that the swap partner wants to be payed
	// in order to participate in the swap.
	Premium uint64 `json:"premium"`
}

type SwapInReceiverInitAction struct{}

type SwapInRequestMessage struct {
	// ProtocolVersion is the version of the PeerSwap peer protocol the sending
	// node uses.
	ProtocolVersion uint8 `json:"protocol_version"`
	// SwapId is a randomly generated 32 byte string that must be kept the same
	// through the whole process of a swap and serves as an identifier for a
	// specific swap.
	SwapId *SwapId `json:"swap_id"`
	// Network is the desired on-chain network to use. This can be:
	// Bitcoin: mainnet, testnet, signet, regtest
	// Liquid: The field is left blank as the asset id also defines the bitcoinNetwork.
	Network string `json:"network"`
	// Asset is the desired on-chain asset to use. This can be:
	// Bitcoin: The field is left blank.
	// Liquid: The asset id of the networks Bitcoin asset.
	Asset string `json:"asset"`
	// Scid is the short channel id in human readable format, defined by BOLT#7
	// with x as separator, e.g. 539268x845x1.
	Scid string `json:"scid"`
	// Amount is The amount in Sats that is asked for.
	Amount uint64 `json:"amount"`
	Pubkey string `json:"pubkey"`
}

type SwapOutAgreementMessage struct {
	// ProtocolVersion is the version of the PeerSwap peer protocol the sending
	// node uses.
	ProtocolVersion uint8 `json:"protocol_version"`
	// SwapId is a randomly generated 32 byte string that must be kept the same
	// through the whole process of a swap and serves as an identifier for a
	// specific swap.
	SwapId *SwapId `json:"swap_id"`
	// Pubkey is a 33 byte compressed public key used for the spending paths in
	// the opening_transaction.
	Pubkey string `json:"pubkey"`
	// Payreq is a BOLT#11 invoice with an amount that covers the fee expenses
	// for the on-chain transactions.
	Payreq string
}

type SwapOutRequestMessage struct {
	// ProtocolVersion is the version of the PeerSwap peer protocol the sending
	// node uses.
	ProtocolVersion uint8 `json:"protocol_version"`
	// SwapId is a randomly generated 32 byte string that must be kept the same
	// through the whole process of a swap and serves as an identifier for a
	// specific swap.
	SwapId *SwapId `json:"swap_id"`
	// Asset is the desired on-chain asset to use. This can be:
	// Bitcoin: The field is left blank.
	// Liquid: The asset id of the networks Bitcoin asset.
	Asset string `json:"asset"`
	// Network is the desired on-chain network to use. This can be:
	// Bitcoin: mainnet, testnet, signet, regtest
	// Liquid: The field is left blank as the asset id also defines the bitcoinNetwork.
	Network string `json:"network"`
	// Scid is the short channel id in human readable format, defined by BOLT#7
	// with x as separator, e.g. 539268x845x1.
	Scid string `json:"scid"`
	// Amount is The amount in Sats that is asked for.
	Amount uint64 `json:"amount"`
	// Pubkey is a 33 byte compressed public key used for the spending paths in
	// the opening_transaction.
	Pubkey string `json:"pubkey"`
}

type SwapRole int

type SwapService struct {
	BitcoinEnabled bool
	LiquidEnabled  bool
	sync.RWMutex
	// contains filtered or unexported fields
}

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

type SwapStateMachine struct {
	// Id holds the unique Id for the store
	SwapId *SwapId `json:"swap_id"`

	// Data holds the statemachine metadata
	Data *SwapData `json:"data"`

	// Type holds the SwapType
	Type SwapType `json:"type"`

	// Role holds the local Role
	Role SwapRole `json:"role"`

	// Previous represents the previous state.
	Previous StateType `json:"previous"`

	// Current represents the current state.
	Current StateType `json:"current"`

	// States holds the configuration of states and events handled by the state machine.
	States States `json:"-"`
	// contains filtered or unexported fields
}

type SwapType int

type TakerSendPrivkeyAction struct{}

type TimeOutService interface {
	// contains filtered or unexported methods
}

type TxWatcher interface {
	AddWaitForConfirmationTx(swapId, txId string, vout, startingHeight uint32, scriptpubkey []byte)
	AddWaitForCsvTx(swapId, txId string, vout uint32, startingHeight uint32, scriptpubkey []byte)
	AddConfirmationCallback(func(swapId string, txHex string) error)
	AddCsvCallback(func(swapId string) error)
	GetBlockHeight() (uint32, error)
}

type ValidateTxAndPayClaimInvoiceAction struct{}

type Validator interface {
	TxIdFromHex(txHex string) (string, error)
	ValidateTx(swapParams *OpeningParams, txHex string) (bool, error)
	GetCSVHeight() uint32
}

type Wallet interface {
	CreateOpeningTransaction(swapParams *OpeningParams) (unpreparedTxHex string, fee uint64, vout uint32, err error)
	BroadcastOpeningTx(unpreparedTxHex string) (txId, txHex string, error error)
	CreatePreimageSpendingTransaction(swapParams *OpeningParams, claimParams *ClaimParams) (string, string, error)
	CreateCsvSpendingTransaction(swapParams *OpeningParams, claimParams *ClaimParams) (txId, txHex string, error error)
	CreateCoopSpendingTransaction(swapParams *OpeningParams, claimParams *ClaimParams, takerSigner Signer) (txId, txHex string, error error)
	GetOutputScript(params *OpeningParams) ([]byte, error)
	NewAddress() (string, error)
	GetRefundFee() (uint64, error)
	GetFlatSwapOutFee() (uint64, error)
	GetAsset() string
	GetNetwork() string
	GetOnchainBalance() (uint64, error)
}

type WrongAssetError string