w3c
Unclear definition of "Read" operation for DID methods
This refers to 'the "Read" operation of the applicable DID method as described in Method Operations', but https://www.w3.org/TR/did-core/#method-operations doesn't mention the word "Read". What's the signature of that operation?
From https://github.com/w3ctag/design-reviews/issues/1157#issuecomment-3439062470
DID v1.1 spec states:
A DID method specification MUST specify how a DID resolver uses a DID to resolve a DID document, including how the DID resolver can verify the authenticity of the response.
So perhaps we change DID Resolution to use the "Resolve" operation.
Also this:
What's the signature of that operation?
Makes me wonder if we should define resolve(did, resolutionOptions) as the interface, making it clearer that resolutionOptions get passed through to DID methods after generic processing by the DID resolver.
Also, how do DID Method specific errors get surfaced by the DID resolver?
This is step 3 of the DID Resolution Algorithm https://www.w3.org/TR/did-resolution/#resolving-algorithm
As @jandrieu pointed out we are not trying to standardize this. The DID Resolver is providing a common interface to resolve distinct DID methods. The DID resolver does the work of integrating "Read" operations of these DID methods.
We should probably change the language from Read to resolve
This was discussed during the #did meeting on 06 November 2025.
View the transcript
w3c/did-resolution#230
<ottomorac> https://
<Wip> https://
wip: I think this is a good point. I don't know what we can do about it. In the 4.4 DID resolution algorithm step 3, we execute the read operation, and it's not clear what it means; it's under-defined.
JoeAndrieu: I agree, it shouldn't be "read".
… The "read" language is in quotes because we previously used the CRUD style. The advantage of that reference doesn't help anymore, and I think it's just a resolve operation.
<Wip> https://
wip: It points to the DID Core specification. I wonder if we should make it more concrete by passing in the DID, the method, and the resolution options.
JoeAndrieu: I think we need to define a resolver that's going to resolve. We tried to separate this out because we had concerns about the protocol boundary in our charter.
… We're standardizing the front end, not the back end. That's the point.
wip: I think I agree the "read" operation should be "resolve". We should respond to Jeffrey to say that we'
… we're not trying to standardize this.
@peacekeeper can you chime in on this? Current proposal is to update the "Read" to Resolve
The PR should also handle #223 and remove the normative requirement to pass the resolutionOptions
This was discussed during the #did meeting on 11 November 2025.
View the transcript
w3c/did-resolution#230
wip: We discussed this. We don't define the read resolution anywhere.
… I think Joe commented that we don't have a concrete interface
… We also discussed changing this from Read to Resolve
… The argument to change it to resolve is that we don't define "Read" we define "Resolve"
… There is no read. It's either an old term.
JoeAndrieu: Its just an unfortunate and editorial change, the "Read" is in quotes as the CRUD read... it's not meant to be normative. We are talking about just resolution.
wip: Jeffrey is saying that there is no signature for this operation
JoeAndrieu: I don't think his point isn't that there is a formal signature on the endpoint, he proposes did resolution options as the interface. We had RESOLVE as a function that was defined... I think he does have a signature. DID Methods must support these contracts.
wip: Ok. Let's just update this from read to resolve.
denken: I just think it would be just easier to add in 7.2 method operations in DID v1.1, we just mention that the that Resolution is "Read"
wip: there are two ways to do this. Either change did core or change did-resolution
… seems we are more aligned with Resolve, although I note that Markus thinks of it as the DID Method defining "read" which is executed by the resolver
manu: I'm looking at the DID 1.1 spec and we use the resolve language
JoeAndrieu: Markus noted that the resolver is doing resolution, the DID Method spec is the thing that provides the read operation for the resolver.
wip: let's check in with Markus
… Great. That was all of Jeffrey's TAG issues
… Next, we'll work through the issues labelled "discuss"
Unfortunately marking this as discuss again - apologies.
@peacekeeper I would like your input either in the comments or on this weeks call.
We use the language Read throughout the current DID resolution specification 15 times. Sometimes as "Read" other times as <a data-cite="did-core#method-operations">Read</a> or equivalent.
Including in the introduction:
DID resolution is the process of obtaining a DID document for a given DID. This is one of four required operations that can be performed on any DID ("Read"; the other ones being "Create", "Update", and "Deactivate").
We also use "Read" once in the DID core document when defining DID resolution - https://www.w3.org/TR/did-1.1/#dfn-did-resolution.
While I could replace all these instances with Resolve, I think there does seem to be a clear intention to distinguish Resolve from Read.
What is confusing Jeffery I think is that the method operations in DID 1.1. - https://www.w3.org/TR/did-1.1/#method-operations - make no mention of a Read operation. This is the relevant bullet from that section:
A DID method specification MUST specify how a DID resolver uses a DID to resolve a DID document, including how the DID resolver can verify the authenticity of the response.
Would it be possible to clarify this bullet is referring to the Read operation?
In my mind there should be a distinction between the resolve() function and a DID method's "Read" operation. The former is how a client invokes a resolver, and the latter is how a DID method obtains the data for a DID document from a VDR. At some point, the "Read" operation was explicitly mentioned in https://www.w3.org/TR/did-1.0/#method-operations, unfortunately I don't remember now when that was replaced with "resolve".
Thanks Markus, I do think this is a useful distinction.
Perhaps we should be changing DID core instead?
@msporny what do you think
This was discussed during the #did meeting on 04 December 2025.
View the transcript
Unclear definition of ""Read"" operation for DID methods #230 \[2\] (7 min)
<ottomorac> w3c/
<ottomorac> There is one additional clarification that Will requested on this issue regarding the Resolve vs. Read Operation and how we are managing that in DID Core. Markus has provided his perspective, and Will would like Manu to weigh in here as well.
ottomorac: this issue had some conversation in the past day
… Markus would like Manu's take on this, as it may also impact DID core.
manu: I think I agree with what Markus is saying in this issue
… I need to look in more depth on how it impacts DID core
… Markus says that there is a difference between read and resolve
… "read" just instructs the resolver to perform the resolution
… "resolve" is the process applied by the resolver
… we could transfer this issue to DID core, I believe it is editorial, so we could make it in CR
JoeAndrieu: I do think we need this nuance, but I'm not sure I would put it exactly as manu did.
<manu> +1 that there is nuance to tease out
JoeAndrieu: for me "read" is what the resolver is doing, "resolve" is what the method defines
<KevinDean> "Resolve" is a function within "Read".
JoeAndrieu: we can discuss on proposed text
<swcurran> Wow...Joe, I think the reverse.
swcurran: I think the only reason the term "read" is here is because the acronym CRUD is used.
… if DID core dropped "CRUD", resolve would be enough
<manu> We'd have Create, Resolve, Update, and Deactivate :)
swcurran: but +1 to tease it out in a PR
Just reading the minutes from yesterday.
I also think the opposite of what @jandrieu stated.
For me, the resolver is executing resulting requests to resolve DIDs. The resolver is resolving. As part of any resolution, the resolver calls the read operation of a specific DID method identified in the DID string.
Read is a function within resolve.
If DID methods are implementing resolve, then I think the DID Resolver with its resolve() function and resolution algorithm is confusing.
Maybe there are other names we can come up with to distinguish what the method implements Vs what a resolver does?
This was discussed during the #did meeting on 11 December 2025.
View the transcript
DID Resolution "Read" operation
<Wip> w3c/
Wip: What is the impact here? Move resolve to read? What are we doing here?
Wip: There is significant change to change Read -> resolve.
JoeAndrieu: I don't think we had consensus -- I think I'm on the opposite side... DID Methods define resolve -- what they dont' define is how they read from the VDR. Bitcoin defines how you read from Bitcoin, Method says how to resolve.
JoeAndrieu: I think we need more conversation.
manu: We need to tease out the nuance here, more discussion needed.
Wip: It feels like what is being said is "Read" as an operation needs to be moved from Resolution spec -- resolver has "resolve" function, which then calls "resolve" operation for DID Method? I'll take another pass and have a look.
Wip: I was looking through did:cel and that defines a "READ" operation -- read algorithm, that's true of many DID Methods... they don't define "resolve", they define "read".
Okay I took another look at this.
One proposal I heard yesterday was to change the "Read" operation to be the "Resolve" operation. So DID Methods define a resolve operation not a read operation. It is within this Resolve operation that DID Methods "read" from their verifiable data registry.
I am okay with making this change, but it is fairly significant. Especially for the method architectures section - https://w3c.github.io/did-resolution/#method-architectures
Do we keep the terms verifiable and unverifiable read? I suggest we do, as they are specifically related to access to the VDR.
The other thing I will note is from a random sampling of DID method specifications. A significant number are defining a Read operation. Often like Read (Resolve).
E.g.:
- did:web
- did:key
- did:webvh
- did:btcr
- did:btcr2 -- Although I believe there was a decision to move to Resolve, the current spec uses Read.
- did:nostr
Some do define resolve instead of read:
It seems this is not exactly clear for DID method implementers.
So do we go ahead and change "Read" operation to "Resolve"?
Either way, I also think we could clarify the DID spec to explicitly name the method operations - https://www.w3.org/TR/did/upcoming/#method-operations.