@misofm/platform 0.23.0 → 0.25.0

package/src/contracts/composition_royalty_pool_plugin/composition_royalty_pool_plugin.ts

@@ -0,0 +1,165 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/** Vault adapter for Composition royalty-pool Actions. */
+
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+import { normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+export interface InstallArguments {
+    vault: RawTransactionArgument<string>;
+    vaultAdminCap: RawTransactionArgument<string>;
+}
+export interface InstallOptions {
+    package?: string;
+    arguments: InstallArguments | [
+        vault: RawTransactionArgument<string>,
+        vaultAdminCap: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export function install(options: InstallOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_royalty_pool_plugin';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault", "vaultAdminCap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_royalty_pool_plugin',
+        function: 'install',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface UninstallArguments {
+    vault: RawTransactionArgument<string>;
+    vaultAdminCap: RawTransactionArgument<string>;
+}
+export interface UninstallOptions {
+    package?: string;
+    arguments: UninstallArguments | [
+        vault: RawTransactionArgument<string>,
+        vaultAdminCap: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export function uninstall(options: UninstallOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_royalty_pool_plugin';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault", "vaultAdminCap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_royalty_pool_plugin',
+        function: 'uninstall',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface IsInstalledArguments {
+    vault: RawTransactionArgument<string>;
+}
+export interface IsInstalledOptions {
+    package?: string;
+    arguments: IsInstalledArguments | [
+        vault: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export function isInstalled(options: IsInstalledOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_royalty_pool_plugin';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_royalty_pool_plugin',
+        function: 'is_installed',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface ReceiveAndDepositArguments {
+    vault: RawTransactionArgument<string>;
+    composition: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    coins: TransactionArgument;
+}
+export interface ReceiveAndDepositOptions {
+    package?: string;
+    arguments: ReceiveAndDepositArguments | [
+        vault: RawTransactionArgument<string>,
+        composition: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        coins: TransactionArgument
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export function receiveAndDeposit(options: ReceiveAndDepositOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_royalty_pool_plugin';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'vector<null>'
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault", "composition", "pool", "coins"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_royalty_pool_plugin',
+        function: 'receive_and_deposit',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface RedeemAndDepositArguments {
+    vault: RawTransactionArgument<string>;
+    composition: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    value: RawTransactionArgument<number | bigint>;
+}
+export interface RedeemAndDepositOptions {
+    package?: string;
+    arguments: RedeemAndDepositArguments | [
+        vault: RawTransactionArgument<string>,
+        composition: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        value: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export function redeemAndDeposit(options: RedeemAndDepositOptions) {
+    const packageAddress = options.package ?? '@local-pkg/composition_royalty_pool_plugin';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'u64'
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault", "composition", "pool", "value"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'composition_royalty_pool_plugin',
+        function: 'redeem_and_deposit',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}

package/src/contracts/composition_royalty_pool_plugin/witness.ts

@@ -0,0 +1,8 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveTuple } from '../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
+const $moduleName = '@local-pkg/composition_royalty_pool_plugin::witness';
+export const Witness = new MoveTuple({ name: `${$moduleName}::Witness`, fields: [bcs.bool()] });

package/src/contracts/cover_art/cover_art.ts

@@ -0,0 +1,98 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * The evolvable cover art value used by the recording/release cover art
+ * extensions.
+ *
+ * CoverArt format changes over time (static-only → +animated → future formats).
+ * Keeping it in an extension rather than immutable core means a new format is a
+ * republish of this small package (or a brand-new cover art standard), not of the
+ * frozen protocol. `CoverArt` references external storage via
+ * `ori::data::WalrusBlob`.
+ */
+
+import { MoveStruct, normalizeMoveArguments } from '../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+import * as data from './deps/ori/data.ts';
+const $moduleName = '@local-pkg/cover_art::cover_art';
+export const CoverArt = new MoveStruct({ name: `${$moduleName}::CoverArt`, fields: {
+        still: data.WalrusBlob,
+        animated: bcs.option(data.WalrusBlob)
+    } });
+export interface NewArguments {
+    still: TransactionArgument;
+    animated: TransactionArgument;
+}
+export interface NewOptions {
+    package?: string;
+    arguments: NewArguments | [
+        still: TransactionArgument,
+        animated: TransactionArgument
+    ];
+}
+/** Creates cover art with a still image and optional animated version. */
+export function _new(options: NewOptions) {
+    const packageAddress = options.package ?? '@local-pkg/cover_art';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["still", "animated"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'cover_art',
+        function: 'new',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface StillArguments {
+    self: TransactionArgument;
+}
+export interface StillOptions {
+    package?: string;
+    arguments: StillArguments | [
+        self: TransactionArgument
+    ];
+}
+/** Returns a reference to the still image data. */
+export function still(options: StillOptions) {
+    const packageAddress = options.package ?? '@local-pkg/cover_art';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'cover_art',
+        function: 'still',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface AnimatedArguments {
+    self: TransactionArgument;
+}
+export interface AnimatedOptions {
+    package?: string;
+    arguments: AnimatedArguments | [
+        self: TransactionArgument
+    ];
+}
+/** Returns a reference to the optional animated cover art data. */
+export function animated(options: AnimatedOptions) {
+    const packageAddress = options.package ?? '@local-pkg/cover_art';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'cover_art',
+        function: 'animated',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/src/contracts/cover_art/deps/ori/confidentiality.ts

@@ -0,0 +1,24 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveEnum, MoveStruct } from '../../../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
+const $moduleName = 'ori::confidentiality';
+/**
+ * Confidentiality metadata for referenced data.
+ *
+ * Variants can only be constructed in this module, so encrypted values always
+ * carry a non-empty Seal-sealed data-encryption key.
+ */
+export const Confidentiality = new MoveEnum({ name: `${$moduleName}::Confidentiality`, fields: {
+        /** The referenced data is stored in the clear. */
+        Unencrypted: null,
+        /**
+         * The referenced data is encrypted. `sealed_dek` is its Seal-sealed
+         * data-encryption key, not the plaintext key.
+         */
+        Encrypted: new MoveStruct({ name: `Confidentiality.Encrypted`, fields: {
+                sealed_dek: bcs.vector(bcs.u8())
+            } })
+    } });

package/src/contracts/cover_art/deps/ori/data.ts

@@ -0,0 +1,12 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct } from '../../../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
+import * as confidentiality from './confidentiality.ts';
+const $moduleName = 'ori::data';
+export const WalrusBlob = new MoveStruct({ name: `${$moduleName}::WalrusBlob`, fields: {
+        blob_id: bcs.u256(),
+        confidentiality: confidentiality.Confidentiality
+    } });

package/src/contracts/genre/genre.ts

@@ -0,0 +1,121 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * Genre vocabulary for Miso — a canonical, deduplicated set of `Genre` objects.
+ *
+ * Genre is a classification, not protocol-verifiable state, so it lives in an
+ * extension rather than core. This module owns the **vocabulary**: `Genre` objects
+ * are created permissionlessly and derived by canonical name, so the set stays
+ * deduplicated and canonical (no "hip-hop" vs "Hip Hop" forks).
+ *
+ * Genre _assignment_ — classifying a release and its individual tracks — lives in
+ * the `release_genre` module. How a recording is presented and classified is a
+ * property of the release (the consumer object), not of the recording's objective
+ * sound data, so nothing here touches `Recording`.
+ */
+
+import { MoveStruct, MoveTuple, normalizeMoveArguments, type RawTransactionArgument } from '../utils/index.ts';
+import { bcs } from '@mysten/sui/bcs';
+import type {} from "@mysten/bcs";
+import { type Transaction } from '@mysten/sui/transactions';
+const $moduleName = '@local-pkg/genre::genre';
+export const GenreRegistry = new MoveStruct({ name: `${$moduleName}::GenreRegistry`, fields: {
+        id: bcs.Address
+    } });
+export const Genre = new MoveStruct({ name: `${$moduleName}::Genre`, fields: {
+        id: bcs.Address,
+        /** Canonical genre name (e.g. "HIP_HOP"). */
+        name: bcs.string()
+    } });
+export const GenreKey = new MoveTuple({ name: `${$moduleName}::GenreKey`, fields: [bcs.string()] });
+export const GenreCreatedEvent = new MoveStruct({ name: `${$moduleName}::GenreCreatedEvent`, fields: {
+        genre_id: bcs.Address,
+        name: bcs.string()
+    } });
+export interface NewArguments {
+    registry: RawTransactionArgument<string>;
+    name: RawTransactionArgument<string>;
+}
+export interface NewOptions {
+    package?: string;
+    arguments: NewArguments | [
+        registry: RawTransactionArgument<string>,
+        name: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Creates a genre in the canonical vocabulary. Creation is permissionless; the
+ * validated canonical name fully determines the derived object, so caller identity
+ * cannot change its id or contents. Creating the same name twice aborts (dedup is
+ * automatic). The `Genre` is frozen — immutable and globally readable by
+ * reference.
+ */
+export function _new(options: NewOptions) {
+    const packageAddress = options.package ?? '@local-pkg/genre';
+    const argumentsTypes = [
+        null,
+        '0x1::string::String'
+    ] satisfies (string | null)[];
+    const parameterNames = ["registry", "name"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'genre',
+        function: 'new',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface DeriveAddressArguments {
+    self: RawTransactionArgument<string>;
+    name: RawTransactionArgument<string>;
+}
+export interface DeriveAddressOptions {
+    package?: string;
+    arguments: DeriveAddressArguments | [
+        self: RawTransactionArgument<string>,
+        name: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Derives the address a `Genre` with the given name would have, without creating
+ * it. Lets clients resolve/check a genre address offline.
+ */
+export function deriveAddress(options: DeriveAddressOptions) {
+    const packageAddress = options.package ?? '@local-pkg/genre';
+    const argumentsTypes = [
+        null,
+        '0x1::string::String'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "name"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'genre',
+        function: 'derive_address',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface NameArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface NameOptions {
+    package?: string;
+    arguments: NameArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/** Returns the genre's canonical name. */
+export function name(options: NameOptions) {
+    const packageAddress = options.package ?? '@local-pkg/genre';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'genre',
+        function: 'name',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/src/contracts/party_cta/party_cta.ts

@@ -0,0 +1,213 @@
+/**************************************************************
+ * 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 {} from "@mysten/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),
+    });
+}