Developers — Yoalto

~/yoalto — zshdevnet

#build the CLI from source

$go build -o yoalto ./apps/cli

$./yoalto version --rpc http://localhost:3000/rpc/v1

#a keystore is an identity; the identity fixes the partition

$./yoalto key generate --out dev.key

$./yoalto key show --key dev.key

~claim 0x9f3c…a71d

~partition 0x2d

#read the account, then anchor a file and check the proof

$./yoalto account --key dev.key

$./yoalto attest invoice.pdf --key dev.key

$./yoalto prove invoice.pdf --issuer 0x9f3c…a71d

~✓ proof verified locally

~→ the proof is checked client-side; the node is not trusted

main.gogo · libs/sdk

package main

import (
    "context"
    "log"

    "github.com/yoalto-rnd/yoalto/libs/sdk/pkg/api"
    "github.com/yoalto-rnd/yoalto/libs/sdk/pkg/yoalto"
)

func main() {
    ctx := context.Background()

    conn, closer, err := api.Dial(ctx, "http://localhost:3000/rpc/v1", "")
    if err != nil {
        log.Fatal(err)
    }
    defer closer()

    c := &yoalto.Client{API: conn}

    // Fetches the proof over JSON-RPC, then verifies it locally.
    // A lying node fails the check rather than the check trusting it.
    found, verified, _, err := c.ProveFile(ctx, "invoice.pdf", issuer, pid)
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("found=%v verified=%v", found, verified)
}

There is no installer and no release binary yet — no curl | sh, no package manager. You build from source, and the source is not public yet either. If that is a blocker for you, it is worth telling us.

SDKs

One language, honestly.

Language	Package	Status	Covers
Go	libs/sdk	Shipped	Account and key handling, tx build + sign, JSON-RPC client, local proof verification
TypeScript	—	Designed	Not started
Rust, Python, Swift, Kotlin	—	Designed	Not started

The Go SDK is the only client that exists. Everything else on this list is an intention, and is marked as one.

CLI reference

Seven commands.

yoalto key generateGenerate a keypair, optionally writing a keystore

yoalto key showShow the identity: pubkey, claim, partition

yoalto accountQuery an account — balance, nonce, tokens

yoalto attestHash a file (SHA-256) and record it on chain

yoalto proveProve a file is attested, verifying the proof locally

yoalto submitSubmit a raw BCS-encoded signed transaction

yoalto versionPrint the API service version

Global flags: --rpc (defaults to http://localhost:3000/rpc/v1), --key for a keystore, and --api-key when the server requires one.

JSON-RPC

One endpoint, HTTP or WebSocket.

Yoalto.VersionService version — also the liveness probe

Yoalto.GetAccountpartition, claim → balance, nonce, tokens

Yoalto.SubmitTransactionpartition, raw BCS hex → admission ack

Yoalto.GetStateProofpartition, tag, key → state proof

Yoalto.GetTxInclusionProofpartition, height, tx hash

Yoalto.GetAttestationProofByHashpartition, issuer, content hash

JSON-RPC 2.0 on /rpc/v1; WebSocket upgrades on the same path. Behind a body cap, optional API key, per-caller rate limit and a WS connection cap. /health is unauthenticated. Trading methods (GetOrderBook, SubscribeTrades) are present but the matching engine is not built.

What to build

What the action layer supports today.

Proof of existence

Hash a document, record it under your issuer, and let anyone verify it later without trusting your server or ours. Batched attestations share one hash-chain accumulator per partition.

Record anchoring

The first real integration does exactly this — a vehicle-service platform anchoring PDF hashes through the SDK, so a service record can be checked years later by someone who never trusted the workshop.

Tokens and NFTs

Fungible tokens with deploy, mint, burn, send and receive; NFT collections with mint, transfer and burn. Both run end-to-end across partitions.

NFT marketplace

Fixed-price listings, per-NFT offers and royalty enforcement, shipped end-to-end. Cancellation is two-step and completed by a node keeper.

Native payments

YOA send, receive and change, with a free quota of ten fee-less transactions per rolling hour before a fee is required.

Order-book trading

Action types, state structs and store signatures exist. The matching engine does not — this one is a schema you could build against, not a feature you can use.

Getting in touch.

Yoalto is pre‑mainnet and the repository is private, so there is no issue tracker to point you at yet and no community to join. That will change; until it does, this page will not invent one.

Source

github.com/yoalto-rnd/yoalto — private

Go monorepo · Apache-2.0 · not public yet