From event digest to verifiable credential,
integrate Gnomon with APIs and SDKs

import { GnomonClient, fromHex } from '@gnomon/sdk';

const client = new GnomonClient({
  endpoint: 'https://<your-node-base-url>',
  apiKey: 'your-api-key',
  originFingerprint: '<origin from /healthz>',
});

const health = await client.healthz();
const deployerClaim = await client.createClaimAnchor({
  entityFingerprint: '11'.repeat(32),
  attributeType: 0x0201,
  attributeHash: '22'.repeat(32),
  subjectPublicKey: new Uint8Array(32).fill(0x33),
  subjectPrivateKey: new Uint8Array(32).fill(0x44),
  issuerPublicKey: new Uint8Array(32).fill(0x55),
  issuerPrivateKey: new Uint8Array(32).fill(0x66),
});
const agentClaim = await client.createClaimAnchor({
  entityFingerprint: '77'.repeat(32),
  attributeType: 0x0301,
  attributeHash: '88'.repeat(32),
  subjectPublicKey: new Uint8Array(32).fill(0x99),
  subjectPrivateKey: new Uint8Array(32).fill(0xaa),
  issuerPublicKey: new Uint8Array(32).fill(0xbb),
  issuerPrivateKey: new Uint8Array(32).fill(0xcc),
});
const grant = await client.createGrantAnchor({
  grantorClaimRef: deployerClaim.anchor.anchorId,
  granteeClaimRef: agentClaim.anchor.anchorId,
  scopeHash: 'dd'.repeat(32),
  delegationDepth: 0,
  grantorPublicKey: new Uint8Array(32).fill(0xee),
  grantorPrivateKey: new Uint8Array(32).fill(0xff),
  witnessPublicKey: new Uint8Array(32).fill(0x10),
  witnessPrivateKey: new Uint8Array(32).fill(0x20),
});
const hash = new Uint8Array(32).fill(0xaa);
const created = await client.createEventAnchor(hash, {
  semanticAnchor: {
    irisRef: agentClaim.anchor.anchorId,
    grantRef: grant.anchor.anchorId,
    eventDataHash: hash,
  },
  clientEventId: 'evt-001',
});

use gnomon_sdk::GnomonClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = GnomonClient::builder()
        .endpoint("https://<your-node-base-url>")
        .api_key("your-api-key")
        .origin_fingerprint([0x01u8; 32])
        .build()?;

    let health = client.healthz().await?;
    println!("{} {:?}", health.status, health.origin_fingerprint);
    let deployer_claim = client.create_claim_anchor(
        &gnomon_types::EntityFingerprint([0x11; 32]),
        0x0201,
        [0x22; 32],
        &[0x33; 32],
        &[0x44; 32],
        &[0x55; 32],
        &[0x66; 32],
        gnomon_sdk::CreateClaimAnchorOptions::default(),
    ).await?;
    let agent_claim = client.create_claim_anchor(
        &gnomon_types::EntityFingerprint([0x77; 32]),
        0x0301,
        [0x88; 32],
        &[0x99; 32],
        &[0xaa; 32],
        &[0xbb; 32],
        &[0xcc; 32],
        gnomon_sdk::CreateClaimAnchorOptions::default(),
    ).await?;
    let grant = client.create_grant_anchor(
        &deployer_claim.anchor.anchor_id,
        &agent_claim.anchor.anchor_id,
        [0xdd; 32],
        0,
        &[0xee; 32],
        &[0xff; 32],
        &[0x10; 32],
        &[0x20; 32],
        gnomon_sdk::CreateGrantAnchorOptions::default(),
    ).await?;
    let hash = [0xAAu8; 32];
    let created = client.create_event_anchor_with_options(
        hash,
        gnomon_sdk::CreateAnchorOptions {
            semantic_anchor_refs: Some(gnomon_core::SemanticAnchorRefs {
                iris_ref: agent_claim.anchor.anchor_id,
                scroll_ref: gnomon_types::AnchorId::default(),
                grant_ref: grant.anchor.anchor_id,
                bond_ref: gnomon_types::AnchorId::default(),
                yield_ref: gnomon_types::AnchorId::default(),
                event_data_hash: hash,
            }),
            ..gnomon_sdk::CreateAnchorOptions::default()
        }
    ).await?;
    Ok(())
}