@towns-protocol/sdk 0.0.191

package/dist/sync-agent/timeline/models/timelineEvent.js

@@ -0,0 +1,1080 @@
+import { bin_toHexString } from '@towns-protocol/dlog';
+import { MembershipOp, ChannelMessage_Post_AttachmentSchema, ChannelMessage_PostSchema, } from '@towns-protocol/proto';
+import { isDefined, logNever, checkNever } from '../../../check';
+import { EventStatus, MessageType, Membership, RiverTimelineEvent, } from './timeline-types';
+import { userIdFromAddress, streamIdFromBytes, streamIdAsString } from '../../../id';
+import { isLocalEvent, isRemoteEvent, isCiphertext, } from '../../../types';
+import { getSpaceReviewEventDataBin } from '@towns-protocol/web3';
+import { create } from '@bufbuild/protobuf';
+export function toEvent(timelineEvent, userId) {
+    const eventId = timelineEvent.hashStr;
+    const senderId = timelineEvent.creatorUserId;
+    // TODO: get sender metadata from store
+    const sender = {
+        id: senderId,
+    };
+    const { content, error } = toTownsContent(timelineEvent);
+    const isSender = sender.id === userId;
+    const fbc = `${content?.kind ?? '??'} ${getFallbackContent(sender.id, content, error)}`;
+    function extractSessionId(event) {
+        const payload = event.remoteEvent?.event.payload;
+        if (!payload ||
+            payload.case !== 'channelPayload' ||
+            payload.value.content.case !== 'message') {
+            return undefined;
+        }
+        return payload.value.content.value.sessionId;
+    }
+    const sessionId = extractSessionId(timelineEvent);
+    return {
+        eventId: eventId,
+        localEventId: timelineEvent.localEvent?.localId,
+        eventNum: timelineEvent.eventNum,
+        latestEventId: eventId,
+        latestEventNum: timelineEvent.eventNum,
+        status: isSender ? getEventStatus(timelineEvent) : EventStatus.RECEIVED,
+        createdAtEpochMs: Number(timelineEvent.createdAtEpochMs),
+        updatedAtEpochMs: undefined,
+        content: content,
+        fallbackContent: fbc,
+        isEncrypting: eventId.startsWith('~'),
+        isLocalPending: timelineEvent.remoteEvent === undefined,
+        isSendFailed: timelineEvent.localEvent?.status === 'failed',
+        confirmedEventNum: timelineEvent.confirmedEventNum,
+        confirmedInBlockNum: timelineEvent.miniblockNum,
+        threadParentId: getThreadParentId(content),
+        replyParentId: getReplyParentId(content),
+        reactionParentId: getReactionParentId(content),
+        isMentioned: getIsMentioned(content, userId),
+        isRedacted: false, // redacted is handled in use timeline store when the redaction event is received
+        sender,
+        sessionId,
+    };
+}
+function toTownsContent(timelineEvent) {
+    if (isLocalEvent(timelineEvent)) {
+        return toTownsContent_FromChannelMessage(timelineEvent.localEvent.channelMessage, 'local event', timelineEvent.hashStr);
+    }
+    else if (isRemoteEvent(timelineEvent)) {
+        return toTownsContent_fromParsedEvent(timelineEvent.hashStr, timelineEvent);
+    }
+    else {
+        return { error: 'unknown event content type' };
+    }
+}
+function validateEvent(eventId, message) {
+    let error;
+    if (!message.event.payload || !message.event.payload.value) {
+        error = { error: 'payloadless payload' };
+        return error;
+    }
+    if (!message.event.payload.case) {
+        error = { error: 'caseless payload' };
+        return error;
+    }
+    if (!message.event.payload.value.content.case) {
+        error = { error: `${message.event.payload.case} - caseless payload content` };
+        return error;
+    }
+    const description = `${message.event.payload.case}::${message.event.payload.value.content.case} id: ${eventId}`;
+    return { description };
+}
+function toTownsContent_fromParsedEvent(eventId, timelineEvent) {
+    const message = timelineEvent.remoteEvent;
+    const { error, description } = validateEvent(eventId, message);
+    if (error) {
+        return { error };
+    }
+    if (!description) {
+        return { error: 'no description' };
+    }
+    switch (message.event.payload.case) {
+        case 'userPayload':
+            return toTownsContent_UserPayload(timelineEvent, message, message.event.payload.value, description);
+        case 'channelPayload':
+            return toTownsContent_ChannelPayload(eventId, timelineEvent, message.event.payload.value, description);
+        case 'dmChannelPayload':
+            return toTownsContent_ChannelPayload(eventId, timelineEvent, message.event.payload.value, description);
+        case 'gdmChannelPayload':
+            return toTownsContent_ChannelPayload(eventId, timelineEvent, message.event.payload.value, description);
+        case 'spacePayload':
+            return toTownsContent_SpacePayload(eventId, message, message.event.payload.value, description);
+        case 'userMetadataPayload':
+            return {
+                error: `${description} userMetadataPayload not supported?`,
+            };
+        case 'userSettingsPayload':
+            return {
+                error: `${description} userSettingsPayload not supported?`,
+            };
+        case 'userInboxPayload':
+            return {
+                error: `${description} userInboxPayload not supported?`,
+            };
+        case 'miniblockHeader':
+            return toTownsContent_MiniblockHeader(eventId, message, message.event.payload.value, description);
+        case 'mediaPayload':
+            return {
+                error: `${description} mediaPayload not supported?`,
+            };
+        case 'memberPayload':
+            return toTownsContent_MemberPayload(timelineEvent, message, message.event.payload.value, description);
+        case undefined:
+            return { error: `Undefined payload case: ${description}` };
+        default:
+            logNever(message.event.payload);
+            return { error: `Unknown payload case: ${description}` };
+    }
+}
+function toTownsContent_MiniblockHeader(eventId, message, value, _description) {
+    return {
+        content: {
+            kind: RiverTimelineEvent.MiniblockHeader,
+            miniblockNum: value.miniblockNum,
+            hasSnapshot: value.snapshot !== undefined,
+        },
+    };
+}
+function toTownsContent_MemberPayload(event, message, value, description) {
+    switch (value.content.case) {
+        case 'membership':
+            return {
+                content: {
+                    kind: RiverTimelineEvent.StreamMembership,
+                    userId: userIdFromAddress(value.content.value.userAddress),
+                    initiatorId: userIdFromAddress(value.content.value.initiatorAddress),
+                    membership: toMembership(value.content.value.op),
+                },
+            };
+        case 'keySolicitation':
+            return {
+                content: {
+                    kind: RiverTimelineEvent.KeySolicitation,
+                    sessionIds: value.content.value.sessionIds,
+                    deviceKey: value.content.value.deviceKey,
+                    isNewDevice: value.content.value.isNewDevice,
+                },
+            };
+        case 'keyFulfillment':
+            return {
+                content: {
+                    kind: RiverTimelineEvent.Fulfillment,
+                    sessionIds: value.content.value.sessionIds,
+                    deviceKey: value.content.value.deviceKey,
+                    to: userIdFromAddress(value.content.value.userAddress),
+                    from: message.creatorUserId,
+                },
+            };
+        case 'displayName':
+            return {
+                content: {
+                    kind: RiverTimelineEvent.SpaceDisplayName,
+                    userId: message.creatorUserId,
+                    displayName: event.decryptedContent?.kind === 'text'
+                        ? event.decryptedContent.content
+                        : value.content.value.ciphertext,
+                },
+            };
+        case 'username':
+            return {
+                content: {
+                    kind: RiverTimelineEvent.SpaceUsername,
+                    userId: message.creatorUserId,
+                    username: event.decryptedContent?.kind === 'text'
+                        ? event.decryptedContent.content
+                        : value.content.value.ciphertext,
+                },
+            };
+        case 'ensAddress':
+            return {
+                content: {
+                    kind: RiverTimelineEvent.SpaceEnsAddress,
+                    userId: message.creatorUserId,
+                    ensAddress: value.content.value,
+                },
+            };
+        case 'nft':
+            return {
+                content: {
+                    kind: RiverTimelineEvent.SpaceNft,
+                    userId: message.creatorUserId,
+                    contractAddress: bin_toHexString(value.content.value.contractAddress),
+                    tokenId: bin_toHexString(value.content.value.tokenId),
+                    chainId: value.content.value.chainId,
+                },
+            };
+        case 'pin':
+            return {
+                content: {
+                    kind: RiverTimelineEvent.Pin,
+                    userId: message.creatorUserId,
+                    pinnedEventId: bin_toHexString(value.content.value.eventId),
+                },
+            };
+        case 'unpin':
+            return {
+                content: {
+                    kind: RiverTimelineEvent.Unpin,
+                    userId: message.creatorUserId,
+                    unpinnedEventId: bin_toHexString(value.content.value.eventId),
+                },
+            };
+        case 'encryptionAlgorithm':
+            return {
+                content: {
+                    kind: RiverTimelineEvent.StreamEncryptionAlgorithm,
+                    algorithm: value.content.value.algorithm,
+                },
+            };
+        case 'memberBlockchainTransaction': {
+            const fromUserAddress = value.content.value.fromUserAddress;
+            const transaction = value.content.value.transaction;
+            if (!transaction) {
+                return { error: `${description} no transaction` };
+            }
+            if (!transaction.receipt?.transactionHash) {
+                return { error: `${description} no transactionHash` };
+            }
+            switch (transaction.content.case) {
+                case 'tip': {
+                    const tipContent = transaction.content.value;
+                    if (!tipContent.event) {
+                        return { error: `${description} no event in tip` };
+                    }
+                    return {
+                        content: {
+                            kind: RiverTimelineEvent.TipEvent,
+                            transaction: transaction,
+                            tip: tipContent,
+                            transactionHash: bin_toHexString(transaction.receipt.transactionHash),
+                            fromUserId: userIdFromAddress(fromUserAddress),
+                            refEventId: bin_toHexString(tipContent.event.messageId),
+                            toUserId: userIdFromAddress(tipContent.toUserAddress),
+                        },
+                    };
+                }
+                case 'tokenTransfer':
+                    return {
+                        content: {
+                            kind: RiverTimelineEvent.TokenTransfer,
+                            transaction: transaction,
+                            transfer: transaction.content.value,
+                            fromUserId: userIdFromAddress(fromUserAddress),
+                            createdAtEpochMs: event.createdAtEpochMs,
+                            threadParentId: bin_toHexString(transaction.content.value.messageId),
+                        },
+                    };
+                case 'spaceReview': {
+                    if (!transaction.receipt) {
+                        return { error: `${description} no receipt` };
+                    }
+                    const reviewContent = transaction.content.value;
+                    if (!reviewContent.event) {
+                        return { error: `${description} no event in space review` };
+                    }
+                    const { comment, rating } = getSpaceReviewEventDataBin(transaction.receipt.logs, reviewContent.event.user);
+                    return {
+                        content: {
+                            kind: RiverTimelineEvent.SpaceReview,
+                            action: reviewContent.action,
+                            rating: rating,
+                            comment: comment,
+                            fromUserId: userIdFromAddress(fromUserAddress),
+                        },
+                    };
+                }
+                case undefined:
+                    return {
+                        content: {
+                            kind: RiverTimelineEvent.MemberBlockchainTransaction,
+                            transaction: value.content.value.transaction,
+                            fromUserId: bin_toHexString(value.content.value.fromUserAddress),
+                        },
+                    };
+                default:
+                    logNever(transaction.content);
+                    return { error: `${description} unknown transaction content` };
+            }
+        }
+        case undefined:
+            return { error: `Undefined payload case: ${description}` };
+        default:
+            logNever(value.content);
+            return {
+                error: `Unknown payload case: ${description}`,
+            };
+    }
+}
+function toTownsContent_UserPayload(event, message, value, description) {
+    switch (value.content.case) {
+        case 'inception': {
+            return {
+                content: {
+                    kind: RiverTimelineEvent.Inception,
+                    creatorId: message.creatorUserId,
+                    type: message.event.payload.case,
+                },
+            };
+        }
+        case 'userMembership': {
+            const payload = value.content.value;
+            const streamId = streamIdFromBytes(payload.streamId);
+            return {
+                content: {
+                    kind: RiverTimelineEvent.StreamMembership,
+                    userId: '', // this is just the current user
+                    initiatorId: '',
+                    membership: toMembership(payload.op),
+                    streamId: streamId,
+                },
+            };
+        }
+        case 'userMembershipAction': {
+            // these are admin actions where you can invite, join, or kick someone
+            const payload = value.content.value;
+            return {
+                content: {
+                    kind: RiverTimelineEvent.StreamMembership,
+                    userId: userIdFromAddress(payload.userId),
+                    initiatorId: event.remoteEvent.creatorUserId,
+                    membership: toMembership(payload.op),
+                },
+            };
+        }
+        case 'blockchainTransaction': {
+            const payload = value.content.value;
+            return {
+                content: {
+                    kind: RiverTimelineEvent.UserBlockchainTransaction,
+                    transaction: payload,
+                },
+            };
+        }
+        case 'receivedBlockchainTransaction': {
+            const payload = value.content.value;
+            return {
+                content: {
+                    kind: RiverTimelineEvent.UserReceivedBlockchainTransaction,
+                    receivedTransaction: payload,
+                },
+            };
+        }
+        case undefined: {
+            return { error: `Undefined payload case: ${description}` };
+        }
+        default: {
+            logNever(value.content);
+            return {
+                error: `Unknown payload case: ${description}`,
+            };
+        }
+    }
+}
+function toTownsContent_ChannelPayload(eventId, timelineEvent, value, description) {
+    const message = timelineEvent.remoteEvent;
+    switch (value.content.case) {
+        case 'inception': {
+            return {
+                content: {
+                    kind: RiverTimelineEvent.Inception,
+                    creatorId: message.creatorUserId,
+                    type: message.event.payload.case,
+                },
+            };
+        }
+        case 'message': {
+            if (timelineEvent.decryptedContent?.kind === 'channelMessage') {
+                return toTownsContent_FromChannelMessage(timelineEvent.decryptedContent.content, description, eventId);
+            }
+            const payload = value.content.value;
+            return toTownsContent_ChannelPayload_Message(timelineEvent, payload, description);
+        }
+        case 'channelProperties': {
+            const payload = value.content.value;
+            return toTownsContent_ChannelPayload_ChannelProperties(timelineEvent, payload, description);
+        }
+        case 'redaction':
+            return {
+                content: {
+                    kind: RiverTimelineEvent.RedactionActionEvent,
+                    refEventId: bin_toHexString(value.content.value.eventId),
+                    adminRedaction: true,
+                },
+            };
+        case undefined: {
+            return { error: `Undefined payload case: ${description}` };
+        }
+        default:
+            logNever(value.content);
+            return { error: `Unknown payload case: ${description}` };
+    }
+}
+function toTownsContent_FromChannelMessage(channelMessage, description, eventId) {
+    switch (channelMessage.payload?.case) {
+        case 'post':
+            return (toTownsContent_ChannelPayload_Message_Post(channelMessage.payload.value, eventId, undefined, description) ?? {
+                error: `${description} unknown message type`,
+            });
+        case 'reaction':
+            return {
+                content: {
+                    kind: RiverTimelineEvent.Reaction,
+                    reaction: channelMessage.payload.value.reaction,
+                    targetEventId: channelMessage.payload.value.refEventId,
+                },
+            };
+        case 'redaction':
+            return {
+                content: {
+                    kind: RiverTimelineEvent.RedactionActionEvent,
+                    refEventId: channelMessage.payload.value.refEventId,
+                    adminRedaction: false,
+                },
+            };
+        case 'edit': {
+            const newPost = channelMessage.payload.value.post;
+            if (!newPost) {
+                return { error: `${description} no post in edit` };
+            }
+            const newContent = toTownsContent_ChannelPayload_Message_Post(newPost, eventId, channelMessage.payload.value.refEventId, description);
+            return newContent ?? { error: `${description} no content in edit` };
+        }
+        case undefined:
+            return { error: `Undefined payload case: ${description}` };
+        default: {
+            logNever(channelMessage.payload);
+            return {
+                error: `Unknown payload case: ${description}`,
+            };
+        }
+    }
+}
+function toTownsContent_ChannelPayload_Message(timelineEvent, payload, description) {
+    if (isCiphertext(payload.ciphertext)) {
+        if (payload.refEventId) {
+            return {
+                content: {
+                    kind: RiverTimelineEvent.ChannelMessageEncryptedWithRef,
+                    refEventId: payload.refEventId,
+                },
+            };
+        }
+        return {
+            // if payload is an EncryptedData message, than it is encrypted content kind
+            content: {
+                kind: RiverTimelineEvent.ChannelMessageEncrypted,
+                error: timelineEvent.decryptedContentError,
+            },
+        };
+    }
+    // do not handle non-encrypted messages that should be encrypted
+    return { error: `${description} message text invalid channel message` };
+}
+function toTownsContent_ChannelPayload_ChannelProperties(timelineEvent, payload, description) {
+    if (timelineEvent.decryptedContent?.kind === 'channelProperties') {
+        return {
+            content: {
+                kind: RiverTimelineEvent.ChannelProperties,
+                properties: timelineEvent.decryptedContent.content,
+            },
+        };
+    }
+    // If the payload is encrypted, we display nothing.
+    return { error: `${description} encrypted channel properties` };
+}
+function toTownsContent_ChannelPayload_Message_Post(value, eventId, editsEventId, description) {
+    switch (value.content.case) {
+        case 'text':
+            return {
+                content: {
+                    kind: RiverTimelineEvent.ChannelMessage,
+                    body: value.content.value.body,
+                    threadId: value.threadId,
+                    threadPreview: value.threadPreview,
+                    replyId: value.replyId,
+                    replyPreview: value.replyPreview,
+                    mentions: value.content.value.mentions,
+                    editsEventId: editsEventId,
+                    content: {
+                        msgType: MessageType.Text,
+                    },
+                    attachments: toAttachments(value.content.value.attachments, eventId),
+                },
+            };
+        case 'image':
+            return {
+                content: {
+                    kind: RiverTimelineEvent.ChannelMessage,
+                    body: value.content.value.title,
+                    threadId: value.threadId,
+                    threadPreview: value.threadPreview,
+                    mentions: [],
+                    editsEventId: editsEventId,
+                    content: {
+                        msgType: MessageType.Image,
+                        info: value.content.value.info,
+                        thumbnail: value.content.value.thumbnail,
+                    },
+                },
+            };
+        case 'gm':
+            return {
+                content: {
+                    kind: RiverTimelineEvent.ChannelMessage,
+                    body: value.content.value.typeUrl,
+                    threadId: value.threadId,
+                    threadPreview: value.threadPreview,
+                    mentions: [],
+                    editsEventId: editsEventId,
+                    content: {
+                        msgType: MessageType.GM,
+                        data: value.content.value.value,
+                    },
+                },
+            };
+        case undefined:
+            return { error: `Undefined payload case: ${description}` };
+        default:
+            logNever(value.content);
+            return { error: `Unknown payload case: ${description}` };
+    }
+}
+function toTownsContent_SpacePayload(eventId, message, value, description) {
+    switch (value.content.case) {
+        case 'inception': {
+            return {
+                content: {
+                    kind: RiverTimelineEvent.Inception,
+                    creatorId: message.creatorUserId,
+                    type: message.event.payload.case,
+                },
+            };
+        }
+        case 'channel': {
+            const payload = value.content.value;
+            const channelId = streamIdAsString(payload.channelId);
+            return {
+                content: {
+                    kind: RiverTimelineEvent.ChannelCreate,
+                    creatorId: message.creatorUserId,
+                    channelId,
+                    channelOp: payload.op,
+                    channelSettings: payload.settings,
+                },
+            };
+        }
+        case 'updateChannelAutojoin': {
+            const payload = value.content.value;
+            const channelId = streamIdAsString(payload.channelId);
+            return {
+                content: {
+                    kind: RiverTimelineEvent.SpaceUpdateAutojoin,
+                    autojoin: payload.autojoin,
+                    channelId: channelId,
+                },
+            };
+        }
+        case 'updateChannelHideUserJoinLeaveEvents': {
+            const payload = value.content.value;
+            const channelId = streamIdAsString(payload.channelId);
+            return {
+                content: {
+                    kind: RiverTimelineEvent.SpaceUpdateHideUserJoinLeaves,
+                    hideUserJoinLeaves: payload.hideUserJoinLeaveEvents,
+                    channelId: channelId,
+                },
+            };
+        }
+        case 'spaceImage': {
+            return {
+                content: {
+                    kind: RiverTimelineEvent.SpaceImage,
+                },
+            };
+        }
+        case undefined:
+            return { error: `Undefined payload case: ${description}` };
+        default:
+            logNever(value.content);
+            return { error: `Unknown payload case: ${description}` };
+    }
+}
+function getEventStatus(timelineEvent) {
+    if (timelineEvent.remoteEvent) {
+        return EventStatus.SENT;
+    }
+    else if (timelineEvent.localEvent && timelineEvent.hashStr.startsWith('~')) {
+        return EventStatus.ENCRYPTING;
+    }
+    else if (timelineEvent.localEvent) {
+        switch (timelineEvent.localEvent.status) {
+            case 'failed':
+                return EventStatus.NOT_SENT;
+            case 'sending':
+                return EventStatus.SENDING;
+            case 'sent':
+                return EventStatus.SENT;
+            default:
+                logNever(timelineEvent.localEvent.status);
+                return EventStatus.NOT_SENT;
+        }
+    }
+    else {
+        return EventStatus.NOT_SENT;
+    }
+}
+function toAttachments(attachments, parentEventId) {
+    return attachments
+        .map((attachment, index) => toAttachment(attachment, parentEventId, index))
+        .filter(isDefined);
+}
+function toAttachment(attachment, parentEventId, index) {
+    const id = `${parentEventId}-${index}`;
+    switch (attachment.content.case) {
+        case 'chunkedMedia': {
+            const info = attachment.content.value.info;
+            if (!info) {
+                return undefined;
+            }
+            const thumbnailInfo = attachment.content.value.thumbnail?.info;
+            const thumbnailContent = attachment.content.value.thumbnail?.content;
+            const thumbnail = thumbnailInfo && thumbnailContent
+                ? {
+                    info: thumbnailInfo,
+                    content: thumbnailContent,
+                }
+                : undefined;
+            const encryption = attachment.content.value.encryption.case === 'aesgcm'
+                ? attachment.content.value.encryption.value
+                : undefined;
+            if (!encryption) {
+                return undefined;
+            }
+            return {
+                type: 'chunked_media',
+                info,
+                streamId: attachment.content.value.streamId,
+                encryption,
+                id,
+                thumbnail: thumbnail,
+            };
+        }
+        case 'embeddedMedia': {
+            const info = attachment.content.value.info;
+            if (!info) {
+                return undefined;
+            }
+            return {
+                type: 'embedded_media',
+                info,
+                content: attachment.content.value.content,
+                id,
+            };
+        }
+        case 'image': {
+            const info = attachment.content.value.info;
+            if (!info) {
+                return undefined;
+            }
+            return { type: 'image', info, id };
+        }
+        case 'embeddedMessage': {
+            const content = attachment.content.value;
+            if (!content?.post || !content?.info) {
+                return undefined;
+            }
+            const channelMessageEvent = toTownsContent_ChannelPayload_Message_Post(content.post, content.info.messageId, undefined, '').content;
+            return channelMessageEvent?.kind === RiverTimelineEvent.ChannelMessage
+                ? ({
+                    type: 'embedded_message',
+                    ...content,
+                    info: content.info,
+                    channelMessageEvent: channelMessageEvent,
+                    id,
+                })
+                : undefined;
+        }
+        case 'unfurledUrl': {
+            const content = attachment.content.value;
+            return {
+                type: 'unfurled_link',
+                url: content.url,
+                title: content.title,
+                description: content.description,
+                image: content.image,
+                id,
+            };
+        }
+        default:
+            return undefined;
+    }
+}
+// function isDMMessageEventBlocked(
+//     event: TimelineEvent,
+//     kind: SnapshotCaseType,
+//     streamClient: Client,
+// ) {
+//     if (kind !== 'dmChannelContent') {
+//         return false
+//     }
+//     if (!streamClient?.userSettingsStreamId) {
+//         return false
+//     }
+//     const stream = streamClient.stream(streamClient.userSettingsStreamId)
+//     check(isDefined(stream), 'stream must be defined')
+//     return stream.view.userSettingsContent.isUserBlockedAt(event.sender.id, event.eventNum)
+// }
+export function getFallbackContent(senderDisplayName, content, error) {
+    if (error) {
+        return error;
+    }
+    if (!content) {
+        throw new Error('Either content or error should be defined');
+    }
+    switch (content.kind) {
+        case RiverTimelineEvent.MiniblockHeader:
+            return `Miniblock miniblockNum:${content.miniblockNum}, hasSnapshot:${content.hasSnapshot.toString()}`;
+        case RiverTimelineEvent.Reaction:
+            return `${senderDisplayName} reacted with ${content.reaction} to ${content.targetEventId}`;
+        case RiverTimelineEvent.Inception:
+            return content.type ? `type: ${content.type}` : '';
+        case RiverTimelineEvent.ChannelMessageEncrypted:
+            return `Decrypting...`;
+        case RiverTimelineEvent.StreamMembership: {
+            return `[${content.membership}] userId: ${content.userId} initiatorId: ${content.initiatorId}`;
+        }
+        case RiverTimelineEvent.ChannelMessage:
+            return `${senderDisplayName}: ${content.body}`;
+        case RiverTimelineEvent.ChannelProperties:
+            return `properties: ${content.properties.name ?? ''} ${content.properties.topic ?? ''}`;
+        case RiverTimelineEvent.SpaceUsername:
+            return `username: ${content.username}`;
+        case RiverTimelineEvent.SpaceDisplayName:
+            return `username: ${content.displayName}`;
+        case RiverTimelineEvent.SpaceEnsAddress:
+            return `ensAddress: ${bin_toHexString(content.ensAddress)}`;
+        case RiverTimelineEvent.SpaceNft:
+            return `contractAddress: ${content.contractAddress}, tokenId: ${content.tokenId}, chainId: ${content.chainId}`;
+        case RiverTimelineEvent.RedactedEvent:
+            return `~Redacted~`;
+        case RiverTimelineEvent.RedactionActionEvent:
+            return `Redacts ${content.refEventId} adminRedaction: ${content.adminRedaction}`;
+        case RiverTimelineEvent.ChannelCreate:
+            if (content.channelSettings !== undefined) {
+                return `channelId: ${content.channelId} autojoin: ${content.channelSettings.autojoin} hideUserJoinLeaves: ${content.channelSettings.hideUserJoinLeaveEvents}`;
+            }
+            return `channelId: ${content.channelId}`;
+        case RiverTimelineEvent.SpaceUpdateAutojoin:
+            return `channelId: ${content.channelId} autojoin: ${content.autojoin}`;
+        case RiverTimelineEvent.SpaceUpdateHideUserJoinLeaves:
+            return `channelId: ${content.channelId} hideUserJoinLeaves: ${content.hideUserJoinLeaves}`;
+        case RiverTimelineEvent.SpaceImage:
+            return `SpaceImage`;
+        case RiverTimelineEvent.Fulfillment:
+            return `Fulfillment sessionIds: ${content.sessionIds.length ? content.sessionIds.join(',') : 'forNewDevice: true'}, from: ${content.from} to: ${content.deviceKey}`;
+        case RiverTimelineEvent.KeySolicitation:
+            if (content.isNewDevice) {
+                return `KeySolicitation deviceKey: ${content.deviceKey}, newDevice: true`;
+            }
+            return `KeySolicitation deviceKey: ${content.deviceKey} sessionIds: ${content.sessionIds.length}`;
+        case RiverTimelineEvent.ChannelMessageMissing:
+            return `eventId: ${content.eventId}`;
+        case RiverTimelineEvent.ChannelMessageEncryptedWithRef:
+            return `refEventId: ${content.refEventId}`;
+        case RiverTimelineEvent.Pin:
+            return `pinnedEventId: ${content.pinnedEventId} by: ${content.userId}`;
+        case RiverTimelineEvent.Unpin:
+            return `unpinnedEventId: ${content.unpinnedEventId} by: ${content.userId}`;
+        case RiverTimelineEvent.UserBlockchainTransaction:
+            return getFallbackContent_BlockchainTransaction(content.transaction);
+        case RiverTimelineEvent.MemberBlockchainTransaction:
+            return `memberTransaction from: ${content.fromUserId} ${getFallbackContent_BlockchainTransaction(content.transaction)}`;
+        case RiverTimelineEvent.TipEvent:
+            return `tip from: ${content.fromUserId} to: ${content.toUserId} refEventId: ${content.refEventId} amount: ${content.tip.event?.amount.toString() ?? '??'}`;
+        case RiverTimelineEvent.TokenTransfer:
+            return `tokenTransfer from: ${content.fromUserId} amount: ${content.transfer.amount}`;
+        case RiverTimelineEvent.SpaceReview:
+            return `spaceReview from: ${content.fromUserId} rating: ${content.rating} comment: ${content.comment}`;
+        case RiverTimelineEvent.UserReceivedBlockchainTransaction:
+            return `kind: ${content.receivedTransaction.transaction?.content?.case ?? '??'} fromUserAddress: ${content.receivedTransaction.fromUserAddress
+                ? bin_toHexString(content.receivedTransaction.fromUserAddress)
+                : ''}`;
+        case RiverTimelineEvent.StreamEncryptionAlgorithm:
+            return `algorithm: ${content.algorithm}`;
+        default:
+            checkNever(content); // these are client side after parsing events, everything should be covered
+    }
+}
+function getFallbackContent_BlockchainTransaction(transaction) {
+    if (!transaction) {
+        return '??';
+    }
+    switch (transaction.content.case) {
+        case 'tip':
+            if (!transaction.content.value?.event) {
+                return '??';
+            }
+            return `kind: ${transaction.content.case} messageId: ${bin_toHexString(transaction.content.value.event.messageId)} receiver: ${bin_toHexString(transaction.content.value.event.receiver)} amount: ${transaction.content.value.event.amount.toString()}`;
+        default:
+            return `kind: ${transaction.content.case ?? 'unspecified'}`;
+    }
+}
+export function transformAttachments(attachments) {
+    if (!attachments) {
+        return [];
+    }
+    return attachments
+        .map((attachment) => {
+        switch (attachment.type) {
+            case 'chunked_media':
+                return create(ChannelMessage_Post_AttachmentSchema, {
+                    content: {
+                        case: 'chunkedMedia',
+                        value: {
+                            info: attachment.info,
+                            streamId: attachment.streamId,
+                            encryption: {
+                                case: 'aesgcm',
+                                value: attachment.encryption,
+                            },
+                            thumbnail: {
+                                info: attachment.thumbnail?.info,
+                                content: attachment.thumbnail?.content,
+                            },
+                        },
+                    },
+                });
+            case 'embedded_media':
+                return create(ChannelMessage_Post_AttachmentSchema, {
+                    content: {
+                        case: 'embeddedMedia',
+                        value: {
+                            info: attachment.info,
+                            content: attachment.content,
+                        },
+                    },
+                });
+            case 'image':
+                return create(ChannelMessage_Post_AttachmentSchema, {
+                    content: {
+                        case: 'image',
+                        value: {
+                            info: attachment.info,
+                        },
+                    },
+                });
+            case 'embedded_message': {
+                const { channelMessageEvent, ...content } = attachment;
+                if (!channelMessageEvent) {
+                    return;
+                }
+                const post = create(ChannelMessage_PostSchema, {
+                    threadId: channelMessageEvent.threadId,
+                    threadPreview: channelMessageEvent.threadPreview,
+                    content: {
+                        case: 'text',
+                        value: {
+                            ...channelMessageEvent,
+                            attachments: transformAttachments(channelMessageEvent.attachments),
+                        },
+                    },
+                });
+                const value = create(ChannelMessage_Post_AttachmentSchema, {
+                    content: {
+                        case: 'embeddedMessage',
+                        value: {
+                            ...content,
+                            post,
+                        },
+                    },
+                });
+                return value;
+            }
+            case 'unfurled_link':
+                return create(ChannelMessage_Post_AttachmentSchema, {
+                    content: {
+                        case: 'unfurledUrl',
+                        value: {
+                            url: attachment.url,
+                            title: attachment.title,
+                            description: attachment.description,
+                            image: attachment.image
+                                ? {
+                                    height: attachment.image.height,
+                                    width: attachment.image.width,
+                                    url: attachment.image.url,
+                                }
+                                : undefined,
+                        },
+                    },
+                });
+            case 'ticker':
+                return create(ChannelMessage_Post_AttachmentSchema, {
+                    content: {
+                        case: 'ticker',
+                        value: {
+                            chainId: attachment.chainId,
+                            address: attachment.address,
+                        },
+                    },
+                });
+            default:
+                logNever(attachment);
+                return undefined;
+        }
+    })
+        .filter(isDefined);
+}
+// function getEditsId(content: TimelineEvent_OneOf | undefined): string | undefined {
+//     return content?.kind === RiverEvent.ChannelMessage ? content.editsEventId : undefined
+// }
+// function getRedactsId(content: TimelineEvent_OneOf | undefined): string | undefined {
+//     return content?.kind === RiverEvent.RedactionActionEvent ? content.refEventId : undefined
+// }
+function getThreadParentId(content) {
+    return content?.kind === RiverTimelineEvent.ChannelMessage ? content.threadId : undefined;
+}
+function getReplyParentId(content) {
+    return content?.kind === RiverTimelineEvent.ChannelMessage ? content.replyId : undefined;
+}
+function getReactionParentId(content) {
+    return content?.kind === RiverTimelineEvent.Reaction ? content.targetEventId : undefined;
+}
+function getIsMentioned(content, userId) {
+    //TODO: comparison below should be changed as soon as this HNT-1576 will be resolved
+    return content?.kind === RiverTimelineEvent.ChannelMessage
+        ? content.mentions.findIndex((x) => (x.userId ?? '')
+            .toLowerCase()
+            .localeCompare(userId.toLowerCase(), undefined, { sensitivity: 'base' }) == 0) >= 0
+        : false;
+}
+export function toMembership(membershipOp) {
+    switch (membershipOp) {
+        case MembershipOp.SO_JOIN:
+            return Membership.Join;
+        case MembershipOp.SO_INVITE:
+            return Membership.Invite;
+        case MembershipOp.SO_LEAVE:
+            return Membership.Leave;
+        case MembershipOp.SO_UNSPECIFIED:
+            return Membership.None;
+        case undefined:
+            return Membership.None;
+        default:
+            checkNever(membershipOp);
+    }
+}
+export function toReplacedMessageEvent(prev, next) {
+    if (!canReplaceEvent(prev, next)) {
+        return prev;
+    }
+    else if (next.content?.kind === RiverTimelineEvent.ChannelMessage &&
+        prev.content?.kind === RiverTimelineEvent.ChannelMessage) {
+        // when we replace an event, we copy the content up to the root event
+        // so we keep the prev id, but use the next content
+        const isLocalId = prev.eventId.startsWith('~');
+        const eventId = !isLocalId ? prev.eventId : next.eventId;
+        return {
+            ...next,
+            eventId: eventId,
+            eventNum: prev.eventNum,
+            latestEventId: next.eventId,
+            latestEventNum: next.eventNum,
+            confirmedEventNum: prev.confirmedEventNum ?? next.confirmedEventNum,
+            confirmedInBlockNum: prev.confirmedInBlockNum ?? next.confirmedInBlockNum,
+            createdAtEpochMs: prev.createdAtEpochMs,
+            updatedAtEpochMs: next.createdAtEpochMs,
+            content: {
+                ...next.content,
+                threadId: prev.content.threadId,
+            },
+            threadParentId: prev.threadParentId,
+            reactionParentId: prev.reactionParentId,
+            sender: prev.sender,
+        };
+    }
+    else if (next.content?.kind === RiverTimelineEvent.RedactedEvent) {
+        // for redacted events, carry over previous pointers to content
+        // we don't want to lose thread info
+        return {
+            ...next,
+            eventId: prev.eventId,
+            eventNum: prev.eventNum,
+            latestEventId: next.eventId,
+            latestEventNum: next.eventNum,
+            confirmedEventNum: prev.confirmedEventNum ?? next.confirmedEventNum,
+            confirmedInBlockNum: prev.confirmedInBlockNum ?? next.confirmedInBlockNum,
+            createdAtEpochMs: prev.createdAtEpochMs,
+            updatedAtEpochMs: next.createdAtEpochMs,
+            threadParentId: prev.threadParentId,
+            reactionParentId: prev.reactionParentId,
+        };
+    }
+    else if (prev.content?.kind === RiverTimelineEvent.RedactedEvent) {
+        // replacing a redacted event should maintain the redacted state
+        return {
+            ...prev,
+            latestEventId: next.eventId,
+            latestEventNum: next.eventNum,
+            confirmedEventNum: prev.confirmedEventNum ?? next.confirmedEventNum,
+            confirmedInBlockNum: prev.confirmedInBlockNum ?? next.confirmedInBlockNum,
+        };
+    }
+    else {
+        // make sure we carry the createdAtEpochMs of the previous event
+        // so we don't end up with a timeline that has events out of order.
+        return {
+            ...next,
+            eventId: prev.eventId,
+            eventNum: prev.eventNum,
+            latestEventId: next.eventId,
+            latestEventNum: next.eventNum,
+            confirmedEventNum: prev.confirmedEventNum ?? next.confirmedEventNum,
+            confirmedInBlockNum: prev.confirmedInBlockNum ?? next.confirmedInBlockNum,
+            createdAtEpochMs: prev.createdAtEpochMs,
+            updatedAtEpochMs: next.createdAtEpochMs,
+        };
+    }
+}
+function canReplaceEvent(prev, next) {
+    if (next.content?.kind === RiverTimelineEvent.RedactedEvent && next.content.isAdminRedaction) {
+        return true;
+    }
+    if (next.sender.id === prev.sender.id) {
+        return true;
+    }
+    return false;
+}
+export function getEditsId(content) {
+    return content?.kind === RiverTimelineEvent.ChannelMessage ? content.editsEventId : undefined;
+}
+export function getRedactsId(content) {
+    return content?.kind === RiverTimelineEvent.RedactionActionEvent
+        ? content.refEventId
+        : undefined;
+}
+export function makeRedactionEvent(redactionAction) {
+    if (redactionAction.content?.kind !== RiverTimelineEvent.RedactionActionEvent) {
+        throw new Error('makeRedactionEvent called with non-redaction action event');
+    }
+    const newContent = {
+        kind: RiverTimelineEvent.RedactedEvent,
+        isAdminRedaction: redactionAction.content.adminRedaction,
+    };
+    return {
+        ...redactionAction,
+        content: newContent,
+        fallbackContent: getFallbackContent('', newContent),
+        isRedacted: true,
+    };
+}
+export function getMessageSenderId(event) {
+    if (!getChannelMessageContent(event)) {
+        return undefined;
+    }
+    return event.sender.id;
+}
+export function getChannelMessageContent(event) {
+    return event?.content?.kind === RiverTimelineEvent.ChannelMessage ? event.content : undefined;
+}
+//# sourceMappingURL=timelineEvent.js.map