Persona Functions

int kc_persona_destruct(kc_persona_t** persona_ptr)

kc_persona_t* persona = NULL;
// ... get persona from somewhere ...
int result = kc_persona_destruct(&persona);
if (result == 0) {
    // persona is now NULL
    printf("Persona destructed successfully\n");
}

int kc_persona_equals(
    const kc_persona_t* lhs_ptr,
    bool* out_is_equal,
    const kc_persona_t* rhs_ptr
)

bool are_equal = false;
int result = kc_persona_equals(persona1, &are_equal, persona2);
if (result == 0) {
    printf("Personas are %s\n", are_equal ? "equal" : "different");
}

int kc_persona_is_null(
    const kc_persona_t* persona_ptr,
    bool* out_is_null
)

int kc_persona_is_mature(
    const kc_persona_t* persona_ptr,
    bool* out_is_mature
)

int kc_persona_is_auto_renewing(
    const kc_persona_t* persona_ptr,
    bool* out_is_auto_renewing
)

int kc_persona_encryption_algorithm(
    const kc_persona_t* persona_ptr,
    tkc_encryption_scheme* out_value
)

int kc_persona_name(
    const kc_persona_t* persona_ptr,
    char** out_name,
    unsigned int* out_size
)

char* name = NULL;
unsigned int name_size = 0;
int result = kc_persona_name(persona, &name, &name_size);
if (result == 0) {
    printf("Persona name: %.*s\n", name_size, name);
    kc_common_delete_buffer(&name);
}

int kc_persona_subname(
    const kc_persona_t* persona_ptr,
    char** out_subname,
    unsigned int* out_size
)

int kc_persona_did(
    const kc_persona_t* persona_ptr,
    kc_persona_did_t** out_did_ptr
)

kc_persona_did_t* persona_did = NULL;
int result = kc_persona_did(persona, &persona_did);
if (result == 0) {
    // Use the persona DID...
    kc_persona_did_destruct(&persona_did);
}

int kc_persona_keychain(
    const kc_persona_t* persona_ptr,
    kc_keychain_element_t*** out_keychain_link_array,
    unsigned int* out_array_size,
    const unsigned int keychain_type
)

int kc_persona_encrypt(
    kc_persona_t* persona,
    kc_encrypted_data_t** out_encrypted_data,
    const kc_serialized_data_t* cleartext,
    const kc_contact_t** contact_array,
    const unsigned int contact_array_size
)

kc_serialized_data_t* plaintext = NULL;
kc_encrypted_data_t* encrypted = NULL;
kc_contact_t* recipient = NULL;

// Create serialized data and get recipient contact...

const kc_contact_t* recipients[] = {recipient};
int result = kc_persona_encrypt(persona, &encrypted, plaintext,
                               recipients, 1);
if (result == 0) {
    printf("Data encrypted successfully\n");
    kc_encrypted_data_destruct(&encrypted);
}

int kc_persona_decrypt(
    kc_persona_t* persona,
    kc_serialized_data_t** out_cleartext,
    const kc_encrypted_data_t* ciphertext
)

int kc_persona_sign(
    kc_persona_t* persona,
    kc_verifiable_data_t** out_signed_data,
    const kc_serialized_data_t* cleartext,
    const bool is_approval,
    const kc_tag_set_t* tags,
    const kc_tag_set_t* vars
)

kc_verifiable_data_t* signed_data = NULL;
kc_serialized_data_t* document = NULL;

// Create document...

int result = kc_persona_sign(persona, &signed_data, document,
                            false, NULL, NULL);
if (result == 0) {
    printf("Document signed successfully\n");
    kc_verifiable_data_destruct(&signed_data);
}

int kc_persona_create_credential(
    kc_persona_t* persona,
    kc_credential_t** out_signed_credential,
    const char* id,
    const unsigned int id_size,
    const char* cred_type,
    const unsigned int cred_type_size,
    const char* subject_id,
    const unsigned int subject_id_size,
    const uint64_t start_timestamp,
    const uint64_t end_timestamp,
    const kc_tag_set_t* claims,
    const kc_tag_set_t* tags,
    const kc_tag_set_t* vars
)

kc_credential_t* credential = NULL;
const char* cred_id = "credential-12345";
const char* cred_type = "IdentityCredential";
const char* subject = "did:example:alice";

// Create credential valid for 1 year
uint64_t now = time(NULL) * 1000; // Convert to milliseconds
uint64_t one_year = now + (365 * 24 * 60 * 60 * 1000ULL);

int result = kc_persona_create_credential(persona, &credential,
    cred_id, strlen(cred_id),
    cred_type, strlen(cred_type),
    subject, strlen(subject),
    now, one_year,
    NULL, NULL, NULL);

if (result == 0) {
    printf("Credential created successfully\n");
    kc_credential_destruct(&credential);
}