@interest-protocol/blast-migrators-sdk 0.0.0-stage → 0.1.1

package/package.json

@@ -1,6 +1,70 @@
 {
   "name": "@interest-protocol/blast-migrators-sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Blast migrators SDK",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/interest-protocol/blast-v2-sdk.git",
+    "directory": "packages/migrators"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src"
+  ],
+  "exports": {
+    "./bluefin-pool": {
+      "types": "./dist/bluefin-pool.d.ts",
+      "default": "./dist/bluefin-pool.js"
+    },
+    "./cetus-pool": {
+      "types": "./dist/cetus-pool.d.ts",
+      "default": "./dist/cetus-pool.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "default": "./dist/client.js"
+    },
+    "./events": {
+      "types": "./dist/events.d.ts",
+      "default": "./dist/events.js"
+    },
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./reducer": {
+      "types": "./dist/reducer.d.ts",
+      "default": "./dist/reducer.js"
+    },
+    "./state": {
+      "types": "./dist/state.d.ts",
+      "default": "./dist/state.js"
+    },
+    "./transactions": {
+      "types": "./dist/transactions.d.ts",
+      "default": "./dist/transactions.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "node --eval \"fs.rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "check:package": "publint --strict && attw --pack . --profile esm-only",
+    "prepack": "npm run build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@interest-protocol/blast-core": "0.1.0",
+    "@interest-protocol/blast-launchpad-sdk": "0.1.1"
+  },
+  "peerDependencies": {
+    "@mysten/sui": "^2.26.2"
+  }
+}

package/src/bluefin-pool.ts

@@ -0,0 +1,180 @@
+import { requireU64 } from "@interest-protocol/blast-core/integers";
+import { moveResults } from "@interest-protocol/blast-core/ptb";
+import type { SharedObjectReference } from "@interest-protocol/blast-core/sui";
+import { normalizeSharedObjectReference } from "@interest-protocol/blast-core/sui";
+import type { LaunchTypes } from "@interest-protocol/blast-launchpad-sdk/transactions";
+import { normalizeLaunchTypes } from "@interest-protocol/blast-launchpad-sdk/transactions";
+import type {
+  Transaction,
+  TransactionObjectArgument,
+  TransactionObjectInput,
+} from "@mysten/sui/transactions";
+import { normalizeSuiAddress, SUI_TYPE_ARG } from "@mysten/sui/utils";
+
+/** Bluefin's pool metadata; amounts and prices always use atomic coin units. */
+export type BluefinCoinMetadata = {
+  symbol: string;
+  decimals: number;
+  iconUrl?: string;
+};
+
+export type BluefinPoolCreation = LaunchTypes & {
+  /** Runtime package and config from the deployment's Bluefin venue identities. */
+  bluefinPackageId: string;
+  bluefinConfig: SharedObjectReference<true>;
+  memeMetadata: BluefinCoinMetadata;
+  quoteMetadata: BluefinCoinMetadata;
+  /** Optional pool NFT icon. The name is `<Meme symbol>-<Quote symbol>`. */
+  iconUrl?: string;
+  tickSpacing: number;
+  /** Bluefin fee units: 1,000,000 is 100%. */
+  feeRate: bigint;
+  /** Q64.64 square root of Quote atoms per Meme atom. */
+  sqrtPriceX64: bigint;
+  /** SUI atoms (MIST), read from the current config; never assumed zero. */
+  creationFee: bigint;
+  /** Signed ticks, aligned to tickSpacing; encoded as i32 two's-complement bits. */
+  lowerTick: number;
+  upperTick: number;
+  /** Coins consumed; their balances bound each side's maximum contribution. */
+  memeCoin: TransactionObjectInput;
+  quoteCoin: TransactionObjectInput;
+  /** Atomic amount on the fixed side. Bluefin calculates the other side. */
+  fixedAmount: bigint;
+  fixedMeme: boolean;
+};
+
+export type BluefinPoolCreationResult = {
+  /** Fresh owned Pool<Meme, Quote>. Call shareBluefinPool after composing. */
+  pool: TransactionObjectArgument;
+  /** Position to pass to PresaleCalls.newBluefinVault, or transfer to its owner. */
+  position: TransactionObjectArgument;
+  /** Residual coins, including zero coins; callers must consume or transfer both. */
+  memeResidual: TransactionObjectArgument;
+  quoteResidual: TransactionObjectArgument;
+};
+
+/**
+ * Creates Pool<Meme, Quote>, opens a position, and adds fixed-side liquidity.
+ * Mirrors the pinned Bluefin Spot interface (91ce930). No presale is needed.
+ * The fresh pool remains usable in this PTB, e.g. by newBluefinVault; the
+ * caller must then share it, consume the position, and handle both residuals.
+ * The input coins cap spending; Bluefin aborts if the other side is too small.
+ */
+export function addBluefinPoolWithLiquidity(
+  tx: Transaction,
+  options: BluefinPoolCreation,
+): BluefinPoolCreationResult {
+  const types = normalizeLaunchTypes(options);
+  const typeArguments = [types.memeType, types.quoteType];
+  const target = (name: string) =>
+    `${normalizeSuiAddress(options.bluefinPackageId)}::pool::${name}`;
+  const config = tx.sharedObjectRef(
+    normalizeSharedObjectReference(
+      "bluefinConfig",
+      options.bluefinConfig,
+      true,
+    ),
+  );
+  const bytes = (value: string) =>
+    tx.pure.vector("u8", new TextEncoder().encode(value));
+  const balance = (coin: TransactionObjectInput, type: string) =>
+    tx.moveCall({
+      target: "0x2::coin::into_balance",
+      typeArguments: [type],
+      arguments: [tx.object(coin)],
+    });
+  const creationFee = requireU64("creationFee", options.creationFee);
+  const fee =
+    creationFee === 0n
+      ? tx.moveCall({
+          target: "0x2::balance::zero",
+          typeArguments: [SUI_TYPE_ARG],
+        })
+      : balance(
+          tx.coin({ type: SUI_TYPE_ARG, balance: creationFee }),
+          SUI_TYPE_ARG,
+        );
+  const pool = tx.moveCall({
+    target: target("create_pool_and_get_object"),
+    typeArguments: [...typeArguments, SUI_TYPE_ARG],
+    arguments: [
+      tx.object.clock(),
+      config,
+      bytes(`${options.memeMetadata.symbol}-${options.quoteMetadata.symbol}`),
+      bytes(options.iconUrl ?? ""),
+      bytes(options.memeMetadata.symbol),
+      tx.pure.u8(options.memeMetadata.decimals),
+      bytes(options.memeMetadata.iconUrl ?? ""),
+      bytes(options.quoteMetadata.symbol),
+      tx.pure.u8(options.quoteMetadata.decimals),
+      bytes(options.quoteMetadata.iconUrl ?? ""),
+      tx.pure.u32(options.tickSpacing),
+      tx.pure.u64(options.feeRate),
+      tx.pure.u128(options.sqrtPriceX64),
+      fee,
+    ],
+  });
+  const position = tx.moveCall({
+    target: target("open_position"),
+    typeArguments,
+    arguments: [
+      config,
+      pool,
+      tx.pure.u32(tickBits(options.lowerTick)),
+      tx.pure.u32(tickBits(options.upperTick)),
+    ],
+  });
+  const [, , memeResidual, quoteResidual] = moveResults(
+    tx.moveCall({
+      target: target("add_liquidity_with_fixed_amount"),
+      typeArguments,
+      arguments: [
+        tx.object.clock(),
+        config,
+        pool,
+        position,
+        balance(options.memeCoin, types.memeType),
+        balance(options.quoteCoin, types.quoteType),
+        tx.pure.u64(options.fixedAmount),
+        tx.pure.bool(options.fixedMeme),
+      ],
+    }),
+    4,
+  );
+  const coin = (residual: TransactionObjectArgument, type: string) =>
+    tx.moveCall({
+      target: "0x2::coin::from_balance",
+      typeArguments: [type],
+      arguments: [residual],
+    });
+  return {
+    pool,
+    position,
+    memeResidual: coin(memeResidual, types.memeType),
+    quoteResidual: coin(quoteResidual, types.quoteType),
+  };
+}
+
+/** Shares a fresh Bluefin pool after all calls that borrow it in this PTB. */
+export function shareBluefinPool(
+  tx: Transaction,
+  options: LaunchTypes & {
+    bluefinPackageId: string;
+    pool: TransactionObjectInput;
+  },
+): void {
+  const { memeType, quoteType } = normalizeLaunchTypes(options);
+  tx.moveCall({
+    target: `${normalizeSuiAddress(options.bluefinPackageId)}::pool::share_pool_object`,
+    typeArguments: [memeType, quoteType],
+    arguments: [tx.object(options.pool)],
+  });
+}
+
+function tickBits(tick: number): number {
+  if (!Number.isInteger(tick) || tick < -(2 ** 31) || tick > 2 ** 31 - 1) {
+    throw new RangeError("tick must be an i32");
+  }
+  return tick >>> 0;
+}

package/src/cetus-pool.ts

@@ -0,0 +1,107 @@
+import { cetusMemeSide } from "@interest-protocol/blast-core/cetus";
+import { grossGasBudget } from "@interest-protocol/blast-core/gas";
+import { moveResults } from "@interest-protocol/blast-core/ptb";
+import type { SharedObjectReference } from "@interest-protocol/blast-core/sui";
+import { normalizeSharedObjectReference } from "@interest-protocol/blast-core/sui";
+import type { LaunchTypes } from "@interest-protocol/blast-launchpad-sdk/transactions";
+import { normalizeLaunchTypes } from "@interest-protocol/blast-launchpad-sdk/transactions";
+import type {
+  Transaction,
+  TransactionObjectArgument,
+  TransactionObjectInput,
+} from "@mysten/sui/transactions";
+import { normalizeSuiAddress } from "@mysten/sui/utils";
+
+export type CetusPoolCreation = LaunchTypes & {
+  /** Runtime package and shared objects from the deployment's Cetus identities. */
+  cetusPackageId: string;
+  cetusConfig: SharedObjectReference<false>;
+  cetusPools: SharedObjectReference<true>;
+  tickSpacing: number;
+  /** Q64.64 square root of coin B atoms per coin A atom, in Cetus coin order. */
+  sqrtPriceX64: bigint;
+  /** Pool/position metadata URL; empty by default. */
+  url?: string;
+  /** Signed ticks aligned to tickSpacing, encoded as i32 two's-complement bits. */
+  lowerTick: number;
+  upperTick: number;
+  /**
+   * Coins consumed. The fixed side uses this coin's entire balance; the other
+   * coin caps the maximum contribution. Split exact input coins beforehand.
+   */
+  memeCoin: TransactionObjectInput;
+  quoteCoin: TransactionObjectInput;
+  fixedMeme: boolean;
+  /** Required only for a pair/tier already reserved by this Cetus creation cap. */
+  poolCreationCap?: TransactionObjectInput;
+};
+
+export type CetusPoolCreationResult = {
+  /** Transfer to its owner; newCetusVault can consume it in the next PTB. */
+  position: TransactionObjectArgument;
+  /** Residual Coins, including zero coins; consume or transfer both. */
+  memeResidual: TransactionObjectArgument;
+  quoteResidual: TransactionObjectArgument;
+};
+
+/**
+ * Creates and seeds a Cetus pool through the revision-15 pool_creator v3 API.
+ * Coin types, input coins, fixed side and residuals follow cetusMemeSide.
+ * Cetus shares the pool internally; its public API returns no pool handle.
+ * Execute this PTB, read the shared pool/position IDs, then call newCetusVault
+ * in a later PTB. No presale or TreasuryCap is needed for an unreserved pair.
+ * ABI: CetusProtocol/cetus-contracts ddfbdeba, pool_creator.move and factory.move;
+ * runtime package 0x260693ec785a6e6c9d81d58c7d2ff72f1288ae0fa6a9725abe05a6478b11f084.
+ */
+export function addCetusPoolWithLiquidity(
+  tx: Transaction,
+  options: CetusPoolCreation,
+): CetusPoolCreationResult {
+  const { memeType, quoteType } = normalizeLaunchTypes(options);
+  const memeIsA = cetusMemeSide(memeType, quoteType) === "a";
+  const typeArguments = memeIsA ? [memeType, quoteType] : [quoteType, memeType];
+  const lowerTick = tickBits(options.lowerTick);
+  const upperTick = tickBits(options.upperTick);
+  const config = tx.sharedObjectRef(
+    normalizeSharedObjectReference("cetusConfig", options.cetusConfig, false),
+  );
+  const pools = tx.sharedObjectRef(
+    normalizeSharedObjectReference("cetusPools", options.cetusPools, true),
+  );
+  tx.addBuildPlugin(grossGasBudget());
+  const [position, residualA, residualB] = moveResults(
+    tx.moveCall({
+      target: `${normalizeSuiAddress(options.cetusPackageId)}::pool_creator::${options.poolCreationCap === undefined ? "create_pool_v3" : "create_pool_v3_with_creation_cap"}`,
+      typeArguments,
+      arguments: [
+        config,
+        pools,
+        ...(options.poolCreationCap === undefined
+          ? []
+          : [tx.object(options.poolCreationCap)]),
+        tx.pure.u32(options.tickSpacing),
+        tx.pure.u128(options.sqrtPriceX64),
+        tx.pure.string(options.url ?? ""),
+        tx.pure.u32(lowerTick),
+        tx.pure.u32(upperTick),
+        tx.object(memeIsA ? options.memeCoin : options.quoteCoin),
+        tx.object(memeIsA ? options.quoteCoin : options.memeCoin),
+        tx.pure.bool(memeIsA === options.fixedMeme),
+        tx.object.clock(),
+      ],
+    }),
+    3,
+  );
+  return {
+    position,
+    memeResidual: memeIsA ? residualA : residualB,
+    quoteResidual: memeIsA ? residualB : residualA,
+  };
+}
+
+function tickBits(tick: number): number {
+  if (!Number.isInteger(tick) || tick < -(2 ** 31) || tick > 2 ** 31 - 1) {
+    throw new RangeError("tick must be an i32");
+  }
+  return tick >>> 0;
+}

package/src/client.ts

@@ -0,0 +1,76 @@
+import type { CoinSourceOptions } from "@interest-protocol/blast-core/coins";
+import type { RewardRoundState } from "@interest-protocol/blast-core/rewards/state";
+import { getRewardRound } from "@interest-protocol/blast-core/rewards/state";
+import type {
+  ClientWithCoreApi,
+  SuiClientRegistration,
+} from "@mysten/sui/client";
+import type { LpFeePolicyState, LpFeeShares, LpVaultState } from "./state.ts";
+import { getLpFeePolicy, getLpFeeShares, getLpVault } from "./state.ts";
+import type { MigratorsDeployment } from "./transactions.ts";
+import { MigratorCalls, MigratorTransactions } from "./transactions.ts";
+
+export class MigratorsClient {
+  readonly call: MigratorCalls;
+  readonly tx: MigratorTransactions;
+  readonly #client: ClientWithCoreApi;
+
+  constructor(
+    client: ClientWithCoreApi,
+    deployment: MigratorsDeployment,
+    options: CoinSourceOptions = {},
+  ) {
+    this.#client = client;
+    this.call = new MigratorCalls(deployment);
+    this.tx = new MigratorTransactions(deployment, options);
+  }
+
+  async getLpVault(objectId: string): Promise<LpVaultState> {
+    return getLpVault(
+      this.#client,
+      objectId,
+      this.call.deployment.originalPackageId,
+    );
+  }
+
+  async getLpFeePolicy(): Promise<LpFeePolicyState> {
+    return getLpFeePolicy(
+      this.#client,
+      this.call.deployment.lpFeePolicy.objectId,
+      this.call.deployment.originalPackageId,
+    );
+  }
+
+  /** Blast's live LP-fee shares for `memeType`: its own pair, else the defaults. */
+  async getLpFeeShares(
+    memeType: string,
+  ): Promise<LpFeeShares & { source: "coin" | "default" }> {
+    return getLpFeeShares(this.#client, await this.getLpFeePolicy(), memeType);
+  }
+
+  async getHolderRewardRound(objectId: string): Promise<RewardRoundState> {
+    return getRewardRound(
+      this.#client,
+      objectId,
+      this.call.deployment.originalPackageId,
+    );
+  }
+}
+
+export type MigratorsExtensionOptions<Name extends string> =
+  MigratorsDeployment & { name?: Name };
+
+/** Adds a typed `blastMigrators` extension to any Sui Core API client. */
+export function blastMigrators<const Name extends string = "blastMigrators">({
+  name = "blastMigrators" as Name,
+  ...deployment
+}: MigratorsExtensionOptions<Name>): SuiClientRegistration<
+  ClientWithCoreApi,
+  Name,
+  MigratorsClient
+> {
+  return {
+    name,
+    register: (client) => new MigratorsClient(client, deployment),
+  };
+}