ethagent 2.1.1 → 2.2.0

package/src/providers/openai-responses.ts

@@ -0,0 +1,276 @@
+import type { ProviderId } from '../storage/config.js'
+import type { Message, Provider, ProviderCompleteOptions, StreamEvent } from './contracts.js'
+import { ProviderError } from './contracts.js'
+import { providerErrorFromResponse } from './errors.js'
+import { fetchWithRetryStreamEvents } from './retry.js'
+import { iterSseEvents } from './sse.js'
+import { buildResponsesBody } from './openai-responses-format.js'
+import type { OpenAIToolDefinition } from './openai-chat.js'
+
+const READ_TIMEOUT_MS = 45_000
+
+type DoneStopReason = 'end_turn' | 'tool_use' | 'max_tokens' | 'stop_sequence' | 'unknown'
+
+export type OpenAIResponsesProviderOptions = {
+  model: string
+  baseUrl: string
+  accessToken: string
+  accountId?: string
+  originator?: string
+  tools?: OpenAIToolDefinition[]
+  maxRetries?: number
+  refresh?: () => Promise<string>
+}
+
+type StreamingToolCall = {
+  callId: string
+  name: string
+  inputJson: string
+  started: boolean
+}
+
+export class OpenAIResponsesProvider implements Provider {
+  readonly id: ProviderId = 'openai'
+  readonly model: string
+  readonly supportsTools: boolean
+  private accessToken: string
+  private readonly baseUrl: string
+  private readonly accountId?: string
+  private readonly originator: string
+  private readonly tools: OpenAIToolDefinition[]
+  private readonly maxRetries?: number
+  private readonly refresh?: () => Promise<string>
+
+  constructor(opts: OpenAIResponsesProviderOptions) {
+    this.model = opts.model
+    this.baseUrl = opts.baseUrl.replace(/\/+$/, '')
+    this.accessToken = opts.accessToken
+    this.accountId = opts.accountId
+    this.originator = opts.originator ?? 'codex_cli_rs'
+    this.tools = opts.tools ?? []
+    this.maxRetries = opts.maxRetries
+    this.refresh = opts.refresh
+    this.supportsTools = this.tools.length > 0
+  }
+
+  async *complete(
+    messages: Message[],
+    signal: AbortSignal,
+    options: ProviderCompleteOptions = {},
+  ): AsyncIterable<StreamEvent> {
+    if (!this.accessToken) {
+      const error = new ProviderError('missing OAuth access token for openai (sign in again via the model picker)')
+      yield { type: 'error', message: error.message }
+      return
+    }
+
+    let attempt = 0
+    while (true) {
+      attempt += 1
+      const body = JSON.stringify(buildResponsesBody({
+        model: this.model,
+        messages,
+        tools: this.tools,
+        maxOutputTokens: options.maxTokens,
+      }))
+
+      let response: Response
+      try {
+        response = yield* fetchWithRetryStreamEvents(`${this.baseUrl}/responses`, {
+          method: 'POST',
+          headers: this.requestHeaders(),
+          body,
+        }, { signal, maxRetries: this.maxRetries, rateLimitResetProvider: 'openai-compatible' })
+      } catch (err: unknown) {
+        if (signal.aborted) return
+        yield { type: 'error', message: networkErrorMessage(this.baseUrl, err) }
+        return
+      }
+
+      if (response.status === 401 && this.refresh && attempt === 1) {
+        try {
+          this.accessToken = await this.refresh()
+          continue
+        } catch (refreshErr) {
+          const message = refreshErr instanceof Error ? refreshErr.message : String(refreshErr)
+          yield { type: 'error', message: `OpenAI sign-in expired and refresh failed: ${message}` }
+          return
+        }
+      }
+
+      if (!response.ok) {
+        const error = await providerErrorFromResponse('openai', response)
+        yield { type: 'error', message: error.message }
+        return
+      }
+      if (!response.body) {
+        yield { type: 'error', message: 'empty response body' }
+        return
+      }
+
+      yield* this.parseStream(response.body, signal)
+      return
+    }
+  }
+
+  private requestHeaders(): Record<string, string> {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      Accept: 'text/event-stream',
+      Authorization: `Bearer ${this.accessToken}`,
+      originator: this.originator,
+    }
+    if (this.accountId) headers['chatgpt-account-id'] = this.accountId
+    return headers
+  }
+
+  private async *parseStream(body: ReadableStream<Uint8Array>, signal: AbortSignal): AsyncIterable<StreamEvent> {
+    const toolCalls = new Map<string, StreamingToolCall>()
+    let inputTokens: number | undefined
+    let outputTokens: number | undefined
+    let stopReason: DoneStopReason = 'unknown'
+
+    try {
+      for await (const frame of iterSseEvents(body, signal, READ_TIMEOUT_MS)) {
+        const eventName = frame.event ?? ''
+        if (!frame.data || frame.data === '[DONE]') continue
+        let parsed: Record<string, unknown>
+        try {
+          parsed = JSON.parse(frame.data) as Record<string, unknown>
+        } catch {
+          continue
+        }
+
+        switch (eventName) {
+          case 'response.output_text.delta': {
+            const delta = typeof parsed.delta === 'string' ? parsed.delta : ''
+            if (delta) yield { type: 'text', delta }
+            break
+          }
+          case 'response.reasoning_summary_text.delta':
+          case 'response.reasoning.delta':
+          case 'response.reasoning_text.delta': {
+            const delta = typeof parsed.delta === 'string' ? parsed.delta : ''
+            if (delta) yield { type: 'thinking', delta }
+            break
+          }
+          case 'response.output_item.added': {
+            const item = (parsed.item ?? {}) as Record<string, unknown>
+            if (item.type === 'function_call') {
+              const callId = pickString(item.call_id) ?? pickString(item.id) ?? `tool-${toolCalls.size}`
+              const name = pickString(item.name) ?? ''
+              toolCalls.set(callId, { callId, name, inputJson: '', started: false })
+              if (name) {
+                toolCalls.get(callId)!.started = true
+                yield { type: 'tool_use_start', id: callId, name }
+              }
+            }
+            break
+          }
+          case 'response.function_call_arguments.delta': {
+            const callId = resolveCallId(parsed, toolCalls)
+            const delta = typeof parsed.delta === 'string' ? parsed.delta : ''
+            if (!callId || !delta) break
+            const existing = toolCalls.get(callId)
+            if (!existing) break
+            existing.inputJson += delta
+            yield { type: 'tool_use_delta', id: callId, delta }
+            break
+          }
+          case 'response.output_item.done': {
+            const item = (parsed.item ?? {}) as Record<string, unknown>
+            if (item.type === 'function_call') {
+              const callId = pickString(item.call_id) ?? pickString(item.id)
+              if (!callId) break
+              const existing = toolCalls.get(callId)
+              const name = pickString(item.name) ?? existing?.name ?? ''
+              const argsJson = pickString(item.arguments) ?? existing?.inputJson ?? ''
+              stopReason = 'tool_use'
+              yield {
+                type: 'tool_use_stop',
+                id: callId,
+                name,
+                input: parseToolArguments(argsJson),
+              }
+              toolCalls.delete(callId)
+            }
+            break
+          }
+          case 'response.completed': {
+            const usage = (parsed.response as { usage?: Record<string, unknown> } | undefined)?.usage
+            const tokens = readUsage(usage)
+            if (tokens.input !== undefined) inputTokens = tokens.input
+            if (tokens.output !== undefined) outputTokens = tokens.output
+            if (stopReason !== 'tool_use') stopReason = 'end_turn'
+            break
+          }
+          case 'response.failed':
+          case 'response.error':
+          case 'error': {
+            const error = parsed.error as { message?: string } | undefined
+            const message = error?.message ?? 'Responses API error'
+            yield { type: 'error', message }
+            return
+          }
+          case 'response.incomplete': {
+            const reason = pickString((parsed.response as { incomplete_details?: { reason?: string } } | undefined)?.incomplete_details?.reason)
+            if (reason === 'max_output_tokens') stopReason = 'max_tokens'
+            break
+          }
+          default:
+            break
+        }
+      }
+    } catch (err: unknown) {
+      if (signal.aborted) return
+      yield { type: 'error', message: networkErrorMessage(this.baseUrl, err, 'stream error') }
+      return
+    }
+
+    if (signal.aborted) return
+    yield { type: 'done', inputTokens, outputTokens, stopReason }
+  }
+}
+
+function pickString(value: unknown): string | undefined {
+  return typeof value === 'string' && value.length > 0 ? value : undefined
+}
+
+function resolveCallId(parsed: Record<string, unknown>, calls: Map<string, StreamingToolCall>): string | undefined {
+  return (
+    pickString(parsed.call_id)
+    ?? pickString(parsed.item_id)
+    ?? pickString((parsed.item as Record<string, unknown> | undefined)?.call_id)
+    ?? pickString((parsed.item as Record<string, unknown> | undefined)?.id)
+    ?? (calls.size === 1 ? Array.from(calls.keys())[0] : undefined)
+  )
+}
+
+function readUsage(usage: Record<string, unknown> | undefined): { input?: number; output?: number } {
+  if (!usage) return {}
+  const input = typeof usage.input_tokens === 'number'
+    ? usage.input_tokens
+    : typeof usage.prompt_tokens === 'number' ? usage.prompt_tokens : undefined
+  const output = typeof usage.output_tokens === 'number'
+    ? usage.output_tokens
+    : typeof usage.completion_tokens === 'number' ? usage.completion_tokens : undefined
+  return { input, output }
+}
+
+function parseToolArguments(input: string): Record<string, unknown> {
+  const trimmed = input.trim()
+  if (!trimmed) return {}
+  try {
+    const parsed = JSON.parse(trimmed) as unknown
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? (parsed as Record<string, unknown>)
+      : {}
+  } catch {
+    return {}
+  }
+}
+
+function networkErrorMessage(baseUrl: string, err: unknown, fallback = 'network error'): string {
+  const message = (err as Error).message || fallback
+  return `openai request failed at ${baseUrl}: ${message}`
+}

package/src/providers/registry.ts

@@ -6,10 +6,19 @@ import type { SessionMode } from '../runtime/sessionMode.js'
 import { AnthropicProvider } from './anthropic.js'
 import { GeminiProvider } from './gemini.js'
 import { OpenAIChatProvider } from './openai-chat.js'
+import { OpenAIResponsesProvider } from './openai-responses.js'
 import { anthropicTools, geminiTools, openAITools } from '../tools/registry.js'
-import { openAIBaseUrlFor } from '../models/catalog.js'
+import { openAIBaseUrlFor, OPENAI_OAUTH_DEFAULT_MODEL, isOpenAIOAuthAllowedModel } from '../models/catalog.js'
+import {
+  getOpenAIOAuthCredentials,
+  setOpenAIOAuthCredentials,
+  type OpenAIOAuthCredentials,
+} from '../auth/openaiOAuth/credentials.js'
+import { refreshOpenAIAccessToken, shouldRefresh } from '../auth/openaiOAuth/refresh.js'
 import type { Tool } from '../tools/contracts.js'
 
+export const OPENAI_CHATGPT_BACKEND_URL = 'https://chatgpt.com/backend-api/codex'
+
 export function isLocalProvider(provider: string): boolean {
   return provider === 'llamacpp'
 }
@@ -27,16 +36,84 @@ export function createProvider(config: EthagentConfig, options: { mode?: Session
         tools: openAITools(mode, toolContext),
       })
     case 'openai':
-      return new OpenAIChatProvider({
-        id: 'openai',
-        model: config.model,
-        baseUrl: openAIBaseUrlFor(config),
-        loadApiKey: () => getKey('openai'),
-        tools: openAITools(mode, toolContext),
-      })
+      return createOpenAIProvider(config, openAITools(mode, toolContext))
     case 'anthropic':
       return new AnthropicProvider({ model: config.model, tools: anthropicTools(mode, toolContext) })
     case 'gemini':
       return new GeminiProvider({ model: config.model, tools: geminiTools(mode, toolContext) })
   }
 }
+
+function createOpenAIProvider(config: EthagentConfig, tools: ReturnType<typeof openAITools>): Provider {
+  return new OpenAIRoutingProvider(config, tools)
+}
+
+class OpenAIRoutingProvider implements Provider {
+  readonly id = 'openai' as const
+  readonly model: string
+  readonly supportsTools: boolean
+  private delegate: Provider | null = null
+  private readonly config: EthagentConfig
+  private readonly tools: ReturnType<typeof openAITools>
+
+  constructor(config: EthagentConfig, tools: ReturnType<typeof openAITools>) {
+    this.config = config
+    this.tools = tools
+    this.model = config.model
+    this.supportsTools = tools.length > 0
+  }
+
+  async *complete(...args: Parameters<Provider['complete']>): ReturnType<Provider['complete']> {
+    if (!this.delegate) this.delegate = await this.resolveDelegate()
+    yield* this.delegate.complete(...args)
+  }
+
+  private async resolveDelegate(): Promise<Provider> {
+    const oauth = await loadFreshOAuthCredentials()
+    if (oauth) {
+      const oauthModel = isOpenAIOAuthAllowedModel(this.model) ? this.model : OPENAI_OAUTH_DEFAULT_MODEL
+      return new OpenAIResponsesProvider({
+        model: oauthModel,
+        baseUrl: OPENAI_CHATGPT_BACKEND_URL,
+        accessToken: oauth.accessToken,
+        accountId: oauth.accountId,
+        tools: this.tools,
+        refresh: async () => {
+          const next = await loadFreshOAuthCredentials({ force: true })
+          if (!next) throw new Error('No OAuth credentials available')
+          return next.accessToken
+        },
+      })
+    }
+    return new OpenAIChatProvider({
+      id: 'openai',
+      model: this.model,
+      baseUrl: openAIBaseUrlFor(this.config),
+      loadApiKey: () => getKey('openai'),
+      tools: this.tools,
+    })
+  }
+}
+
+async function loadFreshOAuthCredentials(options: { force?: boolean } = {}): Promise<OpenAIOAuthCredentials | null> {
+  const current = await getOpenAIOAuthCredentials()
+  if (!current) return null
+  if (!options.force && !shouldRefresh(current)) return current
+
+  try {
+    const refreshed = await refreshOpenAIAccessToken(current.refreshToken)
+    const now = Date.now()
+    const next: OpenAIOAuthCredentials = {
+      accessToken: refreshed.accessToken,
+      refreshToken: refreshed.refreshToken,
+      idToken: refreshed.idToken ?? current.idToken,
+      accountId: refreshed.accountId ?? current.accountId,
+      expiresAt: now + refreshed.expiresIn * 1000,
+      lastRefreshAt: now,
+    }
+    await setOpenAIOAuthCredentials(next)
+    return next
+  } catch {
+    return current
+  }
+}

package/src/runtime/systemPrompt.ts

@@ -93,6 +93,7 @@ function buildToolEnabledPrompt(ctx: SystemPromptContext): string {
                     'When exact private continuity text is needed for surgical removal or targeted replacement, call `read_private_continuity_file` with `file: "MEMORY.md"` or `file: "SOUL.md"` first.',
                     'When the user wants memory, persona, preferences, or private identity continuity changed, call `propose_private_continuity_edit`; do NOT create, overwrite, or patch SOUL.md/MEMORY.md with `write_file` or `edit_file`.',
                     'For private continuity, edit the existing scaffold and build on top of it: prefer `appendToSection`+`appendText` for new notes or use `oldText`+`newText` for targeted replacement. Never omit the edit anchor, never create a new file, and never replace the whole file.',
+                    'Never call `propose_private_continuity_edit` with `{}` or only `file`. Send exactly one edit mode: either `appendToSection` + non-empty `appendText`, or `oldText` + `newText`. Omit the fields you are not using — do not pass empty strings for `oldText`/`newText` alongside an append, or empty `appendToSection`/`appendText` alongside a targeted edit.',
                     'If the user asks to remember preferences or facts, call exactly one private continuity append such as `{"file":"MEMORY.md","appendToSection":"Durable User Preferences","appendText":"- User preference or durable memory."}`.',
                     'If the user asks to change persona or standing behavior, call exactly one private continuity append such as `{"file":"SOUL.md","appendToSection":"Persona","appendText":"- Persona or standing behavior."}`.',
                   ]
@@ -120,7 +121,6 @@ function buildToolEnabledPrompt(ctx: SystemPromptContext): string {
               ? [
                   'For private SOUL.md or MEMORY.md inspection, do not search project folders. Call `read_private_continuity_file` with `file: "SOUL.md"` or `file: "MEMORY.md"`.',
                   'For private SOUL.md or MEMORY.md changes, call `propose_private_continuity_edit` with `file: "SOUL.md"` or `file: "MEMORY.md"` and an in-place append/replacement payload.',
-                  'Never call `propose_private_continuity_edit` with `{}` or only `file`. For memory/preferences include `appendToSection: "Durable User Preferences"` and a non-empty `appendText`; for persona include `appendToSection: "Persona"` and a non-empty `appendText`.',
                 ]
               : []),
             'For targeted private continuity edits with `oldText`, copy the text verbatim from the most recent `read_private_continuity_file` output. For workspace targeted edits, copy from the most recent `read_file` output.',

package/src/runtime/turn.ts

@@ -461,7 +461,6 @@ function nextToolResultRepairNudge(
   completedTools: ExecutedToolUse[],
 ): string | null {
   if (!provider.supportsTools) return null
-  if (provider.id !== 'llamacpp') return null
   const failedPrivateEdit = completedTools.some(completed =>
     completed.name === 'propose_private_continuity_edit'
     && !completed.result.ok

package/src/storage/secrets.ts

@@ -129,8 +129,11 @@ export async function getSecret(account: string): Promise<string | null> {
 }
 
 export async function setSecret(account: string, value: string): Promise<KeyBackend> {
+  if (typeof value !== 'string') {
+    throw new Error(`setSecret(${account}): value is ${typeof value}, expected string`)
+  }
   const trimmed = value.trim()
-  if (!trimmed) throw new Error('Secret value is empty')
+  if (!trimmed) throw new Error(`setSecret(${account}): value is empty`)
   const keytar = await loadKeytar()
   if (keytar) {
     await keytar.setPassword(KEYTAR_SERVICE, account, trimmed)

package/src/tools/privateContinuityEditTool.ts

@@ -166,6 +166,12 @@ function normalizePrivateContinuityInput(input: Record<string, unknown>): Record
   if (normalized.appendText === undefined) {
     normalized.appendText = normalized.note ?? normalized.text ?? normalized.content
   }
+  for (const key of ['oldText', 'newText', 'appendToSection', 'appendText'] as const) {
+    const value = normalized[key]
+    if (typeof value === 'string' && value.trim() === '') {
+      normalized[key] = undefined
+    }
+  }
   return normalized
 }
 

package/src/utils/openExternal.ts

@@ -3,18 +3,28 @@ import { spawn } from 'node:child_process'
 export function openExternalUrl(url: string): void {
   const target = url.trim()
   if (!target) return
-  const command = process.platform === 'win32'
-    ? 'cmd'
-    : process.platform === 'darwin'
-      ? 'open'
-      : 'xdg-open'
-  const args = process.platform === 'win32'
-    ? ['/c', 'start', '', target]
-    : [target]
-  const child = spawn(command, args, {
+
+  if (process.platform === 'win32') {
+    const safe = target.replace(/"/g, '%22')
+    const child = spawn(
+      'cmd.exe',
+      ['/s', '/c', `start "" "${safe}"`],
+      {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+        windowsVerbatimArguments: true,
+      },
+    )
+    child.on('error', () => {})
+    child.unref()
+    return
+  }
+
+  const command = process.platform === 'darwin' ? 'open' : 'xdg-open'
+  const child = spawn(command, [target], {
     detached: true,
     stdio: 'ignore',
-    windowsHide: true,
   })
   child.on('error', () => {})
   child.unref()

package/src/identity/ens/ensRegistration.ts

@@ -1,199 +0,0 @@
-import {
-  encodeAbiParameters,
-  encodeFunctionData,
-  getAddress,
-  keccak256,
-  namehash,
-  parseAbi,
-  type Address,
-  type Hex,
-  type PublicClient,
-} from 'viem'
-
-export const ETH_REGISTRAR_CONTROLLER_MAINNET = '0x253553366Da8546fC250F225fe3d25d0C782303b' as Address
-export const PUBLIC_RESOLVER_MAINNET = '0x231b0Ee14048e9dCcD1d247744d114a4EB5E8E63' as Address
-export const MIN_COMMIT_AGE_SECONDS = 60
-export const MAX_COMMIT_AGE_SECONDS = 86_400
-export const ONE_YEAR_SECONDS = 31_557_600
-export const REGISTER_VALUE_BUFFER_BIPS = 500n
-
-const CONTROLLER_ABI = parseAbi([
-  'function available(string name) view returns (bool)',
-  'function rentPrice(string name, uint256 duration) view returns (uint256 base, uint256 premium)',
-  'function commit(bytes32 commitment)',
-  'function register(string name, address owner, uint256 duration, bytes32 secret, address resolver, bytes[] data, bool reverseRecord, uint16 ownerControlledFuses) payable',
-])
-
-const RESOLVER_ABI = parseAbi([
-  'function setAddr(bytes32 node, address a)',
-])
-
-export type RegistrableNameValidation =
-  | { ok: true; label: string }
-  | { ok: false; reason: 'too-short' | 'too-long' | 'invalid-characters' | 'leading-hyphen' | 'trailing-hyphen' | 'contains-dot'; detail: string }
-
-export function validateRegistrableName(value: string): RegistrableNameValidation {
-  const label = value.trim().toLowerCase()
-  if (label.includes('.')) {
-    return { ok: false, reason: 'contains-dot', detail: 'Enter only the label, not a full .eth name.' }
-  }
-  if (label.length < 3) {
-    return { ok: false, reason: 'too-short', detail: 'Names must be at least 3 characters.' }
-  }
-  if (label.length > 64) {
-    return { ok: false, reason: 'too-long', detail: 'Names must be 64 characters or fewer.' }
-  }
-  if (label.startsWith('-')) {
-    return { ok: false, reason: 'leading-hyphen', detail: 'Names cannot start with a hyphen.' }
-  }
-  if (label.endsWith('-')) {
-    return { ok: false, reason: 'trailing-hyphen', detail: 'Names cannot end with a hyphen.' }
-  }
-  if (!/^[a-z0-9-]+$/.test(label)) {
-    return { ok: false, reason: 'invalid-characters', detail: 'Names use lowercase letters, numbers, and hyphens only.' }
-  }
-  return { ok: true, label }
-}
-
-type RentPrice = {
-  base: bigint
-  premium: bigint
-  total: bigint
-}
-
-export type EnsRegistrationReadClient = Pick<PublicClient, 'readContract'>
-
-export async function readRentPrice(
-  client: EnsRegistrationReadClient,
-  label: string,
-  durationSeconds: bigint,
-): Promise<RentPrice> {
-  const result = await client.readContract({
-    address: ETH_REGISTRAR_CONTROLLER_MAINNET,
-    abi: CONTROLLER_ABI,
-    functionName: 'rentPrice',
-    args: [label, durationSeconds],
-  }) as readonly [bigint, bigint]
-  const [base, premium] = result
-  return { base, premium, total: base + premium }
-}
-
-export async function readNameAvailable(
-  client: EnsRegistrationReadClient,
-  label: string,
-): Promise<boolean> {
-  return await client.readContract({
-    address: ETH_REGISTRAR_CONTROLLER_MAINNET,
-    abi: CONTROLLER_ABI,
-    functionName: 'available',
-    args: [label],
-  }) as boolean
-}
-
-type CommitmentArgs = {
-  label: string
-  owner: Address
-  durationSeconds: bigint
-  secret: Hex
-  resolver?: Address
-  setAddrToOwner?: boolean
-  reverseRecord?: boolean
-  ownerControlledFuses?: number
-}
-
-type CommitmentBuild = {
-  commitment: Hex
-  resolver: Address
-  data: Hex[]
-  reverseRecord: boolean
-  ownerControlledFuses: number
-}
-
-export function buildCommitment(args: CommitmentArgs): CommitmentBuild {
-  const owner = getAddress(args.owner)
-  const resolver = getAddress(args.resolver ?? PUBLIC_RESOLVER_MAINNET)
-  const reverseRecord = args.reverseRecord ?? false
-  const ownerControlledFuses = args.ownerControlledFuses ?? 0
-  const data: Hex[] = []
-  if (args.setAddrToOwner ?? true) {
-    data.push(encodeFunctionData({
-      abi: RESOLVER_ABI,
-      functionName: 'setAddr',
-      args: [namehash(`${args.label}.eth`), owner],
-    }))
-  }
-  const commitment = keccak256(encodeAbiParameters(
-    [
-      { type: 'string' },
-      { type: 'address' },
-      { type: 'uint256' },
-      { type: 'bytes32' },
-      { type: 'address' },
-      { type: 'bytes[]' },
-      { type: 'bool' },
-      { type: 'uint16' },
-    ],
-    [args.label, owner, args.durationSeconds, args.secret, resolver, data, reverseRecord, ownerControlledFuses],
-  ))
-  return { commitment, resolver, data, reverseRecord, ownerControlledFuses }
-}
-
-export function encodeCommitTransaction(commitment: Hex): { to: Address; data: Hex } {
-  return {
-    to: ETH_REGISTRAR_CONTROLLER_MAINNET,
-    data: encodeFunctionData({
-      abi: CONTROLLER_ABI,
-      functionName: 'commit',
-      args: [commitment],
-    }),
-  }
-}
-
-type RegisterTransactionArgs = {
-  label: string
-  owner: Address
-  durationSeconds: bigint
-  secret: Hex
-  rentPrice: RentPrice
-  resolver?: Address
-  setAddrToOwner?: boolean
-  reverseRecord?: boolean
-  ownerControlledFuses?: number
-}
-
-export function encodeRegisterTransaction(args: RegisterTransactionArgs): { to: Address; data: Hex; value: Hex } {
-  const owner = getAddress(args.owner)
-  const built = buildCommitment({
-    label: args.label,
-    owner,
-    durationSeconds: args.durationSeconds,
-    secret: args.secret,
-    ...(args.resolver !== undefined ? { resolver: args.resolver } : {}),
-    ...(args.setAddrToOwner !== undefined ? { setAddrToOwner: args.setAddrToOwner } : {}),
-    ...(args.reverseRecord !== undefined ? { reverseRecord: args.reverseRecord } : {}),
-    ...(args.ownerControlledFuses !== undefined ? { ownerControlledFuses: args.ownerControlledFuses } : {}),
-  })
-  const data = encodeFunctionData({
-    abi: CONTROLLER_ABI,
-    functionName: 'register',
-    args: [args.label, owner, args.durationSeconds, args.secret, built.resolver, built.data, built.reverseRecord, built.ownerControlledFuses],
-  })
-  const buffered = (args.rentPrice.total * (10000n + REGISTER_VALUE_BUFFER_BIPS)) / 10000n
-  return {
-    to: ETH_REGISTRAR_CONTROLLER_MAINNET,
-    data,
-    value: ('0x' + buffered.toString(16)) as Hex,
-  }
-}
-
-export function generateRegistrationSecret(): Hex {
-  const bytes = new Uint8Array(32)
-  if (typeof globalThis.crypto?.getRandomValues === 'function') {
-    globalThis.crypto.getRandomValues(bytes)
-  } else {
-    for (let i = 0; i < bytes.length; i++) bytes[i] = Math.floor(Math.random() * 256)
-  }
-  let hex = '0x'
-  for (const byte of bytes) hex += byte.toString(16).padStart(2, '0')
-  return hex as Hex
-}