@misofm/platform 0.0.0 → 0.18.0

package/src/release-extensions.ts

@@ -0,0 +1,311 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// First-party metadata attached to a protocol Release. The JSON/CLI release
+// intent aggregates these concerns, but every value is written by its own
+// independently deployed extension package.
+
+import type { ClientWithCoreApi } from "@mysten/sui/client";
+import { bcs } from "@mysten/sui/bcs";
+import { deriveDynamicFieldID, deriveObjectID } from "@mysten/sui/utils";
+import type {
+  Transaction,
+  TransactionArgument,
+  TransactionObjectArgument,
+} from "@mysten/sui/transactions";
+import type { TxThunk } from "./transactions.ts";
+import * as genre from "@misofm/protocol/contracts/genre/genre";
+import * as releaseDescription from "@misofm/protocol/contracts/release_description/release_description";
+import * as releaseDspLink from "@misofm/protocol/contracts/release_dsp_link/release_dsp_link";
+import * as releaseGenre from "@misofm/protocol/contracts/release_genre/release_genre";
+import * as releaseKind from "@misofm/protocol/contracts/release_kind/release_kind";
+import { asU64, directAdminCap, invokeWithAdminCap, type AdminCapAuthority, type ObjectInput, type U64Input } from "./vault.ts";
+
+function object(tx: Transaction, value: ObjectInput): TransactionObjectArgument {
+  return typeof value === "string" ? tx.object(value) : value;
+}
+
+type ReleaseAuthorityInput =
+  | { readonly authority: AdminCapAuthority; readonly releaseAdminCapId?: never }
+  | { readonly authority?: never; readonly releaseAdminCapId: string };
+interface ReleaseExtensionTargetBase {
+  releaseId: ObjectInput;
+}
+export type ReleaseExtensionTarget = ReleaseExtensionTargetBase & ReleaseAuthorityInput;
+function authority(p: ReleaseExtensionTarget): AdminCapAuthority {
+  if (p.authority !== undefined) return p.authority;
+  if (p.releaseAdminCapId !== undefined) return directAdminCap(p.releaseAdminCapId);
+  throw new Error("release authority is required");
+}
+
+export type SetReleaseKindParams = ReleaseExtensionTarget & {
+  kind: string;
+  releaseKindPackageId: string;
+};
+
+/** Attach the release's self-declared kind (for example "EP" or "Mixtape"). */
+export function setReleaseKind(p: SetReleaseKindParams): TxThunk {
+  const bytes = new TextEncoder().encode(p.kind).length;
+  if (bytes === 0) throw new Error("setReleaseKind: kind must not be empty");
+  if (bytes > 32) {
+    throw new Error(
+      `setReleaseKind: kind must be at most 32 UTF-8 bytes (got ${bytes})`,
+    );
+  }
+  return (tx) => {
+    invokeWithAdminCap(tx, authority(p), {
+      target: `${p.releaseKindPackageId}::release_kind::set_kind`,
+      arguments: [object(tx, p.releaseId), tx.pure.string(p.kind)],
+      adminCapIndex: 1,
+    });
+  };
+}
+
+const ReleaseKindField = bcs.struct("Field", {
+  id: bcs.Address,
+  name: releaseKind.ExtensionKey,
+  value: bcs.string(),
+});
+const RELEASE_KIND_KEY_BYTES = releaseKind.ExtensionKey.serialize([
+  false,
+]).toBytes();
+
+/** Deterministic dynamic-field id for a Release's optional self-declared kind. */
+export function releaseKindFieldId(
+  releaseId: string,
+  releaseKindPackageId: string,
+): string {
+  return deriveDynamicFieldID(
+    releaseId,
+    `${releaseKindPackageId}::release_kind::ExtensionKey`,
+    RELEASE_KIND_KEY_BYTES,
+  );
+}
+
+/** Parse the dynamic field storing `Option<String>` as its present string. */
+export function parseReleaseKindContent(content: Uint8Array): string {
+  return ReleaseKindField.parse(content).value;
+}
+
+/** Read a Release's self-declared kind, or `null` when the extension is absent. */
+export async function getReleaseKind(
+  client: ClientWithCoreApi,
+  releaseId: string,
+  releaseKindPackageId: string,
+): Promise<string | null> {
+  const { objects } = await client.core.getObjects({
+    objectIds: [releaseKindFieldId(releaseId, releaseKindPackageId)],
+    include: { content: true },
+  });
+  const object = objects[0];
+  if (!object || object instanceof Error || !object.content) return null;
+  return parseReleaseKindContent(object.content);
+}
+
+export type SetReleaseDescriptionParams = ReleaseExtensionTarget & {
+  description: string;
+  releaseDescriptionPackageId: string;
+};
+
+/** Attach the release's editorial description. */
+export function setReleaseDescription(p: SetReleaseDescriptionParams): TxThunk {
+  const bytes = new TextEncoder().encode(p.description).length;
+  if (bytes === 0) {
+    throw new Error("setReleaseDescription: description must not be empty");
+  }
+  if (bytes > 8192) {
+    throw new Error(
+      `setReleaseDescription: description must be at most 8192 UTF-8 bytes (got ${bytes})`,
+    );
+  }
+  return (tx) => {
+    invokeWithAdminCap(tx, authority(p), {
+      target: `${p.releaseDescriptionPackageId}::release_description::set_description`,
+      arguments: [object(tx, p.releaseId), tx.pure.string(p.description)],
+      adminCapIndex: 1,
+    });
+  };
+}
+
+const GENRE_NAME_RE = /^[A-Z]+(?:_[A-Z]+)*$/;
+
+/** Validate the canonical on-chain genre vocabulary spelling. */
+export function assertCanonicalGenreName(name: string): void {
+  const bytes = new TextEncoder().encode(name).length;
+  if (bytes === 0 || bytes > 64 || !GENRE_NAME_RE.test(name)) {
+    throw new Error(
+      `Genre name must be 1-64 bytes of uppercase A-Z and underscores; got ${JSON.stringify(name)}`,
+    );
+  }
+}
+
+/** Derive the immutable Genre object address for a canonical vocabulary name.
+ * `genrePackageId` must be the genre package's defining (original publish)
+ * address — the on-chain derivation hashes type names with defining IDs. */
+export function deriveGenreAddress(
+  genreRegistryId: string,
+  genrePackageId: string,
+  canonicalName: string,
+): string {
+  assertCanonicalGenreName(canonicalName);
+  return deriveObjectID(
+    genreRegistryId,
+    `${genrePackageId}::genre::GenreKey`,
+    genre.GenreKey.serialize([canonicalName]).toBytes(),
+  );
+}
+
+export interface TrackGenreAssignment {
+  trackIndex: U64Input;
+  genreId: string;
+}
+
+export type SetReleaseGenresParams = ReleaseExtensionTarget & {
+  primaryGenreId: string;
+  secondaryGenreIds?: readonly string[];
+  trackPrimaryGenres?: readonly TrackGenreAssignment[];
+  releaseGenrePackageId: string;
+};
+
+/** Attach primary/secondary release genres and optional per-track overrides. */
+export function setReleaseGenres(p: SetReleaseGenresParams): TxThunk {
+  return (tx) => {
+    invokeWithAdminCap(tx, authority(p), {
+      target: `${p.releaseGenrePackageId}::release_genre::set_primary_genre`,
+      arguments: [object(tx, p.releaseId), tx.object(p.primaryGenreId)],
+      adminCapIndex: 1,
+    });
+    for (const genreId of p.secondaryGenreIds ?? []) {
+      invokeWithAdminCap(tx, authority(p), {
+        target: `${p.releaseGenrePackageId}::release_genre::add_secondary_genre`,
+        arguments: [object(tx, p.releaseId), tx.object(genreId)],
+        adminCapIndex: 1,
+      });
+    }
+    for (const assignment of p.trackPrimaryGenres ?? []) {
+      invokeWithAdminCap(tx, authority(p), {
+        target: `${p.releaseGenrePackageId}::release_genre::set_track_primary_genre`,
+        arguments: [
+          object(tx, p.releaseId),
+          tx.pure.u64(asU64("trackIndex", assignment.trackIndex)),
+          tx.object(assignment.genreId),
+        ],
+        adminCapIndex: 1,
+      });
+    }
+  };
+}
+
+export type DspLink =
+  | { platform: "Spotify"; id: string }
+  | {
+      platform: "AppleMusic";
+      storefront: string;
+      albumId: string;
+      trackId?: string;
+    }
+  | { platform: "AmazonMusic"; albumId: string; trackId?: string }
+  | { platform: "Bandcamp"; subdomain: string; slug: string }
+  | { platform: "Deezer"; id: string }
+  | { platform: "SoundCloud"; user: string; slug: string }
+  | { platform: "Tidal"; id: string }
+  | { platform: "YouTubeMusic"; id: string };
+
+function buildDspLink(
+  tx: Transaction,
+  packageId: string,
+  link: DspLink,
+): TransactionArgument {
+  switch (link.platform) {
+    case "Spotify":
+      return tx.add(
+        releaseDspLink.newSpotify({ package: packageId, arguments: [link.id] }),
+      );
+    case "AppleMusic":
+      return tx.add(
+        link.trackId === undefined
+          ? releaseDspLink.newAppleMusicAlbum({
+              package: packageId,
+              arguments: [link.storefront, link.albumId],
+            })
+          : releaseDspLink.newAppleMusicTrack({
+              package: packageId,
+              arguments: [link.storefront, link.albumId, link.trackId],
+            }),
+      );
+    case "AmazonMusic":
+      return tx.add(
+        link.trackId === undefined
+          ? releaseDspLink.newAmazonMusicAlbum({
+              package: packageId,
+              arguments: [link.albumId],
+            })
+          : releaseDspLink.newAmazonMusicTrack({
+              package: packageId,
+              arguments: [link.albumId, link.trackId],
+            }),
+      );
+    case "Bandcamp":
+      return tx.add(
+        releaseDspLink.newBandcamp({
+          package: packageId,
+          arguments: [link.subdomain, link.slug],
+        }),
+      );
+    case "Deezer":
+      return tx.add(
+        releaseDspLink.newDeezer({ package: packageId, arguments: [link.id] }),
+      );
+    case "SoundCloud":
+      return tx.add(
+        releaseDspLink.newSoundcloud({
+          package: packageId,
+          arguments: [link.user, link.slug],
+        }),
+      );
+    case "Tidal":
+      return tx.add(
+        releaseDspLink.newTidal({ package: packageId, arguments: [link.id] }),
+      );
+    case "YouTubeMusic":
+      return tx.add(
+        releaseDspLink.newYoutubeMusic({
+          package: packageId,
+          arguments: [link.id],
+        }),
+      );
+  }
+}
+
+export interface TrackDspLink {
+  trackIndex: U64Input;
+  link: DspLink;
+}
+
+export type SetReleaseDspLinksParams = ReleaseExtensionTarget & {
+  releaseLinks?: readonly DspLink[];
+  trackLinks?: readonly TrackDspLink[];
+  releaseDspLinkPackageId: string;
+};
+
+/** Attach release-level and per-track DSP links. */
+export function setReleaseDspLinks(p: SetReleaseDspLinksParams): TxThunk {
+  return (tx) => {
+    for (const link of p.releaseLinks ?? []) {
+      const value = buildDspLink(tx, p.releaseDspLinkPackageId, link);
+      invokeWithAdminCap(tx, authority(p), {
+        target: `${p.releaseDspLinkPackageId}::release_dsp_link::set_release_link`,
+        arguments: [object(tx, p.releaseId), value],
+        adminCapIndex: 1,
+      });
+    }
+    for (const item of p.trackLinks ?? []) {
+      const value = buildDspLink(tx, p.releaseDspLinkPackageId, item.link);
+      invokeWithAdminCap(tx, authority(p), {
+        target: `${p.releaseDspLinkPackageId}::release_dsp_link::set_track_link`,
+        arguments: [object(tx, p.releaseId), tx.pure.u64(asU64("trackIndex", item.trackIndex)), value],
+        adminCapIndex: 1,
+      });
+    }
+  };
+}

package/src/release-graph.ts

@@ -0,0 +1,219 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// Single-PTB publisher for a whole release graph: creates every composition and
+// recording, derives the release id ON-CHAIN
+// (so recordings need not be shared first), builds the tracks/release,
+// then shares everything and transfers the admin caps — all in ONE transaction.
+//
+// Share currencies must already be published + initialized (their Currency objects
+// shared on-chain); their ids/types are passed in. Ordering is load-bearing:
+//   1. composition::new → recording::new(&comp)  (borrow-before-share)
+//   2. release::derive_target_release_id(<recording::id results>) →
+//      track::new(cap, &rec, derivedId, split) → release::new(registry, …)
+//   3. publish (share) comps + recs + release, disperse supply, transfer caps
+// Steps 1–2 borrow the works; step 3 consumes them into share_object.
+//
+// Release tracks come in two shapes (see TrackNode): recordings created in THIS
+// PTB, and existing recordings authorized by their admin cap.
+//
+// This is the whole-graph orchestration half of the opinionated publish flow —
+// it composes `@misofm/protocol`'s bare `composition`/`recording`/`track`/
+// `release` core call bindings with its
+// own `disperseShares`/`finalizeRelease` helpers into one PTB. Royalty pools are
+// installed later through an admin-cap Vault plugin; the retired raw-cap helper
+// is intentionally not used here.
+
+import { Transaction, type TransactionObjectArgument } from "@mysten/sui/transactions";
+import { contracts } from "@misofm/protocol";
+import { custodyOf, disperseShares, finalizeRelease, recordingAuthorityOf, requiredCommandResult, type AdminCustodyInput, type RecordingAuthorityInput, type ShareRecipient } from "./transactions.ts";
+import { disposeNewAdminCap, invokeWithAdminCap } from "./vault.ts";
+
+const { composition, recording, track } = contracts;
+
+interface CompositionNodeBase {
+  shareType: string;
+  shareCurrencyId: string;
+  shareTreasuryCapId: string;
+  title: string;
+  royaltyRateBps: number;
+  shareRecipients: ShareRecipient[];
+}
+export type CompositionNode = CompositionNodeBase & AdminCustodyInput;
+
+interface RecordingNodeBase {
+  shareType: string;
+  shareCurrencyId: string;
+  shareTreasuryCapId: string;
+  /** The parent composition's share type. */
+  compositionShareType: string;
+  shareRecipients: ShareRecipient[];
+}
+type RecordingParent =
+  | { readonly parentCompositionIndex: number; readonly parentCompositionId?: never }
+  | { readonly parentCompositionIndex?: never; readonly parentCompositionId: string };
+export type RecordingNode = RecordingNodeBase & RecordingParent & AdminCustodyInput;
+
+/** A track whose recording is created in THIS PTB. */
+export interface FreshTrackNode {
+  /** Index into `recordings[]`. */
+  recordingIndex: number;
+  splitBps: number;
+}
+
+/**
+ * A track over an EXISTING recording, authorized by its admin cap held by the
+ * sender. This can coexist with recordings created in this PTB.
+ */
+interface CapTrackNodeBase {
+  recordingId: string;
+  recordingShareType: string;
+  compositionShareType: string;
+  splitBps: number;
+}
+export type CapTrackNode = CapTrackNodeBase & RecordingAuthorityInput;
+
+export type TrackNode = FreshTrackNode | CapTrackNode;
+
+const isFresh = (t: TrackNode): t is FreshTrackNode => "recordingIndex" in t;
+
+function requiredAt<T>(items: readonly T[], index: number, description: string): T {
+  const item = items[index];
+  if (item === undefined) throw new Error(`${description} index ${index} is out of range`);
+  return item;
+}
+
+interface ReleaseNodeBase {
+  title: string;
+  /** u256 nonce as a decimal string (deterministic release id). */
+  nonce: string;
+  releaseRegistryId: string;
+  /** The ordered tracklist. Display grouping (discs/sides) is extension data. */
+  tracks: TrackNode[];
+}
+export type ReleaseNode = ReleaseNodeBase & AdminCustodyInput;
+
+export interface PublishReleaseGraphParams {
+  compositions: CompositionNode[];
+  recordings: RecordingNode[];
+  release?: ReleaseNode;
+  misoPackageId: string;
+  minatoPackageId: string;
+}
+
+interface Parts {
+  work: TransactionObjectArgument;
+  adminCap: TransactionObjectArgument;
+  balance: TransactionObjectArgument;
+}
+
+/** Builds the entire graph in a single transaction (see file header for ordering). */
+export function publishReleaseGraph(params: PublishReleaseGraphParams): (tx: Transaction) => void {
+  const { misoPackageId: pkg, minatoPackageId } = params;
+  return (tx) => {
+    // ── 1) Create every composition, then every recording (borrow-before-share) ──
+    const comps: Parts[] = params.compositions.map((c) => {
+      const r = tx.add(
+        composition._new({
+          package: pkg,
+          typeArguments: [c.shareType],
+          arguments: [tx.pure.string(c.title), tx.pure.u16(c.royaltyRateBps), tx.object(c.shareCurrencyId), tx.object(c.shareTreasuryCapId)],
+        }),
+      );
+      const parts: Parts = {
+        work: requiredCommandResult(r, 0, "composition::_new"),
+        adminCap: requiredCommandResult(r, 1, "composition::_new"),
+        balance: requiredCommandResult(r, 2, "composition::_new"),
+      };
+      return parts;
+    });
+
+    const recTypeArgs = (i: number): [string, string] => {
+      const n = requiredAt(params.recordings, i, "recording");
+      return [n.shareType, n.compositionShareType];
+    };
+
+    const recs: Parts[] = params.recordings.map((rec, i) => {
+      const parent = rec.parentCompositionIndex !== undefined
+        ? requiredAt(comps, rec.parentCompositionIndex, "parent composition").work
+        : tx.object(rec.parentCompositionId);
+      const typeArgs = recTypeArgs(i);
+      const r = tx.add(
+        recording._new({ package: pkg, typeArguments: typeArgs, arguments: [parent, tx.object(rec.shareCurrencyId), tx.object(rec.shareTreasuryCapId)] }),
+      );
+      const parts: Parts = {
+        work: requiredCommandResult(r, 0, "recording::_new"),
+        adminCap: requiredCommandResult(r, 1, "recording::_new"),
+        balance: requiredCommandResult(r, 2, "recording::_new"),
+      };
+      return parts;
+    });
+
+    // ── 2) Release: derive the id on-chain, then tracks → release ──────────
+    if (params.release) {
+      const rel = params.release;
+      const ordered = rel.tracks;
+      const idVec = tx.makeMoveVec({
+        type: "0x2::object::ID",
+        elements: ordered.map((t) =>
+          isFresh(t)
+            ? tx.moveCall({
+                target: "0x2::object::id",
+                typeArguments: [
+                  `${pkg}::recording::Recording<${recTypeArgs(t.recordingIndex).join(",")}>`,
+                ],
+                arguments: [requiredAt(recs, t.recordingIndex, "fresh recording").work],
+              })
+            : tx.pure.id(t.recordingId),
+        ),
+      });
+      const splitVec = tx.makeMoveVec({ type: "u64", elements: ordered.map((t) => tx.pure.u64(t.splitBps)) });
+      // This returns an ID value (not an object); pass the result straight to
+      // `track::new` so every track consents to this exact release target.
+      const releaseId = tx.moveCall({
+        target: `${pkg}::release::derive_target_release_id`,
+        arguments: [tx.object(rel.releaseRegistryId), idVec, splitVec, tx.pure.u256(BigInt(rel.nonce))],
+      });
+
+      const trackArgs = ordered.map((t) => {
+        if (isFresh(t)) {
+          const typeArgs = recTypeArgs(t.recordingIndex);
+          const parts = requiredAt(recs, t.recordingIndex, "fresh recording");
+          return tx.add(track._new({ package: pkg, typeArguments: typeArgs, arguments: [parts.adminCap, parts.work, releaseId, tx.pure.u16(t.splitBps)] }));
+        }
+        const typeArgs: [string, string] = [t.recordingShareType, t.compositionShareType];
+        const rec = tx.object(t.recordingId);
+        return invokeWithAdminCap(tx, recordingAuthorityOf(t), {
+          target: `${pkg}::track::new`,
+          typeArguments: typeArgs,
+          arguments: [rec, releaseId, tx.pure.u16(t.splitBps)],
+          adminCapIndex: 0,
+        });
+      });
+      const trackVec = tx.makeMoveVec({ type: `${pkg}::track::Track`, elements: trackArgs });
+      const created = tx.moveCall({
+        target: `${pkg}::release::new`,
+        arguments: [tx.object(rel.releaseRegistryId), tx.pure.string(rel.title), trackVec, tx.pure.u256(BigInt(rel.nonce))],
+      });
+      const releaseParts = {
+        release: requiredCommandResult(created, 0, "release::new"),
+        adminCap: requiredCommandResult(created, 1, "release::new"),
+      };
+      finalizeRelease(tx, { ...releaseParts, adminCustody: custodyOf(rel), misoPackageId: pkg });
+    }
+
+    // ── 3) Share every work, disperse its supply, transfer admin caps ──
+    params.compositions.forEach((c, i) => {
+      const parts = requiredAt(comps, i, "composition");
+      disperseShares(tx, minatoPackageId, c.shareType, parts.balance, c.shareRecipients);
+      tx.add(composition.publish({ package: pkg, typeArguments: [c.shareType], arguments: [parts.work, parts.adminCap] }));
+      disposeNewAdminCap(tx, parts.adminCap, custodyOf(c));
+    });
+    params.recordings.forEach((rec, i) => {
+      const parts = requiredAt(recs, i, "recording");
+      tx.add(recording.publish({ package: pkg, typeArguments: recTypeArgs(i), arguments: [parts.work, parts.adminCap] }));
+      disperseShares(tx, minatoPackageId, rec.shareType, parts.balance, rec.shareRecipients);
+      disposeNewAdminCap(tx, parts.adminCap, custodyOf(rec));
+    });
+  };
+}

package/src/share-template.ts

@@ -0,0 +1,55 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// Embedded share-currency bytecode template: the compiled `share` Move package
+// (deps 0x1/0x2, network-agnostic). `patchInitializer` stamps the INITIALIZER
+// address into a fresh copy before publish. Kept as a typed const rather than a
+// JSON asset so the SDK is self-contained — no file read, no path resolution, and
+// it bundles cleanly. Regenerate from the compiled package if the share module
+// changes.
+
+import type { PackageBytecode } from "./transactions.ts";
+
+export const SHARE_TEMPLATE: PackageBytecode = {
+  "modules": [
+    "oRzrCwYAAAAKAQAOAg4gAy4gBE4EBVJHB5kB1QEI7gJgBs4DNwqFBAYMiwQ4ABEBEgIHAggCCQIPAhMAAggAAQMHAAMEDAEAAQQACAAEAQABAAEFBgQABgUCAAANAAEAARQFBgACCwUEAAQKCgIBAAQOCAkBCAYQAwQABAcDBwUIAQgBCAEHCAMHCAYBCwIBCAAAAQYIBgEFAQoCAQgBAQgABwcIAwIIAQgBCAEIAQcIBgILBAEJAAsCAQkAAgsEAQkABwgGDENvaW5SZWdpc3RyeRNDdXJyZW5jeUluaXRpYWxpemVyBVNoYXJlBlN0cmluZwtUcmVhc3VyeUNhcAlUeENvbnRleHQDVUlEB2FkZHJlc3MEY29pbg1jb2luX3JlZ2lzdHJ5IGZpbmFsaXplX2FuZF9kZWxldGVfbWV0YWRhdGFfY2FwCmZyb21fYnl0ZXMCaWQKaW5pdGlhbGl6ZQxuZXdfY3VycmVuY3kGb2JqZWN0BnNlbmRlcgVzaGFyZQZzdHJpbmcKdHhfY29udGV4dAR1dGY4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCgIhIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwgAAAAAAAAAAAoCBgVTSEFSRQACAQwIBQABAAABHAoELhEFBwARAiEECAUOCwQBCwMBBwEnCwMxBgcCEQELAAsBCwIKBDgADAULBDgBCwUCAA=="
+  ],
+  "dependencies": [
+    "0x0000000000000000000000000000000000000000000000000000000000000001",
+    "0x0000000000000000000000000000000000000000000000000000000000000002"
+  ],
+  "digest": [
+    191,
+    44,
+    36,
+    112,
+    72,
+    10,
+    163,
+    173,
+    88,
+    79,
+    123,
+    99,
+    33,
+    92,
+    255,
+    215,
+    122,
+    199,
+    22,
+    101,
+    247,
+    141,
+    222,
+    237,
+    187,
+    42,
+    28,
+    13,
+    201,
+    193,
+    173,
+    204
+  ]
+};