@provex/utils 1.9.2 → 1.10.0-rc.20260912192040.fdbb8fc

package/dist/rateInput.js

@@ -0,0 +1,173 @@
+/**
+ * @fileoverview Parsing, keystroke handling and plausibility checks for
+ * maker-entered conversion rates.
+ *
+ * ## Why this module exists
+ *
+ * A conversion rate is typed as text and stored on chain as an 18-decimal
+ * bigint. Ten production deposits were created with rates inflated by exactly
+ * `10 ** (decimal places typed)` — `1.029` became `1029`, `1.15` became `115`,
+ * `1.2` became `12` — because the deposit-creation form held the rate in
+ * component state as a bigint and re-derived the displayed text from it on
+ * every keystroke. The half-finished string `"1."` parses to the same bigint as
+ * `"1"`, so the formatter rendered it back as `"1"` and the decimal separator
+ * the maker had just typed was erased. Every later digit then landed in the
+ * whole-number part.
+ *
+ * Three deposits are still live on PulseChain priced a thousand times above
+ * market, which no buyer will ever fill.
+ *
+ * ## The rule this module enforces
+ *
+ * The maker's raw text is the single source of truth while editing, and it is
+ * converted to a bigint exactly once, at submit. Nothing re-derives the text
+ * from the number. {@link nextRateInputValue} is the whole of the editing
+ * transition, and it is a pure string-to-string function precisely so that
+ * "type it one character at a time" and "paste it in one go" cannot diverge —
+ * see the fuzz tests in `rateInput.test.ts`, which assert that equivalence over
+ * generated input.
+ *
+ * ## Separator policy
+ *
+ * Digits and a single separator are accepted, and **every separator is a
+ * decimal separator**. A comma is normalised to a period, so a maker on a
+ * locale that writes `0,978` and one that writes `0.978` both get 0.978.
+ * Group separators are deliberately *not* accepted: a rate never needs
+ * grouping to be typed, and accepting it reintroduces the exact ambiguity that
+ * makes `1,029` unreadable — one thousand and twenty-nine, or one point oh two
+ * nine? Rejecting is safe because it is loud; guessing is not.
+ *
+ * @see {@link parseRateInput} for the text-to-bigint conversion
+ * @see {@link nextRateInputValue} for the editing transition
+ */
+import { parseUnits as viemParseUnits } from 'viem';
+/**
+ * Decimal places a conversion rate carries on chain. Rates are always
+ * 18-decimal fixed point regardless of the fiat currency's own precision — the
+ * currency's `decimals` field describes how the rate is *displayed*, never how
+ * it is stored.
+ */
+export const RATE_DECIMALS = 18;
+/** Digits plus the two accepted decimal separators, and nothing else. */
+const ACCEPTED_CHARACTERS = /^[0-9.,]*$/;
+/** Matches every decimal separator, in either locale convention. */
+const SEPARATORS = /[.,]/g;
+/**
+ * Count decimal separators in a candidate string, treating period and comma
+ * alike.
+ *
+ * @param candidate - Text to inspect
+ * @returns Number of separator characters present
+ */
+const countSeparators = (candidate) => (candidate.match(SEPARATORS) ?? []).length;
+/**
+ * Normalise a candidate rate string, or reject it.
+ *
+ * Accepts a partially-typed value — `''`, `'1'`, `'1.'` and `'1.0'` are all
+ * legal states on the way to `'1.02'` — because this runs on every keystroke.
+ * Completeness is checked at submit by {@link parseRateInput}, not here.
+ *
+ * @param candidate - Text the input element now holds
+ * @returns The candidate with any comma rewritten to a period, or `null` if it
+ *   is not a legal partial rate
+ *
+ * @example
+ * ```ts
+ * normalizeRateInput('1,029')  // '1.029'  — comma is a decimal separator
+ * normalizeRateInput('1.')     // '1.'     — legal mid-typing
+ * normalizeRateInput('1.2.3')  // null     — ambiguous
+ * normalizeRateInput('1e3')    // null     — not a digit or separator
+ * ```
+ */
+export const normalizeRateInput = (candidate) => {
+    if (candidate === '')
+        return '';
+    if (!ACCEPTED_CHARACTERS.test(candidate))
+        return null;
+    if (countSeparators(candidate) > 1)
+        return null;
+    return candidate.replace(',', '.');
+};
+/**
+ * Next value of the rate field, given the text the input element now holds.
+ *
+ * This is the entire editing transition. It is pure and string-to-string: the
+ * value is never routed through a bigint and back, which is what erased the
+ * decimal separator and inflated ten production deposits. An illegal candidate
+ * leaves the field on its previous value, which is how a keystroke is refused.
+ *
+ * @param options - Current field value and the candidate replacing it
+ * @returns The value the field should now hold
+ *
+ * @example
+ * ```ts
+ * nextRateInputValue({ current: '1', candidate: '1,' })    // '1.'
+ * nextRateInputValue({ current: '1.2', candidate: '1.2.' }) // '1.2' — refused
+ * ```
+ */
+export const nextRateInputValue = ({ current, candidate }) => {
+    const normalized = normalizeRateInput(candidate);
+    return normalized === null ? current : normalized;
+};
+/**
+ * Convert maker-entered rate text into an 18-decimal bigint.
+ *
+ * Call this once, at submit. Calling it on every keystroke and rendering the
+ * result back into the field is the defect this module exists to prevent.
+ *
+ * @param candidate - Raw text the maker entered
+ * @returns Parsed rate, or the reason it could not be parsed
+ *
+ * @example
+ * ```ts
+ * parseRateInput('0.978')  // { status: 'parsed', value: 978000000000000000n, ... }
+ * parseRateInput('0,978')  // identical — comma is a decimal separator
+ * parseRateInput('978')    // { status: 'parsed', value: 978000000000000000000n, ... }
+ * parseRateInput('')       // { status: 'failed', reason: 'empty' }
+ * ```
+ */
+export const parseRateInput = (candidate) => {
+    const trimmed = candidate.trim();
+    if (trimmed === '')
+        return { status: 'failed', reason: 'empty' };
+    if (!ACCEPTED_CHARACTERS.test(trimmed))
+        return { status: 'failed', reason: 'unsupportedCharacter' };
+    if (countSeparators(trimmed) > 1)
+        return { status: 'failed', reason: 'multipleDecimalSeparators' };
+    const [wholePart = '', fractionalPart = ''] = trimmed.replace(',', '.').split('.');
+    if (wholePart === '' && fractionalPart === '')
+        return { status: 'failed', reason: 'missingDigits' };
+    if (fractionalPart.length > RATE_DECIMALS)
+        return { status: 'failed', reason: 'tooManyDecimalPlaces' };
+    const canonicalText = `${wholePart === '' ? '0' : wholePart}.${fractionalPart === '' ? '0' : fractionalPart}`;
+    const value = viemParseUnits(canonicalText, RATE_DECIMALS);
+    if (value <= 0n)
+        return { status: 'failed', reason: 'notPositive' };
+    return { status: 'parsed', value, canonicalText };
+};
+/**
+ * Rates at or above this many fiat units per token are held back for the maker
+ * to confirm.
+ *
+ * This is a deliberately crude backstop, not a market check. It exists because
+ * every rate corrupted in production landed far above it (12, 115, 978, 1020,
+ * 1029, 1099) while every legitimate rate observed on chain sat near 1 — the
+ * highest genuine one being roughly 18, for Mexican pesos. A handful of
+ * currencies do trade in the thousands per dollar, so this asks rather than
+ * refuses; the maker can confirm and proceed.
+ */
+export const RATE_CONFIRMATION_THRESHOLD = 100n * 10n ** BigInt(RATE_DECIMALS);
+/**
+ * Whether a parsed rate is large enough that the maker should confirm it before
+ * the deposit is created.
+ *
+ * @param options - The parsed rate, as an 18-decimal bigint
+ * @returns `true` when the rate warrants an explicit confirmation
+ *
+ * @example
+ * ```ts
+ * needsRateConfirmation({ value: parseUnits('1.029', 18) })  // false
+ * needsRateConfirmation({ value: parseUnits('1029', 18) })   // true
+ * ```
+ */
+export const needsRateConfirmation = ({ value }) => value >= RATE_CONFIRMATION_THRESHOLD;

package/dist/rateInput.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/rateInput.test.js

@@ -0,0 +1,318 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { parseUnits } from 'viem';
+import { RATE_DECIMALS, RATE_CONFIRMATION_THRESHOLD, normalizeRateInput, nextRateInputValue, parseRateInput, needsRateConfirmation, } from './rateInput.js';
+/**
+ * Replay a string into the rate field one character at a time, exactly as the
+ * input element does: each keystroke offers the whole field's new text as the
+ * candidate.
+ *
+ * The defect this module exists to prevent lived here and nowhere else — the
+ * old form re-derived the field's text from a bigint on every keystroke, so
+ * typing `0.978` left-to-right produced 978 while pasting the same string
+ * produced 0.978. Every property below that compares these two functions is
+ * guarding that specific divergence.
+ */
+const typeSequentially = (text) => {
+    let current = '';
+    for (const character of text) {
+        current = nextRateInputValue({ current, candidate: current + character });
+    }
+    return current;
+};
+/** Paste the whole string in a single change, the way a clipboard drop lands. */
+const pasteWhole = (text) => nextRateInputValue({ current: '', candidate: text });
+/**
+ * Deterministic pseudo-random generator so a fuzz failure is reproducible from
+ * the seed printed in the assertion message rather than vanishing on re-run.
+ */
+const createRandom = (seed) => {
+    let state = seed >>> 0;
+    return () => {
+        state = (state + 0x6d2b79f5) >>> 0;
+        let drawn = Math.imul(state ^ (state >>> 15), 1 | state);
+        drawn = (drawn + Math.imul(drawn ^ (drawn >>> 7), 61 | drawn)) ^ drawn;
+        return ((drawn ^ (drawn >>> 14)) >>> 0) / 4294967296;
+    };
+};
+const pickInteger = (random, lowest, highest) => lowest + Math.floor(random() * (highest - lowest + 1));
+const buildDigits = (random, count) => Array.from({ length: count }, () => String(pickInteger(random, 0, 9))).join('');
+/** A legal rate: digits, optionally one separator, at most 18 decimal places. */
+const buildLegalRate = (random) => {
+    const wholePart = buildDigits(random, pickInteger(random, 0, 6));
+    const fractionalPart = buildDigits(random, pickInteger(random, 0, RATE_DECIMALS));
+    const separator = random() < 0.5 ? '.' : ',';
+    const hasSeparator = fractionalPart.length > 0 || random() < 0.3;
+    // A bare separator carries no digits and is rejected by design; give it one.
+    const safeWholePart = wholePart === '' && fractionalPart === '' ? '1' : wholePart;
+    const text = hasSeparator
+        ? `${safeWholePart}${separator}${fractionalPart}`
+        : safeWholePart;
+    return { text, wholePart: safeWholePart, fractionalPart: hasSeparator ? fractionalPart : '', separator };
+};
+const FUZZ_ITERATIONS = 2000;
+describe('parseRateInput — production regressions', () => {
+    // The four rates still live or recently live on PulseChain, each the result
+    // of a decimal separator being eaten mid-typing. The left column is what the
+    // maker meant; the right is what reached the escrow.
+    const corrupted = [
+        ['0.978', '978'],
+        ['1.029', '1029'],
+        ['1.020', '1020'],
+        ['1.099', '1099'],
+        ['1.15', '115'],
+        ['1.2', '12'],
+    ];
+    for (const [intended, corruptedText] of corrupted) {
+        it(`typing "${intended}" yields ${intended}, never ${corruptedText}`, () => {
+            const typed = typeSequentially(intended);
+            const result = parseRateInput(typed);
+            assert.equal(result.status, 'parsed');
+            assert.ok(result.status === 'parsed');
+            assert.equal(result.value, parseUnits(intended, RATE_DECIMALS), `typing "${intended}" must produce ${intended}`);
+            assert.notEqual(result.value, parseUnits(corruptedText, RATE_DECIMALS), `typing "${intended}" must never produce ${corruptedText} — this is the bug that ` +
+                'priced three PulseChain deposits a thousand times above market');
+        });
+    }
+    it('reaches the same value whether the maker types or pastes', () => {
+        for (const [intended] of corrupted) {
+            assert.equal(typeSequentially(intended), pasteWhole(intended), `"${intended}" diverged between typing and pasting`);
+        }
+    });
+    it('treats a comma decimal separator as the maker intends', () => {
+        // A maker on a euro-zone locale types 0,978 and means 0.978.
+        assert.equal(typeSequentially('0,978'), '0.978');
+        const result = parseRateInput('0,978');
+        assert.ok(result.status === 'parsed');
+        assert.equal(result.value, parseUnits('0.978', RATE_DECIMALS));
+    });
+});
+describe('parseRateInput — accepted values', () => {
+    it('parses a whole number', () => {
+        const result = parseRateInput('978');
+        assert.ok(result.status === 'parsed');
+        assert.equal(result.value, parseUnits('978', RATE_DECIMALS));
+    });
+    it('parses a value with no whole part', () => {
+        const result = parseRateInput('.5');
+        assert.ok(result.status === 'parsed');
+        assert.equal(result.value, parseUnits('0.5', RATE_DECIMALS));
+    });
+    it('parses a value with a trailing separator', () => {
+        const result = parseRateInput('1.');
+        assert.ok(result.status === 'parsed');
+        assert.equal(result.value, parseUnits('1', RATE_DECIMALS));
+    });
+    it('preserves full 18-decimal precision', () => {
+        const text = `0.${'1'.repeat(RATE_DECIMALS)}`;
+        const result = parseRateInput(text);
+        assert.ok(result.status === 'parsed');
+        assert.equal(result.value, parseUnits(text, RATE_DECIMALS));
+    });
+    it('ignores surrounding whitespace', () => {
+        const result = parseRateInput('  1.02  ');
+        assert.ok(result.status === 'parsed');
+        assert.equal(result.value, parseUnits('1.02', RATE_DECIMALS));
+    });
+});
+describe('parseRateInput — rejected values', () => {
+    const rejections = [
+        ['', 'empty'],
+        ['   ', 'empty'],
+        ['1e3', 'unsupportedCharacter'],
+        ['-1.5', 'unsupportedCharacter'],
+        ['1 000', 'unsupportedCharacter'],
+        ['abc', 'unsupportedCharacter'],
+        // Group separators are refused rather than guessed at: "1,234.56" cannot be
+        // told apart from a locale writing one point two three four.
+        ['1,234.56', 'multipleDecimalSeparators'],
+        ['1.2.3', 'multipleDecimalSeparators'],
+        ['1,029,000', 'multipleDecimalSeparators'],
+        ['.', 'missingDigits'],
+        [',', 'missingDigits'],
+        [`0.${'1'.repeat(RATE_DECIMALS + 1)}`, 'tooManyDecimalPlaces'],
+        ['0', 'notPositive'],
+        ['0.0', 'notPositive'],
+        ['0.000', 'notPositive'],
+    ];
+    for (const [text, reason] of rejections) {
+        it(`rejects ${JSON.stringify(text)} as ${reason}`, () => {
+            const result = parseRateInput(text);
+            assert.ok(result.status === 'failed', `expected ${JSON.stringify(text)} to be refused`);
+            assert.equal(result.reason, reason);
+        });
+    }
+    it('refuses a zero rate, which no buyer could ever fill', () => {
+        // Guards intent, not shape: a deposit priced at zero is not "free", it is
+        // unfillable, so it must never reach the escrow.
+        const result = parseRateInput('0');
+        assert.ok(result.status === 'failed');
+        assert.equal(result.reason, 'notPositive');
+    });
+});
+describe('fuzz — the separator is never eaten', () => {
+    it('parsed value always equals the digits scaled by the decimal places typed', () => {
+        const random = createRandom(0x51ee7);
+        for (let iteration = 0; iteration < FUZZ_ITERATIONS; iteration += 1) {
+            const { text, wholePart, fractionalPart } = buildLegalRate(random);
+            const result = parseRateInput(text);
+            if (result.status !== 'parsed')
+                continue;
+            // The whole point: digits are placed by how many decimals were typed. If a
+            // separator is ever swallowed, this lands 10**fractionalPart.length high.
+            const digits = `${wholePart}${fractionalPart}`;
+            const expected = BigInt(digits === '' ? '0' : digits)
+                * 10n ** BigInt(RATE_DECIMALS - fractionalPart.length);
+            assert.equal(result.value, expected, `iteration ${iteration}: ${JSON.stringify(text)} parsed to ${result.value}, expected ${expected}`);
+        }
+    });
+    it('never inflates a fractional rate to its digits-only reading', () => {
+        const random = createRandom(0xea7e2);
+        for (let iteration = 0; iteration < FUZZ_ITERATIONS; iteration += 1) {
+            const { text, wholePart, fractionalPart } = buildLegalRate(random);
+            if (fractionalPart.length === 0)
+                continue;
+            const result = parseRateInput(text);
+            if (result.status !== 'parsed')
+                continue;
+            const digitsOnly = BigInt(`${wholePart}${fractionalPart}` || '0') * 10n ** BigInt(RATE_DECIMALS);
+            assert.notEqual(result.value, digitsOnly, `iteration ${iteration}: ${JSON.stringify(text)} was inflated to its digits-only reading`);
+            assert.ok(result.value < digitsOnly, `iteration ${iteration}: ${JSON.stringify(text)} must be smaller than its digits-only reading`);
+        }
+    });
+});
+describe('fuzz — typing equals pasting', () => {
+    it('holds for generated legal rates', () => {
+        const random = createRandom(0x7ab1e);
+        for (let iteration = 0; iteration < FUZZ_ITERATIONS; iteration += 1) {
+            const { text } = buildLegalRate(random);
+            assert.equal(typeSequentially(text), pasteWhole(text), `iteration ${iteration}: ${JSON.stringify(text)} diverged between typing and pasting`);
+        }
+    });
+    it('holds for the parsed value, not just the displayed text', () => {
+        const random = createRandom(0xba5ed);
+        for (let iteration = 0; iteration < FUZZ_ITERATIONS; iteration += 1) {
+            const { text } = buildLegalRate(random);
+            const typed = parseRateInput(typeSequentially(text));
+            const pasted = parseRateInput(pasteWhole(text));
+            assert.deepEqual(typed, pasted, `iteration ${iteration}: ${JSON.stringify(text)} parsed differently when typed than when pasted`);
+        }
+    });
+    it('holds when a comma is retyped as a period', () => {
+        const random = createRandom(0xc0ffee);
+        for (let iteration = 0; iteration < FUZZ_ITERATIONS; iteration += 1) {
+            const { text } = buildLegalRate(random);
+            const withComma = text.replace('.', ',');
+            const withPeriod = text.replace(',', '.');
+            assert.deepEqual(parseRateInput(withComma), parseRateInput(withPeriod), `iteration ${iteration}: ${JSON.stringify(withComma)} and ${JSON.stringify(withPeriod)} disagreed`);
+        }
+    });
+});
+describe('fuzz — totality and idempotence over arbitrary input', () => {
+    const CHARACTER_POOL = '0123456789.,eE+- \t\u0660\u06F5\u4E07\u200B/*abcXYZ%$\u20AC\u00A3';
+    const buildJunk = (random) => Array.from({ length: pickInteger(random, 0, 24) }, () => CHARACTER_POOL[pickInteger(random, 0, CHARACTER_POOL.length - 1)]).join('');
+    it('parseRateInput never throws, whatever it is handed', () => {
+        const random = createRandom(0x1a5cf);
+        for (let iteration = 0; iteration < FUZZ_ITERATIONS; iteration += 1) {
+            const junk = buildJunk(random);
+            assert.doesNotThrow(() => parseRateInput(junk), `iteration ${iteration}: parseRateInput threw on ${JSON.stringify(junk)}`);
+        }
+    });
+    it('nextRateInputValue always leaves the field holding a legal partial value', () => {
+        const random = createRandom(0x1e9a1);
+        for (let iteration = 0; iteration < FUZZ_ITERATIONS; iteration += 1) {
+            const junk = buildJunk(random);
+            let current = '';
+            for (const character of junk) {
+                current = nextRateInputValue({ current, candidate: current + character });
+                assert.equal(normalizeRateInput(current), current, `iteration ${iteration}: field held illegal value ${JSON.stringify(current)}`);
+            }
+        }
+    });
+    it('normalizeRateInput is idempotent', () => {
+        const random = createRandom(0x1d3a9);
+        for (let iteration = 0; iteration < FUZZ_ITERATIONS; iteration += 1) {
+            const once = normalizeRateInput(buildJunk(random));
+            if (once === null)
+                continue;
+            assert.equal(normalizeRateInput(once), once, `iteration ${iteration}: normalising ${JSON.stringify(once)} twice changed it`);
+        }
+    });
+    it('canonical text re-parses to the identical value', () => {
+        const random = createRandom(0xca90a);
+        for (let iteration = 0; iteration < FUZZ_ITERATIONS; iteration += 1) {
+            const { text } = buildLegalRate(random);
+            const first = parseRateInput(text);
+            if (first.status !== 'parsed')
+                continue;
+            const second = parseRateInput(first.canonicalText);
+            assert.ok(second.status === 'parsed');
+            assert.equal(second.value, first.value, `iteration ${iteration}: ${JSON.stringify(text)} did not survive a round trip through its canonical form`);
+        }
+    });
+});
+describe('fuzz — ordering', () => {
+    it('appending a decimal digit never changes the whole-number part', () => {
+        const random = createRandom(0x0d3e1);
+        for (let iteration = 0; iteration < FUZZ_ITERATIONS; iteration += 1) {
+            const wholePart = buildDigits(random, pickInteger(random, 1, 4));
+            const fractionalPart = buildDigits(random, pickInteger(random, 0, 6));
+            const shorter = parseRateInput(`${wholePart}.${fractionalPart}`);
+            const longer = parseRateInput(`${wholePart}.${fractionalPart}${pickInteger(random, 0, 9)}`);
+            if (shorter.status !== 'parsed' || longer.status !== 'parsed')
+                continue;
+            const scale = 10n ** BigInt(RATE_DECIMALS);
+            assert.equal(longer.value / scale, shorter.value / scale, `iteration ${iteration}: adding a decimal to ${wholePart}.${fractionalPart} moved the whole-number part`);
+        }
+    });
+    it('a longer whole-number part always parses larger', () => {
+        const random = createRandom(0x10b9e);
+        for (let iteration = 0; iteration < FUZZ_ITERATIONS; iteration += 1) {
+            const wholePart = buildDigits(random, pickInteger(random, 1, 4)).replace(/^0+/, '') || '1';
+            const shorter = parseRateInput(wholePart);
+            const longer = parseRateInput(`${wholePart}0`);
+            assert.ok(shorter.status === 'parsed' && longer.status === 'parsed');
+            assert.ok(longer.value > shorter.value, `iteration ${iteration}: ${wholePart}0 did not exceed ${wholePart}`);
+        }
+    });
+});
+describe('needsRateConfirmation', () => {
+    it('passes the rates makers legitimately set', () => {
+        for (const text of ['0.70', '0.78', '0.895', '0.92', '1.02', '1.029', '18.07']) {
+            const result = parseRateInput(text);
+            assert.ok(result.status === 'parsed');
+            assert.equal(needsRateConfirmation({ value: result.value }), false, `${text} is a rate seen on chain and must not be questioned`);
+        }
+    });
+    it('questions the corrupted rates that a magnitude check can reach', () => {
+        for (const text of ['115', '978', '1020', '1029', '1099']) {
+            const result = parseRateInput(text);
+            assert.ok(result.status === 'parsed');
+            assert.equal(needsRateConfirmation({ value: result.value }), true, `${text} corrupted a real deposit and must be questioned`);
+        }
+    });
+    it('cannot reach a corrupted rate that lands below the threshold', () => {
+        // Deposit 180 reached the escrow at 12.0 — the maker meant 1.2 and lost one
+        // decimal place rather than three. No magnitude threshold can catch this
+        // without also questioning genuine rates: Mexican pesos trade near 18, so a
+        // threshold low enough to flag 12 would flag real liquidity as suspect.
+        //
+        // This is why the backstop is not the fix. The parser is: 1.2 can no longer
+        // become 12, so this case is prevented rather than merely questioned.
+        const result = parseRateInput('12');
+        assert.ok(result.status === 'parsed');
+        assert.equal(needsRateConfirmation({ value: result.value }), false);
+        const mexicanPesoRate = parseRateInput('18.07');
+        assert.ok(mexicanPesoRate.status === 'parsed');
+        assert.equal(needsRateConfirmation({ value: mexicanPesoRate.value }), false);
+        // The real guarantee: typing 1.2 produces 1.2, so 12 never arises.
+        assert.equal(typeSequentially('1.2'), '1.2');
+        const typed = parseRateInput(typeSequentially('1.2'));
+        assert.ok(typed.status === 'parsed');
+        assert.equal(typed.value, parseUnits('1.2', RATE_DECIMALS));
+    });
+    it('asks rather than refuses at the threshold boundary', () => {
+        assert.equal(needsRateConfirmation({ value: RATE_CONFIRMATION_THRESHOLD }), true);
+        assert.equal(needsRateConfirmation({ value: RATE_CONFIRMATION_THRESHOLD - 1n }), false);
+    });
+});