@learncard/lca-api-service 1.5.1 → 1.5.3

package/src/services/escrow-enclave/authorityContract.ts

@@ -0,0 +1,126 @@
+import { z } from 'zod';
+import {
+    encodeEscrowEnrollmentIntent,
+    ESCROW_ALGORITHM,
+    ESCROW_ENVELOPE_VERSION,
+} from '@learncard/sss-key-manager';
+
+export const safeInteger = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+const label = z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9_-]+$/);
+export const AuthorityEnvelopeValidator = z
+    .object({
+        version: z.literal(ESCROW_ENVELOPE_VERSION),
+        algorithm: z.literal(ESCROW_ALGORITHM),
+        keyId: z.string().min(1).max(128),
+        ephemeralPublicKey: z.string().max(256),
+        salt: z.string().max(128),
+        iv: z.string().max(64),
+        ciphertext: z.string().max(16_384),
+    })
+    .strict();
+export const AuthorityRecordValidator = z
+    .object({
+        version: z.literal(1),
+        kind: z.enum(['proposal', 'commit', 'snapshot']),
+        keyId: z.string().min(1).max(128),
+        measurement: z.array(z.number().int().min(0).max(255)).length(32),
+        payload: z.string().min(1).max(49_152),
+        signature: z.string().length(88),
+    })
+    .strict();
+export const AuthorityCommitValidator = AuthorityRecordValidator.extend({
+    kind: z.literal('commit'),
+    payload: z.string().min(1).max(8192),
+});
+// Idempotent-retry attestation for confirm-hold / send-release-warning (see
+// `authority_hold_snapshot` in policy/authority.rs): a fresh call returns a
+// `commit`; a retry of an already-applied operation returns this instead,
+// signed over the hold's current fields rather than a new ledger transition.
+export const AuthorityHoldSnapshotValidator = AuthorityRecordValidator.extend({
+    kind: z.literal('snapshot'),
+});
+// confirm-hold and send-release-warning responses carry whichever shape the
+// enclave actually returned; callers must not assume `commit`.
+export const AuthorityHoldReceiptValidator = z.union([
+    AuthorityCommitValidator,
+    AuthorityHoldSnapshotValidator,
+]);
+export const SignedEnrollmentIntentValidator = z
+    .object({
+        intent: z
+            .object({
+                version: z.literal(2),
+                tenant: label,
+                did: z.string().length(56),
+                authorityGeneration: label,
+                expectedEnrollmentVersion: safeInteger,
+                action: z.enum(['enroll', 'replace', 'disable', 'carry']),
+                sourceBlobIdentity: z
+                    .string()
+                    .regex(/^[0-9a-f]{64}$/)
+                    .nullable(),
+                targetBlobIdentity: z
+                    .string()
+                    .regex(/^[0-9a-f]{64}$/)
+                    .nullable(),
+                pinAction: z.enum(['set', 'change', 'clear', 'keep']),
+                shareVersion: z.number().int().positive().max(0xffffffff),
+                enrollmentEpoch: safeInteger.positive(),
+                requestId: z.string().min(1).max(112),
+                allowRewrap: z.boolean(),
+                // P9.1 (attack C): shape only — `encodeEscrowEnrollmentIntent` below
+                // enforces normalization, the paired requirement, and the language
+                // allow-list; lca-api never re-derives or overrides these values.
+                recoveryEmail: z.string().min(3).max(254).nullable(),
+                recoveryLanguage: z.string().length(2).nullable(),
+            })
+            .strict()
+            .refine(intent => {
+                try {
+                    encodeEscrowEnrollmentIntent(intent);
+                    return true;
+                } catch {
+                    return false;
+                }
+            }, 'Invalid enrollment intent'),
+        signature: z.string().length(88),
+    })
+    .strict();
+export const AuthorityStateValidator = z
+    .object({
+        tenant: label,
+        authorityGeneration: label,
+        did: z.string().min(1).max(8192),
+        enrollmentVersion: safeInteger,
+        enrollmentEpoch: safeInteger,
+        status: z.enum(['empty', 'active', 'disabled']),
+        envelope: AuthorityEnvelopeValidator.nullable(),
+        shareVersion: z.number().int().positive().max(0xffffffff).nullable(),
+        hasPin: z.boolean(),
+        pinGeneration: safeInteger,
+        attemptsUsed: z.number().int().min(0).max(10),
+    })
+    .strict();
+export const AuthorityStateResponseValidator = z
+    .object({
+        state: AuthorityStateValidator,
+        proof: AuthorityRecordValidator.extend({ kind: z.literal('snapshot') }),
+    })
+    .strict();
+export const AuthorityMutationValidator = z
+    .object({
+        envelope: AuthorityEnvelopeValidator.nullable(),
+        receipt: AuthorityCommitValidator,
+        authorityGeneration: label,
+        enrollmentVersion: safeInteger.positive(),
+        enrollmentEpoch: safeInteger.positive(),
+    })
+    .strict();
+export type AuthorityRecord = z.infer<typeof AuthorityRecordValidator>;
+export type AuthorityHoldReceipt = z.infer<typeof AuthorityHoldReceiptValidator>;
+export type AuthorityMutationResult = z.infer<typeof AuthorityMutationValidator>;
+export type AuthorityStateResponse = z.infer<typeof AuthorityStateResponseValidator>;

package/src/services/escrow-enclave/cancellation.ts

@@ -40,13 +40,13 @@ export const cancelHoldInEnclave = async (
         ) {
             throw new Error('Cancellation material unavailable');
         }
-        await getEscrowEnclave().cancelHold({
+        const result = await getEscrowEnclave().cancelHold({
             envelope,
             hold: hold.holdRecord,
             clientEphemeralPublicKey: hold.clientEphemeralPublicKey,
             expectedDid: hold.primaryDid,
         });
-        await confirmEscrowEnclaveCancellation(hold._id);
+        await confirmEscrowEnclaveCancellation(hold._id, result?.receipt);
         return true;
     } catch {
         // Policy/unknown/terminal errors are ambiguous, not proof of cancellation.

package/src/services/escrow-enclave/logFailure.test.ts

@@ -0,0 +1,64 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { createRemoteEnclave } from './remoteEnclave';
+import { logEscrowFailure } from './logFailure';
+import { EscrowUnavailableError } from './types';
+
+afterEach(() => vi.restoreAllMocks());
+
+describe('escrow failure reasons', () => {
+    it('logs invalid outbound holds without error details', () => {
+        const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+        const error = new EscrowUnavailableError('invalid_hold');
+        error.message = 'private hold contents';
+        logEscrowFailure(error);
+        expect(warn).toHaveBeenCalledExactlyOnceWith('[LCA escrow] enclave operation failed', {
+            reason: 'invalid_hold',
+        });
+    });
+    it.each([
+        [403, 'policy', 'policy'],
+        [403, 'pinMismatch', 'pin_mismatch'],
+        [403, 'codeMismatch', 'code_mismatch'],
+        [403, 'codeExpired', 'code_expired'],
+        [403, 'codeLocked', 'code_locked'],
+        [403, 'blob', 'blob'],
+        [503, 'ledger', 'ledger'],
+        [503, 'time', 'time'],
+        [412, 'unavailable', 'unavailable'],
+        [403, 'secret-unknown-code', 'http_refusal'],
+        [429, 'unknown', 'rate_limit'],
+        [200, 'unknown', 'invalid_response'],
+    ])('classifies HTTP %s / %s without logging payloads', async (status, code, reason) => {
+        const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+        const enclave = createRemoteEnclave({
+            baseUrl: 'https://example.invalid',
+            token: 'secret-token',
+            timeoutMs: 100,
+            transport: {
+                post: async () => ({ status, data: { code, message: 'secret@example.com' } }),
+            },
+        });
+        await enclave.getAttestation().catch(logEscrowFailure);
+        expect(warn).toHaveBeenCalledExactlyOnceWith('[LCA escrow] enclave operation failed', {
+            reason,
+        });
+    });
+
+    it('drops transport error details', async () => {
+        const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+        const enclave = createRemoteEnclave({
+            baseUrl: 'https://example.invalid',
+            token: 'secret-token',
+            timeoutMs: 100,
+            transport: {
+                post: async () => {
+                    throw new Error('secret-token');
+                },
+            },
+        });
+        await enclave.getAttestation().catch(logEscrowFailure);
+        expect(warn).toHaveBeenCalledExactlyOnceWith('[LCA escrow] enclave operation failed', {
+            reason: 'transport',
+        });
+    });
+});

package/src/services/escrow-enclave/logFailure.ts

@@ -0,0 +1,29 @@
+import {
+    EscrowBlobError,
+    EscrowCodeError,
+    EscrowPinMismatchError,
+    EscrowPolicyError,
+    EscrowUnavailableError,
+} from './types';
+
+/** Only allowlisted classifications reach logs; never serialize remote errors or payloads. */
+export const logEscrowFailure = (error: unknown): void => {
+    const reason =
+        error instanceof EscrowCodeError
+            ? {
+                  codeMismatch: 'code_mismatch',
+                  codeExpired: 'code_expired',
+                  codeLocked: 'code_locked',
+              }[error.reason]
+            : error instanceof EscrowUnavailableError
+              ? error.reason
+              : error instanceof EscrowPolicyError
+                ? 'policy'
+                : error instanceof EscrowPinMismatchError
+                  ? 'pin_mismatch'
+                  : error instanceof EscrowBlobError
+                    ? 'blob'
+                    : 'unexpected';
+    // lca-api uses structured console warnings rather than the browser logger.
+    console.warn('[LCA escrow] enclave operation failed', { reason });
+};

package/src/services/escrow-enclave/remoteEnclave.test.ts

@@ -3,6 +3,7 @@ import type { EscrowEnvelope } from '@learncard/sss-key-manager';
 import { createRemoteEnclave, type RemoteEnclaveTransportResponse } from './remoteEnclave';
 import {
     EscrowBlobError,
+    EscrowCodeError,
     EscrowPinMismatchError,
     EscrowPolicyError,
     EscrowUnavailableError,
@@ -12,6 +13,35 @@ import {
 const baseUrl = 'https://enclave-host.internal';
 const token = 't'.repeat(32);
 const timeoutMs = 10_000;
+const receipt = {
+    version: 1 as const,
+    kind: 'commit' as const,
+    keyId: 'key-1',
+    measurement: Array(32).fill(0),
+    payload: 'AQ==',
+    signature: Buffer.alloc(64).toString('base64'),
+};
+
+// Real Rust shape for the idempotent-retry path (`authority_hold_snapshot`,
+// policy/authority.rs): a signed tuple, never an `AuthorityCommitValidator`.
+const snapshotReceipt = {
+    version: 1 as const,
+    kind: 'snapshot' as const,
+    keyId: 'key-1',
+    measurement: Array(32).fill(0),
+    payload: Buffer.from(
+        JSON.stringify([
+            'learncard-authority-hold-snapshot-v2',
+            'hold-1',
+            Array(32).fill(7),
+            'pending',
+            1700000000000,
+            1700086400000,
+            'g1',
+        ])
+    ).toString('base64'),
+    signature: Buffer.alloc(64).toString('base64'),
+};
 
 const envelope: EscrowEnvelope = {
     version: 1,
@@ -85,6 +115,40 @@ describe('createRemoteEnclave', () => {
         );
     });
 
+    it.each(['codeMismatch', 'codeExpired', 'codeLocked'] as const)(
+        'maps %s without forwarding diagnostic text',
+        async code => {
+            const post = vi
+                .fn()
+                .mockResolvedValue(respond(403, { code, message: 'sensitive diagnostic' }));
+            const enclave = createRemoteEnclave({ baseUrl, token, timeoutMs, transport: { post } });
+            await expect(enclave.confirmHold!(confirmInput)).rejects.toEqual(
+                new EscrowCodeError(code)
+            );
+        }
+    );
+
+    it('separates delivery evidence from the signed hold before subsequent requests', async () => {
+        const delivery = { codeSent: false, proof: snapshotReceipt };
+        const post = vi.fn().mockResolvedValue(respond(200, { ...hold, delivery }));
+        const enclave = createRemoteEnclave({ baseUrl, token, timeoutMs, transport: { post } });
+        await expect(enclave.createHold(createInput)).resolves.toEqual({
+            holdRecord: hold,
+            delivery,
+        });
+    });
+
+    it('forwards fresh hold-state nonces under the existing bearer authentication', async () => {
+        const post = vi.fn().mockResolvedValue(respond(200, { proof: snapshotReceipt }));
+        const enclave = createRemoteEnclave({ baseUrl, token, timeoutMs, transport: { post } });
+        const input = { expectedDid: hold.hold.did, hold, nonce: 'ab'.repeat(32) };
+        await expect(enclave.getHoldState!(input)).resolves.toEqual({ proof: snapshotReceipt });
+        expect(post).toHaveBeenCalledWith(`${baseUrl}/v1/hold-state`, input, {
+            headers: { Authorization: `Bearer ${token}` },
+            timeout: timeoutMs,
+        });
+    });
+
     it('sends an empty nonce array when none is given', async () => {
         const post = vi.fn().mockResolvedValue(respond(200, attestationBody));
         const enclave = createRemoteEnclave({ baseUrl, token, timeoutMs, transport: { post } });
@@ -223,7 +287,14 @@ describe('createRemoteEnclave', () => {
     });
 
     it('rewraps an escrow blob sealed under a previous key onto the current key', async () => {
-        const post = vi.fn().mockResolvedValue(respond(200, { envelope }));
+        const authority = {
+            envelope,
+            receipt,
+            authorityGeneration: 'g1',
+            enrollmentVersion: 2,
+            enrollmentEpoch: 1,
+        };
+        const post = vi.fn().mockResolvedValue(respond(200, { result: authority }));
         const enclave = createRemoteEnclave({ baseUrl, token, timeoutMs, transport: { post } });
         const input = {
             envelope,
@@ -232,10 +303,10 @@ describe('createRemoteEnclave', () => {
             sourceEnrollmentEpoch: 1,
         };
 
-        await expect(enclave.rewrapEscrowBlob(input)).resolves.toEqual({ envelope });
+        await expect(enclave.rewrapEscrowBlob(input)).resolves.toEqual({ envelope, authority });
 
         expect(post).toHaveBeenCalledWith(
-            `${baseUrl}/v1/rewrap-escrow-blob`,
+            `${baseUrl}/v1/authority-rewrap`,
             {
                 envelope,
                 expectedDid: 'did:example:alice',
@@ -246,6 +317,243 @@ describe('createRemoteEnclave', () => {
         );
     });
 
+    it('preserves v2 cancellation receipts and stable release IDs, refusing absent commit evidence', async () => {
+        const v2 = {
+            ...hold,
+            hold: {
+                ...hold.hold,
+                policyVersion: 2,
+                signature: Buffer.from(JSON.stringify(receipt)).toString('base64'),
+            },
+        };
+        const post = vi.fn().mockResolvedValue(respond(200, { ok: true, receipt }));
+        const enclave = createRemoteEnclave({ baseUrl, token, timeoutMs, transport: { post } });
+        const input = {
+            envelope,
+            hold: v2,
+            expectedDid: v2.hold.did,
+            clientEphemeralPublicKey: v2.hold.clientEphemeralPublicKey,
+            requestId: 'stable-id',
+        };
+        await expect(enclave.cancelHold(input)).resolves.toEqual({ receipt });
+        post.mockResolvedValue(respond(200, { sealed: envelope, receipt }));
+        await expect(enclave.releaseEscrow(input)).resolves.toEqual({ sealed: envelope, receipt });
+        expect(post.mock.calls.at(-1)?.[1]).toMatchObject({ requestId: 'stable-id' });
+        post.mockResolvedValue(respond(200, { sealed: envelope }));
+        await expect(enclave.releaseEscrow(input)).rejects.toMatchObject({
+            reason: 'invalid_response',
+        });
+        post.mockResolvedValue(respond(200, { ok: true }));
+        await expect(enclave.cancelHold(input)).rejects.toMatchObject({
+            reason: 'invalid_response',
+        });
+    });
+
+    it.each([
+        { ...hold, ledgerSeq: -1 },
+        { ...hold, hold: { ...hold.hold, policyVersion: 2, signature: 'invalid' } },
+    ])('distinguishes invalid outbound holds from invalid returned holds', async invalidHold => {
+        const post = vi.fn().mockResolvedValue(respond(200, invalidHold));
+        const enclave = createRemoteEnclave({ baseUrl, token, timeoutMs, transport: { post } });
+        const input = {
+            envelope,
+            hold: invalidHold,
+            expectedDid: hold.hold.did,
+            clientEphemeralPublicKey: hold.hold.clientEphemeralPublicKey,
+        };
+        await expect(enclave.releaseEscrow(input)).rejects.toMatchObject({
+            reason: 'invalid_hold',
+        });
+        await expect(enclave.cancelHold(input)).rejects.toMatchObject({ reason: 'invalid_hold' });
+        await expect(enclave.confirmHold!({ ...input, code: '12345678' })).rejects.toMatchObject({
+            reason: 'invalid_hold',
+        });
+        await expect(enclave.resendCode!(input)).rejects.toMatchObject({ reason: 'invalid_hold' });
+        expect(post).not.toHaveBeenCalled();
+        await expect(
+            enclave.createHold({
+                envelope,
+                ...hold.hold,
+                expectedDid: hold.hold.did,
+                expectedShareVersion: 1,
+            })
+        ).rejects.toMatchObject({ reason: 'invalid_response' });
+    });
+
+    it.each([
+        { envelope: null, enrollmentEpoch: 1 },
+        { envelope, enrollmentEpoch: 2 },
+    ])('classifies invalid rewrap envelope/epoch as a response failure', async result => {
+        const post = vi.fn().mockResolvedValue(
+            respond(200, {
+                result: {
+                    ...result,
+                    receipt,
+                    authorityGeneration: 'g1',
+                    enrollmentVersion: 2,
+                },
+            })
+        );
+        const enclave = createRemoteEnclave({ baseUrl, token, timeoutMs, transport: { post } });
+        await expect(
+            enclave.rewrapEscrowBlob({
+                envelope,
+                expectedDid: hold.hold.did,
+                expectedShareVersion: 1,
+                sourceEnrollmentEpoch: 1,
+            })
+        ).rejects.toMatchObject({ reason: 'invalid_response' });
+    });
+
+    // [A] confirm-hold/send-release-warning: a fresh call returns a signed
+    // `commit`; an idempotent retry (lost response, hourly job re-run)
+    // returns a signed `snapshot` instead — both are real response shapes
+    // the enclave can return, never a stub that only ever returns `commit`.
+    const confirmInput = {
+        envelope,
+        hold,
+        clientEphemeralPublicKey: hold.hold.clientEphemeralPublicKey,
+        expectedDid: hold.hold.did,
+        code: '12345678',
+    };
+    it('confirmHold accepts a fresh commit receipt and returns the authoritative confirmation time', async () => {
+        const post = vi
+            .fn()
+            .mockResolvedValue(
+                respond(200, { confirmed: true, receipt, confirmedHiMs: 1700000000000 })
+            );
+        const enclave = createRemoteEnclave({ baseUrl, token, timeoutMs, transport: { post } });
+
+        await expect(enclave.confirmHold!(confirmInput)).resolves.toEqual({
+            receipt,
+            confirmedAtMs: 1700000000000,
+        });
+    });
+    it('confirmHold accepts a retry snapshot receipt (not a commit) and returns the SAME confirmation time', async () => {
+        const post = vi.fn().mockResolvedValue(
+            respond(200, {
+                confirmed: true,
+                receipt: snapshotReceipt,
+                confirmedHiMs: 1700000000000,
+            })
+        );
+        const enclave = createRemoteEnclave({ baseUrl, token, timeoutMs, transport: { post } });
+
+        await expect(enclave.confirmHold!(confirmInput)).resolves.toEqual({
+            receipt: snapshotReceipt,
+            confirmedAtMs: 1700000000000,
+        });
+    });
+    it('confirmHold fails closed when the receipt is neither a commit nor a snapshot', async () => {
+        const post = vi.fn().mockResolvedValue(
+            respond(200, {
+                confirmed: true,
+                receipt: { ...receipt, kind: 'proposal' },
+                confirmedHiMs: 1700000000000,
+            })
+        );
+        const enclave = createRemoteEnclave({ baseUrl, token, timeoutMs, transport: { post } });
+
+        await expect(enclave.confirmHold!(confirmInput)).rejects.toBeInstanceOf(
+            EscrowUnavailableError
+        );
+    });
+    it('confirmHold fails closed when confirmedHiMs is missing (pre-fix response shape)', async () => {
+        const post = vi.fn().mockResolvedValue(respond(200, { confirmed: true, receipt }));
+        const enclave = createRemoteEnclave({ baseUrl, token, timeoutMs, transport: { post } });
+
+        await expect(enclave.confirmHold!(confirmInput)).rejects.toBeInstanceOf(
+            EscrowUnavailableError
+        );
+    });
+
+    const warningInput = { holdId: hold.hold.holdId, expectedDid: hold.hold.did };
+    it('sendReleaseWarning accepts a fresh commit receipt and returns the authoritative send time', async () => {
+        const post = vi
+            .fn()
+            .mockResolvedValue(
+                respond(200, { sent: true, receipt, releaseWarningSentHiMs: 1700086400000 })
+            );
+        const enclave = createRemoteEnclave({ baseUrl, token, timeoutMs, transport: { post } });
+
+        await expect(enclave.sendReleaseWarning!(warningInput)).resolves.toEqual({
+            receipt,
+            releaseWarningSentAtMs: 1700086400000,
+        });
+    });
+    it('sendReleaseWarning accepts a retry snapshot receipt (not a commit) and returns the SAME send time', async () => {
+        const post = vi.fn().mockResolvedValue(
+            respond(200, {
+                sent: true,
+                receipt: snapshotReceipt,
+                releaseWarningSentHiMs: 1700086400000,
+            })
+        );
+        const enclave = createRemoteEnclave({ baseUrl, token, timeoutMs, transport: { post } });
+
+        await expect(enclave.sendReleaseWarning!(warningInput)).resolves.toEqual({
+            receipt: snapshotReceipt,
+            releaseWarningSentAtMs: 1700086400000,
+        });
+    });
+    it('sendReleaseWarning fails closed when releaseWarningSentHiMs is missing (pre-fix response shape)', async () => {
+        const post = vi.fn().mockResolvedValue(respond(200, { sent: true, receipt }));
+        const enclave = createRemoteEnclave({ baseUrl, token, timeoutMs, transport: { post } });
+
+        await expect(enclave.sendReleaseWarning!(warningInput)).rejects.toBeInstanceOf(
+            EscrowUnavailableError
+        );
+    });
+
+    it('forwards signed enrollment once and rejects a proposal or mismatched result generation', async () => {
+        const input = {
+            signedIntent: {
+                intent: {
+                    version: 2 as const,
+                    tenant: 'learncard',
+                    did: 'did:key:z6MktwupdmLXVVqTzCw4i46r4uGyosGXRnR3XjN4Zq7oMMsw',
+                    authorityGeneration: 'g1',
+                    expectedEnrollmentVersion: 0,
+                    action: 'enroll' as const,
+                    sourceBlobIdentity: null,
+                    targetBlobIdentity: 'ab'.repeat(32),
+                    pinAction: 'keep' as const,
+                    shareVersion: 1,
+                    enrollmentEpoch: 1,
+                    requestId: 'request',
+                    allowRewrap: true,
+                    recoveryEmail: 'owner@example.com',
+                    recoveryLanguage: 'en',
+                },
+                signature: Buffer.alloc(64).toString('base64'),
+            },
+            sourceEnvelope: null,
+            targetEnvelope: envelope,
+        };
+        const result = {
+            envelope,
+            receipt,
+            authorityGeneration: 'g1',
+            enrollmentVersion: 1,
+            enrollmentEpoch: 1,
+        };
+        const post = vi.fn().mockResolvedValue(respond(200, { result }));
+        const enclave = createRemoteEnclave({ baseUrl, token, timeoutMs, transport: { post } });
+        await expect(enclave.applyEnrollmentIntent!(input)).resolves.toEqual(result);
+        expect(post).toHaveBeenCalledTimes(1);
+        expect(post.mock.calls[0]?.slice(0, 2)).toEqual([`${baseUrl}/v1/apply-enrollment`, input]);
+        post.mockResolvedValue(respond(200, { result: { ...result, authorityGeneration: 'g2' } }));
+        await expect(enclave.applyEnrollmentIntent!(input)).rejects.toBeInstanceOf(
+            EscrowUnavailableError
+        );
+        post.mockResolvedValue(
+            respond(200, { result: { ...result, receipt: { ...receipt, kind: 'proposal' } } })
+        );
+        await expect(enclave.applyEnrollmentIntent!(input)).rejects.toBeInstanceOf(
+            EscrowUnavailableError
+        );
+    });
+
     it.each([
         ['policy', EscrowPolicyError],
         ['pinMismatch', EscrowPinMismatchError],
@@ -412,7 +720,10 @@ describe('createRemoteEnclave', () => {
         const created = await enclave.createHold(createInput);
         expect(created).toEqual({ holdRecord: opaque });
         const config = { headers: { Authorization: `Bearer ${token}` }, timeout: timeoutMs };
-        expect(post).toHaveBeenNthCalledWith(1, `${baseUrl}/v1/create-hold`, createInput, config);
+        expect(post).toHaveBeenNthCalledWith(1, `${baseUrl}/v1/create-hold`, createInput, {
+            ...config,
+            headers: { ...config.headers, 'X-Escrow-Delivery-Evidence': '1' },
+        });
         await expect(
             enclave.cancelHold({ ...cancelInput, hold: created.holdRecord })
         ).resolves.toBeUndefined();