@stasho/vf-records 0.1.0 → 0.2.0

package/dist/client-check.d.ts

@@ -8,6 +8,10 @@ export type ExpectedRecord = {
     kind: "transfer";
     domain: string;
     newVault: string;
+} | {
+    kind: "accept";
+    domain: string;
+    transfer: string;
 };
 export type CheckResult = {
     ok: true;

package/dist/client-check.js

@@ -53,6 +53,9 @@ export function checkPreparedMessage(args) {
     if (record.kind === "transfer" && args.expected.kind === "transfer" && record.newVault !== args.expected.newVault) {
         return refuse(`transfer target ${record.newVault} differs from ${args.expected.newVault}`);
     }
+    if (record.kind === "accept" && args.expected.kind === "accept" && record.transfer !== args.expected.transfer) {
+        return refuse(`accept names transfer ${record.transfer}, you asked for ${args.expected.transfer}`);
+    }
     const t = Date.parse(record.ts);
     if (!Number.isFinite(t) || Math.abs(t - args.now) > CLIENT_CHECK_SKEW_MS)
         return refuse("record timestamp is more than 10 minutes from this clock");

package/dist/records.d.ts

@@ -51,6 +51,26 @@ export type VfRecord = {
     vault: string;
     op: "bind" | "unbind";
     ts: string;
+}
+/**
+ * Signed by the INCOMING authority of a pending transfer, naming the
+ * transfer transaction it accepts. Bound to that signature so it is
+ * single-use by construction: a rejected transfer's acceptance cannot be
+ * replayed on a later request to the same key (spec § 2, Decision #446).
+ */
+ | {
+    kind: "accept";
+    domain: string;
+    transfer: string;
+    ts: string;
 };
 export declare function parsePayload(payload: string): VfRecord | null;
+/**
+ * Parses a record the way the backend index STORES it: the decoded
+ * `VfRecord` as JSON (`{"kind":"pub","domain":…}`), not the raw memo text.
+ * Validation is delegated to `parsePayload` by re-encoding the candidate, so
+ * there is exactly one validator; every field must be a string for the
+ * re-encode to be faithful.
+ */
+export declare function parseStoredRecord(json: string): VfRecord | null;
 export declare function encodeRecord(record: VfRecord): string;

package/dist/records.js

@@ -103,8 +103,37 @@ export function parsePayload(payload) {
             return null;
         return { kind: "bind", domain, vault, op, ts };
     }
+    if (kind === "accept") {
+        const transfer = str("transfer");
+        return transfer ? { kind: "accept", domain, transfer, ts } : null;
+    }
     return null;
 }
+const RECORD_KINDS = new Set(["pub", "transfer", "bind", "accept"]);
+/**
+ * Parses a record the way the backend index STORES it: the decoded
+ * `VfRecord` as JSON (`{"kind":"pub","domain":…}`), not the raw memo text.
+ * Validation is delegated to `parsePayload` by re-encoding the candidate, so
+ * there is exactly one validator; every field must be a string for the
+ * re-encode to be faithful.
+ */
+export function parseStoredRecord(json) {
+    let candidate;
+    try {
+        candidate = JSON.parse(json);
+    }
+    catch {
+        return null;
+    }
+    if (typeof candidate !== "object" || candidate === null)
+        return null;
+    const fields = candidate;
+    if (!RECORD_KINDS.has(fields["kind"]))
+        return null;
+    if (!Object.values(fields).every((v) => typeof v === "string"))
+        return null;
+    return parsePayload(encodeRecord(fields));
+}
 export function encodeRecord(record) {
     if (record.kind === "pub") {
         return `${VF_PREFIX}pub:${JSON.stringify({
@@ -116,6 +145,11 @@ export function encodeRecord(record) {
             d: record.domain, newVault: record.newVault, t: record.ts,
         })}`;
     }
+    if (record.kind === "accept") {
+        return `${VF_PREFIX}accept:${JSON.stringify({
+            d: record.domain, transfer: record.transfer, t: record.ts,
+        })}`;
+    }
     return `${VF_PREFIX}bind:${JSON.stringify({
         d: record.domain, vault: record.vault, op: record.op, t: record.ts,
     })}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stasho/vf-records",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Stasho Verified Frontends record codec + the client-side check of a prepared publish message. Zero dependencies, browser-safe.",
   "license": "MIT",
   "type": "module",