@misofm/sdk 0.12.4 → 0.14.0

package/dist/publication.js

@@ -0,0 +1,666 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Opinionated, atomic Miso catalog publication.
+ *
+ * Share packages and their registered Currency objects must already exist. This
+ * builder then creates every declared Party, Composition, Recording, Track,
+ * Release, extension, Vault plugin, Pressing, and Listing in one PTB. Fresh raw
+ * protocol capabilities never leave the transaction: data extensions use them
+ * directly, Vault-only plugins are configured while each new Vault is still
+ * owned, and only the selected direct cap or VaultAdminCap is delivered.
+ */
+import { Transaction } from "@mysten/sui/transactions";
+import { contracts as protocolContracts, deriveCompositionAdminCapId, deriveRecordingAdminCapId, deriveReleaseAdminCapId, } from "@misonetwork/sdk";
+import { derivePartyAdminCapId } from "@misonetwork/sdk/party";
+import { disperseShares, requiredCommandResult } from "./transactions.js";
+import { addRecordingPrimaryArtist, addReleaseCredit, attachCompositionCredit, attachRecordingCredit, } from "./credits.js";
+import { setRecordingAdvisory, setRecordingInstrumental, setRecordingLanguages, setRecordingMasterReference, setRecordingPreview, } from "./recording-extensions.js";
+import { setReleaseDescription, setReleaseDspLinks, setReleaseGenres, setReleaseKind, } from "./release-extensions.js";
+import { setReleaseCover, setReleaseTrackCover } from "./cover.js";
+import { custodyNewAdminCap, directAdminCap, disposeNewAdminCap, initializeCompositionRoyaltyPool, initializeRecordingRoyaltyPool, installCompositionRoutedStakePlugin, installCompositionRoyaltyPoolPlugin, installPartyWalletPlugin, installRecordingRoyaltyPoolPlugin, installReleaseRevenueDistributorPlugin, invokeWithAdminCap, parseVaultCreatedEvent, } from "./vault.js";
+import { derivePressingAdminCapId, derivePressingId, } from "./pressing.js";
+import { allCreatedByType, createdByExactType } from "./execute.js";
+import * as pressingContract from "./contracts/miso_pressing/pressing.js";
+import * as listingContract from "./contracts/miso_pressing/listing.js";
+const { composition, recording, release, track, party } = protocolContracts;
+export const MAX_ATOMIC_PUBLICATION_COMMANDS = 900;
+export const MAX_ATOMIC_PUBLICATION_INPUTS = 2048;
+function requiredAt(items, index, description) {
+    const value = items[index];
+    if (value === undefined)
+        throw new Error(`${description} index ${index} is out of range`);
+    return value;
+}
+function partyCapType(p) {
+    return `${p.deployment.protocol.misoParty}::party::PartyAdminCap`;
+}
+function compositionCapType(p, shareType) {
+    return `${p.deployment.protocol.miso}::composition::CompositionAdminCap<${shareType}>`;
+}
+function recordingCapType(p, shareType) {
+    return `${p.deployment.protocol.miso}::recording::RecordingAdminCap<${shareType}>`;
+}
+function releaseCapType(p) {
+    return `${p.deployment.protocol.miso}::release::ReleaseAdminCap`;
+}
+function pressingCapType(p) {
+    return `${p.deployment.packages.pressing}::pressing::PressingAdminCap`;
+}
+function custody(p, selected, capType, configure) {
+    if (selected.kind === "direct")
+        return { kind: "direct", owner: selected.owner };
+    return {
+        kind: "vault",
+        owner: selected.owner,
+        capType,
+        vaultPackageId: p.deployment.packages.vault,
+        configure,
+    };
+}
+function partyByRef(parties, ref) {
+    const value = parties.get(ref);
+    if (!value)
+        throw new Error(`Unknown publication party ref ${JSON.stringify(ref)}`);
+    return value;
+}
+function languageVector(tx, p, codes) {
+    const values = codes.map((code) => tx.moveCall({
+        target: `${p.deployment.protocol.languageCode}::language_code::new`,
+        arguments: [tx.pure.string(code)],
+    }));
+    return tx.makeMoveVec({
+        type: `${p.deployment.protocol.languageCode}::language_code::LanguageCode`,
+        elements: values,
+    });
+}
+function walrusBlob(tx, p, blobId) {
+    return tx.moveCall({
+        target: `${p.deployment.packages.ori}::walrus_data::new_blob`,
+        arguments: [tx.pure.u256(blobId)],
+    });
+}
+function pressingState(tx, p, state) {
+    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, p, price) {
+    const pkg = p.deployment.packages.pressing;
+    const args = { package: pkg, arguments: [BigInt(price.amount)] };
+    return tx.add(price.kind === "fixed"
+        ? listingContract.newFixedPrice(args)
+        : listingContract.newFloorPrice(args));
+}
+function publishComposition(tx, p, node, parts) {
+    disperseShares(tx, p.deployment.packages.minato, node.shareType, parts.balance, node.shareRecipients);
+    const typeArguments = [node.shareType];
+    if (node.custody.kind === "direct") {
+        tx.add(composition.publish({
+            package: p.deployment.protocol.miso,
+            typeArguments,
+            arguments: [parts.work, parts.adminCap],
+        }));
+        disposeNewAdminCap(tx, parts.adminCap, custody(p, node.custody, compositionCapType(p, node.shareType)));
+        return;
+    }
+    custodyNewAdminCap(tx, {
+        adminCap: parts.adminCap,
+        capType: compositionCapType(p, node.shareType),
+        vaultPackageId: p.deployment.packages.vault,
+        owner: node.custody.owner,
+        configure: (vault, vaultAdminCap) => {
+            if (node.royaltyPool) {
+                installCompositionRoyaltyPoolPlugin(tx, {
+                    vault, vaultAdminCap, compositionShareType: node.shareType,
+                    pluginPackageId: p.deployment.packages.compositionRoyaltyPoolPlugin,
+                });
+                initializeCompositionRoyaltyPool(tx, {
+                    vault, vaultAdminCap, composition: parts.work,
+                    compositionShareType: node.shareType,
+                    currencyType: node.royaltyPool.currencyType,
+                    pluginPackageId: p.deployment.packages.compositionRoyaltyPoolPlugin,
+                });
+            }
+            if (node.routedStake) {
+                installCompositionRoutedStakePlugin(tx, {
+                    vault, vaultAdminCap, compositionShareType: node.shareType,
+                    pluginPackageId: p.deployment.packages.compositionRoutedStakePlugin,
+                });
+            }
+            invokeWithAdminCap(tx, {
+                kind: "vault", vault, vaultAdminCap,
+                capType: compositionCapType(p, node.shareType),
+                vaultPackageId: p.deployment.packages.vault,
+            }, {
+                target: `${p.deployment.protocol.miso}::composition::publish`,
+                typeArguments,
+                arguments: [parts.work, tx.object.clock()],
+                adminCapIndex: 1,
+            });
+        },
+    });
+}
+function publishRecording(tx, p, node, parts) {
+    const typeArguments = [node.shareType, node.compositionShareType];
+    disperseShares(tx, p.deployment.packages.minato, node.shareType, parts.balance, node.shareRecipients);
+    if (node.custody.kind === "direct") {
+        tx.add(recording.publish({
+            package: p.deployment.protocol.miso,
+            typeArguments,
+            arguments: [parts.work, parts.adminCap],
+        }));
+        disposeNewAdminCap(tx, parts.adminCap, custody(p, node.custody, recordingCapType(p, node.shareType)));
+        return;
+    }
+    custodyNewAdminCap(tx, {
+        adminCap: parts.adminCap,
+        capType: recordingCapType(p, node.shareType),
+        vaultPackageId: p.deployment.packages.vault,
+        owner: node.custody.owner,
+        configure: (vault, vaultAdminCap) => {
+            if (node.royaltyPool) {
+                installRecordingRoyaltyPoolPlugin(tx, {
+                    vault, vaultAdminCap,
+                    recordingShareType: node.shareType,
+                    compositionShareType: node.compositionShareType,
+                    pluginPackageId: p.deployment.packages.recordingRoyaltyPoolPlugin,
+                });
+                initializeRecordingRoyaltyPool(tx, {
+                    vault, vaultAdminCap, recording: parts.work,
+                    recordingShareType: node.shareType,
+                    compositionShareType: node.compositionShareType,
+                    currencyType: node.royaltyPool.currencyType,
+                    pluginPackageId: p.deployment.packages.recordingRoyaltyPoolPlugin,
+                });
+            }
+            invokeWithAdminCap(tx, {
+                kind: "vault", vault, vaultAdminCap,
+                capType: recordingCapType(p, node.shareType),
+                vaultPackageId: p.deployment.packages.vault,
+            }, {
+                target: `${p.deployment.protocol.miso}::recording::publish`,
+                typeArguments,
+                arguments: [parts.work, tx.object.clock()],
+                adminCapIndex: 1,
+            });
+        },
+    });
+}
+function publishReleaseObject(tx, p, node, releaseObject, adminCap) {
+    if (node.custody.kind === "direct") {
+        tx.add(release.publish({
+            package: p.deployment.protocol.miso,
+            arguments: [releaseObject, adminCap],
+        }));
+        disposeNewAdminCap(tx, adminCap, custody(p, node.custody, releaseCapType(p)));
+        return;
+    }
+    custodyNewAdminCap(tx, {
+        adminCap,
+        capType: releaseCapType(p),
+        vaultPackageId: p.deployment.packages.vault,
+        owner: node.custody.owner,
+        configure: (vault, vaultAdminCap) => {
+            if (node.revenueDistribution) {
+                installReleaseRevenueDistributorPlugin(tx, {
+                    vault, vaultAdminCap,
+                    pluginPackageId: p.deployment.packages.releaseRevenueDistributorPlugin,
+                });
+            }
+            invokeWithAdminCap(tx, {
+                kind: "vault", vault, vaultAdminCap,
+                capType: releaseCapType(p),
+                vaultPackageId: p.deployment.packages.vault,
+            }, {
+                target: `${p.deployment.protocol.miso}::release::publish`,
+                arguments: [releaseObject, tx.object.clock()],
+                adminCapIndex: 1,
+            });
+        },
+    });
+}
+/** Build the complete post-share catalog graph as one atomic PTB. */
+export function publishAtomicCatalog(p) {
+    if (p.pressing && !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 (p.release?.revenueDistribution && p.release.custody.kind !== "vault") {
+        throw new Error("Release revenue distribution requires Vault custody");
+    }
+    return (tx) => {
+        const createdParties = new Map();
+        const parties = new Map();
+        for (const node of p.parties) {
+            if ("id" in node) {
+                parties.set(node.ref, tx.object(node.id));
+                continue;
+            }
+            const kind = tx.add(node.create === "group"
+                ? party.newGroupKind({ package: p.deployment.protocol.misoParty })
+                : party.newIndividualKind({ package: p.deployment.protocol.misoParty }));
+            const created = tx.add(party._new({
+                package: p.deployment.protocol.misoParty,
+                arguments: [kind, node.name],
+            }));
+            const parts = {
+                party: requiredCommandResult(created, 0, "party::new"),
+                adminCap: requiredCommandResult(created, 1, "party::new"),
+            };
+            createdParties.set(node.ref, parts);
+            parties.set(node.ref, parts.party);
+        }
+        const compositions = p.compositions.map((node) => {
+            const created = tx.add(composition._new({
+                package: p.deployment.protocol.miso,
+                typeArguments: [node.shareType],
+                arguments: [node.title, node.royaltyRateBps, node.shareCurrencyId, node.shareTreasuryCapId],
+            }));
+            return {
+                work: requiredCommandResult(created, 0, "composition::new"),
+                adminCap: requiredCommandResult(created, 1, "composition::new"),
+                balance: requiredCommandResult(created, 2, "composition::new"),
+            };
+        });
+        const recordings = p.recordings.map((node) => {
+            const parent = node.parentCompositionIndex !== undefined
+                ? requiredAt(compositions, node.parentCompositionIndex, "parent composition").work
+                : tx.object(node.parentCompositionId);
+            const created = tx.add(recording._new({
+                package: p.deployment.protocol.miso,
+                typeArguments: [node.shareType, node.compositionShareType],
+                arguments: [parent, node.shareCurrencyId, node.shareTreasuryCapId],
+            }));
+            return {
+                work: requiredCommandResult(created, 0, "recording::new"),
+                adminCap: requiredCommandResult(created, 1, "recording::new"),
+                balance: requiredCommandResult(created, 2, "recording::new"),
+            };
+        });
+        let releaseObject;
+        let releaseAdminCap;
+        if (p.release) {
+            const ids = p.release.tracks.map((node) => "recordingIndex" in node
+                ? tx.moveCall({
+                    target: "0x2::object::id",
+                    typeArguments: [`${p.deployment.protocol.miso}::recording::Recording<${p.recordings[node.recordingIndex].shareType},${p.recordings[node.recordingIndex].compositionShareType}>`],
+                    arguments: [requiredAt(recordings, node.recordingIndex, "fresh recording").work],
+                })
+                : tx.pure.id(node.recordingId));
+            const targetReleaseId = tx.moveCall({
+                target: `${p.deployment.protocol.miso}::release::derive_target_release_id`,
+                arguments: [
+                    tx.object(p.deployment.objects.releaseRegistry),
+                    tx.makeMoveVec({ type: "0x2::object::ID", elements: ids }),
+                    tx.makeMoveVec({ type: "u64", elements: p.release.tracks.map((node) => tx.pure.u64(node.splitBps)) }),
+                    tx.pure.u256(BigInt(p.release.nonce)),
+                ],
+            });
+            const tracks = p.release.tracks.map((node) => {
+                if ("recordingIndex" in node) {
+                    const recNode = requiredAt(p.recordings, node.recordingIndex, "fresh recording");
+                    const rec = requiredAt(recordings, node.recordingIndex, "fresh recording");
+                    return tx.add(track._new({
+                        package: p.deployment.protocol.miso,
+                        typeArguments: [recNode.shareType, recNode.compositionShareType],
+                        arguments: [rec.adminCap, rec.work, targetReleaseId, node.splitBps],
+                    }));
+                }
+                return invokeWithAdminCap(tx, node.authority, {
+                    target: `${p.deployment.protocol.miso}::track::new`,
+                    typeArguments: [node.recordingShareType, node.compositionShareType],
+                    arguments: [tx.object(node.recordingId), targetReleaseId, tx.pure.u16(node.splitBps)],
+                    adminCapIndex: 0,
+                });
+            });
+            const created = tx.moveCall({
+                target: `${p.deployment.protocol.miso}::release::new`,
+                arguments: [
+                    tx.object(p.deployment.objects.releaseRegistry),
+                    tx.pure.string(p.release.title),
+                    tx.makeMoveVec({ type: `${p.deployment.protocol.miso}::track::Track`, elements: tracks }),
+                    tx.pure.u256(BigInt(p.release.nonce)),
+                ],
+            });
+            releaseObject = requiredCommandResult(created, 0, "release::new");
+            releaseAdminCap = requiredCommandResult(created, 1, "release::new");
+        }
+        p.compositions.forEach((node, index) => {
+            const parts = requiredAt(compositions, index, "composition");
+            for (const credit of node.credits ?? []) {
+                attachCompositionCredit({
+                    compositionId: parts.work,
+                    authority: directAdminCap(parts.adminCap),
+                    partyId: partyByRef(parties, credit.party),
+                    displayName: credit.displayName,
+                    roles: credit.roles,
+                    compositionShareType: node.shareType,
+                    compositionCreditsPackageId: p.deployment.packages.compositionCredits,
+                    misoCreditPackageId: p.deployment.packages.credit,
+                })(tx);
+            }
+        });
+        p.recordings.forEach((node, index) => {
+            const parts = requiredAt(recordings, index, "recording");
+            const authority = directAdminCap(parts.adminCap);
+            for (const credit of node.credits ?? []) {
+                const target = partyByRef(parties, credit.party);
+                attachRecordingCredit({
+                    recordingId: parts.work, authority, partyId: target,
+                    displayName: credit.displayName, roles: credit.roles,
+                    recordingShareType: node.shareType,
+                    compositionShareType: node.compositionShareType,
+                    recordingCreditsPackageId: p.deployment.packages.recordingCredits,
+                    misoCreditPackageId: p.deployment.packages.credit,
+                })(tx);
+                if (credit.primaryArtist) {
+                    addRecordingPrimaryArtist({
+                        recordingId: parts.work, authority, partyId: target,
+                        recordingShareType: node.shareType,
+                        compositionShareType: node.compositionShareType,
+                        recordingCreditsPackageId: p.deployment.packages.recordingCredits,
+                    })(tx);
+                }
+            }
+            if (node.advisory)
+                setRecordingAdvisory({
+                    recordingId: parts.work, authority,
+                    recordingShareType: node.shareType,
+                    compositionShareType: node.compositionShareType,
+                    recordingAdvisoryPackageId: p.deployment.packages.recordingAdvisory,
+                    rating: node.advisory,
+                })(tx);
+            if (node.languages?.kind === "instrumental")
+                setRecordingInstrumental({
+                    recordingId: parts.work, authority,
+                    recordingShareType: node.shareType,
+                    compositionShareType: node.compositionShareType,
+                    recordingLanguagePackageId: p.deployment.packages.recordingLanguage,
+                })(tx);
+            if (node.languages?.kind === "languages")
+                setRecordingLanguages({
+                    recordingId: parts.work, authority,
+                    recordingShareType: node.shareType,
+                    compositionShareType: node.compositionShareType,
+                    recordingLanguagePackageId: p.deployment.packages.recordingLanguage,
+                    languages: languageVector(tx, p, node.languages.codes),
+                })(tx);
+            if (node.masterReferenceBlobId !== undefined)
+                setRecordingMasterReference({
+                    recordingId: parts.work, authority,
+                    recordingShareType: node.shareType,
+                    compositionShareType: node.compositionShareType,
+                    recordingMasterReferencePackageId: p.deployment.packages.recordingMasterReference,
+                    reference: walrusBlob(tx, p, node.masterReferenceBlobId),
+                })(tx);
+            if (node.previewBlobId !== undefined)
+                setRecordingPreview({
+                    recordingId: parts.work, authority,
+                    recordingShareType: node.shareType,
+                    compositionShareType: node.compositionShareType,
+                    recordingPreviewPackageId: p.deployment.packages.recordingPreview,
+                    reference: walrusBlob(tx, p, node.previewBlobId),
+                })(tx);
+        });
+        if (p.release && releaseObject && releaseAdminCap) {
+            const authority = directAdminCap(releaseAdminCap);
+            for (const credit of p.release.credits ?? [])
+                addReleaseCredit({
+                    releaseId: releaseObject, authority,
+                    partyId: partyByRef(parties, credit.party),
+                    displayName: credit.displayName, role: credit.role,
+                    releaseCreditsPackageId: p.deployment.packages.releaseCredits,
+                    misoCreditPackageId: p.deployment.packages.credit,
+                })(tx);
+            if (p.release.kind)
+                setReleaseKind({
+                    releaseId: releaseObject, authority, kind: p.release.kind,
+                    releaseKindPackageId: p.deployment.packages.releaseKind,
+                })(tx);
+            if (p.release.description)
+                setReleaseDescription({
+                    releaseId: releaseObject, authority, description: p.release.description,
+                    releaseDescriptionPackageId: p.deployment.packages.releaseDescription,
+                })(tx);
+            if (p.release.genres)
+                setReleaseGenres({
+                    releaseId: releaseObject, authority,
+                    primaryGenreId: p.release.genres.primaryGenreId,
+                    secondaryGenreIds: p.release.genres.secondaryGenreIds ?? [],
+                    trackPrimaryGenres: p.release.genres.tracks ?? [],
+                    releaseGenrePackageId: p.deployment.packages.releaseGenre,
+                })(tx);
+            if (p.release.dspLinks)
+                setReleaseDspLinks({
+                    releaseId: releaseObject, authority,
+                    releaseLinks: p.release.dspLinks.release ?? [],
+                    trackLinks: p.release.dspLinks.tracks ?? [],
+                    releaseDspLinkPackageId: p.deployment.packages.releaseDspLink,
+                })(tx);
+            if (p.release.cover?.stillBlobId !== undefined)
+                setReleaseCover({
+                    releaseId: releaseObject, authority,
+                    stillBlobId: p.release.cover.stillBlobId,
+                    animatedBlobId: p.release.cover.animatedBlobId,
+                    coverArtPackageId: p.deployment.packages.coverArt,
+                    releaseCoverArtPackageId: p.deployment.packages.releaseCoverArt,
+                    oriPackageId: p.deployment.packages.ori,
+                })(tx);
+            for (const cover of p.release.cover?.tracks ?? [])
+                setReleaseTrackCover({
+                    releaseId: releaseObject, authority,
+                    trackIndex: cover.trackIndex,
+                    stillBlobId: cover.stillBlobId,
+                    animatedBlobId: cover.animatedBlobId,
+                    coverArtPackageId: p.deployment.packages.coverArt,
+                    releaseCoverArtPackageId: p.deployment.packages.releaseCoverArt,
+                    oriPackageId: p.deployment.packages.ori,
+                })(tx);
+        }
+        let pressingParts;
+        if (p.pressing && releaseObject && releaseAdminCap) {
+            const created = tx.add(pressingContract._new({
+                package: p.deployment.packages.pressing,
+                arguments: [
+                    releaseObject,
+                    releaseAdminCap,
+                    pressingState(tx, p, p.pressing.state ?? { kind: "active" }),
+                ],
+            }));
+            pressingParts = {
+                pressing: requiredCommandResult(created, 0, "pressing::new"),
+                adminCap: requiredCommandResult(created, 1, "pressing::new"),
+            };
+            for (const listing of p.pressing.listings) {
+                tx.add(listingContract._new({
+                    package: p.deployment.packages.pressing,
+                    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 })),
+                    ],
+                }));
+            }
+        }
+        p.compositions.forEach((node, index) => publishComposition(tx, p, node, requiredAt(compositions, index, "composition")));
+        p.recordings.forEach((node, index) => publishRecording(tx, p, node, requiredAt(recordings, index, "recording")));
+        if (p.release && releaseObject && releaseAdminCap) {
+            publishReleaseObject(tx, p, p.release, releaseObject, releaseAdminCap);
+        }
+        for (const node of p.parties) {
+            if ("id" in node)
+                continue;
+            const parts = createdParties.get(node.ref);
+            tx.add(party.share({
+                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.partyWalletPlugin,
+                })
+                : undefined));
+        }
+        if (p.pressing && pressingParts) {
+            tx.add(pressingContract.share({
+                package: p.deployment.packages.pressing,
+                arguments: [pressingParts.pressing],
+            }));
+            disposeNewAdminCap(tx, pressingParts.adminCap, custody(p, p.pressing.custody, pressingCapType(p)));
+        }
+    };
+}
+/** Assemble without RPC access so callers can fail before publishing share packages. */
+export function inspectAtomicPublication(p) {
+    const tx = new Transaction();
+    publishAtomicCatalog(p)(tx);
+    const data = tx.getData();
+    return { commands: data.commands.length, inputs: data.inputs.length };
+}
+export function assertAtomicPublicationBounds(p) {
+    const inspection = inspectAtomicPublication(p);
+    if (inspection.commands > MAX_ATOMIC_PUBLICATION_COMMANDS) {
+        throw new Error(`Atomic publication requires ${inspection.commands} commands; the SDK safety cap is ` +
+            `${MAX_ATOMIC_PUBLICATION_COMMANDS} (Sui permits at most 1024).`);
+    }
+    if (inspection.inputs > MAX_ATOMIC_PUBLICATION_INPUTS) {
+        throw new Error(`Atomic publication requires ${inspection.inputs} inputs; Sui permits at most ` +
+            `${MAX_ATOMIC_PUBLICATION_INPUTS}.`);
+    }
+    return inspection;
+}
+function compactType(type) {
+    return type.replace(/\s+/g, "");
+}
+function findByShareType(created, shareType, description) {
+    const wanted = compactType(shareType);
+    const matches = created.filter((item) => compactType(item.objectType).includes(wanted));
+    if (matches.length !== 1)
+        throw new Error(`Expected one ${description} for ${shareType}; found ${matches.length}`);
+    return matches[0].objectId;
+}
+function vaultsByWrappedCap(result) {
+    const out = new Map();
+    for (const event of result.events) {
+        if (!event.eventType.includes("::vault::VaultCreatedEvent<"))
+            continue;
+        const parsed = parseVaultCreatedEvent(event.bcs);
+        out.set(parsed.wrapped_cap_id, {
+            vaultId: parsed.vault_id,
+            vaultAdminCapId: parsed.vault_admin_cap_id,
+        });
+    }
+    return out;
+}
+function authorityOut(result, vaults, selected, adminCapId, capType, vaultPackageId) {
+    if (selected.kind === "direct")
+        return { kind: "direct", adminCapId };
+    const found = vaults.get(adminCapId);
+    if (!found)
+        throw new Error(`No VaultCreatedEvent wrapped admin cap ${adminCapId} in ${result.digest}`);
+    return { kind: "vault", ...found, capType, vaultPackageId };
+}
+/** Parse one atomic publication using type identity plus lifecycle event payloads. */
+export function parseAtomicPublicationResult(p, result) {
+    const vaults = vaultsByWrappedCap(result);
+    const createdCompositions = allCreatedByType(result, "::composition::Composition<");
+    const createdRecordings = allCreatedByType(result, "::recording::Recording<");
+    const createdPools = allCreatedByType(result, "::pool::RoyaltyPool<");
+    const createdPartyNodes = p.parties.filter((node) => "create" in node);
+    const partyEvents = result.events.filter((event) => event.eventType.endsWith("::party::PartyCreatedEvent"));
+    if (partyEvents.length !== createdPartyNodes.length) {
+        throw new Error(`Expected ${createdPartyNodes.length} PartyCreatedEvent values; found ${partyEvents.length}`);
+    }
+    const parties = {};
+    for (const node of p.parties) {
+        if ("id" in node) {
+            parties[node.ref] = {
+                id: node.id,
+                adminCapId: derivePartyAdminCapId(node.id, p.deployment.protocol.misoParty),
+                created: false,
+            };
+        }
+    }
+    createdPartyNodes.forEach((node, index) => {
+        const event = partyEvents[index];
+        const parsed = protocolContracts.party.PartyCreatedEvent.parse(event.bcs);
+        const adminCapId = derivePartyAdminCapId(parsed.party_id, p.deployment.protocol.misoParty);
+        parties[node.ref] = {
+            id: parsed.party_id,
+            adminCapId,
+            created: true,
+            authority: authorityOut(result, vaults, node.custody, adminCapId, partyCapType(p), p.deployment.packages.vault),
+        };
+    });
+    const compositions = {};
+    p.compositions.forEach((node) => {
+        const id = findByShareType(createdCompositions, node.shareType, "Composition");
+        const adminCapId = deriveCompositionAdminCapId(id, p.deployment.protocol.miso);
+        compositions[node.ref] = {
+            id,
+            adminCapId,
+            shareType: node.shareType,
+            authority: authorityOut(result, vaults, node.custody, adminCapId, compositionCapType(p, node.shareType), p.deployment.packages.vault),
+            royaltyPoolId: node.royaltyPool ? findByShareType(createdPools, node.shareType, "Composition RoyaltyPool") : undefined,
+        };
+    });
+    const recordings = {};
+    p.recordings.forEach((node) => {
+        const id = findByShareType(createdRecordings, node.shareType, "Recording");
+        const adminCapId = deriveRecordingAdminCapId(id, p.deployment.protocol.miso);
+        recordings[node.ref] = {
+            id,
+            adminCapId,
+            shareType: node.shareType,
+            compositionShareType: node.compositionShareType,
+            authority: authorityOut(result, vaults, node.custody, adminCapId, recordingCapType(p, node.shareType), p.deployment.packages.vault),
+            royaltyPoolId: node.royaltyPool ? findByShareType(createdPools, node.shareType, "Recording RoyaltyPool") : undefined,
+        };
+    });
+    let releaseOut;
+    if (p.release) {
+        const id = createdByExactType(result, `${p.deployment.protocol.miso}::release::Release`);
+        const adminCapId = deriveReleaseAdminCapId(id, p.deployment.protocol.miso);
+        releaseOut = {
+            id,
+            adminCapId,
+            authority: authorityOut(result, vaults, p.release.custody, adminCapId, releaseCapType(p), p.deployment.packages.vault),
+        };
+    }
+    let pressingOut;
+    if (p.pressing && releaseOut) {
+        const id = derivePressingId(releaseOut.id, p.deployment.packages.pressing);
+        const adminCapId = derivePressingAdminCapId(id, p.deployment.packages.pressing);
+        pressingOut = {
+            id,
+            adminCapId,
+            authority: authorityOut(result, vaults, p.pressing.custody, adminCapId, pressingCapType(p), p.deployment.packages.vault),
+        };
+    }
+    return {
+        digest: result.digest,
+        gasUsed: result.gasUsed,
+        parties,
+        compositions,
+        recordings,
+        release: releaseOut,
+        pressing: pressingOut,
+    };
+}
+//# sourceMappingURL=publication.js.map