@misofm/platform 0.24.0 → 0.25.0

package/src/contracts/release_genre/release_genre.ts

@@ -0,0 +1,203 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * The genre(s) a musicos `Release` is classified under, stored as a dynamic field
+ * on the release's UID and written through its cap-gated `uid_mut`.
+ *
+ * Genre is intrinsic to a recording — a fact about the master, not about any one
+ * product it appears on — so a recording's own genre lives in the sibling package
+ * `recording_genre`, on the recording itself. This package carries the different
+ * claim: what a release, as a released product, is classified as. A compilation
+ * can be "Jazz" on the shelf even when half its tracks are Blues or Funk on their
+ * own terms; that classification belongs to nobody but the release, and no amount
+ * of inspecting its recordings derives it. The intended read order for a track's
+ * genre is the recording's own (`recording_genre`), falling back to this release's
+ * primary when the recording has none — the release is the product-level default,
+ * not a per-track override, because a `Recording` carries no back-reference to any
+ * release and one recording can appear on many.
+ *
+ * Its own package, for the same reason genre is separated from every other release
+ * fact: it is set by different people, at different times, under a vocabulary (the
+ * shared `genre` registry) that evolves on its own schedule. A consumer building a
+ * metadata profile picks this extension up or ignores it, and revising it never
+ * disturbs anything else the release carries.
+ *
+ * Genres are kept as one ordered list, primary first, rather than a primary field
+ * plus a separate secondary set. A release either has a primary genre or it has no
+ * genre assignment at all — there is no state where secondaries exist without a
+ * primary, or where the primary and a secondary are the same entry needing to be
+ * kept disjoint — so the two structures collapse to one without losing anything
+ * the list needs to say. Reordering — including promoting an existing entry to
+ * primary — is `clear_genres` followed by `add_genre` in the desired order,
+ * atomically within one programmable transaction block. That is preferable to a
+ * dedicated set-primary function: one fewer function to review and keep in sync
+ * with `recording_genre`, no conditional-capacity branch (insert-new-at-front vs.
+ * move-existing-to- front), and the client expresses its intended final order
+ * directly instead of encoding it as a sequence of promotions. Order beyond index
+ * 0 is the caller's, in the same convention `recording_language` uses for its
+ * language vector: first is authoritative, the rest are unranked.
+ *
+ * The stored value is a bare `vector<ID>` under the package's own key, with no
+ * wrapper struct — the same shape `party_genre` uses for its `VecSet<ID>` and
+ * `recording_language` for its `vector<LanguageCode>`. The list is non-empty by
+ * construction: `remove_genre` drops the field the moment the last entry leaves,
+ * so "the field exists" and "there is a primary" are the same fact and no reader
+ * has to handle an attached-but-empty case. Every write takes `&Genre`, so only an
+ * id that the shared vocabulary actually minted can ever enter the list; removal
+ * takes a bare `ID` because nothing about proving membership is needed to take an
+ * entry back out.
+ *
+ * This module exposes no function derivable by composing the others. This package
+ * is never upgraded — every publish is a fresh identity at a fresh address — so
+ * every public function is permanent surface: once live, it must be carried,
+ * re-published, and re-audited for as long as the package is in use. A predicate
+ * or accessor a caller can compute from `genres()` earns nothing by also living
+ * on-chain. Concretely: emptiness is `genres(release).is_empty()`, and the primary
+ * is `genres(release)[0]` (valid whenever the vector is non-empty, by the
+ * non-empty-by-construction invariant above).
+ */
+
+import { MoveTuple, MoveStruct, 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/release_genre::release_genre';
+export const ExtensionKey = new MoveTuple({ name: `${$moduleName}::ExtensionKey`, fields: [bcs.bool()] });
+export const GenreAddedEvent = new MoveStruct({ name: `${$moduleName}::GenreAddedEvent`, fields: {
+        release_id: bcs.Address,
+        genre_id: bcs.Address
+    } });
+export const GenreRemovedEvent = new MoveStruct({ name: `${$moduleName}::GenreRemovedEvent`, fields: {
+        release_id: bcs.Address,
+        genre_id: bcs.Address
+    } });
+export const GenresClearedEvent = new MoveStruct({ name: `${$moduleName}::GenresClearedEvent`, fields: {
+        release_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>
+    ];
+}
+/**
+ * Appends a genre to the release's list. Creates the field on first use, in which
+ * case that genre becomes the primary by being the only entry. Aborts
+ * `EDuplicateGenre` if the genre is already present, `EMaxGenres` if the release
+ * is already at capacity.
+ */
+export function addGenre(options: AddGenreOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_genre';
+    const argumentsTypes = [
+        null,
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "genre"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_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 release by id. If it was the primary, the next entry
+ * (if any) becomes primary by virtue of now sitting at index 0. Removing the last
+ * genre drops the field entirely and additionally emits `GenresClearedEvent`.
+ * Aborts `EGenreNotPresent` if the genre is not currently assigned, including when
+ * the release has no genres at all.
+ */
+export function removeGenre(options: RemoveGenreOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_genre';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "genreId"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_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 release's entire genre list. A no-op when nothing is attached. Emits
+ * `GenresClearedEvent` only when a list was actually removed.
+ */
+export function clearGenres(options: ClearGenresOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_genre';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_genre',
+        function: 'clear_genres',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface GenresArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface GenresOptions {
+    package?: string;
+    arguments: GenresArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/**
+ * The release's genre ids, in order, primary first. Empty when nothing is
+ * attached.
+ */
+export function genres(options: GenresOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_genre';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_genre',
+        function: 'genres',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/src/contracts/release_kind/release_kind.ts

@@ -0,0 +1,154 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * What a release calls itself — "Album", "EP", "Mixtape", "Split" — asserted by
+ * whoever holds the release's admin cap, and believed.
+ *
+ * Deliberately a free string rather than an enum. An enum would not decide the
+ * classification (the admin still picks) but it would decide the _menu_, and
+ * deciding which self-descriptions are legitimate is not the protocol's job.
+ * Artists release beat tapes and splits and things nobody has named yet; a closed
+ * set would make each of those a package swap, and in the meantime would quietly
+ * push releases into whichever official-looking box fit worst.
+ *
+ * Nothing here derives the value or checks it for plausibility. A four-track
+ * release may call itself an Album and a twelve-track one an EP; both happen, and
+ * the artist's intent is the fact worth recording. The only checks are structural
+ * — non-empty and bounded — so the field stays storable.
+ *
+ * This is the opposite call from `release_genre`, on purpose. Genre is a curated
+ * vocabulary because discovery and reward-eligibility depend on releases agreeing
+ * with each other about what a genre _is_. Nothing depends on two releases
+ * agreeing about what an EP is.
+ *
+ * The cost of that freedom lands on readers: "EP", "ep" and "Extended Play" are
+ * three distinct values here. Clients that group or facet by kind should normalise
+ * (case-fold at minimum) rather than expect canonical strings.
+ */
+
+import { MoveTuple, MoveStruct, 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/release_kind::release_kind';
+export const ExtensionKey = new MoveTuple({ name: `${$moduleName}::ExtensionKey`, fields: [bcs.bool()] });
+export const KindSetEvent = new MoveStruct({ name: `${$moduleName}::KindSetEvent`, fields: {
+        release_id: bcs.Address,
+        kind: bcs.string()
+    } });
+export const KindUnsetEvent = new MoveStruct({ name: `${$moduleName}::KindUnsetEvent`, fields: {
+        release_id: bcs.Address
+    } });
+export interface SetKindArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    kind: RawTransactionArgument<string>;
+}
+export interface SetKindOptions {
+    package?: string;
+    arguments: SetKindArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        kind: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Sets (or replaces) what the release calls itself.
+ *
+ * The string is stored exactly as given, including case — it is the release's own
+ * word for itself, and normalising it here would be the protocol having an opinion
+ * after all.
+ */
+export function setKind(options: SetKindOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_kind';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x1::string::String'
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap", "kind"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_kind',
+        function: 'set_kind',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface UnsetKindArguments {
+    self: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+}
+export interface UnsetKindOptions {
+    package?: string;
+    arguments: UnsetKindArguments | [
+        self: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Removes the kind, if any. Idempotent. Leaves the release having said nothing
+ * about what it is, which is a different state from calling itself anything.
+ */
+export function unsetKind(options: UnsetKindOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_kind';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self", "cap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_kind',
+        function: 'unset_kind',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface HasKindArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface HasKindOptions {
+    package?: string;
+    arguments: HasKindArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/** Whether a kind is attached to this release. */
+export function hasKind(options: HasKindOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_kind';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_kind',
+        function: 'has_kind',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface KindArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface KindOptions {
+    package?: string;
+    arguments: KindArguments | [
+        self: RawTransactionArgument<string>
+    ];
+}
+/** What the release calls itself. Aborts if nothing is attached. */
+export function kind(options: KindOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_kind';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["self"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_kind',
+        function: 'kind',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/src/contracts/release_revenue_distributor/release_revenue_distributor.ts

@@ -0,0 +1,141 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/**
+ * Raw-cap Release revenue actions.
+ *
+ * Revenue is split from the immutable Release tracklist and sent to the
+ * corresponding Recording addresses. Callers select only funds already held by the
+ * Release; they cannot select recipients or alter split amounts.
+ */
+
+import { 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/release_revenue_distributor::release_revenue_distributor';
+export const ReleaseTrackRevenueDistributedEvent = new MoveStruct({ name: `${$moduleName}::ReleaseTrackRevenueDistributedEvent<phantom Currency>`, fields: {
+        release_id: bcs.Address,
+        track_index: bcs.u64(),
+        recording_id: bcs.Address,
+        amount: bcs.u64()
+    } });
+export const ReleaseRevenueDistributedEvent = new MoveStruct({ name: `${$moduleName}::ReleaseRevenueDistributedEvent<phantom Currency>`, fields: {
+        release_id: bcs.Address,
+        total_input: bcs.u64(),
+        total_distributed: bcs.u64(),
+        remainder: bcs.u64()
+    } });
+export interface RedeemAndDistributeArguments {
+    release: RawTransactionArgument<string>;
+    adminCap: RawTransactionArgument<string>;
+    value: RawTransactionArgument<number | bigint>;
+}
+export interface RedeemAndDistributeOptions {
+    package?: string;
+    arguments: RedeemAndDistributeArguments | [
+        release: RawTransactionArgument<string>,
+        adminCap: RawTransactionArgument<string>,
+        value: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Redeem `value` from the Release accumulator and distribute it according to the
+ * immutable tracklist.
+ */
+export function redeemAndDistribute(options: RedeemAndDistributeOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_revenue_distributor';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64'
+    ] satisfies (string | null)[];
+    const parameterNames = ["release", "adminCap", "value"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_revenue_distributor',
+        function: 'redeem_and_distribute',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface RedeemAllAndDistributeArguments {
+    release: RawTransactionArgument<string>;
+    adminCap: RawTransactionArgument<string>;
+}
+export interface RedeemAllAndDistributeOptions {
+    package?: string;
+    arguments: RedeemAllAndDistributeArguments | [
+        release: RawTransactionArgument<string>,
+        adminCap: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Redeem all Release funds settled at the start of the current consensus commit
+ * and distribute them according to the immutable tracklist.
+ *
+ * The framework snapshot is capped at `u64::MAX`; excess funds, newly sent funds,
+ * and per-track flooring remainder settle for a later call. This fixed crank
+ * prevents permissionless adapters from selecting dust-sized fragments. A zero
+ * settled snapshot is an idempotent no-op.
+ */
+export function redeemAllAndDistribute(options: RedeemAllAndDistributeOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_revenue_distributor';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::accumulator::AccumulatorRoot'
+    ] satisfies (string | null)[];
+    const parameterNames = ["release", "adminCap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_revenue_distributor',
+        function: 'redeem_all_and_distribute',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface ReceiveAndDistributeArguments {
+    release: RawTransactionArgument<string>;
+    adminCap: RawTransactionArgument<string>;
+    coins: TransactionArgument;
+}
+export interface ReceiveAndDistributeOptions {
+    package?: string;
+    arguments: ReceiveAndDistributeArguments | [
+        release: RawTransactionArgument<string>,
+        adminCap: RawTransactionArgument<string>,
+        coins: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Receive selected coins sent to the Release and distribute their combined value
+ * according to the immutable tracklist.
+ */
+export function receiveAndDistribute(options: ReceiveAndDistributeOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_revenue_distributor';
+    const argumentsTypes = [
+        null,
+        null,
+        'vector<null>'
+    ] satisfies (string | null)[];
+    const parameterNames = ["release", "adminCap", "coins"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_revenue_distributor',
+        function: 'receive_and_distribute',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}

package/src/contracts/release_revenue_distributor_plugin/release_revenue_distributor_plugin.ts

@@ -0,0 +1,143 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+
+/** Vault adapter for Release revenue-distribution 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>
+    ];
+}
+export function install(options: InstallOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_revenue_distributor_plugin';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault", "vaultAdminCap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_revenue_distributor_plugin',
+        function: 'install',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface UninstallArguments {
+    vault: RawTransactionArgument<string>;
+    vaultAdminCap: RawTransactionArgument<string>;
+}
+export interface UninstallOptions {
+    package?: string;
+    arguments: UninstallArguments | [
+        vault: RawTransactionArgument<string>,
+        vaultAdminCap: RawTransactionArgument<string>
+    ];
+}
+export function uninstall(options: UninstallOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_revenue_distributor_plugin';
+    const argumentsTypes = [
+        null,
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault", "vaultAdminCap"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_revenue_distributor_plugin',
+        function: 'uninstall',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface IsInstalledArguments {
+    vault: RawTransactionArgument<string>;
+}
+export interface IsInstalledOptions {
+    package?: string;
+    arguments: IsInstalledArguments | [
+        vault: RawTransactionArgument<string>
+    ];
+}
+export function isInstalled(options: IsInstalledOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_revenue_distributor_plugin';
+    const argumentsTypes = [
+        null
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_revenue_distributor_plugin',
+        function: 'is_installed',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export interface ReceiveAndDistributeArguments {
+    vault: RawTransactionArgument<string>;
+    release: RawTransactionArgument<string>;
+    coins: TransactionArgument;
+}
+export interface ReceiveAndDistributeOptions {
+    package?: string;
+    arguments: ReceiveAndDistributeArguments | [
+        vault: RawTransactionArgument<string>,
+        release: RawTransactionArgument<string>,
+        coins: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export function receiveAndDistribute(options: ReceiveAndDistributeOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_revenue_distributor_plugin';
+    const argumentsTypes = [
+        null,
+        null,
+        'vector<null>'
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault", "release", "coins"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_revenue_distributor_plugin',
+        function: 'receive_and_distribute',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface RedeemAllAndDistributeArguments {
+    vault: RawTransactionArgument<string>;
+    release: RawTransactionArgument<string>;
+}
+export interface RedeemAllAndDistributeOptions {
+    package?: string;
+    arguments: RedeemAllAndDistributeArguments | [
+        vault: RawTransactionArgument<string>,
+        release: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export function redeemAllAndDistribute(options: RedeemAllAndDistributeOptions) {
+    const packageAddress = options.package ?? '@local-pkg/release_revenue_distributor_plugin';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::accumulator::AccumulatorRoot'
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault", "release"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'release_revenue_distributor_plugin',
+        function: 'redeem_all_and_distribute',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}

package/src/contracts/release_revenue_distributor_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/release_revenue_distributor_plugin::witness';
+export const Witness = new MoveTuple({ name: `${$moduleName}::Witness`, fields: [bcs.bool()] });