@antseed/node 0.2.106 → 0.2.108

package/dist/discovery/metadata-codec.js

@@ -1,6 +1,8 @@
+import { SERVICE_CAPABILITY_MODALITIES } from "./peer-metadata.js";
 import { hexToBytes, bytesToHex } from "../utils/hex.js";
 import { toPeerId } from "../types/peer.js";
-import { isKnownServiceApiProtocol } from "../types/service-api.js";
+import { WELL_KNOWN_SERVICE_API_PROTOCOLS, isKnownServiceApiProtocol } from "../types/service-api.js";
+import { UNIT_BILLING_MATCH_KEYS_V1, UNIT_BILLING_UNITS_V1, } from "../types/billing.js";
 const SERVICE_CATEGORIES_METADATA_VERSION = 3;
 const SERVICE_API_PROTOCOLS_METADATA_VERSION = 4;
 const PUBLIC_ADDRESS_METADATA_VERSION = 5;
@@ -12,15 +14,22 @@ const DOMAIN_VERIFICATION_METHOD_IDS = {
     "https-well-known": 1,
 };
 const DOMAIN_VERIFICATION_METHODS_BY_ID = ["dns-txt", "https-well-known"];
+const SERVICE_UNIT_BILLING_METADATA_VERSION = 11;
+const SERVICE_CAPABILITIES_METADATA_VERSION = 12;
+const WIDE_SERVICE_COUNTS_METADATA_VERSION = 12;
+const UNIT_BILLING_UNITS_BY_ID = [...UNIT_BILLING_UNITS_V1];
+const UNIT_BILLING_UNIT_IDS = new Map(UNIT_BILLING_UNITS_BY_ID.map((unit, index) => [unit, index]));
+const UNIT_BILLING_MATCH_KEYS_BY_ID = [...UNIT_BILLING_MATCH_KEYS_V1];
+const UNIT_BILLING_MATCH_KEY_IDS = new Map(UNIT_BILLING_MATCH_KEYS_BY_ID.map((key, index) => [key, index]));
 /**
  * Encode metadata into binary format:
  * [version:1][peerId:20][regionLen:1][region:N][timestamp:8 BigUint64][providerCount:1]
  * for each provider:
- *   [providerLen:1][provider:N][serviceCount:1][services...]
+ *   [providerLen:1][provider:N][serviceCount:1|2][services...]
  *   [defaultInputPrice:4][defaultOutputPrice:4][defaultCachedInputPrice:4]
- *   [servicePricingCount:1][servicePricingEntries...]
- *   [serviceCategoryCount:1][serviceCategoryEntries...] (v3+ only)
- *   [serviceApiProtocolCount:1][serviceApiProtocolEntries...] (v4+ only)
+ *   [servicePricingCount:1|2][servicePricingEntries...]
+ *   [serviceCategoryCount:1|2][serviceCategoryEntries...] (v3+ only)
+ *   [serviceApiProtocolCount:1|2][serviceApiProtocolEntries...] (v4+ only)
  *   [maxConcurrency:2][currentLoad:2]
  * servicePricingEntry: [serviceLen:1][service:N][inputPrice:4][outputPrice:4][cachedInputPrice:4]
  * serviceCategoryEntry(v3+): [serviceLen:1][service:N][categoryCount:1][categories...]
@@ -58,6 +67,7 @@ function encodeBody(metadata) {
     const parts = [];
     const hasServiceCategoryExtensions = metadata.version >= SERVICE_CATEGORIES_METADATA_VERSION;
     const hasServiceApiProtocolExtensions = metadata.version >= SERVICE_API_PROTOCOLS_METADATA_VERSION;
+    const hasWideServiceCounts = metadata.version >= WIDE_SERVICE_COUNTS_METADATA_VERSION;
     // version: 1 byte
     parts.push(new Uint8Array([metadata.version]));
     // peerId: 20 bytes (EVM address)
@@ -78,8 +88,7 @@ function encodeBody(metadata) {
         const providerNameBytes = new TextEncoder().encode(p.provider);
         parts.push(new Uint8Array([providerNameBytes.length]));
         parts.push(providerNameBytes);
-        // serviceCount: 1 byte
-        parts.push(new Uint8Array([p.services.length]));
+        pushServiceEntryCount(parts, p.services.length, hasWideServiceCounts);
         // each service: length-prefixed
         for (const service of p.services) {
             const serviceBytes = new TextEncoder().encode(service);
@@ -100,7 +109,7 @@ function encodeBody(metadata) {
         parts.push(new Uint8Array(cachedInputPriceBuf));
         // servicePricing entries
         const servicePricingEntries = Object.entries(p.servicePricing ?? {}).sort(([a], [b]) => a.localeCompare(b));
-        parts.push(new Uint8Array([servicePricingEntries.length]));
+        pushServiceEntryCount(parts, servicePricingEntries.length, hasWideServiceCounts);
         for (const [serviceName, pricing] of servicePricingEntries) {
             const serviceNameBytes = new TextEncoder().encode(serviceName);
             parts.push(new Uint8Array([serviceNameBytes.length]));
@@ -126,7 +135,7 @@ function encodeBody(metadata) {
             })
                 .filter(([, categories]) => categories.length > 0)
                 .sort(([a], [b]) => a.localeCompare(b));
-            parts.push(new Uint8Array([serviceCategoryEntries.length]));
+            pushServiceEntryCount(parts, serviceCategoryEntries.length, hasWideServiceCounts);
             for (const [serviceName, categories] of serviceCategoryEntries) {
                 const serviceNameBytes = new TextEncoder().encode(serviceName);
                 parts.push(new Uint8Array([serviceNameBytes.length]));
@@ -149,7 +158,7 @@ function encodeBody(metadata) {
             })
                 .filter(([, protocols]) => protocols.length > 0)
                 .sort(([a], [b]) => a.localeCompare(b));
-            parts.push(new Uint8Array([serviceApiProtocolEntries.length]));
+            pushServiceEntryCount(parts, serviceApiProtocolEntries.length, hasWideServiceCounts);
             for (const [serviceName, protocols] of serviceApiProtocolEntries) {
                 const serviceNameBytes = new TextEncoder().encode(serviceName);
                 parts.push(new Uint8Array([serviceNameBytes.length]));
@@ -162,6 +171,12 @@ function encodeBody(metadata) {
                 }
             }
         }
+        if (metadata.version >= SERVICE_UNIT_BILLING_METADATA_VERSION) {
+            encodeServiceUnitBillingModels(parts, p.serviceUnitBillingModels, hasWideServiceCounts);
+        }
+        if (metadata.version >= SERVICE_CAPABILITIES_METADATA_VERSION) {
+            encodeServiceCapabilities(parts, p.serviceCapabilities, hasWideServiceCounts);
+        }
         // maxConcurrency: 2 bytes (uint16)
         const maxConcBuf = new ArrayBuffer(2);
         new DataView(maxConcBuf).setUint16(0, p.maxConcurrency, false);
@@ -335,6 +350,303 @@ function encodeBody(metadata) {
     }
     return result;
 }
+function encodeServiceUnitBillingModels(parts, serviceUnitBillingModels, hasWideServiceCounts) {
+    const entries = [];
+    for (const [serviceName, protocolModels] of Object.entries(serviceUnitBillingModels ?? {})) {
+        for (const protocol of WELL_KNOWN_SERVICE_API_PROTOCOLS) {
+            const model = protocolModels?.[protocol];
+            if (model)
+                entries.push([serviceName, protocol, model]);
+        }
+    }
+    entries.sort(([serviceA, protocolA], [serviceB, protocolB]) => serviceA === serviceB
+        ? WELL_KNOWN_SERVICE_API_PROTOCOLS.indexOf(protocolA) - WELL_KNOWN_SERVICE_API_PROTOCOLS.indexOf(protocolB)
+        : serviceA.localeCompare(serviceB));
+    pushServiceEntryCount(parts, entries.length, hasWideServiceCounts);
+    for (const [serviceName, protocol, model] of entries) {
+        pushUtf8(parts, serviceName);
+        parts.push(new Uint8Array([WELL_KNOWN_SERVICE_API_PROTOCOLS.indexOf(protocol)]));
+        parts.push(new Uint8Array([model.version]));
+        parts.push(new Uint8Array([model.components.length]));
+        for (const component of model.components) {
+            parts.push(new Uint8Array([UNIT_BILLING_UNIT_IDS.get(component.unit) ?? 255]));
+            const priceBuf = new ArrayBuffer(4);
+            new DataView(priceBuf).setFloat32(0, component.priceUsd, false);
+            parts.push(new Uint8Array(priceBuf));
+            const matchEntries = Object.entries(component.match ?? {})
+                .filter((entry) => UNIT_BILLING_MATCH_KEY_IDS.has(entry[0]))
+                .sort(([a], [b]) => (UNIT_BILLING_MATCH_KEY_IDS.get(a) ?? 0) - (UNIT_BILLING_MATCH_KEY_IDS.get(b) ?? 0));
+            parts.push(new Uint8Array([matchEntries.length]));
+            for (const [key, value] of matchEntries) {
+                parts.push(new Uint8Array([UNIT_BILLING_MATCH_KEY_IDS.get(key) ?? 255]));
+                pushUtf8(parts, value);
+            }
+        }
+    }
+}
+// Presence bits for the per-service capability entry. A set bit means the
+// field was announced (booleans distinguish "known false" from "unknown").
+const CAP_HAS_CONTEXT_WINDOW = 1 << 0;
+const CAP_HAS_MAX_OUTPUT_TOKENS = 1 << 1;
+const CAP_HAS_INPUTS = 1 << 2;
+const CAP_HAS_REASONING = 1 << 3;
+const CAP_HAS_TOOL_USE = 1 << 4;
+const CAP_HAS_STRUCTURED_OUTPUT = 1 << 5;
+const CAP_HAS_OUTPUTS = 1 << 6;
+const CAP_HAS_SUPPORTED_PARAMETERS = 1 << 7;
+const CAP_PRESENCE_MASK = CAP_HAS_CONTEXT_WINDOW | CAP_HAS_MAX_OUTPUT_TOKENS | CAP_HAS_INPUTS
+    | CAP_HAS_REASONING | CAP_HAS_TOOL_USE | CAP_HAS_STRUCTURED_OUTPUT
+    | CAP_HAS_OUTPUTS | CAP_HAS_SUPPORTED_PARAMETERS;
+// Value bits for the boolean-values byte. Deliberately a separate namespace
+// from the presence bits: presence says "announced", value says "true".
+const CAP_VAL_REASONING = 1 << 0;
+const CAP_VAL_TOOL_USE = 1 << 1;
+const CAP_VAL_STRUCTURED_OUTPUT = 1 << 2;
+const CAP_VALUE_MASK = CAP_VAL_REASONING | CAP_VAL_TOOL_USE | CAP_VAL_STRUCTURED_OUTPUT;
+const CAP_MODALITY_MASK = (1 << SERVICE_CAPABILITY_MODALITIES.length) - 1;
+function encodeModalityBits(modalities) {
+    let bits = 0;
+    for (const modality of modalities) {
+        const id = SERVICE_CAPABILITY_MODALITIES.indexOf(modality);
+        if (id >= 0)
+            bits |= 1 << id;
+    }
+    return bits;
+}
+function decodeModalityBits(bits, label) {
+    if (bits & ~CAP_MODALITY_MASK) {
+        throw new Error(`Unknown service capability ${label} bits 0x${bits.toString(16)}`);
+    }
+    const modalities = [];
+    for (let id = 0; id < SERVICE_CAPABILITY_MODALITIES.length; id += 1) {
+        if (bits & (1 << id))
+            modalities.push(SERVICE_CAPABILITY_MODALITIES[id]);
+    }
+    return modalities;
+}
+function encodeServiceCapabilities(parts, serviceCapabilities, hasWideServiceCounts) {
+    // Code-unit sort, not localeCompare: buyers verify signatures by re-encoding
+    // decoded metadata, so entry order must not depend on the verifier's locale.
+    const entries = Object.entries(serviceCapabilities ?? {})
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+    pushServiceEntryCount(parts, entries.length, hasWideServiceCounts);
+    for (const [serviceName, caps] of entries) {
+        pushUtf8(parts, serviceName);
+        let presence = 0;
+        if (caps.contextWindow !== undefined)
+            presence |= CAP_HAS_CONTEXT_WINDOW;
+        if (caps.maxOutputTokens !== undefined)
+            presence |= CAP_HAS_MAX_OUTPUT_TOKENS;
+        if (caps.inputs !== undefined)
+            presence |= CAP_HAS_INPUTS;
+        if (caps.outputs !== undefined)
+            presence |= CAP_HAS_OUTPUTS;
+        if (caps.reasoning !== undefined)
+            presence |= CAP_HAS_REASONING;
+        if (caps.toolUse !== undefined)
+            presence |= CAP_HAS_TOOL_USE;
+        if (caps.structuredOutput !== undefined)
+            presence |= CAP_HAS_STRUCTURED_OUTPUT;
+        if (caps.supportedParameters !== undefined)
+            presence |= CAP_HAS_SUPPORTED_PARAMETERS;
+        parts.push(new Uint8Array([presence]));
+        if (caps.contextWindow !== undefined) {
+            const buf = new ArrayBuffer(4);
+            new DataView(buf).setUint32(0, caps.contextWindow, false);
+            parts.push(new Uint8Array(buf));
+        }
+        if (caps.maxOutputTokens !== undefined) {
+            const buf = new ArrayBuffer(4);
+            new DataView(buf).setUint32(0, caps.maxOutputTokens, false);
+            parts.push(new Uint8Array(buf));
+        }
+        if (caps.inputs !== undefined) {
+            parts.push(new Uint8Array([encodeModalityBits(caps.inputs)]));
+        }
+        if (caps.outputs !== undefined) {
+            parts.push(new Uint8Array([encodeModalityBits(caps.outputs)]));
+        }
+        let boolBits = 0;
+        if (caps.reasoning === true)
+            boolBits |= CAP_VAL_REASONING;
+        if (caps.toolUse === true)
+            boolBits |= CAP_VAL_TOOL_USE;
+        if (caps.structuredOutput === true)
+            boolBits |= CAP_VAL_STRUCTURED_OUTPUT;
+        parts.push(new Uint8Array([boolBits]));
+        if (caps.supportedParameters !== undefined) {
+            // Code-unit sort for the same reason as the entry sort above: buyers
+            // verify signatures by re-encoding decoded metadata.
+            const parameters = [...caps.supportedParameters].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+            if (parameters.length > 255) {
+                throw new Error(`Too many supported parameters (${parameters.length})`);
+            }
+            parts.push(new Uint8Array([parameters.length]));
+            for (const parameter of parameters) {
+                pushUtf8(parts, parameter);
+            }
+        }
+    }
+}
+function decodeServiceCapabilities(data, getOffset, setOffset, checkBounds, hasWideServiceCounts) {
+    let offset = getOffset();
+    const [entryCount, nextOffset] = readServiceEntryCount(data, offset, checkBounds, hasWideServiceCounts);
+    offset = nextOffset;
+    const serviceCapabilities = {};
+    for (let i = 0; i < entryCount; i += 1) {
+        const [serviceName, serviceOffset] = readUtf8(data, offset, checkBounds);
+        offset = serviceOffset;
+        checkBounds(offset, 1, data.length);
+        const presence = data[offset];
+        offset += 1;
+        if (presence & ~CAP_PRESENCE_MASK) {
+            // Unknown bits would decode into a struct that re-encodes to different
+            // bytes and fails signature verification anyway — reject explicitly so
+            // additive extensions are forced through a metadata version bump.
+            throw new Error(`Unknown service capability presence bits 0x${presence.toString(16)}`);
+        }
+        const caps = {};
+        if (presence & CAP_HAS_CONTEXT_WINDOW) {
+            checkBounds(offset, 4, data.length);
+            caps.contextWindow = new DataView(data.buffer, data.byteOffset + offset, 4).getUint32(0, false);
+            offset += 4;
+        }
+        if (presence & CAP_HAS_MAX_OUTPUT_TOKENS) {
+            checkBounds(offset, 4, data.length);
+            caps.maxOutputTokens = new DataView(data.buffer, data.byteOffset + offset, 4).getUint32(0, false);
+            offset += 4;
+        }
+        if (presence & CAP_HAS_INPUTS) {
+            checkBounds(offset, 1, data.length);
+            caps.inputs = decodeModalityBits(data[offset], "input");
+            offset += 1;
+        }
+        if (presence & CAP_HAS_OUTPUTS) {
+            checkBounds(offset, 1, data.length);
+            caps.outputs = decodeModalityBits(data[offset], "output");
+            offset += 1;
+        }
+        checkBounds(offset, 1, data.length);
+        const boolBits = data[offset];
+        offset += 1;
+        if (boolBits & ~CAP_VALUE_MASK) {
+            throw new Error(`Unknown service capability value bits 0x${boolBits.toString(16)}`);
+        }
+        if (presence & CAP_HAS_REASONING)
+            caps.reasoning = (boolBits & CAP_VAL_REASONING) !== 0;
+        if (presence & CAP_HAS_TOOL_USE)
+            caps.toolUse = (boolBits & CAP_VAL_TOOL_USE) !== 0;
+        if (presence & CAP_HAS_STRUCTURED_OUTPUT)
+            caps.structuredOutput = (boolBits & CAP_VAL_STRUCTURED_OUTPUT) !== 0;
+        if (presence & CAP_HAS_SUPPORTED_PARAMETERS) {
+            checkBounds(offset, 1, data.length);
+            const parameterCount = data[offset];
+            offset += 1;
+            const parameters = [];
+            for (let p = 0; p < parameterCount; p += 1) {
+                const [parameter, parameterOffset] = readUtf8(data, offset, checkBounds);
+                offset = parameterOffset;
+                parameters.push(parameter);
+            }
+            caps.supportedParameters = parameters;
+        }
+        serviceCapabilities[serviceName] = caps;
+    }
+    setOffset(offset);
+    return Object.keys(serviceCapabilities).length > 0 ? serviceCapabilities : undefined;
+}
+function pushUtf8(parts, value) {
+    const bytes = new TextEncoder().encode(value);
+    if (bytes.length > 255) {
+        throw new Error(`Metadata string too long (${bytes.length} bytes)`);
+    }
+    parts.push(new Uint8Array([bytes.length]));
+    parts.push(bytes);
+}
+function pushServiceEntryCount(parts, count, hasWideServiceCounts) {
+    if (hasWideServiceCounts) {
+        if (count > 0xffff)
+            throw new Error(`Service entry count ${count} exceeds uint16`);
+        const countBuffer = new ArrayBuffer(2);
+        new DataView(countBuffer).setUint16(0, count, false);
+        parts.push(new Uint8Array(countBuffer));
+        return;
+    }
+    if (count > 0xff)
+        throw new Error(`Service entry count ${count} requires metadata v${WIDE_SERVICE_COUNTS_METADATA_VERSION}`);
+    parts.push(new Uint8Array([count]));
+}
+function readServiceEntryCount(data, offset, checkBounds, hasWideServiceCounts) {
+    const width = hasWideServiceCounts ? 2 : 1;
+    checkBounds(offset, width, data.length);
+    if (!hasWideServiceCounts)
+        return [data[offset], offset + 1];
+    return [new DataView(data.buffer, data.byteOffset + offset, 2).getUint16(0, false), offset + 2];
+}
+function decodeServiceUnitBillingModels(data, getOffset, setOffset, checkBounds, hasWideServiceCounts) {
+    let offset = getOffset();
+    const [entryCount, nextOffset] = readServiceEntryCount(data, offset, checkBounds, hasWideServiceCounts);
+    offset = nextOffset;
+    const serviceUnitBillingModels = {};
+    for (let i = 0; i < entryCount; i += 1) {
+        const [serviceName, serviceOffset] = readUtf8(data, offset, checkBounds);
+        offset = serviceOffset;
+        checkBounds(offset, 1, data.length);
+        const protocol = WELL_KNOWN_SERVICE_API_PROTOCOLS[data[offset]];
+        offset += 1;
+        if (!protocol) {
+            throw new Error("Unsupported service unit billing protocol id");
+        }
+        checkBounds(offset, 2, data.length);
+        const version = data[offset];
+        offset += 1;
+        if (version !== 1) {
+            throw new Error(`Unsupported service unit billing model version ${version}`);
+        }
+        const componentCount = data[offset];
+        offset += 1;
+        const components = [];
+        for (let j = 0; j < componentCount; j += 1) {
+            checkBounds(offset, 6, data.length);
+            const unit = UNIT_BILLING_UNITS_BY_ID[data[offset]];
+            offset += 1;
+            if (!unit) {
+                throw new Error("Unsupported service unit billing component unit");
+            }
+            const priceUsd = new DataView(data.buffer, data.byteOffset + offset, 4).getFloat32(0, false);
+            offset += 4;
+            const matchCount = data[offset];
+            offset += 1;
+            const match = {};
+            for (let k = 0; k < matchCount; k += 1) {
+                checkBounds(offset, 1, data.length);
+                const key = UNIT_BILLING_MATCH_KEYS_BY_ID[data[offset]];
+                offset += 1;
+                if (!key) {
+                    throw new Error("Unsupported service unit billing match key");
+                }
+                const [value, valueOffset] = readUtf8(data, offset, checkBounds);
+                offset = valueOffset;
+                match[key] = value;
+            }
+            const base = { unit, priceUsd, ...(Object.keys(match).length > 0 ? { match } : {}) };
+            components.push(base);
+        }
+        serviceUnitBillingModels[serviceName] = {
+            ...(serviceUnitBillingModels[serviceName] ?? {}),
+            [protocol]: { version: 1, components },
+        };
+    }
+    setOffset(offset);
+    return Object.keys(serviceUnitBillingModels).length > 0 ? serviceUnitBillingModels : undefined;
+}
+function readUtf8(data, offset, checkBounds) {
+    checkBounds(offset, 1, data.length);
+    const length = data[offset];
+    const valueOffset = offset + 1;
+    checkBounds(valueOffset, length, data.length);
+    return [new TextDecoder().decode(data.slice(valueOffset, valueOffset + length)), valueOffset + length];
+}
 /**
  * Decode binary metadata back into PeerMetadata.
  */
@@ -353,6 +665,7 @@ export function decodeMetadata(data) {
     const hasServiceCategoryExtensions = version >= SERVICE_CATEGORIES_METADATA_VERSION;
     const hasServiceApiProtocolExtensions = version >= SERVICE_API_PROTOCOLS_METADATA_VERSION;
     const hasPublicAddressExtension = version >= PUBLIC_ADDRESS_METADATA_VERSION;
+    const hasWideServiceCounts = version >= WIDE_SERVICE_COUNTS_METADATA_VERSION;
     offset += 1;
     // peerId: 20 bytes (EVM address)
     checkBounds(offset, 20, data.length);
@@ -384,10 +697,8 @@ export function decodeMetadata(data) {
         checkBounds(offset, providerLen, data.length);
         const provider = new TextDecoder().decode(data.slice(offset, offset + providerLen));
         offset += providerLen;
-        // serviceCount: 1 byte
-        checkBounds(offset, 1, data.length);
-        const serviceCount = data[offset];
-        offset += 1;
+        const [serviceCount, serviceCountOffset] = readServiceEntryCount(data, offset, checkBounds, hasWideServiceCounts);
+        offset = serviceCountOffset;
         const services = [];
         for (let j = 0; j < serviceCount; j++) {
             checkBounds(offset, 1, data.length);
@@ -414,9 +725,8 @@ export function decodeMetadata(data) {
         const defaultCachedInputUsdPerMillion = cachedInputPriceView.getFloat32(0, false);
         offset += 4;
         // servicePricing entries
-        checkBounds(offset, 1, data.length);
-        const servicePricingCount = data[offset];
-        offset += 1;
+        const [servicePricingCount, servicePricingOffset] = readServiceEntryCount(data, offset, checkBounds, hasWideServiceCounts);
+        offset = servicePricingOffset;
         const servicePricing = {};
         for (let j = 0; j < servicePricingCount; j++) {
             checkBounds(offset, 1, data.length);
@@ -446,9 +756,8 @@ export function decodeMetadata(data) {
         }
         let serviceCategories;
         if (hasServiceCategoryExtensions) {
-            checkBounds(offset, 1, data.length);
-            const serviceCategoryCount = data[offset];
-            offset += 1;
+            const [serviceCategoryCount, serviceCategoryOffset] = readServiceEntryCount(data, offset, checkBounds, hasWideServiceCounts);
+            offset = serviceCategoryOffset;
             if (serviceCategoryCount > 0) {
                 serviceCategories = {};
                 for (let j = 0; j < serviceCategoryCount; j++) {
@@ -477,9 +786,8 @@ export function decodeMetadata(data) {
         }
         let serviceApiProtocols;
         if (hasServiceApiProtocolExtensions) {
-            checkBounds(offset, 1, data.length);
-            const serviceApiProtocolCount = data[offset];
-            offset += 1;
+            const [serviceApiProtocolCount, serviceApiProtocolOffset] = readServiceEntryCount(data, offset, checkBounds, hasWideServiceCounts);
+            offset = serviceApiProtocolOffset;
             if (serviceApiProtocolCount > 0) {
                 serviceApiProtocols = {};
                 for (let j = 0; j < serviceApiProtocolCount; j++) {
@@ -506,6 +814,12 @@ export function decodeMetadata(data) {
                 }
             }
         }
+        const serviceUnitBillingModels = version >= SERVICE_UNIT_BILLING_METADATA_VERSION
+            ? decodeServiceUnitBillingModels(data, () => offset, (next) => { offset = next; }, checkBounds, hasWideServiceCounts)
+            : undefined;
+        const serviceCapabilities = version >= SERVICE_CAPABILITIES_METADATA_VERSION
+            ? decodeServiceCapabilities(data, () => offset, (next) => { offset = next; }, checkBounds, hasWideServiceCounts)
+            : undefined;
         // maxConcurrency: 2 bytes uint16
         checkBounds(offset, 2, data.length);
         const maxConcView = new DataView(data.buffer, data.byteOffset + offset, 2);
@@ -527,6 +841,8 @@ export function decodeMetadata(data) {
             ...(servicePricingCount > 0 ? { servicePricing } : {}),
             ...(serviceCategories && Object.keys(serviceCategories).length > 0 ? { serviceCategories } : {}),
             ...(serviceApiProtocols && Object.keys(serviceApiProtocols).length > 0 ? { serviceApiProtocols } : {}),
+            ...(serviceUnitBillingModels && Object.keys(serviceUnitBillingModels).length > 0 ? { serviceUnitBillingModels } : {}),
+            ...(serviceCapabilities && Object.keys(serviceCapabilities).length > 0 ? { serviceCapabilities } : {}),
             maxConcurrency,
             currentLoad,
         });