@midnight-ntwrk/midnight-did 0.4.0-snapshot.51.a3d433c5e196

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,71 @@
+# @midnight-ntwrk/midnight-did
+
+Mapping layer between on-ledger contract state and DID Core-compatible domain documents.
+
+## Responsibilities
+
+- Convert contract ledger data to domain DID documents
+- Resolve canonical absolute DID URLs from stored fragment identifiers
+- Provide network/identifier utilities for `did:midnight`
+
+## Architecture
+
+```mermaid
+graph TD
+  Ledger[(Contract ledger state)]
+  Mapper[LedgerToDomain]
+  Domain[Domain DID document]
+  Resolver[Resolver/API consumers]
+
+  Ledger --> Mapper --> Domain --> Resolver
+```
+
+## Resolution Sequence
+
+```mermaid
+sequenceDiagram
+  participant Consumer
+  participant DIDPkg as did package
+  participant Mapper as LedgerToDomain
+  participant Domain
+
+  Consumer->>DIDPkg: DID Resolution input (DID string)
+  DIDPkg->>Mapper: map ledger state
+  Mapper->>Domain: construct canonical document
+  Domain-->>DIDPkg: validated model
+  DIDPkg-->>Consumer: DID Resolution Result
+```
+
+## Resolution Result Shape
+
+`MidnightDIDResolver.resolveDIDResolutionResult` returns a DID Core Resolution
+Result envelope with `didDocument`, `didDocumentMetadata`, and
+`didResolutionMetadata`. Successful abstract `resolve` results return an empty
+`didResolutionMetadata` object and do not set `contentType`. Missing ledger
+state returns `didResolutionMetadata.error = "notFound"`.
+
+The `resolve` and `resolveResult` methods remain convenience APIs for callers
+that want a DID Document directly or a nullable document-plus-metadata pair.
+
+Use `contentType` only for `resolveRepresentation`-style responses where the
+body is a DID Document byte stream. Midnight DID Document representations should
+be reported as `application/did+ld+json` for JSON-LD streams or
+`application/did+json` for DID Core JSON streams.
+
+## Identifier Canonicalization
+
+```mermaid
+stateDiagram-v2
+  [*] --> FragmentStored
+  FragmentStored --> AbsoluteReference : during resolution
+  AbsoluteReference --> [*]
+```
+
+Resolution output uses absolute DID URL references where required by DID Core,
+while compact fragment identifiers may still be used in ledger storage.
+
+## Build & Test
+
+- Build: `pnpm --filter ./packages/did build`
+- Test: `pnpm --filter ./packages/did test -- --pool=threads`
+- Coverage: `pnpm --filter ./packages/did coverage`

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { LedgerToDomain } from "./ledger-to-domain.js";
+export * from "./midnight.js";
+export * from "./midnight-did-document.js";
+export * from "./midnight-did-resolver.js";
+export * from "./offchain-midnight-did.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,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,cAAc,eAAe,CAAC;AAC9B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export { LedgerToDomain } from "./ledger-to-domain.js";
+export * from "./midnight.js";
+export * from "./midnight-did-document.js";
+export * from "./midnight-did-resolver.js";
+export * from "./offchain-midnight-did.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,cAAc,eAAe,CAAC;AAC9B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC","sourcesContent":["export { LedgerToDomain } from \"./ledger-to-domain.js\";\nexport * from \"./midnight.js\";\nexport * from \"./midnight-did-document.js\";\nexport * from \"./midnight-did-resolver.js\";\nexport * from \"./offchain-midnight-did.js\";\n"]}

package/dist/ledger-to-domain.d.ts

@@ -0,0 +1,28 @@
+import { DIDContract } from "@midnight-ntwrk/midnight-did-contract";
+import { DIDDocumentMetadata, PublicKeyJwk, Service } from "@midnight-ntwrk/midnight-did-domain";
+import { MidnightNetwork, parseContractAddress } from "./midnight.js";
+import { MidnightDIDDocument } from "./midnight-did-document.js";
+type Ledger = DIDContract.Ledger;
+type LedgerPublicKeyJwk = DIDContract.PublicKeyJwk;
+type LedgerSchnorrJubjubVerificationMethod = DIDContract.SchnorrJubjubVerificationMethod;
+type LedgerService = DIDContract.Service;
+export declare class LedgerToDomain {
+    private static readonly KeyTypeMap;
+    private static readonly CurveTypeMap;
+    private static readonly VerificationMethodTypeMap;
+    private static readonly VerificationMethodRelationMap;
+    static publicKeyJwk(publicKeyJwk: LedgerPublicKeyJwk): PublicKeyJwk;
+    static schnorrJubjubPublicKeyJwk(verificationMethod: LedgerSchnorrJubjubVerificationMethod): PublicKeyJwk;
+    private static ledgerOpaqueString;
+    static service(service: LedgerService): Service;
+    private static parseServiceType;
+    private static parseServiceEndpoint;
+    static verificationMethodId(id: string): string;
+    static absoluteDidUrlReference(did: string, id: string): string;
+    static toJSON(ledger: Ledger): object;
+    static ledgerStateToDIDDocument(ledger: Ledger, network: MidnightNetwork, contractAddress: ReturnType<typeof parseContractAddress>): MidnightDIDDocument;
+    static ledgerStateToMetadata(ledger: Ledger): DIDDocumentMetadata;
+    private static timestampToIsoString;
+}
+export {};
+//# sourceMappingURL=ledger-to-domain.d.ts.map

package/dist/ledger-to-domain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ledger-to-domain.d.ts","sourceRoot":"","sources":["../src/ledger-to-domain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,uCAAuC,CAAC;AACpE,OAAO,EAIL,mBAAmB,EAInB,YAAY,EAEZ,OAAO,EAKR,MAAM,qCAAqC,CAAC;AAE7C,OAAO,EAEL,eAAe,EACf,oBAAoB,EACrB,MAAM,eAAe,CAAC;AACvB,OAAO,EAEL,mBAAmB,EACpB,MAAM,4BAA4B,CAAC;AAsBpC,KAAK,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC;AACjC,KAAK,kBAAkB,GAAG,WAAW,CAAC,YAAY,CAAC;AACnD,KAAK,qCAAqC,GACxC,WAAW,CAAC,+BAA+B,CAAC;AAC9C,KAAK,aAAa,GAAG,WAAW,CAAC,OAAO,CAAC;AAkBzC,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAKhC;IAEF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,CAWlC;IAEF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,yBAAyB,CAO/C;IAEF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,6BAA6B,CAgBnD;IAEF,MAAM,CAAC,YAAY,CAAC,YAAY,EAAE,kBAAkB,GAAG,YAAY;IAsBnE,MAAM,CAAC,yBAAyB,CAC9B,kBAAkB,EAAE,qCAAqC,GACxD,YAAY;IASf,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAkBjC,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO;IAwB/C,OAAO,CAAC,MAAM,CAAC,gBAAgB;IA4B/B,OAAO,CAAC,MAAM,CAAC,oBAAoB;IA4CnC,MAAM,CAAC,oBAAoB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAc/C,MAAM,CAAC,uBAAuB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM;IAM/D,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IA0DrC,MAAM,CAAC,wBAAwB,CAC7B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,eAAe,EACxB,eAAe,EAAE,UAAU,CAAC,OAAO,oBAAoB,CAAC,GACvD,mBAAmB;IAsHtB,MAAM,CAAC,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,mBAAmB;IAsBjE,OAAO,CAAC,MAAM,CAAC,oBAAoB;CASpC"}

package/dist/ledger-to-domain.js

@@ -0,0 +1,341 @@
+import { DIDContract } from "@midnight-ntwrk/midnight-did-contract";
+import { createService, createVerificationMethod, CurveType, encodeBase64Url, KeyType, normalizeServiceEndpoint, PublicKeyJwkSchema, ServiceEndpointSchema, VerificationMethodRelationType, VerificationMethodType, } from "@midnight-ntwrk/midnight-did-domain";
+import { createMidnightDIDString, } from "./midnight.js";
+import { createMidnightDIDDocument, } from "./midnight-did-document.js";
+const bytesToHex = (bytes) => {
+    let hex = "";
+    for (const byte of bytes) {
+        hex += Number(byte).toString(16).padStart(2, "0");
+    }
+    return hex;
+};
+const LedgerCurveType = DIDContract.CurveType;
+const LedgerKeyType = DIDContract.KeyType;
+const LedgerVerificationMethodType = DIDContract.VerificationMethodType;
+const LedgerVerificationMethodRelation = DIDContract.VerificationMethodRelation;
+const bigintTo32Le = (value) => {
+    if (value < 0n) {
+        throw new Error("Jubjub public key coordinate must be non-negative");
+    }
+    const bytes = new Uint8Array(32);
+    let remaining = value;
+    for (let i = 0; i < bytes.length; i += 1) {
+        bytes[i] = Number(remaining & 0xffn);
+        remaining >>= 8n;
+    }
+    if (remaining !== 0n) {
+        throw new Error("Jubjub public key coordinate does not fit in 32 bytes");
+    }
+    return bytes;
+};
+export class LedgerToDomain {
+    static KeyTypeMap = {
+        [LedgerKeyType.EC]: KeyType.EC,
+        [LedgerKeyType.RSA]: KeyType.RSA,
+        [LedgerKeyType.oct]: KeyType.oct,
+        [LedgerKeyType.OKP]: KeyType.OKP,
+    };
+    static CurveTypeMap = {
+        [LedgerCurveType.Ed25519]: CurveType.Ed25519,
+        [LedgerCurveType.X25519]: CurveType.X25519,
+        [LedgerCurveType.Jubjub]: CurveType.Jubjub,
+        [LedgerCurveType.P256]: CurveType.P256,
+        [LedgerCurveType.Secp256k1]: CurveType.Secp256k1,
+        [LedgerCurveType.BLS12381G1]: CurveType.BLS12381G1,
+        [LedgerCurveType.BLS12381G2]: CurveType.BLS12381G2,
+    };
+    static VerificationMethodTypeMap = {
+        [LedgerVerificationMethodType.Undefined]: VerificationMethodType.Undefined,
+        [LedgerVerificationMethodType.JsonWebKey]: VerificationMethodType.JsonWebKey,
+    };
+    static VerificationMethodRelationMap = {
+        [LedgerVerificationMethodRelation.Undefined]: VerificationMethodRelationType.Undefined,
+        [LedgerVerificationMethodRelation.Authentication]: VerificationMethodRelationType.Authentication,
+        [LedgerVerificationMethodRelation.AssertionMethod]: VerificationMethodRelationType.AssertionMethod,
+        [LedgerVerificationMethodRelation.KeyAgreement]: VerificationMethodRelationType.KeyAgreement,
+        [LedgerVerificationMethodRelation.CapabilityInvocation]: VerificationMethodRelationType.CapabilityInvocation,
+        [LedgerVerificationMethodRelation.CapabilityDelegation]: VerificationMethodRelationType.CapabilityDelegation,
+    };
+    static publicKeyJwk(publicKeyJwk) {
+        const kty = this.KeyTypeMap[publicKeyJwk.kty];
+        const crv = this.CurveTypeMap[publicKeyJwk.crv];
+        const x = this.ledgerOpaqueString(publicKeyJwk.x, "publicKeyJwk.x");
+        const y = this.ledgerOpaqueString(publicKeyJwk.y, "publicKeyJwk.y");
+        if (kty === KeyType.OKP &&
+            (crv === CurveType.Ed25519 ||
+                crv === CurveType.X25519 ||
+                crv === CurveType.BLS12381G1 ||
+                crv === CurveType.BLS12381G2)) {
+            if (y !== "") {
+                throw new Error("OKP ledger publicKeyJwk.y must be empty");
+            }
+            return PublicKeyJwkSchema.parse({ kty, crv, x });
+        }
+        return PublicKeyJwkSchema.parse({ kty, crv, x, y });
+    }
+    static schnorrJubjubPublicKeyJwk(verificationMethod) {
+        return PublicKeyJwkSchema.parse({
+            kty: KeyType.EC,
+            crv: CurveType.Jubjub,
+            x: encodeBase64Url(bigintTo32Le(verificationMethod.publicKey.x)),
+            y: encodeBase64Url(bigintTo32Le(verificationMethod.publicKey.y)),
+        });
+    }
+    static ledgerOpaqueString(value, label) {
+        if (typeof value === "string")
+            return value;
+        if (value instanceof Uint8Array)
+            return new TextDecoder().decode(value);
+        if (ArrayBuffer.isView(value)) {
+            const view = value;
+            return new TextDecoder().decode(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+        }
+        const shape = value === null
+            ? "null"
+            : typeof value === "object"
+                ? (value.constructor?.name ?? "object")
+                : typeof value;
+        throw new Error(`${label} has an unsupported runtime shape: ${shape}`);
+    }
+    static service(service) {
+        const rawId = service.id.trim();
+        const needsFragmentPrefix = rawId.startsWith("//") ||
+            (!rawId.startsWith("did:") &&
+                !rawId.startsWith("#") &&
+                !rawId.startsWith("/") &&
+                !rawId.startsWith(".") &&
+                !rawId.startsWith("?"));
+        const serviceId = needsFragmentPrefix ? `#${rawId}` : rawId;
+        const serviceEndpoint = this.parseServiceEndpoint(service.serviceEndpoint);
+        const serviceType = this.parseServiceType(service.typ ??
+            service.type ??
+            "");
+        return {
+            id: serviceId,
+            type: serviceType,
+            serviceEndpoint,
+        };
+    }
+    static parseServiceType(raw) {
+        const value = raw.trim();
+        if (value.length === 0) {
+            throw new Error("Invalid service type: empty value");
+        }
+        if (value.startsWith("[")) {
+            try {
+                const parsed = JSON.parse(value);
+                if (Array.isArray(parsed) &&
+                    parsed.length > 0 &&
+                    parsed.every((entry) => typeof entry === "string" && entry.trim().length > 0) &&
+                    new Set(parsed.map((entry) => entry.trim())).size === parsed.length) {
+                    return parsed.map((entry) => entry.trim());
+                }
+            }
+            catch {
+                throw new Error("Invalid service type: malformed JSON array");
+            }
+            throw new Error("Invalid service type: expected non-empty unique strings");
+        }
+        return value;
+    }
+    static parseServiceEndpoint(endpoint) {
+        const normalize = (value) => normalizeServiceEndpoint(value);
+        if (Array.isArray(endpoint)) {
+            const filtered = endpoint
+                .map((value) => (typeof value === "string" ? value.trim() : ""))
+                .filter((value) => value !== "");
+            if (filtered.length === 0) {
+                throw new Error("Invalid serviceEndpoint: empty legacy endpoint array");
+            }
+            if (filtered.length === 1)
+                return normalize(filtered[0]);
+            return normalize(filtered);
+        }
+        if (typeof endpoint === "string") {
+            const raw = endpoint.trim();
+            if (raw === "") {
+                throw new Error("Invalid serviceEndpoint: empty value");
+            }
+            try {
+                const parsed = JSON.parse(raw);
+                return normalize(ServiceEndpointSchema.parse(parsed));
+            }
+            catch {
+                const direct = ServiceEndpointSchema.safeParse(raw);
+                if (direct.success) {
+                    return normalize(direct.data);
+                }
+                throw new Error("Invalid serviceEndpoint: malformed JSON payload");
+            }
+        }
+        const parsed = ServiceEndpointSchema.safeParse(endpoint);
+        if (parsed.success) {
+            return normalize(parsed.data);
+        }
+        throw new Error("Invalid serviceEndpoint: unsupported endpoint shape");
+    }
+    static verificationMethodId(id) {
+        const rawId = id.trim();
+        if (rawId.startsWith("did:")) {
+            if (rawId.includes("#"))
+                return rawId;
+            return `${rawId}#${rawId.slice(rawId.lastIndexOf(":") + 1)}`;
+        }
+        const needsFragmentPrefix = !rawId.startsWith("#") &&
+            !rawId.startsWith("/") &&
+            !rawId.startsWith(".") &&
+            !rawId.startsWith("?");
+        return needsFragmentPrefix ? `#${rawId}` : rawId;
+    }
+    static absoluteDidUrlReference(did, id) {
+        const normalized = this.verificationMethodId(id);
+        if (normalized.startsWith("did:"))
+            return normalized;
+        return `${did}${normalized}`;
+    }
+    static toJSON(ledger) {
+        const created = this.timestampToIsoString(ledger.created);
+        const updated = this.timestampToIsoString(ledger.updated);
+        const opaqueVerificationMethods = Array.from(ledger.verificationMethods, ([id, method]) => ({
+            id: this.verificationMethodId(id),
+            type: this.VerificationMethodTypeMap[method.typ],
+            publicKeyJwk: this.publicKeyJwk(method.publicKeyJwk),
+        }));
+        const schnorrJubjubVerificationMethods = Array.from(ledger.schnorrJubjubVerificationMethods, ([id, method]) => ({
+            id: this.verificationMethodId(id),
+            type: VerificationMethodType.JsonWebKey,
+            publicKeyJwk: this.schnorrJubjubPublicKeyJwk(method),
+        }));
+        return {
+            id: bytesToHex(ledger.id.bytes),
+            version: Number(ledger.version.toString()),
+            active: ledger.active,
+            operationCount: Number(ledger.operationCount.toString()),
+            created,
+            updated,
+            deactivated: ledger.deactivated,
+            alsoKnownAs: Array.from(ledger.alsoKnownAs),
+            verificationMethods: [
+                ...opaqueVerificationMethods,
+                ...schnorrJubjubVerificationMethods,
+            ],
+            authenticationRelation: Array.from(ledger.authenticationRelation, (value) => this.verificationMethodId(value)),
+            assertionMethodRelation: Array.from(ledger.assertionMethodRelation, (value) => this.verificationMethodId(value)),
+            keyAgreementRelation: Array.from(ledger.keyAgreementRelation, (value) => this.verificationMethodId(value)),
+            capabilityInvocationRelation: Array.from(ledger.capabilityInvocationRelation, (value) => this.verificationMethodId(value)),
+            capabilityDelegationRelation: Array.from(ledger.capabilityDelegationRelation, (value) => this.verificationMethodId(value)),
+            services: Array.from(ledger.services, ([, service]) => this.service(service)),
+        };
+    }
+    static ledgerStateToDIDDocument(ledger, network, contractAddress) {
+        const did = createMidnightDIDString(contractAddress, network);
+        const verificationMethod = [];
+        const verificationMethodIds = new Set();
+        const registerVerificationMethodId = (id) => {
+            const normalizedId = this.verificationMethodId(id);
+            if (verificationMethodIds.has(normalizedId)) {
+                throw new Error(`Duplicate verification method id '${this.absoluteDidUrlReference(did, id)}'`);
+            }
+            verificationMethodIds.add(normalizedId);
+        };
+        for (const [id, method] of ledger.verificationMethods) {
+            const verificationMethodType = LedgerToDomain.VerificationMethodTypeMap[method.typ];
+            if (verificationMethodType !== VerificationMethodType.JsonWebKey) {
+                throw new Error(`Unsupported verification method type for id '${id}': ${verificationMethodType}`);
+            }
+            registerVerificationMethodId(id);
+            verificationMethod.push(createVerificationMethod({
+                id: this.absoluteDidUrlReference(did, id),
+                type: verificationMethodType,
+                controller: did,
+                publicKeyJwk: this.publicKeyJwk(method.publicKeyJwk),
+            }));
+        }
+        for (const [id, method] of ledger.schnorrJubjubVerificationMethods) {
+            registerVerificationMethodId(id);
+            verificationMethod.push(createVerificationMethod({
+                id: this.absoluteDidUrlReference(did, id),
+                type: VerificationMethodType.JsonWebKey,
+                controller: did,
+                publicKeyJwk: this.schnorrJubjubPublicKeyJwk(method),
+            }));
+        }
+        const assertRelationTargetsExist = (relationName, relation) => {
+            if (relation.isEmpty())
+                return;
+            for (const methodId of relation) {
+                if (!verificationMethodIds.has(this.verificationMethodId(methodId))) {
+                    throw new Error(`${relationName} references missing verification method '${this.absoluteDidUrlReference(did, methodId)}'`);
+                }
+            }
+        };
+        assertRelationTargetsExist("authentication", ledger.authenticationRelation);
+        assertRelationTargetsExist("assertionMethod", ledger.assertionMethodRelation);
+        assertRelationTargetsExist("keyAgreement", ledger.keyAgreementRelation);
+        assertRelationTargetsExist("capabilityInvocation", ledger.capabilityInvocationRelation);
+        assertRelationTargetsExist("capabilityDelegation", ledger.capabilityDelegationRelation);
+        const mapRelation = (relation) => relation.isEmpty()
+            ? undefined
+            : Array.from(relation, (value) => this.verificationMethodId(value));
+        const assertionMethod = mapRelation(ledger.assertionMethodRelation);
+        const authentication = mapRelation(ledger.authenticationRelation);
+        const capabilityDelegation = mapRelation(ledger.capabilityDelegationRelation);
+        const capabilityInvocation = mapRelation(ledger.capabilityInvocationRelation);
+        const keyAgreement = mapRelation(ledger.keyAgreementRelation);
+        const service = ledger.services.isEmpty()
+            ? undefined
+            : Array.from(ledger.services, ([, s]) => {
+                const parsed = this.service(s);
+                return createService({
+                    id: this.absoluteDidUrlReference(did, s.id),
+                    type: parsed.type,
+                    serviceEndpoint: parsed.serviceEndpoint,
+                });
+            });
+        const alsoKnownAs = ledger.alsoKnownAs.isEmpty()
+            ? undefined
+            : Array.from(ledger.alsoKnownAs);
+        return createMidnightDIDDocument({
+            id: did,
+            verificationMethod,
+            authentication,
+            assertionMethod,
+            keyAgreement,
+            capabilityInvocation,
+            capabilityDelegation,
+            service,
+            alsoKnownAs,
+        });
+    }
+    static ledgerStateToMetadata(ledger) {
+        const created = this.timestampToIsoString(ledger.created);
+        const updated = this.timestampToIsoString(ledger.updated);
+        const deactivatedAt = ledger.deactivated
+            ? this.timestampToIsoString(ledger.updated)
+            : undefined;
+        const isDeactivated = ledger.deactivated || !ledger.active;
+        const metadata = {
+            created,
+            updated,
+            deactivated: isDeactivated ? true : undefined,
+            versionId: ledger.version.toString(),
+        };
+        if (isDeactivated && deactivatedAt !== undefined) {
+            metadata.updated = deactivatedAt;
+        }
+        return metadata;
+    }
+    static timestampToIsoString(timestamp) {
+        if (timestamp === 0n)
+            return undefined;
+        const maxSafe = BigInt(Number.MAX_SAFE_INTEGER);
+        if (timestamp > maxSafe || timestamp < 0n)
+            return undefined;
+        const milliseconds = Number(timestamp);
+        if (Number.isNaN(milliseconds))
+            return undefined;
+        const iso = new Date(milliseconds).toISOString();
+        return iso.replace(/\.\d{3}Z$/, "Z");
+    }
+}
+//# sourceMappingURL=ledger-to-domain.js.map