Skip to main content

Kotlin — raw HTTP today, native client planned

Native client status: PLANNED

There is no published Kotlin artifact yet — nothing on Maven Central, and no packages/sdk-kotlin/ directory exists in the repo. Today you get full parity through three real surfaces: the terminal CLI (/cli/), raw HTTP (the wire format below — what every client wraps), and zeq.py (Python — single file, fetched from any node). When a native client ships it will wrap exactly this wire format, so code written against HTTP today won't change semantically.

Get the CLI (recommended first install)

Every node serves the terminal CLI with a sha256-pinned installer — the fastest way onto the framework:

curl -fsSL https://zeqstate.com/install.sh | sh   # any node works as the origin
zeq tutorial   # guided: account → machine → first compute → verify

Full install notes + the complete command reference: /cli/.

Compute over raw HTTP — JDK stdlib only​

java.net.http.HttpClient from the JDK (11+), no third-party dependencies. Compile-ready:

import java.net.URI
import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse

fun main() {
    val body = """
        { "operators": ["KO42", "QM5", "GR40"],
          "domain":    "cross",
          "inputs":    { "t": 0 } }
    """.trimIndent()

    val req = HttpRequest.newBuilder()
        .uri(URI.create("https://zeqapi.com/api/zeq/compute"))
        .header("Authorization", "Bearer " + System.getenv("ZEQ_KEY"))
        .header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString(body))
        .build()

    val res = HttpClient.newHttpClient().send(req, HttpResponse.BodyHandlers.ofString())

    // Full envelope: value, unit, uncertainty, signed, compliance, zeqProof, explorer_url …
    println(res.body())
}

Parse with kotlinx.serialization, Jackson, or Moshi — the envelope is plain JSON. On Android, the same call works with OkHttp. The public pulse needs no key: GET https://zeqapi.com/api/zeq/pulse.

The response's compliance field is the ZeqCompliance v1 envelope — the 13-standard regulatory record returned on every call. Every result also carries signed — an Ed25519-signed claim (claim + signature + public_key) verifiable offline by anyone, or by POSTing the block to any node's public /api/attest. Or pipe the whole envelope to the CLI: … | zeq verify -.

Why Kotlin here​

  • Android apps. Wrap the call in a suspend function — one coroutine per compute, no callback hell.
  • Server-side Ktor or Spring. Drop the call into your service handler; the same envelope shape SOC 2 expects flows straight through.
  • Multiplatform projects. The wire contract is plain JSON over HTTPS — the same calls compile for JVM, Android, iOS (Kotlin/Native), and JS with each platform's HTTP client.

Compose with​

  • Java — the same JDK HttpClient call from any Java caller.
  • Hosted API reference — every route, body, response, error.
  • HTTP / curl — the full wire-format walkthrough (solve, multibody, attest).

Status & source​

  • Native Kotlin client: planned — pending the self-hosted package-registry decision; no coordinates are reserved.
  • The wire contract it will wrap is live today and documented in full at HTTP / curl and the API reference.