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

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

@@ -1,12 +1,12 @@
 import { accountForCall, convOf, lineOf } from './accounts.js';
-import { respond } from './wire.js';
+import { respond } from '@metro-labs/core/stations/station-runtime';
 import { warmGroupName } from './conv-helpers.js';
 import { mergeAppData, readAppData, type GroupLike } from './labels.js';
-import { TrainError } from '@metro-labs/mcp/train-error';
+import { TrainError } from '@metro-labs/core/train-error';
 
 type Args = Record<string, unknown>;
 
-export function resolveLine(args: Args, verb: string): string {
+function resolveLine(args: Args, verb: string): string {
   const line = (args as { line?: string }).line;
   if (line) return line;
   const groupId = (args as { groupId?: string }).groupId;
@@ -53,7 +53,7 @@ async function applyMergedAppData(
   return readAppData(group.appData);
 }
 
-export async function applyChannelMeta(
+async function applyChannelMeta(
   args: {
     line: string;
     name?: string;
@@ -116,42 +116,3 @@ export async function updateChannelMeta(id: string, args: Args): Promise<void> {
   );
   respond(id, { result });
 }
-
-export async function setGithub(id: string, args: Args): Promise<void> {
-  const line = resolveLine(args, 'setGithub');
-  const { url } = args as { url: string };
-  if (typeof url !== 'string')
-    throw new Error('setGithub requires a `url` string');
-  const result = await applyChannelMeta(
-    { line, appData: { github: url } },
-    'setGithub',
-  );
-  respond(id, {
-    result: {
-      line: result.line,
-      id: result.id,
-      account: result.account,
-      github: result.github,
-    },
-  });
-}
-
-export async function setPreview(id: string, args: Args): Promise<void> {
-  const line = resolveLine(args, 'setPreview');
-  const a = args as { preview?: unknown; url?: unknown };
-  const value = typeof a.preview === 'string' ? a.preview : a.url;
-  if (typeof value !== 'string')
-    throw new Error('setPreview requires a `preview` string');
-  const result = await applyChannelMeta(
-    { line, appData: { preview: value } },
-    'setPreview',
-  );
-  respond(id, {
-    result: {
-      line: result.line,
-      id: result.id,
-      account: result.account,
-      preview: result.preview,
-    },
-  });
-}

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

@@ -1,27 +1,19 @@
-import { ReactionAction, ReactionSchema } from '@xmtp/node-sdk';
+import { ReactionAction, ReactionSchema, type Conversation } from '@xmtp/node-sdk';
 import type { Reply } from '@xmtp/node-bindings';
 import {
   AttachmentCodec,
   type Attachment,
 } from '@xmtp/content-type-remote-attachment';
-import {
-  WalletSendCallsCodec,
-  type WalletSendCallsParams,
-} from '@xmtp/content-type-wallet-send-calls';
-import { toHex } from 'viem';
 import { convOf } from './accounts.js';
-import { resolveMsgId, respond } from './wire.js';
+import { resolveMsgId } from './wire.js';
 import { emitOutbound } from './emit.js';
-import {
-  PollCodec,
-  buildPollContent,
-  SignatureRequestCodec,
-  type SignatureRequestContent,
-} from './codecs.js';
+import { PollCodec, buildPollContent } from './codecs.js';
 import { convHandlers } from './actions-conv.js';
-import { normalizeXmtp } from '@metro-labs/mcp/stations/messaging-normalize';
-import { TrainError } from '@metro-labs/mcp/train-error';
-import { makeStation, type CallMsg } from '@metro-labs/mcp/stations/station-runtime';
+import { messagingAliases } from '@metro-labs/core/stations/messaging-normalize';
+import { TrainError } from '@metro-labs/core/train-error';
+import { claimNameAction, nameAction, setProfile } from './profile.js';
+import { profileAction } from './sender.js';
+import { makeStation, respond, type CallMsg } from '@metro-labs/core/stations/station-runtime';
 
 type Args = Record<string, unknown>;
 
@@ -40,68 +32,47 @@ async function send(id: string, args: Args): Promise<void> {
 }
 
 async function ask(id: string, args: Args): Promise<void> {
-  const { line, pollId } = args as { line: string; pollId?: string };
+  const { line } = args as { line: string };
   const { acct, conv } = await convOf(line);
   if (!conv) throw noConv(line);
-  const fallbackId = `poll_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
-  const mintedId =
-    pollId ??
-    (typeof crypto?.randomUUID === 'function'
-      ? crypto.randomUUID()
-      : fallbackId);
+  const mintedId = crypto.randomUUID();
   const { poll, title } = buildPollContent(args, mintedId);
   const sentId = await conv.send(new PollCodec().encode(poll));
   emitOutbound(acct.cfg.id, line, sentId, `📊 Poll: ${title}`);
   respond(id, { result: { messageId: sentId, pollId: mintedId } });
 }
 
+async function referenceInboxOf(conv: Conversation, xmtpMsgId: string): Promise<string> {
+  const recent = await conv.messages({ limit: 200, direction: 1 });
+  const inbox = recent.find((m) => m.id === xmtpMsgId)?.senderInboxId;
+  if (!inbox)
+    throw new TrainError('NOT_FOUND', `could not resolve referenceInboxId for ${xmtpMsgId}`);
+  return inbox;
+}
+
 async function react(id: string, args: Args): Promise<void> {
-  const {
-    line,
-    messageId,
-    emoji,
-    action: reactAction,
-    schema: reactSchema,
-  } = args as {
+  const { line, messageId, emoji, action: reactAction } = args as {
     line: string;
     messageId: string;
     emoji: string;
     action?: 'added' | 'removed';
-    schema?: string;
-    referenceInboxId?: string;
   };
   const { acct, conv } = await convOf(line);
   if (!conv) throw noConv(line);
   const xmtpMsgId = resolveMsgId(messageId);
-  let refInbox = (args as { referenceInboxId?: string }).referenceInboxId;
-  if (!refInbox) {
-    const recent = await conv.messages({ limit: 200, direction: 1 });
-    refInbox = recent.find((m) => m.id === xmtpMsgId)?.senderInboxId;
-    if (!refInbox)
-      throw new TrainError(
-        'NOT_FOUND',
-        `could not resolve referenceInboxId for ${xmtpMsgId}`,
-      );
-  }
-  const schemaEnum =
-    reactSchema === 'custom'
-      ? ReactionSchema.Custom
-      : reactSchema === 'shortcode'
-        ? ReactionSchema.Shortcode
-        : ReactionSchema.Unicode;
+  const removed = reactAction === 'removed';
   const sentId = await conv.sendReaction({
     reference: xmtpMsgId,
-    referenceInboxId: refInbox,
-    action:
-      reactAction === 'removed' ? ReactionAction.Removed : ReactionAction.Added,
+    referenceInboxId: await referenceInboxOf(conv, xmtpMsgId),
+    action: removed ? ReactionAction.Removed : ReactionAction.Added,
     content: emoji,
-    schema: schemaEnum,
+    schema: ReactionSchema.Unicode,
   });
   emitOutbound(
     acct.cfg.id,
     line,
     sentId,
-    `[react ${emoji}${reactAction === 'removed' ? ' (removed)' : ''}]`,
+    `[react ${emoji}${removed ? ' (removed)' : ''}]`,
     { type: 'react', emoji, targetId: xmtpMsgId },
   );
   respond(id, { result: { messageId: sentId } });
@@ -159,175 +130,34 @@ const IMG_MIME_BY_EXT: Record<string, string> = {
   webp: 'image/webp',
 };
 
-async function loadImageBytes(
-  path: string | undefined,
-  dataB64: string | undefined,
-): Promise<Uint8Array> {
-  if (path) {
-    const { readFileSync } = await import('node:fs');
-    return new Uint8Array(readFileSync(path));
-  }
-  if (dataB64) return new Uint8Array(Buffer.from(dataB64, 'base64'));
-  throw badArgs('sendImage requires path or dataB64');
-}
-
-function imageMime(
-  mimeType: string | undefined,
-  filename: string | undefined,
-  path: string | undefined,
-): string {
-  if (mimeType) return mimeType;
-  const ext = (filename ?? path ?? '').toLowerCase().split('.').pop() ?? '';
+function imageMime(path: string): string {
+  const ext = path.toLowerCase().split('.').pop() ?? '';
   return IMG_MIME_BY_EXT[ext] ?? 'image/png';
 }
 
-function imageFilename(
-  filename: string | undefined,
-  path: string | undefined,
-): string {
-  if (filename) return filename;
-  const baseName = path ? path.split('/').pop() : undefined;
+function imageFilename(path: string): string {
+  const baseName = path.split('/').pop();
   return baseName != null && baseName !== '' ? baseName : 'image.png';
 }
 
 async function sendImage(id: string, args: Args): Promise<void> {
-  const { line, path, dataB64, filename, mimeType } = args as {
-    line: string;
-    path?: string;
-    dataB64?: string;
-    filename?: string;
-    mimeType?: string;
-  };
+  const { line, path } = args as { line: string; path?: string };
+  if (!path) throw badArgs('sendImage requires path');
   const { acct, conv } = await convOf(line);
   if (!conv) throw noConv(line);
-  const bytes = await loadImageBytes(path, dataB64);
-  const mime = imageMime(mimeType, filename, path);
-  const fname = imageFilename(filename, path);
+  const { readFileSync } = await import('node:fs');
+  const mime = imageMime(path);
+  const fname = imageFilename(path);
   const attachment: Attachment = {
     filename: fname,
     mimeType: mime,
-    data: bytes,
+    data: new Uint8Array(readFileSync(path)),
   };
   const sentId = await conv.send(new AttachmentCodec().encode(attachment));
   emitOutbound(acct.cfg.id, line, sentId, `[${mime.split('/')[0]}: ${fname}]`);
   respond(id, { result: { messageId: sentId } });
 }
 
-interface TxRequestArgs {
-  to: string;
-  amountEth?: number;
-  data?: string;
-  note?: string;
-  chainId?: number;
-}
-
-function validateTxAmount(amountEth: number | undefined, hasData: boolean): void {
-  if (!hasData && (typeof amountEth !== 'number' || !(amountEth > 0))) {
-    throw badArgs(
-      'sendTxRequest requires a positive `amountEth` (or `data` for a contract call)',
-    );
-  }
-  if (amountEth != null && (typeof amountEth !== 'number' || amountEth < 0)) {
-    throw badArgs('sendTxRequest `amountEth` must be a non-negative number');
-  }
-}
-
-function validateTxRequest(a: TxRequestArgs): boolean {
-  const { to, amountEth, data } = a;
-  if (!to || typeof to !== 'string' || !/^0x[0-9a-fA-F]{40}$/.test(to)) {
-    throw badArgs('sendTxRequest requires a valid 0x `to` address');
-  }
-  const hasData = data != null;
-  if (
-    hasData &&
-    (typeof data !== 'string' || !/^0x([0-9a-fA-F]{2})*$/.test(data))
-  ) {
-    throw badArgs('sendTxRequest `data` must be 0x-prefixed hex calldata');
-  }
-  validateTxAmount(amountEth, hasData);
-  return hasData;
-}
-
-function buildTxContent(
-  a: TxRequestArgs,
-  from: string,
-  hasData: boolean,
-): WalletSendCallsParams {
-  const { to, amountEth, data, note, chainId } = a;
-  const weiHex = amountEth
-    ? '0x' + BigInt(Math.round(amountEth * 1e18)).toString(16)
-    : '0x0';
-  return {
-    version: '1.0',
-    chainId: toHex(chainId ?? 1),
-    from: from as `0x${string}`,
-    calls: [
-      {
-        to: to as `0x${string}`,
-        value: weiHex as `0x${string}`,
-        ...(hasData ? { data: data as `0x${string}` } : {}),
-        metadata: {
-          description: note ?? (hasData ? 'Contract call' : 'Payment request'),
-          transactionType: 'transfer',
-        },
-      },
-    ],
-  };
-}
-
-function txRequestLabel(a: TxRequestArgs, hasData: boolean): string {
-  const { amountEth, note } = a;
-  return hasData
-    ? `📝 ${note ?? 'Contract call'}${amountEth ? ` (${amountEth} ETH)` : ''}`
-    : `💸 ${note ?? 'Payment request'} (${amountEth} ETH)`;
-}
-
-async function sendTxRequest(id: string, args: Args): Promise<void> {
-  const { line } = args as { line: string };
-  const txArgs = args as Args & TxRequestArgs;
-  const { acct, conv } = await convOf(line);
-  if (!conv) throw noConv(line);
-  const hasData = validateTxRequest(txArgs);
-  const content = buildTxContent(txArgs, acct.address, hasData);
-  const sentId = await conv.send(new WalletSendCallsCodec().encode(content));
-  emitOutbound(acct.cfg.id, line, sentId, txRequestLabel(txArgs, hasData));
-  respond(id, { result: { messageId: sentId } });
-}
-
-async function sendSignatureRequest(id: string, args: Args): Promise<void> {
-  const { line, kind, eip712, message, description } = args as {
-    line: string;
-    kind?: 'eip712' | 'personal';
-    eip712?: unknown;
-    message?: string;
-    description?: string;
-  };
-  const { acct, conv } = await convOf(line);
-  if (!conv) throw noConv(line);
-  const k: 'eip712' | 'personal' = kind === 'eip712' ? 'eip712' : 'personal';
-  if (k === 'eip712' && !eip712)
-    throw badArgs(
-      'sendSignatureRequest eip712 requires an `eip712` typed-data object',
-    );
-  if (k === 'personal' && (!message || typeof message !== 'string')) {
-    throw badArgs('sendSignatureRequest personal requires a `message` string');
-  }
-  const content: SignatureRequestContent = {
-    id: 'sig_' + Date.now().toString(36),
-    kind: k,
-    ...(k === 'eip712' ? { eip712 } : { message }),
-    description,
-  };
-  const sentId = await conv.send(new SignatureRequestCodec().encode(content));
-  emitOutbound(
-    acct.cfg.id,
-    line,
-    sentId,
-    `✍️ ${description ?? 'Signature request'}`,
-  );
-  respond(id, { result: { messageId: sentId } });
-}
-
 async function accountsAction(id: string): Promise<void> {
   const { accounts } = await import('./accounts.js');
   respond(id, {
@@ -335,35 +165,27 @@ async function accountsAction(id: string): Promise<void> {
       accounts: [...accounts.values()].map((a) => ({
         id: a.cfg.id,
         handle: a.address,
-        url: `https://etherscan.io/address/${a.address}`,
+        url: `https://stage.box/#/${a.address}`,
         address: a.address,
         inboxId: a.inboxId,
-        env: 'production',
-        owner: a.cfg.owner ?? null,
-        keySource: 'privateKey',
+        smart: a.smart !== null,
       })),
     },
   });
 }
 
-function unsupportedVerb(id: string, verb: string): Promise<void> {
-  respond(id, { error: `unsupported verb '${verb}' on xmtp` });
-  return Promise.resolve();
-}
-
 const handlers: Record<string, (id: string, args: Args) => Promise<void>> = {
   accounts: (id) => accountsAction(id),
+  set_profile: setProfile,
+  claim_name: claimNameAction,
+  name: nameAction,
+  profile: profileAction,
   send,
   ask,
-  sendPoll: ask,
   react,
   reply,
   sendAttachment,
   sendImage,
-  sendTxRequest,
-  sendSignatureRequest,
-  edit: (id) => unsupportedVerb(id, 'edit'),
-  delete: (id) => unsupportedVerb(id, 'delete'),
   ...convHandlers,
 };
 
@@ -371,5 +193,5 @@ export type { CallMsg };
 
 export const handleCall = makeStation({
   handlers,
-  normalize: normalizeXmtp,
+  normalize: messagingAliases({ action: 'removed' }),
 });

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

@@ -6,9 +6,9 @@ import {
 import {
   saveBufferToCache,
   assertAttachmentSize,
-} from '@metro-labs/mcp/stations/attachments';
-import type { SavedAttachment } from '@metro-labs/mcp/stations/attachments';
-import { errMsg } from '@metro-labs/mcp/log';
+} from '@metro-labs/core/stations/attachments';
+import type { SavedAttachment } from '@metro-labs/core/stations/attachments';
+import { errMsg } from '@metro-labs/core/log';
 
 export type { SavedAttachment };
 

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

@@ -1,8 +1,8 @@
 import { IdentifierKind } from '@xmtp/node-sdk';
 import { convOf, type Account } from './accounts.js';
 import { inboxEthCache, cacheInboxEth } from './wire.js';
-import { TrainError } from '@metro-labs/mcp/train-error';
-import type { MemberList, MetroMember } from '@metro-labs/mcp/stations/types';
+import { TrainError } from '@metro-labs/core/train-error';
+import type { MemberList, MetroMember } from '@metro-labs/core/stations/types';
 import { readAppData, type GroupLike } from './labels.js';
 
 export { parseMemberArgs, resolveMembers } from './member-args.js';
@@ -39,7 +39,7 @@ export async function createGroupWithMembers(
   return created;
 }
 
-async function resolveAddresses(
+export async function resolveAddresses(
   acct: Account,
   inboxIds: string[],
 ): Promise<Record<string, string>> {

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