@misonetwork/sdk 0.8.0 → 0.9.1

package/src/contracts/party_cta/party_cta.ts

@@ -0,0 +1,212 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * Off-Miso call-to-action links for a party — the "what do you want people to do"
+ * row (Tickets, Merch, Newsletter, external Listen, …).
+ *
+ * Deliberately slim: a CTA is just a `{ label, url }`. On-Miso actions (collect /
+ * listen-on-Miso / pin) are a different, interactive concern and live in
+ * `party_featured`, which references object ids and can render live state — so
+ * this package stays a plain, dependency-light external link hub.
+ *
+ * The CTAs are an ordered list: **position is priority**. The whole list is
+ * written at once (`set_ctas`) — the natural fit for a drag-to-reorder editor that
+ * saves on submit — so there are no per-entry ids to track. Gated by the
+ * `PartyAdminCap`; views are permissionless.
+ */
+
+import { MoveTuple, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+const $moduleName = '@local-pkg/party_cta::party_cta';
+export const CtasKey = new MoveTuple({ name: `${$moduleName}::CtasKey`, fields: [bcs.bool()] });
+export const Cta = new MoveStruct({ name: `${$moduleName}::Cta`, fields: {
+        label: bcs.string(),
+        url: bcs.string()
+    } });
+export const CtasSetEvent = new MoveStruct({ name: `${$moduleName}::CtasSetEvent`, fields: {
+        party_id: bcs.Address,
+        count: bcs.u64()
+    } });
+export const CtasClearedEvent = new MoveStruct({ name: `${$moduleName}::CtasClearedEvent`, fields: {
+        party_id: bcs.Address
+    } });
+export interface NewCtaArguments {
+    label: RawTransactionArgument<string>;
+    url: RawTransactionArgument<string>;
+}
+export interface NewCtaOptions {
+    package?: string;
+    arguments: NewCtaArguments | [
+        label: RawTransactionArgument<string>,
+        url: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Builds a CTA. Aborts if the label or url is empty or too long. Callers build the
+ * ordered `vector<Cta>` client-side and submit it with `set_ctas`.
+ */
+export function newCta(options: NewCtaOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_cta';
+    const argumentsTypes = [
+        '0x1::string::String',
+        '0x1::string::String'
+    ] satisfies (string | null)[];
+    const parameterNames = ["label", "url"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_cta',
+        function: 'new_cta',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface LabelArguments {
+    self: TransactionArgument;
+}
+export interface LabelOptions {
+    package?: string;
+    arguments: LabelArguments | [
+        self: TransactionArgument
+    ];
+}
+/** The CTA's display label. */
+export function label(options: LabelOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_cta';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_cta',
+        function: 'label',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface UrlArguments {
+    self: TransactionArgument;
+}
+export interface UrlOptions {
+    package?: string;
+    arguments: UrlArguments | [
+        self: TransactionArgument
+    ];
+}
+/** The CTA's destination url. */
+export function url(options: UrlOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_cta';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_cta',
+        function: 'url',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface SetCtasArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    ctas: TransactionArgument;
+}
+export interface SetCtasOptions {
+    package?: string;
+    arguments: SetCtasArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        ctas: TransactionArgument
+    ];
+}
+/** Sets (or replaces) the party's ordered CTA list. Position is priority. */
+export function setCtas(options: SetCtasOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_cta';
+    const argumentsTypes = [
+        null,
+        null,
+        'vector<null>'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "ctas"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_cta',
+        function: 'set_ctas',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface ClearCtasArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+}
+export interface ClearCtasOptions {
+    package?: string;
+    arguments: ClearCtasArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>
+    ];
+}
+/** Removes the party's CTA list. No-op if none is set. */
+export function clearCtas(options: ClearCtasOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_cta';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_cta',
+        function: 'clear_ctas',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface HasCtasArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface HasCtasOptions {
+    package?: string;
+    arguments: HasCtasArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/** Whether the party has a CTA list. */
+export function hasCtas(options: HasCtasOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_cta';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_cta',
+        function: 'has_ctas',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface CtasArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface CtasOptions {
+    package?: string;
+    arguments: CtasArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/** The party's ordered CTA list (empty if unset). */
+export function ctas(options: CtasOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_cta';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_cta',
+        function: 'ctas',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/src/contracts/party_genre/party_genre.ts

@@ -0,0 +1,199 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * Musical-genre tags for a party, piggybacking the Miso genre vocabulary.
+ *
+ * Stores a set of `genre::Genre` object ids — the same canonical, name-derived
+ * genres the shared vocabulary primitive mints, so a party's genres reference
+ * exactly the ids releases (and anything else) use. Adding a genre takes a
+ * `&Genre`, proving the id is a real vocabulary entry; removal is by id. Genre is
+ * presentation, not protocol-verifiable state, so a party's genres are a
+ * lightweight display tag list — no primary/secondary ranking, no anti-churn
+ * locks. The set mechanics — storage, duplicate and capacity checks, field
+ * reclamation — live in the shared `typed_set` primitive; this package keeps the
+ * vocabulary proof, the capacity, and the typed events. Duplicate / not-present /
+ * over-max aborts come from `typed_set` with its own error codes. All writes are
+ * gated by the `PartyAdminCap`; views are permissionless.
+ */
+
+import { MoveTuple, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction } from '@mysten/sui/transactions';
+const $moduleName = '@local-pkg/party_genre::party_genre';
+export const GenresKey = new MoveTuple({ name: `${$moduleName}::GenresKey`, fields: [bcs.bool()] });
+export const GenreAddedEvent = new MoveStruct({ name: `${$moduleName}::GenreAddedEvent`, fields: {
+        party_id: bcs.Address,
+        genre_id: bcs.Address
+    } });
+export const GenreRemovedEvent = new MoveStruct({ name: `${$moduleName}::GenreRemovedEvent`, fields: {
+        party_id: bcs.Address,
+        genre_id: bcs.Address
+    } });
+export const GenresClearedEvent = new MoveStruct({ name: `${$moduleName}::GenresClearedEvent`, fields: {
+        party_id: bcs.Address
+    } });
+export interface AddGenreArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    genre: RawTransactionArgument<string>;
+}
+export interface AddGenreOptions {
+    package?: string;
+    arguments: AddGenreArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        genre: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Adds a genre to the party. Takes `&Genre` so only a real vocabulary entry can be
+ * tagged. Aborts in `typed_set` if already present or the max is reached.
+ */
+export function addGenre(options: AddGenreOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_genre';
+    const argumentsTypes = [
+        null,
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "genre"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_genre',
+        function: 'add_genre',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface RemoveGenreArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    genreId: RawTransactionArgument<string>;
+}
+export interface RemoveGenreOptions {
+    package?: string;
+    arguments: RemoveGenreArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        genreId: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Removes a genre from the party. Aborts in `typed_set` if not present. The whole
+ * field is dropped when the last genre leaves.
+ */
+export function removeGenre(options: RemoveGenreOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_genre';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "genreId"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_genre',
+        function: 'remove_genre',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface ClearGenresArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+}
+export interface ClearGenresOptions {
+    package?: string;
+    arguments: ClearGenresArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>
+    ];
+}
+/** Removes the party's entire genre set. No-op if none is set. */
+export function clearGenres(options: ClearGenresOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_genre';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_genre',
+        function: 'clear_genres',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface HasGenresArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface HasGenresOptions {
+    package?: string;
+    arguments: HasGenresArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/** Whether the party carries any genres. */
+export function hasGenres(options: HasGenresOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_genre';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_genre',
+        function: 'has_genres',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface HasGenreArguments {
+    self: RawTransactionArgument<string>;
+    genreId: RawTransactionArgument<string>;
+}
+export interface HasGenreOptions {
+    package?: string;
+    arguments: HasGenreArguments | [
+        self: RawTransactionArgument<string>,
+        genreId: RawTransactionArgument<string>
+    ];
+}
+/** Whether the party carries the given genre. */
+export function hasGenre(options: HasGenreOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_genre';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "genreId"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_genre',
+        function: 'has_genre',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface GenresArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface GenresOptions {
+    package?: string;
+    arguments: GenresArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/** The party's genre ids. */
+export function genres(options: GenresOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_genre';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_genre',
+        function: 'genres',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/src/contracts/party_media/party_media.ts

@@ -0,0 +1,141 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * Profile imagery for a party, stored as a single Walrus quilt.
+ *
+ * All of a party's images (avatar, header/cover, …) live together in one Walrus
+ * quilt — batching them under a single storage reservation is markedly cheaper
+ * than one blob each, which matters when the platform sponsors storage. Only the
+ * quilt's blob id is held on-chain, as a `Media` dynamic field on the party's UID,
+ * gated by the `PartyAdminCap`; views are permissionless.
+ *
+ * The chain is deliberately role-agnostic: which patch is the avatar vs the header
+ * is a client convention (quilt patch _identifiers_, e.g. "avatar" / "header"),
+ * derived off-chain — never stored here. Updating any image means re-storing the
+ * quilt and calling `set_media` with the new id.
+ */
+
+import { MoveTuple, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction } from '@mysten/sui/transactions';
+const $moduleName = '@local-pkg/party_media::party_media';
+export const MediaKey = new MoveTuple({ name: `${$moduleName}::MediaKey`, fields: [bcs.bool()] });
+export const Media = new MoveStruct({ name: `${$moduleName}::Media`, fields: {
+        /**
+           * Walrus quilt blob id holding all of the party's images. Individual images are
+           * quilt patches addressed by identifier ("avatar", "header", …); those roles are a
+           * client convention, derived off-chain, not stored here.
+           */
+        quilt: bcs.u256()
+    } });
+export const MediaSetEvent = new MoveStruct({ name: `${$moduleName}::MediaSetEvent`, fields: {
+        party_id: bcs.Address,
+        quilt: bcs.u256()
+    } });
+export const MediaClearedEvent = new MoveStruct({ name: `${$moduleName}::MediaClearedEvent`, fields: {
+        party_id: bcs.Address
+    } });
+export interface SetMediaArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    quilt: RawTransactionArgument<number | bigint>;
+}
+export interface SetMediaOptions {
+    package?: string;
+    arguments: SetMediaArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        quilt: RawTransactionArgument<number | bigint>
+    ];
+}
+/** Sets (or replaces) the party's media quilt. Aborts on a zero id. */
+export function setMedia(options: SetMediaOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_media';
+    const argumentsTypes = [
+        null,
+        null,
+        'u256'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "quilt"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_media',
+        function: 'set_media',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface ClearMediaArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+}
+export interface ClearMediaOptions {
+    package?: string;
+    arguments: ClearMediaArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>
+    ];
+}
+/** Removes the party's media. No-op if none is set. */
+export function clearMedia(options: ClearMediaOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_media';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_media',
+        function: 'clear_media',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface HasMediaArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface HasMediaOptions {
+    package?: string;
+    arguments: HasMediaArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/** Whether the party has media set. */
+export function hasMedia(options: HasMediaOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_media';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_media',
+        function: 'has_media',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface QuiltArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface QuiltOptions {
+    package?: string;
+    arguments: QuiltArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/** The party's media quilt id, if set. */
+export function quilt(options: QuiltOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_media';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_media',
+        function: 'quilt',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}