@forestrie/receipt-verify 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Robin Bryce
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cose-key.d.ts

@@ -0,0 +1,10 @@
+export declare const COSE_ALG_ES256 = -7;
+export declare const COSE_ALG_KS256 = -65799;
+export declare const COSE_KEY_KTY = 1;
+export declare const COSE_KEY_ALG = 3;
+export declare const COSE_EC2_CRV = -1;
+export declare const COSE_EC2_X = -2;
+export declare const COSE_EC2_Y = -3;
+export declare const COSE_KTY_EC2 = 2;
+export declare const COSE_CRV_P256 = 1;
+//# sourceMappingURL=cose-key.d.ts.map

package/dist/cose-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cose-key.d.ts","sourceRoot":"","sources":["../src/cose-key.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,KAAK,CAAC;AACjC,eAAO,MAAM,cAAc,SAAS,CAAC;AACrC,eAAO,MAAM,YAAY,IAAI,CAAC;AAC9B,eAAO,MAAM,YAAY,IAAI,CAAC;AAC9B,eAAO,MAAM,YAAY,KAAK,CAAC;AAC/B,eAAO,MAAM,UAAU,KAAK,CAAC;AAC7B,eAAO,MAAM,UAAU,KAAK,CAAC;AAC7B,eAAO,MAAM,YAAY,IAAI,CAAC;AAC9B,eAAO,MAAM,aAAa,IAAI,CAAC"}

package/dist/cose-key.js

@@ -0,0 +1,9 @@
+export const COSE_ALG_ES256 = -7;
+export const COSE_ALG_KS256 = -65799;
+export const COSE_KEY_KTY = 1;
+export const COSE_KEY_ALG = 3;
+export const COSE_EC2_CRV = -1;
+export const COSE_EC2_X = -2;
+export const COSE_EC2_Y = -3;
+export const COSE_KTY_EC2 = 2;
+export const COSE_CRV_P256 = 1;

package/dist/decode-forestrie-grant-cose.d.ts

@@ -0,0 +1,9 @@
+import type { Grant } from "./grant.js";
+/**
+ * Decode Forestrie-Grant COSE Sign1 (Custodian transparent statement profile).
+ */
+export declare function decodeForestrieGrantCose(bytes: Uint8Array): {
+    grant: Grant;
+    idtimestampBe8: Uint8Array;
+};
+//# sourceMappingURL=decode-forestrie-grant-cose.d.ts.map

package/dist/decode-forestrie-grant-cose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode-forestrie-grant-cose.d.ts","sourceRoot":"","sources":["../src/decode-forestrie-grant-cose.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAmCxC;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,UAAU,GAAG;IAC3D,KAAK,EAAE,KAAK,CAAC;IACb,cAAc,EAAE,UAAU,CAAC;CAC5B,CAmCA"}

package/dist/decode-forestrie-grant-cose.js

@@ -0,0 +1,62 @@
+import { sha256 } from "@noble/hashes/sha256";
+import { decode as decodeCbor } from "cbor-x";
+import { HEADER_FORESTRIE_GRANT_V0, HEADER_IDTIMESTAMP, } from "./forest-genesis-labels.js";
+import { decodeGrantPayload } from "./grant-codec.js";
+const IDTIMESTAMP_BYTES = 8;
+function toHeaderMap(value) {
+    if (value instanceof Map)
+        return value;
+    if (typeof value === "object" &&
+        value !== null &&
+        !(value instanceof Uint8Array)) {
+        const out = new Map();
+        for (const [k, v] of Object.entries(value)) {
+            const n = Number(k);
+            if (Number.isFinite(n))
+                out.set(n, v);
+        }
+        return out;
+    }
+    return new Map();
+}
+function digestEquals(a, b) {
+    if (a.length !== b.length)
+        return false;
+    let x = 0;
+    for (let i = 0; i < a.length; i++)
+        x |= a[i] ^ b[i];
+    return x === 0;
+}
+/**
+ * Decode Forestrie-Grant COSE Sign1 (Custodian transparent statement profile).
+ */
+export function decodeForestrieGrantCose(bytes) {
+    const raw = decodeCbor(bytes);
+    const arr = Array.isArray(raw) ? raw : null;
+    if (!arr || arr.length !== 4) {
+        throw new Error("Forestrie-Grant must be COSE Sign1 (array of 4)");
+    }
+    const [, unprotectedRaw, payloadRaw] = arr;
+    if (!(payloadRaw instanceof Uint8Array) || payloadRaw.length !== 32) {
+        throw new Error("Forestrie-Grant COSE payload must be 32-byte digest");
+    }
+    const unprotected = toHeaderMap(unprotectedRaw);
+    const embedded = unprotected.get(HEADER_FORESTRIE_GRANT_V0);
+    if (!(embedded instanceof Uint8Array) || embedded.length === 0) {
+        throw new Error("Forestrie-Grant missing unprotected -65538 grant CBOR");
+    }
+    if (!digestEquals(sha256(embedded), payloadRaw)) {
+        throw new Error("Forestrie-Grant digest mismatch");
+    }
+    const idtimestampVal = unprotected.get(HEADER_IDTIMESTAMP);
+    const idtimestampBe8 = idtimestampVal instanceof Uint8Array &&
+        idtimestampVal.length >= IDTIMESTAMP_BYTES
+        ? idtimestampVal.length === IDTIMESTAMP_BYTES
+            ? idtimestampVal
+            : idtimestampVal.slice(-IDTIMESTAMP_BYTES)
+        : new Uint8Array(IDTIMESTAMP_BYTES);
+    return {
+        grant: decodeGrantPayload(embedded),
+        idtimestampBe8: new Uint8Array(idtimestampBe8),
+    };
+}

package/dist/decode-trust-root-cbor.d.ts

@@ -0,0 +1,6 @@
+import type { ParsedVerifyKey } from "@forestrie/encoding";
+import { type RootVerifyKey } from "./root-verify-key.js";
+export declare function importEs256PublicKeyFromGrantDataXy64(xy: Uint8Array): Promise<CryptoKey>;
+export declare function decodeTrustRootCbor(decoded: unknown): Promise<RootVerifyKey>;
+export declare function es256ReceiptVerifyKeys(keys: RootVerifyKey[]): ParsedVerifyKey[];
+//# sourceMappingURL=decode-trust-root-cbor.d.ts.map

package/dist/decode-trust-root-cbor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode-trust-root-cbor.d.ts","sourceRoot":"","sources":["../src/decode-trust-root-cbor.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAGL,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAE9B,wBAAsB,qCAAqC,CACzD,EAAE,EAAE,UAAU,GACb,OAAO,CAAC,SAAS,CAAC,CAgBpB;AAsCD,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,aAAa,CAAC,CAwCxB;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,aAAa,EAAE,GACpB,eAAe,EAAE,CAEnB"}

package/dist/decode-trust-root-cbor.js

@@ -0,0 +1,85 @@
+import { COSE_ALG_ES256, COSE_ALG_KS256 } from "@forestrie/encoding";
+import { isParsedKs256RootKey, } from "./root-verify-key.js";
+export async function importEs256PublicKeyFromGrantDataXy64(xy) {
+    if (xy.length !== 64) {
+        throw new Error("ES256 grantData must be 64 bytes (x||y) for raw public key import");
+    }
+    const raw = new Uint8Array(65);
+    raw[0] = 0x04;
+    raw.set(xy, 1);
+    return crypto.subtle.importKey("raw", raw, { name: "ECDSA", namedCurve: "P-256" }, false, ["verify"]);
+}
+function asUint8Array(v) {
+    if (v instanceof Uint8Array)
+        return v;
+    return null;
+}
+function parseAlgInt(raw) {
+    if (typeof raw === "number" && Number.isInteger(raw))
+        return raw;
+    if (typeof raw === "bigint") {
+        const n = Number(raw);
+        return Number.isSafeInteger(n) ? n : null;
+    }
+    if (typeof raw === "string") {
+        const n = Number(raw);
+        if (Number.isInteger(n))
+            return n;
+    }
+    return null;
+}
+function ks256RootFromAddress(address) {
+    return { kind: "KS256", alg: COSE_ALG_KS256, address };
+}
+function recordToTrustRootFields(decoded) {
+    if (decoded instanceof Map) {
+        const out = {};
+        for (const [k, v] of decoded.entries()) {
+            out[String(k)] = v;
+        }
+        return out;
+    }
+    if (typeof decoded === "object" && decoded !== null) {
+        return decoded;
+    }
+    throw new Error("trust-root CBOR must be a map");
+}
+export async function decodeTrustRootCbor(decoded) {
+    const fields = recordToTrustRootFields(decoded);
+    const algRaw = fields.alg;
+    const key = asUint8Array(fields.key);
+    const algInt = parseAlgInt(algRaw);
+    if (algInt === COSE_ALG_KS256) {
+        if (!key || key.length !== 20) {
+            throw new Error("KS256 trust-root key must be 20 bytes");
+        }
+        return ks256RootFromAddress(key);
+    }
+    if (algInt === COSE_ALG_ES256 && key) {
+        if (key.length !== 64) {
+            throw new Error("ES256 trust-root key must be 64 bytes (x||y)");
+        }
+        return importEs256PublicKeyFromGrantDataXy64(key);
+    }
+    if (typeof algRaw === "string" && algRaw.toUpperCase() === "KS256") {
+        if (!key || key.length !== 20) {
+            throw new Error("KS256 trust-root key must be 20 bytes");
+        }
+        return ks256RootFromAddress(key);
+    }
+    if (typeof algRaw === "string" && algRaw.toUpperCase() === "ES256") {
+        const x = asUint8Array(fields.x);
+        const y = asUint8Array(fields.y);
+        if (!x || x.length !== 32 || !y || y.length !== 32) {
+            throw new Error("ES256 trust-root x/y must be 32 bytes each");
+        }
+        const xy = new Uint8Array(64);
+        xy.set(x, 0);
+        xy.set(y, 32);
+        return importEs256PublicKeyFromGrantDataXy64(xy);
+    }
+    throw new Error(`unsupported trust-root alg ${String(algRaw)}`);
+}
+export function es256ReceiptVerifyKeys(keys) {
+    return keys.filter((k) => !isParsedKs256RootKey(k));
+}

package/dist/decode-trust-root-from-genesis.d.ts

@@ -0,0 +1,7 @@
+import type { RootVerifyKey } from "./root-verify-key.js";
+/**
+ * Extract receipt verify key from a forest genesis document CBOR blob.
+ * Offline path: genesis-only trust anchor (ADR-0045).
+ */
+export declare function decodeTrustRootFromGenesis(genesisCbor: Uint8Array): Promise<RootVerifyKey>;
+//# sourceMappingURL=decode-trust-root-from-genesis.d.ts.map

package/dist/decode-trust-root-from-genesis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode-trust-root-from-genesis.d.ts","sourceRoot":"","sources":["../src/decode-trust-root-from-genesis.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAmB1D;;;GAGG;AACH,wBAAsB,0BAA0B,CAC9C,WAAW,EAAE,UAAU,GACtB,OAAO,CAAC,aAAa,CAAC,CA0CxB"}

package/dist/decode-trust-root-from-genesis.js

@@ -0,0 +1,64 @@
+import { decode as decodeCbor } from "cbor-x";
+import { COSE_ALG_ES256, COSE_CRV_P256, COSE_EC2_CRV, COSE_EC2_X, COSE_EC2_Y, COSE_KEY_ALG, COSE_KEY_KTY, COSE_KTY_EC2, } from "./cose-key.js";
+import { FOREST_GENESIS_LABEL_BOOTSTRAP_KEY, FOREST_GENESIS_LABEL_GENESIS_ALG, FOREST_GENESIS_LABEL_GENESIS_VERSION, FOREST_GENESIS_SCHEMA_V1, FOREST_GENESIS_SCHEMA_V2, } from "./forest-genesis-labels.js";
+import { decodeTrustRootCbor } from "./decode-trust-root-cbor.js";
+function decodeBodyAsIntKeyMap(raw) {
+    if (raw instanceof Map)
+        return raw;
+    if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
+        const out = new Map();
+        for (const [k, v] of Object.entries(raw)) {
+            const n = Number(k);
+            if (Number.isFinite(n))
+                out.set(n, v);
+        }
+        return out;
+    }
+    return null;
+}
+function asGenesisUint8Array(v) {
+    return v instanceof Uint8Array ? v : null;
+}
+/**
+ * Extract receipt verify key from a forest genesis document CBOR blob.
+ * Offline path: genesis-only trust anchor (ADR-0045).
+ */
+export async function decodeTrustRootFromGenesis(genesisCbor) {
+    let raw;
+    try {
+        raw = decodeCbor(genesisCbor);
+    }
+    catch {
+        throw new Error("genesis CBOR decode failed");
+    }
+    const m = decodeBodyAsIntKeyMap(raw);
+    if (!m)
+        throw new Error("genesis document must be a CBOR map");
+    const versionRaw = m.get(FOREST_GENESIS_LABEL_GENESIS_VERSION);
+    if (versionRaw === FOREST_GENESIS_SCHEMA_V2) {
+        const alg = m.get(FOREST_GENESIS_LABEL_GENESIS_ALG);
+        const bootstrapKey = asGenesisUint8Array(m.get(FOREST_GENESIS_LABEL_BOOTSTRAP_KEY));
+        if (bootstrapKey === null) {
+            throw new Error("v2 genesis missing bootstrapKey");
+        }
+        return decodeTrustRootCbor({ alg, key: bootstrapKey });
+    }
+    const kty = m.get(COSE_KEY_KTY);
+    const crv = m.get(COSE_EC2_CRV);
+    const x = asGenesisUint8Array(m.get(COSE_EC2_X));
+    const y = asGenesisUint8Array(m.get(COSE_EC2_Y));
+    if (kty === COSE_KTY_EC2 && crv === COSE_CRV_P256 && x && y) {
+        const alg = m.get(COSE_KEY_ALG);
+        if (alg !== undefined && alg !== COSE_ALG_ES256) {
+            throw new Error("genesis EC2 key must be ES256");
+        }
+        const xy = new Uint8Array(64);
+        xy.set(x, 0);
+        xy.set(y, 32);
+        return decodeTrustRootCbor({ alg: COSE_ALG_ES256, key: xy });
+    }
+    if (versionRaw === FOREST_GENESIS_SCHEMA_V1 || versionRaw === undefined) {
+        throw new Error("unsupported or invalid genesis schema for trust root");
+    }
+    throw new Error("unsupported genesis document");
+}

package/dist/forest-genesis-labels.d.ts

@@ -0,0 +1,10 @@
+export declare const FOREST_GENESIS_LABEL_GENESIS_VERSION = -68009;
+export declare const FOREST_GENESIS_LABEL_GENESIS_ALG = -68014;
+export declare const FOREST_GENESIS_LABEL_BOOTSTRAP_KEY = -68015;
+export declare const FOREST_GENESIS_LABEL_UNIVOCITY_ADDR = -68011;
+export declare const FOREST_GENESIS_LABEL_CHAIN_ID = -68013;
+export declare const FOREST_GENESIS_SCHEMA_V2 = 2;
+export declare const FOREST_GENESIS_SCHEMA_V1 = 1;
+export declare const HEADER_IDTIMESTAMP = -65537;
+export declare const HEADER_FORESTRIE_GRANT_V0 = -65538;
+//# sourceMappingURL=forest-genesis-labels.d.ts.map

package/dist/forest-genesis-labels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forest-genesis-labels.d.ts","sourceRoot":"","sources":["../src/forest-genesis-labels.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oCAAoC,SAAS,CAAC;AAC3D,eAAO,MAAM,gCAAgC,SAAS,CAAC;AACvD,eAAO,MAAM,kCAAkC,SAAS,CAAC;AACzD,eAAO,MAAM,mCAAmC,SAAS,CAAC;AAC1D,eAAO,MAAM,6BAA6B,SAAS,CAAC;AACpD,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAC1C,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C,eAAO,MAAM,kBAAkB,SAAS,CAAC;AACzC,eAAO,MAAM,yBAAyB,SAAS,CAAC"}

package/dist/forest-genesis-labels.js

@@ -0,0 +1,9 @@
+export const FOREST_GENESIS_LABEL_GENESIS_VERSION = -68009;
+export const FOREST_GENESIS_LABEL_GENESIS_ALG = -68014;
+export const FOREST_GENESIS_LABEL_BOOTSTRAP_KEY = -68015;
+export const FOREST_GENESIS_LABEL_UNIVOCITY_ADDR = -68011;
+export const FOREST_GENESIS_LABEL_CHAIN_ID = -68013;
+export const FOREST_GENESIS_SCHEMA_V2 = 2;
+export const FOREST_GENESIS_SCHEMA_V1 = 1;
+export const HEADER_IDTIMESTAMP = -65537;
+export const HEADER_FORESTRIE_GRANT_V0 = -65538;

package/dist/grant-codec.d.ts

@@ -0,0 +1,8 @@
+import type { Grant } from "./grant.js";
+export declare function decodeGrantPayload(bytes: Uint8Array): Grant;
+export declare function decodeGrantResponse(bytes: Uint8Array): {
+    grant: Grant;
+    idtimestamp: Uint8Array;
+};
+export declare function encodeGrantPayload(grant: Grant): Uint8Array;
+//# sourceMappingURL=grant-codec.d.ts.map

package/dist/grant-codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grant-codec.d.ts","sourceRoot":"","sources":["../src/grant-codec.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAuDxC,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,KAAK,CAO3D;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG;IACtD,KAAK,EAAE,KAAK,CAAC;IACb,WAAW,EAAE,UAAU,CAAC;CACzB,CAsBA;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,CAa3D"}

package/dist/grant-codec.js

@@ -0,0 +1,88 @@
+import { decode as decodeCbor, encode as encodeCbor } from "cbor-x";
+import { grantDataToBytes } from "./grant-data.js";
+import { fromPaddedWire32, toPaddedWire32 } from "./uuid-bytes.js";
+const CBOR_KEY_IDTIMESTAMP = 0;
+const CBOR_KEY_LOG_ID = 1;
+const CBOR_KEY_OWNER_LOG_ID = 2;
+const CBOR_KEY_GRANT_FLAGS = 3;
+const CBOR_KEY_MAX_HEIGHT = 4;
+const CBOR_KEY_MIN_GROWTH = 5;
+const CBOR_KEY_GRANT_DATA = 6;
+const WIRE_GRANT_FLAGS_BYTES = 8;
+const IDTIMESTAMP_BYTES = 8;
+function leftPad(b, length) {
+    if (b.length >= length) {
+        return b.length === length ? b : b.slice(-length);
+    }
+    const out = new Uint8Array(length);
+    out.set(b, length - b.length);
+    return out;
+}
+function mapToGrant(m) {
+    const get = (k) => m instanceof Map ? m.get(k) : m[k];
+    const requireBstr = (v, minLen = 0) => {
+        if (!(v instanceof Uint8Array))
+            throw new Error("Grant payload: value must be bstr");
+        if (v.length < minLen)
+            throw new Error("Grant payload: bstr too short");
+        return v;
+    };
+    const requireUint = (v) => {
+        if (typeof v === "number" && Number.isInteger(v))
+            return v;
+        if (typeof v === "bigint")
+            return Number(v);
+        throw new Error("Grant payload: expected uint");
+    };
+    return {
+        logId: fromPaddedWire32(requireBstr(get(CBOR_KEY_LOG_ID))),
+        ownerLogId: fromPaddedWire32(requireBstr(get(CBOR_KEY_OWNER_LOG_ID))),
+        grant: leftPad(requireBstr(get(CBOR_KEY_GRANT_FLAGS)), WIRE_GRANT_FLAGS_BYTES),
+        maxHeight: requireUint(get(CBOR_KEY_MAX_HEIGHT)),
+        minGrowth: requireUint(get(CBOR_KEY_MIN_GROWTH)),
+        grantData: get(CBOR_KEY_GRANT_DATA) instanceof Uint8Array
+            ? get(CBOR_KEY_GRANT_DATA)
+            : new Uint8Array(0),
+    };
+}
+export function decodeGrantPayload(bytes) {
+    if (!bytes?.length)
+        throw new Error("Grant payload is empty");
+    const raw = decodeCbor(bytes);
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        throw new Error("Grant payload must be a CBOR map");
+    }
+    return mapToGrant(raw);
+}
+export function decodeGrantResponse(bytes) {
+    const raw = decodeCbor(bytes);
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        throw new Error("Grant response must be a CBOR map");
+    }
+    const m = raw;
+    const get = (k) => m instanceof Map ? m.get(k) : m[k];
+    const idtimestampVal = get(CBOR_KEY_IDTIMESTAMP);
+    if (!(idtimestampVal instanceof Uint8Array) ||
+        idtimestampVal.length < IDTIMESTAMP_BYTES) {
+        throw new Error("Grant response: key 0 must be 8-byte bstr");
+    }
+    const idtimestamp = new Uint8Array(IDTIMESTAMP_BYTES);
+    idtimestamp.set(idtimestampVal.length === IDTIMESTAMP_BYTES
+        ? idtimestampVal
+        : idtimestampVal.slice(-IDTIMESTAMP_BYTES));
+    return { grant: mapToGrant(m), idtimestamp };
+}
+export function encodeGrantPayload(grant) {
+    const map = new Map([
+        [CBOR_KEY_LOG_ID, toPaddedWire32(grant.logId)],
+        [CBOR_KEY_OWNER_LOG_ID, toPaddedWire32(grant.ownerLogId)],
+        [CBOR_KEY_GRANT_FLAGS, leftPad(grant.grant, WIRE_GRANT_FLAGS_BYTES)],
+        [CBOR_KEY_MAX_HEIGHT, grant.maxHeight ?? 0],
+        [CBOR_KEY_MIN_GROWTH, grant.minGrowth ?? 0],
+        [
+            CBOR_KEY_GRANT_DATA,
+            grantDataToBytes(grant.grantData ?? new Uint8Array(0)),
+        ],
+    ]);
+    return new Uint8Array(encodeCbor(map));
+}

package/dist/grant-commitment.d.ts

@@ -0,0 +1,3 @@
+import type { Grant } from "./grant.js";
+export declare function grantCommitmentHashFromGrant(grant: Grant): Promise<Uint8Array>;
+//# sourceMappingURL=grant-commitment.d.ts.map

package/dist/grant-commitment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grant-commitment.d.ts","sourceRoot":"","sources":["../src/grant-commitment.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAwDxC,wBAAsB,4BAA4B,CAChD,KAAK,EAAE,KAAK,GACX,OAAO,CAAC,UAAU,CAAC,CAIrB"}

package/dist/grant-commitment.js

@@ -0,0 +1,55 @@
+import { grantDataToBytes } from "./grant-data.js";
+import { toPaddedWire32 } from "./uuid-bytes.js";
+const GRANT_FLAGS_32_BYTES = 32;
+const U64_BYTES = 8;
+function u64Be(n) {
+    const out = new Uint8Array(U64_BYTES);
+    let v = BigInt(n) & 0xffffffffffffffffn;
+    for (let i = 7; i >= 0; i--) {
+        out[i] = Number(v & 0xffn);
+        v >>= 8n;
+    }
+    return out;
+}
+function grantFlags32(flags) {
+    const out = new Uint8Array(GRANT_FLAGS_32_BYTES);
+    if (flags.length >= 8) {
+        out.set(flags.slice(-8), 24);
+    }
+    else if (flags.length > 0) {
+        out.set(flags, 32 - flags.length);
+    }
+    return out;
+}
+function grantCommitmentPreimage(grant) {
+    const logId = toPaddedWire32(grant.logId);
+    const flags32 = grantFlags32(grant.grant);
+    const maxHeight = grant.maxHeight ?? 0;
+    const minGrowth = grant.minGrowth ?? 0;
+    const ownerLogId = toPaddedWire32(grant.ownerLogId);
+    const grantData = grantDataToBytes(grant.grantData ?? new Uint8Array(0));
+    const total = logId.length +
+        flags32.length +
+        U64_BYTES * 2 +
+        ownerLogId.length +
+        grantData.length;
+    const out = new Uint8Array(total);
+    let off = 0;
+    out.set(logId, off);
+    off += logId.length;
+    out.set(flags32, off);
+    off += flags32.length;
+    out.set(u64Be(maxHeight), off);
+    off += U64_BYTES;
+    out.set(u64Be(minGrowth), off);
+    off += U64_BYTES;
+    out.set(ownerLogId, off);
+    off += ownerLogId.length;
+    out.set(grantData, off);
+    return out;
+}
+export async function grantCommitmentHashFromGrant(grant) {
+    const preimage = grantCommitmentPreimage(grant);
+    const hash = await crypto.subtle.digest("SHA-256", preimage);
+    return new Uint8Array(hash);
+}

package/dist/grant-data.d.ts

@@ -0,0 +1,7 @@
+export interface GrantDataEs256Xy {
+    readonly kind: "es256-xy";
+    readonly xy: Uint8Array;
+}
+export type GrantData = Uint8Array | GrantDataEs256Xy;
+export declare function grantDataToBytes(data: Uint8Array | GrantData): Uint8Array;
+//# sourceMappingURL=grant-data.d.ts.map

package/dist/grant-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grant-data.d.ts","sourceRoot":"","sources":["../src/grant-data.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAC;CACzB;AAED,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,gBAAgB,CAAC;AAEtD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,SAAS,GAAG,UAAU,CAIzE"}

package/dist/grant-data.js

@@ -0,0 +1,7 @@
+export function grantDataToBytes(data) {
+    if (data instanceof Uint8Array)
+        return data;
+    if (data.kind === "es256-xy")
+        return data.xy;
+    throw new Error("Unsupported GrantData variant");
+}

package/dist/grant.d.ts

@@ -0,0 +1,12 @@
+import type { GrantData } from "./grant-data.js";
+/** On-chain grant content aligned with Univocity `PublishGrant`. */
+export interface Grant {
+    logId: Uint8Array;
+    grant: Uint8Array;
+    request?: bigint;
+    maxHeight?: number;
+    minGrowth?: number;
+    ownerLogId: Uint8Array;
+    grantData: Uint8Array | GrantData;
+}
+//# sourceMappingURL=grant.d.ts.map

package/dist/grant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grant.d.ts","sourceRoot":"","sources":["../src/grant.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,oEAAoE;AACpE,MAAM,WAAW,KAAK;IACpB,KAAK,EAAE,UAAU,CAAC;IAClB,KAAK,EAAE,UAAU,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,UAAU,CAAC;IACvB,SAAS,EAAE,UAAU,GAAG,SAAS,CAAC;CACnC"}

package/dist/grant.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export type { ReceiptVerifyResult, ReceiptVerifyStage, } from "./receipt-verify-result.js";
+export type { Grant } from "./grant.js";
+export type { VerifyGrantReceiptOfflineInput } from "./verify-grant-receipt-offline.js";
+export { parseReceipt } from "./parse-receipt.js";
+export { decodeTrustRootFromGenesis } from "./decode-trust-root-from-genesis.js";
+export { verifyGrantReceiptOffline } from "./verify-grant-receipt-offline.js";
+export { decodeForestrieGrantCose } from "./decode-forestrie-grant-cose.js";
+export { decodeGrantPayload, decodeGrantResponse } from "./grant-codec.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,4BAA4B,CAAC;AACpC,YAAY,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,YAAY,EAAE,8BAA8B,EAAE,MAAM,mCAAmC,CAAC;AACxF,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,0BAA0B,EAAE,MAAM,qCAAqC,CAAC;AACjF,OAAO,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAC9E,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export { parseReceipt } from "./parse-receipt.js";
+export { decodeTrustRootFromGenesis } from "./decode-trust-root-from-genesis.js";
+export { verifyGrantReceiptOffline } from "./verify-grant-receipt-offline.js";
+export { decodeForestrieGrantCose } from "./decode-forestrie-grant-cose.js";
+export { decodeGrantPayload, decodeGrantResponse } from "./grant-codec.js";

package/dist/leaf-commitment.d.ts

@@ -0,0 +1,2 @@
+export declare function univocityLeafHash(idtimestamp: bigint | Uint8Array, grantCommitmentHash: Uint8Array): Promise<Uint8Array>;
+//# sourceMappingURL=leaf-commitment.d.ts.map

package/dist/leaf-commitment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"leaf-commitment.d.ts","sourceRoot":"","sources":["../src/leaf-commitment.ts"],"names":[],"mappings":"AAUA,wBAAsB,iBAAiB,CACrC,WAAW,EAAE,MAAM,GAAG,UAAU,EAChC,mBAAmB,EAAE,UAAU,GAC9B,OAAO,CAAC,UAAU,CAAC,CAqBrB"}

package/dist/leaf-commitment.js

@@ -0,0 +1,27 @@
+const IDTIMESTAMP_BYTES = 8;
+function writeU64BE(out, offset, value) {
+    let v = value & 0xffffffffffffffffn;
+    for (let i = 7; i >= 0; i--) {
+        out[offset + i] = Number(v & 0xffn);
+        v >>= 8n;
+    }
+}
+export async function univocityLeafHash(idtimestamp, grantCommitmentHash) {
+    const idtimestampBytes = new Uint8Array(IDTIMESTAMP_BYTES);
+    if (typeof idtimestamp === "bigint") {
+        writeU64BE(idtimestampBytes, 0, idtimestamp);
+    }
+    else {
+        if (idtimestamp.length < IDTIMESTAMP_BYTES) {
+            throw new Error("idtimestamp must be at least 8 bytes");
+        }
+        idtimestampBytes.set(idtimestamp.length > IDTIMESTAMP_BYTES
+            ? idtimestamp.slice(-IDTIMESTAMP_BYTES)
+            : idtimestamp);
+    }
+    const preimage = new Uint8Array(idtimestampBytes.length + grantCommitmentHash.length);
+    preimage.set(idtimestampBytes);
+    preimage.set(grantCommitmentHash, idtimestampBytes.length);
+    const hash = await crypto.subtle.digest("SHA-256", preimage);
+    return new Uint8Array(hash);
+}

package/dist/parse-receipt.d.ts

@@ -0,0 +1,15 @@
+import type { Proof } from "@forestrie/merklelog";
+type CoseSign1 = [
+    protectedHeader: Uint8Array,
+    unprotectedHeader: Map<number, unknown> | Record<string, unknown>,
+    payload: Uint8Array | null,
+    signature: Uint8Array
+];
+export declare function parseReceipt(receiptBytes: Uint8Array): {
+    explicitPeak: Uint8Array | null;
+    proof: Proof;
+    receiptCbor: Uint8Array;
+    coseSign1: CoseSign1;
+};
+export {};
+//# sourceMappingURL=parse-receipt.d.ts.map

package/dist/parse-receipt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-receipt.d.ts","sourceRoot":"","sources":["../src/parse-receipt.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAIlD,KAAK,SAAS,GAAG;IACf,eAAe,EAAE,UAAU;IAC3B,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACjE,OAAO,EAAE,UAAU,GAAG,IAAI;IAC1B,SAAS,EAAE,UAAU;CACtB,CAAC;AAgDF,wBAAgB,YAAY,CAAC,YAAY,EAAE,UAAU,GAAG;IACtD,YAAY,EAAE,UAAU,GAAG,IAAI,CAAC;IAChC,KAAK,EAAE,KAAK,CAAC;IACb,WAAW,EAAE,UAAU,CAAC;IACxB,SAAS,EAAE,SAAS,CAAC;CACtB,CAwDA"}