@misonetwork/sdk 0.1.0

package/src/contracts/miso/track.ts

@@ -0,0 +1,153 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * Represents a track on a release, linking a recording to its position in the
+ * tracklist.
+ * 
+ * A `Track` is the minimal positioned (recording, revenue-share) pair:
+ * 
+ * - `recording_id` — the routing target for the track's revenue, and the handle
+ *   through which all other metadata (title, cover art, and the
+ *   recording/composition share-type identities) is reached.
+ * - `split_bps` — this track's share of the release's revenue; genuinely
+ *   release-specific and not derivable from the recording.
+ * - `state` — the assign-once lifecycle that carries (then sheds) each deal's
+ *   target release commitment; see `TrackState`.
+ * 
+ * `Track` is intentionally monomorphic: a `Release` holds a `vector<Track>` of
+ * tracks from many different recordings/compositions, so it cannot be generic over
+ * their share types. It stores no title, cover art, or share-type — all derived
+ * from the recording via `recording_id`.
+ */
+
+import { MoveEnum, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+import * as bps from './deps/bps/bps.js';
+const $moduleName = '@local-pkg/miso::track';
+/**
+ * Lifecycle state of a track within a release. A track is born `Unassigned`,
+ * carrying the target `release_id` its originating `Deal` committed to (the
+ * release id is a digest of the whole tracklist, so this is the recording owner's
+ * consent to the exact release configuration). At publish the release verifies the
+ * match and transitions the track to `Assigned`, which carries no id — shedding
+ * the 32-byte commitment once it has served its purpose.
+ */
+export const TrackState = new MoveEnum({ name: `${$moduleName}::TrackState`, fields: {
+        /**
+          * Track has been created but not yet assigned to a release. Carries the target
+          * release id the originating deal committed to.
+          */
+        Unassigned: bcs.Address,
+        /** Track has been assigned to its target release. */
+        Assigned: null
+    } });
+export const Track = new MoveStruct({ name: `${$moduleName}::Track`, fields: {
+        /** Current state of the track. */
+        state: TrackState,
+        /**
+         * ID of the recording on this track. The routing target for the track's revenue;
+         * also the handle a consumer uses to fetch the recording (whose type carries the
+         * recording and composition share-type identities).
+         */
+        recording_id: bcs.Address,
+        /**
+         * This track's share of the release's revenue, in basis points. All tracks in a
+         * release sum to 100%. The composition's cut is settled as recording-share
+         * ownership at recording creation, so it is not split out here — a track routes
+         * its full share to the recording.
+         */
+        split_bps: bps.BPS
+    } });
+export interface NewArguments {
+    deal: RawTransactionArgument<string>;
+    recording: RawTransactionArgument<string>;
+}
+export interface NewOptions {
+    package?: string;
+    arguments: NewArguments | [
+        deal: RawTransactionArgument<string>,
+        recording: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Creates a new track by accepting a deal. The deal is the authorization — created
+ * by the recording's admin, carrying the target release and the agreed split.
+ * Emits a `DealAcceptedEvent`.
+ *
+ * The deal's `RecordingShare`/`CompositionShare` phantoms are erased here: a
+ * `Track` is monomorphic so it can live in a release's heterogeneous
+ * `vector<Track>`. Identity rides on those phantoms up to this point, but the
+ * monomorphic `Track` must store the recording's _address_ for revenue routing —
+ * and an address can't come from a phantom. So the matching `Recording` is passed
+ * in (the deal's phantoms force it to be the right one) purely to read its id; the
+ * deal no longer stores it.
+ */
+export function _new(options: NewOptions) {
+    const packageAddress = options.package ?? '@local-pkg/miso';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["deal", "recording"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'track',
+        function: 'new',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface RecordingIdArguments {
+    self: TransactionArgument;
+}
+export interface RecordingIdOptions {
+    package?: string;
+    arguments: RecordingIdArguments | [
+        self: TransactionArgument
+    ];
+}
+/** Returns the ID of the recording. */
+export function recordingId(options: RecordingIdOptions) {
+    const packageAddress = options.package ?? '@local-pkg/miso';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'track',
+        function: 'recording_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface SplitBpsArguments {
+    self: TransactionArgument;
+}
+export interface SplitBpsOptions {
+    package?: string;
+    arguments: SplitBpsArguments | [
+        self: TransactionArgument
+    ];
+}
+/** Returns this track's share of the release's revenue (in basis points). */
+export function splitBps(options: SplitBpsOptions) {
+    const packageAddress = options.package ?? '@local-pkg/miso';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'track',
+        function: 'split_bps',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/src/contracts/recording_credits/deps/miso_credit/credit.ts

@@ -0,0 +1,27 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * Represents a party's credit on a work or activity. A credit pairs a display name
+ * with one or more roles, identifying how a party contributed to the work.
+ */
+
+import { type BcsType, bcs } from '@mysten/sui/bcs';
+import { MoveStruct } from '../../../utils/index.js';
+const $moduleName = 'miso_credit::credit';
+/**
+ * A credit attributing roles to a party on a work. Generic over the role type to
+ * support domain-specific roles.
+ */
+export function Credit<Role extends BcsType<any>>(...typeParameters: [
+    Role
+]) {
+    return new MoveStruct({ name: `${$moduleName}::Credit<${typeParameters[0].name as Role['name']}>`, fields: {
+            /** Human-readable name to display for this credit. */
+            display_name: bcs.string(),
+            /** Roles assigned to the credited party. */
+            roles: bcs.vector(typeParameters[0])
+        } });
+}

package/src/contracts/recording_credits/deps/sui/vec_map.ts

@@ -0,0 +1,33 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type BcsType, bcs } from '@mysten/sui/bcs';
+import { MoveStruct } from '../../../utils/index.js';
+const $moduleName = '0x2::vec_map';
+/** An entry in the map */
+export function Entry<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [
+    K,
+    V
+]) {
+    return new MoveStruct({ name: `${$moduleName}::Entry<${typeParameters[0].name as K['name']}, ${typeParameters[1].name as V['name']}>`, fields: {
+            key: typeParameters[0],
+            value: typeParameters[1]
+        } });
+}
+/**
+ * A map data structure backed by a vector. The map is guaranteed not to contain
+ * duplicate keys, but entries are _not_ sorted by key--entries are included in
+ * insertion order. All operations are O(N) in the size of the map--the intention
+ * of this data structure is only to provide the convenience of programming against
+ * a map API. Large maps should use handwritten parent/child relationships instead.
+ * Maps that need sorted iteration rather than insertion order iteration should
+ * also be handwritten.
+ */
+export function VecMap<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [
+    K,
+    V
+]) {
+    return new MoveStruct({ name: `${$moduleName}::VecMap<${typeParameters[0].name as K['name']}, ${typeParameters[1].name as V['name']}>`, fields: {
+            contents: bcs.vector(Entry(typeParameters[0], typeParameters[1]))
+        } });
+}

package/src/contracts/recording_credits/deps/sui/vec_set.ts

@@ -0,0 +1,21 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type BcsType, bcs } from '@mysten/sui/bcs';
+import { MoveStruct } from '../../../utils/index.js';
+const $moduleName = '0x2::vec_set';
+/**
+ * A set data structure backed by a vector. The set is guaranteed not to contain
+ * duplicate keys. All operations are O(N) in the size of the set
+ *
+ * - the intention of this data structure is only to provide the convenience of
+ *   programming against a set API. Sets that need sorted iteration rather than
+ *   insertion order iteration should be handwritten.
+ */
+export function VecSet<K extends BcsType<any>>(...typeParameters: [
+    K
+]) {
+    return new MoveStruct({ name: `${$moduleName}::VecSet<${typeParameters[0].name as K['name']}>`, fields: {
+            contents: bcs.vector(typeParameters[0])
+        } });
+}

package/src/contracts/recording_credits/recording_credits.ts

@@ -0,0 +1,458 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * First-party credits extension for recordings.
+ * 
+ * Attribution (credits + primary/featured artists) is display-oriented and varies
+ * across platforms, so it lives here as a dynamic field on the recording rather
+ * than in immutable core. The data is attached under `ExtensionKey()` via the
+ * recording's cap-gated `uid_mut`, so every mutation is authorized by the
+ * recording's admin and credits survive into any lifecycle state (they may be
+ * attached before or after the recording is published).
+ * 
+ * This is Miso's canonical credits standard; because it is an extension, other
+ * parties may publish their own recording-credits standard against the same
+ * `Recording`. Credits are NOT read by the economics — they are attribution.
+ */
+
+import { MoveTuple, MoveStruct, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+import * as vec_map from './deps/sui/vec_map.js';
+import * as credit from './deps/miso_credit/credit.js';
+import * as recording_party_role from './recording_party_role.js';
+import * as vec_set from './deps/sui/vec_set.js';
+const $moduleName = '@local-pkg/recording_credits::recording_credits';
+export const ExtensionKey = new MoveTuple({ name: `${$moduleName}::ExtensionKey`, fields: [bcs.bool()] });
+export const RecordingCredits = new MoveStruct({ name: `${$moduleName}::RecordingCredits`, fields: {
+        /** Map of party IDs to their credit (display name + roles). */
+        credits: vec_map.VecMap(bcs.Address, credit.Credit(recording_party_role.RecordingPartyRole)),
+        /** IDs of the primary artists. Always a subset of `credits`. */
+        primary_artist_ids: vec_set.VecSet(bcs.Address),
+        /** IDs of the featured artists. Always a subset of `credits`. */
+        featured_artist_ids: vec_set.VecSet(bcs.Address)
+    } });
+export const CreditAddedEvent = new MoveStruct({ name: `${$moduleName}::CreditAddedEvent`, fields: {
+        recording_id: bcs.Address,
+        party_id: bcs.Address,
+        credit: credit.Credit(recording_party_role.RecordingPartyRole)
+    } });
+export const CreditRemovedEvent = new MoveStruct({ name: `${$moduleName}::CreditRemovedEvent`, fields: {
+        recording_id: bcs.Address,
+        party_id: bcs.Address,
+        credit: credit.Credit(recording_party_role.RecordingPartyRole)
+    } });
+export const PrimaryArtistAddedEvent = new MoveStruct({ name: `${$moduleName}::PrimaryArtistAddedEvent`, fields: {
+        recording_id: bcs.Address,
+        party_id: bcs.Address
+    } });
+export const PrimaryArtistRemovedEvent = new MoveStruct({ name: `${$moduleName}::PrimaryArtistRemovedEvent`, fields: {
+        recording_id: bcs.Address,
+        party_id: bcs.Address
+    } });
+export const FeaturedArtistAddedEvent = new MoveStruct({ name: `${$moduleName}::FeaturedArtistAddedEvent`, fields: {
+        recording_id: bcs.Address,
+        party_id: bcs.Address
+    } });
+export const FeaturedArtistRemovedEvent = new MoveStruct({ name: `${$moduleName}::FeaturedArtistRemovedEvent`, fields: {
+        recording_id: bcs.Address,
+        party_id: bcs.Address
+    } });
+export interface AddCreditArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    party: RawTransactionArgument<string>;
+    credit: TransactionArgument;
+}
+export interface AddCreditOptions {
+    package?: string;
+    arguments: AddCreditArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        party: RawTransactionArgument<string>,
+        credit: TransactionArgument
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Adds a credit for a party on the recording, lazily creating the credits record
+ * on first use. Each credit must have 1-10 roles, and a party may hold at most one
+ * credit. Requires the recording's admin capability.
+ */
+export function addCredit(options: AddCreditOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "party", "credit"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_credits',
+        function: 'add_credit',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface RemoveCreditArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    partyId: RawTransactionArgument<string>;
+}
+export interface RemoveCreditOptions {
+    package?: string;
+    arguments: RemoveCreditArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        partyId: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Removes a party's credit. Also drops them from the primary/featured sets,
+ * preserving the invariant that those are subsets of the credited parties.
+ * Requires the recording's admin capability.
+ */
+export function removeCredit(options: RemoveCreditOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "partyId"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_credits',
+        function: 'remove_credit',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface AddPrimaryArtistArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    party: RawTransactionArgument<string>;
+}
+export interface AddPrimaryArtistOptions {
+    package?: string;
+    arguments: AddPrimaryArtistArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        party: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Designates an already-credited party as a primary artist. The party must be
+ * credited and not already a primary or featured artist.
+ */
+export function addPrimaryArtist(options: AddPrimaryArtistOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null,
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "party"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_credits',
+        function: 'add_primary_artist',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface RemovePrimaryArtistArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    partyId: RawTransactionArgument<string>;
+}
+export interface RemovePrimaryArtistOptions {
+    package?: string;
+    arguments: RemovePrimaryArtistArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        partyId: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Removes a party from the primary-artist set (leaves the credit intact). */
+export function removePrimaryArtist(options: RemovePrimaryArtistOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "partyId"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_credits',
+        function: 'remove_primary_artist',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface AddFeaturedArtistArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    party: RawTransactionArgument<string>;
+}
+export interface AddFeaturedArtistOptions {
+    package?: string;
+    arguments: AddFeaturedArtistArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        party: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Designates an already-credited party as a featured artist. The party must be
+ * credited and not already a primary or featured artist.
+ */
+export function addFeaturedArtist(options: AddFeaturedArtistOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null,
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "party"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_credits',
+        function: 'add_featured_artist',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface RemoveFeaturedArtistArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    partyId: RawTransactionArgument<string>;
+}
+export interface RemoveFeaturedArtistOptions {
+    package?: string;
+    arguments: RemoveFeaturedArtistArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        partyId: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Removes a party from the featured-artist set (leaves the credit intact). */
+export function removeFeaturedArtist(options: RemoveFeaturedArtistOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "partyId"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_credits',
+        function: 'remove_featured_artist',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface HasCreditsArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface HasCreditsOptions {
+    package?: string;
+    arguments: HasCreditsArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Returns whether a credits record has been attached to this recording yet. */
+export function hasCredits(options: HasCreditsOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_credits',
+        function: 'has_credits',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface CreditsArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface CreditsOptions {
+    package?: string;
+    arguments: CreditsArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Returns the party-to-credit map. Aborts if no credits are attached. */
+export function credits(options: CreditsOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_credits',
+        function: 'credits',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface PrimaryArtistIdsArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface PrimaryArtistIdsOptions {
+    package?: string;
+    arguments: PrimaryArtistIdsArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Returns the primary-artist IDs. Aborts if no credits are attached. */
+export function primaryArtistIds(options: PrimaryArtistIdsOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_credits',
+        function: 'primary_artist_ids',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface FeaturedArtistIdsArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface FeaturedArtistIdsOptions {
+    package?: string;
+    arguments: FeaturedArtistIdsArguments | [
+        self: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Returns the featured-artist IDs. Aborts if no credits are attached. */
+export function featuredArtistIds(options: FeaturedArtistIdsOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_credits',
+        function: 'featured_artist_ids',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface IsPrimaryArtistArguments {
+    self: RawTransactionArgument<string>;
+    partyId: RawTransactionArgument<string>;
+}
+export interface IsPrimaryArtistOptions {
+    package?: string;
+    arguments: IsPrimaryArtistArguments | [
+        self: RawTransactionArgument<string>,
+        partyId: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Returns whether the party is a primary artist (false if no credits attached). */
+export function isPrimaryArtist(options: IsPrimaryArtistOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "partyId"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_credits',
+        function: 'is_primary_artist',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface IsFeaturedArtistArguments {
+    self: RawTransactionArgument<string>;
+    partyId: RawTransactionArgument<string>;
+}
+export interface IsFeaturedArtistOptions {
+    package?: string;
+    arguments: IsFeaturedArtistArguments | [
+        self: RawTransactionArgument<string>,
+        partyId: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Returns whether the party is a featured artist (false if no credits attached). */
+export function isFeaturedArtist(options: IsFeaturedArtistOptions) {
+    const packageAddress = options.package ?? '@local-pkg/recording_credits';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "partyId"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'recording_credits',
+        function: 'is_featured_artist',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}