@unicitylabs/sphere-sdk 0.17.2-dev.1 → 0.17.2-dev.3

package/dist/token-engine/index.cjs

@@ -22,6 +22,7 @@ var token_engine_exports = {};
 __export(token_engine_exports, {
   CheckpointPersistFailedError: () => CheckpointPersistFailedError,
   CheckpointTrustbaseMismatchError: () => CheckpointTrustbaseMismatchError,
+  NFT_DOCUMENT_MEDIA_TYPE: () => NFT_DOCUMENT_MEDIA_TYPE,
   NFT_FORMAT_VERSION: () => NFT_FORMAT_VERSION,
   NFT_LINK_TAG: () => NFT_LINK_TAG,
   NFT_MEDIA_TAG: () => NFT_MEDIA_TAG,
@@ -36,7 +37,9 @@ __export(token_engine_exports, {
   deriveDirectAddress: () => deriveDirectAddress,
   encodeNftContent: () => encodeNftContent,
   encodeNftSigned: () => encodeNftSigned,
+  isNftDocumentLink: () => isNftDocumentLink,
   nftSignedDigest: () => nftSignedDigest,
+  parseNftDocument: () => parseNftDocument,
   parseNftPayload: () => parseNftPayload,
   sphereAssetToSdk: () => sphereAssetToSdk,
   verifyNftLinkContent: () => verifyNftLinkContent,
@@ -973,7 +976,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;
@@ -981,12 +985,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);
@@ -998,6 +1005,7 @@ var fieldName = (prefix, name) => prefix === "" ? name : `${prefix}.${name}`;
 var isText = (value) => typeof value === "string" && value.length > 0 && !LONE_SURROGATE.test(value);
 var isBytes2 = (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++) {
@@ -1040,8 +1048,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");
@@ -1058,6 +1067,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) {
@@ -1115,6 +1125,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,
@@ -1124,7 +1135,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) {
@@ -1182,13 +1194,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) {
@@ -1201,7 +1214,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([
@@ -1213,6 +1227,10 @@ var UNSIGNED_DECODERS = /* @__PURE__ */ new Map([
   [NFT_MEDIA_TAG, decodeMedia],
   [NFT_LINK_TAG, decodeLink]
 ]);
+var DOCUMENT_DECODERS = /* @__PURE__ */ new Map([
+  [NFT_METADATA_TAG, decodeMetadata],
+  [NFT_MEDIA_TAG, decodeMedia]
+]);
 function decodeBody(decoders, field, tag, body) {
   const decode = decoders.get(tag);
   if (decode === void 0) throw refuse(field, `tag ${tag} is not allowed here`);
@@ -1247,20 +1265,35 @@ function parseNftPayload(data) {
     return null;
   }
 }
-function nftSignedDigest(tokenIdCbor, recipientPredicateCbor, payload) {
+function parseNftDocument(bytes) {
+  try {
+    const document = decodeItem(DOCUMENT_DECODERS, "document", bytes);
+    checkContent(document);
+    return document;
+  } catch {
+    return null;
+  }
+}
+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";
@@ -1391,8 +1424,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());
 }
@@ -1401,31 +1434,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;
   }
@@ -2074,6 +2117,7 @@ async function createSphereTokenEngine(config) {
 0 && (module.exports = {
   CheckpointPersistFailedError,
   CheckpointTrustbaseMismatchError,
+  NFT_DOCUMENT_MEDIA_TYPE,
   NFT_FORMAT_VERSION,
   NFT_LINK_TAG,
   NFT_MEDIA_TAG,
@@ -2088,7 +2132,9 @@ async function createSphereTokenEngine(config) {
   deriveDirectAddress,
   encodeNftContent,
   encodeNftSigned,
+  isNftDocumentLink,
   nftSignedDigest,
+  parseNftDocument,
   parseNftPayload,
   sphereAssetToSdk,
   verifyNftLinkContent,