application

Documentation

Index

• Constants
• Variables
• type AddressAndBlindingKey
• type Balance
• type BalanceInfo
• type BalanceWithFee
• type Blinder
• type BlindingData
• type BlockchainListener
  • func NewBlockchainListener(crawlerSvc crawler.Service, repoManager ports.RepoManager, ...) BlockchainListener
• type Fee
• type FeeInfo
• type FillProposalOpts
• type FillProposalResult
• type InitWalletReply
• type Market
• type MarketInfo
• type MarketStrategy
• type MarketWithFee
• type MarketWithPrice
• type OperatorService
  • func NewOperatorService(repoManager ports.RepoManager, explorerSvc explorer.Service, ...) OperatorService
• type PassphraseMsg
• type Price
• type PriceWithFee
• type ReportMarketFee
• type SendToManyRequest
• type SwapFailInfo
• type SwapInfo
• type TradeHandler
• type TradeInfo
• type TradeService
  • func NewTradeService(repoManager ports.RepoManager, explorerSvc explorer.Service, ...) TradeService
• type TransactionHandler
• type TxOut
• type TxOutpoint
• type UnblindedResult
• type Unspents
  • func (u Unspents) ToUtxos() []explorer.Utxo
• type UtxoInfo
• type UtxoInfoList
• type WalletService
  • func NewWalletService(repoManager ports.RepoManager, explorerService explorer.Service, ...) (WalletService, error)
• type Webhook
• type WebhookInfo
• type WithdrawMarketReq

Constants

const (
	InitWallet = iota
	UnlockWallet
	ChangePassphrase
)

Passphrase msg type

const (
	TradeBuy = iota
	TradeSell
)

trade type

const (
	Processing = iota
	Done
)

restore status

const (
	TradeSettled = iota
	AccountLowBalance
	AccountWithdraw
)

Topics to be published

Variables

var (
	// ErrFeeAccountNotFunded ...
	ErrFeeAccountNotFunded = errors.New("fee account not funded")
	// ErrUnknownStrategy ...
	ErrUnknownStrategy = errors.New("strategy not supported")
	// ErrTxNotConfirmed ...
	ErrTxNotConfirmed = errors.New("transaction not confirmed")
	// ErrMarketNotExist ...
	ErrMarketNotExist = errors.New("market does not exists")
	// ErrMarketNotFunded ...
	ErrMarketNotFunded = errors.New("market account not funded")
	// ErrMissingNonFundedMarkets ...
	ErrMissingNonFundedMarkets = errors.New("no non-funded markets found")
	// ErrInvalidOutpoint ...
	ErrInvalidOutpoint = errors.New("outpoint refers to inexistent tx output")
	// ErrInvalidOutpoints ...
	ErrInvalidOutpoints = errors.New("all outpoints must be funded for the same account")
	// ErrServiceUnavailable is the error returned by the trade service in case of
	// internal errors
	ErrServiceUnavailable = errors.New("service is unavailable, try again later")
	// ErrPubSubServiceNotInitialized is returned when attempting to use
	// AddWebhook or RemoveWebhook RPCs without having initialized the pubsub
	// service at the start up.
	ErrPubSubServiceNotInitialized = errors.New("pubsub service is not initialized")
	// ErrInvalidActionType is returned if the attempting to register a webhook
	// for an invalid action type.
	ErrInvalidActionType = errors.New("action type is unknown")
	// ErrMarketBaseBalanceTooLow is returned when the balance of the base asset
	// of a market is below 0.
	ErrMarketBaseBalanceTooLow = errors.New("market base balance is too low")
	// ErrMarketQuoteBalanceTooLow is returned when the balance of the quote asset
	// of a market is below 0.
	ErrMarketQuoteBalanceTooLow = errors.New("market quote balance is too low")
	// ErrWithdrawBaseAmountTooBig is returned when attempting to withdraw more
	// than the total amount of base asset of a market.
	ErrWithdrawBaseAmountTooBig = errors.New(
		"base amount to withdraw exceeds the market base balance",
	)
	// ErrWithdrawQuoteAmountTooBig is returned when attempting to withdraw more
	// than the total amount of quote asset of a market.
	ErrWithdrawQuoteAmountTooBig = errors.New(
		"quote amount to withdraw is too big",
	)
)

var (
	BlinderManager     Blinder
	TradeManager       TradeHandler
	TransactionManager TransactionHandler
)

var (
	// ErrWalletNotFunded ...
	ErrWalletNotFunded = fmt.Errorf("wallet not funded")
	// ErrWalletIsSyncing ...
	ErrWalletIsSyncing = fmt.Errorf(
		"wallet is syncing data from blockchain. All functionalities are " +
			"disabled until this operation is completed",
	)
	// ErrWalletNotInitialized ...
	ErrWalletNotInitialized = fmt.Errorf("wallet not initialized")
)

Types

type AddressAndBlindingKey

type AddressAndBlindingKey struct {
	Address     string
	BlindingKey string
}

type Balance

type Balance struct {
	BaseAmount  uint64
	QuoteAmount uint64
}

type BalanceInfo

type BalanceInfo struct {
	TotalBalance       uint64
	ConfirmedBalance   uint64
	UnconfirmedBalance uint64
}

type BalanceWithFee

type BalanceWithFee struct {
	Balance Balance
	Fee     Fee
}

type Blinder

type Blinder interface {
	UnblindOutput(txout *transaction.TxOutput, key []byte) (UnblindedResult, bool)
}

type BlindingData

type BlindingData wallet.BlindingData

type BlockchainListener

type BlockchainListener interface {
	StartObservation()
	StopObservation()

	StartObserveAddress(accountIndex int, addr string, blindKey []byte)
	StopObserveAddress(addr string)

	StartObserveTx(txid string)
	StopObserveTx(txid string)

	PubSubService() ports.SecurePubSub
}

BlockchainListener defines the needed method sto start and stop a blockchain listener

func NewBlockchainListener

func NewBlockchainListener(
	crawlerSvc crawler.Service,
	repoManager ports.RepoManager,
	pubsubSvc ports.SecurePubSub,
	marketBaseAsset string,
	net *network.Network,
) BlockchainListener

NewBlockchainListener returns a BlockchainListener with all the needed services

type Fee

type Fee struct {
	BasisPoint    int64
	FixedBaseFee  int64
	FixedQuoteFee int64
}

type FeeInfo

type FeeInfo struct {
	TradeID     string
	BasisPoint  int64
	Asset       string
	Amount      uint64
	MarketPrice decimal.Decimal
}

type FillProposalOpts

type FillProposalOpts struct {
	Mnemonic      []string
	SwapRequest   domain.SwapRequest
	MarketUtxos   []explorer.Utxo
	FeeUtxos      []explorer.Utxo
	MarketInfo    domain.AddressesInfo
	FeeInfo       domain.AddressesInfo
	OutputInfo    domain.AddressInfo
	ChangeInfo    domain.AddressInfo
	FeeChangeInfo domain.AddressInfo
	Network       *network.Network
}

type FillProposalResult

type FillProposalResult struct {
	PsetBase64         string
	SelectedUnspents   []explorer.Utxo
	InputBlindingKeys  map[string][]byte
	OutputBlindingKeys map[string][]byte
}

type InitWalletReply

type InitWalletReply struct {
	AccountIndex int
	AddressIndex int
	Status       int
	Data         string
}

type Market

type Market struct {
	BaseAsset  string
	QuoteAsset string
}

type MarketInfo

type MarketInfo struct {
	AccountIndex uint64
	Market       Market
	Fee          Fee
	Tradable     bool
	StrategyType int
	Price        domain.Prices
}

MarketInfo is the data struct returned by ListMarket RPC.

type MarketStrategy

type MarketStrategy struct {
	Market
	Strategy domain.StrategyType
}

type MarketWithFee

type MarketWithFee struct {
	Market
	Fee
}

type MarketWithPrice

type MarketWithPrice struct {
	Market
	Price
}

type OperatorService

type OperatorService interface {
	DepositMarket(
		ctx context.Context,
		baseAsset string,
		quoteAsset string,
		numOfAddresses int,
	) ([]AddressAndBlindingKey, error)
	DepositFeeAccount(
		ctx context.Context,
		numOfAddresses int,
	) ([]AddressAndBlindingKey, error)
	OpenMarket(
		ctx context.Context,
		baseAsset string,
		quoteAsset string,
	) error
	CloseMarket(
		ctx context.Context,
		baseAsset string,
		quoteAsset string,
	) error
	UpdateMarketPercentageFee(
		ctx context.Context,
		req MarketWithFee,
	) (*MarketWithFee, error)
	UpdateMarketFixedFee(
		ctx context.Context,
		req MarketWithFee,
	) (*MarketWithFee, error)
	UpdateMarketPrice(
		ctx context.Context,
		req MarketWithPrice,
	) error
	UpdateMarketStrategy(
		ctx context.Context,
		req MarketStrategy,
	) error
	ListTrades(
		ctx context.Context,
	) ([]TradeInfo, error)
	ListMarketExternalAddresses(
		ctx context.Context,
		req Market,
	) ([]string, error)
	WithdrawMarketFunds(
		ctx context.Context,
		req WithdrawMarketReq,
	) ([]byte, error)
	FeeAccountBalance(ctx context.Context) (int64, error)
	ClaimMarketDeposit(
		ctx context.Context,
		market Market,
		outpoints []TxOutpoint,
	) error
	ClaimFeeDeposit(
		ctx context.Context,
		outpoints []TxOutpoint,
	) error
	ListMarket(
		ctx context.Context,
	) ([]MarketInfo, error)
	GetCollectedMarketFee(
		ctx context.Context,
		market Market,
	) (*ReportMarketFee, error)
	ListUtxos(ctx context.Context) (map[uint64]UtxoInfoList, error)
	ReloadUtxos(ctx context.Context) error
	DropMarket(ctx context.Context, accountIndex int) error
	AddWebhook(ctx context.Context, hook Webhook) (string, error)
	RemoveWebhook(ctx context.Context, id string) error
	ListWebhooks(ctx context.Context, actionType int) ([]WebhookInfo, error)
}

OperatorService defines the methods of the application layer for the operator service.

func NewOperatorService

func NewOperatorService(
	repoManager ports.RepoManager,
	explorerSvc explorer.Service,
	bcListener BlockchainListener,
	marketBaseAsset string,
	marketFee int64,
	net *network.Network,
	feeAccountBalanceThreshold uint64,
) OperatorService

NewOperatorService is a constructor function for OperatorService.

type PassphraseMsg

type PassphraseMsg struct {
	Method     int
	CurrentPwd string
	NewPwd     string
}

type Price

type Price struct {
	BasePrice  decimal.Decimal
	QuotePrice decimal.Decimal
}

type PriceWithFee

type PriceWithFee struct {
	Price   Price
	Fee     Fee
	Amount  uint64
	Asset   string
	Balance Balance
}

type ReportMarketFee

type ReportMarketFee struct {
	CollectedFees              []FeeInfo
	TotalCollectedFeesPerAsset map[string]int64
}

type SendToManyRequest

type SendToManyRequest struct {
	Outputs         []TxOut
	MillisatPerByte int64
	Push            bool
}

type SwapFailInfo

type SwapFailInfo struct {
	Code    int
	Message string
}

type SwapInfo

type SwapInfo struct {
	AmountP uint64
	AssetP  string
	AmountR uint64
	AssetR  string
}

SwapInfo contains info about a swap

type TradeHandler

type TradeHandler interface {
	FillProposal(FillProposalOpts) (*FillProposalResult, error)
}

type TradeInfo

type TradeInfo struct {
	ID               string
	Status           domain.Status
	SwapInfo         SwapInfo
	SwapFailInfo     SwapFailInfo
	MarketWithFee    MarketWithFee
	Price            Price
	TxURL            string
	RequestTimeUnix  uint64
	AcceptTimeUnix   uint64
	CompleteTimeUnix uint64
	SettleTimeUnix   uint64
	ExpiryTimeUnix   uint64
}

TradeInfo contains info about a trade.

type TradeService

type TradeService interface {
	GetTradableMarkets(ctx context.Context) ([]MarketWithFee, error)
	GetMarketPrice(
		ctx context.Context,
		market Market,
		tradeType int,
		amount uint64,
		asset string,
	) (*PriceWithFee, error)
	TradePropose(
		ctx context.Context,
		market Market,
		tradeType int,
		swapRequest domain.SwapRequest,
	) (domain.SwapAccept, domain.SwapFail, uint64, error)
	TradeComplete(
		ctx context.Context,
		swapComplete *domain.SwapComplete,
		swapFail *domain.SwapFail,
	) (string, domain.SwapFail, error)
	GetMarketBalance(
		ctx context.Context,
		market Market,
	) (*BalanceWithFee, error)
}

func NewTradeService

func NewTradeService(
	repoManager ports.RepoManager,
	explorerSvc explorer.Service,
	bcListener BlockchainListener,
	marketBaseAsset string,
	expiryDuration time.Duration,
	priceSlippage decimal.Decimal,
	net *network.Network,
) TradeService

type TransactionHandler

type TransactionHandler interface {
	ExtractUnspents(
		txhex string,
		infoByScript map[string]domain.AddressInfo,
		network *network.Network,
	) ([]domain.Unspent, []domain.UnspentKey, error)
	ExtractBlindingData(
		psetBase64 string,
		inBlindingKeys, outBlidningKeys map[string][]byte,
	) (map[int]BlindingData, map[int]BlindingData, error)
}

type TxOut

type TxOut struct {
	Asset   string
	Value   int64
	Address string
}

type TxOutpoint

type TxOutpoint struct {
	Hash  string
	Index int
}

type UnblindedResult

type UnblindedResult *transactionutil.UnblindedResult

type Unspents

type Unspents []domain.Unspent

func (Unspents) ToUtxos

func (u Unspents) ToUtxos() []explorer.Utxo

type UtxoInfo

type UtxoInfo struct {
	Outpoint *TxOutpoint
	Value    uint64
	Asset    string
}

type UtxoInfoList

type UtxoInfoList struct {
	Unspents []UtxoInfo
	Spents   []UtxoInfo
	Locks    []UtxoInfo
}

type WalletService

type WalletService interface {
	GenSeed(ctx context.Context) ([]string, error)
	InitWallet(
		ctx context.Context,
		mnemonic []string,
		passphrase string,
		restore bool,
		chRes chan *InitWalletReply,
		chErr chan error,
	)
	UnlockWallet(
		ctx context.Context,
		passphrase string,
	) error
	ChangePassword(
		ctx context.Context,
		currentPassphrase string,
		newPassphrase string) error
	GenerateAddressAndBlindingKey(
		ctx context.Context,
	) (address string, blindingKey string, err error)
	GetWalletBalance(
		ctx context.Context,
	) (map[string]BalanceInfo, error)
	SendToMany(
		ctx context.Context,
		req SendToManyRequest,
	) ([]byte, error)
	PassphraseChan() chan PassphraseMsg
}

func NewWalletService

func NewWalletService(
	repoManager ports.RepoManager,
	explorerService explorer.Service,
	blockchainListener BlockchainListener,
	net *network.Network,
	marketFee int64,
	marketBaseAsset string,
) (WalletService, error)

type Webhook

type Webhook struct {
	ActionType int
	Endpoint   string
	Secret     string
}

type WebhookInfo

type WebhookInfo struct {
	Id         string
	ActionType int
	Endpoint   string
	IsSecured  bool
}

type WithdrawMarketReq

type WithdrawMarketReq struct {
	Market
	BalanceToWithdraw Balance
	MillisatPerByte   int64
	Address           string
	Push              bool
}