@misonetwork/sdk 0.8.0 → 0.9.0

package/src/contracts/routed_stake/routed_stake.ts

@@ -332,33 +332,6 @@ export function sweep(options: SweepOptions) {
         typeArguments: options.typeArguments
     });
 }
-export interface IdArguments {
-    self: RawTransactionArgument<string>;
-}
-export interface IdOptions {
-    package?: string;
-    arguments: IdArguments | [
-        self: RawTransactionArgument<string>
-    ];
-    typeArguments: [
-        string,
-        string
-    ];
-}
-export function id(options: IdOptions) {
-    const packageAddress = options.package ?? '@local-pkg/routed_stake';
-    const argumentsTypes = [
-        null
-    ] satisfies (string | null)[];
-    const parameterNames = ["self"];
-    return (tx: Transaction) => tx.moveCall({
-        package: packageAddress,
-        module: 'routed_stake',
-        function: 'id',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-        typeArguments: options.typeArguments
-    });
-}
 export interface HasStakeArguments {
     self: RawTransactionArgument<string>;
 }

package/src/contracts/royalty_pool/pool.ts

@@ -412,33 +412,6 @@ export function pendingRewards(options: PendingRewardsOptions) {
         typeArguments: options.typeArguments
     });
 }
-export interface IdArguments {
-    self: RawTransactionArgument<string>;
-}
-export interface IdOptions {
-    package?: string;
-    arguments: IdArguments | [
-        self: RawTransactionArgument<string>
-    ];
-    typeArguments: [
-        string,
-        string
-    ];
-}
-export function id(options: IdOptions) {
-    const packageAddress = options.package ?? '@local-pkg/royalty_pool';
-    const argumentsTypes = [
-        null
-    ] satisfies (string | null)[];
-    const parameterNames = ["self"];
-    return (tx: Transaction) => tx.moveCall({
-        package: packageAddress,
-        module: 'pool',
-        function: 'id',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-        typeArguments: options.typeArguments
-    });
-}
 export interface BalanceArguments {
     self: RawTransactionArgument<string>;
 }

package/src/contracts/royalty_pool/stake.ts

@@ -108,32 +108,6 @@ export function destroy(options: DestroyOptions) {
         typeArguments: options.typeArguments
     });
 }
-export interface IdArguments {
-    self: RawTransactionArgument<string>;
-}
-export interface IdOptions {
-    package?: string;
-    arguments: IdArguments | [
-        self: RawTransactionArgument<string>
-    ];
-    typeArguments: [
-        string
-    ];
-}
-export function id(options: IdOptions) {
-    const packageAddress = options.package ?? '@local-pkg/royalty_pool';
-    const argumentsTypes = [
-        null
-    ] satisfies (string | null)[];
-    const parameterNames = ["self"];
-    return (tx: Transaction) => tx.moveCall({
-        package: packageAddress,
-        module: 'stake',
-        function: 'id',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-        typeArguments: options.typeArguments
-    });
-}
 export interface BalanceArguments {
     self: RawTransactionArgument<string>;
 }

package/src/contracts.ts

@@ -28,10 +28,11 @@ import * as rawRecordingPreview from "./contracts/recording_preview/recording_pr
 import * as rawReleaseCoverArt from "./contracts/release_cover_art/release_cover_art.ts";
 import * as rawReleaseCredits from "./contracts/release_credits/release_credits.ts";
 import * as rawReleaseDescription from "./contracts/release_description/release_description.ts";
-import * as rawReleaseSnapshotBundle from "./contracts/release_snapshot_bundle/release_snapshot_bundle.ts";
 import * as rawRoyaltyPool from "./contracts/royalty_pool/pool.ts";
 import * as rawRoyaltyStake from "./contracts/royalty_pool/stake.ts";
 import * as rawRoutedStake from "./contracts/routed_stake/routed_stake.ts";
+import * as rawParty from "./contracts/miso_party/party.ts";
+import * as rawPartyProfile from "./contracts/party_profile/party_profile.ts";
 
 // Protocol core (BCS codecs remain available; PTB-inaccessible references do not).
 export const composition = withoutUnsafeCalls(rawComposition, ["title", "uid", "uidMut"] as const);
@@ -55,7 +56,6 @@ export const releaseDescription = withoutUnsafeCalls(rawReleaseDescription, ["de
 export * as releaseDspLink from "./contracts/release_dsp_link/release_dsp_link.ts";
 export * as releaseGenre from "./contracts/release_genre/release_genre.ts";
 export * as releaseKind from "./contracts/release_kind/release_kind.ts";
-export const releaseSnapshotBundle = withoutUnsafeCalls(rawReleaseSnapshotBundle, ["snapshotBundle"] as const);
 
 // First-party generic primitives.
 export const royaltyPool = withoutUnsafeCalls(rawRoyaltyPool, ["balance", "_new"] as const);
@@ -64,3 +64,16 @@ export const routedStake = withoutUnsafeCalls(
   rawRoutedStake,
   ["stake", "_new", "register", "unregister", "unstake", "restake"] as const,
 );
+
+// Party core and extensions.
+export const party = withoutUnsafeCalls(rawParty, ["groupMembers", "uid", "uidMut"] as const);
+export * as partyCta from "./contracts/party_cta/party_cta.ts";
+export * as partyGenre from "./contracts/party_genre/party_genre.ts";
+export * as partyMedia from "./contracts/party_media/party_media.ts";
+export * as partyMusic from "./contracts/party_music/party_music.ts";
+export * as partyPlatformLink from "./contracts/party_platform_link/party_platform_link.ts";
+export * as partyProLink from "./contracts/party_pro_link/party_pro_link.ts";
+export const partyProfile = withoutUnsafeCalls(rawPartyProfile, ["profile"] as const);
+export * as partyRoles from "./contracts/party_roles/party_roles.ts";
+export * as partySocial from "./contracts/party_social/party_social.ts";
+export * as partyTags from "./contracts/party_tags/party_tags.ts";

package/src/deployments.ts

@@ -7,7 +7,7 @@ import { normalizeSuiAddress } from "@mysten/sui/utils";
 export type MisoNetwork = "mainnet" | "testnet";
 
 /**
- * Every independently published package owned by this SDK surface.
+ * Every independently published package required by this SDK surface.
  *
  * These names are stable deployment-manifest keys, not Move module names. Their
  * values are never inferred from source labels or a previous publish.
@@ -26,9 +26,22 @@ const CANONICAL_MISO_PACKAGE_NAMES = [
   "releaseDspLink",
   "releaseGenre",
   "releaseKind",
-  "releaseSnapshotBundle",
   "royaltyPool",
   "routedStake",
+  "misoParty",
+  "partyCta",
+  "partyGenre",
+  "partyMedia",
+  "partyMusic",
+  "partyPlatformLink",
+  "partyProLink",
+  "partyProfile",
+  "partyRoles",
+  "partySocial",
+  "partyTags",
+  "countryCode",
+  "languageCode",
+  "genre",
 ] as const;
 
 /** Public immutable copy; validation always uses the private canonical tuple. */
@@ -131,7 +144,9 @@ export function assertMisoDeployment(
   deployment: unknown,
 ): asserts deployment is MisoDeployment {
   if (!deployment || typeof deployment !== "object" || Array.isArray(deployment)) {
-    throw new Error("@misonetwork/sdk: deployment must be an object with exactly the 16 Miso package IDs.");
+    throw new Error(
+      `@misonetwork/sdk: deployment must be an object with exactly ${CANONICAL_MISO_PACKAGE_NAMES.length} Miso package IDs.`,
+    );
   }
   const entries = deployment as Record<string, unknown>;
   const keys = Object.keys(entries);

package/src/events.ts

@@ -20,7 +20,6 @@ import * as releaseDescription from "./contracts/release_description/release_des
 import * as releaseDspLink from "./contracts/release_dsp_link/release_dsp_link.ts";
 import * as releaseGenre from "./contracts/release_genre/release_genre.ts";
 import * as releaseKind from "./contracts/release_kind/release_kind.ts";
-import * as releaseSnapshotBundle from "./contracts/release_snapshot_bundle/release_snapshot_bundle.ts";
 import * as release from "./contracts/miso/release.ts";
 import * as royaltyPool from "./contracts/royalty_pool/pool.ts";
 import * as royaltyStake from "./contracts/royalty_pool/stake.ts";
@@ -105,9 +104,6 @@ export const eventParsers = {
       kindSet: decoder(releaseKind.KindSetEvent),
       kindUnset: decoder(releaseKind.KindUnsetEvent),
     },
-    releaseSnapshotBundle: {
-      bundleSet: decoder(releaseSnapshotBundle.SnapshotBundleSetEvent),
-    },
   },
   primitives: {
     royaltyPool: {

package/src/index.ts

@@ -15,6 +15,8 @@ export * from "./view.ts";
 export * from "./client.ts";
 export * from "./deployments.ts";
 export * from "./packages.ts";
+export * as party from "./party/index.ts";
+export type { PartyProtocolClient } from "./party/client.ts";
 
 // Generated, ABI-bound bindings (BCS structs + type-safe Move calls).
 export * as contracts from "./contracts.ts";

package/src/packages.ts

@@ -31,12 +31,23 @@ import * as releaseDescription from "./contracts/release_description/release_des
 import * as releaseDspLink from "./contracts/release_dsp_link/release_dsp_link.ts";
 import * as releaseGenre from "./contracts/release_genre/release_genre.ts";
 import * as releaseKind from "./contracts/release_kind/release_kind.ts";
-import * as releaseSnapshotBundle from "./contracts/release_snapshot_bundle/release_snapshot_bundle.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";
 
+import * as party from "./contracts/miso_party/party.ts";
+import * as partyCta from "./contracts/party_cta/party_cta.ts";
+import * as partyGenre from "./contracts/party_genre/party_genre.ts";
+import * as partyMedia from "./contracts/party_media/party_media.ts";
+import * as partyMusic from "./contracts/party_music/party_music.ts";
+import * as partyPlatformLink from "./contracts/party_platform_link/party_platform_link.ts";
+import * as partyProLink from "./contracts/party_pro_link/party_pro_link.ts";
+import * as partyProfile from "./contracts/party_profile/party_profile.ts";
+import * as partyRoles from "./contracts/party_roles/party_roles.ts";
+import * as partySocial from "./contracts/party_social/party_social.ts";
+import * as partyTags from "./contracts/party_tags/party_tags.ts";
+
 type BoundMoveFunction<F> = F extends (options: infer Options) => infer Result
   ? Options extends { package?: unknown }
     ? (options: Omit<Options, "package">) => Result
@@ -97,7 +108,6 @@ export const REF_RETURNING_CALLS = {
   releaseCoverArt: ["cover"],
   releaseCredits: ["credits"],
   releaseDescription: ["description"],
-  releaseSnapshotBundle: ["snapshotBundle"],
   // `new` is emitted as `_new`; its `&mut UID` parent credential cannot be
   // constructed by a caller-side PTB, so only authority-package code may use it.
   royaltyPool: ["balance", "_new"],
@@ -106,6 +116,8 @@ export const REF_RETURNING_CALLS = {
   // caller-provided PTB input. Only `share`, `sweep`, scalar reads and derives
   // remain usable at this layer.
   routedStake: ["stake", "_new", "register", "unregister", "unstake", "restake"],
+  party: ["groupMembers", "uid", "uidMut"],
+  partyProfile: ["profile"],
 } as const;
 
 /**
@@ -188,11 +200,6 @@ export class MisoPackageBindings {
         releaseDspLink: bindModulePackage(releaseDspLink, d.releaseDspLink),
         releaseGenre: bindModulePackage(releaseGenre, d.releaseGenre),
         releaseKind: bindModulePackage(releaseKind, d.releaseKind),
-        releaseSnapshotBundle: bindModulePackage(
-          releaseSnapshotBundle,
-          d.releaseSnapshotBundle,
-          REF_RETURNING_CALLS.releaseSnapshotBundle,
-        ),
       },
       primitives: {
         royaltyPool: {
@@ -201,6 +208,19 @@ export class MisoPackageBindings {
         },
         routedStake: bindModulePackage(routedStake, d.routedStake, REF_RETURNING_CALLS.routedStake),
       },
+      party: {
+        core: bindModulePackage(party, d.misoParty, REF_RETURNING_CALLS.party),
+        cta: bindModulePackage(partyCta, d.partyCta),
+        genre: bindModulePackage(partyGenre, d.partyGenre),
+        media: bindModulePackage(partyMedia, d.partyMedia),
+        music: bindModulePackage(partyMusic, d.partyMusic),
+        platformLink: bindModulePackage(partyPlatformLink, d.partyPlatformLink),
+        proLink: bindModulePackage(partyProLink, d.partyProLink),
+        profile: bindModulePackage(partyProfile, d.partyProfile, REF_RETURNING_CALLS.partyProfile),
+        roles: bindModulePackage(partyRoles, d.partyRoles),
+        social: bindModulePackage(partySocial, d.partySocial),
+        tags: bindModulePackage(partyTags, d.partyTags),
+      },
     };
   }
 
@@ -235,12 +255,24 @@ export class MisoPackageBindings {
         releaseDspLink: codecsOnly(releaseDspLink),
         releaseGenre: codecsOnly(releaseGenre),
         releaseKind: codecsOnly(releaseKind),
-        releaseSnapshotBundle: codecsOnly(releaseSnapshotBundle),
       },
       primitives: {
         royaltyPool: { pool: codecsOnly(royaltyPool), stake: codecsOnly(royaltyStake) },
         routedStake: codecsOnly(routedStake),
       },
+      party: {
+        core: codecsOnly(party),
+        cta: codecsOnly(partyCta),
+        genre: codecsOnly(partyGenre),
+        media: codecsOnly(partyMedia),
+        music: codecsOnly(partyMusic),
+        platformLink: codecsOnly(partyPlatformLink),
+        proLink: codecsOnly(partyProLink),
+        profile: codecsOnly(partyProfile),
+        roles: codecsOnly(partyRoles),
+        social: codecsOnly(partySocial),
+        tags: codecsOnly(partyTags),
+      },
     };
   }
 }

package/src/party/client.ts

@@ -0,0 +1,283 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// Party queries and transaction builders bound to the same complete deployment
+// as `MisoProtocolClient`. Consumers reach this through `client.miso.party`.
+
+import type { ClientWithCoreApi } from "@mysten/sui/client";
+import type { MisoDeployment } from "../deployments.ts";
+import type { TxThunk } from "./transactions.ts";
+import * as queries from "./queries.ts";
+import * as transactions from "./transactions.ts";
+import * as profileExt from "./extensions/profile.ts";
+import * as mediaExt from "./extensions/media.ts";
+import * as rolesExt from "./extensions/roles.ts";
+import * as tagsExt from "./extensions/tags.ts";
+import * as genresExt from "./extensions/genres.ts";
+import * as ctasExt from "./extensions/ctas.ts";
+import * as linksExt from "./extensions/links.ts";
+import type { Cta, Media, Party, PlatformKey, PlatformLink, Profile } from "./types.ts";
+import * as partyMod from "../contracts/miso_party/party.ts";
+import * as profileMod from "../contracts/party_profile/party_profile.ts";
+import * as mediaMod from "../contracts/party_media/party_media.ts";
+import * as rolesMod from "../contracts/party_roles/party_roles.ts";
+import * as tagsMod from "../contracts/party_tags/party_tags.ts";
+import * as ctaMod from "../contracts/party_cta/party_cta.ts";
+import * as genreMod from "../contracts/party_genre/party_genre.ts";
+import * as platformLinkMod from "../contracts/party_platform_link/party_platform_link.ts";
+import * as socialMod from "../contracts/party_social/party_social.ts";
+import * as musicMod from "../contracts/party_music/party_music.ts";
+import * as proLinkMod from "../contracts/party_pro_link/party_pro_link.ts";
+
+type BoundMoveFunction<F> = F extends (options: infer Options) => infer Result
+  ? Options extends { package?: unknown }
+    ? (options: Omit<Options, "package">) => Result
+    : F
+  : F;
+type BoundModule<M extends object, Removed extends PropertyKey> = {
+  [Key in Exclude<keyof M, Removed>]: BoundMoveFunction<M[Key]>;
+};
+
+/** Defaults generated calls to one package and removes reference-returning calls. */
+function bindModulePackage<M extends object, K extends readonly (keyof M)[]>(
+  mod: M,
+  pkg: string,
+  unavailable: K = [] as unknown as K,
+): BoundModule<M, K[number]> {
+  const out: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries({ ...mod })) {
+    if ((unavailable as readonly string[]).includes(key)) continue;
+    out[key] =
+      typeof value === "function"
+        ? (options: { package?: string }) => (value as (o: unknown) => unknown)({ package: pkg, ...options })
+        : value;
+  }
+  return out as BoundModule<M, K[number]>;
+}
+
+/** Package-bound Party client exposed at `client.miso.party`. */
+export class PartyProtocolClient {
+  #client: ClientWithCoreApi;
+  #pkg: string;
+  #profilePkg: string;
+  #countryCodePkg: string;
+  #languageCodePkg: string;
+  #mediaPkg: string;
+  #rolesPkg: string;
+  #tagsPkg: string;
+  #partyGenrePkg: string;
+  #ctaPkg: string;
+  #platformLinkPkg: string;
+  #socialPkg: string;
+  #musicPkg: string;
+  #proLinkPkg: string;
+  #genrePkg: string;
+
+  constructor(client: ClientWithCoreApi, o: MisoDeployment) {
+    this.#client = client;
+    this.#pkg = o.misoParty;
+    this.#profilePkg = o.partyProfile;
+    this.#countryCodePkg = o.countryCode;
+    this.#languageCodePkg = o.languageCode;
+    this.#mediaPkg = o.partyMedia;
+    this.#rolesPkg = o.partyRoles;
+    this.#tagsPkg = o.partyTags;
+    this.#partyGenrePkg = o.partyGenre;
+    this.#ctaPkg = o.partyCta;
+    this.#platformLinkPkg = o.partyPlatformLink;
+    this.#socialPkg = o.partySocial;
+    this.#musicPkg = o.partyMusic;
+    this.#proLinkPkg = o.partyProLink;
+    this.#genrePkg = o.genre;
+  }
+
+  /**
+   * The `genre` vocabulary package id. Callers resolve `Genre` objects from it to
+   * pass to `tx.addGenre` (which takes a genre object id, not this package).
+   */
+  get genrePackageId(): string {
+    return this.#genrePkg;
+  }
+
+  // === Queries ===
+
+  async getPartyById(partyId: string): Promise<Party> {
+    return queries.getPartyById(this.#client, partyId);
+  }
+  async getPartiesByIds(
+    partyIds: readonly string[],
+  ): Promise<Partial<Record<string, Party>>> {
+    return queries.getPartiesByIds(this.#client, partyIds);
+  }
+  derivePartyAdminCapId(partyId: string): string {
+    return queries.derivePartyAdminCapId(partyId, this.#pkg);
+  }
+  async getProfile(partyId: string): Promise<Profile | null> {
+    return queries.getProfile(this.#client, partyId, this.#profilePkg);
+  }
+  async getMedia(partyId: string): Promise<Media | null> {
+    return queries.getMedia(this.#client, partyId, this.#mediaPkg);
+  }
+  /** The party's artist-type roles (display names). */
+  async getRoles(partyId: string): Promise<string[]> {
+    return queries.getRoles(this.#client, partyId, this.#rolesPkg);
+  }
+  /** The party's free-form tags. */
+  async getTags(partyId: string): Promise<string[]> {
+    return queries.getTags(this.#client, partyId, this.#tagsPkg);
+  }
+  /** The party's genre object ids. */
+  async getGenres(partyId: string): Promise<string[]> {
+    return queries.getGenres(this.#client, partyId, this.#partyGenrePkg);
+  }
+  /** The party's ordered CTA list (position is priority). */
+  async getCtas(partyId: string): Promise<Cta[]> {
+    return queries.getCtas(this.#client, partyId, this.#ctaPkg);
+  }
+  /** All external-platform links attached to the party (social, music, professional). */
+  async getLinks(partyId: string): Promise<PlatformLink[]> {
+    return queries.getLinks(this.#client, partyId);
+  }
+  /** Group ids a party belongs to (member-side membership records). */
+  async getMemberships(partyId: string): Promise<string[]> {
+    return queries.getMemberships(this.#client, partyId);
+  }
+  /** Member ids invited to a group but not yet accepted. */
+  async getPendingInvites(groupId: string): Promise<string[]> {
+    return queries.getPendingInvites(this.#client, groupId);
+  }
+  /** Group ids that have invited this party but are awaiting its response. */
+  async getPendingMemberships(partyId: string): Promise<string[]> {
+    return queries.getPendingMemberships(this.#client, partyId);
+  }
+  /** Whether a party is a member of a group. */
+  async isMember(memberId: string, groupId: string): Promise<boolean> {
+    return queries.isMember(this.#client, memberId, groupId, this.#pkg);
+  }
+
+  // === Transaction builders (thunks; package ids bound from the client) ===
+
+  get tx() {
+    const pkg = this.#pkg;
+    const profilePkg = this.#profilePkg;
+    const cc = this.#countryCodePkg;
+    const lc = this.#languageCodePkg;
+    const mediaPkg = this.#mediaPkg;
+    const rolesPkg = this.#rolesPkg;
+    const tagsPkg = this.#tagsPkg;
+    const ctaPkg = this.#ctaPkg;
+    const partyGenrePkg = this.#partyGenrePkg;
+    const linkIds: linksExt.LinkPackageIds = {
+      partyPlatformLinkPackageId: this.#platformLinkPkg,
+      partySocialPackageId: this.#socialPkg,
+      partyMusicPackageId: this.#musicPkg,
+      partyProLinkPackageId: this.#proLinkPkg,
+    };
+    return {
+      createIndividualParty: (p: Omit<transactions.CreatePartyParams, "partyPackageId">): TxThunk =>
+        transactions.createIndividualParty({ ...p, partyPackageId: pkg }),
+      createGroupParty: (p: Omit<transactions.CreatePartyParams, "partyPackageId">): TxThunk =>
+        transactions.createGroupParty({ ...p, partyPackageId: pkg }),
+      setName: (p: Omit<transactions.SetNameParams, "partyPackageId">): TxThunk =>
+        transactions.setName({ ...p, partyPackageId: pkg }),
+      inviteParty: (p: Omit<transactions.InvitePartyParams, "partyPackageId">): TxThunk =>
+        transactions.inviteParty({ ...p, partyPackageId: pkg }),
+      acceptInvite: (p: Omit<transactions.AcceptInviteParams, "partyPackageId">): TxThunk =>
+        transactions.acceptInvite({ ...p, partyPackageId: pkg }),
+      declineInvite: (p: Omit<transactions.DeclineInviteParams, "partyPackageId">): TxThunk =>
+        transactions.declineInvite({ ...p, partyPackageId: pkg }),
+      revokeInvite: (p: Omit<transactions.RevokeInviteParams, "partyPackageId">): TxThunk =>
+        transactions.revokeInvite({ ...p, partyPackageId: pkg }),
+      leaveGroup: (p: Omit<transactions.LeaveGroupParams, "partyPackageId">): TxThunk =>
+        transactions.leaveGroup({ ...p, partyPackageId: pkg }),
+      removeMember: (p: Omit<transactions.RemoveMemberParams, "partyPackageId">): TxThunk =>
+        transactions.removeMember({ ...p, partyPackageId: pkg }),
+      setProfile: (
+        p: Omit<profileExt.SetProfileParams, "partyProfilePackageId" | "countryCodePackageId" | "languageCodePackageId">,
+      ): TxThunk =>
+        profileExt.setProfile({
+          ...p,
+          partyProfilePackageId: profilePkg,
+          countryCodePackageId: cc,
+          languageCodePackageId: lc,
+        }),
+      clearProfile: (p: Omit<profileExt.ClearProfileParams, "partyProfilePackageId">): TxThunk =>
+        profileExt.clearProfile({ ...p, partyProfilePackageId: profilePkg }),
+      setMedia: (p: Omit<mediaExt.SetMediaParams, "partyMediaPackageId">): TxThunk =>
+        mediaExt.setMedia({ ...p, partyMediaPackageId: mediaPkg }),
+      clearMedia: (p: Omit<mediaExt.ClearMediaParams, "partyMediaPackageId">): TxThunk =>
+        mediaExt.clearMedia({ ...p, partyMediaPackageId: mediaPkg }),
+      // Roles
+      addRole: (p: Omit<rolesExt.AddRoleParams, "partyRolesPackageId">): TxThunk =>
+        rolesExt.addRole({ ...p, partyRolesPackageId: rolesPkg }),
+      removeRole: (p: Omit<rolesExt.RemoveRoleParams, "partyRolesPackageId">): TxThunk =>
+        rolesExt.removeRole({ ...p, partyRolesPackageId: rolesPkg }),
+      clearRoles: (p: Omit<rolesExt.ClearRolesParams, "partyRolesPackageId">): TxThunk =>
+        rolesExt.clearRoles({ ...p, partyRolesPackageId: rolesPkg }),
+      // Tags
+      addTag: (p: Omit<tagsExt.AddTagParams, "partyTagsPackageId">): TxThunk =>
+        tagsExt.addTag({ ...p, partyTagsPackageId: tagsPkg }),
+      removeTag: (p: Omit<tagsExt.RemoveTagParams, "partyTagsPackageId">): TxThunk =>
+        tagsExt.removeTag({ ...p, partyTagsPackageId: tagsPkg }),
+      clearTags: (p: Omit<tagsExt.ClearTagsParams, "partyTagsPackageId">): TxThunk =>
+        tagsExt.clearTags({ ...p, partyTagsPackageId: tagsPkg }),
+      // Genres
+      addGenre: (p: Omit<genresExt.AddGenreParams, "partyGenrePackageId">): TxThunk =>
+        genresExt.addGenre({ ...p, partyGenrePackageId: partyGenrePkg }),
+      removeGenre: (p: Omit<genresExt.RemoveGenreParams, "partyGenrePackageId">): TxThunk =>
+        genresExt.removeGenre({ ...p, partyGenrePackageId: partyGenrePkg }),
+      clearGenres: (p: Omit<genresExt.ClearGenresParams, "partyGenrePackageId">): TxThunk =>
+        genresExt.clearGenres({ ...p, partyGenrePackageId: partyGenrePkg }),
+      // CTAs
+      setCtas: (p: Omit<ctasExt.SetCtasParams, "partyCtaPackageId">): TxThunk =>
+        ctasExt.setCtas({ ...p, partyCtaPackageId: ctaPkg }),
+      clearCtas: (p: Omit<ctasExt.ClearCtasParams, "partyCtaPackageId">): TxThunk =>
+        ctasExt.clearCtas({ ...p, partyCtaPackageId: ctaPkg }),
+      // Platform links — generic (any platform) plus per-platform `set…`/`clear…`.
+      setLink: (platform: PlatformKey, p: linksExt.BoundSetLinkParams): TxThunk =>
+        linksExt.setLink(platform, { ...p, ...linkIds }),
+      clearLink: (platform: PlatformKey, p: linksExt.BoundClearLinkParams): TxThunk =>
+        linksExt.clearLink(platform, { ...p, ...linkIds }),
+      ...linksExt.linkTxBuilders(linkIds),
+    };
+  }
+
+  // === Generated type-safe Move calls (for tx.add) ===
+
+  get call() {
+    return {
+      party: bindModulePackage(partyMod, this.#pkg, ["groupMembers", "uid", "uidMut"] as const),
+      profile: bindModulePackage(profileMod, this.#profilePkg, ["profile"] as const),
+      media: bindModulePackage(mediaMod, this.#mediaPkg),
+      roles: bindModulePackage(rolesMod, this.#rolesPkg),
+      tags: bindModulePackage(tagsMod, this.#tagsPkg),
+      cta: bindModulePackage(ctaMod, this.#ctaPkg),
+      genre: bindModulePackage(genreMod, this.#partyGenrePkg),
+      platformLink: bindModulePackage(platformLinkMod, this.#platformLinkPkg),
+      social: bindModulePackage(socialMod, this.#socialPkg),
+      music: bindModulePackage(musicMod, this.#musicPkg),
+      proLink: bindModulePackage(proLinkMod, this.#proLinkPkg),
+    };
+  }
+
+  // === Generated BCS structs (for parsing object/event content) ===
+
+  get bcs() {
+    return {
+      Party: partyMod.Party,
+      PartyAdminCap: partyMod.PartyAdminCap,
+      Profile: profileMod.Profile,
+      ProfileSetEvent: profileMod.ProfileSetEvent,
+      Media: mediaMod.Media,
+      MediaSetEvent: mediaMod.MediaSetEvent,
+      ArtistRole: rolesMod.ArtistRole,
+      RoleAddedEvent: rolesMod.RoleAddedEvent,
+      TagAddedEvent: tagsMod.TagAddedEvent,
+      Cta: ctaMod.Cta,
+      CtasSetEvent: ctaMod.CtasSetEvent,
+      GenreAddedEvent: genreMod.GenreAddedEvent,
+      LinkSetEvent: platformLinkMod.LinkSetEvent,
+      LinkClearedEvent: platformLinkMod.LinkClearedEvent,
+    };
+  }
+}

package/src/party/extensions/ctas.ts

@@ -0,0 +1,46 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// The `party_cta` extension: a party's ordered call-to-action list (Tickets,
+// Merch, Newsletter, …). Each CTA is a `{ label, url }`; the whole list is written
+// at once (position is priority). The builder constructs each `Cta` via `new_cta`
+// and passes the vector to `set_ctas`.
+
+import * as ctaMod from "../../contracts/party_cta/party_cta.ts";
+import type { TxThunk } from "../transactions.ts";
+import type { Cta } from "../types.ts";
+
+export interface SetCtasParams {
+  partyId: string;
+  capId: string;
+  /** The ordered CTA list — position is priority. */
+  ctas: Cta[];
+  partyCtaPackageId: string;
+}
+
+/** Sets (or replaces) the party's ordered CTA list. */
+export function setCtas(params: SetCtasParams): TxThunk {
+  return (tx) => {
+    const ctaType = `${params.partyCtaPackageId}::party_cta::Cta`;
+    const ctas = tx.makeMoveVec({
+      type: ctaType,
+      elements: params.ctas.map((c) =>
+        tx.add(ctaMod.newCta({ package: params.partyCtaPackageId, arguments: [c.label, c.url] })),
+      ),
+    });
+    tx.add(ctaMod.setCtas({ package: params.partyCtaPackageId, arguments: [params.partyId, params.capId, ctas] }));
+  };
+}
+
+export interface ClearCtasParams {
+  partyId: string;
+  capId: string;
+  partyCtaPackageId: string;
+}
+
+/** Removes the party's CTA list. No-op on-chain if none is set. */
+export function clearCtas(params: ClearCtasParams): TxThunk {
+  return (tx) => {
+    tx.add(ctaMod.clearCtas({ package: params.partyCtaPackageId, arguments: [params.partyId, params.capId] }));
+  };
+}