fix: dedup redelivered business messages

A business bot replied to the same message repeatedly: Telegram may redeliver
updates (notably to bots, which lack user-style getDifference gap recovery), so
the same updateBotNewBusinessMessage arrives more than once. The official
telegram-bot-api server is once-only because TDLib dedups; match that with a
bounded FIFO set keyed by connectionID:msgID:editDate (Bot.businessSeen),
checked in dispatchBusinessMessage before routing. Edit date lets genuine edits
through while suppressing redeliveries.

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

Author: ernado

bot.go

@@ -50,6 +50,10 @@ type Bot struct {
 	runCtx context.Context
 
 	self *tg.User
+
+	// businessSeen suppresses re-processing of redelivered business messages, so
+	// the bot does not reply to the same message twice.
+	businessSeen *businessDedup
 }
 
 // New constructs an unconnected Bot from a BotFather token. It performs no
@@ -118,6 +122,7 @@ func New(token string, opt Options) (*Bot, error) {
 		disp:             disp,
 		onStart:          opt.OnStart,
 		registerCommands: !opt.DisableCommandRegistration,
+		businessSeen:     newBusinessDedup(businessDedupSize),
 	}
 	b.installHandlers()
 

business_dedup.go

@@ -0,0 +1,61 @@
+package botapi
+
+import (
+	"strconv"
+	"sync"
+
+	"github.com/gotd/td/tg"
+)
+
+// businessDedupSize is the number of recent business messages remembered for
+// deduplication. Telegram may redeliver updates (notably to bots after a
+// reconnect), and the qts sequence does not always suppress this; the window
+// only needs to cover the burst a redelivery replays.
+const businessDedupSize = 4096
+
+// businessDedup remembers recently delivered business messages so a redelivered
+// update does not fire handlers — and reply — twice. It is a fixed-size set with
+// FIFO eviction: safe for concurrent use, bounded in memory.
+type businessDedup struct {
+	mu   sync.Mutex
+	seen map[string]struct{}
+	ring []string
+	pos  int
+}
+
+func newBusinessDedup(size int) *businessDedup {
+	return &businessDedup{
+		seen: make(map[string]struct{}, size),
+		ring: make([]string, size),
+	}
+}
+
+// fresh reports whether key has not been seen recently, recording it. A repeated
+// key (a redelivered update) returns false.
+func (d *businessDedup) fresh(key string) bool {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
+	if _, ok := d.seen[key]; ok {
+		return false
+	}
+
+	if old := d.ring[d.pos]; old != "" {
+		delete(d.seen, old)
+	}
+
+	d.ring[d.pos] = key
+	d.pos = (d.pos + 1) % len(d.ring)
+	d.seen[key] = struct{}{}
+
+	return true
+}
+
+// businessMessageKey identifies a business message for deduplication. The edit
+// date distinguishes a genuine edit (which should be handled) from a redelivery
+// of the same message (which should not).
+func businessMessageKey(connectionID string, m *tg.Message) string {
+	edit, _ := m.GetEditDate()
+
+	return connectionID + ":" + strconv.Itoa(m.ID) + ":" + strconv.Itoa(edit)
+}

business_updates.go

@@ -61,6 +61,12 @@ func (b *Bot) dispatchBusinessMessage(ctx context.Context, e tg.Entities, connec
 
 	m.BusinessConnectionID = connectionID
 	if m.raw != nil {
+		// Drop redelivered messages so the bot does not reply to the same one
+		// twice (Telegram may resend updates, especially to bots on reconnect).
+		if b.businessSeen != nil && !b.businessSeen.fresh(businessMessageKey(connectionID, m.raw)) {
+			return
+		}
+
 		m.businessPeer = inputPeerFromEntities(m.raw.PeerID, e)
 	}
 

business_updates_test.go

@@ -74,6 +74,48 @@ func TestDispatchBusinessMessageEdited(t *testing.T) {
 	}
 }
 
+func TestDispatchBusinessMessageDedup(t *testing.T) {
+	b := newMockBot(newMockInvoker())
+
+	var fires int
+
+	b.OnBusinessMessage(func(c *Context) error { fires++; return nil })
+
+	e := tg.Entities{Users: map[int64]*tg.User{10: {ID: 10, AccessHash: 1}}}
+	msg := &tg.Message{ID: 50, PeerID: &tg.PeerUser{UserID: 10}}
+
+	// A redelivered (identical) business message must be handled only once.
+	b.dispatchBusinessMessage(context.Background(), e, "bc1", msg, false)
+	b.dispatchBusinessMessage(context.Background(), e, "bc1", msg, false)
+
+	if fires != 1 {
+		t.Fatalf("handler fired %d times, want 1", fires)
+	}
+
+	// The same id on a different connection is a different message.
+	b.dispatchBusinessMessage(context.Background(), e, "bc2", msg, false)
+
+	if fires != 2 {
+		t.Fatalf("handler fired %d times, want 2", fires)
+	}
+}
+
+func TestBusinessDedupFresh(t *testing.T) {
+	d := newBusinessDedup(2)
+
+	if !d.fresh("a") || d.fresh("a") {
+		t.Fatal("first 'a' fresh, second not")
+	}
+
+	// Fill past capacity to evict "a", which then reads as fresh again.
+	d.fresh("b")
+	d.fresh("c")
+
+	if !d.fresh("a") {
+		t.Fatal("evicted key should read fresh again")
+	}
+}
+
 func TestContextBusinessFromMessage(t *testing.T) {
 	b := newMockBot(newMockInvoker())
 	c := &Context{Context: context.Background(), Bot: b, Update: &Update{

harness_test.go

@@ -193,6 +193,8 @@ func newMockBot(inv *mockInvoker) *Bot {
 		peers:   peers.Options{}.Build(raw),
 		disp:    tg.NewUpdateDispatcher(),
 		self:    &tg.User{ID: 1, Bot: true, AccessHash: 1, Username: "test_bot"},
+
+		businessSeen: newBusinessDedup(businessDedupSize),
 	}
 }