use crate::app::chat::access::{
build_actor_setup, transfer_selector, u256_be, withdraw_credits_selector,
};
use crate::encoding::parse_address;
use crate::tools::ClosureTool;
async fn resolve_lh_recipient(recipient_arg: &str) -> Result<String, crate::error::Error> {
use crate::encoding::Recipient;
let kind = crate::encoding::classify_recipient(recipient_arg)
.map_err(crate::error::Error::other)?;
match kind {
Recipient::Address(addr) => Ok(addr),
Recipient::Name(name) => crate::app::registry::owner_of_name(&name)
.await
.map_err(crate::error::Error::other)?
.ok_or_else(|| {
crate::error::Error::other(format!(
"no on-chain owner for subdomain \"{name}\" — is it registered?"
))
}),
}
}
fn lh_transfer_call(
to_hex: &str,
amount_wei: u128,
) -> Result<crate::tempo_tx::TempoCall, crate::error::Error> {
let to_bytes = parse_address(to_hex).map_err(crate::error::Error::other)?;
let mut to_padded = [0u8; 32];
to_padded[12..].copy_from_slice(&to_bytes);
let mut calldata = Vec::with_capacity(4 + 64);
calldata.extend_from_slice(&transfer_selector());
calldata.extend_from_slice(&to_padded);
calldata.extend_from_slice(&u256_be(amount_wei));
let token_addr = parse_address(crate::registry::LOCALHARNESS_TOKEN_ADDRESS)
.map_err(crate::error::Error::other)?;
Ok(crate::tempo_tx::TempoCall {
to: token_addr,
value_wei: 0,
input: calldata,
})
}
async fn meter_bridge_call(
from_hex: &str,
needed_wei: u128,
) -> Result<Option<crate::tempo_tx::TempoCall>, crate::error::Error> {
let shortfall = crate::app::chat::access::escrow_bridge_wei(from_hex, needed_wei)
.await
.map_err(crate::error::Error::other)?;
if shortfall == 0 {
return Ok(None);
}
let mut calldata = Vec::with_capacity(4 + 32);
calldata.extend_from_slice(&withdraw_credits_selector());
calldata.extend_from_slice(&u256_be(shortfall));
let diamond = parse_address(crate::registry::REGISTRY_ADDRESS)
.map_err(crate::error::Error::other)?;
Ok(Some(crate::tempo_tx::TempoCall {
to: diamond,
value_wei: 0,
input: calldata,
}))
}
pub(crate) fn create_subdomain_tool() -> std::sync::Arc<dyn crate::tools::Tool> {
let schema = serde_json::json!({
"type": "object",
"properties": {
"name": {
"type": "string",
"description": "Subdomain to register, e.g. \"alice\" \
becomes alice.localharness.xyz. 3-32 chars; lowercase \
letters, digits, and hyphens only."
},
"persona": {
"type": "string",
"description": "OPTIONAL system instruction / persona for the new \
agent — published on-chain as its system prompt (the persona \
that headless `call`s and the public face read). Omit to leave \
the default."
},
"prefund_lh": {
"type": "string",
"description": "OPTIONAL amount of $LH to prefund the new agent with, \
as a decimal string (\"5\", \"1.5\"). Transferred from YOUR \
wallet to the new subdomain's token-bound account (its own \
spendable wallet — used to pay other agents via x402). Omit, or \
pass \"0\", to skip. Must not exceed your $LH balance."
}
},
"required": ["name"]
});
ClosureTool::new(
"create_subdomain",
"Register a new <name>.localharness.xyz subdomain on-chain (the ACTOR MODEL). \
The owner's master wallet pays gas and ends up holding the resulting ERC-721 \
NFT. OPTIONALLY spawn the actor WITH behavior + funds in one call: `persona` \
publishes its on-chain system instruction; `prefund_lh` moves that much $LH \
from your wallet into the new agent's token-bound account (its own wallet). \
Returns { name, url, owner, tx_hash, persona_set?, prefunded_lh?, tba? }.",
schema,
|args: serde_json::Value, _ctx| async move {
let name = args.get("name").and_then(|v| v.as_str()).unwrap_or("").trim();
let persona = args.get("persona").and_then(|v| v.as_str());
let prefund_lh = args.get("prefund_lh").and_then(|v| v.as_str());
let cleaned = crate::app::tenant::sanitize(name);
if cleaned.len() < 3 || cleaned.len() > 32 {
return Err(crate::error::Error::other("invalid name"));
}
let (owner, claim_tx) = crate::app::verify::claim_name_via_iframe(&cleaned)
.await
.map_err(|e| crate::error::Error::other(format!("claim failed: {e}")))?;
{
let n = cleaned.clone();
wasm_bindgen_futures::spawn_local(async move {
crate::app::events::sync_local_key_to_main(&n).await;
});
}
let want_persona = persona.map(|p| !p.trim().is_empty()).unwrap_or(false);
let want_prefund = prefund_lh
.map(|p| {
let t = p.trim();
!t.is_empty() && t != "0"
})
.unwrap_or(false);
let mut result = serde_json::json!({
"name": cleaned,
"url": format!("https://{cleaned}.localharness.xyz/"),
"owner": owner,
"tx_hash": claim_tx,
});
if want_persona || want_prefund {
let token_id = match crate::app::registry::id_of_name(&cleaned).await {
Ok(id) if id != 0 => id,
Ok(_) => {
return Err(crate::error::Error::other(
"registered but tokenId not yet visible on-chain — retry \
persona/prefund shortly",
))
}
Err(e) => return Err(crate::error::Error::other(format!("id_of_name: {e}"))),
};
let setup = build_actor_setup(
&owner,
token_id,
&cleaned,
persona,
prefund_lh,
)
.await?;
if !setup.calls.is_empty() {
let tx_hash = crate::app::events::run_sponsored_tempo_call(
&owner,
setup.calls,
setup.extra_gas,
"spawn actor (persona + prefund)",
)
.await
.map_err(|e| {
crate::error::Error::other(format!("actor setup failed: {e}"))
})?;
result["setup_tx_hash"] = serde_json::json!(tx_hash);
result["persona_set"] = serde_json::json!(setup.persona_set);
if let Some(amt) = setup.prefunded_lh {
result["prefunded_lh"] = serde_json::json!(amt);
}
if let Some(tba) = setup.tba {
result["tba"] = serde_json::json!(tba);
}
}
}
Ok(result)
},
)
}
pub(crate) fn create_and_publish_app_tool() -> std::sync::Arc<dyn crate::tools::Tool> {
let schema = serde_json::json!({
"type": "object",
"properties": {
"name": {
"type": "string",
"description": "Subdomain to register, e.g. \"clock\" \
becomes clock.localharness.xyz. 3-32 chars; lowercase \
letters, digits, and hyphens only."
},
"source": {
"type": "string",
"description": "rustlite cartridge source — the SAME dialect as \
run_cartridge. Exports `fn frame(t: i32)` (animated) or \
`fn render()` and draws via `use host::display;`. This becomes \
the subdomain's fullscreen public face."
},
"persona": {
"type": "string",
"description": "OPTIONAL system instruction / persona for the new \
agent — published on-chain as its system prompt (read by \
headless `call`s). Omit to leave the default."
},
"prefund_lh": {
"type": "string",
"description": "OPTIONAL amount of $LH to prefund the new agent with, \
as a decimal string (\"5\", \"1.5\"). Transferred from YOUR \
wallet to the new subdomain's token-bound account (its own \
spendable wallet). Omit, or pass \"0\", to skip. Must not exceed \
your $LH balance."
}
},
"required": ["name", "source"]
});
ClosureTool::new(
"create_and_publish_app",
"One-shot: register a new <name>.localharness.xyz AND publish a compiled \
rustlite cartridge as its fullscreen public face, in a single call (compile \
+ on-chain register + sponsored setMetadata publish). Use this for \"make me \
a clock/<app> subdomain\". The ACTOR MODEL: optionally also set the new \
agent's `persona` (on-chain system instruction) and `prefund_lh` it with $LH \
(into its token-bound account), all in the SAME sponsored tx. create_subdomain \
remains for registering a name-only subdomain. Returns { name, url, tx_hash, \
persona_set?, prefunded_lh?, tba? }.",
schema,
|args: serde_json::Value, _ctx| async move {
let name = args.get("name").and_then(|v| v.as_str()).unwrap_or("").trim();
let source = args.get("source").and_then(|v| v.as_str()).unwrap_or("");
let persona = args.get("persona").and_then(|v| v.as_str());
let prefund_lh = args.get("prefund_lh").and_then(|v| v.as_str());
let cleaned = crate::app::tenant::sanitize(name);
if cleaned.len() < 3 || cleaned.len() > 32 {
return Err(crate::error::Error::other("invalid name"));
}
if source.trim().is_empty() {
return Err(crate::error::Error::other("source cannot be empty"));
}
let wasm = crate::rustlite::compile(source).map_err(|e| {
crate::error::Error::other(format!("compile failed: {}", e.render(source)))
})?;
if wasm.len() > 16_384 {
return Err(crate::error::Error::other(format!(
"app wasm too large to publish: {} bytes (max 16384)",
wasm.len()
)));
}
let (owner, _claim_tx) = crate::app::verify::claim_name_via_iframe(&cleaned)
.await
.map_err(|e| crate::error::Error::other(format!("claim failed: {e}")))?;
{
let n = cleaned.clone();
wasm_bindgen_futures::spawn_local(async move {
crate::app::events::sync_local_key_to_main(&n).await;
});
}
let token_id = match crate::app::registry::id_of_name(&cleaned).await {
Ok(id) if id != 0 => id,
Ok(_) => {
return Err(crate::error::Error::other(
"registered but tokenId not yet visible on-chain — retry publish shortly",
))
}
Err(e) => return Err(crate::error::Error::other(format!("id_of_name: {e}"))),
};
let registry_addr = parse_address(crate::app::registry::REGISTRY_ADDRESS)
.map_err(crate::error::Error::other)?;
let mk = |input: Vec<u8>| crate::tempo_tx::TempoCall {
to: registry_addr,
value_wei: 0,
input,
};
let mut calls = vec![
mk(crate::app::registry::encode_set_app_wasm(token_id, &wasm)),
mk(crate::app::registry::encode_set_public_face(token_id, "app")),
];
let mut gas = crate::app::gas::set_metadata_gas(wasm.len());
let setup =
build_actor_setup(&owner, token_id, &cleaned, persona, prefund_lh).await?;
calls.extend(setup.calls);
gas += setup.extra_gas;
let tx_hash = crate::app::events::run_sponsored_tempo_call(
&owner,
calls,
gas,
"create + publish app",
)
.await
.map_err(|e| crate::error::Error::other(format!("publish failed: {e}")))?;
let mut result = serde_json::json!({
"name": cleaned,
"url": format!("https://{cleaned}.localharness.xyz/"),
"tx_hash": tx_hash,
});
if setup.persona_set {
result["persona_set"] = serde_json::json!(true);
}
if let Some(amt) = setup.prefunded_lh {
result["prefunded_lh"] = serde_json::json!(amt);
}
if let Some(tba) = setup.tba {
result["tba"] = serde_json::json!(tba);
}
Ok(result)
},
)
}
pub(crate) fn release_subdomain_tool() -> std::sync::Arc<dyn crate::tools::Tool> {
let schema = serde_json::json!({
"type": "object",
"properties": {
"name": {
"type": "string",
"description": "Subdomain to release/recycle — burns the NFT, frees the name."
},
"confirmation": {
"type": "string",
"description": "Must EXACTLY equal `name`. Pass ONLY after the owner has \
TYPED the exact name in this chat. Never auto-fill or invent it."
}
},
"required": ["name", "confirmation"]
});
ClosureTool::new(
"release_subdomain",
"DESTRUCTIVE + IRREVERSIBLE: burn a subdomain NFT and free its name. Requires \
`confirmation` to exactly equal `name` (the owner must type the name). Refuses \
your MAIN. Returns the tx hash.",
schema,
|args: serde_json::Value, _ctx| async move {
let name = args.get("name").and_then(|v| v.as_str()).unwrap_or("").trim().to_string();
let confirmation = args
.get("confirmation")
.and_then(|v| v.as_str())
.unwrap_or("")
.trim()
.to_string();
if name.is_empty() {
return Err(crate::error::Error::other("name is required"));
}
if confirmation != name {
return Err(crate::error::Error::other(format!(
"release_subdomain NOT executed — confirmation must exactly equal \"{name}\". \
Ask the owner to TYPE \"{name}\" to confirm, then retry. Do not auto-fill it."
)));
}
match crate::app::events::run_release_subdomain(&name).await {
Ok(tx) => Ok(serde_json::json!({ "released": name, "tx_hash": tx })),
Err(e) => Err(crate::error::Error::other(format!("release failed: {e}"))),
}
},
)
}
pub(crate) fn bulk_release_subdomains_tool() -> std::sync::Arc<dyn crate::tools::Tool> {
let schema = serde_json::json!({
"type": "object",
"properties": {
"names": {
"type": "array",
"items": { "type": "string" },
"description": "OPTIONAL subset of subdomain names to release in one \
batch. Omit to target EVERY non-MAIN subdomain the owner holds."
},
"confirmation": {
"type": "string",
"description": "Must EXACTLY equal `release all non-main`. Pass ONLY after \
the owner has TYPED that exact phrase in this chat. First call this \
tool with confirmation empty to GET the list of names that will be \
released, show the user, and ask them to type the phrase. Never \
auto-fill or invent it."
}
},
"required": []
});
ClosureTool::new(
"bulk_release_subdomains",
"DESTRUCTIVE + IRREVERSIBLE: burn MANY subdomain NFTs and free their names in \
ONE batch. With no `names`, releases EVERY non-MAIN subdomain the owner holds; \
with `names`, only that subset. Requires a SINGLE master `confirmation` equal to \
\"release all non-main\" (the owner types it once — NOT one confirmation per \
name). ALWAYS call first with confirmation empty to receive the list of names it \
will release, show the user, then ask them to type the phrase and retry. Always \
refuses your MAIN. Returns the released names + tx hash.",
schema,
|args: serde_json::Value, _ctx| async move {
const CONFIRM_PHRASE: &str = "release all non-main";
let confirmation = args
.get("confirmation")
.and_then(|v| v.as_str())
.unwrap_or("")
.trim()
.to_lowercase();
let (_, owner) = crate::app::tenant::current_tenant_owner()
.await
.map_err(crate::error::Error::other)?;
let main_id = crate::app::registry::main_of(&owner)
.await
.map_err(crate::error::Error::other)?;
let explicit: Vec<String> = args
.get("names")
.and_then(|v| v.as_array())
.map(|a| {
a.iter()
.filter_map(|v| v.as_str())
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.collect()
})
.unwrap_or_default();
let targets: Vec<String> = if explicit.is_empty() {
let tokens = crate::app::registry::list_owned_tokens(&owner)
.await
.map_err(crate::error::Error::other)?;
tokens
.into_iter()
.filter(|t| main_id == 0 || t.token_id != main_id)
.map(|t| t.name)
.collect()
} else {
explicit
};
if targets.is_empty() {
return Ok(serde_json::json!({
"status": "nothing_to_release",
"note": "no non-MAIN subdomains to release"
}));
}
if confirmation != CONFIRM_PHRASE {
return Ok(serde_json::json!({
"status": "confirmation_required",
"count": targets.len(),
"will_release": targets,
"instruction": format!(
"These {} subdomain(s) will be PERMANENTLY released (burned). \
Show this list to the owner. To proceed, the owner must TYPE the \
exact phrase \"{}\" — then call bulk_release_subdomains again with \
that confirmation. Do NOT auto-fill it.",
targets.len(), CONFIRM_PHRASE
)
}));
}
match crate::app::events::run_bulk_release(&targets).await {
Ok((released, tx)) => Ok(serde_json::json!({
"released": released,
"count": released.len(),
"tx_hash": tx,
})),
Err(e) => Err(crate::error::Error::other(format!("bulk release failed: {e}"))),
}
},
)
}
pub(crate) fn batch_create_subdomains_tool() -> std::sync::Arc<dyn crate::tools::Tool> {
let schema = serde_json::json!({
"type": "object",
"properties": {
"names": {
"type": "array",
"items": { "type": "string" },
"description": "Subdomain names to register in ONE tx, e.g. \
[\"alice\",\"bob\"] -> alice.localharness.xyz, \
bob.localharness.xyz. Each: 3-32 chars, lowercase letters, \
digits, hyphens. Already-taken or invalid names are skipped \
and reported back. Max 20 per call."
}
},
"required": ["names"]
});
ClosureTool::new(
"batch_create_subdomains",
"Register MANY <name>.localharness.xyz subdomains on-chain in a SINGLE \
sponsored transaction. PREFER THIS over calling create_subdomain in a \
loop when registering more than one name — it is one tx, not N. The \
owner's master wallet ends up holding every resulting ERC-721 NFT. \
Taken or invalid names are skipped (not an error) and listed in \
`skipped`. Max 20 names per call. Returns { registered, skipped, \
count, tx_hash, urls }.",
schema,
|args: serde_json::Value, _ctx| async move {
const MAX_BATCH_CREATE: usize = 20;
let requested: Vec<String> = args
.get("names")
.and_then(|v| v.as_array())
.map(|a| {
a.iter()
.filter_map(|v| v.as_str())
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.collect()
})
.unwrap_or_default();
if requested.is_empty() {
return Err(crate::error::Error::other("names cannot be empty"));
}
if requested.len() > MAX_BATCH_CREATE {
return Err(crate::error::Error::other(format!(
"too many names: {} (max {MAX_BATCH_CREATE} per batch) — \
split into multiple calls",
requested.len()
)));
}
match crate::app::events::run_batch_create_subdomains(&requested).await {
Ok((registered, tx)) => {
let skipped: Vec<&String> = requested
.iter()
.filter(|r| {
let c = crate::app::tenant::sanitize(r);
!registered.iter().any(|reg| reg == &c)
})
.collect();
Ok(serde_json::json!({
"registered": registered,
"skipped": skipped,
"count": registered.len(),
"tx_hash": tx,
"urls": registered.iter()
.map(|n| format!("https://{n}.localharness.xyz/"))
.collect::<Vec<_>>(),
}))
}
Err(e) => Err(crate::error::Error::other(format!(
"batch create failed: {e}"
))),
}
},
)
}
pub(crate) fn list_subdomains_tool() -> std::sync::Arc<dyn crate::tools::Tool> {
ClosureTool::new(
"list_subdomains",
"List every subdomain owned by this agent's owner (their identity's holdings on \
the registry). Read-only. Use when the user asks what subdomains/agents they have.",
serde_json::json!({ "type": "object", "properties": {} }),
|_args: serde_json::Value, _ctx| async move {
let (_, owner) = crate::app::tenant::current_tenant_owner()
.await
.map_err(crate::error::Error::other)?;
let tokens = crate::app::registry::list_owned_tokens(&owner)
.await
.map_err(crate::error::Error::other)?;
let subdomains: Vec<_> = tokens
.iter()
.map(|t| {
serde_json::json!({
"name": t.name,
"url": format!("https://{}.localharness.xyz/", t.name),
"token_id": t.token_id,
})
})
.collect();
Ok(serde_json::json!({
"owner": owner,
"count": subdomains.len(),
"subdomains": subdomains,
}))
},
)
}
pub(crate) fn discover_agents_tool() -> std::sync::Arc<dyn crate::tools::Tool> {
fn snippet(persona: &str) -> String {
const MAX: usize = 160;
let trimmed = persona.trim();
if trimmed.chars().count() <= MAX {
return trimmed.to_string();
}
let mut s: String = trimmed.chars().take(MAX).collect();
s.push('…');
s
}
ClosureTool::new(
"discover_agents",
"Find peer agents by capability or persona. Read-only registry scan: \
returns the agents whose subdomain NAME or on-chain persona matches \
`query`. MULTI-KEYWORD: the query is split on whitespace and an agent \
matches ANY keyword, ranked by how many it matches (name matches above \
persona matches) — so ONE call with \"game tool puzzle\" replaces a \
sequential call per keyword. Use this to LOCATE an agent to delegate \
to, then call_agent it. Returns { agents: [ { name, persona } ], \
count } (persona is a short preview).",
serde_json::json!({
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "What to look for — capabilities, topics, or \
keywords matched (case-insensitively) against agent names \
and personas. Several keywords are ORed and ranked by \
overlap (e.g. \"solidity audit security\"). \
Empty returns recent agents."
}
},
"required": ["query"]
}),
|args: serde_json::Value, _ctx| async move {
let query = args
.get("query")
.and_then(|v| v.as_str())
.unwrap_or("")
.to_string();
let matches = crate::app::registry::discover_agents(&query, 100)
.await
.map_err(crate::error::Error::other)?;
let agents: Vec<_> = matches
.iter()
.map(|(name, persona)| {
serde_json::json!({
"name": name,
"persona": snippet(persona),
})
})
.collect();
Ok(serde_json::json!({
"count": agents.len(),
"agents": agents,
}))
},
)
}
pub(crate) fn send_lh_tool() -> std::sync::Arc<dyn crate::tools::Tool> {
let schema = serde_json::json!({
"type": "object",
"properties": {
"recipient": {
"type": "string",
"description": "Who receives the $LH: either a raw 0x… 20-byte \
address, or a subdomain name like \"alice\" (the funds go to \
that subdomain's on-chain OWNER address)."
},
"amount": {
"type": "string",
"description": "Amount of $LH to send, as a decimal string \
(e.g. \"5\", \"1.5\", \"0.01\"). Must be greater than 0."
}
},
"required": ["recipient", "amount"]
});
ClosureTool::new(
"send_lh",
"Transfer real $LH credits from the owner's wallet to a recipient. \
`recipient` is a raw 0x… address OR a subdomain name (funds go to that \
name's on-chain owner). `amount` is a decimal $LH figure (must be > 0). \
Moves value: confirm the recipient + amount with the owner before \
calling. Returns { amount, recipient (input), resolved_recipient, \
tx_hash }.",
schema,
|args: serde_json::Value, _ctx| async move {
use crate::encoding::parse_token_amount;
let recipient_arg = args
.get("recipient")
.and_then(|v| v.as_str())
.unwrap_or("")
.trim()
.to_string();
let amount_arg = args
.get("amount")
.and_then(|v| v.as_str())
.unwrap_or("")
.trim()
.to_string();
let amount_wei = parse_token_amount(&amount_arg).ok_or_else(|| {
crate::error::Error::other(format!(
"could not parse amount \"{amount_arg}\" — pass a decimal $LH \
figure like \"5\" or \"1.5\""
))
})?;
if amount_wei == 0 {
return Err(crate::error::Error::other(
"amount must be greater than 0",
));
}
let to_hex = resolve_lh_recipient(&recipient_arg).await?;
let (_, from) = crate::app::tenant::current_tenant_owner()
.await
.map_err(crate::error::Error::other)?;
let mut calls = Vec::with_capacity(2);
let bridged = match meter_bridge_call(&from, amount_wei).await? {
Some(bridge) => {
calls.push(bridge);
true
}
None => false,
};
calls.push(lh_transfer_call(&to_hex, amount_wei)?);
let amount_display = amount_arg.clone();
let purpose = format!("send {amount_display} $LH to {to_hex}");
let gas = if bridged { 650_000 } else { 500_000 };
let tx_hash =
crate::app::events::run_sponsored_tempo_call(&from, calls, gas, &purpose)
.await
.map_err(|e| crate::error::Error::other(format!("send_lh failed: {e}")))?;
Ok(serde_json::json!({
"amount": amount_display,
"recipient": recipient_arg,
"resolved_recipient": to_hex,
"bridged_from_meter": bridged,
"tx_hash": tx_hash,
}))
},
)
}
pub(crate) fn batch_send_lh_tool() -> std::sync::Arc<dyn crate::tools::Tool> {
let schema = serde_json::json!({
"type": "object",
"properties": {
"transfers": {
"type": "array",
"description": "Up to 20 transfers, executed atomically in one \
on-chain transaction.",
"items": {
"type": "object",
"properties": {
"recipient": {
"type": "string",
"description": "0x… address or subdomain name (funds \
go to the name's on-chain owner)."
},
"amount": {
"type": "string",
"description": "Decimal $LH amount, e.g. \"1\" or \
\"0.5\". Must be greater than 0."
}
},
"required": ["recipient", "amount"]
}
}
},
"required": ["transfers"]
});
ClosureTool::new(
"batch_send_lh",
"Transfer $LH to MULTIPLE recipients in ONE on-chain transaction (up \
to 20). Each transfer names a 0x… address or a subdomain (paid to its \
on-chain owner). Far cheaper than repeated send_lh calls. Moves value: \
confirm the full list with the owner before calling. Returns \
{ count, total, transfers: [{recipient, resolved, amount}], tx_hash }.",
schema,
|args: serde_json::Value, _ctx| async move {
use crate::encoding::parse_token_amount;
let items = args
.get("transfers")
.and_then(|v| v.as_array())
.cloned()
.unwrap_or_default();
if items.is_empty() {
return Err(crate::error::Error::other(
"batch_send_lh: transfers must be a non-empty array",
));
}
if items.len() > 20 {
return Err(crate::error::Error::other(
"batch_send_lh: at most 20 transfers per batch",
));
}
let mut resolved: Vec<(String, String, u128, String)> =
Vec::with_capacity(items.len());
let mut total_wei: u128 = 0;
for item in &items {
let recipient = item
.get("recipient")
.and_then(|v| v.as_str())
.unwrap_or("")
.trim()
.to_string();
let amount_str = item
.get("amount")
.and_then(|v| v.as_str())
.unwrap_or("")
.trim()
.to_string();
let amount_wei = parse_token_amount(&amount_str).ok_or_else(|| {
crate::error::Error::other(format!(
"could not parse amount \"{amount_str}\" for \"{recipient}\""
))
})?;
if amount_wei == 0 {
return Err(crate::error::Error::other(format!(
"amount for \"{recipient}\" must be greater than 0"
)));
}
let to_hex = resolve_lh_recipient(&recipient).await?;
total_wei = total_wei.saturating_add(amount_wei);
resolved.push((recipient, to_hex, amount_wei, amount_str));
}
let (_, from) = crate::app::tenant::current_tenant_owner()
.await
.map_err(crate::error::Error::other)?;
let mut calls = Vec::with_capacity(resolved.len() + 1);
let bridged = match meter_bridge_call(&from, total_wei).await? {
Some(bridge) => {
calls.push(bridge);
true
}
None => false,
};
for (_, to_hex, amount_wei, _) in &resolved {
calls.push(lh_transfer_call(to_hex, *amount_wei)?);
}
let purpose = format!(
"batch-send {} $LH to {} recipients",
crate::app::format_wei_as_test_eth(total_wei),
resolved.len()
);
let gas = 500_000
+ 80_000 * (resolved.len() as u128 - 1)
+ if bridged { 150_000 } else { 0 };
let tx_hash =
crate::app::events::run_sponsored_tempo_call(&from, calls, gas, &purpose)
.await
.map_err(|e| {
crate::error::Error::other(format!("batch_send_lh failed: {e}"))
})?;
let transfers: Vec<serde_json::Value> = resolved
.iter()
.map(|(recipient, to_hex, _, amount_str)| {
serde_json::json!({
"recipient": recipient,
"resolved": to_hex,
"amount": amount_str,
})
})
.collect();
Ok(serde_json::json!({
"count": transfers.len(),
"total": crate::app::format_wei_as_test_eth(total_wei),
"bridged_from_meter": bridged,
"transfers": transfers,
"tx_hash": tx_hash,
}))
},
)
}
pub(crate) fn check_balances_tool() -> std::sync::Arc<dyn crate::tools::Tool> {
let schema = serde_json::json!({
"type": "object",
"properties": {}
});
ClosureTool::new(
"check_balances",
"Read this agent's $LH balances: the owner WALLET (pays send_lh and \
x402 agent calls), the chat METER (pays model usage; auto-bridges \
into the wallet when it is short), and this subdomain's token-bound \
account (TBA — where bounty rewards and x402 earnings land). \
Read-only, costs nothing. Returns decimal $LH figures plus raw wei.",
schema,
|_args: serde_json::Value, _ctx| async move {
let (name, owner) = crate::app::tenant::current_tenant_owner()
.await
.map_err(crate::error::Error::other)?;
let wallet = crate::app::registry::token_balance_of(&owner)
.await
.unwrap_or(0);
let meter = crate::app::registry::credit_balance_of(&owner)
.await
.unwrap_or(0);
let tba_hex = crate::app::registry::tba_of_name(&name)
.await
.ok()
.flatten();
let tba_balance = match &tba_hex {
Some(addr) => crate::app::registry::token_balance_of(addr)
.await
.unwrap_or(0),
None => 0,
};
Ok(serde_json::json!({
"owner_address": owner,
"wallet_lh": crate::app::format_wei_as_test_eth(wallet),
"wallet_wei": wallet.to_string(),
"meter_lh": crate::app::format_wei_as_test_eth(meter),
"meter_wei": meter.to_string(),
"tba_address": tba_hex,
"tba_lh": crate::app::format_wei_as_test_eth(tba_balance),
"tba_wei": tba_balance.to_string(),
"spendable_total_lh": crate::app::format_wei_as_test_eth(
wallet.saturating_add(meter)
),
}))
},
)
}