Update to Golang SDK

go/services/account_service.go

@@ -12,14 +12,14 @@ import (
 
 // NewAccountService returns an account servcie with the base service configured
 // using the provided options
-func NewAccountService(options *sdk.ServiceOptions) (AccountService, error) {
+func NewAccountService(options *Options) (AccountService, error) {
 	base, err := NewServiceBase(options)
 	if err != nil {
 		return nil, err
 	}
-	service := &AccountBase{
-		ServiceBase: base,
-		client:      sdk.NewAccountClient(base.channel),
+	service := &accountBase{
+		Service: base,
+		client:  sdk.NewAccountClient(base.GetChannel()),
 	}
 
 	return service, nil
@@ -29,9 +29,9 @@ func NewAccountService(options *sdk.ServiceOptions) (AccountService, error) {
 type AccountService interface {
 	Service
 	// SignIn returns an encoded auth token
-	SignIn(userContext context.Context, details *sdk.AccountDetails, inviteCode, ecosystemID string) (string, sdk.ConfirmationMethod, error)
+	SignIn(userContext context.Context, request *sdk.SignInRequest) (string, sdk.ConfirmationMethod, error)
 	// Unprotect takes an authtoken that has been protected using a pin code
-	// and returns an ulocked token
+	// and returns an unlocked token
 	Unprotect(authtoken, securityCode string) (string, error)
 	// Protect will apply the given security code blind to the provided token
 	Protect(authtoken, securityCode string) (string, error)
@@ -43,37 +43,35 @@ type AccountService interface {
 	RevokeDevice(userContext context.Context, request *sdk.RevokeDeviceRequest) (*sdk.RevokeDeviceResponse, error)
 }
 
-// AccountBase implements the AccountService interface
-type AccountBase struct {
-	*ServiceBase
+type accountBase struct {
+	Service
 	client sdk.AccountClient
 }
 
 // SignIn to a given account
-func (a *AccountBase) SignIn(userContext context.Context, details *sdk.AccountDetails, inviteCode, ecosystemID string) (string, sdk.ConfirmationMethod, error) {
-	if details == nil {
-		details = &sdk.AccountDetails{}
-	}
-
-	if len(ecosystemID) == 0 {
-		ecosystemID = a.options.DefaultEcosystem
+func (a *accountBase) SignIn(userContext context.Context, request *sdk.SignInRequest) (string, sdk.ConfirmationMethod, error) {
+	if len(request.EcosystemId) == 0 {
+		request.EcosystemId = a.GetServiceOptions().DefaultEcosystem
 	}
 
-	response, err := a.client.SignIn(userContext, &sdk.SignInRequest{Details: details, InvitationCode: inviteCode, EcosystemId: ecosystemID})
+	resp, err := a.client.SignIn(userContext, request)
 	if err != nil {
 		return "", sdk.ConfirmationMethod_None, err
 	}
 
-	tkn, err := ProfileToToken(response.Profile)
+	tkn, err := ProfileToToken(resp.Profile)
 	if err != nil {
 		return "", sdk.ConfirmationMethod_None, err
 	}
 
-	return tkn, response.ConfirmationMethod, nil
+	return tkn, resp.ConfirmationMethod, nil
 }
 
 // Unprotect an authtoken using the given security code
-func (a *AccountBase) Unprotect(authtoken, securityCode string) (string, error) {
+//
+// This method can be called multiple times on an individual token
+// to "unwrap" the blindings that have been applied
+func (a *accountBase) Unprotect(authtoken, securityCode string) (string, error) {
 	profile, err := ProfileFromToken(authtoken)
 	if err != nil {
 		return "", err
@@ -101,8 +99,8 @@ func (a *AccountBase) Unprotect(authtoken, securityCode string) (string, error)
 // Protect an authtoken with the given security code. Must be unprotected before use
 //
 // This method can be called as many times as you want, but each code must be "unwrapped"
-// in the reverse order before use
-func (a *AccountBase) Protect(authtoken, securityCode string) (string, error) {
+// by calling Unprotect in the reverse order before use
+func (a *accountBase) Protect(authtoken, securityCode string) (string, error) {
 	profile, err := ProfileFromToken(authtoken)
 	if err != nil {
 		return "", err
@@ -128,7 +126,7 @@ func (a *AccountBase) Protect(authtoken, securityCode string) (string, error) {
 }
 
 // GetInfo associated with a given wallet
-func (a *AccountBase) GetInfo(userContext context.Context) (*sdk.InfoResponse, error) {
+func (a *accountBase) GetInfo(userContext context.Context) (*sdk.InfoResponse, error) {
 	request := &sdk.InfoRequest{}
 	md, err := a.GetMetadataContext(userContext, request)
 	if err != nil {
@@ -142,7 +140,7 @@ func (a *AccountBase) GetInfo(userContext context.Context) (*sdk.InfoResponse, e
 }
 
 // ListDevices that can access the cloud wallet
-func (a *AccountBase) ListDevices(userContext context.Context, request *sdk.ListDevicesRequest) (*sdk.ListDevicesResponse, error) {
+func (a *accountBase) ListDevices(userContext context.Context, request *sdk.ListDevicesRequest) (*sdk.ListDevicesResponse, error) {
 	md, err := a.GetMetadataContext(userContext, request)
 	if err != nil {
 		return nil, err
@@ -155,7 +153,7 @@ func (a *AccountBase) ListDevices(userContext context.Context, request *sdk.List
 }
 
 // RevokeDevice from the cloud wallet
-func (a *AccountBase) RevokeDevice(userContext context.Context, request *sdk.RevokeDeviceRequest) (*sdk.RevokeDeviceResponse, error) {
+func (a *accountBase) RevokeDevice(userContext context.Context, request *sdk.RevokeDeviceRequest) (*sdk.RevokeDeviceResponse, error) {
 	md, err := a.GetMetadataContext(userContext, request)
 	if err != nil {
 		return nil, err

go/services/account_service_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	sdk "github.com/trinsic-id/sdk/go/proto"
 )
 
 func TestProtectUnprotectProfile(t *testing.T) {
@@ -19,7 +20,8 @@ func TestProtectUnprotectProfile(t *testing.T) {
 	if !assert2.Nil(err) {
 		return
 	}
-	profile, _, err := accountService.SignIn(context.Background(), nil, "", "default")
+
+	profile, _, err := accountService.SignIn(context.Background(), &sdk.SignInRequest{})
 	if !assert2.Nil(err) {
 		return
 	}
@@ -35,7 +37,7 @@ func TestProtectUnprotectProfile(t *testing.T) {
 	}
 
 	t.Run("Protected profile should fail", func(t *testing.T) {
-		accountService.SetProfile(protectedProfile)
+		accountService.SetToken(protectedProfile)
 		info2, err2 := accountService.GetInfo(context.Background())
 		if !assert2.NotNil(err2) {
 			t.FailNow()
@@ -46,7 +48,7 @@ func TestProtectUnprotectProfile(t *testing.T) {
 	})
 
 	t.Run("Unprotected profile should work", func(t *testing.T) {
-		accountService.SetProfile(unprotectedProfile)
+		accountService.SetToken(unprotectedProfile)
 		info2, err2 := accountService.GetInfo(context.Background())
 		if !assert2.Nil(err2) {
 			t.FailNow()

go/services/credential_service.go

@@ -2,125 +2,107 @@ package services
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 
 	sdk "github.com/trinsic-id/sdk/go/proto"
 )
 
-type Document map[string]interface{}
-
-func NewCredentialService(options *sdk.ServiceOptions) (CredentialService, error) {
+// NewCredentialService returns a credential service with the base service configured
+// using the provided options
+func NewCredentialService(options *Options) (CredentialService, error) {
 	base, err := NewServiceBase(options)
 	if err != nil {
 		return nil, err
 	}
-	service := &CredentialBase{
-		ServiceBase: base,
-		client:      sdk.NewVerifiableCredentialClient(base.channel),
+	service := &credentialBase{
+		Service: base,
+		client:  sdk.NewVerifiableCredentialClient(base.GetChannel()),
 	}
 
 	return service, nil
 }
 
+// CredentialService defines the interface for interacting with credentials
 type CredentialService interface {
 	Service
-	IssueCredential(userContext context.Context, document Document) (Document, error)
+	// IssueCredential using a document json
+	IssueCredential(userContext context.Context, request *sdk.IssueRequest) (*sdk.IssueResponse, error)
+	// IssueFromTemplate issues a credential using a template
 	IssueFromTemplate(userContext context.Context, request *sdk.IssueFromTemplateRequest) (*sdk.IssueFromTemplateResponse, error)
+	// CheckStatus of the credential
 	CheckStatus(userContext context.Context, request *sdk.CheckStatusRequest) (*sdk.CheckStatusResponse, error)
+	// UpdateStatus of the credential (i.e. revoke)
 	UpdateStatus(userContext context.Context, request *sdk.UpdateStatusRequest) (*sdk.UpdateStatusResponse, error)
-	CreateProof(userContext context.Context, documentId string, revealDocument Document) (Document, error)
-	VerifyProof(userContext context.Context, proofDocument Document) (bool, error)
-	Send(userContext context.Context, document Document, email string) error
+	// CreateProof using either a credential in a cloud wallet or based on the json document provided
+	CreateProof(userContext context.Context, request *sdk.CreateProofRequest) (*sdk.CreateProofResponse, error)
+	// VerifyProof presentation
+	VerifyProof(userContext context.Context, request *sdk.VerifyProofRequest) (bool, error)
+	// Send a credential to another use's wallet
+	Send(userContext context.Context, request *sdk.SendRequest) error
 }
 
-type CredentialBase struct {
-	*ServiceBase
+type credentialBase struct {
+	Service
 	client sdk.VerifiableCredentialClient
 }
 
-func (c *CredentialBase) IssueCredential(userContext context.Context, document Document) (Document, error) {
-	jsonBytes, err := json.Marshal(document)
+func (c *credentialBase) IssueCredential(userContext context.Context, request *sdk.IssueRequest) (*sdk.IssueResponse, error) {
+	md, err := c.GetMetadataContext(userContext, request)
 	if err != nil {
 		return nil, err
 	}
-	issueRequest := &sdk.IssueRequest{
-		DocumentJson: string(jsonBytes),
-	}
 
-	md, err := c.GetMetadataContext(userContext, issueRequest)
-	if err != nil {
-		return nil, err
-	}
-	response, err := c.client.Issue(md, issueRequest)
-	if err != nil {
-		return nil, err
-	}
-	var doc map[string]interface{}
-	err = json.Unmarshal([]byte(response.SignedDocumentJson), &doc)
+	response, err := c.client.Issue(md, request)
 	if err != nil {
 		return nil, err
 	}
-	return doc, nil
+
+	return response, nil
 }
 
-func (c *CredentialBase) IssueFromTemplate(userContext context.Context, request *sdk.IssueFromTemplateRequest) (*sdk.IssueFromTemplateResponse, error) {
+func (c *credentialBase) IssueFromTemplate(userContext context.Context, request *sdk.IssueFromTemplateRequest) (*sdk.IssueFromTemplateResponse, error) {
 	md, err := c.GetMetadataContext(userContext, request)
 	if err != nil {
 		return nil, err
 	}
+
 	response, err := c.client.IssueFromTemplate(md, request)
 	if err != nil {
 		return nil, err
 	}
+
 	return response, nil
 }
 
-func (c *CredentialBase) CreateProof(userContext context.Context, documentId string, revealDocument Document) (Document, error) {
-	jsonString, err := json.Marshal(revealDocument)
-	if err != nil {
-		return nil, err
-	}
-	request := &sdk.CreateProofRequest{
-		Proof:              &sdk.CreateProofRequest_ItemId{ItemId: documentId},
-		RevealDocumentJson: string(jsonString),
-	}
+func (c *credentialBase) CreateProof(userContext context.Context, request *sdk.CreateProofRequest) (*sdk.CreateProofResponse, error) {
 	md, err := c.GetMetadataContext(userContext, request)
 	if err != nil {
 		return nil, err
 	}
-	proof, err := c.client.CreateProof(md, request)
-	if err != nil {
-		return nil, err
-	}
-	var proofMap map[string]interface{}
-	err = json.Unmarshal([]byte(proof.ProofDocumentJson), &proofMap)
+
+	response, err := c.client.CreateProof(md, request)
 	if err != nil {
 		return nil, err
 	}
-	return proofMap, nil
+
+	return response, nil
 }
 
-func (c *CredentialBase) VerifyProof(userContext context.Context, proofDocument Document) (bool, error) {
-	jsonString, err := json.Marshal(proofDocument)
-	if err != nil {
-		return false, err
-	}
-	request := &sdk.VerifyProofRequest{
-		ProofDocumentJson: string(jsonString),
-	}
+func (c *credentialBase) VerifyProof(userContext context.Context, request *sdk.VerifyProofRequest) (bool, error) {
 	md, err := c.GetMetadataContext(userContext, request)
 	if err != nil {
 		return false, err
 	}
+
 	proof, err := c.client.VerifyProof(md, request)
 	if err != nil {
 		return false, err
 	}
+
 	return proof.IsValid, nil
 }
 
-func (c *CredentialBase) CheckStatus(userContext context.Context, request *sdk.CheckStatusRequest) (*sdk.CheckStatusResponse, error) {
+func (c *credentialBase) CheckStatus(userContext context.Context, request *sdk.CheckStatusRequest) (*sdk.CheckStatusResponse, error) {
 	md, err := c.GetMetadataContext(userContext, request)
 	if err != nil {
 		return nil, err
@@ -132,7 +114,7 @@ func (c *CredentialBase) CheckStatus(userContext context.Context, request *sdk.C
 	return response, nil
 }
 
-func (c *CredentialBase) UpdateStatus(userContext context.Context, request *sdk.UpdateStatusRequest) (*sdk.UpdateStatusResponse, error) {
+func (c *credentialBase) UpdateStatus(userContext context.Context, request *sdk.UpdateStatusRequest) (*sdk.UpdateStatusResponse, error) {
 	md, err := c.GetMetadataContext(userContext, request)
 	if err != nil {
 		return nil, err
@@ -147,24 +129,16 @@ func (c *CredentialBase) UpdateStatus(userContext context.Context, request *sdk.
 	return response, fmt.Errorf("error - did not run to completion %s", response.Status)
 }
 
-func (c *CredentialBase) Send(userContext context.Context, document Document, email string) error {
-	jsonString, err := json.Marshal(document)
-	if err != nil {
-		return err
-	}
-	request := &sdk.SendRequest{
-		DeliveryMethod: &sdk.SendRequest_Email{
-			Email: email,
-		},
-		DocumentJson: string(jsonString),
-	}
+func (c *credentialBase) Send(userContext context.Context, request *sdk.SendRequest) error {
 	md, err := c.GetMetadataContext(userContext, request)
 	if err != nil {
 		return err
 	}
+
 	_, err = c.client.Send(md, request)
 	if err != nil {
 		return err
 	}
+
 	return nil
 }