@@ -82,6 +82,10 @@ Decoded nodes carry the nodes that decoded them, so their values can be formatte
 | `formatDateTime`   | `DecodedDateTimeTypeNode`   | `"2024-01-01T00:00:00.5Z"`      |
 | `formatDuration`   | `DecodedDurationTypeNode`   | `"49:00:00"`, `"-00:00:01.5"`   |
 | `formatString`     | `DecodedStringTypeNode`     | `"abcd"`, sliced by its display |
+| `formatBoolean`    | `DecodedBooleanTypeNode`    | `"true"`                        |
+| `formatBytes`      | `DecodedBytesTypeNode`      | `"0x0102"`                      |
+| `formatEnum`       | `DecodedEnumTypeNode`       | `"Move"`, `"Move To"`           |
+| `formatPublicKey`  | `DecodedPublicKeyTypeNode`  | `"USDC"`, or its address        |
 
 ```ts
 import { formatInteger, getNodeCodec, isDecodedNode } from '@codama/dynamic-codecs';
@@ -97,15 +101,19 @@ Numbers are formatted exactly, including 128-bit integers and binary fixed point
 
 - **Units:** the unit of a display node wins over the unit of a type, which is the fallback whenever the former is absent or cannot be resolved. Units follow their value after a space, except `%`, `‰` and `°`.
 - **Amounts:** when the `decimals` of an `amountNumberDisplayNode` cannot be resolved, `formatInteger` returns `null` rather than a wrongly scaled amount, so you can present the raw value instead.
-- **Ticks:** `formatDateTime` and `formatDuration` return `null` when `ticksPerSecond` is not a positive integer.
-
-`formatInteger`, `formatFloat` and `formatFixedPoint` accept options:
-
-| Name                   | Type                                             | Description                                                                                                                                                                  |
-| ---------------------- | ------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `formatUnit`           | `(value: string, unit: string) => string`        | Place a unit next to a value, e.g. `` (value, unit) => `${unit} ${value}` `` for `"USD 40.5"`. Defaults to `formatUnit`, also exported.                                      |
-| `numberFormat`         | `Intl.NumberFormat`                              | Format numbers for a locale, e.g. `"1,234,567.89"`. Its options decide the digits shown. Amounts and fixed points are given to it exactly, never through a JavaScript float. |
-| `resolveInjectedValue` | `(path: NodePath<InjectedValueNode>) => unknown` | Resolve injected values of display nodes, e.g. `decimals` provided by an instruction, from their path through the decoded node. `undefined` means unresolved.                |
+- **Ticks:** `formatDateTime` and `formatDuration` throw `CODAMA_ERROR__INVALID_TICKS_PER_SECOND` when `ticksPerSecond` is not a positive integer.
+- **Bytes:** bytes are written in hexadecimal whatever the encoding they were decoded with. Bytes decoded as `utf8` cannot be recovered exactly when they are not valid UTF-8, so decode them with another encoding.
+- **Enums:** the label of the variant's display node, or the variant's identifier in title case otherwise. The data of the variant is not included.
+- **Public keys:** formatted by the `formatAddress` option, e.g. to name or truncate them, or written as the address otherwise.
+
+All formatters share the `(decoded, options)` signature and accept the following options, though each only uses those relevant to it, e.g. `formatAddress` for public keys and `numberFormat` for numbers:
+
+| Name                   | Type                                             | Description                                                                                                                                                                                       |
+| ---------------------- | ------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `formatUnit`           | `(value: string, unit: string) => string`        | Place a unit next to a value, e.g. `` (value, unit) => `${unit} ${value}` `` for `"USD 40.5"`. Defaults to `formatUnit`, also exported.                                                           |
+| `formatAddress`        | `(address: Address) => string`                   | Format an address, e.g. to name it from sources you trust such as a token list or an address book, or to truncate it: `address => names.get(address) ?? address`. Defaults to the address itself. |
+| `numberFormat`         | `Intl.NumberFormat`                              | Format numbers for a locale, e.g. `"1,234,567.89"`. Its options decide the digits shown. Amounts and fixed points are given to it exactly, never through a JavaScript float.                      |
+| `resolveInjectedValue` | `(path: NodePath<InjectedValueNode>) => unknown` | Resolve injected values of display nodes, e.g. `decimals` provided by an instruction, from their path through the decoded node. `undefined` means unresolved.                                     |
 
 ## Node paths
 
 
@@ -0,0 +1,21 @@
+import { CODAMA_ERROR__UNRECOGNIZED_BYTES_ENCODING, CodamaError } from '@codama/errors';
+import { BytesEncoding } from '@codama/nodes';
+import { getBase16Codec, getBase58Codec, getBase64Codec, getUtf8Codec } from '@solana/codecs';
+
+/** The codec of a bytes encoding, e.g. a base58 codec for `'base58'`. */
+export function getCodecFromBytesEncoding(encoding: BytesEncoding) {
+    switch (encoding) {
+        case 'base16':
+            return getBase16Codec();
+        case 'base58':
+            return getBase58Codec();
+        case 'base64':
+            return getBase64Codec();
+        case 'utf8':
+            return getUtf8Codec();
+        default:
+            throw new CodamaError(CODAMA_ERROR__UNRECOGNIZED_BYTES_ENCODING, {
+                encoding: encoding satisfies never,
+            });
+    }
+}
@@ -2,7 +2,6 @@ import {
     CODAMA_ERROR__DEFINED_TYPE_HAS_NO_FINITE_VALUE,
     CODAMA_ERROR__DYNAMIC_CLIENT__INVARIANT_VIOLATION,
     CODAMA_ERROR__DYNAMIC_CLIENT__UNEXPECTED_VALUE_TYPE,
-    CODAMA_ERROR__UNRECOGNIZED_BYTES_ENCODING,
     CODAMA_ERROR__UNRECOGNIZED_NUMBER_FORMAT,
     CodamaError,
 } from '@codama/errors';
@@ -52,9 +51,7 @@ import {
     fixCodecSize,
     FixedSizeNumberCodec,
     getArrayCodec,
-    getBase16Codec,
     getBase58Codec,
-    getBase64Codec,
     getBooleanCodec,
     getConstantCodec,
     getF32Codec,
@@ -77,7 +74,6 @@ import {
     getU128Codec,
     getUnionCodec,
     getUnitCodec,
-    getUtf8Codec,
     isFixedSize,
     isOption,
     isSome,
@@ -93,6 +89,7 @@ import {
     transformCodec,
 } from '@solana/codecs';
 
+import { getCodecFromBytesEncoding } from './bytes';
 import type {
     DecodedAccountNode,
     DecodedNodeCodec,
@@ -937,23 +934,6 @@ export function getConstantValueBytes(
     return visit(node.type, codecVisitor).encode(visit(node.value, valueVisitor));
 }
 
-function getCodecFromBytesEncoding(encoding: BytesEncoding) {
-    switch (encoding) {
-        case 'base16':
-            return getBase16Codec();
-        case 'base58':
-            return getBase58Codec();
-        case 'base64':
-            return getBase64Codec();
-        case 'utf8':
-            return getUtf8Codec();
-        default:
-            throw new CodamaError(CODAMA_ERROR__UNRECOGNIZED_BYTES_ENCODING, {
-                encoding: encoding satisfies never,
-            });
-    }
-}
-
 /** Integers always decode as `bigint`s, whatever their size, and encode from `number`s or `bigint`s. */
 function getIntegerCodec(node: IntegerTypeNode): Codec<bigint | number, bigint> {
     const config = { endian: node.endian === 'be' ? Endian.Big : Endian.Little };
 
@@ -1,5 +1,10 @@
+import { CODAMA_ERROR__INVALID_TICKS_PER_SECOND, CodamaError } from '@codama/errors';
+import { titleCase } from '@codama/fragments/casing';
 import {
     AmountNumberDisplayNode,
+    DateTimeTypeNode,
+    DurationTypeNode,
+    getTextNodeContent,
     InjectableIntegerValueNode,
     InjectableStringValueNode,
     InjectedValueNode,
@@ -9,28 +14,38 @@ import {
     UnitNumberDisplayNode,
 } from '@codama/nodes';
 import { getLastNodeFromPath, NodePath } from '@codama/visitors-core';
+import type { Address } from '@solana/addresses';
 import {
     BinaryFixedPoint,
     binaryFixedPointToString,
     DecimalFixedPoint,
     decimalFixedPointToString,
     formatBinaryFixedPoint,
     formatDecimalFixedPoint,
+    getBase16Decoder,
     rawBinaryFixedPoint,
     rawDecimalFixedPoint,
     Signedness,
 } from '@solana/codecs';
 
+import { getCodecFromBytesEncoding } from './bytes';
 import type {
+    DecodedBooleanTypeNode,
+    DecodedBytesTypeNode,
     DecodedDateTimeTypeNode,
     DecodedDurationTypeNode,
+    DecodedEnumTypeNode,
     DecodedFixedPointTypeNode,
     DecodedFloatTypeNode,
     DecodedIntegerTypeNode,
+    DecodedPublicKeyTypeNode,
     DecodedStringTypeNode,
 } from './decoded';
 
-/** Options shared by the formatters of decoded nodes. */
+/**
+ * Options shared by the formatters of decoded nodes. Every formatter accepts them, even those
+ * that use none of them yet, so all formatters share the `(decoded, options)` signature.
+ */
 export type FormatOptions = {
     /**
      * Place a unit next to a formatted value, e.g. to write `"USD 40.5"`. Defaults to
@@ -44,6 +59,12 @@ export type FormatOptions = {
      * fraction digit, e.g. `"1234.56789"`.
      */
     numberFormat?: Intl.NumberFormat;
+    /**
+     * Format an address, e.g. to name it from sources the caller trusts, such as a token list or
+     * an address book, or to truncate it: `address => names.get(address) ?? address`. Defaults to
+     * the address itself.
+     */
+    formatAddress?: (address: Address) => string;
     /**
      * Resolve the value of an injected value node used by a display node, e.g. the `decimals` of
      * an amount provided by its instruction, given its path through the decoded node, e.g.
@@ -145,16 +166,15 @@ export function formatFixedPoint(decoded: DecodedFixedPointTypeNode, options: Fo
  * when not zero, exactly when `ticksPerSecond` is a power of 10 and rounded to the
  * nanosecond otherwise.
  *
- * Returns `null` when `ticksPerSecond` is not a positive integer.
+ * @throws `CODAMA_ERROR__INVALID_TICKS_PER_SECOND` when `ticksPerSecond` is not a positive integer.
  *
  * @example
  * ```ts
  * formatDateTime(decoded); // "2024-01-01T00:00:00Z"
  * ```
  */
-export function formatDateTime(decoded: DecodedDateTimeTypeNode): string | null {
-    const time = toSeconds(decoded.value, getLastNodeFromPath(decoded.path).ticksPerSecond);
-    if (!time) return null;
+export function formatDateTime(decoded: DecodedDateTimeTypeNode, _options: FormatOptions = {}): string {
+    const time = toSeconds(decoded.value, decoded.path);
     const days = floorDiv(time.seconds, SECONDS_PER_DAY);
     const secondsOfDay = time.seconds - days * SECONDS_PER_DAY;
     const [year, month, day] = getCivilDate(days);
@@ -167,17 +187,16 @@ export function formatDateTime(decoded: DecodedDateTimeTypeNode): string | null
  * needed, e.g. `"49:00:00"`, with a leading `-` when negative. Fractions of a second are shown
  * as for {@link formatDateTime}.
  *
- * Returns `null` when `ticksPerSecond` is not a positive integer.
+ * @throws `CODAMA_ERROR__INVALID_TICKS_PER_SECOND` when `ticksPerSecond` is not a positive integer.
  *
  * @example
  * ```ts
  * formatDuration(decoded); // "01:30:00"
  * ```
  */
-export function formatDuration(decoded: DecodedDurationTypeNode): string | null {
+export function formatDuration(decoded: DecodedDurationTypeNode, _options: FormatOptions = {}): string {
     const negative = decoded.value < 0n;
-    const time = toSeconds(negative ? -decoded.value : decoded.value, getLastNodeFromPath(decoded.path).ticksPerSecond);
-    if (!time) return null;
+    const time = toSeconds(negative ? -decoded.value : decoded.value, decoded.path);
     return `${negative ? '-' : ''}${formatClock(time.seconds)}${time.fraction}`;
 }
 
@@ -192,14 +211,73 @@ export function formatDuration(decoded: DecodedDurationTypeNode): string | null
  * formatString(decoded); // "abcd"
  * ```
  */
-export function formatString(decoded: DecodedStringTypeNode): string {
+export function formatString(decoded: DecodedStringTypeNode, _options: FormatOptions = {}): string {
     const display = getLastNodeFromPath(decoded.path).display;
     if (!display) return decoded.value;
     return Array.from(decoded.value)
         .slice(display.sliceStart ?? 0, display.sliceEnd)
         .join('');
 }
 
+/**
+ * Format a decoded boolean as `"true"` or `"false"`.
+ *
+ * @example
+ * ```ts
+ * formatBoolean(decoded); // "true"
+ * ```
+ */
+export function formatBoolean(decoded: DecodedBooleanTypeNode, _options: FormatOptions = {}): string {
+    return decoded.value ? 'true' : 'false';
+}
+
+/**
+ * Format decoded bytes as hexadecimal with a `0x` prefix, whatever the encoding they were
+ * decoded with, e.g. `["base64", "AQI="]` gives `"0x0102"`. Bytes decoded as `utf8` are
+ * re-encoded from their text, so invalid UTF-8 sequences, already replaced when decoding, are
+ * not recovered: decode bytes with another encoding to format them exactly.
+ *
+ * @example
+ * ```ts
+ * formatBytes(decoded); // "0x0102"
+ * ```
+ */
+export function formatBytes(decoded: DecodedBytesTypeNode, _options: FormatOptions = {}): string {
+    const [encoding, data] = decoded.value;
+    return `0x${getBase16Decoder().decode(getCodecFromBytesEncoding(encoding).encode(data))}`;
+}
+
+/**
+ * Format a decoded enum as the label of its variant's display node, or the identifier of its
+ * variant in title case otherwise, e.g. `"Move To"` for `moveTo`. The data of the variant, if
+ * any, is not included.
+ *
+ * @example
+ * ```ts
+ * // enumVariantTypeNode('moveTo', { display: enumVariantDisplayNode({ label: 'Move' }) })
+ * formatEnum(decoded); // "Move"
+ * ```
+ */
+export function formatEnum(decoded: DecodedEnumTypeNode, _options: FormatOptions = {}): string {
+    const variant = getLastNodeFromPath(decoded.variant.path);
+    const label = variant.display?.label;
+    return label === undefined ? titleCase(variant.identifier) : getTextNodeContent(label);
+}
+
+/**
+ * Format a decoded public key with `formatAddress`, if any, or as its address otherwise.
+ *
+ * @example
+ * ```ts
+ * formatPublicKey(decoded); // "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
+ * formatPublicKey(decoded, { formatAddress: address => names.get(address) ?? address }); // "USDC"
+ * ```
+ */
+export function formatPublicKey(decoded: DecodedPublicKeyTypeNode, options: FormatOptions = {}): string {
+    const address = decoded.value as Address;
+    return options.formatAddress ? options.formatAddress(address) : address;
+}
+
 const SECONDS_PER_DAY = 86_400n;
 
 /** The signedness and bit width of an integer format, for Kit's fixed points. */
@@ -263,14 +341,18 @@ function resolveStringInput(
 }
 
 /**
- * Split a non-negative number of ticks into whole seconds and the fraction of a second,
- * e.g. `".5"`. Ticks that are not powers of 10 of a second are rounded to the nanosecond.
+ * Split a non-negative number of ticks of a date-time or duration into whole seconds and the
+ * fraction of a second, e.g. `".5"`. Ticks that are not powers of 10 of a second are rounded to
+ * the nanosecond.
  */
 function toSeconds(
     ticks: bigint,
-    ticksPerSecond: number | undefined = 1,
-): { fraction: string; seconds: bigint } | undefined {
-    if (!Number.isSafeInteger(ticksPerSecond) || ticksPerSecond <= 0) return undefined;
+    path: NodePath<DateTimeTypeNode | DurationTypeNode>,
+): { fraction: string; seconds: bigint } {
+    const ticksPerSecond = getLastNodeFromPath(path).ticksPerSecond ?? 1;
+    if (!Number.isSafeInteger(ticksPerSecond) || ticksPerSecond <= 0) {
+        throw new CodamaError(CODAMA_ERROR__INVALID_TICKS_PER_SECOND, { path, ticksPerSecond });
+    }
     let perSecond = BigInt(ticksPerSecond);
     let digits = getPowerOfTen(perSecond);
     if (digits === undefined) {
 
@@ -0,0 +1,15 @@
+import { booleanTypeNode } from '@codama/nodes';
+import { expect, test } from 'vitest';
+
+import { formatBoolean, getNodeCodec } from '../../src';
+import { hex } from '../_setup';
+
+test('it formats true booleans', () => {
+    const decoded = getNodeCodec([booleanTypeNode()]).decode(hex('01'));
+    expect(formatBoolean(decoded)).toBe('true');
+});
+
+test('it formats false booleans', () => {
+    const decoded = getNodeCodec([booleanTypeNode()]).decode(hex('00'));
+    expect(formatBoolean(decoded)).toBe('false');
+});
@@ -0,0 +1,27 @@
+import { bytesTypeNode } from '@codama/nodes';
+import { expect, test } from 'vitest';
+
+import { formatBytes, getNodeCodec } from '../../src';
+import { hex } from '../_setup';
+
+test('it formats bytes as hexadecimal', () => {
+    const decoded = getNodeCodec([bytesTypeNode()]).decode(hex('01020aff'));
+    expect(formatBytes(decoded)).toBe('0x01020aff');
+});
+
+test('it formats bytes as hexadecimal whatever the encoding they were decoded with', () => {
+    const decoded = getNodeCodec([bytesTypeNode()], { bytesEncoding: 'base58' }).decode(hex('0001020aff'));
+    expect(decoded.value[0]).toBe('base58');
+    expect(formatBytes(decoded)).toBe('0x0001020aff');
+});
+
+test('it formats bytes decoded as utf8 as hexadecimal', () => {
+    const decoded = getNodeCodec([bytesTypeNode()], { bytesEncoding: 'utf8' }).decode(hex('6869'));
+    expect(decoded.value).toStrictEqual(['utf8', 'hi']);
+    expect(formatBytes(decoded)).toBe('0x6869');
+});
+
+test('it formats empty bytes', () => {
+    const decoded = getNodeCodec([bytesTypeNode()]).decode(hex(''));
+    expect(formatBytes(decoded)).toBe('0x');
+});
@@ -1,3 +1,4 @@
+import { CODAMA_ERROR__INVALID_TICKS_PER_SECOND, CodamaError } from '@codama/errors';
 import { dateTimeTypeNode, integerTypeNode } from '@codama/nodes';
 import { getI64Encoder } from '@solana/codecs';
 import { expect, test } from 'vitest';
@@ -65,6 +66,10 @@ test('it matches JavaScript dates within their range', () => {
     expect(seconds.map(second => formatDateTime(decodeDateTime(second)))).toStrictEqual(expected);
 });
 
-test('it does not format date-times whose ticks per second are not positive integers', () => {
-    expect(formatDateTime(decodeDateTime(1n, 0))).toBeNull();
+test('it throws when the ticks per second of a date-time are not a positive integer', () => {
+    const node = dateTimeTypeNode(integerTypeNode('i64'), { ticksPerSecond: 0 });
+    const decoded = getNodeCodec([node]).decode(getI64Encoder().encode(1n));
+    expect(() => formatDateTime(decoded)).toThrow(
+        new CodamaError(CODAMA_ERROR__INVALID_TICKS_PER_SECOND, { path: [node], ticksPerSecond: 0 }),
+    );
 });