Skip to content

Finance mistakes

  • Timestamps in trading and payment messages: FIX UTC timestamps at the precision their digits state, leap seconds included.

The Finance layer reads and writes the timestamps of trading and payment messages. The mistakes around them are the ones a quick conversion makes: treating the fraction as a decimal of any width, widening a stamp to digits nobody measured, rounding it into the next second, reading a second of sixty as the start of the next minute, accepting it on any day, and writing a local time as a UTC stamp. SWIFT value dates add three more: a century cut-off of your own, writing a year SWIFT cannot read back, and checking the digits without the century. Every output shown here is what the function returns.

HIGH

Treating the fraction as a decimal of any width

A FIX fraction states its precision by its length: three digits are milliseconds, six microseconds, nine nanoseconds. Read as a decimal, .100 becomes .1, a tenth of a second, and .12 becomes a width FIX does not name. parseFixUtcTimestamp keeps the digits sent and returns null for a width with no precision.

Wrong

// the stamp reads "20240615-14:30:00.100"
Number("0." + "100");
// 0.1 — the three digits, and the precision they state, are gone

Right

import { parseFixUtcTimestamp } from "@northguild/gmt/finance/parse";
parseFixUtcTimestamp("20240615-14:30:00.100");
// { instant: "2024-06-15T14:30:00.100Z", precision: "millisecond", leapSecond: false, picoseconds: 0 }
parseFixUtcTimestamp("20240615-14:30:00.12");
// null
output 
MEDIUM

Widening a millisecond stamp to nanoseconds

A standard instant holds nanoseconds, so writing a millisecond stamp at nine digits pads six zeros that look like a measurement. The precision of the stamp is a fact about the clock that made it. parseFixUtcTimestamp returns it, and formatFixUtcTimestamp writes the width you state.

Wrong

Temporal.Instant.from("2024-06-15T14:30:00.123Z").toString({ fractionalSecondDigits: 9 });
// "2024-06-15T14:30:00.123000000Z" — six digits nobody measured

Right

import { parseFixUtcTimestamp } from "@northguild/gmt/finance/parse";
parseFixUtcTimestamp("20240615-14:30:00.123");
// { instant: "2024-06-15T14:30:00.123Z", precision: "millisecond", leapSecond: false, picoseconds: 0 }
output 

See the same slip in A Millisecond Stamp Read as Nanoseconds.

HIGH

Rounding when narrowing

Rounding a fraction can carry into the next second, minute or day. A trade stamped at 23:59:59.9996 and written at millisecond precision with rounding becomes the next day at 00:00:00.000, a moment that had not happened. formatFixUtcTimestamp cuts the fraction and never rounds it.

Wrong

// round to three digits
Math.round(0.9996 * 1000) / 1000;
// 1 — 23:59:59.9996 becomes 00:00:00.000 of the next day

Right

import { formatFixUtcTimestamp } from "@northguild/gmt/finance/format";
formatFixUtcTimestamp("2024-06-15T23:59:59.9996Z", "millisecond");
// "20240615-23:59:59.999"
formatFixUtcTimestamp("2024-06-15T23:59:59.9996Z", "second");
// "20240615-23:59:59"
output 
HIGH

Reading a 60 as 00 of the next minute

A second of 60 is not a typo for 00 of the next minute. At the end of 2016 UTC inserted one, between 23:59:59 and 00:00:00, and it belongs to 2016-12-31. Shifting it forward writes a moment one second after the one that was sent. parseFixUtcTimestamp reads it as the inserted second and flags it.

Wrong

// the stamp reads "20161231-23:59:60"
new Date(Date.UTC(2016, 11, 31, 23, 59, 60)).toISOString();
// "2017-01-01T00:00:00.000Z" — the inserted second is now the first of the new year

Right

import { parseFixUtcTimestamp } from "@northguild/gmt/finance/parse";
parseFixUtcTimestamp("20161231-23:59:60");
// { instant: "2016-12-31T23:59:60Z", precision: "second", leapSecond: true, picoseconds: 0 }
output 
HIGH

Accepting a 60 on any day

FIX allows a second of 60 only for a UTC leap second, and UTC has inserted 27, the last at the end of 2016. A pattern that allows 60 passes every day, and Temporal clamps it to 59, so a second that never happened is stored as a real one. isValidFixUtcTimestamp checks the day.

Wrong

Temporal.Instant.from("2017-12-31T23:59:60Z").toString();
// "2017-12-31T23:59:59Z" — a second that never happened, stored as a real one

Right

import { isValidFixUtcTimestamp } from "@northguild/gmt/finance/validate";
isValidFixUtcTimestamp("20171231-23:59:60");
// false
isValidFixUtcTimestamp("20161231-23:59:60");
// true
output 

See Second Sixty on an Ordinary Day.

HIGH

Writing a local time as a FIX stamp

A FIX UTCTimestamp is UTC. A local date-time carries no offset, so relabelling its digits as UTC is wrong by the zone's offset, four hours in New York in June. formatFixUtcTimestamp refuses a value with no offset, and resolveLocal turns it into an instant first.

Wrong

// 14:30 in New York, with the digits relabelled as UTC
"2024-06-15T14:30:00".replace(/^(\d{4})-(\d{2})-(\d{2})T/, "$1$2$3-");
// "20240615-14:30:00" — four hours before the moment it names

Right

import { formatFixUtcTimestamp } from "@northguild/gmt/finance/format";
import { resolveLocal } from "@northguild/gmt/instant/convert";
formatFixUtcTimestamp("2024-06-15T14:30:00", "second");
// ""
formatFixUtcTimestamp(resolveLocal("2024-06-15T14:30:00", "America/New_York"), "second");
// "20240615-18:30:00"
output 
HIGH

A century cut-off of your own

A SWIFT value date has two year digits, and SWIFT states the century: it reads 01 to 60 as 2001 to 2060 and refuses any other year with T50. A cut-off of your own is a choice, not that rule. With 1930 as the window, 350615 reads as 1935, a century early, and 750615 is accepted, though SWIFT refuses it. parseSwiftDate applies the SWIFT rule.

Wrong

import { parseDateWithPattern } from "@northguild/gmt/plain/parse";
parseDateWithPattern("350615", "yyMMdd", undefined, { yearWindow: 1930 });
// "1935-06-15"
parseDateWithPattern("750615", "yyMMdd", undefined, { yearWindow: 1930 });
// "1975-06-15" — accepted

Right

import { parseSwiftDate } from "@northguild/gmt/finance/parse";
parseSwiftDate("350615");
// "2035-06-15"
parseSwiftDate("750615");
// ""
output 
HIGH

Writing a year SWIFT cannot read back

Keeping the last two digits of a year drops its century. SWIFT reads 24 as 2024, so a date in 1924 written that way comes back a century late. formatSwiftDate refuses a year outside 2001 to 2060, so everything it writes reads back as the same date.

Wrong

String(1924).slice(-2) + "0615";
// "240615" — which SWIFT reads as 15 June 2024

Right

import { formatSwiftDate } from "@northguild/gmt/finance/format";
formatSwiftDate("1924-06-15");
// ""
formatSwiftDate("2060-12-31");
// "601231"
output 
MEDIUM

Checking the digits without the century

Whether a value date exists depends on its year, and SWIFT states the year. 050229 has a valid month and a day from 1 to 31, but 2005 was not a leap year. 750101 has valid digits too, but 75 is not a year SWIFT reads, so it is refused. isValidSwiftDate applies the century first.

Wrong

/^d{2}(0[1-9]|1[0-2])(0[1-9]|[12]d|3[01])$/.test("050229");
// true
/^d{2}(0[1-9]|1[0-2])(0[1-9]|[12]d|3[01])$/.test("750101");
// true

Right

import { isValidSwiftDate } from "@northguild/gmt/finance/validate";
isValidSwiftDate("040229");
// true
isValidSwiftDate("050229");
// false
isValidSwiftDate("750101");
// false
output 

See A Value Date in the Wrong Century, the guide Finance: Message Timestamps and the SWIFT Value Date Reader.

© 2026 NorthGuild · Licences

Code examples: MIT-0. Packages: MIT. Third-party data and components: their own licences, credited where they appear. Everything else: © 2026 NorthGuild, all rights reserved.