@tabai/sdk 0.2.0

package/dist/http/headers.d.ts

@@ -0,0 +1,173 @@
+/**
+ * The Tab HTTP header contract, and the only parser and formatter for it.
+ *
+ * This module is the reconciliation point between the two halves of the wire
+ * protocol: the client wrapper in `client-402.ts` (R23.2) reads these headers off
+ * a Service response, and the server-side post-paid plugin writes them. Both
+ * halves go through the functions here rather than through their own string
+ * handling, so a disagreement about a format is a compile or test failure in one
+ * file instead of a silent mis-parse in production.
+ *
+ * ## The contract
+ *
+ * | Header | Direction | Required | Value format |
+ * | --- | --- | --- | --- |
+ * | `Tab-Charge-Amount` | response | yes, within the block | decimal integer Asset base units, no sign, no separators, no exponent |
+ * | `Tab-Charge-Asset` | response | yes, within the block | `<chainId>:<address>`: the decimal EVM chain id, a colon, then a `0x` 20-byte address |
+ * | `Tab-Charge-Service` | response | yes, within the block | `0x` 32-byte word: the `serviceId` |
+ * | `Tab-Charge-Tool` | response | yes, within the block | `0x` 32-byte word: the `bytes32` tool key from the applied price list |
+ * | `Tab-Open-Tab` | response | yes, within the block | decimal integer base units: the Open Tab for that Agent, Service, and Asset after this call |
+ * | `Tab-Headroom` | response | yes, within the block | decimal integer base units: headroom remaining for that Agent and Asset |
+ * | `Tab-Agent` | request | yes on a metered call | `0x` 20-byte address: the Agent's Monad address, its identity on the rail |
+ * | `Tab-Authorisation` | request | optional | `0x` 32-byte word: the `authKey` the Service should meter against |
+ *
+ * ## Five decisions the table does not show, each of which 15.3 must match
+ *
+ * **1. The six response headers are one all-or-nothing block.** A response
+ * carrying none of them is simply not a metered response, and
+ * {@link parseChargeHeaders} returns `ok(undefined)` for it, an unmetered health
+ * endpoint behind the same client must not become an error. A response carrying
+ * *some* of them is a malformed metered response and is an `err`, because the
+ * alternative is a client that silently records a charge against the wrong Asset
+ * or against no Asset at all. There is no partial block and no default value: a
+ * missing `Tab-Headroom` does not mean zero headroom.
+ *
+ * **2. Every amount is an integer count of Asset base units, parsed to
+ * `bigint`.** Never a `number`, never a decimal, never a rate. USDC is 6
+ * decimals, so `10_000` is one cent, and an Open Tab routinely exceeds the range
+ * a float represents exactly. `Number.parseInt` would round a large Open Tab into
+ * something that still looks plausible, which is worse than failing. The grammar
+ * is deliberately narrow, `/^[0-9]+$/`, so `1e6`, `1.0`, `1_000`, `+1`, `-1`,
+ * `0x10`, and `1,000` are all rejected rather than coerced.
+ *
+ * **3. `Tab-Charge-Asset` carries the chain id and the Asset address and nothing
+ * else.** Decimals and symbol are deliberately absent: they are registry facts,
+ * not per-call facts, and a Service that could restate an Asset's decimals on
+ * every response could restate what a base unit means. So the parsed
+ * {@link ChargedAsset} is a two-field reference rather than an `AssetRef`, and a
+ * caller that needs decimals resolves them from its own configuration.
+ *
+ * **4. The chain id is bounded as a `uint64` and not narrowed to Monad's two
+ * networks.** Refusing an unknown chain id here would close a set the
+ * payment-strategy seam deliberately leaves open (R23.6): a strategy settling on a
+ * network this release has never heard of should still be able to read its own
+ * charge headers.
+ *
+ * **5. The Asset address is lower-cased on parse, and `serviceId` and the tool
+ * key are not.** An address arrives checksummed from one source and lower-case
+ * from another, and two spellings of one Asset in a ledger keyed by Asset is a
+ * client that reports two Open Tabs where there is one. A `bytes32` word has no
+ * checksum convention to normalise, so it is carried through byte-for-byte.
+ *
+ * A `bytes32` tool key is usually a short name right-padded with zero bytes -
+ * `0x7461622e64656d6f…` is `tab.demo`, but nothing
+ * here decodes it. The key is what `ServiceRegistry.priceOf` is keyed on, and it
+ * is carried as the word it is so it round-trips into a contract call unchanged.
+ *
+ * Requirements: 23.2, 21.5
+ */
+import { type Address, type Bytes32, type Result } from "../_shared/index.js";
+/** Every Tab header name, in the casing this SDK writes. */
+export declare const TAB_HEADER: {
+    readonly chargeAmount: "Tab-Charge-Amount";
+    readonly chargeAsset: "Tab-Charge-Asset";
+    readonly chargeService: "Tab-Charge-Service";
+    readonly chargeTool: "Tab-Charge-Tool";
+    readonly openTab: "Tab-Open-Tab";
+    readonly headroom: "Tab-Headroom";
+    readonly agent: "Tab-Agent";
+    readonly authorisation: "Tab-Authorisation";
+};
+/**
+ * The six response headers that form the charge block, all six required whenever
+ * any one of them is present.
+ */
+export declare const CHARGE_RESPONSE_HEADERS: readonly ["Tab-Charge-Amount", "Tab-Charge-Asset", "Tab-Charge-Service", "Tab-Charge-Tool", "Tab-Open-Tab", "Tab-Headroom"];
+/**
+ * The Asset a charge is denominated in, exactly as `Tab-Charge-Asset` carries it:
+ * a chain id and an address, with no decimals and no symbol.
+ */
+export interface ChargedAsset {
+    /** The EVM chain id the Asset lives on: 143 for Monad Mainnet, 10143 for Monad Testnet. */
+    readonly chainId: bigint;
+    /** Lower-cased on parse, so one Asset has one spelling in a ledger keyed by it. */
+    readonly address: Address;
+}
+/** One decoded charge block: what the Service says this call cost and what it left. */
+export interface ChargeBlock {
+    /** Integer Asset base units for this call. */
+    readonly amount: bigint;
+    readonly asset: ChargedAsset;
+    readonly serviceId: Bytes32;
+    /** The `bytes32` tool key from the applied price list. */
+    readonly tool: Bytes32;
+    /** The Open Tab for this Agent, Service, and Asset after this call. */
+    readonly openTab: bigint;
+    /** Headroom remaining for this Agent and Asset. */
+    readonly headroom: bigint;
+}
+/**
+ * Anything that answers a case-insensitive header lookup. A `Headers` instance
+ * satisfies it, and so does {@link headerReaderOf} over a plain object.
+ */
+export interface HeaderReader {
+    get(name: string): string | null | undefined;
+}
+/** A header bag as a framework hands one over: values, or repeated values. */
+export type HeaderRecord = Readonly<Record<string, string | readonly string[] | undefined>>;
+/** The registry key for a charged Asset: `${chainId}:${address}`, lower-cased. */
+export declare const chargedAssetKey: (asset: ChargedAsset) => string;
+/** True when both refs name the same Asset on the same chain, spelling aside. */
+export declare const sameChargedAsset: (a: ChargedAsset, b: ChargedAsset) => boolean;
+/**
+ * Wraps a plain header object as a {@link HeaderReader}, matching names
+ * case-insensitively.
+ *
+ * Repeated values are joined with `, ` rather than resolved to one of them. Every
+ * Tab header is single-valued, so a repeat is a bug on the emitting side, and
+ * joining makes it fail the format check loudly instead of picking a winner.
+ */
+export declare function headerReaderOf(source: HeaderReader | HeaderRecord): HeaderReader;
+/**
+ * Parses a decimal integer count of Asset base units.
+ *
+ * `bigint` because base units are exact integers of arbitrary size, and a narrow
+ * grammar because every rejected spelling is a spelling that would otherwise be
+ * silently rounded or silently truncated.
+ */
+export declare function parseBaseUnits(raw: string, header: string, code: string): Result<bigint>;
+/** Renders `Tab-Charge-Asset`: `<chainId>:<address>`. */
+export declare const formatChargedAsset: (asset: ChargedAsset) => string;
+/** Parses `Tab-Charge-Asset`. */
+export declare function parseChargedAsset(raw: string): Result<ChargedAsset>;
+/**
+ * Reads the charge block off a response.
+ *
+ * Three outcomes, and the middle one is the reason this returns
+ * `Result<ChargeBlock | undefined>` rather than `Result<ChargeBlock>`:
+ *
+ * - all six headers present and well-formed, `ok(block)`;
+ * - none of the six present, `ok(undefined)`, an unmetered response;
+ * - some present, or one malformed, `err`, because a partial block cannot be
+ *   completed by guessing and a zero is not a safe stand-in for an absent amount.
+ */
+export declare function parseChargeHeaders(source: HeaderReader | HeaderRecord): Result<ChargeBlock | undefined>;
+/**
+ * Renders a charge block as the six response headers.
+ *
+ * Exported for the emitting side, so the server plugin writes what this module's
+ * parser reads rather than what a second string-building routine believes. The
+ * round trip through {@link parseChargeHeaders} is asserted in the tests.
+ */
+export declare function formatChargeHeaders(block: ChargeBlock): Result<Record<string, string>>;
+/**
+ * Builds the request headers that identify the Agent being metered.
+ *
+ * `Tab-Agent` is the Agent's Monad address, its identity on the rail, and
+ * the only thing that tells a Service which tab to charge. `Tab-Authorisation` is
+ * optional here because the authKey is a per-Service arrangement a caller may not
+ * hold; a Service that requires one answers 403 through the ordinary error path
+ * rather than through this function.
+ */
+export declare function agentRequestHeaders(agent: Address, authorisation?: Bytes32): Result<Record<string, string>>;
+//# sourceMappingURL=headers.d.ts.map

package/dist/http/headers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers.d.ts","sourceRoot":"","sources":["../../src/http/headers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AAEH,OAAO,EAKL,KAAK,OAAO,EACZ,KAAK,OAAO,EACZ,KAAK,MAAM,EACZ,MAAM,eAAe,CAAC;AAGvB,4DAA4D;AAC5D,eAAO,MAAM,UAAU;;;;;;;;;CASb,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,uBAAuB,6HAO1B,CAAC;AAEX;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,2FAA2F;IAC3F,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,mFAAmF;IACnF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED,uFAAuF;AACvF,MAAM,WAAW,WAAW;IAC1B,8CAA8C;IAC9C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,0DAA0D;IAC1D,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,uEAAuE;IACvE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,mDAAmD;IACnD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CAC9C;AAED,8EAA8E;AAC9E,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC,CAAC,CAAC;AAE5F,kFAAkF;AAClF,eAAO,MAAM,eAAe,GAAI,OAAO,YAAY,KAAG,MACU,CAAC;AAEjE,iFAAiF;AACjF,eAAO,MAAM,gBAAgB,GAAI,GAAG,YAAY,EAAE,GAAG,YAAY,KAAG,OACzB,CAAC;AAE5C;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,YAAY,GAAG,YAAY,GAAG,YAAY,CAQhF;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAexF;AAED,yDAAyD;AACzD,eAAO,MAAM,kBAAkB,GAAI,OAAO,YAAY,KAAG,MACO,CAAC;AAEjE,iCAAiC;AACjC,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,YAAY,CAAC,CA6BnE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,YAAY,GAAG,YAAY,GAClC,MAAM,CAAC,WAAW,GAAG,SAAS,CAAC,CAwEjC;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAiDtF;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,OAAO,EACd,aAAa,CAAC,EAAE,OAAO,GACtB,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAiBhC"}

package/dist/http/headers.js

@@ -0,0 +1,284 @@
+/**
+ * The Tab HTTP header contract, and the only parser and formatter for it.
+ *
+ * This module is the reconciliation point between the two halves of the wire
+ * protocol: the client wrapper in `client-402.ts` (R23.2) reads these headers off
+ * a Service response, and the server-side post-paid plugin writes them. Both
+ * halves go through the functions here rather than through their own string
+ * handling, so a disagreement about a format is a compile or test failure in one
+ * file instead of a silent mis-parse in production.
+ *
+ * ## The contract
+ *
+ * | Header | Direction | Required | Value format |
+ * | --- | --- | --- | --- |
+ * | `Tab-Charge-Amount` | response | yes, within the block | decimal integer Asset base units, no sign, no separators, no exponent |
+ * | `Tab-Charge-Asset` | response | yes, within the block | `<chainId>:<address>`: the decimal EVM chain id, a colon, then a `0x` 20-byte address |
+ * | `Tab-Charge-Service` | response | yes, within the block | `0x` 32-byte word: the `serviceId` |
+ * | `Tab-Charge-Tool` | response | yes, within the block | `0x` 32-byte word: the `bytes32` tool key from the applied price list |
+ * | `Tab-Open-Tab` | response | yes, within the block | decimal integer base units: the Open Tab for that Agent, Service, and Asset after this call |
+ * | `Tab-Headroom` | response | yes, within the block | decimal integer base units: headroom remaining for that Agent and Asset |
+ * | `Tab-Agent` | request | yes on a metered call | `0x` 20-byte address: the Agent's Monad address, its identity on the rail |
+ * | `Tab-Authorisation` | request | optional | `0x` 32-byte word: the `authKey` the Service should meter against |
+ *
+ * ## Five decisions the table does not show, each of which 15.3 must match
+ *
+ * **1. The six response headers are one all-or-nothing block.** A response
+ * carrying none of them is simply not a metered response, and
+ * {@link parseChargeHeaders} returns `ok(undefined)` for it, an unmetered health
+ * endpoint behind the same client must not become an error. A response carrying
+ * *some* of them is a malformed metered response and is an `err`, because the
+ * alternative is a client that silently records a charge against the wrong Asset
+ * or against no Asset at all. There is no partial block and no default value: a
+ * missing `Tab-Headroom` does not mean zero headroom.
+ *
+ * **2. Every amount is an integer count of Asset base units, parsed to
+ * `bigint`.** Never a `number`, never a decimal, never a rate. USDC is 6
+ * decimals, so `10_000` is one cent, and an Open Tab routinely exceeds the range
+ * a float represents exactly. `Number.parseInt` would round a large Open Tab into
+ * something that still looks plausible, which is worse than failing. The grammar
+ * is deliberately narrow, `/^[0-9]+$/`, so `1e6`, `1.0`, `1_000`, `+1`, `-1`,
+ * `0x10`, and `1,000` are all rejected rather than coerced.
+ *
+ * **3. `Tab-Charge-Asset` carries the chain id and the Asset address and nothing
+ * else.** Decimals and symbol are deliberately absent: they are registry facts,
+ * not per-call facts, and a Service that could restate an Asset's decimals on
+ * every response could restate what a base unit means. So the parsed
+ * {@link ChargedAsset} is a two-field reference rather than an `AssetRef`, and a
+ * caller that needs decimals resolves them from its own configuration.
+ *
+ * **4. The chain id is bounded as a `uint64` and not narrowed to Monad's two
+ * networks.** Refusing an unknown chain id here would close a set the
+ * payment-strategy seam deliberately leaves open (R23.6): a strategy settling on a
+ * network this release has never heard of should still be able to read its own
+ * charge headers.
+ *
+ * **5. The Asset address is lower-cased on parse, and `serviceId` and the tool
+ * key are not.** An address arrives checksummed from one source and lower-case
+ * from another, and two spellings of one Asset in a ledger keyed by Asset is a
+ * client that reports two Open Tabs where there is one. A `bytes32` word has no
+ * checksum convention to normalise, so it is carried through byte-for-byte.
+ *
+ * A `bytes32` tool key is usually a short name right-padded with zero bytes -
+ * `0x7461622e64656d6f…` is `tab.demo`, but nothing
+ * here decodes it. The key is what `ServiceRegistry.priceOf` is keyed on, and it
+ * is carried as the word it is so it round-trips into a contract call unchanged.
+ *
+ * Requirements: 23.2, 21.5
+ */
+import { UINT64_MAX, isAddress, isBytes32, ok, } from "../_shared/index.js";
+import { validationError } from "../errors.js";
+/** Every Tab header name, in the casing this SDK writes. */
+export const TAB_HEADER = {
+    chargeAmount: "Tab-Charge-Amount",
+    chargeAsset: "Tab-Charge-Asset",
+    chargeService: "Tab-Charge-Service",
+    chargeTool: "Tab-Charge-Tool",
+    openTab: "Tab-Open-Tab",
+    headroom: "Tab-Headroom",
+    agent: "Tab-Agent",
+    authorisation: "Tab-Authorisation",
+};
+/**
+ * The six response headers that form the charge block, all six required whenever
+ * any one of them is present.
+ */
+export const CHARGE_RESPONSE_HEADERS = [
+    TAB_HEADER.chargeAmount,
+    TAB_HEADER.chargeAsset,
+    TAB_HEADER.chargeService,
+    TAB_HEADER.chargeTool,
+    TAB_HEADER.openTab,
+    TAB_HEADER.headroom,
+];
+/** The registry key for a charged Asset: `${chainId}:${address}`, lower-cased. */
+export const chargedAssetKey = (asset) => `${asset.chainId.toString(10)}:${asset.address.toLowerCase()}`;
+/** True when both refs name the same Asset on the same chain, spelling aside. */
+export const sameChargedAsset = (a, b) => chargedAssetKey(a) === chargedAssetKey(b);
+/**
+ * Wraps a plain header object as a {@link HeaderReader}, matching names
+ * case-insensitively.
+ *
+ * Repeated values are joined with `, ` rather than resolved to one of them. Every
+ * Tab header is single-valued, so a repeat is a bug on the emitting side, and
+ * joining makes it fail the format check loudly instead of picking a winner.
+ */
+export function headerReaderOf(source) {
+    if (typeof source.get === "function")
+        return source;
+    const indexed = new Map();
+    for (const [name, value] of Object.entries(source)) {
+        if (value === undefined)
+            continue;
+        indexed.set(name.toLowerCase(), Array.isArray(value) ? value.join(", ") : value);
+    }
+    return { get: (name) => indexed.get(name.toLowerCase()) ?? null };
+}
+/**
+ * Parses a decimal integer count of Asset base units.
+ *
+ * `bigint` because base units are exact integers of arbitrary size, and a narrow
+ * grammar because every rejected spelling is a spelling that would otherwise be
+ * silently rounded or silently truncated.
+ */
+export function parseBaseUnits(raw, header, code) {
+    const value = raw.trim();
+    if (value.length === 0) {
+        return validationError(code, `${header} is empty; it must carry a decimal integer of base units`, {
+            details: { header },
+        });
+    }
+    if (!/^[0-9]+$/.test(value)) {
+        return validationError(code, `${header} carries \`${value}\`, which is not a decimal integer of base units; no sign, separator, decimal point, exponent, or 0x prefix is accepted`, { details: { header, value } });
+    }
+    return ok(BigInt(value));
+}
+/** Renders `Tab-Charge-Asset`: `<chainId>:<address>`. */
+export const formatChargedAsset = (asset) => `${asset.chainId.toString(10)}:${asset.address.toLowerCase()}`;
+/** Parses `Tab-Charge-Asset`. */
+export function parseChargedAsset(raw) {
+    const value = raw.trim();
+    const parts = value.split(":");
+    const [chainIdPart, addressPart] = parts;
+    if (parts.length !== 2 || chainIdPart === undefined || addressPart === undefined) {
+        return validationError("CHARGE_ASSET_INVALID", `${TAB_HEADER.chargeAsset} carries \`${value}\`; it must be exactly \`<chainId>:<address>\``, { details: { header: TAB_HEADER.chargeAsset, value } });
+    }
+    const chainId = parseBaseUnits(chainIdPart, `${TAB_HEADER.chargeAsset} chainId`, "CHARGE_ASSET_INVALID");
+    if (!chainId.ok)
+        return chainId;
+    if (chainId.value > UINT64_MAX) {
+        return validationError("CHARGE_ASSET_INVALID", `${TAB_HEADER.chargeAsset} names chain id ${chainId.value.toString(10)}, which exceeds uint64`, { details: { header: TAB_HEADER.chargeAsset, value } });
+    }
+    const address = addressPart.trim();
+    if (!isAddress(address)) {
+        return validationError("CHARGE_ASSET_INVALID", `${TAB_HEADER.chargeAsset} names \`${address}\` as its Asset, which is not a 20-byte 0x address`, { details: { header: TAB_HEADER.chargeAsset, value } });
+    }
+    return ok({ chainId: chainId.value, address: address.toLowerCase() });
+}
+/**
+ * Reads the charge block off a response.
+ *
+ * Three outcomes, and the middle one is the reason this returns
+ * `Result<ChargeBlock | undefined>` rather than `Result<ChargeBlock>`:
+ *
+ * - all six headers present and well-formed, `ok(block)`;
+ * - none of the six present, `ok(undefined)`, an unmetered response;
+ * - some present, or one malformed, `err`, because a partial block cannot be
+ *   completed by guessing and a zero is not a safe stand-in for an absent amount.
+ */
+export function parseChargeHeaders(source) {
+    const headers = headerReaderOf(source);
+    const raw = new Map();
+    const absent = [];
+    for (const name of CHARGE_RESPONSE_HEADERS) {
+        const value = headers.get(name);
+        if (value === null || value === undefined || value.trim().length === 0) {
+            absent.push(name);
+            continue;
+        }
+        raw.set(name, value);
+    }
+    if (absent.length === CHARGE_RESPONSE_HEADERS.length)
+        return ok(undefined);
+    if (absent.length > 0) {
+        return validationError("CHARGE_HEADERS_INCOMPLETE", `the response carries part of a Tab charge block and is missing ${absent.join(", ")}; the ${CHARGE_RESPONSE_HEADERS.length} charge headers are all-or-nothing, because a missing header is not a zero`, { details: { missing: absent.join(", "), present: [...raw.keys()].join(", ") } });
+    }
+    const amount = parseBaseUnits(raw.get(TAB_HEADER.chargeAmount) ?? "", TAB_HEADER.chargeAmount, "CHARGE_AMOUNT_INVALID");
+    if (!amount.ok)
+        return amount;
+    const asset = parseChargedAsset(raw.get(TAB_HEADER.chargeAsset) ?? "");
+    if (!asset.ok)
+        return asset;
+    const serviceId = (raw.get(TAB_HEADER.chargeService) ?? "").trim();
+    if (!isBytes32(serviceId)) {
+        return validationError("CHARGE_SERVICE_INVALID", `${TAB_HEADER.chargeService} carries \`${serviceId}\`, which is not a 32-byte 0x word`, { details: { header: TAB_HEADER.chargeService, value: serviceId } });
+    }
+    const tool = (raw.get(TAB_HEADER.chargeTool) ?? "").trim();
+    if (!isBytes32(tool)) {
+        return validationError("CHARGE_TOOL_INVALID", `${TAB_HEADER.chargeTool} carries \`${tool}\`, which is not a 32-byte 0x word; the tool key is the bytes32 the price list is keyed on, not its decoded name`, { details: { header: TAB_HEADER.chargeTool, value: tool } });
+    }
+    const openTab = parseBaseUnits(raw.get(TAB_HEADER.openTab) ?? "", TAB_HEADER.openTab, "OPEN_TAB_INVALID");
+    if (!openTab.ok)
+        return openTab;
+    const headroom = parseBaseUnits(raw.get(TAB_HEADER.headroom) ?? "", TAB_HEADER.headroom, "HEADROOM_INVALID");
+    if (!headroom.ok)
+        return headroom;
+    return ok({
+        amount: amount.value,
+        asset: asset.value,
+        serviceId,
+        tool,
+        openTab: openTab.value,
+        headroom: headroom.value,
+    });
+}
+/**
+ * Renders a charge block as the six response headers.
+ *
+ * Exported for the emitting side, so the server plugin writes what this module's
+ * parser reads rather than what a second string-building routine believes. The
+ * round trip through {@link parseChargeHeaders} is asserted in the tests.
+ */
+export function formatChargeHeaders(block) {
+    for (const [label, value, code] of [
+        [TAB_HEADER.chargeAmount, block.amount, "CHARGE_AMOUNT_INVALID"],
+        [TAB_HEADER.openTab, block.openTab, "OPEN_TAB_INVALID"],
+        [TAB_HEADER.headroom, block.headroom, "HEADROOM_INVALID"],
+    ]) {
+        if (typeof value !== "bigint") {
+            return validationError(code, `${label} must be a bigint count of base units, never a number`, {
+                details: { header: label },
+            });
+        }
+        if (value < 0n) {
+            return validationError(code, `${label} must not be negative, received ${value.toString(10)}`, {
+                details: { header: label },
+            });
+        }
+    }
+    if (typeof block.asset.chainId !== "bigint" || block.asset.chainId < 0n) {
+        return validationError("CHARGE_ASSET_INVALID", `${TAB_HEADER.chargeAsset} needs a non-negative bigint chain id`);
+    }
+    if (block.asset.chainId > UINT64_MAX) {
+        return validationError("CHARGE_ASSET_INVALID", `${TAB_HEADER.chargeAsset} chain id exceeds uint64: ${block.asset.chainId.toString(10)}`);
+    }
+    if (!isAddress(block.asset.address)) {
+        return validationError("CHARGE_ASSET_INVALID", `${TAB_HEADER.chargeAsset} needs a 20-byte 0x Asset address`);
+    }
+    if (!isBytes32(block.serviceId)) {
+        return validationError("CHARGE_SERVICE_INVALID", `${TAB_HEADER.chargeService} needs a 32-byte 0x word`);
+    }
+    if (!isBytes32(block.tool)) {
+        return validationError("CHARGE_TOOL_INVALID", `${TAB_HEADER.chargeTool} needs a 32-byte 0x word`);
+    }
+    return ok({
+        [TAB_HEADER.chargeAmount]: block.amount.toString(10),
+        [TAB_HEADER.chargeAsset]: formatChargedAsset(block.asset),
+        [TAB_HEADER.chargeService]: block.serviceId,
+        [TAB_HEADER.chargeTool]: block.tool,
+        [TAB_HEADER.openTab]: block.openTab.toString(10),
+        [TAB_HEADER.headroom]: block.headroom.toString(10),
+    });
+}
+/**
+ * Builds the request headers that identify the Agent being metered.
+ *
+ * `Tab-Agent` is the Agent's Monad address, its identity on the rail, and
+ * the only thing that tells a Service which tab to charge. `Tab-Authorisation` is
+ * optional here because the authKey is a per-Service arrangement a caller may not
+ * hold; a Service that requires one answers 403 through the ordinary error path
+ * rather than through this function.
+ */
+export function agentRequestHeaders(agent, authorisation) {
+    if (!isAddress(agent)) {
+        return validationError("AGENT_INVALID", `${TAB_HEADER.agent} must be the Agent's 20-byte 0x Monad address, received \`${String(agent)}\``);
+    }
+    if (authorisation !== undefined && !isBytes32(authorisation)) {
+        return validationError("AUTHORISATION_INVALID", `${TAB_HEADER.authorisation} must be a 32-byte 0x authKey, received \`${String(authorisation)}\``);
+    }
+    return ok({
+        [TAB_HEADER.agent]: agent,
+        ...(authorisation === undefined ? {} : { [TAB_HEADER.authorisation]: authorisation }),
+    });
+}
+//# sourceMappingURL=headers.js.map

package/dist/http/headers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers.js","sourceRoot":"","sources":["../../src/http/headers.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The Tab HTTP header contract, and the only parser and formatter for it.\n *\n * This module is the reconciliation point between the two halves of the wire\n * protocol: the client wrapper in `client-402.ts` (R23.2) reads these headers off\n * a Service response, and the server-side post-paid plugin writes them. Both\n * halves go through the functions here rather than through their own string\n * handling, so a disagreement about a format is a compile or test failure in one\n * file instead of a silent mis-parse in production.\n *\n * ## The contract\n *\n * | Header | Direction | Required | Value format |\n * | --- | --- | --- | --- |\n * | `Tab-Charge-Amount` | response | yes, within the block | decimal integer Asset base units, no sign, no separators, no exponent |\n * | `Tab-Charge-Asset` | response | yes, within the block | `<chainId>:<address>`: the decimal EVM chain id, a colon, then a `0x` 20-byte address |\n * | `Tab-Charge-Service` | response | yes, within the block | `0x` 32-byte word: the `serviceId` |\n * | `Tab-Charge-Tool` | response | yes, within the block | `0x` 32-byte word: the `bytes32` tool key from the applied price list |\n * | `Tab-Open-Tab` | response | yes, within the block | decimal integer base units: the Open Tab for that Agent, Service, and Asset after this call |\n * | `Tab-Headroom` | response | yes, within the block | decimal integer base units: headroom remaining for that Agent and Asset |\n * | `Tab-Agent` | request | yes on a metered call | `0x` 20-byte address: the Agent's Monad address, its identity on the rail |\n * | `Tab-Authorisation` | request | optional | `0x` 32-byte word: the `authKey` the Service should meter against |\n *\n * ## Five decisions the table does not show, each of which 15.3 must match\n *\n * **1. The six response headers are one all-or-nothing block.** A response\n * carrying none of them is simply not a metered response, and\n * {@link parseChargeHeaders} returns `ok(undefined)` for it, an unmetered health\n * endpoint behind the same client must not become an error. A response carrying\n * *some* of them is a malformed metered response and is an `err`, because the\n * alternative is a client that silently records a charge against the wrong Asset\n * or against no Asset at all. There is no partial block and no default value: a\n * missing `Tab-Headroom` does not mean zero headroom.\n *\n * **2. Every amount is an integer count of Asset base units, parsed to\n * `bigint`.** Never a `number`, never a decimal, never a rate. USDC is 6\n * decimals, so `10_000` is one cent, and an Open Tab routinely exceeds the range\n * a float represents exactly. `Number.parseInt` would round a large Open Tab into\n * something that still looks plausible, which is worse than failing. The grammar\n * is deliberately narrow, `/^[0-9]+$/`, so `1e6`, `1.0`, `1_000`, `+1`, `-1`,\n * `0x10`, and `1,000` are all rejected rather than coerced.\n *\n * **3. `Tab-Charge-Asset` carries the chain id and the Asset address and nothing\n * else.** Decimals and symbol are deliberately absent: they are registry facts,\n * not per-call facts, and a Service that could restate an Asset's decimals on\n * every response could restate what a base unit means. So the parsed\n * {@link ChargedAsset} is a two-field reference rather than an `AssetRef`, and a\n * caller that needs decimals resolves them from its own configuration.\n *\n * **4. The chain id is bounded as a `uint64` and not narrowed to Monad's two\n * networks.** Refusing an unknown chain id here would close a set the\n * payment-strategy seam deliberately leaves open (R23.6): a strategy settling on a\n * network this release has never heard of should still be able to read its own\n * charge headers.\n *\n * **5. The Asset address is lower-cased on parse, and `serviceId` and the tool\n * key are not.** An address arrives checksummed from one source and lower-case\n * from another, and two spellings of one Asset in a ledger keyed by Asset is a\n * client that reports two Open Tabs where there is one. A `bytes32` word has no\n * checksum convention to normalise, so it is carried through byte-for-byte.\n *\n * A `bytes32` tool key is usually a short name right-padded with zero bytes -\n * `0x7461622e64656d6f…` is `tab.demo`, but nothing\n * here decodes it. The key is what `ServiceRegistry.priceOf` is keyed on, and it\n * is carried as the word it is so it round-trips into a contract call unchanged.\n *\n * Requirements: 23.2, 21.5\n */\n\nimport {\n  UINT64_MAX,\n  isAddress,\n  isBytes32,\n  ok,\n  type Address,\n  type Bytes32,\n  type Result,\n} from \"../_shared/index.js\";\nimport { validationError } from \"../errors.js\";\n\n/** Every Tab header name, in the casing this SDK writes. */\nexport const TAB_HEADER = {\n  chargeAmount: \"Tab-Charge-Amount\",\n  chargeAsset: \"Tab-Charge-Asset\",\n  chargeService: \"Tab-Charge-Service\",\n  chargeTool: \"Tab-Charge-Tool\",\n  openTab: \"Tab-Open-Tab\",\n  headroom: \"Tab-Headroom\",\n  agent: \"Tab-Agent\",\n  authorisation: \"Tab-Authorisation\",\n} as const;\n\n/**\n * The six response headers that form the charge block, all six required whenever\n * any one of them is present.\n */\nexport const CHARGE_RESPONSE_HEADERS = [\n  TAB_HEADER.chargeAmount,\n  TAB_HEADER.chargeAsset,\n  TAB_HEADER.chargeService,\n  TAB_HEADER.chargeTool,\n  TAB_HEADER.openTab,\n  TAB_HEADER.headroom,\n] as const;\n\n/**\n * The Asset a charge is denominated in, exactly as `Tab-Charge-Asset` carries it:\n * a chain id and an address, with no decimals and no symbol.\n */\nexport interface ChargedAsset {\n  /** The EVM chain id the Asset lives on: 143 for Monad Mainnet, 10143 for Monad Testnet. */\n  readonly chainId: bigint;\n  /** Lower-cased on parse, so one Asset has one spelling in a ledger keyed by it. */\n  readonly address: Address;\n}\n\n/** One decoded charge block: what the Service says this call cost and what it left. */\nexport interface ChargeBlock {\n  /** Integer Asset base units for this call. */\n  readonly amount: bigint;\n  readonly asset: ChargedAsset;\n  readonly serviceId: Bytes32;\n  /** The `bytes32` tool key from the applied price list. */\n  readonly tool: Bytes32;\n  /** The Open Tab for this Agent, Service, and Asset after this call. */\n  readonly openTab: bigint;\n  /** Headroom remaining for this Agent and Asset. */\n  readonly headroom: bigint;\n}\n\n/**\n * Anything that answers a case-insensitive header lookup. A `Headers` instance\n * satisfies it, and so does {@link headerReaderOf} over a plain object.\n */\nexport interface HeaderReader {\n  get(name: string): string | null | undefined;\n}\n\n/** A header bag as a framework hands one over: values, or repeated values. */\nexport type HeaderRecord = Readonly<Record<string, string | readonly string[] | undefined>>;\n\n/** The registry key for a charged Asset: `${chainId}:${address}`, lower-cased. */\nexport const chargedAssetKey = (asset: ChargedAsset): string =>\n  `${asset.chainId.toString(10)}:${asset.address.toLowerCase()}`;\n\n/** True when both refs name the same Asset on the same chain, spelling aside. */\nexport const sameChargedAsset = (a: ChargedAsset, b: ChargedAsset): boolean =>\n  chargedAssetKey(a) === chargedAssetKey(b);\n\n/**\n * Wraps a plain header object as a {@link HeaderReader}, matching names\n * case-insensitively.\n *\n * Repeated values are joined with `, ` rather than resolved to one of them. Every\n * Tab header is single-valued, so a repeat is a bug on the emitting side, and\n * joining makes it fail the format check loudly instead of picking a winner.\n */\nexport function headerReaderOf(source: HeaderReader | HeaderRecord): HeaderReader {\n  if (typeof (source as HeaderReader).get === \"function\") return source as HeaderReader;\n  const indexed = new Map<string, string>();\n  for (const [name, value] of Object.entries(source as HeaderRecord)) {\n    if (value === undefined) continue;\n    indexed.set(name.toLowerCase(), Array.isArray(value) ? value.join(\", \") : (value as string));\n  }\n  return { get: (name) => indexed.get(name.toLowerCase()) ?? null };\n}\n\n/**\n * Parses a decimal integer count of Asset base units.\n *\n * `bigint` because base units are exact integers of arbitrary size, and a narrow\n * grammar because every rejected spelling is a spelling that would otherwise be\n * silently rounded or silently truncated.\n */\nexport function parseBaseUnits(raw: string, header: string, code: string): Result<bigint> {\n  const value = raw.trim();\n  if (value.length === 0) {\n    return validationError(code, `${header} is empty; it must carry a decimal integer of base units`, {\n      details: { header },\n    });\n  }\n  if (!/^[0-9]+$/.test(value)) {\n    return validationError(\n      code,\n      `${header} carries \\`${value}\\`, which is not a decimal integer of base units; no sign, separator, decimal point, exponent, or 0x prefix is accepted`,\n      { details: { header, value } },\n    );\n  }\n  return ok(BigInt(value));\n}\n\n/** Renders `Tab-Charge-Asset`: `<chainId>:<address>`. */\nexport const formatChargedAsset = (asset: ChargedAsset): string =>\n  `${asset.chainId.toString(10)}:${asset.address.toLowerCase()}`;\n\n/** Parses `Tab-Charge-Asset`. */\nexport function parseChargedAsset(raw: string): Result<ChargedAsset> {\n  const value = raw.trim();\n  const parts = value.split(\":\");\n  const [chainIdPart, addressPart] = parts;\n  if (parts.length !== 2 || chainIdPart === undefined || addressPart === undefined) {\n    return validationError(\n      \"CHARGE_ASSET_INVALID\",\n      `${TAB_HEADER.chargeAsset} carries \\`${value}\\`; it must be exactly \\`<chainId>:<address>\\``,\n      { details: { header: TAB_HEADER.chargeAsset, value } },\n    );\n  }\n  const chainId = parseBaseUnits(chainIdPart, `${TAB_HEADER.chargeAsset} chainId`, \"CHARGE_ASSET_INVALID\");\n  if (!chainId.ok) return chainId;\n  if (chainId.value > UINT64_MAX) {\n    return validationError(\n      \"CHARGE_ASSET_INVALID\",\n      `${TAB_HEADER.chargeAsset} names chain id ${chainId.value.toString(10)}, which exceeds uint64`,\n      { details: { header: TAB_HEADER.chargeAsset, value } },\n    );\n  }\n  const address = addressPart.trim();\n  if (!isAddress(address)) {\n    return validationError(\n      \"CHARGE_ASSET_INVALID\",\n      `${TAB_HEADER.chargeAsset} names \\`${address}\\` as its Asset, which is not a 20-byte 0x address`,\n      { details: { header: TAB_HEADER.chargeAsset, value } },\n    );\n  }\n  return ok({ chainId: chainId.value, address: address.toLowerCase() as Address });\n}\n\n/**\n * Reads the charge block off a response.\n *\n * Three outcomes, and the middle one is the reason this returns\n * `Result<ChargeBlock | undefined>` rather than `Result<ChargeBlock>`:\n *\n * - all six headers present and well-formed, `ok(block)`;\n * - none of the six present, `ok(undefined)`, an unmetered response;\n * - some present, or one malformed, `err`, because a partial block cannot be\n *   completed by guessing and a zero is not a safe stand-in for an absent amount.\n */\nexport function parseChargeHeaders(\n  source: HeaderReader | HeaderRecord,\n): Result<ChargeBlock | undefined> {\n  const headers = headerReaderOf(source);\n  const raw = new Map<string, string>();\n  const absent: string[] = [];\n  for (const name of CHARGE_RESPONSE_HEADERS) {\n    const value = headers.get(name);\n    if (value === null || value === undefined || value.trim().length === 0) {\n      absent.push(name);\n      continue;\n    }\n    raw.set(name, value);\n  }\n\n  if (absent.length === CHARGE_RESPONSE_HEADERS.length) return ok(undefined);\n  if (absent.length > 0) {\n    return validationError(\n      \"CHARGE_HEADERS_INCOMPLETE\",\n      `the response carries part of a Tab charge block and is missing ${absent.join(\", \")}; the ${CHARGE_RESPONSE_HEADERS.length} charge headers are all-or-nothing, because a missing header is not a zero`,\n      { details: { missing: absent.join(\", \"), present: [...raw.keys()].join(\", \") } },\n    );\n  }\n\n  const amount = parseBaseUnits(\n    raw.get(TAB_HEADER.chargeAmount) ?? \"\",\n    TAB_HEADER.chargeAmount,\n    \"CHARGE_AMOUNT_INVALID\",\n  );\n  if (!amount.ok) return amount;\n\n  const asset = parseChargedAsset(raw.get(TAB_HEADER.chargeAsset) ?? \"\");\n  if (!asset.ok) return asset;\n\n  const serviceId = (raw.get(TAB_HEADER.chargeService) ?? \"\").trim();\n  if (!isBytes32(serviceId)) {\n    return validationError(\n      \"CHARGE_SERVICE_INVALID\",\n      `${TAB_HEADER.chargeService} carries \\`${serviceId}\\`, which is not a 32-byte 0x word`,\n      { details: { header: TAB_HEADER.chargeService, value: serviceId } },\n    );\n  }\n\n  const tool = (raw.get(TAB_HEADER.chargeTool) ?? \"\").trim();\n  if (!isBytes32(tool)) {\n    return validationError(\n      \"CHARGE_TOOL_INVALID\",\n      `${TAB_HEADER.chargeTool} carries \\`${tool}\\`, which is not a 32-byte 0x word; the tool key is the bytes32 the price list is keyed on, not its decoded name`,\n      { details: { header: TAB_HEADER.chargeTool, value: tool } },\n    );\n  }\n\n  const openTab = parseBaseUnits(\n    raw.get(TAB_HEADER.openTab) ?? \"\",\n    TAB_HEADER.openTab,\n    \"OPEN_TAB_INVALID\",\n  );\n  if (!openTab.ok) return openTab;\n\n  const headroom = parseBaseUnits(\n    raw.get(TAB_HEADER.headroom) ?? \"\",\n    TAB_HEADER.headroom,\n    \"HEADROOM_INVALID\",\n  );\n  if (!headroom.ok) return headroom;\n\n  return ok({\n    amount: amount.value,\n    asset: asset.value,\n    serviceId,\n    tool,\n    openTab: openTab.value,\n    headroom: headroom.value,\n  });\n}\n\n/**\n * Renders a charge block as the six response headers.\n *\n * Exported for the emitting side, so the server plugin writes what this module's\n * parser reads rather than what a second string-building routine believes. The\n * round trip through {@link parseChargeHeaders} is asserted in the tests.\n */\nexport function formatChargeHeaders(block: ChargeBlock): Result<Record<string, string>> {\n  for (const [label, value, code] of [\n    [TAB_HEADER.chargeAmount, block.amount, \"CHARGE_AMOUNT_INVALID\"],\n    [TAB_HEADER.openTab, block.openTab, \"OPEN_TAB_INVALID\"],\n    [TAB_HEADER.headroom, block.headroom, \"HEADROOM_INVALID\"],\n  ] as const) {\n    if (typeof value !== \"bigint\") {\n      return validationError(code, `${label} must be a bigint count of base units, never a number`, {\n        details: { header: label },\n      });\n    }\n    if (value < 0n) {\n      return validationError(code, `${label} must not be negative, received ${value.toString(10)}`, {\n        details: { header: label },\n      });\n    }\n  }\n  if (typeof block.asset.chainId !== \"bigint\" || block.asset.chainId < 0n) {\n    return validationError(\n      \"CHARGE_ASSET_INVALID\",\n      `${TAB_HEADER.chargeAsset} needs a non-negative bigint chain id`,\n    );\n  }\n  if (block.asset.chainId > UINT64_MAX) {\n    return validationError(\n      \"CHARGE_ASSET_INVALID\",\n      `${TAB_HEADER.chargeAsset} chain id exceeds uint64: ${block.asset.chainId.toString(10)}`,\n    );\n  }\n  if (!isAddress(block.asset.address)) {\n    return validationError(\n      \"CHARGE_ASSET_INVALID\",\n      `${TAB_HEADER.chargeAsset} needs a 20-byte 0x Asset address`,\n    );\n  }\n  if (!isBytes32(block.serviceId)) {\n    return validationError(\"CHARGE_SERVICE_INVALID\", `${TAB_HEADER.chargeService} needs a 32-byte 0x word`);\n  }\n  if (!isBytes32(block.tool)) {\n    return validationError(\"CHARGE_TOOL_INVALID\", `${TAB_HEADER.chargeTool} needs a 32-byte 0x word`);\n  }\n  return ok({\n    [TAB_HEADER.chargeAmount]: block.amount.toString(10),\n    [TAB_HEADER.chargeAsset]: formatChargedAsset(block.asset),\n    [TAB_HEADER.chargeService]: block.serviceId,\n    [TAB_HEADER.chargeTool]: block.tool,\n    [TAB_HEADER.openTab]: block.openTab.toString(10),\n    [TAB_HEADER.headroom]: block.headroom.toString(10),\n  });\n}\n\n/**\n * Builds the request headers that identify the Agent being metered.\n *\n * `Tab-Agent` is the Agent's Monad address, its identity on the rail, and\n * the only thing that tells a Service which tab to charge. `Tab-Authorisation` is\n * optional here because the authKey is a per-Service arrangement a caller may not\n * hold; a Service that requires one answers 403 through the ordinary error path\n * rather than through this function.\n */\nexport function agentRequestHeaders(\n  agent: Address,\n  authorisation?: Bytes32,\n): Result<Record<string, string>> {\n  if (!isAddress(agent)) {\n    return validationError(\n      \"AGENT_INVALID\",\n      `${TAB_HEADER.agent} must be the Agent's 20-byte 0x Monad address, received \\`${String(agent)}\\``,\n    );\n  }\n  if (authorisation !== undefined && !isBytes32(authorisation)) {\n    return validationError(\n      \"AUTHORISATION_INVALID\",\n      `${TAB_HEADER.authorisation} must be a 32-byte 0x authKey, received \\`${String(authorisation)}\\``,\n    );\n  }\n  return ok({\n    [TAB_HEADER.agent]: agent,\n    ...(authorisation === undefined ? {} : { [TAB_HEADER.authorisation]: authorisation }),\n  });\n}\n"]}

package/dist/http/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The HTTP surface of the SDK: the header contract, and the post-paid 402 client
+ * that reads it.
+ *
+ * `headers.ts` is the shared half. It is the only definition of the `Tab-*` wire
+ * format, and both directions go through it, the client here parses with it, and
+ * the server-side post-paid plugin formats with it, so the two halves cannot
+ * drift apart without a test failing.
+ *
+ * Requirements: 23.2, 21.5
+ */
+export * from "./headers.js";
+export * from "./client-402.js";
+export * from "./metering-claim.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/http/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/http/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC"}

package/dist/http/index.js

@@ -0,0 +1,15 @@
+/**
+ * The HTTP surface of the SDK: the header contract, and the post-paid 402 client
+ * that reads it.
+ *
+ * `headers.ts` is the shared half. It is the only definition of the `Tab-*` wire
+ * format, and both directions go through it, the client here parses with it, and
+ * the server-side post-paid plugin formats with it, so the two halves cannot
+ * drift apart without a test failing.
+ *
+ * Requirements: 23.2, 21.5
+ */
+export * from "./headers.js";
+export * from "./client-402.js";
+export * from "./metering-claim.js";
+//# sourceMappingURL=index.js.map

package/dist/http/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/http/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC","sourcesContent":["/**\n * The HTTP surface of the SDK: the header contract, and the post-paid 402 client\n * that reads it.\n *\n * `headers.ts` is the shared half. It is the only definition of the `Tab-*` wire\n * format, and both directions go through it, the client here parses with it, and\n * the server-side post-paid plugin formats with it, so the two halves cannot\n * drift apart without a test failing.\n *\n * Requirements: 23.2, 21.5\n */\n\nexport * from \"./headers.js\";\nexport * from \"./client-402.js\";\nexport * from \"./metering-claim.js\";\n"]}

package/dist/http/metering-claim.d.ts

@@ -0,0 +1,82 @@
+/**
+ * The metering claim: what a signed metered request binds, and who may sign it.
+ *
+ * ## Two signers, one digest
+ *
+ * A metered call records a delivery on chain and spends the Service operator's
+ * gas, so a metering endpoint anyone can reach must know the call was meant.
+ * Two parties can say so, and the digest they sign is the same string:
+ *
+ *   - **The operator**, from the Service's own front, which has authenticated
+ *     its caller however it likes. `Tab-Operator-Signature` carries it.
+ *   - **The Agent**, whose Open Tab the charge lands on. `Tab-Agent-Signature`
+ *     carries it, recovered against the address in `Tab-Agent`, so the one
+ *     party that pays for the call is the one that asked for it, and a
+ *     stranger who knows an Agent's address can put nothing on its tab.
+ *
+ * The digest binds the method, the path, the Agent, the tool, the unit count
+ * and a timestamp. Binding the Agent and the units is the point: a signature
+ * over the path alone would be a bearer token that replays against a
+ * different Agent for a different amount. The timestamp bounds replay to a
+ * window the gateway checks.
+ *
+ * ## Why it is written out and not JSON
+ *
+ * Newline-separated and fully ordered, so two different claims can never
+ * produce one digest. JSON key order is not guaranteed across
+ * implementations, and a signature over a reordered object would fail for a
+ * caller who did nothing wrong.
+ *
+ * Requirements: 12.1, 12.2, 21.5
+ */
+import type { ServiceHeaderProvider } from "../payments/config.js";
+/** The headers a signed metering request carries, by who signed it. */
+export declare const METERING_HEADER: {
+    readonly operatorSignature: "Tab-Operator-Signature";
+    readonly operatorIssuedAt: "Tab-Operator-Issued-At";
+    readonly agentSignature: "Tab-Agent-Signature";
+    readonly agentIssuedAt: "Tab-Agent-Issued-At";
+};
+/** The fields a metering request signature binds. */
+export interface MeteringRequestClaim {
+    readonly method: string;
+    readonly path: string;
+    readonly agent: string;
+    /** The 32-byte tool key the price list is keyed by, never the label. */
+    readonly tool: string;
+    readonly units: number;
+    /** Milliseconds since the epoch, as the caller stated it. */
+    readonly issuedAt: number;
+}
+/** The exact string a signer signs, with EIP-191 `personal_sign`. */
+export declare function meteringDigest(claim: MeteringRequestClaim): string;
+/** A signer that can `personal_sign`. An ethers `Wallet` satisfies it. */
+export interface MeteringSigner {
+    getAddress(): Promise<string>;
+    signMessage(message: string): Promise<string>;
+}
+/** A tool name as the caller gave it, packed to the key the price list holds, unless it already is one. */
+export declare function toolKeyOf(tool: string): string;
+/**
+ * A header provider that signs every metered call as the Agent.
+ *
+ * Put it on a Service entry in `tab.config` and `tab_call` sends
+ * `Tab-Agent-Signature` and `Tab-Agent-Issued-At` with each call, signed by
+ * the key the factory returns. A factory, like the strategies, so the key is
+ * built only when a call is made and every read stays keyless; one that
+ * returns nothing sends the call unsigned, and a gateway that requires a
+ * signature says so in its refusal.
+ *
+ * It signs only when the key it is given is the Agent the call is metered
+ * against, because that is what the gateway recovers the signature against.
+ * A key for anyone else adds nothing and the Service decides: one that
+ * requires a signature refuses by name, and one that does not is unaffected.
+ * That is the case where the Agent comes from somewhere other than this
+ * config, such as a wallet the MetaMask Agent Wallet plugin reads, and it is
+ * an honest "this key is not that Agent" rather than a signature that could
+ * only be rejected.
+ */
+export declare function agentSignedMetering(signer: () => MeteringSigner | undefined, options?: {
+    readonly now?: () => number;
+}): ServiceHeaderProvider;
+//# sourceMappingURL=metering-claim.d.ts.map

package/dist/http/metering-claim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metering-claim.d.ts","sourceRoot":"","sources":["../../src/http/metering-claim.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAIH,OAAO,KAAK,EAAE,qBAAqB,EAAwB,MAAM,uBAAuB,CAAC;AAEzF,uEAAuE;AACvE,eAAO,MAAM,eAAe;;;;;CAKlB,CAAC;AAEX,qDAAqD;AACrD,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,6DAA6D;IAC7D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,qEAAqE;AACrE,wBAAgB,cAAc,CAAC,KAAK,EAAE,oBAAoB,GAAG,MAAM,CAUlE;AAED,0EAA0E;AAC1E,MAAM,WAAW,cAAc;IAC7B,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAC9B,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAC/C;AAED,2GAA2G;AAC3G,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,cAAc,GAAG,SAAS,EACxC,OAAO,GAAE;IAAE,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;CAAO,GAC5C,qBAAqB,CAqBvB"}