Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func DisableLog

func DisableLog()

    DisableLog disables all library log output. Logging output is disabled by default until UseLogger is called.

    func UseLogger

    func UseLogger(logger slog.Logger)

      UseLogger uses a specified Logger to output package logging info.

      Types

      type AssetConf

      type AssetConf struct {
      	Symbol     string `json:"bip44symbol"`
      	Network    string `json:"network"`
      	LotSize    uint64 `json:"lotSize"`
      	RateStep   uint64 `json:"rateStep"`
      	MaxFeeRate uint64 `json:"maxFeeRate"`
      	SwapConf   uint32 `json:"swapConf"`
      	ConfigPath string `json:"configPath"`
      }

        AssetConf is like dex.Asset except it lacks the BIP44 integer ID, has Network and ConfigPath strings, and has JSON tags.

        type DBConf

        type DBConf struct {
        	DBName       string
        	User         string
        	Pass         string
        	Host         string
        	Port         uint16
        	ShowPGConfig bool
        }

          DBConf groups the database configuration parameters.

          type DEX

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

            DEX is the DEX manager, which creates and controls the lifetime of all components of the DEX.

            func NewDEX

            func NewDEX(cfg *DexConf) (*DEX, error)

              NewDEX creates the dex manager and starts all subsystems. Use Stop to shutdown cleanly.

              1. Validate each specified asset.
              2. Create CoinLockers for each asset.
              3. Create and start asset backends.
              4. Create the archivist and connect to the storage backend.
              5. Create the authentication manager.
              6. Create and start the Swapper.
              7. Create and start the markets.
              8. Create and start the book router, and create the order router.
              9. Create and start the comms server.
              

              func (*DEX) AccountInfo

              func (dm *DEX) AccountInfo(aid account.AccountID) (*db.Account, error)

                AccountInfo returns data for an account.

                func (*DEX) Accounts

                func (dm *DEX) Accounts() ([]*db.Account, error)

                  Accounts returns data for all accounts.

                  func (*DEX) Asset

                  func (dm *DEX) Asset(id uint32) (*asset.BackedAsset, error)

                    Asset retrieves an asset backend by its ID.

                    func (*DEX) ConfigMsg

                    func (dm *DEX) ConfigMsg() json.RawMessage

                      Config returns the current dex configuration.

                      func (*DEX) ForgiveMatchFail

                      func (dm *DEX) ForgiveMatchFail(aid account.AccountID, mid order.MatchID) (forgiven, unbanned bool, err error)

                        ForgiveMatchFail forgives a user for a specific match failure, potentially allowing them to resume trading if their score becomes passing.

                        func (*DEX) MarketRunning

                        func (dm *DEX) MarketRunning(mktName string) (found, running bool)

                          TODO: for just market running status, the DEX manager should use its knowledge of Market subsystem state.

                          func (*DEX) MarketStatus

                          func (dm *DEX) MarketStatus(mktName string) *market.Status

                            MarketStatus returns the market.Status for the named market. If the market is unknown to the DEX, nil is returned.

                            func (*DEX) MarketStatuses

                            func (dm *DEX) MarketStatuses() map[string]*market.Status

                              MarketStatuses returns a map of market names to market.Status for all known markets.

                              func (*DEX) Notify

                              func (dm *DEX) Notify(acctID account.AccountID, msg *msgjson.Message)

                                Notify sends a text notification to a connected client.

                                func (*DEX) NotifyAll

                                func (dm *DEX) NotifyAll(msg *msgjson.Message)

                                  NotifyAll sends a text notification to all connected clients.

                                  func (*DEX) Penalize

                                  func (dm *DEX) Penalize(aid account.AccountID, rule account.Rule, details string) error

                                    Penalize bans an account by canceling the client's orders and setting their rule status to rule.

                                    func (*DEX) ResumeMarket

                                    func (dm *DEX) ResumeMarket(name string, asSoonAs time.Time) (startEpoch int64, startTime time.Time, err error)

                                      ResumeMarket launches a stopped market subsystem as early as the given time. The actual time the market will resume depends on the configure epoch duration, as the market only starts at the beginning of an epoch.

                                      func (*DEX) ScaleFeeRate

                                      func (dm *DEX) ScaleFeeRate(assetID uint32, rate uint64) uint64

                                        ScaleFeeRate scales the provided fee rate with the given asset's swap fee rate scale factor, which is 1.0 by default.

                                        func (*DEX) SetFeeRateScale

                                        func (dm *DEX) SetFeeRateScale(assetID uint32, scale float64)

                                          SetFeeRateScale specifies a scale factor that the Swapper should use to scale the optimal fee rates for new swaps for for the specified asset. That is, values above 1 increase the fee rate, while values below 1 decrease it.

                                          func (*DEX) Stop

                                          func (dm *DEX) Stop()

                                            Stop shuts down the DEX. Stop returns only after all components have completed their shutdown.

                                            func (*DEX) SuspendMarket

                                            func (dm *DEX) SuspendMarket(name string, tSusp time.Time, persistBooks bool) (suspEpoch *market.SuspendEpoch, err error)

                                              SuspendMarket schedules a suspension of a given market, with the option to persist the orders on the book (or purge the book automatically on market shutdown). The scheduled final epoch and suspend time are returned. This is a passthrough to the OrderRouter. A TradeSuspension notification is broadcasted to all connected clients.

                                              func (*DEX) Unban

                                              func (dm *DEX) Unban(aid account.AccountID) error

                                                Unban reverses a ban and allows a client to resume trading.

                                                type DexConf

                                                type DexConf struct {
                                                	DataDir          string
                                                	LogBackend       *dex.LoggerMaker
                                                	Markets          []*dex.MarketInfo
                                                	Assets           []*AssetConf
                                                	Network          dex.Network
                                                	DBConf           *DBConf
                                                	RegFeeXPub       string
                                                	RegFeeConfirms   int64
                                                	RegFeeAmount     uint64
                                                	BroadcastTimeout time.Duration
                                                	CancelThreshold  float64
                                                	Anarchy          bool
                                                	FreeCancels      bool
                                                	BanScore         uint32
                                                	DEXPrivKey       *secp256k1.PrivateKey
                                                	CommsCfg         *RPCConfig
                                                	IgnoreState      bool
                                                	StatePath        string
                                                }

                                                  DexConf is the configuration data required to create a new DEX.

                                                  type RPCConfig

                                                  type RPCConfig = comms.RPCConfig

                                                    RPCConfig is an alias for the comms Server's RPC config struct.

                                                    Source Files