@misofm/sdk 0.11.0 → 0.12.1

package/src/read/artist.ts

@@ -4,26 +4,22 @@
 // Artist reads: a `Party` plus every extension attached to its UID.
 //
 // The artist page is the clearest case for this whole layer. Its data lives in
-// EIGHT separate dynamic fields, each its own package, each its own read — party,
-// profile, ctas, genres, links, roles, tags, featured. miso-app fanned all eight
-// out from the browser (`lib/party-queries.ts`, plus a second identical fan-out in
-// `PartyEditSheet`). Here they are one call, resolved once, cached once.
+// separate dynamic fields, each its own package and read — party, profile, ctas,
+// genres, links, roles, and tags. Here they are one call, resolved once, cached
+// once.
 //
-// `roles`, `tags`, and the resolved featured release are opt-in via `include`.
+// `roles` and `tags` are opt-in via `include`.
 
 import { resolveGenreNames } from "./genres.ts";
-import { getReleaseResources } from "./catalog.ts";
-import { getPressing } from "../pressing.ts";
 import type { MisoClient } from "./client.ts";
 import type {
   ArtistProfile,
-  FeaturedRelease,
   PartyMember,
   PartySummary,
 } from "./types.ts";
 
 /** Optional sub-resources — read only when asked for. */
-export type ArtistInclude = "roles" | "tags" | "featured";
+export type ArtistInclude = "roles" | "tags";
 
 export interface GetArtistOptions {
   include?: readonly ArtistInclude[];
@@ -45,7 +41,7 @@ export async function getArtistProfile(
   options: GetArtistOptions = {},
 ): Promise<ArtistProfile> {
   const include = new Set(options.include ?? []);
-  const { party } = client.sui;
+  const { party } = client.sui.miso;
 
   const [profile, ctas, genreIds, links, roles, tags, entity] =
     await Promise.all([
@@ -62,15 +58,12 @@ export async function getArtistProfile(
       party.getPartyById(partyId),
     ]);
 
-  const [genres, members, featured] = await Promise.all([
+  const [genres, members] = await Promise.all([
     resolveGenreNames(client, genreIds),
     resolveMembers(
       client,
       entity.kind === "group" ? (entity.members ?? []) : [],
     ),
-    include.has("featured")
-      ? resolveFeaturedRelease(client, partyId, entity.name).catch(() => null)
-      : Promise.resolve(undefined),
   ]);
 
   return {
@@ -92,7 +85,6 @@ export async function getArtistProfile(
     members,
     ...(roles !== undefined ? { roles } : {}),
     ...(tags !== undefined ? { tags } : {}),
-    ...(featured !== undefined ? { featured } : {}),
     avatarUrl: partyAvatarUrl(client.config.apiBaseUrl, entity.id),
   };
 }
@@ -103,7 +95,7 @@ async function resolveMembers(
   memberIds: readonly string[],
 ): Promise<PartyMember[]> {
   if (memberIds.length === 0) return [];
-  const parties = await client.sui.party
+  const parties = await client.sui.miso.party
     .getPartiesByIds([...memberIds])
     .catch(() => ({}) as Record<string, undefined>);
   return memberIds.flatMap((id) => {
@@ -118,58 +110,9 @@ export async function getPartySummaries(
   ids: readonly string[],
 ): Promise<PartySummary[]> {
   if (ids.length === 0) return [];
-  const parties = await client.sui.party.getPartiesByIds([...ids]);
+  const parties = await client.sui.miso.party.getPartiesByIds([...ids]);
   return ids.flatMap((id) => {
     const p = parties[id];
     return p ? [{ id, name: p.name, kind: p.kind }] : [];
   });
 }
-
-/**
- * The party's pinned pressing, resolved through to its release and cover.
- * `null` — a successful empty — when nothing is pinned or the pin is dangling
- * (the pressing id was invalid or was never opened).
- */
-async function resolveFeaturedRelease(
-  client: MisoClient,
-  partyId: string,
-  fallbackArtist?: string,
-): Promise<FeaturedRelease | null> {
-  const pressingId = await client.sui.party.getFeaturedDrop(partyId);
-  if (!pressingId) return null;
-
-  const pressing = await getPressing(client.protocol, pressingId, client.config.protocol.pressing);
-  if (!pressing) return null;
-
-  const [resources, entity] = await Promise.all([
-    getReleaseResources(client, pressing.releaseId, ["cover", "credits"]),
-    fallbackArtist === undefined
-      ? client.sui.party.getPartyById(partyId)
-      : Promise.resolve(null),
-  ]);
-  const { release, cover, credits } = resources;
-
-  // The artist line prefers the release's own PRIMARY credits and falls back to
-  // the party whose page this is — a release with no credits set still shows an
-  // artist, which is the behavior the featured card has always had.
-  const primary = (credits ?? [])
-    .filter((c) => c.roles.includes("Primary"))
-    .map((c) => c.displayName);
-
-  return {
-    pressingId,
-    releaseId: pressing.releaseId,
-    title: release.title,
-    artist: primary.length
-      ? primary.join(", ")
-      : (fallbackArtist ?? entity?.name ?? ""),
-    coverUrl: cover?.still.url ?? null,
-  };
-}
-
-export async function getFeaturedRelease(
-  client: MisoClient,
-  partyId: string,
-): Promise<FeaturedRelease | null> {
-  return resolveFeaturedRelease(client, partyId);
-}

package/src/read/catalog.ts

@@ -317,7 +317,7 @@ export async function getReleaseDetail(
       client.protocol,
       client.graphql,
       recordingIds,
-      client.config.protocol.miso,
+      client.config.deployment.miso,
     ),
     options.include?.includes("trackCredits")
       ? getTrackCreditsForRecordingIds(client, recordingIds)
@@ -345,13 +345,13 @@ async function getTrackCreditsForRecordingIds(
   client: MisoClient,
   recordingIds: readonly string[],
 ): Promise<Record<string, TrackCredits>> {
-  const { compositionCredits, recordingCredits, miso } = client.config.protocol;
+  const { compositionCredits, recordingCredits } = client.config.protocol;
   const tracks = await getTrackCreditsByRecordingIds(
     client.protocol,
     client.graphql,
     recordingIds,
     {
-      misoPackageId: miso,
+      misoPackageId: client.config.deployment.miso,
       compositionCreditsPackageId: compositionCredits,
       recordingCreditsPackageId: recordingCredits,
     },

package/src/read/client.ts

@@ -13,18 +13,12 @@
 // It also carries the resolved `MisoConfig`, so a read function takes ONE argument
 // and never has a package id threaded through its signature.
 //
-// The casts below are load-bearing and deliberate: @misonetwork/miso-protocol and
-// @misonetwork/miso-party each type against their own installed copy of
-// @mysten/sui. Those copies are structurally identical but nominally distinct
-// (private class fields), so TypeScript refuses the assignment even though the
-// runtime object is the same one. miso-app solved this with a cast at each call
-// site (`lib/pressing.ts:25`, `lib/party.ts:55`); here it happens ONCE, and
-// nothing downstream of this file casts anything.
+// Party now shares the same network SDK registration and deployment as protocol
+// core, so every read hangs off one `sui.miso` namespace.
 
 import { SuiGrpcClient } from "@mysten/sui/grpc";
 import { SuiGraphQLClient } from "@mysten/sui/graphql";
-import type { SuiClientRegistration } from "@mysten/sui/client";
-import { party, type PartyClient } from "@misonetwork/miso-party/client";
+import { miso, type MisoProtocolClient } from "@misonetwork/sdk/client";
 import { misoConfig, networkFrom, type MisoConfig, type MisoConfigOverrides, type Network } from "./config.ts";
 
 function definedOverrides<T extends object>(value: T): Partial<T> {
@@ -44,8 +38,8 @@ export type ProtocolGraphQLClient = SuiGraphQLClient;
 
 export interface MisoClient {
   config: MisoConfig;
-  /** gRPC data plane, extended with the party read API (`sui.party.getPartyById(…)`). */
-  sui: SuiGrpcClient & { party: PartyClient };
+  /** gRPC data plane, including Party at `sui.miso.party`. */
+  sui: SuiGrpcClient & { miso: MisoProtocolClient };
   /** The same client, typed for the protocol SDK's read helpers. */
   protocol: ProtocolClient;
   /** GraphQL RPC, typed for the protocol SDK's type-discovery queries. */
@@ -82,8 +76,7 @@ export function createMisoClient(options: CreateMisoClientOptions = {}): MisoCli
   const grpc = new SuiGrpcClient({ baseUrl: config.grpcUrl, network: config.network });
   const graphqlRaw = new SuiGraphQLClient({ url: config.graphqlUrl, network: config.network });
 
-  const registration = party(config.party) as unknown as SuiClientRegistration<typeof grpc, "party", PartyClient>;
-  const sui = grpc.$extend(registration);
+  const sui = grpc.$extend(miso({ deployment: config.deployment }));
 
   return {
     config,

package/src/read/config.ts

@@ -11,6 +11,8 @@
 // republished. A read client must receive a complete verified configuration from
 // its caller; silently retaining the old ABI would be unsafe.
 
+import type { MisoDeployment } from "@misonetwork/sdk/deployments";
+
 export type Network = "testnet" | "mainnet";
 
 /** Missing defaults to Testnet for local development; invalid values fail closed. */
@@ -22,14 +24,10 @@ export function networkFrom(value: string | undefined): Network {
 
 /** Package ids for the miso protocol core and the extensions the read layer touches. */
 export interface ProtocolIds {
-  /** `miso` core — Composition / Recording / Release, and the origin of every derived admin cap. */
-  miso: string;
   /** `miso_pressing` — permanent Pressing runs and per-currency Listings. */
   pressing: string;
   /** `miso_record` package — the exact owner/type namespace for `record::Record`. */
   record: string;
-  /** `miso_record` shared `Settings` object — the mint witness authorizer. */
-  recordSettings: string;
   /** `release_cover_art` — the release cover extension. */
   releaseCoverArt: string;
   /** `composition_credits` / `recording_credits` / `release_credits` extensions. */
@@ -40,25 +38,6 @@ export interface ProtocolIds {
   credit: string;
 }
 
-/** Package ids for PartyOS core and every party extension the artist page reads. */
-export interface PartyIds {
-  partyPackageId: string;
-  partyProfilePackageId: string;
-  countryCodePackageId: string;
-  languageCodePackageId: string;
-  partyMediaPackageId: string;
-  partyRolesPackageId: string;
-  partyTagsPackageId: string;
-  partyGenrePackageId: string;
-  partyCtaPackageId: string;
-  partyPlatformLinkPackageId: string;
-  partySocialPackageId: string;
-  partyMusicPackageId: string;
-  partyProLinkPackageId: string;
-  partyFeaturedDropPackageId: string;
-  genrePackageId: string;
-}
-
 /** The currency the app prices records in, and where test dollars come from. */
 export interface MoneyIds {
   /** Coin type balances, listings, and purchases are denominated in. */
@@ -68,8 +47,9 @@ export interface MoneyIds {
 
 export interface MisoConfig {
   network: Network;
+  /** Complete package set used by the integrated `client.miso` SDK. */
+  deployment: MisoDeployment;
   protocol: ProtocolIds;
-  party: PartyIds;
   money: MoneyIds;
   /** Sui gRPC-web endpoint the data plane reads through. */
   grpcUrl: string;

package/src/read/index.ts

@@ -5,8 +5,8 @@
 //
 // One place that knows how to turn Sui objects into the things Miso talks about:
 // a pressing, a release, an artist, a library, a receipt. It composes
-// @misonetwork/miso-protocol and @misonetwork/miso-party, owns the per-network id
-// manifest, and returns view types that survive JSON.
+// @misonetwork/sdk, owns the per-network id manifest, and returns view types that
+// survive JSON.
 //
 // Browser- and server-compatible. The HTTP API is a thin cached transport over
 // this same surface; direct clients can use it without going through the API.
@@ -24,7 +24,6 @@ export type {
   DiscoverSale,
   MoneyIds,
   Network,
-  PartyIds,
   ProtocolIds,
 } from "./config.ts";
 
@@ -52,7 +51,6 @@ export type { ReleaseResources } from "./catalog.ts";
 
 export {
   getArtistProfile,
-  getFeaturedRelease,
   getPartySummaries,
   partyAvatarUrl,
 } from "./artist.ts";

package/src/read/receipts.ts

@@ -268,7 +268,7 @@ async function compositionRatesByRecording(client: MisoClient, recordingIds: str
   const addresses = await getWorkAddressesByShareTypes(
     client.graphql,
     { compositions: shareTypes, recordings: [] },
-    client.config.protocol.miso,
+    client.config.deployment.miso,
   );
   const compositionIds = Object.values(addresses.compositions).filter((id): id is string => !!id);
   const compositions = await getCompositionsByIds(client.protocol, compositionIds);

package/src/read/types.ts

@@ -261,22 +261,10 @@ export interface ArtistProfile {
   /** Present only when requested via `include` — the owner-editor fields. */
   roles?: string[];
   tags?: string[];
-  /** Present only when requested via `include`; null means nothing is pinned. */
-  featured?: FeaturedRelease | null;
   /** Public avatar URL (miso-api R2 lane; may 404 when unset). */
   avatarUrl: string;
 }
 
-/** A party's pinned Pressing, fully resolved. Null when nothing is pinned. */
-export interface FeaturedRelease {
-  pressingId: string;
-  releaseId: string;
-  title: string;
-  /** The party whose page this is — shown as the release's artist. */
-  artist: string;
-  coverUrl: string | null;
-}
-
 /** The minimal party projection used for lists (`?ids=`). */
 export interface PartySummary {
   id: string;

package/src/read/wallet.ts

@@ -11,8 +11,8 @@
 // than be reimplemented by every browser, Worker, server, or native client.
 
 import { normalizeSuiAddress } from "@mysten/sui/utils";
-import { contracts as partyContracts } from "@misonetwork/miso-party";
 import {
+  contracts as networkContracts,
   getCompositionByShareType,
   getOwnedReleaseAdminCaps,
   getRecordingByShareType,
@@ -110,7 +110,7 @@ export async function getOwnedRecords(client: MisoClient, owner: string): Promis
  * authoritative in a way that remembering created parties client-side is not.
  */
 export async function getOwnedParties(client: MisoClient, owner: string): Promise<OwnedParty[]> {
-  const capType = `${client.config.party.partyPackageId}::party::PartyAdminCap`;
+  const capType = `${client.config.deployment.misoParty}::party::PartyAdminCap`;
 
   // One page of 50 caps is plenty for launch-scale artists; paginate if labels
   // ever start hitting the cap.
@@ -123,7 +123,7 @@ export async function getOwnedParties(client: MisoClient, owner: string): Promis
 
   const caps = objects.flatMap((obj) => {
     try {
-      const cap = partyContracts.party.PartyAdminCap.parse(obj.content);
+      const cap = networkContracts.party.PartyAdminCap.parse(obj.content);
       return [{ capId: obj.objectId, partyId: cap.party_id }];
     } catch {
       return [];
@@ -131,7 +131,7 @@ export async function getOwnedParties(client: MisoClient, owner: string): Promis
   });
   if (caps.length === 0) return [];
 
-  const parties = await client.sui.party.getPartiesByIds(caps.map((c) => c.partyId));
+  const parties = await client.sui.miso.party.getPartiesByIds(caps.map((c) => c.partyId));
   return caps.flatMap(({ capId, partyId }) => {
     const p = parties[partyId];
     return p ? [{ partyId, capId, name: p.name, kind: p.kind }] : [];
@@ -157,13 +157,13 @@ export async function getPendingMemberships(
   const invitations = await Promise.all(
     individuals.map(async (member) => ({
       member,
-      groupIds: await client.sui.party.getPendingMemberships(member.partyId),
+      groupIds: await client.sui.miso.party.getPendingMemberships(member.partyId),
     })),
   );
   const groupIds = [...new Set(invitations.flatMap(({ groupIds }) => groupIds))];
   if (groupIds.length === 0) return [];
 
-  const groups = await client.sui.party.getPartiesByIds(groupIds);
+  const groups = await client.sui.miso.party.getPartiesByIds(groupIds);
   return invitations.flatMap(({ member, groupIds }) =>
     groupIds.flatMap((groupId): PendingMembership[] => {
       const group = groups[groupId];
@@ -203,7 +203,7 @@ async function ownedGenericCaps(client: MisoClient, owner: string, capType: stri
  * `release_id` directly.
  */
 export async function getOwnedWorks(client: MisoClient, owner: string): Promise<OwnedWork[]> {
-  const miso = client.config.protocol.miso;
+  const miso = client.config.deployment.miso;
 
   const [compCaps, recCaps, relCaps] = await Promise.all([
     ownedGenericCaps(client, owner, `${miso}::composition::CompositionAdminCap`),
@@ -257,7 +257,7 @@ export async function getOwnedWorks(client: MisoClient, owner: string): Promise<
 
 /** Classify a cap by its on-chain type, then resolve the work behind it. */
 export async function getWorkByCap(client: MisoClient, capId: string): Promise<WorkDetail | null> {
-  const miso = client.config.protocol.miso;
+  const miso = client.config.deployment.miso;
 
   let type: string;
   let json: Record<string, unknown> | null;
@@ -355,7 +355,7 @@ function isAddressOwner(owner: unknown, address: string): boolean {
  * stays hidden rather than being offered and then rejected on submit.
  */
 export async function ownsParty(client: MisoClient, address: string, partyId: string): Promise<Ownership> {
-  const capId = client.sui.party.derivePartyAdminCapId(partyId);
+  const capId = client.sui.miso.party.derivePartyAdminCapId(partyId);
   const isOwner = await client.protocol.core
     .getObject({ objectId: capId })
     .then(({ object }) => isAddressOwner(object?.owner, address))

package/src/release-extensions.ts

@@ -5,7 +5,7 @@
 // intent aggregates these concerns, but every value is written by its own
 // independently deployed extension package.
 
-import { deriveDynamicFieldID } from "@mysten/sui/utils";
+import { deriveObjectID } from "@mysten/sui/utils";
 import type {
   Transaction,
   TransactionArgument,
@@ -91,14 +91,16 @@ export function assertCanonicalGenreName(name: string): void {
   }
 }
 
-/** Derive the immutable Genre object id for a canonical vocabulary name. */
-export function deriveGenreId(
+/** 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 deriveDynamicFieldID(
+  return deriveObjectID(
     genreRegistryId,
     `${genrePackageId}::genre::GenreKey`,
     genre.GenreKey.serialize([canonicalName]).toBytes(),

package/src/release-graph.ts

@@ -157,7 +157,13 @@ export function publishReleaseGraph(params: PublishReleaseGraphParams): (tx: Tra
         type: "0x2::object::ID",
         elements: ordered.map((t) =>
           isFresh(t)
-            ? tx.add(recording.id({ package: pkg, typeArguments: recTypeArgs(t.recordingIndex), arguments: [requiredAt(recs, t.recordingIndex, "fresh recording").work] }))
+            ? 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),
         ),
       });

package/src/vault.ts

@@ -597,7 +597,7 @@ export function registerCompositionRoutedStake(
 /** Unregister a routed stake after pending rewards have been swept. */
 export function unregisterCompositionRoutedStake(
   tx: Transaction,
-  params: Omit<ManageCompositionRoutedStakeParams, "recording">,
+  params: ManageCompositionRoutedStakeParams,
 ): void {
   tx.add(
     compositionRoutedStake.unregister({
@@ -610,6 +610,7 @@ export function unregisterCompositionRoutedStake(
       arguments: [
         params.vault,
         params.composition,
+        params.recording,
         params.routedStake,
         params.royaltyPool,
         params.vaultAdminCap,