Documentation ¶
Overview ¶
Package presentproof provides support for the Present Proof Protocol 2.0: https://github.com/hyperledger/aries-rfcs/blob/master/features/0454-present-proof-v2/README.md.
A protocol supporting a general purpose verifiable presentation exchange regardless of the specifics of the underlying verifiable presentation request and verifiable presentation format.
1. Create your client:
client, err := presentproof.New(ctx) if err != nil { panic(err) }
2. Register an action event channel.
actions := make(chan service.DIDCommAction) client.RegisterActionEvent(actions)
3. Handle incoming actions.
for { select { case event := <-actions: piid := e.Properties.All()["piid"].(string) if event.Message.Type() == presentproof.ProposePresentationMsgType { // If Verifier is willing to accept the proposal. client.AcceptProposePresentation(piid, &RequestPresentation{}) // If Verifier is not willing to accept the proposal. client.DeclineProposePresentation(piid, reason) } if event.Message.Type() == presentproof.RequestPresentationMsgType { // If Prover is willing to accept a request. client.AcceptRequestPresentation(piid, &Presentation{}) // If Prover wants to counter a request they received with a proposal. client.NegotiateRequestPresentation(piid, &ProposePresentation{}) // If Prover is not willing to accept a request. client.DeclineRequestPresentation(piid, reason) } if event.Message.Type() == presentproof.PresentationMsgType { // If Verifier is willing to accept the presentation. client.AcceptPresentation(piid, names) // If Verifier is not willing to accept the presentation. client.DeclinePresentation(piid, reason) } if event.Message.Type() == presentproof.ProblemReportMsgType { Problem report message is triggered to notify client about the error. In that case, there is only one option - accept it. client.AcceptProblemReport(piid) } } }
How to initiate the protocol? The protocol can be initiated by the Verifier or by the Prover. Prover initiates the protocol.
client.SendProposePresentation(&ProposePresentation{}, myDID, theirDID)
Verifier initiates the protocol.
client.SendRequestPresentation(&RequestPresentation{}, myDID, theirDID)
Index ¶
- func WithFriendlyNames(names ...string) presentproof.Opt
- func WithPresentation(msg *Presentation) presentproof.Opt
- func WithProposePresentation(msg *ProposePresentation) presentproof.Opt
- func WithRequestPresentation(msg *RequestPresentation) presentproof.Opt
- type Action
- type Client
- func (c *Client) AcceptPresentation(piID string, names ...string) error
- func (c *Client) AcceptProblemReport(piID string) error
- func (c *Client) AcceptProposePresentation(piID string, msg *RequestPresentation) error
- func (c *Client) AcceptRequestPresentation(piID string, msg *Presentation) error
- func (c *Client) Actions() ([]Action, error)
- func (c *Client) DeclinePresentation(piID, reason string) error
- func (c *Client) DeclineProposePresentation(piID, reason string) error
- func (c *Client) DeclineRequestPresentation(piID, reason string) error
- func (c *Client) NegotiateRequestPresentation(piID string, msg *ProposePresentation) error
- func (c *Client) SendProposePresentation(msg *ProposePresentation, myDID, theirDID string) (string, error)
- func (c *Client) SendRequestPresentation(msg *RequestPresentation, myDID, theirDID string) (string, error)
- type Presentation
- type ProposePresentation
- type ProtocolService
- type Provider
- type RequestPresentation
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func WithFriendlyNames ¶
func WithFriendlyNames(names ...string) presentproof.Opt
WithFriendlyNames allows providing names for the presentations.
func WithPresentation ¶
func WithPresentation(msg *Presentation) presentproof.Opt
WithPresentation allows providing Presentation message Use this option to respond to RequestPresentation.
func WithProposePresentation ¶
func WithProposePresentation(msg *ProposePresentation) presentproof.Opt
WithProposePresentation allows providing ProposePresentation message Use this option to respond to RequestPresentation.
func WithRequestPresentation ¶
func WithRequestPresentation(msg *RequestPresentation) presentproof.Opt
WithRequestPresentation allows providing RequestPresentation message Use this option to respond to ProposePresentation.
Types ¶
type Client ¶
Client enable access to presentproof API https://github.com/hyperledger/aries-rfcs/tree/master/features/0037-present-proof
func (*Client) AcceptPresentation ¶
AcceptPresentation is used by the Verifier to accept a presentation.
func (*Client) AcceptProblemReport ¶
AcceptProblemReport accepts problem report action.
func (*Client) AcceptProposePresentation ¶
func (c *Client) AcceptProposePresentation(piID string, msg *RequestPresentation) error
AcceptProposePresentation is used when the Verifier is willing to accept the propose presentation.
func (*Client) AcceptRequestPresentation ¶
func (c *Client) AcceptRequestPresentation(piID string, msg *Presentation) error
AcceptRequestPresentation is used by the Prover is to accept a presentation request.
func (*Client) DeclinePresentation ¶
DeclinePresentation is used by the Verifier to decline a presentation.
func (*Client) DeclineProposePresentation ¶
DeclineProposePresentation is used when the Verifier does not want to accept the propose presentation.
func (*Client) DeclineRequestPresentation ¶
DeclineRequestPresentation is used when the Prover does not want to accept the request presentation.
func (*Client) NegotiateRequestPresentation ¶
func (c *Client) NegotiateRequestPresentation(piID string, msg *ProposePresentation) error
NegotiateRequestPresentation is used by the Prover to counter a presentation request they received with a proposal.
func (*Client) SendProposePresentation ¶
func (c *Client) SendProposePresentation(msg *ProposePresentation, myDID, theirDID string) (string, error)
SendProposePresentation is used by the Prover to send a propose presentation. It returns the threadID of the new instance of the protocol.
Example ¶
nolint: gocyclo
transport := map[string]chan payload{ Alice: make(chan payload), Bob: make(chan payload), } // Alice creates client clientAlice, err := New(mockContext(Alice, transport)) if err != nil { panic(err) } // Alice registers channel for actions actionsAlice := make(chan service.DIDCommAction) err = clientAlice.RegisterActionEvent(actionsAlice) if err != nil { panic(err) } // Bob creates client clientBob, err := New(mockContext(Bob, transport)) if err != nil { panic(err) } // Bob registers channel for actions actionsBob := make(chan service.DIDCommAction) err = clientBob.RegisterActionEvent(actionsBob) if err != nil { panic(err) } go func() { for { var acceptErr error var e service.DIDCommAction select { case e = <-actionsAlice: case e = <-actionsBob: } piid, ok := e.Properties.All()["piid"].(string) if !ok { fmt.Println("empty piid") } if e.Message.Type() == presentproof.PresentationMsgType { acceptErr = clientBob.AcceptPresentation(piid) } if e.Message.Type() == presentproof.ProposePresentationMsgType { acceptErr = clientBob.AcceptProposePresentation(piid, &RequestPresentation{WillConfirm: true}) } if e.Message.Type() == presentproof.RequestPresentationMsgType { acceptErr = clientAlice.AcceptRequestPresentation(piid, &Presentation{}) } if acceptErr != nil { fmt.Println(acceptErr) } } }() // Alice waitForAlice := waitForFn(clientAlice) // Bob waitForBob := waitForFn(clientBob) _, err = clientAlice.SendProposePresentation(&ProposePresentation{}, Alice, Bob) if err != nil { fmt.Println(err) } waitForAlice() waitForBob()
Output: Bob received https://didcomm.org/present-proof/2.0/propose-presentation from Alice Alice received https://didcomm.org/present-proof/2.0/request-presentation from Bob Bob received https://didcomm.org/present-proof/2.0/presentation from Alice Alice received https://didcomm.org/present-proof/2.0/ack from Bob
func (*Client) SendRequestPresentation ¶
func (c *Client) SendRequestPresentation(msg *RequestPresentation, myDID, theirDID string) (string, error)
SendRequestPresentation is used by the Verifier to send a request presentation. It returns the threadID of the new instance of the protocol.
Example ¶
transport := map[string]chan payload{ Alice: make(chan payload), Bob: make(chan payload), } // Alice creates client clientAlice, err := New(mockContext(Alice, transport)) if err != nil { panic(err) } // Alice registers channel for actions actionsAlice := make(chan service.DIDCommAction) err = clientAlice.RegisterActionEvent(actionsAlice) if err != nil { panic(err) } // Bob creates client clientBob, err := New(mockContext(Bob, transport)) if err != nil { panic(err) } // Bob registers channel for actions actionsBob := make(chan service.DIDCommAction) err = clientBob.RegisterActionEvent(actionsBob) if err != nil { panic(err) } go func() { for { var acceptErr error select { case e := <-actionsAlice: acceptErr = clientAlice.AcceptPresentation(e.Properties.All()["piid"].(string)) case e := <-actionsBob: acceptErr = clientBob.AcceptRequestPresentation(e.Properties.All()["piid"].(string), &Presentation{}) } if acceptErr != nil { fmt.Println(acceptErr) } } }() // Alice waitForAlice := waitForFn(clientAlice) // Bob waitForBob := waitForFn(clientBob) _, err = clientAlice.SendRequestPresentation(&RequestPresentation{}, Alice, Bob) if err != nil { fmt.Println(err) } waitForAlice() waitForBob()
Output: Bob received https://didcomm.org/present-proof/2.0/request-presentation from Alice Alice received https://didcomm.org/present-proof/2.0/presentation from Bob
Example (Second) ¶
transport := map[string]chan payload{ Alice: make(chan payload), Bob: make(chan payload), } // Alice creates client clientAlice, err := New(mockContext(Alice, transport)) if err != nil { panic(err) } // Alice registers channel for actions actionsAlice := make(chan service.DIDCommAction) err = clientAlice.RegisterActionEvent(actionsAlice) if err != nil { panic(err) } // Bob creates client clientBob, err := New(mockContext(Bob, transport)) if err != nil { panic(err) } // Bob registers channel for actions actionsBob := make(chan service.DIDCommAction) err = clientBob.RegisterActionEvent(actionsBob) if err != nil { panic(err) } go func() { for { var acceptErr error select { case e := <-actionsAlice: acceptErr = clientAlice.AcceptPresentation(e.Properties.All()["piid"].(string)) case e := <-actionsBob: acceptErr = clientBob.AcceptRequestPresentation(e.Properties.All()["piid"].(string), &Presentation{}) } if acceptErr != nil { fmt.Println(acceptErr) } } }() // Alice waitForAlice := waitForFn(clientAlice) // Bob waitForBob := waitForFn(clientBob) _, err = clientAlice.SendRequestPresentation(&RequestPresentation{WillConfirm: true}, Alice, Bob) if err != nil { fmt.Println(err) } waitForAlice() waitForBob()
Output: Bob received https://didcomm.org/present-proof/2.0/request-presentation from Alice Alice received https://didcomm.org/present-proof/2.0/presentation from Bob Bob received https://didcomm.org/present-proof/2.0/ack from Alice
type Presentation ¶
type Presentation presentproof.Presentation
Presentation is a response to a RequestPresentation message and contains signed presentations.
type ProposePresentation ¶
type ProposePresentation presentproof.ProposePresentation
ProposePresentation is an optional message sent by the Prover to the verifier to initiate a proof presentation process, or in response to a request-presentation message when the Prover wants to propose using a different presentation format.
type ProtocolService ¶
type ProtocolService interface { service.DIDComm Actions() ([]presentproof.Action, error) ActionContinue(piID string, opt presentproof.Opt) error ActionStop(piID string, err error) error }
ProtocolService defines the presentproof service.
type Provider ¶
Provider contains dependencies for the protocol and is typically created by using aries.Context().
type RequestPresentation ¶
type RequestPresentation presentproof.RequestPresentation
RequestPresentation describes values that need to be revealed and predicates that need to be fulfilled.