@verana-labs/vs-agent-sdk 2.0.0-dev.9 → 2.0.0-dev.90

package/build/vtFlow/VtFlowOrchestrator.d.ts

@@ -1,10 +1,10 @@
-import { type DidCommJsonLdCredentialDetailFormat, type JsonCredential } from '@credo-ts/didcomm';
-import { VtFlowRecord } from '@verana-labs/credo-ts-didcomm-vt-flow';
+import type { JsonObject } from '@credo-ts/core';
+import type { DidCommDataIntegrityOfferCredentialFormat } from '@credo-ts/didcomm';
+import { VtFlowRecord, type VtFlowCheckParticipantIdContext, type VtFlowEcsIssuanceExemptionContext, type VtFlowIssuance } from '@verana-labs/credo-ts-didcomm-vt-flow';
 import { BaseAgentModules, VsAgent } from '../agent';
-import { VeranaIndexerService } from '../blockchain/VeranaIndexerService';
+import { Participant, ParticipantDto } from '../blockchain/types';
 export interface VtFlowOrchestratorOptions {
     publicApiBaseUrl?: string;
-    indexer?: VeranaIndexerService;
     agentParticipantId?: number;
     walletAgentParticipantId?: number;
 }
@@ -13,13 +13,33 @@ export interface StartOnboardingProcessInput {
     participantSessionId?: string;
     claims?: Record<string, unknown>;
 }
-export interface ValidateAndOfferCredentialInput {
+export interface ValidateOnboardingProcessInput {
     vtFlowRecordId: string;
+    /** Only for a HOLDER. It defaults to the schema of the applicant participant. */
+    credentialSchemaId?: string;
+    credentialType?: string[];
+    credentialContext?: string[];
+}
+export interface ValidateFlowInput {
+    vtFlowRecordId: string;
+    validationFees?: number;
+    issuanceFees?: number;
+    verificationFees?: number;
+    issuanceFeeDiscount?: number;
+    verificationFeeDiscount?: number;
+    effectiveUntil?: string;
+    opSummaryDigest?: string;
+}
+export interface OfferOnboardingCredentialInput {
+    vtFlowRecordId: string;
+    /** The credential validateOnboardingProcess built. Without it the method builds one. */
+    credential?: JsonObject;
+    /** It defaults to the schema of the applicant participant. */
+    credentialSchemaId?: string;
+    /** The participant validateOnboardingProcess returned; saves a second chain read. */
+    participant?: Participant;
     credentialType?: string[];
     credentialContext?: string[];
-    credentialSchemaId: string;
-    agentParticipantId?: number;
-    walletAgentParticipantId?: number;
 }
 export interface AcceptCredentialInput {
     vtFlowRecordId: string;
@@ -29,25 +49,97 @@ export declare class VtFlowOrchestrator {
     private readonly options;
     constructor(agent: VsAgent<BaseAgentModules>, options?: VtFlowOrchestratorOptions);
     startOnboardingProcess(input: StartOnboardingProcessInput): Promise<VtFlowRecord>;
-    validateAndOfferCredential(input: ValidateAndOfferCredentialInput): Promise<VtFlowRecord>;
+    /**
+     * Validate an onboarding process: record the outcome on-chain, accept the onboarding request and
+     * move the record to VALIDATED. It sends no credential. Only a HOLDER takes part in a credential
+     * exchange; an ISSUER, a VERIFIER or a grantor joins the Ecosystem, and SetParticipantOPToValidated
+     * is the whole of it. The caller decides what follows, from the role of the returned participant.
+     *
+     * For a HOLDER it builds the credential before the chain write, and returns it for
+     * offerOnboardingCredential. Claims that do not satisfy the schema, or a schema fetch that fails,
+     * must stop the process while the chain holds no outcome yet and the caller can repeat the call.
+     *
+     * A record that is already VALIDATED and has no credential exchange keeps the chain outcome and
+     * only builds the credential again. A repeat call thus re-drives an offer that did not complete.
+     */
+    validateOnboardingProcess(input: ValidateOnboardingProcessInput): Promise<{
+        record: VtFlowRecord;
+        participant: Participant;
+        credential?: JsonObject;
+    }>;
+    /**
+     * Offer the credential of an onboarding process to its applicant. Call it only for a HOLDER, and
+     * only after validateOnboardingProcess has moved the record to VALIDATED. Give it the credential
+     * that validateOnboardingProcess built, so that the process does not build the credential twice.
+     */
+    offerOnboardingCredential(input: OfferOnboardingCredentialInput): Promise<VtFlowRecord>;
+    /**
+     * Close an onboarding process that carries no credential exchange, on the validator side. The
+     * applicant reaches the same state from the SetParticipantOPToValidated chain event.
+     */
+    completeOnboardingProcess(vtFlowRecordId: string): Promise<VtFlowRecord>;
+    /** [VSA-ADM-VT-FL-VALIDATE] */
+    validateFlow(input: ValidateFlowInput): Promise<VtFlowRecord>;
+    private validateDirectIssuance;
+    private sendValidating;
+    private assertClaims;
+    private assertValidateState;
+    private validationTerms;
+    private assertClaimsAndTerm;
+    private submissionPath;
+    private submitValidation;
+    private preflight;
+    private anchor;
+    resolveValidationTx(recordId: string): Promise<void>;
+    private failUnlessValidated;
+    /**
+     * [VSA-VTI-FLOW-OP-ISSUE]: moves the flow to VALIDATED and fills `validation` from the validated
+     * entry. Without the landed transaction, a recorded broadcast keeps its tx, and its submission
+     * unless that tx failed.
+     */
+    markValidated(recordId: string, entry: ParticipantDto, landed?: {
+        hash: string;
+        height: number;
+        timestamp?: string;
+    }): Promise<VtFlowRecord>;
+    /** rejectFlow ended the flow with its transaction in flight, and no newer flow of the applicant replaced it ([VSA-ADM-VT-FL-REJECT-2]). */
+    isRejectedInFlight(record: VtFlowRecord): Promise<boolean>;
+    continueAfterValidated(recordId: string): Promise<VtFlowRecord>;
+    /** [VSA-ADM-VT-FL-VALIDATE-8]: at startup, resume every flow left in VALIDATION_TX_SUBMITTED. */
+    resumeValidationSubmissions(): Promise<void>;
+    /** [VSA-VTI-FLOW-ISSUE-1]: at startup, resume every anchoring left SUBMITTED through the stored issued credential. */
+    resumeIssuanceSubmissions(): Promise<void>;
     acceptCredential(input: AcceptCredentialInput): Promise<VtFlowRecord>;
     buildDirectIssuanceOffer(vtFlowRecordId: string): Promise<{
         credentialFormats: {
-            jsonld: DidCommJsonLdCredentialDetailFormat;
+            dataIntegrity: DidCommDataIntegrityOfferCredentialFormat;
         };
         issuerParticipantId: number;
     } | null>;
+    /**
+     * Builds the unsigned VC Data Model 2.0 credential that goes into the offer. RFC 0809 derives the
+     * advertised data model version from its context, and the issuer secures it with a
+     * DataIntegrityProof once the applicant requests it.
+     */
     private buildCredential;
+    private resolveJsonSchemaCredentialId;
     /** Per the spec the algorithm comes from the schema, never from the digest value. */
     private digestAlgorithmForSchema;
-    /** Fired after signing and before delivery, so a failure here must abort the issuance. */
-    onCredentialIssued(vtFlowRecordId: string, signedCredential: JsonCredential): Promise<string>;
+    private credentialSchema;
+    /** Fired after signing and before delivery. A failed anchoring comes back in `issuance`, and the credential stays undelivered. */
+    onCredentialIssued(vtFlowRecordId: string, signedCredential: Record<string, unknown>): Promise<{
+        credentialDigest: string;
+        issuance: VtFlowIssuance;
+    }>;
     verifyOfferedCredential(vtFlowRecordId: string): Promise<void>;
+    /** [VSA-VTI-FLOW-FMT-1]. Credo already verified the proof and its assertionMethod key, for data model 2.0 only. */
+    private assertFlowCredentialFormat;
     onCredentialRevoked(vtFlowRecordId: string): Promise<void>;
     onCredentialCompleted(vtFlowRecordId: string): Promise<void>;
-    private triggerResolver;
-    private getOfferedCredentialJson;
-    private requireIndexer;
+    /** The signed credential as the issuer attached it, which is the exact JSON its digest covers. */
+    private getReceivedCredentialJson;
+    checkEcsIssuanceExemption(context: VtFlowEcsIssuanceExemptionContext): Promise<boolean>;
+    checkParticipantId({ record }: VtFlowCheckParticipantIdContext): Promise<boolean | 'validated'>;
     publishCredentialAsLinkedVp(vtFlowRecordId: string): Promise<void>;
     private extractSchemaBaseId;
     rotateRequesterDidToPeer(connectionId: string): Promise<void>;