store

type ChannelAccount struct {
	PublicKey  string       `db:"public_key"`
	PrivateKey string       `db:"private_key"` // TODO: remove this from the model, since we now rely on a Signer interface.
	UpdatedAt  *time.Time   `db:"updated_at"`
	CreatedAt  *time.Time   `db:"created_at"`
	LockedAt   sql.NullTime `db:"locked_at"`
	// LockedUntilLedgerNumber is the ledger number after which the lock expires. It should be synched with the
	// expiration ledger bound of the transaction submitted by this Stellar channel account.
	LockedUntilLedgerNumber sql.NullInt32 `db:"locked_until_ledger_number"`
}

type ChannelAccountModel struct {
	DBConnectionPool db.DBConnectionPool
}

type ChannelAccountStore interface {
	Delete(ctx context.Context, sqlExec db.SQLExecuter, publicKey string) (err error)
	DeleteIfLockedUntil(ctx context.Context, publicKey string, lockedUntilLedgerNumber int) (err error)
	Get(ctx context.Context, sqlExec db.SQLExecuter, publicKey string, currentLedgerNumber int) (ca *ChannelAccount, err error)
	GetAndLock(ctx context.Context, publicKey string, currentLedger, nextLedgerLock int) (*ChannelAccount, error)
	Count(ctx context.Context) (count int, err error)
	GetAll(ctx context.Context, sqlExec db.SQLExecuter, currentLedger, limit int) ([]*ChannelAccount, error)
	GetAndLockAll(ctx context.Context, currentLedger, nextLedgerLock, limit int) ([]*ChannelAccount, error)
	Insert(ctx context.Context, sqlExec db.SQLExecuter, publicKey string, privateKey string) error
	InsertAndLock(ctx context.Context, publicKey string, privateKey string, currentLedger, nextLedgerLock int) error
	BatchInsert(ctx context.Context, sqlExec db.SQLExecuter, channelAccounts []*ChannelAccount) error
	BatchInsertAndLock(ctx context.Context, channelAccounts []*ChannelAccount, currentLedger, nextLedgerLock int) error
	// Lock management:
	Lock(ctx context.Context, sqlExec db.SQLExecuter, publicKey string, currentLedger, nextLedgerLock int32) (*ChannelAccount, error)
	Unlock(ctx context.Context, sqlExec db.SQLExecuter, publicKey string) (*ChannelAccount, error)
}

type ChannelTransactionBundle struct {
	// ChannelAccount is the resource needed to process the Transaction.
	ChannelAccount ChannelAccount `db:"channel_account"`
	// Transaction is the job that would be handled by the worker.
	Transaction Transaction `db:"transaction"`
	// LockedUntilLedgerNumber is the ledger number until which both the transaction and channel account are locked.
	LockedUntilLedgerNumber int `db:"locked_until_ledger_number"`
}

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

type DBVault interface {
	BatchInsert(ctx context.Context, dbVaultEntries []*DBVaultEntry) error
	Get(ctx context.Context, publicKey string) (*DBVaultEntry, error)
	Delete(ctx context.Context, publicKey string) error
}

type DBVaultEntry struct {
	PublicKey           string    `db:"public_key"`
	EncryptedPrivateKey string    `db:"encrypted_private_key"`
	UpdatedAt           time.Time `db:"updated_at"`
	CreatedAt           time.Time `db:"created_at"`
}

type DBVaultModel struct {
	DBConnectionPool db.DBConnectionPool
}

type Transaction struct {
	ID string `db:"id"`
	// ExternalID contains an external ID for the transaction. This is used for reconciliation.
	ExternalID string `db:"external_id"`
	// Status is the status of the transaction. Don't change it directly and use the internal methods of the model instead.
	Status        TransactionStatus        `db:"status"`
	StatusMessage sql.NullString           `db:"status_message"`
	StatusHistory TransactionStatusHistory `db:"status_history"`
	AssetCode     string                   `db:"asset_code"`
	AssetIssuer   string                   `db:"asset_issuer"`
	Amount        float64                  `db:"amount"`
	Destination   string                   `db:"destination"`

	TenantID            string         `db:"tenant_id"`
	DistributionAccount sql.NullString `db:"distribution_account"`

	CreatedAt *time.Time `db:"created_at"`
	UpdatedAt *time.Time `db:"updated_at"`
	// StartedAt is when the transaction was read from the queue into memory.
	StartedAt *time.Time `db:"started_at"`
	// SentAt is when the transaction was sent to the Stellar network.
	SentAt *time.Time `db:"sent_at"`
	// CompletedAt is when the transaction reached a terminal state, either SUCCESS or ERROR.
	CompletedAt *time.Time `db:"completed_at"`
	// SyncedAt is when the transaction was synced with SDP.
	SyncedAt *time.Time `db:"synced_at"`

	AttemptsCount          int            `db:"attempts_count"`
	StellarTransactionHash sql.NullString `db:"stellar_transaction_hash"`
	// XDRSent is the EnvelopeXDR submitted when creating a Stellar transaction in the network.
	XDRSent sql.NullString `db:"xdr_sent"`
	// XDRReceived is the ResultXDR received from the Stellar network when attempting to create a transaction.
	XDRReceived sql.NullString `db:"xdr_received"`
	LockedAt    *time.Time     `db:"locked_at"`
	// LockedUntilLedgerNumber is the ledger number after which the lock expires. It should be synched with the
	// expiration ledger bound set in the Stellar transaction submitted to the blockchain, and the same value in the
	// namesake column of the channel account model.
	LockedUntilLedgerNumber sql.NullInt32 `db:"locked_until_ledger_number"`
}

type TransactionFixture struct {
	ExternalID          string
	AssetCode           string
	AssetIssuer         string
	DestinationAddress  string
	Status              TransactionStatus
	Amount              float64
	TenantID            string
	DistributionAccount string
}

type TransactionModel struct {
	DBConnectionPool db.DBConnectionPool
}

type TransactionStatus string

type TransactionStatusHistory []TransactionStatusHistoryEntry

type TransactionStatusHistoryEntry struct {
	Status                 string    `json:"status"`
	StatusMessage          string    `json:"status_message"`
	Timestamp              time.Time `json:"timestamp"`
	StellarTransactionHash string    `json:"stellar_transaction_hash"`
	XDRSent                string    `json:"xdr_sent"`
	XDRReceived            string    `json:"xdr_received"`
}

type TransactionStore interface {
	// CRUD:
	Insert(ctx context.Context, tx Transaction) (*Transaction, error)
	BulkInsert(ctx context.Context, sqlExec db.SQLExecuter, transactions []Transaction) ([]Transaction, error)
	Get(ctx context.Context, txID string) (tx *Transaction, err error)
	GetAllByPaymentIDs(ctx context.Context, paymentIDs []string) (transactions []*Transaction, err error)
	// Status & Lock management:
	UpdateStatusToSuccess(ctx context.Context, tx Transaction) (updatedTx *Transaction, err error)
	UpdateStatusToError(ctx context.Context, tx Transaction, message string) (updatedTx *Transaction, err error)
	UpdateStellarTransactionXDRReceived(ctx context.Context, txID string, xdrReceived string) (*Transaction, error)
	UpdateStellarTransactionHashAndXDRSent(ctx context.Context, txID string, txHash, txXDRSent string) (*Transaction, error)
	Lock(ctx context.Context, sqlExec db.SQLExecuter, transactionID string, currentLedger, nextLedgerLock int32) (*Transaction, error)
	Unlock(ctx context.Context, sqlExec db.SQLExecuter, publicKey string) (*Transaction, error)
	// Queue management:
	PrepareTransactionForReprocessing(ctx context.Context, sqlExec db.SQLExecuter, transactionID string) (*Transaction, error)
	GetTransactionBatchForUpdate(ctx context.Context, dbTx db.DBTransaction, batchSize int, tenantID string) (transactions []*Transaction, err error)
	GetTransactionPendingUpdateByID(ctx context.Context, sqlExec db.SQLExecuter, txID string) (transaction *Transaction, err error)
	UpdateSyncedTransactions(ctx context.Context, sqlExec db.SQLExecuter, txIDs []string) error
}