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/qrchan.go

@@ -0,0 +1,180 @@
+// Copyright (c) 2022 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"
+	"slices"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"go.mau.fi/whatsmeow/types/events"
+	waLog "go.mau.fi/whatsmeow/util/log"
+)
+
+type QRChannelItem struct {
+	// The type of event, "code" for new QR codes (see Code field) and "error" for pairing errors (see Error) field.
+	// For non-code/error events, you can just compare the whole item to the event variables (like QRChannelSuccess).
+	Event string
+	// If the item is a pair error, then this field contains the error message.
+	Error error
+	// If the item is a new code, then this field contains the raw data.
+	Code string
+	// The timeout after which the next code will be sent down the channel.
+	Timeout time.Duration
+}
+
+const QRChannelEventCode = "code"
+const QRChannelEventError = "error"
+
+// Possible final items in the QR channel. In addition to these, an `error` event may be emitted,
+// in which case the Error field will have the error that occurred during pairing.
+var (
+	// QRChannelSuccess is emitted from GetQRChannel when the pairing is successful.
+	QRChannelSuccess = QRChannelItem{Event: "success"}
+	// QRChannelTimeout is emitted from GetQRChannel if the socket gets disconnected by the server before the pairing is successful.
+	QRChannelTimeout = QRChannelItem{Event: "timeout"}
+	// QRChannelErrUnexpectedEvent is emitted from GetQRChannel if an unexpected connection event is received,
+	// as that likely means that the pairing has already happened before the channel was set up.
+	QRChannelErrUnexpectedEvent = QRChannelItem{Event: "err-unexpected-state"}
+	// QRChannelClientOutdated is emitted from GetQRChannel if events.ClientOutdated is received.
+	QRChannelClientOutdated = QRChannelItem{Event: "err-client-outdated"}
+	// QRChannelScannedWithoutMultidevice is emitted from GetQRChannel if events.QRScannedWithoutMultidevice is received.
+	QRChannelScannedWithoutMultidevice = QRChannelItem{Event: "err-scanned-without-multidevice"}
+)
+
+type qrChannel struct {
+	sync.Mutex
+	cli       *Client
+	log       waLog.Logger
+	ctx       context.Context
+	handlerID uint32
+	closed    uint32
+	output    chan<- QRChannelItem
+	stopQRs   chan struct{}
+}
+
+func (qrc *qrChannel) emitQRs(codes []string) {
+	var nextCode string
+	for {
+		if len(codes) == 0 {
+			if atomic.CompareAndSwapUint32(&qrc.closed, 0, 1) {
+				qrc.log.Debugf("Ran out of QR codes, closing channel with status %s and disconnecting client", QRChannelTimeout)
+				qrc.output <- QRChannelTimeout
+				close(qrc.output)
+				go qrc.cli.RemoveEventHandler(qrc.handlerID)
+				qrc.cli.Disconnect()
+			} else {
+				qrc.log.Debugf("Ran out of QR codes, but channel is already closed")
+			}
+			return
+		} else if atomic.LoadUint32(&qrc.closed) == 1 {
+			qrc.log.Debugf("QR code channel is closed, exiting QR emitter")
+			return
+		}
+		timeout := 20 * time.Second
+		if len(codes) == 6 {
+			timeout = 60 * time.Second
+		}
+		nextCode, codes = codes[0], codes[1:]
+		qrc.log.Debugf("Emitting QR code %s", nextCode)
+		select {
+		case qrc.output <- QRChannelItem{Code: nextCode, Timeout: timeout, Event: QRChannelEventCode}:
+		default:
+			qrc.log.Debugf("Output channel didn't accept code, exiting QR emitter")
+			if atomic.CompareAndSwapUint32(&qrc.closed, 0, 1) {
+				close(qrc.output)
+				go qrc.cli.RemoveEventHandler(qrc.handlerID)
+				qrc.cli.Disconnect()
+			}
+			return
+		}
+		select {
+		case <-time.After(timeout):
+		case <-qrc.stopQRs:
+			qrc.log.Debugf("Got signal to stop QR emitter")
+			return
+		case <-qrc.ctx.Done():
+			qrc.log.Debugf("Context is done, stopping QR emitter")
+			if atomic.CompareAndSwapUint32(&qrc.closed, 0, 1) {
+				close(qrc.output)
+				go qrc.cli.RemoveEventHandler(qrc.handlerID)
+				qrc.cli.Disconnect()
+			}
+		}
+	}
+}
+
+func (qrc *qrChannel) handleEvent(rawEvt interface{}) {
+	if atomic.LoadUint32(&qrc.closed) == 1 {
+		qrc.log.Debugf("Dropping event of type %T, channel is closed", rawEvt)
+		return
+	}
+	var outputType QRChannelItem
+	switch evt := rawEvt.(type) {
+	case *events.QR:
+		qrc.log.Debugf("Received QR code event, starting to emit codes to channel")
+		go qrc.emitQRs(slices.Clone(evt.Codes))
+		return
+	case *events.QRScannedWithoutMultidevice:
+		qrc.log.Debugf("QR code scanned without multidevice enabled")
+		qrc.output <- QRChannelScannedWithoutMultidevice
+		return
+	case *events.ClientOutdated:
+		outputType = QRChannelClientOutdated
+	case *events.PairSuccess:
+		outputType = QRChannelSuccess
+	case *events.PairError:
+		outputType = QRChannelItem{
+			Event: QRChannelEventError,
+			Error: evt.Error,
+		}
+	case *events.Disconnected:
+		outputType = QRChannelTimeout
+	case *events.Connected, *events.ConnectFailure, *events.LoggedOut, *events.TemporaryBan:
+		outputType = QRChannelErrUnexpectedEvent
+	default:
+		return
+	}
+	close(qrc.stopQRs)
+	if atomic.CompareAndSwapUint32(&qrc.closed, 0, 1) {
+		qrc.log.Debugf("Closing channel with status %+v", outputType)
+		qrc.output <- outputType
+		close(qrc.output)
+	} else {
+		qrc.log.Debugf("Got status %+v, but channel is already closed", outputType)
+	}
+	// Has to be done in background because otherwise there's a deadlock with eventHandlersLock
+	go qrc.cli.RemoveEventHandler(qrc.handlerID)
+}
+
+// GetQRChannel returns a channel that automatically outputs a new QR code when the previous one expires.
+//
+// This must be called *before* Connect(). It will then listen to all the relevant events from the client.
+//
+// The last value to be emitted will be a special event like "success", "timeout" or another error code
+// depending on the result of the pairing. The channel will be closed immediately after one of those.
+func (cli *Client) GetQRChannel(ctx context.Context) (<-chan QRChannelItem, error) {
+	if cli == nil {
+		return nil, ErrClientIsNil
+	} else if cli.IsConnected() {
+		return nil, ErrQRAlreadyConnected
+	} else if cli.Store.ID != nil {
+		return nil, ErrQRStoreContainsID
+	}
+	ch := make(chan QRChannelItem, 8)
+	qrc := qrChannel{
+		output:  ch,
+		stopQRs: make(chan struct{}),
+		cli:     cli,
+		log:     cli.Log.Sub("QRChannel"),
+		ctx:     ctx,
+	}
+	qrc.handlerID = cli.AddEventHandler(qrc.handleEvent)
+	return ch, nil
+}

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

@@ -0,0 +1,238 @@
+// 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"
+	"time"
+
+	waBinary "go.mau.fi/whatsmeow/binary"
+	"go.mau.fi/whatsmeow/types"
+	"go.mau.fi/whatsmeow/types/events"
+)
+
+func (cli *Client) handleReceipt(node *waBinary.Node) {
+	defer cli.maybeDeferredAck(node)()
+	receipt, err := cli.parseReceipt(node)
+	if err != nil {
+		cli.Log.Warnf("Failed to parse receipt: %v", err)
+	} else if receipt != nil {
+		if receipt.Type == types.ReceiptTypeRetry {
+			go func() {
+				err := cli.handleRetryReceipt(receipt, node)
+				if err != nil {
+					cli.Log.Errorf("Failed to handle retry receipt for %s/%s from %s: %v", receipt.Chat, receipt.MessageIDs[0], receipt.Sender, err)
+				}
+			}()
+		}
+		cli.dispatchEvent(receipt)
+	}
+}
+
+func (cli *Client) handleGroupedReceipt(partialReceipt events.Receipt, participants *waBinary.Node) {
+	pag := participants.AttrGetter()
+	partialReceipt.MessageIDs = []types.MessageID{pag.String("key")}
+	for _, child := range participants.GetChildren() {
+		if child.Tag != "user" {
+			cli.Log.Warnf("Unexpected node in grouped receipt participants: %s", child.XMLString())
+			continue
+		}
+		ag := child.AttrGetter()
+		receipt := partialReceipt
+		receipt.Timestamp = ag.UnixTime("t")
+		receipt.MessageSource.Sender = ag.JID("jid")
+		if !ag.OK() {
+			cli.Log.Warnf("Failed to parse user node %s in grouped receipt: %v", child.XMLString(), ag.Error())
+			continue
+		}
+		go cli.dispatchEvent(&receipt)
+	}
+}
+
+func (cli *Client) parseReceipt(node *waBinary.Node) (*events.Receipt, error) {
+	ag := node.AttrGetter()
+	source, err := cli.parseMessageSource(node, false)
+	if err != nil {
+		return nil, err
+	}
+	receipt := events.Receipt{
+		MessageSource: source,
+		Timestamp:     ag.UnixTime("t"),
+		Type:          types.ReceiptType(ag.OptionalString("type")),
+		MessageSender: ag.OptionalJIDOrEmpty("recipient"),
+	}
+	if source.IsGroup && source.Sender.IsEmpty() {
+		participantTags := node.GetChildrenByTag("participants")
+		if len(participantTags) == 0 {
+			return nil, &ElementMissingError{Tag: "participants", In: "grouped receipt"}
+		}
+		for _, pcp := range participantTags {
+			cli.handleGroupedReceipt(receipt, &pcp)
+		}
+		return nil, nil
+	}
+	mainMessageID := ag.String("id")
+	if !ag.OK() {
+		return nil, fmt.Errorf("failed to parse read receipt attrs: %+v", ag.Errors)
+	}
+
+	receiptChildren := node.GetChildren()
+	if len(receiptChildren) == 1 && receiptChildren[0].Tag == "list" {
+		listChildren := receiptChildren[0].GetChildren()
+		receipt.MessageIDs = make([]string, 1, len(listChildren)+1)
+		receipt.MessageIDs[0] = mainMessageID
+		for _, item := range listChildren {
+			if id, ok := item.Attrs["id"].(string); ok && item.Tag == "item" {
+				receipt.MessageIDs = append(receipt.MessageIDs, id)
+			}
+		}
+	} else {
+		receipt.MessageIDs = []types.MessageID{mainMessageID}
+	}
+	return &receipt, nil
+}
+
+func (cli *Client) maybeDeferredAck(node *waBinary.Node) func() {
+	if cli.SynchronousAck {
+		return func() {
+			cli.sendAck(node)
+		}
+	} else {
+		go cli.sendAck(node)
+		return func() {}
+	}
+}
+
+func (cli *Client) sendAck(node *waBinary.Node) {
+	attrs := waBinary.Attrs{
+		"class": node.Tag,
+		"id":    node.Attrs["id"],
+	}
+	attrs["to"] = node.Attrs["from"]
+	if participant, ok := node.Attrs["participant"]; ok {
+		attrs["participant"] = participant
+	}
+	if recipient, ok := node.Attrs["recipient"]; ok {
+		attrs["recipient"] = recipient
+	}
+	if receiptType, ok := node.Attrs["type"]; node.Tag != "message" && ok {
+		attrs["type"] = receiptType
+	}
+	err := cli.sendNode(waBinary.Node{
+		Tag:   "ack",
+		Attrs: attrs,
+	})
+	if err != nil {
+		cli.Log.Warnf("Failed to send acknowledgement for %s %s: %v", node.Tag, node.Attrs["id"], err)
+	}
+}
+
+// MarkRead sends a read receipt for the given message IDs including the given timestamp as the read at time.
+//
+// The first JID parameter (chat) must always be set to the chat ID (user ID in DMs and group ID in group chats).
+// The second JID parameter (sender) must be set in group chats and must be the user ID who sent the message.
+//
+// You can mark multiple messages as read at the same time, but only if the messages were sent by the same user.
+// To mark messages by different users as read, you must call MarkRead multiple times (once for each user).
+//
+// To mark a voice message as played, specify types.ReceiptTypePlayed as the last parameter.
+// Providing more than one receipt type will panic: the parameter is only a vararg for backwards compatibility.
+func (cli *Client) MarkRead(ids []types.MessageID, timestamp time.Time, chat, sender types.JID, receiptTypeExtra ...types.ReceiptType) error {
+	if len(ids) == 0 {
+		return fmt.Errorf("no message IDs specified")
+	}
+	receiptType := types.ReceiptTypeRead
+	if len(receiptTypeExtra) == 1 {
+		receiptType = receiptTypeExtra[0]
+	} else if len(receiptTypeExtra) > 1 {
+		panic(fmt.Errorf("too many receipt types specified"))
+	}
+	node := waBinary.Node{
+		Tag: "receipt",
+		Attrs: waBinary.Attrs{
+			"id":   ids[0],
+			"type": string(receiptType),
+			"to":   chat,
+			"t":    timestamp.Unix(),
+		},
+	}
+	if chat.Server == types.NewsletterServer || cli.GetPrivacySettings().ReadReceipts == types.PrivacySettingNone {
+		switch receiptType {
+		case types.ReceiptTypeRead:
+			node.Attrs["type"] = string(types.ReceiptTypeReadSelf)
+			// TODO change played to played-self?
+		}
+	}
+	if !sender.IsEmpty() && chat.Server != types.DefaultUserServer && chat.Server != types.MessengerServer {
+		node.Attrs["participant"] = sender.ToNonAD()
+	}
+	if len(ids) > 1 {
+		children := make([]waBinary.Node, len(ids)-1)
+		for i := 1; i < len(ids); i++ {
+			children[i-1].Tag = "item"
+			children[i-1].Attrs = waBinary.Attrs{"id": ids[i]}
+		}
+		node.Content = []waBinary.Node{{
+			Tag:     "list",
+			Content: children,
+		}}
+	}
+	return cli.sendNode(node)
+}
+
+// SetForceActiveDeliveryReceipts will force the client to send normal delivery
+// receipts (which will show up as the two gray ticks on WhatsApp), even if the
+// client isn't marked as online.
+//
+// By default, clients that haven't been marked as online will send delivery
+// receipts with type="inactive", which is transmitted to the sender, but not
+// rendered in the official WhatsApp apps. This is consistent with how WhatsApp
+// web works when it's not in the foreground.
+//
+// To mark the client as online, use
+//
+//	cli.SendPresence(types.PresenceAvailable)
+//
+// Note that if you turn this off (i.e. call SetForceActiveDeliveryReceipts(false)),
+// receipts will act like the client is offline until SendPresence is called again.
+func (cli *Client) SetForceActiveDeliveryReceipts(active bool) {
+	if cli == nil {
+		return
+	}
+	if active {
+		cli.sendActiveReceipts.Store(2)
+	} else {
+		cli.sendActiveReceipts.Store(0)
+	}
+}
+
+func (cli *Client) sendMessageReceipt(info *types.MessageInfo) {
+	attrs := waBinary.Attrs{
+		"id": info.ID,
+	}
+	if info.IsFromMe {
+		attrs["type"] = string(types.ReceiptTypeSender)
+	} else if cli.sendActiveReceipts.Load() == 0 {
+		attrs["type"] = string(types.ReceiptTypeInactive)
+	}
+	attrs["to"] = info.Chat
+	if info.IsGroup {
+		attrs["participant"] = info.Sender
+	} else if info.IsFromMe {
+		attrs["recipient"] = info.Sender
+	} else {
+		// Override the to attribute with the JID version with a device number
+		attrs["to"] = info.Sender
+	}
+	err := cli.sendNode(waBinary.Node{
+		Tag:   "receipt",
+		Attrs: attrs,
+	})
+	if err != nil {
+		cli.Log.Warnf("Failed to send receipt for %s: %v", info.ID, err)
+	}
+}

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

@@ -0,0 +1,225 @@
+// 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"
+	"fmt"
+	"strconv"
+	"time"
+
+	waBinary "go.mau.fi/whatsmeow/binary"
+	"go.mau.fi/whatsmeow/types"
+)
+
+func (cli *Client) generateRequestID() string {
+	return cli.uniqueID + strconv.FormatUint(cli.idCounter.Add(1), 10)
+}
+
+var xmlStreamEndNode = &waBinary.Node{Tag: "xmlstreamend"}
+
+func isDisconnectNode(node *waBinary.Node) bool {
+	return node == xmlStreamEndNode || node.Tag == "stream:error"
+}
+
+// isAuthErrorDisconnect checks if the given disconnect node is an error that shouldn't cause retrying.
+func isAuthErrorDisconnect(node *waBinary.Node) bool {
+	if node.Tag != "stream:error" {
+		return false
+	}
+	code, _ := node.Attrs["code"].(string)
+	conflict, _ := node.GetOptionalChildByTag("conflict")
+	conflictType := conflict.AttrGetter().OptionalString("type")
+	if code == "401" || conflictType == "replaced" || conflictType == "device_removed" {
+		return true
+	}
+	return false
+}
+
+func (cli *Client) clearResponseWaiters(node *waBinary.Node) {
+	cli.responseWaitersLock.Lock()
+	for _, waiter := range cli.responseWaiters {
+		select {
+		case waiter <- node:
+		default:
+			close(waiter)
+		}
+	}
+	cli.responseWaiters = make(map[string]chan<- *waBinary.Node)
+	cli.responseWaitersLock.Unlock()
+}
+
+func (cli *Client) waitResponse(reqID string) chan *waBinary.Node {
+	ch := make(chan *waBinary.Node, 1)
+	cli.responseWaitersLock.Lock()
+	cli.responseWaiters[reqID] = ch
+	cli.responseWaitersLock.Unlock()
+	return ch
+}
+
+func (cli *Client) cancelResponse(reqID string, ch chan *waBinary.Node) {
+	cli.responseWaitersLock.Lock()
+	close(ch)
+	delete(cli.responseWaiters, reqID)
+	cli.responseWaitersLock.Unlock()
+}
+
+func (cli *Client) receiveResponse(data *waBinary.Node) bool {
+	id, ok := data.Attrs["id"].(string)
+	if !ok || (data.Tag != "iq" && data.Tag != "ack") {
+		return false
+	}
+	cli.responseWaitersLock.Lock()
+	waiter, ok := cli.responseWaiters[id]
+	if !ok {
+		cli.responseWaitersLock.Unlock()
+		return false
+	}
+	delete(cli.responseWaiters, id)
+	cli.responseWaitersLock.Unlock()
+	waiter <- data
+	return true
+}
+
+type infoQueryType string
+
+const (
+	iqSet infoQueryType = "set"
+	iqGet infoQueryType = "get"
+)
+
+type infoQuery struct {
+	Namespace string
+	Type      infoQueryType
+	To        types.JID
+	Target    types.JID
+	ID        string
+	Content   interface{}
+
+	Timeout time.Duration
+	NoRetry bool
+	Context context.Context
+}
+
+func (cli *Client) sendIQAsyncAndGetData(query *infoQuery) (<-chan *waBinary.Node, []byte, error) {
+	if cli == nil {
+		return nil, nil, ErrClientIsNil
+	}
+	if len(query.ID) == 0 {
+		query.ID = cli.generateRequestID()
+	}
+	waiter := cli.waitResponse(query.ID)
+	attrs := waBinary.Attrs{
+		"id":    query.ID,
+		"xmlns": query.Namespace,
+		"type":  string(query.Type),
+	}
+	if !query.To.IsEmpty() {
+		attrs["to"] = query.To
+	}
+	if !query.Target.IsEmpty() {
+		attrs["target"] = query.Target
+	}
+	data, err := cli.sendNodeAndGetData(waBinary.Node{
+		Tag:     "iq",
+		Attrs:   attrs,
+		Content: query.Content,
+	})
+	if err != nil {
+		cli.cancelResponse(query.ID, waiter)
+		return nil, data, err
+	}
+	return waiter, data, nil
+}
+
+func (cli *Client) sendIQAsync(query infoQuery) (<-chan *waBinary.Node, error) {
+	ch, _, err := cli.sendIQAsyncAndGetData(&query)
+	return ch, err
+}
+
+const defaultRequestTimeout = 75 * time.Second
+
+func (cli *Client) sendIQ(query infoQuery) (*waBinary.Node, error) {
+	resChan, data, err := cli.sendIQAsyncAndGetData(&query)
+	if err != nil {
+		return nil, err
+	}
+	if query.Timeout == 0 {
+		query.Timeout = defaultRequestTimeout
+	}
+	if query.Context == nil {
+		query.Context = context.Background()
+	}
+	select {
+	case res := <-resChan:
+		if isDisconnectNode(res) {
+			if query.NoRetry {
+				return nil, &DisconnectedError{Action: "info query", Node: res}
+			}
+			res, err = cli.retryFrame("info query", query.ID, data, res, query.Context, query.Timeout)
+			if err != nil {
+				return nil, err
+			}
+		}
+		resType, _ := res.Attrs["type"].(string)
+		if res.Tag != "iq" || (resType != "result" && resType != "error") {
+			return res, &IQError{RawNode: res}
+		} else if resType == "error" {
+			return res, parseIQError(res)
+		}
+		return res, nil
+	case <-query.Context.Done():
+		return nil, query.Context.Err()
+	case <-time.After(query.Timeout):
+		return nil, ErrIQTimedOut
+	}
+}
+
+func (cli *Client) retryFrame(reqType, id string, data []byte, origResp *waBinary.Node, ctx context.Context, timeout time.Duration) (*waBinary.Node, error) {
+	if isAuthErrorDisconnect(origResp) {
+		cli.Log.Debugf("%s (%s) was interrupted by websocket disconnection (%s), not retrying as it looks like an auth error", id, reqType, origResp.XMLString())
+		return nil, &DisconnectedError{Action: reqType, Node: origResp}
+	}
+
+	cli.Log.Debugf("%s (%s) was interrupted by websocket disconnection (%s), waiting for reconnect to retry...", id, reqType, origResp.XMLString())
+	if !cli.WaitForConnection(5 * time.Second) {
+		cli.Log.Debugf("Websocket didn't reconnect within 5 seconds of failed %s (%s)", reqType, id)
+		return nil, &DisconnectedError{Action: reqType, Node: origResp}
+	}
+
+	cli.socketLock.RLock()
+	sock := cli.socket
+	cli.socketLock.RUnlock()
+	if sock == nil {
+		return nil, ErrNotConnected
+	}
+
+	respChan := cli.waitResponse(id)
+	err := sock.SendFrame(data)
+	if err != nil {
+		cli.cancelResponse(id, respChan)
+		return nil, err
+	}
+	var resp *waBinary.Node
+	timeoutChan := make(<-chan time.Time, 1)
+	if timeout > 0 {
+		timeoutChan = time.After(timeout)
+	}
+	select {
+	case resp = <-respChan:
+	case <-ctx.Done():
+		return nil, ctx.Err()
+	case <-timeoutChan:
+		// FIXME this error isn't technically correct (but works for now - the timeout param is only used from sendIQ)
+		return nil, ErrIQTimedOut
+	}
+	if isDisconnectNode(resp) {
+		cli.Log.Debugf("Retrying %s %s was interrupted by websocket disconnection (%v), not retrying anymore", reqType, id, resp.XMLString())
+		return nil, &DisconnectedError{Action: fmt.Sprintf("%s (retry)", reqType), Node: resp}
+	}
+	return resp, nil
+}