@credo-ts/didcomm 0.6.0-alpha-20250128162925

package/build/modules/proofs/ProofsModule.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProofsModule = void 0;
+const FeatureRegistry_1 = require("../../FeatureRegistry");
+const MessageHandlerRegistry_1 = require("../../MessageHandlerRegistry");
+const ProofsApi_1 = require("./ProofsApi");
+const ProofsModuleConfig_1 = require("./ProofsModuleConfig");
+const protocol_1 = require("./protocol");
+const repository_1 = require("./repository");
+class ProofsModule {
+    constructor(config) {
+        this.api = ProofsApi_1.ProofsApi;
+        this.config = new ProofsModuleConfig_1.ProofsModuleConfig({
+            ...config,
+            // NOTE: the proofProtocols defaults are set in the ProofsModule rather than the ProofsModuleConfig to
+            // avoid dependency cycles.
+            proofProtocols: config?.proofProtocols ?? [new protocol_1.V2ProofProtocol({ proofFormats: [] })],
+        });
+    }
+    /**
+     * Registers the dependencies of the proofs module on the dependency manager.
+     */
+    register(dependencyManager) {
+        // Config
+        dependencyManager.registerInstance(ProofsModuleConfig_1.ProofsModuleConfig, this.config);
+        // Repositories
+        dependencyManager.registerSingleton(repository_1.ProofRepository);
+    }
+    async initialize(agentContext) {
+        const messageHandlerRegistry = agentContext.dependencyManager.resolve(MessageHandlerRegistry_1.MessageHandlerRegistry);
+        const featureRegistry = agentContext.dependencyManager.resolve(FeatureRegistry_1.FeatureRegistry);
+        for (const proofProtocol of this.config.proofProtocols) {
+            proofProtocol.register(messageHandlerRegistry, featureRegistry);
+        }
+    }
+}
+exports.ProofsModule = ProofsModule;
+//# sourceMappingURL=ProofsModule.js.map

package/build/modules/proofs/ProofsModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProofsModule.js","sourceRoot":"","sources":["../../../src/modules/proofs/ProofsModule.ts"],"names":[],"mappings":";;;AAIA,2DAAuD;AACvD,yEAAqE;AAErE,2CAAuC;AACvC,6DAAyD;AACzD,yCAA4C;AAC5C,6CAA8C;AAa9C,MAAa,YAAY;IAKvB,YAAmB,MAA4C;QAF/C,QAAG,GAA2C,qBAAS,CAAA;QAGrE,IAAI,CAAC,MAAM,GAAG,IAAI,uCAAkB,CAAC;YACnC,GAAG,MAAM;YACT,sGAAsG;YACtG,2BAA2B;YAC3B,cAAc,EAAE,MAAM,EAAE,cAAc,IAAI,CAAC,IAAI,0BAAe,CAAC,EAAE,YAAY,EAAE,EAAE,EAAE,CAAC,CAAC;SACtF,CAAuC,CAAA;IAC1C,CAAC;IAED;;OAEG;IACI,QAAQ,CAAC,iBAAoC;QAClD,SAAS;QACT,iBAAiB,CAAC,gBAAgB,CAAC,uCAAkB,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;QAEnE,eAAe;QACf,iBAAiB,CAAC,iBAAiB,CAAC,4BAAe,CAAC,CAAA;IACtD,CAAC;IAEM,KAAK,CAAC,UAAU,CAAC,YAA0B;QAChD,MAAM,sBAAsB,GAAG,YAAY,CAAC,iBAAiB,CAAC,OAAO,CAAC,+CAAsB,CAAC,CAAA;QAC7F,MAAM,eAAe,GAAG,YAAY,CAAC,iBAAiB,CAAC,OAAO,CAAC,iCAAe,CAAC,CAAA;QAC/E,KAAK,MAAM,aAAa,IAAI,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;YACvD,aAAa,CAAC,QAAQ,CAAC,sBAAsB,EAAE,eAAe,CAAC,CAAA;QACjE,CAAC;IACH,CAAC;CACF;AAhCD,oCAgCC"}

package/build/modules/proofs/ProofsModuleConfig.d.ts

@@ -0,0 +1,34 @@
+import type { ProofProtocol } from './protocol/ProofProtocol';
+import { AutoAcceptProof } from './models/ProofAutoAcceptType';
+/**
+ * ProofsModuleConfigOptions defines the interface for the options of the ProofsModuleConfig class.
+ * This can contain optional parameters that have default values in the config class itself.
+ */
+export interface ProofsModuleConfigOptions<ProofProtocols extends ProofProtocol[]> {
+    /**
+     * Whether to automatically accept proof messages. Applies to all present proof protocol versions.
+     *
+     * @default {@link AutoAcceptProof.Never}
+     */
+    autoAcceptProofs?: AutoAcceptProof;
+    /**
+     * Proof protocols to make available to the proofs module. Only one proof protocol should be registered for each proof
+     * protocol version.
+     *
+     * When not provided, the `V2ProofProtocol` is registered by default.
+     *
+     * @default
+     * ```
+     * [V2ProofProtocol]
+     * ```
+     */
+    proofProtocols: ProofProtocols;
+}
+export declare class ProofsModuleConfig<ProofProtocols extends ProofProtocol[]> {
+    private options;
+    constructor(options: ProofsModuleConfigOptions<ProofProtocols>);
+    /** See {@link ProofsModuleConfigOptions.autoAcceptProofs} */
+    get autoAcceptProofs(): AutoAcceptProof;
+    /** See {@link ProofsModuleConfigOptions.proofProtocols} */
+    get proofProtocols(): ProofProtocols;
+}

package/build/modules/proofs/ProofsModuleConfig.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProofsModuleConfig = void 0;
+const ProofAutoAcceptType_1 = require("./models/ProofAutoAcceptType");
+class ProofsModuleConfig {
+    constructor(options) {
+        this.options = options;
+    }
+    /** See {@link ProofsModuleConfigOptions.autoAcceptProofs} */
+    get autoAcceptProofs() {
+        return this.options.autoAcceptProofs ?? ProofAutoAcceptType_1.AutoAcceptProof.Never;
+    }
+    /** See {@link ProofsModuleConfigOptions.proofProtocols} */
+    get proofProtocols() {
+        return this.options.proofProtocols;
+    }
+}
+exports.ProofsModuleConfig = ProofsModuleConfig;
+//# sourceMappingURL=ProofsModuleConfig.js.map

package/build/modules/proofs/ProofsModuleConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProofsModuleConfig.js","sourceRoot":"","sources":["../../../src/modules/proofs/ProofsModuleConfig.ts"],"names":[],"mappings":";;;AAEA,sEAA8D;AA4B9D,MAAa,kBAAkB;IAG7B,YAAmB,OAAkD;QACnE,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;IACxB,CAAC;IAED,6DAA6D;IAC7D,IAAW,gBAAgB;QACzB,OAAO,IAAI,CAAC,OAAO,CAAC,gBAAgB,IAAI,qCAAe,CAAC,KAAK,CAAA;IAC/D,CAAC;IAED,2DAA2D;IAC3D,IAAW,cAAc;QACvB,OAAO,IAAI,CAAC,OAAO,CAAC,cAAc,CAAA;IACpC,CAAC;CACF;AAhBD,gDAgBC"}

package/build/modules/proofs/errors/PresentationProblemReportReason.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Presentation error code in RFC 0037.
+ *
+ * @see https://github.com/hyperledger/aries-rfcs/blob/main/features/0037-present-proof/README.md
+ */
+export declare enum PresentationProblemReportReason {
+    Abandoned = "abandoned"
+}

package/build/modules/proofs/errors/PresentationProblemReportReason.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PresentationProblemReportReason = void 0;
+/**
+ * Presentation error code in RFC 0037.
+ *
+ * @see https://github.com/hyperledger/aries-rfcs/blob/main/features/0037-present-proof/README.md
+ */
+var PresentationProblemReportReason;
+(function (PresentationProblemReportReason) {
+    PresentationProblemReportReason["Abandoned"] = "abandoned";
+})(PresentationProblemReportReason || (exports.PresentationProblemReportReason = PresentationProblemReportReason = {}));
+//# sourceMappingURL=PresentationProblemReportReason.js.map

package/build/modules/proofs/errors/PresentationProblemReportReason.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PresentationProblemReportReason.js","sourceRoot":"","sources":["../../../../src/modules/proofs/errors/PresentationProblemReportReason.ts"],"names":[],"mappings":";;;AAAA;;;;GAIG;AACH,IAAY,+BAEX;AAFD,WAAY,+BAA+B;IACzC,0DAAuB,CAAA;AACzB,CAAC,EAFW,+BAA+B,+CAA/B,+BAA+B,QAE1C"}

package/build/modules/proofs/errors/index.d.ts

@@ -0,0 +1 @@
+export * from './PresentationProblemReportReason';

package/build/modules/proofs/errors/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./PresentationProblemReportReason"), exports);
+//# sourceMappingURL=index.js.map

package/build/modules/proofs/errors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/modules/proofs/errors/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,oEAAiD"}

package/build/modules/proofs/formats/ProofFormat.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Get the payload for a specific method from a list of ProofFormat interfaces and a method
+ *
+ * @example
+ * ```
+ *
+ * type CreateRequestProofFormats = ProofFormatPayload<[IndyProofFormat, PresentationExchangeProofFormat], 'createRequest'>
+ *
+ * // equal to
+ * type CreateRequestProofFormats = {
+ *  indy: {
+ *   // ... params for indy create request ...
+ *  },
+ *  presentationExchange: {
+ *  // ... params for pex create request ...
+ *  }
+ * }
+ * ```
+ */
+export type ProofFormatPayload<PFs extends ProofFormat[], M extends keyof ProofFormat['proofFormats']> = {
+    [ProofFormat in PFs[number] as ProofFormat['formatKey']]?: ProofFormat['proofFormats'][M];
+};
+/**
+ * Get the input or output for the getCredentialsForRequest and selectCredentialsForRequest method with specific format data
+ *
+ * @example
+ * ```
+ *
+ * type SelectedCredentialsForRequest = ProofFormatCredentialForRequestPayload<[IndyProofFormat, PresentationExchangeProofFormat], 'selectCredentialsForRequest', 'output'>
+ *
+ * // equal to
+ * type SelectedCredentialsForRequest = {
+ *  indy: {
+ *   // ... return value for indy selected credentials ...
+ *  },
+ *  presentationExchange: {
+ *  // ... return value for presentation exchange selected credentials ...
+ *  }
+ * }
+ * ```
+ */
+export type ProofFormatCredentialForRequestPayload<PFs extends ProofFormat[], M extends 'selectCredentialsForRequest' | 'getCredentialsForRequest', IO extends 'input' | 'output'> = {
+    [ProofFormat in PFs[number] as ProofFormat['formatKey']]?: ProofFormat['proofFormats'][M][IO];
+};
+export interface ProofFormat {
+    formatKey: string;
+    proofFormats: {
+        createProposal: unknown;
+        acceptProposal: unknown;
+        createRequest: unknown;
+        acceptRequest: unknown;
+        getCredentialsForRequest: {
+            input: unknown;
+            output: unknown;
+        };
+        selectCredentialsForRequest: {
+            input: unknown;
+            output: unknown;
+        };
+    };
+    formatData: {
+        proposal: unknown;
+        request: unknown;
+        presentation: unknown;
+    };
+}

package/build/modules/proofs/formats/ProofFormat.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ProofFormat.js.map

package/build/modules/proofs/formats/ProofFormat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProofFormat.js","sourceRoot":"","sources":["../../../../src/modules/proofs/formats/ProofFormat.ts"],"names":[],"mappings":""}

package/build/modules/proofs/formats/ProofFormatService.d.ts

@@ -0,0 +1,19 @@
+import type { ProofFormat } from './ProofFormat';
+import type { ProofFormatAcceptProposalOptions, ProofFormatAcceptRequestOptions, ProofFormatCreateProposalOptions, FormatCreateRequestOptions, ProofFormatProcessPresentationOptions, ProofFormatCreateReturn, ProofFormatProcessOptions, ProofFormatGetCredentialsForRequestOptions, ProofFormatGetCredentialsForRequestReturn, ProofFormatSelectCredentialsForRequestOptions, ProofFormatSelectCredentialsForRequestReturn, ProofFormatAutoRespondProposalOptions, ProofFormatAutoRespondRequestOptions, ProofFormatAutoRespondPresentationOptions } from './ProofFormatServiceOptions';
+import type { AgentContext } from '@credo-ts/core';
+export interface ProofFormatService<PF extends ProofFormat = ProofFormat> {
+    formatKey: PF['formatKey'];
+    createProposal(agentContext: AgentContext, options: ProofFormatCreateProposalOptions<PF>): Promise<ProofFormatCreateReturn>;
+    processProposal(agentContext: AgentContext, options: ProofFormatProcessOptions): Promise<void>;
+    acceptProposal(agentContext: AgentContext, options: ProofFormatAcceptProposalOptions<PF>): Promise<ProofFormatCreateReturn>;
+    createRequest(agentContext: AgentContext, options: FormatCreateRequestOptions<PF>): Promise<ProofFormatCreateReturn>;
+    processRequest(agentContext: AgentContext, options: ProofFormatProcessOptions): Promise<void>;
+    acceptRequest(agentContext: AgentContext, options: ProofFormatAcceptRequestOptions<PF>): Promise<ProofFormatCreateReturn>;
+    processPresentation(agentContext: AgentContext, options: ProofFormatProcessPresentationOptions): Promise<boolean>;
+    getCredentialsForRequest(agentContext: AgentContext, options: ProofFormatGetCredentialsForRequestOptions<PF>): Promise<ProofFormatGetCredentialsForRequestReturn<PF>>;
+    selectCredentialsForRequest(agentContext: AgentContext, options: ProofFormatSelectCredentialsForRequestOptions<PF>): Promise<ProofFormatSelectCredentialsForRequestReturn<PF>>;
+    shouldAutoRespondToProposal(agentContext: AgentContext, options: ProofFormatAutoRespondProposalOptions): Promise<boolean>;
+    shouldAutoRespondToRequest(agentContext: AgentContext, options: ProofFormatAutoRespondRequestOptions): Promise<boolean>;
+    shouldAutoRespondToPresentation(agentContext: AgentContext, options: ProofFormatAutoRespondPresentationOptions): Promise<boolean>;
+    supportsFormat(formatIdentifier: string): boolean;
+}

package/build/modules/proofs/formats/ProofFormatService.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ProofFormatService.js.map

package/build/modules/proofs/formats/ProofFormatService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProofFormatService.js","sourceRoot":"","sources":["../../../../src/modules/proofs/formats/ProofFormatService.ts"],"names":[],"mappings":""}

package/build/modules/proofs/formats/ProofFormatServiceOptions.d.ts

@@ -0,0 +1,103 @@
+import type { ProofFormat, ProofFormatCredentialForRequestPayload, ProofFormatPayload } from './ProofFormat';
+import type { ProofFormatService } from './ProofFormatService';
+import type { Attachment } from '../../../decorators/attachment/Attachment';
+import type { ProofFormatSpec } from '../models/ProofFormatSpec';
+import type { ProofExchangeRecord } from '../repository/ProofExchangeRecord';
+/**
+ * Infer the {@link ProofFormat} based on a {@link ProofFormatService}.
+ *
+ * It does this by extracting the `ProofFormat` generic from the `ProofFormatService`.
+ *
+ * @example
+ * ```
+ * // TheProofFormat is now equal to IndyProofFormat
+ * type TheProofFormat = ExtractProofFormat<IndyProofFormatService>
+ * ```
+ *
+ * Because the `IndyProofFormatService` is defined as follows:
+ * ```
+ * class IndyProofFormatService implements ProofFormatService<IndyProofFormat> {
+ * }
+ * ```
+ */
+export type ExtractProofFormat<Type> = Type extends ProofFormatService<infer ProofFormat> ? ProofFormat : never;
+/**
+ * Infer an array of {@link ProofFormat} types based on an array of {@link ProofFormatService} types.
+ *
+ * This is based on {@link ExtractProofFormat}, but allows to handle arrays.
+ */
+export type ExtractProofFormats<PFs extends ProofFormatService[]> = {
+    [PF in keyof PFs]: ExtractProofFormat<PFs[PF]>;
+};
+/**
+ * Base return type for all methods that create an attachment format.
+ *
+ * It requires an attachment and a format to be returned.
+ */
+export interface ProofFormatCreateReturn {
+    format: ProofFormatSpec;
+    attachment: Attachment;
+}
+/**
+ * Base type for all proof process methods.
+ */
+export interface ProofFormatProcessOptions {
+    attachment: Attachment;
+    proofRecord: ProofExchangeRecord;
+}
+export interface ProofFormatProcessPresentationOptions extends ProofFormatProcessOptions {
+    requestAttachment: Attachment;
+}
+export interface ProofFormatCreateProposalOptions<PF extends ProofFormat> {
+    proofRecord: ProofExchangeRecord;
+    proofFormats: ProofFormatPayload<[PF], 'createProposal'>;
+    attachmentId?: string;
+}
+export interface ProofFormatAcceptProposalOptions<PF extends ProofFormat> {
+    proofRecord: ProofExchangeRecord;
+    proofFormats?: ProofFormatPayload<[PF], 'acceptProposal'>;
+    attachmentId?: string;
+    proposalAttachment: Attachment;
+}
+export interface FormatCreateRequestOptions<PF extends ProofFormat> {
+    proofRecord: ProofExchangeRecord;
+    proofFormats: ProofFormatPayload<[PF], 'createRequest'>;
+    attachmentId?: string;
+}
+export interface ProofFormatAcceptRequestOptions<PF extends ProofFormat> {
+    proofRecord: ProofExchangeRecord;
+    proofFormats?: ProofFormatPayload<[PF], 'acceptRequest'>;
+    attachmentId?: string;
+    requestAttachment: Attachment;
+    proposalAttachment?: Attachment;
+}
+export interface ProofFormatGetCredentialsForRequestOptions<PF extends ProofFormat> {
+    proofRecord: ProofExchangeRecord;
+    proofFormats?: ProofFormatCredentialForRequestPayload<[PF], 'getCredentialsForRequest', 'input'>;
+    requestAttachment: Attachment;
+    proposalAttachment?: Attachment;
+}
+export type ProofFormatGetCredentialsForRequestReturn<PF extends ProofFormat> = PF['proofFormats']['getCredentialsForRequest']['output'];
+export interface ProofFormatSelectCredentialsForRequestOptions<PF extends ProofFormat> {
+    proofRecord: ProofExchangeRecord;
+    proofFormats?: ProofFormatCredentialForRequestPayload<[PF], 'selectCredentialsForRequest', 'input'>;
+    requestAttachment: Attachment;
+    proposalAttachment?: Attachment;
+}
+export type ProofFormatSelectCredentialsForRequestReturn<PF extends ProofFormat> = PF['proofFormats']['selectCredentialsForRequest']['output'];
+export interface ProofFormatAutoRespondProposalOptions {
+    proofRecord: ProofExchangeRecord;
+    proposalAttachment: Attachment;
+    requestAttachment: Attachment;
+}
+export interface ProofFormatAutoRespondRequestOptions {
+    proofRecord: ProofExchangeRecord;
+    requestAttachment: Attachment;
+    proposalAttachment: Attachment;
+}
+export interface ProofFormatAutoRespondPresentationOptions {
+    proofRecord: ProofExchangeRecord;
+    proposalAttachment?: Attachment;
+    requestAttachment: Attachment;
+    presentationAttachment: Attachment;
+}

package/build/modules/proofs/formats/ProofFormatServiceOptions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ProofFormatServiceOptions.js.map

package/build/modules/proofs/formats/ProofFormatServiceOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProofFormatServiceOptions.js","sourceRoot":"","sources":["../../../../src/modules/proofs/formats/ProofFormatServiceOptions.ts"],"names":[],"mappings":""}

package/build/modules/proofs/formats/dif-presentation-exchange/DifPresentationExchangeProofFormat.d.ts

@@ -0,0 +1,52 @@
+import type { ProofFormat } from '../ProofFormat';
+import type { DifPexInputDescriptorToCredentials, DifPexCredentialsForRequest, DifPresentationExchangeDefinitionV1, W3cJsonPresentation } from '@credo-ts/core';
+export type DifPresentationExchangeProposal = DifPresentationExchangeDefinitionV1;
+export interface DifPexGetCredentialsForProofRequestOptions {
+}
+export type DifPresentationExchangeRequest = {
+    options?: {
+        challenge?: string;
+        domain?: string;
+    };
+    presentation_definition: DifPresentationExchangeDefinitionV1;
+};
+export type DifPresentationExchangePresentation = W3cJsonPresentation | string;
+export interface DifPresentationExchangeProofFormat extends ProofFormat {
+    formatKey: 'presentationExchange';
+    proofFormats: {
+        createProposal: {
+            presentationDefinition: DifPresentationExchangeDefinitionV1;
+        };
+        acceptProposal: {
+            options?: {
+                challenge?: string;
+                domain?: string;
+            };
+        };
+        createRequest: {
+            presentationDefinition: DifPresentationExchangeDefinitionV1;
+            options?: {
+                challenge?: string;
+                domain?: string;
+            };
+        };
+        acceptRequest: {
+            credentials?: DifPexInputDescriptorToCredentials;
+        };
+        getCredentialsForRequest: {
+            input: DifPexGetCredentialsForProofRequestOptions;
+            output: DifPexCredentialsForRequest;
+        };
+        selectCredentialsForRequest: {
+            input: DifPexGetCredentialsForProofRequestOptions;
+            output: {
+                credentials: DifPexInputDescriptorToCredentials;
+            };
+        };
+    };
+    formatData: {
+        proposal: DifPresentationExchangeProposal;
+        request: DifPresentationExchangeRequest;
+        presentation: DifPresentationExchangePresentation;
+    };
+}

package/build/modules/proofs/formats/dif-presentation-exchange/DifPresentationExchangeProofFormat.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=DifPresentationExchangeProofFormat.js.map

package/build/modules/proofs/formats/dif-presentation-exchange/DifPresentationExchangeProofFormat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DifPresentationExchangeProofFormat.js","sourceRoot":"","sources":["../../../../../src/modules/proofs/formats/dif-presentation-exchange/DifPresentationExchangeProofFormat.ts"],"names":[],"mappings":""}

package/build/modules/proofs/formats/dif-presentation-exchange/DifPresentationExchangeProofFormatService.d.ts

@@ -0,0 +1,31 @@
+import type { DifPresentationExchangeProofFormat } from './DifPresentationExchangeProofFormat';
+import type { ProofFormatService } from '../ProofFormatService';
+import type { ProofFormatCreateProposalOptions, ProofFormatCreateReturn, ProofFormatProcessOptions, ProofFormatAcceptProposalOptions, FormatCreateRequestOptions, ProofFormatAcceptRequestOptions, ProofFormatProcessPresentationOptions, ProofFormatGetCredentialsForRequestOptions, ProofFormatSelectCredentialsForRequestOptions, ProofFormatAutoRespondProposalOptions, ProofFormatAutoRespondRequestOptions, ProofFormatAutoRespondPresentationOptions } from '../ProofFormatServiceOptions';
+import type { AgentContext, DifPexInputDescriptorToCredentials } from '@credo-ts/core';
+export declare class DifPresentationExchangeProofFormatService implements ProofFormatService<DifPresentationExchangeProofFormat> {
+    readonly formatKey: "presentationExchange";
+    private presentationExchangeService;
+    supportsFormat(formatIdentifier: string): boolean;
+    createProposal(agentContext: AgentContext, { proofFormats, attachmentId }: ProofFormatCreateProposalOptions<DifPresentationExchangeProofFormat>): Promise<ProofFormatCreateReturn>;
+    processProposal(agentContext: AgentContext, { attachment }: ProofFormatProcessOptions): Promise<void>;
+    acceptProposal(agentContext: AgentContext, { attachmentId, proposalAttachment, proofFormats, }: ProofFormatAcceptProposalOptions<DifPresentationExchangeProofFormat>): Promise<ProofFormatCreateReturn>;
+    createRequest(agentContext: AgentContext, { attachmentId, proofFormats }: FormatCreateRequestOptions<DifPresentationExchangeProofFormat>): Promise<ProofFormatCreateReturn>;
+    processRequest(agentContext: AgentContext, { attachment }: ProofFormatProcessOptions): Promise<void>;
+    acceptRequest(agentContext: AgentContext, { attachmentId, requestAttachment, proofFormats, }: ProofFormatAcceptRequestOptions<DifPresentationExchangeProofFormat>): Promise<ProofFormatCreateReturn>;
+    private shouldVerifyUsingAnonCredsDataIntegrity;
+    processPresentation(agentContext: AgentContext, { requestAttachment, attachment, proofRecord }: ProofFormatProcessPresentationOptions): Promise<boolean>;
+    getCredentialsForRequest(agentContext: AgentContext, { requestAttachment }: ProofFormatGetCredentialsForRequestOptions<DifPresentationExchangeProofFormat>): Promise<import("@credo-ts/core").DifPexCredentialsForRequest>;
+    selectCredentialsForRequest(agentContext: AgentContext, { requestAttachment }: ProofFormatSelectCredentialsForRequestOptions<DifPresentationExchangeProofFormat>): Promise<{
+        credentials: DifPexInputDescriptorToCredentials;
+    }>;
+    shouldAutoRespondToProposal(_agentContext: AgentContext, { requestAttachment, proposalAttachment }: ProofFormatAutoRespondProposalOptions): Promise<boolean>;
+    shouldAutoRespondToRequest(_agentContext: AgentContext, { requestAttachment, proposalAttachment }: ProofFormatAutoRespondRequestOptions): Promise<boolean>;
+    /**
+     *
+     * The presentation is already verified in processPresentation, so we can just return true here.
+     * It's only an ack, so it's just that we received the presentation.
+     *
+     */
+    shouldAutoRespondToPresentation(_agentContext: AgentContext, _options: ProofFormatAutoRespondPresentationOptions): Promise<boolean>;
+    private getFormatData;
+}