resolve comments

resolvers/onchain.go

@@ -23,42 +23,44 @@ import (
 	"github.com/pkg/errors"
 )
 
-// OnChainResolverConfig options for credential status verification
-type OnChainResolverConfig struct {
-	EthClients        map[core.ChainID]*ethclient.Client
-	StateContractAddr common.Address
-}
-
 // OnChainResolver is a struct that allows to interact with the onchain contract and build the revocation status.
 type OnChainResolver struct {
-	config OnChainResolverConfig
+	ethClients             map[core.ChainID]*ethclient.Client
+	stateContractAddresses map[core.ChainID]common.Address
 }
 
 // NewOnChainResolver returns new onChain resolver
-func NewOnChainResolver(config OnChainResolverConfig) *OnChainResolver {
-	return &OnChainResolver{config}
+func NewOnChainResolver(ethClients map[core.ChainID]*ethclient.Client, stateContractAddresses map[core.ChainID]common.Address) *OnChainResolver {
+	return &OnChainResolver{
+		ethClients:             ethClients,
+		stateContractAddresses: stateContractAddresses,
+	}
 }
 
 // Resolve is a method to resolve a credential status from the blockchain.
 func (r OnChainResolver) Resolve(ctx context.Context,
 	status verifiable.CredentialStatus) (out verifiable.RevocationStatus, err error) {
 
+	if status.Type != verifiable.Iden3OnchainSparseMerkleTreeProof2023 {
+		return out, errors.New("invalid status type")
+	}
+
 	issuerDID := verifiable.GetIssuerDID(ctx)
 	if issuerDID == nil {
 		return out, errors.New("issuer DID is not set in context")
 	}
 
 	issuerID, err := core.IDFromDID(*issuerDID)
 	if err != nil {
-		return out, err
+		return out, errors.WithMessage((err), "can't parse issuer DID")
 	}
 
-	var zeroID core.ID
-	if issuerID == zeroID {
-		return out, errors.New("issuer ID is empty")
+	ethClient, err := getEthClientForDID(issuerDID, r.ethClients)
+	if err != nil {
+		return out, err
 	}
 
-	ethClient, err := getEthClientForDID(issuerDID, r.config.EthClients)
+	stateAddr, err := getStateContractForDID(issuerDID, r.stateContractAddresses)
 	if err != nil {
 		return out, err
 	}
@@ -80,7 +82,7 @@ func (r OnChainResolver) Resolve(ctx context.Context,
 			onchainRevStatus.revNonce, status.RevocationNonce)
 	}
 
-	isStateContractHasID, err := stateContractHasID(ctx, r.config.StateContractAddr, ethClient, &issuerID)
+	isStateContractHasID, err := stateContractHasID(ctx, stateAddr, ethClient, &issuerID)
 	if err != nil {
 		return out, err
 	}
@@ -304,6 +306,19 @@ func getEthClientForDID(did *w3c.DID, ethClients map[core.ChainID]*ethclient.Cli
 	return ethClient, nil
 }
 
+func getStateContractForDID(did *w3c.DID, stateContracts map[core.ChainID]common.Address) (out common.Address, err error) {
+	chainID, err := core.ChainIDfromDID(*did)
+	if err != nil {
+		return out, err
+	}
+
+	contractAddr, ok := stateContracts[chainID]
+	if !ok {
+		return out, errors.Errorf("chain id is not registered for network %v", chainID)
+	}
+	return contractAddr, nil
+}
+
 func toRevocationStatus(status onchainABI.IOnchainCredentialStatusResolverCredentialStatus) (out verifiable.RevocationStatus, err error) {
 	var existence bool
 	var nodeAux *merkletree.NodeAux

resolvers/onchain_test.go

@@ -33,12 +33,10 @@ func TestOnChainResolver(t *testing.T) {
 	var ethClients map[core.ChainID]*ethclient.Client = make(map[core.ChainID]*ethclient.Client)
 	ethClients[80001] = client
 
-	config := OnChainResolverConfig{
-		EthClients:        ethClients,
-		StateContractAddr: stateAddr,
-	}
+	var stateAddresses map[core.ChainID]common.Address = make(map[core.ChainID]common.Address)
+	stateAddresses[80001] = stateAddr
 
-	onChainResolver := NewOnChainResolver(config)
+	onChainResolver := NewOnChainResolver(ethClients, stateAddresses)
 
 	httpmock.Activate()
 	defer httpmock.DeactivateAndReset()

resolvers/rhs.go

@@ -10,30 +10,35 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient"
-	"github.com/iden3/go-iden3-core/v2"
+	core "github.com/iden3/go-iden3-core/v2"
 	"github.com/iden3/go-merkletree-sql/v2"
 	"github.com/iden3/go-schema-processor/v2/verifiable"
 	mp "github.com/iden3/merkletree-proof/http"
 	"github.com/pkg/errors"
 )
 
-// RHSResolverConfig options for credential status verification
-type RHSResolverConfig OnChainResolverConfig
-
 // RHSResolver is a struct that allows to interact with the RHS service to get revocation status.
 type RHSResolver struct {
-	config RHSResolverConfig
+	ethClients             map[core.ChainID]*ethclient.Client
+	stateContractAddresses map[core.ChainID]common.Address
 }
 
 // NewRHSResolver returns new RHS resolver
-func NewRHSResolver(config RHSResolverConfig) *RHSResolver {
-	return &RHSResolver{config}
+func NewRHSResolver(ethClients map[core.ChainID]*ethclient.Client, stateContractAddresses map[core.ChainID]common.Address) *RHSResolver {
+	return &RHSResolver{
+		ethClients:             ethClients,
+		stateContractAddresses: stateContractAddresses,
+	}
 }
 
 // Resolve is a method to resolve a credential status from the RHS.
 func (r RHSResolver) Resolve(ctx context.Context,
 	status verifiable.CredentialStatus) (out verifiable.RevocationStatus, err error) {
 
+	if status.Type != verifiable.Iden3ReverseSparseMerkleTreeProof {
+		return out, errors.New("invalid status type")
+	}
+
 	issuerDID := verifiable.GetIssuerDID(ctx)
 	if issuerDID == nil {
 		return out, errors.New("issuer DID is not set in context")
@@ -51,11 +56,16 @@ func (r RHSResolver) Resolve(ctx context.Context,
 		return out, err
 	}
 
-	ethClient, err := getEthClientForDID(issuerDID, r.config.EthClients)
+	ethClient, err := getEthClientForDID(issuerDID, r.ethClients)
+	if err != nil {
+		return out, err
+	}
+
+	stateAddr, err := getStateContractForDID(issuerDID, r.stateContractAddresses)
 	if err != nil {
 		return out, err
 	}
-	state, err := identityStateForRHS(ctx, r.config.StateContractAddr, ethClient, &issuerID, genesisState)
+	state, err := identityStateForRHS(ctx, stateAddr, ethClient, &issuerID, genesisState)
 	if err != nil {
 		return out, err
 	}

resolvers/rhs_test.go

@@ -49,12 +49,10 @@ func TestRhsResolver(t *testing.T) {
 	var ethClients map[core.ChainID]*ethclient.Client = make(map[core.ChainID]*ethclient.Client)
 	ethClients[80001] = client
 
-	config := RHSResolverConfig{
-		EthClients:        ethClients,
-		StateContractAddr: stateAddr,
-	}
+	var stateAddresses map[core.ChainID]common.Address = make(map[core.ChainID]common.Address)
+	stateAddresses[80001] = stateAddr
 
-	rhsResolver := NewRHSResolver(config)
+	rhsResolver := NewRHSResolver(ethClients, stateAddresses)
 	ctx := verifiable.WithIssuerDID(context.Background(), issuerDID)
 	_, err = rhsResolver.Resolve(ctx, credStatus)
 	require.NoError(t, err)