Add rofl-client-ts use case with eliza

Author: ZigaMr

docs/build/use-cases/trustless-agent.mdx

@@ -117,8 +117,8 @@ WORKDIR /app
 # Copy your ElizaOS project (created with `elizaos create ...`).
 ADD . /app
 
-# Install ElizaOS CLI and project dependencies.
-RUN bun install -g @elizaos/cli && bun install
+# Install ElizaOS CLI and project dependencies (npm-based).
+RUN npm i -g @elizaos/cli && npm ci
 
 # Minimal entrypoint that launches the agent.
 ENTRYPOINT ["/bin/sh", "/app/docker/entry.sh"]
@@ -193,6 +193,175 @@ By default, the Oasis-maintained provider is selected on Testnet.
   `appd`. The tx originates from the enclave-bound key of your ROFL app.
 - Contracts can require verified ROFL origin to bind calls to your app.
 
+### Eliza + ROFL TypeScript client (inline)
+
+Use the official ROFL TypeScript client directly inside your Eliza agent. Add a
+small helper you can import from any Eliza action/tool to derive the enclave key,
+expose the wallet address, and sign+submit transactions via appd.
+
+<details>
+  <summary>src/rofl.ts</summary>
+
+```ts
+import { RoflClient, KeyKind } from "@oasisprotocol/rofl-client";
+import { Interface, Wallet } from "ethers";
+import http from "node:http";
+
+export async function ensureEnclaveWallet(keyId = "agent-identity-key") {
+  const client = new RoflClient(); // connects to /run/rofl-appd.sock inside ROFL
+  const key = await client.generateKey(keyId, KeyKind.SECP256K1);
+  const wallet = new Wallet("0x" + key);
+  await client.setMetadata({ key_fingerprint: key.slice(0, 16) });
+  return { wallet, key, client };
+}
+
+export async function signSubmitEthTx(params: {
+  to: string;
+  abi: any[];
+  method: string;
+  args?: any[];
+  gasLimit?: number;
+}) {
+  const { to, abi, method, args, gasLimit } = params;
+  const iface = new Interface(abi);
+  const data = iface.encodeFunctionData(method, args ?? []);
+  const body = JSON.stringify({
+    tx: { kind: "eth", data: { gas_limit: gasLimit ?? 200000, to, value: 0, data } },
+  });
+  return await new Promise<any>((resolve, reject) => {
+    const req = http.request(
+      {
+        socketPath: "/run/rofl-appd.sock",
+        path: "/rofl/v1/tx/sign-submit",
+        method: "POST",
+        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) },
+      },
+      (res) => {
+        let buf = "";
+        res.on("data", (c) => (buf += c));
+        res.on("end", () => {
+          try {
+            resolve(JSON.parse(buf || "{}"));
+          } catch {
+            resolve({ raw: buf });
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.write(body);
+    req.end();
+  });
+}
+```
+</details>
+
+Use the helper from inside your Eliza agent (e.g., in a tool/action handler):
+
+<details>
+  <summary>Example usage in an Eliza handler</summary>
+
+```ts
+import { ensureEnclaveWallet, signSubmitEthTx } from "./rofl";
+
+// During agent startup (once):
+const { wallet } = await ensureEnclaveWallet("agent-identity-key");
+console.log("ROFL enclave EVM address:", wallet.address);
+
+// Later, on user intent (e.g., tool call):
+await signSubmitEthTx({
+  to: "0xYourContract",
+  abi: [ /* contract ABI */ ],
+  method: "yourMethod",
+  args: [ /* arguments */ ],
+  gasLimit: 200000,
+});
+```
+</details>
+
+#### Wire into ElizaOS (enable tool and prompting)
+
+Add a small tool wrapper Eliza can call. Register it in your agent config and nudge the model to invoke it via system instructions.
+
+<details>
+  <summary>tools/rofl.ts</summary>
+
+```ts
+import { ensureEnclaveWallet, signSubmitEthTx } from "../src/rofl";
+
+export async function generate_rofl_wallet(params?: { keyId?: string }) {
+  const { wallet } = await ensureEnclaveWallet(params?.keyId ?? "agent-identity-key");
+  return { address: wallet.address };
+}
+
+export async function submit_rofl_tx(input: {
+  to: string;
+  abi: any[];
+  method: string;
+  args?: any[];
+  gasLimit?: number;
+}) {
+  return await signSubmitEthTx(input);
+}
+```
+</details>
+
+Register the tool in your Eliza agent configuration (adjust pathing to your build output):
+
+<details>
+  <summary>agent.config.json</summary>
+
+```json
+{
+  "name": "rofl-eliza",
+  "model": "openai:gpt-4o-mini",
+  "tools": ["./dist/tools/rofl.js"]
+}
+```
+</details>
+
+Guide the model to use the tool via system prompt:
+
+<details>
+  <summary>system-prompt.txt</summary>
+
+```
+You are a ROFL-enabled Eliza agent. When a user asks to create a wallet or perform an on-chain action:
+- First call generate_rofl_wallet to ensure an enclave-bound EVM address exists.
+- Then call submit_rofl_tx with the target contract (to), ABI, method and args.
+Never expose private keys; only share the EVM address.
+```
+</details>
+
+Ensure the appd UNIX socket is available to your container:
+
+<details>
+  <summary>compose.yaml (socket mount)</summary>
+
+```yaml
+services:
+  eliza-agent:
+    # ...
+    volumes:
+      - /run/rofl-appd.sock:/run/rofl-appd.sock
+```
+</details>
+ 
+Install dependencies and build with your app:
+
+```shell
+npm i ethers @oasisprotocol/rofl-client typescript
+npx tsc
+```
+
+Your `docker/entry.sh` can continue to start just the Eliza agent:
+
+```shell
+#!/bin/sh
+set -e
+exec elizaos start
+```
+
 ## Testing it out
 
 After `oasis rofl deploy`, use the CLI to check machine status and view logs.