models

type APIKey struct {
	Model
	Description sql.NullString
	ClientID    string
	Secret      string
	LastSeen    sql.NullTime
	// contains filtered or unexported fields
}

type APIKeyPage struct {
	APIKeys []*APIKey `json:"api_keys"`
	Page    *PageInfo `json:"page"`
}

type Account struct {
	Model
	CustomerID    sql.NullString  // Account ID of internal user record (optional)
	FirstName     sql.NullString  // First name (forename) of user
	LastName      sql.NullString  // Last name (surname) of user
	TravelAddress sql.NullString  // Generated TravelAddress for this user
	IVMSRecord    *ivms101.Person // IVMS101 record for the account
	// contains filtered or unexported fields
}

type AccountsPage struct {
	Accounts []*Account `json:"accounts"`
	Page     *PageInfo  `json:"page"`
}

type ComplianceAuditLog struct {
	// ID is a unique indentifier for a ComplianceAuditLog
	ID ulid.ULID
	// ActorID can be a ULID or UUID, depending on the ActorType
	ActorID []byte
	// ActorType allows us to decode the ActorID and is human-readable
	ActorType enum.Actor
	// ResourceID can be a ULID or UUID, depending on the ResourceType
	ResourceID []byte
	// ResourceType allows us to decode the ResourceID and is human-readable
	ResourceType enum.Resource
	// ResourceModified is the time the resource was modified at
	ResourceModified time.Time
	// Action is the type of change made in the database
	Action enum.Action
	// ChangeNotes is an optional string that can include further details
	ChangeNotes sql.NullString

	// Signature is a cryptographic Signature that can be used to verify that an
	// instance of a ComplianceAuditLog was not modified
	Signature []byte
	// KeyID is the identification for the public key that can verify this log
	KeyID string
	// Algorithm is the identification for the algorithm that can verify this log
	Algorithm string
}

type ComplianceAuditLogPage struct {
	Logs []*ComplianceAuditLog       `json:"logs"`
	Page *ComplianceAuditLogPageInfo `json:"page"`
}

type ComplianceAuditLogPageInfo struct {
	PageInfo

	// Maximum number of records to query from database
	// TODO: remove this once proper pagination has been implemented
	Limit int

	// ResourceTypes filters results to include only these enum.Resource values
	ResourceTypes []string
	// ResourceID filters results by a specific resource ID
	ResourceID string
	// ResourceTypes filters results to include only these enum.Actor values
	ActorTypes []string
	// ActorID filters results by a specific actor ID
	ActorID string
	// After filters results to include logs with ResourceModified on or after this time (inclusive)
	After time.Time
	// Before filters results to include logs with ResourceModified before this time (exclusive)
	Before time.Time

	// DetailedLogs will return the full log entry if true (otherwise List
	// returns only summary info)
	DetailedLogs bool
}

type Contact struct {
	Model
	Name           string    // The full name of the contact
	Email          string    // A unique address for the contact (professional email) must be lowercase
	Role           string    // A description of what the contact does at the counterparty
	CounterpartyID ulid.ULID // Reference to the counterparty the contact is associated with
	// contains filtered or unexported fields
}

type ContactsPage struct {
	Contacts []*Contact `json:"contacts"`
	Page     *PageInfo  `json:"page"`
}

type Counterparty struct {
	Model
	Source              enum.Source          // either directory or locally created
	DirectoryID         sql.NullString       // the directory ID associated with the counterparty (directory only)
	RegisteredDirectory sql.NullString       // the registered directory of the counterparty (directory only)
	Protocol            enum.Protocol        // the protocol to use to send travel rule information (TRISA, TRP, Sunrise, etc.)
	CommonName          string               // common name - a unique name to identify the endpoint
	Endpoint            string               // the full endpoint to connect to the counterparty on
	Name                string               // the counterparty's legal entity name
	Website             sql.NullString       // website with more information about the counterparty
	Country             sql.NullString       // country the counterparty is associated with
	BusinessCategory    sql.NullString       // the business category of the counterparty
	VASPCategories      VASPCategories       // the categories of how the VASP handles crypto assets
	VerifiedOn          sql.NullTime         // the datetime the VASP was verified in the directory (directory only)
	IVMSRecord          *ivms101.LegalPerson // IVMS101 record for the counterparty
	LEI                 sql.NullString       // Legal Entity Identifier for the counterparty (generally for TRP)
	// contains filtered or unexported fields
}

type CounterpartyPage struct {
	Counterparties []*Counterparty       `json:"counterparties"`
	Page           *CounterpartyPageInfo `json:"page"`
}

type CounterpartyPageInfo struct {
	PageInfo
	Source string `json:"source,omitempty"`
}

type CounterpartySourceInfo struct {
	ID                  ulid.ULID
	Source              string         // either directory or locally created
	DirectoryID         sql.NullString // the directory ID associated with the counterparty (directory only)
	RegisteredDirectory sql.NullString // the registered directory of the counterparty (directory only)
	Protocol            string         // the protocol to use to send travel rule information (TRISA, TRP, Sunrise, etc.)
}

type CryptoAddress struct {
	Model
	AccountID     ulid.ULID      // Reference to account the crypto address belongs to
	CryptoAddress string         // The actual crypto address of the wallet
	Network       string         // The network associated with the crypto address in SIP0044 encoding
	AssetType     sql.NullString // The asset type with the crypto address (optional)
	Tag           sql.NullString // The memo or destination tag associated with the address (optional)
	TravelAddress sql.NullString // Generated TravelAddress for this wallet address
	// contains filtered or unexported fields
}

type CryptoAddressPage struct {
	CryptoAddresses []*CryptoAddress `json:"crypto_addresses"`
	Page            *PageInfo        `json:"page"`
}

type EnvelopeStorage interface {
	AddEnvelope(*SecureEnvelope) error
}

type Model struct {
	ID       ulid.ULID `json:"id"`
	Created  time.Time `json:"created"`
	Modified time.Time `json:"modified"`
}

type PageInfo struct {
	PageSize   uint32    `json:"page_size"`
	NextPageID ulid.ULID `json:"next_page_id"`
	PrevPageID ulid.ULID `json:"prev_page_id"`
}

type Permission struct {
	ID          int64
	Title       string
	Description string
	Created     time.Time
	Modified    time.Time
}

type PreparedTransaction interface {
	Created() bool                                                         // Returns true if the transaction was newly created, false if it already existed
	Fetch() (*Transaction, error)                                          // Fetches the current transaction record from the database
	Update(*Transaction, *ComplianceAuditLog) error                        // Update the transaction with new information; e.g. data from decryption
	AddCounterparty(*Counterparty, *ComplianceAuditLog) error              // Add counterparty by database ULID, counterparty name, or registered directory ID; if the counterparty doesn't exist, it is created
	UpdateCounterparty(*Counterparty, *ComplianceAuditLog) error           // Update the counterparty with new information
	LookupCounterparty(field, value string) (*Counterparty, error)         // Lookup a counterparty by field and value
	AddEnvelope(*SecureEnvelope, *ComplianceAuditLog) error                // Associate a secure envelope with the prepared transaction
	CreateSunrise(*Sunrise, *ComplianceAuditLog) error                     // Create a sunrise message sent to the counterparty for the transaction
	UpdateSunrise(*Sunrise, *ComplianceAuditLog) error                     // Update the sunrise message
	UpdateSunriseStatus(uuid.UUID, enum.Status, *ComplianceAuditLog) error // Update the status of all sunrise messages
	Rollback() error                                                       // Rollback the prepared transaction and conclude it
	Commit() error                                                         // Commit the prepared transaction and conclude it
}

type ResetPasswordLink struct {
	Model
	UserID     ulid.ULID         // A foreign key reference to the user's account
	Email      string            // Email address of recipient the token was sent to
	Expiration time.Time         // The timestamp that the sunrise verification token is no longer valid
	Signature  *vero.SignedToken // The signed token produced by the sunrise package for verification purposes
	SentOn     sql.NullTime      // The timestamp that the email message was sent
}

type ResetPasswordLinkPage struct {
	Links []*ResetPasswordLink `json:"links"`
	Page  *PageInfo            `json:"page"`
}

type Role struct {
	ID          int64
	Title       string
	Description string
	IsDefault   bool
	Created     time.Time
	Modified    time.Time
	// contains filtered or unexported fields
}

type Scanner interface {
	Scan(dest ...any) error
}

type SearchQuery struct {
	Query string
	Limit int
}

type SecureEnvelope struct {
	Model
	EnvelopeID    uuid.UUID           // Also a foreign key reference to the Transaction
	Direction     enum.Direction      // Either "out" outgoing or "in" incoming
	Remote        sql.NullString      // The common name of the remote peer this message was going to or coming from
	ReplyTo       ulid.NullULID       // If this envelope is a response, a reference to the original request envelope
	IsError       bool                // If the envelope contains an error/rejection rather than a payload
	EncryptionKey []byte              // The encryption key, encrypted with the public key of the local node. Note this may differ from the value in the envelope for outgoing messages
	HMACSecret    []byte              // The hmac secret, encrypted with the public key of the local node. Note that this may differ from the value in the envelope for outgoing messages
	ValidHMAC     sql.NullBool        // If the hmac has been validated against the payload and non-repudiation properties are satisfied
	Timestamp     time.Time           // The timestamp of the envelope as defined by the envelope
	PublicKey     sql.NullString      // The signature of the public key that sealed the encryption key and hmac secret, may differ from the value in the envelope for ougoing envelopes.
	TransferState int32               // The transfer state of the secure envelope
	Envelope      *api.SecureEnvelope // The secure envelope protocol buffer stored as a BLOB
	// contains filtered or unexported fields
}

type SecureEnvelopePage struct {
	Envelopes []*SecureEnvelope `json:"envelopes"`
	Page      *PageInfo         `json:"page"`
}

type Sunrise struct {
	Model
	EnvelopeID uuid.UUID         // A foreign key reference to the Transaction
	Email      string            // Email address of recipients the token is sent to (might be a comma separated list)
	Expiration time.Time         // The timestamp that the sunrise verification token is no longer valid
	Signature  *vero.SignedToken // The signed token produced by the sunrise package for verification purposes
	Status     enum.Status       // The status of the sunrise message (should be similar to the status of the transaction)
	SentOn     sql.NullTime      // The timestamp that the email message was sent
	VerifiedOn sql.NullTime      // The last timestamp that the user verified the token
}

type SunrisePage struct {
	Messages []*Sunrise `json:"messages"`
	Page     *PageInfo  `json:"page"`
}

type Transaction struct {
	ID                 uuid.UUID      // Transaction IDs are UUIDs not ULIDs per the TRISA spec, this is also used for the envelope ID
	Source             enum.Source    // Either "local" meaning the transaction was created by the user, or "remote" meaning it is an incoming message
	Status             enum.Status    // Can be "unspecified", "started", "pending", "review", "repair", "accepted", "completed", or "rejected"
	Counterparty       string         // The name of the counterparty in the transaction
	CounterpartyID     ulid.NullULID  // A reference to the counterparty in the database, if any
	Originator         sql.NullString // Full name of the originator natural person or account
	OriginatorAddress  sql.NullString // The crypto address of the originator
	Beneficiary        sql.NullString // Full name of the beneficiary natural person or account
	BeneficiaryAddress sql.NullString // The crypto address of the beneficiary
	VirtualAsset       string         // A representation of the network/asset type
	Amount             float64        // The amount of the transaction
	Archived           bool           // If the transaction is archived or not
	ArchivedOn         sql.NullTime   // The timestamp the transaction was archived
	LastUpdate         sql.NullTime   // The last time a TRISA RPC occurred for this transaction
	Created            time.Time      // Timestamp the transaction was created
	Modified           time.Time      // Timestamp the transaction was last modified, including when a new secure envelope was received
	// contains filtered or unexported fields
}

type TransactionCounts struct {
	Active   map[string]int // Active transaction counts by status
	Archived map[string]int // Archived transaction counts by status
}

type TransactionPage struct {
	Transactions []*Transaction       `json:"transactions"`
	Page         *TransactionPageInfo `json:"page"`
}

type TransactionPageInfo struct {
	PageInfo
	Status       []string `json:"status,omitempty"`
	VirtualAsset []string `json:"asset,omitempty"`
	Archives     bool     `json:"archives,omitempty"`
}

type TravelAddressFactory func(any) (string, error)

type User struct {
	Model
	Name      sql.NullString
	Email     string
	Password  string
	RoleID    int64
	LastLogin sql.NullTime
	// contains filtered or unexported fields
}

type UserPage struct {
	Users []*User       `json:"users"`
	Page  *UserPageInfo `json:"page"`
}

type UserPageInfo struct {
	PageInfo
	Role string `json:"role,omitempty"`
}

type VASPCategories []string