From 22106bc816673c6d2064f5afda6deb6bf5820e2a Mon Sep 17 00:00:00 2001 From: Stas Dm Date: Tue, 13 Aug 2024 12:57:56 +0200 Subject: [PATCH] feat: more refresh tests --- pkg/restapi/v1/refresh/controller_test.go | 218 ++++++++++++++++++ pkg/restapi/v1/refresh/interfaces.go | 2 + pkg/service/refresh/refresh.go | 56 +++-- test/bdd/features/oidc4vc_api.feature | 8 +- .../cognito-config/db/local_5a9GzRvB.json | 31 ++- 5 files changed, 289 insertions(+), 26 deletions(-) diff --git a/pkg/restapi/v1/refresh/controller_test.go b/pkg/restapi/v1/refresh/controller_test.go index a06dc27ee..f75a7d39a 100644 --- a/pkg/restapi/v1/refresh/controller_test.go +++ b/pkg/restapi/v1/refresh/controller_test.go @@ -5,3 +5,221 @@ SPDX-License-Identifier: Apache-2.0 */ package refresh_test + +import ( + "bytes" + "encoding/json" + "errors" + "io" + "net/http" + "net/http/httptest" + "testing" + + "github.com/golang/mock/gomock" + "github.com/labstack/echo/v4" + "github.com/stretchr/testify/assert" + + profileapi "github.com/trustbloc/vcs/pkg/profile" + "github.com/trustbloc/vcs/pkg/restapi/v1/refresh" + refresh2 "github.com/trustbloc/vcs/pkg/service/refresh" +) + +const ( + orgID = "orgID1" + profileID = "testID" + profileVersion = "v1.0" +) + +func TestGetRefreshStatus(t *testing.T) { + t.Run("success", func(t *testing.T) { + recorder := httptest.NewRecorder() + + profileSvc := NewMockProfileService(gomock.NewController(t)) + refreshSvc := NewMockCredentialRefreshService(gomock.NewController(t)) + + echoCtx := echoContext( + withRecorder(recorder), + ) + + echoCtx.Request().URL.Path = "/refresh/" + profileID + "/" + profileVersion + + issuer := &profileapi.Issuer{} + profileSvc.EXPECT().GetProfile(profileID, profileVersion). + Return(issuer, nil) + + refreshSvc.EXPECT().RequestRefreshStatus(gomock.Any(), "some-cred-id", *issuer). + Return(&refresh2.GetRefreshStateResponse{ + Challenge: "challenge", + Domain: "domain", + RefreshServiceType: refresh2.ServiceType{ + Type: "someType", + URL: "someURL", + }, + }, nil) + + ctr := refresh.NewController(&refresh.Config{ + ProfileService: profileSvc, + RefreshService: refreshSvc, + IssuerVCSPublicHost: "https://public.local/api/vc", + }) + + assert.NoError(t, ctr.RequestRefreshStatus(echoCtx, profileID, profileVersion, refresh.RequestRefreshStatusParams{ + CredentialID: "some-cred-id", + })) + + var res refresh.CredentialRefreshAvailableResponse + assert.NoError(t, json.Unmarshal(recorder.Body.Bytes(), &res)) + + assert.Equal(t, "challenge", res.VerifiablePresentationRequest.Challenge) + assert.Equal(t, "domain", res.VerifiablePresentationRequest.Domain) + + assert.Len(t, res.VerifiablePresentationRequest.Interact.Service, 1) + assert.Equal(t, "someType", res.VerifiablePresentationRequest.Interact.Service[0].Type) + assert.Equal(t, "https://public.local/api/vc/refresh/testID/v1.0", + res.VerifiablePresentationRequest.Interact.Service[0].ServiceEndpoint) + + assert.EqualValues(t, recorder.Result().StatusCode, http.StatusOK) + }) + + t.Run("no updates", func(t *testing.T) { + recorder := httptest.NewRecorder() + + profileSvc := NewMockProfileService(gomock.NewController(t)) + refreshSvc := NewMockCredentialRefreshService(gomock.NewController(t)) + + echoCtx := echoContext( + withRecorder(recorder), + ) + + echoCtx.Request().URL.Path = "/refresh/" + profileID + "/" + profileVersion + + issuer := &profileapi.Issuer{} + profileSvc.EXPECT().GetProfile(profileID, profileVersion). + Return(issuer, nil) + + refreshSvc.EXPECT().RequestRefreshStatus(gomock.Any(), "some-cred-id", *issuer). + Return(nil, nil) + + ctr := refresh.NewController(&refresh.Config{ + ProfileService: profileSvc, + RefreshService: refreshSvc, + IssuerVCSPublicHost: "https://public.local/api/vc", + }) + + assert.NoError(t, ctr.RequestRefreshStatus(echoCtx, profileID, profileVersion, refresh.RequestRefreshStatusParams{ + CredentialID: "some-cred-id", + })) + + assert.EqualValues(t, recorder.Result().StatusCode, http.StatusNoContent) + }) + + t.Run("refresh err", func(t *testing.T) { + recorder := httptest.NewRecorder() + + profileSvc := NewMockProfileService(gomock.NewController(t)) + refreshSvc := NewMockCredentialRefreshService(gomock.NewController(t)) + + echoCtx := echoContext( + withRecorder(recorder), + ) + + echoCtx.Request().URL.Path = "/refresh/" + profileID + "/" + profileVersion + + issuer := &profileapi.Issuer{} + profileSvc.EXPECT().GetProfile(profileID, profileVersion). + Return(issuer, nil) + + refreshSvc.EXPECT().RequestRefreshStatus(gomock.Any(), "some-cred-id", *issuer). + Return(nil, errors.New("refresh err")) + + ctr := refresh.NewController(&refresh.Config{ + ProfileService: profileSvc, + RefreshService: refreshSvc, + IssuerVCSPublicHost: "https://public.local/api/vc", + }) + + assert.ErrorContains(t, ctr.RequestRefreshStatus(echoCtx, profileID, profileVersion, refresh.RequestRefreshStatusParams{ + CredentialID: "some-cred-id", + }), "refresh err") + }) + + t.Run("profile err", func(t *testing.T) { + recorder := httptest.NewRecorder() + + profileSvc := NewMockProfileService(gomock.NewController(t)) + refreshSvc := NewMockCredentialRefreshService(gomock.NewController(t)) + + echoCtx := echoContext( + withRecorder(recorder), + ) + + echoCtx.Request().URL.Path = "/refresh/" + profileID + "/" + profileVersion + + profileSvc.EXPECT().GetProfile(profileID, profileVersion). + Return(nil, errors.New("profile err")) + + ctr := refresh.NewController(&refresh.Config{ + ProfileService: profileSvc, + RefreshService: refreshSvc, + IssuerVCSPublicHost: "https://public.local/api/vc", + }) + + assert.ErrorContains(t, ctr.RequestRefreshStatus(echoCtx, profileID, profileVersion, refresh.RequestRefreshStatusParams{ + CredentialID: "some-cred-id", + }), "profile err") + }) +} + +type options struct { + tenantID string + requestBody []byte + responseWriter http.ResponseWriter +} + +type contextOpt func(*options) + +func withTenantID(tenantID string) contextOpt { + return func(o *options) { + o.tenantID = tenantID + } +} + +func withRequestBody(body []byte) contextOpt { + return func(o *options) { + o.requestBody = body + } +} + +func withRecorder(w http.ResponseWriter) contextOpt { + return func(o *options) { + o.responseWriter = w + } +} + +func echoContext(opts ...contextOpt) echo.Context { + o := &options{ + tenantID: orgID, + responseWriter: httptest.NewRecorder(), + } + + for _, fn := range opts { + fn(o) + } + + e := echo.New() + + var body io.Reader = http.NoBody + + if o.requestBody != nil { + body = bytes.NewReader(o.requestBody) + } + + req := httptest.NewRequest(http.MethodPost, "/", body) + req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON) + + if o.tenantID != "" { + req.Header.Set("X-Tenant-ID", o.tenantID) + } + + return e.NewContext(req, o.responseWriter) +} diff --git a/pkg/restapi/v1/refresh/interfaces.go b/pkg/restapi/v1/refresh/interfaces.go index 891cbfffd..248e3be11 100644 --- a/pkg/restapi/v1/refresh/interfaces.go +++ b/pkg/restapi/v1/refresh/interfaces.go @@ -15,6 +15,8 @@ import ( "github.com/trustbloc/vcs/pkg/service/refresh" ) +//go:generate mockgen -destination interfaces_mocks_test.go -package refresh_test -source=interfaces.go + // ProfileService defines issuer profile service interface. type ProfileService interface { GetProfile(profileID profileapi.ID, profileVersion profileapi.Version) (*profileapi.Issuer, error) diff --git a/pkg/service/refresh/refresh.go b/pkg/service/refresh/refresh.go index 69ed1fd4a..3d56155ac 100644 --- a/pkg/service/refresh/refresh.go +++ b/pkg/service/refresh/refresh.go @@ -73,28 +73,14 @@ func (s *Service) GetRefreshedCredential( } cred := presentation.Credentials()[0] - allTypes := cred.Contents().Types - if len(allTypes) == 0 { - return nil, errors.New("no types in credential") - } - - lastType := allTypes[len(cred.Contents().Types)-1] - - var template *profile.CredentialTemplate - for _, t := range issuer.CredentialTemplates { - if t.Type == lastType { - template = t - break - } - } - - if template == nil { - return nil, fmt.Errorf("no credential template found for credential type %v", lastType) + template, err := s.findCredentialTemplate(cred.Contents().Types, issuer) + if err != nil { + return nil, err } - config, configID := s.findCredConfigSupported(issuer, lastType) + config, configID := s.findCredConfigSupported(issuer, template.Type) if config == nil { - return nil, fmt.Errorf("no credential configuration found for credential type %v", lastType) + return nil, fmt.Errorf("no credential configuration found for credential type %v", template.Type) } tx, err := s.cfg.TxStore.FindByOpState(ctx, s.getOpState(cred.Contents().ID, issuer.ID)) @@ -150,6 +136,31 @@ func (s *Service) GetRefreshedCredential( return updatedCred, err } +func (s *Service) findCredentialTemplate( + allTypes []string, + issuer profile.Issuer, +) (*profile.CredentialTemplate, error) { + if len(allTypes) == 0 { + return nil, errors.New("no types in credential") + } + + lastType := allTypes[len(allTypes)-1] + + var template *profile.CredentialTemplate + for _, t := range issuer.CredentialTemplates { + if t.Type == lastType { + template = t + break + } + } + + if template == nil { + return nil, fmt.Errorf("no credential template found for credential type %v", lastType) + } + + return template, nil +} + func (s *Service) findCredConfigSupported( issuer profile.Issuer, lastType string, @@ -245,6 +256,11 @@ func (s *Service) CreateRefreshState( opState := s.getOpState(req.CredentialID, req.Issuer.ID) + refreshServiceEnabled := false + if req.Issuer.VCConfig != nil { + refreshServiceEnabled = req.Issuer.VCConfig.RefreshServiceEnabled + } + tx, err := s.cfg.TxStore.Create(ctx, ttl, &issuecredential.TransactionData{ ProfileID: req.Issuer.ID, ProfileVersion: req.Issuer.Version, @@ -252,7 +268,7 @@ func (s *Service) CreateRefreshState( OrgID: req.Issuer.OrganizationID, OpState: opState, WebHookURL: req.Issuer.WebHook, - RefreshServiceEnabled: req.Issuer.VCConfig.RefreshServiceEnabled, + RefreshServiceEnabled: refreshServiceEnabled, CredentialConfiguration: []*issuecredential.TxCredentialConfiguration{ { ClaimDataType: issuecredential.ClaimDataTypeClaims, diff --git a/test/bdd/features/oidc4vc_api.feature b/test/bdd/features/oidc4vc_api.feature index 0cb32679e..f63647ae5 100644 --- a/test/bdd/features/oidc4vc_api.feature +++ b/test/bdd/features/oidc4vc_api.feature @@ -24,15 +24,15 @@ Feature: OIDC4VC REST API Examples: | issuerProfile | credentialType | clientRegistrationMethod | credentialTemplate | verifierProfile | presentationDefinitionID | fields | # SDJWT issuer, JWT verifier, no limit disclosure in PD query. -# | bank_issuer/v1.0 | UniversityDegreeCredential | dynamic | universityDegreeTemplateID | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-single-field | degree_type_id | + | bank_issuer/v1.0 | UniversityDegreeCredential | dynamic | universityDegreeTemplateID | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-single-field | degree_type_id | # SDJWT issuer, JWT verifier, limit disclosure and optional fields in PD query. -# | bank_issuer/v1.0 | CrudeProductCredential | discoverable | crudeProductCredentialTemplateID | v_myprofile_jwt/v1.0 | 3c8b1d9a-limit-disclosure-optional-fields | unit_of_measure_barrel,api_gravity,category,supplier_address | + | bank_issuer/v1.0 | CrudeProductCredential | discoverable | crudeProductCredentialTemplateID | v_myprofile_jwt/v1.0 | 3c8b1d9a-limit-disclosure-optional-fields | unit_of_measure_barrel,api_gravity,category,supplier_address | # JWT issuer, JWT verifier, no limit disclosure and optional fields in PD query. -# | i_myprofile_ud_es256k_jwt/v1.0 | PermanentResidentCard | pre-registered | permanentResidentCardTemplateID | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-optional-fields | lpr_category_id,registration_city,commuter_classification | + | i_myprofile_ud_es256k_jwt/v1.0 | PermanentResidentCard | pre-registered | permanentResidentCardTemplateID | v_myprofile_jwt/v1.0 | 32f54163-no-limit-disclosure-optional-fields | lpr_category_id,registration_city,commuter_classification | # LDP Data Integrity issuer, LDP verifier, no limit disclosure and schema match in PD query. | i_myprofile_ud_di_ecdsa-2019/v1.0 | PermanentResidentCard | pre-registered | permanentResidentCardTemplateID | v_myprofile_ldp/v1.0 | 062759b1-no-limit-disclosure-optional-fields | lpr_category_id,registration_city,commuter_classification | # LDP issuer, LDP verifier, no limit disclosure and schema match in PD query. -# | i_myprofile_cmtr_p256_ldp/v1.0 | CrudeProductCredential | pre-registered | crudeProductCredentialTemplateID | v_myprofile_ldp/v1.0 | lp403pb9-schema-match | schema_id | + | i_myprofile_cmtr_p256_ldp/v1.0 | CrudeProductCredential | pre-registered | crudeProductCredentialTemplateID | v_myprofile_ldp/v1.0 | lp403pb9-schema-match | schema_id | @oidc4vc_rest_auth_flow_batch_credential_configuration_id Scenario Outline: OIDC Batch credential issuance and verification Auth flow (request all credentials by credentialConfigurationID) diff --git a/test/bdd/fixtures/cognito-config/db/local_5a9GzRvB.json b/test/bdd/fixtures/cognito-config/db/local_5a9GzRvB.json index 8e78dda89..f4f53aaac 100644 --- a/test/bdd/fixtures/cognito-config/db/local_5a9GzRvB.json +++ b/test/bdd/fixtures/cognito-config/db/local_5a9GzRvB.json @@ -355,7 +355,25 @@ "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjM0NzcwODcsImp0aSI6ImVjZjU4ZWNkLTM2NDAtNDk5Ny1iZDQ3LTJlYjU5Y2U2NGZmOSIsImV4cCI6MTcyNDA4MTg4NywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.f28_6Z60lOSDRta7pjU2Wo8Sbn16dzqBnrEyT_ARNnzxc5B29I711iiqkgcudtzJviKbjR8FjFhOJWahi9LAm3jW2Dco89Q6gXUT4BQbWO0JoLe8ylZtjsGsFTTW0t9EHO5IHIgOjPYN_uL2VAtuW8A3eA5Td6GuW4R97KsdRBfpWwBtRsXDyWIkquBLn46GdMkJFK2yK__I6RiGDCn39hicsw2MoTtSCtpjuWtdCSzwN0t6P780kY16jbIy-ND16njpbpRIDVjAkalriWnRp02QFkYMl11XP_yDhtwF1Q6tLroNIdlJeLf5Xgu5jwwrMG2A6Do3_RwiSNZtyBya7w", "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjM0NzcwODgsImp0aSI6ImIwNTFlMDE4LWQyOTctNDdhZS05Y2ViLTAxNGNiMjFjNGRjMyIsImV4cCI6MTcyNDA4MTg4OCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.Ahck4NBIrPhsyuhkz3ScJY1hJoTb5-jXG_oi1PvlOA_vBizzAm_j3Ml7WRg5DWhAU8EEw06OMLwnpRqPYgMWFCk3KjHrqXWdnm2YC351IpKTWMqcvUbHECG_S-YfYhx5ljRMOn2e7w25tFMRLaeq3Hcgd2BRoull_6CSeda4wUVxZi4oldO3UgCI4jKXAN-kyTcsk0rhKqnjOMQlQdTtGx0gAnY5sszJpmI8FMHy60MgU-lqot6BR1j9gYJwNDW1sj1R_lEmhqArQGBhq6VCLeOZ-SNCH5JSofrji_ThZg4XdQ95TzYJIcS5qnirY19bNFn9qqsuHStq3K3bKeXCdA", "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjM0NzcxNjIsImp0aSI6ImU3ZjQzZWJiLTkyMzUtNDAzNS04Y2EzLWE3NzZlYTQ3NjExMCIsImV4cCI6MTcyNDA4MTk2MiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.1a2RJ1hrmfWTTsQmU6Ast-zZH5iJ_rMwE3MHi8R8eFZAulAnAJrHB0oWDFVZvHKNQ8_-0o8xuJtFY_wH1sdmUVl5h880l7aJj0FhwJexmNZIpGwg4jBPxLgYDLieHZSWq3ryo8SMSFS3qcO6Y4gBKN8T5UwrbTXNfNIauIXu3gqIDhE0CwQR8M3mGzxMgVWWR2OAucyCDgPq4501yL65-KJ59Q1jRtw0QnHTL1Dlf44ruyYcemXI-yqM_I60fV13Id1bDIizbDZA2o5arHgptzYhxhsftFEaAfCxHFZORBvBOk5pq0HLuhLOO0ieHphkVuQrU3wSkoGY1NEiV5m97w", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjM0NzcxNjIsImp0aSI6ImEyNjA5MmFhLWI5YjgtNGQ3NC1iYWYxLWUxNzJmZjY3Zjk5NiIsImV4cCI6MTcyNDA4MTk2MiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.FaADo30a9wBe2WfUR7Gv3WcYYKcmA0qupmVIK2CLrS_e5KCgO2Q63Oxpxr822fB5kGf04KUzD19rHNWcKNrlaqnY8D7RczmQRpUZmWatgxBMolixTaOLimcSQzmeHhLJo1baewOflpY7MTmm6a2KyJk7TUoO9aMpYK4Q1jA_PZDk6v2nCnid2uos3zHlTPvELtdqVhce1J60sGuz49ROKi_Ci63JFt9AoBNaclVIvJVmpB3tkIsxfI320lRiV9d399AiJlMRDV5D0jTOwXWJcfSj8rU_Z3ngNVW75YK7n6kMASKL15hznAQW14NPJRErQSokOMjZtFTpNGex4dY_Yw" + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjM0NzcxNjIsImp0aSI6ImEyNjA5MmFhLWI5YjgtNGQ3NC1iYWYxLWUxNzJmZjY3Zjk5NiIsImV4cCI6MTcyNDA4MTk2MiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.FaADo30a9wBe2WfUR7Gv3WcYYKcmA0qupmVIK2CLrS_e5KCgO2Q63Oxpxr822fB5kGf04KUzD19rHNWcKNrlaqnY8D7RczmQRpUZmWatgxBMolixTaOLimcSQzmeHhLJo1baewOflpY7MTmm6a2KyJk7TUoO9aMpYK4Q1jA_PZDk6v2nCnid2uos3zHlTPvELtdqVhce1J60sGuz49ROKi_Ci63JFt9AoBNaclVIvJVmpB3tkIsxfI320lRiV9d399AiJlMRDV5D0jTOwXWJcfSj8rU_Z3ngNVW75YK7n6kMASKL15hznAQW14NPJRErQSokOMjZtFTpNGex4dY_Yw", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjM1NDYzNDMsImp0aSI6Ijg5ZGY2NzcxLTQ5YWUtNGU0Yi04NTM5LTc5OGJhMTQ3ZjhlMCIsImV4cCI6MTcyNDE1MTE0MywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.P8FvbsdFhg9cMOac7oBrHnYuIlhtcPR5eE2mkxrq9I-S2kkk2CkB8PAYXONKSGkRQbLtTAhiMvGJ0uonPsQWK3cPZhBgYCsU19E3_YwWoXUuJAzDggKavj0pz_w3nLHEC4yNb_Mcw-guzHT4abY2HCNuBgwpAvbjchJZbQXHuIXSYu9u1pZmwvF0AVRCDKLPSM9jhkpNK7OWBnwuKouoZPexUmrGs58cwGqCptYHCppERa7jOmzvrVYk-mVQZWAvHeVHjr7ULWNL1jSi-Bt5MPEocPAiklr-eUlNpTtvEt7Y0O0SAjXrCMeewdyMf12Fvp_5O_TcKplFZpqBjH32xw", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjM1NDYzNDMsImp0aSI6ImEzYWQ1YmEyLTQ1ODUtNGVhNy1hN2Q2LTM0ODE4OWQwMDg2MCIsImV4cCI6MTcyNDE1MTE0MywiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.vAhUgBp8P97kqBrTdS9HVTehXgN3f5ljgGf1fVXXWk2qH-dN6MacsoiIGqrmmC8UeZEgRkhaysAPAYBgdLjlnJPZU8zEnjGz0GnUN4Ct5sV1N0z_F451xZ0u5bFSdaJhBT5zmZoqj4SImsBVWOV3bfRfwckmnhqD6mgY6F-QOhVt92GeQEBLPfY23mFEJmMLLDkyj4UAkEoW8gdNx79XZDDcJhYHRntgEJVr6Knd9GGqS5y1FDmtVV7KD9GE9EUvaEi_zaKqmu7miCzlFfp7glTBSyRTbS8bsppR00Ky7x_mJpVx7MI7mfy6gKbXDriIQLRTn7It6wwO2zfunYZMnA", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjM1NDYzNDUsImp0aSI6ImU0NGVlNWQxLWZmODEtNDBkNS05NmVkLWU2YTdmNzQ3YWI1MiIsImV4cCI6MTcyNDE1MTE0NSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.HSKwGfK1I8T9imqoCf3RcI5lQmcDy7CFTrUx86YmrnnQEKNNUwWidGSz9zSQJFJ3Z3SZi3MIhRqOjpvMvRCM67KvRH0RSAJl3Vy5c3yNOLtcXLvpr5cmtQRDidviozjJ3ECb3eOekrayunbVMpKm8z2dbLP8AGfXW_-1iOTf-WNo6nhaUayQjuTASkSEdk9IeMPOzEvPKD5V5NVWxLYc_L9fjNBWDxAovMxmf01ek-N_wlCcQItYWTtJ9Vu5Au8G2hUESLqZpMUDlE_dy1sd_9XeylNWF55nwDBGQ7b-E4qOnHyrZqmzyhqL8RxHIrMlolumN8L8EUmDXVWGfdvwGQ", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjM1NDYzNDYsImp0aSI6IjY1ZWU3ODUwLTAxNjUtNGNhNS1hNGFjLTdkNTUyOTFiMWFlMSIsImV4cCI6MTcyNDE1MTE0NiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.rbBRo8xjIPp13Bi4sPrx1GZO_gbVFMU4LbBlKwicx6aMhANAEb34LU2WDyze6zEJMf6GlG2XOQnub8QrxQEYGqTPB_hTmMSnqO4DtUGWeCd-ymoXM-kn0udY8fnwdxmmG-DavspUrO1SkMDai6k5il8x5fT2uNUw-pyjD-28KGGviBbMLOwyrnpuFsmdYBF_l5R9OS-ElmsV3egGaZYOmfzD_BhwHc0lRgPwMLD01qoVqmzuFlfp9JXU4VYRT9B2rCLcnTtnNFQLOZZV5XUYjxRXi0Vjo18220Vw-7XNjT_NVkWhsgsMQM2vSEAQlFBRC20NaZwYe1ahNRfT1GqSsA", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjM1NDYzNDgsImp0aSI6Ijc4YjYzMjhiLTAxYjYtNGM3Zi1iNjFhLTNkMmMyY2FlMTUyYSIsImV4cCI6MTcyNDE1MTE0OCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.C1Y8K_tSzZJbvsRFxfuf8tyyhPRR3Pp09VSWiA4AIJWgexhAOkFNbevxZTOk7ADj7ctY4THHWij3vkF-lNNCiLV-s-gWxXUTsmU4q5Q2KTOgMhEoTt9Ci91WBBYHorYmLTk8EYFs25T90G1A2QBkmgVvmTAoVEibAuradGAW2gYfCqAONkW0Ojxp8gpDbNUZrAtqHstzrPh8nvVvB8uNnMLdT56DWXT9tvX2tXscCQnTWMC2uOzCMP8buqY0PCpcKixluRWnPOW6twp81zpRsgVVMhHb8H9ijB69tyVpVWEm4GlFhUPQLiBP0rztTUrSOgk--6jNw3GGJpR_zIoaCQ", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjM1NDYzNDksImp0aSI6IjQwNzAwMzFmLWZlMzQtNDQ5ZS04NzFjLTM4NTI5N2Q4OTRkMyIsImV4cCI6MTcyNDE1MTE0OSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.iYfJHxTGtUcXOA6AgFEqBiWr_5wQjUSDzSt11d6fsFKNG-HOpoHJLa_43SN45VFySQKJU7BpEY_-uExCbtek2F6g4Q0SIr6ba8zFe2RR6kxal3wyPnWtXLJM9w66_oYcTJhdNRP-4Dcx6hKPGOwhg6Jwo0DHvsrAXlYr2NZzal5zxX7FxotfSQYaKgRbP9RjCoJww7WEnRk3b2PnBMb3yNAYNVFVRiWW-PYkY3nBDhhFrzsvibi1yj7YFSDA3_eLVJgUNLC5RcXgYGA_j6CfWeLhlfyr7eaTKv3BhHu30FPkz8CmWkQnSIfZ6wu3GEiUqy9-kt7qyyvkJ0iOIJpT6A", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjM1NDYzNTEsImp0aSI6ImE2YTkwNjk4LTNkYmUtNDEyMy04NzNiLTczNDA1YzcyNTgzOCIsImV4cCI6MTcyNDE1MTE1MSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.mk3eUIeGcyVB6utIW6M8GQZqYZNG6C5biokmjlifmzVJ6Pfu1Yhu5QnaLpUKOm4oUPniSqHRbqC-EmxMYCWo2katsPhLWvIMBae_zHLGLyj7w5IlplWzBOL6zzWnUfVL-u4PaIBJj0_VvSQS4gtJwPbCtZnPBYm1YPqvnHDZY84T3bWgVhBsd3TWb4z1EPlOCo6IZwA1EqdFZULpLuVQITaDcPSMY4wsgK2LSXVjMloLAf1dpUK4XSAX1ooKjJU0C5cm3I0RTinoz2wHNhnhBg521A2Wp0clZEVsmo0KMwAXl_GecoRlyChwU8DgRFwYazzQKGVSEC9aXbFky6Ew-Q", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjM1NDYzNTIsImp0aSI6ImQ1NzE5MDU1LTY2NTEtNGQ1Yi1hMzZiLWExZGE3ZDgwNmFkNyIsImV4cCI6MTcyNDE1MTE1MiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.UKwTMeu53j0_FStB74LRgVKgt08LkOkTQ55t305xlvemytTl-FhMDGnyCw5GxWkVw94RDdRbhc5kiStfimz0yHBlgx7eUKAkao0jZtkye7huWIoXhRv6gGiLSlZmdWWI0pT3E7AIe9DFDzq_87H0rd8ihCfw5SjjnAq3P0JXTU4lrhgz2gK_QPBrSkEYCffAuFeox3sXJ0_xScLGIab1Tbcd14EB2EWnUoUMvUXBXf7E9Ys3f3PQ6_Ig5yxo9pYxSBk1ketx7wu5QBf7np8un-zMVPMN_BmanjQwtgmAvIKTToS86m1JVQ41ELRczJ3nD8Y1bVpwTzTFQYYLAkJ1gQ", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjM1NDY1MTksImp0aSI6IjU1ZWQ0ZDc0LWY3NjYtNDJhYi04YWY1LWViNmVmMjFkZTMwZSIsImV4cCI6MTcyNDE1MTMxOSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.lBE6ppU_c8Yge1WQUu3jYLYmETH9XZoOsoVzvtQjxjgo2krZA83VFx2HBjY2BTjst5k3tL54S1HFS9DjSmDsyeD4Hu8HUAuAU6xyL7xtTCxmAdLLLwRwjmQrfn2LNPRRSk5huAE2wJ3clFffr_nGFJ6lk7M1wiiw_Ecyn7Lh4F7bUSMlru8s_6lGpO_XVrxFDLihvHiq2KRjZh0ilqKsNKAEJP4gfv2Amf7XAMfcu5wxFV1Y1Qz9zc-Sqfe8j-8v2j4mTjIhmQDAUtN5MV4A1S0NHj9a80a6om1pzPhWeU8kZ6zKE-NLN1xJhIdDdilTJKCJDZuXv1Yy_SBwAu-35Q", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjM1NDY1MTksImp0aSI6IjQyYmE5MDlhLTY3MDQtNDQ1My04YjlmLWJiYWEwMDRlNDdjOCIsImV4cCI6MTcyNDE1MTMxOSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.Kf4zgEJgtPIAisVoveZE5qaZ6EQthGiv-EA6GQSUBDWHJEPj1buE61hziHUaByUDD2Y589mMh19jJTYElyr2wCHkYcAguU7wKqQSm0S_pq0mN-gzJ8khh03SfioX8rddCAkGiUJJFRFjb41mThdIKC3gw8-2X9RigWmcWOCHE9A4i20_GagI5u1x3nmHPHCAnPGKisQGQoK6RpIQomPI8tnC8eXbDWKakohE83cy5vr0eaec-iQGPIMKbIPJ8QP8GPO6fp5hjn8DIyBBvEbq9hLxQ7NJfQkAFQlt4NqFf-B98PvCQo7OpYF4-oSW3mq55_Dl5CwtZqTkXHapHrdN1A", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjM1NDY1MjIsImp0aSI6IjIyZThlYzk0LTZiYmYtNGNkNi1iMjNmLTBlOTIzMDM0MDM4MCIsImV4cCI6MTcyNDE1MTMyMiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.cIZfcXfVT5Q0JPbk_5aU27cS8CuLJOAZeTFGgaBQXVMU-y6djO8abw20OFVhPkQO6yh_Xqyqvu3ttOwzCKVhiX-svK4ISqaW1sWthHdntMPSXyGm_vmHgKgUjotLUwVokgp1rJuu7tBht-edn4BkWN7J7OScq6oVVeqw5WeQ3aoSHRICJJIE_c9Jrz488mlbhZ8P7IwFWGkK1N6VdcPd4-vGjY7faxUeY42Vd_75qw-AKL17mpeduvCpf57Dt6gRFUErpAbOnQOuQ3AMMhkKcktMFHpDHxtV5AbuFfjq0fZi7yw3z9Dnd5RA9zfPAk5Q_OkuLO32e7rd9D_EFuS-zg", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjM1NDY1MjIsImp0aSI6IjBjNWMyMTgyLTI5ZmItNDgxYi1iNzljLWJjNDA2ZTNjZjZjOSIsImV4cCI6MTcyNDE1MTMyMiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.xSEggeubWli71Y-RQuroe6ByLUCpEDTEIkVoj3Ch4hwud80sW-lqrJi2d7tLJ59LipjVIoOW7oDVgghiumIRRiX9m3fyAj-qTf7hiOeD5v14SNfobvR4uLcLg1_LsrWLubWWawOo45SRTGvbMiY2efPrmM6PER8hHokeMYIg2i5T1RCQEXggX53RHxfwVQsE23e1J-IDWlBkt1eQBVwvjT6XS27NsdvF44d8QZvXTkrS-49AH1xFX_yubmH3RDaXq29FkbeZX9DVb4WW6t5ZvgMBMDR5gRCwIdsLxkSxQB6dho8LM1jckwhkVxg5zAJU1W_Iyq_3DRaQaHEct6GO9A", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjM1NDY1MjUsImp0aSI6IjRlNmYwNzc2LWQ4OWItNDZhZS1hNDFkLTkwYTMwZTYwYzIzNyIsImV4cCI6MTcyNDE1MTMyNSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.FK4uKJWLrqYkUzDerIiYoJijQUo8mLPfGbhvD37BGbLVgCVMUqdC0UUHLmeeVdkJ09DaQggjHEU6colAAOdTqxrd9B6MEaVaVvYV5uIJ-PLiSWuwsLoEYW_z10iIkTDt700wmB4JWXISEzIljO1km3zAf2c92x-kesX60gQ_XUiABE8NECMlakvM_CLA2vfAbQOT88QoRE4GE7XAv8mEJVHyHIGszVEl9boPVpgEYTkNx01AGcTLaL903SxbjyaxBJ-lmml3jxVX1KCRrbZYkOOAzw0xkN-MtyIU5H2Bj-0Cp8XD2PoqSTi7aJnmZM2X9tLQf9IKAQuue0HzG5--Nw", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjM1NDY1MjUsImp0aSI6Ijk5MjVkZDM3LWExOGMtNDZiMC1hYTM2LWE1YTAxYWUyMjY1ZiIsImV4cCI6MTcyNDE1MTMyNSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.alUohDSAEqeTbcuyiZSyNLZ9UUY5vN0-0p6NttqSk-oDRaLQRPC99QHrKafgAIu-SRzWmUannA-Zwei_cHA28mjQD7I9BkLuIDAtnfUxbrTZT-UGVQbPffjbiIKFOMrlotYMEcuioLvPVL_QFaowdrRFxlaW5xLA_7Ta5UlT5c61cQQq0XiC04jVwet68qY_03nG-0KI4ML2LroUSj6O3sHaMM2ASnJa6BcARUsEviAVClK--D2dZAgsR0AiszjwbXPi5F0i4e0aEZL9OnoF0yuFEtcjJxkq4-9e4Mmvu_gP5ki3HjU3Z8PKqTTm3_iofqWUrUTI5dMu7HLO6js6HQ", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjM1NDY1MjgsImp0aSI6IjVkYWMwNTE4LTFhN2ItNDRlMi05NWUxLTc4MTk0MjFlYWY3MCIsImV4cCI6MTcyNDE1MTMyOCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.oRgNGORz229FuIN-4tPGwyLqTuBgyAk894u1tJAeMmiVzRxg1GOl-dF6KT2oN-ovPulmq9Qjc3iMmOjjCSMxkY8NxLLo5zvz1O89MDsXVtU6aLY4jzZT_xQU1E4IgUTVNNEJm8oEiQE1NBi4nMggh7PO08Avt_OftrOiQl-KaSnZczI22MmF9CycFA2RKTrX7z2qMUPr-7NrGiUbc2tW8y9ZnQGv63HqOqE2urDq4wy--evkRjO62HqQ84oxsMmZZ5YRRs_ZKsVIQSbleEMwN0TYo2NDO9NPCU9ByKwXDwR7VYWBu4MwfJynZsyfv8FBJD2jRkgG7oNZ2YUbXelyDA", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjM1NDY1MjgsImp0aSI6ImExNzU4YjczLTBkZTYtNDA0My04OTkwLWY5YjVkOWQxODQ4NCIsImV4cCI6MTcyNDE1MTMyOCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.g8jHKrPQQM2nYRe3jk1XJeWeEWtJT769pQP7C9_hbHCAPISuaGkID0qHCAY9mHzUE6tX_hnGAGEpxXPDhpyL7QOGhSOwza7eg-7WSrmtQe3R3LdpcT3Zr5aVGN9qBUI8Umy-ZPPM7flqzWx_C9nh0_GF2qQNKtX-efT3uXQJOPov93PFphWMXzABqQTohM69Lu8_QCJKJazJiRM3EI6qmOIbrAugsLSiOGsUJSFUFN7JWRG8rA5xf-fKK3pxrC_Lyc7Ws_BtRL7VnE37B0YdDHRntu-nLz8QC6KqCBSocvYrItGb_kVexom6y5dkhT8YNqWCGBeUseDYt7kX5cs4JQ", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjM1NDY1NDgsImp0aSI6ImIxZGRkZmJmLWMwNDQtNDAyNi1iMzQ4LTZlMTNiOWI0NWNkNyIsImV4cCI6MTcyNDE1MTM0OCwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.XyIUuKAeBDfqH7zOiJ9kxQ8UtjfwItKNtj3Y71p42ZF9ob8CmZjmWwdGACitfeDBPjXdOiZpBJpmJl98OCQzQWKKTT0tHpFpGAN5DUWxaMObIBCDuTeW_7_OnMBIm64HAkCEOwL-s3g09j1OsqgTG3CQy5Mu7H39aDruYsYKvHwjwcg4Yc86uZGbSyvx-SVEY0G4x8Wa6sB76kBTV_Geqerls0uFAYozOkPx-4EdBF4KhhuIhulIxr30H7uv9ctTdZIcIaV3tYQ_YLGvN21i3_TiI2nTSHyGCFWskKgi-rs0UByayRcwMTWbSkPlgmRHBm5GSrLVdtdL50wgCA5B9Q", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLWlzc3Vlci0xIiwiZW1haWwiOiJwcm9maWxlLXVzZXItaXNzdWVyLTFAZXhhbXBsZS5jb20iLCJpYXQiOjE3MjM1NDY1NDksImp0aSI6ImVlOTk2NjBhLTRjNjktNDNhNC05ZGI1LTI1ZGE0NjYxYzQxYyIsImV4cCI6MTcyNDE1MTM0OSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo5MjI5L2xvY2FsXzVhOUd6UnZCIn0.PscCO_Y5ZYU8Nn9GFNGAS7uUHLIj4SCTvki4Kwm-iB5NaenOLz020Nc_Bd6sOfwRkjrguuz_1joVj-7R7gTIrOXF6djfrzDXic8GU6vOQc6V1jjhO9lvIKQFdK0MD6d9IIAemS03DjEGDiu1S8KgEqjhG9NP9rkcFbGtCZ4ehyQrY2DkNnzll5izjHlUi7B-Z8D8yhEM0oOe2H9Ql25vzsYcq9g8C0Ht4HToNKrEBPgfWxTvyWgUK56c2PtsmAabGOk84W3f_ECqj7LhfCOVKfTkjWSVCwR9zQShauv02t2vYLwejcVWNhMmdVcvTeEsQzqkCRdXNZ67Pcah8EsYYQ" ] }, "profile-user-verifier-1": { @@ -553,7 +571,16 @@ "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIzNDc3MDM1LCJqdGkiOiI3NTQwZDI4Ni0yZDZmLTRjY2UtOTZiYi04Y2Y3MDU3MDQyYWMiLCJleHAiOjE3MjQwODE4MzUsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.YJz_q7Xtb3rSTI1nBV05KAYNkdDaMb3DVbGngXO5FckKbc8NEk9qkfk7iBP73NGNR2PCQRIQWacUZypfdJgZDhDdg06G_OjaZ8vz7w0K2yKmAX1RpVErQjhhc7xlACRxTydqfXkiy4OxpfyIzQpbiUmqEa7Niv2VkcY2lxJRtChjy4dpRBxIktp4K-FG-S7bmdsMzwWwYqwZpp1e5H_g7-30Xz1OgecRY2ut5svhugihYqnnHxQH0th8rQ3ki_oDqV_WeCUpqW1FQzuyrNowrJ5v2uIcKU3TziJAjzJ2Snf3Y_WsqwyBLGSSYXi5kKJvo4Mvmyybe4gmjnm1gqdy6Q", "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIzNDc3MDgwLCJqdGkiOiI1MTA0Y2JkZC1hMDRjLTRjN2EtYmJhOS02MDM0YmZhODk1OWUiLCJleHAiOjE3MjQwODE4ODAsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.iM_XK_YV6Ib9zJqfs0m_eal4GjYejbm98YmiUwCch9QC5CEEDbzDCNdpqmTgE6KCd0iFhAFxFgRJ8GjLgslHcqvKgCGSYc8zRqmlYmfIGyGVlNpQTAvPQHI9N5txYxSCiQpw9vIGIDdK2qBlZle7WkaRVSC0dd2X8HLBl7ZX9YiyysjWyCQiLiCB_jeDvZsvZYKbduAaz493oa-Aegdpj_wBuD_-Id0y_ayo7U09hjff1OQaZ8IxBPoPw6_-jSebJs2cfVuRE9RfFGNk6LS93P1zczOH_m3iy5j7Zz0MyiBrpxu2hxzO3tQy3EuS-sdeWJk8e0m8okxvm_khlLDltg", "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIzNDc3MDg3LCJqdGkiOiIyMTY5MzQ2OC0wYWU0LTQxYjktODViMS0wZjYwNTc2YmYxYTMiLCJleHAiOjE3MjQwODE4ODcsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.qnQ3t5xjO6kUsIBKPBWdUNcllJHj0AJc6j4bMI5Q8lPouRBZb-1hll35dqchL_HlW0w_65P64KpT0UMxUXP_2w8Z_4VtuFJDTXCPBHsEEvItxn2Fpoi7s0dFCnv8Q-1m1a-uaa-wtvn5WHj1KBzAaTJrI5Oc3V4GfsTlhBdZnCr2Kr9Z8TI7L3d1USCXmhogKncJavNJEwvgs6M4mMy0ZsiybIm-rO33qcLx5YfbEkQwvDmxfmhByp8yz_Oi3yhGl6NFVdZ9eQO9EdGFGcerq9Y8FolBo142x5cSrVqLYVW2iYAGb3GZGDUfm-mqSgEa2cKPdH1sqgP86Ea0vwAKog", - "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIzNDc3MTYyLCJqdGkiOiIwNDIwZGM5Zi1jNTVhLTRmZmQtOTY5NS03NmQyZTdmMTkyMDkiLCJleHAiOjE3MjQwODE5NjIsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.WLriPBORG5NjuLfpNTdbHV2lsUlZAO-_40dU8KU_TYkd6-6dpFfMXvE2t7doh_3EaBvp3XyjwxH_eTV4-Jq31uw_eRQpNn1T18lEFQMO8SmHXTAOvEjUtlc7zyo59JVYsQf4E0snnUfnD4lJwyq6BFPsFoIMRL7YUz5mTgqPkzrrmAeKiWHxTUuuu4KQPdvxBtewxjSYvKQtGoiL7Hz1vz0M9blPTUirGy47uAxe6dll1K519T3D6Np_Xdj1W2TyOcFYvGl53Xxh_MXyYTSMm5RwadXLRduwiVimlL9C02F8stHZIgnBBPsfkfdiNDO6ywrtOXjBZeyD7uSMQ-PjEw" + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIzNDc3MTYyLCJqdGkiOiIwNDIwZGM5Zi1jNTVhLTRmZmQtOTY5NS03NmQyZTdmMTkyMDkiLCJleHAiOjE3MjQwODE5NjIsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.WLriPBORG5NjuLfpNTdbHV2lsUlZAO-_40dU8KU_TYkd6-6dpFfMXvE2t7doh_3EaBvp3XyjwxH_eTV4-Jq31uw_eRQpNn1T18lEFQMO8SmHXTAOvEjUtlc7zyo59JVYsQf4E0snnUfnD4lJwyq6BFPsFoIMRL7YUz5mTgqPkzrrmAeKiWHxTUuuu4KQPdvxBtewxjSYvKQtGoiL7Hz1vz0M9blPTUirGy47uAxe6dll1K519T3D6Np_Xdj1W2TyOcFYvGl53Xxh_MXyYTSMm5RwadXLRduwiVimlL9C02F8stHZIgnBBPsfkfdiNDO6ywrtOXjBZeyD7uSMQ-PjEw", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIzNTQ2MzQzLCJqdGkiOiI5ZjYyOThkYS1hZmEyLTQzOTUtYjI3OS04NjdmOGFiMTQzODEiLCJleHAiOjE3MjQxNTExNDMsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.1P9LpM2RK4SP3g6f7KxTyTNHSRb3YE8Vt2L2zj_bwncubbb9AUYaGJDiFHxPyfABvgd47FiSynE6xqWQBLbN41cVSa38nHz2s7YjsV40ebm5nXLANIcUpupmDhE2Lr9YeRFVcKa8V6yNDn_HmKPtvnGW3BnTeN4HcrpL7ICBW8A-jAFA0S-vxKGYrw4kDqeTXmAch7hKnqg420hcMrTXKJoxRVQjYtlq8tNlF4MUHuxhZiKswkuuCHPS74wJ908Oa2osrCoHTMvK9q3x39GQz-E1Qbdl-0KA1_a63wsuKNdLCToOgGDaboWuLQ1n_xuiI9rqrZfWcG9CxPEp97bhuw", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIzNTQ2MzQ1LCJqdGkiOiI4MzMyMTY3Zi05MTVkLTRkYTYtOTM1YS05MmVkMzM1MWYzZmQiLCJleHAiOjE3MjQxNTExNDUsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.gYRUmenIq9CRAJdKwGGIW0aMOB-jQaoXibVCNsRe6Rylj6Q4L-rfUOlL4Na1qpagSrOCVe52J6I7yCBFdQoxXyt2cCFuvo8EMRorvjD-BsIHj_P4b_aBLjBNqFPU88gd1LKuF2_iZ0uVvcuedj0or7Bg3NaqM2qZUD6C3qzSjsw37d1T4pi8VH8szEfEqZua_o040gZvwj1KPlCWJxvu4oJ8JyOrWz5WIIqctgCmE-ZhslPWYahnnMJBv9VNCbIc8ziL5QhzGEWBaysDuRuDMS_jkAhJf_7a8ZCc5ZX2sQmf2BW9GGL0Sb9kz_0YHMu7f1bMEFCzO7gFPkRv3Vpvag", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIzNTQ2MzQ4LCJqdGkiOiIzMzIxNTk2NS04MDdiLTRiMDMtYjkwNS1hMDA5ZDZjODFlMzQiLCJleHAiOjE3MjQxNTExNDgsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.SfHpfpKni9EcHfoBpJZnRa2dN4vtM5FuZDB3gBICFxRN1ut1R1q7kQlOhnRcjHp5ZuykmztQRMtB6eY7AvfqKaVHei4P_BjjqZvy_SY-tj_PAh3YfbPo1ZtX1auKe_qwtE1d4DaNIa1-wQcIZ7m0CNSqpLMAF1MAs-9zR6filKYZtHfqcA05wnda2PCtyrtOCaqD2TvpOlRv9oz-NaCca3az1Ypm550ScuD6bREtesVJp4EUbcAzUrVAGz-gxm-cLs-vhD0nC6_2qv7Ts7_niSgX8n_-80kIKcPCdkzPWi5ZQcYPcgYt4bZycOYEtmj8-nEnp0fjzZCguunDjbFtFw", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIzNTQ2MzUxLCJqdGkiOiIxYjA4YjFmMS1iNWJjLTQ3ZTUtODJkOS0xY2YxMzA5OTY3NTEiLCJleHAiOjE3MjQxNTExNTEsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.v4bb8kYDY6Vclqk6a_4dJpqvhJ6rB5pb7_el1avXevvX112hz4vpX-XH9KVzww0wsAzoYVPmtVzColTRaaCzLv5cf-Of4TG5xJ7ScpDlm7txeQ6wwzOTJtv-ofxg8LAiYNG7qW2xvKi4ytND3d5QWI2ZuYMo1nit31QiZnsYAxBIwWf1wxKqsgJLFC3RDAiwjoQHITlj5RInOTaIKBYlmluq9JmBbgc_y6qn4MmefMMdmk6_tSSJP4jzLcg-71u2N-3649SHNUxIFv7c9teyUQvktn86djNUojAOtzHv522-ISPVqZeOajBsxKzPSV0NnP4HTP2rRQCQPKZy6O0jvQ", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIzNTQ2NTE5LCJqdGkiOiI2NGI4ZTdiOS1lZDgxLTQxY2UtYmNiYS04NmUzZDY0Yzg4ZWEiLCJleHAiOjE3MjQxNTEzMTksImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.eTvY0q3TsA5o7wuNhPAFYNNYJ4bTeVLhTt2LtkTiGQAqC3jrxjXF2ujGpqCZp9CRe2eV7oF0WhthVDIBi7EDMi03ZVljNekFt4-GUIDZPBc1MqtYOhC0gQjYN-wVrzmY0Cn0v7zOv4_DHnPPrKoJlw3bpoLs-EA3GxqOU5jPYRVzzSSVBcGWEprI-aUixYlsB0_nmlP4uiL1Ny9JZ7p9prjkO7wqmaSRup9AgE5IBUWm2ArGPZVsuKTSLLLD2rCXFyoI1Gvimf6gIzQcuITjwfpgJIAiwoR_aPm5oG-s25uRQeVNCNS6cPWpdUPUKM_C-fgYxiCYn52aQBJ4_Im7ag", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIzNTQ2NTIyLCJqdGkiOiIzMGU0ZDZkNi01ZGYxLTQxZTMtODk2Ni1mOTlkYTgwMDg1YjEiLCJleHAiOjE3MjQxNTEzMjIsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.jRT2qZgwol4dQRLQc4I5efdWtHqnsxViD6D5wxRVsNlvJJxSScmyAkL-m8XdiLPyhtDQDivKT7S7OA9t7KD6qH0liY3J_UGUIul1mSmKnnf19ZUBouy6_WaOkw22QjqOMbMLV6fzlZzqDw-xCOkB5_xslSY-dzSG92uGMS1zYFYEHjK9kG5I93_w7-5jyThjBr6lupH8NjIztCqHRFOzfwiUMJKIEElggrWftqWpeDQ4EUSV04cZq810HjIj32P7lsZRPNdh6lrRyXhBVDMXfKLMQWlgYJklG5c0Er9h_hMZIfrvk8qlYWjt8KpO4yM6a9YH27NpUpsjlsK3PPgO-w", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIzNTQ2NTI1LCJqdGkiOiI4Mjg2ZmVmMC1iOGMxLTQ2OWYtYjlmYi02MDNjMjIwYWIwNjIiLCJleHAiOjE3MjQxNTEzMjUsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.Vaw7e-lSZXg2AdYWXaVezI5JPqUHsm-RLiyoDdgFW8XU-qgyoKumwPeESbiakdGunXVIoPD-1S_uoFOE5eummcWk7qx6ab7PiXbabSLwm6qeor6_GB-ajvhcZ2A2or1BosG20B7YQUV9lAmATGW1p7RtWHBC8f--khH1Ax6Ba0bohq8DR5U1bsB7q8Fh9n1DJbatj-bxIy6p7Cl2fiGeB8xfYTvHv7m14Vpw348uXzzvV9O2awlpWjLxRH08hGHXygMqCG-xlLUxRO91OQ2LfsEfbgRjuQLWvcDCIKPAfKiiNisCFRxWY3zNFWUxWXn7Bvh3_Bq7Mq1ERJkeYUU30Q", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIzNTQ2NTI4LCJqdGkiOiIxYmMwNWFkMy04ODkyLTRmZmEtYmE1Mi00OTM2NWM2YjgzZDIiLCJleHAiOjE3MjQxNTEzMjgsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.BenVce_NKSM7P3F0-uD_NHT_1Iihfj4ZQkuvcyOFC60JuZsF3gT_pbu9YgLKXv_aB_4nu99leRaDrszh8CPQ5YXJGHuJu8CLRu9aGQokoLHrGPQaYAqMSigOiULNoLtPYcHmmGNJKEw-XaK1AtPOZ4wCDKmpPz9U_adchSI_0i6sGoGg8pXYjkk9Xti_It13ZmR0-4TWJDftgZXQCFgGO1KgsaUxkfGvU60-TKF24mBGjL8ZIyIMxtVNlMDGOQndGsRzMlBv8LDRtxjXBvUkWr9GTRFWZ38OoxBzAUfx7EPhkoLqVtPZTY9kWQvOYjQ6_505BGXgQFZHVowKmJn-HA", + "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjb2duaXRvOnVzZXJuYW1lIjoicHJvZmlsZS11c2VyLXZlcmlmaWVyLTEiLCJlbWFpbCI6InByb2ZpbGUtdXNlci12ZXJpZmllci0xQGV4YW1wbGUuY29tIiwiaWF0IjoxNzIzNTQ2NTQ4LCJqdGkiOiJhN2UzNWU4NS04YTM3LTQ5YzktYWIxNS1kZTA5NmJhYWUwZWQiLCJleHAiOjE3MjQxNTEzNDgsImlzcyI6Imh0dHA6Ly9sb2NhbGhvc3Q6OTIyOS9sb2NhbF81YTlHelJ2QiJ9.vcDsf5XSBKAcK4dBHm5XPu5bCY7WTLEbVzZYe-S8c841Yazcs8ZjDgpUOBy04o5gfSnJvfoMgats1sN8b1mkAGg7WcEHxuhIFQTWJIm0xDJbQCCIpWC_OYKpiT03VpoeCXrni8Ht_9euGLPzpeyoqVTNugYun4PIJp5lSIZSBC9j6Scn3nYdGtbBjjJC0mWeLog_nChVoX2v5cQDtaBfLjiccSjs9h11vHAiZhcgQHNHXTlMrTseOV1bSor9EBA2j7Y9V4J_Y6-WHzax13xq3kZcdy0vPTmDjGEPkB3wUpRA6HAEhZMwBLuxppOwm5XvYQ2nCVdaod_j0gvBYEe3wQ" ] }, "profile-user-non-issuer-1": {