@misofm/sdk 0.15.11 → 0.17.0

package/src/publication.ts

@@ -23,7 +23,11 @@ import {
   deriveReleaseAdminCapId,
 } from "@misonetwork/sdk";
 import { derivePartyAdminCapId } from "@misonetwork/sdk/party";
-import type { MisoPlatformDeployment } from "./deployments.ts";
+import {
+  requireOperationsDeployment,
+  type AvailableOperationsDeployment,
+  type MisoPlatformDeployment,
+} from "./deployments.ts";
 import type { TxThunk } from "./transactions.ts";
 import {
   createShareStakes,
@@ -59,13 +63,10 @@ import {
 import { setReleaseCover, setReleaseTrackCover } from "./cover.ts";
 import {
   custodyNewAdminCap,
+  deriveVaultAdminCapId,
   directAdminCap,
   disposeNewAdminCap,
-  initializeCompositionRoyaltyPool,
-  initializeRecordingRoyaltyPool,
-  installCompositionRoutedStakePlugin,
   installCompositionRoyaltyPoolPlugin,
-  installPartyWalletPlugin,
   installRecordingRoyaltyPoolPlugin,
   installReleaseRevenueDistributorPlugin,
   invokeWithAdminCap,
@@ -79,11 +80,11 @@ import {
   derivePressingAdminCapId,
   derivePressingId,
   type ListingPrice,
-  type PressingRunState,
 } from "./pressing.ts";
+import { requireRecordSalesDeployment } from "./deployments.ts";
 import { allCreatedByType, createdByExactType, type PlatformExecResult } from "./execute.ts";
-import * as pressingContract from "./contracts/miso_pressing/pressing.ts";
-import * as listingContract from "./contracts/miso_pressing/listing.ts";
+import * as pressingContract from "./contracts/miso_record/pressing.ts";
+import * as listingContract from "./contracts/miso_record_shop/listing.ts";
 
 const { composition, recording, release, track, party } = protocolContracts;
 
@@ -102,8 +103,6 @@ export type PublicationParty =
       readonly create: "individual" | "group";
       readonly name: string;
       readonly custody: PublicationCustody;
-      /** Defaults to true with Vault custody. */
-      readonly installWallet?: boolean;
     };
 
 export interface PublicationCompositionCredit {
@@ -138,7 +137,6 @@ export interface PublicationComposition {
   readonly custody: PublicationCustody;
   readonly credits?: PublicationCompositionCredit[];
   readonly royaltyPool?: { readonly currencyType: string };
-  readonly routedStake?: boolean;
 }
 
 type PublicationRecordingParent =
@@ -212,7 +210,10 @@ export interface PublicationRelease {
 }
 
 export interface PublicationPressing {
-  readonly state?: PressingRunState;
+  /** Positive edition number encoded as Move u16. */
+  readonly edition: number;
+  /** Immutable positive u32 ceiling, or null/omitted for an uncapped edition. */
+  readonly maxSupply?: number | null;
   readonly listings: {
     readonly currencyType: string;
     readonly price: ListingPrice;
@@ -264,7 +265,24 @@ function releaseCapType(p: AtomicPublicationParams): string {
 }
 
 function pressingCapType(p: AtomicPublicationParams): string {
-  return `${p.deployment.packages.pressing}::pressing::PressingAdminCap`;
+  return `${requireRecordSalesDeployment(p.deployment.recordSales).recordPackageId}::pressing::PressingAdminCap`;
+}
+
+function publicationUsesVault(p: AtomicPublicationParams): boolean {
+  return (
+    p.parties.some((node) => "create" in node && node.custody.kind === "vault") ||
+    p.compositions.some((node) => node.custody.kind === "vault") ||
+    p.recordings.some((node) => node.custody.kind === "vault") ||
+    p.release?.custody.kind === "vault" ||
+    p.release?.tracks.some((node) =>
+      "authority" in node && node.authority.kind === "vault"
+    ) === true ||
+    p.pressing?.custody.kind === "vault"
+  );
+}
+
+function operations(p: AtomicPublicationParams): AvailableOperationsDeployment {
+  return requireOperationsDeployment(p.deployment.operations);
 }
 
 function custody(
@@ -274,12 +292,13 @@ function custody(
   configure?: Exclude<AdminCapCustody, { kind: "direct" }>["configure"],
 ): AdminCapCustody {
   if (selected.kind === "direct") return { kind: "direct", owner: selected.owner };
+  const available = operations(p);
   return {
     kind: "vault",
     owner: selected.owner,
-    vaultRegistry: p.deployment.objects.vaultRegistry,
+    vaultRegistry: available.vault.registryId,
     capType,
-    vaultPackageId: p.deployment.packages.vault,
+    vaultPackageId: available.vault.packageId,
     configure,
   };
 }
@@ -311,24 +330,27 @@ function walrusBlob(tx: Transaction, p: AtomicPublicationParams, blobId: bigint
   });
 }
 
-function pressingState(tx: Transaction, p: AtomicPublicationParams, state: PressingRunState) {
-  const pkg = p.deployment.packages.pressing;
-  if (state.kind === "scheduled") {
-    return tx.add(pressingContract.newScheduledState({
-      package: pkg,
-      arguments: [BigInt(state.startTimestampMs)],
-    }));
-  }
-  if (state.kind === "paused") return tx.add(pressingContract.newPausedState({ package: pkg }));
-  return tx.add(pressingContract.newActiveState({ package: pkg }));
-}
-
 function listingPrice(tx: Transaction, p: AtomicPublicationParams, price: ListingPrice) {
-  const pkg = p.deployment.packages.pressing;
+  const pkg = requireRecordSalesDeployment(p.deployment.recordSales).recordShopPackageId;
   const args = { package: pkg, arguments: [BigInt(price.amount)] as [bigint] };
   return tx.add(price.kind === "fixed"
-    ? listingContract.newFixedPrice(args)
-    : listingContract.newFloorPrice(args));
+    ? listingContract.fixed(args)
+    : listingContract.floor(args));
+}
+
+function publicationEdition(value: number): number {
+  if (!Number.isInteger(value) || value <= 0 || value > 0xffff) {
+    throw new RangeError("pressing.edition must be an integer from 1 to 65535");
+  }
+  return value;
+}
+
+function publicationMaxSupply(value: number | null | undefined): number | null {
+  if (value == null) return null;
+  if (!Number.isInteger(value) || value <= 0 || value > 0xffff_ffff) {
+    throw new RangeError("pressing.maxSupply must be a positive u32 or null");
+  }
+  return value;
 }
 
 interface PublicationShareAllocation {
@@ -397,6 +419,7 @@ function publishComposition(
   node: PublicationComposition,
   parts: WorkParts,
 ): void {
+  const available = node.custody.kind === "vault" ? operations(p) : undefined;
   const stakes = allocatePublicationShares(tx, p, node, parts.balance);
   const typeArguments: [string] = [node.shareType];
   if (node.custody.kind === "direct") {
@@ -411,45 +434,42 @@ function publishComposition(
   }
   custodyNewAdminCap(tx, {
     adminCap: parts.adminCap,
-    vaultRegistry: p.deployment.objects.vaultRegistry,
+    vaultRegistry: available!.vault.registryId,
     capType: compositionCapType(p, node.shareType),
-    vaultPackageId: p.deployment.packages.vault,
+    vaultPackageId: available!.vault.packageId,
     owner: node.custody.owner,
     configure: (vault, vaultAdminCap) => {
       if (node.royaltyPool) {
         installCompositionRoyaltyPoolPlugin(tx, {
           vault, vaultAdminCap, compositionShareType: node.shareType,
-          pluginPackageId: p.deployment.packages.vaultCompositionRoyaltyPoolPlugin,
+          pluginPackageId: available!.plugins.compositionRoyaltyPool,
         });
+        const authority: AdminCapAuthority = {
+          kind: "vault", vault, vaultAdminCap,
+          capType: compositionCapType(p, node.shareType),
+          vaultPackageId: available!.vault.packageId,
+        };
         const poolParams = {
-          vault, vaultAdminCap, composition: parts.work,
+          authority, composition: parts.work,
           compositionShareType: node.shareType,
           currencyType: node.royaltyPool.currencyType,
-          pluginPackageId: p.deployment.packages.vaultCompositionRoyaltyPoolPlugin,
+          actionPackageId: available!.actions.compositionRoyaltyPool,
         };
+        const pool = newCompositionRoyaltyPool(tx, poolParams);
         if (stakes.length > 0) {
-          const pool = newCompositionRoyaltyPool(tx, poolParams);
           registerPublicationStakes(tx, p, node, stakes, pool, node.royaltyPool.currencyType);
-          shareRoyaltyPool(tx, {
-            pool,
-            shareType: node.shareType,
-            currencyType: node.royaltyPool.currencyType,
-            royaltyPoolPackageId: p.deployment.packages.royaltyPool,
-          });
-        } else {
-          initializeCompositionRoyaltyPool(tx, poolParams);
         }
-      }
-      if (node.routedStake) {
-        installCompositionRoutedStakePlugin(tx, {
-          vault, vaultAdminCap, compositionShareType: node.shareType,
-          pluginPackageId: p.deployment.packages.vaultCompositionRoutedStakePlugin,
+        shareRoyaltyPool(tx, {
+          pool,
+          shareType: node.shareType,
+          currencyType: node.royaltyPool.currencyType,
+          royaltyPoolPackageId: p.deployment.packages.royaltyPool,
         });
       }
       invokeWithAdminCap(tx, {
         kind: "vault", vault, vaultAdminCap,
         capType: compositionCapType(p, node.shareType),
-        vaultPackageId: p.deployment.packages.vault,
+        vaultPackageId: available!.vault.packageId,
       }, {
         target: `${p.deployment.protocol.miso}::composition::publish`,
         typeArguments,
@@ -467,6 +487,7 @@ function publishRecording(
   node: PublicationRecording,
   parts: WorkParts,
 ): void {
+  const available = node.custody.kind === "vault" ? operations(p) : undefined;
   const typeArguments: [string, string] = [node.shareType, node.compositionShareType];
   const stakes = allocatePublicationShares(tx, p, node, parts.balance);
   if (node.custody.kind === "direct") {
@@ -481,9 +502,9 @@ function publishRecording(
   }
   custodyNewAdminCap(tx, {
     adminCap: parts.adminCap,
-    vaultRegistry: p.deployment.objects.vaultRegistry,
+    vaultRegistry: available!.vault.registryId,
     capType: recordingCapType(p, node.shareType),
-    vaultPackageId: p.deployment.packages.vault,
+    vaultPackageId: available!.vault.packageId,
     owner: node.custody.owner,
     configure: (vault, vaultAdminCap) => {
       if (node.royaltyPool) {
@@ -491,32 +512,35 @@ function publishRecording(
           vault, vaultAdminCap,
           recordingShareType: node.shareType,
           compositionShareType: node.compositionShareType,
-          pluginPackageId: p.deployment.packages.vaultRecordingRoyaltyPoolPlugin,
+          pluginPackageId: available!.plugins.recordingRoyaltyPool,
         });
+        const authority: AdminCapAuthority = {
+          kind: "vault", vault, vaultAdminCap,
+          capType: recordingCapType(p, node.shareType),
+          vaultPackageId: available!.vault.packageId,
+        };
         const poolParams = {
-          vault, vaultAdminCap, recording: parts.work,
+          authority, recording: parts.work,
           recordingShareType: node.shareType,
           compositionShareType: node.compositionShareType,
           currencyType: node.royaltyPool.currencyType,
-          pluginPackageId: p.deployment.packages.vaultRecordingRoyaltyPoolPlugin,
+          actionPackageId: available!.actions.recordingRoyaltyPool,
         };
+        const pool = newRecordingRoyaltyPool(tx, poolParams);
         if (stakes.length > 0) {
-          const pool = newRecordingRoyaltyPool(tx, poolParams);
           registerPublicationStakes(tx, p, node, stakes, pool, node.royaltyPool.currencyType);
-          shareRoyaltyPool(tx, {
-            pool,
-            shareType: node.shareType,
-            currencyType: node.royaltyPool.currencyType,
-            royaltyPoolPackageId: p.deployment.packages.royaltyPool,
-          });
-        } else {
-          initializeRecordingRoyaltyPool(tx, poolParams);
         }
+        shareRoyaltyPool(tx, {
+          pool,
+          shareType: node.shareType,
+          currencyType: node.royaltyPool.currencyType,
+          royaltyPoolPackageId: p.deployment.packages.royaltyPool,
+        });
       }
       invokeWithAdminCap(tx, {
         kind: "vault", vault, vaultAdminCap,
         capType: recordingCapType(p, node.shareType),
-        vaultPackageId: p.deployment.packages.vault,
+        vaultPackageId: available!.vault.packageId,
       }, {
         target: `${p.deployment.protocol.miso}::recording::publish`,
         typeArguments,
@@ -535,6 +559,7 @@ function publishReleaseObject(
   releaseObject: TransactionObjectArgument,
   adminCap: TransactionObjectArgument,
 ): void {
+  const available = node.custody.kind === "vault" ? operations(p) : undefined;
   if (node.custody.kind === "direct") {
     tx.add(release.publish({
       package: p.deployment.protocol.miso,
@@ -545,21 +570,21 @@ function publishReleaseObject(
   }
   custodyNewAdminCap(tx, {
     adminCap,
-    vaultRegistry: p.deployment.objects.vaultRegistry,
+    vaultRegistry: available!.vault.registryId,
     capType: releaseCapType(p),
-    vaultPackageId: p.deployment.packages.vault,
+    vaultPackageId: available!.vault.packageId,
     owner: node.custody.owner,
     configure: (vault, vaultAdminCap) => {
       if (node.revenueDistribution) {
         installReleaseRevenueDistributorPlugin(tx, {
           vault, vaultAdminCap,
-          pluginPackageId: p.deployment.packages.vaultReleaseRevenueDistributorPlugin,
+          pluginPackageId: available!.plugins.releaseRevenueDistributor,
         });
       }
       invokeWithAdminCap(tx, {
         kind: "vault", vault, vaultAdminCap,
         capType: releaseCapType(p),
-        vaultPackageId: p.deployment.packages.vault,
+        vaultPackageId: available!.vault.packageId,
       }, {
         target: `${p.deployment.protocol.miso}::release::publish`,
         arguments: [releaseObject, tx.object.clock()],
@@ -571,10 +596,16 @@ function publishReleaseObject(
 
 /** Build the complete post-share catalog graph as one atomic PTB. */
 export function publishAtomicCatalog(p: AtomicPublicationParams): TxThunk {
-  if (p.pressing && !p.release) throw new Error("A pressing requires a release");
+  if (publicationUsesVault(p)) {
+    requireOperationsDeployment(p.deployment.operations);
+  }
+  if (p.pressing) {
+    requireRecordSalesDeployment(p.deployment.recordSales);
+    if (!p.release) throw new Error("A pressing requires a release");
+  }
   for (const node of [...p.compositions, ...p.recordings]) {
-    if ((node.royaltyPool || ("routedStake" in node && node.routedStake)) && node.custody.kind !== "vault") {
-      throw new Error(`${node.ref}: Vault-only plugins require Vault custody`);
+    if (node.royaltyPool && node.custody.kind !== "vault") {
+      throw new Error(`${node.ref}: permissionless royalty cranks require Vault custody`);
     }
   }
   if (p.release?.revenueDistribution && p.release.custody.kind !== "vault") {
@@ -807,31 +838,51 @@ export function publishAtomicCatalog(p: AtomicPublicationParams): TxThunk {
 
     let pressingParts: { pressing: TransactionObjectArgument; adminCap: TransactionObjectArgument } | undefined;
     if (p.pressing && releaseObject && releaseAdminCap) {
+      const sales = requireRecordSalesDeployment(p.deployment.recordSales);
       const created = tx.add(pressingContract._new({
-        package: p.deployment.packages.pressing,
+        package: sales.recordPackageId,
         arguments: [
           releaseObject,
           releaseAdminCap,
-          pressingState(tx, p, p.pressing.state ?? { kind: "active" }),
+          publicationEdition(p.pressing.edition),
+          publicationMaxSupply(p.pressing.maxSupply),
         ],
       }));
       pressingParts = {
         pressing: requiredCommandResult(created, 0, "pressing::new"),
         adminCap: requiredCommandResult(created, 1, "pressing::new"),
       };
+      tx.add(pressingContract.authorizeDistributor({
+        package: sales.recordPackageId,
+        typeArguments: [`${sales.recordShopPackageId}::witness::Witness`],
+        arguments: [pressingParts.pressing, pressingParts.adminCap],
+      }));
       for (const listing of p.pressing.listings) {
-        tx.add(listingContract._new({
-          package: p.deployment.packages.pressing,
+        const createdListing = tx.add(listingContract._new({
+          package: sales.recordShopPackageId,
           typeArguments: [listing.currencyType],
           arguments: [
             pressingParts.pressing,
             pressingParts.adminCap,
             listingPrice(tx, p, listing.price),
-            tx.add(listing.enabled === false
-              ? listingContract.newDisabledState({ package: p.deployment.packages.pressing })
-              : listingContract.newEnabledState({ package: p.deployment.packages.pressing })),
           ],
         }));
+        if (listing.enabled === false) {
+          tx.add(listingContract.setState({
+            package: sales.recordShopPackageId,
+            typeArguments: [listing.currencyType],
+            arguments: [
+              createdListing,
+              pressingParts.adminCap,
+              tx.add(listingContract.disabled({ package: sales.recordShopPackageId })),
+            ],
+          }));
+        }
+        tx.add(listingContract.share({
+          package: sales.recordShopPackageId,
+          typeArguments: [listing.currencyType],
+          arguments: [createdListing],
+        }));
       }
     }
 
@@ -848,22 +899,13 @@ export function publishAtomicCatalog(p: AtomicPublicationParams): TxThunk {
         package: p.deployment.protocol.misoParty,
         arguments: [parts.party, parts.adminCap],
       }));
-      disposeNewAdminCap(tx, parts.adminCap, custody(
-        p,
-        node.custody,
-        partyCapType(p),
-        node.custody.kind === "vault" && node.installWallet !== false
-          ? (vault, vaultAdminCap) => installPartyWalletPlugin(tx, {
-              vault, vaultAdminCap,
-              pluginPackageId: p.deployment.packages.vaultPartyWalletPlugin,
-            })
-          : undefined,
-      ));
+      disposeNewAdminCap(tx, parts.adminCap, custody(p, node.custody, partyCapType(p)));
     }
 
     if (p.pressing && pressingParts) {
+      const sales = requireRecordSalesDeployment(p.deployment.recordSales);
       tx.add(pressingContract.share({
-        package: p.deployment.packages.pressing,
+        package: sales.recordPackageId,
         arguments: [pressingParts.pressing],
       }));
       disposeNewAdminCap(tx, pressingParts.adminCap, custody(
@@ -932,14 +974,14 @@ function findByShareType(
   return matches[0]!.objectId;
 }
 
-function vaultsByCap(result: PlatformExecResult) {
+function vaultsByCap(result: PlatformExecResult, vaultPackageId: string) {
   const out = new Map<string, { vaultId: string; vaultAdminCapId: string }>();
   for (const event of result.events) {
     if (!event.eventType.includes("::vault::VaultCreatedEvent<")) continue;
     const parsed = parseVaultCreatedEvent(event.bcs);
     out.set(parsed.cap_id, {
       vaultId: parsed.vault_id,
-      vaultAdminCapId: parsed.vault_admin_cap_id,
+      vaultAdminCapId: deriveVaultAdminCapId(parsed.vault_id, vaultPackageId),
     });
   }
   return out;
@@ -964,7 +1006,11 @@ export function parseAtomicPublicationResult(
   p: AtomicPublicationParams,
   result: PlatformExecResult,
 ): AtomicPublicationResult {
-  const vaults = vaultsByCap(result);
+  const available = publicationUsesVault(p) ? operations(p) : undefined;
+  const vaultPackageId = available?.vault.packageId ?? "";
+  const vaults = available
+    ? vaultsByCap(result, vaultPackageId)
+    : new Map<string, { vaultId: string; vaultAdminCapId: string }>();
   const createdCompositions = allCreatedByType(result, "::composition::Composition<");
   const createdRecordings = allCreatedByType(result, "::recording::Recording<");
   const createdPools = allCreatedByType(result, "::pool::RoyaltyPool<");
@@ -992,7 +1038,7 @@ export function parseAtomicPublicationResult(
       id: parsed.party_id,
       adminCapId,
       created: true,
-      authority: authorityOut(result, vaults, node.custody, adminCapId, partyCapType(p), p.deployment.packages.vault),
+      authority: authorityOut(result, vaults, node.custody, adminCapId, partyCapType(p), vaultPackageId),
     };
   });
 
@@ -1004,7 +1050,7 @@ export function parseAtomicPublicationResult(
       id,
       adminCapId,
       shareType: node.shareType,
-      authority: authorityOut(result, vaults, node.custody, adminCapId, compositionCapType(p, node.shareType), p.deployment.packages.vault),
+      authority: authorityOut(result, vaults, node.custody, adminCapId, compositionCapType(p, node.shareType), vaultPackageId),
       royaltyPoolId: node.royaltyPool ? findByShareType(createdPools, node.shareType, "Composition RoyaltyPool") : undefined,
     };
   });
@@ -1018,7 +1064,7 @@ export function parseAtomicPublicationResult(
       adminCapId,
       shareType: node.shareType,
       compositionShareType: node.compositionShareType,
-      authority: authorityOut(result, vaults, node.custody, adminCapId, recordingCapType(p, node.shareType), p.deployment.packages.vault),
+      authority: authorityOut(result, vaults, node.custody, adminCapId, recordingCapType(p, node.shareType), vaultPackageId),
       royaltyPoolId: node.royaltyPool ? findByShareType(createdPools, node.shareType, "Recording RoyaltyPool") : undefined,
     };
   });
@@ -1030,18 +1076,19 @@ export function parseAtomicPublicationResult(
     releaseOut = {
       id,
       adminCapId,
-      authority: authorityOut(result, vaults, p.release.custody, adminCapId, releaseCapType(p), p.deployment.packages.vault),
+      authority: authorityOut(result, vaults, p.release.custody, adminCapId, releaseCapType(p), vaultPackageId),
     };
   }
 
   let pressingOut: AtomicPublicationResult["pressing"];
   if (p.pressing && releaseOut) {
-    const id = derivePressingId(releaseOut.id, p.deployment.packages.pressing);
-    const adminCapId = derivePressingAdminCapId(id, p.deployment.packages.pressing);
+    const sales = requireRecordSalesDeployment(p.deployment.recordSales);
+    const id = derivePressingId(releaseOut.id, p.pressing.edition, sales.recordPackageId);
+    const adminCapId = derivePressingAdminCapId(id, sales.recordPackageId);
     pressingOut = {
       id,
       adminCapId,
-      authority: authorityOut(result, vaults, p.pressing.custody, adminCapId, pressingCapType(p), p.deployment.packages.vault),
+      authority: authorityOut(result, vaults, p.pressing.custody, adminCapId, pressingCapType(p), vaultPackageId),
     };
   }