Trust in the Wallet Ecosystem
When a wallet receives a credential from an issuer, or responds to a request from a verifier, it needs a way to answer a simple question: can this party be trusted? Because you choose your wallet from any certified provider and a verifier may be an organisation you have never dealt with, that link cannot be assumed; it has to be proven. A valid cryptographic signature proves that a credential was not tampered with, but it does not, on its own, prove who the signer is or whether that signer is a recognised, accountable entity. Establishing that link between a key and a real, recognised organisation is the job of a trust framework.
This page explains how the iGrant.io Data Wallet and Organisation Wallet establish trust in the parties they interact with, the trust mechanisms they support, and how the result of that check is shown to the user.
The bigger picture: Layers of trust
Trust in the EU Digital Identity ecosystem is not a single check but several layers, each resting on the one below. It helps to see where the checks on this page fit.

- Legal foundation. eIDAS 2.0 and its Implementing Acts define the roles, certification and supervision for everyone.
- Ecosystem trust (who is who). Trusted Lists record which providers, issuers and relying parties are recognised, so parties that have never met can verify each other.
- Wallet and device trust. The Wallet Unit Attestation proves a wallet is genuine and that its keys are in secure hardware. See Wallet Unit Attestation (WUA).
- Credential trust. Credentials are signed by trusted issuers and bound to the holder's keys, so they cannot be forged or copied.
- Transaction trust. At each exchange, the parties prove themselves before any data is shared.
This page focuses on Layer 2: how the wallet checks that an issuer or verifier is a recognised entity (against the EU Trust List and related mechanisms), and how it surfaces the result (Layer 5).
What is being checked
This page concentrates on the ecosystem-trust layer: confirming that an issuer or verifier is a recognised entity. The other layers are covered in separate articles, for example Wallet Unit Attestation (WUA) for wallet and device trust and the credential issuance lifecycle for how credentials are issued and bound to the holder.
Trust is evaluated for the two roles a wallet interacts with:
- Issuers, also called service providers in the wallet interface, who issue credentials into the wallet during an issuance (OpenID4VCI) flow.
- Verifiers, also called relying parties, who request credentials from the wallet during a presentation (OpenID4VP) flow.
In both cases the wallet attempts to match the party's identity (for example, its certificate, decentralised identifier, or registered entity details) against one or more trusted sources. If a match is found, the party is treated as trusted and its verified details can be shown to the user. If no match is found, the wallet displays a "not verified" notice. See The "not verified" provider notice for what that notice means and how to resolve it.
Supported trust mechanisms
The wallet can validate issuers and verifiers against several trust mechanisms. The most relevant for European Digital Identity (EUDI) scenarios is the EU Trust List.
| Mechanism | Description |
|---|---|
| EU Trust List (as per ETSI TS 119 612) | Each EU member state publishes a trusted list of qualified and non-qualified trust service providers. These national lists are aggregated through the European List of Trusted Lists (LoTL). The wallet checks whether the issuer or verifier appears on a list it validates against. Most established issuers in the EUDI framework are included. |
| Lists of trusted entities (as per ETSI TS 119 602) | The EU publishes lists of trusted entities for wallet providers, PID providers, PuB-EAA providers, and the providers of access and registration certificates for relying parties. The wallet checks whether the party appears on one of these lists. |
| X.509 certificates (trust anchors) | Trust is anchored in a Public Key Infrastructure (PKI) certificate chain that terminates at a CA certificate the organisation has added as a trust anchor. |
| Accepted trust sources | Each check uses only the trust sources in its accepted list (for example acceptedCredentialSigners of a credential query), so you decide which sources count for each check. See Accepted lists. |
| OpenID Federation | Trust established through an OpenID Federation trust chain. Support is on the roadmap (coming soon). |
The mechanisms available to a specific deployment depend on the organisation's trust sources: CA certificates (trust anchors) and published lists (ETSI trusted lists and ETSI lists of trusted entities). Each organisation, and each sandbox organisation, has its own trust sources. When you add a list as a trust source, the wallet reads it immediately. If the list cannot be read as a list of the kind you selected, or its signature does not verify with the list signer certificates you provided, the API rejects the trust source with trust_source.list_not_usable and nothing is saved. See the Trust Sources APIs.
EU Trust List validation versus Trust Anchor onboarding
These two terms are easy to confuse, so it is worth being precise about the difference.
- EU Trust List validation answers "is this issuer or verifier on a recognised trusted list?". It is a lookup the wallet performs against published trusted lists (ETSI TS 119 612 and the LoTL). It is the mechanism most often behind the "not verified" notice.
- Trust Anchor onboarding is the process of registering an entity into a trust framework, so that it becomes trusted in the first place. The exact mechanism depends on the framework, for example an entry on a national trusted list or on an EU list of trusted entities, or a certificate issued by a CA that the parties trust. Onboarding can also be established through X.509 certificates alone: this is how a relying party is registered on the iGrant.io test network so the Data Wallet treats it as trusted, described in Register as a Wallet-Relying Party.
In short: onboarding puts an entity into a trust framework, and trust list validation checks an entity against the trusted lists at the time of issuance or presentation. An issuer that has not been onboarded to any framework the wallet recognises, and that does not appear on a trusted list the wallet validates against, will be shown as an untrusted service provider.
Trust in the wallet provider of a wallet
Trust also runs the other way: an issuer checks the wallet that asks for a credential. The wallet sends a Wallet Instance Attestation (WIA) and, for its binding keys, a key attestation. The WIA is signed by the wallet provider, and its x5c header carries the wallet provider's certificate chain. See Wallet Unit Attestation (WUA).
Key attestations
A key attestation must carry one of the following certificate chains in its x5c header:
- the certificate chain of a wallet provider, when a wallet provider signs the key attestation (mode
wallet_provider), or - on Android, the chain from the device's hardware Keystore to the Google Hardware Attestation Root, when the device key signs the key attestation (mode
android_keystore).
The issuer rejects a key attestation that has neither chain, for example one that the attested key signed itself (KA_ROOT_UNTRUSTED).
An iOS wallet unit sends a key attestation signed by its wallet provider (mode wallet_provider), because the wallet provider already checked App Attest when the iOS wallet unit registered. The issuer therefore checks only the wallet provider and does not check an Apple root.
An Android hardware Keystore key attestation has no wallet provider signer, so the issuer does not run a trusted list check for it. Instead, it runs a platform root check: the chain must end at the Google Hardware Attestation Root, and no certificate in the chain may be revoked in the Google attestation status list. If the issuer's stored copy of the Google attestation status list is not current, it cannot check revocation. In that case, it rejects a required Android key attestation with HTTP 503, and accepts an optional one without a level and with the warning KA_ANDROID_STATUS_UNAVAILABLE. The proof of possession has no trusted list check.
Trusting a wallet provider
When requiresTrustedWalletProvider is on, the issuer checks the signer of the WIA, and of any key attestation signed by a wallet provider, for the role wallet_provider. The signer is trusted only when its certificate chain validates to a trust source in acceptedWalletProviders that is used for this role:
- a list of trusted entities (
etsi_lote) for wallet providers that includes the wallet provider, or - a trust anchor (
trust_anchor) used forwallet_providerthat holds the wallet provider's root CA certificate.
No other source establishes trust. An entry for another role (for example a PID provider) does not make a wallet provider trusted, and the issuer does not trust a wallet provider on the same platform unless one of these trust sources covers it. It does not use a list of wallet providers from a registry either. Only attestations with an x5c header are accepted.
Two settings of the credential definition control what the issuer rejects:
requiresTrustedWalletProvideris the trust switch for the wallet provider. When it is on, the wallet must send a valid WIA (signature, proof of possession, expiry and revocation status), otherwise the issuer rejects the request withinvalid_client. A trust source inacceptedWalletProvidersmust also cover the signer of each WIA, and of each wallet provider key attestation, that the wallet sends, for the rolewallet_provider. The issuer rejects a wallet provider that is not trusted withinvalid_client(Client attestation refused: the wallet provider of the attestation is not trusted for this credential), and the issuance history records the error:WUA_WALLET_PROVIDER_NOT_TRUSTEDin the validity of the WIA (the WIA itself stays valid) andKA_WALLET_PROVIDER_NOT_TRUSTEDin the validity of the key attestation.acceptedWalletProvidersis the accepted list for the switch. It is required when the switch is on (trust.accepted_list_required), and every trust source in it must be used forwallet_provider(trust.accepted_list_wrong_role).
A key attestation remains optional unless the credential configuration requires one.
For development, leave requiresTrustedWalletProvider off. The issuer then runs no trust check: it only checks the validity of a WIA that the wallet sends, and records an invalid WIA without rejecting the request. The key_storage and user_authentication levels of a key attestation still count when its certificate chain is currently valid. The trust switch does not apply to an Android hardware Keystore key attestation, where the platform root check decides.
What the issuer records
The issuer records the results in the issuance history. When requiresTrustedWalletProvider is off, no trust check runs, and each walletProviderTrustedListCheck has the reason.code not_required.
authorisation.walletUnitAttestation.walletProviderTrustedListCheck: the trusted list check of the WIA's wallet provider.authorisation.keyAttestation.walletProviderTrustedListCheck: the trusted list check of the key attestation's wallet provider (modewallet_provider), orauthorisation.keyAttestation.platformRootCheck(modeandroid_keystore).authorisation.keyAttestation.validity: the result of each check of the key attestation (signature, expiry, revocation, nonce, proof key and levels), with any errors and their stable codes (KA_*). The issuer records it even when it rejects the key attestation.trustRequiredof the WIA and of the key attestation: the value ofrequiresTrustedWalletProviderthat applied.trustof the WIA and of the key attestation: a summary of who makes the attestation trusted, based on its one trust check.kindis eithertrust_source(from the trusted list check:anchorIdandanchorNameidentify the trust source of the matched entry, andproviderNameis the provider of the entry) orplatform_root(from the platform root check of an Android key attestation:Google Hardware Attestation Root, providerGoogle).trustedholds the result, and the reason for a result that is not trusted is in the check itself.trustisnullwhen no check ran.
In the dashboard, the issuance history shows these results in two cards. The Wallet unit attestation card shows the checks of the WIA (including Is Trusted) and of the proof of possession. The Key attestation card shows the proof type, who attested the key (the wallet provider or the Android hardware Keystore), the levels and the checks (Proof valid, the checks of the key attestation and Is Trusted). The hover text of Is Trusted tells you who makes the attestation trusted: the provider and the trust source, or the platform root. With the switch off, the Is Trusted chip is grey and its hover text names the switch that is off. With the switch on, a result that is not trusted is shown as an error. Any issues are listed one per line, each with its code and message.
Follow these steps for each issuer organisation that accepts the wallets of a wallet provider:
- Get the root CA certificate (PEM) of the wallet provider, that is, the CA that issued the certificate of its attestation signing key. For a wallet provider on this platform, you can find it in the certificate chain of the key selected in its wallet provider configuration (Key Management).
- Add it as a trust source of the issuer organisation: in the dashboard, add a trust anchor used for Wallet provider, or call Add trust source with
"kind": "trust_anchor","usedFor": "wallet_provider"and the PEM text ascertificates. - Add the
idof the new trust source toacceptedWalletProvidersof the credential definition, and turn onrequiresTrustedWalletProvider. - Repeat these steps whenever the wallet provider moves to a new root CA.
The wallet provider does not use trusted lists for its own wallets. When a wallet asks it for a key attestation, it accepts only a WIA that it signed itself with the current signing key of its configuration. After the wallet provider replaces that key, its wallets must request a new WIA.
Accepted lists
A check runs only when its Require switch is on, and it then uses only the trust sources in its accepted list. An accepted list is an array of trust source IDs:
acceptedWalletProvidersof a credential definition (switch:requiresTrustedWalletProvider).credentialQueryOptions.<credential query id>.acceptedCredentialSignersof a presentation definition (switch:requiresTrustedCredentialSignerof the query).acceptedCredentialSigners,acceptedRelyingPartiesandacceptedIssuersof the holder configuration (switches:requiresTrustedCredentialSigner,requiresTrustedRelyingPartyandrequiresTrustedIssuer).acceptedStatusIssuersof the holder configuration and of a credential query (switch:requiresTrustedStatusIssuer), for the signer of a credential's status list. By default, the credential signer may also sign the status list (acceptCredentialSignerAsStatusIssuer); the check then passes with the reasonsame_as_credential_signer, without a list lookup.
When the switch is off, no check runs: the recorded value has the result not_applicable and the reason.code not_required. In the dashboard, the trust chip is grey, and its hover text explains why.
When the switch is on, the list is required, and the API rejects a save without it with 400 (trust.accepted_list_required). An empty list accepts nothing. Each value must be the ID of one of the organisation's trust sources (trust.accepted_list_not_a_trust_source), the source must be turned on (trust.accepted_list_source_disabled), and its usedFor must fit the list (trust.accepted_list_wrong_role). A signer that none of the listed sources covers gives not_found. A trust source that is in an accepted list cannot be deleted or turned off (trust_source.in_use); use Read trust source usage to see where it is used.
The status of the matched entry also counts. A status that the list declares negative, such as withdrawn, gives not_trusted, while an unusual status passes with a warning that explains what is wrong. Entries of an ETSI TS 119 602 list have no status, which is correct.
An expired list stays in use, based on its last stored copy. A match then gives trusted with the warning list_expired, which states when the list stopped being valid, and no match gives not_found. A status that the list declares negative still fails. If an accepted source has no good copy at all, the result is error when nothing matches.
The holder configuration also has acceptedClientIds: client IDs with the prefix x509_san_dns: or x509_hash:. This optional list narrows acceptedRelyingParties: when it is set, the client_id of a presentation request must be one of them, and an empty list does not narrow anything. A client ID on its own never makes a signer trusted. The holder configuration also has acceptedEtsiTrustedLists, the ETSI list trust sources that an etsi_tl item in a request may name, with no switch. The wallet keeps only the URLs of these lists. If an item names a URL that is not accepted, the wallet rejects the request and informs the verifier with access_denied and the reason.
{
"requiresTrustedRelyingParty": true,
"acceptedRelyingParties": ["3f1e5a6b-7c8d-4e9f-8a0b-1c2d3e4f5a6b"],
"acceptedClientIds": ["x509_san_dns:verifier.example.com"]
}
These lists are checks that the wallet makes itself: it never sends them to another wallet or to a verifier. The DCQL trusted_authorities of a credential query are a separate mechanism. They keep the OpenID4VP 1.0 types aki and etsi_tl, and the verifier sends them to the wallet so that the wallet offers only matching credentials. They do not depend on a Require switch and have no role. aki is only a filter for finding matching credentials and does not prove trust. An etsi_tl value is the URL of one of the organisation's ETSI list trust sources, whose signer certificates provide the authenticity. When a query uses both mechanisms, the verifier applies acceptedCredentialSigners as an additional step after the DCQL query. See DCQL query with a trusted authority.
How trust status is surfaced
After the wallet checks a party, the result is shown both in the wallet interface and in the API. Every check has the same shape (TrustedListCheck, in a member named after its gate): verified; result (trusted, not_trusted, not_found, not_applicable or error); the role that the check asks for; the matched entry, with its entryId, its roles and its trust source; a reason for not_trusted, not_applicable and error; a warning for an unusual entry status or an expired list; and presentedCertificates, the certificates that the signer presented.
- A held credential has
credentialSignerTrustedListCheck(for the signer of the credential, switchrequiresTrustedCredentialSigner) andissuerTrustedListCheck(for the signer of the issuer's signed metadata, switchrequiresTrustedIssuer). It also hasstatusIssuerTrustedListCheckandstatusIssuerIsCredentialSignerfor the signer of its status list, which has its own switch,requiresTrustedStatusIssuer. With that switch on, the wallet rejects a credential whose status list signer is not trusted (held_credential.status_issuer_not_trusted); at a later status refresh, the new result is recorded and the credential stays in the wallet. - A holder presentation has
relyingPartyTrustedListCheck(for the signer of the verifier's request, switchrequiresTrustedRelyingParty).
When verified is false, the wallet shows the "not verified" notice to the user.
A verifier reads the trust result for each issuer in its verification record, in presentationValidity[].credentialSignerTrustedListCheck. A check that passes with an unusual entry status also adds the warning TRUST_ENTRY_STATUS, and one that passes against an expired list adds TRUST_LIST_EXPIRED. Each entry also has statusIssuerTrustedListCheck and statusIssuerIsCredentialSigner for the signer of the credential's status list. When requiresTrustedStatusIssuer is on for the credential query, a status list signer that is not trusted fails the credential with PRES_STATUS_ISSUER_NOT_TRUSTED.
In the dashboard, each trust chip reads Is Trusted, and its colour shows the state: green when the party is trusted, amber when it passes with a warning or when the check could not decide, red when it is not trusted, and grey when no check ran. The hover text explains who trusts the party, or why not.