@oxyhq/contracts 0.6.0 → 0.8.0

package/dist/esm/deviceSession.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+export const sessionAccountSchema = z.object({
+    accountId: z.string(),
+    sessionId: z.string(),
+    authuser: z.number().int().nonnegative(),
+    operatedByUserId: z.string().optional(),
+});
+export const deviceSessionStateSchema = z.object({
+    deviceId: z.string(),
+    accounts: z.array(sessionAccountSchema),
+    activeAccountId: z.string().nullable(),
+    revision: z.number().int().nonnegative(),
+    updatedAt: z.number(),
+});
+export const activeTokenSchema = z.object({
+    accessToken: z.string(),
+    expiresAt: z.string(),
+});
+export const deviceSessionSyncSchema = z.object({
+    state: deviceSessionStateSchema,
+    activeToken: activeTokenSchema.nullable(),
+});

package/dist/esm/fedcmToken.js

@@ -42,5 +42,12 @@ export const fedcmTokenPayloadSchema = z
     exp: z.number().optional(),
     iat: z.number().optional(),
     nonce: z.string().optional(),
+    /**
+     * An explicit central deviceId minted by the IdP, threaded through so the
+     * RP session can inherit a unified device id instead of deriving one from
+     * the (userId, RP origin) stableDeviceKey. Optional and additive — omitted
+     * tokens fall back to the existing stableDeviceKey/UA-IP derivation.
+     */
+    deviceId: z.string().optional(),
 })
     .passthrough();

package/dist/esm/identity.js

@@ -38,12 +38,27 @@
  * `require()`).
  */
 import { z } from 'zod';
-export const verificationMethodSchema = z.object({
+// The option schemas are left UN-annotated so they keep their concrete
+// `ZodObject` type — `z.discriminatedUnion` requires object options and an
+// explicit `z.ZodType<>` annotation would erase the shape it discriminates on.
+// `z.object` already infers each option's type exactly (id/type/controller +
+// the key field), so the union is structurally `VerificationMethod`.
+const secp256k1VerificationMethodSchema = z.object({
     id: z.string(),
     type: z.literal('EcdsaSecp256k1VerificationKey2019'),
     controller: z.string(),
     publicKeyHex: z.string(),
 });
+const multikeyVerificationMethodSchema = z.object({
+    id: z.string(),
+    type: z.literal('Multikey'),
+    controller: z.string(),
+    publicKeyMultibase: z.string(),
+});
+export const verificationMethodSchema = z.discriminatedUnion('type', [
+    secp256k1VerificationMethodSchema,
+    multikeyVerificationMethodSchema,
+]);
 export const didServiceSchema = z.object({
     id: z.string(),
     type: z.string(),
@@ -62,16 +77,9 @@ export const didDocumentSchema = z.object({
 export const signedRecordEnvelopeSchema = z
     .object({
     version: z.union([z.literal(1), z.literal(2)]),
-    type: z.enum([
-        'identity',
-        'profile',
-        'reputation_attestation',
-        'real_life_attestation',
-        'validation_verdict',
-        'personhood_vouch',
-        'credential',
-        'node',
-    ]),
+    // Open, app-defined category (see the `type` doc above). The Oxy STORE
+    // re-narrows to `oxySignedRecordTypeSchema`; an app to its own constant.
+    type: z.string().min(1),
     subject: z.string(),
     issuer: z.string(),
     record: z.record(z.unknown()),

package/dist/esm/index.js

@@ -28,9 +28,16 @@ export {
 verificationMethodSchema, didServiceSchema, didDocumentSchema, signedRecordEnvelopeSchema, verifiedDomainSchema, domainVerificationRequestSchema, domainVerificationInstructionsSchema, authMethodEntrySchema, authMethodsResponseSchema, exportAttestationSchema, exportBundleSchema, } from './identity.js';
 export { 
 // Schemas
+oxySignedRecordTypeSchema, } from './oxyRecordTypes.js';
+export { 
+// Schemas
+chainHeadResponseSchema, logPageResponseSchema, } from './protocol.js';
+export { 
+// Schemas
 publicCardSchema, signedPublicCardSchema, realLifeAttestationRecordSchema, realLifeAttestationResultSchema, validationVerdictRecordSchema, validationOpenRequestSchema, validationOpenResultSchema, validationRequestSummarySchema, validationVoteResultSchema, personhoodVouchRecordSchema, personhoodBreakdownSchema, personhoodStatusResultSchema, vouchResultSchema, 
 // Verifiable Credentials (Fase 4 — NEW)
 credentialRecordSchema, verifiableCredentialResponseSchema, credentialIssueResultSchema, credentialListResultSchema, credentialVerifyResultSchema, } from './civic.js';
 export { 
 // Schemas
 linkPreviewSchema, linkPreviewBatchRequestSchema, linkPreviewBatchResponseSchema, linkPreviewResponseSchema, } from './links.js';
+export { sessionAccountSchema, deviceSessionStateSchema, activeTokenSchema, deviceSessionSyncSchema, } from './deviceSession.js';

package/dist/esm/oxyRecordTypes.js

@@ -0,0 +1,37 @@
+/**
+ * Oxy-scoped signed-record types.
+ *
+ * The base `signedRecordEnvelopeSchema` (`./identity`) now treats `type` as an
+ * OPEN, non-empty string so ANY Oxy app may define its own record categories
+ * (e.g. `app.mention.*`'s `app_record`) on the shared envelope grammar. The Oxy
+ * identity/civic/node STORE, however, accepts ONLY the closed set of categories
+ * it knows how to verify and materialize — this module is that closed set.
+ *
+ * `oxySignedRecordTypeSchema` is the runtime gate the Oxy store re-narrows with
+ * (the API's `verifyEnvelope` rejects any `type` outside it; the Mongoose
+ * `SignedRecord.type` enum is derived from `.options`); `OxySignedRecordType` is
+ * the matching compile-time union the SDK identity/civic mixins type against.
+ *
+ * The signing input INCLUDES `type`, so this set is part of the signed bytes —
+ * a record cannot have its category swapped after signing.
+ *
+ * v1 only ever carried `identity` / `profile` (already in production); v2 added
+ * the civic record types (reputation attestations, real-life / peer validations,
+ * personhood vouches, verifiable credentials) and the user-node registration
+ * record. Every value here is an Oxy `app.oxy.*` (or legacy v1) category — an
+ * app's own `type` (e.g. `app_record`) is intentionally NOT in this set and is
+ * rejected by the Oxy store.
+ *
+ * Platform-agnostic — zod only, no react/react-native/expo, ESM-safe.
+ */
+import { z } from 'zod';
+export const oxySignedRecordTypeSchema = z.enum([
+    'identity',
+    'profile',
+    'reputation_attestation',
+    'real_life_attestation',
+    'validation_verdict',
+    'personhood_vouch',
+    'credential',
+    'node',
+]);

package/dist/esm/protocol.js

@@ -0,0 +1,50 @@
+/**
+ * Generic "Oxy Protocol" record surface — the app-agnostic conventions every app
+ * follows to decentralize its own content on the shared signed-record substrate.
+ *
+ * The base `signedRecordEnvelopeSchema` (`./identity`) is the WIRE grammar: a
+ * signed envelope whose `type` is an open string and whose `record` is an opaque
+ * `Record<string, unknown>`. An app layers its own LEXICON on top of that
+ * grammar — a typed projection of the `record` payload, addressed by an
+ * AtProto-style `(collection, rkey)` key — WITHOUT forking the envelope schema.
+ *
+ * ## Recipe — defining an app lexicon record
+ *
+ * For each record kind an app wants to publish:
+ *
+ * 1. Define the `record` PAYLOAD schema as a `z.ZodType<XPayload>` (e.g.
+ *    `app.mention.feed.post` → `mentionPostRecordSchema: z.ZodType<MentionPost>`).
+ *    This validates ONLY the inner `record`, not the envelope.
+ * 2. Declare the `collection` NSID as a constant (e.g.
+ *    `export const MENTION_POST_COLLECTION = 'app.mention.feed.post'`).
+ * 3. Reuse the UNCHANGED {@link signedRecordEnvelopeSchema} for the envelope. The
+ *    base treats `record` as `z.record(z.unknown())`, so the app validates the
+ *    envelope with the base schema first, then parses `envelope.record` with its
+ *    own payload schema. {@link LexiconRecord} is the typed projection that pairs
+ *    the `(collection, rkey)` key with the parsed payload.
+ *
+ * The Oxy civic contracts (`./civic`) already follow this convention implicitly:
+ * each civic record (`real_life_attestation`, `personhood_vouch`, `credential`,
+ * …) ships a `record`-payload schema and is carried by the base envelope.
+ *
+ * ## Chain-wire shapes
+ *
+ * {@link ChainHeadResponse} and {@link LogPageResponse} are the shared response
+ * shapes every chain store exposes (Oxy's `GET /identity/records/:userId/chain/head`,
+ * `GET /identity/head/:userId`, `GET /identity/log/:userId`, and any app node's
+ * equivalents). They are defined ONCE here so producers and consumers (the API
+ * handlers, the SDK identity/nodes mixins, app nodes) cannot drift.
+ *
+ * Platform-agnostic — zod only, no react/react-native/expo, ESM-safe.
+ */
+import { z } from 'zod';
+import { signedRecordEnvelopeSchema } from './identity.js';
+export const chainHeadResponseSchema = z.object({
+    headRecordId: z.string().nullable(),
+    seq: z.number().int(),
+    recordCount: z.number().int().nonnegative(),
+});
+export const logPageResponseSchema = z.object({
+    records: z.array(signedRecordEnvelopeSchema),
+    count: z.number().int().nonnegative(),
+});