Documentation

Signet is a verifiable developer career record built on Stellar/Soroban. A handle is bound to a wallet on-chain; the contracts that wallet has deployed and invoked become a public, citable history.

The trust model

Bindings live in the Identity Registry Soroban contract (packages/contracts/identity-registry). To claim a handle, the wallet owner authorizes the claim(handle, wallet) call — Soroban requires a valid signature from that wallet's key, so a binding can only be created by the key holder. No trusted oracle, no off-chain admin minting identities.

If the registry is ever replaced

The registry contract is immutable — the same property that stops anyone rewriting the rule above also means a defect in it cannot be patched. Recovery is a new contract, and because a binding can only be created by the wallet that signs for it, bindings do not move across by decree: you would re-claim your handle on the new registry with one signature. Your handle is held for your wallet during a grace period, so the move is not a race, and your profile and history — both derived from the wallet, not the registry entry — come back unchanged. The procedure is public in docs/CONTRACT_MIGRATION.md.

Reading a profile

Every profile lives at /p/{handle}. The on-chain operations shown are fetched from the public Stellar Horizon API, and each row links to its transaction on Stellar Expert for independent verification.

Reading a contract diagram

The Diagram tab on a contract page is a picture of a Soroban contract’s public interface, drawn from its compiled spec: which functions it exposes and which data types they take and return. Everything solid in it is declared by the contract. Anything dashed is observed: seen in transactions Signet indexed, never promised by the contract. The legend under each diagram lists exactly the shapes and lines it uses.

Nodes

Errors and events are not nodes. They relate to many functions at once, so they are listed in the docs tabs instead of adding lines here.

Lines

An argument merely named token or pool is never drawn as a relationship: only the types are.

Groups

Soroban contracts conventionally prefix related functions, for exampleadmin_ or pool_. The diagram clusters functions that share a prefix into a group, with the well-known lifecycle entrypoints (init, upgrade and the like) in their own. A contract with more than 25 functions starts with every group collapsed. Grouping is a reading aid based on naming, not something the language enforces.

When there is no diagram

A diagram is only drawn when it adds something. A contract whose functions use no types of their own, such as the registry, gets no diagram, because its docs already say everything a picture could. A contract with more than 60 nodes after grouping gets the function list with a note that it is too large to diagram usefully. Text never renders smaller than 12px: a wide diagram scrolls inside its own box instead of shrinking.

What is observed, and how far it reaches

Each of these says under it what it was built from: how many transactions, between which ledgers. Signet only sees calls made since it began indexing a contract, within the RPC’s retention window (about 7 days on testnet), and keeps a limited number per contract, so a quiet or new contract shows little, and that absence is not evidence.

What the diagram cannot show

Saving a diagram

Download SVG saves the interface diagram with the contract’s address, network and WASM hash printed under it;Download PNG saves the same at twice the size; the storage view has its own SVG download. Every diagram state is also a link: the URL keeps the search, the expanded groups, the activity range and a focused node.

Linking your deploy wallet

Claiming a handle binds it to the wallet that signs the claim — usually a browser wallet, which is rarely the keystore identity you run stellar contract deploy from. To make a profile a real career record you link that deploy wallet from a terminal:

npx @signet/cli link

The command proves control of the deploy key and associates it with your handle; the indexer then attributes every contract that wallet has deployed and invoked to your profile. This is the path from a claimed handle to an indexed profile — until a deploy wallet is linked, a claimed handle points at an address that has deployed nothing and the profile renders empty. Terminal linking is not live yet; the full sequence is specified in docs/CLI.md.

Run a contract locally

signet dev runs a deployed contract on your machine. It forks the contract's ledger state from a Soroban RPC, builds your crate, and on every change replays saved and real calls against the deployed code and your build, then reports what differs. Nothing runs on Signet's servers.

# once: write signet.dev.toml for the contract you deployed
signet dev init CASFJHI5PQSRWS7JV25CF7FOMRKIVBP3RXRP3E2GH2CV4BCAG7FUJRCN --path ./contract

# the loop: rebuild, replay on both versions, diff, on every save
signet dev CASFJHI5PQSRWS7JV25CF7FOMRKIVBP3RXRP3E2GH2CV4BCAG7FUJRCN --path ./contract

It needs the stellar CLI, Rust with the wasm32v1-none target, and the signet-simulator next to signet. The CLI is not on npm yet; docs/CLI.md covers building it, and docs/SANDBOX.md is the full guide, including --ci for pull requests.

API and SDK

The public, read-only API is documented in the API reference: every endpoint, its parameters and responses, with examples. Every endpoint is a plain GET; no key is needed:

curl -s https://your-deployment.example/api/v1/profiles/yourhandle/contracts?limit=10
# → { "data": [{ "address": "C…", "deployer": "G…", "deployedAt": "…", … }],
#     "meta": { "nextCursor": null, "total": 3, "truncated": false, … } }

Integrators can also read it through @signet/sdk:

import { SignetClient } from '@signet/sdk';

const signet = new SignetClient({ baseUrl: 'https://your-deployment.example' });
const profile = await signet.getProfile('yourhandle');
// → { handle, displayName, primaryWallet, wallets, counts, … }

Phases

How Signet works ↗