DEV Community: diogenicious

Average price and break-even from a list of buys, in TypeScript

diogenicious — Fri, 13 Nov 2026 14:50:52 +0000

"What is my average price?" sounds like a one line problem. It is, but the obvious one liner is wrong, and the bug is common enough to be worth a short post.

Disclosure: I am the founder of copy.top. We publish a free dca and average price calculator, and this post explains the math behind that kind of tool. The code below is a minimal version written for this article.

The bug

You buy twice, 100 dollars each time: once at 1.00 and once at 0.50.

The tempting answer is the mean of the two prices:

(1.0 + 0.5) / 2; // 0.75, wrong

It is wrong because you did not buy the same number of coins each time. The first buy got 100 coins, the second got 200. You hold 300 coins for 200 dollars, so the average price is 200 / 300, about 0.667.

When each buy is a fixed amount of money, the average price is the harmonic mean of the prices, not the arithmetic mean. You never need to remember that if you always compute it the same way:

average = total spent / total coins

The code

interface Buy {
  spent: number; // money spent on this buy
  price: number; // price paid per coin
}

interface Position {
  spent: number;   // total money in
  coins: number;   // total coins held
  average: number; // average price, also the break-even price
  valueAt: (price: number) => number;
  pnlAt: (price: number) => number;
}

export function averagePrice(buys: Buy[]): Position {
  const valid = buys.filter((b) => b.spent > 0 && b.price > 0);
  if (valid.length === 0) {
    throw new RangeError("add at least one buy with a positive amount and price");
  }

  const spent = valid.reduce((sum, b) => sum + b.spent, 0);
  const coins = valid.reduce((sum, b) => sum + b.spent / b.price, 0);

  return {
    spent,
    coins,
    average: spent / coins,
    valueAt: (price) => coins * price,
    pnlAt: (price) => coins * price - spent,
  };
}

A worked example

const p = averagePrice([
  { spent: 100, price: 1.0 },
  { spent: 100, price: 0.5 },
]);

p.spent;       // 200
p.coins;       // 300
p.average;     // 0.6666...
p.pnlAt(0.8);  // 40

Break-even is the average price

Your position is worth what you paid when coins * price = spent, so the break-even price is spent / coins. That is the average price. No second formula needed.

In practice the real break-even is a little higher, because selling has costs. A calculator should say that its break-even is before fees and slippage.

Two design choices

Filter or throw? The function ignores rows where the amount or the price is not positive, and throws only if nothing is left. In a form with several rows, people leave empty rows all the time. Throwing on the first empty row makes the tool annoying, and silently returning NaN makes it wrong.

Store the buys, not the average. If you keep only a running average and a coin count, you cannot edit or remove a past buy without rounding drift. Keep the list and recompute. It is a reduce over a handful of rows.

A related one liner: the market cap multiple

The same kind of question comes up with small coins: "what is my bag worth if the market cap goes from here to there?" With the supply unchanged, value scales with market cap:

const valueAtCap = (bagValue: number, capNow: number, capTarget: number) =>
  bagValue * (capTarget / capNow);

valueAtCap(250, 5_000_000, 50_000_000); // 2500

It is a hypothetical, not a forecast. Most coins never reach the cap people type into that field.

If you only need the numbers, the hosted versions are here, free and with no sign up: dca and average price and market cap. Nothing here is financial advice.

Position sizing in a few lines of TypeScript

diogenicious — Fri, 13 Nov 2026 14:42:39 +0000

Position sizing answers one question: how big can this trade be if I accept to lose a fixed share of my account when my stop is hit?

It is a small formula, and a good exercise in input validation and floating point. Here is a version in TypeScript.

Disclosure: I am the founder of copy.top. We publish a free position size calculator, and this post explains the math behind that kind of tool. The code below is a minimal version written for this article.

The formula

Four inputs:

account: the size of your account
riskPct: the share of the account you accept to lose on one trade, in percent
entry: your entry price
stop: the price where you exit if you are wrong

Then:

riskAmount  = account * riskPct / 100
lossPerCoin = |entry - stop|
quantity    = riskAmount / lossPerCoin
notional    = quantity * entry

The idea is that the stop distance decides the size. A tight stop allows a bigger position, a wide stop forces a smaller one, and the loss at the stop stays the same.

The code

interface SizeInput {
  account: number;
  riskPct: number;
  entry: number;
  stop: number;
}

interface SizeResult {
  side: "long" | "short";
  riskAmount: number;     // what you lose if the stop is hit
  quantity: number;       // position size in coins
  notional: number;       // position size in quote currency
  leverageNeeded: number; // notional / account
}

export function positionSize(i: SizeInput): SizeResult {
  if (i.account <= 0 || i.entry <= 0 || i.stop <= 0) {
    throw new RangeError("account, entry and stop must be positive");
  }
  if (i.riskPct <= 0 || i.riskPct > 100) {
    throw new RangeError("riskPct must be above 0 and at most 100");
  }
  if (i.entry === i.stop) {
    throw new RangeError("entry and stop must differ");
  }

  const riskAmount = i.account * (i.riskPct / 100);
  const lossPerCoin = Math.abs(i.entry - i.stop);
  const quantity = riskAmount / lossPerCoin;
  const notional = quantity * i.entry;

  return {
    side: i.stop < i.entry ? "long" : "short",
    riskAmount,
    quantity,
    notional,
    leverageNeeded: notional / i.account,
  };
}

The side is inferred from the stop: a stop below the entry means a long, a stop above means a short. One less field for the user to get wrong.

A worked example

positionSize({ account: 1000, riskPct: 1, entry: 0.5, stop: 0.45 });
// side: "long"
// riskAmount: 10
// quantity: 200.00000000000006
// notional: 100.00000000000003
// leverageNeeded: 0.10000000000000003

With a tighter stop at 0.49, the same risk gives about 1000 coins and a notional of about 500. Same loss at the stop, five times the size.

The floating point detail

0.5 - 0.45 is not exactly 0.05 in binary floating point, which is why the quantity is 200.00000000000006.

Do the math in full precision and round only for display:

const fmt = (n: number, digits = 2) =>
  n.toLocaleString("en-US", { maximumFractionDigits: digits });

fmt(200.00000000000006); // "200"

Do not round the intermediate values. Rounding lossPerCoin before dividing can change the result by a visible amount when the stop is very close to the entry.

What `leverageNeeded` tells you

If leverageNeeded is above 1, the position is larger than the account, so it can only be opened with leverage. That is worth showing in a UI: a tight stop can quietly ask for a lot of leverage.

What the formula cannot do

The loss is riskAmount only if you exit exactly at the stop. On thin markets the price can jump past it, and the real loss is larger. Fees and slippage add to it. Treat the result as the planned loss, not the maximum loss.

If you only need the numbers, the hosted version is here, free and with no sign up. Nothing here is financial advice.

The math behind a liquidation price calculator, in TypeScript

diogenicious — Fri, 13 Nov 2026 14:41:39 +0000

Most leverage calculators hide one small piece of algebra. Here it is, derived step by step, with a TypeScript function you can paste into a project.

Disclosure: I am the founder of copy.top. We publish a free leverage and liquidation calculator, and this post explains the math behind that kind of tool. The code below is a minimal version written for this article.

The setup

You post some margin, choose a leverage, and open a position at an entry price.

Position size in quote currency: notional = margin * leverage
Position size in coins: quantity = notional / entry

The exchange closes the position when your equity falls to the maintenance requirement. For an isolated position, with a maintenance margin rate m:

Equity at price P, long: margin + quantity * (P - entry)
Maintenance requirement at price P: m * quantity * P

Solving for the liquidation price

Set equity equal to the requirement for a long:

margin + quantity * (P - entry) = m * quantity * P

Divide by quantity and use margin / quantity = entry / leverage:

entry / leverage + P - entry = m * P
P * (1 - m) = entry * (1 - 1 / leverage)
P = entry * (1 - 1 / leverage) / (1 - m)

For a short the signs flip:

P = entry * (1 + 1 / leverage) / (1 + m)

Both cases fit in one formula with a direction of +1 for a long and -1 for a short.

The code

type Side = "long" | "short";

interface LeverageInput {
  margin: number;      // collateral you post, in quote currency
  leverage: number;    // 1 or more
  entry: number;       // entry price
  side: Side;
  maintenance: number; // maintenance margin rate, for example 0.005
}

interface LeverageResult {
  notional: number;    // position size in quote currency
  quantity: number;    // position size in coins
  liquidation: number; // estimated liquidation price
  pnlAt: (exit: number) => number;
}

export function leverage(i: LeverageInput): LeverageResult {
  if (i.margin <= 0 || i.entry <= 0) {
    throw new RangeError("margin and entry must be positive");
  }
  if (i.leverage < 1) {
    throw new RangeError("leverage must be 1 or more");
  }
  if (i.maintenance < 0 || i.maintenance >= 1 / i.leverage) {
    throw new RangeError("maintenance rate must be below 1 / leverage");
  }

  const notional = i.margin * i.leverage;
  const quantity = notional / i.entry;
  const dir = i.side === "long" ? 1 : -1;
  const liquidation =
    (i.entry * (1 - dir / i.leverage)) / (1 - dir * i.maintenance);

  return {
    notional,
    quantity,
    liquidation,
    pnlAt: (exit) => dir * quantity * (exit - i.entry),
  };
}

A worked example

const r = leverage({
  margin: 100,
  leverage: 10,
  entry: 2,
  side: "long",
  maintenance: 0.005,
});

r.notional;    // 1000
r.quantity;    // 500
r.liquidation; // 1.809045...
r.pnlAt(2.1);  // 50 (floating point gives 50.00000000000004)

The same inputs as a short give a liquidation price of about 2.189.

A quick way to test the function: at the liquidation price, margin + pnlAt(liquidation) must equal maintenance * quantity * liquidation. Here both sides are about 4.52.

Three things the formula ignores

Fees and funding. Both reduce equity over time, so the real liquidation price is closer to your entry than the estimate.
Cross margin. With cross margin the whole account backs the position, and the answer depends on your other positions.
Tiered maintenance rates. Many venues raise the maintenance rate with position size. A single m is an approximation.

That is why a calculator should label the result as an estimate.

Why the validation line matters

maintenance >= 1 / leverage means the position would be liquidated the moment it opens. Without that check the function returns a liquidation price on the wrong side of the entry, and a UI would show it as if it were valid. Reject it early.

If you only need the numbers, the hosted version is here, free and with no sign up. Leverage multiplies losses as well as gains, and nothing here is financial advice.

DEV Community: diogenicious

Average price and break-even from a list of buys, in TypeScript

The bug

The code

A worked example

Break-even is the average price

Two design choices

A related one liner: the market cap multiple

Position sizing in a few lines of TypeScript

The formula

The code

A worked example

The floating point detail

What leverageNeeded tells you

What the formula cannot do

The math behind a liquidation price calculator, in TypeScript

The setup

Solving for the liquidation price

The code

A worked example

Three things the formula ignores

Why the validation line matters

What `leverageNeeded` tells you