@bcts/provenance-mark 1.0.0-alpha.8 → 1.0.0-beta.0

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@bcts/provenance-mark",
-  "version": "1.0.0-alpha.8",
+  "version": "1.0.0-beta.0",
   "type": "module",
   "description": "Blockchain Commons Provenance Mark for TypeScript - A cryptographically-secured system for establishing and verifying the authenticity of works",
   "license": "BSD-2-Clause-Patent",
-  "author": "Leonardo Custodio <leonardo@custodio.me>",
-  "homepage": "https://github.com/leonardocustodio/bcts",
+  "author": "Parity Technologies <admin@parity.io> (https://parity.io)",
+  "homepage": "https://bcts.dev",
   "repository": {
     "type": "git",
-    "url": "https://github.com/leonardocustodio/bcts",
+    "url": "https://github.com/paritytech/bcts",
     "directory": "packages/provenance-mark"
   },
   "bugs": {
-    "url": "https://github.com/leonardocustodio/bcts/issues"
+    "url": "https://github.com/paritytech/bcts/issues"
   },
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
@@ -33,11 +33,10 @@
   ],
   "scripts": {
     "build": "tsdown",
-    "dev": "tsdown --watch",
     "test": "vitest run",
     "test:watch": "vitest",
-    "lint": "eslint 'src/**/*.ts'",
-    "lint:fix": "eslint 'src/**/*.ts' --fix",
+    "lint": "eslint 'src/**/*.ts' 'tests/**/*.ts'",
+    "lint:fix": "eslint 'src/**/*.ts' 'tests/**/*.ts' --fix",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist",
     "docs": "typedoc",
@@ -57,22 +56,23 @@
   "devDependencies": {
     "@bcts/eslint": "^0.1.0",
     "@bcts/tsconfig": "^0.1.0",
-    "@eslint/js": "^9.39.1",
-    "@typescript-eslint/eslint-plugin": "^8.49.0",
-    "@typescript-eslint/parser": "^8.49.0",
-    "eslint": "^9.39.1",
+    "@eslint/js": "^10.0.1",
+    "@typescript-eslint/eslint-plugin": "^8.59.0",
+    "@typescript-eslint/parser": "^8.59.0",
+    "eslint": "^10.2.1",
     "ts-node": "^10.9.2",
-    "tsdown": "^0.17.2",
-    "typedoc": "^0.28.15",
-    "typescript": "^5.9.3",
-    "vitest": "^3.2.4"
+    "tsdown": "^0.21.0",
+    "typedoc": "^0.28.19",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
   },
   "dependencies": {
-    "@bcts/dcbor": "^1.0.0-alpha.8",
-    "@bcts/rand": "^1.0.0-alpha.8",
-    "@bcts/tags": "^1.0.0-alpha.8",
-    "@bcts/uniform-resources": "^1.0.0-alpha.8",
-    "@noble/ciphers": "^1.3.0",
-    "@noble/hashes": "^1.8.0"
+    "@bcts/dcbor": "^1.0.0-beta.0",
+    "@bcts/envelope": "^1.0.0-beta.0",
+    "@bcts/rand": "^1.0.0-beta.0",
+    "@bcts/tags": "^1.0.0-beta.0",
+    "@bcts/uniform-resources": "^1.0.0-beta.0",
+    "@noble/ciphers": "^2.2.0",
+    "@noble/hashes": "^2.2.0"
   }
 }

package/src/crypto-utils.ts

@@ -1,8 +1,14 @@
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ */
+
 // Ported from provenance-mark-rust/src/crypto_utils.rs
 
-import { sha256 as sha256Hash } from "@noble/hashes/sha256";
-import { hkdf } from "@noble/hashes/hkdf";
-import { chacha20 } from "@noble/ciphers/chacha";
+import { sha256 as sha256Hash } from "@noble/hashes/sha2.js";
+import { hkdf } from "@noble/hashes/hkdf.js";
+import { chacha20 } from "@noble/ciphers/chacha.js";
 
 export const SHA256_SIZE = 32;
 

package/src/date.ts

@@ -1,3 +1,9 @@
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ */
+
 // Ported from provenance-mark-rust/src/date.rs
 
 import { ProvenanceMarkError, ProvenanceMarkErrorType } from "./error.js";
@@ -214,3 +220,39 @@ export function dateToDateString(date: Date): string {
   const day = date.getUTCDate().toString().padStart(2, "0");
   return `${year}-${month}-${day}`;
 }
+
+/**
+ * Renders a `Date` the way Rust's `dcbor::Date::Display` does
+ * (`bc-dcbor-rust/src/date.rs:485-492`):
+ *
+ * - When the UTC time is exactly `00:00:00` (subsecond precision is
+ *   ignored — Rust's check is `hour == 0 && minute == 0 && second == 0`,
+ *   matching `chrono::SecondsFormat::Secs`), emit just `YYYY-MM-DD`.
+ * - Otherwise emit RFC 3339 with second precision (no fractional
+ *   seconds), e.g. `2023-02-08T15:30:45Z`.
+ *
+ * This is the canonical "Rust string" for dates across the
+ * provenance-mark public surface — `mark.toDebugString`,
+ * `mark.precedesOpt` `DateOrdering` issue, `markdownSummary`, and the
+ * validation report's `DateOrdering` payload all use it. Centralising
+ * here keeps every call site in lockstep with the Rust output.
+ *
+ * @example
+ * ```typescript
+ * dateToDisplay(new Date("2023-06-20T00:00:00Z"));   // "2023-06-20"
+ * dateToDisplay(new Date("2023-06-20T15:30:45Z"));   // "2023-06-20T15:30:45Z"
+ * dateToDisplay(new Date("2023-06-20T15:30:45.123Z")); // "2023-06-20T15:30:45Z"
+ * ```
+ */
+export function dateToDisplay(date: Date): string {
+  const hasTime =
+    date.getUTCHours() !== 0 || date.getUTCMinutes() !== 0 || date.getUTCSeconds() !== 0;
+  if (!hasTime) {
+    // Midnight (subsecond precision ignored) — show only the date.
+    return dateToDateString(date);
+  }
+  // Full RFC 3339, second precision. JS `toISOString()` always emits
+  // millisecond precision (`.NNNZ`); strip the fractional component to
+  // match Rust's `SecondsFormat::Secs`.
+  return date.toISOString().replace(/\.\d{3}Z$/, "Z");
+}

package/src/envelope.ts

@@ -0,0 +1,122 @@
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ *
+ * Envelope support for Provenance Marks
+ *
+ * This module provides Gordian Envelope integration for ProvenanceMark and
+ * ProvenanceMarkGenerator, enabling them to be used with the bc-envelope
+ * ecosystem.
+ *
+ * Ported from provenance-mark-rust/src/mark.rs and generator.rs (envelope feature)
+ */
+
+import {
+  type Envelope,
+  type FormatContext,
+  withFormatContextMut,
+  registerTagsIn as envelopeRegisterTagsIn,
+} from "@bcts/envelope";
+import { type Cbor, type SummarizerResult } from "@bcts/dcbor";
+import { PROVENANCE_MARK } from "@bcts/tags";
+import { ProvenanceMark } from "./mark.js";
+import { ProvenanceMarkGenerator } from "./generator.js";
+
+// ============================================================================
+// Tag Registration
+// ============================================================================
+
+/**
+ * Registers provenance mark tags in the global format context.
+ *
+ * Matches Rust: register_tags()
+ */
+export function registerTags(): void {
+  withFormatContextMut((context) => {
+    registerTagsIn(context);
+  });
+}
+
+/**
+ * Registers provenance mark tags in a specific format context.
+ *
+ * Matches Rust: register_tags_in()
+ *
+ * @param context - The format context to register tags in
+ */
+export function registerTagsIn(context: FormatContext): void {
+  envelopeRegisterTagsIn(context);
+
+  context
+    .tags()
+    .setSummarizer(
+      BigInt(PROVENANCE_MARK.value),
+      (untaggedCbor: Cbor, _flat: boolean): SummarizerResult => {
+        try {
+          const mark = ProvenanceMark.fromUntaggedCbor(untaggedCbor);
+          return { ok: true, value: mark.toString() };
+        } catch {
+          return { ok: false, error: { type: "Custom", message: "invalid provenance mark" } };
+        }
+      },
+    );
+}
+
+// ============================================================================
+// ProvenanceMark Envelope Support
+// ============================================================================
+
+/**
+ * Convert a ProvenanceMark to an Envelope.
+ *
+ * Delegates to ProvenanceMark.intoEnvelope() — single source of truth.
+ *
+ * @param mark - The provenance mark to convert
+ * @returns An envelope containing the mark
+ */
+export function provenanceMarkToEnvelope(mark: ProvenanceMark): Envelope {
+  return mark.intoEnvelope();
+}
+
+/**
+ * Extract a ProvenanceMark from an Envelope.
+ *
+ * Delegates to ProvenanceMark.fromEnvelope() — single source of truth.
+ *
+ * @param envelope - The envelope to extract from
+ * @returns The extracted provenance mark
+ * @throws ProvenanceMarkError if extraction fails
+ */
+export function provenanceMarkFromEnvelope(envelope: Envelope): ProvenanceMark {
+  return ProvenanceMark.fromEnvelope(envelope);
+}
+
+// ============================================================================
+// ProvenanceMarkGenerator Envelope Support
+// ============================================================================
+
+/**
+ * Convert a ProvenanceMarkGenerator to an Envelope.
+ *
+ * Delegates to ProvenanceMarkGenerator.intoEnvelope() — single source of truth.
+ *
+ * @param generator - The generator to convert
+ * @returns An envelope containing the generator
+ */
+export function provenanceMarkGeneratorToEnvelope(generator: ProvenanceMarkGenerator): Envelope {
+  return generator.intoEnvelope();
+}
+
+/**
+ * Extract a ProvenanceMarkGenerator from an Envelope.
+ *
+ * Delegates to ProvenanceMarkGenerator.fromEnvelope() — single source of truth.
+ *
+ * @param envelope - The envelope to extract from
+ * @returns The extracted generator
+ * @throws ProvenanceMarkError if extraction fails
+ */
+export function provenanceMarkGeneratorFromEnvelope(envelope: Envelope): ProvenanceMarkGenerator {
+  return ProvenanceMarkGenerator.fromEnvelope(envelope);
+}

package/src/error.ts

@@ -1,3 +1,9 @@
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ */
+
 // Ported from provenance-mark-rust/src/error.rs
 
 /**
@@ -50,6 +56,19 @@ export enum ProvenanceMarkErrorType {
   IntegerConversionError = "IntegerConversionError",
   /** Validation error */
   ValidationError = "ValidationError",
+  /**
+   * Envelope serialization/deserialization error.
+   *
+   * Mirrors Rust `Error::Envelope(...)`
+   * (`provenance-mark-rust/src/error.rs`). The Rust enum surfaces
+   * envelope-format failures as their own variant; in earlier
+   * revisions of this port they collapsed into `CborError`. Both
+   * shapes are still emitted in practice (CBOR errors during envelope
+   * round-trip stay as `CborError`); this variant exists for the
+   * structural-level mismatches the Rust port tags as
+   * `Error::Envelope`.
+   */
+  EnvelopeError = "EnvelopeError",
 }
 
 /**
@@ -129,6 +148,8 @@ export class ProvenanceMarkError extends Error {
         return `integer conversion error: ${d("message")}`;
       case ProvenanceMarkErrorType.ValidationError:
         return `validation error: ${d("message")}`;
+      case ProvenanceMarkErrorType.EnvelopeError:
+        return `envelope error: ${d("message")}`;
       default:
         return type;
     }

package/src/generator.ts

@@ -1,10 +1,22 @@
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ */
+
 // Ported from provenance-mark-rust/src/generator.rs
 
 import { toBase64, fromBase64, bytesToHex } from "./utils.js";
 import { type Cbor } from "@bcts/dcbor";
+import { Envelope } from "@bcts/envelope";
 
 import { ProvenanceMarkError, ProvenanceMarkErrorType } from "./error.js";
-import { type ProvenanceMarkResolution, linkLength } from "./resolution.js";
+import {
+  type ProvenanceMarkResolution,
+  linkLength,
+  resolutionToNumber,
+  resolutionFromCbor,
+} from "./resolution.js";
 import { ProvenanceSeed } from "./seed.js";
 import { RngState } from "./rng-state.js";
 import { sha256 } from "./crypto-utils.js";
@@ -150,9 +162,24 @@ export class ProvenanceMarkGenerator {
 
   /**
    * String representation.
+   *
+   * Mirrors Rust `Display for ProvenanceMarkGenerator`
+   * (`provenance-mark-rust/src/generator.rs:135-147`):
+   *
+   * ```rust
+   * write!(f, "ProvenanceMarkGenerator(chainID: {}, res: {}, seed: {}, nextSeq: {}, rngState: {:?})",
+   *     hex::encode(&self.chain_id), self.res, self.seed.hex(), self.next_seq, self.rng_state)
+   * ```
+   *
+   * The `rngState` field uses Rust's `{:?}` (Debug) format, which on a
+   * `RngState([u8; 32])` tuple struct produces `RngState([n0, n1, ...])`
+   * with each byte rendered as a decimal integer. Earlier revisions of
+   * this port omitted `rngState` entirely from `toString()`, so the
+   * output diverged from Rust's `Display`.
    */
   toString(): string {
-    return `ProvenanceMarkGenerator(chainID: ${bytesToHex(this._chainId)}, res: ${this._res}, seed: ${this._seed.hex()}, nextSeq: ${this._nextSeq})`;
+    const rngBytes = Array.from(this._rngState.toBytes()).join(", ");
+    return `ProvenanceMarkGenerator(chainID: ${bytesToHex(this._chainId)}, res: ${this._res}, seed: ${this._seed.hex()}, nextSeq: ${this._nextSeq}, rngState: RngState([${rngBytes}]))`;
   }
 
   /**
@@ -179,4 +206,128 @@ export class ProvenanceMarkGenerator {
     const rngState = RngState.fromBytes(fromBase64(json["rngState"] as string));
     return ProvenanceMarkGenerator.new(res, seed, chainId, nextSeq, rngState);
   }
+
+  // ============================================================================
+  // Envelope Support (EnvelopeEncodable)
+  // ============================================================================
+
+  /**
+   * Convert this generator to a Gordian Envelope.
+   *
+   * The envelope contains structured assertions for all generator fields:
+   * - isA: "provenance-generator"
+   * - res: The resolution
+   * - seed: The seed
+   * - next-seq: The next sequence number
+   * - rng-state: The RNG state
+   *
+   * Note: Use provenanceMarkGeneratorToEnvelope() for a standalone function alternative.
+   */
+  intoEnvelope(): Envelope {
+    // Create envelope with chain ID as subject
+    let envelope = Envelope.new(this._chainId);
+
+    // Add type assertion (using addType() which uses IS_A KnownValue, like Rust's add_type())
+    envelope = envelope.addType("provenance-generator");
+
+    // Add resolution
+    envelope = envelope.addAssertion("res", resolutionToNumber(this._res));
+
+    // Add seed
+    envelope = envelope.addAssertion("seed", this._seed.toBytes());
+
+    // Add next sequence number
+    envelope = envelope.addAssertion("next-seq", this._nextSeq);
+
+    // Add RNG state
+    envelope = envelope.addAssertion("rng-state", this._rngState.toBytes());
+
+    return envelope;
+  }
+
+  /**
+   * Extract a ProvenanceMarkGenerator from a Gordian Envelope.
+   *
+   * @param envelope - The envelope to extract from
+   * @returns The extracted generator
+   * @throws ProvenanceMarkError if extraction fails
+   */
+  static fromEnvelope(envelope: Envelope): ProvenanceMarkGenerator {
+    type EnvelopeExt = Envelope & {
+      asByteString(): Uint8Array | undefined;
+      hasType(t: string): boolean;
+      assertionsWithPredicate(p: string): Envelope[];
+      subject(): Envelope;
+    };
+
+    const env = envelope as EnvelopeExt;
+
+    // Check type
+    if (!env.hasType("provenance-generator")) {
+      throw new ProvenanceMarkError(ProvenanceMarkErrorType.CborError, undefined, {
+        message: "Envelope is not a provenance-generator",
+      });
+    }
+
+    // Extract chain ID from subject
+    const subject = env.subject() as EnvelopeExt;
+    const chainId = subject.asByteString();
+    if (chainId === undefined) {
+      throw new ProvenanceMarkError(ProvenanceMarkErrorType.CborError, undefined, {
+        message: "Could not extract chain ID",
+      });
+    }
+
+    // Helper to extract assertion object value
+    const extractAssertion = (predicate: string): { cbor: Cbor; bytes: Uint8Array | undefined } => {
+      const assertions = env.assertionsWithPredicate(predicate);
+      if (assertions.length === 0) {
+        throw new ProvenanceMarkError(ProvenanceMarkErrorType.CborError, undefined, {
+          message: `Missing ${predicate} assertion`,
+        });
+      }
+      const assertionCase = assertions[0].case();
+      if (assertionCase.type !== "assertion") {
+        throw new ProvenanceMarkError(ProvenanceMarkErrorType.CborError, undefined, {
+          message: `Invalid ${predicate} assertion`,
+        });
+      }
+      const obj = assertionCase.assertion.object() as EnvelopeExt;
+      const objCase = obj.case();
+      if (objCase.type === "leaf") {
+        return { cbor: objCase.cbor, bytes: obj.asByteString() };
+      }
+      throw new ProvenanceMarkError(ProvenanceMarkErrorType.CborError, undefined, {
+        message: `Invalid ${predicate} value`,
+      });
+    };
+
+    // Extract resolution
+    const resValue = extractAssertion("res");
+    const res = resolutionFromCbor(resValue.cbor);
+
+    // Extract seed
+    const seedValue = extractAssertion("seed");
+    if (seedValue.bytes === undefined) {
+      throw new ProvenanceMarkError(ProvenanceMarkErrorType.CborError, undefined, {
+        message: "Invalid seed data",
+      });
+    }
+    const seed = ProvenanceSeed.fromBytes(seedValue.bytes);
+
+    // Extract next-seq
+    const seqValue = extractAssertion("next-seq");
+    const nextSeq = Number(seqValue.cbor);
+
+    // Extract rng-state
+    const rngValue = extractAssertion("rng-state");
+    if (rngValue.bytes === undefined) {
+      throw new ProvenanceMarkError(ProvenanceMarkErrorType.CborError, undefined, {
+        message: "Invalid rng-state data",
+      });
+    }
+    const rngState = RngState.fromBytes(rngValue.bytes);
+
+    return ProvenanceMarkGenerator.new(res, seed, chainId, nextSeq, rngState);
+  }
 }

package/src/index.ts

@@ -1,3 +1,9 @@
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ */
+
 // Ported from provenance-mark-rust
 
 // Error types
@@ -44,8 +50,13 @@ export {
   dateToIso8601,
   dateFromIso8601,
   dateToDateString,
+  dateToDisplay,
 } from "./date.js";
 
+// User-facing parsers (mirroring Rust `util::parse_seed` /
+// `util::parse_date`).
+export { parseSeed, parseDate } from "./utils.js";
+
 // Crypto utilities
 export {
   SHA256_SIZE,
@@ -88,3 +99,16 @@ export {
 
 // Mark Info
 export { ProvenanceMarkInfo } from "./mark-info.js";
+
+// Envelope support
+export {
+  registerTags,
+  registerTagsIn,
+  provenanceMarkToEnvelope,
+  provenanceMarkFromEnvelope,
+  provenanceMarkGeneratorToEnvelope,
+  provenanceMarkGeneratorFromEnvelope,
+} from "./envelope.js";
+
+// Re-export FormatContext for registerTagsIn callers
+export { FormatContext } from "@bcts/envelope";

package/src/mark-info.ts

@@ -1,10 +1,15 @@
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ */
+
 // Ported from provenance-mark-rust/src/mark_info.rs
 
-import { UR } from "@bcts/uniform-resources";
-import { decodeCbor, cborData } from "@bcts/dcbor";
-import { PROVENANCE_MARK } from "@bcts/tags";
+import type { UR } from "@bcts/uniform-resources";
 
 import { ProvenanceMark } from "./mark.js";
+import { dateToDisplay } from "./date.js";
 
 /**
  * Wrapper for a provenance mark with additional display information.
@@ -32,16 +37,21 @@ export class ProvenanceMarkInfo {
 
   /**
    * Create a new ProvenanceMarkInfo from a mark.
+   *
+   * Mirrors Rust `ProvenanceMarkInfo::new`
+   * (`provenance-mark-rust/src/mark_info.rs`), which calls
+   * `mark.ur()` — i.e. the `UREncodable` implementation, whose
+   * payload is the **untagged** CBOR with type `"provenance"`. Earlier
+   * revisions of this port called `decodeCbor(mark.toCborData())` and
+   * wrapped the resulting *tagged* CBOR in `UR.new("provenance", ...)`,
+   * which prepended the CBOR tag to the UR bytewords and broke
+   * cross-impl interop (UR strings produced by Rust would not parse,
+   * and vice versa).
    */
   static new(mark: ProvenanceMark, comment = ""): ProvenanceMarkInfo {
-    const tagName = PROVENANCE_MARK.name;
-    if (tagName === undefined) {
-      throw new Error("PROVENANCE_MARK tag has no name");
-    }
-    const cborValue = decodeCbor(mark.toCborData());
-    const ur = UR.new(tagName, cborValue);
-    const bytewords = mark.bytewordsIdentifier(true);
-    const bytemoji = mark.bytemojiIdentifier(true);
+    const ur = mark.ur();
+    const bytewords = mark.idBytewords(4, true);
+    const bytemoji = mark.idBytemoji(4, true);
     return new ProvenanceMarkInfo(mark, ur, bytewords, bytemoji, comment);
   }
 
@@ -67,6 +77,10 @@ export class ProvenanceMarkInfo {
 
   /**
    * Generate a markdown summary of the mark.
+   *
+   * Date rendering uses {@link dateToDisplay} so midnight-UTC dates
+   * appear as `YYYY-MM-DD` (matching Rust `format!("{}",
+   * self.mark.date())`), not as `YYYY-MM-DDT00:00:00Z`.
    */
   markdownSummary(): string {
     const lines: string[] = [];
@@ -74,7 +88,7 @@ export class ProvenanceMarkInfo {
     lines.push("---");
 
     lines.push("");
-    lines.push(this._mark.date().toISOString());
+    lines.push(dateToDisplay(this._mark.date()));
 
     lines.push("");
     lines.push(`#### ${this._ur.toString()}`);
@@ -95,29 +109,36 @@ export class ProvenanceMarkInfo {
   }
 
   /**
-   * JSON serialization.
+   * JSON serialization. Field order mirrors Rust's `#[derive(Serialize)]`
+   * on `ProvenanceMarkInfo` (provenance-mark-rust/src/mark_info.rs):
+   * `ur, bytewords, bytemoji, [comment,] mark` — `comment` (when present)
+   * comes BEFORE `mark`. Rust uses `skip_serializing_if = "String::is_empty"`,
+   * matched here by the `if (...length > 0)` guard.
    */
   toJSON(): Record<string, unknown> {
     const result: Record<string, unknown> = {
       ur: this._ur.toString(),
       bytewords: this._bytewords,
       bytemoji: this._bytemoji,
-      mark: this._mark.toJSON(),
     };
     if (this._comment.length > 0) {
       result["comment"] = this._comment;
     }
+    result["mark"] = this._mark.toJSON();
     return result;
   }
 
   /**
    * Create from JSON object.
+   *
+   * Decodes the UR string through {@link ProvenanceMark.fromURString},
+   * which correctly handles the **untagged** CBOR payload that
+   * `mark.ur()` produces — symmetric with the constructor.
    */
   static fromJSON(json: Record<string, unknown>): ProvenanceMarkInfo {
     const urString = json["ur"] as string;
-    const ur = UR.fromURString(urString);
-    const cborBytes = cborData(ur.cbor());
-    const mark = ProvenanceMark.fromCborData(cborBytes);
+    const mark = ProvenanceMark.fromURString(urString);
+    const ur = mark.ur();
     const bytewords = json["bytewords"] as string;
     const bytemoji = json["bytemoji"] as string;
     const comment = typeof json["comment"] === "string" ? json["comment"] : "";