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

package/src/state.ts

@@ -1,316 +1,122 @@
 import {
-  moveTypeNameBcs,
-  suiBalanceBcs,
-  suiIdBcs,
-  suiObjectIdBcs,
   suiUidBcs,
+  u64Bcs,
+  unitKeyBcs,
 } from "@interest-protocol/blast-core/bcs";
-import { normalizePositiveU64 } from "@interest-protocol/blast-core/integers";
-import type { SharedObjectReference } from "@interest-protocol/blast-core/sui";
-import type { FeeSplit } from "@interest-protocol/blast-launchpad-sdk/allocation";
-import {
-  bpsBcs,
-  feeSplitBcs,
-} from "@interest-protocol/blast-launchpad-sdk/allocation";
 import { bcs } from "@mysten/sui/bcs";
 import type { ClientWithCoreApi } from "@mysten/sui/client";
 import { ObjectError } from "@mysten/sui/client";
-import {
-  normalizeStructTag,
-  normalizeSuiAddress,
-  normalizeSuiObjectId,
-  parseStructTag,
-} from "@mysten/sui/utils";
-
-/** Venues whose adapters the migrators package ships. */
-export const MIGRATOR_VENUES = ["bluefin", "cetus"] as const;
-export type MigratorVenue = (typeof MIGRATOR_VENUES)[number];
-
-export type LaunchMigrationRoute = {
-  venue: MigratorVenue;
-  tickSpacing: number;
-  feeRate: bigint;
-};
+import { normalizeStructTag, normalizeSuiObjectId } from "@mysten/sui/utils";
+import type { MigratorsDeployment } from "./transactions.ts";
 
 /**
- * Identifies a launch's recorded route from its `migration_witness` (the
- * adapter's `Witness` type, by original package ID) and its pool tier. Rejects
- * a witness from another migrators package or a venue this SDK cannot route.
+ * BCS layout of `venue_config::VenueConfig`: its UID only. Venue records are
+ * dynamic fields of it, keyed by venue-sealed field-less structs
+ * (`PoolTierKey<Meme>()`, `CreationCapKey<Meme>()`) that encode as one zero
+ * byte.
  */
-export function launchMigrationRoute(
-  launch: {
-    migrationWitnessType: string;
-    poolTickSpacing: number;
-    poolFeeRate: bigint;
-  },
-  migratorsOriginalPackageId: string,
-): LaunchMigrationRoute {
-  const tag = parseStructTag(launch.migrationWitnessType);
-  if (tag.address !== normalizeSuiAddress(migratorsOriginalPackageId)) {
-    throw new TypeError(
-      "the launch migrates through another migrators package",
-    );
-  }
-  const venue = tag.module as MigratorVenue;
-  if (!MIGRATOR_VENUES.includes(venue) || tag.name !== "Witness") {
-    throw new RangeError(
-      `unsupported migration route ${tag.module}::${tag.name}`,
-    );
-  }
-  return {
-    venue,
-    tickSpacing: launch.poolTickSpacing,
-    feeRate: launch.poolFeeRate,
-  };
-}
-
-/** BCS layout of `blast_fun_migrators::vault::LpVault<Meme, Quote>`. */
-export const lpVaultBcs = bcs.struct("LpVault", {
-  id: suiUidBcs,
-  pool_id: suiIdBcs,
-  partner_id: bcs.option(suiObjectIdBcs),
-  protocol_meme_residual: suiBalanceBcs,
-  protocol_quote_residual: suiBalanceBcs,
-  unpaid_protocol_meme: suiBalanceBcs,
-  unpaid_protocol_quote: suiBalanceBcs,
-  fee_split: feeSplitBcs,
-  creator_meme: suiBalanceBcs,
-  creator_quote: suiBalanceBcs,
-  auto_lp_meme: suiBalanceBcs,
-  auto_lp_quote: suiBalanceBcs,
-  rewards_meme: suiBalanceBcs,
-  rewards_quote: suiBalanceBcs,
-  burn_quote: suiBalanceBcs,
-  next_round: bcs.u64(),
-  last_checkpoint: bcs.option(bcs.u64()),
-});
+export const venueConfigBcs = bcs.struct("VenueConfig", { id: suiUidBcs });
 
-/** BCS layout of `blast_fun_migrators::lp_fee_policy::SharePair`. */
-export const lpFeeSharePairBcs = bcs.struct("SharePair", {
-  meme_bps: bpsBcs,
-  quote_bps: bpsBcs,
+/** `bluefin::PoolTier`: the Bluefin pool tier a Meme's migration uses. */
+export const bluefinPoolTierBcs = bcs.struct("PoolTier", {
+  tick_spacing: bcs.u32(),
+  fee_rate: u64Bcs,
 });
 
-/** BCS layout of `blast_fun_migrators::lp_fee_policy::LpFeePolicy`. */
-export const lpFeePolicyBcs = bcs.struct("LpFeePolicy", {
-  id: suiUidBcs,
-  destination: bcs.Address,
-  defaults: lpFeeSharePairBcs,
-  coins: bcs.struct("Table", { id: suiUidBcs, size: bcs.u64() }),
-});
-
-export type LpVaultState = SharedObjectReference<true> & {
-  memeType: string;
-  quoteType: string;
-  poolId: string;
-  /** The partner the launch named, paid its cut of Blast's LP fees; null for none. */
-  partnerId: string | null;
-  /** Protocol-owned migration residuals, claimable by an administrator. */
-  protocolMemeResidual: bigint;
-  protocolQuoteResidual: bigint;
-  /** Blast's LP fees a partnered vault holds until `claimProtocolLpFeesWithPartner`. */
-  unpaidProtocolMeme: bigint;
-  unpaidProtocolQuote: bigint;
-  feeSplit: FeeSplit;
-  /** Creator LP fees claimable by the launch's live `CurveFeeCap`. */
-  creatorMeme: bigint;
-  creatorQuote: bigint;
-  /** Auto-LP amounts the pool did not take yet; the next collection retries. */
-  autoLpMeme: bigint;
-  autoLpQuote: bigint;
-  /** Rewards not yet reserved by a holder-reward round. */
-  rewardsMeme: bigint;
-  rewardsQuote: bigint;
-  /** Burn-share Quote waiting for a buyback admin to swap it for Meme to burn. */
-  burnQuote: bigint;
-  /** Number the next holder-reward round must carry. */
-  nextRound: bigint;
-  /** Checkpoint the next round must start at; null before the first round. */
-  lastCheckpoint: bigint | null;
-};
-
-export type LpVaultObject = SharedObjectReference<true> & {
-  type: string;
-  content: Uint8Array;
-};
+/** A Bluefin pool tier; `feeRate` is in Bluefin fee units (1,000,000 is 100%). */
+export type BluefinPoolTier = { tickSpacing: number; feeRate: bigint };
 
-export type LpFeeShares = { memeBps: bigint; quoteBps: bigint };
-
-export type LpFeePolicyState = SharedObjectReference<false> & {
-  /** Address every collection pays Blast's share to. */
-  protocolDestination: string;
-  defaultShares: LpFeeShares;
-  /** Table of per-coin share pairs, keyed by original Meme `TypeName`. */
-  coinSharesTableId: string;
-  coinSharesCount: bigint;
-};
-
-export function decodeLpVaultObject(
-  object: LpVaultObject,
-  originalPackageId: string,
-): LpVaultState {
-  const tag = parseStructTag(object.type);
-  if (tag.module !== "vault" || tag.name !== "LpVault") {
-    throw new TypeError(`object ${object.objectId} is not an LP vault`);
-  }
-  if (tag.typeParams.length !== 2) {
-    throw new TypeError(
-      `LP vault ${object.objectId} must have two type arguments`,
-    );
-  }
-  if (tag.address !== normalizeSuiAddress(originalPackageId)) {
-    throw new TypeError(
-      `LP vault ${object.objectId} has an unexpected package`,
-    );
-  }
-  if (object.mutable !== true) {
-    throw new TypeError(`LP vault ${object.objectId} must be mutable`);
-  }
-
-  const parsed = lpVaultBcs.parse(object.content);
-  const objectId = normalizeSuiObjectId(object.objectId);
-  if (normalizeSuiObjectId(parsed.id.id.bytes) !== objectId) {
-    throw new TypeError(`LP vault ${object.objectId} has a mismatched UID`);
-  }
-
-  return {
-    objectId,
-    initialSharedVersion: normalizePositiveU64(
-      "initialSharedVersion",
-      object.initialSharedVersion,
-    ),
-    mutable: true,
-    memeType: normalizeTypeParameter(tag.typeParams[0]),
-    quoteType: normalizeTypeParameter(tag.typeParams[1]),
-    poolId: normalizeSuiObjectId(parsed.pool_id.bytes),
-    partnerId: parsed.partner_id,
-    protocolMemeResidual: BigInt(parsed.protocol_meme_residual.value),
-    protocolQuoteResidual: BigInt(parsed.protocol_quote_residual.value),
-    unpaidProtocolMeme: BigInt(parsed.unpaid_protocol_meme.value),
-    unpaidProtocolQuote: BigInt(parsed.unpaid_protocol_quote.value),
-    feeSplit: parsed.fee_split,
-    creatorMeme: BigInt(parsed.creator_meme.value),
-    creatorQuote: BigInt(parsed.creator_quote.value),
-    autoLpMeme: BigInt(parsed.auto_lp_meme.value),
-    autoLpQuote: BigInt(parsed.auto_lp_quote.value),
-    rewardsMeme: BigInt(parsed.rewards_meme.value),
-    rewardsQuote: BigInt(parsed.rewards_quote.value),
-    burnQuote: BigInt(parsed.burn_quote.value),
-    nextRound: BigInt(parsed.next_round),
-    lastCheckpoint:
-      parsed.last_checkpoint === null ? null : BigInt(parsed.last_checkpoint),
-  };
-}
+type VenueConfigReader = Pick<
+  MigratorsDeployment,
+  "originalPackageId" | "venueConfig"
+>;
 
-export async function getLpVault(
+/**
+ * The tick spacing `cetus::prepare` recorded for `memeType`
+ * (`cetus::PoolTierKey<Meme>`), or null before the Meme is prepared for
+ * Cetus. Pass the Meme's original (defining) type address.
+ */
+export async function getCetusPoolTier(
   client: ClientWithCoreApi,
-  objectId: string,
-  originalPackageId: string,
-): Promise<LpVaultState> {
-  const { object } = await client.core.getObject({
-    objectId,
-    include: { content: true },
-  });
-  if (object.owner.$kind !== "Shared") {
-    throw new TypeError(`LP vault ${object.objectId} is not a shared object`);
-  }
-  return decodeLpVaultObject(
-    {
-      objectId: object.objectId,
-      initialSharedVersion: object.owner.Shared.initialSharedVersion,
-      mutable: true,
-      type: object.type,
-      content: object.content,
-    },
-    originalPackageId,
-  );
+  migrators: VenueConfigReader,
+  memeType: string,
+): Promise<number | null> {
+  const value = await venueField(client, migrators, "cetus", memeType);
+  return value === null ? null : bcs.u32().parse(value);
 }
 
-/** Reads the shared `LpFeePolicy` singleton. */
-export async function getLpFeePolicy(
+/**
+ * The tier `bluefin::prepare` recorded for `memeType`
+ * (`bluefin::PoolTierKey<Meme>`), or null before the Meme is prepared for
+ * Bluefin.
+ */
+export async function getBluefinPoolTier(
   client: ClientWithCoreApi,
-  objectId: string,
-  originalPackageId: string,
-): Promise<LpFeePolicyState> {
-  const { object } = await client.core.getObject({
-    objectId,
-    include: { content: true },
-  });
-  if (object.owner.$kind !== "Shared") {
-    throw new TypeError(`LP-fee policy ${object.objectId} is not shared`);
-  }
-  const expected = normalizeStructTag(
-    `${normalizeSuiAddress(originalPackageId)}::lp_fee_policy::LpFeePolicy`,
-  );
-  if (normalizeStructTag(object.type) !== expected) {
-    throw new TypeError(`object ${object.objectId} is not the LP-fee policy`);
-  }
-  const parsed = lpFeePolicyBcs.parse(object.content);
-  if (
-    normalizeSuiObjectId(parsed.id.id.bytes) !==
-    normalizeSuiObjectId(object.objectId)
-  ) {
-    throw new TypeError(
-      `LP-fee policy ${object.objectId} has a mismatched UID`,
-    );
-  }
-  return {
-    objectId: normalizeSuiObjectId(object.objectId),
-    initialSharedVersion: normalizePositiveU64(
-      "initialSharedVersion",
-      object.owner.Shared.initialSharedVersion,
-    ),
-    mutable: false,
-    protocolDestination: normalizeSuiAddress(parsed.destination),
-    defaultShares: {
-      memeBps: parsed.defaults.meme_bps,
-      quoteBps: parsed.defaults.quote_bps,
-    },
-    coinSharesTableId: normalizeSuiObjectId(parsed.coins.id.id.bytes),
-    coinSharesCount: BigInt(parsed.coins.size),
-  };
+  migrators: VenueConfigReader,
+  memeType: string,
+): Promise<BluefinPoolTier | null> {
+  const value = await venueField(client, migrators, "bluefin", memeType);
+  if (value === null) return null;
+  const tier = bluefinPoolTierBcs.parse(value);
+  return { tickSpacing: tier.tick_spacing, feeRate: tier.fee_rate };
 }
 
 /**
- * Mirrors `lp_fee_policy::shares<Meme>`: the coin's own pair when an
- * administrator set one, otherwise the default pair. `source` says which.
+ * The ID of the Meme type's Cetus `PoolCreationCap`, kept in `VenueConfig`
+ * under `cetus::CreationCapKey<Meme>` (the `pool_creation_cap_id` of its
+ * `CetusPoolReserved`), or null before the Meme is prepared for Cetus.
  */
-export async function getLpFeeShares(
+export async function getCetusPoolCreationCapId(
   client: ClientWithCoreApi,
-  policy: Pick<LpFeePolicyState, "coinSharesTableId" | "defaultShares">,
+  migrators: VenueConfigReader,
   memeType: string,
-): Promise<LpFeeShares & { source: "coin" | "default" }> {
+): Promise<string | null> {
   try {
-    const { dynamicField } = await client.core.getDynamicField({
-      parentId: policy.coinSharesTableId,
-      name: {
-        type: "0x1::type_name::TypeName",
-        bcs: moveTypeNameBcs
-          .serialize(originalTypeNameText(memeType))
-          .toBytes(),
-      },
+    const { object } = await client.core.getDynamicObjectField({
+      parentId: normalizeSuiObjectId(migrators.venueConfig.objectId),
+      name: venueKey(migrators, "cetus", "CreationCapKey", memeType),
     });
-    const pair = lpFeeSharePairBcs.parse(dynamicField.value.bcs);
-    return { memeBps: pair.meme_bps, quoteBps: pair.quote_bps, source: "coin" };
+    return normalizeSuiObjectId(object.objectId);
   } catch (error) {
-    if (!(error instanceof ObjectError) || error.reason !== "notFound") {
-      throw error;
-    }
-    return { ...policy.defaultShares, source: "default" };
+    if (error instanceof ObjectError && error.reason === "notFound")
+      return null;
+    throw error;
   }
 }
 
-/** Move `TypeName` text: the normalized tag without the `0x` address prefix. */
-function originalTypeNameText(type: string): string {
-  const normalized = normalizeStructTag(type);
-  return normalized.startsWith("0x") ? normalized.slice(2) : normalized;
+/**
+ * The `VenueConfig` dynamic-field name `<original>::<venue>::<key><Meme>()`:
+ * the key type with the Meme's original type address, and one zero byte.
+ */
+function venueKey(
+  migrators: Pick<MigratorsDeployment, "originalPackageId">,
+  venue: "cetus" | "bluefin",
+  key: "PoolTierKey" | "CreationCapKey",
+  memeType: string,
+): { type: string; bcs: Uint8Array } {
+  return {
+    type: normalizeStructTag(
+      `${normalizeSuiObjectId(migrators.originalPackageId)}::${venue}::${key}<${normalizeStructTag(memeType)}>`,
+    ),
+    bcs: unitKeyBcs.serialize(null).toBytes(),
+  };
 }
 
-function normalizeTypeParameter(
-  type: ReturnType<typeof parseStructTag>["typeParams"][number] | undefined,
-): string {
-  if (type === undefined || typeof type === "string") {
-    throw new TypeError("LP vault coin type must be a struct type");
+async function venueField(
+  client: ClientWithCoreApi,
+  migrators: VenueConfigReader,
+  venue: "cetus" | "bluefin",
+  memeType: string,
+): Promise<Uint8Array | null> {
+  try {
+    const { dynamicField } = await client.core.getDynamicField({
+      parentId: normalizeSuiObjectId(migrators.venueConfig.objectId),
+      name: venueKey(migrators, venue, "PoolTierKey", memeType),
+    });
+    return dynamicField.value.bcs;
+  } catch (error) {
+    if (error instanceof ObjectError && error.reason === "notFound")
+      return null;
+    throw error;
   }
-  return normalizeStructTag(type);
 }