Go SDK

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
    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",
            "degree_type":     "Bachelor of Science",
        },
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Attestation ID: %s\n", attestation.ID)

    // 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")
    }
}

package main

import (
    "context"
    "fmt"
    "log"

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

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

    ctx := context.Background()

    revoked, err := client.Attestations.Revoke(ctx,
        "660e8400-e29b-41d4-a716-446655440001",
        &truthlock.RevokeRequest{
            Reason: "Certificate holder no longer employed",
        },
    )
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Status: %s\n", revoked.Status)     // "REVOKED"
    fmt.Printf("Revoked at: %s\n", revoked.RevokedAt)

    // Subsequent verifications reflect the revocation
    result, err := client.Verify.VerifyOnline(ctx, &truthlock.VerifyRequest{
        AttestationID: "660e8400-e29b-41d4-a716-446655440001",
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Verdict: %s\n", result.Verdict) // "REVOKED"
}

package main

import (
    "context"
    "encoding/base64"
    "encoding/json"
    "fmt"
    "log"

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

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

    ctx := context.Background()

    // Supersede an attestation with updated claims
    updatedClaims, _ := json.Marshal(map[string]string{
        "student_name": "Jane Doe",
        "degree_type":  "Master of Science", // Updated from Bachelor to Master
    })
    payloadB64 := base64.RawURLEncoding.EncodeToString(updatedClaims)

    result, err := client.Attestations.Supersede(ctx,
        "660e8400-e29b-41d4-a716-446655440001", // Original attestation ID
        &truthlock.SupersedeRequest{
            PayloadB64URL: payloadB64,
        },
    )
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Old attestation status: %s\n", result.Old.Status) // "SUPERSEDED"
    fmt.Printf("New attestation ID: %s\n", result.New.ID)
}

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

        // Check for specific error types
        if tlErr.IsCode("RATE_LIMITED") {
            // Already retried MaxRetries times — back off at the application level
        }
        if tlErr.NotFoundError() {
            // Resource does not exist — do not retry
        }
    }
    return err
}

package main

import (
	"context"
	"fmt"
	"log"

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

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

	// Query recent attestation events
	events, err := client.Audit.Query(ctx, map[string]string{
		"action": "attestation.mint",
		"from":   "2026-01-01T00:00:00Z",
		"to":     "2026-01-31T23:59:59Z",
		"limit":  "100",
	})
	if err != nil {
		log.Fatal(err)
	}

	for _, event := range events {
		fmt.Printf("[%s] %s by %s\n", event.Timestamp, event.Action, event.ActorID)
	}

	// Export audit logs for compliance
	exportJob, err := client.Audit.Export(ctx, &truthlock.AuditExportRequest{
		StartDate: "2026-01-01",
		EndDate:   "2026-01-31",
		Format:    "csv",
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Export started: %s (status: %s)\n", exportJob.ID, exportJob.Status)
}

package main

import (
	"context"
	"fmt"
	"log"

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

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

	// Create a governance request to suspend an issuer
	req, err := client.Governance.CreateRequest(ctx, &truthlock.GovernanceRequest{
		Action:   "suspend",
		IssuerID: "issuer-uuid",
		Reason:   "Compliance review pending",
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Request created: %s (status: %s)\n", req.ID, req.Status)

	// Another authorized user approves the request
	if _, err := client.Governance.ApproveRequest(ctx, req.ID); err != nil {
		log.Fatal(err)
	}

	// Execute the approved request
	result, err := client.Governance.ExecuteRequest(ctx, req.ID)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Executed: %s — issuer is now %s\n", result.ID, result.IssuerStatus)

	// List all governance requests
	requests, err := client.Governance.ListRequests(ctx)
	if err != nil {
		log.Fatal(err)
	}
	for _, r := range requests {
		fmt.Printf("[%s] %s %s — %s\n", r.Status, r.Action, r.IssuerID, r.Reason)
	}
}

package main

import (
	"context"
	"fmt"
	"log"

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

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

	// Mint a payment receipt
	receipt, err := client.Receipts.Mint(ctx, &truthlock.MintReceiptRequest{
		IssuerID:    "your-issuer-id",
		KID:         "ed-key-2026",
		Alg:         "Ed25519",
		ReceiptType: "payment_receipt",
		Subject:     "customer@example.com",
		Payload: map[string]interface{}{
			"amount":             5000,
			"currency":           "USD",
			"provider":           "stripe",
			"provider_reference": "ch_3Px...",
		},
	})
	if err != nil {
		log.Fatal(err)
	}

	// Verify a receipt
	result, err := client.Receipts.Verify(ctx, receipt.ReceiptID)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Verdict: %s\n", result.Verdict) // "VALID"

	// Download a proof bundle for offline verification
	bundle, err := client.Receipts.GetProofBundle(ctx, receipt.ReceiptID)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Bundle version: %s\n", bundle["bundle_version"])

	// Search receipts
	results, err := client.Receipts.Search(ctx, &truthlock.SearchReceiptsQuery{
		Q:           "stripe",
		ReceiptType: "payment_receipt",
		FromDate:    "2026-01-01T00:00:00Z",
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Found %d receipts\n", len(results.Items))

	// Export receipts as JSON
	exportJob, err := client.Receipts.Export(ctx, &truthlock.CreateExportRequest{
		Format:  "json",
		Filters: map[string]interface{}{"receipt_type": "payment_receipt"},
	})
	if err != nil {
		log.Fatal(err)
	}

	// Poll for completion
	completed, err := client.Receipts.GetExport(ctx, exportJob.ID)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Export status: %s\n", completed.Status)

	// Redact PII from a receipt (permanent, for GDPR erasure requests)
	_, err = client.Receipts.Redact(ctx, receipt.ReceiptID)
	if err != nil {
		log.Fatal(err)
	}
}