@ens-node-metadata/agent 0.3.1 → 0.3.2

package/dist/commands/registry/identity/register.js

@@ -0,0 +1,112 @@
+import {
+  estimateCost,
+  formatCost
+} from "../../../chunk-X6M7WZJF.js";
+import {
+  IdentityRegistry_default,
+  SUPPORTED_CHAINS,
+  resolveChain
+} from "../../../chunk-DXAESRZH.js";
+import "../../../chunk-YZFATT7X.js";
+
+// src/commands/registry/identity/register.tsx
+import { Box, Text, useApp } from "ink";
+import React from "react";
+import { encodeFunctionData, http, createPublicClient, createWalletClient } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { z } from "zod";
+var description = "Register agent identity on ERC-8004 registry";
+var options = z.object({
+  chainName: z.enum(SUPPORTED_CHAINS).default("mainnet").describe("Chain name (e.g. mainnet, base, arbitrum, optimism)"),
+  privateKey: z.string().describe("Private key for signing (hex, prefixed with 0x)"),
+  broadcast: z.boolean().default(false).describe("Broadcast the transaction on-chain (default: dry run)")
+});
+var args = z.tuple([z.string().describe("agent-uri (e.g. ipfs://...)")]);
+function Register({
+  options: { chainName, privateKey, broadcast },
+  args: [agentUri]
+}) {
+  const { exit } = useApp();
+  const [state, setState] = React.useState({ status: "idle" });
+  React.useEffect(() => {
+    if (state.status === "done") exit();
+    else if (state.status === "error") exit(new Error(state.message));
+  }, [state, exit]);
+  React.useEffect(() => {
+    async function run() {
+      const { chain, registryAddress } = resolveChain(chainName);
+      const account = privateKeyToAccount(privateKey);
+      if (!broadcast) {
+        const publicClient = createPublicClient({ chain, transport: http() });
+        const data = encodeFunctionData({
+          abi: IdentityRegistry_default,
+          functionName: "register",
+          args: [agentUri]
+        });
+        let costLine = "  Est. Cost: unable to estimate";
+        try {
+          const est = await estimateCost(publicClient, {
+            account: account.address,
+            to: registryAddress,
+            data
+          });
+          costLine = `  Est. Cost: ${formatCost(est)}`;
+        } catch {
+        }
+        setState({
+          status: "done",
+          message: [
+            `Dry run \u2014 would call register on ${chainName}:`,
+            "",
+            `  Registry:  ${registryAddress}`,
+            `  Agent URI: ${agentUri}`,
+            `  Signer:    ${account.address}`,
+            costLine,
+            "",
+            "Run with --broadcast to submit on-chain."
+          ].join("\n")
+        });
+        return;
+      }
+      setState({ status: "working", message: `Registering agent on ${chainName}\u2026` });
+      try {
+        const publicClient = createPublicClient({ chain, transport: http() });
+        const walletClient = createWalletClient({
+          account,
+          chain,
+          transport: http()
+        });
+        const { request } = await publicClient.simulateContract({
+          account,
+          address: registryAddress,
+          abi: IdentityRegistry_default,
+          functionName: "register",
+          args: [agentUri]
+        });
+        const txHash = await walletClient.writeContract(request);
+        setState({
+          status: "done",
+          message: [
+            `\u2705 Agent registered on ${chainName}`,
+            `   Agent URI: ${agentUri}`,
+            `   Tx Hash:  ${txHash}`,
+            `   Registry: ${registryAddress}`
+          ].join("\n")
+        });
+      } catch (err) {
+        setState({
+          status: "error",
+          message: `Registration failed: ${err.message}`
+        });
+      }
+    }
+    run();
+  }, [chainName, privateKey, broadcast, agentUri]);
+  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, state.status === "idle" && /* @__PURE__ */ React.createElement(Text, { color: "gray" }, "Preparing\u2026"), state.status === "working" && /* @__PURE__ */ React.createElement(Text, { color: "cyan" }, state.message), state.status === "done" && /* @__PURE__ */ React.createElement(Text, { color: "green" }, state.message), state.status === "error" && /* @__PURE__ */ React.createElement(Text, { color: "red" }, "\u274C ", state.message));
+}
+export {
+  args,
+  Register as default,
+  description,
+  options
+};

package/dist/commands/registry/identity/set-uri.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import { z } from 'zod';
+
+declare const description = "Update agent URI on the ERC-8004 registry";
+declare const options: z.ZodObject<{
+    chainName: z.ZodDefault<z.ZodEnum<[string, ...string[]]>>;
+    privateKey: z.ZodString;
+    broadcast: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    chainName: string;
+    privateKey: string;
+    broadcast: boolean;
+}, {
+    privateKey: string;
+    chainName?: string | undefined;
+    broadcast?: boolean | undefined;
+}>;
+declare const args: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+type Props = {
+    options: z.infer<typeof options>;
+    args: z.infer<typeof args>;
+};
+declare function SetUri({ options: { chainName, privateKey, broadcast }, args: [agentId, newUri], }: Props): React.JSX.Element;
+
+export { args, SetUri as default, description, options };

package/dist/commands/registry/identity/set-uri.js

@@ -0,0 +1,113 @@
+import {
+  estimateCost,
+  formatCost
+} from "../../../chunk-X6M7WZJF.js";
+import {
+  IdentityRegistry_default,
+  SUPPORTED_CHAINS,
+  resolveChain
+} from "../../../chunk-DXAESRZH.js";
+import "../../../chunk-YZFATT7X.js";
+
+// src/commands/registry/identity/set-uri.tsx
+import { Box, Text, useApp } from "ink";
+import React from "react";
+import { encodeFunctionData, http, createPublicClient, createWalletClient } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { z } from "zod";
+var description = "Update agent URI on the ERC-8004 registry";
+var options = z.object({
+  chainName: z.enum(SUPPORTED_CHAINS).default("mainnet").describe("Chain name (e.g. mainnet, base, arbitrum, optimism)"),
+  privateKey: z.string().describe("Private key for signing (hex, prefixed with 0x)"),
+  broadcast: z.boolean().default(false).describe("Broadcast the transaction on-chain (default: dry run)")
+});
+var args = z.tuple([
+  z.string().describe("agent-id (token ID)"),
+  z.string().describe("new-uri (e.g. ipfs://...)")
+]);
+function SetUri({
+  options: { chainName, privateKey, broadcast },
+  args: [agentId, newUri]
+}) {
+  const { exit } = useApp();
+  const [state, setState] = React.useState({ status: "idle" });
+  React.useEffect(() => {
+    if (state.status === "done") exit();
+    else if (state.status === "error") exit(new Error(state.message));
+  }, [state, exit]);
+  React.useEffect(() => {
+    async function run() {
+      const { chain, registryAddress } = resolveChain(chainName);
+      const account = privateKeyToAccount(privateKey);
+      const tokenId = BigInt(agentId);
+      if (!broadcast) {
+        const publicClient = createPublicClient({ chain, transport: http() });
+        const data = encodeFunctionData({
+          abi: IdentityRegistry_default,
+          functionName: "setAgentURI",
+          args: [tokenId, newUri]
+        });
+        let costLine = "  Est. Cost: unable to estimate";
+        try {
+          const est = await estimateCost(publicClient, {
+            account: account.address,
+            to: registryAddress,
+            data
+          });
+          costLine = `  Est. Cost: ${formatCost(est)}`;
+        } catch {
+        }
+        setState({
+          status: "done",
+          message: [
+            `Dry run \u2014 would call setAgentURI on ${chainName}:`,
+            "",
+            `  Registry:  ${registryAddress}`,
+            `  Agent ID:  ${tokenId.toString()}`,
+            `  New URI:   ${newUri}`,
+            `  Signer:    ${account.address}`,
+            costLine,
+            "",
+            "Run with --broadcast to submit on-chain."
+          ].join("\n")
+        });
+        return;
+      }
+      setState({ status: "working", message: `Updating agent URI on ${chainName}\u2026` });
+      try {
+        const publicClient = createPublicClient({ chain, transport: http() });
+        const walletClient = createWalletClient({ account, chain, transport: http() });
+        const { request } = await publicClient.simulateContract({
+          account,
+          address: registryAddress,
+          abi: IdentityRegistry_default,
+          functionName: "setAgentURI",
+          args: [tokenId, newUri]
+        });
+        const txHash = await walletClient.writeContract(request);
+        setState({
+          status: "done",
+          message: [
+            `\u2705 Agent URI updated on ${chainName}`,
+            `   Agent ID: ${tokenId.toString()}`,
+            `   New URI:  ${newUri}`,
+            `   Tx Hash:  ${txHash}`
+          ].join("\n")
+        });
+      } catch (err) {
+        setState({
+          status: "error",
+          message: `setAgentURI failed: ${err.message}`
+        });
+      }
+    }
+    run();
+  }, [chainName, privateKey, broadcast, agentId, newUri]);
+  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, state.status === "idle" && /* @__PURE__ */ React.createElement(Text, { color: "gray" }, "Preparing\u2026"), state.status === "working" && /* @__PURE__ */ React.createElement(Text, { color: "cyan" }, state.message), state.status === "done" && /* @__PURE__ */ React.createElement(Text, { color: "green" }, state.message), state.status === "error" && /* @__PURE__ */ React.createElement(Text, { color: "red" }, "\u274C ", state.message));
+}
+export {
+  args,
+  SetUri as default,
+  description,
+  options
+};

package/dist/commands/registry/identity/set-wallet.d.ts

@@ -0,0 +1,31 @@
+import React from 'react';
+import { z } from 'zod';
+
+declare const description = "Link a verified wallet to an agent via EIP-712 signature";
+declare const options: z.ZodObject<{
+    chainName: z.ZodDefault<z.ZodEnum<[string, ...string[]]>>;
+    privateKey: z.ZodString;
+    broadcast: z.ZodDefault<z.ZodBoolean>;
+    deadline: z.ZodOptional<z.ZodString>;
+    signature: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    chainName: string;
+    privateKey: string;
+    broadcast: boolean;
+    deadline?: string | undefined;
+    signature?: string | undefined;
+}, {
+    privateKey: string;
+    deadline?: string | undefined;
+    signature?: string | undefined;
+    chainName?: string | undefined;
+    broadcast?: boolean | undefined;
+}>;
+declare const args: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+type Props = {
+    options: z.infer<typeof options>;
+    args: z.infer<typeof args>;
+};
+declare function SetWallet({ options: { chainName, privateKey, broadcast, deadline: deadlineOpt, signature: signatureOpt }, args: [agentId, walletAddress], }: Props): React.JSX.Element;
+
+export { args, SetWallet as default, description, options };

package/dist/commands/registry/identity/set-wallet.js

@@ -0,0 +1,191 @@
+import {
+  estimateCost,
+  formatCost
+} from "../../../chunk-X6M7WZJF.js";
+import {
+  IdentityRegistry_default,
+  SUPPORTED_CHAINS,
+  resolveChain
+} from "../../../chunk-DXAESRZH.js";
+import "../../../chunk-YZFATT7X.js";
+
+// src/commands/registry/identity/set-wallet.tsx
+import { Box, Text, useApp } from "ink";
+import React from "react";
+import { encodeFunctionData, http, createPublicClient, createWalletClient, verifyTypedData } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { z } from "zod";
+var description = "Link a verified wallet to an agent via EIP-712 signature";
+var options = z.object({
+  chainName: z.enum(SUPPORTED_CHAINS).default("mainnet").describe("Chain name (e.g. mainnet, base, arbitrum, optimism)"),
+  privateKey: z.string().describe("Private key for signing (hex, prefixed with 0x)"),
+  broadcast: z.boolean().default(false).describe("Broadcast the transaction on-chain (default: dry run)"),
+  deadline: z.string().optional().describe("Deadline unix timestamp (auto-generated if omitted)"),
+  signature: z.string().optional().describe("EIP-712 signature from the wallet (auto-signed if omitted)")
+});
+var args = z.tuple([
+  z.string().describe("agent-id (token ID)"),
+  z.string().describe("wallet-address (0x...)")
+]);
+var EIP712_TYPES = {
+  AgentWalletSet: [
+    { name: "agentId", type: "uint256" },
+    { name: "newWallet", type: "address" },
+    { name: "owner", type: "address" },
+    { name: "deadline", type: "uint256" }
+  ]
+};
+function SetWallet({
+  options: { chainName, privateKey, broadcast, deadline: deadlineOpt, signature: signatureOpt },
+  args: [agentId, walletAddress]
+}) {
+  const { exit } = useApp();
+  const [state, setState] = React.useState({ status: "idle" });
+  React.useEffect(() => {
+    if (state.status === "done") exit();
+    else if (state.status === "error") exit(new Error(state.message));
+  }, [state, exit]);
+  React.useEffect(() => {
+    async function run() {
+      const { chain, registryAddress } = resolveChain(chainName);
+      const account = privateKeyToAccount(privateKey);
+      const publicClient = createPublicClient({ chain, transport: http() });
+      const tokenId = BigInt(agentId);
+      const chainId = await publicClient.getChainId();
+      const domain = {
+        name: "ERC8004IdentityRegistry",
+        version: "1",
+        chainId,
+        verifyingContract: registryAddress
+      };
+      let finalDeadline;
+      let finalSignature;
+      if (signatureOpt && deadlineOpt) {
+        finalDeadline = BigInt(deadlineOpt);
+        finalSignature = signatureOpt;
+        const valid = await verifyTypedData({
+          address: walletAddress,
+          domain,
+          types: EIP712_TYPES,
+          primaryType: "AgentWalletSet",
+          message: {
+            agentId: tokenId,
+            newWallet: walletAddress,
+            owner: account.address,
+            deadline: finalDeadline
+          },
+          signature: finalSignature
+        });
+        if (!valid) {
+          setState({
+            status: "error",
+            message: `Signature does not recover to wallet ${walletAddress}`
+          });
+          return;
+        }
+      } else {
+        const block = await publicClient.getBlock();
+        finalDeadline = block.timestamp + 240n;
+        const walletClient = createWalletClient({ account, chain, transport: http() });
+        finalSignature = await walletClient.signTypedData({
+          account,
+          domain,
+          types: EIP712_TYPES,
+          primaryType: "AgentWalletSet",
+          message: {
+            agentId: tokenId,
+            newWallet: walletAddress,
+            owner: account.address,
+            deadline: finalDeadline
+          }
+        });
+      }
+      if (!broadcast) {
+        const data = encodeFunctionData({
+          abi: IdentityRegistry_default,
+          functionName: "setAgentWallet",
+          args: [tokenId, walletAddress, finalDeadline, finalSignature]
+        });
+        let costLine = "  Est. Cost: unable to estimate";
+        try {
+          const est = await estimateCost(publicClient, {
+            account: account.address,
+            to: registryAddress,
+            data
+          });
+          costLine = `  Est. Cost: ${formatCost(est)}`;
+        } catch {
+        }
+        const lines = [
+          `Dry run \u2014 would call setAgentWallet on ${chainName}:`,
+          "",
+          `  Registry:  ${registryAddress}`,
+          `  Agent ID:  ${tokenId.toString()}`,
+          `  Wallet:    ${walletAddress}`,
+          `  Deadline:  ${finalDeadline.toString()}`,
+          `  Signer:    ${account.address}`,
+          `  Signature: ${signatureOpt ? "provided (verified)" : "auto-signed"}`,
+          costLine
+        ];
+        if (!signatureOpt) {
+          lines.push(
+            "",
+            "If the wallet is controlled by a different key, have them sign:",
+            "",
+            "  EIP-712 Domain:",
+            `    name:              ERC8004IdentityRegistry`,
+            `    version:           1`,
+            `    chainId:           ${chainId}`,
+            `    verifyingContract: ${registryAddress}`,
+            "",
+            "  Primary Type: AgentWalletSet",
+            "  Message:",
+            `    agentId:   ${tokenId.toString()}`,
+            `    newWallet: <wallet-address>`,
+            `    owner:     ${account.address}`,
+            `    deadline:  <unix-timestamp>`,
+            "",
+            "Then pass --signature <0x...> --deadline <timestamp>"
+          );
+        }
+        lines.push("", "Run with --broadcast to submit on-chain.");
+        setState({ status: "done", message: lines.join("\n") });
+        return;
+      }
+      setState({ status: "working", message: `Linking wallet on ${chainName}\u2026` });
+      try {
+        const walletClient = createWalletClient({ account, chain, transport: http() });
+        const { request } = await publicClient.simulateContract({
+          account,
+          address: registryAddress,
+          abi: IdentityRegistry_default,
+          functionName: "setAgentWallet",
+          args: [tokenId, walletAddress, finalDeadline, finalSignature]
+        });
+        const txHash = await walletClient.writeContract(request);
+        setState({
+          status: "done",
+          message: [
+            `\u2705 Wallet linked on ${chainName}`,
+            `   Agent ID: ${tokenId.toString()}`,
+            `   Wallet:   ${walletAddress}`,
+            `   Tx Hash:  ${txHash}`
+          ].join("\n")
+        });
+      } catch (err) {
+        setState({
+          status: "error",
+          message: `setAgentWallet failed: ${err.message}`
+        });
+      }
+    }
+    run();
+  }, [chainName, privateKey, broadcast, agentId, walletAddress, deadlineOpt, signatureOpt]);
+  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, state.status === "idle" && /* @__PURE__ */ React.createElement(Text, { color: "gray" }, "Preparing\u2026"), state.status === "working" && /* @__PURE__ */ React.createElement(Text, { color: "cyan" }, state.message), state.status === "done" && /* @__PURE__ */ React.createElement(Text, { color: "green" }, state.message), state.status === "error" && /* @__PURE__ */ React.createElement(Text, { color: "red" }, "\u274C ", state.message));
+}
+export {
+  args,
+  SetWallet as default,
+  description,
+  options
+};

package/dist/commands/registry/identity/unset-wallet.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import { z } from 'zod';
+
+declare const description = "Clear the verified wallet from an agent";
+declare const options: z.ZodObject<{
+    chainName: z.ZodDefault<z.ZodEnum<[string, ...string[]]>>;
+    privateKey: z.ZodString;
+    broadcast: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    chainName: string;
+    privateKey: string;
+    broadcast: boolean;
+}, {
+    privateKey: string;
+    chainName?: string | undefined;
+    broadcast?: boolean | undefined;
+}>;
+declare const args: z.ZodTuple<[z.ZodString], null>;
+type Props = {
+    options: z.infer<typeof options>;
+    args: z.infer<typeof args>;
+};
+declare function UnsetWallet({ options: { chainName, privateKey, broadcast }, args: [agentId], }: Props): React.JSX.Element;
+
+export { args, UnsetWallet as default, description, options };

package/dist/commands/registry/identity/unset-wallet.js

@@ -0,0 +1,108 @@
+import {
+  estimateCost,
+  formatCost
+} from "../../../chunk-X6M7WZJF.js";
+import {
+  IdentityRegistry_default,
+  SUPPORTED_CHAINS,
+  resolveChain
+} from "../../../chunk-DXAESRZH.js";
+import "../../../chunk-YZFATT7X.js";
+
+// src/commands/registry/identity/unset-wallet.tsx
+import { Box, Text, useApp } from "ink";
+import React from "react";
+import { encodeFunctionData, http, createPublicClient, createWalletClient } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { z } from "zod";
+var description = "Clear the verified wallet from an agent";
+var options = z.object({
+  chainName: z.enum(SUPPORTED_CHAINS).default("mainnet").describe("Chain name (e.g. mainnet, base, arbitrum, optimism)"),
+  privateKey: z.string().describe("Private key for signing (hex, prefixed with 0x)"),
+  broadcast: z.boolean().default(false).describe("Broadcast the transaction on-chain (default: dry run)")
+});
+var args = z.tuple([z.string().describe("agent-id (token ID)")]);
+function UnsetWallet({
+  options: { chainName, privateKey, broadcast },
+  args: [agentId]
+}) {
+  const { exit } = useApp();
+  const [state, setState] = React.useState({ status: "idle" });
+  React.useEffect(() => {
+    if (state.status === "done") exit();
+    else if (state.status === "error") exit(new Error(state.message));
+  }, [state, exit]);
+  React.useEffect(() => {
+    async function run() {
+      const { chain, registryAddress } = resolveChain(chainName);
+      const account = privateKeyToAccount(privateKey);
+      const tokenId = BigInt(agentId);
+      if (!broadcast) {
+        const publicClient = createPublicClient({ chain, transport: http() });
+        const data = encodeFunctionData({
+          abi: IdentityRegistry_default,
+          functionName: "unsetAgentWallet",
+          args: [tokenId]
+        });
+        let costLine = "  Est. Cost: unable to estimate";
+        try {
+          const est = await estimateCost(publicClient, {
+            account: account.address,
+            to: registryAddress,
+            data
+          });
+          costLine = `  Est. Cost: ${formatCost(est)}`;
+        } catch {
+        }
+        setState({
+          status: "done",
+          message: [
+            `Dry run \u2014 would call unsetAgentWallet on ${chainName}:`,
+            "",
+            `  Registry:  ${registryAddress}`,
+            `  Agent ID:  ${tokenId.toString()}`,
+            `  Signer:    ${account.address}`,
+            costLine,
+            "",
+            "Run with --broadcast to submit on-chain."
+          ].join("\n")
+        });
+        return;
+      }
+      setState({ status: "working", message: `Clearing wallet on ${chainName}\u2026` });
+      try {
+        const publicClient = createPublicClient({ chain, transport: http() });
+        const walletClient = createWalletClient({ account, chain, transport: http() });
+        const { request } = await publicClient.simulateContract({
+          account,
+          address: registryAddress,
+          abi: IdentityRegistry_default,
+          functionName: "unsetAgentWallet",
+          args: [tokenId]
+        });
+        const txHash = await walletClient.writeContract(request);
+        setState({
+          status: "done",
+          message: [
+            `\u2705 Wallet cleared on ${chainName}`,
+            `   Agent ID: ${tokenId.toString()}`,
+            `   Tx Hash:  ${txHash}`
+          ].join("\n")
+        });
+      } catch (err) {
+        setState({
+          status: "error",
+          message: `unsetAgentWallet failed: ${err.message}`
+        });
+      }
+    }
+    run();
+  }, [chainName, privateKey, broadcast, agentId]);
+  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, state.status === "idle" && /* @__PURE__ */ React.createElement(Text, { color: "gray" }, "Preparing\u2026"), state.status === "working" && /* @__PURE__ */ React.createElement(Text, { color: "cyan" }, state.message), state.status === "done" && /* @__PURE__ */ React.createElement(Text, { color: "green" }, state.message), state.status === "error" && /* @__PURE__ */ React.createElement(Text, { color: "red" }, "\u274C ", state.message));
+}
+export {
+  args,
+  UnsetWallet as default,
+  description,
+  options
+};

package/dist/commands/skill.js

@@ -1,3 +1,5 @@
+import "../chunk-YZFATT7X.js";
+
 // src/commands/skill.tsx
 import { copyFileSync, existsSync, readFileSync } from "fs";
 import { dirname, join, resolve } from "path";

package/dist/index.js

@@ -2,6 +2,7 @@ import {
   SCHEMA_8004_V2,
   validateRegistrationFile
 } from "./chunk-UDZL55XF.js";
+import "./chunk-YZFATT7X.js";
 export {
   SCHEMA_8004_V2,
   validateRegistrationFile