@misofm/platform 0.24.0 → 0.25.0

package/src/release-extensions.ts

@@ -7,18 +7,16 @@
 
 import type { ClientWithCoreApi } from "@mysten/sui/client";
 import { bcs } from "@mysten/sui/bcs";
-import { deriveDynamicFieldID, deriveObjectID } from "@mysten/sui/utils";
+import { deriveDynamicFieldID } 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 * as releaseDescription from "./contracts/release_description/release_description.ts";
+import * as releaseDspLink from "./contracts/release_dsp_link/release_dsp_link.ts";
+import * as releaseKind from "./contracts/release_kind/release_kind.ts";
 import { asU64, directAdminCap, invokeWithAdminCap, type AdminCapAuthority, type ObjectInput, type U64Input } from "./vault.ts";
 
 function object(tx: Transaction, value: ObjectInput): TransactionObjectArgument {
@@ -127,75 +125,6 @@ export function setReleaseDescription(p: SetReleaseDescriptionParams): TxThunk {
   };
 }
 
-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 }
   | {

package/src/release-graph.ts

@@ -18,14 +18,14 @@
 // 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`/
+// it composes `@misofm/musicos`'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 { contracts } from "@misofm/musicos";
 import { custodyOf, disperseShares, finalizeRelease, recordingAuthorityOf, requiredCommandResult, type AdminCustodyInput, type RecordingAuthorityInput, type ShareRecipient } from "./transactions.ts";
 import { disposeNewAdminCap, invokeWithAdminCap } from "./vault.ts";
 

package/src/royalty.ts

@@ -0,0 +1,167 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// Generic royalty-pool / stake / routed-stake reads and PTB builders. These are
+// the raw, caller-owned primitives against the bare `royalty_pool` and
+// `routed_stake` packages — Vault-gated crank operations (composition/recording
+// royalty pool plugins, routed-stake Actions bound to a VaultAdminCap) live in
+// `./vault.ts` instead; this module does not duplicate those.
+
+import type { ClientWithCoreApi } from "@mysten/sui/client";
+import { Transaction, type TransactionArgument, type TransactionObjectArgument } from "@mysten/sui/transactions";
+import { deriveObjectID } from "@mysten/sui/utils";
+import { getObjectByBcs } from "@misofm/musicos/queries";
+
+import { RoyaltyPool as RoyaltyPoolBcs } from "./contracts/royalty_pool/pool.ts";
+import { Stake as RoyaltyStakeBcs } from "./contracts/royalty_pool/stake.ts";
+import { RoutedStake as RoutedStakeBcs } from "./contracts/routed_stake/routed_stake.ts";
+import * as royaltyPool from "./contracts/royalty_pool/pool.ts";
+import * as royaltyStake from "./contracts/royalty_pool/stake.ts";
+import * as routedStake from "./contracts/routed_stake/routed_stake.ts";
+
+/** Key bytes for Move unit structs (single `0x00` for `dummy_field: bool = false`). */
+const UNIT_STRUCT_KEY_BYTES = new Uint8Array([0x00]);
+
+// ============================================================================
+// Reads
+// ============================================================================
+
+/** Parse a royalty pool by object ID. Phantom type arguments do not affect BCS. */
+export async function getRoyaltyPoolById(
+  client: ClientWithCoreApi,
+  poolId: string,
+) {
+  return getObjectByBcs(client, poolId, RoyaltyPoolBcs);
+}
+
+/** Parse an owned `Stake<Share>` by object ID. */
+export async function getRoyaltyStakeById(
+  client: ClientWithCoreApi,
+  stakeId: string,
+) {
+  return getObjectByBcs(client, stakeId, RoyaltyStakeBcs);
+}
+
+/** Parse a shared routed stake by object ID. */
+export async function getRoutedStakeById(
+  client: ClientWithCoreApi,
+  routedStakeId: string,
+) {
+  return getObjectByBcs(client, routedStakeId, RoutedStakeBcs);
+}
+
+/** Deterministically derive the royalty-pool ID for a parent and type pair. */
+export function deriveRoyaltyPoolId(
+  parentId: string,
+  shareType: string,
+  currencyType: string,
+  royaltyPoolPackageId: string,
+): string {
+  return deriveObjectID(
+    parentId,
+    `${royaltyPoolPackageId}::pool::RoyaltyPoolKey<${shareType}, ${currencyType}>`,
+    UNIT_STRUCT_KEY_BYTES,
+  );
+}
+
+/** Deterministically derive the routed-stake ID for a parent and stake share. */
+export function deriveRoutedStakeId(
+  parentId: string,
+  stakeShareType: string,
+  routedStakePackageId: string,
+): string {
+  return deriveObjectID(
+    parentId,
+    `${routedStakePackageId}::routed_stake::RoutedStakeKey<${stakeShareType}>`,
+    UNIT_STRUCT_KEY_BYTES,
+  );
+}
+
+// ============================================================================
+// Generic royalty primitives (PTB builders)
+// ============================================================================
+
+/** Create an owned `Stake<Share>` from a by-value `Balance<Share>`. */
+export function createRoyaltyStake(
+  tx: Transaction,
+  params: {
+    balance: TransactionArgument;
+    shareType: string;
+    royaltyPoolPackageId: string;
+  },
+): TransactionObjectArgument {
+  return tx.add(
+    royaltyStake._new({
+      package: params.royaltyPoolPackageId,
+      typeArguments: [params.shareType],
+      arguments: [params.balance],
+    }),
+  );
+}
+
+/** Destroy an unregistered stake and return its principal `Balance<Share>`. */
+export function destroyRoyaltyStake(
+  tx: Transaction,
+  params: {
+    stake: TransactionObjectArgument;
+    shareType: string;
+    royaltyPoolPackageId: string;
+  },
+): TransactionObjectArgument {
+  return tx.add(
+    royaltyStake.destroy({
+      package: params.royaltyPoolPackageId,
+      typeArguments: [params.shareType],
+      arguments: [params.stake],
+    }),
+  );
+}
+
+/** Register an owned stake against a shared royalty pool. */
+export function registerRoyaltyStake(
+  tx: Transaction,
+  params: {
+    poolId: string;
+    stakeId?: string;
+    /** A `Stake` created earlier in this same PTB. */
+    stake?: TransactionObjectArgument;
+    shareType: string;
+    currencyType: string;
+    royaltyPoolPackageId: string;
+  },
+): void {
+  if (!params.stake && !params.stakeId) {
+    throw new Error("registerRoyaltyStake: stakeId or stake required");
+  }
+  tx.add(
+    royaltyPool.registerStake({
+      package: params.royaltyPoolPackageId,
+      typeArguments: [params.shareType, params.currencyType],
+      arguments: [tx.object(params.poolId), params.stake ?? tx.object(params.stakeId!)],
+    }),
+  );
+}
+
+/** Claim rewards. The returned `Balance<Currency>` must be consumed in this PTB. */
+export function claimRoyaltyRewards(
+  tx: Transaction,
+  params: {
+    poolId: string;
+    stakeId: string;
+    shareType: string;
+    currencyType: string;
+    royaltyPoolPackageId: string;
+  },
+): TransactionObjectArgument {
+  return tx.add(
+    royaltyPool.claimRewards({
+      package: params.royaltyPoolPackageId,
+      typeArguments: [params.shareType, params.currencyType],
+      arguments: [tx.object(params.poolId), tx.object(params.stakeId)],
+    }),
+  );
+}
+
+// `sweepRoutedStake` — the permissionless routed-stake reward sweep — already
+// lives in `./vault.ts` and is exported from the package root from there; this
+// module does not duplicate it.

package/src/share.ts

@@ -32,7 +32,7 @@ import {
   createdByType,
   allCreatedByType,
   type ExecResult,
-} from "@misofm/protocol";
+} from "@misofm/musicos";
 
 import { publishShareCurrency, initializeShareCurrency, type PackageBytecode } from "./transactions.ts";
 import { SHARE_TEMPLATE } from "./share-template.ts";

package/src/transactions.ts

@@ -6,7 +6,7 @@
 // `Transaction`, so a platform call composes with protocol calls and anything
 // else in the same PTB.
 //
-// This module holds the OPINIONATED publish flows. `@misofm/protocol` does the
+// This module holds the OPINIONATED publish flows. `@misofm/musicos` does the
 // minimum the Move semantics FORCE and returns anything a caller could
 // legitimately route elsewhere; deciding where those values GO is the
 // platform-layer call that lives here:
@@ -27,7 +27,7 @@
 // constraint, not a same-function one, which is exactly what makes this split
 // possible.
 //
-// Composes with `@misofm/protocol`'s calls in the same PTB (the
+// Composes with `@misofm/musicos`'s calls in the same PTB (the
 // transaction-thunk composition pattern, just crossing a package boundary now).
 
 import { Transaction, type TransactionObjectArgument } from "@mysten/sui/transactions";
@@ -41,10 +41,10 @@ import {
   type RecordingParts,
   type ShareCurrencyBinding,
   type TxThunk,
-} from "@misofm/protocol";
+} from "@misofm/musicos";
 import { asU64, directAdminCap, disposeNewAdminCap, invokeWithAdminCap, type AdminCapAuthority, type AdminCapCustody, type U64Input } from "./vault.ts";
-import * as royaltyPool from "@misofm/protocol/contracts/royalty_pool/pool";
-import * as royaltyPoolStake from "@misofm/protocol/contracts/royalty_pool/stake";
+import * as royaltyPool from "./contracts/royalty_pool/pool.ts";
+import * as royaltyPoolStake from "./contracts/royalty_pool/stake.ts";
 
 const { track, release } = contracts;
 
@@ -284,7 +284,7 @@ export type FinalizeCompositionParams = FinalizeCompositionParamsBase & AdminCus
  * The opinionated finish for a composition: disperse its share supply to
  * `shareRecipients`, publish (share) it, and transfer its admin cap to
  * `adminAddress`. Consumers that want different economics skip this and act on
- * the `CompositionParts` from `@misofm/protocol`'s `createComposition` directly.
+ * the `CompositionParts` from `@misofm/musicos`'s `createComposition` directly.
  */
 export function finalizeComposition(tx: Transaction, params: FinalizeCompositionParams): void {
   disperseShares(tx, params.minatoPackageId, params.shareType, params.balance, params.shareRecipients);

package/src/vault.ts

@@ -20,12 +20,12 @@ import type {
   TransactionObjectArgument,
 } from "@mysten/sui/transactions";
 import { deriveObjectID, normalizeStructTag } from "@mysten/sui/utils";
-import * as vault from "@misofm/protocol/contracts/vault/vault";
-import * as releaseRevenueDistributor from "@misofm/protocol/contracts/release_revenue_distributor/release_revenue_distributor";
-import * as compositionRoyaltyPoolPlugin from "@misofm/protocol/contracts/composition_royalty_pool_plugin/composition_royalty_pool_plugin";
-import * as recordingRoyaltyPoolPlugin from "@misofm/protocol/contracts/recording_royalty_pool_plugin/recording_royalty_pool_plugin";
-import * as releaseRevenueDistributorPlugin from "@misofm/protocol/contracts/release_revenue_distributor_plugin/release_revenue_distributor_plugin";
-import * as routedStake from "@misofm/protocol/contracts/routed_stake/routed_stake";
+import * as vault from "./contracts/vault/vault.ts";
+import * as releaseRevenueDistributor from "./contracts/release_revenue_distributor/release_revenue_distributor.ts";
+import * as compositionRoyaltyPoolPlugin from "./contracts/composition_royalty_pool_plugin/composition_royalty_pool_plugin.ts";
+import * as recordingRoyaltyPoolPlugin from "./contracts/recording_royalty_pool_plugin/recording_royalty_pool_plugin.ts";
+import * as releaseRevenueDistributorPlugin from "./contracts/release_revenue_distributor_plugin/release_revenue_distributor_plugin.ts";
+import * as routedStake from "./contracts/routed_stake/routed_stake.ts";
 
 /** A legacy work whose raw protocol admin cap is still address-owned. */
 /** An object id resolved lazily when a transaction thunk is applied. */