presentproof

package
v0.1.7 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 14, 2021 License: Apache-2.0 Imports: 4 Imported by: 14

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

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func WithAddProofFn added in v0.1.6 

func WithAddProofFn(sign addProof) presentproof.Opt

WithAddProofFn allows providing function that will sign the Presentation. Use this option to respond to RequestPresentation.

func WithFriendlyNames added in v0.1.4 

func WithFriendlyNames(names ...string) presentproof.Opt

WithFriendlyNames allows providing names for the presentations.

func WithMultiOptions added in v0.1.6 

func WithMultiOptions(opts ...presentproof.Opt) presentproof.Opt

WithMultiOptions allows combining several options into one.

func WithPresentation 

func WithPresentation(msg *Presentation) presentproof.Opt

WithPresentation allows providing Presentation message Use this option to respond to RequestPresentation.

func WithPresentationV3 added in v0.1.7 

func WithPresentationV3(msg *PresentationV3) presentproof.Opt

WithPresentationV3 allows providing PresentationV3 message Use this option to respond to RequestPresentationV3.

func WithProposePresentation 

func WithProposePresentation(msg *ProposePresentation) presentproof.Opt

WithProposePresentation allows providing ProposePresentation message Use this option to respond to RequestPresentation.

func WithProposePresentationV3 added in v0.1.7 

func WithProposePresentationV3(msg *ProposePresentationV3) presentproof.Opt

WithProposePresentationV3 allows providing ProposePresentationV3 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.

func WithRequestPresentationV3 added in v0.1.7 

func WithRequestPresentationV3(msg *RequestPresentationV3) presentproof.Opt

WithRequestPresentationV3 allows providing RequestPresentation message Use this option to respond to ProposePresentation.

Types

type Action 

type Action presentproof.Action

Action contains helpful information about action.

type Client 

type Client struct {
	service.Event
	// contains filtered or unexported fields
}

Client enable access to presentproof API https://github.com/hyperledger/aries-rfcs/tree/master/features/0037-present-proof

func New 

func New(ctx Provider) (*Client, error)

New returns new instance of the presentproof client.

func (*Client) AcceptPresentation 

func (c *Client) AcceptPresentation(piID string, names ...string) error

AcceptPresentation is used by the Verifier to accept a presentation.

func (*Client) AcceptProblemReport added in v0.1.4 

func (c *Client) AcceptProblemReport(piID string) error

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) AcceptProposePresentationV3 added in v0.1.7 

func (c *Client) AcceptProposePresentationV3(piID string, msg *RequestPresentationV3) error

AcceptProposePresentationV3 is used when the Verifier is willing to accept the propose presentation.

func (*Client) AcceptRequestPresentation 

func (c *Client) AcceptRequestPresentation(piID string, msg *Presentation, sign addProof) error

AcceptRequestPresentation is used by the Prover is to accept a presentation request.

func (*Client) AcceptRequestPresentationV3 added in v0.1.7 

func (c *Client) AcceptRequestPresentationV3(piID string, msg *PresentationV3, sign addProof) error

AcceptRequestPresentationV3 is used by the Prover is to accept a presentation request.

func (*Client) Actions 

func (c *Client) Actions() ([]Action, error)

Actions returns pending actions that have yet to be executed or cancelled.

func (*Client) DeclinePresentation 

func (c *Client) DeclinePresentation(piID, reason string) error

DeclinePresentation is used by the Verifier to decline a presentation.

func (*Client) DeclineProposePresentation 

func (c *Client) DeclineProposePresentation(piID, reason string) error

DeclineProposePresentation is used when the Verifier does not want to accept the propose presentation.

func (*Client) DeclineRequestPresentation 

func (c *Client) DeclineRequestPresentation(piID, reason string) error

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) NegotiateRequestPresentationV3 added in v0.1.7 

func (c *Client) NegotiateRequestPresentationV3(piID string, msg *ProposePresentationV3) error

NegotiateRequestPresentationV3 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.PresentationMsgTypeV2 {
			acceptErr = clientBob.AcceptPresentation(piid)
		}

		if e.Message.Type() == presentproof.ProposePresentationMsgTypeV2 {
			acceptErr = clientBob.AcceptProposePresentation(piid, &RequestPresentation{WillConfirm: true})
		}

		if e.Message.Type() == presentproof.RequestPresentationMsgTypeV2 {
			acceptErr = clientAlice.AcceptRequestPresentation(piid, &Presentation{}, nil)
		}

		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) SendProposePresentationV3 added in v0.1.7 

func (c *Client) SendProposePresentationV3(msg *ProposePresentationV3, myDID, theirDID string) (string, error)

SendProposePresentationV3 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.PresentationMsgTypeV3 {
			acceptErr = clientBob.AcceptPresentation(piid)
		}

		if e.Message.Type() == presentproof.ProposePresentationMsgTypeV3 {
			rp3 := &RequestPresentationV3{}
			rp3.Body.WillConfirm = true

			acceptErr = clientBob.AcceptProposePresentationV3(piid, rp3)
		}

		if e.Message.Type() == presentproof.RequestPresentationMsgTypeV3 {
			acceptErr = clientAlice.AcceptRequestPresentationV3(piid, &PresentationV3{}, nil)
		}

		if acceptErr != nil {
			fmt.Println(acceptErr)
		}
	}
}()

// Alice
waitForAlice := waitForFn(clientAlice)
// Bob
waitForBob := waitForFn(clientBob)

_, err = clientAlice.SendProposePresentationV3(&ProposePresentationV3{}, Alice, Bob)
if err != nil {
	fmt.Println(err)
}

waitForAlice()
waitForBob()

Output:

Bob received https://didcomm.org/present-proof/3.0/propose-presentation from Alice
Alice received https://didcomm.org/present-proof/3.0/request-presentation from Bob
Bob received https://didcomm.org/present-proof/3.0/presentation from Alice
Alice received https://didcomm.org/present-proof/3.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{}, nil)
		}

		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{}, nil)
		}

		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

func (*Client) SendRequestPresentationV3 added in v0.1.7 

func (c *Client) SendRequestPresentationV3(msg *RequestPresentationV3, myDID, theirDID string) (string, error)

SendRequestPresentationV3 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.AcceptRequestPresentationV3(e.Properties.All()["piid"].(string), &PresentationV3{}, nil)
		}

		if acceptErr != nil {
			fmt.Println(acceptErr)
		}
	}
}()

// Alice
waitForAlice := waitForFn(clientAlice)
// Bob
waitForBob := waitForFn(clientBob)

_, err = clientAlice.SendRequestPresentationV3(&RequestPresentationV3{}, Alice, Bob)
if err != nil {
	fmt.Println(err)
}

waitForAlice()
waitForBob()

Output:

Bob received https://didcomm.org/present-proof/3.0/request-presentation from Alice
Alice received https://didcomm.org/present-proof/3.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.AcceptRequestPresentationV3(e.Properties.All()["piid"].(string), &PresentationV3{}, nil)
		}

		if acceptErr != nil {
			fmt.Println(acceptErr)
		}
	}
}()

// Alice
waitForAlice := waitForFn(clientAlice)
// Bob
waitForBob := waitForFn(clientBob)

_, err = clientAlice.SendRequestPresentationV3(&RequestPresentationV3{
	Body: presentproof.RequestPresentationV3Body{WillConfirm: true},
}, Alice, Bob)
if err != nil {
	fmt.Println(err)
}

waitForAlice()
waitForBob()

Output:

Bob received https://didcomm.org/present-proof/3.0/request-presentation from Alice
Alice received https://didcomm.org/present-proof/3.0/presentation from Bob
Bob received https://didcomm.org/present-proof/3.0/ack from Alice

type Presentation 

type Presentation presentproof.Presentation

Presentation is a response to a RequestPresentation message and contains signed presentations.

type PresentationV3 added in v0.1.7 

type PresentationV3 presentproof.PresentationV3

PresentationV3 is a response to a RequestPresentationV3 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 ProposePresentationV3 added in v0.1.7 

type ProposePresentationV3 presentproof.ProposePresentationV3

ProposePresentationV3 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 

type Provider interface {
	Service(id string) (interface{}, error)
}

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.

type RequestPresentationV3 added in v0.1.7 

type RequestPresentationV3 presentproof.RequestPresentationV3

RequestPresentationV3 describes values that need to be revealed and predicates that need to be fulfilled.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.