diff --git a/apps/credit-history/src/app/api/presentations/[ref]/route.ts b/apps/credit-history/src/app/api/presentations/[ref]/route.ts
new file mode 100644
index 0000000..c1849f6
--- /dev/null
+++ b/apps/credit-history/src/app/api/presentations/[ref]/route.ts
@@ -0,0 +1,38 @@
+/**
+ * GET /api/presentations/[ref] — resolve a share reference.
+ *
+ * Expiration is enforced here, not by the caller: an expired reference returns
+ * 410 and is dropped from the store, so editing the URL cannot extend a link.
+ */
+
+import { NextResponse } from 'next/server';
+import { resolveStoredPresentation } from '@/lib/presentation-store';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+const NO_STORE = { 'Cache-Control': 'no-store' } as const;
+
+export async function GET(
+  _request: Request,
+  { params }: { params: Promise<{ ref: string }> }
+): Promise<NextResponse> {
+  const { ref } = await params;
+  const resolution = await resolveStoredPresentation(ref);
+
+  if (resolution.status === 'not_found') {
+    return NextResponse.json({ reason: 'not_found' }, { status: 404, headers: NO_STORE });
+  }
+
+  if (resolution.status === 'expired') {
+    return NextResponse.json(
+      { reason: 'expired', expiresAt: resolution.expiresAt },
+      { status: 410, headers: NO_STORE }
+    );
+  }
+
+  return NextResponse.json(
+    { presentation: resolution.presentation },
+    { status: 200, headers: NO_STORE }
+  );
+}
diff --git a/apps/credit-history/src/app/api/presentations/route.ts b/apps/credit-history/src/app/api/presentations/route.ts
new file mode 100644
index 0000000..58d12ff
--- /dev/null
+++ b/apps/credit-history/src/app/api/presentations/route.ts
@@ -0,0 +1,103 @@
+/**
+ * POST /api/presentations — create a shareable presentation.
+ *
+ * The holder posts the credential ids they picked, the expiration they chose
+ * and (when the wallet could produce one) a proof over the presentation
+ * digest. The response only contains the opaque reference; the payload itself
+ * never leaves the server.
+ */
+
+import { NextResponse } from 'next/server';
+import {
+  InvalidPresentationError,
+  presentationExpiresAt,
+  type PresentationProof,
+} from '@acta-products/acta/presentation';
+import { createStoredPresentation } from '@/lib/presentation-store';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+interface CreateRequestBody {
+  holder?: unknown;
+  credentialIds?: unknown;
+  expiresAt?: unknown;
+  createdAt?: unknown;
+  proof?: unknown;
+}
+
+function parseProof(raw: unknown): PresentationProof | undefined {
+  if (typeof raw !== 'object' || raw === null) return undefined;
+  const proof = raw as Record<string, unknown>;
+
+  if (
+    typeof proof.digest !== 'string' ||
+    typeof proof.signature !== 'string' ||
+    typeof proof.verificationMethod !== 'string'
+  ) {
+    return undefined;
+  }
+
+  return {
+    type: 'StellarWalletSignature2026',
+    created: typeof proof.created === 'string' ? proof.created : new Date().toISOString(),
+    verificationMethod: proof.verificationMethod,
+    digest: proof.digest,
+    signature: proof.signature,
+  };
+}
+
+export async function POST(request: Request): Promise<NextResponse> {
+  let body: CreateRequestBody;
+
+  try {
+    body = (await request.json()) as CreateRequestBody;
+  } catch {
+    return NextResponse.json({ error: 'Malformed JSON body.' }, { status: 400 });
+  }
+
+  const { holder, credentialIds, expiresAt, createdAt } = body;
+
+  if (typeof holder !== 'string' || holder.length === 0) {
+    return NextResponse.json({ error: 'A holder DID is required.' }, { status: 400 });
+  }
+
+  if (!Array.isArray(credentialIds)) {
+    return NextResponse.json({ error: 'credentialIds must be an array.' }, { status: 400 });
+  }
+
+  if (expiresAt !== null && typeof expiresAt !== 'number') {
+    return NextResponse.json(
+      { error: 'expiresAt must be a timestamp in milliseconds or null.' },
+      { status: 400 }
+    );
+  }
+
+  if (createdAt !== undefined && typeof createdAt !== 'number') {
+    return NextResponse.json(
+      { error: 'createdAt must be a timestamp in milliseconds.' },
+      { status: 400 }
+    );
+  }
+
+  try {
+    const { ref, presentation } = await createStoredPresentation({
+      holder,
+      credentialIds: credentialIds as string[],
+      expiresAt,
+      createdAt,
+      proof: parseProof(body.proof),
+    });
+
+    return NextResponse.json(
+      { ref, expiresAt: presentationExpiresAt(presentation) },
+      { status: 201, headers: { 'Cache-Control': 'no-store' } }
+    );
+  } catch (err) {
+    if (err instanceof InvalidPresentationError) {
+      return NextResponse.json({ error: err.message }, { status: 400 });
+    }
+    console.error('Failed to create presentation', err);
+    return NextResponse.json({ error: 'Could not create the presentation.' }, { status: 500 });
+  }
+}
diff --git a/apps/credit-history/src/app/share/page.tsx b/apps/credit-history/src/app/share/page.tsx
index 373f60c..6304351 100644
--- a/apps/credit-history/src/app/share/page.tsx
+++ b/apps/credit-history/src/app/share/page.tsx
@@ -27,9 +27,17 @@ import {
   FileText,
   CheckCircle2,
 } from 'lucide-react';
+import {
+  createPresentationLink,
+  PresentationLinkError,
+  signPresentation,
+} from '@/lib/presentation-link';
+import { useSession } from '@/session/session-provider';
+import { getWalletConnector, resolveNetworkPassphrase } from '@/session/wallet-connector';
 
 export default function SharePage() {
   const t = useTranslations('share');
+  const { address, did } = useSession();
   const format = useFormatter();
   const [credentials, setCredentials] = React.useState<CreditCredential[]>([]);
   const [profile, setProfile] = React.useState<CreditProfileSummary | null>(null);
@@ -101,40 +109,49 @@ export default function SharePage() {
     }
   };
 
-  const handleGenerateLink = () => {
+  const handleGenerateLink = async () => {
     if (selectedIds.length === 0) {
       alert(t('noSelection'));
       return;
     }
 
-    setIsGenerating(true);
+    const holder = did ?? profile?.holderDid ?? '';
+    if (!holder) {
+      alert(t('noHolder'));
+      return;
+    }
 
-    // Simulate link generation delay
-    setTimeout(() => {
-      const now = Date.now();
-      const expirationTime = getExpirationTimestamp(now);
-      setGeneratedExpirationTime(expirationTime);
+    setIsGenerating(true);
 
-      // SEAM: the real ACTA sharing will be wired here (encrypted off-chain payload / ZK).
-      // Today we only generate a mock token. Missing: encryption, persistence, real expiration.
-      const payload = {
-        ids: selectedIds,
-        exp: expirationTime,
+    try {
+      const createdAt = Date.now();
+      const expirationTime = getExpirationTimestamp(createdAt);
+      const input = {
+        holder,
+        credentialIds: selectedIds,
+        expiresAt: expirationTime,
+        createdAt,
       };
 
-      const jsonStr = JSON.stringify(payload);
-
-      // Safe base64url encoding client-side
-      const utf8Bytes = new TextEncoder().encode(jsonStr);
-      const base64 = btoa(String.fromCharCode(...utf8Bytes));
-      const token = base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+      // Holder proof over the presentation digest. Best-effort: a wallet that
+      // declines to sign a bare digest must not block the share flow — the
+      // opaque server-side reference is what makes the link tamper-evident.
+      const proof =
+        (await signPresentation(getWalletConnector(), input, {
+          networkPassphrase: resolveNetworkPassphrase(),
+          address: address ?? undefined,
+        })) ?? undefined;
 
-      const origin = typeof window !== 'undefined' ? window.location.origin : '';
-      const shareUrl = `${origin}/verify/${token}`;
+      const { url, expiresAt } = await createPresentationLink({ ...input, proof });
 
-      setGeneratedLink(shareUrl);
+      setGeneratedExpirationTime(expiresAt);
+      setGeneratedLink(url);
+    } catch (err) {
+      console.error('Failed to create the shareable presentation', err);
+      alert(err instanceof PresentationLinkError ? err.message : t('generateError'));
+    } finally {
       setIsGenerating(false);
-    }, 800);
+    }
   };
 
   const resetForm = () => {
@@ -386,7 +403,7 @@ export default function SharePage() {
                 </CardContent>
                 <CardFooter className="border-t border-border/50 pt-6">
                   <Button
-                    onClick={handleGenerateLink}
+                    onClick={() => void handleGenerateLink()}
                     disabled={selectedIds.length === 0 || isGenerating}
                     className="h-auto min-h-10 w-full whitespace-normal py-2.5 text-center text-sm font-semibold cursor-pointer"
                   >
diff --git a/apps/credit-history/src/components/verify/public-verification-view.test.tsx b/apps/credit-history/src/components/verify/public-verification-view.test.tsx
index 93565d9..6a0d4f3 100644
--- a/apps/credit-history/src/components/verify/public-verification-view.test.tsx
+++ b/apps/credit-history/src/components/verify/public-verification-view.test.tsx
@@ -1,12 +1,13 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { cleanup, screen } from '@testing-library/react';
 import type { CreditCredential, CreditProfileSummary } from '@acta-products/acta/types';
+import { buildPresentation } from '@acta-products/acta/presentation';
 import { renderWithIntl } from '@/test/render-with-intl';
-import { encodePresentationToken } from '@/lib/presentation-token';
 
-const { listCredentials, getProfileSummary } = vi.hoisted(() => ({
+const { listCredentials, getProfileSummary, resolvePresentationRef } = vi.hoisted(() => ({
   listCredentials: vi.fn(),
   getProfileSummary: vi.fn(),
+  resolvePresentationRef: vi.fn(),
 }));
 
 vi.mock('@acta-products/ui', () => import('@/test/ui-mock'));
@@ -15,6 +16,8 @@ vi.mock('@acta-products/acta', () => ({
   getCredentialSource: () => ({ listCredentials, getProfileSummary }),
 }));
 
+vi.mock('@/lib/presentation-link', () => ({ resolvePresentationRef }));
+
 import { PublicVerificationView } from './public-verification-view';
 
 const CREDENTIAL: CreditCredential = {
@@ -36,9 +39,12 @@ const PROFILE: CreditProfileSummary = {
   activeCredentialsCount: 1,
 };
 
+const REF = 'a'.repeat(43);
+
 beforeEach(() => {
   listCredentials.mockReset().mockResolvedValue([CREDENTIAL]);
   getProfileSummary.mockReset().mockResolvedValue(PROFILE);
+  resolvePresentationRef.mockReset();
 });
 
 afterEach(() => {
@@ -46,24 +52,45 @@ afterEach(() => {
 });
 
 describe('PublicVerificationView', () => {
-  it('renders the invalid state for a malformed token', async () => {
-    renderWithIntl(<PublicVerificationView token="not-a-valid-token!!!" />);
+  it('renders the invalid state when the reference does not resolve', async () => {
+    resolvePresentationRef.mockResolvedValue({ status: 'not_found' });
+
+    renderWithIntl(<PublicVerificationView token="not-a-valid-reference!!!" />);
+
     expect(await screen.findByText('Invalid or expired presentation')).toBeInTheDocument();
     expect(screen.getByText('Presentation verification failed')).toBeInTheDocument();
   });
 
-  it('renders the expired state (with the expiry date) for an expired token', async () => {
-    const token = encodePresentationToken({ ids: ['cred-income'], exp: Date.now() - 60_000 });
-    renderWithIntl(<PublicVerificationView token={token} />);
+  it('renders the expired state (with the expiry date) when the resolver reports expiry', async () => {
+    resolvePresentationRef.mockResolvedValue({
+      status: 'expired',
+      expiresAt: Date.now() - 60_000,
+    });
+
+    renderWithIntl(<PublicVerificationView token={REF} />);
+
     expect(await screen.findByText('Invalid or expired presentation')).toBeInTheDocument();
     expect(screen.getByText(/expired on/i)).toBeInTheDocument();
   });
 
-  it('renders the verified report for a valid token', async () => {
-    const token = encodePresentationToken({ ids: ['cred-income'], exp: Date.now() + 3_600_000 });
-    renderWithIntl(<PublicVerificationView token={token} />);
+  it('renders the verified report for a live reference', async () => {
+    resolvePresentationRef.mockResolvedValue({
+      status: 'ok',
+      presentation: buildPresentation({
+        holder: 'did:stellar:testnet:GHOLDER',
+        credentialIds: ['cred-income'],
+        expiresAt: Date.now() + 3_600_000,
+      }),
+    });
+
+    renderWithIntl(<PublicVerificationView token={REF} />);
+
     expect(await screen.findByText('Verifiable presentation report')).toBeInTheDocument();
     expect(screen.getByText('Anchor Payroll Income')).toBeInTheDocument();
     expect(screen.getByText('Alex Mercer')).toBeInTheDocument();
   });
+
+  it('never puts credential data in the shared reference', () => {
+    expect(REF).not.toContain('cred-income');
+  });
 });
diff --git a/apps/credit-history/src/components/verify/public-verification-view.tsx b/apps/credit-history/src/components/verify/public-verification-view.tsx
index ab0f41e..f103842 100644
--- a/apps/credit-history/src/components/verify/public-verification-view.tsx
+++ b/apps/credit-history/src/components/verify/public-verification-view.tsx
@@ -27,7 +27,7 @@ import {
   revokedAtOf,
   statusKindOf,
 } from '@/lib/credentials';
-import { decodePresentationToken } from '@/lib/presentation-token';
+import { resolvePresentationRef } from '@/lib/presentation-link';
 
 type LoadState =
   | { phase: 'loading' }
@@ -98,24 +98,31 @@ export function PublicVerificationView({ token }: PublicVerificationViewProps) {
     let cancelled = false;
 
     const verify = async () => {
-      const payload = decodePresentationToken(token);
-      if (!payload) {
+      // The URL only carries an opaque reference — the presentation itself
+      // (credential ids, holder, expiration, holder proof) is resolved from the
+      // server, which is also where expiration is enforced. Nothing here can be
+      // bypassed by editing the link.
+      const resolution = await resolvePresentationRef(token);
+
+      if (resolution.status === 'not_found') {
         if (!cancelled) setState({ phase: 'invalid', reason: 'malformed' });
         return;
       }
 
-      if (payload.exp && Date.now() > payload.exp) {
+      if (resolution.status === 'expired') {
         if (!cancelled) {
           setState({
             phase: 'invalid',
             reason: 'expired',
-            expirationDate: new Date(payload.exp),
+            expirationDate: new Date(resolution.expiresAt),
           });
         }
         return;
       }
 
-      const expirationDate = payload.exp ? new Date(payload.exp) : null;
+      const { presentation } = resolution;
+      const expiresAt = presentation.expires ? Date.parse(presentation.expires) : null;
+      const expirationDate = expiresAt === null ? null : new Date(expiresAt);
 
       try {
         // SEAM: this is where the SDK verification will be called by RPC against the vc-vault.
@@ -127,7 +134,9 @@ export function PublicVerificationView({ token }: PublicVerificationViewProps) {
           source.getProfileSummary(),
         ]);
 
-        const credentials = allCredentials.filter((c) => payload.ids.includes(c.id));
+        const credentials = allCredentials.filter((c) =>
+          presentation.verifiableCredential.includes(c.id)
+        );
 
         if (credentials.length === 0) {
           if (!cancelled) setState({ phase: 'invalid', reason: 'malformed' });
@@ -138,7 +147,10 @@ export function PublicVerificationView({ token }: PublicVerificationViewProps) {
           setState({
             phase: 'ready',
             credentials,
-            profile,
+            // The holder DID shown to the verifier comes from the stored
+            // presentation, not from the vault read — it is the identity the
+            // presentation was created (and proved) under.
+            profile: { ...profile, holderDid: presentation.holder || profile.holderDid },
             expirationDate,
           });
         }
diff --git a/apps/credit-history/src/i18n/messages/en.json b/apps/credit-history/src/i18n/messages/en.json
index 58a4e2a..61a468a 100644
--- a/apps/credit-history/src/i18n/messages/en.json
+++ b/apps/credit-history/src/i18n/messages/en.json
@@ -152,7 +152,9 @@
     "issuer": "Issuer:",
     "vaultTitle": "ACTA Credit Vault",
     "revoked": "Revoked",
-    "valid": "Valid"
+    "valid": "Valid",
+    "noHolder": "Connect your wallet to generate a presentation link.",
+    "generateError": "The presentation link could not be generated. Please try again."
   },
   "verify": {
     "title": "Verifiable presentation report",
diff --git a/apps/credit-history/src/i18n/messages/es.json b/apps/credit-history/src/i18n/messages/es.json
index db527b4..8fbf4a2 100644
--- a/apps/credit-history/src/i18n/messages/es.json
+++ b/apps/credit-history/src/i18n/messages/es.json
@@ -152,7 +152,9 @@
     "issuer": "Emisor:",
     "vaultTitle": "Bóveda de Crédito ACTA",
     "revoked": "Revocada",
-    "valid": "Vigente"
+    "valid": "Vigente",
+    "noHolder": "Conecta tu billetera para generar un enlace de presentación.",
+    "generateError": "No se pudo generar el enlace de presentación. Inténtalo de nuevo."
   },
   "verify": {
     "title": "Reporte de presentación verificable",
diff --git a/apps/credit-history/src/lib/presentation-link.ts b/apps/credit-history/src/lib/presentation-link.ts
new file mode 100644
index 0000000..a725e98
--- /dev/null
+++ b/apps/credit-history/src/lib/presentation-link.ts
@@ -0,0 +1,139 @@
+/**
+ * @fileoverview Client-side helpers for the share (#39) and verify (#40) flows.
+ *
+ * Replaces the old `presentation-token` codec: nothing is encoded into the URL
+ * any more. `createPresentationLink` asks the server to persist a presentation
+ * and returns the opaque reference; `resolvePresentationRef` exchanges that
+ * reference back for the presentation, with expiration decided server-side.
+ */
+
+import {
+  buildPresentation,
+  presentationDigest,
+  type PresentationProof,
+  type VerifiablePresentation,
+} from '@acta-products/acta/presentation';
+import type { SignTransactionOpts, WalletConnector } from '@/session/wallet-connector';
+
+const API_ROOT = '/api/presentations';
+
+export interface CreatePresentationLinkInput {
+  holder: string;
+  credentialIds: string[];
+  /** Epoch milliseconds, or null for a link that never expires. */
+  expiresAt: number | null;
+  /**
+   * Creation time in epoch milliseconds. Sent explicitly so the server rebuilds
+   * byte-identical presentation to the one the holder signed — otherwise the
+   * two `created` timestamps differ and the proof digest no longer matches.
+   * The server rejects values that are not close to its own clock.
+   */
+  createdAt: number;
+  proof?: PresentationProof;
+}
+
+export interface CreatedPresentationLink {
+  ref: string;
+  /** Absolute URL the holder shares with a verifier. */
+  url: string;
+  expiresAt: number | null;
+}
+
+export class PresentationLinkError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'PresentationLinkError';
+  }
+}
+
+export async function createPresentationLink(
+  input: CreatePresentationLinkInput,
+  origin: string = typeof window !== 'undefined' ? window.location.origin : ''
+): Promise<CreatedPresentationLink> {
+  const response = await fetch(API_ROOT, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(input),
+  });
+
+  if (!response.ok) {
+    const detail = await response
+      .json()
+      .then((body: { error?: string }) => body.error)
+      .catch(() => undefined);
+    throw new PresentationLinkError(detail ?? 'The presentation could not be created.');
+  }
+
+  const { ref, expiresAt } = (await response.json()) as { ref: string; expiresAt: number | null };
+
+  return { ref, url: `${origin}/verify/${ref}`, expiresAt };
+}
+
+export type PresentationResolution =
+  | { status: 'ok'; presentation: VerifiablePresentation }
+  | { status: 'not_found' }
+  | { status: 'expired'; expiresAt: number };
+
+export async function resolvePresentationRef(ref: string): Promise<PresentationResolution> {
+  let response: Response;
+
+  try {
+    response = await fetch(`${API_ROOT}/${encodeURIComponent(ref)}`, { cache: 'no-store' });
+  } catch {
+    // A network failure is indistinguishable from an unknown reference for the
+    // verifier's purposes — both mean "this link cannot be trusted right now".
+    return { status: 'not_found' };
+  }
+
+  if (response.status === 410) {
+    const body = (await response.json().catch(() => ({}))) as { expiresAt?: number };
+    return { status: 'expired', expiresAt: body.expiresAt ?? 0 };
+  }
+
+  if (!response.ok) {
+    return { status: 'not_found' };
+  }
+
+  const { presentation } = (await response.json()) as { presentation: VerifiablePresentation };
+  return { status: 'ok', presentation };
+}
+
+// ─── Holder proof ─────────────────────────────────────────────────────────────
+
+/**
+ * Ask the connected wallet to sign the digest of the presentation about to be
+ * created.
+ *
+ * Best-effort by design: `signTransaction` expects a Stellar XDR envelope, and
+ * neither the mock connector nor every real wallet will sign a bare digest. A
+ * refusal must not block sharing, so failures resolve to `null` and the
+ * presentation is persisted unsigned — the opaque reference is what makes the
+ * link tamper-evident, the proof is the extra attribution layer the public
+ * verifier (#40) will validate against the holder's did:stellar key.
+ */
+export async function signPresentation(
+  connector: WalletConnector,
+  input: { holder: string; credentialIds: string[]; expiresAt: number | null; createdAt: number },
+  opts: SignTransactionOpts
+): Promise<PresentationProof | null> {
+  if (!connector.signTransaction) return null;
+
+  try {
+    const presentation = buildPresentation(input);
+    const digest = await presentationDigest(presentation);
+    const { signedXdr } = await connector.signTransaction(digest, opts);
+
+    if (!signedXdr) return null;
+
+    return {
+      type: 'StellarWalletSignature2026',
+      created: new Date().toISOString(),
+      verificationMethod: input.holder,
+      digest,
+      signature: signedXdr,
+    };
+  } catch (err) {
+    console.warn('Holder proof skipped — the wallet could not sign the presentation digest.', err);
+    return null;
+  }
+}
diff --git a/apps/credit-history/src/lib/presentation-store.test.ts b/apps/credit-history/src/lib/presentation-store.test.ts
new file mode 100644
index 0000000..8fa1a9f
--- /dev/null
+++ b/apps/credit-history/src/lib/presentation-store.test.ts
@@ -0,0 +1,122 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { InvalidPresentationError } from '@acta-products/acta/presentation';
+import {
+  createPresentationRef,
+  createStoredPresentation,
+  isPresentationRef,
+  MAX_CREATED_AT_DRIFT_MS,
+  resolveStoredPresentation,
+} from './presentation-store';
+
+const HOLDER = 'did:stellar:testnet:GHOLDER';
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+describe('createPresentationRef', () => {
+  it('produces an opaque 43-char base64url reference', () => {
+    const ref = createPresentationRef();
+    expect(ref).toMatch(/^[A-Za-z0-9_-]{43}$/);
+    expect(isPresentationRef(ref)).toBe(true);
+  });
+
+  it('never repeats a reference', () => {
+    const refs = new Set(Array.from({ length: 200 }, createPresentationRef));
+    expect(refs.size).toBe(200);
+  });
+
+  it.each(['', 'short', 'not-a-ref!!', 'a'.repeat(44)])('rejects %o as a reference', (value) => {
+    expect(isPresentationRef(value)).toBe(false);
+  });
+});
+
+describe('createStoredPresentation', () => {
+  it('returns a reference that leaks nothing about the presentation', async () => {
+    const { ref } = await createStoredPresentation({
+      holder: HOLDER,
+      credentialIds: ['cred-income', 'cred-loan'],
+      expiresAt: Date.now() + 3_600_000,
+    });
+
+    expect(ref).not.toContain('cred-income');
+    expect(atob(ref.replace(/-/g, '+').replace(/_/g, '/'))).not.toContain('cred');
+  });
+
+  it('rejects a createdAt that drifts from the server clock', async () => {
+    await expect(
+      createStoredPresentation({
+        holder: HOLDER,
+        credentialIds: ['cred-income'],
+        expiresAt: null,
+        createdAt: Date.now() - MAX_CREATED_AT_DRIFT_MS - 1,
+      })
+    ).rejects.toBeInstanceOf(InvalidPresentationError);
+  });
+
+  it('rejects an empty selection', async () => {
+    await expect(
+      createStoredPresentation({ holder: HOLDER, credentialIds: [], expiresAt: null })
+    ).rejects.toBeInstanceOf(InvalidPresentationError);
+  });
+});
+
+describe('resolveStoredPresentation', () => {
+  beforeEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('resolves a live reference to its presentation', async () => {
+    const { ref } = await createStoredPresentation({
+      holder: HOLDER,
+      credentialIds: ['cred-income'],
+      expiresAt: Date.now() + 3_600_000,
+    });
+
+    const resolution = await resolveStoredPresentation(ref);
+    expect(resolution.status).toBe('ok');
+    if (resolution.status !== 'ok') return;
+    expect(resolution.presentation.holder).toBe(HOLDER);
+    expect(resolution.presentation.verifiableCredential).toEqual(['cred-income']);
+  });
+
+  it('reports an unknown or malformed reference as not_found', async () => {
+    expect((await resolveStoredPresentation(createPresentationRef())).status).toBe('not_found');
+    expect((await resolveStoredPresentation('tampered')).status).toBe('not_found');
+    expect((await resolveStoredPresentation(undefined)).status).toBe('not_found');
+  });
+
+  it('enforces expiration on resolution and burns the reference', async () => {
+    const expiresAt = Date.now() + 60_000;
+    const { ref } = await createStoredPresentation({
+      holder: HOLDER,
+      credentialIds: ['cred-income'],
+      expiresAt,
+    });
+
+    expect((await resolveStoredPresentation(ref)).status).toBe('ok');
+
+    vi.useFakeTimers();
+    vi.setSystemTime(expiresAt + 1);
+
+    const expired = await resolveStoredPresentation(ref);
+    expect(expired).toEqual({ status: 'expired', expiresAt });
+
+    // Once expired the reference stops resolving even if the clock moves back.
+    vi.setSystemTime(expiresAt - 10_000);
+    expect((await resolveStoredPresentation(ref)).status).toBe('not_found');
+  });
+
+  it('keeps resolving a presentation that never expires', async () => {
+    const { ref } = await createStoredPresentation({
+      holder: HOLDER,
+      credentialIds: ['cred-income'],
+      expiresAt: null,
+    });
+
+    vi.useFakeTimers();
+    vi.setSystemTime(Date.now() + 365 * 24 * 60 * 60 * 1000);
+
+    expect((await resolveStoredPresentation(ref)).status).toBe('ok');
+  });
+});
diff --git a/apps/credit-history/src/lib/presentation-store.ts b/apps/credit-history/src/lib/presentation-store.ts
new file mode 100644
index 0000000..43eb4e9
--- /dev/null
+++ b/apps/credit-history/src/lib/presentation-store.ts
@@ -0,0 +1,179 @@
+/**
+ * @fileoverview Server-side persistence and resolution of shared presentations.
+ *
+ * This module must only ever be imported from Route Handlers / Server
+ * Components. It is what makes a share link tamper-evident:
+ *
+ *   - the link carries an opaque 256-bit random reference, not the payload, so
+ *     it can be neither decoded into credential data nor edited;
+ *   - the presentation (credential ids + expiration + holder proof) lives
+ *     here, out of the verifier's reach;
+ *   - expiration is enforced on resolution, so extending a link is impossible
+ *     without asking the holder for a new one.
+ *
+ * SEAM: `InMemoryPresentationStore` is process-local — it does not survive a
+ * restart and is not shared between serverless instances. It implements the
+ * `PresentationStore` contract from `@acta-products/acta/presentation`;
+ * swapping it for an ACTA off-chain payload (or any durable KV) is a one-line
+ * change in `getPresentationStore()` and touches nothing else.
+ */
+
+import {
+  buildPresentation,
+  InvalidPresentationError,
+  isPresentationExpired,
+  presentationExpiresAt,
+  type PresentationProof,
+  type PresentationStore,
+  type VerifiablePresentation,
+} from '@acta-products/acta/presentation';
+
+/** 32 random bytes → 43 base64url chars. */
+const REF_BYTES = 32;
+const REF_PATTERN = /^[A-Za-z0-9_-]{43}$/;
+
+export function createPresentationRef(): string {
+  const bytes = new Uint8Array(REF_BYTES);
+  globalThis.crypto.getRandomValues(bytes);
+  let binary = '';
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+
+export function isPresentationRef(value: unknown): value is string {
+  return typeof value === 'string' && REF_PATTERN.test(value);
+}
+
+// ─── In-memory store ──────────────────────────────────────────────────────────
+
+/**
+ * Held on `globalThis` so the map survives Next.js dev hot-reloads, which
+ * re-evaluate this module on every edit and would otherwise drop every link
+ * generated since the last save.
+ */
+const GLOBAL_KEY = Symbol.for('acta:presentation-store');
+
+type GlobalWithStore = typeof globalThis & {
+  [GLOBAL_KEY]?: Map<string, VerifiablePresentation>;
+};
+
+function records(): Map<string, VerifiablePresentation> {
+  const scope = globalThis as GlobalWithStore;
+  scope[GLOBAL_KEY] ??= new Map<string, VerifiablePresentation>();
+  return scope[GLOBAL_KEY];
+}
+
+class InMemoryPresentationStore implements PresentationStore {
+  async save(ref: string, presentation: VerifiablePresentation): Promise<void> {
+    records().set(ref, presentation);
+  }
+
+  async get(ref: string): Promise<VerifiablePresentation | null> {
+    return records().get(ref) ?? null;
+  }
+
+  async delete(ref: string): Promise<void> {
+    records().delete(ref);
+  }
+}
+
+let store: PresentationStore | null = null;
+
+export function getPresentationStore(): PresentationStore {
+  store ??= new InMemoryPresentationStore();
+  return store;
+}
+
+/** Test seam — lets a test swap in its own store implementation. */
+export function setPresentationStore(next: PresentationStore | null): void {
+  store = next;
+}
+
+// ─── Create / resolve ─────────────────────────────────────────────────────────
+
+export interface CreatePresentationInput {
+  holder: string;
+  credentialIds: string[];
+  expiresAt: number | null;
+  /**
+   * Creation time supplied by the holder so the server rebuilds the exact
+   * object that was signed. Rejected when it drifts more than
+   * `MAX_CREATED_AT_DRIFT_MS` from the server clock, so it can't be used to
+   * backdate or postdate a presentation.
+   */
+  createdAt?: number;
+  proof?: PresentationProof;
+}
+
+/** Tolerance for the holder-supplied `createdAt` against the server clock. */
+export const MAX_CREATED_AT_DRIFT_MS = 5 * 60 * 1000;
+
+export interface CreatedPresentation {
+  ref: string;
+  presentation: VerifiablePresentation;
+}
+
+/**
+ * Build, sign-wrap and persist a presentation.
+ *
+ * Throws `InvalidPresentationError` when the input is malformed — callers
+ * should map that to a 400.
+ */
+export async function createStoredPresentation({
+  holder,
+  credentialIds,
+  expiresAt,
+  createdAt,
+  proof,
+}: CreatePresentationInput): Promise<CreatedPresentation> {
+  const now = Date.now();
+
+  if (createdAt !== undefined && Math.abs(now - createdAt) > MAX_CREATED_AT_DRIFT_MS) {
+    throw new InvalidPresentationError('createdAt is too far from the server clock.');
+  }
+
+  const built = buildPresentation({
+    holder,
+    credentialIds,
+    expiresAt,
+    createdAt: createdAt ?? now,
+  });
+  const presentation = proof ? { ...built, proof } : built;
+
+  const ref = createPresentationRef();
+  await getPresentationStore().save(ref, presentation);
+
+  return { ref, presentation };
+}
+
+export type PresentationResolution =
+  | { status: 'ok'; presentation: VerifiablePresentation }
+  | { status: 'not_found' }
+  | { status: 'expired'; expiresAt: number };
+
+/**
+ * Resolve a share reference, enforcing expiration here rather than trusting
+ * the client. Expired presentations are dropped from the store on the way out
+ * so the reference stops resolving for good.
+ */
+export async function resolveStoredPresentation(ref: unknown): Promise<PresentationResolution> {
+  if (!isPresentationRef(ref)) {
+    return { status: 'not_found' };
+  }
+
+  const activeStore = getPresentationStore();
+  const presentation = await activeStore.get(ref);
+
+  if (!presentation) {
+    return { status: 'not_found' };
+  }
+
+  if (isPresentationExpired(presentation)) {
+    await activeStore.delete(ref);
+    return { status: 'expired', expiresAt: presentationExpiresAt(presentation) ?? 0 };
+  }
+
+  return { status: 'ok', presentation };
+}
diff --git a/apps/credit-history/src/lib/presentation-token.test.ts b/apps/credit-history/src/lib/presentation-token.test.ts
deleted file mode 100644
index cb4972b..0000000
--- a/apps/credit-history/src/lib/presentation-token.test.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  decodePresentationToken,
-  encodePresentationToken,
-  type PresentationPayload,
-} from './presentation-token';
-
-describe('presentation-token codec', () => {
-  it('round-trips a payload with a numeric expiry', () => {
-    const payload: PresentationPayload = { ids: ['cred-a', 'cred-b'], exp: 1_800_000_000_000 };
-    expect(decodePresentationToken(encodePresentationToken(payload))).toEqual(payload);
-  });
-
-  it('round-trips a payload with a null expiry', () => {
-    const payload: PresentationPayload = { ids: ['cred-a'], exp: null };
-    expect(decodePresentationToken(encodePresentationToken(payload))).toEqual(payload);
-  });
-
-  it('round-trips ids containing unicode and url-unsafe bytes', () => {
-    const payload: PresentationPayload = { ids: ['crédito-ñ-🎉', 'a+b/c=d'], exp: null };
-    expect(decodePresentationToken(encodePresentationToken(payload))).toEqual(payload);
-  });
-
-  it('produces a url-safe token (no +, /, or = padding)', () => {
-    const token = encodePresentationToken({ ids: ['a', 'b', 'c'], exp: 123 });
-    expect(token).not.toMatch(/[+/=]/);
-  });
-
-  describe('rejects tampered or malformed input', () => {
-    it('returns null for non-base64 garbage', () => {
-      expect(decodePresentationToken('not a token!!!')).toBeNull();
-    });
-
-    it('returns null for valid base64 that is not JSON', () => {
-      const token = btoa('this is plain text, not json').replace(/=+$/, '');
-      expect(decodePresentationToken(token)).toBeNull();
-    });
-
-    it('returns null when ids is missing', () => {
-      const token = btoa(JSON.stringify({ exp: 123 })).replace(/=+$/, '');
-      expect(decodePresentationToken(token)).toBeNull();
-    });
-
-    it('returns null when ids is not an array', () => {
-      const token = btoa(JSON.stringify({ ids: 'cred-a', exp: 123 })).replace(/=+$/, '');
-      expect(decodePresentationToken(token)).toBeNull();
-    });
-
-    it('returns null when ids is an empty array', () => {
-      const token = btoa(JSON.stringify({ ids: [], exp: null })).replace(/=+$/, '');
-      expect(decodePresentationToken(token)).toBeNull();
-    });
-
-    it('returns null for a JSON literal that is not an object', () => {
-      const token = btoa(JSON.stringify(42)).replace(/=+$/, '');
-      expect(decodePresentationToken(token)).toBeNull();
-    });
-
-    it('returns null for an empty token', () => {
-      expect(decodePresentationToken('')).toBeNull();
-    });
-  });
-});
diff --git a/apps/credit-history/src/lib/presentation-token.ts b/apps/credit-history/src/lib/presentation-token.ts
deleted file mode 100644
index 42b9d12..0000000
--- a/apps/credit-history/src/lib/presentation-token.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-/**
- * Presentation link token codec shared between the share flow (#7) and the
- * public verify view (#20). Payload is base64url-encoded JSON.
- */
-export interface PresentationPayload {
-  ids: string[];
-  exp: number | null;
-}
-
-function base64UrlEncode(bytes: Uint8Array): string {
-  const base64 = btoa(String.fromCharCode(...bytes));
-  return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
-}
-
-function base64UrlDecode(token: string): string {
-  const base64 = token
-    .replace(/-/g, '+')
-    .replace(/_/g, '/')
-    .padEnd(token.length + ((4 - (token.length % 4)) % 4), '=');
-
-  return decodeURIComponent(
-    atob(base64)
-      .split('')
-      .map((c) => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2))
-      .join('')
-  );
-}
-
-export function encodePresentationToken(payload: PresentationPayload): string {
-  const jsonStr = JSON.stringify(payload);
-  const utf8Bytes = new TextEncoder().encode(jsonStr);
-  return base64UrlEncode(utf8Bytes);
-}
-
-export function decodePresentationToken(token: string): PresentationPayload | null {
-  try {
-    const jsonStr = base64UrlDecode(token);
-    const parsed = JSON.parse(jsonStr) as PresentationPayload;
-
-    if (!parsed || !Array.isArray(parsed.ids) || parsed.ids.length === 0) {
-      return null;
-    }
-
-    return parsed;
-  } catch {
-    return null;
-  }
-}
diff --git a/apps/credit-history/src/session/wallet-connector.ts b/apps/credit-history/src/session/wallet-connector.ts
index 417cca8..2246651 100644
--- a/apps/credit-history/src/session/wallet-connector.ts
+++ b/apps/credit-history/src/session/wallet-connector.ts
@@ -41,7 +41,7 @@ export interface WalletConnector {
 
 // ── Network helpers ───────────────────────────────────────────────────────────
 
-function resolveNetworkPassphrase(): Networks {
+export function resolveNetworkPassphrase(): Networks {
   const raw = process.env.NEXT_PUBLIC_STELLAR_NETWORK ?? 'testnet';
   switch (raw.toLowerCase()) {
     case 'mainnet':
diff --git a/packages/acta/package.json b/packages/acta/package.json
index 87746d3..16fa97b 100644
--- a/packages/acta/package.json
+++ b/packages/acta/package.json
@@ -7,7 +7,8 @@
     ".": "./src/index.ts",
     "./did": "./src/did.ts",
     "./hooks": "./src/hooks.ts",
-    "./types": "./src/types.ts"
+    "./types": "./src/types.ts",
+    "./presentation": "./src/presentation.ts"
   },
   "scripts": {
     "typecheck": "tsc --noEmit",
diff --git a/packages/acta/src/index.ts b/packages/acta/src/index.ts
index 078c7b7..b93a493 100644
--- a/packages/acta/src/index.ts
+++ b/packages/acta/src/index.ts
@@ -4,3 +4,4 @@
 export * from '@acta-team/credentials';
 export * from './did';
 export * from './mock';
+export * from './presentation';
diff --git a/packages/acta/src/presentation.test.ts b/packages/acta/src/presentation.test.ts
new file mode 100644
index 0000000..cdd0117
--- /dev/null
+++ b/packages/acta/src/presentation.test.ts
@@ -0,0 +1,133 @@
+import { describe, expect, it } from 'vitest';
+import type { BuildPresentationInput } from './presentation';
+import {
+  attachPresentationProof,
+  buildPresentation,
+  canonicalPresentationPayload,
+  InvalidPresentationError,
+  isPresentationExpired,
+  MAX_PRESENTATION_CREDENTIALS,
+  presentationDigest,
+  presentationExpiresAt,
+} from './presentation';
+
+const HOLDER = 'did:stellar:testnet:GHOLDER';
+const NOW = Date.parse('2026-07-22T12:00:00.000Z');
+
+describe('buildPresentation', () => {
+  it('builds a W3C-shaped presentation that references credentials by id only', () => {
+    const vp = buildPresentation({
+      holder: HOLDER,
+      credentialIds: ['cred-a', 'cred-b'],
+      expiresAt: NOW + 3_600_000,
+      createdAt: NOW,
+    });
+
+    expect(vp).toEqual({
+      '@context': ['https://www.w3.org/ns/credentials/v2'],
+      type: ['VerifiablePresentation'],
+      holder: HOLDER,
+      verifiableCredential: ['cred-a', 'cred-b'],
+      created: '2026-07-22T12:00:00.000Z',
+      expires: '2026-07-22T13:00:00.000Z',
+    });
+    expect(JSON.stringify(vp)).not.toContain('claims');
+  });
+
+  it('accepts a null expiration for links that never expire', () => {
+    const vp = buildPresentation({ holder: HOLDER, credentialIds: ['a'], expiresAt: null });
+    expect(vp.expires).toBeNull();
+    expect(presentationExpiresAt(vp)).toBeNull();
+    expect(isPresentationExpired(vp)).toBe(false);
+  });
+
+  it('deduplicates credential ids while preserving order', () => {
+    const vp = buildPresentation({
+      holder: HOLDER,
+      credentialIds: ['b', 'a', 'b'],
+      expiresAt: null,
+    });
+    expect(vp.verifiableCredential).toEqual(['b', 'a']);
+  });
+
+  it.each<[string, BuildPresentationInput]>([
+    ['an empty holder', { holder: '', credentialIds: ['a'], expiresAt: null }],
+    ['no credentials', { holder: HOLDER, credentialIds: [], expiresAt: null }],
+    ['a blank credential id', { holder: HOLDER, credentialIds: [''], expiresAt: null }],
+    [
+      'an expiration in the past',
+      { holder: HOLDER, credentialIds: ['a'], expiresAt: NOW - 1, createdAt: NOW },
+    ],
+    [
+      'too many credentials',
+      {
+        holder: HOLDER,
+        credentialIds: Array.from({ length: MAX_PRESENTATION_CREDENTIALS + 1 }, (_, i) => `c${i}`),
+        expiresAt: null,
+      },
+    ],
+  ])('rejects %s', (_label, input) => {
+    expect(() => buildPresentation(input)).toThrow(InvalidPresentationError);
+  });
+});
+
+describe('canonicalPresentationPayload', () => {
+  it('is stable regardless of key order and excludes the proof', async () => {
+    const vp = buildPresentation({
+      holder: HOLDER,
+      credentialIds: ['a'],
+      expiresAt: null,
+      createdAt: NOW,
+    });
+    const digest = await presentationDigest(vp);
+
+    const signed = attachPresentationProof(vp, {
+      type: 'StellarWalletSignature2026',
+      created: new Date(NOW).toISOString(),
+      verificationMethod: HOLDER,
+      digest,
+      signature: 'signed-xdr',
+    });
+
+    expect(canonicalPresentationPayload(signed)).toBe(canonicalPresentationPayload(vp));
+    expect(await presentationDigest(signed)).toBe(digest);
+
+    const reordered = {
+      ...vp,
+      created: vp.created,
+      holder: vp.holder,
+    };
+    expect(canonicalPresentationPayload(reordered)).toBe(canonicalPresentationPayload(vp));
+  });
+
+  it('changes the digest when the expiration changes', async () => {
+    const base = buildPresentation({
+      holder: HOLDER,
+      credentialIds: ['a'],
+      expiresAt: NOW + 1000,
+      createdAt: NOW,
+    });
+    const tampered = { ...base, expires: new Date(NOW + 999_999).toISOString() };
+
+    expect(await presentationDigest(tampered)).not.toBe(await presentationDigest(base));
+  });
+});
+
+describe('isPresentationExpired', () => {
+  it('reports expiry against the given clock', () => {
+    const vp = buildPresentation({
+      holder: HOLDER,
+      credentialIds: ['a'],
+      expiresAt: NOW + 1000,
+      createdAt: NOW,
+    });
+
+    expect(isPresentationExpired(vp, NOW)).toBe(false);
+    expect(isPresentationExpired(vp, NOW + 1001)).toBe(true);
+  });
+
+  it('treats an unparseable expiry as expired', () => {
+    const vp = buildPresentation({ holder: HOLDER, credentialIds: ['a'], expiresAt: null });
+    expect(isPresentationExpired({ ...vp, expires: 'not-a-date' })).toBe(true);
+  });
+});
diff --git a/packages/acta/src/presentation.ts b/packages/acta/src/presentation.ts
new file mode 100644
index 0000000..8c511ce
--- /dev/null
+++ b/packages/acta/src/presentation.ts
@@ -0,0 +1,206 @@
+/**
+ * @fileoverview Verifiable Presentation model for ACTA share links.
+ *
+ * Replaces the plaintext base64url token that used to carry `{ ids, exp }` in
+ * the URL. A presentation is now a W3C-shaped object built here, signed by the
+ * holder (see `attachPresentationProof`) and persisted server-side; the share
+ * URL only carries an opaque reference to it.
+ *
+ * The presentation deliberately references credentials by id only — the claims
+ * themselves are never part of the shared object. The resolving side re-reads
+ * them from the holder's ACTA vault, so a share link can never leak credential
+ * data on its own.
+ *
+ * NOTE ON PERSISTENCE:
+ * `@acta-team/credentials` exposes its client exclusively through the
+ * `useActaClient()` React hook, so it cannot be constructed on a server
+ * runtime. Persistence therefore lives behind the `PresentationStore`
+ * interface below; the product wires the concrete store (see
+ * `apps/credit-history/src/lib/presentation-store.ts`). When the SDK exposes a
+ * non-hook client or a dedicated off-chain payload endpoint, swap the store
+ * implementation — nothing else in this file changes.
+ */
+
+/** W3C VC Data Model v2 context, the same one `vcIssue` requires for vcData. */
+export const PRESENTATION_CONTEXT = 'https://www.w3.org/ns/credentials/v2';
+
+export const PRESENTATION_TYPE = 'VerifiablePresentation';
+
+/**
+ * Holder proof over the canonical presentation payload.
+ *
+ * `signature` is produced by the connected wallet (Freighter / Stellar Wallets
+ * Kit). It is stored alongside the presentation and surfaced to the verifier;
+ * cryptographic validation of the signature against the holder's did:stellar
+ * key belongs to the public verification flow (#40).
+ */
+export interface PresentationProof {
+  type: 'StellarWalletSignature2026';
+  /** ISO timestamp of when the proof was created. */
+  created: string;
+  /** DID whose key produced the signature — always the holder DID. */
+  verificationMethod: string;
+  /** base64url SHA-256 digest of the canonical presentation payload. */
+  digest: string;
+  /** Wallet-produced signature over `digest`. */
+  signature: string;
+}
+
+export interface VerifiablePresentation {
+  '@context': string[];
+  type: string[];
+  /** Holder DID in did:stellar:{network}:{G…} form. */
+  holder: string;
+  /** ACTA vault credential ids included in this presentation. */
+  verifiableCredential: string[];
+  /** ISO timestamp of creation. */
+  created: string;
+  /** ISO timestamp after which the presentation must be rejected, or null. */
+  expires: string | null;
+  proof?: PresentationProof;
+}
+
+export interface BuildPresentationInput {
+  /** Holder DID (did:stellar:…). */
+  holder: string;
+  /** Credential ids selected by the holder. */
+  credentialIds: string[];
+  /** Expiration as epoch milliseconds, or null for a link that never expires. */
+  expiresAt: number | null;
+  /** Creation time as epoch milliseconds. Defaults to now. */
+  createdAt?: number;
+}
+
+export class InvalidPresentationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'InvalidPresentationError';
+  }
+}
+
+/** Maximum number of credentials a single presentation may reference. */
+export const MAX_PRESENTATION_CREDENTIALS = 64;
+
+export function buildPresentation({
+  holder,
+  credentialIds,
+  expiresAt,
+  createdAt = Date.now(),
+}: BuildPresentationInput): VerifiablePresentation {
+  if (typeof holder !== 'string' || holder.length === 0) {
+    throw new InvalidPresentationError('A holder DID is required to build a presentation.');
+  }
+
+  if (!Array.isArray(credentialIds) || credentialIds.length === 0) {
+    throw new InvalidPresentationError('A presentation must reference at least one credential.');
+  }
+
+  if (credentialIds.length > MAX_PRESENTATION_CREDENTIALS) {
+    throw new InvalidPresentationError(
+      `A presentation may reference at most ${MAX_PRESENTATION_CREDENTIALS} credentials.`
+    );
+  }
+
+  if (credentialIds.some((id) => typeof id !== 'string' || id.length === 0)) {
+    throw new InvalidPresentationError('Credential ids must be non-empty strings.');
+  }
+
+  if (expiresAt !== null) {
+    if (!Number.isFinite(expiresAt)) {
+      throw new InvalidPresentationError('Expiration must be a finite timestamp or null.');
+    }
+    if (expiresAt <= createdAt) {
+      throw new InvalidPresentationError('Expiration must be in the future.');
+    }
+  }
+
+  // Deduplicate while preserving the holder's selection order.
+  const ids = [...new Set(credentialIds)];
+
+  return {
+    '@context': [PRESENTATION_CONTEXT],
+    type: [PRESENTATION_TYPE],
+    holder,
+    verifiableCredential: ids,
+    created: new Date(createdAt).toISOString(),
+    expires: expiresAt === null ? null : new Date(expiresAt).toISOString(),
+  };
+}
+
+/**
+ * Deterministic JSON serialisation used as the signing payload.
+ *
+ * Object keys are sorted recursively and `proof` is excluded, so the digest is
+ * stable regardless of property insertion order and can be recomputed by a
+ * verifier from the stored presentation.
+ */
+export function canonicalPresentationPayload(presentation: VerifiablePresentation): string {
+  const { proof: _proof, ...unsigned } = presentation;
+  return stableStringify(unsigned);
+}
+
+function stableStringify(value: unknown): string {
+  if (value === null || typeof value !== 'object') {
+    return JSON.stringify(value) ?? 'null';
+  }
+
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(',')}]`;
+  }
+
+  const entries = Object.entries(value as Record<string, unknown>)
+    .filter(([, v]) => v !== undefined)
+    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+    .map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`);
+
+  return `{${entries.join(',')}}`;
+}
+
+/** base64url SHA-256 of the canonical payload. Works in browser and Node 22+. */
+export async function presentationDigest(presentation: VerifiablePresentation): Promise<string> {
+  const bytes = new TextEncoder().encode(canonicalPresentationPayload(presentation));
+  const hash = await globalThis.crypto.subtle.digest('SHA-256', bytes);
+  return base64UrlEncode(new Uint8Array(hash));
+}
+
+export function base64UrlEncode(bytes: Uint8Array): string {
+  let binary = '';
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+
+export function attachPresentationProof(
+  presentation: VerifiablePresentation,
+  proof: PresentationProof
+): VerifiablePresentation {
+  return { ...presentation, proof };
+}
+
+/** Expiration as epoch milliseconds, or null when the presentation never expires. */
+export function presentationExpiresAt(presentation: VerifiablePresentation): number | null {
+  if (presentation.expires === null) return null;
+  const parsed = Date.parse(presentation.expires);
+  // An unparseable expiry is treated as "already expired" rather than "never".
+  return Number.isNaN(parsed) ? 0 : parsed;
+}
+
+export function isPresentationExpired(
+  presentation: VerifiablePresentation,
+  now: number = Date.now()
+): boolean {
+  const expiresAt = presentationExpiresAt(presentation);
+  return expiresAt !== null && now > expiresAt;
+}
+
+/**
+ * Persistence seam for presentations. Implementations must treat `ref` as an
+ * opaque, unguessable capability — never derive it from the presentation
+ * contents.
+ */
+export interface PresentationStore {
+  save(ref: string, presentation: VerifiablePresentation): Promise<void>;
+  get(ref: string): Promise<VerifiablePresentation | null>;
+  delete(ref: string): Promise<void>;
+}