@stage-labs/metro 0.1.0-beta.153 → 0.1.0-beta.155

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.153",
+  "version": "0.1.0-beta.155",
   "description": "The metro command line. Sign in once per machine, then hand your MCP connector list to Claude Code without the credentials touching disk, argv or shell history.",
   "license": "MIT",
   "repository": {

package/runtime/marketplace/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.153",
+  "version": "0.1.0-beta.155",
   "description": "Metro for Claude Code, installed by the metro daemon on this machine: every connector the agent holds as its own MCP server relayed through the daemon, the orchestrator-only guard on the main thread, and the standing rules loaded at each session start. No vendor credential ever sits in a config file.",
   "author": {
     "name": "Bonustrack",

package/runtime/node_modules/@metro-labs/core/src/stations/types.ts

@@ -101,6 +101,7 @@ export interface Station {
   groupOps?: ReadonlySet<GroupOp>;
   resolvesSenders?: boolean;
   profileFields?: ReadonlySet<ProfileField>;
+  claimsName?: boolean;
   attachmentMode: AttachmentMode;
   sendAttachments?(
     line: string,

package/runtime/node_modules/@metro-labs/daemon/src/agents/account-routes.ts

@@ -10,7 +10,8 @@ export type AccountRoute =
   | { kind: 'allowlist'; station: StationName; accountId: string }
   | { kind: 'senders'; station: StationName; accountId: string }
   | { kind: 'resolve'; station: StationName; accountId: string }
-  | { kind: 'enabled'; station: StationName; accountId: string };
+  | { kind: 'enabled'; station: StationName; accountId: string }
+  | { kind: 'name'; station: StationName; accountId: string };
 
 const ROUTE_METHODS: Record<AccountRoute['kind'], string[]> = {
   start: ['POST'],
@@ -21,9 +22,10 @@ const ROUTE_METHODS: Record<AccountRoute['kind'], string[]> = {
   senders: ['GET'],
   resolve: ['GET'],
   enabled: ['PUT'],
+  name: ['GET', 'POST'],
 };
 
-const SUB_ROUTES = ['allowlist', 'senders', 'resolve', 'enabled'] as const;
+const SUB_ROUTES = ['allowlist', 'senders', 'resolve', 'enabled', 'name'] as const;
 
 type SubRoute = (typeof SUB_ROUTES)[number];
 

package/runtime/node_modules/@metro-labs/daemon/src/agents/accounts-api.ts

@@ -77,6 +77,11 @@ export interface AccountApiDeps {
     accountId: string,
     query: string,
   ) => Promise<unknown>;
+  accountCall: (
+    station: StationName,
+    action: string,
+    args: Record<string, unknown>,
+  ) => Promise<unknown>;
   setAccountEnabled: (
     subject: string,
     agentId: string,
@@ -110,6 +115,23 @@ async function handleResolve(
   sendJson(req, res, 200, found);
 }
 
+async function handleName(
+  req: IncomingMessage,
+  res: ServerResponse,
+  deps: AccountApiDeps,
+  target: { station: StationName; accountId: string },
+): Promise<void> {
+  if (stationByName(target.station)?.claimsName !== true)
+    throw new ApiError(`${target.station} accounts have no name to claim`, 400);
+  if (req.method === 'GET') {
+    sendJson(req, res, 200, await deps.accountCall(target.station, 'name', { account: target.accountId }));
+    return;
+  }
+  const label = bodyField(await readJsonBody(req), 'label');
+  if (typeof label !== 'string' || label.trim() === '') throw new ApiError('a label is required', 400);
+  sendJson(req, res, 200, await deps.accountCall(target.station, 'claim_name', { account: target.accountId, label }));
+}
+
 async function activate(
   deps: AccountApiDeps,
   station: StationName,
@@ -342,6 +364,7 @@ async function dispatchRoute(
   if (route.kind === 'allowlist') return handleAllowlist(req, res, deps, session, agentId, route);
   if (route.kind === 'enabled') return handleEnabled(req, res, deps, session, agentId, route);
   if (route.kind === 'resolve') return handleResolve(req, res, deps, route);
+  if (route.kind === 'name') return handleName(req, res, deps, route);
   if (route.kind === 'senders') {
     sendJson(req, res, 200, { senders: deps.recentSenders(route.station, route.accountId) });
     return;

package/runtime/node_modules/@metro-labs/daemon/src/mcp/profile-tool.ts

@@ -19,12 +19,14 @@ export const SET_PROFILE_TOOL = {
     '`profiles`); a field the station cannot set is refused by name, never dropped. Discord changes ' +
     'the bot username and app description (Discord allows two username changes an hour); Telegram ' +
     'bots set their name, description and photo; a Telegram user account sets its first name, bio ' +
-    '(70 chars) and photo; WhatsApp sets the profile name, about and picture. Visible to everyone ' +
+    '(70 chars) and photo; WhatsApp sets the profile name, about and picture; XMTP writes the ' +
+    'name, description and avatar records of the account\'s <label>.stage.base.eth name on Base, ' +
+    'so it needs a name first (claimed on the channel page, never by you). Visible to everyone ' +
     'who talks to the account, so do it when asked, not on your own. Returns {account, applied}.',
   inputSchema: {
     type: 'object',
     properties: {
-      station: { type: 'string', description: 'discord-bot | telegram-bot | telegram | whatsapp' },
+      station: { type: 'string', description: 'discord-bot | telegram-bot | telegram | whatsapp | xmtp' },
       account: { type: 'string', description: 'The account id on that station, from list_accounts.' },
       name: { type: 'string', description: 'The display name.' },
       bio: { type: 'string', description: 'The bio or about line.' },
@@ -46,7 +48,7 @@ export const profileCapabilities = (): Record<string, ProfileField[]> => {
 
 const asked = (a: Record<string, unknown>): ProfileField[] => PROFILE_FIELDS.filter((f) => a[f] !== undefined);
 
-type Target = { station: Station; fields: ProfileField[] } | { refused: string };
+type Target = { station: Station } | { refused: string };
 
 function targetOf(a: Record<string, unknown>): Target {
   const name = str(a.station);
@@ -59,7 +61,7 @@ function targetOf(a: Record<string, unknown>): Target {
   if (wanted.length === 0) return { refused: 'set_profile needs at least one of name, bio, avatar' };
   const refused = wanted.filter((f) => !fields.has(f));
   if (refused.length > 0) return { refused: `${name} cannot set ${refused.join(', ')}; it takes ${[...fields].join(', ')}` };
-  return { station, fields: wanted };
+  return { station };
 }
 
 function trainArgs(a: Record<string, unknown>, picture: ResolvedAttachment | undefined): Record<string, unknown> {

package/runtime/node_modules/@metro-labs/daemon/src/routes/local-mode.ts

@@ -98,7 +98,8 @@ function agentApi(deps: LocalModeDeps): AgentApiDeps {
     setAllowlist: localSetAllowlist,
     setAccountEnabled: localSetAccountEnabled,
     recentSenders,
-    resolveSender,
+    resolveSender: (station, accountId, query) => accountCall(station, 'resolve_sender', { account: accountId, query }),
+    accountCall,
     reloadAgents: deps.reloadAgents,
   };
 }
@@ -169,17 +170,14 @@ function localModeInfo(): ModeInfo {
   return { mode: 'local', owner: localOwner(), project: LOCAL_PROJECT_ID, version: METRO_VERSION };
 }
 
-async function resolveSender(
+async function accountCall(
   station: StationName,
-  accountId: string,
-  query: string,
+  action: string,
+  args: Record<string, unknown>,
 ): Promise<unknown> {
   let response;
   try {
-    response = await forwardTrainCall(station, 'resolve_sender', {
-      account: accountId,
-      query,
-    });
+    response = await forwardTrainCall(station, action, args);
   } catch (err) {
     throw new ApiError(
       `metro could not reach the ${station} train: ${errMsg(err)}`,

package/runtime/node_modules/@metro-labs/daemon/src/stations/attach-xmtp.ts

@@ -89,7 +89,7 @@ export async function verifyXmtpKeyOutOfProcess(
   dbPath: string,
 ): Promise<XmtpIdentity> {
   const raw = await runVerifier(
-    JSON.stringify({ privateKey, dbPath }),
+    JSON.stringify({ privateKey, dbPath, smart: true }),
   ).catch((err: unknown) => {
     log.warn({ err: errMsg(err) }, 'attach-xmtp: could not run the inbox check');
     throw new XmtpAttachError(UNREACHABLE);

package/runtime/node_modules/@metro-labs/daemon/src/stations/attach.ts

@@ -158,7 +158,7 @@ async function prepareXmtp(verify: VerifyXmtpKey): Promise<PreparedAccount> {
     ),
   );
   return {
-    config: { privateKey, dbPath },
+    config: { privateKey, dbPath, smart: true },
     identity: { inboxId: identity.inboxId, address: identity.address },
     secret: {
       label: 'xmtp private key',

package/runtime/node_modules/@metro-labs/xmtp/package.json

@@ -21,6 +21,8 @@
     "@xmtp/content-type-wallet-send-calls": "^2.0.0",
     "@xmtp/node-bindings": "1.9.1",
     "@xmtp/node-sdk": "^6.0.0",
+    "@zerodev/ecdsa-validator": "5.4.9",
+    "@zerodev/sdk": "5.5.10",
     "viem": "^2.52.2"
   },
   "devDependencies": {

package/runtime/node_modules/@metro-labs/xmtp/src/accounts.ts

@@ -7,7 +7,8 @@ import { homedir } from 'node:os';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { CODECS } from './codecs.js';
-import { expandHome, signerFor, XMTP_ENV } from './identity.js';
+import { expandHome, identityFor, XMTP_ENV } from './identity.js';
+import type { SmartAccount } from './smart.js';
 import {
   makeAccountStore,
   resolveAccountId,
@@ -23,6 +24,7 @@ export interface AccountConfig {
   privateKey?: string;
   owner?: string;
   dbPath?: string;
+  smart?: boolean;
 }
 
 export const { loadAccounts } = makeAccountStore<AccountConfig>({
@@ -50,18 +52,19 @@ export interface Account {
   client: Client<unknown>;
   inboxId: string;
   address: string;
+  smart: SmartAccount | null;
 }
 export const accounts = new Map<string, Account>();
 
 export async function bootAccount(cfg: AccountConfig): Promise<void> {
-  const { signer, address } = signerFor(resolvePrivateKey(cfg));
+  const { signer, address, smart } = await identityFor(resolvePrivateKey(cfg), cfg.smart === true);
   const dbPath = expandHome(
     cfg.dbPath ?? join(homedir(), '.metro', `xmtp-${XMTP_ENV}-${cfg.id}.db3`),
   );
   const fresh = !existsSync(dbPath);
   const options: ClientOptions = { env: XMTP_ENV, codecs: CODECS(), dbPath };
   const client: Client<unknown> = await Client.create(signer, options);
-  accounts.set(cfg.id, { cfg, client, inboxId: client.inboxId, address });
+  accounts.set(cfg.id, { cfg, client, inboxId: client.inboxId, address, smart });
   if (fresh)
     process.stderr.write(
       `xmtp[${cfg.id}] registered a NEW installation for this machine — ` +

package/runtime/node_modules/@metro-labs/xmtp/src/actions.ts

@@ -21,6 +21,7 @@ import {
 import { convHandlers } from './actions-conv.js';
 import { normalizeXmtp } from '@metro-labs/core/stations/messaging-normalize';
 import { TrainError } from '@metro-labs/core/train-error';
+import { claimNameAction, nameAction, setProfile } from './profile.js';
 import { makeStation, type CallMsg } from '@metro-labs/core/stations/station-runtime';
 
 type Args = Record<string, unknown>;
@@ -338,6 +339,7 @@ async function accountsAction(id: string): Promise<void> {
         url: `https://stage.box/#/${a.address}`,
         address: a.address,
         inboxId: a.inboxId,
+        smart: a.smart !== null,
         env: 'production',
         owner: a.cfg.owner ?? null,
         keySource: 'privateKey',
@@ -353,6 +355,9 @@ function unsupportedVerb(id: string, verb: string): Promise<void> {
 
 const handlers: Record<string, (id: string, args: Args) => Promise<void>> = {
   accounts: (id) => accountsAction(id),
+  set_profile: setProfile,
+  claim_name: claimNameAction,
+  name: nameAction,
   send,
   ask,
   sendPoll: ask,

package/runtime/node_modules/@metro-labs/xmtp/src/identity.ts

@@ -2,32 +2,46 @@ import { IdentifierKind, type Signer } from '@xmtp/node-sdk';
 import { privateKeyToAccount } from 'viem/accounts';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { SMART_CHAIN_ID, smartAccountFor, type SmartAccount } from './smart.js';
 
 export const XMTP_ENV = 'production' as const;
 
 export const expandHome = (p: string): string =>
   p.startsWith('~') ? join(homedir(), p.slice(1)) : p;
 
-export function signerFor(privateKey: string): {
+export interface Identity {
   signer: Signer;
   address: string;
-} {
+  smart: SmartAccount | null;
+}
+
+const bytesOf = (sig: string): Uint8Array => {
+  const hex = sig.slice(2);
+  const out = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < out.length; i++) out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  return out;
+};
+
+export function signerFor(privateKey: string): Identity {
   const acct = privateKeyToAccount(privateKey as `0x${string}`);
   const signer: Signer = {
     type: 'EOA',
-    getIdentifier: () =>
-      Promise.resolve({
-        identifier: acct.address,
-        identifierKind: IdentifierKind.Ethereum,
-      }),
-    signMessage: async (msg: string) => {
-      const sig = await acct.signMessage({ message: msg });
-      const hex = sig.slice(2);
-      const out = new Uint8Array(hex.length / 2);
-      for (let i = 0; i < out.length; i++)
-        out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-      return out;
-    },
+    getIdentifier: () => Promise.resolve({ identifier: acct.address, identifierKind: IdentifierKind.Ethereum }),
+    signMessage: async (msg: string) => bytesOf(await acct.signMessage({ message: msg })),
+  };
+  return { signer, address: acct.address, smart: null };
+}
+
+export async function smartSignerFor(privateKey: string, rpc?: string): Promise<Identity> {
+  const smart = await smartAccountFor(privateKey, rpc);
+  const signer: Signer = {
+    type: 'SCW',
+    getIdentifier: () => Promise.resolve({ identifier: smart.address, identifierKind: IdentifierKind.Ethereum }),
+    signMessage: async (msg: string) => bytesOf(await smart.signMessage(msg)),
+    getChainId: () => BigInt(SMART_CHAIN_ID),
   };
-  return { signer, address: acct.address };
+  return { signer, address: smart.address, smart };
 }
+
+export const identityFor = (privateKey: string, smart: boolean): Promise<Identity> =>
+  smart ? smartSignerFor(privateKey) : Promise.resolve(signerFor(privateKey));

package/runtime/node_modules/@metro-labs/xmtp/src/names.ts

@@ -0,0 +1,61 @@
+import { TrainError } from '@metro-labs/core/train-error';
+
+export const STAGE_NAMES_PARENT = 'stage.base.eth';
+export const STAGE_PROXY = 'https://proxy.stage.box';
+const LABEL_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const MIN = 6;
+const MAX = 32;
+const HEADERS = { 'content-type': 'application/json', 'x-stage-client': '1' };
+
+export const proxyBase = (): string => process.env.METRO_STAGE_PROXY ?? STAGE_PROXY;
+
+export const stageNameOf = (label: string): string => `${label}.${STAGE_NAMES_PARENT}`;
+
+export function parseLabel(raw: unknown): string {
+  const label = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
+  if (label.length < MIN) throw new TrainError('bad_request', `a name needs at least ${String(MIN)} characters`);
+  if (label.length > MAX) throw new TrainError('bad_request', `a name can have at most ${String(MAX)} characters`);
+  if (!LABEL_RE.test(label)) throw new TrainError('bad_request', 'a name is lowercase letters, digits and single inner hyphens');
+  return label;
+}
+
+export const claimMessage = (label: string, address: string, issuedAt: number): string =>
+  `Claim ${stageNameOf(label)} for ${address.toLowerCase()} at ${String(issuedAt)}`;
+
+async function ask(path: string, init: RequestInit, fetchImpl: typeof fetch): Promise<Record<string, unknown>> {
+  let res: Response;
+  try {
+    res = await fetchImpl(`${proxyBase()}/names/${path}`, { ...init, headers: HEADERS, signal: AbortSignal.timeout(30_000) });
+  } catch (err) {
+    throw new TrainError('names_unreachable', `could not reach the stage name service: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const body: unknown = await res.json().catch(() => null);
+  const record = typeof body === 'object' && body !== null ? (body as Record<string, unknown>) : {};
+  if (!res.ok) throw new TrainError('names_refused', typeof record.error === 'string' ? record.error : `the stage name service answered ${String(res.status)}`);
+  return record;
+}
+
+export async function nameOf(address: string, fetchImpl: typeof fetch = fetch): Promise<string | null> {
+  const body = await ask(`status?address=${encodeURIComponent(address)}`, {}, fetchImpl);
+  return typeof body.name === 'string' && body.name !== '' ? body.name : null;
+}
+
+export async function checkLabel(label: string, fetchImpl: typeof fetch = fetch): Promise<void> {
+  const body = await ask(`check?label=${encodeURIComponent(label)}`, {}, fetchImpl);
+  if (body.valid !== true) throw new TrainError('bad_request', typeof body.reason === 'string' ? body.reason : `${stageNameOf(label)} is not a valid name`);
+  if (body.available !== true) throw new TrainError('name_taken', `${stageNameOf(label)} is already taken`);
+}
+
+export async function claimName(
+  label: string,
+  address: string,
+  sign: (message: string) => Promise<string>,
+  fetchImpl: typeof fetch = fetch,
+  now = Date.now(),
+): Promise<string> {
+  await checkLabel(label, fetchImpl);
+  const signature = await sign(claimMessage(label, address, now));
+  const body = await ask('claim', { method: 'POST', body: JSON.stringify({ label, address, issuedAt: now, signature }) }, fetchImpl);
+  if (typeof body.name !== 'string' || body.name === '') throw new TrainError('names_refused', 'the stage name service issued no name');
+  return body.name;
+}

package/runtime/node_modules/@metro-labs/xmtp/src/profile.ts

@@ -0,0 +1,112 @@
+import { readFile } from 'node:fs/promises';
+import { encodeFunctionData, namehash, type Hex } from 'viem';
+import { normalize } from 'viem/ens';
+import { TrainError } from '@metro-labs/core/train-error';
+import {
+  assertImage,
+  fieldsOf,
+  parseProfileChange,
+  type ProfileApplied,
+  type ProfileAvatar,
+  type ProfileChange,
+} from '@metro-labs/core/stations/profile';
+import { accountForCall } from './accounts.js';
+import { claimName, nameOf, parseLabel } from './names.js';
+import { sendSponsored, type SmartAccount } from './smart.js';
+import { respond } from './wire.js';
+
+export const BASENAME_REGISTRY = '0xB94704422c2a1E396835A571837Aa5AE53285a95' as const;
+export const BASENAME_L2_RESOLVER = '0xC6d566A56A1aFf6508b41f6c90ff131615583BCD' as const;
+export const PINEAPPLE_UPLOAD_URL = 'https://pineapple.fyi/upload';
+const STAMP_CLEAR_URL = 'https://stamp.fyi/clear/';
+const ZERO = '0x0000000000000000000000000000000000000000';
+const TEXT_KEYS = { name: 'name', bio: 'description', avatar: 'avatar' } as const;
+
+const REGISTRY_ABI = [
+  { name: 'resolver', type: 'function', stateMutability: 'view', inputs: [{ name: 'node', type: 'bytes32' }], outputs: [{ name: '', type: 'address' }] },
+] as const;
+
+const RESOLVER_ABI = [
+  {
+    name: 'setText',
+    type: 'function',
+    stateMutability: 'nonpayable',
+    inputs: [{ name: 'node', type: 'bytes32' }, { name: 'key', type: 'string' }, { name: 'value', type: 'string' }],
+    outputs: [],
+  },
+  { name: 'multicall', type: 'function', stateMutability: 'nonpayable', inputs: [{ name: 'data', type: 'bytes[]' }], outputs: [{ name: 'results', type: 'bytes[]' }] },
+] as const;
+
+type Args = Record<string, unknown>;
+
+const NO_NAME = 'this XMTP account has no name yet, so it has no profile: claim a <label>.stage.base.eth name on its channel page first';
+const NOT_SMART = 'this XMTP account was attached before names existed and cannot hold one; attach XMTP again to get an account that can';
+
+export async function pinAvatar(avatar: ProfileAvatar, fetchImpl: typeof fetch = fetch): Promise<string> {
+  assertImage(avatar);
+  const form = new FormData();
+  form.append('file', new Blob([await readFile(avatar.path)], { type: avatar.mime }), avatar.name);
+  const res = await fetchImpl(PINEAPPLE_UPLOAD_URL, { method: 'POST', body: form, signal: AbortSignal.timeout(60_000) });
+  const body = (await res.json().catch(() => ({}))) as { result?: { cid?: string }; error?: { message?: string } };
+  if (!res.ok) throw new TrainError('avatar_upload', `the image upload answered ${String(res.status)}`);
+  if (typeof body.error?.message === 'string') throw new TrainError('avatar_upload', body.error.message);
+  if (typeof body.result?.cid !== 'string' || body.result.cid === '') throw new TrainError('avatar_upload', 'the image upload returned no CID');
+  return `ipfs://${body.result.cid}`;
+}
+
+export function encodeTextRecords(name: string, records: Record<string, string>): Hex {
+  const node = namehash(normalize(name));
+  const calls = Object.entries(records).map(([key, value]) => encodeFunctionData({ abi: RESOLVER_ABI, functionName: 'setText', args: [node, key, value] }));
+  return encodeFunctionData({ abi: RESOLVER_ABI, functionName: 'multicall', args: [calls] });
+}
+
+async function resolverFor(smart: SmartAccount, name: string): Promise<Hex> {
+  const found: Hex = await smart.publicClient.readContract({ address: BASENAME_REGISTRY, abi: REGISTRY_ABI, functionName: 'resolver', args: [namehash(normalize(name))] });
+  return found === ZERO ? BASENAME_L2_RESOLVER : found;
+}
+
+async function recordsFor(change: ProfileChange, fetchImpl: typeof fetch): Promise<Record<string, string>> {
+  const records: Record<string, string> = {};
+  if (change.name !== undefined) records[TEXT_KEYS.name] = change.name;
+  if (change.bio !== undefined) records[TEXT_KEYS.bio] = change.bio;
+  if (change.avatar !== undefined) records[TEXT_KEYS.avatar] = await pinAvatar(change.avatar, fetchImpl);
+  return records;
+}
+
+export async function writeProfile(smart: SmartAccount, name: string, change: ProfileChange, fetchImpl: typeof fetch = fetch): Promise<Hex> {
+  const records = await recordsFor(change, fetchImpl);
+  const hash = await sendSponsored(smart, await resolverFor(smart, name), encodeTextRecords(name, records));
+  const id = smart.address.toLowerCase();
+  await Promise.all([fetchImpl(`${STAMP_CLEAR_URL}address/${id}`), fetchImpl(`${STAMP_CLEAR_URL}avatar/eth:${id}`)]).catch(() => undefined);
+  return hash;
+}
+
+const smartOf = (args: Args): { accountId: string; address: string; smart: SmartAccount } => {
+  const acct = accountForCall(args);
+  if (acct.smart === null) throw new TrainError('no_name', NOT_SMART);
+  return { accountId: acct.cfg.id, address: acct.address, smart: acct.smart };
+};
+
+export async function setProfile(id: string, args: Args): Promise<void> {
+  const { accountId, address, smart } = smartOf(args);
+  const change = parseProfileChange(args);
+  const name = await nameOf(address);
+  if (name === null) throw new TrainError('no_name', NO_NAME);
+  const tx = await writeProfile(smart, name, change);
+  const result: ProfileApplied & { name: string; tx: string } = { account: accountId, applied: fieldsOf(change), name, tx };
+  respond(id, { result });
+}
+
+export async function claimNameAction(id: string, args: Args): Promise<void> {
+  const { accountId, address, smart } = smartOf(args);
+  const held = await nameOf(address);
+  if (held !== null) throw new TrainError('name_held', `this account already holds ${held}`);
+  const name = await claimName(parseLabel(args.label), address, (message) => smart.signMessage(message));
+  respond(id, { result: { account: accountId, name } });
+}
+
+export async function nameAction(id: string, args: Args): Promise<void> {
+  const acct = accountForCall(args);
+  const name = acct.smart === null ? null : await nameOf(acct.address);
+  respond(id, { result: { account: acct.cfg.id, name, canClaim: acct.smart !== null && name === null } });
+}

package/runtime/node_modules/@metro-labs/xmtp/src/smart.ts

@@ -0,0 +1,72 @@
+import { createPublicClient, http, type Hex } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { base } from 'viem/chains';
+import {
+  createKernelAccount,
+  createKernelAccountClient,
+  createZeroDevPaymasterClient,
+  getUserOperationGasPrice,
+  type KernelAccountClient,
+} from '@zerodev/sdk';
+import { getEntryPoint, KERNEL_V3_1 } from '@zerodev/sdk/constants';
+import { signerToEcdsaValidator } from '@zerodev/ecdsa-validator';
+
+export const SMART_CHAIN_ID = 8453;
+const STAGE_ZERODEV_PROJECT = 'c107f734-f7bb-48c1-a5d2-ceb3f70a42f6';
+const ENTRY_POINT = getEntryPoint('0.7');
+
+export const zerodevRpc = (): string =>
+  `https://rpc.zerodev.app/api/v3/${process.env.METRO_ZERODEV_PROJECT ?? STAGE_ZERODEV_PROJECT}/chain/${String(SMART_CHAIN_ID)}`;
+
+const makePublicClient = (rpc: string) => createPublicClient({ chain: base, transport: http(rpc) });
+
+export type BaseClient = ReturnType<typeof makePublicClient>;
+
+export interface SmartAccount {
+  address: Hex;
+  publicClient: BaseClient;
+  client: () => KernelAccountClient;
+  signMessage: (message: string) => Promise<Hex>;
+  deployed: () => Promise<boolean>;
+}
+
+export async function smartAccountFor(privateKey: string, rpc = zerodevRpc()): Promise<SmartAccount> {
+  const owner = privateKeyToAccount(privateKey as Hex);
+  const publicClient = makePublicClient(rpc);
+  const validator = await signerToEcdsaValidator(publicClient, { signer: owner, entryPoint: ENTRY_POINT, kernelVersion: KERNEL_V3_1 });
+  const account = await createKernelAccount(publicClient, { plugins: { sudo: validator }, entryPoint: ENTRY_POINT, kernelVersion: KERNEL_V3_1, index: 0n });
+  const paymaster = createZeroDevPaymasterClient({ chain: base, transport: http(rpc) });
+  const client = (): KernelAccountClient =>
+    createKernelAccountClient({
+      account,
+      chain: base,
+      bundlerTransport: http(rpc),
+      client: publicClient,
+      paymaster: { getPaymasterData: (userOperation) => paymaster.sponsorUserOperation({ userOperation }) },
+      userOperation: { estimateFeesPerGas: ({ bundlerClient }) => getUserOperationGasPrice(bundlerClient) },
+    });
+  return {
+    address: account.address,
+    publicClient,
+    client,
+    signMessage: (message) => account.signMessage({ message }),
+    deployed: async () => {
+      const code = await publicClient.getCode({ address: account.address });
+      return code !== undefined && code !== '0x';
+    },
+  };
+}
+
+export async function sendSponsored(smart: SmartAccount, to: Hex, data: Hex): Promise<Hex> {
+  const client = smart.client();
+  const hash = await client.sendTransaction({ to, data, value: 0n } as Parameters<typeof client.sendTransaction>[0]);
+  const receipt = await smart.publicClient.waitForTransactionReceipt({ hash });
+  if (receipt.status !== 'success') throw new Error(`the Base transaction ${hash} reverted`);
+  return hash;
+}
+
+export async function ensureDeployed(smart: SmartAccount): Promise<boolean> {
+  if (await smart.deployed()) return false;
+  await sendSponsored(smart, smart.address, '0x');
+  return true;
+}

package/runtime/node_modules/@metro-labs/xmtp/src/station.ts

@@ -1,4 +1,5 @@
 import type { GroupOp, Station, Verb } from '@metro-labs/core/stations/types';
+import { PROFILE_FIELDS, type ProfileField } from '@metro-labs/core/stations/profile';
 import { XMTP_TOOLS, xmtpSendAttachments } from './tools.js';
 
 export const xmtpStation: Station = {
@@ -8,6 +9,8 @@ export const xmtpStation: Station = {
   messageVerbs: new Set<Verb>(['send', 'reply', 'react', 'unreact', 'read']),
   groupOps: new Set<GroupOp>(['create_group', 'add_members', 'remove_members']),
   attachmentMode: 'native',
+  profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  claimsName: true,
   sendAttachments: xmtpSendAttachments,
   tools: XMTP_TOOLS,
 };

package/runtime/node_modules/@metro-labs/xmtp/src/verify.ts

@@ -1,7 +1,8 @@
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { Client, type ClientOptions, type Signer } from '@xmtp/node-sdk';
-import { expandHome, signerFor, XMTP_ENV } from './identity.js';
+import { expandHome, identityFor, signerFor, XMTP_ENV } from './identity.js';
+import { ensureDeployed } from './smart.js';
 
 export class XmtpVerifyError extends Error {}
 
@@ -10,6 +11,7 @@ export interface XmtpVerified {
   address: string;
   installationId: string;
   dbPath: string;
+  smart: boolean;
 }
 
 interface RegisteredClient {
@@ -34,15 +36,25 @@ const reason = (err: unknown): string =>
 export async function verifyXmtpKey(
   privateKey: string,
   dbPath: string,
+  smart = false,
   create: CreateXmtpClient = openInbox,
 ): Promise<XmtpVerified> {
-  let signer: Signer;
-  let address: string;
+  let identity: Awaited<ReturnType<typeof identityFor>>;
   try {
-    ({ signer, address } = signerFor(privateKey));
+    signerFor(privateKey);
   } catch {
     throw new XmtpVerifyError('that is not a usable XMTP private key');
   }
+  try {
+    identity = await identityFor(privateKey, smart);
+  } catch (err) {
+    throw new XmtpVerifyError(`could not build the smart account on Base: ${reason(err)}`);
+  }
+  const { signer, address } = identity;
+  if (identity.smart !== null)
+    await ensureDeployed(identity.smart).catch((err: unknown) => {
+      throw new XmtpVerifyError(`could not deploy the smart account on Base (is the ZeroDev sponsorship still on?): ${reason(err)}`);
+    });
   const resolved = expandHome(dbPath);
   mkdirSync(dirname(resolved), { recursive: true });
   const client = await create(signer, resolved).catch((err: unknown) => {
@@ -59,6 +71,7 @@ export async function verifyXmtpKey(
     address,
     installationId: client.installationId,
     dbPath: resolved,
+    smart,
   };
 }
 
@@ -68,10 +81,11 @@ async function runCli(): Promise<void> {
     const input = JSON.parse(readFileSync(0, 'utf8')) as {
       privateKey?: unknown;
       dbPath?: unknown;
+      smart?: unknown;
     };
     if (typeof input.privateKey !== 'string' || typeof input.dbPath !== 'string')
       throw new XmtpVerifyError('xmtp verify needs a privateKey and a dbPath');
-    out = { ok: true, ...(await verifyXmtpKey(input.privateKey, input.dbPath)) };
+    out = { ok: true, ...(await verifyXmtpKey(input.privateKey, input.dbPath, input.smart === true)) };
   } catch (err) {
     out = { ok: false, error: reason(err) };
   }

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.153"
+  "version": "0.1.0-beta.155"
 }

package/runtime/stations.json

@@ -15,6 +15,8 @@
       "@xmtp/content-type-wallet-send-calls": "^2.0.0",
       "@xmtp/node-bindings": "1.9.1",
       "@xmtp/node-sdk": "^6.0.0",
+      "@zerodev/ecdsa-validator": "5.4.9",
+      "@zerodev/sdk": "5.5.10",
       "viem": "^2.52.2"
     },
     "telegram-bot": {},