package transactions import ( "context" "database/sql" "errors" "fmt" "time" sq "github.com/Masterminds/squirrel" "github.com/emochka2007/block-accounting/internal/pkg/models" sqltools "github.com/emochka2007/block-accounting/internal/pkg/sqlutils" "github.com/emochka2007/block-accounting/internal/usecase/repository/organizations" "github.com/google/uuid" ) type GetTransactionsParams struct { Ids uuid.UUIDs OrganizationId uuid.UUID Limit int64 CursorId uuid.UUID Pending bool ReadyToConfirm bool } type ConfirmTransactionParams struct { TxId uuid.UUID UserId uuid.UUID OrganizationId uuid.UUID } type CancelTransactionParams struct { TxId uuid.UUID UserId uuid.UUID OrganizationId uuid.UUID } type Repository interface { GetTransactions(ctx context.Context, params GetTransactionsParams) ([]*models.Transaction, error) CreateTransaction(ctx context.Context, tx models.Transaction) error UpdateTransaction(ctx context.Context, tx models.Transaction) error DeleteTransaction(ctx context.Context, tx models.Transaction) error ConfirmTransaction(ctx context.Context, params ConfirmTransactionParams) error CancelTransaction(ctx context.Context, params CancelTransactionParams) error AddMultisig(ctx context.Context, multisig models.Multisig) error ListMultisig(ctx context.Context, params ListMultisigsParams) ([]models.Multisig, error) ConfirmMultisig(ctx context.Context, params ConfirmMultisigParams) error AddPayrollContract(ctx context.Context, params AddPayrollContract) error ListPayrolls(ctx context.Context, params ListPayrollsParams) ([]models.Payroll, error) } type repositorySQL struct { db *sql.DB orgRepo organizations.Repository } func NewRepository(db *sql.DB, orgRepo organizations.Repository) Repository { return &repositorySQL{ db: db, orgRepo: orgRepo, } } func (s *repositorySQL) Conn(ctx context.Context) sqltools.DBTX { if tx, ok := ctx.Value(sqltools.TxCtxKey).(*sql.Tx); ok { return tx } return s.db } func (r *repositorySQL) GetTransactions( ctx context.Context, params GetTransactionsParams, ) ([]*models.Transaction, error) { var txs []*models.Transaction = make([]*models.Transaction, 0, len(params.Ids)) err := sqltools.Transaction(ctx, r.db, func(ctx context.Context) (err error) { query := buildGetTransactionsQuery(params) rows, err := query.RunWith(r.Conn(ctx)).QueryContext(ctx) if err != nil { return fmt.Errorf("error fetch transactions data from database. %w", err) } defer func() { if cErr := rows.Close(); cErr != nil { err = errors.Join(fmt.Errorf("error close database rows. %w", cErr), err) } }() for rows.Next() { var ( id uuid.UUID description string organizationId uuid.UUID amount float64 toAddr []byte maxFeeAllowed float64 deadline sql.NullTime createdAt time.Time updatedAt time.Time confirmedAt sql.NullTime cancelledAt sql.NullTime commitedAt sql.NullTime createdById uuid.UUID createdBySeed []byte createdByCreatedAt time.Time createdByActivatedAt sql.NullTime createdByIsAdmin bool ) if err = rows.Scan( &id, &description, &organizationId, &createdById, &amount, &toAddr, &maxFeeAllowed, &deadline, &createdAt, &updatedAt, &confirmedAt, &cancelledAt, &commitedAt, &createdBySeed, &createdByCreatedAt, &createdByActivatedAt, &createdByIsAdmin, ); err != nil { return fmt.Errorf("error scan row. %w", err) } tx := &models.Transaction{ Id: id, Description: description, OrganizationId: organizationId, Amount: amount, ToAddr: toAddr, MaxFeeAllowed: maxFeeAllowed, CreatedBy: &models.OrganizationUser{ User: models.User{ ID: createdById, Bip39Seed: createdBySeed, }, }, CreatedAt: createdAt, UpdatedAt: updatedAt, } if deadline.Valid { tx.Deadline = deadline.Time } if confirmedAt.Valid { tx.ConfirmedAt = confirmedAt.Time } if commitedAt.Valid { tx.CommitedAt = commitedAt.Time } if cancelledAt.Valid { tx.CancelledAt = cancelledAt.Time } if createdByActivatedAt.Valid { tx.CreatedBy.Activated = true } txs = append(txs, tx) } return nil }) if err != nil { return nil, err } return txs, nil } func (r *repositorySQL) CreateTransaction(ctx context.Context, tx models.Transaction) error { if err := sqltools.Transaction(ctx, r.db, func(ctx context.Context) error { columns := []string{ "id", "description", "organization_id", "created_by", "amount", "to_addr", "max_fee_allowed", "created_at", "updated_at", } values := []any{ tx.Id, tx.Description, tx.OrganizationId, tx.CreatedBy.ID, tx.Amount, tx.ToAddr, tx.MaxFeeAllowed, tx.CreatedAt, tx.CreatedAt, } if !tx.Deadline.IsZero() { columns = append(columns, "deadline") values = append(values, tx.Deadline) } query := sq.Insert("transactions"). Columns(columns...). Values(values...). PlaceholderFormat(sq.Dollar) // todo add optional insertions if _, err := query.RunWith(r.Conn(ctx)).ExecContext(ctx); err != nil { return fmt.Errorf("error insert new transaction. %w", err) } return nil }); err != nil { return err } return nil } func (r *repositorySQL) UpdateTransaction(ctx context.Context, tx models.Transaction) error { return nil } func (r *repositorySQL) DeleteTransaction(ctx context.Context, tx models.Transaction) error { return nil } func (r *repositorySQL) ConfirmTransaction(ctx context.Context, params ConfirmTransactionParams) error { if err := sqltools.Transaction(ctx, r.db, func(ctx context.Context) error { query := sq.Update("transactions"). SetMap(sq.Eq{ "confirmed_at": time.Now(), "cancelled_at": nil, }). Where(sq.Eq{ "id": params.TxId, "organization_id": params.OrganizationId, }).PlaceholderFormat(sq.Dollar) if _, err := query.RunWith(r.Conn(ctx)).ExecContext(ctx); err != nil { return fmt.Errorf("error update confirmed at. %w", err) } return nil }); err != nil { return err } return nil } func (r *repositorySQL) CancelTransaction(ctx context.Context, params CancelTransactionParams) error { if err := sqltools.Transaction(ctx, r.db, func(ctx context.Context) error { query := sq.Update("transactions"). SetMap(sq.Eq{ "cancelled_at": time.Now(), "confirmed_at": nil, }). Where(sq.Eq{ "id": params.TxId, "organization_id": params.OrganizationId, }).PlaceholderFormat(sq.Dollar) if _, err := query.RunWith(r.Conn(ctx)).ExecContext(ctx); err != nil { return fmt.Errorf("error update confirmed at. %w", err) } return nil }); err != nil { return err } return nil } func buildGetTransactionsQuery(params GetTransactionsParams) sq.SelectBuilder { query := sq.Select( `t.id, t.description, t.organization_id, t.created_by, t.amount, t.to_addr, t.max_fee_allowed, t.deadline, t.confirmations_required, t.created_at, t.updated_at, t.confirmed_at, t.cancelled_at, t.commited_at, u.seed, u.created_at, u.activated_at, ou.is_admin`, ).From("transactions as t"). InnerJoin("users as u on u.id = t.created_by"). InnerJoin( `organizations_users as ou on u.id = ou.user_id and ou.organization_id = t.organization_id`, ). Where(sq.Eq{ "t.organization_id": params.OrganizationId, }).PlaceholderFormat(sq.Dollar) if len(params.Ids) > 0 { query = query.Where(sq.Eq{ "t.id": params.Ids, }) } if params.OrganizationId != uuid.Nil { query = query.Where(sq.Eq{ "t.organization_id": params.OrganizationId, }) } if params.Pending { query = query.InnerJoin("multisig_confirmations as mc on mc.multisig_id = t.multisig_id").Where( sq.Lt{}, ) } query = query.Limit(uint64(params.Limit)) return query } func (r *repositorySQL) AddMultisig( ctx context.Context, multisig models.Multisig, ) error { return sqltools.Transaction(ctx, r.db, func(ctx context.Context) error { query := sq.Insert("multisigs").Columns( "id", "organization_id", "title", "address", "confirmations", "created_at", "updated_at", ).Values( multisig.ID, multisig.OrganizationID, multisig.Title, multisig.Address, multisig.ConfirmationsRequired, multisig.CreatedAt, multisig.UpdatedAt, ).PlaceholderFormat(sq.Dollar) if _, err := query.RunWith(r.Conn(ctx)).ExecContext(ctx); err != nil { return fmt.Errorf("error insert multisig data. %w", err) } for _, owner := range multisig.Owners { addOwnerQuery := sq.Insert("multisig_owners").Columns( "multisig_id", "owner_id", "created_at", "updated_at", ).Values( multisig.ID, owner.Id(), multisig.CreatedAt, multisig.UpdatedAt, ).PlaceholderFormat(sq.Dollar) if _, err := addOwnerQuery.RunWith(r.Conn(ctx)).ExecContext(ctx); err != nil { return fmt.Errorf("error insert multisig owner data. %w", err) } } return nil }) } type ListMultisigsParams struct { IDs uuid.UUIDs OrganizationID uuid.UUID } func (r *repositorySQL) ListMultisig( ctx context.Context, params ListMultisigsParams, ) ([]models.Multisig, error) { msgs := make([]models.Multisig, 0) if err := sqltools.Transaction(ctx, r.db, func(ctx context.Context) error { query := sq.Select( "id", "organization_id", "title", "address", "confirmations", "created_at", "updated_at", ).From("multisigs").Where(sq.Eq{ "organization_id": params.OrganizationID, }).PlaceholderFormat(sq.Dollar) if len(params.IDs) > 0 { query = query.Where(sq.Eq{ "id": params.IDs, }) } rows, err := query.RunWith(r.Conn(ctx)).QueryContext(ctx) if err != nil { return fmt.Errorf("error fetch multisigs from database. %w", err) } defer rows.Close() msgsTmp := make([]*models.Multisig, 0) for rows.Next() { var ( id uuid.UUID organizationID uuid.UUID address []byte title string confirmations int createdAt time.Time updatedAt time.Time ) if err = rows.Scan( &id, &organizationID, &title, &address, &confirmations, &createdAt, &updatedAt, ); err != nil { return fmt.Errorf("error scan row. %w", err) } msgsTmp = append(msgsTmp, &models.Multisig{ ID: id, Title: title, Address: address, OrganizationID: organizationID, ConfirmationsRequired: confirmations, CreatedAt: createdAt, UpdatedAt: updatedAt, }) } for _, m := range msgsTmp { owners, err := r.fetchOwners(ctx, fetchOwnersParams{ OrganizationID: params.OrganizationID, MultisigID: m.ID, }) if err != nil { return err } m.Owners = owners msgs = append(msgs, *m) } return nil }); err != nil { return nil, err } return msgs, nil } type ConfirmMultisigParams struct { MultisigID uuid.UUID OrganizationsID uuid.UUID CinfirmedBy *models.OrganizationUser ConfirmedAt time.Time } func (r *repositorySQL) ConfirmMultisig(ctx context.Context, params ConfirmMultisigParams) error { return sqltools.Transaction(ctx, r.db, func(ctx context.Context) error { deleteOldQuery := sq.Delete("multisig_confirmations"). Where(sq.Eq{ "multisig_id": params.MultisigID, "owner_id": params.CinfirmedBy.Id(), }). PlaceholderFormat(sq.Dollar) if _, err := deleteOldQuery.RunWith(r.Conn(ctx)).ExecContext(ctx); err != nil { return fmt.Errorf("error delete old multisig confirmation. %w", err) } query := sq.Insert("multisig_confirmations"). Columns( "multisig_id", "owner_id", "created_at", ). Values( params.MultisigID, params.CinfirmedBy.Id(), params.ConfirmedAt, ). PlaceholderFormat(sq.Dollar) if _, err := query.RunWith(r.Conn(ctx)).ExecContext(ctx); err != nil { return fmt.Errorf("error add multisig confirmation. %w", err) } return nil }) } type AddPayrollContract struct { ID uuid.UUID Title string Description string Address []byte Payload []byte OrganizationID uuid.UUID MultisigID uuid.UUID CreatedAt time.Time } func (r *repositorySQL) AddPayrollContract( ctx context.Context, params AddPayrollContract, ) error { return sqltools.Transaction(ctx, r.db, func(ctx context.Context) error { query := sq.Insert("payrolls"). Columns( "id", "title", "description", "address", "payload", "organization_id", "multisig_id", "created_at", ). Values( params.ID, params.Title, params.Description, params.Address, params.Payload, params.OrganizationID, params.MultisigID, params.CreatedAt, ). PlaceholderFormat(sq.Dollar) if _, err := query.RunWith(r.Conn(ctx)).ExecContext(ctx); err != nil { return fmt.Errorf("error add new payroll contract. %w", err) } return nil }) } type fetchOwnersParams struct { MultisigID uuid.UUID OrganizationID uuid.UUID } func (r *repositorySQL) fetchOwners(ctx context.Context, params fetchOwnersParams) ([]models.OrganizationParticipant, error) { owners := make([]models.OrganizationParticipant, 0) if err := sqltools.Transaction(ctx, r.db, func(ctx context.Context) error { query := sq.Select("owner_id").From("multisig_owners").Where(sq.Eq{ "multisig_id": params.MultisigID, }).PlaceholderFormat(sq.Dollar) rows, err := query.RunWith(r.Conn(ctx)).QueryContext(ctx) if err != nil { return fmt.Errorf("error fetch multisigs owners from database. %w", err) } defer rows.Close() ids := make(uuid.UUIDs, 0) for rows.Next() { var ownerId uuid.UUID if err = rows.Scan(&ownerId); err != nil { return err } ids = append(ids, ownerId) } owners, err = r.orgRepo.Participants(ctx, organizations.ParticipantsParams{ OrganizationId: params.OrganizationID, Ids: ids, UsersOnly: true, }) if err != nil { return fmt.Errorf("error fetch owners as participants. %w", err) } return nil }); err != nil { return nil, err } return owners, nil } type ListPayrollsParams struct { IDs []uuid.UUID Limit int64 OrganizationID uuid.UUID } func (r *repositorySQL) ListPayrolls(ctx context.Context, params ListPayrollsParams) ([]models.Payroll, error) { payrolls := make([]models.Payroll, 0, len(params.IDs)) if err := sqltools.Transaction(ctx, r.db, func(ctx context.Context) error { query := sq.Select( "id", "title", "address", "organization_id", "multisig_id", "created_at", "updated_at", ).Where(sq.Eq{ "organization_id": params.OrganizationID, }).PlaceholderFormat(sq.Dollar) if params.Limit <= 0 { params.Limit = 100 } if len(params.IDs) > 0 { query = query.Where(sq.Eq{ "id": params.IDs, }) } query = query.Limit(uint64(params.Limit)) rows, err := query.RunWith(r.Conn(ctx)).QueryContext(ctx) if err != nil { return fmt.Errorf("error fetch payrolls from database. %w", err) } defer rows.Close() // todo check error for rows.Next() { var ( id uuid.UUID title string address []byte organizationId uuid.UUID multisigId uuid.UUID createdAt time.Time updatedAt time.Time ) if err = rows.Scan( &id, &title, &address, &organizationId, &multisigId, &createdAt, &updatedAt, ); err != nil { return fmt.Errorf("error scan row. %w", err) } payrolls = append(payrolls, models.Payroll{ ID: id, Title: title, Address: address, OrganizationID: organizationId, MultisigID: multisigId, CreatedAt: createdAt, UpdatedAt: updatedAt, }) } return nil }); err != nil { return nil, err } return payrolls, nil }