@verana-labs/vs-agent-sdk 2.0.0-dev.70 → 2.0.0-dev.73

package/build/vtFlow/VtFlowOrchestrator.js

@@ -17,6 +17,8 @@ const DISCOUNT_SCALE = 10000;
 const TX_LOOKUP_TIMEOUT_MS = 60000;
 const TX_LOOKUP_INTERVAL_MS = 3000;
 const FEE_DENOM = 'uvna';
+// the notification handler and the tx lookup can both reach markValidated for one flow at the same time
+const markingValidated = new Set();
 const FEE_KEYS = ['validationFees', 'issuanceFees', 'verificationFees'];
 const DISCOUNT_KEYS = ['issuanceFeeDiscount', 'verificationFeeDiscount'];
 function invalidInput(message) {
@@ -87,9 +89,7 @@ class VtFlowOrchestrator {
         }))
             .filter(record => !(0, credo_ts_didcomm_vt_flow_1.isVtFlowTerminalState)(record.state))
             .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
-        const running = latest !== undefined &&
-            latest.state !== credo_ts_didcomm_vt_flow_1.VtFlowState.Completed &&
-            latest.state !== credo_ts_didcomm_vt_flow_1.VtFlowState.CredRevoked;
+        const running = latest !== undefined && !(0, credo_ts_didcomm_vt_flow_1.isVtFlowRenewable)(latest);
         let connectionId;
         if (latest) {
             const connection = await this.agent.didcomm.connections.findById(latest.connectionId);
@@ -183,7 +183,7 @@ class VtFlowOrchestrator {
      * that validateOnboardingProcess built, so that the process does not build the credential twice.
      */
     async offerOnboardingCredential(input) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         this.requireChain();
         const vtFlowApi = this.resolveVtFlowApi();
         const record = await vtFlowApi.findById(input.vtFlowRecordId);
@@ -200,6 +200,8 @@ class VtFlowOrchestrator {
             claims: ((_d = record.claims) !== null && _d !== void 0 ? _d : {}),
             credentialType: input.credentialType,
             credentialContext: input.credentialContext,
+            // [VSA-VTI-FLOW-FMT-1]: markValidated sets it from the entry on every pass, a renewal included
+            validUntil: (_e = record.validation) === null || _e === void 0 ? void 0 : _e.effectiveUntil,
         }));
         // W3C Data Integrity attachment format (RFC 0809). The applicant DID is the credential subject
         // and the exchange runs over its authenticated connection, so no extra binding is required. The
@@ -222,6 +224,7 @@ class VtFlowOrchestrator {
     }
     /** [VSA-ADM-VT-FL-VALIDATE] */
     async validateFlow(input) {
+        var _a, _b;
         this.requireChain();
         const vtFlowApi = this.resolveVtFlowApi();
         const record = await vtFlowApi.findById(input.vtFlowRecordId);
@@ -230,24 +233,38 @@ class VtFlowOrchestrator {
         }
         if (record.role !== credo_ts_didcomm_vt_flow_1.VtFlowRole.Validator)
             throw invalidState('validate is a validator action');
+        const reissue = record.state === credo_ts_didcomm_vt_flow_1.VtFlowState.CredOffered && ((_b = (_a = record.issuance) === null || _a === void 0 ? void 0 : _a.tx) === null || _b === void 0 ? void 0 : _b.status) === credo_ts_didcomm_vt_flow_1.VtFlowTxStatus.Failed;
+        if (reissue && record.credentialExchangeRecordId) {
+            const { record: issued } = await vtFlowApi.issueCredentialForSession({
+                vtFlowRecordId: record.id,
+                credentialExchangeRecordId: record.credentialExchangeRecordId,
+            });
+            return issued;
+        }
         if (record.variant === credo_ts_didcomm_vt_flow_1.VtFlowVariant.DirectIssuance)
             return this.validateDirectIssuance(record);
         if (!record.applicantParticipantId)
             throw invalidState('the flow names no applicant participant');
         const applicant = await this.agent.indexer.getParticipant(record.applicantParticipantId);
         const entryValidated = applicant.op_state === 'VALIDATED';
-        this.assertValidateState(record, entryValidated);
+        const rejectedInFlight = entryValidated && (await this.isRejectedInFlight(record));
+        if (!rejectedInFlight) {
+            this.assertValidateState(record, entryValidated);
+            if (record.connectionTerminated)
+                throw invalidState('the flow connection is TERMINATED until the applicant reconnects');
+        }
         const terms = this.validationTerms(input, applicant, record);
         await this.assertClaimsAndTerm(record, applicant, terms);
-        if (record.state === credo_ts_didcomm_vt_flow_1.VtFlowState.AwaitingOr)
-            await vtFlowApi.acceptOnboardingRequest(record.id);
+        // [VSA-VTI-FLOW-OP-ISSUE-6]: the connection stays TERMINATED, so issuance waits for the applicant to reconnect
+        if (rejectedInFlight)
+            return this.markValidated(record.id, applicant);
         if (record.state === credo_ts_didcomm_vt_flow_1.VtFlowState.OobPending)
             await this.sendValidating(record);
         if (record.state === credo_ts_didcomm_vt_flow_1.VtFlowState.ValidatedPendingClaims)
             return this.continueAfterValidated(record.id);
         if (entryValidated) {
             if (record.state !== credo_ts_didcomm_vt_flow_1.VtFlowState.Validated)
-                await vtFlowApi.markValidated(record.id);
+                await this.markValidated(record.id, applicant);
             return this.continueAfterValidated(record.id);
         }
         const validation = Object.assign({ decidedAt: new Date().toISOString(), submission: await this.submissionPath(applicant) }, terms);
@@ -292,7 +309,6 @@ class VtFlowOrchestrator {
     }
     assertValidateState(record, entryValidated) {
         const accepted = [
-            credo_ts_didcomm_vt_flow_1.VtFlowState.AwaitingOr,
             credo_ts_didcomm_vt_flow_1.VtFlowState.Validating,
             credo_ts_didcomm_vt_flow_1.VtFlowState.OobPending,
             credo_ts_didcomm_vt_flow_1.VtFlowState.ValidationTxFailed,
@@ -301,6 +317,7 @@ class VtFlowOrchestrator {
         // Once the entry is VALIDATED on chain any validator-side state resumes into issuance, which is
         // how a backend that disabled the default notification handler drives the flow ([VSA-ADM-VT-FL-VALIDATE-11]).
         const acceptedOnceValidated = [
+            credo_ts_didcomm_vt_flow_1.VtFlowState.AwaitingOr,
             credo_ts_didcomm_vt_flow_1.VtFlowState.AwaitingValidationTx,
             credo_ts_didcomm_vt_flow_1.VtFlowState.ValidationTxSubmitted,
             credo_ts_didcomm_vt_flow_1.VtFlowState.Validated,
@@ -365,8 +382,7 @@ class VtFlowOrchestrator {
         this.assertClaims(schema.json_schema, applicant.did, record.claims);
         // An ECS Organization or Persona credential needs a validUntil. With a validity period of 0 the
         // VPR sets no effective_until, so the call has to carry one.
-        const ecsKey = await (0, vs_agent_model_1.classifyEcsSchema)(schema.json_schema);
-        const needsValidUntil = ecsKey === vs_agent_model_1.ECS.ORG || ecsKey === vs_agent_model_1.ECS.PERSONA;
+        const needsValidUntil = (0, vs_agent_model_1.ecsRequiresValidUntil)(await (0, vs_agent_model_1.classifyEcsSchema)(schema.json_schema));
         if (needsValidUntil && ((_a = schema.holder_validation_validity_period) !== null && _a !== void 0 ? _a : 0) === 0 && !terms.effectiveUntil) {
             throw invalidInput('this schema has no validity period, so effectiveUntil is required');
         }
@@ -387,55 +403,79 @@ class VtFlowOrchestrator {
             : credo_ts_didcomm_vt_flow_1.VtFlowSubmission.Operator;
     }
     async submitValidation(recordId, applicant, validation) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b;
         const chain = this.requireChain();
         const vtFlowApi = this.resolveVtFlowApi();
         const fail = (reason, error) => vtFlowApi.recordValidation(recordId, Object.assign(Object.assign({}, validation), { tx: { status: credo_ts_didcomm_vt_flow_1.VtFlowTxStatus.Failed, reason, error } }), credo_ts_didcomm_vt_flow_1.VtFlowState.ValidationTxFailed);
-        const grant = applicant.validator_participant_id == null
-            ? undefined
-            : (_a = this.agent.authorizationService) === null || _a === void 0 ? void 0 : _a.getVsOperatorAuthorizationRecord(applicant.validator_participant_id);
-        const granter = (grant === null || grant === void 0 ? void 0 : grant.withFeegrant) ? chain.corporation : undefined;
         const message = chain.setParticipantOPToValidatedMsg({
             id: applicant.id,
             effectiveUntil: validation.effectiveUntil ? new Date(validation.effectiveUntil) : undefined,
             validationFees: validation.validationFees,
             issuanceFees: validation.issuanceFees,
             verificationFees: validation.verificationFees,
-            issuanceFeeDiscount: Math.round(((_b = validation.issuanceFeeDiscount) !== null && _b !== void 0 ? _b : 0) * DISCOUNT_SCALE),
-            verificationFeeDiscount: Math.round(((_c = validation.verificationFeeDiscount) !== null && _c !== void 0 ? _c : 0) * DISCOUNT_SCALE),
+            issuanceFeeDiscount: Math.round(((_a = validation.issuanceFeeDiscount) !== null && _a !== void 0 ? _a : 0) * DISCOUNT_SCALE),
+            verificationFeeDiscount: Math.round(((_b = validation.verificationFeeDiscount) !== null && _b !== void 0 ? _b : 0) * DISCOUNT_SCALE),
             opSummaryDigest: validation.opSummaryDigest,
         });
+        const checked = await this.preflight(message, applicant.validator_participant_id);
+        if ('reason' in checked)
+            return fail(checked.reason, checked.error);
+        let hash;
+        try {
+            hash = await chain.broadcastWithoutWaiting([message], checked.fee);
+        }
+        catch (error) {
+            return fail(credo_ts_didcomm_vt_flow_1.VtFlowTxReason.BroadcastError, errorMessage(error));
+        }
+        const submitted = await vtFlowApi.recordValidation(recordId, Object.assign(Object.assign({}, validation), { tx: { hash, submittedAt: new Date().toISOString(), status: credo_ts_didcomm_vt_flow_1.VtFlowTxStatus.Submitted } }), credo_ts_didcomm_vt_flow_1.VtFlowState.ValidationTxSubmitted);
+        void this.resolveValidationTx(recordId).catch(error => this.agent.config.logger.error(`[vt-flow] resolving the validation of ${recordId} failed`, {
+            error: errorMessage(error),
+        }));
+        return submitted;
+    }
+    // [VSA-ADM-VT-FL-VALIDATE-6]: the fee payer is the Corporation when the grant of the entry has with_feegrant
+    async preflight(message, participantId) {
+        var _a, _b, _c;
+        const chain = this.requireChain();
+        const grant = participantId == null
+            ? undefined
+            : (_a = this.agent.authorizationService) === null || _a === void 0 ? void 0 : _a.getVsOperatorAuthorizationRecord(participantId);
+        const granter = (grant === null || grant === void 0 ? void 0 : grant.withFeegrant) ? chain.corporation : undefined;
+        const failed = (reason, error) => ({
+            reason,
+            error,
+        });
         let allowance;
         try {
             allowance = granter ? await chain.feeAllowance(granter, FEE_DENOM) : undefined;
         }
         catch (error) {
-            return fail(credo_ts_didcomm_vt_flow_1.VtFlowTxReason.PreflightError, errorMessage(error));
+            return failed(credo_ts_didcomm_vt_flow_1.VtFlowTxReason.PreflightError, errorMessage(error));
         }
         if (granter && !allowance) {
-            return fail(credo_ts_didcomm_vt_flow_1.VtFlowTxReason.FeegrantExpired, 'the Corporation grants the agent no active fee allowance');
+            return failed(credo_ts_didcomm_vt_flow_1.VtFlowTxReason.FeegrantExpired, 'the Corporation grants the agent no active fee allowance');
         }
         let fee;
         try {
             fee = await chain.estimateFee([message], granter);
         }
         catch (error) {
-            return fail(credo_ts_didcomm_vt_flow_1.VtFlowTxReason.PreflightError, errorMessage(error));
+            return failed(credo_ts_didcomm_vt_flow_1.VtFlowTxReason.PreflightError, errorMessage(error));
         }
-        const amount = BigInt((_e = (_d = fee.amount.find(coin => coin.denom === FEE_DENOM)) === null || _d === void 0 ? void 0 : _d.amount) !== null && _e !== void 0 ? _e : '0');
+        const amount = BigInt((_c = (_b = fee.amount.find(coin => coin.denom === FEE_DENOM)) === null || _b === void 0 ? void 0 : _b.amount) !== null && _c !== void 0 ? _c : '0');
         if (granter && allowance) {
             if (!allowance.unlimited && allowance.remaining < amount) {
-                return fail(credo_ts_didcomm_vt_flow_1.VtFlowTxReason.FeegrantExhausted, `the fee allowance has ${allowance.remaining}${FEE_DENOM} left`);
+                return failed(credo_ts_didcomm_vt_flow_1.VtFlowTxReason.FeegrantExhausted, `the fee allowance has ${allowance.remaining}${FEE_DENOM} left`);
             }
             let corporation;
             try {
                 corporation = BigInt((await chain.getAccountBalance(granter, FEE_DENOM)).amount);
             }
             catch (error) {
-                return fail(credo_ts_didcomm_vt_flow_1.VtFlowTxReason.PreflightError, errorMessage(error));
+                return failed(credo_ts_didcomm_vt_flow_1.VtFlowTxReason.PreflightError, errorMessage(error));
             }
             if (corporation < amount) {
-                return fail(credo_ts_didcomm_vt_flow_1.VtFlowTxReason.InsufficientFundsCorporation, `the Corporation holds ${corporation}${FEE_DENOM}`);
+                return failed(credo_ts_didcomm_vt_flow_1.VtFlowTxReason.InsufficientFundsCorporation, `the Corporation holds ${corporation}${FEE_DENOM}`);
             }
         }
         else {
@@ -444,24 +484,55 @@ class VtFlowOrchestrator {
                 own = BigInt((await chain.getBalance(FEE_DENOM)).amount);
             }
             catch (error) {
-                return fail(credo_ts_didcomm_vt_flow_1.VtFlowTxReason.PreflightError, errorMessage(error));
+                return failed(credo_ts_didcomm_vt_flow_1.VtFlowTxReason.PreflightError, errorMessage(error));
             }
             if (own < amount) {
-                return fail(credo_ts_didcomm_vt_flow_1.VtFlowTxReason.InsufficientFundsAgent, `the agent account holds ${own}${FEE_DENOM}`);
+                return failed(credo_ts_didcomm_vt_flow_1.VtFlowTxReason.InsufficientFundsAgent, `the agent account holds ${own}${FEE_DENOM}`);
             }
         }
-        let hash;
-        try {
-            hash = await chain.broadcastWithoutWaiting([message], fee);
+        return { fee };
+    }
+    // [VSA-VTI-FLOW-ISSUE-1]: [VSA-ADM-VT-FL-VALIDATE-6] to -9 applied to the anchoring, which the delivery waits for.
+    // A transaction left SUBMITTED by a restart is looked up again, not broadcast twice.
+    async anchor(record, message, issuerParticipantId) {
+        var _a, _b, _c;
+        const chain = this.requireChain();
+        const pending = ((_b = (_a = record.issuance) === null || _a === void 0 ? void 0 : _a.tx) === null || _b === void 0 ? void 0 : _b.status) === credo_ts_didcomm_vt_flow_1.VtFlowTxStatus.Submitted ? record.issuance.tx : undefined;
+        let hash = pending === null || pending === void 0 ? void 0 : pending.hash;
+        let submittedAt = (_c = pending === null || pending === void 0 ? void 0 : pending.submittedAt) !== null && _c !== void 0 ? _c : new Date().toISOString();
+        if (!hash) {
+            const checked = await this.preflight(message, issuerParticipantId);
+            if ('reason' in checked)
+                return Object.assign({ status: credo_ts_didcomm_vt_flow_1.VtFlowTxStatus.Failed }, checked);
+            try {
+                hash = await chain.broadcastWithoutWaiting([message], checked.fee);
+            }
+            catch (error) {
+                return {
+                    status: credo_ts_didcomm_vt_flow_1.VtFlowTxStatus.Failed,
+                    reason: credo_ts_didcomm_vt_flow_1.VtFlowTxReason.BroadcastError,
+                    error: errorMessage(error),
+                };
+            }
+            submittedAt = new Date().toISOString();
+            await this.resolveVtFlowApi().recordIssuance(record.id, {
+                tx: { hash, submittedAt, status: credo_ts_didcomm_vt_flow_1.VtFlowTxStatus.Submitted },
+            });
         }
-        catch (error) {
-            return fail(credo_ts_didcomm_vt_flow_1.VtFlowTxReason.BroadcastError, errorMessage(error));
+        for (;;) {
+            const tx = await chain.findTx(hash).catch(() => undefined);
+            if ((tx === null || tx === void 0 ? void 0 : tx.code) === 0)
+                return { hash, submittedAt, height: tx.height, status: credo_ts_didcomm_vt_flow_1.VtFlowTxStatus.Succeeded };
+            if (tx) {
+                const failure = { status: credo_ts_didcomm_vt_flow_1.VtFlowTxStatus.Failed, reason: credo_ts_didcomm_vt_flow_1.VtFlowTxReason.TxFailed, error: tx.rawLog };
+                return Object.assign({ hash, submittedAt, height: tx.height }, failure);
+            }
+            if (Date.now() - Date.parse(submittedAt) >= TX_LOOKUP_TIMEOUT_MS) {
+                const error = 'not found 60 seconds after the broadcast';
+                return { hash, submittedAt, status: credo_ts_didcomm_vt_flow_1.VtFlowTxStatus.Failed, reason: credo_ts_didcomm_vt_flow_1.VtFlowTxReason.TxNotFound, error };
+            }
+            await new Promise(resolve => setTimeout(resolve, TX_LOOKUP_INTERVAL_MS));
         }
-        const submitted = await vtFlowApi.recordValidation(recordId, Object.assign(Object.assign({}, validation), { tx: { hash, submittedAt: new Date().toISOString(), status: credo_ts_didcomm_vt_flow_1.VtFlowTxStatus.Submitted } }), credo_ts_didcomm_vt_flow_1.VtFlowState.ValidationTxSubmitted);
-        void this.resolveValidationTx(recordId).catch(error => this.agent.config.logger.error(`[vt-flow] resolving the validation of ${recordId} failed`, {
-            error: errorMessage(error),
-        }));
-        return submitted;
     }
     // [VSA-ADM-VT-FL-VALIDATE-8]. Leaving VALIDATION_TX_SUBMITTED ends the loop, so the notification
     // handler moving the flow first wins the race.
@@ -469,23 +540,35 @@ class VtFlowOrchestrator {
         var _a, _b, _c;
         const chain = this.requireChain();
         const vtFlowApi = this.resolveVtFlowApi();
+        let landed;
         for (;;) {
             const record = await vtFlowApi.findById(recordId);
             const validation = record === null || record === void 0 ? void 0 : record.validation;
             const hash = (_a = validation === null || validation === void 0 ? void 0 : validation.tx) === null || _a === void 0 ? void 0 : _a.hash;
-            if (!record || !validation || !hash || record.state !== credo_ts_didcomm_vt_flow_1.VtFlowState.ValidationTxSubmitted)
+            if (!(record === null || record === void 0 ? void 0 : record.applicantParticipantId) || !validation || !hash)
                 return;
-            const tx = await chain.findTx(hash).catch(() => undefined);
-            if (tx && tx.code === 0) {
-                await vtFlowApi.recordValidation(recordId, Object.assign(Object.assign({}, validation), { tx: Object.assign(Object.assign({}, validation.tx), { height: tx.height, status: credo_ts_didcomm_vt_flow_1.VtFlowTxStatus.Succeeded }) }));
-                await vtFlowApi.markValidated(recordId);
-                await this.continueAfterValidated(recordId);
+            if (record.state !== credo_ts_didcomm_vt_flow_1.VtFlowState.ValidationTxSubmitted)
                 return;
+            const tx = landed !== null && landed !== void 0 ? landed : (await chain.findTx(hash).catch(() => undefined));
+            if (tx && tx.code === 0) {
+                landed = tx;
+                // the indexer can lag the block of the transaction, and the fill needs the validated entry
+                const entry = await this.agent.indexer.getParticipant(record.applicantParticipantId);
+                if (entry.op_state === 'VALIDATED') {
+                    await this.markValidated(recordId, entry, { hash, height: tx.height });
+                    await this.continueAfterValidated(recordId);
+                    return;
+                }
             }
-            if (tx)
+            else if (tx) {
                 return this.failUnlessValidated(record, validation, credo_ts_didcomm_vt_flow_1.VtFlowTxReason.TxFailed, tx.rawLog, tx.height);
+            }
             const submittedAt = (_c = (_b = validation.tx) === null || _b === void 0 ? void 0 : _b.submittedAt) !== null && _c !== void 0 ? _c : validation.decidedAt;
             if (Date.now() - Date.parse(submittedAt) >= TX_LOOKUP_TIMEOUT_MS) {
+                if (tx) {
+                    this.agent.config.logger.warn(`[vt-flow] the transaction of flow ${recordId} landed, but the indexer does not show the entry VALIDATED yet: its notification completes the flow`);
+                    return;
+                }
                 return this.failUnlessValidated(record, validation, credo_ts_didcomm_vt_flow_1.VtFlowTxReason.TxNotFound, 'not found 60 seconds after the broadcast');
             }
             await new Promise(resolve => setTimeout(resolve, TX_LOOKUP_INTERVAL_MS));
@@ -494,18 +577,77 @@ class VtFlowOrchestrator {
     // The VPR has no distinct error for a second SetParticipantOPtoValidated, so the entry tells a
     // rejected duplicate apart from a real failure.
     async failUnlessValidated(record, validation, reason, error, height) {
+        var _a;
         const vtFlowApi = this.resolveVtFlowApi();
         const applicant = record.applicantParticipantId
             ? await this.agent.indexer.getParticipant(record.applicantParticipantId)
             : undefined;
+        const failed = Object.assign(Object.assign({}, validation), { tx: Object.assign(Object.assign({}, validation.tx), { height, status: credo_ts_didcomm_vt_flow_1.VtFlowTxStatus.Failed, reason, error }) });
         if ((applicant === null || applicant === void 0 ? void 0 : applicant.op_state) === 'VALIDATED') {
-            await vtFlowApi.markValidated(record.id);
+            // the notification handler may have moved the flow while the tx and the entry were read
+            if (((_a = (await vtFlowApi.findById(record.id))) === null || _a === void 0 ? void 0 : _a.state) !== credo_ts_didcomm_vt_flow_1.VtFlowState.ValidationTxSubmitted)
+                return;
+            if (reason === credo_ts_didcomm_vt_flow_1.VtFlowTxReason.TxFailed)
+                await vtFlowApi.recordValidation(record.id, failed);
+            await this.markValidated(record.id, applicant);
             await this.continueAfterValidated(record.id);
             return;
         }
-        await vtFlowApi.recordValidation(record.id, Object.assign(Object.assign({}, validation), { tx: Object.assign(Object.assign({}, validation.tx), { height, status: credo_ts_didcomm_vt_flow_1.VtFlowTxStatus.Failed, reason, error }) }), credo_ts_didcomm_vt_flow_1.VtFlowState.ValidationTxFailed);
+        await vtFlowApi.recordValidation(record.id, failed, credo_ts_didcomm_vt_flow_1.VtFlowState.ValidationTxFailed);
+    }
+    /**
+     * [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.
+     */
+    async markValidated(recordId, entry, landed) {
+        var _a, _b, _c, _d, _e;
+        const vtFlowApi = this.resolveVtFlowApi();
+        if (markingValidated.has(recordId))
+            throw invalidState('the flow is already moving to VALIDATED');
+        markingValidated.add(recordId);
+        try {
+            const record = await vtFlowApi.findById(recordId);
+            if (!record)
+                throw new Error(`vt-flow record ${recordId} not found`);
+            if (!credo_ts_didcomm_vt_flow_1.VtFlowValidatedFromStates.has(record.state) &&
+                record.state !== credo_ts_didcomm_vt_flow_1.VtFlowState.TerminatedByValidator) {
+                throw invalidState(`the flow is '${record.state}', which does not precede VALIDATED`);
+            }
+            const recorded = record.validation;
+            const agentTx = landed && ((_a = recorded === null || recorded === void 0 ? void 0 : recorded.tx) === null || _a === void 0 ? void 0 : _a.hash) === landed.hash ? recorded.tx : undefined;
+            const validation = Object.assign(Object.assign(Object.assign({}, recorded), { decidedAt: (_c = (_b = recorded === null || recorded === void 0 ? void 0 : recorded.decidedAt) !== null && _b !== void 0 ? _b : landed === null || landed === void 0 ? void 0 : landed.timestamp) !== null && _c !== void 0 ? _c : entry.modified, submission: !landed && ((_d = recorded === null || recorded === void 0 ? void 0 : recorded.tx) === null || _d === void 0 ? void 0 : _d.hash) && recorded.tx.reason !== credo_ts_didcomm_vt_flow_1.VtFlowTxReason.TxFailed
+                    ? recorded.submission
+                    : agentTx
+                        ? credo_ts_didcomm_vt_flow_1.VtFlowSubmission.Agent
+                        : credo_ts_didcomm_vt_flow_1.VtFlowSubmission.Operator, validationFees: entry.validation_fees, issuanceFees: entry.issuance_fees, verificationFees: entry.verification_fees, issuanceFeeDiscount: entry.issuance_fee_discount, verificationFeeDiscount: entry.verification_fee_discount, effectiveUntil: (_e = entry.effective_until) !== null && _e !== void 0 ? _e : undefined }), (agentTx && {
+                tx: {
+                    hash: agentTx.hash,
+                    submittedAt: agentTx.submittedAt,
+                    height: landed === null || landed === void 0 ? void 0 : landed.height,
+                    status: credo_ts_didcomm_vt_flow_1.VtFlowTxStatus.Succeeded,
+                },
+            }));
+            return await vtFlowApi.recordValidation(recordId, validation, credo_ts_didcomm_vt_flow_1.VtFlowState.Validated);
+        }
+        finally {
+            markingValidated.delete(recordId);
+        }
+    }
+    /** rejectFlow ended the flow with its transaction in flight, and no newer flow of the applicant replaced it ([VSA-ADM-VT-FL-REJECT-2]). */
+    async isRejectedInFlight(record) {
+        if (record.state !== credo_ts_didcomm_vt_flow_1.VtFlowState.TerminatedByValidator || !record.validation)
+            return false;
+        if (!record.applicantParticipantId)
+            return false;
+        const [latest] = (await this.resolveVtFlowApi().findAllByQuery({
+            role: credo_ts_didcomm_vt_flow_1.VtFlowRole.Validator,
+            applicantParticipantId: record.applicantParticipantId,
+        })).sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+        return (latest === null || latest === void 0 ? void 0 : latest.id) === record.id;
     }
     async continueAfterValidated(recordId) {
+        var _a;
         const vtFlowApi = this.resolveVtFlowApi();
         const record = await vtFlowApi.findById(recordId);
         if (!record)
@@ -517,7 +659,14 @@ class VtFlowOrchestrator {
         if (!participant)
             throw new Error(`Applicant participant ${record.applicantParticipantId} not found`);
         if (Number(participant.role) !== types_2.HOLDER_PARTICIPANT_TYPE)
-            return this.completeOnboardingProcess(recordId);
+            return record;
+        const schema = await this.agent.indexer.getCredentialSchema(participant.schemaId);
+        const violations = (0, utils_1.schemaViolations)(JSON.parse(schema.json_schema), Object.assign({ id: participant.did }, ((_a = record.claims) !== null && _a !== void 0 ? _a : {})));
+        if (violations.length > 0) {
+            this.agent.config.logger.error(`[vt-flow] not offering the credential of flow ${recordId}: its claims do not satisfy the ` +
+                `json_schema of schema ${participant.schemaId}: ${violations.map(v => `${v.path} ${v.message}`.trim()).join(', ')}`);
+            return record.state === credo_ts_didcomm_vt_flow_1.VtFlowState.Validated ? vtFlowApi.markPendingClaims(recordId) : record;
+        }
         return this.offerOnboardingCredential({ vtFlowRecordId: recordId, participant });
     }
     /** [VSA-ADM-VT-FL-VALIDATE-8]: at startup, resume every flow left in VALIDATION_TX_SUBMITTED. */
@@ -528,6 +677,20 @@ class VtFlowOrchestrator {
         });
         await Promise.all(pending.map(record => this.resolveValidationTx(record.id)));
     }
+    /** [VSA-VTI-FLOW-ISSUE-1]: at startup, resume every anchoring left SUBMITTED through the stored issued credential. */
+    async resumeIssuanceSubmissions() {
+        const vtFlowApi = this.resolveVtFlowApi();
+        const offered = await vtFlowApi.findAllByQuery({
+            role: credo_ts_didcomm_vt_flow_1.VtFlowRole.Validator,
+            flowState: credo_ts_didcomm_vt_flow_1.VtFlowState.CredOffered,
+        });
+        await Promise.all(offered.map(({ id, issuance, credentialExchangeRecordId }) => {
+            var _a;
+            return ((_a = issuance === null || issuance === void 0 ? void 0 : issuance.tx) === null || _a === void 0 ? void 0 : _a.status) === credo_ts_didcomm_vt_flow_1.VtFlowTxStatus.Submitted && credentialExchangeRecordId
+                ? vtFlowApi.issueCredentialForSession({ vtFlowRecordId: id, credentialExchangeRecordId })
+                : undefined;
+        }));
+    }
     async acceptCredential(input) {
         const vtFlowApi = this.resolveVtFlowApi();
         const record = await vtFlowApi.findById(input.vtFlowRecordId);
@@ -603,6 +766,7 @@ class VtFlowOrchestrator {
             context: input.credentialContext,
             credentialSubject: Object.assign(Object.assign({}, input.claims), { id: input.subjectDid }),
             credentialSchema: { id: jsonSchemaCredentialId, type: 'JsonSchemaCredential' },
+            validUntil: input.validUntil,
         });
         return (0, utils_1.toOfferedCredentialJson)(unsignedCredential);
     }
@@ -620,7 +784,7 @@ class VtFlowOrchestrator {
         }
         return { digestAlgorithm: schema.digest_algorithm, ecsKey: await (0, vs_agent_model_1.classifyEcsSchema)(schema.json_schema) };
     }
-    /** Fired after signing and before delivery, so a failure here must abort the issuance. */
+    /** Fired after signing and before delivery. A failed anchoring comes back in `issuance`, and the credential stays undelivered. */
     async onCredentialIssued(vtFlowRecordId, signedCredential) {
         var _a, _b;
         const chain = this.requireChain();
@@ -634,14 +798,17 @@ class VtFlowOrchestrator {
         const issuer = await this.agent.indexer.getParticipant(record.issuerParticipantId);
         const algorithm = await this.digestAlgorithmForSchema(issuer.schema_id);
         const digest = (0, verre_1.computeCredentialDigestJCS)(signedCredential, algorithm);
-        await chain.createOrUpdateParticipantSession({
+        const message = chain.createOrUpdateParticipantSessionMsg({
             id: record.participantSessionId,
             issuerParticipantId: record.issuerParticipantId,
             agentParticipantId: Number((_a = record.agentParticipantId) !== null && _a !== void 0 ? _a : 0) || 0,
             walletAgentParticipantId: Number((_b = record.walletAgentParticipantId) !== null && _b !== void 0 ? _b : 0) || 0,
             digest,
         });
-        return digest;
+        return {
+            credentialDigest: digest,
+            issuance: { tx: await this.anchor(record, message, record.issuerParticipantId) },
+        };
     }
     async verifyOfferedCredential(vtFlowRecordId) {
         var _a, _b;
@@ -676,6 +843,7 @@ class VtFlowOrchestrator {
             throw new Error(`Issuer participant schema ${issuer.schema_id} does not match credential schema ${record.schemaId}`);
         }
         const credentialJson = await this.getReceivedCredentialJson(record.credentialExchangeRecordId);
+        await this.assertFlowCredentialFormat(credentialJson, issuer);
         const { digestAlgorithm, ecsKey } = await this.credentialSchema(issuer.schema_id);
         const digest = (0, verre_1.computeCredentialDigestJCS)(credentialJson, digestAlgorithm);
         const anchored = await indexer.getDigest(digest);
@@ -685,6 +853,26 @@ class VtFlowOrchestrator {
         if (ecsKey)
             await vtFlowApi.setEcsSchemaKey(record.id, ecsKey);
     }
+    /** [VSA-VTI-FLOW-FMT-1]. Credo already verified the proof and its assertionMethod key, for data model 2.0 only. */
+    async assertFlowCredentialFormat(credential, issuer) {
+        var _a, _b, _c;
+        if (!(0, utils_1.isVcdm2Credential)(credential)) {
+            throw new Error('Received credential is not a VC Data Model 2.0 credential');
+        }
+        const verificationMethod = (_a = credential.proof) === null || _a === void 0 ? void 0 : _a.verificationMethod;
+        if (!issuer.did || (verificationMethod === null || verificationMethod === void 0 ? void 0 : verificationMethod.split('#')[0]) !== issuer.did) {
+            throw new Error(`Proof verification method ${verificationMethod} is not one of the validator ${issuer.did}`);
+        }
+        const subjectId = (_b = credential.credentialSubject) === null || _b === void 0 ? void 0 : _b.id;
+        if (subjectId !== this.agent.did) {
+            throw new Error(`Credential subject ${subjectId} is not the applicant ${this.agent.did}`);
+        }
+        const schemaRef = (_c = credential.credentialSchema) === null || _c === void 0 ? void 0 : _c.id;
+        const jsonSchemaCredentialId = await this.resolveJsonSchemaCredentialId(String(issuer.schema_id));
+        if (schemaRef !== jsonSchemaCredentialId) {
+            throw new Error(`Credential schema ${schemaRef} is not the VTJSC ${jsonSchemaCredentialId} of the flow`);
+        }
+    }
     async onCredentialRevoked(vtFlowRecordId) {
         const vtFlowApi = this.resolveVtFlowApi();
         const record = await vtFlowApi.findById(vtFlowRecordId);
@@ -734,6 +922,45 @@ class VtFlowOrchestrator {
             trustedEcosystemDids: this.agent.trustedEcosystemDids,
         }, context);
     }
+    // the indexer can still lag the applicant's own transaction, so wait for it as a tx lookup does
+    async checkParticipantId({ record }) {
+        if (!record.applicantParticipantId || !this.agent.did)
+            return false;
+        const deadline = Date.now() + TX_LOOKUP_TIMEOUT_MS;
+        let validatedAtFirstRead;
+        for (;;) {
+            const entry = await this.agent.indexer
+                .getParticipant(record.applicantParticipantId)
+                .catch(() => undefined);
+            validatedAtFirstRead !== null && validatedAtFirstRead !== void 0 ? validatedAtFirstRead : (validatedAtFirstRead = (entry === null || entry === void 0 ? void 0 : entry.op_state) === 'VALIDATED');
+            if (entry) {
+                if (entry.revoked || entry.slashed || entry.validator_participant_id == null)
+                    return false;
+                const validator = await this.agent.indexer
+                    .getParticipant(entry.validator_participant_id)
+                    .catch(() => undefined);
+                if (validator && validator.did !== this.agent.did)
+                    return false;
+                if (validator && entry.op_state === 'PENDING')
+                    return true;
+                if (validator && entry.op_state === 'VALIDATED') {
+                    const flow = await this.resolveVtFlowApi().findById(record.id);
+                    // the flow has moved on, or another path is moving it to VALIDATED and continues it itself
+                    if ((flow === null || flow === void 0 ? void 0 : flow.state) !== credo_ts_didcomm_vt_flow_1.VtFlowState.AwaitingOr || markingValidated.has(record.id))
+                        return 'validated';
+                    // VALIDATED at the first read can be the round before this request, which it does not settle
+                    if (!validatedAtFirstRead) {
+                        await this.markValidated(record.id, entry);
+                        await this.continueAfterValidated(record.id);
+                        return 'validated';
+                    }
+                }
+            }
+            if (Date.now() >= deadline)
+                return false;
+            await new Promise(resolve => setTimeout(resolve, TX_LOOKUP_INTERVAL_MS));
+        }
+    }
     async publishCredentialAsLinkedVp(vtFlowRecordId) {
         var _a;
         if (!this.options.publicApiBaseUrl) {