Go SDK

go get github.com/truthlocks/sdk-go@latest

package main

import (
    "context"
    "fmt"
    "log"

    truthlock "github.com/truthlocks/sdk-go"
)

func main() {
    // 1. Create client
    client := truthlock.NewClient(truthlock.Config{
        BaseURL:  "https://api.truthlocks.com",
        TenantID: "your-tenant-id",
        APIKey:   "tl_live_...",
    })

    ctx := context.Background()

    // 2. Create and trust an issuer
    issuer, err := client.Issuers.Create(ctx, &truthlock.CreateIssuerRequest{
        Name:        "My Organization",
        LegalName:   "My Organization Inc.",
        DisplayName: "My Org",
    })
    if err != nil {
        log.Fatal(err)
    }

    if _, err := client.Issuers.Trust(ctx, issuer.ID); err != nil {
        log.Fatal(err)
    }

    // 3. Register a signing key
    _, err = client.Keys.Register(ctx, issuer.ID, &truthlock.RegisterKeyRequest{
        KID:          "key-2026",
        Alg:          truthlock.AlgEd25519,
        PublicKeyB64: "your-public-key-base64url",
    })
    if err != nil {
        log.Fatal(err)
    }

    // 4. Mint an attestation (with optional email delivery)
    attestation, err := client.Attestations.Mint(ctx, &truthlock.MintRequest{
        IssuerID: issuer.ID,
        KID:      "key-2026",
        Alg:      truthlock.AlgEd25519,
        Schema:   "degree",
        Claims: map[string]interface{}{
            "student_name":    "Jane Doe",
            "institution":     "State University",
            "degree_type":     "Bachelor of Science",
            "field_of_study":  "Computer Science",
            "graduation_date": "2026-05-15",
        },
        RecipientEmail: "jane.doe@example.com", // optional
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Attestation ID: %s\n", attestation.ID)
    fmt.Printf("Log index: %d\n", attestation.LogIndex)

    // 5. Verify
    result, err := client.Verify.VerifyOnline(ctx, &truthlock.VerifyRequest{
        AttestationID: attestation.ID,
    })
    if err != nil {
        log.Fatal(err)
    }

    if result.Verdict == truthlock.VerdictValid {
        fmt.Println("Attestation verified successfully")
    }
}

client := truthlock.NewClient(truthlock.Config{
    // Required
    BaseURL:  "https://api.truthlocks.com",  // API base URL
    TenantID: "your-tenant-id",              // From Console > Settings
    APIKey:   "tl_live_...",                 // From Console > API Keys

    // Optional
    Timeout:    30 * time.Second,  // Request timeout (default: 30s)
    MaxRetries: 3,                 // Auto-retry with backoff (default: 3)
    HTTPClient: &http.Client{},    // Custom HTTP client
})

Issuers

Keys

Attestations

Verification

API Keys

Audit

Governance

attestation, err := client.Attestations.Mint(ctx, req)
if err != nil {
    var tlErr *truthlock.Error
    if errors.As(err, &tlErr) {
        fmt.Printf("Code:    %s\n", tlErr.Code)    // e.g. "ISSUER_NOT_TRUSTED"
        fmt.Printf("Message: %s\n", tlErr.Message) // Human-readable
        fmt.Printf("Status:  %d\n", tlErr.Status)  // HTTP status code

        switch tlErr.Code {
        case truthlock.ErrIssuerNotTrusted:
            // Issuer needs to be trusted before minting
        case truthlock.ErrKeyNotFound:
            // Signing key not registered
        case truthlock.ErrQuotaExceeded:
            // Plan limit reached
        }
    }
    return err
}

func mintBatch(ctx context.Context, client *truthlock.Client, employees []Employee) error {
    var errs []error
    for _, emp := range employees {
        _, err := client.Attestations.Mint(ctx, &truthlock.MintRequest{
            IssuerID: issuerId,
            KID:      "key-2026",
            Alg:      truthlock.AlgEd25519,
            Schema:   "employment-verification",
            Claims: map[string]interface{}{
                "employee_name":   emp.Name,
                "employer":        "Acme Corp",
                "position":        emp.Title,
                "department":      emp.Dept,
                "employment_type": "Full-time",
                "start_date":      emp.StartDate,
            },
            RecipientEmail: emp.Email,
        })
        if err != nil {
            errs = append(errs, fmt.Errorf("mint %s: %w", emp.Name, err))
            continue
        }
    }
    return errors.Join(errs...)
}

// Per-operation timeout (overrides client default)
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()

result, err := client.Verify.VerifyOnline(ctx, &truthlock.VerifyRequest{
    AttestationID: attestationID,
})
if err != nil {
    if errors.Is(err, context.DeadlineExceeded) {
        log.Println("Verification timed out")
    }
    return err
}

// Use a custom HTTP client for corporate proxy or mutual TLS
client := truthlock.NewClient(truthlock.Config{
    BaseURL:  "https://api.truthlocks.com",
    TenantID: "your-tenant-id",
    APIKey:   "tl_live_...",
    HTTPClient: &http.Client{
        Transport: &http.Transport{
            Proxy: http.ProxyFromEnvironment,
            TLSClientConfig: &tls.Config{
                Certificates: []tls.Certificate{clientCert},
            },
        },
    },
})