@stage-labs/metro 0.1.0-beta.21 → 0.1.0-beta.211

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

@@ -1,4 +1,4 @@
-import { errMsg } from '@metro-labs/mcp/log';
+import { errMsg } from '@metro-labs/core/log';
 import { ConsentState, type DecodedMessage } from '@xmtp/node-sdk';
 import {
   accounts,
@@ -6,10 +6,12 @@ import {
   loadAccounts,
   type Account,
 } from './accounts.js';
-import { emitInbound, envelope } from './emit.js';
+import { emitInbound } from '@metro-labs/core/stations/train-events';
+import { announceAccounts } from '@metro-labs/core/stations/train-boot';
+import { envelope } from './emit.js';
 import { groupNameFor } from './conv-helpers.js';
-import { handleControlDm, pushInbound } from './push.js';
-import { readCalls } from '@metro-labs/mcp/trains/protocol';
+import { senderFieldsNow } from './sender.js';
+import { readCalls } from '@metro-labs/core/trains/protocol';
 import { handleCall } from './actions.js';
 
 readCalls('xmtp', handleCall);
@@ -59,21 +61,15 @@ async function handleStreamMessage(
   const { id } = acct.cfg;
   if (msg.senderInboxId === acct.client.inboxId) return;
   if (SILENT_TYPES.has(msg.contentType?.typeId ?? '')) return;
-  if (handleControlDm(id, msg)) return;
   const conv = await acct.client.conversations.getConversationById(
     msg.conversationId,
   );
   if (!conv) return;
   const env = envelope(id, msg, conv);
+  Object.assign(env, senderFieldsNow(acct, msg.senderInboxId));
   const name = await groupNameFor(msg.conversationId, conv);
-  if (name) {
-    env.line_name = name;
-    env.lineName = name;
-    const p = (env.payload ?? {}) as Record<string, unknown>;
-    env.payload = { ...p, lineName: name };
-  }
+  if (name) env.line_name = name;
   emitInbound(id, env);
-  pushInbound(id, env, msg, conv);
 }
 
 async function runAccount(acct: Account): Promise<void> {
@@ -88,7 +84,9 @@ async function runAccount(acct: Account): Promise<void> {
       });
       for await (const msg of stream) {
         if (!msg) continue;
-        await handleStreamMessage(acct, msg);
+        await handleStreamMessage(acct, msg).catch((err: unknown) => {
+          process.stderr.write(`xmtp[${id}] one message failed and was skipped: ${errMsg(err)}\n`);
+        });
       }
     } catch (err) {
       process.stderr.write(
@@ -109,13 +107,7 @@ for (const cfg of cfgs) {
     );
   }
 }
-if (accounts.size === 0) {
-  process.stderr.write('xmtp: no accounts booted, exiting\n');
-  process.exit(2);
-}
-process.stderr.write(
-  `xmtp train ready — ${accounts.size} account(s): ${[...accounts.keys()].join(', ')}\n`,
-);
+announceAccounts('xmtp', accounts.keys());
 
 for (const acct of accounts.values())
   runAccount(acct).catch((err: unknown) => {

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

@@ -11,7 +11,7 @@ export interface GroupLike {
 const MAX_LABELS = 16;
 const MAX_LABEL_LEN = 24;
 
-export function cleanLabels(raw: unknown): string[] {
+function cleanLabels(raw: unknown): string[] {
   if (!Array.isArray(raw)) return [];
   const out: string[] = [];
   const seen = new Set<string>();
@@ -41,24 +41,6 @@ function parseAppDataObject(
   return {};
 }
 
-export function labelsBlob(
-  existingAppData: string | undefined,
-  labels: string[],
-  github?: string,
-): string {
-  const existing = parseAppDataObject(existingAppData);
-  const blob: Record<string, unknown> = {
-    ...existing,
-    v: 1,
-    labels: cleanLabels(labels),
-  };
-  if (typeof github === 'string') {
-    if (github.trim()) blob.github = github.trim();
-    else delete blob.github;
-  }
-  return JSON.stringify(blob);
-}
-
 function trimmedString(v: unknown): string | undefined {
   return typeof v === 'string' && v.trim() ? v.trim() : undefined;
 }

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

@@ -1,4 +1,4 @@
-import { TrainError } from '@metro-labs/mcp/train-error';
+import { TrainError } from '@metro-labs/core/train-error';
 
 type Args = Record<string, unknown>;
 

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,153 @@
+import { readFile } from 'node:fs/promises';
+import { encodeFunctionData, encodePacked, keccak256, namehash, stringToBytes, 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 '@metro-labs/core/stations/station-runtime';
+
+export const BASENAME_REGISTRY = '0xB94704422c2a1E396835A571837Aa5AE53285a95' as const;
+export const BASENAME_L2_RESOLVER = '0xC6d566A56A1aFf6508b41f6c90ff131615583BCD' as const;
+export const BASENAME_REVERSE_REGISTRAR = '0x79EA96012eEa67A83431F1701B3dFf7e37F9E282' 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;
+
+export 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;
+
+const REVERSE_ABI = [
+  { name: 'setName', type: 'function', stateMutability: 'nonpayable', inputs: [{ name: 'name', type: 'string' }], outputs: [{ name: '', type: 'bytes32' }] },
+] as const;
+
+export const NAME_ABI = [
+  { name: 'name', type: 'function', stateMutability: 'view', inputs: [{ name: 'node', type: 'bytes32' }], outputs: [{ name: '', type: 'string' }] },
+] as const;
+
+const BASE_REVERSE_ROOT = namehash('80002105.reverse');
+
+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 const encodePrimaryName = (name: string): Hex => encodeFunctionData({ abi: REVERSE_ABI, functionName: 'setName', args: [name] });
+
+export const reverseNodeOf = (address: string): Hex =>
+  keccak256(encodePacked(['bytes32', 'bytes32'], [BASE_REVERSE_ROOT, keccak256(stringToBytes(address.slice(2).toLowerCase()))]));
+
+async function resolverOf(smart: SmartAccount, node: Hex): Promise<Hex> {
+  const found: Hex = await smart.publicClient.readContract({ address: BASENAME_REGISTRY, abi: REGISTRY_ABI, functionName: 'resolver', args: [node] });
+  return found === ZERO ? BASENAME_L2_RESOLVER : found;
+}
+
+export async function primaryNameOf(smart: SmartAccount): Promise<string | null> {
+  const node = reverseNodeOf(smart.address);
+  const found = await smart.publicClient.readContract({ address: await resolverOf(smart, node), abi: NAME_ABI, functionName: 'name', args: [node] }).catch(() => '');
+  return found === '' ? null : found;
+}
+
+export async function setPrimaryName(smart: SmartAccount, name: string): Promise<boolean> {
+  try {
+    await sendSponsored(smart, BASENAME_REVERSE_REGISTRAR, encodePrimaryName(name));
+    return true;
+  } catch (err) {
+    process.stderr.write(`xmtp: the name ${name} is claimed but not set as the primary name of ${smart.address}: ${err instanceof Error ? err.message : String(err)}\n`);
+    return false;
+  }
+}
+
+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] });
+}
+
+const resolverFor = (smart: SmartAccount, name: string): Promise<Hex> => resolverOf(smart, namehash(normalize(name)));
+
+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));
+  const primary = await setPrimaryName(smart, name);
+  respond(id, { result: { account: accountId, name, primary } });
+}
+
+export async function ensurePrimaryName(smart: SmartAccount, name: string): Promise<boolean> {
+  if ((await primaryNameOf(smart)) === name) return true;
+  return setPrimaryName(smart, 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);
+  const primary = acct.smart !== null && name !== null ? await ensurePrimaryName(acct.smart, name) : false;
+  respond(id, { result: { account: acct.cfg.id, name, primary, canClaim: acct.smart !== null && name === null } });
+}

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

@@ -0,0 +1,112 @@
+import { createPublicClient, http, namehash, type Hex } from 'viem';
+import { base } from 'viem/chains';
+import { normalize } from 'viem/ens';
+import { makeProfileCache, type SenderProfile as Profile } from '@metro-labs/core/stations/sender-profile';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+import { TrainError } from '@metro-labs/core/train-error';
+import { accountForCall, accounts, type Account } from './accounts.js';
+import { resolveAddresses } from './conv-helpers.js';
+import { nameOf } from './names.js';
+import { BASENAME_L2_RESOLVER, BASENAME_REGISTRY, NAME_ABI, REGISTRY_ABI, reverseNodeOf } from './profile.js';
+
+export interface SenderProfile {
+  address: string;
+  name: string | null;
+  displayName: string | null;
+  about: string | null;
+  avatar: string | null;
+}
+
+const BASE_RPC = 'https://rpc.brovider.xyz/8453';
+const ZERO = '0x0000000000000000000000000000000000000000';
+const AVATAR_RE = /^(https?:\/\/|ipfs:\/\/|data:image\/)/i;
+
+const TEXT_ABI = [
+  { name: 'addr', type: 'function', stateMutability: 'view', inputs: [{ name: 'node', type: 'bytes32' }], outputs: [{ name: '', type: 'address' }] },
+  {
+    name: 'text',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [{ name: 'node', type: 'bytes32' }, { name: 'key', type: 'string' }],
+    outputs: [{ name: '', type: 'string' }],
+  },
+] as const;
+
+export const baseRpc = (): string => process.env.METRO_BASE_RPC ?? BASE_RPC;
+
+const makeReader = (rpc: string) => createPublicClient({ chain: base, transport: http(rpc), batch: { multicall: true } });
+
+export type Reader = ReturnType<typeof makeReader>;
+
+let reader: Reader | null = null;
+const readerFor = (): Reader => (reader ??= makeReader(baseRpc()));
+
+const trimmed = (v: string): string | null => (v.trim() === '' ? null : v.trim());
+
+async function resolverOf(client: Reader, node: Hex): Promise<Hex> {
+  const found: Hex = await client.readContract({ address: BASENAME_REGISTRY, abi: REGISTRY_ABI, functionName: 'resolver', args: [node] });
+  return found === ZERO ? BASENAME_L2_RESOLVER : found;
+}
+
+async function primaryName(client: Reader, address: string): Promise<string | null> {
+  const node = reverseNodeOf(address);
+  const found = await client.readContract({ address: await resolverOf(client, node), abi: NAME_ABI, functionName: 'name', args: [node] });
+  return found === '' ? null : found;
+}
+
+async function recordsOf(client: Reader, name: string, address: string): Promise<SenderProfile | null> {
+  const node = namehash(normalize(name));
+  const resolver = { address: await resolverOf(client, node), abi: TEXT_ABI } as const;
+  const text = (key: string): Promise<string> => client.readContract({ ...resolver, functionName: 'text', args: [node, key] });
+  const [forward, displayName, about, avatar] = await Promise.all([
+    client.readContract({ ...resolver, functionName: 'addr', args: [node] }),
+    text('name'),
+    text('description'),
+    text('avatar'),
+  ]);
+  if (forward.toLowerCase() !== address.toLowerCase()) return null;
+  return { address, name, displayName: trimmed(displayName), about: trimmed(about), avatar: AVATAR_RE.test(avatar.trim()) ? avatar.trim() : null };
+}
+
+export async function profileOf(address: string, client: Reader = readerFor(), fetchImpl: typeof fetch = fetch): Promise<SenderProfile> {
+  const bare: SenderProfile = { address, name: null, displayName: null, about: null, avatar: null };
+  const name = (await primaryName(client, address)) ?? (await nameOf(address, fetchImpl));
+  if (name === null) return bare;
+  return (await recordsOf(client, name, address)) ?? bare;
+}
+
+const key = (acct: Account, inboxId: string): string => `${acct.cfg.id}:${inboxId}`;
+
+const senders = makeProfileCache<SenderProfile>(
+  async (k) => {
+    const [accountId, inboxId] = k.split(':', 2) as [string, string];
+    const acct = accounts.get(accountId);
+    if (acct === undefined) return null;
+    const address = (await resolveAddresses(acct, [inboxId]))[inboxId];
+    return address === undefined ? null : profileOf(address);
+  },
+  { onError: (k, err) => process.stderr.write(`xmtp: could not resolve the sender ${k}: ${err instanceof Error ? err.message : String(err)}\n`) },
+);
+
+export const senderFields = (p: SenderProfile | null): Record<string, string> =>
+  p === null ? {} : { from_name: p.name ?? p.address, ...(p.displayName === null ? {} : { from_display_name: p.displayName }) };
+
+export const senderFieldsNow = (acct: Account, inboxId: string): Record<string, string> => senderFields(senders.peek(key(acct, inboxId)));
+
+export const senderProfile = (acct: Account, inboxId: string): Promise<SenderProfile | null> => senders.get(key(acct, inboxId));
+
+export const profileView = (inboxId: string, p: SenderProfile | null): Profile => ({
+  id: inboxId,
+  ...(p === null ? {} : { address: p.address }),
+  ...(p?.name == null ? {} : { name: p.name }),
+  ...(p?.displayName == null ? {} : { display_name: p.displayName }),
+  ...(p?.about == null ? {} : { about: p.about }),
+  ...(p?.avatar == null ? {} : { avatar: p.avatar }),
+});
+
+export async function profileAction(id: string, args: Record<string, unknown>): Promise<void> {
+  const user = typeof args.user === 'string' ? args.user.trim() : '';
+  if (user === '') throw new TrainError('xmtp_user_required', 'profile needs the inbox id of the person', { retryable: false });
+  const acct = accountForCall({ account: typeof args.account === 'string' ? args.account : undefined });
+  respond(id, { result: profileView(user, await senderProfile(acct, user)) });
+}

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)}`;
+
+export 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/mcp/stations/types';
+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,9 @@ 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),
+  readsProfiles: true,
+  claimsName: true,
   sendAttachments: xmtpSendAttachments,
   tools: XMTP_TOOLS,
 };

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

@@ -1,61 +1,14 @@
-import type { CanonicalAttachment, ToolContext } from '@metro-labs/mcp/stations/types';
-import { TrainError } from '@metro-labs/mcp/train-error';
+import type { CanonicalAttachment, ToolContext } from '@metro-labs/core/stations/types';
+import { TrainError } from '@metro-labs/core/train-error';
 import {
   guessMime,
   isImageMime,
   isImageExt,
   kindOf,
-} from '@metro-labs/mcp/stations/attachments';
+} from '@metro-labs/core/stations/attachments';
 
 export const str = (v: unknown): string => (typeof v === 'string' ? v : '');
 
-function strList(value: unknown): string[] {
-  return (value as unknown[] | undefined)?.map(String).filter(Boolean) ?? [];
-}
-
-interface CreatedGroup {
-  line?: string;
-  id?: string;
-  account?: string;
-}
-
-async function applyCreateLabels(
-  line: string,
-  labels: string[],
-  ctx: ToolContext,
-): Promise<unknown> {
-  if (!labels.length) return undefined;
-  return ctx.call('updateChannelMeta', { line, appData: { labels } });
-}
-
-export async function createChannel(
-  a: Record<string, unknown>,
-  ctx: ToolContext,
-) {
-  const addresses = strList(a.addresses);
-  const channelName = str(a.name);
-  const labels = strList(a.labels);
-  const account = str(a.account) || undefined;
-  if (!addresses.length)
-    return ctx.err('create_channel requires a non-empty `addresses` array');
-  if (!channelName) return ctx.err('create_channel requires `name`');
-  const groupArgs: Record<string, unknown> = { addresses, name: channelName };
-  if (account) groupArgs.account = account;
-  const { result } = (await ctx.call('newGroup', groupArgs)) as {
-    result: CreatedGroup | null;
-  };
-  const newLine = result?.line ?? '';
-  const labelResult = newLine.length
-    ? await applyCreateLabels(newLine, labels, ctx)
-    : undefined;
-  return ctx.okJson({
-    line: newLine,
-    convId: result?.id,
-    account: result?.account,
-    labels: labelResult,
-  });
-}
-
 export async function setChannelMetadata(
   a: Record<string, unknown>,
   ctx: ToolContext,
@@ -112,7 +65,7 @@ export async function xmtpSendAttachments(
 ): Promise<string[]> {
   const sent: string[] = [];
   for (const a of atts) {
-    const src = a.path ?? a.url ?? '';
+    const src = a.path ?? '';
     if (!src) continue;
     const mime = a.mime ?? guessMime(src);
     if (isImageMime(mime) || isImageExt(src)) {