feat(stickers): implement GetStickerSet and SetStickerSetThumb

Add the StickerSet type and a tg document -> Bot API Sticker converter,
GetStickerSet (messages.getStickerSet) and SetStickerSetThumb
(stickers.setStickerSetThumb, file_id or upload). Drop both from the
conformance deferred list; only payments and games remain deferred.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: ernado

conformance_test.go

@@ -28,8 +28,6 @@ var deferredMethods = map[string]string{
 	"sendGame":               "games — deferred",
 	"setGameScore":           "games — deferred",
 	"getGameHighScores":      "games — deferred",
-	"getStickerSet":          "stickers — deferred (needs Sticker[] conversion)",
-	"setStickerSetThumb":     "stickers — deferred",
 }
 
 // notApplicableMethods lists published methods that do not apply to the

sticker.go

@@ -20,17 +20,21 @@ const (
 	StickerFormatVideo StickerFormat = "video"
 )
 
-// mimeStickerStatic is the MIME type used for static (and unknown) stickers.
-const mimeStickerStatic = "image/png"
+// Sticker MIME types.
+const (
+	mimeStickerStatic   = "image/png"
+	mimeStickerAnimated = "application/x-tgsticker"
+	mimeStickerVideo    = "video/webm"
+)
 
 // mimeType reports the MTProto MIME type for the sticker format. Static (and
 // any unknown) formats default to PNG.
 func (f StickerFormat) mimeType() string {
 	switch f {
 	case StickerFormatAnimated:
-		return "application/x-tgsticker"
+		return mimeStickerAnimated
 	case StickerFormatVideo:
-		return "video/webm"
+		return mimeStickerVideo
 	case StickerFormatStatic:
 		return mimeStickerStatic
 	default:

sticker_set.go

@@ -0,0 +1,132 @@
+package botapi
+
+import (
+	"context"
+
+	"github.com/gotd/td/fileid"
+	"github.com/gotd/td/tg"
+)
+
+// GetStickerSet returns a sticker set by its short name.
+func (b *Bot) GetStickerSet(ctx context.Context, name string) (*StickerSet, error) {
+	res, err := b.raw.MessagesGetStickerSet(ctx, &tg.MessagesGetStickerSetRequest{
+		Stickerset: &tg.InputStickerSetShortName{ShortName: name},
+		Hash:       0,
+	})
+	if err != nil {
+		return nil, asAPIError(err)
+	}
+	set, ok := res.(*tg.MessagesStickerSet)
+	if !ok {
+		return nil, &Error{Code: 400, Description: "Bad Request: sticker set not found"}
+	}
+
+	typ := stickerSetType(set.Set)
+	out := &StickerSet{
+		Name:        set.Set.ShortName,
+		Title:       set.Set.Title,
+		StickerType: typ,
+	}
+	out.Stickers = make([]Sticker, 0, len(set.Documents))
+	for _, d := range set.Documents {
+		if doc, ok := d.(*tg.Document); ok {
+			out.Stickers = append(out.Stickers, stickerFromDocument(doc, set.Set.ShortName, typ))
+		}
+	}
+	if thumbs := set.Set.Thumbs; len(thumbs) > 0 {
+		if ps := photoSizeFromThumb(thumbs[0]); ps != nil {
+			out.Thumbnail = ps
+		}
+	}
+	return out, nil
+}
+
+// SetStickerSetThumb sets the thumbnail of a sticker set owned by the bot. The
+// thumbnail is referenced by file_id or uploaded.
+func (b *Bot) SetStickerSetThumb(ctx context.Context, name string, thumb InputFile) error {
+	var doc tg.InputDocumentClass
+	switch f := thumb.(type) {
+	case InputFileID:
+		d, err := inputDocumentFromFileID(string(f))
+		if err != nil {
+			return err
+		}
+		doc = d
+	case *InputFileUpload:
+		uploaded, err := b.uploadStickerDocument(ctx, f, StickerFormatStatic)
+		if err != nil {
+			return err
+		}
+		doc = &tg.InputDocument{ID: uploaded.ID, AccessHash: uploaded.AccessHash, FileReference: uploaded.FileReference}
+	default:
+		return &Error{Code: 400, Description: "Bad Request: thumbnail must be a file_id or an uploaded file"}
+	}
+
+	if _, err := b.raw.StickersSetStickerSetThumb(ctx, &tg.StickersSetStickerSetThumbRequest{
+		Stickerset: &tg.InputStickerSetShortName{ShortName: name},
+		Thumb:      doc,
+	}); err != nil {
+		return asAPIError(err)
+	}
+	return nil
+}
+
+// stickerSetType reports the Bot API sticker type of a set.
+func stickerSetType(set tg.StickerSet) StickerType {
+	switch {
+	case set.Masks:
+		return StickerMask
+	case set.Emojis:
+		return StickerCustomEmoji
+	default:
+		return StickerRegular
+	}
+}
+
+// stickerFromDocument converts a sticker document into the Bot API Sticker. typ
+// is the type of the enclosing set.
+func stickerFromDocument(d *tg.Document, setName string, typ StickerType) Sticker {
+	fileID, uniqueID := encodeFileID(fileid.FromDocument(d))
+	s := Sticker{
+		FileID:       fileID,
+		FileUniqueID: uniqueID,
+		Type:         typ,
+		SetName:      setName,
+		FileSize:     int(d.Size),
+		IsAnimated:   d.MimeType == mimeStickerAnimated,
+		IsVideo:      d.MimeType == mimeStickerVideo,
+	}
+	for _, attr := range d.Attributes {
+		switch a := attr.(type) {
+		case *tg.DocumentAttributeImageSize:
+			s.Width, s.Height = a.W, a.H
+		case *tg.DocumentAttributeVideo:
+			s.Width, s.Height = a.W, a.H
+		case *tg.DocumentAttributeSticker:
+			s.Emoji = a.Alt
+		}
+	}
+	if len(d.Thumbs) > 0 {
+		s.Thumbnail = photoSizeFromThumb(d.Thumbs[0])
+	}
+	return s
+}
+
+// photoSizeFromThumb converts a document/sticker thumbnail into a PhotoSize.
+// File ids for thumbnails are not derivable from the document alone, so only the
+// dimensions and size are filled.
+func photoSizeFromThumb(t tg.PhotoSizeClass) *PhotoSize {
+	type sized interface {
+		GetW() int
+		GetH() int
+	}
+	s, ok := t.(sized)
+	if !ok {
+		return nil
+	}
+	ps := &PhotoSize{Width: s.GetW(), Height: s.GetH()}
+	if base, ok := t.(*tg.PhotoSize); ok {
+		ps.FileSize = base.Size
+	}
+	return ps
+}

sticker_set_test.go

@@ -0,0 +1,50 @@
+package botapi
+
+import (
+	"testing"
+
+	"github.com/gotd/td/tg"
+)
+
+func TestStickerFromDocument(t *testing.T) {
+	d := &tg.Document{
+		ID:            5,
+		AccessHash:    6,
+		FileReference: []byte{1},
+		DCID:          2,
+		Size:          4096,
+		MimeType:      mimeStickerVideo,
+		Attributes: []tg.DocumentAttributeClass{
+			&tg.DocumentAttributeImageSize{W: 512, H: 512},
+			&tg.DocumentAttributeSticker{Alt: "🎉"},
+		},
+	}
+	s := stickerFromDocument(d, "myset", StickerRegular)
+	if s.FileID == "" || s.FileUniqueID == "" {
+		t.Fatalf("file ids: %#v", s)
+	}
+	if s.Width != 512 || s.Height != 512 {
+		t.Fatalf("dimensions: %#v", s)
+	}
+	if s.Emoji != "🎉" || s.SetName != "myset" || s.Type != StickerRegular {
+		t.Fatalf("meta: %#v", s)
+	}
+	if !s.IsVideo || s.IsAnimated {
+		t.Fatalf("video flags: %#v", s)
+	}
+	if s.FileSize != 4096 {
+		t.Fatalf("size: %d", s.FileSize)
+	}
+}
+
+func TestStickerSetType(t *testing.T) {
+	if stickerSetType(tg.StickerSet{Masks: true}) != StickerMask {
+		t.Fatal("masks -> mask")
+	}
+	if stickerSetType(tg.StickerSet{Emojis: true}) != StickerCustomEmoji {
+		t.Fatal("emojis -> custom_emoji")
+	}
+	if stickerSetType(tg.StickerSet{}) != StickerRegular {
+		t.Fatal("default -> regular")
+	}
+}

types_media.go

@@ -105,3 +105,12 @@ type UserProfilePhotos struct {
 	TotalCount int           `json:"total_count"`
 	Photos     [][]PhotoSize `json:"photos"`
 }
+
+// StickerSet represents a set of stickers.
+type StickerSet struct {
+	Name        string      `json:"name"`
+	Title       string      `json:"title"`
+	StickerType StickerType `json:"sticker_type"`
+	Stickers    []Sticker   `json:"stickers"`
+	Thumbnail   *PhotoSize  `json:"thumbnail,omitempty"`
+}