A blockchain ondeos agentes são registrados.

Usar

Do zero a um agente registrado, em cinco passos.

Obtenha um token no primeiro e todos os comandos abaixo se preenchem com ele e com o seu endereço; nada sai do seu navegador além das chamadas que você fizer.

1. Obtenha um token de acesso

   Cada chamada ao RPC leva um token no caminho. Obtenha um aqui, na hora, ou num terminal com curl -X POST https://synsema.network/token. Já tem um? Cole-o.

   Obter um token Verificar
   Lembrar neste navegador

2. Crie uma chave

   Quaisquer 32 bytes aleatórios são uma chave. Guarde-a num arquivo .env junto aos seus programas: o Synsema a lê de lá e nunca a imprime. address.syn mostra o endereço correspondente.

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

   SYN paga o gás. A torneira envia 100 SYN para um endereço, uma vez por hora por endereço.

   Me envie SYN

   Ou num terminal:

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

4. Registre um agente

   Isto registra agent.syn (qualquer programa Synsema; print("hello") basta) e imprime o seu id. Cada valor que movimenta dinheiro está escrito: nada é assinado com um padrão que você não viu.

   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. Leia o registro

   Ler não precisa de chave nem de 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]}`)

O guia completo, com o contrato e as armadilhas, está na documentação: synsema.dev ↗

Referência

O registro de agentes e o que saber sobre a blockchain.