@misofm/sdk 0.15.2 → 0.15.4

package/src/contracts/miso_pressing/pressing.ts

@@ -38,9 +38,9 @@
  * Nothing here is ever destroyed, sealed, or wound down — deleting a pressing
  * would strand its whole derived subtree, so there is no destructor at all. The
  * run's lifecycle is `Scheduled → Active → Paused → Active`: it opens itself at
- * its scheduled start (no artist transaction, and nobody can buy early), then the
- * artist stops and starts it at will. The first transition is real, not computed —
- * the first sale past the start rewrites `Scheduled` to `Active` inside
+ * its drop moment (no artist transaction, and nobody can buy early), and after
+ * that the artist stops and starts it at will. The first transition is real, not
+ * computed — the first sale past the start rewrites `Scheduled` to `Active` inside
  * `mint_next`, which is why `Scheduled` only ever describes a run still waiting.
  * Below it, each listing's `Enabled | Disabled` governs one currency. A run that
  * is paused or not yet open sells in no currency, whatever the listings say.
@@ -73,8 +73,8 @@ export const PressingKey = new MoveTuple({ name: `${$moduleName}::PressingKey`,
 export const PressingAdminCapKey = new MoveTuple({ name: `${$moduleName}::PressingAdminCapKey`, fields: [bcs.bool()] });
 /**
  * Whether the run sells, over every currency at once. The lifecycle runs
- * `Scheduled → Active → Paused → Active`: a pressing opens itself at its scheduled
- * start, then the artist stops and starts it at will.
+ * `Scheduled → Active → Paused → Active`: a pressing opens itself at its drop
+ * moment, then the artist stops and starts it at will.
  */
 export const PressingState = new MoveEnum({ name: `${$moduleName}::PressingState`, fields: {
         /**
@@ -85,7 +85,7 @@ export const PressingState = new MoveEnum({ name: `${$moduleName}::PressingState
           * `Active` (in `mint_next`, before any sales logic), so a run reads `Scheduled`
           * only while it is still waiting. Between the start and that first sale the run
           * already sells — `is_selling` answers against the clock — so nobody has to go
-          * first for the Pressing to be open.
+          * first for the drop to be open.
           *
           * Consequence worth knowing: once the transition fires the start time is gone from
           * the object. `PressingOpenedEvent` and `PressingStateChangedEvent` carry it, so
@@ -190,7 +190,7 @@ export interface NewOptions {
     ];
 }
 /**
- * Open a release's pressing in `state` — `Scheduled` for a future start, `Active`
+ * Open a release's pressing in `state` — `Scheduled` for a drop moment, `Active`
  * to sell immediately, `Paused` to set it up quietly. Returns it unshared, so the
  * same transaction can list it (`listing::new`) before `share` puts it on chain,
  * plus the cap that governs it from here on. Neither value has `drop`, so neither

package/src/contracts/party_wallet/party_wallet.ts

@@ -8,11 +8,12 @@
  *
  * Anyone may address objects or funds to a Party ID. This plugin is the bounded
  * withdrawal door: it temporarily leases the matching `PartyAdminCap`, uses it
- * only to reach that Party's UID, returns it to the Vault, and then transfers the
- * withdrawn object or coin to the recipient selected by the Vault administrator.
+ * only to reach that Party's UID, and returns it to the Vault. Object withdrawals
+ * transfer to the recipient selected by the Vault administrator; monetary
+ * withdrawals return a composable `Balance` for the caller's PTB to consume.
  *
  * Installation alone never makes withdrawals permissionless. Every production
- * withdrawal is an `entry fun` requiring the matching `VaultAdminCap`, and no
+ * withdrawal is a `public fun` requiring the matching `VaultAdminCap`, and no
  * endpoint returns the leased capability, its borrow receipt, or a privileged
  * reference. The Party itself stores no plugin data.
  */
@@ -182,7 +183,6 @@ export interface ReceiveCoinsArguments {
     party: RawTransactionArgument<string>;
     vaultAdminCap: RawTransactionArgument<string>;
     coins: TransactionArgument;
-    recipient: RawTransactionArgument<string>;
 }
 export interface ReceiveCoinsOptions {
     package?: string;
@@ -190,16 +190,15 @@ export interface ReceiveCoinsOptions {
         vault: RawTransactionArgument<string>,
         party: RawTransactionArgument<string>,
         vaultAdminCap: RawTransactionArgument<string>,
-        coins: TransactionArgument,
-        recipient: RawTransactionArgument<string>
+        coins: TransactionArgument
     ];
     typeArguments: [
         string
     ];
 }
 /**
- * Receive coin objects of one currency, merge them, and transfer the resulting
- * Coin to `recipient`.
+ * Receive coin objects of one currency, merge them, and return their combined
+ * Balance for the caller's PTB to consume.
  *
  * Aborts with `ENothingToReceive` if `coins` is empty. It also aborts if the Vault
  * administrator, plugin installation, Party capability, or a receiving ticket is
@@ -211,10 +210,9 @@ export function receiveCoins(options: ReceiveCoinsOptions) {
         null,
         null,
         null,
-        'vector<null>',
-        'address'
+        'vector<null>'
     ] satisfies (string | null)[];
-    const parameterNames = ["vault", "party", "vaultAdminCap", "coins", "recipient"];
+    const parameterNames = ["vault", "party", "vaultAdminCap", "coins"];
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'party_wallet',
@@ -223,48 +221,89 @@ export function receiveCoins(options: ReceiveCoinsOptions) {
         typeArguments: options.typeArguments
     });
 }
-export interface RedeemCoinArguments {
+export interface RedeemBalanceArguments {
     vault: RawTransactionArgument<string>;
     party: RawTransactionArgument<string>;
     vaultAdminCap: RawTransactionArgument<string>;
     value: RawTransactionArgument<number | bigint>;
-    recipient: RawTransactionArgument<string>;
 }
-export interface RedeemCoinOptions {
+export interface RedeemBalanceOptions {
     package?: string;
-    arguments: RedeemCoinArguments | [
+    arguments: RedeemBalanceArguments | [
         vault: RawTransactionArgument<string>,
         party: RawTransactionArgument<string>,
         vaultAdminCap: RawTransactionArgument<string>,
-        value: RawTransactionArgument<number | bigint>,
-        recipient: RawTransactionArgument<string>
+        value: RawTransactionArgument<number | bigint>
     ];
     typeArguments: [
         string
     ];
 }
 /**
- * Redeem `value` from the Party's accumulator balance, create a Coin, and transfer
- * it to `recipient`.
+ * Redeem `value` from the Party's accumulator and return a Balance for the
+ * caller's PTB to consume.
  *
  * Aborts if the Vault administrator is wrong, the plugin is not installed, the
  * Vault contains another Party's cap, `value` is zero, or the accumulator cannot
  * cover the requested amount.
  */
-export function redeemCoin(options: RedeemCoinOptions) {
+export function redeemBalance(options: RedeemBalanceOptions) {
     const packageAddress = options.package ?? '@local-pkg/party_wallet';
     const argumentsTypes = [
         null,
         null,
         null,
-        'u64',
-        'address'
+        'u64'
+    ] satisfies (string | null)[];
+    const parameterNames = ["vault", "party", "vaultAdminCap", "value"];
+    return (tx: Transaction) => tx.moveCall({
+        package: packageAddress,
+        module: 'party_wallet',
+        function: 'redeem_balance',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export interface SweepBalanceArguments {
+    vault: RawTransactionArgument<string>;
+    party: RawTransactionArgument<string>;
+    root: RawTransactionArgument<string>;
+    vaultAdminCap: RawTransactionArgument<string>;
+}
+export interface SweepBalanceOptions {
+    package?: string;
+    arguments: SweepBalanceArguments | [
+        vault: RawTransactionArgument<string>,
+        party: RawTransactionArgument<string>,
+        root: RawTransactionArgument<string>,
+        vaultAdminCap: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Redeem the settled `Currency` amount reported for the Party address and return a
+ * Balance for the caller's PTB to consume.
+ *
+ * Funds sent during the current consensus commit are not yet settled and remain
+ * available for a later sweep. Aborts with `ENoSettledFunds` when the settled
+ * amount is zero. The framework caps the reported amount at `u64::MAX`; any excess
+ * remains for a later sweep.
+ */
+export function sweepBalance(options: SweepBalanceOptions) {
+    const packageAddress = options.package ?? '@local-pkg/party_wallet';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null
     ] satisfies (string | null)[];
-    const parameterNames = ["vault", "party", "vaultAdminCap", "value", "recipient"];
+    const parameterNames = ["vault", "party", "root", "vaultAdminCap"];
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'party_wallet',
-        function: 'redeem_coin',
+        function: 'sweep_balance',
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
         typeArguments: options.typeArguments
     });

package/src/contracts/recording_royalty_pool/recording_royalty_pool.ts

@@ -157,19 +157,19 @@ export function receiveAndDeposit(options: ReceiveAndDepositOptions) {
         typeArguments: options.typeArguments
     });
 }
-export interface RedeemAndDepositArguments {
+export interface SweepAndDepositArguments {
     vault: RawTransactionArgument<string>;
     recording: RawTransactionArgument<string>;
     pool: RawTransactionArgument<string>;
-    value: RawTransactionArgument<number | bigint>;
+    root: RawTransactionArgument<string>;
 }
-export interface RedeemAndDepositOptions {
+export interface SweepAndDepositOptions {
     package?: string;
-    arguments: RedeemAndDepositArguments | [
+    arguments: SweepAndDepositArguments | [
         vault: RawTransactionArgument<string>,
         recording: RawTransactionArgument<string>,
         pool: RawTransactionArgument<string>,
-        value: RawTransactionArgument<number | bigint>
+        root: RawTransactionArgument<string>
     ];
     typeArguments: [
         string,
@@ -178,22 +178,27 @@ export interface RedeemAndDepositOptions {
     ];
 }
 /**
- * Redeem funds accumulated at the Recording address and deposit them into its
- * canonical pool. Anyone may crank this after installation.
+ * Redeem the settled `Currency` amount reported for the Recording address and
+ * deposit it into the canonical pool. Anyone may crank this after installation.
+ *
+ * Funds sent during the current consensus commit are not yet settled and remain
+ * available for a later sweep. Aborts with `ENoSettledFunds` when the settled
+ * amount is zero. The framework caps the reported amount at `u64::MAX`; any excess
+ * remains for a later sweep.
  */
-export function redeemAndDeposit(options: RedeemAndDepositOptions) {
+export function sweepAndDeposit(options: SweepAndDepositOptions) {
     const packageAddress = options.package ?? '@local-pkg/recording_royalty_pool';
     const argumentsTypes = [
         null,
         null,
         null,
-        'u64'
+        null
     ] satisfies (string | null)[];
-    const parameterNames = ["vault", "recording", "pool", "value"];
+    const parameterNames = ["vault", "recording", "pool", "root"];
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'recording_royalty_pool',
-        function: 'redeem_and_deposit',
+        function: 'sweep_and_deposit',
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
         typeArguments: options.typeArguments
     });

package/src/contracts/royalty_pool/pool.ts

@@ -29,7 +29,7 @@
  *   track's split there). The address is a pure function of
  *   `(parent_id, Share, Currency)`, so senders need the pool neither shared nor
  *   even created yet; a later `new` claims exactly that ID — and can only be the
- *   correctly-typed, shared pool. `receive_and_deposit` and `redeem_and_deposit`
+ *   correctly-typed, shared pool. `receive_and_deposit` and `sweep_and_deposit`
  *   fold such funds into the accumulator, permissionlessly: anyone can complete
  *   the delivery. Both run through `deposit`, which aborts while no shares are
  *   staked — and the pool has no other withdrawal path — so funds at the pool's
@@ -236,15 +236,15 @@ export function receiveAndDeposit(options: ReceiveAndDepositOptions) {
         typeArguments: options.typeArguments
     });
 }
-export interface RedeemAndDepositArguments {
+export interface SweepAndDepositArguments {
     self: RawTransactionArgument<string>;
-    value: RawTransactionArgument<number | bigint>;
+    root: RawTransactionArgument<string>;
 }
-export interface RedeemAndDepositOptions {
+export interface SweepAndDepositOptions {
     package?: string;
-    arguments: RedeemAndDepositArguments | [
+    arguments: SweepAndDepositArguments | [
         self: RawTransactionArgument<string>,
-        value: RawTransactionArgument<number | bigint>
+        root: RawTransactionArgument<string>
     ];
     typeArguments: [
         string,
@@ -252,21 +252,25 @@ export interface RedeemAndDepositOptions {
     ];
 }
 /**
- * Redeem `value` base units from the pool's funds-accumulator and fold them into
- * the accumulator. Recovery path for funds delivered via Sui's `send_funds`
- * mechanism rather than via the canonical extension path.
+ * Redeem the pool's funds settled at the start of the current consensus commit and
+ * fold them into the royalty accumulator. Recovery path for funds delivered via
+ * Sui's `send_funds` mechanism rather than via the canonical extension path.
+ *
+ * The framework returns at most `u64::MAX` per call. Any excess, along with funds
+ * sent later in the current commit, remains for a subsequent sweep. Aborts with
+ * `ENoSettledFunds` when no positive amount is currently eligible.
  */
-export function redeemAndDeposit(options: RedeemAndDepositOptions) {
+export function sweepAndDeposit(options: SweepAndDepositOptions) {
     const packageAddress = options.package ?? '@local-pkg/royalty_pool';
     const argumentsTypes = [
         null,
-        'u64'
+        null
     ] satisfies (string | null)[];
-    const parameterNames = ["self", "value"];
+    const parameterNames = ["self", "root"];
     return (tx: Transaction) => tx.moveCall({
         package: packageAddress,
         module: 'pool',
-        function: 'redeem_and_deposit',
+        function: 'sweep_and_deposit',
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
         typeArguments: options.typeArguments
     });

package/src/read/catalog.ts

@@ -31,6 +31,10 @@ import {
   releaseCreditsFieldId,
   type CreditView,
 } from "../credits.ts";
+import {
+  parseReleaseKindContent,
+  releaseKindFieldId,
+} from "../release-extensions.ts";
 import { getTrackCreditsByRecordingIds } from "../catalog.ts";
 import { getReleaseById, getReleasesByIds, isNotFound } from "@misonetwork/sdk";
 import type { Release } from "@misonetwork/sdk";
@@ -229,12 +233,13 @@ export async function readReleaseCover(
   return toCover(client.config.walrusAggregatorUrl, covers[releaseId] ?? null);
 }
 
-export type ReleaseResourceInclude = "cover" | "credits";
+export type ReleaseResourceInclude = "cover" | "credits" | "kind";
 
 export interface ReleaseResources {
   release: Release;
   cover?: Cover | null;
   credits?: Credit[];
+  kind?: string | null;
 }
 
 /**
@@ -249,16 +254,21 @@ export async function getReleaseResources(
 ): Promise<ReleaseResources> {
   const wantsCover = include.includes("cover");
   const wantsCredits = include.includes("credits");
+  const wantsKind = include.includes("kind");
   const coverFieldIds = wantsCover
     ? [releaseCoverFieldId(releaseId, client.config.protocol.releaseCoverArt)]
     : [];
   const creditsFieldId = wantsCredits
     ? releaseCreditsFieldId(releaseId, client.config.protocol.releaseCredits)
     : null;
+  const kindFieldId = wantsKind
+    ? releaseKindFieldId(releaseId, client.config.protocol.releaseKind)
+    : null;
   const objectIds = [
     releaseId,
     ...coverFieldIds,
     ...(creditsFieldId ? [creditsFieldId] : []),
+    ...(kindFieldId ? [kindFieldId] : []),
   ];
   const { objects } = await client.protocol.core.getObjects({
     objectIds,
@@ -303,10 +313,21 @@ export async function getReleaseResources(
     }
     credits = toCredits(view);
   }
+  let kind: string | null | undefined;
+  if (wantsKind) {
+    const object = objects[
+      1 + coverFieldIds.length + (creditsFieldId ? 1 : 0)
+    ];
+    kind =
+      object && !(object instanceof Error) && object.content
+        ? parseReleaseKindContent(object.content)
+        : null;
+  }
   return {
     release,
     ...(wantsCover ? { cover: cover ?? null } : {}),
     ...(wantsCredits ? { credits: credits ?? [] } : {}),
+    ...(wantsKind ? { kind: kind ?? null } : {}),
   };
 }
 
@@ -332,10 +353,10 @@ export async function getReleaseDetail(
   releaseId: string,
   options: GetReleaseOptions = {},
 ): Promise<ReleaseDetail> {
-  const { release, cover, credits } = await getReleaseResources(
+  const { release, cover, credits, kind } = await getReleaseResources(
     client,
     releaseId,
-    ["cover", "credits"],
+    ["cover", "credits", "kind"],
   );
 
   const recordingIds = release.tracks.map((track) => track.recordingId);
@@ -356,6 +377,7 @@ export async function getReleaseDetail(
     id: release.id,
     title: release.title,
     subtitle: null,
+    kind: kind ?? null,
     state: toWorkState(release.state),
     publishedAtMs:
       release.state.type === "Published" ? release.state.timestampMs : null,

package/src/read/config.ts

@@ -33,6 +33,8 @@ export interface ProtocolIds {
   vault: string;
   /** `release_cover_art` — the release cover extension. */
   releaseCoverArt: string;
+  /** `release_kind` — the Release's optional self-declared kind. */
+  releaseKind: string;
   /** `composition_credits` / `recording_credits` / `release_credits` extensions. */
   compositionCredits: string;
   recordingCredits: string;
@@ -96,6 +98,7 @@ export function misoConfig(network: Network, overrides: MisoConfigOverrides = {}
       record: platform.packages.record,
       vault: platform.packages.vault,
       releaseCoverArt: platform.packages.releaseCoverArt,
+      releaseKind: platform.packages.releaseKind,
       compositionCredits: platform.packages.compositionCredits,
       recordingCredits: platform.packages.recordingCredits,
       releaseCredits: platform.packages.releaseCredits,

package/src/read/types.ts

@@ -82,6 +82,8 @@ export interface ReleaseDetail {
   id: string;
   title: string;
   subtitle: string | null;
+  /** Self-declared `release_kind`, or null when no extension is attached. */
+  kind: string | null;
   state: WorkState;
   /** Publish time (ms), or null while unpublished. */
   publishedAtMs: number | null;

package/src/release-extensions.ts

@@ -5,7 +5,9 @@
 // intent aggregates these concerns, but every value is written by its own
 // independently deployed extension package.
 
-import { deriveObjectID } from "@mysten/sui/utils";
+import type { ClientWithCoreApi } from "@mysten/sui/client";
+import { bcs } from "@mysten/sui/bcs";
+import { deriveDynamicFieldID, deriveObjectID } from "@mysten/sui/utils";
 import type {
   Transaction,
   TransactionArgument,
@@ -59,6 +61,47 @@ export function setReleaseKind(p: SetReleaseKindParams): TxThunk {
   };
 }
 
+const ReleaseKindField = bcs.struct("Field", {
+  id: bcs.Address,
+  name: releaseKind.ExtensionKey,
+  value: bcs.string(),
+});
+const RELEASE_KIND_KEY_BYTES = releaseKind.ExtensionKey.serialize([
+  false,
+]).toBytes();
+
+/** Deterministic dynamic-field id for a Release's optional self-declared kind. */
+export function releaseKindFieldId(
+  releaseId: string,
+  releaseKindPackageId: string,
+): string {
+  return deriveDynamicFieldID(
+    releaseId,
+    `${releaseKindPackageId}::release_kind::ExtensionKey`,
+    RELEASE_KIND_KEY_BYTES,
+  );
+}
+
+/** Parse the dynamic field storing `Option<String>` as its present string. */
+export function parseReleaseKindContent(content: Uint8Array): string {
+  return ReleaseKindField.parse(content).value;
+}
+
+/** Read a Release's self-declared kind, or `null` when the extension is absent. */
+export async function getReleaseKind(
+  client: ClientWithCoreApi,
+  releaseId: string,
+  releaseKindPackageId: string,
+): Promise<string | null> {
+  const { objects } = await client.core.getObjects({
+    objectIds: [releaseKindFieldId(releaseId, releaseKindPackageId)],
+    include: { content: true },
+  });
+  const object = objects[0];
+  if (!object || object instanceof Error || !object.content) return null;
+  return parseReleaseKindContent(object.content);
+}
+
 export type SetReleaseDescriptionParams = ReleaseExtensionTarget & {
   description: string;
   releaseDescriptionPackageId: string;

package/src/vault.ts

@@ -284,6 +284,7 @@ export interface CompositionRoyaltyPoolCrankParams {
   readonly vault: TransactionObjectArgument;
   readonly composition: TransactionObjectArgument;
   readonly pool: TransactionObjectArgument;
+  readonly accumulatorRoot: TransactionObjectArgument;
   readonly compositionShareType: string;
   readonly currencyType: string;
   readonly pluginPackageId: string;
@@ -307,16 +308,16 @@ export function asU64(name: string, value: U64Input): bigint {
   return parsed;
 }
 
-/** Permissionless crank: redeem address funds into the canonical pool. */
-export function redeemCompositionRoyaltyPool(
+/** Permissionless crank: sweep settled address funds into the canonical pool. */
+export function sweepCompositionRoyaltyPool(
   tx: Transaction,
-  params: CompositionRoyaltyPoolCrankParams & { readonly value: U64Input },
+  params: CompositionRoyaltyPoolCrankParams,
 ): void {
   tx.add(
-    compositionRoyaltyPool.redeemAndDeposit({
+    compositionRoyaltyPool.sweepAndDeposit({
       package: params.pluginPackageId,
       typeArguments: [params.compositionShareType, params.currencyType],
-      arguments: [params.vault, params.composition, params.pool, asU64("value", params.value)],
+      arguments: [params.vault, params.composition, params.pool, params.accumulatorRoot],
     }),
   );
 }
@@ -361,14 +362,16 @@ export function installRecordingRoyaltyPoolPlugin(
   );
 }
 
+export interface PartyWalletPluginParams {
+  readonly vault: TransactionObjectArgument;
+  readonly vaultAdminCap: TransactionObjectArgument;
+  readonly pluginPackageId: string;
+}
+
 /** Install the Party wallet plugin; its canonical witness stays internal. */
 export function installPartyWalletPlugin(
   tx: Transaction,
-  params: {
-    readonly vault: TransactionObjectArgument;
-    readonly vaultAdminCap: TransactionObjectArgument;
-    readonly pluginPackageId: string;
-  },
+  params: PartyWalletPluginParams,
 ): void {
   tx.add(
     partyWallet.install({
@@ -378,6 +381,82 @@ export function installPartyWalletPlugin(
   );
 }
 
+export function uninstallPartyWalletPlugin(
+  tx: Transaction,
+  params: PartyWalletPluginParams,
+): void {
+  tx.add(
+    partyWallet.uninstall({
+      package: params.pluginPackageId,
+      arguments: [params.vault, params.vaultAdminCap],
+    }),
+  );
+}
+
+export interface PartyWalletFundsParams extends PartyWalletPluginParams {
+  readonly party: TransactionObjectArgument;
+  readonly currencyType: string;
+}
+
+/** Receive selected Party-owned coins and return their merged Balance. */
+export function receivePartyWalletBalance(
+  tx: Transaction,
+  params: PartyWalletFundsParams & { readonly coins: readonly ReceivingObjectRef[] },
+): TransactionArgument {
+  return tx.add(
+    partyWallet.receiveCoins({
+      package: params.pluginPackageId,
+      typeArguments: [params.currencyType],
+      arguments: [
+        params.vault,
+        params.party,
+        params.vaultAdminCap,
+        receivingCoins(tx, params.currencyType, params.coins),
+      ],
+    }),
+  );
+}
+
+/** Redeem an exact Party accumulator amount and return its Balance. */
+export function redeemPartyWalletBalance(
+  tx: Transaction,
+  params: PartyWalletFundsParams & { readonly value: U64Input },
+): TransactionArgument {
+  return tx.add(
+    partyWallet.redeemBalance({
+      package: params.pluginPackageId,
+      typeArguments: [params.currencyType],
+      arguments: [
+        params.vault,
+        params.party,
+        params.vaultAdminCap,
+        asU64("value", params.value),
+      ],
+    }),
+  );
+}
+
+/** Sweep the Party's currently settled accumulator funds and return its Balance. */
+export function sweepPartyWalletBalance(
+  tx: Transaction,
+  params: PartyWalletFundsParams & {
+    readonly accumulatorRoot: TransactionObjectArgument;
+  },
+): TransactionArgument {
+  return tx.add(
+    partyWallet.sweepBalance({
+      package: params.pluginPackageId,
+      typeArguments: [params.currencyType],
+      arguments: [
+        params.vault,
+        params.party,
+        params.accumulatorRoot,
+        params.vaultAdminCap,
+      ],
+    }),
+  );
+}
+
 export function uninstallRecordingRoyaltyPoolPlugin(
   tx: Transaction,
   params: RecordingRoyaltyPoolPluginParams,
@@ -412,25 +491,27 @@ export interface RecordingRoyaltyPoolCrankParams {
   readonly vault: TransactionObjectArgument;
   readonly recording: TransactionObjectArgument;
   readonly pool: TransactionObjectArgument;
+  readonly accumulatorRoot: TransactionObjectArgument;
   readonly recordingShareType: string;
   readonly compositionShareType: string;
   readonly currencyType: string;
   readonly pluginPackageId: string;
 }
 
-export function redeemRecordingRoyaltyPool(
+/** Permissionless crank: sweep settled address funds into the canonical pool. */
+export function sweepRecordingRoyaltyPool(
   tx: Transaction,
-  params: RecordingRoyaltyPoolCrankParams & { readonly value: U64Input },
+  params: RecordingRoyaltyPoolCrankParams,
 ): void {
   tx.add(
-    recordingRoyaltyPool.redeemAndDeposit({
+    recordingRoyaltyPool.sweepAndDeposit({
       package: params.pluginPackageId,
       typeArguments: [
         params.recordingShareType,
         params.compositionShareType,
         params.currencyType,
       ],
-      arguments: [params.vault, params.recording, params.pool, asU64("value", params.value)],
+      arguments: [params.vault, params.recording, params.pool, params.accumulatorRoot],
     }),
   );
 }