+2

atproto/label/label.go

··· 140 140 Cid: l.CID, 141 141 Cts: l.CreatedAt, 142 142 Exp: l.ExpiresAt, 143 143 + Neg: l.Negated, 143 144 Sig: []byte(l.Sig), 144 145 Src: l.SourceDID, 145 146 Uri: l.URI, ··· 157 158 CID: l.Cid, 158 159 CreatedAt: l.Cts, 159 160 ExpiresAt: l.Exp, 161 161 + Negated: l.Neg, 160 162 Sig: []byte(l.Sig), 161 163 SourceDID: l.Src, 162 164 URI: l.Uri,

+62

atproto/label/label_test.go

··· 4 4 "encoding/json" 5 5 "testing" 6 6 7 7 + comatproto "github.com/bluesky-social/indigo/api/atproto" 7 8 "github.com/bluesky-social/indigo/atproto/crypto" 8 9 9 10 "github.com/stretchr/testify/assert" ··· 89 90 assert.NoError(l.Sign(priv)) 90 91 assert.NoError(l.VerifySignature(pub)) 91 92 } 93 93 + 94 94 + func TestToLexicon(t *testing.T) { 95 95 + assert := assert.New(t) 96 96 + 97 97 + expiresAt := "2025-07-28T23:53:19.804Z" 98 98 + negated := true 99 99 + cid := "bafyreifxykqhed72s26cr4i64rxvrtofeqrly3j4vjzbkvo3ckkjbxjqtq" 100 100 + 101 101 + l := Label{ 102 102 + CID: &cid, 103 103 + CreatedAt: "2024-10-23T17:51:19.128Z", 104 104 + ExpiresAt: &expiresAt, 105 105 + Negated: &negated, 106 106 + SourceDID: "did:plc:ewvi7nxzyoun6zhxrhs64oiz", 107 107 + URI: "at://did:plc:ewvi7nxzyoun6zhxrhs64oiz/app.bsky.actor.profile/self", 108 108 + Val: "good", 109 109 + Version: ATPROTO_LABEL_VERSION, 110 110 + Sig: []byte("sig"), // invalid, but we only care about the conversion 111 111 + } 112 112 + 113 113 + lex := l.ToLexicon() 114 114 + assert.Equal(l.Version, *lex.Ver) 115 115 + assert.Equal(l.CreatedAt, lex.Cts) 116 116 + assert.Equal(l.URI, lex.Uri) 117 117 + assert.Equal(l.Val, lex.Val) 118 118 + assert.Equal(l.CID, lex.Cid) 119 119 + assert.Equal(l.ExpiresAt, lex.Exp) 120 120 + assert.Equal(l.Negated, lex.Neg) 121 121 + assert.Equal(l.SourceDID, lex.Src) 122 122 + } 123 123 + 124 124 + func TestFromLexicon(t *testing.T) { 125 125 + assert := assert.New(t) 126 126 + 127 127 + expiresAt := "2025-07-28T23:53:19.804Z" 128 128 + negated := true 129 129 + cid := "bafyreifxykqhed72s26cr4i64rxvrtofeqrly3j4vjzbkvo3ckkjbxjqtq" 130 130 + version := int64(1) 131 131 + 132 132 + lex := &comatproto.LabelDefs_Label{ 133 133 + Cid: &cid, 134 134 + Cts: "2024-10-23T17:51:19.128Z", 135 135 + Exp: &expiresAt, 136 136 + Neg: &negated, 137 137 + Src: "did:plc:ewvi7nxzyoun6zhxrhs64oiz", 138 138 + Uri: "at://did:plc:ewvi7nxzyoun6zhxrhs64oiz/app.bsky.actor.profile/self", 139 139 + Val: "good", 140 140 + Ver: &version, 141 141 + Sig: []byte("sig"), // invalid, but we only care about the conversion 142 142 + } 143 143 + 144 144 + l := FromLexicon(lex) 145 145 + assert.Equal(lex.Ver, &l.Version) 146 146 + assert.Equal(lex.Cts, l.CreatedAt) 147 147 + assert.Equal(lex.Uri, l.URI) 148 148 + assert.Equal(lex.Val, l.Val) 149 149 + assert.Equal(lex.Cid, l.CID) 150 150 + assert.Equal(lex.Exp, l.ExpiresAt) 151 151 + assert.Equal(lex.Neg, l.Negated) 152 152 + assert.Equal(lex.Src, l.SourceDID) 153 153 + }

-26

docs/auth.md

··· 1 1 - # Auth 2 2 - 3 3 - The auth system uses two tokens, an access token and a refresh token. 4 4 - 5 5 - The access token is a jwt with the following values: 6 6 - ``` 7 7 - scope: "com.atproto.access" 8 8 - sub: <the users DID> 9 9 - iat: the current time, in unix epoch seconds 10 10 - exp: the expiry date, usually around an hour, but at least 15 minutes 11 11 - ``` 12 12 - 13 13 - The refresh token is a jwt with the following values: 14 14 - ``` 15 15 - scope: "com.atproto.refresh" 16 16 - sub: <the users DID> 17 17 - iat: the current time, in unix epoch seconds 18 18 - exp: the expiry date, usually around a week, must be significantly longer than the access token 19 19 - jti: a unique identifier for this token 20 20 - ``` 21 21 - 22 22 - The access token is what is used for all requests, however since it expires 23 23 - quickly, it must be refreshed periodically using the refresh token. 24 24 - When the refresh token is used, it must be marked as deleted, and the new token then replaces it. 25 25 - Note: The old access token is not necessarily disabled at that point of refreshing. 26 26 -

-37

docs/feed-proposal.md

··· 1 1 - # Feed Structuring Proposal 2 2 - 3 3 - Some thoughts on a new format for feeds. 4 4 - 5 5 - ## Motivation 6 6 - The interface for requesting and getting back feeds is something that I feel is really at the core of what bluesky offers. The user should be able to choose what feeds they subscribe to, feeds should be first class objects, they should be able to be efficiently generated and consumed, and they should be able to trustlessly come from anywhere. 7 7 - There are a lot of changes we *could* make to the current structure, but I don't want to stray too far from where we are at right now. 8 8 - 9 9 - 10 10 - ```go 11 11 - type Feed struct { 12 12 - Items []FeedItem 13 13 - Values map[Cid]Record 14 14 - ItemInfos map[Uri]ItemInfo 15 15 - ActorInfos map[Did]ActorInfo 16 16 - } 17 17 - 18 18 - type FeedItem struct { 19 19 - Uri string 20 20 - Replies []Uri 21 21 - ReplyTo Uri 22 22 - RepostedBy Did 23 23 - } 24 24 - 25 25 - type ItemInfo struct { 26 26 - Cid Cid 27 27 - Upvotes int 28 28 - Reposts int 29 29 - Replies int 30 30 - Author Did 31 31 - } 32 32 - ``` 33 33 - 34 34 - The main idea here is not repeating ourselves, while still providing all the information the client might need. 35 35 - With this structure too, the user could easily request *less* data, asking to 36 36 - skip the inclusion of records older than X, or saying they are okay with stale 37 37 - information in certain places for the sake of efficiency.

+1 -1

mst/mst_test.go

··· 532 532 for i := 0; i < 256; i++ { 533 533 f.Add([]byte{byte(i)}) 534 534 } 535 535 - rx := regexp.MustCompile("^[a-zA-Z0-9_:.-]+$") 535 535 + rx := regexp.MustCompile("^[a-zA-Z0-9_:.~-]+$") 536 536 f.Fuzz(func(t *testing.T, in []byte) { 537 537 s := string(in) 538 538 if a, b := rx.MatchString(s), keyHasAllValidChars(s); a != b {

+2 -2

mst/mst_util.go

··· 197 197 } 198 198 199 199 // keyHasAllValidChars reports whether s matches 200 200 - // the regexp /^[a-zA-Z0-9_:.-]+$/ without using regexp, 200 200 + // the regexp /^[a-zA-Z0-9_:.~-]+$/ without using regexp, 201 201 // which is slower. 202 202 func keyHasAllValidChars(s string) bool { 203 203 if len(s) == 0 { ··· 211 211 continue 212 212 } 213 213 switch b { 214 214 - case '_', ':', '.', '-': 214 214 + case '_', ':', '.', '~', '-': 215 215 continue 216 216 default: 217 217 return false