@interest-protocol/blast-core 0.1.0 → 0.2.0

package/src/migration-math.ts

@@ -5,7 +5,18 @@ const Q128 = 1n << 128n;
 /** Atoms of the other asset `auto_lp_fixed_side` keeps beyond its estimate. */
 export const AUTO_LP_MARGIN = 2n;
 
-/** Mirrors `blast_fun_migrators::migration_math::sqrt_price_x64` over atomic Meme/Quote units. */
+/**
+ * `tick_math` sqrt-price bounds, Q64.64, shared by Cetus and Bluefin
+ * (`blast_core::constants::{min,max}_sqrt_price_x64`).
+ */
+const MIN_SQRT_PRICE_X64 = 4_295_048_016n;
+const MAX_SQRT_PRICE_X64 = 79_226_673_515_401_279_992_447_579_055n;
+
+/**
+ * Mirrors `blast_core::migration::sqrt_price_x64` over atomic Meme/Quote
+ * units: `floor(sqrt(B / A) * 2^64)`, B / A being Quote / Meme when Meme is
+ * coin A and Meme / Quote otherwise.
+ */
 export function sqrtPriceX64(
   memeAmount: bigint,
   quoteAmount: bigint,
@@ -15,7 +26,21 @@ export function sqrtPriceX64(
 }
 
 /**
- * Mirrors `migration_math::auto_lp_fixed_side`, which Bluefin auto-LP uses to
+ * Mirrors `migration::is_seedable_price`: whether Cetus and Bluefin can both
+ * seed a full-range pool at `sqrtPriceX64`, within
+ * `[2 * MIN_SQRT_PRICE_X64, MAX_SQRT_PRICE_X64 / 2]` (the upper bound rounds
+ * down).
+ */
+export function isSeedablePrice(sqrtPriceX64: bigint): boolean {
+  requireU128("sqrtPriceX64", sqrtPriceX64);
+  return (
+    sqrtPriceX64 >= MIN_SQRT_PRICE_X64 * 2n &&
+    sqrtPriceX64 <= MAX_SQRT_PRICE_X64 / 2n
+  );
+}
+
+/**
+ * Mirrors `blast_migrators::bluefin`'s `auto_lp_fixed_side`, which Bluefin auto-LP uses to
  * choose the fixed side from the pool's and the position's Q64.64 sqrt prices.
  * Returns `{ fixA, amount }`; a zero amount means nothing is added now.
  * Divisions round down except the other side's requirement, which rounds up.
@@ -58,10 +83,17 @@ function ratioQ128(
   quoteAmount: bigint,
   memeIsCoinA: boolean,
 ): bigint {
-  requirePositiveU64("memeAmount", memeAmount);
-  requirePositiveU64("quoteAmount", quoteAmount);
-  const numerator = memeIsCoinA ? quoteAmount : memeAmount;
-  const denominator = memeIsCoinA ? memeAmount : quoteAmount;
+  // Move divides by the coin-A side (it aborts at zero) and allows a zero
+  // numerator, whose price is 0 and not seedable.
+  const [numerator, denominator] = memeIsCoinA
+    ? [
+        requireU64("quoteAmount", quoteAmount),
+        requirePositiveU64("memeAmount", memeAmount),
+      ]
+    : [
+        requireU64("memeAmount", memeAmount),
+        requirePositiveU64("quoteAmount", quoteAmount),
+      ];
   return (numerator << 128n) / denominator;
 }
 

package/src/migration.ts

@@ -0,0 +1,69 @@
+import { bcs } from "@mysten/sui/bcs";
+import { moveTypeNameBcs, suiObjectIdBcs } from "./bcs.ts";
+import { bpsBcs } from "./bps.ts";
+import type { FeeSplit } from "./fee-split.ts";
+import { feeSplitBcs } from "./fee-split.ts";
+
+/**
+ * `blast_core::migration::ResidualPolicy`: migration residuals the pool does
+ * not take are paid to Blast (`Protocol`) or held for the owner (`Owner`).
+ * `VenueTicket`, `Migration` and `OwnerProof` have no abilities: they exist
+ * only inside one PTB, as transaction results, and have no BCS here.
+ */
+export type ResidualPolicy = "Protocol" | "Owner";
+
+export const residualPolicyBcs = bcs
+  .enum("ResidualPolicy", { Protocol: null, Owner: null })
+  .transform({
+    input: (policy: ResidualPolicy) =>
+      policy === "Protocol"
+        ? { Protocol: true as const }
+        : { Owner: true as const },
+    output: (policy): ResidualPolicy => policy.$kind,
+  });
+
+/**
+ * `blast_core::migration::VaultTerms`: what a vault snapshots from the sale
+ * that sealed its terms. `origin` is the launch or presale ID and
+ * `packageWitness` the original type of the product's package witness.
+ */
+export type VaultTerms = {
+  origin: string;
+  packageWitness: string;
+  feeSplit: FeeSplit;
+  protocolMemeBps: bigint;
+  protocolQuoteBps: bigint;
+  partnerId: string | null;
+  residuals: ResidualPolicy;
+};
+
+export const vaultTermsBcs = bcs
+  .struct("VaultTerms", {
+    origin: suiObjectIdBcs,
+    package_witness: moveTypeNameBcs,
+    fee_split: feeSplitBcs,
+    protocol_meme_bps: bpsBcs,
+    protocol_quote_bps: bpsBcs,
+    partner_id: bcs.option(suiObjectIdBcs),
+    residuals: residualPolicyBcs,
+  })
+  .transform({
+    input: (terms: VaultTerms) => ({
+      origin: terms.origin,
+      package_witness: terms.packageWitness,
+      fee_split: terms.feeSplit,
+      protocol_meme_bps: terms.protocolMemeBps,
+      protocol_quote_bps: terms.protocolQuoteBps,
+      partner_id: terms.partnerId,
+      residuals: terms.residuals,
+    }),
+    output: (terms): VaultTerms => ({
+      origin: terms.origin,
+      packageWitness: terms.package_witness,
+      feeSplit: terms.fee_split,
+      protocolMemeBps: terms.protocol_meme_bps,
+      protocolQuoteBps: terms.protocol_quote_bps,
+      partnerId: terms.partner_id,
+      residuals: terms.residuals,
+    }),
+  });

package/src/payout.ts

@@ -0,0 +1,57 @@
+import { bcs } from "@mysten/sui/bcs";
+import { addressBcs, u64Bcs } from "./bcs.ts";
+
+/**
+ * `blast_core::payout::VestingTerms`: `periods` equal steps of
+ * `periodDurationMs` each, the first available `cliffDelayMs` after the
+ * payout.
+ */
+export type VestingTerms = {
+  cliffDelayMs: bigint;
+  periodDurationMs: bigint;
+  periods: bigint;
+};
+
+/**
+ * `blast_core::payout::Recipient`: where a payout goes, paid outright when
+ * `vestingTerms` is null and locked under them otherwise.
+ */
+export type Recipient = {
+  destination: string;
+  vestingTerms: VestingTerms | null;
+};
+
+export const vestingTermsBcs = bcs
+  .struct("VestingTerms", {
+    cliff_delay_ms: u64Bcs,
+    period_duration_ms: u64Bcs,
+    periods: u64Bcs,
+  })
+  .transform({
+    input: (terms: VestingTerms) => ({
+      cliff_delay_ms: terms.cliffDelayMs,
+      period_duration_ms: terms.periodDurationMs,
+      periods: terms.periods,
+    }),
+    output: (terms): VestingTerms => ({
+      cliffDelayMs: terms.cliff_delay_ms,
+      periodDurationMs: terms.period_duration_ms,
+      periods: terms.periods,
+    }),
+  });
+
+export const recipientBcs = bcs
+  .struct("Recipient", {
+    destination: addressBcs,
+    vesting_terms: bcs.option(vestingTermsBcs),
+  })
+  .transform({
+    input: (recipient: Recipient) => ({
+      destination: recipient.destination,
+      vesting_terms: recipient.vestingTerms,
+    }),
+    output: (recipient): Recipient => ({
+      destination: recipient.destination,
+      vestingTerms: recipient.vesting_terms,
+    }),
+  });

package/src/protocol-fees.ts

@@ -0,0 +1,174 @@
+import { bcs } from "@mysten/sui/bcs";
+import type { SuiClientTypes } from "@mysten/sui/client";
+import {
+  normalizeStructTag,
+  normalizeSuiAddress,
+  parseStructTag,
+} from "@mysten/sui/utils";
+import {
+  addressBcs,
+  balanceBcs,
+  moveTypeNameBcs,
+  suiObjectIdBcs,
+  u64Bcs,
+} from "./bcs.ts";
+import { applyBpsUp } from "./bps.ts";
+import type { SuiEventPosition } from "./events.ts";
+import { normalizeSuiEventPosition } from "./events.ts";
+import { BASIS_POINTS_DENOMINATOR, mulDivDown } from "./integers.ts";
+
+/**
+ * `blast_core::protocol_fees::Ledger<Meme, Quote>`: Blast's held fees of one
+ * launch, presale or vault. `packageWitness` is the original type of the
+ * package witness that created it; `partnerId` is fixed at creation.
+ */
+export const ledgerBcs = bcs
+  .struct("Ledger", {
+    package_witness: moveTypeNameBcs,
+    origin: suiObjectIdBcs,
+    partner_id: bcs.option(suiObjectIdBcs),
+    meme: balanceBcs,
+    quote: balanceBcs,
+    sui: balanceBcs,
+  })
+  .transform({
+    input: (ledger: Ledger) => ({
+      package_witness: ledger.packageWitness,
+      origin: ledger.origin,
+      partner_id: ledger.partnerId,
+      meme: ledger.meme,
+      quote: ledger.quote,
+      sui: ledger.sui,
+    }),
+    output: (ledger): Ledger => ({
+      packageWitness: ledger.package_witness,
+      origin: ledger.origin,
+      partnerId: ledger.partner_id,
+      meme: ledger.meme,
+      quote: ledger.quote,
+      sui: ledger.sui,
+    }),
+  });
+
+export type Ledger = {
+  packageWitness: string;
+  origin: string;
+  partnerId: string | null;
+  meme: bigint;
+  quote: bigint;
+  sui: bigint;
+};
+
+/**
+ * Mirrors the amount `protocol_fees::take_cut` moves into the ledger from
+ * one fee of one asset: `ceil(amount * bps / 10,000)`; the fee keeps the rest.
+ */
+export function takeCut(amount: bigint, bps: bigint): bigint {
+  return applyBpsUp(amount, bps);
+}
+
+/** `blast_core::blast_core_events::ProtocolFeesPaid<Meme, Quote>`, in Move field order. */
+export const protocolFeesPaidBcs = bcs.struct("ProtocolFeesPaid", {
+  package_witness: moveTypeNameBcs,
+  origin: suiObjectIdBcs,
+  treasury: addressBcs,
+  meme_amount: u64Bcs,
+  quote_amount: u64Bcs,
+  sui_amount: u64Bcs,
+  partner_id: bcs.option(suiObjectIdBcs),
+  partner_meme_amount: u64Bcs,
+  partner_quote_amount: u64Bcs,
+  partner_sui_amount: u64Bcs,
+});
+
+export type ProtocolFeesPaid = ReturnType<typeof protocolFeesPaidBcs.parse>;
+
+export type DecodedProtocolFeesPaid = {
+  source: "core";
+  kind: "ProtocolFeesPaid";
+  memeType: string;
+  quoteType: string;
+  payload: ProtocolFeesPaid;
+  sender: string;
+  position: SuiEventPosition;
+};
+
+/**
+ * Decodes one `<core>::blast_core_events::ProtocolFeesPaid<Meme, Quote>`.
+ * `payload.origin` is the launch, presale or vault whose ledger paid, and
+ * `payload.package_witness` the package that created the ledger.
+ */
+export function decodeProtocolFeesPaid(
+  event: SuiClientTypes.EventEntry,
+  core: { originalPackageId: string },
+): DecodedProtocolFeesPaid {
+  const tag = parseStructTag(event.eventType);
+  const [meme, quote, ...extra] = tag.typeParams;
+  if (
+    tag.address !== normalizeSuiAddress(core.originalPackageId) ||
+    tag.module !== "blast_core_events" ||
+    tag.name !== "ProtocolFeesPaid" ||
+    meme === undefined ||
+    quote === undefined ||
+    extra.length > 0
+  ) {
+    throw new TypeError(`unexpected core event type ${event.eventType}`);
+  }
+  return {
+    source: "core",
+    kind: "ProtocolFeesPaid",
+    memeType: normalizeStructTag(meme),
+    quoteType: normalizeStructTag(quote),
+    payload: protocolFeesPaidBcs.parse(event.bcs),
+    sender: normalizeSuiAddress(event.sender),
+    position: normalizeSuiEventPosition(event),
+  };
+}
+
+/**
+ * Previews `protocol_fees::pay` / `pay_with_partner` over a decoded ledger:
+ * the bound partner's cut of each asset first (`partnerShareBps` of it,
+ * rounded down per asset as `blast_partners::pay`), Blast's treasury the
+ * rest. `partnerShareBps` is required exactly when the ledger names a
+ * partner. Null when the ledger is empty: the contract sends and emits
+ * nothing. Omits `package_witness`, `origin` and `treasury`, which the
+ * ledger and the treasury object carry.
+ */
+export function previewProtocolFeesPaid(
+  ledger: Ledger,
+  partnerShareBps: bigint | null,
+): Pick<
+  ProtocolFeesPaid,
+  | "meme_amount"
+  | "quote_amount"
+  | "sui_amount"
+  | "partner_id"
+  | "partner_meme_amount"
+  | "partner_quote_amount"
+  | "partner_sui_amount"
+> | null {
+  if ((ledger.partnerId === null) !== (partnerShareBps === null)) {
+    throw new TypeError(
+      "a partner share is required exactly when the ledger names a partner",
+    );
+  }
+  if (ledger.meme === 0n && ledger.quote === 0n && ledger.sui === 0n) {
+    return null;
+  }
+  const cut = (amount: bigint) =>
+    partnerShareBps === null
+      ? 0n
+      : mulDivDown(amount, partnerShareBps, BASIS_POINTS_DENOMINATOR);
+  const partnerMeme = cut(ledger.meme);
+  const partnerQuote = cut(ledger.quote);
+  const partnerSui = cut(ledger.sui);
+  return {
+    meme_amount: ledger.meme - partnerMeme,
+    quote_amount: ledger.quote - partnerQuote,
+    sui_amount: ledger.sui - partnerSui,
+    partner_id: ledger.partnerId,
+    partner_meme_amount: partnerMeme,
+    partner_quote_amount: partnerQuote,
+    partner_sui_amount: partnerSui,
+  };
+}

package/src/rewards/allocations.ts

@@ -10,6 +10,7 @@ import { requireU64 } from "../integers.ts";
 import {
   blake2b256,
   merkleLayers,
+  merkleLeaf,
   merkleNode,
   merkleProof,
   merkleRoot,
@@ -30,7 +31,7 @@ export type RewardProof = {
   proof: string[];
 };
 export type RewardManifest = {
-  version: 1;
+  version: 2;
   vaultId: string;
   number: string;
   startCheckpoint: string;
@@ -45,7 +46,6 @@ export type RewardManifest = {
 /** Complete commitment after durable paged construction; it does not contain all proofs in memory. */
 export type RewardManifestSummary = Omit<RewardManifest, "allocations"> & {
   leafCount: number;
-  leafDomain: RewardLeafDomain;
 };
 
 /**
@@ -93,14 +93,16 @@ const manifestHeaderBcs = bcs.struct("RewardManifestHeader", {
   start: bcs.u64(),
   end: bcs.u64(),
 });
-/** Leaf domain of `blast_fun_migrators` holder-reward rounds. */
-export const MIGRATOR_REWARD_LEAF_DOMAIN = "\x00blast-holder-rewards-v1";
-/** Leaf domain of `blast_presale::holder_rewards` rounds; same leaf layout. */
-export const PRESALE_REWARD_LEAF_DOMAIN = "\x00blast-presale-holder-rewards-v1";
-/** The package whose rounds a manifest pays: each hashes leaves under its own domain. */
-export type RewardLeafDomain =
-  | typeof MIGRATOR_REWARD_LEAF_DOMAIN
-  | typeof PRESALE_REWARD_LEAF_DOMAIN;
+/**
+ * `blast_vault::constants::reward_leaf_domain`: every vault's rounds hash
+ * their leaves as `merkle::leaf(REWARD_LEAF_DOMAIN, bcs(leaf))`.
+ */
+export const REWARD_LEAF_DOMAIN = "blast-holder-rewards-v2";
+
+/** One leaf digest: `blake2b256(0x00 || REWARD_LEAF_DOMAIN || bcs(leaf))`. */
+function rewardLeaf(bytes: Uint8Array): Uint8Array {
+  return merkleLeaf(REWARD_LEAF_DOMAIN, bytes);
+}
 
 /** Exact atomic-unit allocations, rounded down. Dust stays in the vault rewards balance. */
 export function allocateHolderRewards(
@@ -136,21 +138,25 @@ export function allocateHolderRewards(
 }
 
 /**
- * Quote atoms = floor(budget * wallet weight / frozen global weight), never a page denominator.
- * Remainders stay holder-owned; sum quoteAllocated over every page to calculate global dust.
- * Inputs are distinct qualifying wallets in canonical order; carry lastAddress into the next page.
+ * Atoms of each asset = floor(budget * wallet weight / frozen global weight), never a page
+ * denominator. Remainders stay holder-owned; sum memeAllocated and quoteAllocated over every page
+ * to calculate global dust. Inputs are distinct qualifying wallets in canonical order; carry
+ * lastAddress into the next page.
  */
 export function allocateHolderRewardPage(
   holders: readonly HolderWeight[],
+  memeBudget: bigint,
   quoteBudget: bigint,
   totalWeight: bigint,
   afterAddress?: string,
 ) {
+  requireU64("memeBudget", memeBudget);
   requireU64("quoteBudget", quoteBudget);
   if (totalWeight <= 0n) throw new RangeError("global weight must be positive");
   let lastAddress =
     afterAddress === undefined ? undefined : rewardAddress(afterAddress);
   let pageWeight = 0n;
+  let memeAllocated = 0n;
   let quoteAllocated = 0n;
   const allocations: RewardAllocation[] = [];
   for (const holder of holders) {
@@ -163,13 +169,21 @@ export function allocateHolderRewardPage(
     pageWeight += holder.weight;
     if (pageWeight > totalWeight)
       throw new RangeError("page weight exceeds global weight");
+    const memeAmount = (memeBudget * holder.weight) / totalWeight;
     const quoteAmount = (quoteBudget * holder.weight) / totalWeight;
-    if (quoteAmount > 0n)
-      allocations.push({ beneficiary, memeAmount: 0n, quoteAmount });
+    if (memeAmount > 0n || quoteAmount > 0n)
+      allocations.push({ beneficiary, memeAmount, quoteAmount });
+    memeAllocated += memeAmount;
     quoteAllocated += quoteAmount;
     lastAddress = beneficiary;
   }
-  return { allocations, pageWeight, quoteAllocated, lastAddress };
+  return {
+    allocations,
+    pageWeight,
+    memeAllocated,
+    quoteAllocated,
+    lastAddress,
+  };
 }
 
 /** Builds the public payout list and every positional proof, independent of the signing key. */
@@ -179,9 +193,7 @@ export function buildRewardManifest(options: {
   startCheckpoint: bigint;
   endCheckpoint: bigint;
   allocations: readonly RewardAllocation[];
-  leafDomain: RewardLeafDomain;
 }): RewardManifest {
-  const leafPrefix = new TextEncoder().encode(options.leafDomain);
   const vaultId = rewardAddress(options.vaultId);
   requireU64("number", options.number);
   requireU64("startCheckpoint", options.startCheckpoint);
@@ -221,9 +233,7 @@ export function buildRewardManifest(options: {
     quote: allocation.quoteAmount,
   }));
   const layers = merkleLayers(
-    leaves.map((leaf) =>
-      blake2b256(concat(leafPrefix, leafBcs.serialize(leaf).toBytes())),
-    ),
+    leaves.map((leaf) => rewardLeaf(leafBcs.serialize(leaf).toBytes())),
   );
   const memeAmount = requireU64(
     "total Meme",
@@ -234,7 +244,7 @@ export function buildRewardManifest(options: {
     allocations.reduce((sum, item) => sum + item.quoteAmount, 0n),
   );
   return {
-    version: 1,
+    version: 2,
     vaultId,
     number: options.number.toString(),
     startCheckpoint: options.startCheckpoint.toString(),
@@ -298,7 +308,6 @@ export async function buildRewardManifestPages(
     options.pageSize > MAX_REWARD_LEAVES
   )
     throw new RangeError("invalid page size");
-  const leafPrefix = new TextEncoder().encode(options.leafDomain);
   const digest = blake2b.create({ dkLen: 32 });
   digest.update(
     manifestHeaderBcs
@@ -331,7 +340,6 @@ export async function buildRewardManifestPages(
     options,
     vaultId,
     digest,
-    leafPrefix,
     store,
     writeHashes,
   );
@@ -343,7 +351,7 @@ export async function buildRewardManifestPages(
   const root = (await readHashes(level, 0, 1))[0];
   if (root === undefined) throw new Error("missing Merkle root");
   const summary: RewardManifestSummary = {
-    version: 1,
+    version: 2,
     vaultId,
     number: options.number.toString(),
     startCheckpoint: options.startCheckpoint.toString(),
@@ -353,9 +361,8 @@ export async function buildRewardManifestPages(
     memeAmount: memeAmount.toString(),
     quoteAmount: quoteAmount.toString(),
     leafCount: options.leafCount,
-    leafDomain: options.leafDomain,
   };
-  await writeManifestProofs(options, summary, leafPrefix, store, readHashes);
+  await writeManifestProofs(options, summary, store, readHashes);
   return summary;
 }
 
@@ -402,7 +409,6 @@ async function writeManifestLeaves(
   options: PagedManifestOptions,
   vaultId: string,
   digest: ReturnType<typeof blake2b.create>,
-  leafPrefix: Uint8Array,
   store: RewardManifestPageStore,
   writeHashes: WriteRewardHashes,
 ) {
@@ -428,7 +434,7 @@ async function writeManifestLeaves(
         quoteAmount + allocation.quoteAmount,
       );
       digest.update(bytes);
-      hashes.push(toHex(blake2b256(concat(leafPrefix, bytes))));
+      hashes.push(toHex(rewardLeaf(bytes)));
     }
     await writeHashes(0, offset, hashes);
   }
@@ -466,7 +472,6 @@ async function buildManifestMerkleLayers(
 async function writeManifestProofs(
   options: PagedManifestOptions,
   summary: RewardManifestSummary,
-  leafPrefix: Uint8Array,
   store: RewardManifestPageStore,
   readHashes: ReadRewardHashes,
 ) {
@@ -479,11 +484,8 @@ async function writeManifestProofs(
     const proofs = allocations.map((allocation, i): RewardProof => {
       if (
         toHex(
-          blake2b256(
-            concat(
-              leafPrefix,
-              rewardLeafBytes(options, summary.vaultId, allocation, offset + i),
-            ),
+          rewardLeaf(
+            rewardLeafBytes(options, summary.vaultId, allocation, offset + i),
           ),
         ) !== hashes[i]
       )
@@ -498,7 +500,7 @@ async function writeManifestProofs(
     });
     await fillManifestProofs(options, offset, proofs, readHashes);
     for (const proof of proofs)
-      if (!verifyRewardSummaryProof(summary, proof, options.leafDomain))
+      if (!verifyRewardSummaryProof(summary, proof))
         throw new Error("proof does not match constructed root");
     await store.writeProofs(offset, proofs);
     const stored = await store.readProofs(offset, count);
@@ -554,12 +556,10 @@ function rewardProofPagesMatch(
 export function verifyRewardProof(
   manifest: RewardManifest,
   allocation: RewardProof,
-  leafDomain: RewardLeafDomain,
 ): boolean {
   return verifyRewardSummaryProof(
-    { ...manifest, leafCount: manifest.allocations.length, leafDomain },
+    { ...manifest, leafCount: manifest.allocations.length },
     allocation,
-    leafDomain,
   );
 }
 
@@ -567,10 +567,7 @@ export function verifyRewardProof(
 export function verifyRewardSummaryProof(
   manifest: RewardManifestSummary,
   allocation: RewardProof,
-  leafDomain: RewardLeafDomain,
 ): boolean {
-  if (manifest.leafDomain !== leafDomain) return false;
-  const leafPrefix = new TextEncoder().encode(leafDomain);
   try {
     let index = Number(requireU64("index", BigInt(allocation.index)));
     const count = manifest.leafCount;
@@ -582,20 +579,17 @@ export function verifyRewardSummaryProof(
       allocation.proof.length !== Math.ceil(Math.log2(count))
     )
       return false;
-    let digest = blake2b256(
-      concat(
-        leafPrefix,
-        leafBcs
-          .serialize({
-            vault: rewardAddress(manifest.vaultId),
-            number: requireU64("number", BigInt(manifest.number)),
-            index: BigInt(index),
-            beneficiary: rewardAddress(allocation.beneficiary),
-            meme: requireU64("meme", BigInt(allocation.memeAmount)),
-            quote: requireU64("quote", BigInt(allocation.quoteAmount)),
-          })
-          .toBytes(),
-      ),
+    let digest = rewardLeaf(
+      leafBcs
+        .serialize({
+          vault: rewardAddress(manifest.vaultId),
+          number: requireU64("number", BigInt(manifest.number)),
+          index: BigInt(index),
+          beneficiary: rewardAddress(allocation.beneficiary),
+          meme: requireU64("meme", BigInt(allocation.memeAmount)),
+          quote: requireU64("quote", BigInt(allocation.quoteAmount)),
+        })
+        .toBytes(),
     );
     for (const sibling of allocation.proof) {
       const bytes = rewardDigest(sibling);
@@ -612,11 +606,8 @@ export function verifyRewardSummaryProof(
 /** Structural validation only; ready-plan evidence must prove durable construction upstream. */
 export function validateRewardManifestSummary(
   summary: RewardManifestSummary,
-  leafDomain: RewardLeafDomain,
 ): RewardManifestSummary {
-  if (summary.leafDomain !== leafDomain)
-    throw new TypeError("manifest leaf domain mismatch");
-  if (summary.version !== 1) throw new Error("unsupported manifest version");
+  if (summary.version !== 2) throw new Error("unsupported manifest version");
   if (summary.vaultId !== rewardAddress(summary.vaultId))
     throw new TypeError("noncanonical vault");
   for (const key of [
@@ -648,9 +639,8 @@ export function validateRewardManifestSummary(
 /** Rejects edited totals, roots, ordering, proofs and manifests before creating transactions. */
 export function validateRewardManifest(
   manifest: RewardManifest,
-  leafDomain: RewardLeafDomain,
 ): RewardManifest {
-  if (manifest.version !== 1) throw new Error("unsupported manifest version");
+  if (manifest.version !== 2) throw new Error("unsupported manifest version");
   const expected = buildRewardManifest({
     vaultId: manifest.vaultId,
     number: BigInt(manifest.number),
@@ -661,7 +651,6 @@ export function validateRewardManifest(
       memeAmount: BigInt(allocation.memeAmount),
       quoteAmount: BigInt(allocation.quoteAmount),
     })),
-    leafDomain,
   });
   for (const key of [
     "vaultId",
@@ -704,7 +693,3 @@ export function rewardDigest(value: string): Uint8Array {
     throw new TypeError("digest must be 32 canonical hex bytes");
   return fromHex(value);
 }
-
-function concat(left: Uint8Array, right: Uint8Array): Uint8Array {
-  return new Uint8Array([...left, ...right]);
-}