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

package/src/core/Messenger.ts

@@ -0,0 +1,394 @@
+import * as Json from 'ox/Json'
+import type * as RpcRequest from 'ox/RpcRequest'
+import type * as RpcResponse from 'ox/RpcResponse'
+import type * as MethodPolicies from '../remote/internal/methodPolicies.js'
+import type * as Theme from '../theme/Theme.js'
+import * as promise from './internal/promise.js'
+import * as Utils from './internal/utils.js'
+import type * as Porto from './Porto.js'
+
+/** Messenger interface. */
+export type Messenger = {
+  destroy: () => void
+  on: <const topic extends Topic>(
+    topic: topic | Topic,
+    listener: (payload: Payload<topic>, event: MessageEvent) => void,
+    id?: string | undefined,
+  ) => () => void
+  send: <const topic extends Topic>(
+    topic: topic | Topic,
+    payload: Payload<topic>,
+    targetOrigin?: string | undefined,
+  ) => Promise<{ id: string; topic: topic; payload: Payload<topic> }>
+  sendAsync: <const topic extends Topic>(
+    topic: topic | Topic,
+    payload: Payload<topic>,
+    targetOrigin?: string | undefined,
+  ) => Promise<Response<topic>>
+}
+
+export type WithReady = Messenger & {
+  ready: (options: ReadyOptions) => void
+}
+
+export type ReadyOptions = {
+  chainIds: readonly [number, ...number[]]
+  methodPolicies?: MethodPolicies.MethodPolicies | undefined
+  trustedHosts?: string[] | undefined
+}
+
+/** Bridge messenger. */
+export type Bridge = WithReady & {
+  waitForReady: () => Promise<ReadyOptions>
+}
+
+/** CLI relay messenger. */
+export type CliRelay = WithReady
+
+/** Messenger schema. */
+export type Schema = [
+  {
+    topic: 'close'
+    payload: undefined
+    response: undefined
+  },
+  {
+    topic: 'ready'
+    payload: ReadyOptions
+    response: undefined
+  },
+  {
+    topic: 'rpc-requests'
+    payload: readonly Porto.QueuedRequest[]
+    response: undefined
+  },
+  {
+    topic: 'rpc-response'
+    payload: RpcResponse.RpcResponse & {
+      _request: RpcRequest.RpcRequest
+    }
+    response: undefined
+  },
+  {
+    topic: 'success'
+    payload: {
+      title: string
+      content: string
+    }
+    response: undefined
+  },
+  {
+    topic: '__internal'
+    payload:
+      | {
+          type: 'init'
+          chainIds?: readonly number[] | undefined
+          mode:
+            | 'inline-iframe'
+            | 'iframe'
+            | 'popup'
+            | 'popup-standalone'
+            | 'page'
+          referrer: {
+            icon?: string | { light: string; dark: string } | undefined
+            title: string
+          }
+          theme?: Theme.ThemeFragment | undefined
+        }
+      | {
+          type: 'switch'
+          mode:
+            | 'inline-iframe'
+            | 'iframe'
+            | 'popup'
+            | 'popup-standalone'
+            | 'page'
+        }
+      | {
+          type: 'resize'
+          height?: number | undefined
+          width?: number | undefined
+        }
+      | {
+          type: 'set-theme'
+          theme: Theme.ThemeFragment
+        }
+      | {
+          // backward compatibility from 0.2.7 (to be removed in a future version)
+          type: 'dialog-lifecycle'
+          action: 'request:close' | 'done:close'
+        }
+    response: undefined
+  },
+]
+
+export type Topic = Schema[number]['topic']
+
+export type Payload<topic extends Topic> = Extract<
+  Schema[number],
+  { topic: topic }
+>['payload']
+
+export type Response<topic extends Topic> = Extract<
+  Schema[number],
+  { topic: topic }
+>['response']
+
+/**
+ * Instantiates a messenger.
+ *
+ * @param messenger - Messenger.
+ * @returns Instantiated messenger.
+ */
+export function from(messenger: Messenger): Messenger {
+  return messenger
+}
+
+/**
+ * Instantiates a messenger from a window instance.
+ *
+ * @param w - Window.
+ * @param options - Options.
+ * @returns Instantiated messenger.
+ */
+export function fromWindow(
+  w: Window,
+  options: fromWindow.Options = {},
+): Messenger {
+  const { targetOrigin } = options
+  const listeners = new Map<string, (event: any) => any>()
+  return from({
+    destroy() {
+      for (const listener of listeners.values()) {
+        w.removeEventListener('message', listener)
+      }
+    },
+    on(topic, listener, id) {
+      function handler(event: MessageEvent) {
+        if (event.data.topic !== topic) return
+        if (id && event.data.id !== id) return
+        if (targetOrigin && event.origin !== targetOrigin) return
+        listener(event.data.payload, event)
+      }
+      w.addEventListener('message', handler)
+      listeners.set(topic, handler)
+      return () => w.removeEventListener('message', handler)
+    },
+    async send(topic, payload, target) {
+      const id = Utils.uuidv4()
+      w.postMessage(
+        Utils.normalizeValue({ id, payload, topic }),
+        target ?? targetOrigin ?? '*',
+      )
+      return { id, payload, topic } as never
+    },
+    async sendAsync(topic, payload, target) {
+      const { id } = await this.send(topic, payload, target)
+      return new Promise<any>((resolve) => this.on(topic as Topic, resolve, id))
+    },
+  })
+}
+
+export declare namespace fromWindow {
+  export type Options = {
+    /**
+     * Target origin.
+     */
+    targetOrigin?: string | undefined
+  }
+}
+
+/**
+ * Bridges two messengers for cross-window (e.g. parent to iframe) communication.
+ *
+ * @param parameters - Parameters.
+ * @returns Instantiated messenger.
+ */
+export function bridge(parameters: bridge.Parameters): Bridge {
+  const { from: from_, to, waitForReady = false } = parameters
+
+  let pending = false
+
+  const ready = promise.withResolvers<ReadyOptions>()
+  from_.on('ready', ready.resolve)
+
+  const messenger = from({
+    destroy() {
+      from_.destroy()
+      to.destroy()
+      if (pending) ready.reject()
+    },
+    on(topic, listener, id) {
+      return from_.on(topic, listener, id)
+    },
+    async send(topic, payload) {
+      pending = true
+      if (waitForReady) await ready.promise.finally(() => (pending = false))
+      return to.send(topic, payload)
+    },
+    async sendAsync(topic, payload) {
+      pending = true
+      if (waitForReady) await ready.promise.finally(() => (pending = false))
+      return to.sendAsync(topic, payload)
+    },
+  })
+
+  return {
+    ...messenger,
+    ready(options) {
+      void messenger.send('ready', options)
+    },
+    waitForReady() {
+      return ready.promise
+    },
+  }
+}
+
+export declare namespace bridge {
+  export type Parameters = {
+    /**
+     * Source messenger.
+     */
+    from: Messenger
+    /**
+     * Target messenger.
+     */
+    to: Messenger
+    /**
+     * Whether to wait for the target messenger to indicate that it is ready via
+     * `messenger.ready()`.
+     */
+    waitForReady?: boolean | undefined
+  }
+}
+
+export function noop(): Bridge {
+  return {
+    destroy() {},
+    on() {
+      return () => {}
+    },
+    ready() {},
+    send() {
+      return Promise.resolve(undefined as never)
+    },
+    sendAsync() {
+      return Promise.resolve(undefined as never)
+    },
+    waitForReady() {
+      return Promise.resolve(undefined as never)
+    },
+  }
+}
+
+/**
+ * Creates a CLI relay messenger that sends messages via fetch to a relay URL
+ * and receives events via server-sent events.
+ *
+ * @param options - Options.
+ * @returns Local relay messenger.
+ */
+export function cliRelay(options: cliRelay.Options): CliRelay {
+  const { relayUrl } = options
+
+  let eventSource: EventSource | null = null
+  const listenerSets = new Map<
+    string,
+    Set<(payload: any, event: any) => void>
+  >()
+
+  function connect() {
+    if (!relayUrl || eventSource) return
+
+    eventSource = new EventSource(relayUrl)
+
+    eventSource.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data)
+        if (!data.topic) return
+        if (!data.payload) return
+
+        const listeners = listenerSets.get(data.topic)
+        if (!listeners) return
+
+        for (const listener of listeners)
+          listener(data.payload, { data, origin: relayUrl })
+      } catch (error) {
+        console.error('Error parsing SSE message:', error)
+      }
+    }
+
+    eventSource.onerror = (error) => {
+      console.error('SSE connection error:', error)
+      eventSource?.close()
+      eventSource = null
+      // attempt to reconnect in 1s
+      setTimeout(connect, 1000)
+    }
+  }
+  connect()
+
+  async function request(topic: Topic, payload: any) {
+    const id = Utils.uuidv4()
+    const data = { id, payload, topic }
+
+    const response = await fetch(relayUrl, {
+      body: Json.stringify(data),
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      method: 'POST',
+    })
+
+    return { id, payload, response, topic }
+  }
+
+  return {
+    destroy() {
+      eventSource?.close()
+      eventSource = null
+      listenerSets.clear()
+    },
+    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)
+      }
+    },
+    async ready(options) {
+      await new Promise((resolve) => setTimeout(resolve, 32))
+      void this.send('ready', options)
+    },
+    async send(topic, payload) {
+      const { id } = await request(topic, payload)
+      return { id, payload, topic } as never
+    },
+    async sendAsync(topic, payload) {
+      const { response } = await request(topic, payload)
+
+      if (!response.ok)
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+
+      const contentType = response.headers.get('content-type')
+      if (contentType?.includes('application/json'))
+        return await response.json()
+
+      return undefined as never
+    },
+  }
+}
+
+export declare namespace cliRelay {
+  export type Options = {
+    /**
+     * Relay URL for both sending messages (POST) and receiving events (GET).
+     */
+    relayUrl: string
+  }
+}

package/src/core/Mode.ts

@@ -0,0 +1,4 @@
+export { from, type Mode } from './internal/mode.js'
+export { dialog } from './internal/modes/dialog.js'
+export { reactNative } from './internal/modes/reactNative.js'
+export { relay } from './internal/modes/relay.js'

package/src/core/Porto.ts

@@ -0,0 +1,287 @@
+import type * as Mipd from 'mipd'
+import type * as Address from 'ox/Address'
+import type * as Hex from 'ox/Hex'
+import type * as RpcRequest from 'ox/RpcRequest'
+import type * as RpcResponse from 'ox/RpcResponse'
+import { http, type Transport } from 'viem'
+import { devtools, persist, subscribeWithSelector } from 'zustand/middleware'
+import { createStore, type Mutate, type StoreApi } from 'zustand/vanilla'
+import type * as Account from '../viem/Account.js'
+import * as Chains from './Chains.js'
+import { hostUrls } from './Dialog.js'
+import type * as Mode from './internal/mode.js'
+import { dialog } from './internal/modes/dialog.js'
+import { relay } from './internal/modes/relay.js'
+import type * as internal from './internal/porto.js'
+import * as Provider from './internal/provider.js'
+import type * as Token from './internal/schema/token.js'
+import type * as Siwe from './internal/siwe.js'
+import type { ExactPartial, OneOf } from './internal/types.js'
+import * as Utils from './internal/utils.js'
+import * as Storage from './Storage.js'
+import { relayUrls } from './Transport.js'
+
+const browser = typeof window !== 'undefined' && typeof document !== 'undefined'
+
+export const defaultConfig = {
+  announceProvider: true,
+  chains: Chains.all,
+  mode: browser ? dialog({ host: hostUrls.prod }) : relay(),
+  relay: http(relayUrls.prod.http),
+  storage:
+    browser && typeof indexedDB !== 'undefined'
+      ? Storage.idb()
+      : Storage.memory(),
+  storageKey: 'porto.store',
+} as const satisfies ExactPartial<Config>
+
+/**
+ * Instantiates an Porto instance.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Porto } from 'rise-wallet'
+ *
+ * const porto = Porto.create()
+ *
+ * const blockNumber = await porto.provider.request({ method: 'eth_blockNumber' })
+ * ```
+ */
+export function create<
+  const chains extends readonly [Chains.Chain, ...Chains.Chain[]],
+>(parameters?: ExactPartial<Config<chains>> | undefined): RiseWallet<chains>
+export function create(
+  parameters: ExactPartial<Config> | undefined = {},
+): RiseWallet {
+  const chains = parameters.chains ?? defaultConfig.chains
+  const transports = Object.fromEntries(
+    chains!.map((chain) => [
+      chain.id,
+      parameters.transports?.[chain.id] ?? http(),
+    ]),
+  )
+
+  const config = {
+    announceProvider:
+      parameters.announceProvider ?? defaultConfig.announceProvider,
+    authUrl: parameters.authUrl,
+    chains,
+    feeToken: parameters.feeToken,
+    merchantUrl: parameters.merchantUrl,
+    mode: parameters.mode ?? defaultConfig.mode,
+    relay: parameters.relay ?? defaultConfig.relay,
+    storage: parameters.storage ?? defaultConfig.storage,
+    storageKey: parameters.storageKey ?? defaultConfig.storageKey,
+    transports,
+  } satisfies Config
+
+  const store = createStore(
+    devtools(
+      subscribeWithSelector(
+        persist<State>(
+          (_) => ({
+            accounts: [],
+            chainIds: config.chains.map((chain) => chain.id) as [
+              number,
+              ...number[],
+            ],
+            feeToken: config.feeToken,
+            requestQueue: [],
+          }),
+          {
+            merge(p, currentState) {
+              const persistedState = p as State
+              const currentChainId =
+                config.chains.find(
+                  (chain) => chain.id === persistedState.chainIds[0],
+                )?.id ?? config.chains[0].id
+              const chainIds = [
+                currentChainId,
+                ...config.chains
+                  .map((chain) => chain.id)
+                  .filter((id) => id !== currentChainId),
+              ] as const
+              return {
+                ...currentState,
+                ...persistedState,
+                chainIds,
+              }
+            },
+            name: config.storageKey,
+            partialize: (state) =>
+              ({
+                accounts: state.accounts.map((account) =>
+                  // omit non-serializable properties (e.g. functions).
+                  Utils.normalizeValue(account),
+                ),
+                chainIds: state.chainIds,
+              }) as unknown as State,
+            storage: config.storage,
+            version: 5,
+          },
+        ),
+      ),
+    ),
+  )
+
+  let mode = config.mode
+
+  const internal = {
+    config,
+    getMode() {
+      return mode
+    },
+    id: Utils.uuidv4(),
+    setMode(i) {
+      destroy?.()
+      mode = i
+      destroy = i.setup({
+        internal,
+      })
+      return destroy
+    },
+    store,
+  } satisfies internal.Internal
+
+  const provider = Provider.from(internal)
+
+  let destroy =
+    mode !== null
+      ? mode.setup({
+          internal,
+        })
+      : () => {}
+
+  return {
+    _internal: internal,
+    config,
+    destroy() {
+      destroy()
+      provider._internal.destroy()
+    },
+    provider,
+  }
+}
+
+export type Config<
+  chains extends readonly [Chains.Chain, ...Chains.Chain[]] = readonly [
+    Chains.Chain,
+    ...Chains.Chain[],
+  ],
+> = {
+  /**
+   * Whether to announce the provider via EIP-6963.
+   * Also accepts EIP-6963 provider info.
+   * @default true
+   */
+  announceProvider: boolean | Partial<Mipd.EIP6963ProviderInfo>
+  /**
+   * API URL(s) to use for offchain SIWE authentication.
+   */
+  authUrl?: string | Siwe.AuthUrl | undefined
+  /**
+   * List of supported chains.
+   */
+  chains: chains
+  /**
+   * Token to use to pay for fees.
+   * @default 'native'
+   */
+  feeToken?: State['feeToken'] | undefined
+  /**
+   * Mode to use.
+   * @default Mode.dialog()
+   */
+  mode: Mode.Mode | null
+  /**
+   * URL to use for merchant server.
+   */
+  merchantUrl?: string | undefined
+  /**
+   * Relay RPC Transport override.
+   */
+  relay: Transport
+  /**
+   * Storage to use.
+   * @default Storage.idb()
+   */
+  storage: Storage.Storage
+  /**
+   * Key to use for store.
+   */
+  storageKey?: string | undefined
+  /**
+   * Public RPC Transport overrides to use for each chain.
+   */
+  transports: Record<chains[number]['id'], Transport>
+}
+
+export type RiseWallet<
+  chains extends readonly [Chains.Chain, ...Chains.Chain[]] = readonly [
+    Chains.Chain,
+    ...Chains.Chain[],
+  ],
+> = {
+  config: Config<chains>
+  destroy: () => void
+  provider: Provider.Provider
+  /**
+   * Not part of versioned API, proceed with caution.
+   * @deprecated
+   */
+  _internal: internal.Internal<chains>
+}
+
+export type State<
+  chains extends readonly [Chains.Chain, ...Chains.Chain[]] = readonly [
+    Chains.Chain,
+    ...Chains.Chain[],
+  ],
+> = {
+  accounts: readonly Account.Account[]
+  chainIds: readonly [chains[number]['id'], ...chains[number]['id'][]]
+  feeToken: Token.Symbol | undefined
+  requestQueue: readonly QueuedRequest[]
+}
+
+export type Store<
+  chains extends readonly [Chains.Chain, ...Chains.Chain[]] = readonly [
+    Chains.Chain,
+    ...Chains.Chain[],
+  ],
+> = Mutate<
+  StoreApi<State<chains>>,
+  [['zustand/subscribeWithSelector', never], ['zustand/persist', any]]
+>
+
+export type QueuedRequest<result = unknown> = {
+  /** Account to assert the request for, and sync if neccessary. */
+  account:
+    | {
+        /** Address of the account. */
+        address: Address.Address
+        /** Active key of the account. */
+        key?:
+          | {
+              /** Credential ID. May be `undefined` when the key is not a WebAuthn credential. */
+              credentialId?: string | undefined
+              /** Public key */
+              publicKey: Hex.Hex
+            }
+          | undefined
+      }
+    | undefined
+  request: RpcRequest.RpcRequest & { _internal?: unknown }
+} & OneOf<
+  | {
+      status: 'pending'
+    }
+  | {
+      result: result
+      status: 'success'
+    }
+  | {
+      error: RpcResponse.ErrorObject
+      status: 'error'
+    }
+>