@misonetwork/sdk 0.8.0 → 0.9.0

package/src/party/extensions/genres.ts

@@ -0,0 +1,62 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// The `party_genre` extension: a set of `genre::Genre` object ids tagged on a
+// party. `add_genre` takes a `&Genre` vocabulary object (proving the id is a real
+// entry), so the builder passes `tx.object(genreId)`; removal is by id.
+
+import * as genreMod from "../../contracts/party_genre/party_genre.ts";
+import type { TxThunk } from "../transactions.ts";
+
+export interface AddGenreParams {
+  partyId: string;
+  capId: string;
+  /** The `genre::Genre` vocabulary object id to tag. */
+  genreId: string;
+  partyGenrePackageId: string;
+}
+
+/** Tags a genre on the party. Aborts on-chain if already present or the max is reached. */
+export function addGenre(params: AddGenreParams): TxThunk {
+  return (tx) => {
+    tx.add(
+      genreMod.addGenre({
+        package: params.partyGenrePackageId,
+        arguments: [params.partyId, params.capId, tx.object(params.genreId)],
+      }),
+    );
+  };
+}
+
+export interface RemoveGenreParams {
+  partyId: string;
+  capId: string;
+  /** The genre id to untag. */
+  genreId: string;
+  partyGenrePackageId: string;
+}
+
+/** Untags a genre from the party. Aborts on-chain if not present. */
+export function removeGenre(params: RemoveGenreParams): TxThunk {
+  return (tx) => {
+    tx.add(
+      genreMod.removeGenre({
+        package: params.partyGenrePackageId,
+        arguments: [params.partyId, params.capId, params.genreId],
+      }),
+    );
+  };
+}
+
+export interface ClearGenresParams {
+  partyId: string;
+  capId: string;
+  partyGenrePackageId: string;
+}
+
+/** Removes the party's entire genre set. No-op on-chain if none is set. */
+export function clearGenres(params: ClearGenresParams): TxThunk {
+  return (tx) => {
+    tx.add(genreMod.clearGenres({ package: params.partyGenrePackageId, arguments: [params.partyId, params.capId] }));
+  };
+}

package/src/party/extensions/links.ts

@@ -0,0 +1,185 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// The platform-link facade: attaches one independent `PlatformLink<Data>` per
+// platform to a party via `party_platform_link`. The payload `Data` types live in
+// their own packages (`party_social`, `party_music`, `party_pro_link`); this file
+// drives all ~27 platforms from a single table (`PLATFORMS`) rather than 27×
+// copy-paste. Each setter builds the link via the platform's constructor move-call
+// (returning a `PlatformLink<…Data>`), then calls `set_link` with the matching
+// `Data` type argument; clearers call `clear_link` with the same type argument.
+// Only the native identifier is stored on-chain; the public URL is rebuilt from it.
+
+import * as platformLinkMod from "../../contracts/party_platform_link/party_platform_link.ts";
+import type { TxThunk } from "../transactions.ts";
+import type { PlatformKey, PlatformLink } from "../types.ts";
+
+/** Which payload package a platform's `Data` type + constructor live in. */
+type PayloadPkgKind = "social" | "music" | "pro";
+
+/** Everything needed to build, store, and rebuild one platform's link. */
+export interface PlatformSpec {
+  key: PlatformKey;
+  /** Payload package the `Data` type + constructor live in. */
+  pkgKind: PayloadPkgKind;
+  /** Move module holding the constructor + `Data` type. */
+  module: "party_social" | "party_music" | "party_pro_link";
+  /** Constructor function (snake_case) — takes a single `String`, returns `PlatformLink<Data>`. */
+  ctor: string;
+  /** The `Data` type name (e.g. `InstagramData`). */
+  dataType: string;
+  /** Rebuilds the public URL from the stored native identifier. */
+  url: (value: string) => string;
+}
+
+/**
+ * Every platform this SDK can link, keyed by `PlatformKey`. The single source of
+ * truth: setters, clearers, and the read-side URL/type mapping all derive from it.
+ */
+export const PLATFORMS: Record<PlatformKey, PlatformSpec> = {
+  // === Social (party_social) ===
+  x: { key: "x", pkgKind: "social", module: "party_social", ctor: "x", dataType: "XData", url: (v) => `https://x.com/${v}` },
+  instagram: { key: "instagram", pkgKind: "social", module: "party_social", ctor: "instagram", dataType: "InstagramData", url: (v) => `https://instagram.com/${v}` },
+  threads: { key: "threads", pkgKind: "social", module: "party_social", ctor: "threads", dataType: "ThreadsData", url: (v) => `https://www.threads.net/@${v}` },
+  tiktok: { key: "tiktok", pkgKind: "social", module: "party_social", ctor: "tiktok", dataType: "TikTokData", url: (v) => `https://www.tiktok.com/@${v}` },
+  youtube: { key: "youtube", pkgKind: "social", module: "party_social", ctor: "youtube", dataType: "YouTubeData", url: (v) => `https://youtube.com/@${v}` },
+  discord: { key: "discord", pkgKind: "social", module: "party_social", ctor: "discord", dataType: "DiscordData", url: (v) => `https://discord.gg/${v}` },
+  telegram: { key: "telegram", pkgKind: "social", module: "party_social", ctor: "telegram", dataType: "TelegramData", url: (v) => `https://t.me/${v}` },
+  reddit: { key: "reddit", pkgKind: "social", module: "party_social", ctor: "reddit", dataType: "RedditData", url: (v) => `https://reddit.com/user/${v}` },
+  twitch: { key: "twitch", pkgKind: "social", module: "party_social", ctor: "twitch", dataType: "TwitchData", url: (v) => `https://twitch.tv/${v}` },
+  facebook: { key: "facebook", pkgKind: "social", module: "party_social", ctor: "facebook", dataType: "FacebookData", url: (v) => `https://facebook.com/${v}` },
+  // === Music (party_music) ===
+  spotify: { key: "spotify", pkgKind: "music", module: "party_music", ctor: "spotify", dataType: "SpotifyData", url: (v) => `https://open.spotify.com/artist/${v}` },
+  bandcamp: { key: "bandcamp", pkgKind: "music", module: "party_music", ctor: "bandcamp", dataType: "BandcampData", url: (v) => `https://${v}.bandcamp.com` },
+  soundcloud: { key: "soundcloud", pkgKind: "music", module: "party_music", ctor: "soundcloud", dataType: "SoundCloudData", url: (v) => `https://soundcloud.com/${v}` },
+  appleMusic: { key: "appleMusic", pkgKind: "music", module: "party_music", ctor: "apple_music", dataType: "AppleMusicData", url: (v) => `https://music.apple.com/artist/${v}` },
+  deezer: { key: "deezer", pkgKind: "music", module: "party_music", ctor: "deezer", dataType: "DeezerData", url: (v) => `https://www.deezer.com/artist/${v}` },
+  tidal: { key: "tidal", pkgKind: "music", module: "party_music", ctor: "tidal", dataType: "TidalData", url: (v) => `https://tidal.com/artist/${v}` },
+  amazonMusic: { key: "amazonMusic", pkgKind: "music", module: "party_music", ctor: "amazon_music", dataType: "AmazonMusicData", url: (v) => `https://music.amazon.com/artists/${v}` },
+  audiomack: { key: "audiomack", pkgKind: "music", module: "party_music", ctor: "audiomack", dataType: "AudiomackData", url: (v) => `https://audiomack.com/${v}` },
+  // === Professional / industry (party_pro_link). URL-based payloads store a full URL. ===
+  website: { key: "website", pkgKind: "pro", module: "party_pro_link", ctor: "website", dataType: "WebsiteData", url: (v) => v },
+  bookingPage: { key: "bookingPage", pkgKind: "pro", module: "party_pro_link", ctor: "booking_page", dataType: "BookingPageData", url: (v) => v },
+  managementPage: { key: "managementPage", pkgKind: "pro", module: "party_pro_link", ctor: "management_page", dataType: "ManagementPageData", url: (v) => v },
+  publisherPage: { key: "publisherPage", pkgKind: "pro", module: "party_pro_link", ctor: "publisher_page", dataType: "PublisherPageData", url: (v) => v },
+  labelPage: { key: "labelPage", pkgKind: "pro", module: "party_pro_link", ctor: "label_page", dataType: "LabelPageData", url: (v) => v },
+  epk: { key: "epk", pkgKind: "pro", module: "party_pro_link", ctor: "epk", dataType: "EpkData", url: (v) => v },
+  patreon: { key: "patreon", pkgKind: "pro", module: "party_pro_link", ctor: "patreon", dataType: "PatreonData", url: (v) => `https://patreon.com/${v}` },
+  substack: { key: "substack", pkgKind: "pro", module: "party_pro_link", ctor: "substack", dataType: "SubstackData", url: (v) => `https://${v}.substack.com` },
+  kofi: { key: "kofi", pkgKind: "pro", module: "party_pro_link", ctor: "kofi", dataType: "KofiData", url: (v) => `https://ko-fi.com/${v}` },
+};
+
+/** All platform keys, in table order. */
+export const PLATFORM_KEYS = Object.keys(PLATFORMS) as PlatformKey[];
+
+/** The package ids the platform-link facade binds (the facade + the three payload packages). */
+export interface LinkPackageIds {
+  partyPlatformLinkPackageId: string;
+  partySocialPackageId: string;
+  partyMusicPackageId: string;
+  partyProLinkPackageId: string;
+}
+
+function payloadPackageId(spec: PlatformSpec, ids: LinkPackageIds): string {
+  switch (spec.pkgKind) {
+    case "social":
+      return ids.partySocialPackageId;
+    case "music":
+      return ids.partyMusicPackageId;
+    case "pro":
+      return ids.partyProLinkPackageId;
+  }
+}
+
+/** The fully-qualified Move `Data` type for a platform (e.g. `0x…::party_social::InstagramData`). */
+function dataTypeArg(spec: PlatformSpec, ids: LinkPackageIds): string {
+  return `${payloadPackageId(spec, ids)}::${spec.module}::${spec.dataType}`;
+}
+
+export interface SetLinkParams extends LinkPackageIds {
+  partyId: string;
+  capId: string;
+  /** The platform-native identifier to store (handle / id / subdomain / full URL). */
+  value: string;
+}
+
+/** Sets (or replaces) a platform's link on the party. */
+export function setLink(platform: PlatformKey, params: SetLinkParams): TxThunk {
+  return (tx) => {
+    const spec = PLATFORMS[platform];
+    const pkg = payloadPackageId(spec, params);
+    const link = tx.moveCall({
+      target: `${pkg}::${spec.module}::${spec.ctor}`,
+      arguments: [tx.pure.string(params.value)],
+    });
+    tx.add(
+      platformLinkMod.setLink({
+        package: params.partyPlatformLinkPackageId,
+        typeArguments: [dataTypeArg(spec, params)],
+        arguments: [params.partyId, params.capId, link],
+      }),
+    );
+  };
+}
+
+export interface ClearLinkParams extends LinkPackageIds {
+  partyId: string;
+  capId: string;
+}
+
+/** Clears a platform's link from the party. No-op on-chain if unset. */
+export function clearLink(platform: PlatformKey, params: ClearLinkParams): TxThunk {
+  return (tx) => {
+    const spec = PLATFORMS[platform];
+    tx.add(
+      platformLinkMod.clearLink({
+        package: params.partyPlatformLinkPackageId,
+        typeArguments: [dataTypeArg(spec, params)],
+        arguments: [params.partyId, params.capId],
+      }),
+    );
+  };
+}
+
+// === Read helpers ===
+
+// The Move `Data` type suffix (`<module>::<dataType>`) → platform key. The package
+// id prefix varies, so match on the last two `::` segments (unique across the table).
+const BY_MOVE_TYPE: Record<string, PlatformKey> = Object.fromEntries(
+  PLATFORM_KEYS.map((k) => [`${PLATFORMS[k].module}::${PLATFORMS[k].dataType}`, k]),
+) as Record<string, PlatformKey>;
+
+/**
+ * The platform for a fully-qualified `Data` type argument, or null if unknown.
+ * @param dataType e.g. `0x…::party_social::InstagramData`.
+ */
+export function platformForDataType(dataType: string): PlatformKey | null {
+  const suffix = dataType.split("::").slice(-2).join("::");
+  return BY_MOVE_TYPE[suffix] ?? null;
+}
+
+/** Builds a public `PlatformLink` from a platform key and its stored native identifier. */
+export function buildLink(platform: PlatformKey, value: string): PlatformLink {
+  return { platform, value, url: PLATFORMS[platform].url(value) };
+}
+
+// === Bound builders (the client binds package ids, then exposes per-platform methods) ===
+
+export type BoundSetLinkParams = Omit<SetLinkParams, keyof LinkPackageIds>;
+export type BoundClearLinkParams = Omit<ClearLinkParams, keyof LinkPackageIds>;
+
+/** Per-platform `setX` / `clearX` builders, keyed off the table so all ~27 are covered. */
+export type LinkTxBuilders =
+  & { [K in PlatformKey as `set${Capitalize<K>}`]: (p: BoundSetLinkParams) => TxThunk }
+  & { [K in PlatformKey as `clear${Capitalize<K>}`]: (p: BoundClearLinkParams) => TxThunk };
+
+/** Builds the per-platform link tx builders with `ids` pre-bound. */
+export function linkTxBuilders(ids: LinkPackageIds): LinkTxBuilders {
+  const out: Record<string, unknown> = {};
+  for (const key of PLATFORM_KEYS) {
+    const cap = key.charAt(0).toUpperCase() + key.slice(1);
+    out[`set${cap}`] = (p: BoundSetLinkParams): TxThunk => setLink(key, { ...p, ...ids });
+    out[`clear${cap}`] = (p: BoundClearLinkParams): TxThunk => clearLink(key, { ...p, ...ids });
+  }
+  return out as LinkTxBuilders;
+}

package/src/party/extensions/media.ts

@@ -0,0 +1,72 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// The `party_media` extension: a party's imagery, stored on-chain as a single
+// Walrus *quilt* id. Individual images are quilt patches addressed by identifier
+// ("avatar", "header", …) — those roles are a client convention, derived here
+// off-chain, never stored on-chain. The write builder takes the quilt's base64url
+// blob id (what `walrus store-quilt` prints) and converts it to the on-chain
+// u256; the read helpers build aggregator URLs per identifier.
+
+import { b64UrlToU256 } from "../internal.ts";
+import * as mediaMod from "../../contracts/party_media/party_media.ts";
+import type { TxThunk } from "../transactions.ts";
+import type { Media } from "../types.ts";
+
+/**
+ * Quilt patch identifiers party media uses, in role order. Uploaders store images
+ * under these identifiers; readers fetch by them. This is the whole "meaning" the
+ * chain defers to the client.
+ */
+export const MEDIA_IDENTIFIERS = { avatar: "avatar", header: "header" } as const;
+export type MediaIdentifier = (typeof MEDIA_IDENTIFIERS)[keyof typeof MEDIA_IDENTIFIERS];
+
+export interface SetMediaParams {
+  partyId: string;
+  capId: string;
+  /** Walrus quilt blob id (base64url), e.g. from `walrus store-quilt`. */
+  quiltId: string;
+  partyMediaPackageId: string;
+}
+
+/** Sets (or replaces) the party's media quilt. */
+export function setMedia(params: SetMediaParams): TxThunk {
+  return (tx) => {
+    tx.add(
+      mediaMod.setMedia({
+        package: params.partyMediaPackageId,
+        arguments: [params.partyId, params.capId, BigInt(b64UrlToU256(params.quiltId))],
+      }),
+    );
+  };
+}
+
+export interface ClearMediaParams {
+  partyId: string;
+  capId: string;
+  partyMediaPackageId: string;
+}
+
+/** Removes the party's media entirely. No-op on-chain if none is set. */
+export function clearMedia(params: ClearMediaParams): TxThunk {
+  return (tx) => {
+    tx.add(mediaMod.clearMedia({ package: params.partyMediaPackageId, arguments: [params.partyId, params.capId] }));
+  };
+}
+
+/** Aggregator URL for one image in a party's quilt, addressed by identifier. */
+export function mediaImageUrl(aggregatorUrl: string, quiltId: string, identifier: string): string {
+  return `${aggregatorUrl.replace(/\/$/, "")}/v1/blobs/by-quilt-id/${quiltId}/${identifier}`;
+}
+
+/** The avatar + header image URLs for a party's media, or null if unset. */
+export function mediaUrls(
+  aggregatorUrl: string,
+  media: Media | null,
+): { avatar: string; header: string } | null {
+  if (!media) return null;
+  return {
+    avatar: mediaImageUrl(aggregatorUrl, media.quiltId, MEDIA_IDENTIFIERS.avatar),
+    header: mediaImageUrl(aggregatorUrl, media.quiltId, MEDIA_IDENTIFIERS.header),
+  };
+}

package/src/party/extensions/profile.ts

@@ -0,0 +1,81 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// The `party_profile` extension: an editable identity card attached to a Party.
+// The builders hide the Option/vector plumbing and construct the validated
+// `CountryCode` / `LanguageCode` values from raw ISO codes.
+
+import * as profileMod from "../../contracts/party_profile/party_profile.ts";
+import type { TxThunk } from "../transactions.ts";
+
+const OPTION_NONE = "0x1::option::none";
+const OPTION_SOME = "0x1::option::some";
+
+export interface SetProfileParams {
+  partyId: string;
+  capId: string;
+  bioShort: string;
+  bioLong?: string;
+  /** ISO 3166-1 alpha-2 country code, e.g. "GB". */
+  country?: string;
+  /** ISO 639-1 language codes, e.g. ["en", "ja"]. */
+  languages?: string[];
+  partyProfilePackageId: string;
+  countryCodePackageId: string;
+  languageCodePackageId: string;
+}
+
+/** Sets (creates or replaces) a party's whole profile. */
+export function setProfile(params: SetProfileParams): TxThunk {
+  return (tx) => {
+    const ccType = `${params.countryCodePackageId}::country_code::CountryCode`;
+    const country = params.country
+      ? tx.moveCall({
+          target: OPTION_SOME,
+          typeArguments: [ccType],
+          arguments: [
+            tx.moveCall({
+              target: `${params.countryCodePackageId}::country_code::new`,
+              arguments: [tx.pure.string(params.country)],
+            }),
+          ],
+        })
+      : tx.moveCall({ target: OPTION_NONE, typeArguments: [ccType], arguments: [] });
+
+    const lcType = `${params.languageCodePackageId}::language_code::LanguageCode`;
+    const languages = tx.makeMoveVec({
+      type: lcType,
+      elements: (params.languages ?? []).map((code) =>
+        tx.moveCall({
+          target: `${params.languageCodePackageId}::language_code::new`,
+          arguments: [tx.pure.string(code)],
+        }),
+      ),
+    });
+
+    tx.add(
+      profileMod.setProfile({
+        package: params.partyProfilePackageId,
+        arguments: [params.partyId, params.capId, params.bioShort, params.bioLong ?? null, country, languages],
+      }),
+    );
+  };
+}
+
+export interface ClearProfileParams {
+  partyId: string;
+  capId: string;
+  partyProfilePackageId: string;
+}
+
+/** Removes a party's profile. No-op on-chain if none is set. */
+export function clearProfile(params: ClearProfileParams): TxThunk {
+  return (tx) => {
+    tx.add(
+      profileMod.clearProfile({
+        package: params.partyProfilePackageId,
+        arguments: [params.partyId, params.capId],
+      }),
+    );
+  };
+}

package/src/party/extensions/roles.ts

@@ -0,0 +1,94 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// The `party_roles` extension: the artist-type roles a party holds (artist,
+// producer, DJ, …), a `VecSet<ArtistRole>` on the party. Roles are a closed enum
+// with a `Custom(String)` escape hatch; the builders construct the right
+// `ArtistRole` value via its constructor move-call, then add/remove it.
+
+import * as rolesMod from "../../contracts/party_roles/party_roles.ts";
+import type { TxThunk } from "../transactions.ts";
+
+/** The canonical role variants (a fixed, typo-free set the frontend can render). */
+export type CanonicalRole =
+  | "artist"
+  | "producer"
+  | "dj"
+  | "composer"
+  | "songwriter"
+  | "band"
+  | "label"
+  | "collective";
+
+/**
+ * A role to add/remove: a canonical variant, or a user-defined `custom` name.
+ * Prefer a canonical variant when one fits.
+ */
+export type Role = { kind: CanonicalRole } | { kind: "custom"; name: string };
+
+// Canonical `kind` → the generated constructor function name (all take no args).
+const CANONICAL_CTORS = {
+  artist: rolesMod.artist,
+  producer: rolesMod.producer,
+  dj: rolesMod.dj,
+  composer: rolesMod.composer,
+  songwriter: rolesMod.songwriter,
+  band: rolesMod.band,
+  label: rolesMod.label,
+  collective: rolesMod.collective,
+} as const;
+
+/** Builds the `ArtistRole` value for a role via its constructor move-call. */
+function buildRole(tx: Parameters<TxThunk>[0], role: Role, pkg: string) {
+  if (role.kind === "custom") {
+    return tx.add(rolesMod.custom({ package: pkg, arguments: [role.name] }));
+  }
+  return tx.add(CANONICAL_CTORS[role.kind]({ package: pkg }));
+}
+
+export interface AddRoleParams {
+  partyId: string;
+  capId: string;
+  role: Role;
+  partyRolesPackageId: string;
+}
+
+/** Adds a role to the party. Aborts on-chain if already held or the max is reached. */
+export function addRole(params: AddRoleParams): TxThunk {
+  return (tx) => {
+    const role = buildRole(tx, params.role, params.partyRolesPackageId);
+    tx.add(
+      rolesMod.addRole({ package: params.partyRolesPackageId, arguments: [params.partyId, params.capId, role] }),
+    );
+  };
+}
+
+export interface RemoveRoleParams {
+  partyId: string;
+  capId: string;
+  role: Role;
+  partyRolesPackageId: string;
+}
+
+/** Removes a role from the party. Aborts on-chain if not held. */
+export function removeRole(params: RemoveRoleParams): TxThunk {
+  return (tx) => {
+    const role = buildRole(tx, params.role, params.partyRolesPackageId);
+    tx.add(
+      rolesMod.removeRole({ package: params.partyRolesPackageId, arguments: [params.partyId, params.capId, role] }),
+    );
+  };
+}
+
+export interface ClearRolesParams {
+  partyId: string;
+  capId: string;
+  partyRolesPackageId: string;
+}
+
+/** Removes the party's entire role set. No-op on-chain if none is set. */
+export function clearRoles(params: ClearRolesParams): TxThunk {
+  return (tx) => {
+    tx.add(rolesMod.clearRoles({ package: params.partyRolesPackageId, arguments: [params.partyId, params.capId] }));
+  };
+}

package/src/party/extensions/tags.ts

@@ -0,0 +1,54 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// The `party_tags` extension: free-form descriptor tags on a party, a
+// `VecSet<String>`. Tags are stored exactly as given; normalization is a client
+// concern.
+
+import * as tagsMod from "../../contracts/party_tags/party_tags.ts";
+import type { TxThunk } from "../transactions.ts";
+
+export interface AddTagParams {
+  partyId: string;
+  capId: string;
+  tag: string;
+  partyTagsPackageId: string;
+}
+
+/** Adds a tag to the party. Aborts on-chain if empty, too long, duplicate, or the max is reached. */
+export function addTag(params: AddTagParams): TxThunk {
+  return (tx) => {
+    tx.add(
+      tagsMod.addTag({ package: params.partyTagsPackageId, arguments: [params.partyId, params.capId, params.tag] }),
+    );
+  };
+}
+
+export interface RemoveTagParams {
+  partyId: string;
+  capId: string;
+  tag: string;
+  partyTagsPackageId: string;
+}
+
+/** Removes a tag from the party. Aborts on-chain if not present. */
+export function removeTag(params: RemoveTagParams): TxThunk {
+  return (tx) => {
+    tx.add(
+      tagsMod.removeTag({ package: params.partyTagsPackageId, arguments: [params.partyId, params.capId, params.tag] }),
+    );
+  };
+}
+
+export interface ClearTagsParams {
+  partyId: string;
+  capId: string;
+  partyTagsPackageId: string;
+}
+
+/** Removes the party's entire tag set. No-op on-chain if none is set. */
+export function clearTags(params: ClearTagsParams): TxThunk {
+  return (tx) => {
+    tx.add(tagsMod.clearTags({ package: params.partyTagsPackageId, arguments: [params.partyId, params.capId] }));
+  };
+}

package/src/party/index.ts

@@ -0,0 +1,14 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+export * from "./types.ts";
+export * from "./transactions.ts";
+export * from "./queries.ts";
+export * from "./client.ts";
+export * from "./extensions/profile.ts";
+export * from "./extensions/media.ts";
+export * from "./extensions/roles.ts";
+export * from "./extensions/tags.ts";
+export * from "./extensions/genres.ts";
+export * from "./extensions/ctas.ts";
+export * from "./extensions/links.ts";