feat: seedphrase account system + bulk-delete offline clients

api/api.go

@@ -47,10 +47,13 @@ func Routes() []*router.Route {
 		router.NewRoute("POST", "/auth/network-delete", handlers.RemoveNetwork),
 		router.NewRoute("POST", "/auth/code-create", handlers.AuthCodeCreate),
 		router.NewRoute("POST", "/auth/code-login", handlers.AuthCodeLogin),
-		router.NewRoute("POST", "/auth/upgrade-guest", handlers.UpgradeGuest),
-		router.NewRoute("POST", "/auth/upgrade-guest-existing", handlers.UpgradeGuestExisting),
+		router.NewRoute("POST", "/auth/add-auth", handlers.AuthAdd),
+		router.NewRoute("POST", "/auth/remove-auth", handlers.AuthRemove),
+		router.NewRoute("POST", "/auth/regenerate-seedphrase", handlers.AuthRegenerateSeedphrase),
+		router.NewRoute("POST", "/auth/generate-seedphrase", handlers.AuthGenerateSeedphrase),
 		router.NewRoute("POST", "/network/auth-client", handlers.AuthNetworkClient),
 		router.NewRoute("POST", "/network/remove-client", handlers.RemoveNetworkClient),
+		router.NewRoute("POST", "/network/remove-clients", handlers.RemoveNetworkClients),
 		router.NewRoute("GET", "/network/clients", handlers.NetworkClients),
 		router.NewRoute("GET", "/network/peers", handlers.NetworkPeers),
 		router.NewRoute("GET", "/network/provider-locations", handlers.NetworkGetProviderLocations),
@@ -132,6 +135,8 @@ func Routes() []*router.Route {
 		router.NewRoute("GET", "/account/referral-network", handlers.GetReferralNetwork),
 		router.NewRoute("GET", "/account/unlink-referral-network", handlers.UnlinkReferralNetwork),
 		router.NewRoute("POST", "/account/set-referral", handlers.SetNetworkReferral),
+		router.NewRoute("POST", "/account/change-name", handlers.ChangeNetworkName),
+		router.NewRoute("POST", "/account/claim-name", handlers.ClaimNetworkName),
 		router.NewRoute("GET", "/account/points", handlers.GetAccountPoints),
 		router.NewRoute("GET", "/account/balance-codes", handlers.GetNetworkRedeemedBalanceCodes),
 		router.NewRoute("POST", "/referral-code/validate", handlers.ValidateReferralCode),

api/handlers/account_handlers.go

@@ -39,3 +39,11 @@ func UnlinkReferralNetwork(w http.ResponseWriter, r *http.Request) {
 func GetNetworkRedeemedBalanceCodes(w http.ResponseWriter, r *http.Request) {
 	router.WrapRequireAuth(controller.GetNetworkRedeemedBalanceCodes, w, r)
 }
+
+func ChangeNetworkName(w http.ResponseWriter, r *http.Request) {
+	router.WrapWithInputRequireAuth(controller.ChangeNetworkName, w, r)
+}
+
+func ClaimNetworkName(w http.ResponseWriter, r *http.Request) {
+	router.WrapWithInputRequireAuth(controller.ClaimNetworkName, w, r)
+}

api/handlers/auth_handlers.go

@@ -241,3 +241,11 @@ func AuthRefreshToken(w http.ResponseWriter, r *http.Request) {
 	// router.WrapWithInputNoAuth(controller.AuthRefreshToken, w, r)
 	router.WrapRequireAuth(controller.RefreshToken, w, r)
 }
+
+func AuthAdd(w http.ResponseWriter, r *http.Request) {
+	router.WrapWithInputRequireAuth(controller.AddAuth, w, r)
+}
+
+func AuthRemove(w http.ResponseWriter, r *http.Request) {
+	router.WrapWithInputRequireAuth(controller.RemoveAuth, w, r)
+}

api/handlers/network_client_handlers.go

@@ -38,6 +38,11 @@ func RemoveNetworkClient(w http.ResponseWriter, r *http.Request) {
 	router.WrapWithInputRequireAuth(model.RemoveNetworkClient, w, r)
 }
 
+func RemoveNetworkClients(w http.ResponseWriter, r *http.Request) {
+	r.Body = http.MaxBytesReader(w, r.Body, 100<<20) // 100 MB cap (allows ~2M UUIDs worst case)
+	router.WrapWithInputRequireAuth(model.RemoveNetworkClients, w, r)
+}
+
 func RemoveNetwork(w http.ResponseWriter, r *http.Request) {
 	router.WrapRequireAuth(controller.NetworkRemove, w, r)
 }

api/handlers/network_user_handlers.go

@@ -10,11 +10,3 @@ import (
 func GetNetworkUser(w http.ResponseWriter, r *http.Request) {
 	router.WrapRequireAuth(controller.GetNetworkUser, w, r)
 }
-
-func UpgradeGuest(w http.ResponseWriter, r *http.Request) {
-	router.WrapWithInputRequireAuth(controller.UpgradeFromGuest, w, r)
-}
-
-func UpgradeGuestExisting(w http.ResponseWriter, r *http.Request) {
-	router.WrapWithInputRequireAuth(controller.UpgradeFromGuestExisting, w, r)
-}

api/handlers/seedphrase_handlers.go

@@ -0,0 +1,16 @@
+package handlers
+
+import (
+	"net/http"
+
+	"github.com/urnetwork/server/controller"
+	"github.com/urnetwork/server/router"
+)
+
+func AuthRegenerateSeedphrase(w http.ResponseWriter, r *http.Request) {
+	router.WrapWithInputRequireAuth(controller.RegenerateSeedphrase, w, r)
+}
+
+func AuthGenerateSeedphrase(w http.ResponseWriter, r *http.Request) {
+	router.WrapWithInputRequireAuth(controller.GenerateSeedphrase, w, r)
+}

api/spec_conformance_test.go

@@ -78,8 +78,10 @@ func registry() []specEndpoint {
 		{"POST", "/auth/network-delete", nil, rt(controller.NetworkRemoveResult{})},
 		{"POST", "/auth/code-create", rt(model.AuthCodeCreateArgs{}), rt(model.AuthCodeCreateResult{})},
 		{"POST", "/auth/code-login", rt(model.AuthCodeLoginArgs{}), rt(model.AuthCodeLoginResult{})},
-		{"POST", "/auth/upgrade-guest", rt(model.UpgradeGuestArgs{}), rt(model.UpgradeGuestResult{})},
-		{"POST", "/auth/upgrade-guest-existing", rt(model.UpgradeGuestExistingArgs{}), rt(model.UpgradeGuestExistingResult{})},
+		{"POST", "/auth/add-auth", rt(controller.AddAuthArgs{}), rt(controller.AddAuthResult{})},
+		{"POST", "/auth/remove-auth", rt(controller.RemoveAuthArgs{}), rt(controller.RemoveAuthResult{})},
+		{"POST", "/auth/regenerate-seedphrase", rt(controller.RegenerateSeedphraseArgs{}), rt(controller.RegenerateSeedphraseResult{})},
+		{"POST", "/auth/generate-seedphrase", rt(controller.GenerateSeedphraseArgs{}), rt(controller.GenerateSeedphraseResult{})},
 
 		{"POST", "/network/auth-client", rt(model.AuthNetworkClientArgs{}), rt(model.AuthNetworkClientResult{})},
 		{"POST", "/network/remove-client", rt(model.RemoveNetworkClientArgs{}), rt(model.RemoveNetworkClientResult{})},
@@ -146,6 +148,8 @@ func registry() []specEndpoint {
 		{"POST", "/account/wallets/verify-seeker", rt(controller.VerifySeekerNftHolderArgs{}), rt(controller.VerifySeekerNftHolderResult{})},
 		{"GET", "/account/balance-codes", nil, rt(controller.GetNetworkRedeemedBalanceCodesResult{})},
 		{"GET", "/account/referral-code", nil, rt(controller.NetworkReferralResult{})},
+		{"POST", "/account/change-name", rt(controller.ChangeNetworkNameArgs{}), rt(controller.ChangeNetworkNameResult{})},
+		{"POST", "/account/claim-name", rt(controller.ClaimNetworkNameArgs{}), rt(controller.ClaimNetworkNameResult{})},
 		{"POST", "/referral-code/validate", rt(controller.ValidateReferralCodeArgs{}), rt(controller.ValidateNetworkReferralCodeResult{})},
 		{"GET", "/account/referral-network", nil, rt(controller.GetNetworkReferralResult{})},
 		{"GET", "/account/unlink-referral-network", nil, rt(controller.UnlinkReferralNetworkResult{})},

controller/account_controller.go

@@ -0,0 +1,259 @@
+package controller
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/urnetwork/server"
+	"github.com/urnetwork/server/model"
+	"github.com/urnetwork/server/session"
+)
+
+const networkNameReclaimCooldown = 24 * time.Hour
+
+type ChangeNetworkNameArgs struct {
+	NetworkName string `json:"network_name"`
+	NewName     string `json:"new_name"`
+}
+
+type ChangeNetworkNameError struct {
+	Message string `json:"message"`
+}
+
+type ChangeNetworkNameResult struct {
+	NetworkName string                  `json:"network_name"`
+	Error       *ChangeNetworkNameError `json:"error,omitempty"`
+}
+
+type ClaimNetworkNameArgs = ChangeNetworkNameArgs
+type ClaimNetworkNameError = ChangeNetworkNameError
+type ClaimNetworkNameResult = ChangeNetworkNameResult
+
+func ChangeNetworkName(
+	args ChangeNetworkNameArgs,
+	session *session.ClientSession,
+) (*ChangeNetworkNameResult, error) {
+	return changeNetworkName(args, session, true)
+}
+
+func ClaimNetworkName(
+	args ClaimNetworkNameArgs,
+	session *session.ClientSession,
+) (*ClaimNetworkNameResult, error) {
+	return changeNetworkName(args, session, false)
+}
+
+func changeNetworkName(
+	args ChangeNetworkNameArgs,
+	session *session.ClientSession,
+	reclaimCooldown bool,
+) (*ChangeNetworkNameResult, error) {
+	// Seedphrase users must have email/phone, SSO, or a wallet bound to
+	// claim/change name — a signed wallet challenge is itself proof the
+	// user controls that identity, same as a verified email or SSO login.
+	if err := requireVerifiedIdentityBound(session.Ctx, session.ByJwt.UserId); err != nil {
+		return &ChangeNetworkNameResult{
+			Error: &ChangeNetworkNameError{
+				Message: err.Error(),
+			},
+		}, nil
+	}
+
+	// Accept either network_name or new_name field
+	name := args.NetworkName
+	if name == "" {
+		name = args.NewName
+	}
+	normalizedName, err := model.ValidateNetworkName(name)
+	if err != nil {
+		return &ChangeNetworkNameResult{
+			Error: &ChangeNetworkNameError{
+				Message: err.Error(),
+			},
+		}, nil
+	}
+
+	available, err := isNetworkNameAvailableForUser(session.Ctx, normalizedName, session.ByJwt.UserId)
+	if err != nil {
+		return nil, err
+	}
+	if !available {
+		return &ChangeNetworkNameResult{
+			Error: &ChangeNetworkNameError{
+				Message: "Network name not available.",
+			},
+		}, nil
+	}
+
+	// Claim (first-time name set, reachable once per account) and change
+	// (renaming an existing name) get separate daily budgets: bundling them
+	// would let a normal onboarding claim consume half of a new user's
+	// same-day rename budget before they've even picked a real name.
+	rateLimitAction := model.AccountActionClaimNetworkName
+	rateLimitDailyLimit := model.AccountActionClaimNetworkNameDailyLimit
+	if reclaimCooldown {
+		rateLimitAction = model.AccountActionChangeNetworkName
+		rateLimitDailyLimit = model.AccountActionChangeNetworkNameDailyLimit
+	}
+	if err := model.CheckAndRecordAccountActionRateLimit(
+		session.Ctx,
+		session.ByJwt.UserId,
+		rateLimitAction,
+		rateLimitDailyLimit,
+		model.AccountActionDailyWindow,
+	); err != nil {
+		return &ChangeNetworkNameResult{
+			Error: &ChangeNetworkNameError{
+				Message: err.Error(),
+			},
+		}, nil
+	}
+
+	var oldName *string
+	server.Db(session.Ctx, func(conn server.PgConn) {
+		result, err := conn.Query(
+			session.Ctx,
+			`
+			SELECT network_name FROM network
+			WHERE admin_user_id = $1
+			`,
+			session.ByJwt.UserId,
+		)
+		server.WithPgResult(result, err, func() {
+			if result.Next() {
+				var name string
+				server.Raise(result.Scan(&name))
+				oldName = &name
+			}
+		})
+	})
+
+	server.Tx(session.Ctx, func(tx server.PgTx) {
+		if reclaimCooldown && oldName != nil && *oldName != normalizedName {
+			coolDownUntil := server.NowUtc().Add(networkNameReclaimCooldown)
+			server.RaisePgResult(tx.Exec(
+				session.Ctx,
+				`
+					INSERT INTO network_name_reclaim (old_name, cool_down_until)
+					VALUES ($1, $2)
+					ON CONFLICT (old_name) DO UPDATE
+					SET cool_down_until = EXCLUDED.cool_down_until
+				`,
+				*oldName,
+				coolDownUntil,
+			))
+		}
+
+		server.RaisePgResult(tx.Exec(
+			session.Ctx,
+			`
+				UPDATE network
+				SET network_name = $2
+				WHERE admin_user_id = $1
+			`,
+			session.ByJwt.UserId,
+			normalizedName,
+		))
+	})
+
+	return &ChangeNetworkNameResult{
+		NetworkName: normalizedName,
+	}, nil
+}
+
+func isNetworkNameAvailableForUser(
+	ctx context.Context,
+	name string,
+	userId server.Id,
+) (bool, error) {
+	available := true
+	reasonErr := error(nil)
+
+	server.Db(ctx, func(conn server.PgConn) {
+		// check if the name is taken by another network
+		result, err := conn.Query(
+			ctx,
+			`
+				SELECT admin_user_id FROM network
+				WHERE network_name = $1
+			`,
+			name,
+		)
+		server.WithPgResult(result, err, func() {
+			if result.Next() {
+				var owner server.Id
+				server.Raise(result.Scan(&owner))
+				if owner != userId {
+					available = false
+				}
+			}
+		})
+
+		if !available {
+			return
+		}
+
+		// check if the name is in cooldown (network_name_reclaim)
+		result, err = conn.Query(
+			ctx,
+			`
+				SELECT cool_down_until FROM network_name_reclaim
+				WHERE old_name = $1
+			`,
+			name,
+		)
+		server.WithPgResult(result, err, func() {
+			if result.Next() {
+				var coolDownUntil time.Time
+				server.Raise(result.Scan(&coolDownUntil))
+				if server.NowUtc().Before(coolDownUntil) {
+					available = false
+				}
+			}
+		})
+	})
+
+	if reasonErr != nil {
+		return false, fmt.Errorf("failed to check network name availability: %w", reasonErr)
+	}
+
+	return available, nil
+}
+
+// requireVerifiedIdentityBound checks that the user has at least one verified
+// email/phone password auth, SSO auth, or wallet bound. Seedphrase-only users
+// can't claim/change names — they need a verifiable identity method.
+func requireVerifiedIdentityBound(ctx context.Context, userId server.Id) error {
+	var hasBoundAuth bool
+
+	server.Db(ctx, func(conn server.PgConn) {
+		result, err := conn.Query(
+			ctx,
+			`
+				SELECT EXISTS (
+					SELECT 1 FROM network_user_auth_password
+					WHERE user_id = $1 AND verified = true
+					UNION ALL
+					SELECT 1 FROM network_user_auth_sso
+					WHERE user_id = $1
+					UNION ALL
+					SELECT 1 FROM network_user_auth_wallet
+					WHERE user_id = $1
+				)
+			`,
+			userId,
+		)
+		server.WithPgResult(result, err, func() {
+			if result.Next() {
+				server.Raise(result.Scan(&hasBoundAuth))
+			}
+		})
+	})
+
+	if !hasBoundAuth {
+		return fmt.Errorf("You must verify an email, bind a social login, or connect a wallet before changing your network name.")
+	}
+
+	return nil
+}