Computing a real, point-inclusive price

"Option A has the lower sticker price, but option B gives more points back — so which is actually cheaper?" You want to answer that in code. The naive version is one line:

const effectivePrice = displayPrice - totalPoints; // this inflates the number

But subtract every point and you're in trouble. Entry-required campaigns and your own loyalty multiplier get folded in, so the "cheapest" becomes a price you only reach if every condition is met — not a floor anyone can count on. The cause is mixing points you'll definitely get with points you might get.

I hit this while computing points for Japanese marketplaces (Rakuten, Yahoo!), and settled on splitting points by certainty into three layers. The code is short; the idea is the point.

Split points by certainty into three layers

Layer	Contents	Used for ranking
① Confirmed	Actual points the API returns	Yes
② Conditional	Known campaigns ("5 and 0 days", etc.)	No
③ Assumed	Your own loyalty multiplier / shop-hopping	No

Rank on the confirmed layer only, and show ② and ③ as "the most it could drop." The order comes out the same for everyone, and the upside flexes per person. It also avoids the behavior where whoever inflates their loyalty settings most reshuffles the top.

Minimal implementation

Floor each layer before summing. Sum first and floor once, and you land a few yen off the real grant.

type Tier = "confirmed" | "conditional" | "assumed";

function computeEffectivePrice(
  base: number,
  layers: { rate: number; cap?: number; tier: Tier }[],
) {
  let confirmed = 0,
    conditional = 0,
    assumed = 0;
  for (const l of layers) {
    let pts = Math.floor(base * l.rate); // floor per layer
    if (l.cap != null) pts = Math.min(pts, l.cap); // cap applies after floor
    if (l.tier === "confirmed") confirmed += pts;
    else if (l.tier === "conditional") conditional += pts;
    else assumed += pts;
  }
  const rankKey = base - confirmed; // ranking subtracts the confirmed layer only
  const total = confirmed + conditional + assumed;
  const effectivePrice = Math.max(0, base - total); // display subtracts all, guarded
  return { rankKey, effectivePrice };
}

The ranking key (rankKey) subtracts only the confirmed layer; the displayed effectivePrice subtracts every layer. Same price, different layers for ranking versus display — that's the crux. High-reward items can push total points past the price, so Math.max(0, …) guards against a negative.

Gotchas

• Floor order: the cap takes Math.min against the floored point-yen. Cap first, floor second, and you're off by one. Real grants are usually floored per campaign too, so per-layer flooring lands closer to the actual amount.
• Store rates as the increment: a campaign's "+4×" is the added grant on top of the tax-inclusive price. Multiply by the raw multiplier and you double-count the standard points everyone already gets. The base 1× is increment zero.

Wrapping up

A real price reads as "sticker minus points" in one line, but a trustworthy one needs the certainty split: rank on the confirmed layer, show conditional and assumed as a range, floor per layer before summing. That alone prevents "the cheapest one was actually conditional."

Leaving shipping out (no marketplace API returns it, so I don't guess), disclosing entry/cap requirements, and wiring this into price history and notifications are on the Aulvem site → Computing the real, point-inclusive price across marketplaces