slidge-whatsapp 0.2.2__cp311-cp311-manylinux_2_36_aarch64.whl → 0.2.5__cp311-cp311-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/pair.go

@@ -0,0 +1,248 @@
+// Copyright (c) 2021 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package whatsmeow
+
+import (
+	"bytes"
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/base64"
+	"fmt"
+	"strings"
+
+	"go.mau.fi/libsignal/ecc"
+	"google.golang.org/protobuf/proto"
+
+	waBinary "go.mau.fi/whatsmeow/binary"
+	"go.mau.fi/whatsmeow/proto/waAdv"
+	"go.mau.fi/whatsmeow/types"
+	"go.mau.fi/whatsmeow/types/events"
+	"go.mau.fi/whatsmeow/util/keys"
+)
+
+func (cli *Client) handleIQ(node *waBinary.Node) {
+	children := node.GetChildren()
+	if len(children) != 1 || node.Attrs["from"] != types.ServerJID {
+		return
+	}
+	switch children[0].Tag {
+	case "pair-device":
+		cli.handlePairDevice(node)
+	case "pair-success":
+		cli.handlePairSuccess(node)
+	}
+}
+
+func (cli *Client) handlePairDevice(node *waBinary.Node) {
+	pairDevice := node.GetChildByTag("pair-device")
+	err := cli.sendNode(waBinary.Node{
+		Tag: "iq",
+		Attrs: waBinary.Attrs{
+			"to":   node.Attrs["from"],
+			"id":   node.Attrs["id"],
+			"type": "result",
+		},
+	})
+	if err != nil {
+		cli.Log.Warnf("Failed to send acknowledgement for pair-device request: %v", err)
+	}
+
+	evt := &events.QR{Codes: make([]string, 0, len(pairDevice.GetChildren()))}
+	for i, child := range pairDevice.GetChildren() {
+		if child.Tag != "ref" {
+			cli.Log.Warnf("pair-device node contains unexpected child tag %s at index %d", child.Tag, i)
+			continue
+		}
+		content, ok := child.Content.([]byte)
+		if !ok {
+			cli.Log.Warnf("pair-device node contains unexpected child content type %T at index %d", child, i)
+			continue
+		}
+		evt.Codes = append(evt.Codes, cli.makeQRData(string(content)))
+	}
+
+	cli.dispatchEvent(evt)
+}
+
+func (cli *Client) makeQRData(ref string) string {
+	noise := base64.StdEncoding.EncodeToString(cli.Store.NoiseKey.Pub[:])
+	identity := base64.StdEncoding.EncodeToString(cli.Store.IdentityKey.Pub[:])
+	adv := base64.StdEncoding.EncodeToString(cli.Store.AdvSecretKey)
+	return strings.Join([]string{ref, noise, identity, adv}, ",")
+}
+
+func (cli *Client) handlePairSuccess(node *waBinary.Node) {
+	id := node.Attrs["id"].(string)
+	pairSuccess := node.GetChildByTag("pair-success")
+
+	deviceIdentityBytes, _ := pairSuccess.GetChildByTag("device-identity").Content.([]byte)
+	businessName, _ := pairSuccess.GetChildByTag("biz").Attrs["name"].(string)
+	jid, _ := pairSuccess.GetChildByTag("device").Attrs["jid"].(types.JID)
+	platform, _ := pairSuccess.GetChildByTag("platform").Attrs["name"].(string)
+
+	go func() {
+		err := cli.handlePair(deviceIdentityBytes, id, businessName, platform, jid)
+		if err != nil {
+			cli.Log.Errorf("Failed to pair device: %v", err)
+			cli.Disconnect()
+			cli.dispatchEvent(&events.PairError{ID: jid, BusinessName: businessName, Platform: platform, Error: err})
+		} else {
+			cli.Log.Infof("Successfully paired %s", cli.Store.ID)
+			cli.dispatchEvent(&events.PairSuccess{ID: jid, BusinessName: businessName, Platform: platform})
+		}
+	}()
+}
+
+func (cli *Client) handlePair(deviceIdentityBytes []byte, reqID, businessName, platform string, jid types.JID) error {
+	var deviceIdentityContainer waAdv.ADVSignedDeviceIdentityHMAC
+	err := proto.Unmarshal(deviceIdentityBytes, &deviceIdentityContainer)
+	if err != nil {
+		cli.sendPairError(reqID, 500, "internal-error")
+		return &PairProtoError{"failed to parse device identity container in pair success message", err}
+	}
+
+	h := hmac.New(sha256.New, cli.Store.AdvSecretKey)
+	h.Write(deviceIdentityContainer.Details)
+	if !bytes.Equal(h.Sum(nil), deviceIdentityContainer.HMAC) {
+		cli.Log.Warnf("Invalid HMAC from pair success message")
+		cli.sendPairError(reqID, 401, "not-authorized")
+		return ErrPairInvalidDeviceIdentityHMAC
+	}
+
+	var deviceIdentity waAdv.ADVSignedDeviceIdentity
+	err = proto.Unmarshal(deviceIdentityContainer.Details, &deviceIdentity)
+	if err != nil {
+		cli.sendPairError(reqID, 500, "internal-error")
+		return &PairProtoError{"failed to parse signed device identity in pair success message", err}
+	}
+
+	if !verifyDeviceIdentityAccountSignature(&deviceIdentity, cli.Store.IdentityKey) {
+		cli.sendPairError(reqID, 401, "not-authorized")
+		return ErrPairInvalidDeviceSignature
+	}
+
+	deviceIdentity.DeviceSignature = generateDeviceSignature(&deviceIdentity, cli.Store.IdentityKey)[:]
+
+	var deviceIdentityDetails waAdv.ADVDeviceIdentity
+	err = proto.Unmarshal(deviceIdentity.Details, &deviceIdentityDetails)
+	if err != nil {
+		cli.sendPairError(reqID, 500, "internal-error")
+		return &PairProtoError{"failed to parse device identity details in pair success message", err}
+	}
+
+	if cli.PrePairCallback != nil && !cli.PrePairCallback(jid, platform, businessName) {
+		cli.sendPairError(reqID, 500, "internal-error")
+		return ErrPairRejectedLocally
+	}
+
+	cli.Store.Account = proto.Clone(&deviceIdentity).(*waAdv.ADVSignedDeviceIdentity)
+
+	mainDeviceJID := jid
+	mainDeviceJID.Device = 0
+	mainDeviceIdentity := *(*[32]byte)(deviceIdentity.AccountSignatureKey)
+	deviceIdentity.AccountSignatureKey = nil
+
+	selfSignedDeviceIdentity, err := proto.Marshal(&deviceIdentity)
+	if err != nil {
+		cli.sendPairError(reqID, 500, "internal-error")
+		return &PairProtoError{"failed to marshal self-signed device identity", err}
+	}
+
+	cli.Store.ID = &jid
+	cli.Store.BusinessName = businessName
+	cli.Store.Platform = platform
+	err = cli.Store.Save()
+	if err != nil {
+		cli.sendPairError(reqID, 500, "internal-error")
+		return &PairDatabaseError{"failed to save device store", err}
+	}
+	err = cli.Store.Identities.PutIdentity(mainDeviceJID.SignalAddress().String(), mainDeviceIdentity)
+	if err != nil {
+		_ = cli.Store.Delete()
+		cli.sendPairError(reqID, 500, "internal-error")
+		return &PairDatabaseError{"failed to store main device identity", err}
+	}
+
+	// Expect a disconnect after this and don't dispatch the usual Disconnected event
+	cli.expectDisconnect()
+
+	err = cli.sendNode(waBinary.Node{
+		Tag: "iq",
+		Attrs: waBinary.Attrs{
+			"to":   types.ServerJID,
+			"type": "result",
+			"id":   reqID,
+		},
+		Content: []waBinary.Node{{
+			Tag: "pair-device-sign",
+			Content: []waBinary.Node{{
+				Tag: "device-identity",
+				Attrs: waBinary.Attrs{
+					"key-index": deviceIdentityDetails.GetKeyIndex(),
+				},
+				Content: selfSignedDeviceIdentity,
+			}},
+		}},
+	})
+	if err != nil {
+		_ = cli.Store.Delete()
+		return fmt.Errorf("failed to send pairing confirmation: %w", err)
+	}
+	return nil
+}
+
+func concatBytes(data ...[]byte) []byte {
+	length := 0
+	for _, item := range data {
+		length += len(item)
+	}
+	output := make([]byte, length)
+	ptr := 0
+	for _, item := range data {
+		ptr += copy(output[ptr:ptr+len(item)], item)
+	}
+	return output
+}
+
+func verifyDeviceIdentityAccountSignature(deviceIdentity *waAdv.ADVSignedDeviceIdentity, ikp *keys.KeyPair) bool {
+	if len(deviceIdentity.AccountSignatureKey) != 32 || len(deviceIdentity.AccountSignature) != 64 {
+		return false
+	}
+
+	signatureKey := ecc.NewDjbECPublicKey(*(*[32]byte)(deviceIdentity.AccountSignatureKey))
+	signature := *(*[64]byte)(deviceIdentity.AccountSignature)
+
+	message := concatBytes([]byte{6, 0}, deviceIdentity.Details, ikp.Pub[:])
+	return ecc.VerifySignature(signatureKey, message, signature)
+}
+
+func generateDeviceSignature(deviceIdentity *waAdv.ADVSignedDeviceIdentity, ikp *keys.KeyPair) *[64]byte {
+	message := concatBytes([]byte{6, 1}, deviceIdentity.Details, ikp.Pub[:], deviceIdentity.AccountSignatureKey)
+	sig := ecc.CalculateSignature(ecc.NewDjbECPrivateKey(*ikp.Priv), message)
+	return &sig
+}
+
+func (cli *Client) sendPairError(id string, code int, text string) {
+	err := cli.sendNode(waBinary.Node{
+		Tag: "iq",
+		Attrs: waBinary.Attrs{
+			"to":   types.ServerJID,
+			"type": "error",
+			"id":   id,
+		},
+		Content: []waBinary.Node{{
+			Tag: "error",
+			Attrs: waBinary.Attrs{
+				"code": code,
+				"text": text,
+			},
+		}},
+	})
+	if err != nil {
+		cli.Log.Errorf("Failed to send pair error node: %v", err)
+	}
+}

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/prekeys.go

@@ -0,0 +1,251 @@
+// Copyright (c) 2021 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package whatsmeow
+
+import (
+	"context"
+	"encoding/binary"
+	"fmt"
+	"time"
+
+	"go.mau.fi/libsignal/ecc"
+	"go.mau.fi/libsignal/keys/identity"
+	"go.mau.fi/libsignal/keys/prekey"
+	"go.mau.fi/libsignal/util/optional"
+
+	waBinary "go.mau.fi/whatsmeow/binary"
+	"go.mau.fi/whatsmeow/types"
+	"go.mau.fi/whatsmeow/util/keys"
+)
+
+const (
+	// WantedPreKeyCount is the number of prekeys that the client should upload to the WhatsApp servers in a single batch.
+	WantedPreKeyCount = 50
+	// MinPreKeyCount is the number of prekeys when the client will upload a new batch of prekeys to the WhatsApp servers.
+	MinPreKeyCount = 5
+)
+
+func (cli *Client) getServerPreKeyCount() (int, error) {
+	resp, err := cli.sendIQ(infoQuery{
+		Namespace: "encrypt",
+		Type:      "get",
+		To:        types.ServerJID,
+		Content: []waBinary.Node{
+			{Tag: "count"},
+		},
+	})
+	if err != nil {
+		return 0, fmt.Errorf("failed to get prekey count on server: %w", err)
+	}
+	count := resp.GetChildByTag("count")
+	ag := count.AttrGetter()
+	val := ag.Int("value")
+	return val, ag.Error()
+}
+
+func (cli *Client) uploadPreKeys() {
+	cli.uploadPreKeysLock.Lock()
+	defer cli.uploadPreKeysLock.Unlock()
+	if cli.lastPreKeyUpload.Add(10 * time.Minute).After(time.Now()) {
+		sc, _ := cli.getServerPreKeyCount()
+		if sc >= WantedPreKeyCount {
+			cli.Log.Debugf("Canceling prekey upload request due to likely race condition")
+			return
+		}
+	}
+	var registrationIDBytes [4]byte
+	binary.BigEndian.PutUint32(registrationIDBytes[:], cli.Store.RegistrationID)
+	preKeys, err := cli.Store.PreKeys.GetOrGenPreKeys(WantedPreKeyCount)
+	if err != nil {
+		cli.Log.Errorf("Failed to get prekeys to upload: %v", err)
+		return
+	}
+	cli.Log.Infof("Uploading %d new prekeys to server", len(preKeys))
+	_, err = cli.sendIQ(infoQuery{
+		Namespace: "encrypt",
+		Type:      "set",
+		To:        types.ServerJID,
+		Content: []waBinary.Node{
+			{Tag: "registration", Content: registrationIDBytes[:]},
+			{Tag: "type", Content: []byte{ecc.DjbType}},
+			{Tag: "identity", Content: cli.Store.IdentityKey.Pub[:]},
+			{Tag: "list", Content: preKeysToNodes(preKeys)},
+			preKeyToNode(cli.Store.SignedPreKey),
+		},
+	})
+	if err != nil {
+		cli.Log.Errorf("Failed to send request to upload prekeys: %v", err)
+		return
+	}
+	cli.Log.Debugf("Got response to uploading prekeys")
+	err = cli.Store.PreKeys.MarkPreKeysAsUploaded(preKeys[len(preKeys)-1].KeyID)
+	if err != nil {
+		cli.Log.Warnf("Failed to mark prekeys as uploaded: %v", err)
+	}
+	cli.lastPreKeyUpload = time.Now()
+}
+
+type preKeyResp struct {
+	bundle *prekey.Bundle
+	err    error
+}
+
+func (cli *Client) fetchPreKeys(ctx context.Context, users []types.JID) (map[types.JID]preKeyResp, error) {
+	requests := make([]waBinary.Node, len(users))
+	for i, user := range users {
+		requests[i].Tag = "user"
+		requests[i].Attrs = waBinary.Attrs{
+			"jid":    user,
+			"reason": "identity",
+		}
+	}
+	resp, err := cli.sendIQ(infoQuery{
+		Context:   ctx,
+		Namespace: "encrypt",
+		Type:      "get",
+		To:        types.ServerJID,
+		Content: []waBinary.Node{{
+			Tag:     "key",
+			Content: requests,
+		}},
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to send prekey request: %w", err)
+	} else if len(resp.GetChildren()) == 0 {
+		return nil, fmt.Errorf("got empty response to prekey request")
+	}
+	list := resp.GetChildByTag("list")
+	respData := make(map[types.JID]preKeyResp)
+	for _, child := range list.GetChildren() {
+		if child.Tag != "user" {
+			continue
+		}
+		jid := child.AttrGetter().JID("jid")
+		bundle, err := nodeToPreKeyBundle(uint32(jid.Device), child)
+		respData[jid] = preKeyResp{bundle, err}
+	}
+	return respData, nil
+}
+
+func preKeyToNode(key *keys.PreKey) waBinary.Node {
+	var keyID [4]byte
+	binary.BigEndian.PutUint32(keyID[:], key.KeyID)
+	node := waBinary.Node{
+		Tag: "key",
+		Content: []waBinary.Node{
+			{Tag: "id", Content: keyID[1:]},
+			{Tag: "value", Content: key.Pub[:]},
+		},
+	}
+	if key.Signature != nil {
+		node.Tag = "skey"
+		node.Content = append(node.GetChildren(), waBinary.Node{
+			Tag:     "signature",
+			Content: key.Signature[:],
+		})
+	}
+	return node
+}
+
+func nodeToPreKeyBundle(deviceID uint32, node waBinary.Node) (*prekey.Bundle, error) {
+	errorNode, ok := node.GetOptionalChildByTag("error")
+	if ok && errorNode.Tag == "error" {
+		return nil, fmt.Errorf("got error getting prekeys: %s", errorNode.XMLString())
+	}
+
+	registrationBytes, ok := node.GetChildByTag("registration").Content.([]byte)
+	if !ok || len(registrationBytes) != 4 {
+		return nil, fmt.Errorf("invalid registration ID in prekey response")
+	}
+	registrationID := binary.BigEndian.Uint32(registrationBytes)
+
+	keysNode, ok := node.GetOptionalChildByTag("keys")
+	if !ok {
+		keysNode = node
+	}
+
+	identityKeyRaw, ok := keysNode.GetChildByTag("identity").Content.([]byte)
+	if !ok || len(identityKeyRaw) != 32 {
+		return nil, fmt.Errorf("invalid identity key in prekey response")
+	}
+	identityKeyPub := *(*[32]byte)(identityKeyRaw)
+
+	preKeyNode, ok := keysNode.GetOptionalChildByTag("key")
+	preKey := &keys.PreKey{}
+	if ok {
+		var err error
+		preKey, err = nodeToPreKey(preKeyNode)
+		if err != nil {
+			return nil, fmt.Errorf("invalid prekey in prekey response: %w", err)
+		}
+	}
+
+	signedPreKey, err := nodeToPreKey(keysNode.GetChildByTag("skey"))
+	if err != nil {
+		return nil, fmt.Errorf("invalid signed prekey in prekey response: %w", err)
+	}
+
+	var bundle *prekey.Bundle
+	if ok {
+		bundle = prekey.NewBundle(registrationID, deviceID,
+			optional.NewOptionalUint32(preKey.KeyID), signedPreKey.KeyID,
+			ecc.NewDjbECPublicKey(*preKey.Pub), ecc.NewDjbECPublicKey(*signedPreKey.Pub), *signedPreKey.Signature,
+			identity.NewKey(ecc.NewDjbECPublicKey(identityKeyPub)))
+	} else {
+		bundle = prekey.NewBundle(registrationID, deviceID, optional.NewEmptyUint32(), signedPreKey.KeyID,
+			nil, ecc.NewDjbECPublicKey(*signedPreKey.Pub), *signedPreKey.Signature,
+			identity.NewKey(ecc.NewDjbECPublicKey(identityKeyPub)))
+	}
+
+	return bundle, nil
+}
+
+func nodeToPreKey(node waBinary.Node) (*keys.PreKey, error) {
+	key := keys.PreKey{
+		KeyPair:   keys.KeyPair{},
+		KeyID:     0,
+		Signature: nil,
+	}
+	if id := node.GetChildByTag("id"); id.Tag != "id" {
+		return nil, fmt.Errorf("prekey node doesn't contain ID tag")
+	} else if idBytes, ok := id.Content.([]byte); !ok {
+		return nil, fmt.Errorf("prekey ID has unexpected content (%T)", id.Content)
+	} else if len(idBytes) != 3 {
+		return nil, fmt.Errorf("prekey ID has unexpected number of bytes (%d, expected 3)", len(idBytes))
+	} else {
+		key.KeyID = binary.BigEndian.Uint32(append([]byte{0}, idBytes...))
+	}
+	if pubkey := node.GetChildByTag("value"); pubkey.Tag != "value" {
+		return nil, fmt.Errorf("prekey node doesn't contain value tag")
+	} else if pubkeyBytes, ok := pubkey.Content.([]byte); !ok {
+		return nil, fmt.Errorf("prekey value has unexpected content (%T)", pubkey.Content)
+	} else if len(pubkeyBytes) != 32 {
+		return nil, fmt.Errorf("prekey value has unexpected number of bytes (%d, expected 32)", len(pubkeyBytes))
+	} else {
+		key.KeyPair.Pub = (*[32]byte)(pubkeyBytes)
+	}
+	if node.Tag == "skey" {
+		if sig := node.GetChildByTag("signature"); sig.Tag != "signature" {
+			return nil, fmt.Errorf("prekey node doesn't contain signature tag")
+		} else if sigBytes, ok := sig.Content.([]byte); !ok {
+			return nil, fmt.Errorf("prekey signature has unexpected content (%T)", sig.Content)
+		} else if len(sigBytes) != 64 {
+			return nil, fmt.Errorf("prekey signature has unexpected number of bytes (%d, expected 64)", len(sigBytes))
+		} else {
+			key.Signature = (*[64]byte)(sigBytes)
+		}
+	}
+	return &key, nil
+}
+
+func preKeysToNodes(prekeys []*keys.PreKey) []waBinary.Node {
+	nodes := make([]waBinary.Node, len(prekeys))
+	for i, key := range prekeys {
+		nodes[i] = preKeyToNode(key)
+	}
+	return nodes
+}

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/presence.go

@@ -0,0 +1,138 @@
+// Copyright (c) 2021 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package whatsmeow
+
+import (
+	"fmt"
+
+	waBinary "go.mau.fi/whatsmeow/binary"
+	"go.mau.fi/whatsmeow/types"
+	"go.mau.fi/whatsmeow/types/events"
+)
+
+func (cli *Client) handleChatState(node *waBinary.Node) {
+	source, err := cli.parseMessageSource(node, true)
+	if err != nil {
+		cli.Log.Warnf("Failed to parse chat state update: %v", err)
+	} else if len(node.GetChildren()) != 1 {
+		cli.Log.Warnf("Failed to parse chat state update: unexpected number of children in element (%d)", len(node.GetChildren()))
+	} else {
+		child := node.GetChildren()[0]
+		presence := types.ChatPresence(child.Tag)
+		if presence != types.ChatPresenceComposing && presence != types.ChatPresencePaused {
+			cli.Log.Warnf("Unrecognized chat presence state %s", child.Tag)
+		}
+		media := types.ChatPresenceMedia(child.AttrGetter().OptionalString("media"))
+		cli.dispatchEvent(&events.ChatPresence{
+			MessageSource: source,
+			State:         presence,
+			Media:         media,
+		})
+	}
+}
+
+func (cli *Client) handlePresence(node *waBinary.Node) {
+	var evt events.Presence
+	ag := node.AttrGetter()
+	evt.From = ag.JID("from")
+	presenceType := ag.OptionalString("type")
+	if presenceType == "unavailable" {
+		evt.Unavailable = true
+	} else if presenceType != "" {
+		cli.Log.Debugf("Unrecognized presence type '%s' in presence event from %s", presenceType, evt.From)
+	}
+	lastSeen := ag.OptionalString("last")
+	if lastSeen != "" && lastSeen != "deny" {
+		evt.LastSeen = ag.UnixTime("last")
+	}
+	if !ag.OK() {
+		cli.Log.Warnf("Error parsing presence event: %+v", ag.Errors)
+	} else {
+		cli.dispatchEvent(&evt)
+	}
+}
+
+// SendPresence updates the user's presence status on WhatsApp.
+//
+// You should call this at least once after connecting so that the server has your pushname.
+// Otherwise, other users will see "-" as the name.
+func (cli *Client) SendPresence(state types.Presence) error {
+	if len(cli.Store.PushName) == 0 {
+		return ErrNoPushName
+	}
+	if state == types.PresenceAvailable {
+		cli.sendActiveReceipts.CompareAndSwap(0, 1)
+	} else {
+		cli.sendActiveReceipts.CompareAndSwap(1, 0)
+	}
+	return cli.sendNode(waBinary.Node{
+		Tag: "presence",
+		Attrs: waBinary.Attrs{
+			"name": cli.Store.PushName,
+			"type": string(state),
+		},
+	})
+}
+
+// SubscribePresence asks the WhatsApp servers to send presence updates of a specific user to this client.
+//
+// After subscribing to this event, you should start receiving *events.Presence for that user in normal event handlers.
+//
+// Also, it seems that the WhatsApp servers require you to be online to receive presence status from other users,
+// so you should mark yourself as online before trying to use this function:
+//
+//	cli.SendPresence(types.PresenceAvailable)
+func (cli *Client) SubscribePresence(jid types.JID) error {
+	privacyToken, err := cli.Store.PrivacyTokens.GetPrivacyToken(jid)
+	if err != nil {
+		return fmt.Errorf("failed to get privacy token: %w", err)
+	} else if privacyToken == nil {
+		if cli.ErrorOnSubscribePresenceWithoutToken {
+			return fmt.Errorf("%w for %v", ErrNoPrivacyToken, jid.ToNonAD())
+		} else {
+			cli.Log.Debugf("Trying to subscribe to presence of %s without privacy token", jid)
+		}
+	}
+	req := waBinary.Node{
+		Tag: "presence",
+		Attrs: waBinary.Attrs{
+			"type": "subscribe",
+			"to":   jid,
+		},
+	}
+	if privacyToken != nil {
+		req.Content = []waBinary.Node{{
+			Tag:     "tctoken",
+			Content: privacyToken.Token,
+		}}
+	}
+	return cli.sendNode(req)
+}
+
+// SendChatPresence updates the user's typing status in a specific chat.
+//
+// The media parameter can be set to indicate the user is recording media (like a voice message) rather than typing a text message.
+func (cli *Client) SendChatPresence(jid types.JID, state types.ChatPresence, media types.ChatPresenceMedia) error {
+	ownID := cli.getOwnID()
+	if ownID.IsEmpty() {
+		return ErrNotLoggedIn
+	}
+	content := []waBinary.Node{{Tag: string(state)}}
+	if state == types.ChatPresenceComposing && len(media) > 0 {
+		content[0].Attrs = waBinary.Attrs{
+			"media": string(media),
+		}
+	}
+	return cli.sendNode(waBinary.Node{
+		Tag: "chatstate",
+		Attrs: waBinary.Attrs{
+			"from": ownID,
+			"to":   jid,
+		},
+		Content: content,
+	})
+}