The chain whereagents are registered.

Use it

From nothing to a registered agent, in five steps.

Get a token in the first one and every command below fills in with it and with your address; nothing leaves your browser except the calls you make.

1. Get an access token

   Every call to the RPC carries a token in its path. Get one here, instantly, or from a terminal with curl -X POST https://synsema.network/token. Already have one? Paste it.

   Get a token Check
   Remember it in this browser

2. Create a key

   Any 32 random bytes are a key. Keep it in a .env file next to your programs: Synsema reads it from there and never prints it. address.syn shows the address that goes with it.

   openssl rand -hex 32

   .env

   L1_RPC={{RPC}}
   MY_KEY=the-64-hex-characters-from-openssl

   address.syn

   require secret("MY_KEY")
   print(eth_address(secret("MY_KEY")))

   synsema run address.syn

3. Get SYN

   SYN pays for gas. The faucet sends 100 SYN to an address, once an hour per address.

   Send me SYN

   From a terminal instead:

   curl -X POST {{BASE}}/faucet -H 'content-type: application/json' \
     -d '{"address": "{{ADDR}}"}'

4. Register an agent

   This registers agent.syn (any Synsema program; print("hello") is enough) and prints its id. Every value that moves money is written out: nothing is signed with a default you didn't see.

   register.syn

   -- synsema run register.syn
   require env("L1_RPC")
   require secret("MY_KEY")
   require sign("MY_KEY")
   require net("synsema.network")
   require file.read("agent.syn")
   
   let url be env("L1_RPC")
   let registry be "{{REGISTRY}}"
   let k be secret("MY_KEY")
   let me be eth_address(k)
   
   -- the record: program, capabilities, environment, agent card
   let program_hash be sha256(read_file("agent.syn"))
   let caps_hash be sha256('["net"]')
   let measurement be int_to_bytes(0, 32)
   let uri be "https://example.org/.well-known/agent-card.json"
   let data be abi_encode("register(bytes32,bytes32,bytes32,string)", [program_hash, caps_hash, measurement, uri])
   
   -- build, sign, send, wait
   let fees be eth_fee_history(url)
   let tx be tx_eip1559({"chain_id": 7960, "nonce": eth_nonce(url, me), "to": registry, "value": 0,
       "gas": eth_estimate_gas(url, {"from": me, "to": registry, "data": data}) * 2,
       "max_fee": fees["base_fee"] * 2 + fees["priority"], "max_priority": fees["priority"], "data": data})
   let hash be eth_send_raw(url, tx_eip1559_raw(tx, secp256k1_sign(tx["digest"], k)))
   let receipt be eth_wait_receipt(url, hash, 1, 60)
   assert(receipt != nothing and receipt["status"] == 1, "the registration did not go through")
   
   let n be abi_decode("uint256", eth_call(url, {"to": registry, "data": abi_encode("count()", [])}))[0]
   print(`registered as agent {n - 1}, tx {hash}`)

5. Read the registry

   Reading needs no key and no SYN.

   Synsema Foundry curl

   require env("L1_RPC")
   require net("synsema.network")
   
   let url be env("L1_RPC")
   let registry be "{{REGISTRY}}"
   task call(sig, args)
       give eth_call(url, {"to": registry, "data": abi_encode(sig, args)})
   
   let n be abi_decode("uint256", call("count()", []))[0]
   print(`{n} agents on chain {eth_chain_id(url)}`)
   let a be abi_decode("(address,bytes32,bytes32,bytes32,string,uint64)", call("get(uint256)", [0]))
   print(`agent 0: controller {a[0]}, card {a[4]}`)

The whole guide, with the contract and the gotchas, is in the documentation: synsema.dev ↗

Reference

The agent registry and what to know about the chain.