@opendatalabs/personal-server-ts-core 0.0.1-canary.00328bf

package/dist/grants/pdpp-binding.d.ts

@@ -0,0 +1,179 @@
+/**
+ * PDPP ↔ Vana chain grant binding (scope §6, "gateway binding" branch).
+ *
+ * ## What this is, and what it deliberately is not
+ *
+ * PDPP Core is chain-neutral. Vana is not: a data read is authorized by a
+ * *chain* grant (a `DataPortabilityPermissions` permission, surfaced through
+ * the Data Gateway as `GatewayGrantResponse`), while PDPP consent produces a
+ * separate *PDPP* grant (an RFC 9396 artifact with a `grant_id`, resolved
+ * streams, and frozen declaration facts). Those are two authorities over two
+ * different objects, and §7 keeps them separate on purpose.
+ *
+ * Section 6 asks for the *smallest real binding* between them. This module is
+ * that binding: a durable record asserting "PDPP grant X is the consent
+ * artifact behind chain permission Y, for owner O and grantee app A".
+ *
+ * ### Why there is no new hash protocol here
+ *
+ * An earlier proposal derived a `keccak256` "binding key" over the permission
+ * fields. That is rejected, for three reasons that matter:
+ *
+ *  1. **A sequential permission ID is not a content address.** The chain
+ *     allocates `permissionId` as a counter. Hashing it produces a value that
+ *     *looks* content-addressed while committing to nothing — a digest of an
+ *     index is still an index.
+ *  2. **Hashing a mutable grant URI does not bind grant bytes.** The on-chain
+ *     `grant` field is a URI (IPFS or HTTPS). Hashing the *URI* binds the
+ *     pointer, not the document; the document behind an HTTPS URI can change
+ *     freely afterwards. Binding actual frozen bytes would require hashing the
+ *     retrieved content, which is what the PDPP declaration digest already
+ *     does — separately, and correctly.
+ *  3. **`endBlock` is mutable, so it cannot be part of a stable identity.**
+ *     Revocation *sets* `endBlock`. A "stable identity" that changes on
+ *     revocation is not an identity; it is a status encoding wearing an
+ *     identity's clothes, and it silently breaks any record keyed by it.
+ *
+ * The chain already provides an unambiguous, durable identity — the tuple
+ * (chainId, contract address, permissionId) — and an unambiguous revocation
+ * signal. A record keyed by that identity is sufficient, so per the scope's
+ * own instruction ("do not invent a new hash protocol if a durable record
+ * keyed by existing chain permission identity suffices") we key by it and
+ * derive nothing.
+ *
+ * ### No signed struct changes
+ *
+ * Nothing here enters the EIP-712 `Grant`/`Permission` payload, so the
+ * typehash is untouched and no coordinated signer/verifier/contract rollout is
+ * triggered. That is what keeps this in the 1–2 day "gateway binding" branch
+ * rather than the 6–8 day chain-migration branch.
+ */
+import type { GatewayGrantResponse } from "@opendatalabs/vana-sdk/browser";
+/**
+ * The chain-side identity of a grant. This tuple — and not any derived digest
+ * — is the binding key.
+ *
+ * `chainId` and `contractAddress` are both required because `permissionId` is
+ * a per-deployment counter: permission 1 on Moksha and permission 1 on Vana
+ * mainnet are unrelated grants. Keying on `permissionId` alone would let a
+ * record from one network authorize a read on another.
+ */
+export interface ChainPermissionRef {
+    /** EIP-155 chain ID of the deployment that allocated `permissionId`. */
+    chainId: number;
+    /** `DataPortabilityPermissions` proxy address on that chain. */
+    contractAddress: `0x${string}`;
+    /** The on-chain permission ID, as a decimal string (uint256). */
+    permissionId: string;
+}
+/**
+ * An immutable binding between one resolved PDPP grant and one chain
+ * permission.
+ *
+ * Immutability is the point: this record is written once, at grant creation,
+ * and is never mutated — not even on revocation. Revocation is a *live* fact
+ * read from the chain grant (`revokedAt`), never a field edited here. Copying
+ * a mutable status into an immutable record is how a stale "still valid" claim
+ * survives a revocation, so the two are kept strictly apart.
+ */
+export interface PdppGrantBinding {
+    /** `grant_id` of the resolved PDPP grant (the consent artifact). */
+    pdppGrantId: string;
+    /** Chain identity of the permission that authorizes reads for this grant. */
+    permission: ChainPermissionRef;
+    /**
+     * The data owner. Must equal both the chain grant's `grantorAddress` and the
+     * PS's configured `serverOwner` at read time.
+     */
+    ownerAddress: `0x${string}`;
+    /**
+     * The grantee app's wallet address — the app's *existing* identity, carried
+     * through unchanged.
+     *
+     * §6 requires one grantee identity per Context Gateway builder/app: the
+     * PDPP `client_id`, the issued grant, the ledger grant, and the access-history
+     * grantee must all resolve to this one address. We record the address the app
+     * already has; we do not allocate one.
+     */
+    granteeAddress: `0x${string}`;
+    /** The PDPP OAuth `client_id` that the above address belongs to. */
+    pdppClientId: string;
+    /** The gateway's grantee ID for that address, as the chain grant reports it. */
+    granteeId: string;
+    /** When the binding was recorded (ISO 8601). Provenance, not status. */
+    boundAt: string;
+}
+/**
+ * Compare two chain permission references. All three components must match —
+ * see `ChainPermissionRef` for why the address and chain ID are load-bearing.
+ */
+export declare function samePermission(a: ChainPermissionRef, b: ChainPermissionRef): boolean;
+export interface CreateBindingInput {
+    pdppGrantId: string;
+    permission: ChainPermissionRef;
+    /** The PS's configured owner address. */
+    serverOwner: `0x${string}`;
+    /** The app's existing grantee wallet address. */
+    granteeAddress: `0x${string}`;
+    pdppClientId: string;
+    /** The chain grant this PDPP grant is being bound to, as the gateway reports it. */
+    chainGrant: GatewayGrantResponse;
+    now?: Date;
+}
+/**
+ * Create the binding at grant-creation time, refusing to record one that is
+ * already inconsistent.
+ *
+ * This is the *creation* boundary check. It is deliberately strict: a binding
+ * written now is trusted later, so anything we fail to verify here becomes an
+ * unverifiable assertion at read time. Specifically it rejects:
+ *
+ *  - a chain grant whose `grantorAddress` is not this server's owner (binding
+ *    another owner's grant to our PDPP consent),
+ *  - a chain grant whose `granteeId` is not the app's (binding a grant issued
+ *    to a *different* app),
+ *  - a chain grant that is already revoked (never record a dead grant as live),
+ *  - a chain grant whose id does not match the permission being bound.
+ */
+export declare function createPdppGrantBinding(input: CreateBindingInput): PdppGrantBinding;
+export interface VerifyBindingInput {
+    /** The retained, immutable binding record. */
+    binding: PdppGrantBinding;
+    /** The PDPP grant id presented by the caller. */
+    pdppGrantId: string;
+    /** The PS's configured owner address, at read time. */
+    serverOwner: `0x${string}`;
+    /** The address that signed this request (the app's grantee wallet). */
+    requestSigner: `0x${string}`;
+    /**
+     * The chain grant as read *now*. Revocation is read live from here; it is
+     * never taken from the binding record.
+     */
+    chainGrant: GatewayGrantResponse | null;
+    /** The deployment the PS is configured against, at read time. */
+    deployment: {
+        chainId: number;
+        contractAddress: `0x${string}`;
+    };
+}
+/**
+ * Verify a binding at read time.
+ *
+ * Every axis §6 names is checked against the *retained* binding, so a
+ * mismatch on any one of owner, app, chain, contract, or record fails closed:
+ *
+ *  - **record**: the presented PDPP grant id must be the one bound,
+ *  - **chain/contract**: the binding's deployment must be the one the PS is
+ *    configured against (a Moksha binding cannot authorize a mainnet read),
+ *  - **owner**: the binding's owner must still be this server's owner, and the
+ *    live chain grant's grantor must agree,
+ *  - **app**: the request signer must be the bound grantee address, and the
+ *    live chain grant must still name that grantee,
+ *  - **revocation**: the live chain grant must exist and be unrevoked.
+ *
+ * No chain I/O happens in this function — the caller supplies the already-read
+ * `chainGrant`. That keeps this usable on the hot read path without adding a
+ * network round trip per request.
+ */
+export declare function verifyPdppGrantBinding(input: VerifyBindingInput): void;
+//# sourceMappingURL=pdpp-binding.d.ts.map

package/dist/grants/pdpp-binding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdpp-binding.d.ts","sourceRoot":"","sources":["../../src/grants/pdpp-binding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AASH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAE3E;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB;IACjC,wEAAwE;IACxE,OAAO,EAAE,MAAM,CAAC;IAChB,gEAAgE;IAChE,eAAe,EAAE,KAAK,MAAM,EAAE,CAAC;IAC/B,iEAAiE;IACjE,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,gBAAgB;IAC/B,oEAAoE;IACpE,WAAW,EAAE,MAAM,CAAC;IACpB,6EAA6E;IAC7E,UAAU,EAAE,kBAAkB,CAAC;IAC/B;;;OAGG;IACH,YAAY,EAAE,KAAK,MAAM,EAAE,CAAC;IAC5B;;;;;;;;OAQG;IACH,cAAc,EAAE,KAAK,MAAM,EAAE,CAAC;IAC9B,oEAAoE;IACpE,YAAY,EAAE,MAAM,CAAC;IACrB,gFAAgF;IAChF,SAAS,EAAE,MAAM,CAAC;IAClB,wEAAwE;IACxE,OAAO,EAAE,MAAM,CAAC;CACjB;AAOD;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,kBAAkB,EACrB,CAAC,EAAE,kBAAkB,GACpB,OAAO,CAMT;AAED,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,kBAAkB,CAAC;IAC/B,yCAAyC;IACzC,WAAW,EAAE,KAAK,MAAM,EAAE,CAAC;IAC3B,iDAAiD;IACjD,cAAc,EAAE,KAAK,MAAM,EAAE,CAAC;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,oFAAoF;IACpF,UAAU,EAAE,oBAAoB,CAAC;IACjC,GAAG,CAAC,EAAE,IAAI,CAAC;CACZ;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,kBAAkB,GACxB,gBAAgB,CA0ClB;AAED,MAAM,WAAW,kBAAkB;IACjC,8CAA8C;IAC9C,OAAO,EAAE,gBAAgB,CAAC;IAC1B,iDAAiD;IACjD,WAAW,EAAE,MAAM,CAAC;IACpB,uDAAuD;IACvD,WAAW,EAAE,KAAK,MAAM,EAAE,CAAC;IAC3B,uEAAuE;IACvE,aAAa,EAAE,KAAK,MAAM,EAAE,CAAC;IAC7B;;;OAGG;IACH,UAAU,EAAE,oBAAoB,GAAG,IAAI,CAAC;IACxC,iEAAiE;IACjE,UAAU,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,eAAe,EAAE,KAAK,MAAM,EAAE,CAAA;KAAE,CAAC;CACjE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,IAAI,CAuFtE"}

package/dist/grants/pdpp-binding.js

@@ -0,0 +1,214 @@
+/**
+ * PDPP ↔ Vana chain grant binding (scope §6, "gateway binding" branch).
+ *
+ * ## What this is, and what it deliberately is not
+ *
+ * PDPP Core is chain-neutral. Vana is not: a data read is authorized by a
+ * *chain* grant (a `DataPortabilityPermissions` permission, surfaced through
+ * the Data Gateway as `GatewayGrantResponse`), while PDPP consent produces a
+ * separate *PDPP* grant (an RFC 9396 artifact with a `grant_id`, resolved
+ * streams, and frozen declaration facts). Those are two authorities over two
+ * different objects, and §7 keeps them separate on purpose.
+ *
+ * Section 6 asks for the *smallest real binding* between them. This module is
+ * that binding: a durable record asserting "PDPP grant X is the consent
+ * artifact behind chain permission Y, for owner O and grantee app A".
+ *
+ * ### Why there is no new hash protocol here
+ *
+ * An earlier proposal derived a `keccak256` "binding key" over the permission
+ * fields. That is rejected, for three reasons that matter:
+ *
+ *  1. **A sequential permission ID is not a content address.** The chain
+ *     allocates `permissionId` as a counter. Hashing it produces a value that
+ *     *looks* content-addressed while committing to nothing — a digest of an
+ *     index is still an index.
+ *  2. **Hashing a mutable grant URI does not bind grant bytes.** The on-chain
+ *     `grant` field is a URI (IPFS or HTTPS). Hashing the *URI* binds the
+ *     pointer, not the document; the document behind an HTTPS URI can change
+ *     freely afterwards. Binding actual frozen bytes would require hashing the
+ *     retrieved content, which is what the PDPP declaration digest already
+ *     does — separately, and correctly.
+ *  3. **`endBlock` is mutable, so it cannot be part of a stable identity.**
+ *     Revocation *sets* `endBlock`. A "stable identity" that changes on
+ *     revocation is not an identity; it is a status encoding wearing an
+ *     identity's clothes, and it silently breaks any record keyed by it.
+ *
+ * The chain already provides an unambiguous, durable identity — the tuple
+ * (chainId, contract address, permissionId) — and an unambiguous revocation
+ * signal. A record keyed by that identity is sufficient, so per the scope's
+ * own instruction ("do not invent a new hash protocol if a durable record
+ * keyed by existing chain permission identity suffices") we key by it and
+ * derive nothing.
+ *
+ * ### No signed struct changes
+ *
+ * Nothing here enters the EIP-712 `Grant`/`Permission` payload, so the
+ * typehash is untouched and no coordinated signer/verifier/contract rollout is
+ * triggered. That is what keeps this in the 1–2 day "gateway binding" branch
+ * rather than the 6–8 day chain-migration branch.
+ */
+import { GrantOwnerMismatchError, GrantRevokedError, InvalidSignatureError, ScopeMismatchError, } from "../errors/catalog.js";
+/** Normalizes an address for comparison. Addresses are case-insensitive. */
+function sameAddress(a, b) {
+    return typeof a === "string" && a.toLowerCase() === b.toLowerCase();
+}
+/**
+ * Compare two chain permission references. All three components must match —
+ * see `ChainPermissionRef` for why the address and chain ID are load-bearing.
+ */
+export function samePermission(a, b) {
+    return (a.chainId === b.chainId &&
+        a.contractAddress.toLowerCase() === b.contractAddress.toLowerCase() &&
+        a.permissionId === b.permissionId);
+}
+/**
+ * Create the binding at grant-creation time, refusing to record one that is
+ * already inconsistent.
+ *
+ * This is the *creation* boundary check. It is deliberately strict: a binding
+ * written now is trusted later, so anything we fail to verify here becomes an
+ * unverifiable assertion at read time. Specifically it rejects:
+ *
+ *  - a chain grant whose `grantorAddress` is not this server's owner (binding
+ *    another owner's grant to our PDPP consent),
+ *  - a chain grant whose `granteeId` is not the app's (binding a grant issued
+ *    to a *different* app),
+ *  - a chain grant that is already revoked (never record a dead grant as live),
+ *  - a chain grant whose id does not match the permission being bound.
+ */
+export function createPdppGrantBinding(input) {
+    const { chainGrant, serverOwner, granteeAddress, permission } = input;
+    if (chainGrant.id !== permission.permissionId) {
+        throw new InvalidSignatureError({
+            reason: "Chain grant id does not match the permission being bound",
+            expected: permission.permissionId,
+            actual: chainGrant.id,
+        });
+    }
+    if (!sameAddress(chainGrant.grantorAddress, serverOwner)) {
+        throw new GrantOwnerMismatchError({
+            grantId: chainGrant.id,
+            expected: serverOwner,
+            actual: chainGrant.grantorAddress ?? null,
+        });
+    }
+    // Bind to the app's EXISTING grantee identity. If the chain grant was issued
+    // to a different grantee, this PDPP consent does not describe it.
+    if (!sameAddress(chainGrant.granteeId, granteeAddress)) {
+        throw new InvalidSignatureError({
+            reason: "Chain grant grantee does not match the app's grantee address",
+            expected: granteeAddress,
+            actual: chainGrant.granteeId,
+        });
+    }
+    if (chainGrant.revokedAt !== null && chainGrant.revokedAt !== undefined) {
+        throw new GrantRevokedError({ grantId: chainGrant.id });
+    }
+    return Object.freeze({
+        pdppGrantId: input.pdppGrantId,
+        permission,
+        ownerAddress: serverOwner,
+        granteeAddress,
+        pdppClientId: input.pdppClientId,
+        granteeId: chainGrant.granteeId,
+        boundAt: (input.now ?? new Date()).toISOString(),
+    });
+}
+/**
+ * Verify a binding at read time.
+ *
+ * Every axis §6 names is checked against the *retained* binding, so a
+ * mismatch on any one of owner, app, chain, contract, or record fails closed:
+ *
+ *  - **record**: the presented PDPP grant id must be the one bound,
+ *  - **chain/contract**: the binding's deployment must be the one the PS is
+ *    configured against (a Moksha binding cannot authorize a mainnet read),
+ *  - **owner**: the binding's owner must still be this server's owner, and the
+ *    live chain grant's grantor must agree,
+ *  - **app**: the request signer must be the bound grantee address, and the
+ *    live chain grant must still name that grantee,
+ *  - **revocation**: the live chain grant must exist and be unrevoked.
+ *
+ * No chain I/O happens in this function — the caller supplies the already-read
+ * `chainGrant`. That keeps this usable on the hot read path without adding a
+ * network round trip per request.
+ */
+export function verifyPdppGrantBinding(input) {
+    const { binding, chainGrant, deployment } = input;
+    // Record binding: the consent artifact presented must be the bound one.
+    if (binding.pdppGrantId !== input.pdppGrantId) {
+        throw new ScopeMismatchError({
+            requestedScope: "pdpp:binding",
+            reason: "PDPP grant id does not match the binding record",
+            expected: binding.pdppGrantId,
+            actual: input.pdppGrantId,
+        });
+    }
+    // Chain/contract binding: a record from another deployment is not evidence
+    // here, because permissionId is only unique within one deployment.
+    if (binding.permission.chainId !== deployment.chainId ||
+        binding.permission.contractAddress.toLowerCase() !==
+            deployment.contractAddress.toLowerCase()) {
+        throw new ScopeMismatchError({
+            requestedScope: "pdpp:binding",
+            reason: "Binding is for a different chain deployment",
+            expected: `${deployment.chainId}:${deployment.contractAddress}`,
+            actual: `${binding.permission.chainId}:${binding.permission.contractAddress}`,
+        });
+    }
+    // Owner binding, against the server's current configuration.
+    if (!sameAddress(binding.ownerAddress, input.serverOwner)) {
+        throw new GrantOwnerMismatchError({
+            grantId: binding.permission.permissionId,
+            expected: input.serverOwner,
+            actual: binding.ownerAddress,
+        });
+    }
+    // App binding: the caller must BE the bound grantee, not merely know its id.
+    if (!sameAddress(input.requestSigner, binding.granteeAddress)) {
+        throw new InvalidSignatureError({
+            reason: "Request signer is not the bound grantee for this PDPP grant",
+            expected: binding.granteeAddress,
+            actual: input.requestSigner,
+        });
+    }
+    // Revocation is read live. A missing chain grant is treated as revoked
+    // rather than as "unknown": failing open here would let a deleted or
+    // unreachable permission authorize reads.
+    if (!chainGrant) {
+        throw new GrantRevokedError({
+            grantId: binding.permission.permissionId,
+            reason: "Chain grant not found",
+        });
+    }
+    if (chainGrant.id !== binding.permission.permissionId) {
+        throw new ScopeMismatchError({
+            requestedScope: "pdpp:binding",
+            reason: "Chain grant id does not match the binding record",
+            expected: binding.permission.permissionId,
+            actual: chainGrant.id,
+        });
+    }
+    if (chainGrant.revokedAt !== null && chainGrant.revokedAt !== undefined) {
+        throw new GrantRevokedError({ grantId: chainGrant.id });
+    }
+    // The live chain grant must still agree with the binding on both parties.
+    // These can diverge from the record only if the gateway is serving a
+    // different grant under the same id, which we must not paper over.
+    if (!sameAddress(chainGrant.grantorAddress, binding.ownerAddress)) {
+        throw new GrantOwnerMismatchError({
+            grantId: chainGrant.id,
+            expected: binding.ownerAddress,
+            actual: chainGrant.grantorAddress ?? null,
+        });
+    }
+    if (!sameAddress(chainGrant.granteeId, binding.granteeAddress)) {
+        throw new InvalidSignatureError({
+            reason: "Chain grant grantee no longer matches the bound grantee",
+            expected: binding.granteeAddress,
+            actual: chainGrant.granteeId,
+        });
+    }
+}
+//# sourceMappingURL=pdpp-binding.js.map

package/dist/grants/pdpp-binding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdpp-binding.js","sourceRoot":"","sources":["../../src/grants/pdpp-binding.ts"],"names":[],"mappings":"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"}

package/dist/keys/index.d.ts

@@ -0,0 +1,3 @@
+export type { KeyFileData, ServerAccount, SignTypedDataParams, } from "./server-account.js";
+export { createPublicOnlyAccount, type PublicOnlyAccountInput, } from "./public-only-account.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/keys/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,WAAW,EACX,aAAa,EACb,mBAAmB,GACpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,uBAAuB,EACvB,KAAK,sBAAsB,GAC5B,MAAM,0BAA0B,CAAC"}

package/dist/keys/index.js

@@ -0,0 +1,2 @@
+export { createPublicOnlyAccount, } from "./public-only-account.js";
+//# sourceMappingURL=index.js.map

package/dist/keys/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/keys/index.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,uBAAuB,GAExB,MAAM,0BAA0B,CAAC"}

package/dist/keys/public-only-account.d.ts

@@ -0,0 +1,8 @@
+import { type Address, type Hex } from "viem";
+import type { ServerAccount } from "./server-account.js";
+export interface PublicOnlyAccountInput {
+    address: Address;
+    publicKey: Hex;
+}
+export declare function createPublicOnlyAccount(input: PublicOnlyAccountInput): ServerAccount;
+//# sourceMappingURL=public-only-account.d.ts.map

package/dist/keys/public-only-account.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-only-account.d.ts","sourceRoot":"","sources":["../../src/keys/public-only-account.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,MAAM,CAAC;AAG9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAIzD,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,GAAG,CAAC;CAChB;AAED,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,sBAAsB,GAC5B,aAAa,CAgBf"}

package/dist/keys/public-only-account.js

@@ -0,0 +1,21 @@
+import { isAddressEqual } from "viem";
+import { publicKeyToAddress } from "viem/accounts";
+import { ServerSigningUnavailableError } from "../errors/catalog.js";
+const KEY_MISMATCH_MESSAGE = "Public key does not match server address";
+export function createPublicOnlyAccount(input) {
+    const derivedAddress = publicKeyToAddress(input.publicKey);
+    if (!isAddressEqual(derivedAddress, input.address)) {
+        throw new Error(KEY_MISMATCH_MESSAGE);
+    }
+    return {
+        address: input.address,
+        publicKey: input.publicKey,
+        async signTypedData() {
+            throw new ServerSigningUnavailableError();
+        },
+        async signMessage() {
+            throw new ServerSigningUnavailableError();
+        },
+    };
+}
+//# sourceMappingURL=public-only-account.js.map

package/dist/keys/public-only-account.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-only-account.js","sourceRoot":"","sources":["../../src/keys/public-only-account.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAA0B,MAAM,MAAM,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,6BAA6B,EAAE,MAAM,sBAAsB,CAAC;AAGrE,MAAM,oBAAoB,GAAG,0CAA0C,CAAC;AAOxE,MAAM,UAAU,uBAAuB,CACrC,KAA6B;IAE7B,MAAM,cAAc,GAAG,kBAAkB,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IAC3D,IAAI,CAAC,cAAc,CAAC,cAAc,EAAE,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;QACnD,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC;IACxC,CAAC;IAED,OAAO;QACL,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,KAAK,CAAC,aAAa;YACjB,MAAM,IAAI,6BAA6B,EAAE,CAAC;QAC5C,CAAC;QACD,KAAK,CAAC,WAAW;YACf,MAAM,IAAI,6BAA6B,EAAE,CAAC;QAC5C,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/keys/server-account.d.ts

@@ -0,0 +1,24 @@
+import type { TypedDataDomain } from "viem";
+export interface SignTypedDataParams {
+    domain: TypedDataDomain;
+    types: Record<string, readonly {
+        name: string;
+        type: string;
+    }[]>;
+    primaryType: string;
+    message: Record<string, unknown>;
+}
+export interface ServerAccount {
+    address: `0x${string}`;
+    /** Uncompressed public key (65 bytes, 0x04 prefix). */
+    publicKey: `0x${string}`;
+    signTypedData(params: SignTypedDataParams): Promise<`0x${string}`>;
+    /** Sign a personal message (EIP-191). */
+    signMessage(message: string): Promise<`0x${string}`>;
+}
+export interface KeyFileData {
+    address: string;
+    publicKey: string;
+    privateKey: string;
+}
+//# sourceMappingURL=server-account.d.ts.map

package/dist/keys/server-account.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-account.d.ts","sourceRoot":"","sources":["../../src/keys/server-account.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,MAAM,CAAC;AAE5C,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,eAAe,CAAC;IAIxB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC,CAAC;IACjE,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,KAAK,MAAM,EAAE,CAAC;IACvB,uDAAuD;IACvD,SAAS,EAAE,KAAK,MAAM,EAAE,CAAC;IACzB,aAAa,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,KAAK,MAAM,EAAE,CAAC,CAAC;IACnE,yCAAyC;IACzC,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,MAAM,EAAE,CAAC,CAAC;CACtD;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB"}

package/dist/keys/server-account.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=server-account.js.map

package/dist/keys/server-account.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-account.js","sourceRoot":"","sources":["../../src/keys/server-account.ts"],"names":[],"mappings":""}

package/dist/lineage/attestation.d.ts

@@ -0,0 +1,42 @@
+/**
+ * LineageAttestation: the server-signed statement that binds a derivative's
+ * lineage to the version it is registered with.
+ *
+ * The on-chain AddData struct is unchanged and `dataHash` (keccak256 of the
+ * plaintext envelope, `$lineage` included) already commits to the lineage.
+ * The gateway cannot open that commitment, so the plaintext source list it
+ * stores next to the registration needs its own proof of authorship: the
+ * AddData signature is public in every gateway attestation, so without one
+ * anybody could replay a registration as a same-version refresh carrying a
+ * different lineage. The attestation is EIP-712 under the DataRegistry
+ * domain (same as AddData), signed by the owner or a registered server,
+ * and bound to the exact version and dataHash so it cannot be moved to
+ * another registration either.
+ */
+export declare const LINEAGE_ATTESTATION_TYPES: {
+    readonly LineageAttestation: readonly [{
+        readonly name: "ownerAddress";
+        readonly type: "address";
+    }, {
+        readonly name: "scope";
+        readonly type: "string";
+    }, {
+        readonly name: "expectedVersion";
+        readonly type: "uint256";
+    }, {
+        readonly name: "dataHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "sources";
+        readonly type: "bytes32[]";
+    }];
+};
+export interface LineageAttestationMessage {
+    ownerAddress: `0x${string}`;
+    scope: string;
+    expectedVersion: bigint;
+    dataHash: `0x${string}`;
+    /** Lowercase source data point ids in the registered order. */
+    sources: readonly `0x${string}`[];
+}
+//# sourceMappingURL=attestation.d.ts.map

package/dist/lineage/attestation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attestation.d.ts","sourceRoot":"","sources":["../../src/lineage/attestation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;CAQ5B,CAAC;AAEX,MAAM,WAAW,yBAAyB;IACxC,YAAY,EAAE,KAAK,MAAM,EAAE,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,KAAK,MAAM,EAAE,CAAC;IACxB,+DAA+D;IAC/D,OAAO,EAAE,SAAS,KAAK,MAAM,EAAE,EAAE,CAAC;CACnC"}

package/dist/lineage/attestation.js

@@ -0,0 +1,25 @@
+/**
+ * LineageAttestation: the server-signed statement that binds a derivative's
+ * lineage to the version it is registered with.
+ *
+ * The on-chain AddData struct is unchanged and `dataHash` (keccak256 of the
+ * plaintext envelope, `$lineage` included) already commits to the lineage.
+ * The gateway cannot open that commitment, so the plaintext source list it
+ * stores next to the registration needs its own proof of authorship: the
+ * AddData signature is public in every gateway attestation, so without one
+ * anybody could replay a registration as a same-version refresh carrying a
+ * different lineage. The attestation is EIP-712 under the DataRegistry
+ * domain (same as AddData), signed by the owner or a registered server,
+ * and bound to the exact version and dataHash so it cannot be moved to
+ * another registration either.
+ */
+export const LINEAGE_ATTESTATION_TYPES = {
+    LineageAttestation: [
+        { name: "ownerAddress", type: "address" },
+        { name: "scope", type: "string" },
+        { name: "expectedVersion", type: "uint256" },
+        { name: "dataHash", type: "bytes32" },
+        { name: "sources", type: "bytes32[]" },
+    ],
+};
+//# sourceMappingURL=attestation.js.map

package/dist/lineage/attestation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attestation.js","sourceRoot":"","sources":["../../src/lineage/attestation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,kBAAkB,EAAE;QAClB,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,SAAS,EAAE;QACzC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE;QACjC,EAAE,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE,SAAS,EAAE;QAC5C,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE;QACrC,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,WAAW,EAAE;KACvC;CACO,CAAC"}