@interest-protocol/blast-migrators-sdk 0.1.1 → 0.2.0

package/src/transactions.ts

@@ -1,45 +1,20 @@
-import type { CoinSourceOptions } from "@interest-protocol/blast-core/coins";
+import { AdminCalls } from "@interest-protocol/blast-admin-sdk/transactions";
+import { cetusMemeSide } from "@interest-protocol/blast-core/cetus";
 import { grossGasBudget } from "@interest-protocol/blast-core/gas";
 import {
   requirePositiveU64,
   requireU64,
+  requireU128,
 } from "@interest-protocol/blast-core/integers";
-import {
-  deploymentObject,
-  moveResults,
-} from "@interest-protocol/blast-core/ptb";
-import type {
-  RewardManifest,
-  RewardProof,
-} from "@interest-protocol/blast-core/rewards/allocations";
-import {
-  MIGRATOR_REWARD_LEAF_DOMAIN,
-  rewardAddress,
-  rewardDigest,
-  validateRewardManifest,
-} from "@interest-protocol/blast-core/rewards/allocations";
-import type {
-  SharedObjectIdentity,
-  SharedObjectReference,
-} from "@interest-protocol/blast-core/sui";
+import { deploymentObject } from "@interest-protocol/blast-core/ptb";
+import { coreRoleType } from "@interest-protocol/blast-core/roles";
+import type { SharedObjectIdentity } from "@interest-protocol/blast-core/sui";
 import {
   normalizeSharedObjectIdentity,
-  normalizeSharedObjectReference,
   normalizeSuiPackageReference,
 } from "@interest-protocol/blast-core/sui";
-import type { FeeSplit } from "@interest-protocol/blast-launchpad-sdk/allocation";
-import type {
-  BlastFunAdminRole,
-  LaunchpadDeployment,
-  LaunchSettings,
-  LaunchTypes,
-  PreShareBuyInput,
-} from "@interest-protocol/blast-launchpad-sdk/transactions";
-import {
-  addLaunchCompletion,
-  LaunchpadCalls,
-  normalizeLaunchTypes,
-} from "@interest-protocol/blast-launchpad-sdk/transactions";
+import type { VaultDeployment } from "@interest-protocol/blast-vault-sdk/transactions";
+import { normalizeVaultDeployment } from "@interest-protocol/blast-vault-sdk/transactions";
 import type {
   TransactionArgument,
   TransactionObjectArgument,
@@ -47,189 +22,291 @@ import type {
   TransactionResult,
 } from "@mysten/sui/transactions";
 import { Transaction } from "@mysten/sui/transactions";
-import { normalizeStructTag, normalizeSuiAddress } from "@mysten/sui/utils";
-import type { MigratorVenue } from "./state.ts";
+import { normalizeStructTag } from "@mysten/sui/utils";
 
 /**
- * The vault's partner, when `LpVaultState.partnerId` is set: the collection
- * then pays it and Blast the LP fees the vault held.
+ * The product-agnostic `blast_migrators` package: its shared
+ * `PackageVersion<BLAST_MIGRATORS>`, `PackageAdmin<BLAST_MIGRATORS>` and
+ * `venue_config::VenueConfig`, and the vault deployment (with core and admin)
+ * every venue call reads.
  */
-export type LpFeePartner = {
-  partner?: SharedObjectReference<false> | null;
-};
-
 export type MigratorsDeployment = {
   packageId: string;
   originalPackageId: string;
-  launchpad: LaunchpadDeployment;
-  /** Migrators `blast_fun_migrators::PackageVersion` checked by every protected entry. */
-  migratorsVersion: SharedObjectIdentity;
-  /** Migrators `lp_fee_policy::LpFeePolicy` read by every LP-fee collection. */
-  lpFeePolicy: SharedObjectIdentity;
-  /** Migrators `venue_config::VenueConfig`, holding each Meme's Cetus `PoolCreationCap`. */
+  packageVersion: SharedObjectIdentity;
+  packageAdmin: SharedObjectIdentity;
   venueConfig: SharedObjectIdentity;
+  vault: VaultDeployment;
+};
+
+/** The venues `blast_migrators` defines, one module each. */
+export const MIGRATOR_VENUES = ["bluefin", "cetus"] as const;
+export type MigratorVenue = (typeof MIGRATOR_VENUES)[number];
+
+/** `constants::bluefin_max_tick_spacing`: Bluefin pool creation's own bound. */
+export const BLUEFIN_MAX_TICK_SPACING = 400;
+
+/** `constants::bluefin_max_fee_rate`: Bluefin pool creation's own bound (1,000,000 is 100%). */
+export const BLUEFIN_MAX_FEE_RATE = 20_000n;
+
+export function normalizeMigratorsDeployment(
+  deployment: MigratorsDeployment,
+): MigratorsDeployment {
+  return {
+    ...normalizeSuiPackageReference("migrators", deployment),
+    packageVersion: normalizeSharedObjectIdentity(
+      "migrators.packageVersion",
+      deployment.packageVersion,
+    ),
+    packageAdmin: normalizeSharedObjectIdentity(
+      "migrators.packageAdmin",
+      deployment.packageAdmin,
+    ),
+    venueConfig: normalizeSharedObjectIdentity(
+      "migrators.venueConfig",
+      deployment.venueConfig,
+    ),
+    vault: normalizeVaultDeployment(deployment.vault),
+  };
+}
+
+/**
+ * `<migrators original>::<venue>::Venue`: the witness a venue seals tickets
+ * and redeems migrations under, and that a product and the vault registry
+ * admit.
+ */
+export function venueWitnessType(
+  migrators: Pick<MigratorsDeployment, "originalPackageId">,
+  venue: MigratorVenue,
+): string {
+  if (!MIGRATOR_VENUES.includes(venue))
+    throw new TypeError(`unknown migrators venue ${String(venue)}`);
+  return normalizeStructTag(`${migrators.originalPackageId}::${venue}::Venue`);
+}
+
+/**
+ * The migrators venue a `Launch.venue` or `Presale.venue` `TypeName`
+ * (original-ID form) names, or null for any other venue.
+ */
+export function venueOf(
+  migrators: Pick<MigratorsDeployment, "originalPackageId">,
+  typeName: string,
+): MigratorVenue | null {
+  const type = normalizeStructTag(typeName);
+  return (
+    MIGRATOR_VENUES.find(
+      (venue) => venueWitnessType(migrators, venue) === type,
+    ) ?? null
+  );
+}
+
+/** A vault's `Meme` and `Quote`; pass original (defining) type addresses. */
+type PairTypes = { memeType: string; quoteType: string };
+
+/** The Cetus `config::GlobalConfig` and LP Burn `lp_burn::BurnManager` fee routes read. */
+type CetusFeeObjects = {
+  config: SharedObjectIdentity;
+  burnManager: SharedObjectIdentity;
 };
 
-import type { CetusMemeSide } from "@interest-protocol/blast-core/cetus";
+/**
+ * One Cetus vault: `vault` is the `Vault<Meme, Quote>` and `pool` its own
+ * `Pool<CoinA, CoinB>`; `currency` is the Meme's Coin Registry
+ * `Currency<Meme>`, which the burn route burns through.
+ */
+type CetusVaultInput = PairTypes & {
+  vault: SharedObjectIdentity;
+  currency: SharedObjectIdentity;
+  cetus: CetusFeeObjects;
+  pool: SharedObjectIdentity;
+};
 
-export type { CetusMemeSide } from "@interest-protocol/blast-core/cetus";
+/** One Bluefin vault: its `Vault<Meme, Quote>`, `Pool<Meme, Quote>` and `Currency<Meme>`. */
+type BluefinVaultInput = PairTypes & {
+  vault: SharedObjectIdentity;
+  currency: SharedObjectIdentity;
+  bluefinConfig: SharedObjectIdentity;
+  pool: SharedObjectIdentity;
+};
 
-/** The Cetus CLMM `config::GlobalConfig` every Cetus route reads. */
-export type CetusObjects = {
-  /** Cetus CLMM `config::GlobalConfig`. */
-  cetusConfig: SharedObjectReference<false>;
+/** A Cetus vault's auto-LP compounding inputs: the vault, Cetus's config and the pool. */
+type CetusCompoundInput = PairTypes & {
+  vault: SharedObjectIdentity;
+  cetus: { config: SharedObjectIdentity };
+  pool: SharedObjectIdentity;
 };
 
-/** Settings for starting a launch through an adapter in one transaction. */
-export type CreateLaunchOptions = LaunchTypes &
-  LaunchSettings &
-  CoinSourceOptions & {
-    /** The `LaunchTicket<Meme>` the generated package's initializer transferred to its publisher. */
-    ticket: TransactionObjectInput;
-    /** The Meme `Currency<Meme>` in the Coin Registry, fixed at finalization. */
-    memeCurrency: SharedObjectReference<true>;
-    /** `LaunchConfig.creation_fee` in MIST, paid as an exact SUI coin. */
-    creationFee: bigint;
-    preShareBuy?: PreShareBuyInput;
-  };
+/** A Bluefin vault's auto-LP compounding inputs: the vault, Bluefin's config and the pool. */
+type BluefinCompoundInput = PairTypes & {
+  vault: SharedObjectIdentity;
+  bluefinConfig: SharedObjectIdentity;
+  pool: SharedObjectIdentity;
+};
 
-/** Maximum Merkle proof depth the holder-reward leaf count (65,536) allows. */
-export const MAX_HOLDER_REWARD_PROOF_DEPTH = 16;
+/** A buyback's admin witness and swap bounds; `quoteIn` is atomic Quote. */
+type BuybackInput = {
+  adminWitness: TransactionObjectInput;
+  quoteIn: bigint;
+  minMemeOut: bigint;
+};
 
+/**
+ * `blast_migrators` venue calls, in Move argument order; `&mut TxContext` is
+ * implicit and the `Clock` is `0x6`. The migrators and vault package
+ * versions, the `VenueConfig`, the `VaultRegistry` and the core treasury
+ * come from the deployment. `prepare*` return the `VenueTicket<Meme, Quote>`
+ * the product's `new` consumes; `migrate*` consume the product's
+ * `Migration<Meme, Quote>` in the same PTB. Cetus calls take
+ * `<Meme, Quote, CoinA, CoinB>` with the pool's coin order from
+ * `cetusMemeSide`, so pass original (defining) type addresses.
+ */
 export class MigratorCalls {
   readonly deployment: MigratorsDeployment;
-  readonly launchpad: LaunchpadCalls;
+  /** `blast_migrators::BLAST_MIGRATORS`, the package's OTW. */
+  readonly otw: string;
 
   constructor(deployment: MigratorsDeployment) {
-    this.launchpad = new LaunchpadCalls(deployment.launchpad);
-    this.deployment = {
-      ...normalizeSuiPackageReference("migrators", deployment),
-      launchpad: this.launchpad.deployment,
-      migratorsVersion: normalizeSharedObjectIdentity(
-        "migratorsVersion",
-        deployment.migratorsVersion,
-      ),
-      lpFeePolicy: normalizeSharedObjectIdentity(
-        "lpFeePolicy",
-        deployment.lpFeePolicy,
-      ),
-      venueConfig: normalizeSharedObjectIdentity(
-        "venueConfig",
-        deployment.venueConfig,
-      ),
-    };
-  }
-
-  /** The adapter witness type a launch stores as its `migration_witness`. */
-  migrationWitnessType(venue: MigratorVenue): string {
-    return normalizeStructTag(
-      `${this.deployment.originalPackageId}::${venue}::Witness`,
+    this.deployment = normalizeMigratorsDeployment(deployment);
+    this.otw = normalizeStructTag(
+      `${this.deployment.originalPackageId}::blast_migrators::BLAST_MIGRATORS`,
     );
   }
 
-  signIn(options: {
-    adminCap: TransactionObjectInput;
-    role: BlastFunAdminRole;
-  }) {
-    return this.launchpad.signIn(options);
-  }
-
   /**
-   * Starts a Cetus launch at `tickSpacing`: Cetus derives the fee rate, and the
-   * Meme type's single `PoolCreationCap` is minted and reserved for the pair.
-   * Returns the `LaunchInitializer`, which the same PTB must finalize.
+   * `cetus::prepare<Meme, Quote>(migrators_version, venue_config,
+   * cetus_config, pools, &mut sealed_treasury_cap, admission, tick_spacing)`:
+   * borrows the coin's sealed `TreasuryCap` with the product's `VenueAdmission`
+   * of this venue (`launch_config::venue_admission` or
+   * `creation_policy::venue_admission`, built earlier in the same PTB),
+   * reserves the Meme's Cetus pool and returns its `VenueTicket`.
    */
-  newCetusLaunch(
-    options: LaunchTypes &
-      CetusObjects & {
-        ticket: TransactionObjectInput;
-        cetusPools: SharedObjectReference<true>;
-        tickSpacing: number;
-      },
-  ) {
-    const types = normalizeLaunchTypes(options);
+  prepareCetus(options: {
+    memeType: string;
+    quoteType: string;
+    cetus: { config: SharedObjectIdentity; pools: SharedObjectIdentity };
+    sealedTreasuryCap: TransactionObjectInput;
+    admission: TransactionArgument;
+    tickSpacing: number;
+  }): (tx: Transaction) => TransactionResult {
+    const types = pair(options);
     const tickSpacing = requireU32("tickSpacing", options.tickSpacing);
-    return (tx: Transaction): TransactionResult =>
+    const cetus = {
+      config: normalizeSharedObjectIdentity(
+        "cetus.config",
+        options.cetus.config,
+      ),
+      pools: normalizeSharedObjectIdentity("cetus.pools", options.cetus.pools),
+    };
+    return (tx) =>
       tx.moveCall({
-        target: `${this.deployment.packageId}::cetus::new`,
-        typeArguments: [types.memeType, types.quoteType],
+        target: this.#target("cetus", "prepare"),
+        typeArguments: types,
         arguments: [
-          tx.object(options.ticket),
           this.#migratorsVersion(tx),
-          this.#launchpadVersion(tx),
-          this.#launchConfig(tx),
           deploymentObject(tx, this.deployment.venueConfig, true),
-          sharedObject(tx, "cetusConfig", options.cetusConfig, false),
-          sharedObject(tx, "cetusPools", options.cetusPools, true),
+          deploymentObject(tx, cetus.config, false),
+          deploymentObject(tx, cetus.pools, true),
+          tx.object(options.sealedTreasuryCap),
+          options.admission,
           tx.pure.u32(tickSpacing),
         ],
       });
   }
 
   /**
-   * Starts a Bluefin launch at the creator's tier (tick spacing 1-400, fee rate
-   * 1-20,000, Bluefin's own bounds). Returns the `LaunchInitializer`.
+   * `bluefin::prepare<Meme, Quote>(migrators_version, venue_config,
+   * &sealed_treasury_cap, &currency, tick_spacing, fee_rate)`: records the
+   * Meme's Bluefin tier and returns its `VenueTicket`. The sealed cap only
+   * proves control of the coin; Bluefin reserves nothing, so it is never
+   * borrowed. Rejects a tier outside
+   * Bluefin's own bounds (`EInvalidTier`: tick spacing 1..=400, fee rate
+   * 1..=20,000); the contract also aborts with `ESymbolTooLong` when the
+   * Meme symbol exceeds 32 bytes.
    */
-  newBluefinLaunch(
-    options: LaunchTypes & {
-      ticket: TransactionObjectInput;
-      tickSpacing: number;
-      feeRate: bigint;
-    },
-  ) {
-    const types = normalizeLaunchTypes(options);
+  prepareBluefin(options: {
+    memeType: string;
+    quoteType: string;
+    sealedTreasuryCap: TransactionObjectInput;
+    currency: SharedObjectIdentity;
+    tickSpacing: number;
+    feeRate: bigint;
+  }): (tx: Transaction) => TransactionResult {
+    const types = pair(options);
     const tickSpacing = requireU32("tickSpacing", options.tickSpacing);
-    requireU64("feeRate", options.feeRate);
-    return (tx: Transaction): TransactionResult =>
+    const feeRate = requireU64("feeRate", options.feeRate);
+    if (
+      tickSpacing === 0 ||
+      tickSpacing > BLUEFIN_MAX_TICK_SPACING ||
+      feeRate === 0n ||
+      feeRate > BLUEFIN_MAX_FEE_RATE
+    ) {
+      throw new RangeError(
+        `a Bluefin tier needs a tick spacing in 1..=${BLUEFIN_MAX_TICK_SPACING} and a fee rate in 1..=${BLUEFIN_MAX_FEE_RATE}`,
+      );
+    }
+    const currency = normalizeSharedObjectIdentity(
+      "currency",
+      options.currency,
+    );
+    return (tx) =>
       tx.moveCall({
-        target: `${this.deployment.packageId}::bluefin::new`,
-        typeArguments: [types.memeType, types.quoteType],
+        target: this.#target("bluefin", "prepare"),
+        typeArguments: types,
         arguments: [
-          tx.object(options.ticket),
           this.#migratorsVersion(tx),
-          this.#launchpadVersion(tx),
-          this.#launchConfig(tx),
+          deploymentObject(tx, this.deployment.venueConfig, true),
+          tx.object(options.sealedTreasuryCap),
+          deploymentObject(tx, currency, false),
           tx.pure.u32(tickSpacing),
-          tx.pure.u64(options.feeRate),
+          tx.pure.u64(feeRate),
         ],
       });
   }
 
   /**
-   * Migrates a MigrationReady Cetus launch: creates the pool with the reserved
-   * capability, seeds full-range liquidity, and burns the position through
-   * Cetus LP Burn. Anyone may call it.
+   * `cetus::migrate<Meme, Quote, CoinA, CoinB>(migration, migrators_version,
+   * venue_config, cetus_config, pools, burn_manager, registry, vault_version,
+   * treasury, clock)`; `CoinA`/`CoinB` follow `cetusMemeSide`. Cetus writes
+   * a clock-dependent amount of storage, so the PTB is budgeted at gross
+   * cost (`grossGasBudget`).
    */
-  migrateCetus(
-    options: LaunchTypes &
-      CetusObjects & {
-        memeSide: CetusMemeSide;
-        launch: SharedObjectReference<true>;
-        memeCurrency: SharedObjectReference<true>;
-        cetusPools: SharedObjectReference<true>;
-        /** Cetus LP Burn `lp_burn::BurnManager`. */
-        burnManager: SharedObjectReference<true>;
-      },
-  ) {
-    const types = normalizeLaunchTypes(options);
-    const memeSide = normalizeMemeSide(options.memeSide);
-    return (tx: Transaction): void => {
-      // Cetus seeds a new pool's tick skip list from the clock, so its storage
-      // differs between simulation and execution by up to 18 bytes, more than
-      // the default budget's headroom: budget this transaction at gross cost.
+  migrateCetus(options: {
+    migration: TransactionArgument;
+    memeType: string;
+    quoteType: string;
+    cetus: {
+      config: SharedObjectIdentity;
+      pools: SharedObjectIdentity;
+      burnManager: SharedObjectIdentity;
+    };
+  }): (tx: Transaction) => void {
+    const typeArguments = cetusTypeArguments(options);
+    const cetus = {
+      config: normalizeSharedObjectIdentity(
+        "cetus.config",
+        options.cetus.config,
+      ),
+      pools: normalizeSharedObjectIdentity("cetus.pools", options.cetus.pools),
+      burnManager: normalizeSharedObjectIdentity(
+        "cetus.burnManager",
+        options.cetus.burnManager,
+      ),
+    };
+    return (tx) => {
       tx.addBuildPlugin(grossGasBudget());
       tx.moveCall({
-        target: `${this.deployment.packageId}::cetus::migrate`,
-        typeArguments: cetusTypeArguments(types, memeSide),
+        target: this.#target("cetus", "migrate"),
+        typeArguments,
         arguments: [
-          sharedObject(tx, "launch", options.launch, true),
+          options.migration,
           this.#migratorsVersion(tx),
-          this.#launchpadVersion(tx),
-          sharedObject(tx, "memeCurrency", options.memeCurrency, true),
           deploymentObject(tx, this.deployment.venueConfig, false),
-          sharedObject(tx, "cetusConfig", options.cetusConfig, false),
-          sharedObject(tx, "cetusPools", options.cetusPools, true),
-          sharedObject(tx, "burnManager", options.burnManager, true),
+          deploymentObject(tx, cetus.config, false),
+          deploymentObject(tx, cetus.pools, true),
+          deploymentObject(tx, cetus.burnManager, true),
+          deploymentObject(tx, this.deployment.vault.registry, true),
+          this.#vaultVersion(tx),
+          this.#treasury(tx),
           tx.object.clock(),
         ],
       });
@@ -237,31 +314,48 @@ export class MigratorCalls {
   }
 
   /**
-   * Migrates a MigrationReady Bluefin launch into a new `Pool<Meme, Quote>`.
-   * `creationFee` must be exactly Bluefin's configured SUI pool-creation fee.
+   * `bluefin::migrate<Meme, Quote>(migration, migrators_version,
+   * venue_config, currency, quote_currency, bluefin_config, registry,
+   * vault_version, treasury, creation_fee, clock)`; `creationFee` is a
+   * `Coin<SUI>` of Bluefin's pool creation fee.
    */
-  migrateBluefin(
-    options: LaunchTypes & {
-      launch: SharedObjectReference<true>;
-      memeCurrency: SharedObjectReference<true>;
-      quoteCurrency: SharedObjectReference<false>;
-      bluefinConfig: SharedObjectReference<true>;
-      creationFee: TransactionObjectInput;
-    },
-  ) {
-    const types = normalizeLaunchTypes(options);
-    return (tx: Transaction): void => {
+  migrateBluefin(options: {
+    migration: TransactionArgument;
+    memeType: string;
+    quoteType: string;
+    currency: SharedObjectIdentity;
+    quoteCurrency: SharedObjectIdentity;
+    bluefinConfig: SharedObjectIdentity;
+    creationFee: TransactionArgument;
+  }): (tx: Transaction) => void {
+    const types = pair(options);
+    const currency = normalizeSharedObjectIdentity(
+      "currency",
+      options.currency,
+    );
+    const quoteCurrency = normalizeSharedObjectIdentity(
+      "quoteCurrency",
+      options.quoteCurrency,
+    );
+    const bluefinConfig = normalizeSharedObjectIdentity(
+      "bluefinConfig",
+      options.bluefinConfig,
+    );
+    return (tx) => {
       tx.moveCall({
-        target: `${this.deployment.packageId}::bluefin::migrate`,
-        typeArguments: [types.memeType, types.quoteType],
+        target: this.#target("bluefin", "migrate"),
+        typeArguments: types,
         arguments: [
-          sharedObject(tx, "launch", options.launch, true),
+          options.migration,
           this.#migratorsVersion(tx),
-          this.#launchpadVersion(tx),
-          sharedObject(tx, "memeCurrency", options.memeCurrency, true),
-          sharedObject(tx, "quoteCurrency", options.quoteCurrency, false),
-          sharedObject(tx, "bluefinConfig", options.bluefinConfig, true),
-          tx.object(options.creationFee),
+          deploymentObject(tx, this.deployment.venueConfig, false),
+          deploymentObject(tx, currency, false),
+          deploymentObject(tx, quoteCurrency, false),
+          deploymentObject(tx, bluefinConfig, true),
+          deploymentObject(tx, this.deployment.vault.registry, true),
+          this.#vaultVersion(tx),
+          this.#treasury(tx),
+          options.creationFee,
           tx.object.clock(),
         ],
       });
@@ -269,214 +363,119 @@ export class MigratorCalls {
   }
 
   /**
-   * Collects the burned migration position's and the auto-LP position's fees,
-   * pays Blast's live share, splits the rest, burns the burn share's Meme, and
-   * adds the auto-LP share back. Anyone may call it.
+   * `cetus::collect_fees<Meme, Quote, CoinA, CoinB>(vault, migrators_version,
+   * vault_version, treasury, currency, cetus_config, burn_manager, pool)`:
+   * collects both positions' fees, splits them and burns the burn share's
+   * Meme; the auto-LP share waits in the vault for `compoundCetusAutoLp`.
+   * Anyone may call it.
    */
-  collectCetusFees(
-    options: LaunchTypes &
-      CetusObjects & {
-        memeSide: CetusMemeSide;
-        vault: SharedObjectReference<true>;
-        memeCurrency: SharedObjectReference<true>;
-        burnManager: SharedObjectReference<false>;
-        pool: SharedObjectReference<true>;
-      },
-  ) {
-    const types = normalizeLaunchTypes(options);
-    const memeSide = normalizeMemeSide(options.memeSide);
-    return (tx: Transaction): void => {
-      tx.moveCall({
-        target: `${this.deployment.packageId}::cetus::collect_fees`,
-        typeArguments: cetusTypeArguments(types, memeSide),
-        arguments: [
-          sharedObject(tx, "vault", options.vault, true),
-          this.#migratorsVersion(tx),
-          this.#lpFeePolicy(tx),
-          sharedObject(tx, "memeCurrency", options.memeCurrency, true),
-          sharedObject(tx, "cetusConfig", options.cetusConfig, false),
-          sharedObject(tx, "burnManager", options.burnManager, false),
-          sharedObject(tx, "pool", options.pool, true),
-          tx.object.clock(),
-        ],
-      });
-    };
+  collectCetusFees(options: CetusVaultInput): (tx: Transaction) => void {
+    return this.#cetusFees("collect_fees", options);
   }
 
-  /** Collects, splits, burns, and adds auto-LP for a Bluefin vault. Anyone may call it. */
-  collectBluefinFees(
-    options: LaunchTypes & {
-      vault: SharedObjectReference<true>;
-      memeCurrency: SharedObjectReference<true>;
-      bluefinConfig: SharedObjectReference<false>;
-      pool: SharedObjectReference<true>;
-    },
-  ) {
-    const types = normalizeLaunchTypes(options);
-    return (tx: Transaction): void => {
-      tx.moveCall({
-        target: `${this.deployment.packageId}::bluefin::collect_fees`,
-        typeArguments: [types.memeType, types.quoteType],
-        arguments: [
-          sharedObject(tx, "vault", options.vault, true),
-          this.#migratorsVersion(tx),
-          this.#lpFeePolicy(tx),
-          sharedObject(tx, "memeCurrency", options.memeCurrency, true),
-          sharedObject(tx, "bluefinConfig", options.bluefinConfig, false),
-          sharedObject(tx, "pool", options.pool, true),
-          tx.object.clock(),
-        ],
-      });
-    };
+  /**
+   * `cetus::settle_and_apply_fee_split(..., pool, clock)`: `collectCetusFees`
+   * under the current split, then applies the ready scheduled split. Anyone
+   * may call it.
+   */
+  settleAndApplyCetusFeeSplit(
+    options: CetusVaultInput,
+  ): (tx: Transaction) => void {
+    return this.#cetusFees("settle_and_apply_fee_split", options);
   }
 
   /**
-   * Settles the fees accrued under the current split, then commits `feeSplit`
-   * as the vault's split. Only the launch's live `CurveFeeCap` authorizes it.
-   * `launch` is read immutably by Move.
+   * `bluefin::collect_fees<Meme, Quote>(vault, migrators_version,
+   * vault_version, treasury, currency, bluefin_config, pool, clock)`: the
+   * auto-LP share waits in the vault for `compoundBluefinAutoLp`. Anyone may
+   * call it.
    */
-  settleAndUpdateCetusFeeSplit(
-    options: LaunchTypes &
-      CetusObjects & {
-        memeSide: CetusMemeSide;
-        vault: SharedObjectReference<true>;
-        launch: SharedObjectReference;
-        curveFeeCap: TransactionObjectInput;
-        memeCurrency: SharedObjectReference<true>;
-        burnManager: SharedObjectReference<false>;
-        pool: SharedObjectReference<true>;
-        feeSplit: FeeSplit;
-      },
-  ) {
-    const types = normalizeLaunchTypes(options);
-    const memeSide = normalizeMemeSide(options.memeSide);
-    const feeSplit = this.launchpad.feeSplit(options.feeSplit);
-    return (tx: Transaction): void => {
-      tx.moveCall({
-        target: `${this.deployment.packageId}::cetus::settle_and_update_fee_split`,
-        typeArguments: cetusTypeArguments(types, memeSide),
-        arguments: [
-          sharedObject(tx, "vault", options.vault, true),
-          this.#migratorsVersion(tx),
-          this.#lpFeePolicy(tx),
-          sharedObject(tx, "launch", options.launch, options.launch.mutable),
-          tx.object(options.curveFeeCap),
-          sharedObject(tx, "memeCurrency", options.memeCurrency, true),
-          sharedObject(tx, "cetusConfig", options.cetusConfig, false),
-          sharedObject(tx, "burnManager", options.burnManager, false),
-          sharedObject(tx, "pool", options.pool, true),
-          tx.add(feeSplit),
-          tx.object.clock(),
-        ],
-      });
-    };
+  collectBluefinFees(options: BluefinVaultInput): (tx: Transaction) => void {
+    return this.#bluefinFees("collect_fees", options);
   }
 
-  /** Bluefin counterpart of `settleAndUpdateCetusFeeSplit`. */
-  settleAndUpdateBluefinFeeSplit(
-    options: LaunchTypes & {
-      vault: SharedObjectReference<true>;
-      launch: SharedObjectReference;
-      curveFeeCap: TransactionObjectInput;
-      memeCurrency: SharedObjectReference<true>;
-      bluefinConfig: SharedObjectReference<false>;
-      pool: SharedObjectReference<true>;
-      feeSplit: FeeSplit;
-    },
-  ) {
-    const types = normalizeLaunchTypes(options);
-    const feeSplit = this.launchpad.feeSplit(options.feeSplit);
-    return (tx: Transaction): void => {
-      tx.moveCall({
-        target: `${this.deployment.packageId}::bluefin::settle_and_update_fee_split`,
-        typeArguments: [types.memeType, types.quoteType],
-        arguments: [
-          sharedObject(tx, "vault", options.vault, true),
-          this.#migratorsVersion(tx),
-          this.#lpFeePolicy(tx),
-          sharedObject(tx, "launch", options.launch, options.launch.mutable),
-          tx.object(options.curveFeeCap),
-          sharedObject(tx, "memeCurrency", options.memeCurrency, true),
-          sharedObject(tx, "bluefinConfig", options.bluefinConfig, false),
-          sharedObject(tx, "pool", options.pool, true),
-          tx.add(feeSplit),
-          tx.object.clock(),
-        ],
-      });
-    };
+  /** `bluefin::settle_and_apply_fee_split`, same arguments as `collectBluefinFees`. */
+  settleAndApplyBluefinFeeSplit(
+    options: BluefinVaultInput,
+  ): (tx: Transaction) => void {
+    return this.#bluefinFees("settle_and_apply_fee_split", options);
   }
 
-  /**
-   * Swaps `quoteIn` atomic units of the vault's burn Quote for Meme in its
-   * Cetus pool and burns it, under a `BuybackAdmin` witness. The contract
-   * aborts with `EBuybackQuoteOutOfRange` when `quoteIn` exceeds the vault's
-   * burn Quote, and unless the swap returns at least `minMemeOut`; set it from
-   * an off-chain price, since anyone can move the pool's price within a
-   * transaction. Unspent Quote waits for the next buyback.
+  /** Adds waiting auto-LP balances under AutoLpAdmin and keeper price bounds.
+   * The private entry consumes and re-shares the pool, so put it last in a PTB.
+   * Bounds are inclusive Q64.64 sqrt prices in venue pool coin order.
    */
-  buybackAndBurnCetus(
-    options: LaunchTypes &
-      CetusObjects & {
-        memeSide: CetusMemeSide;
-        vault: SharedObjectReference<true>;
-        adminWitness: TransactionObjectInput;
-        memeCurrency: SharedObjectReference<true>;
-        pool: SharedObjectReference<true>;
-        quoteIn: bigint;
-        minMemeOut: bigint;
+  compoundCetusAutoLp(
+    options: PairTypes &
+      AutoLpInput & {
+        vault: SharedObjectIdentity;
+        cetus: { config: SharedObjectIdentity };
+        pool: SharedObjectIdentity;
       },
-  ) {
-    const types = normalizeLaunchTypes(options);
-    const memeSide = normalizeMemeSide(options.memeSide);
-    const quoteIn = requirePositiveU64("quoteIn", options.quoteIn);
-    const minMemeOut = requireU64("minMemeOut", options.minMemeOut);
-    return (tx: Transaction): void => {
+  ): (tx: Transaction) => void {
+    const typeArguments = cetusTypeArguments(options);
+    const objects = {
+      vault: normalizeSharedObjectIdentity("vault", options.vault),
+      config: normalizeSharedObjectIdentity(
+        "cetus.config",
+        options.cetus.config,
+      ),
+      pool: normalizeSharedObjectIdentity("pool", options.pool),
+    };
+    const [min, max] = autoLpPriceBounds(options);
+    return (tx) => {
       tx.moveCall({
-        target: `${this.deployment.packageId}::cetus::buyback_and_burn`,
-        typeArguments: cetusTypeArguments(types, memeSide),
+        target: this.#target("cetus", "compound_auto_lp"),
+        typeArguments,
         arguments: [
-          sharedObject(tx, "vault", options.vault, true),
+          deploymentObject(tx, objects.vault, true),
           this.#migratorsVersion(tx),
-          tx.object(options.adminWitness),
-          sharedObject(tx, "memeCurrency", options.memeCurrency, true),
-          sharedObject(tx, "cetusConfig", options.cetusConfig, false),
-          sharedObject(tx, "pool", options.pool, true),
-          tx.pure.u64(quoteIn),
-          tx.pure.u64(minMemeOut),
+          this.#vaultVersion(tx),
+          deploymentObject(tx, this.deployment.vault.admin.acl, false),
+          tx.object(options.adminCap),
+          deploymentObject(tx, objects.config, false),
+          deploymentObject(tx, objects.pool, true),
+          tx.pure.u128(min),
+          tx.pure.u128(max),
           tx.object.clock(),
         ],
       });
     };
   }
 
-  /** Bluefin counterpart of `buybackAndBurnCetus`. */
-  buybackAndBurnBluefin(
-    options: LaunchTypes & {
-      vault: SharedObjectReference<true>;
-      adminWitness: TransactionObjectInput;
-      memeCurrency: SharedObjectReference<true>;
-      bluefinConfig: SharedObjectReference<false>;
-      pool: SharedObjectReference<true>;
-      quoteIn: bigint;
-      minMemeOut: bigint;
-    },
-  ) {
-    const types = normalizeLaunchTypes(options);
-    const quoteIn = requirePositiveU64("quoteIn", options.quoteIn);
-    const minMemeOut = requireU64("minMemeOut", options.minMemeOut);
-    return (tx: Transaction): void => {
+  /** Bluefin's private AutoLpAdmin entry; see compoundCetusAutoLp. */
+  compoundBluefinAutoLp(
+    options: PairTypes &
+      AutoLpInput & {
+        vault: SharedObjectIdentity;
+        bluefinConfig: SharedObjectIdentity;
+        pool: SharedObjectIdentity;
+      },
+  ): (tx: Transaction) => void {
+    const types = pair(options);
+    const objects = {
+      vault: normalizeSharedObjectIdentity("vault", options.vault),
+      config: normalizeSharedObjectIdentity(
+        "bluefinConfig",
+        options.bluefinConfig,
+      ),
+      pool: normalizeSharedObjectIdentity("pool", options.pool),
+    };
+    const [min, max] = autoLpPriceBounds(options);
+    return (tx) => {
       tx.moveCall({
-        target: `${this.deployment.packageId}::bluefin::buyback_and_burn`,
-        typeArguments: [types.memeType, types.quoteType],
+        target: this.#target("bluefin", "compound_auto_lp"),
+        typeArguments: types,
         arguments: [
-          sharedObject(tx, "vault", options.vault, true),
+          deploymentObject(tx, objects.vault, true),
           this.#migratorsVersion(tx),
-          tx.object(options.adminWitness),
-          sharedObject(tx, "memeCurrency", options.memeCurrency, true),
-          sharedObject(tx, "bluefinConfig", options.bluefinConfig, false),
-          sharedObject(tx, "pool", options.pool, true),
-          tx.pure.u64(quoteIn),
-          tx.pure.u64(minMemeOut),
+          this.#vaultVersion(tx),
+          deploymentObject(tx, this.deployment.vault.admin.acl, false),
+          tx.object(options.adminCap),
+          deploymentObject(tx, objects.config, false),
+          deploymentObject(tx, objects.pool, true),
+          tx.pure.u128(min),
+          tx.pure.u128(max),
           tx.object.clock(),
         ],
       });
@@ -484,580 +483,296 @@ export class MigratorCalls {
   }
 
   /**
-   * Claims the creator's accrued LP fees with the launch's live `CurveFeeCap`.
-   * `launch` is read immutably by Move.
+   * `cetus::buyback_and_burn<Meme, Quote, CoinA, CoinB>(vault,
+   * migrators_version, vault_version, admin_witness, currency, cetus_config,
+   * pool, quote_in, min_meme_out, clock)` under a `BuybackAdmin` witness.
+   * Swaps `quoteIn` of the vault's burn Quote and burns the Meme bought;
+   * aborts unless the swap returns at least `minMemeOut`, which the admin
+   * sets from an off-chain price.
    */
-  claimCreatorFees(
-    options: LaunchTypes & {
-      vault: SharedObjectReference<true>;
-      launch: SharedObjectReference;
-      curveFeeCap: TransactionObjectInput;
-    },
-  ) {
-    const types = normalizeLaunchTypes(options);
-    return (tx: Transaction): TransactionResult =>
-      tx.moveCall({
-        target: `${this.deployment.packageId}::vault::claim_creator_fees`,
-        typeArguments: [types.memeType, types.quoteType],
-        arguments: [
-          sharedObject(tx, "vault", options.vault, true),
-          this.#migratorsVersion(tx),
-          sharedObject(tx, "launch", options.launch, options.launch.mutable),
-          tx.object(options.curveFeeCap),
-        ],
-      });
-  }
-
-  /**
-   * `vault::claim_protocol_lp_fees_with_partner`: pays a partnered vault's held
-   * Blast LP fees, the launch's partner its cut in force of each asset, rounded
-   * down, and the `LpFeePolicy` destination the rest. Anyone may call it;
-   * holding nothing pays nothing.
-   */
-  claimProtocolLpFeesWithPartner(
-    options: LaunchTypes & {
-      vault: SharedObjectReference<true>;
-      partner: SharedObjectReference<false>;
-    },
-  ) {
-    const types = normalizeLaunchTypes(options);
-    return (tx: Transaction): void => {
-      tx.moveCall({
-        target: `${this.deployment.packageId}::vault::claim_protocol_lp_fees_with_partner`,
-        typeArguments: [types.memeType, types.quoteType],
-        arguments: [
-          sharedObject(tx, "vault", options.vault, true),
-          this.#migratorsVersion(tx),
-          this.#lpFeePolicy(tx),
-          sharedObject(tx, "partner", options.partner, false),
-          tx.object.clock(),
-        ],
-      });
+  buybackAndBurnCetus(
+    options: PairTypes &
+      BuybackInput & {
+        vault: SharedObjectIdentity;
+        currency: SharedObjectIdentity;
+        cetus: { config: SharedObjectIdentity };
+        pool: SharedObjectIdentity;
+      },
+  ): (tx: Transaction) => void {
+    const typeArguments = cetusTypeArguments(options);
+    const objects = {
+      vault: normalizeSharedObjectIdentity("vault", options.vault),
+      currency: normalizeSharedObjectIdentity("currency", options.currency),
+      config: normalizeSharedObjectIdentity(
+        "cetus.config",
+        options.cetus.config,
+      ),
+      pool: normalizeSharedObjectIdentity("pool", options.pool),
     };
-  }
-
-  /** Claims the protocol-owned migration residuals under a `TreasuryAdmin` witness. */
-  claimProtocolFees(
-    options: LaunchTypes & {
-      vault: SharedObjectReference<true>;
-      adminWitness: TransactionObjectInput;
-    },
-  ) {
-    const types = normalizeLaunchTypes(options);
-    return (tx: Transaction): TransactionResult =>
+    const amounts = buybackAmounts(options);
+    return (tx) => {
       tx.moveCall({
-        target: `${this.deployment.packageId}::vault::claim_protocol_fees`,
-        typeArguments: [types.memeType, types.quoteType],
+        target: this.#target("cetus", "buyback_and_burn"),
+        typeArguments,
         arguments: [
-          sharedObject(tx, "vault", options.vault, true),
+          deploymentObject(tx, objects.vault, true),
           this.#migratorsVersion(tx),
+          this.#vaultVersion(tx),
           tx.object(options.adminWitness),
+          deploymentObject(tx, objects.currency, true),
+          deploymentObject(tx, objects.config, false),
+          deploymentObject(tx, objects.pool, true),
+          tx.pure.u64(amounts.quoteIn),
+          tx.pure.u64(amounts.minMemeOut),
+          tx.object.clock(),
         ],
       });
-  }
-
-  /** Changes Blast's default Meme and Quote LP-fee shares for coins without their own pair (`FeeAdmin`). */
-  setLpFeeDefaultShares(options: {
-    adminWitness: TransactionObjectInput;
-    memeBps: bigint;
-    quoteBps: bigint;
-  }) {
-    return this.#lpFeePolicyAdmin("set_default_shares", [], options, (tx) => [
-      tx.add(this.launchpad.bps(options.memeBps)),
-      tx.add(this.launchpad.bps(options.quoteBps)),
-    ]);
-  }
-
-  /** Sets Blast's LP-fee shares for one original Meme type (`FeeAdmin`). */
-  setLpFeeCoinShares(options: {
-    memeType: string;
-    adminWitness: TransactionObjectInput;
-    memeBps: bigint;
-    quoteBps: bigint;
-  }) {
-    return this.#lpFeePolicyAdmin(
-      "set_coin_shares",
-      [normalizeStructTag(options.memeType)],
-      options,
-      (tx) => [
-        tx.add(this.launchpad.bps(options.memeBps)),
-        tx.add(this.launchpad.bps(options.quoteBps)),
-      ],
-    );
-  }
-
-  /** Removes one Meme type's own pair so its collections use the defaults again (`FeeAdmin`). */
-  clearLpFeeCoinShares(options: {
-    memeType: string;
-    adminWitness: TransactionObjectInput;
-  }) {
-    return this.#lpFeePolicyAdmin(
-      "clear_coin_shares",
-      [normalizeStructTag(options.memeType)],
-      options,
-      () => [],
-    );
-  }
-
-  /** Redirects every later protocol LP-fee payout (`TreasuryAdmin`). */
-  setLpFeeProtocolDestination(options: {
-    adminWitness: TransactionObjectInput;
-    destination: string;
-  }) {
-    const destination = normalizeSuiAddress(options.destination);
-    return this.#lpFeePolicyAdmin(
-      "set_protocol_destination",
-      [],
-      options,
-      (tx) => [tx.pure.address(destination)],
-    );
+    };
   }
 
   /**
-   * Publishes a holder-reward round from a validated manifest, reserving its
-   * budget from the vault's rewards balance, and shares the `Round`
-   * (`RewardsAdmin`).
+   * `bluefin::buyback_and_burn<Meme, Quote>(vault, migrators_version,
+   * vault_version, admin_witness, currency, bluefin_config, pool, quote_in,
+   * min_meme_out, clock)`; see `buybackAndBurnCetus`.
    */
-  publishHolderRewardRound(
-    options: LaunchTypes & {
-      vault: SharedObjectReference<true>;
-      adminWitness: TransactionObjectInput;
-      manifest: RewardManifest;
-    },
-  ) {
-    const types = normalizeLaunchTypes(options);
-    const manifest = validateRewardManifest(
-      options.manifest,
-      MIGRATOR_REWARD_LEAF_DOMAIN,
-    );
-    if (
-      rewardAddress(manifest.vaultId) !== rewardAddress(options.vault.objectId)
-    ) {
-      throw new TypeError("manifest belongs to another vault");
-    }
-    return (tx: Transaction): void => {
+  buybackAndBurnBluefin(
+    options: PairTypes &
+      BuybackInput & {
+        vault: SharedObjectIdentity;
+        currency: SharedObjectIdentity;
+        bluefinConfig: SharedObjectIdentity;
+        pool: SharedObjectIdentity;
+      },
+  ): (tx: Transaction) => void {
+    const types = pair(options);
+    const objects = {
+      vault: normalizeSharedObjectIdentity("vault", options.vault),
+      currency: normalizeSharedObjectIdentity("currency", options.currency),
+      config: normalizeSharedObjectIdentity(
+        "bluefinConfig",
+        options.bluefinConfig,
+      ),
+      pool: normalizeSharedObjectIdentity("pool", options.pool),
+    };
+    const amounts = buybackAmounts(options);
+    return (tx) => {
       tx.moveCall({
-        target: `${this.deployment.packageId}::blast_holder_rewards::publish_round`,
-        typeArguments: [types.memeType, types.quoteType],
+        target: this.#target("bluefin", "buyback_and_burn"),
+        typeArguments: types,
         arguments: [
-          sharedObject(tx, "vault", options.vault, true),
+          deploymentObject(tx, objects.vault, true),
           this.#migratorsVersion(tx),
+          this.#vaultVersion(tx),
           tx.object(options.adminWitness),
-          tx.pure.u64(manifest.number),
-          tx.pure.u64(manifest.startCheckpoint),
-          tx.pure.u64(manifest.endCheckpoint),
-          tx.pure.vector("u8", rewardDigest(manifest.root)),
-          tx.pure.vector("u8", rewardDigest(manifest.manifestDigest)),
-          tx.pure.u64(manifest.allocations.length),
-          tx.pure.u64(manifest.memeAmount),
-          tx.pure.u64(manifest.quoteAmount),
+          deploymentObject(tx, objects.currency, true),
+          deploymentObject(tx, objects.config, false),
+          deploymentObject(tx, objects.pool, true),
+          tx.pure.u64(amounts.quoteIn),
+          tx.pure.u64(amounts.minMemeOut),
+          tx.object.clock(),
         ],
       });
     };
   }
 
-  /** Relays one allocation's proof; the round pays its committed beneficiary. */
-  claimHolderReward(
-    options: LaunchTypes & {
-      round: SharedObjectReference<true>;
-      allocation: RewardProof;
-    },
-  ) {
-    const types = normalizeLaunchTypes(options);
-    const { allocation } = options;
-    const index = requireU64("index", BigInt(allocation.index));
-    const memeAmount = requireU64("memeAmount", BigInt(allocation.memeAmount));
-    const quoteAmount = requireU64(
-      "quoteAmount",
-      BigInt(allocation.quoteAmount),
-    );
-    const beneficiary = rewardAddress(allocation.beneficiary);
-    if (allocation.proof.length > MAX_HOLDER_REWARD_PROOF_DEPTH) {
-      throw new RangeError(
-        `proof exceeds ${MAX_HOLDER_REWARD_PROOF_DEPTH} siblings`,
-      );
-    }
-    const proof = allocation.proof.map((sibling) =>
-      Array.from(rewardDigest(sibling)),
-    );
-    return (tx: Transaction): void => {
+  #cetusFees(
+    name: "collect_fees" | "settle_and_apply_fee_split",
+    options: CetusVaultInput,
+  ): (tx: Transaction) => void {
+    const typeArguments = cetusTypeArguments(options);
+    const objects = {
+      vault: normalizeSharedObjectIdentity("vault", options.vault),
+      currency: normalizeSharedObjectIdentity("currency", options.currency),
+      config: normalizeSharedObjectIdentity(
+        "cetus.config",
+        options.cetus.config,
+      ),
+      burnManager: normalizeSharedObjectIdentity(
+        "cetus.burnManager",
+        options.cetus.burnManager,
+      ),
+      pool: normalizeSharedObjectIdentity("pool", options.pool),
+    };
+    return (tx) => {
       tx.moveCall({
-        target: `${this.deployment.packageId}::blast_holder_rewards::claim`,
-        typeArguments: [types.memeType, types.quoteType],
+        target: this.#target("cetus", name),
+        typeArguments,
         arguments: [
-          sharedObject(tx, "round", options.round, true),
+          deploymentObject(tx, objects.vault, true),
           this.#migratorsVersion(tx),
-          tx.pure.u64(index),
-          tx.pure.address(beneficiary),
-          tx.pure.u64(memeAmount),
-          tx.pure.u64(quoteAmount),
-          tx.pure.vector("vector<u8>", proof),
+          this.#vaultVersion(tx),
+          this.#treasury(tx),
+          deploymentObject(tx, objects.currency, true),
+          deploymentObject(tx, objects.config, false),
+          deploymentObject(tx, objects.burnManager, false),
+          deploymentObject(tx, objects.pool, true),
+          // Only the split's apply reads the clock.
+          ...(name === "settle_and_apply_fee_split" ? [tx.object.clock()] : []),
         ],
       });
     };
   }
 
-  #lpFeePolicyAdmin(
-    functionName: string,
-    typeArguments: string[],
-    options: { adminWitness: TransactionObjectInput },
-    extra: (tx: Transaction) => TransactionArgument[],
-  ) {
-    return (tx: Transaction): void => {
+  #bluefinFees(
+    name: "collect_fees" | "settle_and_apply_fee_split",
+    options: BluefinVaultInput,
+  ): (tx: Transaction) => void {
+    const types = pair(options);
+    const objects = {
+      vault: normalizeSharedObjectIdentity("vault", options.vault),
+      currency: normalizeSharedObjectIdentity("currency", options.currency),
+      config: normalizeSharedObjectIdentity(
+        "bluefinConfig",
+        options.bluefinConfig,
+      ),
+      pool: normalizeSharedObjectIdentity("pool", options.pool),
+    };
+    return (tx) => {
       tx.moveCall({
-        target: `${this.deployment.packageId}::lp_fee_policy::${functionName}`,
-        typeArguments,
+        target: this.#target("bluefin", name),
+        typeArguments: types,
         arguments: [
-          deploymentObject(tx, this.deployment.lpFeePolicy, true),
+          deploymentObject(tx, objects.vault, true),
           this.#migratorsVersion(tx),
-          tx.object(options.adminWitness),
-          ...extra(tx),
+          this.#vaultVersion(tx),
+          this.#treasury(tx),
+          deploymentObject(tx, objects.currency, true),
+          deploymentObject(tx, objects.config, false),
+          deploymentObject(tx, objects.pool, true),
+          tx.object.clock(),
         ],
       });
     };
   }
 
-  #migratorsVersion(tx: Transaction): TransactionObjectArgument {
-    return deploymentObject(tx, this.deployment.migratorsVersion, false);
+  #target(module: MigratorVenue, name: string): string {
+    return `${this.deployment.packageId}::${module}::${name}`;
   }
 
-  #launchpadVersion(tx: Transaction): TransactionObjectArgument {
-    return deploymentObject(
-      tx,
-      this.deployment.launchpad.packageVersion,
-      false,
-    );
+  #migratorsVersion(tx: Transaction): TransactionObjectArgument {
+    return deploymentObject(tx, this.deployment.packageVersion, false);
   }
 
-  #launchConfig(tx: Transaction): TransactionObjectArgument {
-    return deploymentObject(tx, this.deployment.launchpad.launchConfig, false);
+  #vaultVersion(tx: Transaction): TransactionObjectArgument {
+    return deploymentObject(tx, this.deployment.vault.packageVersion, false);
   }
 
-  #lpFeePolicy(tx: Transaction): TransactionObjectArgument {
-    return deploymentObject(tx, this.deployment.lpFeePolicy, false);
+  #treasury(tx: Transaction): TransactionObjectArgument {
+    return deploymentObject(tx, this.deployment.vault.core.treasury, false);
   }
 }
 
+/**
+ * One-call PTBs for a migrated vault's venue routes: fee collection,
+ * settlement and auto-LP compounding (anyone) and buybacks (an `AdminCap` holding
+ * `blast_domain::BuybackAdmin`). Preparation and migration are composed
+ * with the product's own calls by the launchpad and presale packages.
+ */
 export class MigratorTransactions {
   readonly call: MigratorCalls;
-  readonly #useGasCoin: boolean;
+  readonly admin: AdminCalls;
 
-  constructor(
-    deployment: MigratorsDeployment,
-    options: CoinSourceOptions = {},
-  ) {
+  constructor(deployment: MigratorsDeployment) {
     this.call = new MigratorCalls(deployment);
-    this.#useGasCoin = options.useGasCoin ?? true;
+    this.admin = new AdminCalls(this.call.deployment.vault.admin);
   }
 
-  /**
-   * Starts, configures, finalizes, and shares a Cetus launch atomically, with
-   * an optional purchase on the owned launch, routed to its recipient.
-   */
-  createCetusLaunch(
-    options: CreateLaunchOptions &
-      CetusObjects & {
-        cetusPools: SharedObjectReference<true>;
-        tickSpacing: number;
-      },
-  ): Transaction {
-    const tx = new Transaction();
-    const initializer = tx.add(this.call.newCetusLaunch(options));
-    addLaunchCompletion(tx, this.call.launchpad, {
-      ...options,
-      initializer,
-      currency: options.memeCurrency,
-      useGasCoin: options.useGasCoin ?? this.#useGasCoin,
-    });
-    return tx;
-  }
-
-  /** Bluefin counterpart of `createCetusLaunch`. */
-  createBluefinLaunch(
-    options: CreateLaunchOptions & { tickSpacing: number; feeRate: bigint },
-  ): Transaction {
-    const tx = new Transaction();
-    const initializer = tx.add(this.call.newBluefinLaunch(options));
-    addLaunchCompletion(tx, this.call.launchpad, {
-      ...options,
-      initializer,
-      currency: options.memeCurrency,
-      useGasCoin: options.useGasCoin ?? this.#useGasCoin,
-    });
-    return tx;
+  collectCetusFees(options: CetusVaultInput): Transaction {
+    return single(this.call.collectCetusFees(options));
   }
 
-  migrateCetus(
-    options: Parameters<MigratorCalls["migrateCetus"]>[0],
-  ): Transaction {
-    const tx = new Transaction();
-    tx.add(this.call.migrateCetus(options));
-    return tx;
+  settleAndApplyCetusFeeSplit(options: CetusVaultInput): Transaction {
+    return single(this.call.settleAndApplyCetusFeeSplit(options));
   }
 
-  /** Pays Bluefin's SUI pool-creation fee as an exact-balance coin. */
-  migrateBluefin(
-    options: Omit<
-      Parameters<MigratorCalls["migrateBluefin"]>[0],
-      "creationFee"
-    > & {
-      creationFee: bigint;
-    } & CoinSourceOptions,
-  ): Transaction {
-    requireU64("creationFee", options.creationFee);
-    const tx = new Transaction();
-    const creationFee = tx.coin({
-      type: "0x2::sui::SUI",
-      balance: options.creationFee,
-      useGasCoin: options.useGasCoin ?? this.#useGasCoin,
-    });
-    tx.add(this.call.migrateBluefin({ ...options, creationFee }));
-    return tx;
+  collectBluefinFees(options: BluefinVaultInput): Transaction {
+    return single(this.call.collectBluefinFees(options));
   }
 
-  /** Then pays the vault's partner when `partner` is given; see `claimProtocolLpFeesWithPartner`. */
-  collectCetusFees(
-    options: Parameters<MigratorCalls["collectCetusFees"]>[0] & LpFeePartner,
-  ): Transaction {
-    const tx = new Transaction();
-    tx.add(this.call.collectCetusFees(options));
-    return this.#claimProtocolLpFeesWithPartnerAfter(tx, options);
+  settleAndApplyBluefinFeeSplit(options: BluefinVaultInput): Transaction {
+    return single(this.call.settleAndApplyBluefinFeeSplit(options));
   }
 
-  /** Then pays the vault's partner when `partner` is given; see `claimProtocolLpFeesWithPartner`. */
-  collectBluefinFees(
-    options: Parameters<MigratorCalls["collectBluefinFees"]>[0] & LpFeePartner,
+  compoundCetusAutoLp(
+    options: Parameters<MigratorCalls["compoundCetusAutoLp"]>[0],
   ): Transaction {
-    const tx = new Transaction();
-    tx.add(this.call.collectBluefinFees(options));
-    return this.#claimProtocolLpFeesWithPartnerAfter(tx, options);
+    return single(this.call.compoundCetusAutoLp(options));
   }
 
-  /** Pays a partnered vault's partner and Blast the LP fees its collections held. */
-  claimProtocolLpFeesWithPartner(
-    options: Parameters<MigratorCalls["claimProtocolLpFeesWithPartner"]>[0],
+  compoundBluefinAutoLp(
+    options: Parameters<MigratorCalls["compoundBluefinAutoLp"]>[0],
   ): Transaction {
-    const tx = new Transaction();
-    tx.add(this.call.claimProtocolLpFeesWithPartner(options));
-    return tx;
-  }
-
-  settleAndUpdateCetusFeeSplit(
-    options: Omit<
-      Parameters<MigratorCalls["settleAndUpdateCetusFeeSplit"]>[0],
-      "curveFeeCap"
-    > & { curveFeeCapId: string },
-  ): Transaction {
-    const tx = new Transaction();
-    tx.add(
-      this.call.settleAndUpdateCetusFeeSplit({
-        ...options,
-        curveFeeCap: options.curveFeeCapId,
-      }),
-    );
-    return tx;
-  }
-
-  settleAndUpdateBluefinFeeSplit(
-    options: Omit<
-      Parameters<MigratorCalls["settleAndUpdateBluefinFeeSplit"]>[0],
-      "curveFeeCap"
-    > & { curveFeeCapId: string },
-  ): Transaction {
-    const tx = new Transaction();
-    tx.add(
-      this.call.settleAndUpdateBluefinFeeSplit({
-        ...options,
-        curveFeeCap: options.curveFeeCapId,
-      }),
-    );
-    return tx;
-  }
-
-  claimCreatorFees(
-    options: LaunchTypes & {
-      vault: SharedObjectReference<true>;
-      launch: SharedObjectReference;
-      curveFeeCapId: string;
-      recipient: string;
-    },
-  ): Transaction {
-    const tx = new Transaction();
-    const result = tx.add(
-      this.call.claimCreatorFees({
-        ...options,
-        curveFeeCap: options.curveFeeCapId,
-      }),
-    );
-    tx.transferObjects(
-      moveResults(result, 2),
-      normalizeSuiAddress(options.recipient),
-    );
-    return tx;
-  }
-
-  claimProtocolFees(
-    options: LaunchTypes & {
-      vault: SharedObjectReference<true>;
-      adminCapId: string;
-      recipient: string;
-    },
-  ): Transaction {
-    const tx = new Transaction();
-    const adminWitness = tx.add(
-      this.call.signIn({ adminCap: options.adminCapId, role: "TreasuryAdmin" }),
-    );
-    const result = tx.add(
-      this.call.claimProtocolFees({ ...options, adminWitness }),
-    );
-    tx.transferObjects(
-      moveResults(result, 2),
-      normalizeSuiAddress(options.recipient),
-    );
-    return tx;
-  }
-
-  setLpFeeDefaultShares(options: {
-    adminCapId: string;
-    memeBps: bigint;
-    quoteBps: bigint;
-  }): Transaction {
-    return this.#asAdmin(options.adminCapId, "FeeAdmin", (adminWitness) =>
-      this.call.setLpFeeDefaultShares({ ...options, adminWitness }),
-    );
-  }
-
-  setLpFeeCoinShares(options: {
-    memeType: string;
-    adminCapId: string;
-    memeBps: bigint;
-    quoteBps: bigint;
-  }): Transaction {
-    return this.#asAdmin(options.adminCapId, "FeeAdmin", (adminWitness) =>
-      this.call.setLpFeeCoinShares({ ...options, adminWitness }),
-    );
-  }
-
-  clearLpFeeCoinShares(options: {
-    memeType: string;
-    adminCapId: string;
-  }): Transaction {
-    return this.#asAdmin(options.adminCapId, "FeeAdmin", (adminWitness) =>
-      this.call.clearLpFeeCoinShares({ ...options, adminWitness }),
-    );
-  }
-
-  setLpFeeProtocolDestination(options: {
-    adminCapId: string;
-    destination: string;
-  }): Transaction {
-    return this.#asAdmin(options.adminCapId, "TreasuryAdmin", (adminWitness) =>
-      this.call.setLpFeeProtocolDestination({ ...options, adminWitness }),
-    );
+    return single(this.call.compoundBluefinAutoLp(options));
   }
 
+  /** Signs in as `BuybackAdmin` with `adminCapId`, then `buybackAndBurnCetus`. */
   buybackAndBurnCetus(
     options: Omit<
       Parameters<MigratorCalls["buybackAndBurnCetus"]>[0],
       "adminWitness"
     > & { adminCapId: string },
   ): Transaction {
-    return this.#asAdmin(options.adminCapId, "BuybackAdmin", (adminWitness) =>
+    return this.#asBuybackAdmin(options.adminCapId, (adminWitness) =>
       this.call.buybackAndBurnCetus({ ...options, adminWitness }),
     );
   }
 
+  /** Signs in as `BuybackAdmin` with `adminCapId`, then `buybackAndBurnBluefin`. */
   buybackAndBurnBluefin(
     options: Omit<
       Parameters<MigratorCalls["buybackAndBurnBluefin"]>[0],
       "adminWitness"
     > & { adminCapId: string },
   ): Transaction {
-    return this.#asAdmin(options.adminCapId, "BuybackAdmin", (adminWitness) =>
+    return this.#asBuybackAdmin(options.adminCapId, (adminWitness) =>
       this.call.buybackAndBurnBluefin({ ...options, adminWitness }),
     );
   }
 
-  publishHolderRewardRound(
-    options: Omit<
-      Parameters<MigratorCalls["publishHolderRewardRound"]>[0],
-      "adminWitness"
-    > & { adminCapId: string },
-  ): Transaction {
-    return this.#asAdmin(options.adminCapId, "RewardsAdmin", (adminWitness) =>
-      this.call.publishHolderRewardRound({ ...options, adminWitness }),
-    );
-  }
-
-  /** Relays up to `allocations.length` proofs of one round in a single PTB. */
-  claimHolderRewards(
-    options: LaunchTypes & {
-      round: SharedObjectReference<true>;
-      allocations: readonly RewardProof[];
-    },
-  ): Transaction {
-    const tx = new Transaction();
-    for (const allocation of options.allocations) {
-      tx.add(this.call.claimHolderReward({ ...options, allocation }));
-    }
-    return tx;
-  }
-
-  #asAdmin(
+  #asBuybackAdmin(
     adminCapId: string,
-    role: BlastFunAdminRole,
     call: (
       adminWitness: TransactionObjectArgument,
     ) => (tx: Transaction) => void,
   ): Transaction {
     const tx = new Transaction();
     const adminWitness = tx.add(
-      this.call.signIn({ adminCap: adminCapId, role }),
+      this.admin.signIn({
+        adminCap: adminCapId,
+        role: coreRoleType(this.call.deployment.vault.core, "BuybackAdmin"),
+      }),
     );
     tx.add(call(adminWitness));
     return tx;
   }
+}
 
-  #claimProtocolLpFeesWithPartnerAfter(
-    tx: Transaction,
-    options: LaunchTypes & {
-      vault: SharedObjectReference<true>;
-    } & LpFeePartner,
-  ): Transaction {
-    const { partner } = options;
-    if (partner)
-      tx.add(this.call.claimProtocolLpFeesWithPartner({ ...options, partner }));
-    return tx;
-  }
+function single(step: (tx: Transaction) => void): Transaction {
+  const tx = new Transaction();
+  tx.add(step);
+  return tx;
 }
 
-function sharedObject<const Mutable extends boolean>(
-  tx: Transaction,
-  name: string,
-  reference: SharedObjectReference<Mutable>,
-  mutable: Mutable,
-): TransactionObjectArgument {
-  return tx.sharedObjectRef(
-    normalizeSharedObjectReference(name, reference, mutable),
-  );
+function pair(types: PairTypes): [string, string] {
+  return [
+    normalizeStructTag(types.memeType),
+    normalizeStructTag(types.quoteType),
+  ];
 }
 
-/** `[Meme, Quote, CoinA, CoinB]`, the pool's coins in Cetus order. */
-function cetusTypeArguments(
-  types: LaunchTypes,
-  memeSide: CetusMemeSide,
-): string[] {
-  const { memeType, quoteType } = types;
-  return memeSide === "a"
-    ? [memeType, quoteType, memeType, quoteType]
-    : [memeType, quoteType, quoteType, memeType];
+/** `<Meme, Quote, CoinA, CoinB>`, with the pool's coin order from `cetusMemeSide`. */
+function cetusTypeArguments(types: PairTypes): string[] {
+  const [meme, quote] = pair(types);
+  return cetusMemeSide(meme, quote) === "a"
+    ? [meme, quote, meme, quote]
+    : [meme, quote, quote, meme];
 }
 
-function normalizeMemeSide(value: CetusMemeSide): CetusMemeSide {
-  if (value !== "a" && value !== "b") {
-    throw new RangeError("memeSide must be a or b");
-  }
-  return value;
+function buybackAmounts(options: BuybackInput) {
+  return {
+    quoteIn: requirePositiveU64("quoteIn", options.quoteIn),
+    minMemeOut: requireU64("minMemeOut", options.minMemeOut),
+  };
 }
 
 function requireU32(name: string, value: number): number {
@@ -1066,3 +781,19 @@ function requireU32(name: string, value: number): number {
   }
   return value;
 }
+
+/** Authority and inclusive pool-order Q64.64 bounds for a private auto-LP entry. */
+export type AutoLpInput = {
+  adminCap: TransactionObjectInput;
+  minSqrtPrice: bigint;
+  maxSqrtPrice: bigint;
+};
+
+function autoLpPriceBounds(options: AutoLpInput): readonly [bigint, bigint] {
+  const min = requireU128("minSqrtPrice", options.minSqrtPrice);
+  const max = requireU128("maxSqrtPrice", options.maxSqrtPrice);
+  if (min === 0n || min > max) {
+    throw new RangeError("auto-LP needs 0 < minSqrtPrice <= maxSqrtPrice");
+  }
+  return [min, max];
+}