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

package/dist/transactions.js

@@ -1,599 +1,489 @@
+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, } from "@interest-protocol/blast-core/integers";
-import { deploymentObject, moveResults, } from "@interest-protocol/blast-core/ptb";
-import { MIGRATOR_REWARD_LEAF_DOMAIN, rewardAddress, rewardDigest, validateRewardManifest, } from "@interest-protocol/blast-core/rewards/allocations";
-import { normalizeSharedObjectIdentity, normalizeSharedObjectReference, normalizeSuiPackageReference, } from "@interest-protocol/blast-core/sui";
-import { addLaunchCompletion, LaunchpadCalls, normalizeLaunchTypes, } from "@interest-protocol/blast-launchpad-sdk/transactions";
+import { requirePositiveU64, requireU64, requireU128, } from "@interest-protocol/blast-core/integers";
+import { deploymentObject } from "@interest-protocol/blast-core/ptb";
+import { coreRoleType } from "@interest-protocol/blast-core/roles";
+import { normalizeSharedObjectIdentity, normalizeSuiPackageReference, } from "@interest-protocol/blast-core/sui";
+import { normalizeVaultDeployment } from "@interest-protocol/blast-vault-sdk/transactions";
 import { Transaction } from "@mysten/sui/transactions";
-import { normalizeStructTag, normalizeSuiAddress } from "@mysten/sui/utils";
-/** Maximum Merkle proof depth the holder-reward leaf count (65,536) allows. */
-export const MAX_HOLDER_REWARD_PROOF_DEPTH = 16;
+import { normalizeStructTag } from "@mysten/sui/utils";
+/** The venues `blast_migrators` defines, one module each. */
+export const MIGRATOR_VENUES = ["bluefin", "cetus"];
+/** `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 = 20000n;
+export function normalizeMigratorsDeployment(deployment) {
+    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, venue) {
+    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, typeName) {
+    const type = normalizeStructTag(typeName);
+    return (MIGRATOR_VENUES.find((venue) => venueWitnessType(migrators, venue) === type) ?? null);
+}
+/**
+ * `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 {
     deployment;
-    launchpad;
+    /** `blast_migrators::BLAST_MIGRATORS`, the package's OTW. */
+    otw;
     constructor(deployment) {
-        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) {
-        return normalizeStructTag(`${this.deployment.originalPackageId}::${venue}::Witness`);
-    }
-    signIn(options) {
-        return this.launchpad.signIn(options);
+        this.deployment = normalizeMigratorsDeployment(deployment);
+        this.otw = normalizeStructTag(`${this.deployment.originalPackageId}::blast_migrators::BLAST_MIGRATORS`);
     }
     /**
-     * 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) {
-        const types = normalizeLaunchTypes(options);
+    prepareCetus(options) {
+        const types = pair(options);
         const tickSpacing = requireU32("tickSpacing", options.tickSpacing);
+        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) {
-        const types = normalizeLaunchTypes(options);
+    prepareBluefin(options) {
+        const types = pair(options);
         const tickSpacing = requireU32("tickSpacing", options.tickSpacing);
-        requireU64("feeRate", options.feeRate);
+        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) {
-        const types = normalizeLaunchTypes(options);
-        const memeSide = normalizeMemeSide(options.memeSide);
+        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) => {
-            // 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.
             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(),
                 ],
             });
         };
     }
     /**
-     * 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) {
-        const types = normalizeLaunchTypes(options);
+        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(),
                 ],
             });
         };
     }
     /**
-     * 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) {
-        const types = normalizeLaunchTypes(options);
-        const memeSide = normalizeMemeSide(options.memeSide);
-        return (tx) => {
-            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(),
-                ],
-            });
-        };
+        return this.#cetusFees("collect_fees", options);
     }
-    /** Collects, splits, burns, and adds auto-LP for a Bluefin vault. Anyone may call it. */
-    collectBluefinFees(options) {
-        const types = normalizeLaunchTypes(options);
-        return (tx) => {
-            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) {
+        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) {
-        const types = normalizeLaunchTypes(options);
-        const memeSide = normalizeMemeSide(options.memeSide);
-        const feeSplit = this.launchpad.feeSplit(options.feeSplit);
+    collectBluefinFees(options) {
+        return this.#bluefinFees("collect_fees", options);
+    }
+    /** `bluefin::settle_and_apply_fee_split`, same arguments as `collectBluefinFees`. */
+    settleAndApplyBluefinFeeSplit(options) {
+        return this.#bluefinFees("settle_and_apply_fee_split", options);
+    }
+    /** 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.
+     */
+    compoundCetusAutoLp(options) {
+        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::settle_and_update_fee_split`,
-                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),
-                    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),
+                    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 `settleAndUpdateCetusFeeSplit`. */
-    settleAndUpdateBluefinFeeSplit(options) {
-        const types = normalizeLaunchTypes(options);
-        const feeSplit = this.launchpad.feeSplit(options.feeSplit);
+    /** Bluefin's private AutoLpAdmin entry; see compoundCetusAutoLp. */
+    compoundBluefinAutoLp(options) {
+        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::settle_and_update_fee_split`,
-                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),
-                    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),
+                    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(),
                 ],
             });
         };
     }
     /**
-     * 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.
+     * `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.
      */
     buybackAndBurnCetus(options) {
-        const types = normalizeLaunchTypes(options);
-        const memeSide = normalizeMemeSide(options.memeSide);
-        const quoteIn = requirePositiveU64("quoteIn", options.quoteIn);
-        const minMemeOut = requireU64("minMemeOut", options.minMemeOut);
-        return (tx) => {
-            tx.moveCall({
-                target: `${this.deployment.packageId}::cetus::buyback_and_burn`,
-                typeArguments: cetusTypeArguments(types, memeSide),
-                arguments: [
-                    sharedObject(tx, "vault", options.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),
-                    tx.object.clock(),
-                ],
-            });
+        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),
         };
-    }
-    /** Bluefin counterpart of `buybackAndBurnCetus`. */
-    buybackAndBurnBluefin(options) {
-        const types = normalizeLaunchTypes(options);
-        const quoteIn = requirePositiveU64("quoteIn", options.quoteIn);
-        const minMemeOut = requireU64("minMemeOut", options.minMemeOut);
+        const amounts = buybackAmounts(options);
         return (tx) => {
             tx.moveCall({
-                target: `${this.deployment.packageId}::bluefin::buyback_and_burn`,
-                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),
-                    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),
+                    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(),
                 ],
             });
         };
     }
     /**
-     * Claims the creator's accrued LP fees with the launch's live `CurveFeeCap`.
-     * `launch` is read immutably by Move.
-     */
-    claimCreatorFees(options) {
-        const types = normalizeLaunchTypes(options);
-        return (tx) => 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.
+     * `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`.
      */
-    claimProtocolLpFeesWithPartner(options) {
-        const types = normalizeLaunchTypes(options);
-        return (tx) => {
-            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(),
-                ],
-            });
+    buybackAndBurnBluefin(options) {
+        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),
         };
-    }
-    /** Claims the protocol-owned migration residuals under a `TreasuryAdmin` witness. */
-    claimProtocolFees(options) {
-        const types = normalizeLaunchTypes(options);
-        return (tx) => tx.moveCall({
-            target: `${this.deployment.packageId}::vault::claim_protocol_fees`,
-            typeArguments: [types.memeType, types.quoteType],
-            arguments: [
-                sharedObject(tx, "vault", options.vault, true),
-                this.#migratorsVersion(tx),
-                tx.object(options.adminWitness),
-            ],
-        });
-    }
-    /** Changes Blast's default Meme and Quote LP-fee shares for coins without their own pair (`FeeAdmin`). */
-    setLpFeeDefaultShares(options) {
-        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) {
-        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) {
-        return this.#lpFeePolicyAdmin("clear_coin_shares", [normalizeStructTag(options.memeType)], options, () => []);
-    }
-    /** Redirects every later protocol LP-fee payout (`TreasuryAdmin`). */
-    setLpFeeProtocolDestination(options) {
-        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`).
-     */
-    publishHolderRewardRound(options) {
-        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");
-        }
+        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) {
-        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)));
+    #cetusFees(name, options) {
+        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, typeArguments, options, extra) {
+    #bluefinFees(name, options) {
+        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) {
-        return deploymentObject(tx, this.deployment.migratorsVersion, false);
+    #target(module, name) {
+        return `${this.deployment.packageId}::${module}::${name}`;
     }
-    #launchpadVersion(tx) {
-        return deploymentObject(tx, this.deployment.launchpad.packageVersion, false);
+    #migratorsVersion(tx) {
+        return deploymentObject(tx, this.deployment.packageVersion, false);
     }
-    #launchConfig(tx) {
-        return deploymentObject(tx, this.deployment.launchpad.launchConfig, false);
+    #vaultVersion(tx) {
+        return deploymentObject(tx, this.deployment.vault.packageVersion, false);
     }
-    #lpFeePolicy(tx) {
-        return deploymentObject(tx, this.deployment.lpFeePolicy, false);
+    #treasury(tx) {
+        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 {
     call;
-    #useGasCoin;
-    constructor(deployment, options = {}) {
+    admin;
+    constructor(deployment) {
         this.call = new MigratorCalls(deployment);
-        this.#useGasCoin = options.useGasCoin ?? true;
-    }
-    /**
-     * Starts, configures, finalizes, and shares a Cetus launch atomically, with
-     * an optional purchase on the owned launch, routed to its recipient.
-     */
-    createCetusLaunch(options) {
-        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) {
-        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;
-    }
-    migrateCetus(options) {
-        const tx = new Transaction();
-        tx.add(this.call.migrateCetus(options));
-        return tx;
-    }
-    /** Pays Bluefin's SUI pool-creation fee as an exact-balance coin. */
-    migrateBluefin(options) {
-        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;
+        this.admin = new AdminCalls(this.call.deployment.vault.admin);
     }
-    /** Then pays the vault's partner when `partner` is given; see `claimProtocolLpFeesWithPartner`. */
     collectCetusFees(options) {
-        const tx = new Transaction();
-        tx.add(this.call.collectCetusFees(options));
-        return this.#claimProtocolLpFeesWithPartnerAfter(tx, options);
-    }
-    /** Then pays the vault's partner when `partner` is given; see `claimProtocolLpFeesWithPartner`. */
-    collectBluefinFees(options) {
-        const tx = new Transaction();
-        tx.add(this.call.collectBluefinFees(options));
-        return this.#claimProtocolLpFeesWithPartnerAfter(tx, options);
-    }
-    /** Pays a partnered vault's partner and Blast the LP fees its collections held. */
-    claimProtocolLpFeesWithPartner(options) {
-        const tx = new Transaction();
-        tx.add(this.call.claimProtocolLpFeesWithPartner(options));
-        return tx;
-    }
-    settleAndUpdateCetusFeeSplit(options) {
-        const tx = new Transaction();
-        tx.add(this.call.settleAndUpdateCetusFeeSplit({
-            ...options,
-            curveFeeCap: options.curveFeeCapId,
-        }));
-        return tx;
-    }
-    settleAndUpdateBluefinFeeSplit(options) {
-        const tx = new Transaction();
-        tx.add(this.call.settleAndUpdateBluefinFeeSplit({
-            ...options,
-            curveFeeCap: options.curveFeeCapId,
-        }));
-        return tx;
-    }
-    claimCreatorFees(options) {
-        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;
+        return single(this.call.collectCetusFees(options));
     }
-    claimProtocolFees(options) {
-        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;
+    settleAndApplyCetusFeeSplit(options) {
+        return single(this.call.settleAndApplyCetusFeeSplit(options));
     }
-    setLpFeeDefaultShares(options) {
-        return this.#asAdmin(options.adminCapId, "FeeAdmin", (adminWitness) => this.call.setLpFeeDefaultShares({ ...options, adminWitness }));
+    collectBluefinFees(options) {
+        return single(this.call.collectBluefinFees(options));
     }
-    setLpFeeCoinShares(options) {
-        return this.#asAdmin(options.adminCapId, "FeeAdmin", (adminWitness) => this.call.setLpFeeCoinShares({ ...options, adminWitness }));
+    settleAndApplyBluefinFeeSplit(options) {
+        return single(this.call.settleAndApplyBluefinFeeSplit(options));
     }
-    clearLpFeeCoinShares(options) {
-        return this.#asAdmin(options.adminCapId, "FeeAdmin", (adminWitness) => this.call.clearLpFeeCoinShares({ ...options, adminWitness }));
+    compoundCetusAutoLp(options) {
+        return single(this.call.compoundCetusAutoLp(options));
     }
-    setLpFeeProtocolDestination(options) {
-        return this.#asAdmin(options.adminCapId, "TreasuryAdmin", (adminWitness) => this.call.setLpFeeProtocolDestination({ ...options, adminWitness }));
+    compoundBluefinAutoLp(options) {
+        return single(this.call.compoundBluefinAutoLp(options));
     }
+    /** Signs in as `BuybackAdmin` with `adminCapId`, then `buybackAndBurnCetus`. */
     buybackAndBurnCetus(options) {
-        return this.#asAdmin(options.adminCapId, "BuybackAdmin", (adminWitness) => this.call.buybackAndBurnCetus({ ...options, adminWitness }));
+        return this.#asBuybackAdmin(options.adminCapId, (adminWitness) => this.call.buybackAndBurnCetus({ ...options, adminWitness }));
     }
+    /** Signs in as `BuybackAdmin` with `adminCapId`, then `buybackAndBurnBluefin`. */
     buybackAndBurnBluefin(options) {
-        return this.#asAdmin(options.adminCapId, "BuybackAdmin", (adminWitness) => this.call.buybackAndBurnBluefin({ ...options, adminWitness }));
-    }
-    publishHolderRewardRound(options) {
-        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) {
-        const tx = new Transaction();
-        for (const allocation of options.allocations) {
-            tx.add(this.call.claimHolderReward({ ...options, allocation }));
-        }
-        return tx;
+        return this.#asBuybackAdmin(options.adminCapId, (adminWitness) => this.call.buybackAndBurnBluefin({ ...options, adminWitness }));
     }
-    #asAdmin(adminCapId, role, call) {
+    #asBuybackAdmin(adminCapId, call) {
         const tx = new Transaction();
-        const adminWitness = tx.add(this.call.signIn({ adminCap: adminCapId, role }));
+        const adminWitness = tx.add(this.admin.signIn({
+            adminCap: adminCapId,
+            role: coreRoleType(this.call.deployment.vault.core, "BuybackAdmin"),
+        }));
         tx.add(call(adminWitness));
         return tx;
     }
-    #claimProtocolLpFeesWithPartnerAfter(tx, options) {
-        const { partner } = options;
-        if (partner)
-            tx.add(this.call.claimProtocolLpFeesWithPartner({ ...options, partner }));
-        return tx;
-    }
 }
-function sharedObject(tx, name, reference, mutable) {
-    return tx.sharedObjectRef(normalizeSharedObjectReference(name, reference, mutable));
+function single(step) {
+    const tx = new Transaction();
+    tx.add(step);
+    return tx;
 }
-/** `[Meme, Quote, CoinA, CoinB]`, the pool's coins in Cetus order. */
-function cetusTypeArguments(types, memeSide) {
-    const { memeType, quoteType } = types;
-    return memeSide === "a"
-        ? [memeType, quoteType, memeType, quoteType]
-        : [memeType, quoteType, quoteType, memeType];
+function pair(types) {
+    return [
+        normalizeStructTag(types.memeType),
+        normalizeStructTag(types.quoteType),
+    ];
 }
-function normalizeMemeSide(value) {
-    if (value !== "a" && value !== "b") {
-        throw new RangeError("memeSide must be a or b");
-    }
-    return value;
+/** `<Meme, Quote, CoinA, CoinB>`, with the pool's coin order from `cetusMemeSide`. */
+function cetusTypeArguments(types) {
+    const [meme, quote] = pair(types);
+    return cetusMemeSide(meme, quote) === "a"
+        ? [meme, quote, meme, quote]
+        : [meme, quote, quote, meme];
+}
+function buybackAmounts(options) {
+    return {
+        quoteIn: requirePositiveU64("quoteIn", options.quoteIn),
+        minMemeOut: requireU64("minMemeOut", options.minMemeOut),
+    };
 }
 function requireU32(name, value) {
     if (!Number.isInteger(value) || value < 0 || value > 0xffff_ffff) {
@@ -601,4 +491,12 @@ function requireU32(name, value) {
     }
     return value;
 }
+function autoLpPriceBounds(options) {
+    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];
+}
 //# sourceMappingURL=transactions.js.map