Skip to content

Trust Registry Service

The Trust Registry API exposes functionality for managing your Ecosystem's Trust Registry.

A Trust Registry is a list of authorized issuers for the various credential types within an ecosystem.


Register Issuer

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

trinsic trust-registry register-member \
    --schema https://w3id.org/vaccination#VaccinationCertificate \
    --did did:web:xxxxx.....
let response = await trinsic.trustRegistry().registerMember(
    RegisterMemberRequest.fromPartial({
        didUri: didUri,
        schemaUri: schemaUri,
    }),
);
var didUri = "did:example:test";
_ = await trinsic.TrustRegistry.RegisterMemberAsync(new() {
    DidUri = didUri,
    SchemaUri = schemaUri
});
await trinsic_service.trust_registry.register_member(
    request=RegisterMemberRequest(
        did_uri=did_example_test,
        schema_uri=https_schema_org,
    )
)
registerMemberResponse, err := trinsic.TrustRegistry().RegisterMember(context.Background(), &trustregistry.RegisterMemberRequest{
    SchemaUri: schemaURI,
    Member:    &trustregistry.RegisterMemberRequest_DidUri{DidUri: didURI},
})
var memberResponse =
    trinsic
        .trustRegistry()
        .registerMember(
            RegisterMemberRequest.newBuilder().setDidUri(didUri).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.

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-member \
    --schema https://w3id.org/vaccination#VaccinationCertificate \
    --did did:example:fabre
let unregisterResult = await trinsic.trustRegistry().unregisterMember({
    didUri: didUri,
    schemaUri: schemaUri,
});
_ = await trinsic.TrustRegistry.UnregisterMemberAsync(new() {
    DidUri = didUri,
    SchemaUri = schemaUri
});
unregister_issuer_response = await trinsic_service.trust_registry.unregister_member(
    request=UnregisterMemberRequest(
        schema_uri=https_schema_org,
        did_uri=did_example_test,
    )
)
    unregisterMemberResponse, err := trinsic.TrustRegistry().UnregisterMember(context.Background(), &trustregistry.UnregisterMemberRequest{
        SchemaUri: schemaURI,
    })

 

        // Do absolutely nothing
trinsic
    .trustRegistry()
    .unregisterMember(
        UnregisterMemberRequest.newBuilder().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. The URI of the credential schema must 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

Response to UnregisterMemberRequest
This message has no fields


List Issuers

Lists all issuers that are authorized within the ecosystem, optionally filtering against a specific credential type.

trinsic trust-registry list-members
const members = await trinsic.trustRegistry().listAuthorizedMembers({
    schemaUri: schemaUri,
});
var members = await trinsic.TrustRegistry.ListAuthorizedMembersAsync(new() {
    SchemaUri = schemaUri
});
list_response = await trinsic_service.trust_registry.list_authorized_members(
    request=ListAuthorizedMembersRequest(schema_uri=https_schema_org)
)
listMembersResponse, err := trinsic.TrustRegistry().ListAuthorizedMembers(context.Background(), &trustregistry.ListAuthorizedMembersRequest{
    SchemaUri: &schemaURI,
})
var members =
    trinsic
        .trustRegistry()
        .listAuthorizedMembers(
            ListAuthorizedMembersRequest.newBuilder().setSchemaUri(typeUri).build())
        .get();

schema_uri
string
id of schema that needs to be checked
continuation_token
string
Token to fetch next set of results, from previous ListAuthorizedMembersResponse

Response to ListAuthorizedMembersRequest
authorized_members
JSON string containing array of resultant objects
Show child attributes
has_more_results
bool
Whether more data is available to fetch for query
continuation_token
string
Token to fetch next set of results via ListAuthorizedMembersRequest


Get Issuer

Gets an issuer's entry in the ecosystem's trust registry.

This call returns data regarding every credential the issuer is registered to issue for.

=== "Trinsic CLI"
```bash
trinsic trust-registry get-member \
    --did did:example:fabre \  // OR
    --email test@example.com \ // OR
    --wallet urn:trinsic:wallets:example
```
const member = await trinsic.trustRegistry().getMember({
    didUri: didUri,
});
var member = await trinsic.TrustRegistry.GetMemberAsync(new() {
    DidUri = didUri
});
get_member_response = await trinsic_service.trust_registry.get_member(
    request=GetMemberRequest(did_uri=did_example_test)
)
getMemberResponse, err := trinsic.TrustRegistry().GetMember(context.Background(), &trustregistry.GetMemberRequest{
    Member: &trustregistry.GetMemberRequest_DidUri{
        DidUri: didURI,
    },
})
var member =
    trinsic
        .trustRegistry()
        .getMember(GetMemberRequest.newBuilder().setDidUri(typeUri).build())
        .get();

Request to get a member of the Trust Registry
did_uri
string
DID URI of member to get
wallet_id
string
Trinsic Wallet ID of member to get
email
string
Email address of member to get. Must be associated with an existing Trinsic account.

Response to GetMemberAuthorizationStatusRequest
authorized_member
Member for given did in given framework
Show child attributes


Check Issuer Status

Checks the authorization status of an issuer for a specific credential type.

trinsic trust-registry get-membership-status \
    --credential-type https://w3id.org/vaccination#VaccinationCertificate \
    --did did:example:fabre
let issuerStatus = await trinsic
    .trustRegistry()
    .getMemberAuthorizationStatus({
        didUri: didUri,
        schemaUri: schemaUri,
    });
var issuerStatus = await trinsic.TrustRegistry.GetMemberAuthorizationStatusAsync(new() {
    DidUri = didUri,
    SchemaUri = schemaUri
});
check_response = (
    await trinsic_service.trust_registry.get_member_authorization_status(
        request=GetMemberAuthorizationStatusRequest(
            did_uri=did_example_test,
            schema_uri=https_schema_org,
        )
    )
)
getMembershipStatusResponse, err := trinsic.TrustRegistry().GetMemberAuthorizationStatus(context.Background(), &trustregistry.GetMemberAuthorizationStatusRequest{
    DidUri:    didURI,
    SchemaUri: schemaURI,
})
var issuerStatus =
    trinsic
        .trustRegistry()
        .getMemberAuthorizationStatus(
            GetMemberAuthorizationStatusRequest.newBuilder()
                .setDidUri(didUri)
                .setSchemaUri(typeUri)
                .build())
        .get();

Request to fetch member status in Trust Registry for a specific credential schema.
did_uri
string
DID URI of member
schema_uri
string
URI of credential schema associated with member

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