db

type AccountBackup struct {
	KeyParams []byte
	Accounts  []*AccountInfo
}

type AccountInfo struct {
	// Host, Cert, and DEXPubKey identify the DEX server.
	Host      string
	Cert      []byte
	DEXPubKey *secp256k1.PublicKey

	// EncKeyV2 is an encrypted private key generated deterministically from the
	// app seed.
	EncKeyV2 []byte
	// LegacyEncKey is an old-style non-hierarchical key that must be included
	// when exporting the client credentials, since it cannot be regenerated
	// automatically.
	LegacyEncKey []byte

	Bonds        []*Bond
	TargetTier   uint64 // zero means no bond maintenance (allows actual tier to drop negative)
	MaxBondedAmt uint64
	BondAsset    uint32 // the asset to use when auto-posting bonds

	// LegacyFeeCoin is the a legacy registration fee coin ID.
	LegacyFeeCoin    []byte
	LegacyFeeAssetID uint32
	// LegacyFeePaid should be set on retrieval if there is an AccountProof set.
	LegacyFeePaid bool // DEPRECATED
}

type AccountProof struct {
	Host  string
	Stamp uint64
	Sig   []byte
}

type Balance struct {
	asset.Balance
	Stamp time.Time `json:"stamp"`
}

type Bond struct {
	Version    uint16    `json:"ver"`
	AssetID    uint32    `json:"asset"`
	CoinID     dex.Bytes `json:"coinID"`
	UnsignedTx dex.Bytes `json:"utx"`
	SignedTx   dex.Bytes `json:"stx"`  // can be obtained from msgjson.Bond.CoinID
	Data       dex.Bytes `json:"data"` // e.g. redeem script
	Amount     uint64    `json:"amt"`
	LockTime   uint64    `json:"lockTime"`
	KeyIndex   uint32    `json:"keyIndex"` // child key index for HD path: m / hdKeyPurposeBonds / assetID' / bondIndex
	RefundTx   dex.Bytes `json:"refundTx"` // pays to wallet that created it - only a backup for emergency!

	Confirmed bool `json:"confirmed"` // if reached required confs according to server, not in serialization
	Refunded  bool `json:"refunded"`  // not in serialization
}

type BotProgram struct {
	Type    string `json:"type"`
	Program []byte `json:"program"`
}

type DB interface {
	dex.Runner
	// SetPrimaryCredentials sets the initial *PrimaryCredentials.
	SetPrimaryCredentials(creds *PrimaryCredentials) error
	// PrimaryCredentials fetches the *PrimaryCredentials.
	PrimaryCredentials() (*PrimaryCredentials, error)
	// Recrypt re-encrypts the wallet passwords and account private keys, and
	// stores the new *PrimaryCredentials.
	Recrypt(creds *PrimaryCredentials, oldCrypter, newCrypter encrypt.Crypter) (
		walletUpdates map[uint32][]byte, acctUpdates map[string][]byte, err error)
	// ListAccounts returns a list of DEX URLs. The DB is designed to have a
	// single account per DEX, so the account is uniquely identified by the DEX
	// host.
	ListAccounts() ([]string, error)
	// Accounts retrieves all accounts.
	Accounts() ([]*AccountInfo, error)
	// Account gets the AccountInfo associated with the specified DEX node.
	Account(host string) (*AccountInfo, error)
	// CreateAccount saves the AccountInfo.
	CreateAccount(ai *AccountInfo) error
	// UpdateAccountInfo updates the account info for an existing account with
	// the same Host as the parameter. If no account exists with this host,
	// an error is returned.
	UpdateAccountInfo(ai *AccountInfo) error
	// AddBond saves a new Bond or updates an existing bond for a DEX.
	AddBond(host string, bond *Bond) error
	// NextBondKeyIndex returns the next bond key index and increments the
	// stored value so that subsequent calls will always return a higher index.
	NextBondKeyIndex(assetID uint32) (uint32, error)
	// ConfirmBond records that a bond has been accepted by a DEX.
	ConfirmBond(host string, assetID uint32, bondCoinID []byte) error
	// BondRefunded records that a bond has been refunded.
	BondRefunded(host string, assetID uint32, bondCoinID []byte) error
	// DisableAccount sets the AccountInfo disabled status to true.
	DisableAccount(host string) error
	// AccountProof retrieves the AccountPoof value specified by url. DEPRECATED
	AccountProof(host string) (*AccountProof, error)
	// StoreAccountProof stores an AccountProof, marking the account as paid
	// with the legacy registration fee. DEPRECATED
	StoreAccountProof(proof *AccountProof) error
	// UpdateOrder saves the order information in the database. Any existing
	// order info will be overwritten without indication.
	UpdateOrder(m *MetaOrder) error
	// ActiveOrders retrieves all orders which appear to be in an active state,
	// which is either in the epoch queue or in the order book.
	ActiveOrders() ([]*MetaOrder, error)
	// AccountOrders retrieves all orders associated with the specified DEX. The
	// order count can be limited by supplying a non-zero n value. In that case
	// the newest n orders will be returned. The orders can be additionally
	// filtered by supplying a non-zero since value, corresponding to a UNIX
	// timestamp, in milliseconds. n = 0 applies no limit on number of orders
	// returned. since = 0 is equivalent to disabling the time filter, since
	// no orders were created before 1970.
	AccountOrders(dex string, n int, since uint64) ([]*MetaOrder, error)
	// Order fetches a MetaOrder by order ID.
	Order(order.OrderID) (*MetaOrder, error)
	// Orders fetches a slice of orders, sorted by descending time, and filtered
	// with the provided OrderFilter.
	Orders(*OrderFilter) ([]*MetaOrder, error)
	// ActiveDEXOrders retrieves orders for a particular dex, specified by its
	// URL.
	ActiveDEXOrders(dex string) ([]*MetaOrder, error)
	// MarketOrders retrieves all orders for the specified DEX and market. The
	// order count can be limited by supplying a non-zero n value. In that case
	// the newest n orders will be returned. The orders can be additionally
	// filtered by supplying a non-zero since value, corresponding to a UNIX
	// timestamp, in milliseconds. n = 0 applies no limit on number of orders
	// returned. since = 0 is equivalent to disabling the time filter, since
	// no orders were created before 1970.
	MarketOrders(dex string, base, quote uint32, n int, since uint64) ([]*MetaOrder, error)
	// UpdateOrderMetaData updates the order metadata, not including the Host.
	UpdateOrderMetaData(order.OrderID, *OrderMetaData) error
	// UpdateOrderStatus sets the order status for an order.
	UpdateOrderStatus(oid order.OrderID, status order.OrderStatus) error
	// LinkOrder sets the LinkedOrder field of the specified order's
	// OrderMetaData.
	LinkOrder(oid, linkedID order.OrderID) error
	// UpdateMatch updates the match information in the database. Any existing
	// entry for the match will be overwritten without indication.
	UpdateMatch(m *MetaMatch) error
	// ActiveMatches retrieves the matches that are in an active state, which is
	// any state except order.MatchComplete.
	ActiveMatches() ([]*MetaMatch, error)
	// DEXOrdersWithActiveMatches retrieves order IDs for any order that has
	// active matches, regardless of whether the order itself is in an active
	// state.
	DEXOrdersWithActiveMatches(dex string) ([]order.OrderID, error)
	// MatchesForOrder gets the matches for the order ID.
	MatchesForOrder(oid order.OrderID, excludeCancels bool) ([]*MetaMatch, error)
	// Update wallets adds a wallet to the database, or updates the wallet
	// credentials if the wallet already exists. A wallet is specified by the
	// pair (asset ID, account name).
	UpdateWallet(wallet *Wallet) error
	// SetWalletPassword sets the encrypted password for the wallet.
	SetWalletPassword(wid []byte, newPW []byte) error
	// UpdateBalance updates a wallet's balance.
	UpdateBalance(wid []byte, balance *Balance) error
	// Wallets lists all saved wallets.
	Wallets() ([]*Wallet, error)
	// Wallet fetches the wallet for the specified asset by wallet ID.
	Wallet(wid []byte) (*Wallet, error)
	// UpdateWalletStatus updates a wallet's status.
	UpdateWalletStatus(wid []byte, disable bool) error
	// Backup makes a copy of the database to the default "backups" folder.
	Backup() error
	// BackupTo makes a backup of the database at the specified location,
	// optionally overwriting any existing file and compacting the database.
	BackupTo(dst string, overwrite, compact bool) error
	// SaveNotification saves the notification.
	SaveNotification(*Notification) error
	// NotificationsN reads out the N most recent notifications.
	NotificationsN(int) ([]*Notification, error)
	// AckNotification sets the acknowledgement for a notification.
	AckNotification(id []byte) error
	// DeleteInactiveOrders deletes inactive orders from the database that are
	// older than the supplied time and returns the total number of orders
	// deleted. If no time is supplied, the current time is used. Accepts an
	// optional function to perform on deleted orders.
	DeleteInactiveOrders(ctx context.Context, olderThan *time.Time, perOrderFn func(ord *MetaOrder) error) (int, error)
	// DeleteInactiveMatches deletes inactive matches from the database that are
	// older than the supplied time and return total number of matches deleted.
	// If no time is supplied, the current time is used. Accepts an optional
	// function to perform on deleted matches that includes if it was a sell
	// order.
	DeleteInactiveMatches(ctx context.Context, olderThan *time.Time, perMatchFn func(mtch *MetaMatch, isSell bool) error) (int, error)
	// SetSeedGenerationTime stores the time when the app seed was generated.
	SetSeedGenerationTime(time uint64) error
	// SeedGenerationTime fetches the time when the app seed was generated.
	SeedGenerationTime() (uint64, error)
	// DisabledRateSources retrieves disabled fiat rate sources from the
	// database.
	DisabledRateSources() ([]string, error)
	// SaveDisabledRateSources saves disabled fiat rate sources in the database.
	// A source name must not contain a comma.
	SaveDisabledRateSources(disabledSources []string) error
	// SaveBotProgram saves data associated with a bot program. A unique ID
	// is returned that can be used to address this program in future queries.
	SaveBotProgram(*BotProgram) (pgmID uint64, err error)
	// UpdateBotProgram updates the data associated with a running bot program.
	UpdateBotProgram(pgmID uint64, pgm *BotProgram) error
	// RetireBotProgram deletes the bot program from the database.
	RetireBotProgram(pgmID uint64) error
	// ActiveBotPrograms loads a list of active bot program IDs.
	ActiveBotPrograms() (map[uint64]*BotProgram, error)
}

type MatchAuth struct {
	MatchSig        []byte
	MatchStamp      uint64
	InitSig         []byte
	InitStamp       uint64
	AuditSig        []byte
	AuditStamp      uint64
	RedeemSig       []byte
	RedeemStamp     uint64
	RedemptionSig   []byte
	RedemptionStamp uint64
}

type MatchMetaData struct {
	// Proof is the signatures and other verification-related data for the match.
	Proof MatchProof
	// DEX is the URL of the server that this match is associated with.
	DEX string
	// Base is the base asset of the exchange market.
	Base uint32
	// Quote is the quote asset of the exchange market.
	Quote uint32
	// Stamp is the match time (ms UNIX), according to the server's 'match'
	// request timestamp.
	Stamp uint64
}

type MatchProof struct {
	ContractData    []byte
	CounterContract []byte
	CounterTxData   []byte
	SecretHash      []byte
	Secret          []byte
	MakerSwap       order.CoinID
	MakerRedeem     order.CoinID
	TakerSwap       order.CoinID
	TakerRedeem     order.CoinID
	RefundCoin      order.CoinID
	Auth            MatchAuth
	ServerRevoked   bool
	SelfRevoked     bool
	// SwapFeeConfirmed indicate the fees for this match have been
	// confirmed and the value added to the trade.
	SwapFeeConfirmed bool
	// RedemptionFeeConfirmed indicate the fees for this match have been
	// confirmed and the value added to the trade.
	RedemptionFeeConfirmed bool
}

type MetaMatch struct {
	// UserMatch is the match info.
	*order.UserMatch
	// MetaData is important auxiliary information about the match.
	MetaData *MatchMetaData
}

type MetaOrder struct {
	// MetaData is important auxiliary information about the order.
	MetaData *OrderMetaData
	// Order is the order.
	Order order.Order
}

type Notification struct {
	NoteType    string    `json:"type"`
	TopicID     Topic     `json:"topic"`
	SubjectText string    `json:"subject"`
	DetailText  string    `json:"details"`
	Severeness  Severity  `json:"severity"`
	TimeStamp   uint64    `json:"stamp"`
	Ack         bool      `json:"acked"`
	Id          dex.Bytes `json:"id"`
}

type OrderFilter struct {
	// N is the number of orders to return in the set.
	N int
	// Offset can be used to shift the window of the time-sorted orders such
	// that any orders that would sort to index <= the order specified by Offset
	// will be rejected.
	Offset order.OrderID
	// Hosts is a list of acceptable hosts. A zero-length Hosts means all
	// hosts are accepted.
	Hosts []string
	// Assets is a list of BIP IDs for acceptable assets. A zero-length Assets
	// means all assets are accepted.
	Assets []uint32
	// Statuses is a list of acceptable statuses. A zero-length Statuses means
	// all statuses are accepted.
	Statuses []order.OrderStatus
}

type OrderMetaData struct {
	// Status is the last known order status.
	Status order.OrderStatus
	// Host is the hostname of the server that this order is associated with.
	Host string
	// Proof is the signatures and other verification-related data for the order.
	Proof OrderProof
	// ChangeCoin is a change coin from a match. Change coins are "daisy-chained"
	// for matches. All funding coins go into the first match, and the change coin
	// from the initiation transaction is used to fund the next match. The
	// change from that matches ini tx funds the next match, etc.
	ChangeCoin order.CoinID
	// LinkedOrder is used to specify the cancellation order for a trade, or
	// vice-versa.
	LinkedOrder order.OrderID
	// SwapFeesPaid is the sum of the actual fees paid for all swaps.
	SwapFeesPaid uint64
	// RedemptionFeesPaid is the sum of the actual fees paid for all
	// redemptions.
	RedemptionFeesPaid uint64

	// EpochDur is the epoch duration for the market at the time the order was
	// submitted. When considered with the order's ServerTime, we also know the
	// epoch index, which is helpful for determining if an epoch order should
	// have been matched. WARNING: may load from DB as zero for older orders, in
	// which case the current asset config should be used.
	EpochDur uint64

	// FromSwapConf and ToSwapConf are the dex.Asset.SwapConf values at the time
	// the order is submitted. WARNING: may load from DB as zero for older
	// orders, in which case the current asset config should be used.
	FromSwapConf uint32
	ToSwapConf   uint32
	// MaxFeeRate is the dex.Asset.MaxFeeRate at the time of ordering. The rates
	// assigned to matches will be validated against this value.
	MaxFeeRate uint64
	// RedeemMaxFeeRate is the dex.Asset.MaxFeeRate for the redemption asset at
	// the time of ordering. This rate is used to reserve funds for redemption,
	// and therefore this rate can be used when actually submitting a redemption
	// transaction.
	RedeemMaxFeeRate uint64
	// FromVersion is the version of the from asset.
	FromVersion uint32
	// ToVersion is the version of the to asset.
	ToVersion uint32

	// Options are the options offered by the wallet and selected by the user.
	Options map[string]string
	// RedemptionReserves is the amount of funds reserved by the wallet to pay
	// the transaction fees for all the possible redemptions in this order.
	// The amount that should be locked at any point can be determined by
	// checking the status of the order and the status of all matches related
	// to this order, and determining how many more possible redemptions there
	// could be.
	RedemptionReserves uint64
	// RedemptionRefunds is the amount of funds reserved by the wallet to pay
	// the transaction fees for all the possible refunds in this order.
	// The amount that should be locked at any point can be determined by
	// checking the status of the order and the status of all matches related
	// to this order, and determining how many more possible refunds there
	// could be.
	RefundReserves uint64
	// AccelerationCoins keeps track of all the change coins generated from doing
	// accelerations on this order.
	AccelerationCoins []order.CoinID
	// ProgramID is a program ID used to identify the bot program that owns
	// this order.
	ProgramID uint64
}

type OrderProof struct {
	DEXSig   []byte
	Preimage []byte
}

type PrimaryCredentials struct {
	// EncSeed is the root seed used to create a hierarchical deterministic
	// key chain (see also dcrd/hdkeychain.NewMaster/ExtendedKey).
	EncSeed []byte
	// EncInnerKey is an encrypted encryption key. The inner key will never
	// change. The inner key is encrypted with the outer key, which itself is
	// based on the user's password.
	EncInnerKey []byte
	// InnerKeyParams are the key parameters for the inner key.
	InnerKeyParams []byte
	// OuterKeyParams are the key parameters for the outer key.
	OuterKeyParams []byte
}

type Severity uint8

type Topic string

type Wallet struct {
	AssetID     uint32
	Type        string
	Settings    map[string]string
	Balance     *Balance
	EncryptedPW []byte
	Address     string
	Disabled    bool
}