presentproof

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 New(ctx Provider) (*Client, error)
  • 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

• Client.SendProposePresentation
• Client.SendRequestPresentation
• Client.SendRequestPresentation (Second)

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 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

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) AcceptRequestPresentation

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

AcceptRequestPresentation 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) 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

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.