@sphereon/ssi-sdk-ext.did-utils 0.28.1-feature.oyd.cmsm.improv.21 → 0.28.1-next.53

package/dist/index.d.ts

@@ -1,3 +1,272 @@
-export * from './did-functions';
-export * from './types';
-//# sourceMappingURL=index.d.ts.map
+import { TKeyType, JwkKeyUse } from '@sphereon/ssi-sdk-ext.key-utils';
+import { JWK } from '@sphereon/ssi-types';
+import { IIdentifier, IAgentContext, IKeyManager, IDIDManager, IResolver, DIDDocumentSection, DIDDocument, IKey, DIDResolutionResult } from '@veramo/core';
+import { _ExtendedIKey, _NormalizedVerificationMethod, _ExtendedVerificationMethod } from '@veramo/utils';
+import { JWTVerifyOptions, JWTHeader, JWTPayload, Signer } from 'did-jwt';
+import { Resolvable, VerificationMethod, DIDResolutionOptions } from 'did-resolver';
+
+declare enum SupportedDidMethodEnum {
+    DID_ETHR = "ethr",
+    DID_KEY = "key",
+    DID_LTO = "lto",
+    DID_ION = "ion",
+    DID_EBSI = "ebsi",
+    DID_JWK = "jwk",
+    DID_OYD = "oyd"
+}
+declare enum IdentifierAliasEnum {
+    PRIMARY = "primary"
+}
+interface ResolveOpts {
+    jwtVerifyOpts?: JWTVerifyOptions;
+    resolver?: Resolvable;
+    resolveUrl?: string;
+    noUniversalResolverFallback?: boolean;
+    subjectSyntaxTypesSupported?: string[];
+}
+/**
+ * @deprecated Replaced by the identifier resolution service
+ */
+interface IDIDOptions {
+    resolveOpts?: ResolveOpts;
+    idOpts: LegacyIIdentifierOpts;
+    supportedDIDMethods?: string[];
+}
+type IdentifierProviderOpts = {
+    type?: TKeyType;
+    use?: string;
+    method?: SupportedDidMethodEnum;
+    [x: string]: any;
+};
+type CreateIdentifierOpts = {
+    method: SupportedDidMethodEnum;
+    createOpts?: CreateIdentifierCreateOpts;
+};
+type CreateIdentifierCreateOpts = {
+    kms?: string;
+    alias?: string;
+    options?: IdentifierProviderOpts;
+};
+type CreateOrGetIdentifierOpts = {
+    method: SupportedDidMethodEnum;
+    createOpts?: CreateIdentifierCreateOpts;
+};
+declare const DID_PREFIX = "did:";
+interface GetOrCreateResult<T> {
+    created: boolean;
+    result: T;
+}
+/**
+ * @deprecated Replaced by new signer
+ */
+type SignJwtArgs = {
+    idOpts: LegacyIIdentifierOpts;
+    header: Partial<JWTHeader>;
+    payload: Partial<JWTPayload>;
+    options: {
+        issuer: string;
+        expiresIn?: number;
+        canonicalize?: boolean;
+    };
+    context: IRequiredSignAgentContext;
+};
+/**
+ * @deprecated Replaced by new signer
+ */
+type GetSignerArgs = {
+    idOpts: LegacyIIdentifierOpts;
+    context: IRequiredSignAgentContext;
+};
+/**
+ * @deprecated Replaced by the identifier resolution service
+ */
+type LegacyIIdentifierOpts = {
+    identifier: IIdentifier | string;
+};
+type IRequiredSignAgentContext = IAgentContext<IKeyManager & IDIDManager & IResolver>;
+
+declare const getAuthenticationKey: ({ identifier, offlineWhenNoDIDRegistered, noVerificationMethodFallback, keyType, controllerKey, }: {
+    identifier: IIdentifier;
+    keyType?: TKeyType;
+    offlineWhenNoDIDRegistered?: boolean;
+    noVerificationMethodFallback?: boolean;
+    controllerKey?: boolean;
+}, context: IAgentContext<IResolver & IDIDManager>) => Promise<_ExtendedIKey>;
+declare const getFirstKeyWithRelation: ({ identifier, offlineWhenNoDIDRegistered, noVerificationMethodFallback, keyType, controllerKey, vmRelationship, }: {
+    identifier: IIdentifier;
+    keyType?: TKeyType;
+    offlineWhenNoDIDRegistered?: boolean;
+    noVerificationMethodFallback?: boolean;
+    controllerKey?: boolean;
+    vmRelationship: DIDDocumentSection;
+}, context: IAgentContext<IResolver & IDIDManager>) => Promise<_ExtendedIKey>;
+declare const getOrCreatePrimaryIdentifier: (context: IAgentContext<IDIDManager>, opts?: CreateOrGetIdentifierOpts) => Promise<GetOrCreateResult<IIdentifier>>;
+declare const getPrimaryIdentifier: (context: IAgentContext<IDIDManager>, opts?: IdentifierProviderOpts) => Promise<IIdentifier | undefined>;
+declare const createIdentifier: (context: IAgentContext<IDIDManager>, opts?: CreateIdentifierOpts) => Promise<IIdentifier>;
+declare const getFirstKeyWithRelationFromDIDDoc: ({ identifier, vmRelationship, keyType, errorOnNotFound, didDocument, controllerKey, }: {
+    identifier: IIdentifier;
+    controllerKey?: boolean;
+    vmRelationship?: DIDDocumentSection;
+    keyType?: TKeyType;
+    errorOnNotFound?: boolean;
+    didDocument?: DIDDocument;
+}, context: IAgentContext<IResolver & IDIDManager>) => Promise<_ExtendedIKey | undefined>;
+declare const getEthereumAddressFromKey: ({ key }: {
+    key: IKey;
+}) => any;
+declare const getControllerKey: ({ identifier }: {
+    identifier: IIdentifier;
+}) => IKey;
+declare const getKeys: ({ jwkThumbprint, kms, identifier, kmsKeyRef, keyType, controllerKey, }: {
+    identifier: IIdentifier;
+    kmsKeyRef?: string;
+    keyType?: TKeyType;
+    kms?: string;
+    jwkThumbprint?: string;
+    controllerKey?: boolean;
+}) => IKey[];
+/**
+ * Dereferences keys from DID document and normalizes them for easy comparison.
+ *
+ * When dereferencing keyAgreement keys, only Ed25519 and X25519 curves are supported.
+ * Other key types are omitted from the result and Ed25519 keys are converted to X25519
+ *
+ * @returns a Promise that resolves to the list of dereferenced keys.
+ *
+ * @beta This API may change without a BREAKING CHANGE notice.
+ */
+declare function dereferenceDidKeysWithJwkSupport(didDocument: DIDDocument, section: DIDDocumentSection | undefined, context: IAgentContext<IResolver>): Promise<_NormalizedVerificationMethod[]>;
+declare function jwkTtoPublicKeyHex(jwk: JWK): string;
+/**
+ * Converts the publicKey of a VerificationMethod to hex encoding (publicKeyHex)
+ *
+ * @param pk - the VerificationMethod to be converted
+ * @param convert - when this flag is set to true, Ed25519 keys are converted to their X25519 pairs
+ * @returns the hex encoding of the public key
+ *
+ * @beta This API may change without a BREAKING CHANGE notice.
+ */
+declare function extractPublicKeyHexWithJwkSupport(pk: _ExtendedVerificationMethod, convert?: boolean): string;
+declare function isEvenHexString(hex: string): boolean;
+/**
+ * Converts the publicKey of a VerificationMethod to hex encoding (publicKeyHex)
+ *
+ * @param pk - the VerificationMethod to be converted
+ * @param convert - when this flag is set to true, Ed25519 keys are converted to their X25519 pairs
+ * @returns the hex encoding of the public key
+ *
+ * @beta This API may change without a BREAKING CHANGE notice.
+ */
+declare function extractPublicKeyHex(pk: _ExtendedVerificationMethod, convert?: boolean): string;
+declare function verificationMethodToJwk(vm: VerificationMethod, errorOnNotFound?: boolean): JWK | null;
+type DidDocumentJwks = Record<Exclude<DIDDocumentSection, 'publicKey' | 'service'>, Array<JWK>>;
+declare function didDocumentToJwks(didDocument: DIDDocument): DidDocumentJwks;
+/**
+ * Maps the keys of a locally managed {@link @veramo/core#IIdentifier | IIdentifier} to the corresponding
+ * {@link did-resolver#VerificationMethod | VerificationMethod} entries from the DID document.
+ *
+ * @param identifier - the identifier to be mapped
+ * @param section - the section of the DID document to be mapped (see
+ *   {@link https://www.w3.org/TR/did-core/#verification-relationships | verification relationships}), but can also be
+ *   `verificationMethod` to map all the keys.
+ * @param didDocument
+ * @param context - the veramo agent context, which must contain a {@link @veramo/core#IResolver | IResolver}
+ *   implementation that can resolve the DID document of the identifier.
+ *
+ * @returns an array of mapped keys. The corresponding verification method is added to the `meta.verificationMethod`
+ *   property of the key.
+ *
+ * @beta This API may change without a BREAKING CHANGE notice.
+ */
+declare function mapIdentifierKeysToDocWithJwkSupport({ identifier, vmRelationship, didDocument, kmsKeyRef, }: {
+    identifier: IIdentifier;
+    vmRelationship?: DIDDocumentSection;
+    didDocument?: DIDDocument;
+    kmsKeyRef?: string;
+}, context: IAgentContext<IResolver & IDIDManager>): Promise<_ExtendedIKey[]>;
+declare function getAgentDIDMethods(context: IAgentContext<IDIDManager>): Promise<string[]>;
+declare function getDID(idOpts: {
+    identifier: IIdentifier | string;
+}): string;
+declare function toDID(identifier: string | IIdentifier | Partial<IIdentifier>): string;
+declare function toDIDs(identifiers?: (string | IIdentifier | Partial<IIdentifier>)[]): string[];
+declare function getKey({ identifier, vmRelationship, kmsKeyRef, }: {
+    identifier: IIdentifier;
+    vmRelationship?: DIDDocumentSection;
+    kmsKeyRef?: string;
+}, context: IAgentContext<IResolver & IDIDManager>): Promise<_ExtendedIKey>;
+/**
+ * Get the real kid as used in JWTs. This is the kid in the VM or in the JWT, not the kid in the Veramo/Sphereon keystore. That was just a poorly chosen name
+ * @param key
+ * @param idOpts
+ * @param context
+ */
+declare function determineKid({ key, idOpts, }: {
+    key: IKey;
+    idOpts: {
+        identifier: IIdentifier | string;
+        kmsKeyRef?: string;
+    };
+}, context: IAgentContext<IResolver & IDIDManager>): Promise<string>;
+declare function getSupportedDIDMethods(didOpts: IDIDOptions, context: IAgentContext<IDIDManager>): Promise<string[]>;
+declare function getAgentResolver(context: IAgentContext<IResolver & IDIDManager>, opts?: {
+    localResolution?: boolean;
+    uniresolverResolution?: boolean;
+    resolverResolution?: boolean;
+}): Resolvable;
+declare class AgentDIDResolver implements Resolvable {
+    private readonly context;
+    private readonly resolverResolution;
+    private readonly uniresolverResolution;
+    private readonly localResolution;
+    constructor(context: IAgentContext<IResolver & IDIDManager>, opts?: {
+        uniresolverResolution?: boolean;
+        localResolution?: boolean;
+        resolverResolution?: boolean;
+    });
+    resolve(didUrl: string, options?: DIDResolutionOptions): Promise<DIDResolutionResult>;
+}
+/**
+ * Please note that this is not an exact representation of the actual DID Document.
+ *
+ * We try to do our best, to map keys onto relevant verification methods and relationships, but we simply lack the context
+ * of the actual DID method here. Do not relly on this method for DID resolution. It is only handy for offline use cases
+ * when no DID Document is cached. For DID:WEB it does provide an accurate representation!
+ *
+ * @param identifier
+ * @param opts
+ */
+declare function toDidDocument(identifier?: IIdentifier, opts?: {
+    did?: string;
+    use?: JwkKeyUse[];
+}): DIDDocument | undefined;
+declare function toDidResolutionResult(identifier?: IIdentifier, opts?: {
+    did?: string;
+    supportedMethods?: string[];
+}): DIDResolutionResult;
+declare function asDidWeb(hostnameOrDID: string): Promise<string>;
+/**
+ * @deprecated Replaced by the new signer service
+ */
+declare const signDidJWT: (args: SignJwtArgs) => Promise<string>;
+/**
+ * @deprecated Replaced by the new signer service
+ */
+declare const getDidSigner: (args: GetSignerArgs & {
+    idOpts: {
+        /**
+         * @deprecated
+         */
+        identifier: IIdentifier | string;
+        /**
+         * @deprecated
+         */
+        verificationMethodSection?: DIDDocumentSection;
+        /**
+         * @deprecated
+         */
+        kmsKeyRef?: string;
+    };
+}) => Promise<Signer>;
+
+export { AgentDIDResolver, type CreateIdentifierCreateOpts, type CreateIdentifierOpts, type CreateOrGetIdentifierOpts, DID_PREFIX, type DidDocumentJwks, type GetOrCreateResult, type GetSignerArgs, type IDIDOptions, type IRequiredSignAgentContext, IdentifierAliasEnum, type IdentifierProviderOpts, type ResolveOpts, type SignJwtArgs, SupportedDidMethodEnum, asDidWeb, createIdentifier, dereferenceDidKeysWithJwkSupport, determineKid, didDocumentToJwks, extractPublicKeyHex, extractPublicKeyHexWithJwkSupport, getAgentDIDMethods, getAgentResolver, getAuthenticationKey, getControllerKey, getDID, getDidSigner, getEthereumAddressFromKey, getFirstKeyWithRelation, getFirstKeyWithRelationFromDIDDoc, getKey, getKeys, getOrCreatePrimaryIdentifier, getPrimaryIdentifier, getSupportedDIDMethods, isEvenHexString, jwkTtoPublicKeyHex, mapIdentifierKeysToDocWithJwkSupport, signDidJWT, toDID, toDIDs, toDidDocument, toDidResolutionResult, verificationMethodToJwk };