Blockchain: la wallet que el agente usa pero no puede robar

Operá on-chain — leer estado, construir, firmar, difundir y confirmar transacciones — sin que la clave privada se materialice jamás en texto ni se filtre a un LLM. La complejidad (curvas, RLP, checksums, hex-quantities, polling de receipts) la absorbe el lenguaje; lo que escribís es obvio y seguro por construcción.

El diferencial es firmar/custodiar con seguridad estructural que no se puede desactivar: la clave es un secret, firmar es deny-by-default y auditado, y mover fondos pasa por un gate humano. Y el loop está completo: el lado de lectura (nonce, fees, saldos, estado de contratos, receipts) también sale del lenguaje — gateado por la misma capability net(host) que HTTP, con cero puertas de permiso nuevas. Sólo firmar mueve valor: un agente con net pero sin sign puede monitorear todo y no gastar nada.

-- Doc example: sign an Ethereum transaction without the private key ever
-- materializing. The key is a `secret`; signing is deny-by-default (`require sign`)
-- and audited. Derivation/verification are pure. No network — this is the offline
-- signing core; broadcast is a plain http_post to your RPC.
intent: "doc example: blockchain signing"
require sign("HOT_KEY")

test "an ETH address is derived from the key, and ecrecover closes the circuit"
    -- The key arrives sealed as a secret (from .env in real programs). It never
    -- turns into a plain string — text(k) is redacted.
    let k be as_secret("0000000000000000000000000000000000000000000000000000000000000001", "HOT_KEY")
    assert_eq(text(k), "secret(HOT_KEY)")

    -- Address is public: deriving it does NOT expose the private key.
    assert_eq(eth_address(k), "0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf")

    -- Build an EIP-1559 signing payload: 0x02 || rlp([chainId, nonce, ...]).
    let to_addr be bytes("5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed", "hex")
    let fields be [1, 9, 1000000000, 30000000000, 21000, to_addr, 1000000000000000, bytes([]), []]
    let digest be keccak256(bytes([2]) + rlp_encode(fields))

    -- Sign it (deny-by-default: needs `require sign("HOT_KEY")`). Deterministic
    -- (RFC 6979): the same (key, digest) always yields the same signature.
    let sig be secp256k1_sign(digest, k)
    assert_eq(length(sig), 65)
    assert_eq(sig, secp256k1_sign(digest, k))

    -- ecrecover: the recovered public key yields the SAME address.
    let pub be secp256k1_recover(digest, sig)
    assert_eq(eth_address(pub), "0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf")

    -- Assemble the signed raw tx, ready to broadcast: 0x02 || rlp(fields + [v, r, s]).
    -- r/s go in as INTEGERS (minimal RLP, no leading zeros), never as 32-byte blobs —
    -- bytes_to_int is the exact bridge (256 bits, no float involved).
    let v be sig[64]
    let r be bytes_to_int(slice(sig, 0, 32))
    let s be bytes_to_int(slice(sig, 32, 64))
    let raw be bytes([2]) + rlp_encode(fields + [v, r, s])
    assert_eq(raw[0], 2)
    assert_eq(length(rlp_decode(slice(raw, 1, length(raw)))), 12)
    -- int_to_bytes(n, 32) restores the fixed width (closes the r round-trip)
    assert_eq(int_to_bytes(r, 32), slice(sig, 0, 32))

test "ed25519 (Solana/Algorand) signs the RAW message — never a pre-hash"
    let k be as_secret("0000000000000000000000000000000000000000000000000000000000000001", "HOT_KEY")
    let sig be ed25519_sign("transfer 10", k)
    let pk be ed25519_pubkey(k)
    assert(ed25519_verify("transfer 10", sig, pk))

test "the dApp world: ABI calldata, SIWE (EIP-191) and a permit (EIP-712)"
    let k be as_secret("0000000000000000000000000000000000000000000000000000000000000001", "HOT_KEY")
    -- Contract calldata: canonical signature (no spaces), exact big integers.
    let data be abi_encode("transfer(address,uint256)", ["0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf", 1000000000000000000000000])
    assert_eq(decode(slice(data, 0, 4), "hex"), "a9059cbb")
    -- Read calldata back — audit what you are about to sign.
    let args be abi_decode("(address,uint256)", slice(data, 4, length(data)))
    assert_eq(args[1], 1000000000000000000000000)
    -- SIWE login: digest → gated signature → the backend recovers the address.
    let d191 be eip191_digest("app.example.com wants you to sign in")
    let quien be eth_address(secp256k1_recover(d191, secp256k1_sign(d191, k)))
    assert_eq(quien, "0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf")
    -- EIP-712 permit: the typed data is a READABLE map (show it before signing).
    let domain be {"name": "USD Coin", "version": "2", "chainId": 1, "verifyingContract": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"}
    let types be {"Permit": [{"name": "owner", "type": "address"}, {"name": "spender", "type": "address"},
        {"name": "value", "type": "uint256"}, {"name": "nonce", "type": "uint256"}, {"name": "deadline", "type": "uint256"}]}
    let permit be {"owner": quien, "spender": "0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed",
        "value": 1000000, "nonce": 0, "deadline": 1893456000}
    let d712 be eip712_digest(domain, types, "Permit", permit)
    let sig be secp256k1_sign(d712, k)
    assert_eq(eth_address(secp256k1_recover(d712, sig)), quien)

test "Solana and Algorand are transactable: message/tx bytes come out ready"
    let k be as_secret("0000000000000000000000000000000000000000000000000000000000000001", "HOT_KEY")
    let payer be ed25519_pubkey(k)
    -- Solana System transfer: data is u32 LE 2 ‖ u64 LE lamports (int_to_bytes_le).
    let msg be solana_message({
        "fee_payer": payer,
        "recent_blockhash": payer,
        "instructions": [{
            "program": "11111111111111111111111111111111",
            "accounts": [{"pubkey": payer, "signer": true, "writable": true}],
            "data": int_to_bytes_le(2, 4) + int_to_bytes_le(1000000, 8)}]})
    let tx be solana_tx(msg, ed25519_sign(msg, k))
    -- broadcast (userland): decode(tx, "base64") → sendTransaction via http_post
    assert(length(decode(tx, "base64")) > 0)
    -- Algorand pay: protocol short keys; canonical msgpack (zero fields omitted).
    let txn be {"type": "pay", "snd": algo_address(k), "rcv": payer,
        "amt": 123456, "fee": 1000, "fv": 1000, "lv": 2000,
        "gh": bytes("0707070707070707070707070707070707070707070707070707070707070707", "hex")}
    let listo be algorand_tx_encode(txn)
    let stx be algorand_tx(txn, ed25519_sign(listo, k))
    assert(length(stx) > length(listo))

test "read side builders: tx_eip1559 assembles the exact SDK bytes (no hand-rolled RLP)"
    -- Vector from eth-account (the Ethereum Foundation SDK): same key+digest →
    -- same deterministic RFC 6979 signature → the raw tx matches byte-for-byte.
    let k be as_secret("1ab42cc412b618bdea3a599e3c9bae199ebf030895b039e9db1e30dafb12b727", "HOT_KEY")
    let tx be tx_eip1559({"chain_id": 1, "nonce": 7,
        "to": "0x6Fac4D18c912343BF86fa7049364Dd4E424Ab9C0",
        "value": 100000000000000000, "gas": 21000,
        "max_fee": 30000000000, "max_priority": 1500000000})
    -- every value-moving number is echoed back — `confirm` them BEFORE signing
    assert_eq(tx["max_fee"], 30000000000)
    assert_eq(tx["to"], "0x6Fac4D18c912343BF86fa7049364Dd4E424Ab9C0")
    let sig be secp256k1_sign(tx["digest"], k)
    let raw be tx_eip1559_raw(tx, sig)
    assert_eq(decode(raw, "hex"), "02f87301078459682f008506fc23ac00825208946fac4d18c912343bf86fa7049364dd4e424ab9c088016345785d8a000080c080a054afb059cc17c8b3726db836c4d9093aaabfb6d422c9c190ae8e9c561e285fffa03f3c2eb5d5b609d2544817eb1ce8a4e64dfc8d4dbbc9db06f5ce2f2352b13f41")
    -- the tx hash is keccak256 of the signed raw (matches the SDK's too)
    assert_eq(decode(keccak256(raw), "hex"), "6fb18223cd52476122a18a2b59a6c9faca40b36937217962a4f81b0da1c79880")

test "no fee is ever invented: a missing max_fee errors naming the reader"
    let failed be ""
    try
        let tx be tx_eip1559({"chain_id": 1, "nonce": 0,
            "to": "0x6Fac4D18c912343BF86fa7049364Dd4E424Ab9C0",
            "value": 0, "gas": 21000, "max_priority": 1})
    recover e
        set failed to e
    assert(contains(failed, "max_fee"))
    assert(contains(failed, "eth_fee_history"))

test "the read side is net-gated: without `require net` it denies, catchable"
    let failed be ""
    try
        let n be eth_chain_id("http://127.0.0.1:1")
    recover e
        set failed to e
    assert(contains(failed, "net"))

test "Solana SPL tokens: PDAs and instruction data are pure (no key, no gate)"
    -- An SPL TransferChecked instruction's data: tag 12 ‖ amount u64 LE ‖ decimals.
    assert_eq(decode(spl_transfer_checked_data(1000000, 6), "hex"), "0c40420f000000000006")
    -- The associated token account (ATA) is a PDA — derived, off-curve, byte-exact
    -- against the SPL SDK (owner and mint here are 32-byte test pubkeys).
    let owner be bytes("0202020202020202020202020202020202020202020202020202020202020202", "hex")
    let mint be bytes("0303030303030303030303030303030303030303030303030303030303030303", "hex")
    assert_eq(decode(spl_ata(owner, mint), "hex"),
        "9958db38c3bb8bf04f6da81d59d3e34f7e17de3ec94b885e2d79050e75ff3f6e")
    -- solana_pda(seeds, program) returns {address, bump}; the address is off-curve.
    let pda be solana_pda(["metadata", owner], "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA")
    assert_eq(length(pda["address"]), 32)

El modelo de seguridad (por qué esto es distinto)

• La clave nunca se materializa. No hay builtin que devuelva una clave privada. Pasás un secret (del .env, o sellado en runtime con as_secret); se consume del lado Rust para firmar y se borra de memoria. text(k) / json_encode / una línea de log muestran secret(NOMBRE), jamás el valor.
• Firmar es gateado + auditado. secp256k1_sign / ed25519_sign exigen require sign("NOMBRE_CLAVE") (con scope al name del secret de la clave) y escriben una entrada de audit persistente (curva, timestamp, programa, file:line — nunca la clave). Sin la capability → el mismo error deny-by-default que cualquier otra. Dentro de un sandbox (capabilities vaciadas) → firmar está denegado aunque tengas la clave en mano. Todo lo demás — hashear, codificar, verificar, derivar la pubkey/dirección — es puro. El host puede además limitar cuántas firmas hace cada clave por proceso: SYNSEMA_SIGN_CEILING="HOT_KEY:100" (pares clave:cantidad separados por comas) — la firma N+1 falla con error catchable y una entrada denied_by=ceiling en sign.log; sin la variable, el comportamiento no cambia.
• Crear custodia también es gateado + auditado. Generar o importar material de clave (mnemonic_generate, hd_derive, keystore_import, …) exige require wallet — una capability deny-by-default distinta de sign (crear una clave ≠ gastar con ella), auditada en wallet.log, denegada en sandbox. Todo builtin de custodia devuelve un secret; el mnemónico/seed/clave nunca se vuelve un valor plano.
• Determinista y anti-malleabilidad. secp256k1 usa RFC 6979 (nonce determinista — sin la catástrofe de reuso de nonce) y emite firmas low-s. ed25519 es determinista por RFC 8032.

Qué te da el lenguaje

El lado de lectura: cerrar el loop sin hand-rollear JSON-RPC

Antes de esto, un agente firmaba transacciones byte-perfectas pero tenía que hand-rollear

JSON-RPC sobre http_post para leer el nonce, los fees EIP-1559, el chain id o el

recent_blockhash — codificando hex-quantities a mano y decodificando resultados a la

defensiva. Ahí es exactamente donde mueren los tokens y la corrección, así que el lenguaje

lo absorbió:

require net("rpc.example.com")
require sign("HOT_KEY")

let url be "https://rpc.example.com"
let k be secret("HOT_KEY")
-- LEER lo que la tx necesita
let nonce be eth_nonce(url, eth_address(k))       -- eth_getTransactionCount ("pending")
let fees be eth_fee_history(url)                  -- {base_fee, priority, base_fees, rewards}
-- CONSTRUIR: cada campo que mueve valor es explícito (uno faltante errora nombrando el lector)
let tx be tx_eip1559({"chain_id": eth_chain_id(url), "nonce": nonce, "to": destino,
    "value": 100000000000000000, "gas": 21000,
    "max_fee": fees["base_fee"] * 2, "max_priority": fees["priority"]})
-- tx ecoa los números (tx["max_fee"], tx["value"], tx["to"]) — pasalos por `confirm` ANTES de firmar
let sig be secp256k1_sign(tx["digest"], k)        -- la ÚNICA puerta gateada
let raw be tx_eip1559_raw(tx, sig)                -- v/r/s ensamblados por vos
-- ENVIAR y CONFIRMAR
let hash be eth_send_raw(url, raw)                -- tx hash "0x…"
let receipt be eth_wait_receipt(url, hash, 1, 120)  -- nothing al vencer — jamás cuelga
-- receipt["status"]: 1 = éxito, 0 = REVERTIDA (aterrizó pero falló — chequealo siempre)

-- Leer estado de contratos: eth_call devuelve bytes CRUDOS → abi_decode (el 90% de las lecturas)
let calldata be abi_encode("balanceOf(address)", [dueno])
let saldo be abi_decode("uint256", eth_call(url, {"to": token, "data": calldata}))[0]

Solana lo espeja (solana_latest_blockhash → solana_message → ed25519_sign →

solana_tx → solana_send → solana_confirm; solana_balance/spl_balance para

monitoreo), y Algorand también (algorand_params → map del txn → algorand_tx_encode

→ firmar → algorand_tx → algorand_send (el POST binario está resuelto) →

algorand_wait). Las escotillas eth_rpc(url, method, params?) /

solana_rpc(url, method, params?) cubren cualquier método sin wrapper.

Un nodo RPC es input no confiable. Puede mentir, estar comprometido o devolver

basura — por eso todo decode es estricto: un hex-quantity malformado o no canónico,

una respuesta de más de 16 MiB, una forma que no coincide, un id JSON-RPC ajeno →

error atrapable, jamás un panic, jamás data incorrecta en silencio. Los errores

nombran sólo el host, nunca el URL completo (las API keys de RPC suelen viajar en

el path). En qué nodo confiás es tu decisión — Synsema te da la primitiva, no la

confianza.

L2s de EVM: Base, Arbitrum, Optimism, Polygon — sin tocar nada

Un L2 es el mismo wire EVM: apuntá el url al RPC del L2 y todo lo de arriba —

eth_nonce, eth_fee_history, tx_eip1559, eth_call, eth_wait_receipt — funciona

sin cambios. La única regla: leé el chain id del nodo (eth_chain_id(url)), jamás lo

hardcodees — eso es lo que hace que el mismo programa sea correcto en mainnet, Base

(8453), Optimism (10), Arbitrum (42161) o Polygon (137), y es lo que firma la protección

anti-replay de EIP-155.

Una salvedad honesta sobre el costo: en las cadenas OP-stack (Base, Optimism)

eth_estimate_gas cubre sólo la ejecución L2 — la transacción además paga un **fee de

data en L1** que el nodo agrega al incluirla. Llega en el receipt como l1Fee /

l1GasUsed / l1GasPrice (decodificados a int exacto como cualquier otra cantidad), así

que el total real es gasUsed × effectiveGasPrice + l1Fee — visible, nunca escondido en

un string hex. Arbitrum usa otro modelo y pliega su componente L1 directamente en

gasUsed (sin campo extra). Si tu agente reporta costos, leelos del receipt, no del

estimate.

La cripto cross-chain tiene bordes filosos. Estos causan la mayoría de los bugs reales:

Cadenas cubiertas

Ethereum, Avalanche C-Chain, Solana y Algorand quedan end-to-end: construir la transacción, firmarla y ensamblar los bytes exactos del wire en Synsema — verificado byte a byte contra las SDKs oficiales (solana-sdk/solders, algosdk). Solana además tiene tokens SPL (PDAs, associated accounts, TransferChecked), y las cuatro cadenas tienen custodia HD (más abajo).

• Solana: solana_message({fee_payer, recent_blockhash, instructions, version?}) → bytes para firmar con ed25519_sign (v0 con "version": 0; la firma cubre el prefijo de versión); solana_latest_blockhash(url) devuelve el recent_blockhash como bytes(32), listo para enchufar. solana_tx(msg, sig_o_lista) → wire format; el broadcast es solana_send(url, tx) (base64 resuelto) y la confirmación solana_confirm(url, signature). Un transfer del System Program es program: "11111111111111111111111111111111" con data: int_to_bytes_le(2, 4) + int_to_bytes_le(lamports, 8).
• Algorand: algorand_params(url) lee los params sugeridos (fee por byte Y min_fee, fv/lv, gh como bytes, gen) directo al map del txn: algorand_tx_encode({type, snd, rcv, amt, fee, fv, lv, gen, gh, note, …}) (las claves cortas del protocolo; las direcciones text se validan por checksum) → bytes para firmar con ed25519_sign. algorand_tx(txn, sig) → SignedTxn; algorand_send(url, stx) hace el POST application/x-binary por vos y algorand_wait(url, txid) confirma. El TXID es componible: decode(sha512_256(algorand_tx_encode(txn)), "base32").
• Tokens SPL de Solana: solana_pda(seeds, program) → {address, bump} (findProgramAddress; la dirección queda off-curve, así que no puede existir clave privada para ella). spl_ata(owner, mint) deriva el associated token account (que es a su vez un PDA). spl_transfer_checked_data(amount, decimals) es la data de la instrucción — se mete en solana_message como cualquier otra. Todo puro.

Custodia: generá una wallet, no pegues una clave

Hasta ahora la clave llegaba como un string hex en el .env. Ahora un agente genera una wallet desde una frase semilla, la respalda, y deriva cuentas para cada cadena — como Metamask o Phantom — con la misma seguridad estructural que firmar: todo es un secret que nunca se materializa, y crear custodia es deny-by-default (require wallet) y auditado (en wallet.log).

wallet es un permiso aparte de sign: wallet crea claves, sign mueve valor. Un agente puede derivar direcciones para reportar sin poder gastar nunca. Ambos con scope, auditados, y denegados dentro de sandbox.

-- Doc example: HD custody. An agent generates a wallet from a seed phrase and
-- derives accounts for several chains — like Metamask/Phantom — but every result
-- is a `secret` that never materializes, creating custody is deny-by-default
-- (`require wallet`) and audited, and the phrase comes back only through a gated
-- `reveal`. No network: this is the offline custody core.
intent: "doc example: HD wallets / custody"
require wallet("W*")             -- scope: create custody only from secrets named W*
require reveal("W")

-- A known test mnemonic → its addresses match the reference SDKs (ethers, Phantom).
-- We use the canonical all-"abandon" phrase so the vectors are public.
let STD be "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"

-- Deriving from a secret OUTSIDE the wallet("W*") scope → denied (faithful scope,
-- like net(host) for HTTP). The wallet capability names the SOURCE secret.
task seed_from_unscoped_secret()
    give mnemonic_to_seed(as_secret(STD, "OTHER"))

-- A BIP-32 path can't derive ed25519: Solana is SLIP-0010 (hardened-only).
task derive_solana_with_bip32_path()
    let seed be mnemonic_to_seed(as_secret(STD, "W"))
    give hd_derive(seed, "m/44'/501'/0'/0", "ed25519")

test "custody from a secret outside the wallet scope is denied (deny-by-default)"
    assert_error(seed_from_unscoped_secret)

test "generate a fresh 12-word wallet — the phrase is a secret, backed up on purpose"
    let phrase be mnemonic_generate(12, "W")
    -- it is a secret: text()/print never show the words.
    assert(not contains(text(phrase), "abandon"))
    assert(starts_with(text(phrase), "secret("))
    -- reveal() (gated by reveal("W") + audited) backs it up deliberately.
    assert_eq(length(split(reveal(phrase), " ")), 12)

test "ETH: BIP-39 seed → BIP-32 m/44'/60'/0'/0/0 == the ethers vector"
    let seed be mnemonic_to_seed(as_secret(STD, "W"))
    let k be hd_derive(seed, "m/44'/60'/0'/0/0")
    assert_eq(eth_address(k), "0x9858EfFD232B4033E47d90003D41EC34EcaEda94")

test "Solana: same seed → SLIP-0010 m/44'/501'/0'/0' (ed25519) == Phantom's address 0"
    let seed be mnemonic_to_seed(as_secret(STD, "W"))
    let k be hd_derive(seed, "m/44'/501'/0'/0'", "ed25519")
    assert_eq(decode(ed25519_pubkey(k), "base58"), "HAgk14JpMQLgt6rVgv7cBQFJWFto5Dqxi472uT3DKpqk")

test "the SLIP-0010 curve rejects a non-hardened index (Solana derivation is hardened-only)"
    assert_error(derive_solana_with_bip32_path)

require wallet                                   -- crear custodia (aparte de `sign`)
let phrase be mnemonic_generate(12, "W")         -- secret: 12 palabras, entropía del SO (no sembrable)
let seed be mnemonic_to_seed(phrase)             -- secret: seed BIP-39 de 64 bytes (passphrase opcional)
let ethk be hd_derive(seed, "m/44'/60'/0'/0/0")  -- secret: BIP-32 secp256k1 (default) → eth_address/secp256k1_sign
let solk be hd_derive(seed, "m/44'/501'/0'/0'", "ed25519")  -- secret: SLIP-0010 (Solana; solo-hardened)
print(eth_address(ethk))                         -- derivar la dirección PÚBLICA (sin gate)
-- La frase de Algorand es su PROPIO formato de 25 palabras (NO es BIP-39):
let am be algorand_mnemonic(algo_secret32)       -- secret: 25 palabras (formato Pera/Defly)
-- Importar una wallet existente desde un keystore V3 de Geth/MyEtherWallet:
let k be keystore_import(json_text, secret("KS_PASS"), "HOT")  -- secret; pass incorrecta → error, sin fuga

Los secrets derivados llevan un name derivado para que los scopes queden ajustados: mnemonic_to_seed de un mnemónico "W" es W.seed, hd_derive es W/path. Concedé reveal("W*") (o el name exacto) para respaldar una frase; ese mismo name derivado es contra lo que scopean wallet/sign.

El mundo dApp: contratos, logins, permits

Todo lo que un usuario de dApps hace a diario, un agente lo puede hacer — con la propiedad anti-blind-signing de que el typed-data es un map legible que podés pasar por show/confirm antes de firmar:

-- calldata de un transfer ERC-20 (los montos uint256 son enteros exactos, nunca floats)
let data be abi_encode("transfer(address,uint256)", [destino, 1000000000000000000000000])
-- ...va en el campo `data` de la tx EIP-1559 que ya sabés construir.
-- Leer calldata de vuelta (auditar lo que estás por firmar):
let args be abi_decode("(address,uint256)", slice(data, 4, length(data)))

-- Login SIWE: el backend verifica con ecrecover
let digest be eip191_digest(mensaje_siwe)
let sig be secp256k1_sign(digest, k)
-- del lado del server: eth_address(secp256k1_recover(digest, sig)) == la dirección del usuario

-- Permit ERC-2612 (approval sin gas): maps legibles, digest, firma gateada
let domain be {"name": "USD Coin", "version": "2", "chainId": 1, "verifyingContract": usdc}
let types be {"Permit": [{"name": "owner", "type": "address"}, {"name": "spender", "type": "address"},
    {"name": "value", "type": "uint256"}, {"name": "nonce", "type": "uint256"}, {"name": "deadline", "type": "uint256"}]}
let permit be {"owner": mi_addr, "spender": router, "value": 1000000, "nonce": 0, "deadline": 1893456000}
let aprobado be confirm "¿Firmar permit " + json_encode(permit) + "?" within 15m
when aprobado
    let sig be secp256k1_sign(eip712_digest(domain, types, "Permit", permit), k)

eip712_digest soporta structs anidados, arrays y los campos opcionales del domain (orden fijo del EIP). Un campo faltante o de más en el message es error nombrando el campo — nunca firmás data que no leíste.

Componer el flagship

El producto real es la composición, en un solo binario, que ningún otro lenguaje te da:

• cron corre tu monitoreo de verdad (un job programado que lee saldos vía http_get a tu RPC).
• chart() es negociado: el humano ve el dashboard SVG, un agente con Accept: text/markdown lee los mismos datos.
• confirm / approve gatean un movimiento de fondos antes de firmar y hacer broadcast.

route "POST /enviar"
    let url be "https://rpc.example.com"
    let k be secret("HOT_KEY")
    -- LEER lo que la tx necesita (sin JSON-RPC a mano)
    let fees be eth_fee_history(url)
    let tx be tx_eip1559({"chain_id": eth_chain_id(url),
        "nonce": eth_nonce(url, eth_address(k)), "to": destino,
        "value": 100000000000000000, "gas": 21000,
        "max_fee": fees["base_fee"] * 2, "max_priority": fees["priority"]})
    -- MOSTRAR los fees ANTES de firmar (nada escondido dentro de un blob)
    let aprobado be confirm "¿Enviar 0.1 ETH, max fee " + text(tx["max_fee"]) + "?" within 15m
    when not aprobado
        give fail(403, "not approved")
    -- FIRMAR (la única puerta gateada) y ensamblar
    let sig be secp256k1_sign(tx["digest"], k)
    -- ENVIAR y CONFIRMAR (acotado — una tx atascada jamás cuelga la ruta)
    let hash be eth_send_raw(url, tx_eip1559_raw(tx, sig))
    let receipt be eth_wait_receipt(url, hash, 1, 120)
    give when receipt == nothing then fail(504, "not confirmed in time") otherwise receipt

La clave nunca se materializó; firmar exigió sign("HOT_KEY") y quedó auditado; leer, difundir y confirmar pasaron por net; los fees pasaron por un confirm humano antes de que la firma existiera.

Nota sobre firma programada/en agentes: un secret del top-level se redacta al cruzar a un job de cron o a un agente spawneado (seguro — sin fuga — pero inusable ahí). Resolvé la clave dentro del task: let k be secret("HOT_KEY") (o as_secret(...)) en el cuerpo del job, exactamente como hace la ruta flagship.

Para feeds en vivo — suscribirse a un RPC, a un exchange, a la mempool — Synsema tiene un cliente WebSocket general (ws_connect/ws_send/ws_recv/ws_close, gateado por net), no específico de blockchain. eth_subscribe (newHeads/logs) se compone hoy en userland: ws_connect al endpoint WS del nodo, enviar el frame de subscribe, ws_recv las notificaciones. Ver WebSocket.

Todavía no (documentado, no es deuda)

Las address lookup tables de Solana (pasar lookup_tables da error claro), la serialización de Avalanche X/P y las suscripciones WS tipadas (helpers de eth_subscribe — componibles hoy en userland, ver arriba) son los próximos pasos. Bitcoin ya está — su propia matriz UTXO (hash160, sighash BIP-143/341, builder G28, firma Schnorr taproot, read-side Esplora, PSBT): ver Bitcoin. El loop completo — leer (nonce/fees/saldos/eth_call/receipts, blockhash/confirm de Solana, params/wait de algod), construir (tx_eip1559), firmar, enviar y confirmar — más las llamadas a contratos, las firmas de dApp (191/712), los tokens SPL, la custodia HD (BIP-39/32, SLIP-0010, Algorand-25, keystore V3) y un cliente WebSocket en vivo salen hoy.