Note: While the standards governing these architectures have advanced significantly, fully native eIDAS 2.0 wallet payment acceptance remains an emerging capability. This guide serves as a theoretical and architectural preview of how dynamic linking will function under the finalized OpenID4VP 1.0 and European Wallet Consortium (EWC) payment profiles.

Dynamic linking has been a core requirement of European payment security since the introduction of Strong Customer Authentication (SCA) under PSD2. The rule mandates that every remote electronic payment must produce an authentication code cryptographically linked to the specific transaction amount and the designated payee. Historically, banks met this requirement through proprietary mobile banking applications, push notifications, or SMS one-time passwords.

Now, the regulatory landscape is shifting. The proposed Payment Services Regulation (PSR) and PSD3 framework introduces stricter liability for Authorized Push Payment (APP) fraud, expands consumer protections, and raises the technical bar for SCA. As these payment rules advance alongside the rollout of eIDAS 2.0, payments and digital identity are intersecting. Regulated payment service providers and credit institutions will be required to accept the European Digital Identity (EUDI) Wallet. While this acceptance obligation does not mean every single payment must be routed through a wallet, it establishes the wallet as a standardized, cross-border authentication channel.

Recent banking requests for information have begun probing vendors to demonstrate verifiable credential presentation flows that enforce dynamic linking. Specifically, the authorization must bind to an exact transaction ID, amount, currency, and payee, and any modification to these values must immediately invalidate the approval. The following walkthrough covers how this dynamic binding works using OpenID for Verifiable Presentations (OID4VP) and SD-JWT Verifiable Credentials.

Architecture overview

Implementing dynamic linking in an identity wallet architecture requires separating long-lived identity attributes from transient transaction data.

A sequence diagram showing a dynamic linking payment flow between a merchant or verifier, a wallet, and a secure enclave, from the initial OpenID4VP auth request through KB-JWT signing to the verifier’s validation pipeline Dynamic linking payment flow: the merchant or verifier sends the OpenID4VP auth request, the wallet renders the confirmation UI and signs the KB-JWT in the secure enclave, and the verifier runs the validation pipeline before executing the payment

The user carries a credential issued by an authorized bank or public authority, such as a Person Identification Data credential or a Payment Account Attestation. This credential is long-lived and includes a confirmation claim (cnf) containing the user’s public key. The corresponding private key is held securely within the user’s device hardware.

The transaction details (amount, currency, and payee) are dynamic and ephemeral. These values are supplied at the presentation layer by the verifier when initiating the authorization request.

Passing transaction data through OpenID4VP

The mechanism that enables this exchange is the transaction_data parameter, defined in the OpenID for Verifiable Presentations 1.0 specification and used in conjunction with the Digital Credentials Query Language (DCQL). When a user initiates checkout or a fund transfer, the relying party (acting as the verifier) creates an authorization request. This request can be delivered over a browser redirect, an app-to-app deep link, or a cross-device QR code.

Note on Verifier Roles: While our code examples use an e-commerce merchant (checkout.merchant.example), the actual verifier depends on the payment model. In a two-party model, the verifier is the issuing bank directly. In a three-party model (like e-commerce), the merchant initiates the flow but typically relays the resulting Verifiable Presentation to their acquiring Payment Service Provider (PSP) or the issuing bank via open banking APIs or EMV 3-D Secure rails.

The verifier passes transaction_data as an array of Base64URL-encoded strings:

{
  "client_id": "https://checkout.merchant.example",
  "response_uri": "https://checkout.merchant.example/wallet-callback",
  "response_type": "vp_token",
  "response_mode": "direct_post",
  "nonce": "n-0S6_WzA2Mj",
  "dcql_query": {
    "credentials": [
      {
        "id": "payment_attestation_input",
        "format": "dc+sd-jwt",
        "meta": {
          "vct_values": [
            "https://wallet.example.eu/credentials/PaymentAccountAttestation"
          ]
        }
      }
    ]
  },
  "transaction_data": [
    "eyJ0eXBlIjoicGF5bWVudF9kYXRhIiwiY3JlZGVudGlhbF9pZHMiOlsicGF5bWVudF9hdHRlc3RhdGlvbl9pbnB1dCJdLCJ0cmFuc2FjdGlvbl9kYXRhX2hhc2hlc19hbGciOlsic2hhLTI1NiJdLCJwYXltZW50X2RhdGEiOnsicGF5ZWUiOiJBY21lIFNwb3J0cyBCViIsImN1cnJlbmN5X2Ftb3VudCI6eyJjdXJyZW5jeSI6IkVVUiIsInZhbHVlIjoiNDUuMDAifX19"
  ]
}

While OpenID4VP specifies the transport container, the schema of the decoded object is governed by domain profiles, such as the European Digital Identity Wallet Consortium payment profile (EWC RFC-008).

Decoding that entry reveals the nested payment structure:

{
  "type": "payment_data",
  "credential_ids": [
    "payment_attestation_input"
  ],
  "transaction_data_hashes_alg": [
    "sha-256"
  ],
  "payment_data": {
    "payee": "Acme Sports BV",
    "currency_amount": {
      "currency": "EUR",
      "value": "45.00"
    }
  }
}

The type field establishes the schema. The credential_ids array matches the id field defined inside the dcql_query.credentials array, binding the payment data to the requested credential. The transaction_data_hashes_alg array specifies the hashing algorithm required for the presentation. Finally, the nested payment_data object supplies the dynamic linking parameters: payee, amount, and currency.

The wallet’s job: “What you see is what you sign”

OpenID4VP splits responsibility cleanly: the verifier constructs the request, but the wallet decides what the user actually sees and attests to. This section covers the wallet’s two core obligations — displaying the payment details in a trusted prompt so the user approves exactly what will be signed, and producing a hash of the payload that lets the verifier detect any modification.

Display assurance and hash generation

OpenID4VP governs protocol transmission, but ensuring that the user actually sees and confirms these values depends on the wallet implementation. In certified high-assurance wallet environments, the application interacts with operating system security controls to present an isolated, trustworthy prompt displaying the payee, amount, and currency. After the user approves the prompt using device biometrics or a PIN, the wallet prepares the cryptographic proof.

To avoid hash discrepancies caused by JSON key reordering, spacing differences, or varying serialization libraries, OpenID4VP mandates that the wallet compute the digest over the exact ASCII bytes of the Base64URL-encoded entry received in the request. The wallet does not parse, reencode, or reserialize the payload prior to hashing.

SD-JWT VC key binding

To build the presentation response, modern wallet implementations rely on the IETF SD-JWT-based Verifiable Digital Credentials profile.

The returned presentation token includes the issuer-signed credential, any selectively disclosed claims, and an ephemeral Key Binding JWT (KB-JWT) generated by the wallet.

The decoded KB-JWT structure appears as follows:

// JOSE Header
{
  "alg": "ES256",
  "typ": "kb+jwt"
}

// JWT Payload
{
  "nonce": "n-0S6_WzA2Mj",
  "aud": "https://checkout.merchant.example",
  "iat": 1792620000,
  "sd_hash": "b2RhZHNmYXNkZnNkZmFzZGZhZHM",
  "transaction_data_hashes": [
    "oi5oFeP2hOgjHdLwNh6qbDDcSdaD2rvUKiaC3HggTOg"
  ],
  "transaction_data_hashes_alg": "sha-256"
}

The transaction_data_hashes array contains the Base64URL-encoded SHA-256 digest of the raw transaction data string, and the transaction_data_hashes_alg claim echoes the requested algorithm as required by the EWC specification. The wallet signs this KB-JWT using the private key associated with the public key declared in the base credential’s confirmation claim.

Closed loop tamper defense

When the verifier receives the presentation, it must execute a sequential validation pipeline before treating the payment as authorized:

  1. Session, Nonce, and Audience Validation: Confirm that the audience claim matches the verifier identifier. Confirm that the nonce exists in the active session cache and immediately evict it to prevent replay attacks.
  2. Credential Verification: Validate the issuer signature on the base credential using published keys or certificates, and verify the credential status using the relevant status list.
  3. Key Binding Validation: Extract the public key from the confirmation claim of the validated credential, verify the KB-JWT signature and sd_hash, and validate the issuance timestamp (iat).
  4. Dynamic Linking Verification: Retrieve the original, raw Base64URL request string stored in the server session. Compute the SHA-256 digest over the ASCII bytes of that original string. Compare the result to the entry in the transaction_data_hashes array.
  5. Idempotent Execution: Mark the specific transaction payload as authorized.

If an attacker intercepts the request and alters the amount from 45.00 to 450.00, the hash computed by the verifier will not match the hash signed inside the KB-JWT. If the attacker attempts to alter the hash inside the KB-JWT, the signature on the token fails because the attacker lacks the user’s hardware-backed private key. In both instances, verification fails and the transaction is aborted.

When planning integrations, teams must distinguish between base specifications, credential profiles, and domain schemas:

Layer Governing Specification Status Architectural Role
Presentation Protocol OpenID4VP 1.0 Final OpenID4VP 1.0 is a finalized specification that defines the transport protocol and core parameters, including the transaction_data object.
Base Token Format IETF RFC 9901 Final Defines Selective Disclosure JWTs and generic Key Binding JWT structure.
Credential Profile draft-ietf-oauth-sd-jwt-vc-19 Draft Defines verifiable credential claims, metadata, and validation flows.
Payment Schema Profile EWC RFC-008 / EUDI ARF Pilot Specification Defines field-level transaction structures (type: payment_data, payment_data object) and domain-specific rules.
Banking Rules PSD3 Pre-Enforcement Establishes legal compliance for dynamic linking and payment fraud liability.

Upcoming Regulatory Technical Standards from the European Banking Authority will establish the formal operational and certification rules for production payment acceptance across the banking sector.

The path to production with Ping Identity

While this walkthrough demonstrates the target state of EUDI Wallet payment presentations, the reality of implementing this today is heavily dependent on the maturation of EU reference wallets and final EBA certification frameworks.

Ping Identity is actively monitoring the evolution of the EUDI Architecture and Reference Framework (ARF) and the EWC payment profiles. Support for the OpenID4VP transaction_data parameter, DCQL-based complex querying, and SD-JWT Key Binding validation are key considerations of the PingOne Credentials roadmap.

In the meantime, you don’t have to wait to start exploring OpenID4VC with Ping Identity. The PingOne Credentials universal service already offers standards-based capabilities for issuing and verifying digital credentials. You can explore the platform’s current features and capabilities by reviewing the PingOne API developer documentation for OpenID4VP and OpenID4VCI.

Join the discussion on the Ping Identity developer community.

Tags

Developer ResourcesAccess Management & Authorization#PingOne#OAuth#identity#mobile#OpenID4VP#digital credentials#EUDI Wallet#payments