@unicitylabs/sphere-sdk 0.17.2-dev.2 → 0.17.2

package/dist/core/index.cjs

@@ -4624,6 +4624,26 @@ var GroupVisibility = {
   PRIVATE: "PRIVATE"
 };
 
+// modules/groupchat/group-id.ts
+var MAX_SLUG_LENGTH = 24;
+var RANDOM_BYTES = 8;
+function groupIdSlug(name) {
+  const slug = name.normalize("NFKD").replace(/\p{M}/gu, "").toLowerCase().replace(/['\u2019]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  if (slug.length <= MAX_SLUG_LENGTH) return slug;
+  const head = slug.slice(0, MAX_SLUG_LENGTH + 1);
+  const hyphen = head.lastIndexOf("-");
+  return hyphen > 0 ? head.slice(0, hyphen) : slug.slice(0, MAX_SLUG_LENGTH);
+}
+function newGroupId(name) {
+  const crypto2 = globalThis.crypto;
+  if (typeof crypto2?.getRandomValues !== "function") {
+    throw new SphereError("Creating a group requires crypto.getRandomValues", "INVALID_CONFIG");
+  }
+  const bytes = crypto2.getRandomValues(new Uint8Array(RANDOM_BYTES));
+  const random = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${groupIdSlug(name) || "group"}-${random}`;
+}
+
 // modules/groupchat/GroupChatModule.ts
 function createNip29Filter(data) {
   return new import_nostr_js_sdk3.Filter(data);
@@ -5235,9 +5255,9 @@ var GroupChatModule = class {
     if (!this.client) return null;
     const creatorPubkey = this.getMyPublicKey();
     if (!creatorPubkey) return null;
-    const proposedGroupId = options.name.toLowerCase().replace(/[^a-z0-9]/g, "").slice(0, 20) || this.randomId();
     try {
       const isPrivate = options.visibility === GroupVisibility.PRIVATE;
+      const proposedGroupId = newGroupId(options.name);
       const eventId = await this.client.createAndPublishEvent({
         kind: NIP29_KINDS.CREATE_GROUP,
         tags: [["h", proposedGroupId]],
@@ -9869,7 +9889,8 @@ var NFT_MEDIA_TAG = 39053n;
 var NFT_LINK_TAG = 39054n;
 var NFT_SIGNED_TAG = 39055n;
 var NFT_FORMAT_VERSION = 1n;
-var METADATA_ARITY = 8;
+var NFT_DOCUMENT_MEDIA_TYPE = "application/vnd.unicity.nft+cbor";
+var METADATA_ARITY = 9;
 var MEDIA_ARITY = 3;
 var LINK_ARITY = 4;
 var SIGNED_ARITY = 4;
@@ -9877,12 +9898,15 @@ var CREATOR_BYTES = 33;
 var SIGNATURE_BYTES = 65;
 var MAX_URI_LENGTH = 2048;
 var LINK_SCHEMES = ["https://", "ipfs://", "ar://"];
-var SIGNED_DOMAIN = "NftSigned";
+var SIGNED_DOMAIN = new TextEncoder().encode("UNICITY_NFT_SIGNED");
 var MEDIA_TYPE_PATTERN = /^[a-z0-9][a-z0-9!#$&^_.+-]{0,126}\/[a-z0-9][a-z0-9!#$&^_.+-]{0,126}$/;
 var SHA256_HEX_PATTERN = /^[0-9a-f]{64}$/i;
+var COLLECTION_ID_PATTERN = /^(?:[0-9a-f]{2}){1,64}$/i;
 var LONE_SURROGATE = /\p{Cs}/u;
 var CBOR_MAJOR_TYPE_MASK = 224;
 var ATTRIBUTE_VALUE_RULE = "must be non-empty text or an integer within \xB1(2^53 \u2212 1) \u2014 write decimals and larger numbers as text";
+var COLLECTION_ID_RULE = "must be null or 1\u201364 bytes as even-length hex (2\u2013128 characters)";
+var DOCUMENT_AS_MEDIA_RULE = `must not be ${NFT_DOCUMENT_MEDIA_TYPE}: a document link is a token's content, never media`;
 var UTF8 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
 function refuse(field, rule, cause) {
   return new SphereError(`Invalid NFT ${field}: ${rule}`, "VALIDATION_ERROR", cause);
@@ -9894,6 +9918,7 @@ var fieldName = (prefix, name) => prefix === "" ? name : `${prefix}.${name}`;
 var isText = (value) => typeof value === "string" && value.length > 0 && !LONE_SURROGATE.test(value);
 var isBytes3 = (value, length) => value instanceof Uint8Array && (length === void 0 ? value.length > 0 : value.length === length);
 var isMediaType = (value) => typeof value === "string" && MEDIA_TYPE_PATTERN.test(value);
+var isCollectionId = (value) => typeof value === "string" && COLLECTION_ID_PATTERN.test(value);
 var isAttributeValue = (value) => typeof value === "number" ? Number.isSafeInteger(value) : isText(value);
 function hasSpaceOrControl(value) {
   for (let i = 0; i < value.length; i++) {
@@ -9936,8 +9961,9 @@ function checkLink(prefix, link) {
 function checkMediaRef(field, ref) {
   if (ref === null) return;
   if (ref?.kind === "media") return checkMedia(field, ref);
-  if (ref?.kind === "link") return checkLink(field, ref);
-  throw refuse(field, "must be an NftMedia, an NftLink or null");
+  if (ref?.kind !== "link") throw refuse(field, "must be an NftMedia, an NftLink or null");
+  checkLink(field, ref);
+  ensure(!isNftDocumentLink(ref), fieldName(field, "media_type"), DOCUMENT_AS_MEDIA_RULE);
 }
 function checkAttributes(attributes) {
   ensure(Array.isArray(attributes), "attributes", "must be an array \u2014 [] when there are none");
@@ -9954,6 +9980,7 @@ function checkMetadata(metadata) {
   checkOptionalText("external_url", metadata.external_url);
   checkAttributes(metadata.attributes);
   checkOptionalText("collection", metadata.collection);
+  ensure(metadata.collection_id === null || isCollectionId(metadata.collection_id), "collection_id", COLLECTION_ID_RULE);
 }
 function checkContent(content) {
   switch (content?.kind) {
@@ -10011,6 +10038,7 @@ function arrayCbor(items) {
   }
   return out;
 }
+var optionalHexBytes = (value) => import_CborSerializer.CborSerializer.encodeNullable(value, (hex) => import_CborSerializer.CborSerializer.encodeByteString(import_HexConverter.HexConverter.decode(hex.toLowerCase())));
 function metadataCbor(metadata) {
   return versioned(
     NFT_METADATA_TAG,
@@ -10020,7 +10048,8 @@ function metadataCbor(metadata) {
     mediaRefCbor(metadata.animation_url),
     optionalText(metadata.external_url),
     arrayCbor(metadata.attributes.map(attributeCbor)),
-    optionalText(metadata.collection)
+    optionalText(metadata.collection),
+    optionalHexBytes(metadata.collection_id)
   );
 }
 function encodeNftContent(content) {
@@ -10078,13 +10107,14 @@ function decodeMedia(body) {
   const [, mediaType, bytes] = versionedFields(body, MEDIA_ARITY);
   return { kind: "media", media_type: decodeText(mediaType), bytes: import_CborDeserializer.CborDeserializer.decodeByteString(bytes) };
 }
+var decodeHex = (item) => import_HexConverter.HexConverter.encode(import_CborDeserializer.CborDeserializer.decodeByteString(item));
 function decodeLink(body) {
   const [, mediaType, uri, digest] = versionedFields(body, LINK_ARITY);
   return {
     kind: "link",
     media_type: decodeText(mediaType),
     uri: decodeText(uri),
-    sha256: import_HexConverter.HexConverter.encode(import_CborDeserializer.CborDeserializer.decodeByteString(digest))
+    sha256: decodeHex(digest)
   };
 }
 function decodeMetadata(body) {
@@ -10097,7 +10127,8 @@ function decodeMetadata(body) {
     animation_url: decodeMediaRef("animation_url", fields[4]),
     external_url: decodeOptionalText(fields[5]),
     attributes: decodeAttributes(fields[6]),
-    collection: decodeOptionalText(fields[7])
+    collection: decodeOptionalText(fields[7]),
+    collection_id: import_CborDeserializer.CborDeserializer.decodeNullable(fields[8], decodeHex)
   };
 }
 var MEDIA_REF_DECODERS = /* @__PURE__ */ new Map([
@@ -10143,20 +10174,26 @@ function parseNftPayload(data) {
     return null;
   }
 }
-function nftSignedDigest(tokenIdCbor, recipientPredicateCbor, payload) {
+function isNftDocumentLink(content) {
+  return content?.kind === "link" && content.media_type === NFT_DOCUMENT_MEDIA_TYPE;
+}
+function nftSignedDigest(context, payload) {
   const preimage = import_CborSerializer.CborSerializer.encodeArray(
-    import_CborSerializer.CborSerializer.encodeTextString(SIGNED_DOMAIN),
-    tokenIdCbor,
-    recipientPredicateCbor,
+    import_CborSerializer.CborSerializer.encodeByteString(SIGNED_DOMAIN),
+    import_CborSerializer.CborSerializer.encodeUnsignedInteger(NFT_FORMAT_VERSION),
+    import_CborSerializer.CborSerializer.encodeUnsignedInteger(import_NetworkId.NetworkId.fromId(context.networkId).id),
+    import_CborSerializer.CborSerializer.encodeByteString(context.recipientPredicate),
+    import_CborSerializer.CborSerializer.encodeByteString(context.tokenId),
+    import_CborSerializer.CborSerializer.encodeByteString(context.tokenType),
     import_CborSerializer.CborSerializer.encodeByteString(payload)
   );
   return new import_DataHasher.DataHasher(import_HashAlgorithm.HashAlgorithm.SHA256).update(preimage).digest();
 }
-async function verifyNftSignature(signed, tokenIdCbor, recipientPredicateCbor) {
+async function verifyNftSignature(signed, context) {
   try {
     if (!import_SigningService.SigningService.isPublicKeyValid(signed.creator)) return "invalid";
     const signature = import_Signature.Signature.decode(signed.signature);
-    const digest = await nftSignedDigest(tokenIdCbor, recipientPredicateCbor, signed.payload);
+    const digest = await nftSignedDigest(context, signed.payload);
     return await import_SigningService.SigningService.verifyWithPublicKey(digest, signature, signed.creator) ? "valid" : "invalid";
   } catch {
     return "invalid";
@@ -10287,8 +10324,8 @@ function assertMintableData(data) {
 function nftRecipientCbor(pubkey) {
   return import_EncodedPredicate.EncodedPredicate.fromPredicate(import_SignaturePredicate.SignaturePredicate.create(pubkey)).toCBOR();
 }
-async function signPayload(deps, payload, tokenId, recipientPubkey) {
-  const digest = await nftSignedDigest(tokenId.toCBOR(), nftRecipientCbor(recipientPubkey), payload);
+async function signPayload(deps, payload, context) {
+  const digest = await nftSignedDigest(context, payload);
   const signature = await deps.signingService.sign(digest);
   return encodeNftSigned(deps.signingService.publicKey, payload, signature.encode());
 }
@@ -10297,31 +10334,41 @@ async function planNftMint(deps, params) {
   const tokenType = new import_TokenType.TokenType(params.tokenType).bytes;
   const salt = import_TokenSalt.TokenSalt.generate();
   const tokenId = await import_TokenId.TokenId.fromSalt(deps.networkId, salt);
-  const data = params.sign ? await signPayload(deps, payload, tokenId, params.recipientPubkey) : payload;
+  const data = params.sign ? await signPayload(deps, payload, {
+    networkId: deps.networkId.id,
+    recipientPredicate: nftRecipientCbor(params.recipientPubkey),
+    tokenId: tokenId.bytes,
+    tokenType
+  }) : payload;
   assertMintableData(data);
   return { data, salt: salt.toBytes(), tokenType, tokenId: import_HexConverter.HexConverter.encode(tokenId.bytes) };
 }
-async function verifyAgainst(signed, tokenIdCbor, genesisRecipientCbor) {
+async function verifyAgainst(signed, genesisContext) {
   try {
-    return await verifyNftSignature(signed, tokenIdCbor, genesisRecipientCbor());
+    return await verifyNftSignature(signed, genesisContext());
   } catch {
     return "invalid";
   }
 }
-async function readNftData(data, tokenIdCbor, genesisRecipientCbor) {
+async function readNftData(data, genesisContext) {
   const parsed = parseNftPayload(data);
   if (parsed === null) return null;
   if (parsed.signed === null) return { content: parsed.content, creator: null, signature: "unsigned" };
   return {
     content: parsed.content,
     creator: import_HexConverter.HexConverter.encode(parsed.signed.creator),
-    signature: await verifyAgainst(parsed.signed, tokenIdCbor, genesisRecipientCbor)
+    signature: await verifyAgainst(parsed.signed, genesisContext)
   };
 }
 async function readTokenNft(token) {
   try {
     const { genesis } = token.sdkToken;
-    return await readNftData(genesis.data, genesis.tokenId.toCBOR(), () => genesis.recipient.toCBOR());
+    return await readNftData(genesis.data, () => ({
+      networkId: genesis.networkId.id,
+      recipientPredicate: genesis.recipient.toCBOR(),
+      tokenId: genesis.tokenId.bytes,
+      tokenType: genesis.tokenType.bytes
+    }));
   } catch {
     return null;
   }