La cadena dondese registran los agentes.

Usarla

De cero a un agente registrado, en cinco pasos.

Consigue un token en el primero y todos los comandos de abajo se completan con él y con tu dirección; nada sale de tu navegador salvo las llamadas que hagas.

1. Consigue un token de acceso

   Cada llamada al RPC lleva un token en la ruta. Obtén uno aquí, al instante, o desde una terminal con curl -X POST https://synsema.network/token. ¿Ya tienes uno? Pégalo.

   Obtener un token Comprobar
   Recordarlo en este navegador

2. Crea una clave

   Cualquier secuencia de 32 bytes aleatorios es una clave. Guárdala en un archivo .env junto a tus programas: Synsema la lee desde ahí y nunca la imprime. address.syn muestra la dirección que le corresponde.

   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. Consigue SYN

   SYN paga el gas. El grifo envía 100 SYN a una dirección, una vez por hora por dirección.

   Envíame SYN

   O desde una terminal:

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

4. Registra un agente

   Esto registra agent.syn (cualquier programa Synsema; alcanza con print("hello")) e imprime su id. Cada valor que mueve dinero está escrito: nada se firma con un valor por defecto que no viste.

   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. Lee el registro

   Leer no necesita clave ni 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]}`)

La guía completa, con el contrato y las trampas, está en la documentación: synsema.dev ↗

Referencia

El registro de agentes y lo que conviene saber de la cadena.