@towns-labs/sdk 2.0.1

package/dist/views/models/timelineEvent.js

@@ -0,0 +1,1063 @@
+import { MembershipOp, } from '@towns-labs/proto';
+import { EventStatus, RiverTimelineEvent, MessageType, Membership, getIsMentioned, getReactionParentId, getReplyParentId, getThreadParentId, } from './timelineTypes';
+import { checkNever, isDefined, logNever } from '../../check';
+import { isLocalEvent, isRemoteEvent, } from '../../types';
+import { streamIdAsString, streamIdFromBytes, userIdFromAddress } from '../../id';
+import { bin_toHexString, dlogger } from '@towns-labs/utils';
+import { getSpaceReviewEventDataBin } from '@towns-labs/web3';
+const logger = dlogger('csb:timeline');
+export function toEvent(timelineEvent, userId) {
+    const eventId = timelineEvent.hashStr;
+    const senderId = getSenderId(timelineEvent);
+    const sender = {
+        id: senderId,
+    };
+    const { content, error } = toTownsContent(timelineEvent);
+    const isSender = sender.id === userId;
+    const fbc = `${content?.kind ?? '??'} ${getFallbackContent(sender.id, content, error)}`;
+    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,
+        confirmedAtEpochMs: timelineEvent.confirmedAtEpochMs,
+        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 extractSessionId(event) {
+    const payload = event.remoteEvent?.event.payload;
+    if (!payload || payload.value?.content.case !== 'message') {
+        return undefined;
+    }
+    return payload.value.content.value.sessionIdBytes.length > 0
+        ? bin_toHexString(payload.value.content.value.sessionIdBytes)
+        : payload.value.content.value.sessionId;
+}
+function getSenderId(timelineEvent) {
+    const payload = timelineEvent.remoteEvent?.event.payload;
+    if (payload?.case === 'memberPayload' &&
+        payload?.value.content.case === 'memberBlockchainTransaction') {
+        return userIdFromAddress(payload.value.content.value.fromUserAddress);
+    }
+    return timelineEvent.creatorUserId;
+}
+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 implemented`,
+            };
+        case 'userSettingsPayload':
+            return {
+                error: `${description} userSettingsPayload not implemented`,
+            };
+        case 'userInboxPayload':
+            return {
+                error: `${description} userInboxPayload not implemented`,
+            };
+        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 'metadataPayload':
+            return {
+                error: `${description} metadataPayload not supported for timeline events`,
+            };
+        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.snapshotHash !== 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),
+                    reason: value.content.value.reason,
+                    appAddress: value.content.value.appAddress
+                        ? userIdFromAddress(value.content.value.appAddress)
+                        : undefined,
+                },
+            };
+        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 'memberBlockchainTransaction': {
+            const fromUserAddress = value.content.value.fromUserAddress;
+            const transaction = value.content.value.transaction;
+            if (!transaction) {
+                return { error: `${description} no transaction` };
+            }
+            switch (transaction.content.case) {
+                case 'tip': {
+                    if (!transaction.receipt?.transactionHash) {
+                        return { error: `${description} no transactionHash` };
+                    }
+                    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 '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 'tokenTransfer': {
+                    const transferContent = transaction.content.value;
+                    return {
+                        content: {
+                            kind: RiverTimelineEvent.TokenTransfer,
+                            transaction: transaction,
+                            transfer: transferContent,
+                            fromUserId: userIdFromAddress(fromUserAddress),
+                            createdAtEpochMs: event.createdAtEpochMs,
+                            threadParentId: bin_toHexString(transferContent.messageId),
+                        },
+                    };
+                }
+                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 'encryptionAlgorithm':
+            return {
+                error: `Encryption Algorithm not supported: ${description}`,
+            };
+        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,
+                    appAddress: value.content.value.appAddress
+                        ? userIdFromAddress(value.content.value.appAddress)
+                        : undefined,
+                },
+            };
+        }
+        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': {
+            return {
+                content: {
+                    kind: RiverTimelineEvent.UserBlockchainTransaction,
+                    transaction: value.content.value,
+                },
+            };
+        }
+        case 'receivedBlockchainTransaction': {
+            return {
+                content: {
+                    kind: RiverTimelineEvent.UserReceivedBlockchainTransaction,
+                    receivedTransaction: value.content.value,
+                },
+            };
+        }
+        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 'custom':
+            return { error: `Custom payload not supported: ${description}` };
+        case 'interactionRequest': {
+            const recipient = value.content.value.recipient
+                ? bin_toHexString(value.content.value.recipient)
+                : undefined;
+            if (timelineEvent.decryptedContent?.kind === 'interactionRequestPayload') {
+                return {
+                    content: {
+                        kind: RiverTimelineEvent.InteractionRequest,
+                        payload: timelineEvent.decryptedContent.content,
+                        recipient,
+                        threadParentId: value.content.value.threadId
+                            ? bin_toHexString(value.content.value.threadId)
+                            : undefined,
+                    },
+                };
+            }
+            // If not decrypted yet, show as encrypted
+            return {
+                content: {
+                    kind: RiverTimelineEvent.InteractionRequestEncrypted,
+                    error: timelineEvent.decryptedContentError,
+                    recipient,
+                    threadParentId: value.content.value.threadId
+                        ? bin_toHexString(value.content.value.threadId)
+                        : undefined,
+                },
+            };
+        }
+        case 'interactionResponse':
+            return {
+                content: {
+                    kind: RiverTimelineEvent.InteractionResponse,
+                    response: value.content.value,
+                },
+            };
+        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 (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,
+        },
+    };
+}
+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 {
+        content: {
+            kind: RiverTimelineEvent.EncryptedChannelProperties,
+            error: timelineEvent.decryptedContentError,
+        },
+    };
+}
+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 childId = streamIdAsString(payload.channelId);
+            return {
+                content: {
+                    kind: RiverTimelineEvent.ChannelCreate,
+                    creatorId: message.creatorUserId,
+                    channelId: childId,
+                    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 {
+        logger.error('$$$ timelineStoreEvents unknown event status', { timelineEvent });
+        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) {
+                logger.error('$$$ timelineStoreEvents invalid chunkedMedia attachment', {
+                    attachment,
+                });
+                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) {
+                logger.error('$$$ timelineStoreEvents invalid chunkedMedia encryption', {
+                    attachment,
+                });
+                return undefined;
+            }
+            return {
+                type: 'chunked_media',
+                info,
+                streamId: attachment.content.value.streamId,
+                encryption,
+                id,
+                thumbnail: thumbnail,
+            };
+        }
+        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,
+            };
+        }
+        case 'ticker': {
+            const content = attachment.content.value;
+            return {
+                id,
+                type: 'ticker',
+                address: content.address,
+                chainId: content.chainId,
+            };
+        }
+        case 'miniapp': {
+            const content = attachment.content.value;
+            return {
+                type: 'miniapp',
+                url: content.url,
+                id,
+            };
+        }
+        default:
+            return undefined;
+    }
+}
+/// fill in the event with the decrypted content
+/// i don't love this since it duplicates code, but it makes it so that we don't have to keep the
+/// original RemoteTimelineEvent around in memory
+export function toDecryptedEvent(event, decryptedContent, userId) {
+    if (!event.content) {
+        logger.error('$$$ timelineStoreEvents invalid event in toDecryptedEvent', {
+            event,
+            decryptedContent,
+        });
+        return event;
+    }
+    switch (event.content.kind) {
+        case RiverTimelineEvent.ChannelMessageEncrypted:
+        case RiverTimelineEvent.ChannelMessageEncryptedWithRef: {
+            if (decryptedContent.kind === 'channelMessage') {
+                const { content, error } = toTownsContent_FromChannelMessage(decryptedContent.content, `ChannelMessage: ${event.eventId}`, event.eventId);
+                if (error) {
+                    return event;
+                }
+                return {
+                    ...event,
+                    content,
+                    fallbackContent: getFallbackContent(event.sender.id, content),
+                    threadParentId: getThreadParentId(content),
+                    replyParentId: getReplyParentId(content),
+                    reactionParentId: getReactionParentId(content),
+                    isMentioned: getIsMentioned(content, userId),
+                };
+            }
+            else {
+                logger.error('$$$ timelineStoreEvents invalid channelMessageEncrypted', {
+                    event,
+                    decryptedContent,
+                });
+                return event;
+            }
+        }
+        case RiverTimelineEvent.SpaceDisplayName: {
+            if (decryptedContent.kind === 'text') {
+                const content = {
+                    ...event.content,
+                    displayName: decryptedContent.content,
+                };
+                const fallbackContent = getFallbackContent(event.sender.id, content);
+                return {
+                    ...event,
+                    content,
+                    fallbackContent,
+                };
+            }
+            else {
+                logger.error('$$$ timelineStoreEvents invalid spaceDisplayName', {
+                    event,
+                    decryptedContent,
+                });
+                return event;
+            }
+        }
+        case RiverTimelineEvent.SpaceUsername: {
+            if (decryptedContent.kind === 'text') {
+                const content = {
+                    ...event.content,
+                    username: decryptedContent.content,
+                };
+                const fallbackContent = getFallbackContent(event.sender.id, content);
+                return {
+                    ...event,
+                    content,
+                    fallbackContent,
+                };
+            }
+            else {
+                logger.error('$$$ timelineStoreEvents invalid spaceUsername', {
+                    event,
+                    decryptedContent,
+                });
+                return event;
+            }
+        }
+        case RiverTimelineEvent.EncryptedChannelProperties: {
+            if (decryptedContent.kind === 'channelProperties') {
+                const content = {
+                    ...event.content,
+                    properties: decryptedContent.content,
+                };
+                const fallbackContent = getFallbackContent(event.sender.id, content);
+                return {
+                    ...event,
+                    content,
+                    fallbackContent,
+                };
+            }
+            else {
+                logger.error('$$$ timelineStoreEvents invalid encryptedChannelProperties', {
+                    event,
+                    decryptedContent,
+                });
+                return event;
+            }
+        }
+        case RiverTimelineEvent.InteractionRequestEncrypted:
+            if (decryptedContent.kind === 'interactionRequestPayload') {
+                return {
+                    ...event,
+                    content: {
+                        kind: RiverTimelineEvent.InteractionRequest,
+                        payload: decryptedContent.content,
+                        recipient: event.content.recipient,
+                        threadParentId: getThreadParentId(event.content),
+                    },
+                };
+            }
+            else {
+                logger.error('$$$ timelineStoreEvents invalid interactionRequestEncrypted', {
+                    event,
+                    decryptedContent,
+                });
+                return event;
+            }
+        case RiverTimelineEvent.ChannelCreate:
+        case RiverTimelineEvent.ChannelMessage:
+        case RiverTimelineEvent.ChannelMessageMissing:
+        case RiverTimelineEvent.ChannelProperties:
+        case RiverTimelineEvent.Inception:
+        case RiverTimelineEvent.InteractionRequest:
+        case RiverTimelineEvent.InteractionResponse:
+        case RiverTimelineEvent.KeySolicitation:
+        case RiverTimelineEvent.Fulfillment:
+        case RiverTimelineEvent.MemberBlockchainTransaction:
+        case RiverTimelineEvent.MiniblockHeader:
+        case RiverTimelineEvent.Pin:
+        case RiverTimelineEvent.Reaction:
+        case RiverTimelineEvent.RedactedEvent:
+        case RiverTimelineEvent.RedactionActionEvent:
+        case RiverTimelineEvent.SpaceEnsAddress:
+        case RiverTimelineEvent.SpaceNft:
+        case RiverTimelineEvent.SpaceReview:
+        case RiverTimelineEvent.TokenTransfer:
+        case RiverTimelineEvent.TipEvent:
+        case RiverTimelineEvent.SpaceUpdateAutojoin:
+        case RiverTimelineEvent.SpaceUpdateHideUserJoinLeaves:
+        case RiverTimelineEvent.SpaceImage:
+        case RiverTimelineEvent.StreamEncryptionAlgorithm:
+        case RiverTimelineEvent.StreamMembership:
+        case RiverTimelineEvent.Unpin:
+        case RiverTimelineEvent.UserBlockchainTransaction:
+        case RiverTimelineEvent.UserReceivedBlockchainTransaction:
+            return event;
+        default:
+            logNever(event.content);
+            return event;
+    }
+}
+export function toDecryptedContentErrorEvent(event, error) {
+    switch (event.content?.kind) {
+        case RiverTimelineEvent.ChannelMessageEncrypted:
+        case RiverTimelineEvent.EncryptedChannelProperties:
+            return {
+                ...event,
+                content: {
+                    ...event.content,
+                    error,
+                },
+            };
+            break;
+    }
+    return event;
+}
+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 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.InteractionRequest:
+            return content.payload ? `interactionRequest` : `interactionRequest: (encrypted)`;
+        case RiverTimelineEvent.InteractionRequestEncrypted:
+            return `interactionRequest: (encrypted)`;
+        case RiverTimelineEvent.InteractionResponse:
+            return `interactionResponse: ${bin_toHexString(content.response.recipient)}`;
+        case RiverTimelineEvent.ChannelMessageEncrypted:
+            return `Decrypting...`;
+        case RiverTimelineEvent.StreamMembership: {
+            return (`[${content.membership}] userId: ${content.userId} initiatorId: ${content.initiatorId}` +
+                (content.reason ? ` reason: ${content.reason}` : ''));
+        }
+        case RiverTimelineEvent.ChannelMessage:
+            return `${senderDisplayName}: ${content.body}`;
+        case RiverTimelineEvent.ChannelProperties:
+            return `properties: ${content.properties.name ?? ''} ${content.properties.topic ?? ''}`;
+        case RiverTimelineEvent.EncryptedChannelProperties:
+            return `Decrypting Channel Properties...`;
+        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 from: ${content.from} to: ${content.deviceKey} count: ${content.sessionIds.length} sessionIds: ${content.sessionIds.length ? content.sessionIds.join(',') : 'forNewDevice: true'}`;
+        case RiverTimelineEvent.KeySolicitation:
+            return `KeySolicitation deviceKey: ${content.deviceKey} sessionIds: ${content.sessionIds.length} isNewDevice: ${content.isNewDevice}`;
+        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'}`;
+    }
+}
+//# sourceMappingURL=timelineEvent.js.map