@coderoftime/fints 0.2.0 → 0.3.0

package/src/v3/message.ts

@@ -3,14 +3,13 @@
 import { BankMessage } from '../core/bank-info.js';
 import { FinTsFeedback } from '../core/feedback.js';
 import { TanMethod } from '../tan/tan-models.js';
-import { base64Encode, BytesBuilder, latin1Encode, utf8Decode } from '../util/bytes.js';
+import { base64Encode, concatBytes, latin1Encode, utf8Decode } from '../util/bytes.js';
 import { formatFintsDate, formatFintsTime } from '../util/dates.js';
 import { FormatError } from '../util/errors.js';
 import { decodeBankText, decodeBase64Lines } from '../util/text.js';
 import {
   Binary,
-  dataElementMemory,
-  maxDataElements,
+  parsedElementBytes,
   parseSegments,
   type Segment,
   SegmentSpec,
@@ -77,10 +76,14 @@ function keyName(c: PinTanCredentials, keyType: string): SegmentValue {
   return [c.countryCode, c.bankCode, c.userId, keyType, 0, 0];
 }
 
-/** A random integer from 0 below `bound`, from a cryptographically secure source. */
+/** A random integer from 0 below `bound`, each equally likely, from a cryptographically secure source. */
 function secureRandom(bound: number): number {
+  // Values from the last multiple of `bound` on cover only the low remainders, which they would make more likely.
+  const limit = 2 ** 32 - (2 ** 32 % bound);
   const values = new Uint32Array(1);
-  crypto.getRandomValues(values);
+  do {
+    crypto.getRandomValues(values);
+  } while (values[0]! >= limit);
   return values[0]! % bound;
 }
 
@@ -93,20 +96,21 @@ function securityControlReference(): string {
 export class OutgoingMessage {
   constructor(
     readonly bytes: Uint8Array,
-    /** The parts of the masked message, each decoded on its own as the bank's text is. */
-    private readonly maskedParts: readonly Uint8Array[],
+    private readonly buildMasked: () => Uint8Array,
   ) {}
 
-  /** The message with PIN and TAN masked; decoded only when a logger asks for it. */
+  /**
+   * The message with PIN and TAN masked; built only when a logger asks for it. It is decoded as a whole, as the bank's
+   * text is, so a message that mixes ISO 8859-1 text with UTF-8 text (`encodeText`) shows all of it as ISO 8859-1.
+   */
   get masked(): string {
-    return this.maskedParts.map(decodeBankText).join('');
+    return decodeBankText(this.buildMasked());
   }
 }
 
-/** The segments between header and trailer, as sent and with PIN and TAN masked, and the number for the trailer. */
+/** The segments between header and trailer, and the number of the trailer. */
 interface Body {
-  readonly bytes: Uint8Array;
-  readonly masked: readonly Uint8Array[];
+  readonly segments: readonly Uint8Array[];
   readonly nextNumber: number;
 }
 
@@ -116,7 +120,8 @@ interface Body {
  * With `security` the segments are signed with PIN and optional `tan` (HNSHK … HNSHA) and wrapped in the encryption
  * envelope (HNVSK, HNVSD) that PIN/TAN uses without actual encryption.
  *
- * The masked message states the sizes of its masked content, so that the log does not tell how long PIN and TAN are.
+ * The masked message is built as the message is, from the same time stamp and security control reference, with `***`
+ * for PIN and TAN, so that the log does not tell how long they are.
  */
 export function buildMessage(parts: {
   dialogId: string;
@@ -126,12 +131,21 @@ export function buildMessage(parts: {
   tan?: string | undefined;
   now?: Date;
 }): OutgoingMessage {
-  const body =
-    parts.security === undefined
-      ? plainBody(parts.segments)
-      : signedBody(parts.segments, parts.security, parts.tan, parts.now ?? new Date());
+  const { security, tan } = parts;
+  if (security === undefined) {
+    const bytes = withHeaderAndTrailer(parts, plainBody(parts.segments));
+    return new OutgoingMessage(bytes, () => bytes);
+  }
+  const time = parts.now ?? new Date();
+  const controlReference = securityControlReference();
+  const build = (pin: string, tanValue: string | undefined): Uint8Array =>
+    withHeaderAndTrailer(parts, signedBody(parts.segments, security, pin, tanValue, time, controlReference));
+  return new OutgoingMessage(build(security.pin, tan), () => build('***', tan === undefined ? undefined : '***'));
+}
+
+/** `body` between the header and the trailer of message `messageNumber` of the dialog `dialogId`. */
+function withHeaderAndTrailer(parts: { dialogId: string; messageNumber: number }, body: Body): Uint8Array {
   const trailer = new SegmentSpec('HNHBS', 1, [parts.messageNumber]).build(body.nextNumber);
-  // The header states the size of the whole message, itself included; its own size does not depend on it.
   const header = (size: number): Uint8Array =>
     new SegmentSpec('HNHBK', 3, [
       size.toString().padStart(12, '0'),
@@ -139,46 +153,27 @@ export function buildMessage(parts: {
       new Verbatim(parts.dialogId),
       parts.messageNumber,
     ]).build(1);
-  const sizeOf = (sections: readonly Uint8Array[]): number => header(0).length + lengthOf(sections) + trailer.length;
-  const result = new BytesBuilder();
-  result.add(header(sizeOf([body.bytes])));
-  result.add(body.bytes);
-  result.add(trailer);
-  return new OutgoingMessage(result.takeBytes(), [header(sizeOf(body.masked)), ...body.masked, trailer]);
-}
-
-/** The number of bytes in `parts` together. */
-function lengthOf(parts: readonly Uint8Array[]): number {
-  return parts.reduce((sum, part) => sum + part.length, 0);
+  // The header states the size of the whole message, itself included; its own size does not depend on it.
+  const size = header(0).length + body.segments.reduce((sum, s) => sum + s.length, 0) + trailer.length;
+  return concatBytes([header(size), ...body.segments, trailer]);
 }
 
 /** The segments of a message without security, as the anonymous dialog sends them. */
 function plainBody(segments: readonly SegmentSpec[]): Body {
-  const built = segments.map((segment, i) => segment.build(i + 2));
-  const bytes = new BytesBuilder();
-  built.forEach((b) => {
-    bytes.add(b);
-  });
-  return { bytes: bytes.takeBytes(), masked: built, nextNumber: built.length + 2 };
+  return { segments: segments.map((segment, i) => segment.build(i + 2)), nextNumber: segments.length + 2 };
 }
 
-/** The segments signed with PIN and optional `tan`, inside the encryption envelope. */
+/** The segments signed with `pin` and optional `tan`, inside the encryption envelope. */
 function signedBody(
   segments: readonly SegmentSpec[],
   security: PinTanCredentials,
+  pin: string,
   tan: string | undefined,
   time: Date,
+  controlReference: string,
 ): Body {
   const profile = ['PIN', isTwoStep(security) ? 2 : 1];
-  const controlReference = securityControlReference();
-  const inner = new BytesBuilder();
-  const maskedInner: Uint8Array[] = [];
-  const addInner = (built: Uint8Array, masked?: Uint8Array): void => {
-    inner.add(built);
-    maskedInner.push(masked ?? built);
-  };
-
-  addInner(
+  const inner = [
     new SegmentSpec('HNSHK', 4, [
       profile,
       security.securityFunction,
@@ -192,17 +187,10 @@ function signedBody(
       signatureAlgorithm,
       keyName(security, 'S'),
     ]).build(2),
-  );
+  ];
   let number = 3;
-  for (const segment of segments) addInner(segment.build(number++));
-  const signatureEnd = (pin: string, tanValue: string | undefined): SegmentSpec =>
-    new SegmentSpec('HNSHA', 2, [controlReference, null, [pin, tanValue]]);
-  addInner(
-    signatureEnd(security.pin, tan).build(number),
-    signatureEnd('***', tan === undefined ? undefined : '***').build(number),
-  );
-
-  const innerBytes = inner.takeBytes();
+  for (const segment of segments) inner.push(segment.build(number++));
+  inner.push(new SegmentSpec('HNSHA', 2, [controlReference, null, [pin, tan]]).build(number));
   const encryptionHead = new SegmentSpec('HNVSK', 3, [
     profile,
     plainText,
@@ -213,16 +201,8 @@ function signedBody(
     keyName(security, 'V'),
     noCompression,
   ]).build(998);
-  const bytes = new BytesBuilder();
-  bytes.add(encryptionHead);
-  bytes.add(new SegmentSpec('HNVSD', 1, [new Binary(innerBytes)]).build(999));
-  const masked = [
-    encryptionHead,
-    latin1Encode(`HNVSD:999:1+@${lengthOf(maskedInner)}@`),
-    ...maskedInner,
-    latin1Encode("'"),
-  ];
-  return { bytes: bytes.takeBytes(), masked, nextNumber: number + 1 };
+  const encryptedData = new SegmentSpec('HNVSD', 1, [new Binary(concatBytes(inner))]).build(999);
+  return { segments: [encryptionHead, encryptedData], nextNumber: number + 1 };
 }
 
 /** A received message, with the segments of the encryption envelope unpacked. */
@@ -255,19 +235,29 @@ export class IncomingMessage3 {
   /**
    * Parses a message; throws `FormatError` if `data` is not one complete FinTS message, such as the HTML page of a
    * proxy, a maintenance notice, a message cut short, which lacks the message trailer (HNHBS) at its end, or two
-   * messages run together, whose second would pass for part of the first.
+   * messages run together, whose second would pass for part of the first. It does as well for more than one encrypted
+   * part (HNVSD), each of which `parseSegments` would allow as many data elements as the whole message.
    *
-   * Its `size` counts the memory of its data elements along with its bytes, since a message of many short elements
-   * takes far more memory than bytes.
+   * Its `size` counts the memory of the data elements it keeps along with its bytes, since a message of many short
+   * elements takes far more memory than bytes.
    */
   static parse(data: Uint8Array): IncomingMessage3 {
-    const budget = { elements: maxDataElements };
-    const outer = parseSegments(data, budget);
+    let outer: Segment[] = [];
+    try {
+      outer = parseSegments(data);
+    } catch (error) {
+      // Text that is no FinTS message, such as a web page, seldom ends with a segment terminator; that it has no
+      // message header says more than what the parser trips over first.
+      if (!(error instanceof FormatError) || startsWithMessageHeader(data)) throw error;
+    }
     if (outer[0]?.type !== 'HNHBK') throw new FormatError('Not a FinTS message: no message header');
     if (outer.at(-1)?.type !== 'HNHBS') throw new FormatError('Incomplete FinTS message: no message trailer');
     if (outer.filter((s) => s.type === 'HNHBK' || s.type === 'HNHBS').length > 2) {
       throw new FormatError('More than one FinTS message');
     }
+    if (outer.filter((s) => s.type === 'HNVSD').length > 1) {
+      throw new FormatError('More than one encrypted part (HNVSD)');
+    }
     const segments: Segment[] = [];
     for (const s of outer) {
       if (s.type !== 'HNVSD') {
@@ -276,9 +266,11 @@ export class IncomingMessage3 {
       }
       const payload = s.binary(1);
       if (payload === undefined) throw new FormatError('Encrypted data (HNVSD) without binary data');
-      for (const inner of parseSegments(payload, budget)) segments.push(inner);
+      for (const inner of parseSegments(payload)) segments.push(inner);
     }
-    return new IncomingMessage3(segments, data.length + (maxDataElements - budget.elements) * dataElementMemory);
+    let elements = 0;
+    for (const s of segments) for (const group of s.elements) elements += group.length;
+    return new IncomingMessage3(segments, data.length + elements * parsedElementBytes);
   }
 
   static combine(first: IncomingMessage3, second: IncomingMessage3): IncomingMessage3 {
@@ -315,6 +307,23 @@ export class IncomingMessage3 {
     );
   }
 
+  /**
+   * Whether the message is the bank's dialog abort message (Formals B.7.6) for message `number` of the dialog
+   * `dialogId`: unencrypted, with nothing but the header, an error for the whole message (HIRMG) and the trailer. Its
+   * header names the dialog ID and the message number where the bank knows them, and `unbekannt` and 9999 where not.
+   */
+  aborts(number: number, dialogId: string | undefined): boolean {
+    const header = this.segments[0]!;
+    const id = header.verbatim(3);
+    const messageNumber = header.integer(4);
+    return (
+      this.segments.length === 3 &&
+      this.messageRejected &&
+      (id === 'unbekannt' || id === dialogId) &&
+      (messageNumber === 9999 || messageNumber === number)
+    );
+  }
+
   find(type: string): Segment | undefined {
     return this.segments.find((s) => s.type === type);
   }

package/src/v3/parameter-store.ts

@@ -3,8 +3,19 @@
 import type { FinTsConfig } from '../core/config.js';
 import { FormatError } from '../util/errors.js';
 import { readOptionalBoolean, readOptionalObject, readOptionalString, type JsonObject } from '../util/json.js';
+import { trimBlanks } from '../util/text.js';
 import type { IncomingMessage3 } from './message.js';
 import { Bpd3, decodeSegments, Upd3 } from './parameters.js';
+import { Verbatim } from './syntax.js';
+
+/** The limits the bank parameter data set on the messages the client sends (`ParameterStore.limits`). */
+export interface MessageLimits {
+  /** The shortest and longest PIN a login may carry. */
+  readonly pinLength: { readonly min: number | undefined; readonly max: number | undefined } | undefined;
+
+  /** The size of the largest message, in kilobytes. */
+  readonly maxMessageSize: number | undefined;
+}
 
 /**
  * The parameter data and IDs the bank sends the user `config` names, which the messages and business transactions
@@ -22,11 +33,15 @@ export class ParameterStore {
    * the bank send its parameter data anew.
    */
   private bpdAnonymous = false;
+
+  /** The limits a refresh took from the anonymous dialog's parameter data (`keepRefreshedLimits`). */
+  private refreshedLimits: MessageLimits | undefined;
   private upd: Upd3 | undefined;
 
   /**
-   * The names of the TAN media in the bank's last list whose text differs from what the bank sent, by their text, as
-   * `parseTanMedia` notes them. Saved with the state, as the medium in use is.
+   * The names of the TAN media in the bank's last list whose text would not go back as the bank sent them, by their
+   * text, as `parseTanMedia` notes them (`readTanMediumNames` for a state of 0.2.0). Saved with the state, as the
+   * medium in use is.
    */
   private tanMediumNames = new Map<string, string>();
 
@@ -50,9 +65,21 @@ export class ParameterStore {
     return this.systemIdValue;
   }
 
-  /** The version of the bank parameter data a dialog reports: 0 where there are none, or only the anonymous dialog's. */
+  /**
+   * The limits on the messages the client sends: those of the bank parameter data, unless a refresh took others
+   * (`keepRefreshedLimits`).
+   */
+  get limits(): MessageLimits {
+    const bpd = this.bpd;
+    return this.refreshedLimits ?? { pinLength: bpd?.pinTan.pinLength, maxMessageSize: bpd?.bankInfo.maxMessageSize };
+  }
+
+  /**
+   * The version of the bank parameter data a dialog reports: 0 where there are none, only the anonymous dialog's, or
+   * where limits a refresh took stand in for theirs (`keepRefreshedLimits`).
+   */
   get reportedBpdVersion(): number {
-    return this.bpd === undefined || this.bpdAnonymous ? 0 : this.bpd.version;
+    return this.bpd === undefined || this.bpdAnonymous || this.refreshedLimits !== undefined ? 0 : this.bpd.version;
   }
 
   /**
@@ -99,11 +126,28 @@ export class ParameterStore {
     if (this.bpd === undefined || this.bpdAnonymous) this.keepBankParameters(response, true);
   }
 
+  /**
+   * Keeps the limits of the bank parameter data in `response`, the answer of an anonymous dialog the client asked for
+   * after the limits kept ruled out a login: those may be outdated, as saved ones are. Parameter data of the version
+   * kept tell nothing new, and the bank may send a user other ones than the anonymous dialog (PIN/TAN B.4.3.1), so of
+   * those of another version it keeps the limits only, and the PIN lengths only where they state them (HIPINS). They
+   * stand in for those kept until a dialog signed with the PIN brings parameter data.
+   */
+  keepRefreshedLimits(response: IncomingMessage3): void {
+    const fresh = Bpd3.fromSegments(response.segments, this.config.bankCode);
+    if (fresh === undefined || fresh.version === this.bpd?.version) return;
+    this.refreshedLimits = {
+      pinLength: fresh.pinTan.pinLength ?? this.limits.pinLength,
+      maxMessageSize: fresh.bankInfo.maxMessageSize,
+    };
+  }
+
   private keepBankParameters(response: IncomingMessage3, anonymous: boolean): void {
     const bpd = Bpd3.fromSegments(response.segments, this.config.bankCode);
     if (bpd === undefined) return;
     this.bpd = bpd;
     this.bpdAnonymous = anonymous;
+    this.refreshedLimits = undefined;
   }
 
   /** Keeps `names`, the names of the bank's latest list of TAN media as `parseTanMedia` notes them. */
@@ -111,9 +155,13 @@ export class ParameterStore {
     this.tanMediumNames = names;
   }
 
-  /** The TAN medium `name` as the bank sent it in its list of TAN media; `name` itself for one it did not list. */
-  tanMediumAsSent(name: string): string {
-    return this.tanMediumNames.get(name) ?? name;
+  /**
+   * The TAN medium `name` to send: as the bank sent it, where its last list of TAN media noted that (`parseTanMedia`);
+   * otherwise as text, which goes out without the blanks at either end a name the app passes may have.
+   */
+  tanMediumToSend(name: string): string | Verbatim {
+    const asSent = this.tanMediumNames.get(name);
+    return asSent === undefined ? name : new Verbatim(asSent);
   }
 
   /** The parameter data and IDs as JSON data, for the client's saved state. */
@@ -124,37 +172,55 @@ export class ParameterStore {
       bpdAnonymous: this.bpdAnonymous,
       upd: this.upd?.encoded ?? null,
       tanMediumNames: Object.fromEntries(this.tanMediumNames),
+      [blanksNotedKey]: true,
     };
   }
 
-  /** Restores what `saveState` saved; throws if `saved` is damaged, leaving the store unchanged. */
-  restoreState(saved: JsonObject): void {
+  /**
+   * Restores what `saveState` saved, with `tanMedium`, the medium in use the state holds; throws if `saved` is damaged,
+   * leaving the store unchanged.
+   */
+  restoreState(saved: JsonObject, tanMedium?: string): void {
     const bpd = readOptionalString(saved, 'bpd');
     const upd = readOptionalString(saved, 'upd');
     const restoredSystemId = readOptionalString(saved, 'systemId');
-    // A state of the Dart package or an earlier version does not tell, so its parameter data are fetched anew.
+    // A state of fints-ts 0.1 or the Dart package 0.2.0 does not tell, so its parameter data are fetched anew.
     const restoredBpdAnonymous = readOptionalBoolean(saved, 'bpdAnonymous') ?? true;
     const restoredBpd = bpd === undefined ? undefined : Bpd3.fromSegments(decodeSegments(bpd), this.config.bankCode);
     const restoredUpd =
       upd === undefined
         ? undefined
         : Upd3.fromSegments(decodeSegments(upd), this.config.bankCode, this.config.countryCode);
-    const restoredNames = readTanMediumNames(saved);
+    const restoredNames = readTanMediumNames(saved, tanMedium);
     this.systemIdValue = restoredSystemId;
     this.bpd = restoredBpd;
     this.bpdAnonymous = restoredBpdAnonymous;
+    this.refreshedLimits = undefined;
     this.upd = restoredUpd;
     this.tanMediumNames = restoredNames;
   }
 }
 
-/** The TAN medium names `saveState` saved; none in a state of the Dart package or an earlier version. */
-function readTanMediumNames(saved: JsonObject): Map<string, string> {
-  const names = readOptionalObject(saved, 'tanMediumNames') ?? {};
-  return new Map(
-    Object.entries(names).map(([name, asSent]) => {
+/** The key of the saved state that tells the TAN medium names apart from those version 0.2.0 saved. */
+const blanksNotedKey = 'tanMediumBlanksNoted';
+
+/**
+ * The TAN medium names `saveState` saved; none in a state of fints-ts 0.1 or the Dart package 0.2.0.
+ *
+ * Version 0.2.0 noted no name with blanks at either end, and sent every name as it is, so `tanMedium` keeps going out
+ * with its blanks from such a state: the bank may have listed it so.
+ */
+function readTanMediumNames(saved: JsonObject, tanMedium: string | undefined): Map<string, string> {
+  const listed = readOptionalObject(saved, 'tanMediumNames');
+  const names = new Map(
+    Object.entries(listed ?? {}).map(([name, asSent]) => {
       if (typeof asSent !== 'string') throw new FormatError('Saved state: a TAN medium name is not a string');
       return [name, asSent];
     }),
   );
+  const savedBy020 = listed !== undefined && readOptionalBoolean(saved, blanksNotedKey) !== true;
+  if (savedBy020 && tanMedium !== undefined && trimBlanks(tanMedium) !== tanMedium && !names.has(tanMedium)) {
+    names.set(tanMedium, tanMedium);
+  }
+  return names;
 }

package/src/v3/parameters.ts

@@ -6,7 +6,7 @@ import { BankInfo } from '../core/bank-info.js';
 import { FinTsProtocolError } from '../core/errors.js';
 import { TanMethod, tanMediumRequirementOf } from '../tan/tan-models.js';
 import { base64Decode, base64Encode, concatBytes } from '../util/bytes.js';
-import { nonBlank, tryParseInt } from '../util/text.js';
+import { nonBlank, trimBlanks, tryParseInt } from '../util/text.js';
 import { AccountExtension } from './account-extension.js';
 import { parseSegments, type Segment } from './syntax.js';
 
@@ -33,6 +33,12 @@ const Hibpa = {
   maxTimeout: 9,
 } as const;
 
+/** The size or time at `index` of `hibpa`, a field of at most four digits; `undefined` for a larger value, as for none. */
+function hibpaLimit(hibpa: Segment, index: number): number | undefined {
+  const value = hibpa.integer(index);
+  return value !== undefined && value <= 9999 ? value : undefined;
+}
+
 /**
  * The data element of every parameter segment (`HI…S`) that holds its specific parameters, after the maximum number of
  * orders, the minimum number of signatures and the security class.
@@ -66,9 +72,15 @@ export class Bpd3 {
   readonly unsupportedTanMethods: readonly string[];
   readonly pinTan: PinTanParameters;
 
-  /** camt formats the bank offers for HKCAZ. */
+  /** The camt.052 formats the bank offers for HKCAZ, the one camt message the client reads. */
   readonly camtFormats: readonly string[];
 
+  /**
+   * Whether an international account (KTI) may name the national account as well: HISPAS does not rule it out
+   * ("Nationale Kontoverbindung erlaubt").
+   */
+  readonly nationalAccountAllowed: boolean;
+
   /** Versions of each parameter segment, by segment type. */
   private readonly versions: ReadonlyMap<string, ReadonlySet<number>>;
 
@@ -78,22 +90,19 @@ export class Bpd3 {
    */
   readonly dialogLanguage: number;
 
-  private encodedValue: string | undefined;
+  /** The segments as the saved state keeps them. */
+  readonly encoded: string;
 
-  private constructor(
-    readonly segments: readonly Segment[],
-    hibpa: Segment,
-    fallbackBankCode: string,
-  ) {
+  private constructor(segments: readonly Segment[], hibpa: Segment, fallbackBankCode: string) {
     this.bankInfo = new BankInfo({
       bankCode: hibpa.text(Hibpa.bankId, 1) ?? fallbackBankCode,
       name: hibpa.text(Hibpa.bankName),
       bpdVersion: hibpa.integer(Hibpa.version) ?? 0,
       languages: defined(hibpa.texts(Hibpa.languages)),
       supportedVersions: defined(hibpa.texts(Hibpa.fintsVersions)),
-      maxMessageSize: hibpa.integer(Hibpa.maxMessageSize),
-      minTimeout: hibpa.integer(Hibpa.minTimeout),
-      maxTimeout: hibpa.integer(Hibpa.maxTimeout),
+      maxMessageSize: hibpaLimit(hibpa, Hibpa.maxMessageSize),
+      minTimeout: hibpaLimit(hibpa, Hibpa.minTimeout),
+      maxTimeout: hibpaLimit(hibpa, Hibpa.maxTimeout),
     });
     this.offeredMethods = parseTanMethods(segments);
     const offered = [...this.offeredMethods.values()];
@@ -105,9 +114,11 @@ export class Bpd3 {
     this.camtFormats = segments
       .filter((s) => s.type === 'HICAZS')
       .flatMap((s) => defined(s.texts(parameterGroup)))
-      .filter((format) => format.includes('camt'));
+      .filter((format) => format.includes('camt.052'));
+    this.nationalAccountAllowed = highest(segments, 'HISPAS')?.text(parameterGroup, 1) !== 'N';
     this.versions = versionsByType(segments);
     this.dialogLanguage = dialogLanguageOf(segments, this.bankInfo);
+    this.encoded = encodeSegments(segments);
   }
 
   /** The version of the parameter data, which the client reports back so that the bank sends newer ones only. */
@@ -115,11 +126,6 @@ export class Bpd3 {
     return this.bankInfo.bpdVersion;
   }
 
-  /** The segments as the saved state keeps them, encoded once. */
-  get encoded(): string {
-    return (this.encodedValue ??= encodeSegments(this.segments));
-  }
-
   /** The BPD in `all`, or `undefined` if they contain no HIBPA segment. */
   static fromSegments(all: readonly Segment[], fallbackBankCode: string): Bpd3 | undefined {
     const segments = all.filter(isParameterSegment);
@@ -154,13 +160,23 @@ function dialogLanguageOf(segments: readonly Segment[], bankInfo: BankInfo): num
   return bankInfo.languages.map((l) => tryParseInt(l)).find((l) => l !== undefined && languages.has(l)) ?? 0;
 }
 
+const generalParameterSegments = new Set(['HIBPA', 'HIKOM', 'HISHV', 'HIKPV']);
+
 function isParameterSegment(s: Segment): boolean {
   const type = s.type;
-  if (['HIBPA', 'HIKOM', 'HISHV', 'HIKPV'].includes(type)) return true;
-  if (type === 'HIRMS' || type === 'HIRMG') return false;
+  if (generalParameterSegments.has(type)) return true;
+  // Return codes for single segments end with an S, as parameter segments do.
+  if (type === 'HIRMS') return false;
   return type.length >= 5 && (type.startsWith('HI') || type.startsWith('DI')) && type.endsWith('S');
 }
 
+/** The segment of `type` with the highest version in `segments`. */
+function highest(segments: readonly Segment[], type: string): Segment | undefined {
+  let found: Segment | undefined;
+  for (const s of segments) if (s.type === type && (found === undefined || s.version > found.version)) found = s;
+  return found;
+}
+
 function versionsByType(segments: readonly Segment[]): Map<string, Set<number>> {
   const versions = new Map<string, Set<number>>();
   for (const s of segments) {
@@ -270,17 +286,14 @@ function parseHitans(s: Segment): OfferedMethod[] {
 export class PinTanParameters {
   private constructor(
     private readonly tanRequired: ReadonlyMap<string, boolean>,
-    /** The shortest and longest PIN the bank takes. */
-    readonly pinLength: { min: number | undefined; max: number | undefined },
+    /** The shortest and longest PIN the bank takes; `undefined` where the bank parameter data have no HIPINS. */
+    readonly pinLength: { min: number | undefined; max: number | undefined } | undefined,
   ) {}
 
   /** Reads the HIPINS segment of the highest version. */
   static parse(segments: readonly Segment[]): PinTanParameters {
-    let hipins: Segment | undefined;
-    for (const s of segments.filter((s) => s.type === 'HIPINS')) {
-      if (hipins === undefined || s.version > hipins.version) hipins = s;
-    }
-    if (hipins === undefined) return new PinTanParameters(new Map(), { min: undefined, max: undefined });
+    const hipins = highest(segments, 'HIPINS');
+    if (hipins === undefined) return new PinTanParameters(new Map(), undefined);
     const fields = hipins.texts(parameterGroup);
     const tanRequired = new Map<string, boolean>();
     // Five general fields, the PIN lengths first; then pairs of segment type and TAN flag.
@@ -338,18 +351,19 @@ export class Upd3 {
   /** The accounts the user may access. */
   readonly accounts: readonly Account[];
 
-  private encodedValue: string | undefined;
+  /** The segments as the saved state keeps them. */
+  readonly encoded: string;
 
   /** `listsAll` tells whether HIUPA declares the lists of permitted transactions complete ("UPD-Verwendung" 0). */
   private constructor(
-    readonly segments: readonly Segment[],
+    segments: readonly Segment[],
     hiupa: Segment,
     listsAll: boolean,
     defaultBankCode: string,
     defaultCountry: string,
   ) {
     const hiupds = segments.filter((s) => s.type === 'HIUPD');
-    this.userId = hiupa.text(hiupaUserId)?.trim();
+    this.userId = nonBlank(hiupa.text(hiupaUserId));
     this.version = hiupa.integer(hiupaVersion) ?? 0;
     this.listsAllTransactions = listsAll;
     this.listedTransactions = new Set(hiupds.flatMap(transactionsOf));
@@ -357,11 +371,7 @@ export class Upd3 {
       hiupds.map((s) => entryOf(s, defaultBankCode, defaultCountry, listsAll)).filter((e) => e !== undefined),
     );
     this.accounts = Object.freeze(this.entries.map((e) => e.account));
-  }
-
-  /** The segments as the saved state keeps them, encoded once. */
-  get encoded(): string {
-    return (this.encodedValue ??= encodeSegments(this.segments));
+    this.encoded = encodeSegments(segments);
   }
 
   /**
@@ -407,11 +417,13 @@ function transactionsOf(s: Segment): string[] {
 function extensionOf(s: Segment): AccountExtension | undefined {
   if (s.version < 6) return undefined;
   for (let i = allowedFrom(s.version); i < s.length; i++) {
-    const text = s
-      .group(i)
-      .map((e) => e.text)
-      .join(':');
-    if (text.trimStart().startsWith('{')) return AccountExtension.tryParse(text);
+    const text = trimBlanks(
+      s
+        .group(i)
+        .map((e) => e.text)
+        .join(':'),
+    );
+    if (text.startsWith('{')) return AccountExtension.tryParse(text);
   }
   return undefined;
 }
@@ -426,6 +438,22 @@ function entryOf(s: Segment, defaultBankCode: string, defaultCountry: string, li
   };
 }
 
+/** Whether `code` is a country code, three digits, such as `280`; a German bank code has eight. */
+function isCountryCode(code: string | undefined): boolean {
+  return code !== undefined && /^[0-9]{3}$/.test(code);
+}
+
+/**
+ * The national account of the HIUPD `s`: number, sub-account, country and bank code (KTV2), by position in every
+ * version, so that a sub-account or bank code the bank leaves out is empty. Three elements whose second is a country
+ * code and whose third is not are the older layout without sub-account: number, country and bank code.
+ */
+function nationalAccountOf(s: Segment): (string | undefined)[] {
+  const ktv = s.texts(1);
+  const [number, second, third] = ktv;
+  return ktv.length === 3 && isCountryCode(second) && !isCountryCode(third) ? [number, undefined, second, third] : ktv;
+}
+
 function accountOf(
   s: Segment,
   defaultBankCode: string,
@@ -433,8 +461,7 @@ function accountOf(
   listsAll: boolean,
 ): Account | undefined {
   const version = s.version;
-  // Every version names the account as KTV2, by position: a sub-account or bank code the bank leaves out is empty.
-  const [number, subAccount, country, bank] = s.texts(1);
+  const [number, subAccount, country, bank] = nationalAccountOf(s);
   const iban = version >= 6 ? s.text(2) : undefined;
   if (number === undefined && iban === undefined) return undefined;
   // Field positions by HIUPD version: version 6 inserts the IBAN, version 5 the account type.