@bsv/vsc 0.2.0-beta.1

package/dist/jcs.js

@@ -0,0 +1,67 @@
+/**
+ * RFC 8785, the JSON Canonicalization Scheme, as one small exact function.
+ *
+ * Object members are sorted by the UTF-16 code units of their names, which
+ * is what JavaScript's default string comparison does; numbers are written
+ * as ECMAScript's Number-to-string conversion writes them, which is what
+ * JSON.stringify writes for a finite number; strings are escaped as
+ * JSON.stringify escapes them (section 3.2.2.2: the short escapes, then
+ * \u00xx for the remaining control characters, everything else literal).
+ * Anything JSON cannot carry (undefined, a function, a symbol, a bigint, a
+ * non-finite number, a lone surrogate) is refused by name, so two
+ * implementations that both accept a value hash the same bytes.
+ *
+ * The EPCIS event-body digest (epcis-source.ts) is the reason this exists in
+ * this package: a retained source is compared by the digest of its canonical
+ * form, never by its formatting.
+ */
+export class JcsError extends Error {
+    constructor(path, detail) {
+        super(`${path} has no canonical form: ${detail}`);
+        this.name = 'JcsError';
+    }
+}
+const LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+function serialise(value, path) {
+    if (value === null)
+        return 'null';
+    switch (typeof value) {
+        case 'boolean':
+            return value ? 'true' : 'false';
+        case 'number':
+            if (!Number.isFinite(value))
+                throw new JcsError(path, 'JSON has no representation of a non-finite number');
+            // JSON.stringify writes -0 as 0 and otherwise exactly the ES Number-to-string form the RFC requires.
+            return JSON.stringify(value);
+        case 'string':
+            if (LONE_SURROGATE.test(value))
+                throw new JcsError(path, 'a lone surrogate cannot be encoded as UTF-8');
+            return JSON.stringify(value);
+        case 'object': {
+            if (Array.isArray(value))
+                return `[${value.map((item, index) => serialise(item, `${path}/${index}`)).join(',')}]`;
+            const record = value;
+            const keys = Object.keys(record).sort();
+            const members = [];
+            for (const key of keys) {
+                if (LONE_SURROGATE.test(key))
+                    throw new JcsError(`${path}/${key}`, 'a lone surrogate cannot be encoded as UTF-8');
+                if (record[key] === undefined)
+                    throw new JcsError(`${path}/${key}`, 'undefined is not a JSON value');
+                members.push(`${JSON.stringify(key)}:${serialise(record[key], `${path}/${key}`)}`);
+            }
+            return `{${members.join(',')}}`;
+        }
+        default:
+            throw new JcsError(path, `${typeof value} is not a JSON value`);
+    }
+}
+/** The RFC 8785 canonical JSON text of a value. Throws JcsError for anything JSON cannot carry. */
+export function canonicalizeJcs(value) {
+    return serialise(value, '');
+}
+/** The canonical text as UTF-8 bytes, the form a digest is taken over. */
+export function canonicalJcsBytes(value) {
+    return new TextEncoder().encode(canonicalizeJcs(value));
+}
+//# sourceMappingURL=jcs.js.map

package/dist/jcs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jcs.js","sourceRoot":"","sources":["../src/jcs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,OAAO,QAAS,SAAQ,KAAK;IACjC,YAAY,IAAY,EAAE,MAAc;QACtC,KAAK,CAAC,GAAG,IAAI,2BAA2B,MAAM,EAAE,CAAC,CAAC;QAClD,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC;IACzB,CAAC;CACF;AAED,MAAM,cAAc,GAAG,wEAAwE,CAAC;AAEhG,SAAS,SAAS,CAAC,KAAc,EAAE,IAAY;IAC7C,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,MAAM,CAAC;IAClC,QAAQ,OAAO,KAAK,EAAE,CAAC;QACrB,KAAK,SAAS;YACZ,OAAO,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC;QAClC,KAAK,QAAQ;YACX,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;gBAAE,MAAM,IAAI,QAAQ,CAAC,IAAI,EAAE,mDAAmD,CAAC,CAAC;YAC3G,qGAAqG;YACrG,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QAC/B,KAAK,QAAQ;YACX,IAAI,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC;gBAAE,MAAM,IAAI,QAAQ,CAAC,IAAI,EAAE,6CAA6C,CAAC,CAAC;YACxG,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QAC/B,KAAK,QAAQ,CAAC,CAAC,CAAC;YACd,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;gBAAE,OAAO,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,EAAE,GAAG,IAAI,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;YAClH,MAAM,MAAM,GAAG,KAAgC,CAAC;YAChD,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC;YACxC,MAAM,OAAO,GAAa,EAAE,CAAC;YAC7B,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;gBACvB,IAAI,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC;oBAAE,MAAM,IAAI,QAAQ,CAAC,GAAG,IAAI,IAAI,GAAG,EAAE,EAAE,6CAA6C,CAAC,CAAC;gBAClH,IAAI,MAAM,CAAC,GAAG,CAAC,KAAK,SAAS;oBAAE,MAAM,IAAI,QAAQ,CAAC,GAAG,IAAI,IAAI,GAAG,EAAE,EAAE,+BAA+B,CAAC,CAAC;gBACrG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,GAAG,IAAI,IAAI,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;YACrF,CAAC;YACD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;QAClC,CAAC;QACD;YACE,MAAM,IAAI,QAAQ,CAAC,IAAI,EAAE,GAAG,OAAO,KAAK,sBAAsB,CAAC,CAAC;IACpE,CAAC;AACH,CAAC;AAED,mGAAmG;AACnG,MAAM,UAAU,eAAe,CAAC,KAAc;IAC5C,OAAO,SAAS,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;AAC9B,CAAC;AAED,0EAA0E;AAC1E,MAAM,UAAU,iBAAiB,CAAC,KAAc;IAC9C,OAAO,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC;AAC1D,CAAC"}

package/dist/schema.d.ts

@@ -0,0 +1,414 @@
+export declare const sealSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly "@context": {
+            readonly type: "array";
+            readonly items: {
+                readonly enum: readonly ["https://www.w3.org/ns/credentials/v2", "urn:bsv:vsc:context:0.1.0", "https://w3id.org/security/suites/ed25519-2020/v1", "https://w3id.org/security/data-integrity/v2"];
+            };
+            readonly minItems: 2;
+        };
+        readonly type: {
+            readonly const: readonly ["VerifiableCredential", "VSC-SEAL"];
+        };
+        readonly id: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly format: "uri";
+        };
+        readonly issuer: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly pattern: "^did:[a-z0-9]+:[^\\s]+$";
+        };
+        readonly issuanceDate: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly format: "date-time";
+        };
+        readonly validFrom: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly format: "date-time";
+        };
+        readonly validUntil: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly format: "date-time";
+        };
+        readonly sealVersion: {
+            readonly const: "1.0";
+        };
+        readonly sealTimestamp: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly format: "date-time";
+        };
+        readonly correctionOf: {
+            readonly anyOf: readonly [{
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly format: "uri";
+            }, {
+                readonly type: "null";
+            }];
+        };
+        readonly credentialSubject: {
+            readonly type: "object";
+            readonly properties: {
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly format: "uri";
+                };
+                readonly predecessorCredentials: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly format: "uri";
+                    };
+                    readonly minItems: 0;
+                    readonly uniqueItems: true;
+                };
+            };
+            readonly required: readonly ["id"];
+            readonly additionalProperties: false;
+        };
+        readonly credentialStatus: {
+            readonly type: "object";
+            readonly properties: {
+                readonly id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly format: "uri";
+                };
+                readonly type: {
+                    readonly const: "BitstringStatusListEntry";
+                };
+                readonly statusPurpose: {
+                    readonly enum: readonly ["revocation", "suspension"];
+                };
+                readonly statusListIndex: {
+                    readonly type: "string";
+                    readonly pattern: "^(0|[1-9][0-9]*)$";
+                };
+                readonly statusListCredential: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly format: "uri";
+                };
+            };
+            readonly required: readonly ["id", "type", "statusPurpose", "statusListIndex", "statusListCredential"];
+            readonly additionalProperties: false;
+        };
+        readonly eventVector: {
+            readonly type: "object";
+            readonly properties: {
+                readonly what: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly productIdentifiers: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly scheme: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                    readonly value: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                    readonly schemeAuthority: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                    readonly serialNumber: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                };
+                                readonly required: readonly ["scheme", "value", "schemeAuthority"];
+                                readonly additionalProperties: false;
+                            };
+                            readonly minItems: 1;
+                        };
+                        readonly classifications: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "object";
+                            };
+                            readonly minItems: 0;
+                        };
+                        readonly batchOrLot: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly expiryDate: {
+                            readonly type: "string";
+                            readonly format: "date";
+                        };
+                        readonly quantity: {
+                            readonly type: "number";
+                            readonly minimum: 0;
+                        };
+                        readonly quantityUnit: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly description: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                    readonly required: readonly ["productIdentifiers"];
+                    readonly additionalProperties: false;
+                    readonly dependencies: {
+                        readonly quantity: readonly ["quantityUnit"];
+                    };
+                };
+                readonly when: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly eventTime: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly format: "date-time";
+                        };
+                        readonly recordedAt: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly format: "date-time";
+                        };
+                        readonly timezone: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly timePrecision: {
+                            readonly enum: readonly ["millisecond", "second", "minute"];
+                        };
+                    };
+                    readonly required: readonly ["eventTime", "recordedAt", "timezone", "timePrecision"];
+                    readonly additionalProperties: false;
+                };
+                readonly where: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly jurisdiction: {
+                            readonly type: "string";
+                            readonly pattern: "^[A-Z]{2}$";
+                        };
+                        readonly readPoint: {
+                            readonly type: "object";
+                        };
+                        readonly businessLocation: {
+                            readonly type: "object";
+                        };
+                        readonly geoCoordinates: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly latitude: {
+                                    readonly type: "number";
+                                    readonly minimum: -90;
+                                    readonly maximum: 90;
+                                };
+                                readonly longitude: {
+                                    readonly type: "number";
+                                    readonly minimum: -180;
+                                    readonly maximum: 180;
+                                };
+                            };
+                            readonly required: readonly ["latitude", "longitude"];
+                            readonly additionalProperties: false;
+                        };
+                    };
+                    readonly required: readonly ["jurisdiction"];
+                    readonly additionalProperties: false;
+                };
+                readonly who: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly actorDid: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly pattern: "^did:[a-z0-9]+:[^\\s]+$";
+                        };
+                        readonly actorRole: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly assertionMethod: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly pattern: "^did:[a-z0-9]+:[^\\s]+$";
+                        };
+                        readonly actorLicense: {
+                            readonly type: "object";
+                        };
+                    };
+                    readonly required: readonly ["actorDid", "actorRole", "assertionMethod"];
+                    readonly additionalProperties: false;
+                };
+                readonly how: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly eventType: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly eventTypeVocab: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly pattern: "^urn:";
+                        };
+                        readonly businessStep: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly disposition: {
+                            readonly enum: readonly ["active", "in_transit", "stored", "transshipped", "returned", "transformed", "received", "dispensed", "destroyed"];
+                        };
+                        readonly action: {
+                            readonly enum: readonly ["ADD", "OBSERVE", "DELETE"];
+                        };
+                    };
+                    readonly required: readonly ["eventType", "eventTypeVocab", "businessStep", "disposition", "action"];
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly required: readonly ["what", "when", "where", "who", "how"];
+            readonly additionalProperties: false;
+        };
+        readonly extensions: {
+            readonly type: "object";
+            readonly properties: {
+                readonly "+Dn": {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "object";
+                    };
+                };
+            };
+            readonly required: readonly ["+Dn"];
+            readonly additionalProperties: false;
+        };
+        readonly chainOfCustody: {
+            readonly type: "object";
+            readonly properties: {
+                readonly chainId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly format: "uri";
+                };
+                readonly sequenceNumber: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                    readonly maximum: 9007199254740991;
+                };
+                readonly parentSeals: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly format: "uri";
+                    };
+                    readonly minItems: 0;
+                    readonly uniqueItems: true;
+                };
+                readonly childSeals: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly format: "uri";
+                    };
+                    readonly minItems: 0;
+                    readonly uniqueItems: true;
+                };
+                readonly topology: {
+                    readonly enum: readonly ["linear", "fork", "merge", "transform", "correction"];
+                };
+                readonly topologyNote: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+            };
+            readonly required: readonly ["chainId", "sequenceNumber", "parentSeals", "topology"];
+            readonly additionalProperties: false;
+        };
+        readonly proof: {
+            readonly anyOf: readonly [{
+                readonly type: "object";
+                readonly properties: {
+                    readonly type: {
+                        readonly enum: readonly ["Ed25519Signature2020", "DataIntegrityProof"];
+                    };
+                    readonly verificationMethod: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^did:[a-z0-9]+:[^\\s]+$";
+                    };
+                    readonly proofPurpose: {
+                        readonly const: "assertionMethod";
+                    };
+                    readonly proofValue: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^[zu][A-Za-z0-9_-]+$";
+                    };
+                    readonly created: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly format: "date-time";
+                    };
+                    readonly cryptosuite: {
+                        readonly const: "bbs-2023";
+                    };
+                };
+                readonly required: readonly ["type", "verificationMethod", "proofPurpose", "proofValue"];
+                readonly additionalProperties: false;
+            }, {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly type: {
+                            readonly enum: readonly ["Ed25519Signature2020", "DataIntegrityProof"];
+                        };
+                        readonly verificationMethod: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly pattern: "^did:[a-z0-9]+:[^\\s]+$";
+                        };
+                        readonly proofPurpose: {
+                            readonly const: "assertionMethod";
+                        };
+                        readonly proofValue: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly pattern: "^[zu][A-Za-z0-9_-]+$";
+                        };
+                        readonly created: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly format: "date-time";
+                        };
+                        readonly cryptosuite: {
+                            readonly const: "bbs-2023";
+                        };
+                    };
+                    readonly required: readonly ["type", "verificationMethod", "proofPurpose", "proofValue"];
+                    readonly additionalProperties: false;
+                };
+                readonly minItems: 1;
+            }];
+        };
+    };
+    readonly required: readonly ["@context", "type", "id", "issuer", "issuanceDate", "validFrom", "sealVersion", "sealTimestamp", "correctionOf", "credentialSubject", "credentialStatus", "eventVector", "extensions", "chainOfCustody", "proof"];
+    readonly additionalProperties: false;
+    readonly $schema: "http://json-schema.org/draft-07/schema#";
+    readonly $id: "urn:bsv:vsc:schema:0.1.0";
+};
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAshBb,CAAC"}