chore: Add optional parameter to packer.Unpack

mock/proving.go

@@ -82,11 +82,6 @@ func PrepareAuthInputs(hash []byte, _ *w3c.DID, _ circuits.CircuitID) ([]byte, e
 	return j, err
 }
 
-// VerifyState return no error always
-func VerifyState(_ circuits.CircuitID, _ []string) error {
-	return nil
-}
-
 // MockRecipientKeyID is mocked key id for recipient
 const MockRecipientKeyID = "123456789"
 

packager.go

@@ -16,7 +16,7 @@ type Packer interface {
 	// Pack a payload of type ContentType in an Iden3 compliant format using the packer identity
 	Pack(payload []byte, params PackerParams) ([]byte, error)
 	// Unpack an envelope in Iden3 compliant format.
-	Unpack(envelope []byte) (*BasicMessage, error)
+	Unpack(envelope []byte, params ...PackerParams) (*BasicMessage, error)
 	// MediaType returns content type of message
 	MediaType() MediaType
 }
@@ -65,14 +65,14 @@ func (r *PackageManager) Pack(mediaType MediaType, payload []byte, params Packer
 
 // Unpack returns iden3 message method from envelope
 // if it's not valid or can't be decrypted error is returned
-func (r *PackageManager) Unpack(envelope []byte) (*BasicMessage, MediaType, error) {
+func (r *PackageManager) Unpack(envelope []byte, params ...PackerParams) (*BasicMessage, MediaType, error) {
 	safeEnvelope := strings.Trim(strings.TrimSpace(string(envelope)), "\"")
 	mediaType, err := r.GetMediaType([]byte(safeEnvelope))
 	if err != nil {
 		return nil, "", err
 	}
 
-	msg, err := r.unpackSafeEnvelope(mediaType, []byte(safeEnvelope))
+	msg, err := r.unpackSafeEnvelope(mediaType, []byte(safeEnvelope), params...)
 	if err != nil {
 		return nil, mediaType, err
 	}
@@ -85,14 +85,14 @@ func (r *PackageManager) UnpackWithType(mediaType MediaType, envelope []byte) (*
 	return r.unpackSafeEnvelope(mediaType, []byte(safeEnvelope))
 }
 
-func (r *PackageManager) unpackSafeEnvelope(mediaType MediaType, envelope []byte) (*BasicMessage, error) {
+func (r *PackageManager) unpackSafeEnvelope(mediaType MediaType, envelope []byte, params ...PackerParams) (*BasicMessage, error) {
 	p, ok := r.packers[mediaType]
 	if !ok {
 		return nil, errors.Errorf("packer for media type %s doesn't exist", mediaType)
 	}
 
 	// safeEnvelope can be rather base64 encoded or valid json
-	msg, err := p.Unpack(envelope)
+	msg, err := p.Unpack(envelope, params...)
 	if err != nil {
 		return nil, err
 	}

packager_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/google/uuid"
+	"github.com/iden3/go-circuits/v2"
 	"github.com/iden3/go-iden3-core/v2/w3c"
 	"github.com/iden3/go-jwz/v2"
 	"github.com/iden3/iden3comm/v2"
@@ -182,7 +183,7 @@ func initPackageManager(t *testing.T) *iden3comm.PackageManager {
 
 	mockVerificationParam := make(map[jwz.ProvingMethodAlg]packers.VerificationParams)
 	mockVerificationParam[mockedProvingMethod.ProvingMethodAlg] = packers.NewVerificationParams([]byte(""),
-		mock.VerifyState)
+		verifyStateMock)
 
 	mockProvingParamMap := make(map[jwz.ProvingMethodAlg]packers.ProvingParams)
 	mockProvingParamMap[mockedProvingMethod.ProvingMethodAlg] = packers.NewProvingParams(mock.PrepareAuthInputs,
@@ -193,3 +194,8 @@ func initPackageManager(t *testing.T) *iden3comm.PackageManager {
 
 	return pm
 }
+
+// VerifyState return no error always
+func verifyStateMock(_ circuits.CircuitID, _ []string, _ ...packers.DefaultZKPUnpackerOption) error {
+	return nil
+}

packers/anoncrypt.go

@@ -65,7 +65,7 @@ func (p *AnoncryptPacker) Pack(payload []byte, params iden3comm.PackerParams) ([
 }
 
 // Unpack returns unpacked message from transport envelope
-func (p *AnoncryptPacker) Unpack(envelope []byte) (*iden3comm.BasicMessage, error) {
+func (p *AnoncryptPacker) Unpack(envelope []byte, _ ...iden3comm.PackerParams) (*iden3comm.BasicMessage, error) {
 
 	jwe, err := jose.ParseEncrypted(string(envelope))
 	if err != nil {

packers/jws.go

@@ -200,7 +200,7 @@ func (p *JWSPacker) Pack(
 }
 
 // Unpack returns unpacked message from transport envelope with verification of signature
-func (p *JWSPacker) Unpack(envelope []byte) (*iden3comm.BasicMessage, error) {
+func (p *JWSPacker) Unpack(envelope []byte, _ ...iden3comm.PackerParams) (*iden3comm.BasicMessage, error) {
 
 	token, err := jws.Parse(envelope)
 	if err != nil {

packers/plain.go

@@ -32,7 +32,7 @@ func (p *PlainMessagePacker) Pack(payload []byte, _ iden3comm.PackerParams) ([]b
 }
 
 // Unpack returns unpacked message from transport envelope
-func (p *PlainMessagePacker) Unpack(envelope []byte) (*iden3comm.BasicMessage, error) {
+func (p *PlainMessagePacker) Unpack(envelope []byte, _ ...iden3comm.PackerParams) (*iden3comm.BasicMessage, error) {
 
 	var msg iden3comm.BasicMessage
 	err := json.Unmarshal(envelope, &msg)

packers/zkp.go

@@ -30,11 +30,11 @@ func (f DataPreparerHandlerFunc) Prepare(hash []byte, id *w3c.DID, circuitID cir
 }
 
 // VerificationHandlerFunc  registers the handler function for state verification.
-type VerificationHandlerFunc func(id circuits.CircuitID, pubsignals []string) error
+type VerificationHandlerFunc func(id circuits.CircuitID, pubsignals []string, opts ...DefaultZKPUnpackerOption) error
 
 // Verify function is responsible to call provided handler for outputs verification
-func (f VerificationHandlerFunc) Verify(id circuits.CircuitID, pubsignals []string) error {
-	return f(id, pubsignals)
+func (f VerificationHandlerFunc) Verify(id circuits.CircuitID, pubsignals []string, opts ...DefaultZKPUnpackerOption) error {
+	return f(id, pubsignals, opts...)
 }
 
 // VerificationParams defined the verification function and the verification key for ZKP full verification
@@ -133,14 +133,31 @@ func (p *ZKPPacker) Pack(payload []byte, params iden3comm.PackerParams) ([]byte,
 	return []byte(tokenStr), nil
 }
 
-// Unpack returns unpacked message from transport envelope with verification of zeroknowledge proof
-func (p *ZKPPacker) Unpack(envelope []byte) (*iden3comm.BasicMessage, error) {
+// ZKPPUnpackerParams is params for zkp unpacker
+type ZKPPUnpackerParams struct {
+	authVerifyDelay time.Duration
+	iden3comm.PackerParams
+}
+
+// NewZKPPUnpackerParams creates new zkp unpacker params
+func NewZKPPUnpackerParams(authVerifyDelay time.Duration) ZKPPUnpackerParams {
+	return ZKPPUnpackerParams{
+		authVerifyDelay: authVerifyDelay,
+	}
+}
+
+// Unpack returns unpacked message from transport envelope with verification of zero knowledge proof
+// params is variadic but only none or one is accepted
+func (p *ZKPPacker) Unpack(envelope []byte, params ...iden3comm.PackerParams) (*iden3comm.BasicMessage, error) {
+
+	if len(params) > 1 {
+		return nil, errors.New("expecting no more than one parameter in ZKPPacker Unpack")
+	}
 
 	token, err := jwz.Parse(string(envelope))
 	if err != nil {
 		return nil, err
 	}
-
 	verificationKey, ok := p.Verification[jwz.ProvingMethodAlg{Alg: token.Alg, CircuitID: token.CircuitID}]
 	if !ok {
 		return nil, fmt.Errorf("message was packed with unsupported circuit `%s` and alg `%s`", token.CircuitID,
@@ -155,7 +172,15 @@ func (p *ZKPPacker) Unpack(envelope []byte) (*iden3comm.BasicMessage, error) {
 		return nil, errors.New("message proof is invalid")
 	}
 
-	err = verificationKey.VerificationFn.Verify(circuits.CircuitID(token.CircuitID), token.ZkProof.PubSignals)
+	var verifyOpts []DefaultZKPUnpackerOption
+	if len(params) == 1 {
+		zkParams, ok := (params[0]).(ZKPPUnpackerParams)
+		if !ok {
+			return nil, errors.New("can't cast params to zkp unpacker params")
+		}
+		verifyOpts = append(verifyOpts, WithAuthVerifyDelay(zkParams.authVerifyDelay))
+	}
+	err = verificationKey.VerificationFn.Verify(circuits.CircuitID(token.CircuitID), token.ZkProof.PubSignals, verifyOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -238,32 +263,44 @@ func (p *ZKPPacker) MediaType() iden3comm.MediaType {
 }
 
 // DefaultZKPUnpackerOption is a function that sets the default ZKP unpacker options
-type DefaultZKPUnpackerOption func(*defaultZKPUnpacker)
+type DefaultZKPUnpackerOption func(*zkUnpackerOpts)
 
 // WithAuthVerifyDelay sets the delay for the auth verification
 func WithAuthVerifyDelay(delay time.Duration) DefaultZKPUnpackerOption {
-	return func(p *defaultZKPUnpacker) {
+	return func(p *zkUnpackerOpts) {
 		p.authVerifyDelay = delay
 	}
 }
 
-type defaultZKPUnpacker struct {
-	resolvers       map[int]eth.Resolver
+type zkUnpackerOpts struct {
 	authVerifyDelay time.Duration
 }
 
+type defaultZKPUnpacker struct {
+	resolvers map[int]eth.Resolver
+	opts      zkUnpackerOpts
+}
+
 // DefaultZKPUnpacker creates a default ZKP unpacker with the provided verification key and resolvers
 func DefaultZKPUnpacker(verificationKey []byte, resolvers map[int]eth.Resolver, opts ...DefaultZKPUnpackerOption) *ZKPPacker {
-	def := &defaultZKPUnpacker{resolvers, time.Minute * 5}
+	def := &defaultZKPUnpacker{
+		resolvers: resolvers,
+		opts:      zkUnpackerOpts{authVerifyDelay: time.Minute * 5},
+	}
 	for _, opt := range opts {
-		opt(def)
+		opt(&def.opts)
 	}
 	verifications := make(map[jwz.ProvingMethodAlg]VerificationParams)
 	verifications[jwz.AuthV2Groth16Alg] = NewVerificationParams(verificationKey, def.defaultZkpUnpackerVerificationFn)
 	return NewZKPPacker(nil, verifications)
 }
 
-func (d *defaultZKPUnpacker) defaultZkpUnpackerVerificationFn(id circuits.CircuitID, pubsignals []string) error {
+func (d *defaultZKPUnpacker) defaultZkpUnpackerVerificationFn(id circuits.CircuitID, pubsignals []string, opts ...DefaultZKPUnpackerOption) error {
+	options := d.opts
+	for _, opt := range opts {
+		opt(&options)
+	}
+
 	if id != circuits.AuthV2CircuitID {
 		return errors.Errorf("circuit ID '%s' is not supported", id)
 	}
@@ -291,7 +328,10 @@ func (d *defaultZKPUnpacker) defaultZkpUnpackerVerificationFn(id circuits.Circui
 			userDID.String(), err)
 	}
 
-	resolver := d.resolvers[int(chainID)]
+	resolver, found := d.resolvers[int(chainID)]
+	if !found {
+		return errors.Errorf("resolver for chainID '%d' not found", chainID)
+	}
 
 	globalState := authPubSignals.GISTRoot.BigInt()
 	globalStateInfo, err := resolver.ResolveGist(context.Background(), &services.ResolverOpts{GistRoot: globalState})
@@ -306,7 +346,7 @@ func (d *defaultZKPUnpacker) defaultZkpUnpackerVerificationFn(id circuits.Circui
 	}
 
 	if (big.NewInt(0)).Cmp(globalStateInfo.ReplacedByRoot) != 0 &&
-		time.Since(time.Unix(globalStateInfo.ReplacedAtTimestamp.Int64(), 0)) > d.authVerifyDelay {
+		time.Since(time.Unix(globalStateInfo.ReplacedAtTimestamp.Int64(), 0)) > options.authVerifyDelay {
 		return errors.Errorf("global state is too old, replaced timestamp is %v",
 			globalStateInfo.ReplacedAtTimestamp.Int64())
 	}

packers/zkp_test.go

@@ -28,7 +28,7 @@ func TestZKPPacker_Pack(t *testing.T) {
 	})
 
 	mockVerificationParam := make(map[jwz.ProvingMethodAlg]VerificationParams)
-	mockVerificationParam[mockedProvingMethod.ProvingMethodAlg] = NewVerificationParams([]byte(""), mock.VerifyState)
+	mockVerificationParam[mockedProvingMethod.ProvingMethodAlg] = NewVerificationParams([]byte(""), verifyStateMock)
 
 	mockProvingParamMap := make(map[jwz.ProvingMethodAlg]ProvingParams)
 	mockProvingParamMap[mockedProvingMethod.ProvingMethodAlg] =
@@ -77,7 +77,7 @@ func TestPlainMessagePacker_Unpack(t *testing.T) {
 	})
 
 	mockVerificationParam := make(map[jwz.ProvingMethodAlg]VerificationParams)
-	mockVerificationParam[mockedProvingMethod.ProvingMethodAlg] = NewVerificationParams([]byte(""), mock.VerifyState)
+	mockVerificationParam[mockedProvingMethod.ProvingMethodAlg] = NewVerificationParams([]byte(""), verifyStateMock)
 
 	mockProvingParamMap := make(map[jwz.ProvingMethodAlg]ProvingParams)
 	mockProvingParamMap[mockedProvingMethod.ProvingMethodAlg] =
@@ -101,3 +101,7 @@ func TestPlainMessagePacker_Unpack(t *testing.T) {
 	assert.Len(t, authResponse.Body.Scope, 0)
 
 }
+
+func verifyStateMock(_ circuits.CircuitID, _ []string, _ ...DefaultZKPUnpackerOption) error {
+	return nil
+}