~ knotless Search/
↑↓ move↵ open⇧↵ all results

socialweb.computer/socialweb-computer-kcp

socialweb.computer: a compute market on atproto (kcp)

1 collaborator
0
0
423 lines · 12.6 KB Raw History
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},
	}
}