@stage-labs/metro 0.1.0-beta.23 → 0.1.0-beta.231

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

@@ -1,13 +1,14 @@
 import type { Reaction } from '@xmtp/content-type-reaction';
 import type { Reply } from '@xmtp/content-type-reply';
-import { errMsg } from '@metro-labs/mcp/log';
+import { errMsg } from '@metro-labs/core/log';
 import { transcribeAndEmit } from './transcribe.js';
 import {
   saveInlineAttachment,
   saveRemoteAttachment,
   type RemoteEntry,
 } from './attachments.js';
-import { emitInbound, emitAttachmentSaved } from './emit-core.js';
+import { reportAttachment } from '@metro-labs/core/stations/train-events';
+import { sentByMe } from './wire.js';
 
 export interface EnvelopeCtx {
   accountId: string;
@@ -150,6 +151,7 @@ function replyPayload(
         ? c.content
         : `[reply with ${c.contentType?.typeId ?? 'unknown'}]`,
     event: { type: 'reply', replyTo: c.reference },
+    ...(sentByMe(c.reference) ? { reply_to_self: true } : {}),
     payload: {
       contentType: typeId,
       replyTo: c.reference,
@@ -187,19 +189,12 @@ function inlineAttachmentPayload(
       ctx.line,
       ctx.accountId,
       ctx.baseId,
-      emitInbound,
     ).catch((err: unknown) => {
       process.stderr.write(
         `xmtp[${ctx.accountId}] voice transcription failed: ${errMsg(err)}\n`,
       );
     });
-  emitAttachmentSaved(
-    ctx.accountId,
-    ctx.line,
-    ctx.baseId,
-    0,
-    saveInlineAttachment(c, ctx.msgId, 0),
-  );
+  reportAttachment(saveInlineAttachment(c, ctx.msgId, 0), { station: 'xmtp', account: ctx.accountId, line: ctx.line, forId: ctx.baseId, index: 0 });
   return out;
 }
 
@@ -210,13 +205,7 @@ function remoteStaticPayload(
   ctx: EnvelopeCtx,
 ): Record<string, unknown> {
   const kind = IMG_RE.test(c.url) ? 'image' : 'file';
-  emitAttachmentSaved(
-    ctx.accountId,
-    ctx.line,
-    ctx.baseId,
-    0,
-    saveRemoteAttachment(c, ctx.msgId, 0),
-  );
+  reportAttachment(saveRemoteAttachment(c, ctx.msgId, 0), { station: 'xmtp', account: ctx.accountId, line: ctx.line, forId: ctx.baseId, index: 0 });
   return {
     ...base,
     text: `[${kind}: ${c.filename ?? c.url}]`,
@@ -232,13 +221,7 @@ function multiRemoteEnvelope(
 ): Record<string, unknown> {
   const m = c as { attachments?: RemoteEntry[] };
   (Array.isArray(m.attachments) ? m.attachments : []).forEach((r, i) => {
-    emitAttachmentSaved(
-      ctx.accountId,
-      ctx.line,
-      ctx.baseId,
-      i,
-      saveRemoteAttachment(r, ctx.msgId, i),
-    );
+    reportAttachment(saveRemoteAttachment(r, ctx.msgId, i), { station: 'xmtp', account: ctx.accountId, line: ctx.line, forId: ctx.baseId, index: i });
   });
   return multiRemotePayload(base, typeId, c);
 }

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

@@ -1,12 +1,10 @@
 import type { Conversation, DecodedMessage } from '@xmtp/node-sdk';
-import { lineOf, parseLine } from './accounts.js';
-import { emit, mintId, rememberUid, SELF_URI } from './wire.js';
-import { fcmPushToAll } from './push.js';
-import { emitInbound, emitAttachmentSaved } from './emit-core.js';
+import { lineOf } from './accounts.js';
+import { selfUri } from '@metro-labs/core/stations/train-events';
+import { emit, mintId } from '@metro-labs/core/stations/station-runtime';
+import { rememberSent, rememberUid } from './wire.js';
 import { typedEnvelope, type EnvelopeCtx } from './emit-payloads.js';
-import type { StructuredEvent } from '@metro-labs/mcp/events';
-
-export { emitInbound, emitAttachmentSaved };
+import type { StructuredEvent } from '@metro-labs/core/events';
 
 export function envelope(
   accountId: string,
@@ -23,6 +21,7 @@ export function envelope(
     line,
     from: `metro://xmtp/${accountId}/user/${msg.senderInboxId}`,
     message_id: msg.id,
+    is_private: typeof (conv as unknown as { peerInboxId?: unknown }).peerInboxId === 'function',
   };
   rememberUid(base.id, msg.id);
   if (typeof c === 'string')
@@ -53,26 +52,17 @@ export function emitOutbound(
 ): void {
   const uid = mintId();
   rememberUid(uid, messageId);
+  rememberSent(messageId);
   emit({
-    kind: 'outbound',
     id: uid,
     ts: new Date().toISOString(),
     station: 'xmtp',
     line,
-    from: SELF_URI,
+    from: selfUri(),
     to: line,
     message_id: messageId,
     text,
-    account: accountId,
     ...(event ? { event } : {}),
     payload: { account: accountId },
   });
-  void (async (): Promise<void> => {
-    const data: Record<string, string> = { line, messageId };
-    {
-      const p = parseLine(line);
-      if (p) data.convId = p.convId.toLowerCase();
-    }
-    await fcmPushToAll(accountId, data);
-  })().catch(() => undefined);
 }

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

@@ -1,7 +1,7 @@
 import type {
   MemberOutcome,
   MemberOutcomeStatus,
-} from '@metro-labs/mcp/stations/types';
+} from '@metro-labs/core/stations/types';
 
 type Args = Record<string, unknown>;
 

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

@@ -1,5 +1,5 @@
-import { TrainError } from '@metro-labs/mcp/train-error';
-import type { GroupResult } from '@metro-labs/mcp/stations/types';
+import { TrainError } from '@metro-labs/core/train-error';
+import type { GroupResult } from '@metro-labs/core/stations/types';
 import { accountForCall, convOf, lineOf } from './accounts.js';
 import {
   applyMemberOp,

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/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

@@ -1,3 +1,5 @@
+import { TrainError } from '@metro-labs/core/train-error';
+
 export interface GroupLike {
   id: string;
   appData?: string;
@@ -10,8 +12,9 @@ export interface GroupLike {
 
 const MAX_LABELS = 16;
 const MAX_LABEL_LEN = 24;
+const MAX_APP_DATA_BYTES = 8192;
 
-export function cleanLabels(raw: unknown): string[] {
+function cleanLabels(raw: unknown): string[] {
   if (!Array.isArray(raw)) return [];
   const out: string[] = [];
   const seen = new Set<string>();
@@ -27,36 +30,40 @@ export function cleanLabels(raw: unknown): string[] {
   return out;
 }
 
-function parseAppDataObject(
+export function readAppDataObject(
   existingAppData: string | undefined,
 ): Record<string, unknown> {
   if (!existingAppData?.trim()) return {};
-  try {
-    const p: unknown = JSON.parse(existingAppData);
-    if (p && typeof p === 'object' && !Array.isArray(p))
-      return p as Record<string, unknown>;
-  } catch {
-    return {};
+  const parsed: unknown = JSON.parse(existingAppData);
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new TrainError('INVALID_ARGS', 'Channel appData must be a JSON object');
   }
-  return {};
+  return parsed as Record<string, unknown>;
 }
 
-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);
+export function normalizeAssigned(value: unknown): string[] {
+  if (!Array.isArray(value)) {
+    throw new TrainError('INVALID_ARGS', 'assigned must be an array of Ethereum addresses');
+  }
+  const addresses: string[] = [];
+  for (const address of value) {
+    if (typeof address !== 'string' || !/^0x[0-9a-fA-F]{40}$/.test(address.trim())) {
+      throw new TrainError('INVALID_ARGS', 'assigned must contain valid Ethereum addresses');
+    }
+    addresses.push(address.trim().toLowerCase());
+  }
+  return [...new Set(addresses)];
+}
+
+export function metadataPatch(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new TrainError('INVALID_ARGS', 'metadata must be a JSON object');
+  }
+  const patch = value as Record<string, unknown>;
+  if (Object.hasOwn(patch, 'v')) {
+    throw new TrainError('INVALID_ARGS', 'metadata cannot change the reserved v field');
+  }
+  return patch;
 }
 
 function trimmedString(v: unknown): string | undefined {
@@ -83,13 +90,24 @@ export function readAppData(appData: string | undefined): {
   }
 }
 
+function checkedLabels(value: unknown): string[] {
+  if (!Array.isArray(value) || value.some((label: unknown) => typeof label !== 'string')) {
+    throw new TrainError('INVALID_ARGS', 'labels must be an array of strings');
+  }
+  return cleanLabels(value);
+}
+
 function applyMergeKey(
   merged: Record<string, unknown>,
   k: string,
   v: unknown,
 ): void {
   if (k === 'labels') {
-    merged.labels = cleanLabels(v);
+    merged.labels = checkedLabels(v);
+    return;
+  }
+  if (k === 'assigned') {
+    merged.assigned = normalizeAssigned(v);
     return;
   }
   if (k === 'github') {
@@ -105,19 +123,25 @@ function applyMergeKey(
     return;
   }
   if (v === undefined || v === null) Reflect.deleteProperty(merged, k);
-  else merged[k] = v;
+  else Object.defineProperty(merged, k, { value: v, enumerable: true, configurable: true, writable: true });
 }
 
 export function mergeAppData(
   existingAppData: string | undefined,
   patch: Record<string, unknown>,
 ): { blob: string; merged: Record<string, unknown> } {
-  const merged: Record<string, unknown> = {
-    ...parseAppDataObject(existingAppData),
-    v: 1,
-  };
-  for (const [k, v] of Object.entries(patch)) applyMergeKey(merged, k, v);
-  return { blob: JSON.stringify(merged), merged };
+  const current = readAppDataObject(existingAppData);
+  const checked = metadataPatch(patch);
+  if (Object.hasOwn(checked, 'assigned') && Object.hasOwn(current, 'assigned')) {
+    normalizeAssigned(current.assigned);
+  }
+  const merged: Record<string, unknown> = { v: 1, ...current };
+  for (const [k, v] of Object.entries(checked)) applyMergeKey(merged, k, v);
+  const blob = JSON.stringify(merged);
+  if (Buffer.byteLength(blob, 'utf8') > MAX_APP_DATA_BYTES) {
+    throw new TrainError('INVALID_ARGS', `Channel appData exceeds ${MAX_APP_DATA_BYTES} bytes`);
+  }
+  return { blob, merged };
 }
 
 export function normalizeGithubUrl(url: unknown): string {

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 } });
+}