@oma3/omatrust 0.1.0-alpha.10 → 0.1.0-alpha.12

package/dist/index-Bu-xxcv9.d.ts

@@ -0,0 +1,407 @@
+import { A as AuthorizationMetadata, J as JwkValidationResult, a as JwsVerificationError, b as JwsVerificationFailure, c as JwsVerificationResult, P as PublicJwk, d as PublicKeySource, R as ResolveKeyOptions, e as ResolvedControllerDid, f as ResolvedPublicKey, V as VerificationResultInput, g as computeJwkThumbprint, h as didJwkToJwk, i as extractAuthorizationMetadata, j as formatJktValue, k as jwkToDidJwk, p as publicJwkEquals, r as resolveDidUrlToControllerDid, l as resolveDidUrlToPublicKey, v as validatePublicJwk } from './types-Dn0OwaNj.js';
+
+type Hex$1 = `0x${string}`;
+type Did = string;
+declare function isValidDid(did: string): boolean;
+declare function extractDidMethod(did: Did): string | null;
+declare function extractDidIdentifier(did: Did): string | null;
+declare function normalizeDomain(domain: string): string;
+declare function normalizeDidWeb(input: string): Did;
+declare function normalizeDidPkh(input: string): Did;
+declare function normalizeDidHandle(input: string): Did;
+declare function normalizeDidKey(input: string): Did;
+declare function normalizeDid(input: string): Did;
+declare function computeDidHash(did: Did): Hex$1;
+declare function computeDidAddress(didHash: Hex$1): Hex$1;
+declare function didToAddress(did: Did): Hex$1;
+declare function validateDidAddress(did: Did, address: Hex$1): boolean;
+declare function buildDidWeb(domain: string): Did;
+declare function buildDidPkh(namespace: string, chainId: string | number, address: string): Did;
+declare function buildEvmDidPkh(chainId: string | number, address: string): Did;
+declare function buildDidPkhFromCaip10(caip10: string): Did;
+declare function getChainIdFromDidPkh(did: Did): string | null;
+declare function getAddressFromDidPkh(did: Did): string | null;
+declare function getNamespaceFromDidPkh(did: Did): string | null;
+declare function isEvmDidPkh(did: Did): boolean;
+declare function getDomainFromDidWeb(did: Did): string | null;
+/**
+ * Extract an EVM address from a DID or address-like identifier.
+ *
+ * Supports:
+ * - did:pkh (extracts the address portion — currently EVM only)
+ * - did:ethr (extracts the Ethereum address)
+ * - CAIP-10 format (e.g. eip155:1:0xABC)
+ * - Raw EVM addresses (0x + 40 hex chars)
+ *
+ * NOTE: This function is EVM-specific. It does not support non-EVM chains
+ * (e.g. Solana, Cosmos). Non-EVM did:pkh identifiers will throw.
+ * A future version may generalize to support multiple chain families.
+ *
+ * @param identifier - A DID, CAIP-10 string, or raw EVM address
+ * @returns The checksummed EVM address
+ * @throws OmaTrustError if the identifier cannot be resolved to an EVM address
+ */
+declare function extractAddressFromDid(identifier: string): string;
+/** Result of private-key DID validation */
+interface PrivateKeyDidValidation {
+    valid: boolean;
+    method: "pkh" | "jwk" | null;
+    error?: string;
+}
+/**
+ * Check if a DID uses a private-key method (can sign transactions/messages).
+ * Quick boolean check — use validatePrivateKeyDid() for detailed errors.
+ */
+declare function isPrivateKeyDid(did: string): boolean;
+/**
+ * Validate that a DID is a well-formed private-key DID.
+ * Returns detailed validation result with method identification and error messages.
+ *
+ * Supported methods:
+ * - did:pkh — CAIP-10 blockchain account (deep validation for eip155)
+ * - did:jwk — JSON Web Key (structural validation)
+ */
+declare function validatePrivateKeyDid(did: string): PrivateKeyDidValidation;
+/**
+ * Normalize a did:jwk DID.
+ * Validates structure and returns the DID unchanged (did:jwk is already canonical).
+ */
+declare function normalizeDidJwk(input: string): Did;
+
+/**
+ * DID URL Parsing — Phase 1
+ *
+ * Parses DID URLs (e.g. did:web:api.example.com#key-1) into their components.
+ * DID URLs are mutable key references / lookup handles, not durable controller DIDs.
+ */
+/** Parsed DID URL components */
+interface ParsedDidUrl {
+    /** The original full DID URL */
+    didUrl: string;
+    /** The base DID (without fragment) */
+    did: string;
+    /** The fragment identifier (without the '#'), or null if no fragment */
+    fragment: string | null;
+}
+/**
+ * Parse a DID URL into its components.
+ *
+ * A DID URL may include a fragment (e.g. `did:web:api.example.com#key-1`).
+ * The fragment identifies a verification method, key reference, or other
+ * resource under the DID.
+ *
+ * DID URLs are mutable key references. They should not be used as durable
+ * controller DIDs. Use `resolveDidUrlControllerDid()` to derive a durable
+ * `did:jwk` from a DID URL.
+ *
+ * @param input - A DID URL string
+ * @returns Parsed components: didUrl, did, fragment
+ * @throws OmaTrustError with code INVALID_DID_URL if input is malformed
+ */
+declare function parseDidUrl(input: string): ParsedDidUrl;
+/**
+ * Check whether a string is a DID URL (contains a fragment).
+ * Useful for guards that need to reject DID URLs where a bare DID is expected.
+ */
+declare function isDidUrl(input: string): boolean;
+/**
+ * Assert that a string is a bare DID (not a DID URL with a fragment).
+ * Throws if the input contains a fragment.
+ *
+ * Use this in functions that expect a subject DID and must reject DID URLs.
+ */
+declare function assertBareDid(input: string, paramName?: string): void;
+
+/**
+ * Controller ID Comparison
+ *
+ * Determines whether two controller DIDs refer to the same entity.
+ * Handles DID normalization and EVM address-based fallback (chain-agnostic).
+ */
+/**
+ * Check if two controller DIDs refer to the same entity.
+ *
+ * Matching strategies (tried in order):
+ * 1. Exact normalized DID string match
+ * 2. EVM address match (chain-agnostic): if both DIDs resolve to the same
+ *    EVM address, they match regardless of chain ID. This handles cases like
+ *    did:pkh:eip155:1:0xABC matching did:pkh:eip155:137:0xABC.
+ * 3. JWK material match: if both are did:jwk, compare the decoded public key
+ *    material directly (handles non-canonical encoding differences).
+ *
+ * @param a - First controller DID
+ * @param b - Second controller DID
+ * @returns true if both DIDs refer to the same controller
+ */
+declare function isSameControllerId(a: string, b: string): boolean;
+/**
+ * Extract an EVM address from a controller DID, if possible.
+ * Returns null for non-EVM controllers (did:jwk, non-eip155 did:pkh, etc.)
+ */
+declare function extractControllerEvmAddress(controllerDid: string): string | null;
+
+type Caip10 = string;
+type ParsedCaip10 = {
+    namespace: string;
+    reference: string;
+    address: string;
+};
+type ParsedCaip2 = {
+    namespace: string;
+    reference: string;
+};
+declare function parseCaip10(input: string): ParsedCaip10;
+declare function buildCaip10(namespace: string, reference: string, address: string): Caip10;
+declare function normalizeCaip10(input: string): Caip10;
+declare function buildCaip2(namespace: string, reference: string): string;
+declare function parseCaip2(caip2: string): ParsedCaip2;
+
+type Hex = `0x${string}`;
+/**
+ * Parse JSON strictly, rejecting duplicate keys.
+ * Standard JSON.parse() silently accepts duplicates (last-wins).
+ * This function detects duplicates at any nesting depth and throws.
+ */
+declare function parseJsonStrict(input: string): unknown;
+/**
+ * Assert that a value is JSON-safe (representable in JSON without lossy conversion).
+ * Rejects: undefined, NaN, Infinity, -Infinity, BigInt, functions, symbols, Date objects.
+ * These values would be silently coerced or dropped by JSON.stringify / canonicalize.
+ */
+declare function assertJsonSafe(value: unknown, path?: string, depth?: number): void;
+declare function canonicalizeJson(obj: unknown): string;
+/**
+ * Canonicalize a JSON object (JCS / RFC 8785) and compute its keccak256 hash.
+ * Returns both the canonical JCS string and the 0x-prefixed hash.
+ */
+declare function canonicalizeAndKeccak256(obj: unknown): {
+    jcsJson: string;
+    hash: Hex;
+};
+/** @deprecated Use canonicalizeAndKeccak256 instead. */
+declare function canonicalizeForHash(obj: unknown): {
+    jcsJson: string;
+    hash: Hex;
+};
+declare function hashCanonicalizedJson(obj: unknown, algorithm: "keccak256" | "sha256"): Hex;
+
+/**
+ * did:artifact — Content-Addressed DID Method
+ *
+ * Implements construction, parsing, and verification for the did:artifact DID method.
+ * A did:artifact DID names an immutable byte sequence by its SHA-256 content hash,
+ * encoded as a CIDv1 with raw multicodec and base32-lower multibase.
+ *
+ * Construction:
+ *   - artifactDidFromBytes: hash raw bytes (binary artifacts)
+ *   - artifactDidFromJson: canonicalize JSON then hash (JSON artifacts)
+ *
+ * Verification:
+ *   - verifyDidArtifact: verify content matches a did:artifact DID
+ *     (tries canonical JSON first, then raw bytes)
+ *
+ * Spec: https://oma3dao.github.io/omatrust-docs/specification/did-artifact-method-spec.html
+ */
+/** Parsed components of a did:artifact DID */
+interface ParsedArtifactDid {
+    /** The full DID string */
+    did: string;
+    /** The method-specific identifier (base32-encoded CIDv1) */
+    identifier: string;
+    /** The SHA-256 digest as a Uint8Array (32 bytes) */
+    digest: Uint8Array;
+    /** The SHA-256 digest as lowercase hex */
+    digestHex: string;
+}
+/**
+ * Construct a did:artifact DID from raw bytes.
+ *
+ * Use this when the artifact is a binary blob (installer, archive, image, etc.)
+ * where no canonicalization is needed. The bytes are hashed as-is.
+ *
+ * @param bytes - The artifact's raw octets
+ * @returns The did:artifact DID string
+ * @throws OmaTrustError if bytes is empty or not a Uint8Array
+ */
+declare function artifactDidFromBytes(bytes: Uint8Array): Promise<string>;
+/**
+ * Construct a did:artifact DID from a JSON value.
+ *
+ * The input is canonicalized using JCS (RFC 8785), then the canonical UTF-8 bytes
+ * are hashed with SHA-256. If the input is a string, it is parsed strictly
+ * (rejecting duplicate keys, non-JSON-safe values, etc.) before canonicalization.
+ *
+ * Use this when the artifact is a JSON document and you want identity based on
+ * the JSON *value* rather than the exact serialization.
+ *
+ * @param input - A parsed JSON value (object/array/primitive) or a JSON string
+ * @returns The did:artifact DID string
+ * @throws OmaTrustError if canonicalization fails (malformed JSON, duplicate keys, etc.)
+ */
+declare function artifactDidFromJson(input: unknown): Promise<string>;
+/**
+ * Parse and validate a did:artifact DID string.
+ *
+ * Validates:
+ * - Correct prefix
+ * - Valid base32-lower multibase encoding
+ * - CID version 1
+ * - Multicodec is raw (0x55)
+ * - Multihash function is sha2-256 (0x12) with 32-byte digest
+ *
+ * @param did - The DID string to parse
+ * @returns Parsed components including the SHA-256 digest
+ * @throws OmaTrustError if the DID is malformed or uses unsupported parameters
+ */
+declare function parseArtifactDid(did: string): ParsedArtifactDid;
+/** Result of artifact verification */
+interface ArtifactVerificationResult {
+    /** Whether the content matches the DID */
+    valid: boolean;
+    /** Which interpretation matched: "json" if canonical JSON matched, "binary" if raw bytes matched */
+    matchedAs?: "json" | "binary";
+    /** Error reason when valid is false */
+    reason?: string;
+}
+/**
+ * Verify that content matches a did:artifact DID.
+ *
+ * Verification strategy:
+ * 1. Try to interpret the content as JSON: parse strictly, canonicalize, hash, compare.
+ * 2. If JSON interpretation fails or doesn't match, hash the raw bytes and compare.
+ * 3. If either matches, verification succeeds.
+ *
+ * This dual approach is necessary because the verifier doesn't know which path
+ * (artifactDidFromJson vs artifactDidFromBytes) was used at construction time.
+ *
+ * @param did - The did:artifact DID to verify against
+ * @param content - The candidate content (Uint8Array for binary, or string/object for JSON)
+ * @returns Verification result indicating whether and how the content matched
+ */
+declare function verifyDidArtifact(did: string, content: Uint8Array | string | unknown): Promise<ArtifactVerificationResult>;
+
+/**
+ * DID Method Migration Helpers
+ *
+ * Provides conversion functions for deprecated DID methods:
+ * - did:ethr → did:pkh:eip155 (wallet addresses)
+ * - did:key → did:jwk (non-blockchain keys)
+ *
+ * These methods are being deprecated in favor of their canonical replacements.
+ * Use these functions to convert existing identifiers to the preferred format.
+ */
+/**
+ * Convert a did:ethr DID to the equivalent did:pkh:eip155 DID.
+ *
+ * did:ethr format: did:ethr:<address> or did:ethr:<chainId>:<address>
+ * did:pkh format:  did:pkh:eip155:<chainId>:<address>
+ *
+ * If the did:ethr DID omits the chain ID, defaults to chain 1 (Ethereum mainnet).
+ *
+ * @param did - A did:ethr DID string
+ * @returns The equivalent did:pkh:eip155 DID
+ * @throws OmaTrustError if the input is not a valid did:ethr DID
+ */
+declare function didEthrToDidPkh(did: string): string;
+/**
+ * Convert a did:key DID to the equivalent did:jwk DID.
+ *
+ * did:key encodes a public key as a multicodec-prefixed, base58btc-encoded value.
+ * This function decodes the key, identifies the algorithm from the multicodec prefix,
+ * constructs a JWK, and wraps it as did:jwk.
+ *
+ * Supported key types:
+ * - Ed25519 (multicodec 0xed)
+ * - X25519 (multicodec 0xec)
+ *
+ * EC keys (secp256k1, P-256, P-384) are stored compressed in did:key and require
+ * elliptic curve decompression to produce a valid JWK. This is not supported;
+ * use didEthrToDidPkh() for EVM wallet keys instead.
+ *
+ * @param did - A did:key DID string
+ * @returns The equivalent did:jwk DID
+ * @throws OmaTrustError if the input is invalid or uses an unsupported key type
+ */
+declare function didKeyToDidJwk(did: string): string;
+
+type index_ArtifactVerificationResult = ArtifactVerificationResult;
+declare const index_AuthorizationMetadata: typeof AuthorizationMetadata;
+type index_Caip10 = Caip10;
+type index_Did = Did;
+declare const index_JwkValidationResult: typeof JwkValidationResult;
+declare const index_JwsVerificationError: typeof JwsVerificationError;
+declare const index_JwsVerificationFailure: typeof JwsVerificationFailure;
+declare const index_JwsVerificationResult: typeof JwsVerificationResult;
+type index_ParsedArtifactDid = ParsedArtifactDid;
+type index_ParsedCaip10 = ParsedCaip10;
+type index_ParsedCaip2 = ParsedCaip2;
+type index_ParsedDidUrl = ParsedDidUrl;
+type index_PrivateKeyDidValidation = PrivateKeyDidValidation;
+declare const index_PublicJwk: typeof PublicJwk;
+declare const index_PublicKeySource: typeof PublicKeySource;
+declare const index_ResolveKeyOptions: typeof ResolveKeyOptions;
+declare const index_ResolvedControllerDid: typeof ResolvedControllerDid;
+declare const index_ResolvedPublicKey: typeof ResolvedPublicKey;
+declare const index_VerificationResultInput: typeof VerificationResultInput;
+declare const index_artifactDidFromBytes: typeof artifactDidFromBytes;
+declare const index_artifactDidFromJson: typeof artifactDidFromJson;
+declare const index_assertBareDid: typeof assertBareDid;
+declare const index_assertJsonSafe: typeof assertJsonSafe;
+declare const index_buildCaip10: typeof buildCaip10;
+declare const index_buildCaip2: typeof buildCaip2;
+declare const index_buildDidPkh: typeof buildDidPkh;
+declare const index_buildDidPkhFromCaip10: typeof buildDidPkhFromCaip10;
+declare const index_buildDidWeb: typeof buildDidWeb;
+declare const index_buildEvmDidPkh: typeof buildEvmDidPkh;
+declare const index_canonicalizeAndKeccak256: typeof canonicalizeAndKeccak256;
+declare const index_canonicalizeForHash: typeof canonicalizeForHash;
+declare const index_canonicalizeJson: typeof canonicalizeJson;
+declare const index_computeDidAddress: typeof computeDidAddress;
+declare const index_computeDidHash: typeof computeDidHash;
+declare const index_computeJwkThumbprint: typeof computeJwkThumbprint;
+declare const index_didEthrToDidPkh: typeof didEthrToDidPkh;
+declare const index_didJwkToJwk: typeof didJwkToJwk;
+declare const index_didKeyToDidJwk: typeof didKeyToDidJwk;
+declare const index_didToAddress: typeof didToAddress;
+declare const index_extractAddressFromDid: typeof extractAddressFromDid;
+declare const index_extractAuthorizationMetadata: typeof extractAuthorizationMetadata;
+declare const index_extractControllerEvmAddress: typeof extractControllerEvmAddress;
+declare const index_extractDidIdentifier: typeof extractDidIdentifier;
+declare const index_extractDidMethod: typeof extractDidMethod;
+declare const index_formatJktValue: typeof formatJktValue;
+declare const index_getAddressFromDidPkh: typeof getAddressFromDidPkh;
+declare const index_getChainIdFromDidPkh: typeof getChainIdFromDidPkh;
+declare const index_getDomainFromDidWeb: typeof getDomainFromDidWeb;
+declare const index_getNamespaceFromDidPkh: typeof getNamespaceFromDidPkh;
+declare const index_hashCanonicalizedJson: typeof hashCanonicalizedJson;
+declare const index_isDidUrl: typeof isDidUrl;
+declare const index_isEvmDidPkh: typeof isEvmDidPkh;
+declare const index_isPrivateKeyDid: typeof isPrivateKeyDid;
+declare const index_isSameControllerId: typeof isSameControllerId;
+declare const index_isValidDid: typeof isValidDid;
+declare const index_jwkToDidJwk: typeof jwkToDidJwk;
+declare const index_normalizeCaip10: typeof normalizeCaip10;
+declare const index_normalizeDid: typeof normalizeDid;
+declare const index_normalizeDidHandle: typeof normalizeDidHandle;
+declare const index_normalizeDidJwk: typeof normalizeDidJwk;
+declare const index_normalizeDidKey: typeof normalizeDidKey;
+declare const index_normalizeDidPkh: typeof normalizeDidPkh;
+declare const index_normalizeDidWeb: typeof normalizeDidWeb;
+declare const index_normalizeDomain: typeof normalizeDomain;
+declare const index_parseArtifactDid: typeof parseArtifactDid;
+declare const index_parseCaip10: typeof parseCaip10;
+declare const index_parseCaip2: typeof parseCaip2;
+declare const index_parseDidUrl: typeof parseDidUrl;
+declare const index_parseJsonStrict: typeof parseJsonStrict;
+declare const index_publicJwkEquals: typeof publicJwkEquals;
+declare const index_resolveDidUrlToControllerDid: typeof resolveDidUrlToControllerDid;
+declare const index_resolveDidUrlToPublicKey: typeof resolveDidUrlToPublicKey;
+declare const index_validateDidAddress: typeof validateDidAddress;
+declare const index_validatePrivateKeyDid: typeof validatePrivateKeyDid;
+declare const index_validatePublicJwk: typeof validatePublicJwk;
+declare const index_verifyDidArtifact: typeof verifyDidArtifact;
+declare namespace index {
+  export { type index_ArtifactVerificationResult as ArtifactVerificationResult, index_AuthorizationMetadata as AuthorizationMetadata, type index_Caip10 as Caip10, type index_Did as Did, type Hex$1 as Hex, index_JwkValidationResult as JwkValidationResult, index_JwsVerificationError as JwsVerificationError, index_JwsVerificationFailure as JwsVerificationFailure, index_JwsVerificationResult as JwsVerificationResult, type index_ParsedArtifactDid as ParsedArtifactDid, type index_ParsedCaip10 as ParsedCaip10, type index_ParsedCaip2 as ParsedCaip2, type index_ParsedDidUrl as ParsedDidUrl, type index_PrivateKeyDidValidation as PrivateKeyDidValidation, index_PublicJwk as PublicJwk, index_PublicKeySource as PublicKeySource, index_ResolveKeyOptions as ResolveKeyOptions, index_ResolvedControllerDid as ResolvedControllerDid, index_ResolvedPublicKey as ResolvedPublicKey, index_VerificationResultInput as VerificationResultInput, index_artifactDidFromBytes as artifactDidFromBytes, index_artifactDidFromJson as artifactDidFromJson, index_assertBareDid as assertBareDid, index_assertJsonSafe as assertJsonSafe, index_buildCaip10 as buildCaip10, index_buildCaip2 as buildCaip2, index_buildDidPkh as buildDidPkh, index_buildDidPkhFromCaip10 as buildDidPkhFromCaip10, index_buildDidWeb as buildDidWeb, index_buildEvmDidPkh as buildEvmDidPkh, index_canonicalizeAndKeccak256 as canonicalizeAndKeccak256, index_canonicalizeForHash as canonicalizeForHash, index_canonicalizeJson as canonicalizeJson, index_computeDidAddress as computeDidAddress, index_computeDidHash as computeDidHash, index_computeJwkThumbprint as computeJwkThumbprint, index_didEthrToDidPkh as didEthrToDidPkh, index_didJwkToJwk as didJwkToJwk, index_didKeyToDidJwk as didKeyToDidJwk, index_didToAddress as didToAddress, index_extractAddressFromDid as extractAddressFromDid, index_extractAuthorizationMetadata as extractAuthorizationMetadata, index_extractControllerEvmAddress as extractControllerEvmAddress, index_extractDidIdentifier as extractDidIdentifier, index_extractDidMethod as extractDidMethod, index_formatJktValue as formatJktValue, index_getAddressFromDidPkh as getAddressFromDidPkh, index_getChainIdFromDidPkh as getChainIdFromDidPkh, index_getDomainFromDidWeb as getDomainFromDidWeb, index_getNamespaceFromDidPkh as getNamespaceFromDidPkh, index_hashCanonicalizedJson as hashCanonicalizedJson, index_isDidUrl as isDidUrl, index_isEvmDidPkh as isEvmDidPkh, index_isPrivateKeyDid as isPrivateKeyDid, index_isSameControllerId as isSameControllerId, index_isValidDid as isValidDid, index_jwkToDidJwk as jwkToDidJwk, index_normalizeCaip10 as normalizeCaip10, index_normalizeDid as normalizeDid, index_normalizeDidHandle as normalizeDidHandle, index_normalizeDidJwk as normalizeDidJwk, index_normalizeDidKey as normalizeDidKey, index_normalizeDidPkh as normalizeDidPkh, index_normalizeDidWeb as normalizeDidWeb, index_normalizeDomain as normalizeDomain, index_parseArtifactDid as parseArtifactDid, index_parseCaip10 as parseCaip10, index_parseCaip2 as parseCaip2, index_parseDidUrl as parseDidUrl, index_parseJsonStrict as parseJsonStrict, index_publicJwkEquals as publicJwkEquals, index_resolveDidUrlToControllerDid as resolveDidUrlToControllerDid, index_resolveDidUrlToPublicKey as resolveDidUrlToPublicKey, index_validateDidAddress as validateDidAddress, index_validatePrivateKeyDid as validatePrivateKeyDid, index_validatePublicJwk as validatePublicJwk, index_verifyDidArtifact as verifyDidArtifact };
+}
+
+export { parseDidUrl as $, type ArtifactVerificationResult as A, extractDidMethod as B, type Caip10 as C, type Did as D, getAddressFromDidPkh as E, getChainIdFromDidPkh as F, getDomainFromDidWeb as G, type Hex$1 as H, getNamespaceFromDidPkh as I, hashCanonicalizedJson as J, isDidUrl as K, isEvmDidPkh as L, isPrivateKeyDid as M, isSameControllerId as N, isValidDid as O, type ParsedArtifactDid as P, normalizeCaip10 as Q, normalizeDid as R, normalizeDidHandle as S, normalizeDidJwk as T, normalizeDidKey as U, normalizeDidPkh as V, normalizeDidWeb as W, normalizeDomain as X, parseArtifactDid as Y, parseCaip10 as Z, parseCaip2 as _, type ParsedCaip10 as a, parseJsonStrict as a0, validateDidAddress as a1, validatePrivateKeyDid as a2, verifyDidArtifact as a3, type ParsedCaip2 as b, type ParsedDidUrl as c, type PrivateKeyDidValidation as d, artifactDidFromBytes as e, artifactDidFromJson as f, assertBareDid as g, assertJsonSafe as h, index as i, buildCaip10 as j, buildCaip2 as k, buildDidPkh as l, buildDidPkhFromCaip10 as m, buildDidWeb as n, buildEvmDidPkh as o, canonicalizeAndKeccak256 as p, canonicalizeForHash as q, canonicalizeJson as r, computeDidAddress as s, computeDidHash as t, didEthrToDidPkh as u, didKeyToDidJwk as v, didToAddress as w, extractAddressFromDid as x, extractControllerEvmAddress as y, extractDidIdentifier as z };