update handle resolution to use new well-known method

api/atproto/identityresolveHandle.go

···
-// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
-
-package atproto
-
-// schema: com.atproto.identity.resolveHandle
-
-import (
-	"context"
-
-	"github.com/bluesky-social/indigo/xrpc"
-)
-
-// IdentityResolveHandle_Output is the output of a com.atproto.identity.resolveHandle call.
-type IdentityResolveHandle_Output struct {
-	Did string `json:"did" cborgen:"did"`
-}
-
-// IdentityResolveHandle calls the XRPC method "com.atproto.identity.resolveHandle".
-//
-// handle: The handle to resolve. If not supplied, will resolve the host's own handle.
-func IdentityResolveHandle(ctx context.Context, c *xrpc.Client, handle string) (*IdentityResolveHandle_Output, error) {
-	var out IdentityResolveHandle_Output
-
-	params := map[string]interface{}{
-		"handle": handle,
-	}
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.identity.resolveHandle", params, nil, &out); err != nil {
-		return nil, err
-	}
-
-	return &out, nil
-}

api/extra.go

···
 import (
 	"context"
 	"fmt"
+	"io/ioutil"
+	"net"
+	"net/http"
 	"net/url"
+	"strings"
 
-	comatproto "github.com/bluesky-social/indigo/api/atproto"
 	"github.com/bluesky-social/indigo/did"
 	"github.com/bluesky-social/indigo/xrpc"
+	logging "github.com/ipfs/go-log"
 	otel "go.opentelemetry.io/otel"
 )
 
-func ResolveDidToHandle(ctx context.Context, xrpcc *xrpc.Client, res did.Resolver, udid string) (string, string, error) {
+var log = logging.Logger("api")
+
+func ResolveDidToHandle(ctx context.Context, xrpcc *xrpc.Client, res did.Resolver, hr HandleResolver, udid string) (string, string, error) {
 	ctx, span := otel.Tracer("gosky").Start(ctx, "resolveDidToHandle")
 	defer span.End()
 
···
 		return "", "", fmt.Errorf("our XRPC client is authed for a different pds (%s != %s)", svc.ServiceEndpoint, xrpcc.Host)
 	}
 
-	verdid, err := comatproto.IdentityResolveHandle(ctx, xrpcc, handle)
+	verdid, err := hr.ResolveHandleToDid(ctx, handle)
 	if err != nil {
 		return "", "", err
 	}
 
-	if verdid.Did != udid {
+	if verdid != udid {
 		return "", "", fmt.Errorf("pds server reported different did for claimed handle")
 	}
 
 	return handle, svc.ServiceEndpoint, nil
 }
+
+type HandleResolver interface {
+	ResolveHandleToDid(ctx context.Context, handle string) (string, error)
+}
+
+type ProdHandleResolver struct {
+}
+
+func (dr *ProdHandleResolver) ResolveHandleToDid(ctx context.Context, handle string) (string, error) {
+	c := http.DefaultClient
+
+	resp, wkerr := c.Get(fmt.Sprintf("https://%s/.well-known/atproto-did", handle))
+	if wkerr == nil && resp.StatusCode == 200 {
+		b, err := ioutil.ReadAll(resp.Body)
+		if err != nil {
+			return "", fmt.Errorf("failed to read resolved did: %w", err)
+		}
+
+		parsed, err := did.ParseDID(string(b))
+		if err != nil {
+			return "", err
+		}
+
+		return parsed.String(), nil
+	}
+	log.Infof("failed to resolve handle (%s) through well-known route: %s", handle, wkerr)
+
+	res, err := net.LookupTXT("_atproto." + handle)
+	if err != nil {
+		return "", fmt.Errorf("handle lookup failed: %w", err)
+	}
+
+	for _, s := range res {
+		if strings.HasPrefix(s, "did=") {
+			parts := strings.Split(s, "=")
+			pdid, err := did.ParseDID(parts[1])
+			if err != nil {
+				return "", fmt.Errorf("invalid did in record: %w", err)
+			}
+
+			return pdid.String(), nil
+		}
+	}
+
+	return "", fmt.Errorf("no did record found for handle %q", handle)
+}
+
+type TestHandleResolver struct {
+	TrialHosts []string
+}
+
+func (tr *TestHandleResolver) ResolveHandleToDid(ctx context.Context, handle string) (string, error) {
+	c := http.DefaultClient
+
+	for _, h := range tr.TrialHosts {
+		req, err := http.NewRequest("GET", fmt.Sprintf("http://%s/.well-known/atproto-did", h), nil)
+		if err != nil {
+			return "", err
+		}
+
+		req.Host = handle
+
+		resp, err := c.Do(req)
+		if err != nil {
+			log.Warnf("failed to get did: %s", err)
+			continue
+		}
+
+		if resp.StatusCode != 200 {
+			log.Warnf("got non-200 status code while fetching did: %d", resp.StatusCode)
+			continue
+		}
+
+		b, err := ioutil.ReadAll(resp.Body)
+		if err != nil {
+			return "", fmt.Errorf("failed to read resolved did: %w", err)
+		}
+
+		parsed, err := did.ParseDID(string(b))
+		if err != nil {
+			return "", err
+		}
+
+		return parsed.String(), nil
+	}
+
+	return "", fmt.Errorf("no did record found for handle %q", handle)
+}

bgs/bgs.go

···
 	"time"
 
 	"contrib.go.opencensus.io/exporter/prometheus"
+	"github.com/bluesky-social/indigo/api"
 	atproto "github.com/bluesky-social/indigo/api/atproto"
 	comatproto "github.com/bluesky-social/indigo/api/atproto"
 	"github.com/bluesky-social/indigo/blobs"
···
 	didr    did.Resolver
 
 	blobs blobs.BlobStore
+	hr    api.HandleResolver
+
+	// TODO: work on doing away with this flag in favor of more pluggable
+	// pieces that abstract the need for explicit ssl checks
+	ssl bool
 
 	crawlOnly bool
 
···
 	repoman *repomgr.RepoManager
 }
 
-func NewBGS(db *gorm.DB, ix *indexer.Indexer, repoman *repomgr.RepoManager, evtman *events.EventManager, didr did.Resolver, blobs blobs.BlobStore, ssl bool) (*BGS, error) {
+func NewBGS(db *gorm.DB, ix *indexer.Indexer, repoman *repomgr.RepoManager, evtman *events.EventManager, didr did.Resolver, blobs blobs.BlobStore, hr api.HandleResolver, ssl bool) (*BGS, error) {
 	db.AutoMigrate(User{})
 	db.AutoMigrate(AuthToken{})
 	db.AutoMigrate(models.PDS{})
···
 		Index: ix,
 		db:    db,
 
+		hr:      hr,
 		repoman: repoman,
 		events:  evtman,
 		didr:    didr,
···
 		peering.Host = durl.Host
 		peering.SSL = (durl.Scheme == "https")
 
+		if s.ssl != peering.SSL {
+			return nil, fmt.Errorf("did references non-ssl PDS, this is disallowed in prod: %q %q", did, svc.ServiceEndpoint)
+		}
+
 		if err := s.db.Create(&peering).Error; err != nil {
 			return nil, err
 		}
···
 
 	handle := hurl.Host
 
-	res, err := atproto.IdentityResolveHandle(ctx, c, handle)
+	resdid, err := s.hr.ResolveHandleToDid(ctx, handle)
 	if err != nil {
 		return nil, fmt.Errorf("failed to resolve users claimed handle (%q) on pds: %w", handle, err)
 	}
 
-	if res.Did != did {
-		return nil, fmt.Errorf("claimed handle did not match servers response (%s != %s)", res.Did, did)
+	if resdid != did {
+		return nil, fmt.Errorf("claimed handle did not match servers response (%s != %s)", resdid, did)
 	}
 
 	s.extUserLk.Lock()

cmd/bigsky/main.go

···
 			blobstore = &blobs.DiskBlobStore{bsdir}
 		}
 
-		bgs, err := bgs.NewBGS(db, ix, repoman, evtman, cachedidr, blobstore, !cctx.Bool("crawl-insecure-ws"))
+		var hr api.HandleResolver = &api.ProdHandleResolver{}
+		if cctx.Bool("crawl-insecure-ws") {
+			hr = &api.TestHandleResolver{}
+		}
+
+		bgs, err := bgs.NewBGS(db, ix, repoman, evtman, cachedidr, blobstore, hr, !cctx.Bool("crawl-insecure-ws"))
 		if err != nil {
 			return err
 		}

cmd/gosky/admin.go

···
 
 		ctx := context.Background()
 
-		resp, err := atproto.IdentityResolveHandle(ctx, xrpcc, cctx.Args().First())
+		phr := &api.ProdHandleResolver{}
+
+		rdid, err := phr.ResolveHandleToDid(ctx, cctx.Args().First())
 		if err != nil {
 			return fmt.Errorf("resolve handle %q: %w", cctx.Args().First(), err)
 		}
···
 		adminKey := cctx.String("admin-password")
 		xrpcc.AdminToken = &adminKey
 
-		rep, err := atproto.AdminGetRepo(ctx, xrpcc, resp.Did)
+		rep, err := atproto.AdminGetRepo(ctx, xrpcc, rdid)
 		if err != nil {
-			return fmt.Errorf("getRepo %s: %w", resp.Did, err)
+			return fmt.Errorf("getRepo %s: %w", rdid, err)
 		}
 
 		b, err := json.MarshalIndent(rep, "", "  ")
···
 				if fa == "admin" {
 					invby = fa
 				} else {
-					handle, _, err := api.ResolveDidToHandle(ctx, xrpcc, plcc, fa)
+					handle, _, err := api.ResolveDidToHandle(ctx, xrpcc, plcc, phr, fa)
 					if err != nil {
 						return fmt.Errorf("resolve did %q: %w", fa, err)
 					}
···
 		&cli.BoolFlag{
 			Name: "raw",
 		},
+		&cli.BoolFlag{
+			Name:  "resolved",
+			Value: true,
+		},
+		&cli.BoolFlag{
+			Name: "template-output",
+		},
 	},
 	Action: func(cctx *cli.Context) error {
 		xrpcc, err := cliutil.GetXrpcClient(cctx, false)
···
 		adminKey := cctx.String("admin-password")
 		xrpcc.AdminToken = &adminKey
 
-		resp, err := atproto.AdminGetModerationReports(ctx, xrpcc, "", "", 100, true, "")
+		resp, err := atproto.AdminGetModerationReports(ctx, xrpcc, "", "", 100, cctx.Bool("resolved"), "")
 		if err != nil {
 			return err
 		}
···
 		adminKey := cctx.String("admin-password")
 		xrpcc.AdminToken = &adminKey
 
+		phr := &api.ProdHandleResolver{}
 		handle := cctx.Args().First()
 		if !strings.HasPrefix(handle, "did:") {
-			resp, err := atproto.IdentityResolveHandle(ctx, xrpcc, handle)
+			resp, err := phr.ResolveHandleToDid(ctx, handle)
 			if err != nil {
 				return err
 			}
 
-			handle = resp.Did
+			handle = resp
 		}
 
 		return atproto.AdminDisableAccountInvites(ctx, xrpcc, &atproto.AdminDisableAccountInvites_Input{
···
 
 		handle := cctx.Args().First()
 		if !strings.HasPrefix(handle, "did:") {
-			resp, err := atproto.IdentityResolveHandle(ctx, xrpcc, handle)
+			phr := &api.ProdHandleResolver{}
+			resp, err := phr.ResolveHandleToDid(ctx, handle)
 			if err != nil {
 				return err
 			}
 
-			handle = resp.Did
+			handle = resp
 		}
 
 		return atproto.AdminEnableAccountInvites(ctx, xrpcc, &atproto.AdminEnableAccountInvites_Input{

cmd/gosky/debug.go

···
 	"encoding/json"
 	"fmt"
 	"io"
+	"io/ioutil"
 	"net/http"
+	"os"
+	"os/signal"
 	"strconv"
+	"strings"
+	"syscall"
 
 	"github.com/bluesky-social/indigo/api/atproto"
 	comatproto "github.com/bluesky-social/indigo/api/atproto"
···
 		inspectEventCmd,
 		debugStreamCmd,
 		debugFeedGenCmd,
+		debugFeedViewCmd,
+		compareStreamsCmd,
 	},
 }
 
···
 							es = evt.Prev.String()
 						}
 
-						if cs != es {
+						if !evt.Rebase && cs != es {
 							fmt.Printf("\nEvent at sequence %d has mismatch between slice prev and struct prev: %s != %s\n", evt.Seq, prev, evt.Prev)
 						}
 					}
···
 	},
 }
 
+var compareStreamsCmd = &cli.Command{
+	Name: "compare-streams",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:     "host1",
+			Required: true,
+		},
+		&cli.StringFlag{
+			Name:     "host2",
+			Required: true,
+		},
+	},
+	ArgsUsage: `<cursor>`,
+	Action: func(cctx *cli.Context) error {
+		h1 := cctx.String("host1")
+		h2 := cctx.String("host2")
+
+		url1 := fmt.Sprintf("%s/xrpc/com.atproto.sync.subscribeRepos", h1)
+		url2 := fmt.Sprintf("%s/xrpc/com.atproto.sync.subscribeRepos", h2)
+
+		d := websocket.DefaultDialer
+
+		eventChans := []chan *comatproto.SyncSubscribeRepos_Commit{
+			make(chan *comatproto.SyncSubscribeRepos_Commit, 2),
+			make(chan *comatproto.SyncSubscribeRepos_Commit, 2),
+		}
+
+		buffers := []map[string][]*comatproto.SyncSubscribeRepos_Commit{
+			make(map[string][]*comatproto.SyncSubscribeRepos_Commit),
+			make(map[string][]*comatproto.SyncSubscribeRepos_Commit),
+		}
+
+		addToBuffer := func(n int, event *comatproto.SyncSubscribeRepos_Commit) {
+			buffers[n][event.Repo] = append(buffers[n][event.Repo], event)
+		}
+
+		pll := func(ll *lexutil.LexLink) string {
+			if ll == nil {
+				return "<nil>"
+			}
+			return ll.String()
+		}
+
+		findMatchAndRemove := func(n int, event *comatproto.SyncSubscribeRepos_Commit) (*comatproto.SyncSubscribeRepos_Commit, error) {
+			buf := buffers[n]
+			slice, ok := buf[event.Repo]
+			if !ok || len(slice) == 0 {
+				return nil, nil
+			}
+
+			for i, ev := range slice {
+				if ev.Commit == event.Commit {
+					if pll(ev.Prev) != pll(event.Prev) {
+						// same commit different prev??
+						return nil, fmt.Errorf("matched event with same commit but different prev: (%d) %d - %d", n, ev.Seq, event.Seq)
+					}
+				}
+
+				if i != 0 {
+					fmt.Printf("detected skipped event: %d (%d)\n", slice[0].Seq, i)
+				}
+
+				slice = slice[i+1:]
+				buf[event.Repo] = slice
+				return ev, nil
+			}
+
+			return nil, fmt.Errorf("did not find matching event despite having events in buffer")
+		}
+
+		printCurrentDelta := func() {
+			var a, b int
+			for _, sl := range buffers[0] {
+				a += len(sl)
+			}
+			for _, sl := range buffers[1] {
+				b += len(sl)
+			}
+
+			fmt.Printf("%d %d\n", a, b)
+		}
+
+		printDetailedDelta := func() {
+			for did, sl := range buffers[0] {
+				osl := buffers[1][did]
+				if len(osl) > 0 && len(sl) > 0 {
+					fmt.Printf("%s had mismatched events on both streams (%d, %d)\n", did, len(sl), len(osl))
+				}
+
+			}
+		}
+
+		// Create two goroutines for reading events from two URLs
+		for i, url := range []string{url1, url2} {
+			go func(i int, url string) {
+				con, _, err := d.Dial(url, http.Header{})
+				if err != nil {
+					log.Fatalf("Dial failure on url%d: %s", i+1, err)
+				}
+
+				ctx := context.TODO()
+				rsc := &events.RepoStreamCallbacks{
+					RepoCommit: func(evt *comatproto.SyncSubscribeRepos_Commit) error {
+						eventChans[i] <- evt
+						return nil
+					},
+					// TODO: all the other Repo* event types
+					Error: func(evt *events.ErrorFrame) error {
+						return fmt.Errorf("%s: %s", evt.Error, evt.Message)
+					},
+				}
+				if err := events.HandleRepoStream(ctx, con, &events.SequentialScheduler{rsc.EventHandler}); err != nil {
+					log.Fatalf("HandleRepoStream failure on url%d: %s", i+1, err)
+				}
+			}(i, url)
+		}
+
+		ch := make(chan os.Signal, 1)
+		signal.Notify(ch, syscall.SIGTERM, syscall.SIGINT)
+
+		// Compare events from the two URLs
+		for {
+			select {
+			case event := <-eventChans[0]:
+				partner, err := findMatchAndRemove(1, event)
+				if err != nil {
+					fmt.Println("checking for match failed: ", err)
+					continue
+				}
+				if partner == nil {
+					addToBuffer(0, event)
+				} else {
+					// the good case
+					fmt.Println("Match found")
+				}
+
+			case event := <-eventChans[1]:
+				partner, err := findMatchAndRemove(0, event)
+				if err != nil {
+					fmt.Println("checking for match failed: ", err)
+					continue
+				}
+				if partner == nil {
+					addToBuffer(1, event)
+				} else {
+					// the good case
+					fmt.Println("Match found")
+				}
+			case <-ch:
+				printDetailedDelta()
+				/*
+					b, err := json.Marshal(buffers)
+					if err != nil {
+						return err
+					}
+
+					fmt.Println(string(b))
+				*/
+				return nil
+			}
+
+			printCurrentDelta()
+		}
+		return nil
+	},
+}
+
 var debugFeedGenCmd = &cli.Command{
 	Name: "debug-feed",
 	Action: func(cctx *cli.Context) error {
···
 		return nil
 	},
 }
+var debugFeedViewCmd = &cli.Command{
+	Name: "viewFeed",
+	Action: func(cctx *cli.Context) error {
+		xrpcc, err := cliutil.GetXrpcClient(cctx, true)
+		if err != nil {
+			return err
+		}
+
+		didr := cliutil.GetDidResolver(cctx)
+
+		uri := cctx.Args().First()
+		puri, err := util.ParseAtUri(uri)
+		if err != nil {
+			return err
+		}
+
+		ctx := context.TODO()
+
+		out, err := atproto.RepoGetRecord(ctx, xrpcc, "", puri.Collection, puri.Did, puri.Rkey)
+		if err != nil {
+			return fmt.Errorf("getting record: %w", err)
+		}
+
+		fgr, ok := out.Value.Val.(*bsky.FeedGenerator)
+		if !ok {
+			return fmt.Errorf("invalid feedgen record")
+		}
+
+		doc, err := didr.GetDocument(ctx, fgr.Did)
+		if err != nil {
+			return err
+		}
+
+		var ss *did.Service
+		for _, s := range doc.Service {
+			if s.ID.String() == "#bsky_fg" {
+				cp := s
+				ss = &cp
+				break
+			}
+		}
+
+		if ss == nil {
+			return fmt.Errorf("No '#bsky_fg' service entry found in feedgens DID document")
+		}
+
+		fgclient := &xrpc.Client{
+			Host: ss.ServiceEndpoint,
+		}
+
+		cache, err := loadCache("postcache.json")
+		if err != nil {
+			return err
+		}
+		var cacheUpdate bool
+
+		var cursor string
+		getPage := func(curs string) ([]*bsky.FeedDefs_PostView, error) {
+			skel, err := bsky.FeedGetFeedSkeleton(ctx, fgclient, cursor, uri, 30)
+			if err != nil {
+				return nil, fmt.Errorf("failed to fetch feed skeleton: %w", err)
+			}
+
+			if skel.Cursor != nil {
+				cursor = *skel.Cursor
+			}
+
+			var posts []*bsky.FeedDefs_PostView
+			for _, fp := range skel.Feed {
+				cached, ok := cache[fp.Post]
+				if ok {
+					posts = append(posts, cached)
+					continue
+				}
+				fps, err := bsky.FeedGetPosts(ctx, xrpcc, []string{fp.Post})
+				if err != nil {
+					return nil, err
+				}
+
+				if len(fps.Posts) == 0 {
+					fmt.Println("FAILED TO GET POST: ", fp.Post)
+					continue
+				}
+				p := fps.Posts[0]
+				rec := p.Record.Val.(*bsky.FeedPost)
+				rec.Embed = nil // nil out embeds since they sometimes fail to json marshal...
+				posts = append(posts, p)
+				cache[fp.Post] = p
+				cacheUpdate = true
+			}
+
+			return posts, nil
+		}
+
+		printPosts := func(posts []*bsky.FeedDefs_PostView) {
+			for _, p := range posts {
+				text := p.Record.Val.(*bsky.FeedPost).Text
+				text = strings.Replace(text, "\n", " ", -1)
+				if len(text) > 70 {
+					text = text[:70] + "..."
+				}
+				fmt.Printf("%s: %s\n", *p.Author.DisplayName, text)
+			}
+		}
+
+		seen := make(map[string]bool)
+		for i := 1; i < 5; i++ {
+			fmt.Printf("PAGE %d - cursor: %s\n", i, cursor)
+			posts, err := getPage(cursor)
+			if err != nil {
+				return err
+			}
+			var alreadySeen int
+			for _, p := range posts {
+				if seen[p.Uri] {
+					alreadySeen++
+				}
+				seen[p.Uri] = true
+			}
+			fmt.Printf("Already saw %d / %d posts in page 1\n", alreadySeen, len(posts))
+			printPosts(posts)
+			fmt.Println("")
+			fmt.Println("")
+		}
+
+		if cacheUpdate {
+			if err := saveCache("postcache.json", cache); err != nil {
+				return err
+			}
+		}
+
+		return nil
+	},
+}
+
+func loadCache(filename string) (map[string]*bsky.FeedDefs_PostView, error) {
+	var data map[string]*bsky.FeedDefs_PostView
+
+	jsonFile, err := os.Open(filename)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return make(map[string]*bsky.FeedDefs_PostView), nil
+		}
+
+		return nil, fmt.Errorf("failed to open file: %w", err)
+	}
+	defer jsonFile.Close()
+
+	byteValue, err := ioutil.ReadAll(jsonFile)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read file: %w", err)
+	}
+
+	err = json.Unmarshal(byteValue, &data)
+	if err != nil {
+		return nil, fmt.Errorf("failed to unmarshal json: %w", err)
+	}
+
+	return data, nil
+}
+
+func saveCache(filename string, data map[string]*bsky.FeedDefs_PostView) error {
+	file, err := json.MarshalIndent(data, "", " ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal json: %w", err)
+	}
+
+	err = ioutil.WriteFile(filename, file, 0644)
+	if err != nil {
+		return fmt.Errorf("failed to write file: %w", err)
+	}
+
+	return nil
+}

cmd/gosky/main.go

···
 				return err
 			}
 
-			h, _, err := api.ResolveDidToHandle(context.TODO(), xrpcc, s, did)
+			phr := &api.ProdHandleResolver{}
+			h, _, err := api.ResolveDidToHandle(context.TODO(), xrpcc, s, phr, did)
 			if err != nil {
 				return err
 			}
···
 	Action: func(cctx *cli.Context) error {
 		ctx := context.TODO()
 
-		xrpcc, err := cliutil.GetXrpcClient(cctx, false)
-		if err != nil {
-			return err
-		}
-
 		args, err := needArgs(cctx, "handle")
 		if err != nil {
 			return err
 		}
 		handle := args[0]
 
-		out, err := comatproto.IdentityResolveHandle(ctx, xrpcc, handle)
+		phr := &api.ProdHandleResolver{}
+		out, err := phr.ResolveHandleToDid(ctx, handle)
 		if err != nil {
 			return err
 		}
 
-		fmt.Println(out.Did)
+		fmt.Println(out)
 
 		return nil
 	},
···
 		count := cctx.Int("useCount")
 		num := cctx.Int("num")
 
+		phr := &api.ProdHandleResolver{}
 		if bulkfi := cctx.String("bulk"); bulkfi != "" {
 			xrpcc.AdminToken = &adminKey
 			dids, err := readDids(bulkfi)
···
 
 			for i, d := range dids {
 				if !strings.HasPrefix(d, "did:plc:") {
-					out, err := comatproto.IdentityResolveHandle(context.TODO(), xrpcc, d)
+					out, err := phr.ResolveHandleToDid(context.TODO(), d)
 					if err != nil {
 						return fmt.Errorf("failed to resolve %q: %w", d, err)
 					}
 
-					dids[i] = out.Did
+					dids[i] = out
 				}
 			}
 
···
 		var usrdid []string
 		if forUser := cctx.Args().Get(0); forUser != "" {
 			if !strings.HasPrefix(forUser, "did:") {
-				resp, err := comatproto.IdentityResolveHandle(context.TODO(), xrpcc, forUser)
+				resp, err := phr.ResolveHandleToDid(context.TODO(), forUser)
 				if err != nil {
 					return fmt.Errorf("resolving handle: %w", err)
 				}
 
-				usrdid = []string{resp.Did}
+				usrdid = []string{resp}
 			} else {
 				usrdid = []string{forUser}
 			}

did/alias.go

···
 type Document = did.Document
 
 type Service = did.Service
+
+var ParseDID = did.ParseDID

labeler/xrpc_endpoints.go

···
 
 func (s *Server) RegisterHandlersComAtproto(e *echo.Echo) error {
 	// handle/account hosting
-	e.GET("/xrpc/com.atproto.identity.resolveHandle", s.HandleComAtprotoIdentityResolveHandle)
 	e.GET("/xrpc/com.atproto.server.describeServer", s.HandleComAtprotoServerDescribeServer)
 	// TODO: session create/refresh/delete?
 
···
 	e.GET("/xrpc/com.atproto.admin.searchRepos", echo.WrapHandler(rp))
 
 	return nil
-}
-
-func (s *Server) HandleComAtprotoIdentityResolveHandle(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoIdentityResolveHandle")
-	defer span.End()
-	handle := c.QueryParam("handle")
-	var out *atproto.IdentityResolveHandle_Output
-	var handleErr error
-	// func (s *Server) handleComAtprotoIdentityResolveHandle(ctx context.Context,handle string) (*atproto.IdentityResolveHandle_Output, error)
-	out, handleErr = s.handleComAtprotoIdentityResolveHandle(ctx, handle)
-	if handleErr != nil {
-		return handleErr
-	}
-	return c.JSON(200, out)
 }
 
 func (s *Server) HandleComAtprotoServerDescribeServer(c echo.Context) error {

labeler/xrpc_handlers.go

···
 	"gorm.io/gorm"
 )
 
-func (s *Server) handleComAtprotoIdentityResolveHandle(ctx context.Context, handle string) (*atproto.IdentityResolveHandle_Output, error) {
-	// only the one handle, for labelmaker
-	if handle == "" {
-		return &atproto.IdentityResolveHandle_Output{Did: s.user.SigningKey.Public().DID()}, nil
-	} else if handle == s.user.Handle {
-		return &atproto.IdentityResolveHandle_Output{Did: s.user.Did}, nil
-	} else {
-		return nil, echo.NewHTTPError(404, "user not found: %s", handle)
-	}
-}
-
 func (s *Server) handleComAtprotoServerDescribeServer(ctx context.Context) (*atproto.ServerDescribeServer_Output, error) {
 	invcode := true
 	return &atproto.ServerDescribeServer_Output{

pds/handlers.go

···
 	panic("not yet implemented")
 }
 
-func (s *Server) handleComAtprotoIdentityResolveHandle(ctx context.Context, handle string) (*comatprototypes.IdentityResolveHandle_Output, error) {
-	if handle == "" {
-		return &comatprototypes.IdentityResolveHandle_Output{Did: s.signingKey.Public().DID()}, nil
-	}
-	u, err := s.lookupUserByHandle(ctx, handle)
-	if err != nil {
-		return nil, err
-	}
-
-	return &comatprototypes.IdentityResolveHandle_Output{Did: u.Did}, nil
-}
-
 func (s *Server) handleComAtprotoRepoApplyWrites(ctx context.Context, body *comatprototypes.RepoApplyWrites_Input) error {
 	u, err := s.getUser(ctx)
 	if err != nil {

pds/server.go

···
 	"strings"
 	"time"
 
+	"github.com/bluesky-social/indigo/api/atproto"
 	comatproto "github.com/bluesky-social/indigo/api/atproto"
 	bsky "github.com/bluesky-social/indigo/api/bsky"
 	"github.com/bluesky-social/indigo/carstore"
···
 	c := &xrpc.Client{Host: svc.ServiceEndpoint}
 
 	if peering.ID == 0 {
-		pdsdid, err := comatproto.IdentityResolveHandle(ctx, c, "")
+		cfg, err := atproto.ServerDescribeServer(ctx, c)
 		if err != nil {
 			// TODO: failing this shouldnt halt our indexing
-			return nil, fmt.Errorf("failed to get accounts config for unrecognized pds: %w", err)
+			return nil, fmt.Errorf("failed to check unrecognized pds: %w", err)
 		}
 
+		// since handles can be anything, checking against this list doesnt matter...
+		_ = cfg
+
 		// TODO: could check other things, a valid response is good enough for now
 		peering.Host = svc.ServiceEndpoint
-		peering.Did = pdsdid.Did
 
 		if err := s.db.Create(&peering).Error; err != nil {
 			return nil, err
···
 				ctx = context.WithValue(ctx, "auth", auth)
 				c.SetRequest(c.Request().WithContext(ctx))
 				return true
+			case "/.well-known/atproto-did":
+				return true
 			default:
 				return false
 			}
···
 	s.RegisterHandlersAppBsky(e)
 	e.GET("/xrpc/com.atproto.sync.subscribeRepos", s.EventsHandler)
 	e.GET("/xrpc/_health", s.HandleHealthCheck)
+	e.GET("/.well-known/atproto-did", s.HandleResolveDid)
 
 	// In order to support booting on random ports in tests, we need to tell the
 	// Echo instance it's already got a port, and then use its StartServer
···
 	} else {
 		return c.JSON(200, HealthStatus{Status: "ok"})
 	}
+}
+
+func (s *Server) HandleResolveDid(c echo.Context) error {
+	ctx := c.Request().Context()
+
+	handle := c.Request().Host
+	if hh := c.Request().Header.Get("Host"); hh != "" {
+		handle = hh
+	}
+
+	u, err := s.lookupUserByHandle(ctx, handle)
+	if err != nil {
+		return fmt.Errorf("resolving %q: %w", handle, err)
+	}
+
+	return c.String(200, u.Did)
 }
 
 type User struct {

pds/stubs.go

···
 	e.POST("/xrpc/com.atproto.admin.takeModerationAction", s.HandleComAtprotoAdminTakeModerationAction)
 	e.POST("/xrpc/com.atproto.admin.updateAccountEmail", s.HandleComAtprotoAdminUpdateAccountEmail)
 	e.POST("/xrpc/com.atproto.admin.updateAccountHandle", s.HandleComAtprotoAdminUpdateAccountHandle)
-	e.GET("/xrpc/com.atproto.identity.resolveHandle", s.HandleComAtprotoIdentityResolveHandle)
 	e.POST("/xrpc/com.atproto.identity.updateHandle", s.HandleComAtprotoIdentityUpdateHandle)
 	e.GET("/xrpc/com.atproto.label.queryLabels", s.HandleComAtprotoLabelQueryLabels)
 	e.POST("/xrpc/com.atproto.moderation.createReport", s.HandleComAtprotoModerationCreateReport)
···
 		return handleErr
 	}
 	return nil
-}
-
-func (s *Server) HandleComAtprotoIdentityResolveHandle(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoIdentityResolveHandle")
-	defer span.End()
-	handle := c.QueryParam("handle")
-	var out *comatprototypes.IdentityResolveHandle_Output
-	var handleErr error
-	// func (s *Server) handleComAtprotoIdentityResolveHandle(ctx context.Context,handle string) (*comatprototypes.IdentityResolveHandle_Output, error)
-	out, handleErr = s.handleComAtprotoIdentityResolveHandle(ctx, handle)
-	if handleErr != nil {
-		return handleErr
-	}
-	return c.JSON(200, out)
 }
 
 func (s *Server) HandleComAtprotoIdentityUpdateHandle(c echo.Context) error {

search/handlers.go

···
 }
 
 func (s *Server) handleFromDid(ctx context.Context, did string) (string, error) {
-	handle, _, err := api.ResolveDidToHandle(ctx, s.xrpcc, s.plc, did)
+	phr := &api.ProdHandleResolver{}
+	handle, _, err := api.ResolveDidToHandle(ctx, s.xrpcc, s.plc, phr, did)
 	if err != nil {
 		return "", err
 	}

testing/integ_test.go

···
 	b1 := MustSetupBGS(t, "localhost:8231", didr)
 	b1.Run(t)
 
+	b1.tr.TrialHosts = []string{p1.host}
+
 	p1.RequestScraping(t, b1)
 
 	time.Sleep(time.Millisecond * 50)
···
 	b1 := MustSetupBGS(t, "localhost:8281", didr)
 	b1.Run(t)
 
+	b1.tr.TrialHosts = []string{p1.host, p2.host}
+
 	p1.RequestScraping(t, b1)
 	time.Sleep(time.Millisecond * 100)
 
···
 
 	b1 := MustSetupBGS(t, "localhost:8291", didr)
 	b1.Run(t)
+
+	b1.tr.TrialHosts = []string{p1.host, p2.host}
 
 	p1.RequestScraping(t, b1)
 	time.Sleep(time.Millisecond * 50)
···
 	b1 := MustSetupBGS(t, "localhost:8391", didr)
 	b1.Run(t)
 
+	b1.tr.TrialHosts = []string{p1.host}
+
 	p1.RequestScraping(t, b1)
 	time.Sleep(time.Millisecond * 50)
 
···
 
 	b1 := MustSetupBGS(t, "localhost:3231", didr)
 	b1.Run(t)
+
+	b1.tr.TrialHosts = []string{p1.host}
 
 	p1.RequestScraping(t, b1)
 
···
 
 	b1 := MustSetupBGS(t, "localhost:1531", didr)
 	b1.Run(t)
+
+	b1.tr.TrialHosts = []string{p1.host}
 
 	p1.RequestScraping(t, b1)
 

testing/utils.go

···
 type TestBGS struct {
 	bgs  *bgs.BGS
 	host string
+	tr   *api.TestHandleResolver
 }
 
 func MustSetupBGS(t *testing.T, host string, didr plc.PLCClient) *TestBGS {
···
 		}
 	})
 
-	b, err := bgs.NewBGS(maindb, ix, repoman, evtman, didr, nil, false)
+	tr := &api.TestHandleResolver{}
+
+	b, err := bgs.NewBGS(maindb, ix, repoman, evtman, didr, nil, tr, false)
 	if err != nil {
 		return nil, err
 	}
···
 	return &TestBGS{
 		bgs:  b,
 		host: host,
+		tr:   tr,
 	}, nil
 }