@misofm/sdk 0.15.11 → 0.17.0

package/src/vault.ts

@@ -2,12 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0
 
 /**
- * Capability custody and vault-plugin transaction builders.
+ * Capability custody, raw-cap Action, and safe crank-plugin transaction builders.
  *
  * A direct admin cap remains supported for existing works. New work should give
  * the owner a `VaultAdminCap<AdminCap>` and keep the raw admin cap inside the
  * shared Vault. Every authorized call borrows and returns the raw cap inside
  * one helper; borrowed capabilities are never exposed to application code.
+ * Party wallet and routed-stake operations remain Actions because their useful
+ * results must stay under the caller's control.
  */
 
 import type { BcsType } from "@mysten/sui/bcs";
@@ -19,17 +21,19 @@ import type {
 } from "@mysten/sui/transactions";
 import { deriveObjectID, normalizeStructTag } from "@mysten/sui/utils";
 import * as vault from "./contracts/vault/vault.ts";
-import * as compositionRoyaltyPool from "./contracts/composition_royalty_pool/composition_royalty_pool.ts";
-import * as recordingRoyaltyPool from "./contracts/recording_royalty_pool/recording_royalty_pool.ts";
-import * as partyWallet from "./contracts/party_wallet/party_wallet.ts";
-import * as compositionRoutedStake from "./contracts/composition_routed_stake/composition_routed_stake.ts";
 import * as releaseRevenueDistributor from "./contracts/release_revenue_distributor/release_revenue_distributor.ts";
+import * as compositionRoyaltyPoolPlugin from "./contracts/composition_royalty_pool_plugin/composition_royalty_pool_plugin.ts";
+import * as recordingRoyaltyPoolPlugin from "./contracts/recording_royalty_pool_plugin/recording_royalty_pool_plugin.ts";
+import * as releaseRevenueDistributorPlugin from "./contracts/release_revenue_distributor_plugin/release_revenue_distributor_plugin.ts";
 import * as routedStake from "./contracts/routed_stake/routed_stake.ts";
 
 /** A legacy work whose raw protocol admin cap is still address-owned. */
 /** An object id resolved lazily when a transaction thunk is applied. */
 export type ObjectInput = string | TransactionObjectArgument;
 
+/** The framework singleton read by `balance::settled_funds_value`. */
+export const SUI_ACCUMULATOR_ROOT_OBJECT_ID = "0xacc";
+
 function object(tx: Transaction, value: ObjectInput): TransactionObjectArgument {
   return typeof value === "string" ? tx.object(value) : value;
 }
@@ -229,7 +233,7 @@ export function restoreVaultCapability(
   }));
 }
 
-/** Transfer the key-only VaultAdminCap through the Vault module. */
+/** Transfer the `key + store` VaultAdminCap to its next owner. */
 export function transferVaultAdminCap(
   tx: Transaction,
   params: {
@@ -239,15 +243,11 @@ export function transferVaultAdminCap(
     readonly vaultPackageId: string;
   },
 ): void {
-  tx.add(vault.transferAdminCap({
-    package: params.vaultPackageId,
-    typeArguments: [params.capType],
-    arguments: [object(tx, params.vaultAdminCap), params.owner],
-  }));
+  tx.transferObjects([object(tx, params.vaultAdminCap)], params.owner);
 }
 
 /**
- * Custody a freshly-created raw admin cap, optionally install plugins, share the
+ * Custody a freshly-created raw admin cap, optionally configure it, share the
  * Vault, then transfer only the VaultAdminCap to its owner.
  */
 export function custodyNewAdminCap(
@@ -323,7 +323,7 @@ export function installCompositionRoyaltyPoolPlugin(
   params: CompositionRoyaltyPoolPluginParams,
 ): void {
   tx.add(
-    compositionRoyaltyPool.install({
+    compositionRoyaltyPoolPlugin.install({
       package: params.pluginPackageId,
       typeArguments: [params.compositionShareType],
       arguments: [params.vault, params.vaultAdminCap],
@@ -335,48 +335,40 @@ export function uninstallCompositionRoyaltyPoolPlugin(
   tx: Transaction,
   params: CompositionRoyaltyPoolPluginParams,
 ): void {
-  tx.add(compositionRoyaltyPool.uninstall({ package: params.pluginPackageId, typeArguments: [params.compositionShareType], arguments: [params.vault, params.vaultAdminCap] }));
+  tx.add(
+    compositionRoyaltyPoolPlugin.uninstall({
+      package: params.pluginPackageId,
+      typeArguments: [params.compositionShareType],
+      arguments: [params.vault, params.vaultAdminCap],
+    }),
+  );
 }
 
-export interface InitializeCompositionRoyaltyPoolParams
-  extends CompositionRoyaltyPoolPluginParams {
+export interface NewCompositionRoyaltyPoolParams {
+  readonly authority: AdminCapAuthority;
   readonly composition: TransactionObjectArgument;
+  readonly actionPackageId: string;
   readonly currencyType: string;
+  readonly compositionShareType: string;
 }
 
 /** Create the canonical pool without sharing it so callers can configure fresh stakes first. */
 export function newCompositionRoyaltyPool(
   tx: Transaction,
-  params: InitializeCompositionRoyaltyPoolParams,
+  params: NewCompositionRoyaltyPoolParams,
 ): TransactionObjectArgument {
-  return tx.add(
-    compositionRoyaltyPool.newPool({
-      package: params.pluginPackageId,
-      typeArguments: [params.compositionShareType, params.currencyType],
-      arguments: [params.vault, params.composition, params.vaultAdminCap],
-    }),
-  );
-}
-
-/** Create and immediately share the canonical Composition royalty pool. */
-export function initializeCompositionRoyaltyPool(
-  tx: Transaction,
-  params: InitializeCompositionRoyaltyPoolParams,
-): void {
-  tx.add(
-    compositionRoyaltyPool.initializePool({
-      package: params.pluginPackageId,
-      typeArguments: [params.compositionShareType, params.currencyType],
-      arguments: [params.vault, params.composition, params.vaultAdminCap],
-    }),
-  );
+  return invokeWithAdminCap(tx, params.authority, {
+    target: `${params.actionPackageId}::composition_royalty_pool::new_pool`,
+    typeArguments: [params.compositionShareType, params.currencyType],
+    arguments: [params.composition],
+    adminCapIndex: 1,
+  });
 }
 
 export interface CompositionRoyaltyPoolCrankParams {
   readonly vault: TransactionObjectArgument;
   readonly composition: TransactionObjectArgument;
   readonly pool: TransactionObjectArgument;
-  readonly accumulatorRoot: TransactionObjectArgument;
   readonly compositionShareType: string;
   readonly currencyType: string;
   readonly pluginPackageId: string;
@@ -385,6 +377,9 @@ export interface CompositionRoyaltyPoolCrankParams {
 /** JSON-safe input for an on-chain u64. Numbers are rejected to prevent rounding. */
 export type U64Input = bigint | string | number;
 
+/** An exact scalar or the result of an earlier PTB command returning `u64`. */
+export type U64Argument = U64Input | TransactionArgument;
+
 /** Validate an SDK scalar before serializing it as a Move u64. */
 export function asU64(name: string, value: U64Input): bigint {
   if (typeof value === "number" && (!Number.isSafeInteger(value) || value < 0)) {
@@ -400,27 +395,86 @@ export function asU64(name: string, value: U64Input): bigint {
   return parsed;
 }
 
-/** Permissionless crank: sweep settled address funds into the canonical pool. */
-export function sweepCompositionRoyaltyPool(
+function asU64Argument(tx: Transaction, name: string, value: U64Argument): TransactionArgument {
+  if (
+    typeof value === "bigint" ||
+    typeof value === "string" ||
+    typeof value === "number"
+  ) {
+    return tx.pure.u64(asU64(name, value));
+  }
+  return value;
+}
+
+/** Read the commit-settled accumulator balance for an address inside this PTB. */
+export function settledFundsValue(
+  tx: Transaction,
+  params: {
+    readonly address: string | TransactionArgument;
+    readonly currencyType: string;
+    readonly accumulatorRoot?: ObjectInput;
+  },
+): TransactionArgument {
+  return tx.moveCall({
+    target: "0x2::balance::settled_funds_value",
+    typeArguments: [params.currencyType],
+    arguments: [
+      object(tx, params.accumulatorRoot ?? SUI_ACCUMULATOR_ROOT_OBJECT_ID),
+      typeof params.address === "string"
+        ? tx.pure.address(params.address)
+        : params.address,
+    ],
+  });
+}
+
+/** Permissionless crank: redeem an exact Composition amount into its pool. */
+export function redeemAndDepositCompositionRoyaltyPool(
   tx: Transaction,
-  params: CompositionRoyaltyPoolCrankParams,
+  params: CompositionRoyaltyPoolCrankParams & {
+    readonly value: U64Argument;
+  },
 ): void {
   tx.add(
-    compositionRoyaltyPool.sweepAndDeposit({
+    compositionRoyaltyPoolPlugin.redeemAndDeposit({
       package: params.pluginPackageId,
       typeArguments: [params.compositionShareType, params.currencyType],
-      arguments: [params.vault, params.composition, params.pool, params.accumulatorRoot],
+      arguments: [
+        params.vault,
+        params.composition,
+        params.pool,
+        asU64Argument(tx, "value", params.value),
+      ],
     }),
   );
 }
 
+/** Redeem exactly the framework-reported settled Composition funds. */
+export function settleCompositionRoyaltyPool(
+  tx: Transaction,
+  params: Omit<CompositionRoyaltyPoolCrankParams, "composition"> & {
+    readonly compositionId: string;
+    readonly accumulatorRoot?: ObjectInput;
+  },
+): void {
+  const value = settledFundsValue(tx, {
+    address: params.compositionId,
+    currencyType: params.currencyType,
+    accumulatorRoot: params.accumulatorRoot,
+  });
+  redeemAndDepositCompositionRoyaltyPool(tx, {
+    ...params,
+    composition: tx.object(params.compositionId),
+    value,
+  });
+}
+
 /** Permissionless crank: receive selected Composition-owned coins into the pool. */
 export function receiveCompositionRoyaltyPool(
   tx: Transaction,
   params: CompositionRoyaltyPoolCrankParams & { readonly coins: readonly ReceivingObjectRef[] },
 ): void {
   tx.add(
-    compositionRoyaltyPool.receiveAndDeposit({
+    compositionRoyaltyPoolPlugin.receiveAndDeposit({
       package: params.pluginPackageId,
       typeArguments: [params.compositionShareType, params.currencyType],
       arguments: [
@@ -446,7 +500,7 @@ export function installRecordingRoyaltyPoolPlugin(
   params: RecordingRoyaltyPoolPluginParams,
 ): void {
   tx.add(
-    recordingRoyaltyPool.install({
+    recordingRoyaltyPoolPlugin.install({
       package: params.pluginPackageId,
       typeArguments: [params.recordingShareType],
       arguments: [params.vault, params.vaultAdminCap],
@@ -454,40 +508,11 @@ 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: PartyWalletPluginParams,
-): void {
-  tx.add(
-    partyWallet.install({
-      package: params.pluginPackageId,
-      arguments: [params.vault, params.vaultAdminCap],
-    }),
-  );
-}
-
-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 {
+export interface PartyWalletFundsParams {
+  readonly authority: AdminCapAuthority;
   readonly party: TransactionObjectArgument;
   readonly currencyType: string;
+  readonly actionPackageId: string;
 }
 
 /** Receive selected Party-owned coins and return their merged Balance. */
@@ -495,145 +520,148 @@ 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),
-      ],
-    }),
-  );
+  return invokeWithAdminCap(tx, params.authority, {
+    target: `${params.actionPackageId}::party_wallet::receive_balance`,
+    typeArguments: [params.currencyType],
+    arguments: [params.party, receivingCoins(tx, params.currencyType, params.coins)],
+    adminCapIndex: 1,
+  });
 }
 
 /** Redeem an exact Party accumulator amount and return its Balance. */
 export function redeemPartyWalletBalance(
   tx: Transaction,
-  params: PartyWalletFundsParams & { readonly value: U64Input },
+  params: PartyWalletFundsParams & { readonly value: U64Argument },
 ): TransactionArgument {
-  return tx.add(
-    partyWallet.redeemBalance({
-      package: params.pluginPackageId,
-      typeArguments: [params.currencyType],
-      arguments: [
-        params.vault,
-        params.party,
-        params.vaultAdminCap,
-        asU64("value", params.value),
-      ],
-    }),
-  );
+  return invokeWithAdminCap(tx, params.authority, {
+    target: `${params.actionPackageId}::party_wallet::redeem_balance`,
+    typeArguments: [params.currencyType],
+    arguments: [params.party, asU64Argument(tx, "value", params.value)],
+    adminCapIndex: 1,
+  });
 }
 
-/** Sweep the Party's currently settled accumulator funds and return its Balance. */
-export function sweepPartyWalletBalance(
+/** Redeem exactly the framework-reported settled Party funds. */
+export function settlePartyWalletBalance(
   tx: Transaction,
-  params: PartyWalletFundsParams & {
-    readonly accumulatorRoot: TransactionObjectArgument;
+  params: Omit<PartyWalletFundsParams, "party"> & {
+    readonly partyId: string;
+    readonly accumulatorRoot?: ObjectInput;
   },
 ): TransactionArgument {
-  return tx.add(
-    partyWallet.sweepBalance({
-      package: params.pluginPackageId,
-      typeArguments: [params.currencyType],
-      arguments: [
-        params.vault,
-        params.party,
-        params.accumulatorRoot,
-        params.vaultAdminCap,
-      ],
-    }),
-  );
+  const value = settledFundsValue(tx, {
+    address: params.partyId,
+    currencyType: params.currencyType,
+    accumulatorRoot: params.accumulatorRoot,
+  });
+  return redeemPartyWalletBalance(tx, {
+    ...params,
+    party: tx.object(params.partyId),
+    value,
+  });
 }
 
 export function uninstallRecordingRoyaltyPoolPlugin(
   tx: Transaction,
   params: RecordingRoyaltyPoolPluginParams,
 ): void {
-  tx.add(recordingRoyaltyPool.uninstall({ package: params.pluginPackageId, typeArguments: [params.recordingShareType], arguments: [params.vault, params.vaultAdminCap] }));
+  tx.add(
+    recordingRoyaltyPoolPlugin.uninstall({
+      package: params.pluginPackageId,
+      typeArguments: [params.recordingShareType],
+      arguments: [params.vault, params.vaultAdminCap],
+    }),
+  );
 }
 
-export interface InitializeRecordingRoyaltyPoolParams
-  extends RecordingRoyaltyPoolPluginParams {
+export interface NewRecordingRoyaltyPoolParams {
+  readonly authority: AdminCapAuthority;
   readonly recording: TransactionObjectArgument;
+  readonly actionPackageId: string;
   readonly currencyType: string;
+  readonly recordingShareType: string;
+  readonly compositionShareType: string;
 }
 
 /** Create the canonical pool without sharing it so callers can configure fresh stakes first. */
 export function newRecordingRoyaltyPool(
   tx: Transaction,
-  params: InitializeRecordingRoyaltyPoolParams,
+  params: NewRecordingRoyaltyPoolParams,
 ): TransactionObjectArgument {
-  return tx.add(
-    recordingRoyaltyPool.newPool({
-      package: params.pluginPackageId,
-      typeArguments: [
-        params.recordingShareType,
-        params.compositionShareType,
-        params.currencyType,
-      ],
-      arguments: [params.vault, params.recording, params.vaultAdminCap],
-    }),
-  );
-}
-
-/** Create and immediately share the canonical Recording royalty pool. */
-export function initializeRecordingRoyaltyPool(
-  tx: Transaction,
-  params: InitializeRecordingRoyaltyPoolParams,
-): void {
-  tx.add(
-    recordingRoyaltyPool.initializePool({
-      package: params.pluginPackageId,
-      typeArguments: [
-        params.recordingShareType,
-        params.compositionShareType,
-        params.currencyType,
-      ],
-      arguments: [params.vault, params.recording, params.vaultAdminCap],
-    }),
-  );
+  return invokeWithAdminCap(tx, params.authority, {
+    target: `${params.actionPackageId}::recording_royalty_pool::new_pool`,
+    typeArguments: [
+      params.recordingShareType,
+      params.compositionShareType,
+      params.currencyType,
+    ],
+    arguments: [params.recording],
+    adminCapIndex: 1,
+  });
 }
 
 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;
 }
 
-/** Permissionless crank: sweep settled address funds into the canonical pool. */
-export function sweepRecordingRoyaltyPool(
+/** Permissionless crank: redeem an exact Recording amount into its pool. */
+export function redeemAndDepositRecordingRoyaltyPool(
   tx: Transaction,
-  params: RecordingRoyaltyPoolCrankParams,
+  params: RecordingRoyaltyPoolCrankParams & {
+    readonly value: U64Argument;
+  },
 ): void {
   tx.add(
-    recordingRoyaltyPool.sweepAndDeposit({
+    recordingRoyaltyPoolPlugin.redeemAndDeposit({
       package: params.pluginPackageId,
       typeArguments: [
         params.recordingShareType,
         params.compositionShareType,
         params.currencyType,
       ],
-      arguments: [params.vault, params.recording, params.pool, params.accumulatorRoot],
+      arguments: [
+        params.vault,
+        params.recording,
+        params.pool,
+        asU64Argument(tx, "value", params.value),
+      ],
     }),
   );
 }
 
+/** Redeem exactly the framework-reported settled Recording funds. */
+export function settleRecordingRoyaltyPool(
+  tx: Transaction,
+  params: Omit<RecordingRoyaltyPoolCrankParams, "recording"> & {
+    readonly recordingId: string;
+    readonly accumulatorRoot?: ObjectInput;
+  },
+): void {
+  const value = settledFundsValue(tx, {
+    address: params.recordingId,
+    currencyType: params.currencyType,
+    accumulatorRoot: params.accumulatorRoot,
+  });
+  redeemAndDepositRecordingRoyaltyPool(tx, {
+    ...params,
+    recording: tx.object(params.recordingId),
+    value,
+  });
+}
+
 /** Permissionless crank: receive selected Recording-owned coins into the pool. */
 export function receiveRecordingRoyaltyPool(
   tx: Transaction,
   params: RecordingRoyaltyPoolCrankParams & { readonly coins: readonly ReceivingObjectRef[] },
 ): void {
   tx.add(
-    recordingRoyaltyPool.receiveAndDeposit({
+    recordingRoyaltyPoolPlugin.receiveAndDeposit({
       package: params.pluginPackageId,
       typeArguments: [
         params.recordingShareType,
@@ -661,7 +689,7 @@ export function installReleaseRevenueDistributorPlugin(
   params: ReleaseRevenueDistributorPluginParams,
 ): void {
   tx.add(
-    releaseRevenueDistributor.install({
+    releaseRevenueDistributorPlugin.install({
       package: params.pluginPackageId,
       arguments: [params.vault, params.vaultAdminCap],
     }),
@@ -672,27 +700,68 @@ export function uninstallReleaseRevenueDistributorPlugin(
   tx: Transaction,
   params: ReleaseRevenueDistributorPluginParams,
 ): void {
-  tx.add(releaseRevenueDistributor.uninstall({ package: params.pluginPackageId, arguments: [params.vault, params.vaultAdminCap] }));
+  tx.add(releaseRevenueDistributorPlugin.uninstall({ package: params.pluginPackageId, arguments: [params.vault, params.vaultAdminCap] }));
 }
 
-/** Permissionless crank: redeem release-held money and route it by track BPS. */
+export interface ReleaseRevenueDistributorActionParams {
+  readonly authority: AdminCapAuthority;
+  readonly release: TransactionObjectArgument;
+  readonly currencyType: string;
+  readonly actionPackageId: string;
+}
+
+/** Raw-admin composition: redeem an explicit amount and route it by track BPS. */
 export function redeemAndDistributeReleaseRevenue(
+  tx: Transaction,
+  params: ReleaseRevenueDistributorActionParams & {
+    readonly value: U64Argument;
+  },
+): void {
+  invokeWithAdminCap(tx, params.authority, {
+    target: `${params.actionPackageId}::release_revenue_distributor::redeem_and_distribute`,
+    typeArguments: [params.currencyType],
+    arguments: [params.release, asU64Argument(tx, "value", params.value)],
+    adminCapIndex: 1,
+  });
+}
+
+/** Fixed permissionless crank: redeem the commit-settled Release balance. */
+export function redeemAllAndDistributeReleaseRevenue(
   tx: Transaction,
   params: Omit<ReleaseRevenueDistributorPluginParams, "vaultAdminCap"> & {
     readonly release: TransactionObjectArgument;
     readonly currencyType: string;
-    readonly value: U64Input;
+    readonly accumulatorRoot?: ObjectInput;
   },
 ): void {
   tx.add(
-    releaseRevenueDistributor.redeemAndDistribute({
+    releaseRevenueDistributorPlugin.redeemAllAndDistribute({
       package: params.pluginPackageId,
       typeArguments: [params.currencyType],
-      arguments: [params.vault, params.release, asU64("value", params.value)],
+      arguments: [
+        params.vault,
+        params.release,
+        object(tx, params.accumulatorRoot ?? SUI_ACCUMULATOR_ROOT_OBJECT_ID),
+      ],
     }),
   );
 }
 
+/** Convenience form of the fixed crank for a known Release object ID. */
+export function settleAndDistributeReleaseRevenue(
+  tx: Transaction,
+  params: Omit<ReleaseRevenueDistributorPluginParams, "vaultAdminCap"> & {
+    readonly releaseId: string;
+    readonly currencyType: string;
+    readonly accumulatorRoot?: ObjectInput;
+  },
+): void {
+  redeemAllAndDistributeReleaseRevenue(tx, {
+    ...params,
+    release: tx.object(params.releaseId),
+  });
+}
+
 /** Permissionless crank: receive release-owned coins and route them by track BPS. */
 export function receiveAndDistributeReleaseRevenue(
   tx: Transaction,
@@ -703,7 +772,7 @@ export function receiveAndDistributeReleaseRevenue(
   },
 ): void {
   tx.add(
-    releaseRevenueDistributor.receiveAndDistribute({
+    releaseRevenueDistributorPlugin.receiveAndDistribute({
       package: params.pluginPackageId,
       typeArguments: [params.currencyType],
       arguments: [
@@ -715,35 +784,14 @@ export function receiveAndDistributeReleaseRevenue(
   );
 }
 
-export interface CompositionRoutedStakePluginParams {
-  readonly vault: TransactionObjectArgument;
-  readonly vaultAdminCap: TransactionObjectArgument;
+export interface CompositionRoutedStakeActionParams {
+  readonly authority: AdminCapAuthority;
   readonly compositionShareType: string;
-  readonly pluginPackageId: string;
-}
-
-export function installCompositionRoutedStakePlugin(
-  tx: Transaction,
-  params: CompositionRoutedStakePluginParams,
-): void {
-  tx.add(
-    compositionRoutedStake.install({
-      package: params.pluginPackageId,
-      typeArguments: [params.compositionShareType],
-      arguments: [params.vault, params.vaultAdminCap],
-    }),
-  );
-}
-
-export function uninstallCompositionRoutedStakePlugin(
-  tx: Transaction,
-  params: CompositionRoutedStakePluginParams,
-): void {
-  tx.add(compositionRoutedStake.uninstall({ package: params.pluginPackageId, typeArguments: [params.compositionShareType], arguments: [params.vault, params.vaultAdminCap] }));
+  readonly actionPackageId: string;
 }
 
 export interface CreateCompositionRoutedStakeParams
-  extends CompositionRoutedStakePluginParams {
+  extends CompositionRoutedStakeActionParams {
   readonly recording: TransactionObjectArgument;
   readonly composition: TransactionObjectArgument;
   readonly recordingShareType: string;
@@ -753,24 +801,17 @@ export interface CreateCompositionRoutedStakeParams
 export function createCompositionRoutedStake(
   tx: Transaction,
   params: CreateCompositionRoutedStakeParams,
-): void {
-  tx.add(
-    compositionRoutedStake.createStake({
-      package: params.pluginPackageId,
-      typeArguments: [params.recordingShareType, params.compositionShareType],
-      arguments: [
-        params.vault,
-        params.composition,
-        params.recording,
-        params.vaultAdminCap,
-        asU64("value", params.value),
-      ],
-    }),
-  );
+): TransactionObjectArgument {
+  return invokeWithAdminCap(tx, params.authority, {
+    target: `${params.actionPackageId}::composition_routed_stake::create_stake`,
+    typeArguments: [params.recordingShareType, params.compositionShareType],
+    arguments: [params.composition, params.recording, tx.pure.u64(asU64("value", params.value))],
+    adminCapIndex: 1,
+  });
 }
 
 export interface ManageCompositionRoutedStakeParams
-  extends CompositionRoutedStakePluginParams {
+  extends CompositionRoutedStakeActionParams {
   readonly composition: TransactionObjectArgument;
   readonly recording: TransactionObjectArgument;
   readonly routedStake: TransactionObjectArgument;
@@ -784,24 +825,12 @@ export function registerCompositionRoutedStake(
   tx: Transaction,
   params: ManageCompositionRoutedStakeParams,
 ): void {
-  tx.add(
-    compositionRoutedStake.register({
-      package: params.pluginPackageId,
-      typeArguments: [
-        params.recordingShareType,
-        params.compositionShareType,
-        params.currencyType,
-      ],
-      arguments: [
-        params.vault,
-        params.composition,
-        params.recording,
-        params.routedStake,
-        params.royaltyPool,
-        params.vaultAdminCap,
-      ],
-    }),
-  );
+  invokeWithAdminCap(tx, params.authority, {
+    target: `${params.actionPackageId}::composition_routed_stake::register`,
+    typeArguments: [params.recordingShareType, params.compositionShareType, params.currencyType],
+    arguments: [params.composition, params.recording, params.routedStake, params.royaltyPool],
+    adminCapIndex: 1,
+  });
 }
 
 /** Unregister a routed stake after pending rewards have been swept. */
@@ -809,65 +838,40 @@ export function unregisterCompositionRoutedStake(
   tx: Transaction,
   params: ManageCompositionRoutedStakeParams,
 ): void {
-  tx.add(
-    compositionRoutedStake.unregister({
-      package: params.pluginPackageId,
-      typeArguments: [
-        params.recordingShareType,
-        params.compositionShareType,
-        params.currencyType,
-      ],
-      arguments: [
-        params.vault,
-        params.composition,
-        params.recording,
-        params.routedStake,
-        params.royaltyPool,
-        params.vaultAdminCap,
-      ],
-    }),
-  );
+  invokeWithAdminCap(tx, params.authority, {
+    target: `${params.actionPackageId}::composition_routed_stake::unregister`,
+    typeArguments: [params.recordingShareType, params.compositionShareType, params.currencyType],
+    arguments: [params.composition, params.recording, params.routedStake, params.royaltyPool],
+    adminCapIndex: 1,
+  });
 }
 
-/** Return routed principal to the Composition address, never to the caller. */
+/** Unstake and return the routed principal for caller-selected composition. */
 export function unstakeCompositionRoutedStake(
   tx: Transaction,
   params: Omit<ManageCompositionRoutedStakeParams, "recording" | "royaltyPool" | "currencyType">,
-): void {
-  tx.add(
-    compositionRoutedStake.unstake({
-      package: params.pluginPackageId,
-      typeArguments: [params.recordingShareType, params.compositionShareType],
-      arguments: [
-        params.vault,
-        params.composition,
-        params.routedStake,
-        params.vaultAdminCap,
-      ],
-    }),
-  );
+): TransactionObjectArgument {
+  return invokeWithAdminCap(tx, params.authority, {
+    target: `${params.actionPackageId}::composition_routed_stake::unstake`,
+    typeArguments: [params.recordingShareType, params.compositionShareType],
+    arguments: [params.composition, params.routedStake],
+    adminCapIndex: 1,
+  });
 }
 
-/** Refill an empty routed stake from Recording shares held by the Composition. */
+/** Refill an empty routed stake with caller-supplied Recording shares. */
 export function restakeCompositionRoutedStake(
   tx: Transaction,
   params: Omit<ManageCompositionRoutedStakeParams, "recording" | "royaltyPool" | "currencyType"> & {
-    readonly value: U64Input;
+    readonly shares: TransactionArgument;
   },
 ): void {
-  tx.add(
-    compositionRoutedStake.restake({
-      package: params.pluginPackageId,
-      typeArguments: [params.recordingShareType, params.compositionShareType],
-      arguments: [
-        params.vault,
-        params.composition,
-        params.routedStake,
-        params.vaultAdminCap,
-        asU64("value", params.value),
-      ],
-    }),
-  );
+  invokeWithAdminCap(tx, params.authority, {
+    target: `${params.actionPackageId}::composition_routed_stake::restake`,
+    typeArguments: [params.recordingShareType, params.compositionShareType],
+    arguments: [params.composition, params.routedStake, params.shares],
+    adminCapIndex: 1,
+  });
 }
 
 /** Permissionlessly sweep a routed stake's accrued rewards into its parent pool. */