rise-wallet 0.1.4-beta.1 → 0.2.28

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,212 @@
+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 * 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)
+
+  // Create an account.
+  s.start('Creating account...')
+  const { accounts } = await WalletActions.connect(client, {
+    chainIds: [Chains.riseTestnet.id],
+    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: [],
+          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,
+})