Skip to content

Trust Registry Service

The Trust Registry Service exposes functionality for managing Trust Registries -- lists of authorized issuers for the various credential types within an ecosystem.

Under Construction

This section -- and the underlying API -- is under active development.

We are working to define exactly how Trust Registries will be implemented within our platform; this page and API may change as we do so.


Create Governance Framework

Creates a Governance Framework and attaches it to the current ecosystem.

trinsic trust-registry add-framework --name 'Example EGF' --uri 'https://example.com/governance'
const didUri = "did:example:test";
const frameworkUri = `https://example.com/${uuid()}`;
const schemaUri = "https://schema.org/Card";

let frameworkResponse = await trinsic.trustRegistry().addFramework(
    AddFrameworkRequest.fromPartial({
        governanceFrameworkUri: frameworkUri,
        name: `Test Governance Framework - ${uuid()}`,
    })
);
var schemaUri = "https://schema.org/Card";
var frameworkUri = "https://example.com";
var registerFrameworkResponse = await trinsic.TrustRegistry.AddFrameworkAsync(new()
{
    Name = "Demo framework",
    Description = "My governance framework",
    GovernanceFrameworkUri = frameworkUri
});
register_framework_response = await trinsic_service.trust_registry.add_framework(
    request=AddFrameworkRequest(
        governance_framework_uri=https_example_com,
        description="Demo framework",
        name=framework_name,
    )
)
newFramework, err := trinsic.TrustRegistry().AddFramework(context.Background(), &trustregistry.AddFrameworkRequest{
    GovernanceFrameworkUri: frameworkURI,
    Name:                   fmt.Sprintf("Example Framework - %s", uuid.New()),
})
var frameworkResponse =
    trinsic
        .trustRegistry()
        .addFramework(
            AddFrameworkRequest.newBuilder()
                .setGovernanceFrameworkUri(frameworkUri)
                .setName("Example Framework" + UUID.randomUUID())
                .build())
        .get();

Request to register a new ecosystem governance framework in the current ecosystem
governance_framework_uri
string
URI of governance framework organization
name
string
Name of governance framework organization
description
string
Description of governance framework

Response to AddFrameworkRequest
id
string
Unique framework identifier
governing_authority
string
DID URI of Trinsic account which created the governance framework
trust_registry
string
URN of trust registry for governance framework


Register Issuer

Registers an authorized issuer for a specific credential type (identified by its schema_uri).

trinsic trust-registry register-member \
    --egf http://hl7.org/fhir \
    --schema https://w3id.org/vaccination#VaccinationCertificate \
    --did did:key:xxxxx.....
let response = await trinsic.trustRegistry().registerMember(
    RegisterMemberRequest.fromPartial({
        didUri: didUri,
        frameworkId: frameworkResponse.id,
        schemaUri: schemaUri,
    })
);
var didUri = "did:example:test";
_ = await trinsic.TrustRegistry.RegisterMemberAsync(new()
{
    DidUri = didUri,
    FrameworkId = registerFrameworkResponse.Id,
    SchemaUri = schemaUri
});
await trinsic_service.trust_registry.register_member(
    request=RegisterMemberRequest(
        did_uri=did_example_test,
        framework_id=register_framework_response.id,
        schema_uri=https_schema_org,
    )
)
registerMemberResponse, err := trinsic.TrustRegistry().RegisterMember(context.Background(), &trustregistry.RegisterMemberRequest{
    FrameworkId: newFramework.Id,
    SchemaUri:   schemaURI,
    Member:      &trustregistry.RegisterMemberRequest_DidUri{DidUri: didURI},
})
var memberResponse =
    trinsic
        .trustRegistry()
        .registerMember(
            RegisterMemberRequest.newBuilder()
                .setDidUri(didUri)
                .setFrameworkId(frameworkResponse.getId())
                .setSchemaUri(typeUri)
                .build())
        .get();

Request to register a member as a valid issuer of a specific credential schema. Only one of did_uri, wallet_id, or email may be specified.
did_uri
string
DID URI of member to register
wallet_id
string
Trinsic Wallet ID of member to register
email
string
Email address of member to register. Must be associated with an existing Trinsic account.
schema_uri
string
URI of credential schema to register member as authorized issuer of
valid_from_utc
uint64
Unix Timestamp member is valid from. Member will not be considered valid before this timestamp.
valid_until_utc
uint64
Unix Timestamp member is valid until. Member will not be considered valid after this timestamp.
framework_id
string
ID of the governance framework that member is being added to

Response to RegisterMemberRequest
This message has no fields


Unregister Issuer

Unregisters an issuer for a specific credential type (identified by its schema_uri).

trinsic trust-registry unregister-issuer \
    --egf http://hl7.org/fhir \
    --credential-type https://w3id.org/vaccination#VaccinationCertificate \
    --did did:example:fabre
let unregisterResult = await  trinsic.trustRegistry().unregisterMember({
    didUri: didUri,
    frameworkId: frameworkResponse.id,
    schemaUri: schemaUri
})
_ = await trinsic.TrustRegistry.UnregisterMemberAsync(new()
{
    DidUri = didUri,
    FrameworkId = registerFrameworkResponse.Id,
    SchemaUri = schemaUri
});
unregister_issuer_response = await trinsic_service.trust_registry.unregister_member(
    request=UnregisterMemberRequest(
        framework_id=register_framework_response.id,
        schema_uri=https_schema_org,
        did_uri=did_example_test,
    )
)
    unregisterMemberResponse, err := trinsic.TrustRegistry().UnregisterMember(context.Background(), &trustregistry.UnregisterMemberRequest{
        SchemaUri:   schemaURI,
        FrameworkId: newFramework.Id,
    })

 

        // Do absolutely nothing
trinsic
    .trustRegistry()
    .unregisterMember(
        UnregisterMemberRequest.newBuilder()
            .setFrameworkId(frameworkResponse.getId())
            .setDidUri(didUri)
            .setSchemaUri(typeUri)
            .build());

Request to unregister a member as a valid issuer of a specific credential schema. Only one of did_uri, wallet_id, or email may be specified.
did_uri
string
DID URI of member to unregister
wallet_id
string
Trinsic Wallet ID of member to unregister
email
string
Email address of member to unregister. Must be associated with an existing Trinsic account.
schema_uri
string
URI of credential schema to unregister member as authorized issuer of
framework_id
string
ID of the governance framework that member is being removed from

Response to UnregisterMemberRequest
This message has no fields


Check Issuer Status

Check the status of an issuer for a specific credential type.

trinsic trust-registry check-issuer \
    --egf http://hl7.org/fhir \
    --credential-type https://w3id.org/vaccination#VaccinationCertificate \
    --did did:example:fabre
let issuerStatus = await trinsic.trustRegistry().getMembershipStatus(
    GetMembershipStatusRequest.fromPartial({
        didUri: didUri,
        frameworkId: frameworkResponse.id,
        schemaUri: schemaUri,
    })
);
var issuerStatus = await trinsic.TrustRegistry.GetMembershipStatusAsync(new()
{
    DidUri = didUri,
    FrameworkId = frameworkUri,
    SchemaUri = schemaUri
});
check_response = await trinsic_service.trust_registry.get_membership_status(
    request=GetMembershipStatusRequest(
        did_uri=did_example_test,
        framework_id=register_framework_response.id,
        schema_uri=https_schema_org,
    )
)
    getMembershipStatusResponse, err := trinsic.TrustRegistry().GetMembershipStatus(context.Background(), &trustregistry.GetMembershipStatusRequest{
        FrameworkId: frameworkURI,
        DidUri:      didURI,
        SchemaUri:   schemaURI,
    })

 

        // Do absolutely nothing
var issuerStatus =
    trinsic
        .trustRegistry()
        .getMembershipStatus(
            GetMembershipStatusRequest.newBuilder()
                .setDidUri(didUri)
                .setFrameworkId(frameworkResponse.getId())
                .setSchemaUri(typeUri)
                .build())
        .get();

Request to fetch membership status in governance framework for a specific credential schema.
framework_id
string
The ID of the ecosystem governance framework. This ID may be found in the 'trustRegistry' field in the verifiable credential model
did_uri
string
DID URI of member
schema_uri
string
URI of credential schema associated with membership

Response to GetMembershipStatusRequest
status
Status of member for given credential schema
Show enum values


Search the registry for registered issuers using a SQL query.

trinsic trust-registry search --query <SQL query>
let searchResult = await trinsic.trustRegistry().search();
var searchResult = await trinsic.TrustRegistry.SearchAsync(new());
search_result = await trinsic_service.trust_registry.search()
ecosystemList, err := trinsic.TrustRegistry().Search(context.Background(), nil)
var searchResult = trinsic.trustRegistry().search().get();

Request to search all governance frameworks within ecosystem
query
string
SQL query to execute against frameworks. Example: SELECT c from c where c.type == 'GovernanceFramework'
continuation_token
optional string
Token to fetch next set of results, from previous SearchRegistryResponse

Response to SearchRegistryRequest
items_json
string
JSON string containing array of resultant objects
has_more_results
bool
Whether more data is available to fetch for query
continuation_token
string
Token to fetch next set of results via SearchRegistryRequest


Cache Offline Registry File

trinsic trust-registry download