Track terms of use

docs/docs.go

@@ -38,6 +38,46 @@ const docTemplate = `{
                 }
             }
         },
+        "/terms-acceptance": {
+            "post": {
+                "description": "Accept terms by the staker's BTC address (Taproot or Native Segwit)",
+                "produces": [
+                    "application/json"
+                ],
+                "parameters": [
+                    {
+                        "type": "string",
+                        "description": "Staker BTC address in Taproot/Native Segwit format",
+                        "name": "address",
+                        "in": "query",
+                        "required": true
+                    },
+                    {
+                        "description": "Terms acceptance request",
+                        "name": "terms_accepted",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/handlers.TermsAcceptanceRequest"
+                        }
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "Terms acceptance result",
+                        "schema": {
+                            "$ref": "#/definitions/handlers.TermsAcceptancePublic"
+                        }
+                    },
+                    "400": {
+                        "description": "Error: Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/github_com_babylonlabs-io_staking-api-service_internal_types.Error"
+                        }
+                    }
+                }
+            }
+        },
         "/v1/delegation": {
             "get": {
                 "description": "Retrieves a delegation by a given transaction hash",
@@ -474,6 +514,22 @@ const docTemplate = `{
                 }
             }
         },
+        "handlers.TermsAcceptancePublic": {
+            "type": "object",
+            "properties": {
+                "status": {
+                    "type": "boolean"
+                }
+            }
+        },
+        "handlers.TermsAcceptanceRequest": {
+            "type": "object",
+            "properties": {
+                "terms_accepted": {
+                    "type": "boolean"
+                }
+            }
+        },
         "handlers.UnbondDelegationRequestPayload": {
             "type": "object",
             "properties": {

docs/swagger.json

@@ -30,6 +30,46 @@
                 }
             }
         },
+        "/terms-acceptance": {
+            "post": {
+                "description": "Accept terms by the staker's BTC address (Taproot or Native Segwit)",
+                "produces": [
+                    "application/json"
+                ],
+                "parameters": [
+                    {
+                        "type": "string",
+                        "description": "Staker BTC address in Taproot/Native Segwit format",
+                        "name": "address",
+                        "in": "query",
+                        "required": true
+                    },
+                    {
+                        "description": "Terms acceptance request",
+                        "name": "terms_accepted",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/handlers.TermsAcceptanceRequest"
+                        }
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "Terms acceptance result",
+                        "schema": {
+                            "$ref": "#/definitions/handlers.TermsAcceptancePublic"
+                        }
+                    },
+                    "400": {
+                        "description": "Error: Bad Request",
+                        "schema": {
+                            "$ref": "#/definitions/github_com_babylonlabs-io_staking-api-service_internal_types.Error"
+                        }
+                    }
+                }
+            }
+        },
         "/v1/delegation": {
             "get": {
                 "description": "Retrieves a delegation by a given transaction hash",
@@ -466,6 +506,22 @@
                 }
             }
         },
+        "handlers.TermsAcceptancePublic": {
+            "type": "object",
+            "properties": {
+                "status": {
+                    "type": "boolean"
+                }
+            }
+        },
+        "handlers.TermsAcceptanceRequest": {
+            "type": "object",
+            "properties": {
+                "terms_accepted": {
+                    "type": "boolean"
+                }
+            }
+        },
         "handlers.UnbondDelegationRequestPayload": {
             "type": "object",
             "properties": {

docs/swagger.yaml

@@ -68,6 +68,16 @@ definitions:
       status:
         type: integer
     type: object
+  handlers.TermsAcceptancePublic:
+    properties:
+      status:
+        type: boolean
+    type: object
+  handlers.TermsAcceptanceRequest:
+    properties:
+      terms_accepted:
+        type: boolean
+    type: object
   handlers.UnbondDelegationRequestPayload:
     properties:
       staker_signed_signature_hex:
@@ -257,6 +267,32 @@ paths:
           schema:
             type: string
       summary: Health check endpoint
+  /terms-acceptance:
+    post:
+      description: Accept terms by the staker's BTC address (Taproot or Native Segwit)
+      parameters:
+      - description: Staker BTC address in Taproot/Native Segwit format
+        in: query
+        name: address
+        required: true
+        type: string
+      - description: Terms acceptance request
+        in: body
+        name: terms_accepted
+        required: true
+        schema:
+          $ref: '#/definitions/handlers.TermsAcceptanceRequest'
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: Terms acceptance result
+          schema:
+            $ref: '#/definitions/handlers.TermsAcceptancePublic'
+        "400":
+          description: 'Error: Bad Request'
+          schema:
+            $ref: '#/definitions/github_com_babylonlabs-io_staking-api-service_internal_types.Error'
   /v1/delegation:
     get:
       description: Retrieves a delegation by a given transaction hash

internal/api/handlers/terms.go

@@ -0,0 +1,47 @@
+package handlers
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"github.com/babylonlabs-io/staking-api-service/internal/types"
+)
+
+type TermsAcceptanceRequest struct {
+	TermsAccepted bool `json:"terms_accepted"`
+}
+
+type TermsAcceptancePublic struct {
+	Status bool `json:"status"`
+}
+
+// AcceptTerms @Summary Accept terms
+// @Description Track terms acceptance by the staker's BTC address (Taproot or Native Segwit)
+// @Produce json
+// @Param address query string true "Staker BTC address in Taproot/Native Segwit format"
+// @Param terms_accepted body TermsAcceptanceRequest true "Terms acceptance request"
+// @Success 200 {object} TermsAcceptancePublic "Terms acceptance result"
+// @Failure 400 {object} types.Error "Error: Bad Request"
+// @Router /terms-acceptance [post]
+func (h *Handler) AcceptTerms(request *http.Request) (*Result, *types.Error) {
+	address, err := parseBtcAddressQuery(request, "address", h.config.Server.BTCNetParam)
+	if err != nil {
+		return nil, err
+	}
+
+	publicKey, err := parsePublicKeyQuery(request, "public_key", false)
+	if err != nil {
+		return nil, err
+	}
+
+	var req TermsAcceptanceRequest
+	if err := json.NewDecoder(request.Body).Decode(&req); err != nil {
+		return nil, types.NewErrorWithMsg(http.StatusBadRequest, types.BadRequest, "Invalid request payload")
+	}
+
+	if err := h.services.AcceptTerms(request.Context(), address, publicKey, req.TermsAccepted); err != nil {
+		return nil, err
+	}
+
+	return NewResult(TermsAcceptancePublic{Status: true}), nil
+}

internal/api/routes.go

@@ -9,6 +9,7 @@ import (
 func (a *Server) SetupRoutes(r *chi.Mux) {
 	handlers := a.handlers
 	r.Get("/healthcheck", registerHandler(handlers.HealthCheck))
+	r.Post("/terms-acceptance", registerHandler(handlers.AcceptTerms))
 
 	r.Get("/v1/staker/delegations", registerHandler(handlers.GetStakerDelegations))
 	r.Post("/v1/unbonding", registerHandler(handlers.UnbondDelegation))

internal/db/interface.go

@@ -104,6 +104,8 @@ type DBClient interface {
 		ctx context.Context,
 		paginationToken string,
 	) (*DbResultMap[model.DelegationDocument], error)
+	// Accept terms saves the acceptance of the terms of service of the public key
+	SaveTermsAcceptance(ctx context.Context, termsAcceptance *model.TermsAcceptance) error
 }
 
 type DelegationFilter struct {

internal/db/model/setup.go

@@ -24,6 +24,7 @@ const (
 	BtcInfoCollection               = "btc_info"
 	UnprocessableMsgCollection      = "unprocessable_messages"
 	PkAddressMappingsCollection     = "pk_address_mappings"
+	TermsAcceptanceCollection       = "terms_acceptance"
 )
 
 type index struct {
@@ -48,6 +49,7 @@ var collections = map[string][]index{
 		{Indexes: map[string]int{"native_segwit_odd": 1}, Unique: true},
 		{Indexes: map[string]int{"native_segwit_even": 1}, Unique: true},
 	},
+	TermsAcceptanceCollection: {{Indexes: map[string]int{"address": 1, "public_key": 1}, Unique: true}},
 }
 
 func Setup(ctx context.Context, cfg *config.Config) error {

internal/db/model/terms.go

@@ -0,0 +1,10 @@
+package model
+
+import "time"
+
+type TermsAcceptance struct {
+	Address       string    `bson:"address"`
+	PublicKey     string    `bson:"public_key"`
+	TermsAccepted bool      `bson:"terms_accepted"`
+	UpdatedAt     time.Time `bson:"updated_at"`
+}

internal/db/terms.go

@@ -0,0 +1,28 @@
+package db
+
+import (
+	"context"
+
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo/options"
+
+	"github.com/babylonlabs-io/staking-api-service/internal/db/model"
+)
+
+func (db *Database) SaveTermsAcceptance(ctx context.Context, termsAcceptance *model.TermsAcceptance) error {
+	collection := db.Client.Database(db.DbName).Collection(model.TermsAcceptanceCollection)
+
+	filter := bson.M{
+		"address":    termsAcceptance.Address,
+		"public_key": termsAcceptance.PublicKey,
+	}
+
+	update := bson.M{
+		"$setOnInsert": termsAcceptance,
+	}
+
+	opts := options.Update().SetUpsert(true)
+
+	_, err := collection.UpdateOne(ctx, filter, update, opts)
+	return err
+}

internal/services/terms.go

@@ -0,0 +1,27 @@
+package services
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/babylonlabs-io/staking-api-service/internal/db/model"
+	"github.com/babylonlabs-io/staking-api-service/internal/types"
+)
+
+func (s *Services) AcceptTerms(ctx context.Context, address, publicKey string, termsAccepted bool) *types.Error {
+	if address == "" || publicKey == "" {
+		return types.NewErrorWithMsg(http.StatusBadRequest, types.BadRequest, "Address and public key are required")
+	}
+
+	termsAcceptance := &model.TermsAcceptance{
+		Address:       address,
+		PublicKey:     publicKey,
+		TermsAccepted: termsAccepted,
+	}
+
+	if err := s.DbClient.SaveTermsAcceptance(ctx, termsAcceptance); err != nil {
+		return types.NewInternalServiceError(err)
+	}
+
+	return nil
+}