@xmtp/node-sdk 4.6.0 → 5.0.0

package/dist/index.js

@@ -1,8 +1,6 @@
-import { GroupUpdatedCodec, ContentTypeGroupUpdated } from '@xmtp/content-type-group-updated';
-import { ContentTypeText, TextCodec } from '@xmtp/content-type-text';
 import { generateInboxId as generateInboxId$1, getInboxIdForIdentifier as getInboxIdForIdentifier$1, createClient as createClient$1, revokeInstallationsSignatureRequest, applySignatureRequest, inboxStateFromInboxIds, verifySignedWithPublicKey, isAddressAuthorized, isInstallationAuthorized } from '@xmtp/node-bindings';
-export { ConsentEntityType, ConsentState, ConversationType, DeliveryStatus, GroupMember, GroupMembershipState, GroupMessageKind, GroupMetadata, GroupPermissions, GroupPermissionsOptions, IdentifierKind, LogLevel, MetadataField, PermissionLevel, PermissionPolicy, PermissionUpdateType, SignatureRequestHandle, SortDirection } from '@xmtp/node-bindings';
-import { ContentTypeId } from '@xmtp/content-type-primitives';
+export { ActionStyle, ConsentEntityType, ConsentState, ContentType, ConversationType, DeliveryStatus, GroupMembershipState, GroupMessageKind, GroupPermissionsOptions, IdentifierKind, ListConversationsOrderBy, LogLevel, MessageSortBy, MetadataField, PermissionLevel, PermissionPolicy, PermissionUpdateType, ReactionAction, ReactionSchema, SortDirection, contentTypeActions, contentTypeAttachment, contentTypeGroupUpdated, contentTypeIntent, contentTypeLeaveRequest, contentTypeMarkdown, contentTypeMultiRemoteAttachment, contentTypeReaction, contentTypeReadReceipt, contentTypeRemoteAttachment, contentTypeReply, contentTypeText, contentTypeTransactionReference, contentTypeWalletSendCalls, decryptAttachment, encodeActions, encodeAttachment, encodeIntent, encodeMarkdown, encodeMultiRemoteAttachment, encodeReaction, encodeReadReceipt, encodeRemoteAttachment, encodeText, encodeTransactionReference, encodeWalletSendCalls, encryptAttachment } from '@xmtp/node-bindings';
+import { contentTypeToString } from '@xmtp/content-type-primitives';
 import { isPromise } from 'node:util/types';
 import { join } from 'node:path';
 import process from 'node:process';
@@ -34,137 +32,245 @@ const HistorySyncUrls = {
     production: "https://message-history.production.ephemera.network",
 };
 
+class InboxReassignError extends Error {
+    constructor() {
+        super("Unable to create add account signature text, `allowInboxReassign` must be true");
+    }
+}
+class AccountAlreadyAssociatedError extends Error {
+    constructor(inboxId) {
+        super(`Account already associated with inbox ${inboxId}`);
+    }
+}
+class MissingContentTypeError extends Error {
+    constructor() {
+        super("Content type is required when sending encoded content");
+    }
+}
+class SignerUnavailableError extends Error {
+    constructor() {
+        super("Signer unavailable, use Client.create to create a client with a signer");
+    }
+}
+class ClientNotInitializedError extends Error {
+    constructor() {
+        super("Client not initialized, use Client.create or Client.build to create a client");
+    }
+}
+class StreamFailedError extends Error {
+    constructor(retryAttempts) {
+        const times = `time${retryAttempts !== 1 ? "s" : ""}`;
+        super(`Stream failed, retried ${retryAttempts} ${times}`);
+    }
+}
+class StreamInvalidRetryAttemptsError extends Error {
+    constructor() {
+        super("Stream retry attempts must be greater than 0");
+    }
+}
+
+const generateInboxId = (identifier, nonce) => {
+    return generateInboxId$1(identifier, nonce);
+};
+const getInboxIdForIdentifier = async (identifier, env = "dev", gatewayHost) => {
+    const host = ApiUrls[env];
+    const isSecure = host.startsWith("https");
+    return getInboxIdForIdentifier$1(host, gatewayHost, isSecure, identifier);
+};
+
+function isHexString(value) {
+    return typeof value === "string" && /^0x(?:[0-9a-fA-F]{2})+$/.test(value);
+}
+function validHex(value) {
+    if (!isHexString(value)) {
+        throw new TypeError(`Value is not a hexadecimal string.`);
+    }
+    return value;
+}
+
+class CodecRegistry {
+    #codecs;
+    constructor(codecs) {
+        this.#codecs = new Map(codecs.map((codec) => [contentTypeToString(codec.contentType), codec]));
+    }
+    /**
+     * Gets the codec for a given content type
+     *
+     * @param contentType - The content type to get the codec for
+     * @returns The codec, if found
+     */
+    getCodec(contentType) {
+        return this.#codecs.get(contentTypeToString(contentType));
+    }
+}
+
 function nsToDate(ns) {
-    return new Date(ns / 1_000_000);
+    return new Date(Number(ns / 1000000n));
 }
 
+const getContentFromDecodedMessageContent = (content) => {
+    switch (content.type) {
+        case "Text" /* DecodedMessageContentType.Text */: {
+            return content.text;
+        }
+        case "Markdown" /* DecodedMessageContentType.Markdown */: {
+            return content.markdown;
+        }
+        case "Reply" /* DecodedMessageContentType.Reply */: {
+            return content.reply;
+        }
+        case "Reaction" /* DecodedMessageContentType.Reaction */: {
+            return content.reaction;
+        }
+        case "Attachment" /* DecodedMessageContentType.Attachment */: {
+            return content.attachment;
+        }
+        case "RemoteAttachment" /* DecodedMessageContentType.RemoteAttachment */: {
+            return content.remoteAttachment;
+        }
+        case "MultiRemoteAttachment" /* DecodedMessageContentType.MultiRemoteAttachment */: {
+            return content.multiRemoteAttachment;
+        }
+        case "TransactionReference" /* DecodedMessageContentType.TransactionReference */: {
+            return content.transactionReference;
+        }
+        case "GroupUpdated" /* DecodedMessageContentType.GroupUpdated */: {
+            return content.groupUpdated;
+        }
+        case "ReadReceipt" /* DecodedMessageContentType.ReadReceipt */: {
+            return content.readReceipt;
+        }
+        case "LeaveRequest" /* DecodedMessageContentType.LeaveRequest */: {
+            return content.leaveRequest;
+        }
+        case "WalletSendCalls" /* DecodedMessageContentType.WalletSendCalls */: {
+            return content.walletSendCalls;
+        }
+        case "Actions" /* DecodedMessageContentType.Actions */: {
+            return content.actions;
+        }
+        case "Intent" /* DecodedMessageContentType.Intent */: {
+            return content.intent;
+        }
+        case "Custom" /* DecodedMessageContentType.Custom */: {
+            return content.custom;
+        }
+        default:
+            content.type;
+            return null;
+    }
+};
 /**
  * Represents a decoded XMTP message
  *
- * This class transforms network messages into a structured format with
- * content decoding.
- *
  * @class
- * @property {any} content - The decoded content of the message
+ * @property {unknown} content - The decoded content of the message
  * @property {ContentTypeId} contentType - The content type of the message content
  * @property {string} conversationId - Unique identifier for the conversation
  * @property {MessageDeliveryStatus} deliveryStatus - Current delivery status of the message ("unpublished" | "published" | "failed")
+ * @property {bigint} expiresAtNs - Timestamp when the message will expire (in nanoseconds)
+ * @property {Date} expiresAt - Timestamp when the message will expire
  * @property {string} [fallback] - Optional fallback text for the message
- * @property {number} [compression] - Optional compression level applied to the message
  * @property {string} id - Unique identifier for the message
  * @property {MessageKind} kind - Type of message ("application" | "membership_change")
- * @property {Record<string, string>} parameters - Additional parameters associated with the message
+ * @property {number} numReplies - Number of replies to the message
+ * @property {DecodedMessage<Reaction>[]} reactions - Reactions to the message
  * @property {string} senderInboxId - Identifier for the sender's inbox
  * @property {Date} sentAt - Timestamp when the message was sent
- * @property {number} sentAtNs - Timestamp when the message was sent (in nanoseconds)
+ * @property {bigint} sentAtNs - Timestamp when the message was sent (in nanoseconds)
  */
 class DecodedMessage {
-    #client;
     content;
     contentType;
     conversationId;
     deliveryStatus;
+    expiresAtNs;
+    expiresAt;
     fallback;
-    compression;
     id;
     kind;
-    parameters;
+    numReplies;
+    reactions;
     senderInboxId;
     sentAt;
     sentAtNs;
-    constructor(client, message) {
-        this.#client = client;
+    constructor(codecRegistry, message) {
         this.id = message.id;
+        this.expiresAtNs = message.expiresAtNs ?? undefined;
+        this.expiresAt = message.expiresAtNs
+            ? nsToDate(message.expiresAtNs)
+            : undefined;
         this.sentAtNs = message.sentAtNs;
         this.sentAt = nsToDate(message.sentAtNs);
-        this.conversationId = message.convoId;
+        this.conversationId = message.conversationId;
         this.senderInboxId = message.senderInboxId;
-        switch (message.kind) {
-            case 0 /* GroupMessageKind.Application */:
-                this.kind = "application";
-                break;
-            case 1 /* GroupMessageKind.MembershipChange */:
-                this.kind = "membership_change";
-                break;
-            // no default
-        }
-        switch (message.deliveryStatus) {
-            case 0 /* DeliveryStatus.Unpublished */:
-                this.deliveryStatus = "unpublished";
-                break;
-            case 1 /* DeliveryStatus.Published */:
-                this.deliveryStatus = "published";
-                break;
-            case 2 /* DeliveryStatus.Failed */:
-                this.deliveryStatus = "failed";
+        this.contentType = message.contentType;
+        this.fallback = message.fallback ?? undefined;
+        this.kind = message.kind;
+        this.deliveryStatus = message.deliveryStatus;
+        this.numReplies = message.numReplies;
+        this.reactions = message.reactions.map((reaction) => new DecodedMessage(codecRegistry, reaction));
+        this.content =
+            getContentFromDecodedMessageContent(message.content) ??
+                undefined;
+        switch (message.content.type) {
+            case "Reply" /* DecodedMessageContentType.Reply */: {
+                const reply = message.content.reply;
+                let replyContent = getContentFromDecodedMessageContent(reply.content);
+                if (reply.content.type === "Custom" /* DecodedMessageContentType.Custom */) {
+                    const codec = codecRegistry.getCodec(reply.content.custom?.type);
+                    if (codec) {
+                        try {
+                            replyContent = codec.decode(replyContent);
+                        }
+                        catch (error) {
+                            if (error instanceof Error) {
+                                console.warn(`Error decoding custom content: ${error.message}`);
+                            }
+                            else {
+                                console.warn(`Error decoding custom content`);
+                            }
+                        }
+                    }
+                }
+                this.content = {
+                    referenceId: reply.referenceId,
+                    content: replyContent,
+                    inReplyTo: reply.inReplyTo
+                        ? new DecodedMessage(codecRegistry, reply.inReplyTo)
+                        : null,
+                };
                 break;
-            // no default
-        }
-        this.contentType = message.content.type
-            ? new ContentTypeId(message.content.type)
-            : undefined;
-        this.parameters = message.content.parameters;
-        this.fallback = message.content.fallback;
-        this.compression = message.content.compression;
-        this.content = undefined;
-        if (this.contentType) {
-            try {
-                this.content = this.#client.decodeContent(message, this.contentType);
             }
-            catch {
-                this.content = undefined;
+            case "Custom" /* DecodedMessageContentType.Custom */: {
+                const customContent = message.content.custom;
+                if (customContent !== null) {
+                    const codec = codecRegistry.getCodec(this.contentType);
+                    if (codec) {
+                        try {
+                            this.content = codec.decode(customContent);
+                        }
+                        catch (error) {
+                            if (error instanceof Error) {
+                                console.warn(`Error decoding custom content: ${error.message}`);
+                            }
+                            else {
+                                console.warn(`Error decoding custom content`);
+                            }
+                            this.content = undefined;
+                        }
+                    }
+                    else {
+                        console.warn(`No codec found for content type "${contentTypeToString(this.contentType)}"`);
+                        this.content = undefined;
+                    }
+                }
+                break;
             }
         }
     }
 }
 
-class CodecNotFoundError extends Error {
-    constructor(contentType) {
-        super(`Codec not found for "${contentType.toString()}" content type`);
-    }
-}
-class InboxReassignError extends Error {
-    constructor() {
-        super("Unable to create add account signature text, `allowInboxReassign` must be true");
-    }
-}
-class AccountAlreadyAssociatedError extends Error {
-    constructor(inboxId) {
-        super(`Account already associated with inbox ${inboxId}`);
-    }
-}
-class InvalidGroupMembershipChangeError extends Error {
-    constructor(messageId) {
-        super(`Invalid group membership change for message ${messageId}`);
-    }
-}
-class MissingContentTypeError extends Error {
-    constructor() {
-        super("Content type is required when sending content other than text");
-    }
-}
-class SignerUnavailableError extends Error {
-    constructor() {
-        super("Signer unavailable, use Client.create to create a client with a signer");
-    }
-}
-class ClientNotInitializedError extends Error {
-    constructor() {
-        super("Client not initialized, use Client.create or Client.build to create a client");
-    }
-}
-class StreamFailedError extends Error {
-    constructor(retryAttempts) {
-        const times = `time${retryAttempts !== 1 ? "s" : ""}`;
-        super(`Stream failed, retried ${retryAttempts} ${times}`);
-    }
-}
-class StreamInvalidRetryAttemptsError extends Error {
-    constructor() {
-        super("Stream retry attempts must be greater than 0");
-    }
-}
-
 /**
  * AsyncStream provides an async iterable interface for streaming data.
  *
@@ -456,19 +562,19 @@ const createStream = async (streamFunction, streamValueMutator, options) => {
  */
 class Conversation {
     #client;
+    #codecRegistry;
     #conversation;
-    #isCommitLogForked = null;
     /**
      * Creates a new conversation instance
      *
      * @param client - The client instance managing the conversation
+     * @param codecRegistry - The codec registry instance
      * @param conversation - The underlying conversation instance
-     * @param isCommitLogForked
      */
-    constructor(client, conversation, isCommitLogForked) {
+    constructor(client, codecRegistry, conversation) {
         this.#client = client;
+        this.#codecRegistry = codecRegistry;
         this.#conversation = conversation;
-        this.#isCommitLogForked = isCommitLogForked ?? null;
     }
     /**
      * Gets the unique identifier for this conversation
@@ -482,9 +588,6 @@ class Conversation {
     get isActive() {
         return this.#conversation.isActive();
     }
-    get isCommitLogForked() {
-        return this.#isCommitLogForked;
-    }
     /**
      * Gets the inbox ID that added this client's inbox to the conversation
      */
@@ -503,6 +606,17 @@ class Conversation {
     get createdAt() {
         return nsToDate(this.createdAtNs);
     }
+    pausedForVersion() {
+        return this.#conversation.pausedForVersion() ?? undefined;
+    }
+    /**
+     * Gets HMAC keys for this conversation
+     *
+     * @returns The HMAC keys for this conversation
+     */
+    hmacKeys() {
+        return this.#conversation.getHmacKeys();
+    }
     /**
      * Gets the metadata for this conversation
      *
@@ -545,7 +659,8 @@ class Conversation {
             return this.#conversation.stream(callback, onFail);
         };
         const convertMessage = (value) => {
-            return new DecodedMessage(this.#client, value);
+            const enrichedMessage = this.#client.conversations.getMessageById(value.id);
+            return enrichedMessage ?? value;
         };
         return createStream(stream, convertMessage, options);
     }
@@ -558,40 +673,141 @@ class Conversation {
         return this.#conversation.publishMessages();
     }
     /**
-     * Prepares a message to be published
+     * Sends a message with configurable delivery behavior
      *
-     * @param content - The content to send
-     * @param contentType - Optional content type of the message content
-     * @returns Promise that resolves with the message ID
-     * @throws {MissingContentTypeError} if content type is required but not provided
+     * @param encodedContent - The encoded content to send
+     * @param sendOptions - Options for sending the message
+     * @param sendOptions.shouldPush - Indicates whether this message should be
+     * included in push notifications
+     * @param sendOptions.isOptimistic - Indicates whether this message should be
+     * sent optimistically and published later via `publishMessages`
+     * @returns Promise that resolves with the message ID after it has been sent
      */
-    sendOptimistic(content, contentType) {
-        if (typeof content !== "string" && !contentType) {
+    async send(encodedContent, sendOptions) {
+        if (!encodedContent.type) {
             throw new MissingContentTypeError();
         }
-        const { encodedContent, sendOptions } = typeof content === "string"
-            ? this.#client.prepareForSend(content, contentType ?? ContentTypeText)
-            : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                this.#client.prepareForSend(content, contentType);
-        return this.#conversation.sendOptimistic(encodedContent, sendOptions);
+        return this.#conversation.send(encodedContent, sendOptions ?? { shouldPush: false });
     }
     /**
-     * Publishes a new message
+     * Sends a text message
      *
-     * @param content - The content to send
-     * @param contentType - Optional content type of the message content
+     * @param text - The text to send
+     * @param isOptimistic - Whether to send the message optimistically
      * @returns Promise that resolves with the message ID after it has been sent
-     * @throws {MissingContentTypeError} if content type is required but not provided
      */
-    async send(content, contentType) {
-        if (typeof content !== "string" && !contentType) {
-            throw new MissingContentTypeError();
-        }
-        const { encodedContent, sendOptions } = typeof content === "string"
-            ? this.#client.prepareForSend(content, contentType ?? ContentTypeText)
-            : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                this.#client.prepareForSend(content, contentType);
-        return this.#conversation.send(encodedContent, sendOptions);
+    async sendText(text, isOptimistic) {
+        return this.#conversation.sendText(text, isOptimistic);
+    }
+    /**
+     * Sends a markdown message
+     *
+     * @param markdown - The markdown to send
+     * @param isOptimistic - Whether to send the message optimistically
+     * @returns Promise that resolves with the message ID after it has been sent
+     */
+    async sendMarkdown(markdown, isOptimistic) {
+        return this.#conversation.sendMarkdown(markdown, isOptimistic);
+    }
+    /**
+     * Sends a reaction message
+     *
+     * @param reaction - The reaction to send
+     * @param isOptimistic - Whether to send the message optimistically
+     * @returns Promise that resolves with the message ID after it has been sent
+     */
+    async sendReaction(reaction, isOptimistic) {
+        return this.#conversation.sendReaction(reaction, isOptimistic);
+    }
+    /**
+     * Sends a read receipt message
+     *
+     * @param readReceipt - The read receipt to send
+     * @param isOptimistic - Whether to send the message optimistically
+     * @returns Promise that resolves with the message ID after it has been sent
+     */
+    async sendReadReceipt(isOptimistic) {
+        return this.#conversation.sendReadReceipt(isOptimistic);
+    }
+    /**
+     * Sends a reply message
+     *
+     * @param reply - The reply to send
+     * @param isOptimistic - Whether to send the message optimistically
+     * @returns Promise that resolves with the message ID after it has been sent
+     */
+    async sendReply(reply, isOptimistic) {
+        return this.#conversation.sendReply(reply, isOptimistic);
+    }
+    /**
+     * Sends a transaction reference message
+     *
+     * @param transactionReference - The transaction reference to send
+     * @param isOptimistic - Whether to send the message optimistically
+     * @returns Promise that resolves with the message ID after it has been sent
+     */
+    async sendTransactionReference(transactionReference, isOptimistic) {
+        return this.#conversation.sendTransactionReference(transactionReference, isOptimistic);
+    }
+    /**
+     * Sends a wallet send calls message
+     *
+     * @param walletSendCalls - The wallet send calls to send
+     * @param isOptimistic - Whether to send the message optimistically
+     * @returns Promise that resolves with the message ID after it has been sent
+     */
+    async sendWalletSendCalls(walletSendCalls, isOptimistic) {
+        return this.#conversation.sendWalletSendCalls(walletSendCalls, isOptimistic);
+    }
+    /**
+     * Sends a actions message
+     *
+     * @param actions - The actions to send
+     * @param isOptimistic - Whether to send the message optimistically
+     * @returns Promise that resolves with the message ID after it has been sent
+     */
+    async sendActions(actions, isOptimistic) {
+        return this.#conversation.sendActions(actions, isOptimistic);
+    }
+    /**
+     * Sends a intent message
+     *
+     * @param intent - The intent to send
+     * @param isOptimistic - Whether to send the message optimistically
+     * @returns Promise that resolves with the message ID after it has been sent
+     */
+    async sendIntent(intent, isOptimistic) {
+        return this.#conversation.sendIntent(intent, isOptimistic);
+    }
+    /**
+     * Sends an attachment message
+     *
+     * @param attachment - The attachment to send
+     * @param isOptimistic - Whether to send the message optimistically
+     * @returns Promise that resolves with the message ID after it has been sent
+     */
+    async sendAttachment(attachment, isOptimistic) {
+        return this.#conversation.sendAttachment(attachment, isOptimistic);
+    }
+    /**
+     * Sends a multi remote attachment message
+     *
+     * @param multiRemoteAttachment - The multi remote attachment to send
+     * @param isOptimistic - Whether to send the message optimistically
+     * @returns Promise that resolves with the message ID after it has been sent
+     */
+    async sendMultiRemoteAttachment(multiRemoteAttachment, isOptimistic) {
+        return this.#conversation.sendMultiRemoteAttachment(multiRemoteAttachment, isOptimistic);
+    }
+    /**
+     * Sends a remote attachment message
+     *
+     * @param remoteAttachment - The remote attachment to send
+     * @param isOptimistic - Whether to send the message optimistically
+     * @returns Promise that resolves with the message ID after it has been sent
+     */
+    async sendRemoteAttachment(remoteAttachment, isOptimistic) {
+        return this.#conversation.sendRemoteAttachment(remoteAttachment, isOptimistic);
     }
     /**
      * Lists messages in this conversation
@@ -600,8 +816,8 @@ class Conversation {
      * @returns Promise that resolves with an array of decoded messages
      */
     async messages(options) {
-        const messages = await this.#conversation.findMessages(options);
-        return messages.map((message) => new DecodedMessage(this.#client, message));
+        const messages = await this.#conversation.findEnrichedMessages(options);
+        return messages.map((message) => new DecodedMessage(this.#codecRegistry, message));
     }
     /**
      * Counts messages in this conversation
@@ -631,7 +847,7 @@ class Conversation {
     /**
      * Gets the consent state for this conversation
      */
-    get consentState() {
+    consentState() {
         return this.#conversation.consentState();
     }
     /**
@@ -679,17 +895,6 @@ class Conversation {
     isMessageDisappearingEnabled() {
         return this.#conversation.isMessageDisappearingEnabled();
     }
-    pausedForVersion() {
-        return this.#conversation.pausedForVersion() ?? undefined;
-    }
-    /**
-     * Retrieves HMAC keys for this conversation
-     *
-     * @returns The HMAC keys for this conversation
-     */
-    getHmacKeys() {
-        return this.#conversation.getHmacKeys();
-    }
     /**
      * Retrieves information for this conversation to help with debugging
      *
@@ -698,6 +903,15 @@ class Conversation {
     async debugInfo() {
         return this.#conversation.debugInfo();
     }
+    /**
+     * Retrieves the last read times for this conversation
+     *
+     * @returns A map keyed by inbox ID with the last read timestamp
+     * (nanoseconds since epoch)
+     */
+    async lastReadTimes() {
+        return this.#conversation.getLastReadTimes();
+    }
 }
 
 /**
@@ -707,17 +921,19 @@ class Conversation {
  */
 class Dm extends Conversation {
     #client;
+    #codecRegistry;
     #conversation;
     /**
      * Creates a new direct message conversation instance
      *
      * @param client - The client instance managing this direct message conversation
+     * @param codecRegistry - The codec registry instance
      * @param conversation - The underlying conversation instance
-     * @param isCommitLogForked
      */
-    constructor(client, conversation, isCommitLogForked) {
-        super(client, conversation, isCommitLogForked);
+    constructor(client, codecRegistry, conversation) {
+        super(client, codecRegistry, conversation);
         this.#client = client;
+        this.#codecRegistry = codecRegistry;
         this.#conversation = conversation;
     }
     /**
@@ -728,9 +944,9 @@ class Dm extends Conversation {
     get peerInboxId() {
         return this.#conversation.dmPeerInboxId();
     }
-    async getDuplicateDms() {
+    async duplicateDms() {
         const duplicateDms = await this.#conversation.findDuplicateDms();
-        return duplicateDms.map((dm) => new Dm(this.#client, dm));
+        return duplicateDms.map((dm) => new Dm(this.#client, this.#codecRegistry, dm));
     }
 }
 
@@ -745,11 +961,11 @@ class Group extends Conversation {
      * Creates a new group conversation instance
      *
      * @param client - The client instance managing this group conversation
+     * @param codecRegistry - The codec registry instance
      * @param conversation - The underlying conversation object
-     * @param isCommitLogForked
      */
-    constructor(client, conversation, isCommitLogForked) {
-        super(client, conversation, isCommitLogForked);
+    constructor(client, codecRegistry, conversation) {
+        super(client, codecRegistry, conversation);
         this.#conversation = conversation;
     }
     /**
@@ -811,7 +1027,7 @@ class Group extends Conversation {
     /**
      * The permissions of the group
      */
-    get permissions() {
+    permissions() {
         const permissions = this.#conversation.groupPermissions();
         return {
             policyType: permissions.policyType(),
@@ -831,13 +1047,13 @@ class Group extends Conversation {
     /**
      * The list of admins of the group
      */
-    get admins() {
+    listAdmins() {
         return this.#conversation.adminList();
     }
     /**
      * The list of super admins of the group
      */
-    get superAdmins() {
+    listSuperAdmins() {
         return this.#conversation.superAdminList();
     }
     /**
@@ -933,7 +1149,7 @@ class Group extends Conversation {
      *
      * @returns Boolean
      */
-    get isPendingRemoval() {
+    isPendingRemoval() {
         return (this.#conversation.membershipState() ===
             4 /* GroupMembershipState.PendingRemove */);
     }
@@ -946,15 +1162,18 @@ class Group extends Conversation {
  */
 class Conversations {
     #client;
+    #codecRegistry;
     #conversations;
     /**
      * Creates a new conversations instance
      *
      * @param client - The client instance managing the conversations
+     * @param codecRegistry - The codec registry instance
      * @param conversations - The underlying conversations instance
      */
-    constructor(client, conversations) {
+    constructor(client, codecRegistry, conversations) {
         this.#client = client;
+        this.#codecRegistry = codecRegistry;
         this.#conversations = conversations;
     }
     /**
@@ -969,9 +1188,14 @@ class Conversations {
             // findGroupById will throw if group is not found
             const group = this.#conversations.findGroupById(id);
             const metadata = await group.groupMetadata();
-            return metadata.conversationType() === "group"
-                ? new Group(this.#client, group)
-                : new Dm(this.#client, group);
+            switch (metadata.conversationType()) {
+                case 1 /* ConversationType.Group */:
+                    return new Group(this.#client, this.#codecRegistry, group);
+                case 0 /* ConversationType.Dm */:
+                    return new Dm(this.#client, this.#codecRegistry, group);
+                default:
+                    return undefined;
+            }
         }
         catch {
             return undefined;
@@ -988,7 +1212,7 @@ class Conversations {
         try {
             // findDmByTargetInboxId will throw if group is not found
             const group = this.#conversations.findDmByTargetInboxId(inboxId);
-            return new Dm(this.#client, group);
+            return new Dm(this.#client, this.#codecRegistry, group);
         }
         catch {
             return undefined;
@@ -1001,8 +1225,8 @@ class Conversations {
      * @returns Promise that resolves with the DM, if found
      * @see https://docs.xmtp.org/chat-apps/core-messaging/create-conversations#conversation-helper-methods
      */
-    async getDmByIdentifier(identifier) {
-        const inboxId = await this.#client.getInboxIdByIdentifier(identifier);
+    async fetchDmByIdentifier(identifier) {
+        const inboxId = await this.#client.fetchInboxIdByIdentifier(identifier);
         if (!inboxId) {
             return undefined;
         }
@@ -1017,24 +1241,24 @@ class Conversations {
      */
     getMessageById(id) {
         try {
-            // findMessageById will throw if message is not found
-            const message = this.#conversations.findMessageById(id);
-            return new DecodedMessage(this.#client, message);
+            // findEnrichedMessageById will throw if message is not found
+            const message = this.#conversations.findEnrichedMessageById(id);
+            return new DecodedMessage(this.#codecRegistry, message);
         }
         catch {
             return undefined;
         }
     }
     /**
-     * Creates a new group conversation without syncing to the network
+     * Creates a new group conversation without publishing to the network
      *
      * @param options - Optional group creation options
      * @returns The new group
      * @see https://docs.xmtp.org/chat-apps/core-messaging/create-conversations#optimistically-create-a-new-group-chat
      */
-    newGroupOptimistic(options) {
+    createGroupOptimistic(options) {
         const group = this.#conversations.createGroupOptimistic(options);
-        return new Group(this.#client, group);
+        return new Group(this.#client, this.#codecRegistry, group);
     }
     /**
      * Creates a new group conversation with the specified identifiers
@@ -1044,9 +1268,9 @@ class Conversations {
      * @returns The new group
      * @see https://docs.xmtp.org/chat-apps/core-messaging/create-conversations#create-a-new-group-chat
      */
-    async newGroupWithIdentifiers(identifiers, options) {
+    async createGroupWithIdentifiers(identifiers, options) {
         const group = await this.#conversations.createGroup(identifiers, options);
-        const conversation = new Group(this.#client, group);
+        const conversation = new Group(this.#client, this.#codecRegistry, group);
         return conversation;
     }
     /**
@@ -1057,9 +1281,9 @@ class Conversations {
      * @returns The new group
      * @see https://docs.xmtp.org/chat-apps/core-messaging/create-conversations#create-a-new-group-chat
      */
-    async newGroup(inboxIds, options) {
+    async createGroup(inboxIds, options) {
         const group = await this.#conversations.createGroupByInboxId(inboxIds, options);
-        const conversation = new Group(this.#client, group);
+        const conversation = new Group(this.#client, this.#codecRegistry, group);
         return conversation;
     }
     /**
@@ -1070,9 +1294,9 @@ class Conversations {
      * @returns The new DM
      * @see https://docs.xmtp.org/agents/build-agents/create-conversations#by-ethereum-address-1
      */
-    async newDmWithIdentifier(identifier, options) {
+    async createDmWithIdentifier(identifier, options) {
         const group = await this.#conversations.createDm(identifier, options);
-        const conversation = new Dm(this.#client, group);
+        const conversation = new Dm(this.#client, this.#codecRegistry, group);
         return conversation;
     }
     /**
@@ -1083,9 +1307,9 @@ class Conversations {
      * @returns The new DM
      * @see https://docs.xmtp.org/agents/build-agents/create-conversations#by-inbox-id-1
      */
-    async newDm(inboxId, options) {
+    async createDm(inboxId, options) {
         const group = await this.#conversations.createDmByInboxId(inboxId, options);
-        const conversation = new Dm(this.#client, group);
+        const conversation = new Dm(this.#client, this.#codecRegistry, group);
         return conversation;
     }
     /**
@@ -1101,10 +1325,10 @@ class Conversations {
             const metadata = await item.conversation.groupMetadata();
             const conversationType = metadata.conversationType();
             switch (conversationType) {
-                case "dm":
-                    return new Dm(this.#client, item.conversation, item.isCommitLogForked);
-                case "group":
-                    return new Group(this.#client, item.conversation, item.isCommitLogForked);
+                case 0 /* ConversationType.Dm */:
+                    return new Dm(this.#client, this.#codecRegistry, item.conversation);
+                case 1 /* ConversationType.Group */:
+                    return new Group(this.#client, this.#codecRegistry, item.conversation);
                 default:
                     return undefined;
             }
@@ -1124,7 +1348,7 @@ class Conversations {
             conversationType: 1 /* ConversationType.Group */,
         });
         return groups.map((item) => {
-            const conversation = new Group(this.#client, item.conversation, item.isCommitLogForked);
+            const conversation = new Group(this.#client, this.#codecRegistry, item.conversation);
             return conversation;
         });
     }
@@ -1141,7 +1365,7 @@ class Conversations {
             conversationType: 0 /* ConversationType.Dm */,
         });
         return groups.map((item) => {
-            const conversation = new Dm(this.#client, item.conversation, item.isCommitLogForked);
+            const conversation = new Dm(this.#client, this.#codecRegistry, item.conversation);
             return conversation;
         });
     }
@@ -1185,11 +1409,11 @@ class Conversations {
             const conversationType = metadata.conversationType();
             let conversation;
             switch (conversationType) {
-                case "dm":
-                    conversation = new Dm(this.#client, value);
+                case 0 /* ConversationType.Dm */:
+                    conversation = new Dm(this.#client, this.#codecRegistry, value);
                     break;
-                case "group":
-                    conversation = new Group(this.#client, value);
+                case 1 /* ConversationType.Group */:
+                    conversation = new Group(this.#client, this.#codecRegistry, value);
                     break;
             }
             return conversation;
@@ -1211,7 +1435,7 @@ class Conversations {
             return this.#conversations.stream(callback, onFail, 1 /* ConversationType.Group */);
         };
         const convertConversation = (value) => {
-            return new Group(this.#client, value);
+            return new Group(this.#client, this.#codecRegistry, value);
         };
         return createStream(stream, convertConversation, options);
     }
@@ -1230,7 +1454,7 @@ class Conversations {
             return this.#conversations.stream(callback, onFail, 0 /* ConversationType.Dm */);
         };
         const convertConversation = (value) => {
-            return new Dm(this.#client, value);
+            return new Dm(this.#client, this.#codecRegistry, value);
         };
         return createStream(stream, convertConversation, options);
     }
@@ -1251,7 +1475,8 @@ class Conversations {
             return this.#conversations.streamAllMessages(callback, onFail, options?.conversationType, options?.consentStates);
         };
         const convertMessage = (value) => {
-            return new DecodedMessage(this.#client, value);
+            const enrichedMessage = this.getMessageById(value.id);
+            return enrichedMessage ?? value;
         };
         return createStream(streamAllMessages, convertMessage, options);
     }
@@ -1301,7 +1526,7 @@ class Conversations {
         return createStream(stream, undefined, options);
     }
     /**
-     * Retrieves HMAC keys for all conversations
+     * Gets the HMAC keys for all conversations
      *
      * @returns The HMAC keys for all conversations
      * @see https://docs.xmtp.org/chat-apps/push-notifs/push-notifs#get-hmac-keys-for-a-conversation
@@ -1318,10 +1543,8 @@ class Conversations {
  */
 class DebugInformation {
     #client;
-    #options;
-    constructor(client, options) {
+    constructor(client) {
         this.#client = client;
-        this.#options = options;
     }
     apiStatistics() {
         return this.#client.apiStatistics();
@@ -1335,11 +1558,6 @@ class DebugInformation {
     clearAllStatistics() {
         this.#client.clearAllStatistics();
     }
-    uploadDebugArchive(serverUrl) {
-        const env = this.#options?.env || "dev";
-        const historySyncUrl = this.#options?.historySyncUrl || HistorySyncUrls[env];
-        return this.#client.uploadDebugArchive(serverUrl || historySyncUrl);
-    }
 }
 
 /**
@@ -1364,32 +1582,39 @@ class Preferences {
         return this.#client.syncPreferences();
     }
     /**
-     * Retrieves the current inbox state
+     * Retrieves the current inbox state of this client from the local database
      *
-     * @param refreshFromNetwork - Optional flag to force refresh from network
      * @returns Promise that resolves with the inbox state
      */
-    async inboxState(refreshFromNetwork = false) {
-        return this.#client.inboxState(refreshFromNetwork);
+    async inboxState() {
+        return this.#client.inboxState(false);
     }
     /**
-     * Gets the latest inbox state for a specific inbox
+     * Retrieves the latest inbox state of this clientfrom the network
      *
-     * @param inboxId - The inbox ID to get state for
-     * @returns Promise that resolves with the latest inbox state
+     * @returns Promise that resolves with the inbox state
      */
-    async getLatestInboxState(inboxId) {
-        return this.#client.getLatestInboxState(inboxId);
+    async fetchInboxState() {
+        return this.#client.inboxState(true);
     }
     /**
-     * Retrieves inbox state for specific inbox IDs
+     * Retrieves the current inbox states for specified inbox IDs from the local
+     * database
      *
      * @param inboxIds - Array of inbox IDs to get state for
-     * @param refreshFromNetwork - Optional flag to force refresh from network
-     * @returns Promise that resolves with the inbox state for the inbox IDs
+     * @returns Promise that resolves with the inbox states for the inbox IDs
      */
-    async inboxStateFromInboxIds(inboxIds, refreshFromNetwork) {
-        return this.#client.addressesFromInboxId(refreshFromNetwork ?? false, inboxIds);
+    async getInboxStates(inboxIds) {
+        return this.#client.addressesFromInboxId(false, inboxIds);
+    }
+    /**
+     * Retrieves the latest inbox states for specified inbox IDs from the network
+     *
+     * @param inboxIds - Array of inbox IDs to get state for
+     * @returns Promise that resolves with the inbox states for the inbox IDs
+     */
+    async fetchInboxStates(inboxIds) {
+        return this.#client.addressesFromInboxId(true, inboxIds);
     }
     /**
      * Updates consent states for multiple records
@@ -1442,25 +1667,6 @@ class Preferences {
     }
 }
 
-const generateInboxId = (identifier, nonce) => {
-    return generateInboxId$1(identifier, nonce);
-};
-const getInboxIdForIdentifier = async (identifier, env = "dev", gatewayHost) => {
-    const host = ApiUrls[env];
-    const isSecure = host.startsWith("https");
-    return getInboxIdForIdentifier$1(host, gatewayHost, isSecure, identifier);
-};
-
-function isHexString(value) {
-    return typeof value === "string" && /^0x(?:[0-9a-fA-F]{2})+$/.test(value);
-}
-function validHex(value) {
-    if (!isHexString(value)) {
-        throw new TypeError(`Value is not a hexadecimal string.`);
-    }
-    return value;
-}
-
 const createClient = async (identifier, options) => {
     const env = options?.env || "dev";
     const host = options?.apiUrl || ApiUrls[env];
@@ -1483,18 +1689,18 @@ const createClient = async (identifier, options) => {
     }
     const logOptions = {
         structured: options?.structuredLogging ?? false,
-        level: options?.loggingLevel ?? "off" /* LogLevel.off */,
+        level: options?.loggingLevel ?? "Off" /* LogLevel.Off */,
     };
     const historySyncUrl = options?.historySyncUrl === undefined
         ? HistorySyncUrls[env]
         : options.historySyncUrl;
     const deviceSyncWorkerMode = options?.disableDeviceSync
-        ? "disabled" /* SyncWorkerMode.disabled */
-        : "enabled" /* SyncWorkerMode.enabled */;
+        ? "Disabled" /* SyncWorkerMode.Disabled */
+        : "Enabled" /* SyncWorkerMode.Enabled */;
     const dbEncryptionKey = isHexString(options?.dbEncryptionKey)
         ? Buffer.from(options.dbEncryptionKey.replace(/^0x/, ""), "hex")
         : options?.dbEncryptionKey;
-    return createClient$1(host, gatewayHost, isSecure, dbPath, inboxId, identifier, dbEncryptionKey, historySyncUrl, deviceSyncWorkerMode, logOptions, undefined, options?.debugEventsEnabled, options?.appVersion);
+    return createClient$1(host, gatewayHost, isSecure, dbPath, inboxId, identifier, dbEncryptionKey, historySyncUrl, deviceSyncWorkerMode, logOptions, undefined, options?.appVersion);
 };
 
 /**
@@ -1502,11 +1708,11 @@ const createClient = async (identifier, options) => {
  */
 class Client {
     #client;
+    #codecRegistry;
     #conversations;
     #debugInformation;
     #preferences;
     #signer;
-    #codecs;
     #identifier;
     #options;
     /**
@@ -1519,12 +1725,7 @@ class Client {
      */
     constructor(options) {
         this.#options = options;
-        const codecs = [
-            new GroupUpdatedCodec(),
-            new TextCodec(),
-            ...(options?.codecs ?? []),
-        ];
-        this.#codecs = new Map(codecs.map((codec) => [codec.contentType.toString(), codec]));
+        this.#codecRegistry = new CodecRegistry([...(options?.codecs ?? [])]);
     }
     /**
      * Initializes the client with the provided identifier
@@ -1541,8 +1742,8 @@ class Client {
         this.#identifier = identifier;
         this.#client = await createClient(identifier, this.#options);
         const conversations = this.#client.conversations();
-        this.#conversations = new Conversations(this, conversations);
-        this.#debugInformation = new DebugInformation(this.#client, this.#options);
+        this.#conversations = new Conversations(this, this.#codecRegistry, conversations);
+        this.#debugInformation = new DebugInformation(this.#client);
         this.#preferences = new Preferences(this.#client, conversations);
     }
     /**
@@ -1896,7 +2097,7 @@ class Client {
     async unsafe_addAccount(newAccountSigner, allowInboxReassign = false) {
         // check for existing inbox id
         const identifier = await newAccountSigner.getIdentifier();
-        const existingInboxId = await this.getInboxIdByIdentifier(identifier);
+        const existingInboxId = await this.fetchInboxIdByIdentifier(identifier);
         if (existingInboxId && !allowInboxReassign) {
             throw new AccountAlreadyAssociatedError(existingInboxId);
         }
@@ -1973,17 +2174,6 @@ class Client {
         }
         await applySignatureRequest(host, gatewayHost, signatureRequest);
     }
-    /**
-     * Gets the inbox state for the specified inbox IDs without a client
-     *
-     * @param env - The environment to use
-     * @param inboxIds - The inbox IDs to get the state for
-     * @returns The inbox state for the specified inbox IDs
-     */
-    static async inboxStateFromInboxIds(inboxIds, env, gatewayHost) {
-        const host = ApiUrls[env ?? "dev"];
-        return inboxStateFromInboxIds(host, gatewayHost, inboxIds);
-    }
     /**
      * Changes the recovery identifier for the client's inbox
      *
@@ -2013,129 +2203,28 @@ class Client {
         return new Map(Object.entries(canMessage));
     }
     /**
-     * Checks if the specified identifiers can be messaged
-     *
-     * @param identifiers - The identifiers to check
-     * @param env - Optional XMTP environment
-     * @returns Map of identifiers to whether they can be messaged
-     */
-    static async canMessage(identifiers, env) {
-        const canMessageMap = new Map();
-        for (const identifier of identifiers) {
-            const inboxId = await getInboxIdForIdentifier(identifier, env);
-            canMessageMap.set(identifier.identifier.toLowerCase(), inboxId !== null);
-        }
-        return canMessageMap;
-    }
-    /**
-     * Gets the key package statuses for the specified installation IDs
+     * Fetches the key package statuses from the network for the specified
+     * installation IDs
      *
      * @param installationIds - The installation IDs to check
      * @returns The key package statuses
      * @throws {ClientNotInitializedError} if the client is not initialized
      */
-    async getKeyPackageStatusesForInstallationIds(installationIds) {
+    async fetchKeyPackageStatuses(installationIds) {
         if (!this.#client) {
             throw new ClientNotInitializedError();
         }
         return this.#client.getKeyPackageStatusesForInstallationIds(installationIds);
     }
     /**
-     * Gets the codec for a given content type
-     *
-     * @param contentType - The content type to get the codec for
-     * @returns The codec, if found
-     */
-    codecFor(contentType) {
-        return this.#codecs.get(contentType.toString());
-    }
-    /**
-     * Encodes content for a given content type
-     *
-     * @param content - The content to encode
-     * @param contentType - The content type to encode for
-     * @returns The encoded content
-     * @throws {CodecNotFoundError} if no codec is found for the content type
-     */
-    encodeContent(content, contentType) {
-        const codec = this.codecFor(contentType);
-        if (!codec) {
-            throw new CodecNotFoundError(contentType);
-        }
-        return this.#encodeWithCodec(content, codec);
-    }
-    /**
-     * Prepares content for sending by encoding it and generating send options from the codec
-     *
-     * @param content - The message content to prepare for sending
-     * @param contentType - The content type identifier for the appropriate codec
-     * @returns An object containing the encoded content and send options
-     * @throws {CodecNotFoundError} When no codec is registered for the specified content type
-     */
-    prepareForSend(content, contentType) {
-        const codec = this.codecFor(contentType);
-        if (!codec) {
-            throw new CodecNotFoundError(contentType);
-        }
-        return {
-            encodedContent: this.#encodeWithCodec(content, codec),
-            sendOptions: this.#sendMessageOpts(content, codec),
-        };
-    }
-    /**
-     * Encodes content using a specific codec and adds fallback information if available
-     *
-     * @param content - The content to encode
-     * @param codec - The codec to use for encoding
-     * @returns The encoded content with optional fallback
-     */
-    #encodeWithCodec(content, codec) {
-        const encoded = codec.encode(content, this);
-        const fallback = codec.fallback(content);
-        if (fallback) {
-            encoded.fallback = fallback;
-        }
-        return encoded;
-    }
-    /**
-     * Generates send options based on the content and codec
-     *
-     * @param content - The content being sent
-     * @param codec - The codec used for the content
-     * @returns Send options including whether to push notify recipients
-     */
-    #sendMessageOpts(content, codec) {
-        return { shouldPush: codec.shouldPush(content) };
-    }
-    /**
-     * Decodes a message for a given content type
-     *
-     * @param message - The message to decode
-     * @param contentType - The content type to decode for
-     * @returns The decoded content
-     * @throws {CodecNotFoundError} if no codec is found for the content type
-     * @throws {InvalidGroupMembershipChangeError} if the message is an invalid group membership change
-     */
-    decodeContent(message, contentType) {
-        const codec = this.codecFor(contentType);
-        if (!codec) {
-            throw new CodecNotFoundError(contentType);
-        }
-        // throw an error if there's an invalid group membership change message
-        if (contentType.sameAs(ContentTypeGroupUpdated) &&
-            message.kind !== 1 /* GroupMessageKind.MembershipChange */) {
-            throw new InvalidGroupMembershipChangeError(message.id);
-        }
-        return codec.decode(message.content, this);
-    }
-    /**
-     * Finds the inbox ID for a given identifier
+     * Fetches the inbox ID for a given identifier from the local database
+     * If not found, fetches from the network
      *
      * @param identifier - The identifier to look up
      * @returns The inbox ID, if found
      * @throws {ClientNotInitializedError} if the client is not initialized
      */
-    async getInboxIdByIdentifier(identifier) {
+    async fetchInboxIdByIdentifier(identifier) {
         if (!this.#client) {
             throw new ClientNotInitializedError();
         }
@@ -2174,6 +2263,33 @@ class Client {
             return false;
         }
     }
+    /**
+     * Fetches the inbox states for the specified inbox IDs from the network
+     * without a client
+     *
+     * @param env - The environment to use
+     * @param inboxIds - The inbox IDs to get the state for
+     * @returns The inbox states for the specified inbox IDs
+     */
+    static async fetchInboxStates(inboxIds, env, gatewayHost) {
+        const host = ApiUrls[env ?? "dev"];
+        return inboxStateFromInboxIds(host, gatewayHost, inboxIds);
+    }
+    /**
+     * Checks if the specified identifiers can be messaged
+     *
+     * @param identifiers - The identifiers to check
+     * @param env - Optional XMTP environment
+     * @returns Map of identifiers to whether they can be messaged
+     */
+    static async canMessage(identifiers, env) {
+        const canMessageMap = new Map();
+        for (const identifier of identifiers) {
+            const inboxId = await getInboxIdForIdentifier(identifier, env);
+            canMessageMap.set(identifier.identifier.toLowerCase(), inboxId !== null);
+        }
+        return canMessageMap;
+    }
     /**
      * Verifies a signature was made with a public key
      *
@@ -2215,15 +2331,7 @@ class Client {
         const host = ApiUrls[env ?? "dev"];
         return await isInstallationAuthorized(host, gatewayHost, inboxId, installation);
     }
-    /**
-     * Gets the version of the Node bindings
-     * @deprecated
-     */
-    static get version() {
-        console.warn("Client.version is deprecated. Use Client.libxmtpVersion instead.");
-        return undefined;
-    }
 }
 
-export { AccountAlreadyAssociatedError, ApiUrls, Client, ClientNotInitializedError, CodecNotFoundError, Conversation, Conversations, DecodedMessage, Dm, Group, HistorySyncUrls, InboxReassignError, InvalidGroupMembershipChangeError, MissingContentTypeError, SignerUnavailableError, StreamFailedError, StreamInvalidRetryAttemptsError, generateInboxId, getInboxIdForIdentifier, isHexString, validHex };
+export { AccountAlreadyAssociatedError, ApiUrls, Client, ClientNotInitializedError, Conversation, Conversations, DecodedMessage, Dm, Group, HistorySyncUrls, InboxReassignError, MissingContentTypeError, SignerUnavailableError, StreamFailedError, StreamInvalidRetryAttemptsError, generateInboxId, getInboxIdForIdentifier, isHexString, validHex };
 //# sourceMappingURL=index.js.map