Skip to content

Provider Service

The Provider Service helps ecosystem providers with data management and onboarding. This service requires a security profile with administrative authorization access. This can be obtained during the deployment of your ecosystem infrastructure.

Create Ecosystem

Creates a new provider ecosystem

trinsic provider create-ecosystem --name <ECOSYSTEM_NAME> --email <OWNER_EMAIL>

When using one of the SDKs, you must supply a Create Ecosystem Request object.

Field Type Description
name string Globally unique name for the Ecosystem. This name will be part of the ecosystem specific URLs and namespaces. Allowed characters are lowercase letters, numbers, underscore and hyphen.
description string Ecosystem description
uri string External URL associated with your organization or ecosystem entity
details services.account.v1.AccountDetails The account details of the owner of the ecosystem

Then you can supply it to SDK:

let actualCreate = await providerService.createEcosystem(
  CreateEcosystemRequest.fromPartial({
    description: "Test ecosystem from Node",
    uri: "https://example.com",
  })
);
var (actualCreate, _) = await service.CreateEcosystemAsync(new() {
    Description = "My ecosystem",
    Uri = "https://example.com"
});
actual_create = await provider_service.create_ecosystem(
    request=CreateEcosystemRequest(
        description="My ecosystem", uri="https://example.com"
    )
)
actualCreate, err := service.CreateEcosystem(context.Background(), &sdk.CreateEcosystemRequest{
    Description: "My ecosystem",
    Uri:         "https://example.com",
})
var response = service.createEcosystem(ProviderOuterClass.CreateEcosystemRequest.newBuilder().setDescription("My ecosystem").setUri("https://example.com").build()).get();

The response model is of type Create Ecosystem Response:

Field Type Description
ecosystem Ecosystem Details of the created ecosystem
profile services.account.v1.AccountProfile Account profile for auth of the owner of the ecosystem
confirmation_method services.account.v1.ConfirmationMethod Indicates if confirmation of account is required. This setting is configured globally by the server administrator.

Onboarding

Invite Participant

Users can be added as participants in an ecosystem by sending an invitation and a security code. This code can be sent directly to the invitee using existing platforms or via email, SMS, etc. When users accept this invitation, they should do so using the service methods as described in creating wallet with provider invitation

In Trinsic Ecosystems, participants can be Individuals or Organizations. This distinction is important, as providers have the ability to apply restrictions on what functionalities can be invoked by these participants. Additionally, Organizations have the ability to write their DID Document to a public ledger. Currently, the supported ledger is Sovrin, with ION and Element still in development.

trinsic provider invite --organization --method-email [email protected]

trinsic provider invite --person --method-email [email protected]

When using one of the SDKs, you must supply an Invite Request object. This object follows the model below:

Field Type Description
participant ParticipantType Type of participant being invited (individual/organization)
description string Description of invitation
details services.account.v1.AccountDetails Account details of invitee

Then you can supply it to SDK:

import { ProviderService, ParticipantType } from "@trinsic/trinsic";

const providerService = new ProviderService();

let inviteRequest = new InviteRequest();
inviteRequest.setParticipant(ParticipantType.PARTICIPANT_TYPE_ORGANIZATION);
inviteRequest.setEmail("[email protected]");

const inviteResponse = await providerService.inviteParticipant(inviteRequest);

console.log(inviteResponse.getInvitationId());
var inviteResponse = await service.InviteParticipantAsync(new() {
    Participant = ParticipantType.Individual,
    Description = "Doc sample",
    Details = new() {
        Email = "[email protected]"
    }
});
invite_response = await provider_service.invite_participant(
    request=InviteRequest(
        participant=ParticipantType.participant_type_individual,
        description="Doc sample",
        details=AccountDetails(email="[email protected]"),
    )
)
inviteResponse, err := service.InviteParticipant(context.Background(),
    &sdk.InviteRequest{Participant: sdk.ParticipantType_participant_type_individual,
        Details: &sdk.AccountDetails{Email: "[email protected]"}})
inviteResponse = service.inviteParticipant(ProviderOuterClass.InviteRequest.newBuilder().setParticipant(ProviderOuterClass.ParticipantType.participant_type_individual).setDetails(AccountOuterClass.AccountDetails.newBuilder().setEmail("[email protected]").build()).build()).get();

The response model is of type Invite Response:

Field Type Description
invitation_id string ID of created invitation
invitation_code string Invitation Code that must be passed with the account 'SignIn' request to correlate this user with the invitation sent.

The invitation_code in the response contains is security code that users must supply when creating their wallet. If the email method is used during onboarding, participants will receive this code in their email.

Check Invitation Status

User invitation status can be checked with the provided invitation id. It returns an InvitationStatusResponse object.

trinsic provider invitation_status <INVITATION_ID>

When using one of the SDKs, you must supply an Invitation Status Request object. This object follows the model below:

Request details for the status of onboarding an individual or organization. The reference_id passed is the response from the Onboard method call

Field Type Description
invitation_id string ID of invitation

Then you can supply it to SDK:

import { ProviderService, ParticipantType } from "@trinsic/trinsic";

const providerService = new ProviderService();

const inviteResponse = await providerService.invitationStatus("INVITATION ID");

console.log(inviteResponse.getInvitationId());
var inviteStatus = await service.InvitationStatusAsync(new() {InvitationId = invitationId});
invite_status = await provider_service.invitation_status(
    request=InvitationStatusRequest(invitation_id=invite_id)
)
inviteStatus, err := service.InvitationStatus(context.Background(), &sdk.InvitationStatusRequest{InvitationId: inviteResponse.InvitationId})
var invitationStatus = service.invitationStatus(ProviderOuterClass.InvitationStatusRequest.newBuilder().setInvitationId(inviteResponse.getInvitationId()).build()).get();

The response model is of type Invitation Status Response:

Field Type Description
status InvitationStatusResponse.Status Status of invitation
status_details string Human-readable string with details about invitation status