Building Multi-Chain Support for Ironclaw

Source: Dev.to

What’s Ironclaw?

For readers who haven’t met it – Ironclaw is an OpenClaw‑inspired implementation in Rust focused on privacy and security. It runs on your own machine, talks to whichever language model you point it at, and remembers what you tell it across sessions.

Teaching the Agent to Use a NEAR Account

The plan was multi‑chain support from day one: we wanted Ironclaw to send a transaction on any chain its user cared about. The route to “any chain” ran through NEAR, because of a contract on NEAR called the chain‑signatures MPC contract (more on that in a moment). To use that contract, the agent first needed to be able to send transactions from the user’s NEAR account.

Milestone 1 – Full NEAR‑account control

1. First attempt – build a NEAR‑signing tool

   • Compile it to WebAssembly, plug it into Ironclaw, let the agent call it.
   • We hit a wall: Ironclaw’s tool sandbox is intentionally restrictive about secrets. A tool can ask whether a credential exists, but it can never read it. A signer‑as‑a‑tool was a non‑starter.

2. Second attempt – drive near-cli-rs from the shell

   • Instead of building a signer ourselves, we wrote a skill that taught the agent how to drive the user’s existing command‑line tool (near-cli-rs).
   • Shell access in Ironclaw is opt‑in and off by default; you launch the agent with

   ALLOW_LOCAL_TOOLS=true ironclaw

   to enable it.

   • The skill describes the surface of near-cli-rs to the agent: which subcommand maps to which intent, what arguments to compose, how to read the output back.

That worked. The agent could now turn a sentence like “send 0.5 NEAR to bob.testnet” into the right near-cli-rs invocation and run it. Milestone reached – and although NEAR‑account control was useful in its own right, its real importance was as the foundation for what came next.

Going Multi‑Chain via NEAR MPC

What is MPC?

NEAR runs an MPC chain‑signatures contract at v1.signer-prod.testnet. Hand it a payload and a (account, path) pair, and it returns a signature produced by a key that’s derived deterministically from those two inputs.

Result: one NEAR account → infinite addresses on every chain you know how to derive (Ethereum, Bitcoin, Solana, …).

The Architecture

• near-tool – a small Rust WASM tool with deterministic actions (encoding, hashing, etc.).
• MPC_SKILL.md – a skill that teaches the agent how to use the tool.
• near-cli-rs – the shell‑command plumbing from Step One; it makes the actual MPC contract call.

The tool handles chain‑specific encoding; the skill orchestrates the sequence; near-cli-rs performs the contract interaction.

When I sent the original prompt, the agent walked through roughly this sequence:

NEAR account + path
        │
        ▼
1.  get_derived_pubkey                → Sepolia address
                                        (and BTC/Solana too)
2.  evm_parse_value                   → amount in wei (hex)
3.  evm_get_nonce                     → pending nonce
4.  evm_get_gas_price                 → base gas price
5.  evm_get_priority_fee_wei_per_gas → priority fee (+ max fee per gas)
6.  evm_estimate_gas                  → gas limit (20 % buffer)
7.  evm_build_transfer_mpc_payload    → unsigned tx (+ sighash payload)
8.  near-cli-rs sign payload via MPC  → (big_r, s, recovery_id)
9.  evm_attach_mpc_signature_to_tx    → signed tx + tx_hash
10. evm_send_signed_tx                → Etherscan link

Design notes

• The agent narrates every step. The nonce, gas estimate, unsigned transaction, raw signature—all appear in the chat.
• Keeping the flow granular (steps 2‑6 separate) gives legible failure modes. If an RPC endpoint is flaky or a gas estimate is off, the agent knows exactly which piece broke, can show the user the cost before committing, and can retry only the failing part.

What’s Next

• Bitcoin and Solana already work end‑to‑end through the same arc, but their flows are coarser than the EVM’s—fewer intermediate steps, fewer natural seams to surface errors.
• The next push is to bring them up to the same level of granularity: small actions for fee estimation, UTXO selection, block‑hash fetching, etc.

Additional Resources

• Ironclaw –
• NEAR MPC contract – v1.signer-prod.testnet (see NEAR docs)
• near-cli-rs –
• near-tool –
• NEAR chain‑signatures docs –
• near-cli-rs skill –
• MPC contract – v1.signer-prod.testnet