rise-wallet 0.1.4-beta.2 → 0.2.29-beta.1

package/src/cli/Dialog.ts

@@ -0,0 +1,75 @@
+import * as Dialog from '../core/Dialog.js'
+import type { QueuedRequest } from '../core/Porto.js'
+import * as Messenger from './Messenger.js'
+
+export const messenger = await Messenger.cliRelay()
+
+/**
+ * Instantiates a CLI dialog.
+ *
+ * @returns CLI dialog.
+ */
+export async function cli() {
+  let isOpen = false
+
+  return Dialog.from({
+    name: 'cli',
+    setup(parameters) {
+      messenger.on('rpc-response', (response) => {
+        Dialog.handleResponse(parameters.internal.store, response)
+      })
+
+      messenger.on('ready', () => {
+        const { store } = parameters.internal
+        const requestQueue = store.getState().requestQueue
+        const requests = requestQueue
+          .map((x) => (x.status === 'pending' ? x : undefined))
+          .filter(Boolean) as readonly QueuedRequest[]
+        messenger.send('rpc-requests', requests)
+      })
+
+      return {
+        close() {},
+        destroy() {
+          messenger.destroy()
+        },
+        open() {
+          const search = new URLSearchParams([['relayUrl', messenger.relayUrl]])
+
+          const host = parameters.host.replace(/\/$/, '')
+          const url = host + '/?' + search.toString()
+
+          console.log('\n\nOpen the URL below in your browser to continue:')
+          console.log(`\n${url}\n`)
+
+          isOpen = true
+        },
+        async secure() {
+          return {
+            frame: true,
+            host: true,
+            protocol: true,
+          }
+        },
+        async syncRequests(requests) {
+          if (requests.length > 1)
+            throw new Error(
+              'renderer (`cli`) does not support multiple requests.',
+            )
+          if (!requests[0]?.request) return
+
+          if (!isOpen) this.open()
+          await messenger.waitForReady()
+          messenger.send('rpc-requests', requests)
+        },
+      }
+    },
+    supportsHeadless: true,
+  })
+}
+
+export declare namespace cli {
+  type Options = {
+    messenger: Messenger.CliRelay
+  }
+}

package/src/cli/Messenger.ts

@@ -0,0 +1,148 @@
+import type { ServerResponse } from 'node:http'
+import * as Url from 'node:url'
+import { Json } from 'ox'
+import * as promise from '../core/internal/promise.js'
+import { uuidv4 } from '../core/internal/utils.js'
+import type * as Messenger from '../core/Messenger.js'
+import * as Http from './internal/http.js'
+
+export type CliRelay = Messenger.Messenger & {
+  relayUrl: string
+  registerPublicKey: (publicKey: string) => void
+  waitForReady: () => Promise<Messenger.ReadyOptions>
+}
+
+export async function cliRelay(): Promise<CliRelay> {
+  const listenerSets = new Map<
+    string,
+    Set<(payload: any, event: any) => void>
+  >()
+
+  const streams = new Set<ServerResponse>()
+
+  // Store for CLI public keys with expiration
+  const keys = new Set<string>()
+
+  const server = await Http.createServer((req, res) => {
+    const url = Url.parse(req.url!, true)
+
+    res.setHeader('Access-Control-Allow-Origin', '*')
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type')
+    res.setHeader('Access-Control-Allow-Private-Network', 'true')
+
+    if (req.method === 'OPTIONS') {
+      res.writeHead(200)
+      res.end()
+      return
+    }
+
+    if (req.method === 'GET' && url.pathname === '/') {
+      res.writeHead(200, {
+        'Access-Control-Allow-Origin': '*',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+        'Content-Type': 'text/event-stream',
+      })
+
+      streams.add(res)
+
+      req.on('close', () => streams.delete(res))
+
+      return
+    }
+
+    if (req.method === 'POST' && url.pathname === '/') {
+      let body = ''
+
+      req.on('data', (chunk) => (body += chunk.toString()))
+
+      req.on('end', () => {
+        try {
+          const data = JSON.parse(body)
+
+          // Handle the received data
+          if (data.topic && data.payload !== undefined) {
+            const listeners = listenerSets.get(data.topic)
+            if (listeners) {
+              const event = { data, origin: 'http://localhost' }
+              for (const listener of listeners) listener(data.payload, event)
+            }
+          }
+
+          res.writeHead(200, { 'Content-Type': 'text/plain' })
+          res.end('ok')
+        } catch (error) {
+          res.writeHead(400, { 'Content-Type': 'text/plain' })
+          res.end('Invalid JSON')
+        }
+      })
+    } else if (req.method === 'GET' && url.pathname === '/.well-known/keys') {
+      res.writeHead(200, {
+        'Access-Control-Allow-Origin': '*',
+        'Content-Type': 'application/json',
+      })
+      res.end(JSON.stringify({ keys: Array.from(keys) }))
+    } else {
+      res.writeHead(404, { 'Content-Type': 'text/plain' })
+      res.end('not found')
+    }
+  })
+
+  const relayUrl = server.url
+
+  const ready = promise.withResolvers<Messenger.ReadyOptions>()
+
+  const messenger = {
+    destroy() {
+      listenerSets.clear()
+      for (const stream of streams)
+        try {
+          stream.end()
+        } catch {}
+
+      streams.clear()
+      server.close()
+    },
+    on(topic, listener) {
+      if (!listenerSets.has(topic)) listenerSets.set(topic, new Set())
+      listenerSets.get(topic)!.add(listener)
+
+      return () => {
+        const listeners = listenerSets.get(topic)
+        if (!listeners) return
+
+        listeners.delete(listener)
+        if (listeners.size === 0) listenerSets.delete(topic)
+      }
+    },
+    registerPublicKey(publicKey: string) {
+      keys.add(publicKey)
+    },
+    relayUrl,
+    async send(topic, payload) {
+      const id = uuidv4()
+      const data = { id, payload, topic }
+
+      const eventData = `data: ${Json.stringify(data)}\n\n`
+      for (const stream of streams) {
+        try {
+          stream.write(eventData)
+        } catch {
+          streams.delete(stream)
+        }
+      }
+
+      return { id, payload, topic } as never
+    },
+    async sendAsync() {
+      throw new Error('Not implemented')
+    },
+    waitForReady() {
+      messenger.on('ready', ready.resolve)
+      return ready.promise
+    },
+  } satisfies CliRelay
+
+  return messenger
+}

package/src/cli/bin/index.ts

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { cac } from 'cac'
+
+import pkgJson from '../../../package.json' with { type: 'json' }
+
+const cli = cac('porto')
+
+cli.command('[root]', 'Display usage').action(() => {
+  cli.outputHelp()
+  process.exit(0)
+})
+
+cli
+  .command('onboard [alias: o]', 'Create a Porto Account')
+  .alias('o')
+  .option(
+    '-a, --admin-key',
+    'Create and provision an additional admin key for server access',
+    {
+      default: false,
+    },
+  )
+  .option('-d, --dialog <hostname>', 'Dialog hostname', {
+    default: 'id.porto.sh',
+  })
+  .option('-t, --testnet', 'Onboard via testnet', {
+    default: false,
+  })
+  .action(async (_, args) => {
+    const Commands = await import('../internal/commands.js')
+    return Commands.createAccount(null, args)
+  })
+
+cli.help()
+cli.version(pkgJson.version)
+
+cli.parse()

package/src/cli/bin/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "include": ["."],
+  "compilerOptions": {
+    "noEmit": true,
+    "resolveJsonModule": true
+  }
+}

package/src/cli/index.ts

@@ -0,0 +1,2 @@
+export * as Dialog from './Dialog.js'
+export * as Messenger from './Messenger.js'

package/src/cli/internal/commands.ts

@@ -0,0 +1,216 @@
+import * as fs from 'node:fs'
+import * as os from 'node:os'
+import * as path from 'node:path'
+import { setTimeout } from 'node:timers/promises'
+import * as prompts from '@clack/prompts'
+import { numberToHex } from 'viem'
+import * as Actions from 'viem/actions'
+import * as Chains from '../../core/Chains.js'
+import * as Key from '../../viem/Key.js'
+import * as WalletActions from '../../viem/WalletActions.js'
+import * as Dialog from '../Dialog.js'
+import * as Context from './context.js'
+
+/** Creates a Porto account. */
+export async function createAccount(_: unknown, args: createAccount.Arguments) {
+  const client = await Context.getWalletClient(args)
+
+  prompts.intro('Create a Porto Account')
+
+  const s = prompts.spinner()
+
+  const adminKey = args.adminKey ? Key.createSecp256k1() : undefined
+
+  // persist admin key immediately to a secure temp file
+  let tempKeyFile: string | undefined
+  if (adminKey) {
+    try {
+      const tmpDir = path.join(os.tmpdir(), 'porto')
+      fs.mkdirSync(tmpDir, { mode: 0o700, recursive: true })
+      tempKeyFile = path.join(
+        tmpDir,
+        `admin-key-${Date.now()}-${Math.random().toString(36).slice(2)}.key`,
+      )
+      fs.writeFileSync(tempKeyFile, adminKey.privateKey!()!, { mode: 0o600 })
+    } catch {}
+  }
+
+  let shouldPrintKeyOnExit = Boolean(adminKey)
+  function cleanup(label?: string, err?: unknown) {
+    if (!shouldPrintKeyOnExit) return process.exit(1)
+    try {
+      s.stop('Interrupted.')
+    } catch {}
+    if (err) {
+      const message = err instanceof Error ? err.message : String(err)
+      prompts.log.info(`${label ?? 'Error'}: ${message}`)
+    }
+    if (adminKey) {
+      if (tempKeyFile) {
+        prompts.log.info(
+          `Admin key saved securely to temporary file: ${tempKeyFile}`,
+        )
+      } else {
+        prompts.log.warn(
+          'Admin key could not be saved to a temporary file. Please rerun to generate a new key.',
+        )
+      }
+    }
+    shouldPrintKeyOnExit = false
+    process.exit(1)
+  }
+
+  const onSigint = () => cleanup('SIGINT')
+  const onSigterm = () => cleanup('SIGTERM')
+  const onUncaught = (error: unknown) => cleanup('uncaughtException', error)
+  const onUnhandled = (reason: unknown) => cleanup('unhandledRejection', reason)
+  const onExit = () => {
+    if (!shouldPrintKeyOnExit) return
+    if (adminKey) {
+      if (tempKeyFile) {
+        prompts.log.info(
+          `Admin key saved securely to temporary file:\n${tempKeyFile}`,
+        )
+      } else {
+        prompts.log.warn(
+          'Admin key could not be saved to a temporary file. Please rerun to generate a new key.',
+        )
+      }
+    }
+    shouldPrintKeyOnExit = false
+  }
+
+  if (adminKey) {
+    process.on('SIGINT', onSigint)
+    process.on('SIGTERM', onSigterm)
+    process.on('uncaughtException', onUncaught)
+    process.on('unhandledRejection', onUnhandled as never)
+    process.on('exit', onExit)
+  }
+
+  // Register public key for verification.
+  if (adminKey) Dialog.messenger.registerPublicKey(adminKey.publicKey)
+
+  const chainId = Chains.riseTestnet.id
+
+  // Create an account.
+  s.start('Creating account...')
+  const { accounts } = await WalletActions.connect(client, {
+    chainIds: [chainId],
+    createAccount: true,
+    grantAdmins: adminKey
+      ? [
+          {
+            publicKey: adminKey.publicKey,
+            type: adminKey.type,
+          },
+        ]
+      : undefined,
+  })
+  s.stop('Account created.')
+
+  // Onramp the account (needed for delegation on next step).
+  s.start('Onramping...')
+  await client.request({
+    method: 'wallet_addFunds',
+    params: [
+      {
+        address: accounts[0]!.address,
+        token: args.testnet
+          ? undefined
+          : '0x0000000000000000000000000000000000000000',
+      },
+    ],
+  })
+  s.stop('Onramped.')
+
+  // Send success message to the dialog.
+  Dialog.messenger.send('success', {
+    content: 'You have successfully created an account.',
+    title: 'Account created',
+  })
+
+  // Execute a noop call to deploy the account.
+  if (adminKey) {
+    const { digest, ...request } = await client.request({
+      method: 'wallet_prepareCalls',
+      params: [
+        {
+          calls: [],
+          chainId: numberToHex(chainId),
+          key: adminKey,
+        },
+      ],
+    })
+
+    const signature = await Key.sign(adminKey, {
+      address: null,
+      payload: digest,
+      wrap: false,
+    })
+
+    const result = await client.request({
+      method: 'wallet_sendPreparedCalls',
+      params: [
+        {
+          ...request,
+          signature,
+        },
+      ],
+    })
+
+    s.start('Initializing account...')
+    await Actions.waitForCallsStatus(client, {
+      id: result[0]!.id,
+      throwOnFailure: true,
+    })
+    s.stop('Account initialized.')
+  }
+
+  if (adminKey) {
+    const reveal = await prompts.confirm({
+      initialValue: false,
+      message: 'Reveal private key? (This will be visible in terminal)',
+    })
+
+    prompts.log.info('Address: ' + accounts[0]!.address)
+    if (reveal) prompts.log.info('Private key: ' + adminKey?.privateKey!()!)
+    else {
+      const keyFile = path.join(
+        import.meta.dirname,
+        `${accounts[0]!.address}.key`,
+      )
+      fs.writeFileSync(keyFile, adminKey?.privateKey!()!, { mode: 0o600 })
+      fs.chmodSync(keyFile, 0o600)
+      prompts.log.info(`Private key saved securely to: ${keyFile}`)
+    }
+    if (tempKeyFile)
+      try {
+        fs.rmSync(tempKeyFile)
+      } catch {}
+  }
+  prompts.log.info('Manage your account at: https://id.porto.sh')
+
+  shouldPrintKeyOnExit = false
+  if (adminKey) {
+    process.off('SIGINT', onSigint)
+    process.off('SIGTERM', onSigterm)
+    process.off('uncaughtException', onUncaught)
+    process.off('unhandledRejection', onUnhandled as never)
+    process.off('exit', onExit)
+  }
+
+  await setTimeout(1_000)
+  process.exit(0)
+}
+
+export declare namespace createAccount {
+  type Arguments = {
+    /** Create a server key with admin privileges. */
+    adminKey?: boolean | undefined
+    /** Dialog hostname. */
+    dialog?: string | undefined
+    /** Whether to onboard via testnet. */
+    testnet?: boolean | undefined
+  }
+}

package/src/cli/internal/context.ts

@@ -0,0 +1,56 @@
+import { createClient, http } from 'viem'
+import { getChainId } from 'viem/actions'
+
+import * as Chains from '../../core/Chains.js'
+import * as Mode from '../../core/Mode.js'
+import * as Porto from '../../core/Porto.js'
+import * as WalletClient from '../../viem/WalletClient.js'
+import * as Dialog from '../Dialog.js'
+import * as Utils from './utils.js'
+
+/** Gets a Viem client for Porto Dialog. */
+export async function getWalletClient(options: getWalletClient.Options = {}) {
+  const { dialog: host } = options
+  const porto = Porto.create({
+    announceProvider: false,
+    chains: [Chains.riseTestnet],
+    mode: Mode.dialog({
+      host: host ? new URL('/dialog', 'https://' + host).toString() : undefined,
+      renderer: await Dialog.cli(),
+    }),
+  })
+  return WalletClient.fromPorto(porto, {
+    chain: Chains.riseTestnet,
+  })
+}
+
+export declare namespace getWalletClient {
+  type Options = {
+    /** Dialog hostname. */
+    dialog?: string | undefined
+  }
+}
+
+/** Gets a Viem client for Relay. */
+export async function getRelayClient(options: getRelayClient.Options = {}) {
+  const chain = Utils.kebabToCamel(options.chain!) as keyof typeof Chains
+  const client = createClient({
+    // biome-ignore lint/performance/noDynamicNamespaceImportAccess: _
+    chain: Chains[chain] as Chains.Chain,
+    transport: http(options.rpc),
+  })
+  client.chain = {
+    ...client.chain,
+    id: (await getChainId(client)) as never,
+  }
+  return client
+}
+
+export declare namespace getRelayClient {
+  type Options = {
+    /** Chain name. */
+    chain?: string | undefined
+    /** Relay URL. */
+    rpc?: string | undefined
+  }
+}

package/src/cli/internal/http.ts

@@ -0,0 +1,28 @@
+import * as Http from 'node:http'
+import type { AddressInfo } from 'node:net'
+
+export type Server = Http.Server & {
+  closeAsync: () => Promise<unknown>
+  url: string
+}
+
+export function createServer(handler: Http.RequestListener): Promise<Server> {
+  const server = Http.createServer(handler)
+
+  return new Promise((resolve, reject) => {
+    server.on('error', reject)
+    server.listen(() => {
+      const { port } = server.address() as AddressInfo
+      resolve(
+        Object.assign(server, {
+          closeAsync() {
+            return new Promise((resolve, reject) =>
+              server.close((err) => (err ? reject(err) : resolve(undefined))),
+            )
+          },
+          url: `http://localhost:${port}`,
+        }),
+      )
+    })
+  })
+}

package/src/cli/internal/utils.ts

@@ -0,0 +1,28 @@
+import * as Chains from '../../core/Chains.js'
+
+/** Gets all chain names. */
+export function getChainNames() {
+  return Object.entries(Chains)
+    .filter(([_, chain]) => typeof chain === 'object' && 'id' in chain)
+    .map(([key]) => camelToKebab(key))
+}
+
+/** Converts kebab-case string to camelCase. */
+export function kebabToCamel(str: string): string {
+  return str
+    .split('-')
+    .map((word, index) =>
+      index === 0
+        ? word.toLowerCase()
+        : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase(),
+    )
+    .join('')
+}
+
+/** Converts camelCase string to kebab-case. */
+export function camelToKebab(str: string): string {
+  return str
+    .split(/(?=[A-Z])/)
+    .map((word) => word.toLowerCase())
+    .join('-')
+}

package/src/cli/tsdown.config.ts

@@ -0,0 +1,37 @@
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { defineConfig } from 'tsdown'
+
+export default defineConfig({
+  clean: false,
+  dts: false,
+  entry: [resolve(import.meta.dirname, 'bin/index.ts')],
+  external: getExternals(),
+  format: ['esm'],
+  minify: true,
+  outDir: resolve(import.meta.dirname, '../../dist/cli/bin'),
+  target: 'node20',
+})
+
+////////////////////////////////////////////////////////////////////////
+// Utilities
+
+function getExternals() {
+  const pkgJson = JSON.parse(
+    readFileSync(resolve(import.meta.dirname, '../../package.json'), 'utf-8'),
+  )
+
+  const externals: (string | RegExp)[] = []
+  const dependencies = pkgJson.dependencies || {}
+
+  for (const [depName] of Object.entries(dependencies)) {
+    if (depName === 'ox') continue
+
+    // Add a regex pattern for the package and all its subpaths
+    externals.push(
+      new RegExp(`^${depName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(\\/.*)?$`),
+    )
+  }
+
+  return externals
+}

package/src/core/Chains.ts

@@ -0,0 +1,25 @@
+import { type Chain, defineChain } from 'viem'
+import { anvil as viem_anvil } from 'viem/chains'
+import * as chains from './internal/_generated/chains.js'
+
+export type { Chain } from 'viem/chains'
+export * from './internal/_generated/chains.js'
+
+export const all = [
+  chains.riseTestnet,
+  ...Object.values(chains).filter((c) => c.id !== chains.riseTestnet.id),
+] as const satisfies [Chain, ...Chain[]]
+
+export const anvil = viem_anvil
+
+/** Additional Anvil environment, purposed for interop. */
+export const anvil2 = /*#__PURE__*/ defineChain({
+  ...anvil,
+  id: 31_338,
+})
+
+/** Additional Anvil environment, purposed for interop. */
+export const anvil3 = /*#__PURE__*/ defineChain({
+  ...anvil,
+  id: 31_339,
+})