@stage-labs/metro 0.1.0-beta.2 → 0.1.0-beta.200

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

@@ -0,0 +1,56 @@
+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,
+  createGroupWithMembers,
+  warmGroupName,
+} from './conv-helpers.js';
+import { memberOutcomes, splitMembers } from './group-members.js';
+
+type Args = Record<string, unknown>;
+
+export async function groupCreate(args: Args): Promise<GroupResult> {
+  const name = typeof args.name === 'string' ? args.name : '';
+  if (!name) throw new TrainError('INVALID_ARGS', 'groupCreate requires a `name`');
+  const acct = accountForCall(args);
+  const { addrs, inboxes } = splitMembers(args);
+  const group = await createGroupWithMembers(acct, addrs, inboxes, {
+    groupName: name,
+  });
+  warmGroupName(group.id, name);
+  return {
+    capability: { supported: true },
+    line: lineOf(acct.cfg.id, group.id),
+    id: group.id,
+    name,
+    members: memberOutcomes(addrs, inboxes, 'added'),
+  };
+}
+
+async function memberOp(
+  args: Args,
+  mode: 'add' | 'remove',
+  verb: string,
+): Promise<GroupResult> {
+  const line = typeof args.line === 'string' ? args.line : '';
+  if (!line) throw new TrainError('INVALID_ARGS', `${verb} requires a \`line\``);
+  const { addrs, inboxes } = splitMembers(args);
+  if (!addrs.length && !inboxes.length)
+    throw new TrainError('INVALID_ARGS', `${verb} requires members`);
+  const { conv } = await convOf(line);
+  if (!conv) throw new TrainError('NOT_FOUND', `conversation not found for ${line}`);
+  await applyMemberOp(conv, addrs, inboxes, mode);
+  return {
+    capability: { supported: true },
+    line,
+    id: conv.id,
+    members: memberOutcomes(addrs, inboxes, mode === 'add' ? 'added' : 'removed'),
+  };
+}
+
+export const groupAddMembers = (args: Args): Promise<GroupResult> =>
+  memberOp(args, 'add', 'groupAddMembers');
+
+export const groupRemoveMembers = (args: Args): Promise<GroupResult> =>
+  memberOp(args, 'remove', 'groupRemoveMembers');

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

@@ -0,0 +1,47 @@
+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 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) => 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: 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

@@ -0,0 +1,122 @@
+import { errMsg } from '@metro-labs/core/log';
+import { ConsentState, type DecodedMessage } from '@xmtp/node-sdk';
+import {
+  accounts,
+  bootAccount,
+  loadAccounts,
+  type Account,
+} from './accounts.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 { senderFieldsNow } from './sender.js';
+import { readCalls } from '@metro-labs/core/trains/protocol';
+import { handleCall } from './actions.js';
+
+readCalls('xmtp', handleCall);
+
+const SYNC_MS = Number(process.env.XMTP_SYNC_MS ?? '60000');
+const SILENT_TYPES = new Set([
+  'readReceipt',
+  'transactionReference',
+  'walletSendCalls',
+  'groupUpdated',
+  'group_updated',
+]);
+
+async function bootSync(acct: Account): Promise<void> {
+  const { id } = acct.cfg;
+  try {
+    await acct.client.conversations.syncAll([
+      ConsentState.Allowed,
+      ConsentState.Unknown,
+    ]);
+    const initial = await acct.client.conversations.list();
+    process.stderr.write(
+      `xmtp[${id}]: synced ${initial.length} conversation(s) at boot\n`,
+    );
+  } catch (err) {
+    process.stderr.write(
+      `xmtp[${id}] boot sync error: ${errMsg(err)}\n`,
+    );
+  }
+}
+
+function startPeriodicSync(acct: Account): void {
+  const { id } = acct.cfg;
+  setInterval(() => {
+    acct.client.conversations
+      .syncAll([ConsentState.Allowed, ConsentState.Unknown])
+      .catch((err: unknown) => {
+        process.stderr.write(`xmtp[${id}] sync error: ${errMsg(err)}\n`);
+      });
+  }, SYNC_MS).unref();
+}
+
+async function handleStreamMessage(
+  acct: Account,
+  msg: DecodedMessage,
+): Promise<void> {
+  const { id } = acct.cfg;
+  if (msg.senderInboxId === acct.client.inboxId) return;
+  if (SILENT_TYPES.has(msg.contentType?.typeId ?? '')) 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 };
+  }
+  emitInbound(id, env);
+}
+
+async function runAccount(acct: Account): Promise<void> {
+  const { id } = acct.cfg;
+  await bootSync(acct);
+  startPeriodicSync(acct);
+
+  for (;;) {
+    try {
+      const stream = await acct.client.conversations.streamAllMessages({
+        consentStates: [ConsentState.Allowed, ConsentState.Unknown],
+      });
+      for await (const msg of stream) {
+        if (!msg) continue;
+        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(
+        `xmtp[${id}] stream error (retry 5s): ${errMsg(err)}\n`,
+      );
+    }
+    await new Promise((r) => setTimeout(r, 5000));
+  }
+}
+
+const cfgs = loadAccounts();
+for (const cfg of cfgs) {
+  try {
+    await bootAccount(cfg);
+  } catch (err) {
+    process.stderr.write(
+      `xmtp[${cfg.id}] boot FAILED: ${errMsg(err)}\n`,
+    );
+  }
+}
+announceAccounts('xmtp', accounts.keys());
+
+for (const acct of accounts.values())
+  runAccount(acct).catch((err: unknown) => {
+    process.stderr.write(
+      `xmtp[${acct.cfg.id}] account loop failed: ${errMsg(err)}\n`,
+    );
+  });

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

@@ -0,0 +1,139 @@
+export interface GroupLike {
+  id: string;
+  appData?: string;
+  updateAppData?: (s: string) => Promise<void>;
+  updateName?: (s: string) => Promise<void>;
+  updateDescription?: (s: string) => Promise<void>;
+  removeMembers?: (inboxIds: string[]) => Promise<void>;
+  sync?: () => Promise<unknown>;
+}
+
+const MAX_LABELS = 16;
+const MAX_LABEL_LEN = 24;
+
+function cleanLabels(raw: unknown): string[] {
+  if (!Array.isArray(raw)) return [];
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const item of raw) {
+    if (typeof item !== 'string') continue;
+    const label = item.trim().replace(/\s+/g, ' ').slice(0, MAX_LABEL_LEN);
+    const key = label.toLowerCase();
+    if (!label || seen.has(key)) continue;
+    seen.add(key);
+    out.push(label);
+    if (out.length >= MAX_LABELS) break;
+  }
+  return out;
+}
+
+function parseAppDataObject(
+  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 {};
+  }
+  return {};
+}
+
+function trimmedString(v: unknown): string | undefined {
+  return typeof v === 'string' && v.trim() ? v.trim() : undefined;
+}
+
+export function readAppData(appData: string | undefined): {
+  labels: string[];
+  github?: string;
+  preview?: string;
+} {
+  if (!appData?.trim()) return { labels: [] };
+  try {
+    const p: unknown = JSON.parse(appData);
+    if (!p || typeof p !== 'object' || Array.isArray(p)) return { labels: [] };
+    const rec = p as Record<string, unknown>;
+    return {
+      labels: cleanLabels(rec.labels),
+      github: trimmedString(rec.github),
+      preview: trimmedString(rec.preview),
+    };
+  } catch {
+    return { labels: [] };
+  }
+}
+
+function applyMergeKey(
+  merged: Record<string, unknown>,
+  k: string,
+  v: unknown,
+): void {
+  if (k === 'labels') {
+    merged.labels = cleanLabels(v);
+    return;
+  }
+  if (k === 'github') {
+    const g = normalizeGithubUrl(v);
+    if (g) merged.github = g;
+    else delete merged.github;
+    return;
+  }
+  if (k === 'preview') {
+    const p = normalizePreviewUrl(v);
+    if (p) merged.preview = p;
+    else delete merged.preview;
+    return;
+  }
+  if (v === undefined || v === null) Reflect.deleteProperty(merged, k);
+  else merged[k] = v;
+}
+
+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 };
+}
+
+export function normalizeGithubUrl(url: unknown): string {
+  if (typeof url !== 'string')
+    throw new Error('setGithub requires a `url` string');
+  const trimmed = url.trim();
+  if (!trimmed) return '';
+  let parsed: URL;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    throw new Error(`invalid url: ${trimmed}`);
+  }
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+    throw new Error(`github url must be http(s): ${trimmed}`);
+  }
+  if (
+    parsed.hostname !== 'github.com' &&
+    parsed.hostname !== 'www.github.com'
+  ) {
+    throw new Error(`url must be a github.com URL: ${trimmed}`);
+  }
+  return trimmed;
+}
+
+export function normalizePreviewUrl(url: unknown): string {
+  if (typeof url !== 'string')
+    throw new Error('setPreview requires a `preview` string');
+  const trimmed = url.trim();
+  if (!trimmed) return '';
+  try {
+    new URL(trimmed);
+  } catch {
+    throw new Error(`invalid preview url: ${trimmed}`);
+  }
+  return trimmed;
+}

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

@@ -0,0 +1,40 @@
+import { TrainError } from '@metro-labs/core/train-error';
+
+type Args = Record<string, unknown>;
+
+export function filterStrings(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return value.filter((a) => typeof a === 'string' && a.length > 0) as string[];
+}
+
+export function resolveMembers(args: Args): {
+  addrs: string[];
+  inboxes: string[];
+} {
+  const { addresses, inboxIds, memberAddresses, memberInboxIds } = args as {
+    addresses?: string[];
+    inboxIds?: string[];
+    memberAddresses?: string[];
+    memberInboxIds?: string[];
+  };
+  return {
+    addrs: filterStrings(addresses ?? memberAddresses),
+    inboxes: filterStrings(inboxIds ?? memberInboxIds),
+  };
+}
+
+export function parseMemberArgs(
+  args: Args,
+  verb: string,
+): { line: string; addrs: string[]; inboxes: string[] } {
+  const { line } = args as { line: string };
+  if (!line || typeof line !== 'string')
+    throw new TrainError('INVALID_ARGS', `${verb} requires a \`line\``);
+  const { addrs, inboxes } = resolveMembers(args);
+  if (addrs.length === 0 && inboxes.length === 0)
+    throw new TrainError(
+      'INVALID_ARGS',
+      `${verb} requires addresses[] or inboxIds[]`,
+    );
+  return { line, addrs, inboxes };
+}

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 './wire.js';
+
+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 } });
+}