D17-F01-A01 / Released engineering topic

CAPM Beta

Measure how much of an asset's historical excess return moves with the market and separate that slope from unexplained return.

CAPM Beta canonical synthetic teaching chartD17 / D17-F01

Measure how much of an asset's historical excess return moves with the market and separate that slope from unexplained return. The useful result is not just a scalar. You should be able to trace it back to eligible observations, explain which convention produced it and recognize when the calculation should stop.

This tutorial builds OLS market-model beta with an intercept and Bartlett HAC standard errors. CAPM expected-return pricing is a separate restriction, not the fitted regression itself. You will calculate a small example, run matching Python and TypeScript implementations, inspect a controlled synthetic case and change one assumption in a guided lab. No historical market performance is claimed.

CAPM Beta: canonical synthetic calculation and its defining geometry

The chart shows the canonical fixture. Read the axis units before comparing values: a return, a score, a weight and a statistical diagnostic are different objects. Its numerical source is the same fixture used by the executable examples. Open the full-size chart when you need to inspect small labels.

Start with the question, then the mechanism

Think of beta as a conversion rate between two excess-return axes. A one percentage-point market movement corresponds to beta percentage points on the fitted asset line. Alpha shifts the line; it does not rotate it. Residuals are the vertical distances from observations to that line. More observations help only when the market varies and the sample remains relevant. An outlier can rotate the fitted line considerably, so the lab lets you compare a clean relation, larger residual noise and a constant-market rejection.

Fit an intercept and all declared factor columns jointly; reject a rank-deficient design instead of deleting a factor.

From fitted exposure to a pricing claim

There are three different questions in asset pricing. A time-series fit asks how an asset moved with supplied factors. A pricing restriction asks what its expected return should be. A trading decision asks whether a feasible position offers an attractive return after costs and uncertainty. The same coefficient cannot answer all three questions. Keep the expected-return assumption outside the realized-return regression until you have evidence that connects them.

For regression topics, arrange observations in chronological rows, include an intercept, and express every return in decimal units at the same frequency. Subtract the same-period risk-free return once from the asset. Do not subtract it again from a self-financing spread. The factor order is part of the API: a correct vector multiplied by mislabeled columns is a wrong model. Estimate all included columns jointly; one regression per factor does not estimate partial exposures.

The implementation uses reorthogonalized, column-scaled QR to solve least squares. This avoids explicitly forming the normal equations for the coefficient estimate. A column that becomes numerically dependent on earlier columns causes a rejection. Bartlett HAC covariance describes sampling uncertainty under appropriate weak-dependence conditions; it does not repair endogeneity, structural breaks, a mismatched benchmark, or an unrepresentative sample. The intercept remains a per-period return, not an automatically annualized alpha.

Before presenting results, inspect the residual series and fitted-versus-observed plot. Compare an economically motivated competing specification using the same dates. A smaller in-sample residual is expected when adding regressors; it is not by itself a reason to select the larger model. Out-of-sample evidence, model stability and the intended use determine whether the extra exposure estimates are helpful. The APT calculator is deliberately different: it accepts premia as assumptions rather than estimating them from this regression machinery.

Freeze the definition

yt=Ri,t−Rf,t=α+βxt+ϵt,xt=Rm,t−Rf,t;β^=∑t(xt−xˉ)(yt−yˉ)∑t(xt−xˉ)2y_t=R_{i,t}-R_{f,t}=\alpha+\beta x_t+\epsilon_t,\quad x_t=R_{m,t}-R_{f,t};\qquad\widehat\beta=\frac{\sum_t(x_t-\bar x)(y_t-\bar y)}{\sum_t(x_t-\bar x)^2}

R_i and R_f are decimal same-period total and risk-free returns; x is the market excess return; alpha is a per-period intercept; beta is dimensionless; epsilon is the fitted residual.

The sources establish the method's research context; the stated variant fixes the implementation choices for this package. See Sharpe (1964), Capital Asset Prices, statsmodels, cov_hac documentation. Where a teaching convention differs from a published portfolio or test, it is labeled explicitly rather than borrowing the published method's empirical conclusions.

Work a small example before running the code

For market excess returns -2%, -1%, 1%, 2% and asset excess returns -2.5%, -1%, 2%, 3.5%, the means are 0 and 0.5%. Centered cross-products total 0.0015 and squared market deviations total 0.001, so beta=1.5 and alpha=0.005. Residuals are zero by construction; a zero residual standard error is an exact-fit teaching boundary, not infinite economic evidence.

The machine-readable hand check is saved separately from the larger chart fixture. It asserts coefficients against [0.001, 1.2]. Some hand checks use a different small input from the prose example to test the same invariant from another direction. For a model with several regressors, a one-row attribution example cannot estimate the loadings; the multi-period executable fixture supplies the necessary observations.

To audit the arithmetic, carry full precision through intermediate values and round only for display. Ask whether the result's unit is consistent with the formula. Then consider a limiting case: does the method return an explicit rejection or undefined result when its denominator or identifying variation disappears?

Prepare data without borrowing from the future

InputTypeMeaning
assetnumber[]Aligned decimal total returns.
risk_freenumber[]Same-period decimal risk-free returns.
factorsnumber[][]Rows are dates; columns have the declared fixed factor order.
hac_lagsintegerBartlett lag count, 0 through n-1; default 2.

All calls also require formation_at, inputs_available_at and as_of as real ISO calendar dates. Inputs must be available by formation; formation cannot exceed the evaluation cutoff. Evaluation topics additionally require outcome start, end and availability dates. These envelope checks reject impossible chronology but cannot certify the provenance of individual rows. Your adapter must verify IDs, timestamps, frequency, currency, total-return adjustments, release dates and source vintages before building the arrays.

Missing, nonfinite, boolean or string-valued numbers are not silently repaired. The complete-case contract is intentional: changing eligibility changes the quantity being measured. Preserve the rejected records and the reason in a data-quality report, then choose a documented repair or a different model. Do not turn an undefined quantity into zero to make a chart look complete.

Follow the execution path

  1. Align returns and clocks. Fit an intercept and all declared factor columns jointly; reject a rank-deficient design instead of deleting a factor.
  2. Subtract the risk-free leg. Retain the inputs and the intermediate quantities; alignment is part of correctness.
  3. Fit exposures jointly. Calculate at full precision using the declared variant, not a convenient substitute.
  4. Inspect residuals and uncertainty. Check the method’s invariant and preserve undefined outcomes separately from numeric zero.
  5. Compare a competing specification. A loading estimates realized co-movement conditional on the included regressors. It is neither a forecast premium nor proof of a causal exposure.

Run the reference implementation

From the downloaded topic directory:

Shell
python examples/run.py
python -m unittest discover -s tests -p "test_*.py"
npx tsc -p implementations/typescript/tsconfig.json
node tests/test-typescript.mjs

The Python calculation has no third-party runtime dependency. TypeScript needs a compiler and an ES2022-capable JavaScript runtime. The public call accepts one JSON-shaped input and returns a discriminated success or error object. A minimal Python integration is:

Python
from pathlib import Path
import importlib.util, json

root = Path.cwd()  # Run from this topic directory.
spec = importlib.util.spec_from_file_location("topic", root / "implementations/python/algorithm.py")
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
data = json.loads((root / "datasets/canonical-input.json").read_text())
result = module.compute(data)
if result["status"] != "ok":
    raise ValueError(result["code"])
print(result["primary"])

After compilation, the equivalent TypeScript module can be used from JavaScript:

JavaScript
import { readFileSync } from 'node:fs';
import { compute } from './implementations/typescript/dist/algorithm.js';
const input = JSON.parse(readFileSync('./datasets/canonical-input.json', 'utf8'));
const result = compute(input);
if (result.status !== 'ok') throw new Error(result.code);
console.log(result.primary);

The canonical primary display is 1.2. More informative output fields include:

FieldCanonical value / first values
coefficients[0.001, 1.2]
standard_errors[0.000518063234, 0.0296026144]
fitted[0.0041358539, 0.00723735072, 0.0102705098, 0.0132020993, 0.016, 0.0186335576, …]
residuals[0.0029725793, 0.000418113853, -0.00235114101, -0.0039125904, -0.00346410162, -0.00123606798, …]
r_squared0.982532751

Inspect the complete returned object rather than reducing every use case to primary. That field is a playground convenience; the named intermediate and result fields preserve the method's meaning. Both languages use the same defaults and reason codes and do not mutate the input. Package tests compare the whole output tree, while independent mathematical checks avoid treating one implementation as the sole authority for the other.

Use the playground as an experiment

Open the topic's Playground tab or the self-contained guided lab. It starts from a meaningful canonical preview. Choose a scenario, predict the result, use Step to follow the calculation, and explain the evidence before pressing Play. Back and Reset let you revisit exactly the same state. Reduced-motion mode advances one deliberate step instead of running a timed sequence.

The main control is Residual noise multiplier, ranging from 0 to 3 with default 1. The comparison scenario is Double market exposure. The market coefficient describes slope; noise changes residual risk and its uncertainty. Every change recomputes the result through the validated TypeScript kernel; it does not select a prerecorded result.

The deliberate failure scenario, Constant market: exposure cannot be identified, should return SINGULAR_DESIGN. First explain which assumption failed. Then return to the canonical case and identify the information that makes the calculation possible. This rejection is part of the lesson: it prevents an invalid model from producing a plausible-looking number.

Double market exposure: the controlled alternative for CAPM Beta

This second chart uses the comparison scenario at the default parameter. The caption and diagnostics in the lab explain what changes and what remains invariant. Identical output can be the correct outcome of an invariance experiment; do not mistake it for a broken control.

Avoid these interpretation failures

  • Using raw asset returns with an excess market series changes the intercept and can change beta when the risk-free rate varies.
  • A low beta does not imply low total risk: residual volatility may be large.
  • A market return column that is constant cannot identify a slope.

A loading estimates realized co-movement conditional on the included regressors. It is neither a forecast premium nor proof of a causal exposure.

Check your understanding

Predict: If the asset excess returns double while market returns stay fixed, what happens to beta and alpha?

Explain: Both double in the same OLS sample. Correlation need not change. This separates slope scale from normalized association.

Investigate: Run the canonical case, the comparison and the deliberate rejection. Save the input, output and one sentence explaining each difference. Identify a field whose unit could be confused with another field, and describe the consequence of that confusion.

Transfer: Before substituting real data, write the upstream eligibility and alignment rules. Name the source vintage, decision time and missing-value policy. Then identify one out-of-sample or data-quality check needed for your intended use. A successful synthetic calculation is a correctness demonstration, not evidence that the market rewards the signal.

What this package does and does not establish

The implementation makes the declared formula reproducible, exposes intermediates and rejects known invalid inputs. The sources motivate the method. The synthetic fixture lets you control one mechanism at a time. A named historical case remains deferred until its source observations and decision-time provenance can be archived; no invented returns are presented as real history.

Production use needs dataset-specific validation, monitored numerical limits, error logging, independent review and an execution or inference design appropriate to the application. See the source-package data contract and reference ledger for the full boundary. Educational material is not a recommendation to buy, sell or allocate capital.

Sources and further reading

Choosing the method and continuing the lesson

This lesson is for analysts and developers who can work with aligned numerical arrays, means and return units. Regression and statistical-test topics also assume familiarity with residuals and sampling uncertainty; review the linked prerequisite before interpreting an inferential result.

DecisionDeclared approachNeighbor or alternative
Beta versus correlationBeta retains relative volatility scale.Correlation is dimensionless association bounded by one.
OLS versus pricing CAPMEstimate realized intercept and slope.A pricing claim additionally restricts expected excess return to beta times the expected market premium.

Use the declared approach when its input and interpretation match your research question. If you choose the alternative, freeze a new convention and rerun the examples; changing a label is not enough to change the calculation.

Related concepts

Excess return, Total return. For any use with observed market data, keep the point-in-time dataset boundary explicit.

Learning connections

  • Preparation: review the linked glossary definitions, means, dispersion and the input contract before starting.
  • Comparison: Fama-French Three-Factor Model. Compare its question and output units before substituting it for this method.
  • Continue with: Fama-French Three-Factor Model. Carry the same formation clock and declared units into the next calculation.

Inspect the return attribution

In playground steps 3 and 4, the stage changes from fitted-versus-observed returns to an attribution for one selected date. Add alpha, each named factor contribution and the residual to reconstruct that date’s observed excess return. The diagnostic cards expose every loading, so a reversed size, value, momentum or profitability tilt remains visible even when market beta barely changes. Return to step 5 to compare the complete sample.

Calculation flow

ReferencesPrimary sources and evidence notes

Expand the source trail, evidence role, and limitations behind the engineering choices.

Sharpe (1964), Capital Asset Prices

  • Source: Sharpe (1964), Capital Asset Prices
  • Version / date: 1964
  • Accessed: 2026-09-22
  • Supports: Equilibrium CAPM and systematic-risk interpretation; not proof that an empirical beta prices an asset.
  • Limitations: methodological context only; no claim that the source validates this synthetic sample or every educational convention.
  • Reuse: cited, not copied. No source dataset is redistributed.

statsmodels, cov_hac documentation

  • Source: statsmodels, cov_hac documentation
  • Version / date: development documentation, accessed 2026-09-22
  • Accessed: 2026-09-22
  • Supports: Bartlett-weight Newey-West covariance for equally spaced observations; our finite-sample convention is stated explicitly.
  • Limitations: methodological context only; no claim that the source validates this synthetic sample or every educational convention.
  • Reuse: cited, not copied. No source dataset is redistributed.

Evidence boundaries

The formulas are operationalized in the canonical README with explicit package conventions. Original synthetic fixtures isolate mechanisms and are not a historical performance claim. External source access can be restricted; the MacKinlay archive is a bibliographic reference, not a claim that its full text was retrieved during this build.

Historical case decision: deferred. A named empirical case would require a separately archived point-in-time universe, source vintage and outcome design. A synthetic control is used here to demonstrate regression without attributing invented observations to a market. This limits empirical coverage; it does not change the mathematical contract.

When using live data, archive the retrieval date, provider query, license, currency, frequency, adjustment basis and transformation log. Do not imply that the primary authors endorsed this educational implementation.

algorithm.ts
/** D17 reference algorithms. JSON boundary validation is deliberate and shared.
 * Arrays are copied before sorting; callers' inputs are never mutated.
 * QR solves least squares without forming normal equations.
 */
type Data = Record<string, any>;
type Result = Record<string, any>;
class ContractError extends Error {
}
const fail = (code: string): never => { throw new ContractError(code); };
const num = (x: unknown): number => typeof x === 'number' && Number.isFinite(x) ? x : fail('INVALID_NUMBER');
function integer(x: unknown, lo: number, hi: number): number { const v = num(x); return Number.isInteger(v) && v >= lo && v <= hi ? v : fail('INVALID_PARAMETER'); }
function vec(x: unknown, min = 1): number[] { if (!Array.isArray(x))
    fail('INVALID_SHAPE'); const a = x as unknown[]; if (a.length < min)
    fail('INSUFFICIENT_DATA'); return a.map(num); }
function mat(x: unknown, min = 1): number[][] { if (!Array.isArray(x) || x.length < min)
    fail('INSUFFICIENT_DATA'); const a = (x as unknown[]).map(v => vec(v)); if (new Set(a.map(r => r.length)).size !== 1)
    fail('LENGTH_MISMATCH'); return a; }
function same(...x: {
    length: number;
}[]): void { if (new Set(x.map(a => a.length)).size !== 1)
    fail('LENGTH_MISMATCH'); }
function ids(d: Data, n: number): string[] { required(d, ['ids']); if (!Array.isArray(d.ids) || d.ids.length !== n)
    fail('LENGTH_MISMATCH'); if (d.ids.some((v: unknown) => typeof v !== 'string' || !/^[A-Za-z0-9_.-]+$/.test(v)))
    fail('INVALID_ID'); if (new Set(d.ids).size !== n)
    fail('DUPLICATE_ID'); return [...d.ids]; }
function required(d: Data, keys: string[]): void { for (const key of keys)
    if (!Object.hasOwn(d, key))
        fail('MISSING_FIELD'); }
function validDate(v: unknown): boolean { if (typeof v !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(v) || v.startsWith('0000'))
    return false; const date = new Date(v + 'T00:00:00Z'); return Number.isFinite(date.valueOf()) && date.toISOString().slice(0, 10) === v; }
function context(d: Data, op: string): void {
    const keys = ['as_of', 'formation_at', 'inputs_available_at'];
    const evaluation = ['ic', 'rank_ic', 'spread', 'decay'].includes(op);
    if (evaluation)
        keys.push('outcomes_start_at', 'outcomes_end_at', 'outcomes_available_at');
    required(d, keys);
    if (keys.some(k => !validDate(d[k])))
        fail('INVALID_DATE');
    if (d.formation_at > d.as_of || d.inputs_available_at > d.formation_at)
        fail('FUTURE_INPUT');
    if (evaluation) {
        if (d.outcomes_start_at < d.formation_at || d.outcomes_end_at < d.outcomes_start_at)
            fail('INVALID_OUTCOME_WINDOW');
        if (d.outcomes_available_at < d.outcomes_end_at)
            fail('INVALID_DATE_ORDER');
        if (d.outcomes_available_at > d.as_of)
            fail('IMMATURE_OUTCOME');
    }
}
const sum = (a: number[]): number => a.reduce((s, v) => s + v, 0);
const mean = (a: number[]): number => sum(a) / a.length;
const dot = (a: number[], b: number[]): number => sum(a.map((v, i) => v * b[i]));
const tr = (a: number[][]): number[][] => a[0].map((_, j) => a.map(r => r[j]));
const mm = (a: number[][], b: number[][]): number[][] => { const cols = tr(b); return a.map(row => cols.map(col => dot(row, col))); };
function sd(x: number[], ddof = 0): number { const m = mean(x); return Math.sqrt(sum(x.map(v => (v - m) ** 2)) / (x.length - ddof)); }
function standard(x: number[]): number[] { const m = mean(x), s = sd(x); if (s <= 1e-14 * Math.max(1, ...x.map(Math.abs)))
    fail('CONSTANT_CROSS_SECTION'); return x.map(v => (v - m) / s); }
function corr(x: number[], y: number[]): number | null { same(x, y); if (Math.max(...x) === Math.min(...x) || Math.max(...y) === Math.min(...y))
    return null; const xm = mean(x), ym = mean(y), a = x.map(v => v - xm), b = y.map(v => v - ym), den = Math.sqrt(dot(a, a) * dot(b, b)); return den <= 0 ? null : Math.max(-1, Math.min(1, dot(a, b) / den)); }
function ranks(x: number[]): number[] { const order = x.map((_, i) => i).sort((a, b) => x[a] - x[b]); const out = x.map(() => 0); let start = 0; while (start < x.length) {
    let end = start + 1;
    while (end < x.length && x[order[end]] === x[order[start]])
        end++;
    for (let j = start; j < end; j++)
        out[order[j]] = (start + 1 + end) / 2;
    start = end;
} return out; }
function quantile(x: number[], p: number): number { const y = [...x].sort((a, b) => a - b), h = (y.length - 1) * p, j = Math.floor(h), f = h - j; return y[j] * (1 - f) + y[Math.min(j + 1, y.length - 1)] * f; }
function compound(x: number[]): number { if (x.some(v => v <= -1))
    fail('INVALID_RETURN'); return Math.expm1(sum(x.map(Math.log1p))); }
/** erfc(|z|/sqrt(2)) via regularized Gamma(1/2,x); converged series/CF. */
function normalP(z: number): number {
    const x = z * z / 2, a = 0.5, lg = 0.5723649429247001;
    if (x === 0)
        return 1;
    const factor = Math.exp(-x + a * Math.log(x) - lg);
    if (x < a + 1) {
        let term = 1 / a, total = term, ap = a;
        for (let i = 1; i < 500; i++) {
            ap++;
            term *= x / ap;
            total += term;
            if (Math.abs(term) < Math.abs(total) * 1e-15)
                break;
        }
        return Math.max(0, 1 - total * factor);
    }
    let b = x + 1 - a, c = 1e300, d = 1 / b, h = d;
    for (let i = 1; i < 500; i++) {
        const an = -i * (i - a);
        b += 2;
        d = an * d + b;
        if (Math.abs(d) < 1e-300)
            d = 1e-300;
        c = b + an / c;
        if (Math.abs(c) < 1e-300)
            c = 1e-300;
        d = 1 / d;
        const delta = d * c;
        h *= delta;
        if (Math.abs(delta - 1) < 1e-15)
            break;
    }
    return Math.max(0, Math.min(1, factor * h));
}
export function ols(y: number[], x: number[][], lags = 0): Result {
    const n = y.length, p = x[0].length;
    same(y, x);
    if (n <= p)
        fail('INSUFFICIENT_DATA');
    integer(lags, 0, n - 1);
    const cols = tr(x), scales = cols.map(c => Math.sqrt(dot(c, c)));
    if (scales.some(s => s === 0))
        fail('SINGULAR_DESIGN');
    const q: number[][] = [], r = Array.from({ length: p }, () => Array(p).fill(0) as number[]);
    for (let j = 0; j < p; j++) {
        let v = cols[j].map(z => z / scales[j]);
        for (let pass = 0; pass < 2; pass++)
            for (let i = 0; i < j; i++) {
                const proj = dot(q[i], v);
                r[i][j] += proj;
                v = v.map((z, t) => z - proj * q[i][t]);
            }
        r[j][j] = Math.sqrt(dot(v, v));
        if (r[j][j] < 1e-10)
            fail('SINGULAR_DESIGN');
        q.push(v.map(z => z / r[j][j]));
    }
    const solve = (v: number[]): number[] => { const b = Array(p).fill(0) as number[]; for (let i = p - 1; i >= 0; i--) {
        let s = 0;
        for (let j = i + 1; j < p; j++)
            s += r[i][j] * b[j];
        b[i] = (v[i] - s) / r[i][i];
    } return b; };
    const beta = solve(q.map(c => dot(c, y))).map((b, i) => b / scales[i]), fitted = x.map(row => dot(row, beta)), residuals = y.map((v, i) => v - fitted[i]);
    const invr = tr(Array.from({ length: p }, (_, j) => solve(Array.from({ length: p }, (_, i) => Number(i === j)))));
    const bread = mm(invr, tr(invr)).map((row, i) => row.map((v, j) => v / scales[i] / scales[j]));
    const scores = x.map((row, t) => row.map(v => v * residuals[t])), meat = mm(tr(scores), scores);
    for (let lag = 1; lag <= lags; lag++) {
        const w = 1 - lag / (lags + 1);
        for (let t = lag; t < n; t++)
            for (let i = 0; i < p; i++)
                for (let j = 0; j < p; j++)
                    meat[i][j] += w * (scores[t][i] * scores[t - lag][j] + scores[t - lag][i] * scores[t][j]);
    }
    const cov = mm(mm(bread, meat), bread), se = cov.map((row, i) => Math.sqrt(Math.max(0, row[i]))), sse = dot(residuals, residuals), ym = mean(y), sst = sum(y.map(v => (v - ym) ** 2));
    return { coefficients: beta, standard_errors: se, fitted, residuals, r_squared: sst === 0 ? null : 1 - sse / sst, n, df_residual: n - p, hac_lags: lags, residual_sum_squares: sse, qr_min_diagonal: Math.min(...r.map((row, i) => row[i])) };
}
function regression(d: Data, op: string): Result {
    required(d, ['asset', 'risk_free', 'factors']);
    const y = vec(d.asset), rf = vec(d.risk_free), f = mat(d.factors);
    same(y, rf, f);
    if (Math.min(...y, ...rf) < -1)
        fail('INVALID_RETURN');
    const names: Record<string, string[]> = { capm: ['MKT-RF'], ff3: ['MKT-RF', 'SMB', 'HML'], carhart: ['MKT-RF', 'SMB', 'HML', 'MOM'], ff5: ['MKT-RF', 'SMB', 'HML', 'RMW', 'CMA'] };
    if (f[0].length !== names[op].length)
        fail('FACTOR_COUNT');
    const excess = y.map((v, i) => v - rf[i]), out = ols(excess, f.map(row => [1, ...row]), d.hac_lags ?? 2);
    return { ...out, coefficient_names: ['alpha', ...names[op]], primary: out.coefficients[1], excess_returns: excess, factor_contributions: f.map(row => row.map((v, j) => v * out.coefficients[j + 1])) };
}
/** D17-F01-A01 public boundary. No mutation, implicit imputation or silent failure. */
export function compute(input: unknown): Result {
    const op = "capm";
    try {
        if (!input || typeof input !== 'object' || Array.isArray(input))
            fail('INVALID_SHAPE');
        const d = input as Data;
        if (Object.values(d).some(v => v === null))
            fail('INVALID_NUMBER');
        context(d, op);
        const result = regression(d, op);
        const check = (v: unknown): void => { if (typeof v === 'number' && !Number.isFinite(v))
            fail('NUMERICAL_FAILURE'); if (Array.isArray(v))
            v.forEach(check);
        else if (v && typeof v === 'object')
            Object.values(v).forEach(check); };
        check(result);
        return { status: 'ok', method: op, ...result };
    }
    catch (error) {
        if (error instanceof ContractError)
            return { status: 'error', method: op, code: error.message };
        throw error;
    }
}
Full-height lablessonOpen full screen
Written by

Fintech engineer building market-data and financial systems, and the author of every article, glossary record, and reference implementation on The Fintech Builder.