@solarpunkltd/swarm-chat-js 8.1.0 → 10.0.0

package/dist/message/entry.d.ts

@@ -13,11 +13,11 @@ export declare const historyLinkSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type HistoryLink = z.infer<typeof historyLinkSchema>;
 export declare const feedEntrySchema: z.ZodObject<{
-    v: z.ZodLiteral<8>;
+    v: z.ZodLiteral<9>;
     seq: z.ZodNumber;
     at: z.ZodNumber;
     msg: z.ZodObject<{
-        v: z.ZodLiteral<8>;
+        v: z.ZodLiteral<9>;
         topic: z.ZodString;
         id: z.ZodString;
         type: z.ZodEnum<{
@@ -34,11 +34,15 @@ export declare const feedEntrySchema: z.ZodObject<{
             gateway: "gateway";
             "own-stamp": "own-stamp";
         }>;
-        own: z.ZodBoolean;
         idb: z.ZodOptional<z.ZodObject<{
             msg: z.ZodString;
             sig: z.ZodString;
         }, z.core.$strict>>;
+        wl: z.ZodOptional<z.ZodObject<{
+            msg: z.ZodString;
+            wsig: z.ZodString;
+            asig: z.ZodString;
+        }, z.core.$strict>>;
         sig: z.ZodString;
     }, z.core.$strict>;
     history: z.ZodNullable<z.ZodObject<{
@@ -51,7 +55,7 @@ export declare const historyRowSchema: z.ZodObject<{
     seq: z.ZodNumber;
     at: z.ZodNumber;
     msg: z.ZodObject<{
-        v: z.ZodLiteral<8>;
+        v: z.ZodLiteral<9>;
         topic: z.ZodString;
         id: z.ZodString;
         type: z.ZodEnum<{
@@ -68,18 +72,22 @@ export declare const historyRowSchema: z.ZodObject<{
             gateway: "gateway";
             "own-stamp": "own-stamp";
         }>;
-        own: z.ZodBoolean;
         idb: z.ZodOptional<z.ZodObject<{
             msg: z.ZodString;
             sig: z.ZodString;
         }, z.core.$strict>>;
+        wl: z.ZodOptional<z.ZodObject<{
+            msg: z.ZodString;
+            wsig: z.ZodString;
+            asig: z.ZodString;
+        }, z.core.$strict>>;
         sig: z.ZodString;
     }, z.core.$strict>;
 }, z.core.$strict>;
 export type HistoryRow = z.infer<typeof historyRowSchema>;
 /** A row that fails its shape is left out and counted, so one bad row never hides the rest of the file. */
 export declare const historyFileSchema: z.ZodObject<{
-    v: z.ZodLiteral<8>;
+    v: z.ZodLiteral<9>;
     topic: z.ZodString;
     fromSeq: z.ZodNumber;
     toSeq: z.ZodNumber;

package/dist/message/index.d.ts

@@ -1,5 +1,6 @@
 export * from './message.js';
 export * from './binding.js';
+export * from './walletLink.js';
 export * from './ownFeed.js';
 export * from './entry.js';
 export * from './note.js';

package/dist/message/message.d.ts

@@ -1,16 +1,18 @@
 import { PrivateKey } from '@ethersphere/bee-js';
 import { z } from 'zod';
 import { type ChatBinding, type ChatIdentity } from './binding.js';
+import { type WalletLink } from './walletLink.js';
 /**
- * The chat message of version 8: what a browser sends as a GSOC payload, what the server verifies before it
+ * The chat message of version 9: what a browser sends as a GSOC payload, what the server verifies before it
  * publishes, and what every feed entry carries back as `msg`. This module is the only place its bytes are built,
  * signed, checked and read, and the server imports it from here rather than keeping a copy. A message of any other
  * version fails the shape check.
  */
-export declare const MESSAGE_VERSION = 8;
+export declare const MESSAGE_VERSION = 9;
 /**
- * Measured on the UTF-8 of the whole JSON object, on top of the per-field caps. Large enough for a 500 character text
- * of two byte characters with a Swarm ID binding, at every other cap.
+ * Measured on the UTF-8 of the whole JSON object, on top of the per-field caps, wallet link included. Large enough for
+ * a 500 character text of two byte characters with a Swarm ID binding and a wallet link, at every other cap, which
+ * comes to 2,376 bytes.
  */
 export declare const MAX_MESSAGE_BYTES = 3072;
 export declare const MAX_TOPIC_CHARACTERS = 128;
@@ -33,8 +35,18 @@ export type MessageVia = (typeof MessageVia)[keyof typeof MessageVia];
  * once. A composer that shows a count uses this function, so it and the check agree.
  */
 export declare function countCharacters(value: string): number;
+/**
+ * Why a name is refused: `length` is outside 1 to {@link MAX_NAME_CHARACTERS} characters, `invisible` holds a format
+ * or control character, `ens-like` ends in `.eth` as a reader sees it, which only a verified ENS name may show.
+ */
+export type DisplayNameProblem = 'length' | 'invisible' | 'ens-like';
+/**
+ * Whether `name` is one a message may carry, as the message check reads it, and why not when it is not. A composer
+ * calls this on the name as it will be sent, so it and the check agree.
+ */
+export declare function displayNameProblem(name: string): DisplayNameProblem | null;
 export declare const chatMessageSchema: z.ZodObject<{
-    v: z.ZodLiteral<8>;
+    v: z.ZodLiteral<9>;
     topic: z.ZodString;
     id: z.ZodString;
     type: z.ZodEnum<{
@@ -51,11 +63,15 @@ export declare const chatMessageSchema: z.ZodObject<{
         gateway: "gateway";
         "own-stamp": "own-stamp";
     }>;
-    own: z.ZodBoolean;
     idb: z.ZodOptional<z.ZodObject<{
         msg: z.ZodString;
         sig: z.ZodString;
     }, z.core.$strict>>;
+    wl: z.ZodOptional<z.ZodObject<{
+        msg: z.ZodString;
+        wsig: z.ZodString;
+        asig: z.ZodString;
+    }, z.core.$strict>>;
     sig: z.ZodString;
 }, z.core.$strict>;
 export type ChatMessage = z.infer<typeof chatMessageSchema>;
@@ -72,11 +88,12 @@ export type ChatMessageCheck = {
     detail: string;
 };
 /**
- * `origin` is the site the chat runs on, a bare origin such as `https://example.com`, and is required: a binding for
- * any other site is refused, so a binding signed for one site never passes in another site's chat.
+ * `origins` are the sites the chat runs on, each a bare origin such as `https://example.com`, and are required: a
+ * binding for any other site is refused, so a binding signed for one site never passes in a chat that site is not
+ * part of. A chat served from several pages, such as one domain and a copy on Swarm under an ENS name, lists each.
  */
 export interface VerifyOptions {
-    origin: string;
+    origins: readonly string[];
     /** Accept a binding for `http://localhost`, `http://127.0.0.1` or `http://[::1]`, as only a development build signs. */
     allowLocalHttp?: boolean;
 }
@@ -102,10 +119,10 @@ export interface ChatMessageDraft {
     ts?: number;
     /** Who pays for the inbox write. Required, since nothing can tell from here. */
     via: MessageVia;
-    /** Whether the sender also keeps a copy in its own feed, false when left out. */
-    own?: boolean;
     /** The sender's Swarm ID chat binding, given only for a signed-in sender. */
     idb?: ChatBinding;
+    /** The sender's Swarm ID wallet link, given only beside `idb`, for a sender who shows an ENS name. */
+    wl?: WalletLink;
 }
 export interface SignedChatMessage {
     message: ChatMessage;
@@ -123,8 +140,10 @@ export declare function createChatMessage(privateKey: PrivateKey | Uint8Array |
 export declare function hasValidSignature(message: ChatMessage): boolean;
 /**
  * Verifies a message that arrived as an object: its shape, its signature, and, when it carries a binding, that the
- * binding is the fork's four lines for this `addr` and for `options.origin`, and recovers an account. A message whose
- * binding fails is refused as `binding`, never passed as a guest, and so is a bound message checked with no origin.
+ * binding is Swarm ID's four lines for this `addr` and for one of `options.origins`, and recovers an account. When it also
+ * carries a wallet link, the link must be Swarm ID's five lines for that account, signed by its wallet and by the
+ * account, and the identity then names the wallet. A message whose binding or link fails is refused as `binding`,
+ * never passed as a guest, and so is a bound message checked with no origins.
  * Never throws, and touches no DOM and no Node API, so a page runs it in a Web Worker as the server runs it.
  */
 export declare function verifyChatMessage(value: unknown, options: VerifyOptions): ChatMessageCheck;

package/dist/message/ownFeed.d.ts

@@ -1,6 +1,6 @@
 /**
- * A sender may keep a copy of each message it sends in a feed of its own, owned by its chat address `addr`, and says
- * so with `own: true`. That feed is named by `ownFeedTopic(chatTopic)`, turned into a feed topic with
+ * A sender may keep a copy of each message it sends in a feed of its own, owned by its chat address `addr`. The
+ * message says nothing about it, so whether a copy exists is read from that feed. That feed is named by `ownFeedTopic(chatTopic)`, turned into a feed topic with
  * `Topic.fromString` as the chat's own feed is named by `chatTopic`. The prefix carries a version, so a later layout of
  * the copies takes a new topic rather than mixing with this one.
  */

package/dist/message/personalSign.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The address that made `sig` over `text`, `0x` and 40 lowercase hex characters, or null for a signature Swarm ID
+ * would refuse or nothing recovers from. `sig` is `0x` and 130 hex characters of r, s and v, already shape-checked.
+ */
+export declare function recoverPersonalSigner(text: string, sig: string): string | null;
+/** Whether `text` is a date in the one spelling `Date.prototype.toISOString` writes. */
+export declare function isCanonicalDate(text: string): boolean;

package/dist/message/walletLink.d.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+/**
+ * The Swarm ID wallet link: the statement, signed by an account's wallet and countersigned by the account's own key,
+ * that the two belong to the same person, which lets a reader show the wallet's ENS name. The Swarm ID fork makes it
+ * while the person has "Show my ENS name on sites" on, and its canonical description is `docs/Wallet-Link.md` in the
+ * fork (solarpunk-id), with `verifyWalletLink` in its `lib/src/utils/wallet-link.ts`. This module reads it exactly as
+ * that function does, without importing Swarm ID: the same five lines, the second of them read exactly, and both
+ * EIP-191 personal_sign signatures with v 27 or 28 and a low s. It looks nothing up: a reader takes the checked wallet to its own ENS lookup.
+ */
+/** The first line, which also versions the wallet link format. */
+export declare const WALLET_LINK_TITLE = "Swarm ID wallet link v1";
+/** The second line, what the wallet's owner agrees to, which a wallet shows them before they sign. */
+export declare const WALLET_LINK_STATEMENT = "I link this wallet to the Swarm ID account below, so sites may show my ENS name beside its messages.";
+/** Swarm ID's own bound on a wallet link's text, which is 258 characters in the format it writes. */
+export declare const MAX_WALLET_LINK_CHARACTERS = 320;
+/**
+ * A wallet link as a message carries it: Swarm ID's `{ message, walletSignature, accountSignature }` as `msg`, `wsig`
+ * and `asig`. Each signature is spelled as Swarm ID writes it, `0x` and 130 lowercase hex characters of r, s and v, so
+ * one link has one spelling inside the signed bytes.
+ */
+export declare const walletLinkSchema: z.ZodObject<{
+    msg: z.ZodString;
+    wsig: z.ZodString;
+    asig: z.ZodString;
+}, z.core.$strict>;
+export type WalletLink = z.infer<typeof walletLinkSchema>;
+export type WalletLinkCheck = {
+    ok: true;
+    /** The wallet both signatures were checked for, `0x` and 40 lowercase hex characters. */
+    wallet: string;
+    /** The account the link names, which is the one it was checked against. */
+    account: string;
+    /** When the account says it signed, ISO 8601 UTC. */
+    date: string;
+} | {
+    ok: false;
+    detail: string;
+};
+/**
+ * Reads a wallet link for `account` (`0x` and 40 lowercase hex characters), the account a verified chat binding
+ * named. Refuses every text but the five lines Swarm ID writes, its statement included, a wallet signature that does not recover the wallet
+ * the link names, an account signature that does not recover the account it names, and a link naming any other
+ * account. Never throws.
+ */
+export declare function checkWalletLink(link: WalletLink, account: string): WalletLinkCheck;