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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.155",
+  "version": "0.1.0-beta.156",
   "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.155",
+  "version": "0.1.0-beta.156",
   "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/xmtp/src/profile.ts

@@ -1,5 +1,5 @@
 import { readFile } from 'node:fs/promises';
-import { encodeFunctionData, namehash, type Hex } from 'viem';
+import { encodeFunctionData, encodePacked, keccak256, namehash, stringToBytes, type Hex } from 'viem';
 import { normalize } from 'viem/ens';
 import { TrainError } from '@metro-labs/core/train-error';
 import {
@@ -17,6 +17,7 @@ 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';
@@ -37,6 +38,16 @@ const RESOLVER_ABI = [
   { 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;
+
+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';
@@ -54,16 +65,39 @@ export async function pinAvatar(avatar: ProfileAvatar, fetchImpl: typeof fetch =
   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] });
 }
 
-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;
-}
+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> = {};
@@ -102,11 +136,18 @@ export async function claimNameAction(id: string, args: Args): Promise<void> {
   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 } });
+  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);
-  respond(id, { result: { account: acct.cfg.id, name, canClaim: acct.smart !== null && name === null } });
+  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/runtime.json

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