payd

type Balance struct {
	Satoshis uint64 `json:"satoshis" db:"satoshis"`
}

type BalanceReader interface {
	Balance(ctx context.Context) (*Balance, error)
}

type BalanceService interface {
	Balance(ctx context.Context) (*Balance, error)
}

type BroadcastWriter interface {
	// Broadcast will submit a tx to a blockchain network.
	Broadcast(ctx context.Context, tx *bt.Tx) error
}

type ClientError struct {
	ID      string `json:"id" example:"e97970bf-2a88-4bc8-90e6-2f597a80b93d"`
	Code    string `json:"code" example:"N01"`
	Title   string `json:"title" example:"not found"`
	Message string `json:"message" example:"unable to find foo when loading bar"`
}

type DerivationExistsArgs struct {
	KeyName string `db:"key_name"`
	Path    string `db:"derivation_path"`
}

type DerivationReader interface {
	DerivationPathExists(ctx context.Context, args DerivationExistsArgs) (bool, error)
}

type Destination struct {
	SPVRequired bool         `json:"spvRequired"`
	Outputs     []Output     `json:"outputs"`
	Fees        *bt.FeeQuote `json:"fees"`
}

type DestinationCreate struct {
	Script         string `db:"locking_script"`
	DerivationPath string `db:"derivation_path"`
	Satoshis       uint64 `db:"satoshis"`
	Keyname        string `db:"key_name"`
}

type DestinationsArgs struct {
	InvoiceID string `param:"invoiceID"`
}

type DestinationsCreate struct {
	InvoiceID     null.String
	Satoshis      uint64
	Denominations uint64
}

type DestinationsCreateArgs struct {
	// InvoiceID, this is optional, if not supplied destinations
	// will not be associated with an invoice.
	InvoiceID null.String `db:"invoice_id"`
}

type DestinationsReader interface {
	// Destinations will return destination outputs.
	Destinations(ctx context.Context, args DestinationsArgs) ([]Output, error)
}

type DestinationsReaderWriter interface {
	DestinationsReader
	DestinationsWriter
}

type DestinationsService interface {
	// InvoiceCreate will split satoshis into multiple denominations and store
	// as denominations waiting to be fulfilled in a tx.
	DestinationsCreate(ctx context.Context, req DestinationsCreate) (*Destination, error)
	// Destinations given the args, will return a set of Destinations.
	Destinations(ctx context.Context, args DestinationsArgs) (*Destination, error)
}

type DestinationsWriter interface {
	// DestinationsCreate will add a set of destinations to a data store.
	DestinationsCreate(ctx context.Context, args DestinationsCreateArgs, req []DestinationCreate) ([]Output, error)
}

type FeeReader interface {
	// Fees will return fees from a datastore.
	Fees(ctx context.Context) (*bt.FeeQuote, error)
}

type Invoice struct {
	// ID is a unique identifier for an invoice and can be used
	// to lookup a single invoice.
	ID string `json:"id" db:"invoice_id"`
	// Reference is an identifier that can be used to link the
	// PayD invoice with an external system.
	Reference null.String `json:"reference" db:"payment_reference"`
	// Description is an optional text field that can have some further info
	// like 'invoice for oranges'.
	Description null.String `json:"description" db:"description"`
	// Satoshis is the total amount this invoice is to pay.
	Satoshis uint64 `json:"satoshis" db:"satoshis"`
	// ExpiresAt is an optional param that can be passed to set an expiration
	// date on an invoice, after which, payments will not be accepted.
	ExpiresAt null.Time `json:"expiresAt" db:"expires_at"`
	// PaymentReceivedAt will be set when this invoice has been paid and
	// states when the payment was received in UTC time.
	PaymentReceivedAt null.Time `json:"paymentReceivedAt" db:"payment_received_at"`
	// RefundTo is an optional paymail address that can be used to refund the
	// customer if required.
	RefundTo null.String `json:"refundTo" db:"refund_to"`
	// RefundedAt if this payment has been refunded, this date will be set
	// to the UTC time of the refund.
	RefundedAt null.Time `json:"refundedAt" db:"refunded_at"`
	// State is the current status of the invoice.
	State InvoiceState `json:"state" db:"state" enums:"pending,paid,refunded,deleted"`
	// SPVRequired if true will mean this invoice requires a valid spvenvelope otherwise a rawTX will suffice.
	SPVRequired bool `json:"-" db:"spv_required"`
	MetaData
}

type InvoiceArgs struct {
	InvoiceID string `param:"invoiceID" db:"invoice_id"`
}

type InvoiceCreate struct {
	InvoiceID string `json:"-" db:"invoice_id"`
	// Satoshis is the total amount this invoice is to pay.
	Satoshis uint64 `json:"satoshis" db:"satoshis"`
	// Reference is an identifier that can be used to link the
	// payd invoice with an external system.
	// MaxLength is 32 characters.
	Reference null.String `json:"reference" db:"payment_reference"`
	// Description is an optional text field that can have some further info
	// like 'invoice for oranges'.
	// MaxLength is 1024 characters.
	Description null.String `json:"description" db:"description"`
	// ExpiresAt is an optional param that can be passed to set an expiration
	// date on an invoice, after which, payments will not be accepted.
	ExpiresAt null.Time `json:"expiresAt" db:"expires_at"`
	// SPVRequired if true will mean this invoice requires a valid spvenvelope otherwise a rawTX will suffice.
	SPVRequired bool `json:"-" db:"spv_required"`
}

type InvoiceReader interface {
	// Invoice will return an invoice that matches the provided args.
	Invoice(ctx context.Context, args InvoiceArgs) (*Invoice, error)
	// Invoices returns all currently stored invoices TODO: update to support search args
	Invoices(ctx context.Context) ([]Invoice, error)
}

type InvoiceReaderWriter interface {
	InvoiceWriter
	InvoiceReader
}

type InvoiceService interface {
	Invoice(ctx context.Context, args InvoiceArgs) (*Invoice, error)
	Invoices(ctx context.Context) ([]Invoice, error)
	Create(ctx context.Context, req InvoiceCreate) (*Invoice, error)
	Delete(ctx context.Context, args InvoiceArgs) error
}

type InvoiceState string

type InvoiceUpdateArgs struct {
	InvoiceID string
}

type InvoiceUpdatePaid struct {
	PaymentReceivedAt time.Time `db:"payment_received_at"`
}

type InvoiceUpdateRefunded struct {
	// RefundTo will set an invoice as refunded.
	RefundTo null.String `db:"refund_to"`
	// RefundedAt if this payment has been refunded, this date will be set
	// to the UTC time of the refund.
	RefundedAt null.Time `json:"refundedAt" db:"refunded_at"`
}

type InvoiceWriter interface {
	// Create will persist a new Invoice in the data store.
	InvoiceCreate(ctx context.Context, req InvoiceCreate) (*Invoice, error)
	// Update will update an invoice matching the provided args with the requested changes.
	InvoiceUpdate(ctx context.Context, args InvoiceUpdateArgs, req InvoiceUpdatePaid) (*Invoice, error)
	// Delete will remove an invoice from the data store, depending on implementation this could
	// be a hard or soft delete.
	InvoiceDelete(ctx context.Context, args InvoiceArgs) error
}

type KeyArgs struct {
	// Name is the name of the key to return.
	Name string `db:"name"`
}

type MetaData struct {
	// CreatedAt is the UTC time the object was created.
	CreatedAt time.Time `json:"createdAt" db:"created_at"`
	// UpdatedAt is the UTC time the object was updated.
	UpdatedAt time.Time `json:"updatedAt" db:"updated_at"`
	// DeletedAt is the date the object was removed.
	DeletedAt null.Time `json:"deletedAt,omitempty" db:"deleted_at"`
}

type Output struct {
	ID uint64 `json:"-" db:"destination_id"`
	// LockingScript is the P2PKH locking script used.
	LockingScript string `json:"script" db:"locking_script"`
	Satoshis      uint64 `json:"satoshis" db:"satoshis"`
	// DerivationPath is the deterministic path for this destination.
	DerivationPath string `json:"-" db:"derivation_path"`
	// State will indicate if this destination is still waiting on a tx to fulfil it (pending)
	// has been paid to in a tx (received) or has been deleted.
	State string `json:"-" db:"state"  enums:"pending,received,deleted"`
}

type OwnerService interface {
	Owner(ctx context.Context) (*User, error)
}

type OwnerStore interface {
	Owner(ctx context.Context) (*User, error)
}

type P2PCapabilityArgs struct {
	Domain string
	BrfcID string
}

type P2POutputCreateArgs struct {
	Domain string
	Alias  string
}

type P2PPayment struct {
	Satoshis uint64
}

type P2PTransaction struct {
	TxHex    string
	Metadata P2PTransactionMetadata
}

type P2PTransactionArgs struct {
	Alias     string
	Domain    string
	PaymentID string
	TxHex     string
}

type P2PTransactionMetadata struct {
	Note      string // A human readable bit of information about the payment
	PubKey    string // Public key to validate the signature (if signature is given)
	Sender    string // The paymail of the person that originated the transaction
	Signature string
}

type PaymailReader interface {
	Capability(ctx context.Context, args P2PCapabilityArgs) (string, error)
}

type PaymailReaderWriter interface {
	PaymailReader
	PaymailWriter
}

type PaymailWriter interface {
	OutputsCreate(ctx context.Context, args P2POutputCreateArgs, req P2PPayment) ([]*bt.Output, error)
}

type PaymentCreate struct {
	InvoiceID   string        `json:"-" param:"invoiceID"`
	SPVEnvelope *spv.Envelope `json:"spvEnvelope"`
	RawTX       null.String   `json:"rawTx"`
	// ProofCallbacks allow support of multiple callbacks for merkle proofs
	// this will help support multisig and also transmitting proofs to the sender wallet.
	//    "proofCallbacks": {
	//        "http://domain.com/proofs": {
	//            "token": "abc123"
	//        }
	//    }
	ProofCallbacks map[string]ProofCallback `json:"proofCallbacks"`
}

type PaymentsService interface {
	// PaymentCreate will validate a new payment.
	PaymentCreate(ctx context.Context, req PaymentCreate) error
}

type PrivateKey struct {
	// Name of the private key.
	Name string `db:"name"`
	// Xprv is the private key.
	Xprv string `db:"xprv"`
	// CreatedAt is the date/time when the key was stored.
	CreatedAt time.Time `db:"createdAt"`
}

type PrivateKeyReader interface {
	// PrivateKey can be used to return an existing private key.
	PrivateKey(ctx context.Context, args KeyArgs) (*PrivateKey, error)
}

type PrivateKeyReaderWriter interface {
	PrivateKeyReader
	PrivateKeyWriter
}

type PrivateKeyService interface {
	// Create will create a new private key if it doesn't exist already.
	Create(ctx context.Context, keyName string) error
	// PrivateKey will return a private key.
	PrivateKey(ctx context.Context, keyName string) (*bip32.ExtendedKey, error)
}

type PrivateKeyWriter interface {
	// PrivateKeyCreate will add a new private key to the data store.
	PrivateKeyCreate(ctx context.Context, req PrivateKey) (*PrivateKey, error)
}

type ProofCallback struct {
	// Token to use for authentication when sending the proof to the destination. Optional.
	Token string
}

type ProofCallbackArgs struct {
	InvoiceID string `db:"invoice_id"`
}

type ProofCallbackWriter interface {
	// ProofCallBacksCreate can be implemented to store merkle proof callback urls for an invoice.
	ProofCallBacksCreate(ctx context.Context, args ProofCallbackArgs, callbacks map[string]ProofCallback) error
}

type ProofCreateArgs struct {
	// TxID will be used to validate the proof envelope.
	TxID string `json:"txId" param:"txid"`
}

type ProofWrapper struct {
	CallbackPayload *bc.MerkleProof `json:"callbackPayload"`
	BlockHash       string          `json:"blockHash"`
	BlockHeight     uint32          `json:"blockHeight"`
	CallbackTxID    string          `json:"callbackTxID"`
	CallbackReason  string          `json:"callbackReason"`
}

type ProofsService interface {
	// Create will store a JSONEnvelope that contains a merkleproof. The envelope should
	// be validated to not be tampered with and the Envelope should be opened to check the payload
	// is indeed a MerkleProof.
	Create(ctx context.Context, args ProofCreateArgs, req envelope.JSONEnvelope) error
}

type ProofsWriter interface {
	// ProofCreate can be used to persist a merkle proof in TSC format.
	ProofCreate(ctx context.Context, req ProofWrapper) error
}

type SpendTxo struct {
	SpentAt      *time.Time
	SpendingTxID string
}

type SpendTxoArgs struct {
	Outpoint string
}

type Transacter interface {
	WithTx(ctx context.Context) context.Context
	Commit(ctx context.Context) error
	Rollback(ctx context.Context) error
}

type Transaction struct {
	PaymentID string    `db:"paymentid"`
	TxID      string    `db:"tx_id"`
	TxHex     string    `db:"tx_hex"`
	CreatedAt time.Time `db:"created_at"`
	Outputs   []Txo     `db:"-"`
	State     string    `enums:"pending,broadcast,failed,deleted"`
}

type TransactionArgs struct {
	TxID string `db:"tx_id"`
}

type TransactionCreate struct {
	InvoiceID string       `db:"invoice_id"`
	TxID      string       `db:"tx_id"`
	TxHex     string       `db:"tx_hex"`
	Outputs   []*TxoCreate `db:"-"`
}

type TransactionStateUpdate struct {
	State TxState `db:"state"`
}

type TransactionWriter interface {
	TransactionCreate(ctx context.Context, req TransactionCreate) error
	// TransactionUpdateState can be used to change a tx state (failed, broadcast).
	TransactionUpdateState(ctx context.Context, args TransactionArgs, req TransactionStateUpdate) error
}

type TxState string

type Txo struct {
	Outpoint       string      `db:"outpoint"`
	TxID           string      `db:"tx_id"`
	Vout           int         `db:"vout"`
	KeyName        null.String `db:"key_name"`
	DerivationPath null.String `db:"derivation_path"`
	LockingScript  string      `db:"locking_script"`
	Satoshis       uint64      `db:"satoshis"`
	SpentAt        null.Time   `db:"spent_at"`
	SpendingTxID   null.String `db:"spending_txid"`
	CreatedAt      time.Time   `db:"created_at"`
	ModifiedAt     time.Time   `db:"updated_at"`
}

type TxoArgs struct {
	Outpoint string
}

type TxoCreate struct {
	Outpoint      string `db:"outpoint"`
	DestinationID uint64 `db:"destination_id"`
	TxID          string `db:"tx_id"`
	Vout          uint64 `db:"vout"`
}

type TxoWriter interface {
	// TxosCreate will add an array of txos to a data store.
	TxosCreate(ctx context.Context, req []*TxoCreate) error
}

type User struct {
	ID           uint64            `json:"id" db:"user_id"`
	Name         string            `json:"name" db:"name"`
	Avatar       string            `json:"avatar" db:"avatar_url"`
	Email        string            `json:"email" db:"email"`
	Address      string            `json:"address" db:"address"`
	PhoneNumber  string            `json:"phoneNumber" db:"phone_number"`
	ExtendedData map[string]string `json:"extendedData"`
}