package trust import ( "context" "encoding/json" "errors" "fmt" "slices" "strings" "sync" "time" "github.com/johnandersen777/socialweb-computer-kcp/internal/identlink" "github.com/johnandersen777/socialweb-computer-kcp/internal/kit/opt" "github.com/johnandersen777/socialweb-computer-kcp/internal/kit/ttlcache" "github.com/johnandersen777/socialweb-computer-kcp/internal/policyengine/atproto" "github.com/johnandersen777/socialweb-computer-kcp/internal/policyengine/cache" "github.com/johnandersen777/socialweb-computer-kcp/internal/policyengine/models" ) const ( VouchNSID = "sh.tangled.graph.vouch" defaultTrustCacheTTL = 5 * time.Minute trustErrorTTL = 5 * time.Second ) type Host interface { Resolve(ctx context.Context, ref atproto.StrongRef) (map[string]any, error) Walk(ctx context.Context, did string, assoc Association) (identlink.Result, error) Vouches(ctx context.Context, voucher, subject string) (bool, error) Log(level, msg string, meta map[string]any) } var ErrUnconfirmed = errors.New("trust: a lookup failed") type Snapshot struct { OperatorOf map[string]string `json:"operatorOf"` VouchedBy map[string][]string `json:"vouchedBy"` TrustedOperators []string `json:"trustedOperators"` Unconfirmed []string `json:"-"` walkUnconfirmed bool unconfirmedVouches []vouchPair selfDid string counterpartyDid string selfSide []string cpSide []string } func (s *Snapshot) addVouch(voucher, subject string) { s.VouchedBy[voucher] = append(s.VouchedBy[voucher], subject) switch { case slices.Contains(s.selfSide, voucher) && slices.Contains(s.cpSide, subject): s.VouchedBy[voucher] = append(s.VouchedBy[voucher], s.counterpartyDid) case slices.Contains(s.cpSide, voucher) && slices.Contains(s.selfSide, subject): s.VouchedBy[s.counterpartyDid] = append(s.VouchedBy[s.counterpartyDid], s.selfDid) } } func (s *Snapshot) compact() { for voucher, list := range s.VouchedBy { slices.Sort(list) s.VouchedBy[voucher] = slices.Compact(list) } } func (s Snapshot) AssumingUnconfirmedVouches() (Snapshot, bool) { if s.walkUnconfirmed || len(s.unconfirmedVouches) == 0 { return Snapshot{}, false } out := s out.Unconfirmed = nil out.unconfirmedVouches = nil out.VouchedBy = make(map[string][]string, len(s.VouchedBy)) for voucher, list := range s.VouchedBy { out.VouchedBy[voucher] = slices.Clone(list) } for _, p := range s.unconfirmedVouches { out.addVouch(p.voucher, p.subject) } out.compact() return out, true } type ResolverOptions struct { Client *atproto.Client Source identlink.Source Store *cache.Store TTL time.Duration Log func(level, msg string, meta map[string]any) } type walkKey struct { did string assoc Association } type vouchKey struct { voucher string subject string } type Resolver struct { client *atproto.Client source identlink.Source store *cache.Store log func(level, msg string, meta map[string]any) now func() time.Time ttl time.Duration walks *ttlcache.Cache[walkKey, identlink.Result] vouch *ttlcache.Cache[vouchKey, bool] } func NewResolver(opts ResolverOptions) *Resolver { client := opts.Client if client == nil { client = atproto.NewClient() } source := opts.Source if source == nil { source = identlink.NewRemote(identlink.PLCDirectory(client.PLCURL, client.HTTP), client.HTTP) } ttl := opt.Positive(opts.TTL, defaultTrustCacheTTL) log := opts.Log if log == nil { log = func(string, string, map[string]any) {} } return &Resolver{ client: client, source: source, store: opts.Store, log: log, now: time.Now, ttl: ttl, walks: ttlcache.New[walkKey, identlink.Result](ttlcache.Options{TTL: ttl}), vouch: ttlcache.New[vouchKey, bool](ttlcache.Options{TTL: ttl}), } } func (r *Resolver) Resolve(ctx context.Context, ref atproto.StrongRef) (map[string]any, error) { if r.store != nil { if value, ok := cache.ReadRecord(r.store, ref); ok { return value, nil } } repo, collection, rkey := atproto.SplitURI(ref.URI) value, held, err := r.verifiedRecord(ctx, repo, collection, rkey) if err != nil { return nil, err } if value == nil { return nil, fmt.Errorf("%w: %s", atproto.ErrRecordNotFound, ref.URI) } if ref.CID != "" && held != ref.CID { return nil, fmt.Errorf("%w: %s holds %s, not %s", atproto.ErrRecordNotFound, ref.URI, held, ref.CID) } if r.store != nil { cache.WriteRecord(r.store, ref, value) } return value, nil } type verifiedSource interface { GetVerifiedRecord(ctx context.Context, did, collection, rkey string) (map[string]any, string, error) } func (r *Resolver) verifiedRecord(ctx context.Context, repo, collection, rkey string) (map[string]any, string, error) { if source, ok := r.source.(verifiedSource); ok { return source.GetVerifiedRecord(ctx, repo, collection, rkey) } value, err := r.source.GetRecord(ctx, repo, collection, rkey) if err != nil || value == nil { return value, "", err } held, err := identlink.RecordCID(value) return value, held, err } func (r *Resolver) Record(ctx context.Context, repo, collection, rkey string) (map[string]any, error) { return r.source.GetRecord(ctx, repo, collection, rkey) } type walkIO struct { r *Resolver requireContract bool } func (w walkIO) ResolveDID(ctx context.Context, did string) (*identlink.Doc, error) { return w.r.source.ResolveDID(ctx, did) } func (w walkIO) GetRecord(ctx context.Context, repo, collection, rkey string) (map[string]any, error) { value, err := w.r.source.GetRecord(ctx, repo, collection, rkey) if _, scoped := value["contract"]; w.requireContract && collection == identlink.GrantNSID && !scoped { return nil, err } return value, err } func (w walkIO) ContractHeld(ctx context.Context, contract identlink.StrongRef, authorities []string) (bool, error) { return w.r.contractHeld(ctx, atproto.StrongRef{URI: contract.URI, CID: contract.CID}, authorities) } func (w walkIO) Now() time.Time { return w.r.now() } func (r *Resolver) Walk(ctx context.Context, did string, assoc Association) (identlink.Result, error) { did = strings.TrimSpace(did) assoc = assoc.normal() key := walkKey{did: did, assoc: assoc} if res, ok := r.walks.Get(key); ok { return res, nil } res := identlink.Walk(ctx, walkIO{r: r, requireContract: assoc.RequireContract}, did, identlink.Options{MaxDepth: assoc.MaxDepth}) if err := ctx.Err(); err != nil { return identlink.Result{}, err } if len(res.Errors) > 0 { r.log("warn", "identlink walk left edges unconfirmed", map[string]any{"did": did, "errors": res.Errors}) r.walks.SetTTL(key, res, trustErrorTTL) return res, nil } ttl := r.ttl for _, a := range res.Ancestors { if a.ExpiresAt != nil { ttl = min(ttl, max(a.ExpiresAt.Sub(r.now()), time.Second)) } } r.walks.SetTTL(key, res, ttl) return res, nil } func (r *Resolver) Vouches(ctx context.Context, voucher, subject string) (bool, error) { voucher = strings.TrimSpace(voucher) subject = strings.TrimSpace(subject) if voucher == "" || !strings.HasPrefix(subject, "did:") { return false, nil } key := vouchKey{voucher: voucher, subject: subject} if vouched, ok := r.vouch.Get(key); ok { return vouched, nil } value, err := r.Record(ctx, voucher, VouchNSID, subject) if err != nil { if ctx.Err() != nil { return false, ctx.Err() } r.log("warn", "vouches failed", map[string]any{"voucher": voucher, "subject": subject, "error": err.Error()}) return false, fmt.Errorf("%w: the vouch %s -> %s: %v", ErrUnconfirmed, voucher, subject, err) } kind, _ := value["kind"].(string) vouched := value != nil && kind != "denounce" r.vouch.Set(key, vouched) return vouched, nil } func (r *Resolver) Log(level, msg string, meta map[string]any) { r.log(level, msg, meta) } func (r *Resolver) ApplyEvent(did, rkey string) { named := func(x string) bool { return x != "" && (x == did || x == rkey) } r.walks.DeleteFunc(func(key walkKey, res identlink.Result) bool { return named(key.did) || slices.ContainsFunc(res.Ancestors, func(a identlink.Ancestor) bool { return named(a.DID) }) }) if did != "" { r.source.Forget(did) } r.vouch.DeleteKeys(func(key vouchKey) bool { return named(key.voucher) }) } func (r *Resolver) Invalidate() { r.walks.DeleteKeys(func(walkKey) bool { return true }) r.vouch.DeleteKeys(func(vouchKey) bool { return true }) } type walked struct { res identlink.Result err error } type vouchResult struct { voucher string subject string vouched bool err error } func BuildSnapshot(ctx context.Context, host Host, selfDid, counterpartyDid string, assoc Association) (Snapshot, error) { snapshot := Snapshot{ OperatorOf: make(map[string]string), VouchedBy: make(map[string][]string), TrustedOperators: []string{}, } if host == nil { return snapshot, nil } var wg sync.WaitGroup defer wg.Wait() ctx, cancel := context.WithCancel(ctx) defer cancel() var self, cp walked wg.Go(func() { self.res, self.err = host.Walk(ctx, selfDid, Association{MaxDepth: assoc.MaxDepth}) }) if counterpartyDid != "" && counterpartyDid != selfDid { wg.Go(func() { cp.res, cp.err = host.Walk(ctx, counterpartyDid, assoc) }) } wg.Wait() if err := errors.Join(self.err, cp.err); err != nil { return snapshot, err } snapshot.Unconfirmed = slices.Concat(self.res.Errors, cp.res.Errors) snapshot.walkUnconfirmed = len(snapshot.Unconfirmed) > 0 snapshot.OperatorOf = operatorsOf(selfDid, counterpartyDid, self.res, cp.res) selfSide := self.res.Side() snapshot.TrustedOperators = selfSide if counterpartyDid == "" || counterpartyDid == selfDid { snapshot.VouchedBy[selfDid] = []string{} return snapshot, nil } cpSide := cp.res.Side() snapshot.selfDid, snapshot.counterpartyDid, snapshot.selfSide, snapshot.cpSide = selfDid, counterpartyDid, selfSide, cpSide pairs := vouchPairs(selfSide, cpSide) for _, p := range pairs { snapshot.VouchedBy[p.voucher] = []string{} } results := make(chan vouchResult, len(pairs)) for _, p := range pairs { wg.Go(func() { vouched, err := host.Vouches(ctx, p.voucher, p.subject) results <- vouchResult{voucher: p.voucher, subject: p.subject, vouched: vouched, err: err} }) } for range pairs { result := <-results if errors.Is(result.err, ErrUnconfirmed) { snapshot.Unconfirmed = append(snapshot.Unconfirmed, result.err.Error()) snapshot.unconfirmedVouches = append(snapshot.unconfirmedVouches, vouchPair{voucher: result.voucher, subject: result.subject}) continue } if result.err != nil { return snapshot, result.err } if result.vouched { snapshot.addVouch(result.voucher, result.subject) } } snapshot.compact() return snapshot, nil } func operatorsOf(selfDid, counterpartyDid string, self, cp identlink.Result) map[string]string { out := map[string]string{selfDid: selfDid} if len(self.Roots) > 0 { out[selfDid] = self.Roots[0] } if counterpartyDid == "" || counterpartyDid == selfDid { return out } for _, root := range self.Roots { if slices.Contains(cp.Roots, root) { out[selfDid], out[counterpartyDid] = root, root return out } } for _, root := range cp.Roots { if root != counterpartyDid { out[counterpartyDid] = root break } } return out } type vouchPair struct { voucher, subject string } func vouchPairs(selfSide, cpSide []string) []vouchPair { var out []vouchPair add := func(voucher, subject string) { p := vouchPair{voucher: voucher, subject: subject} if voucher != subject && len(out) < identlink.DefaultBudget && !slices.Contains(out, p) { out = append(out, p) } } for sum := 0; sum <= len(selfSide)+len(cpSide)-2; sum++ { for i := max(0, sum-len(cpSide)+1); i <= min(sum, len(selfSide)-1); i++ { add(selfSide[i], cpSide[sum-i]) add(cpSide[sum-i], selfSide[i]) } } return out } func (s Snapshot) ActionVouchedBy() map[string][]string { out := make(map[string][]string, len(s.VouchedBy)) for voucher, list := range s.VouchedBy { out[voucher] = slices.Clone(list) } if len(s.TrustedOperators) == 0 { return out } self := s.TrustedOperators[0] merged := []string{} for _, operator := range s.TrustedOperators { merged = append(merged, s.VouchedBy[operator]...) } slices.Sort(merged) out[self] = slices.Compact(merged) return out } func (s Snapshot) CacheFiles() models.CacheEntry { operatorOf, _ := json.Marshal(s.OperatorOf) vouchedBy, _ := json.Marshal(s.ActionVouchedBy()) trustedOperators, _ := json.Marshal(s.TrustedOperators) return models.CacheEntry{ "operatorOf.json": {Data: string(operatorOf), Encoding: models.CacheEncodingText}, "vouchedBy.json": {Data: string(vouchedBy), Encoding: models.CacheEncodingText}, "trustedOperators.json": {Data: string(trustedOperators), Encoding: models.CacheEncodingText}, } }