rise-wallet 0.1.4-beta.1 → 0.2.28

package/src/core/react-native/utils.ts

@@ -0,0 +1,18 @@
+export function isReactNative() {
+  if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative')
+    return true
+
+  if (
+    typeof window !== 'undefined' &&
+    Object.hasOwn(window, 'ReactNativeWebView')
+  )
+    return true
+
+  if (
+    typeof globalThis !== 'undefined' &&
+    Object.hasOwn(globalThis, 'HermesEngine')
+  )
+    return true
+
+  return false
+}

package/src/index.ts

@@ -0,0 +1,17 @@
+export * as Chains from './core/Chains.js'
+export * as Dialog from './core/Dialog.js'
+export {
+  /** @internal @deprecated export required for inference. */
+  from,
+  /** @internal @deprecated export required for inference. */
+  type Provider,
+} from './core/internal/provider.js'
+export * as Messenger from './core/Messenger.js'
+export * as Mode from './core/Mode.js'
+export * as Porto from './core/Porto.js'
+export * as RpcSchema from './core/RpcSchema.js'
+export * as Storage from './core/Storage.js'
+export * as Transport from './core/Transport.js'
+export * as Account from './viem/Account.js'
+export * as Key from './viem/Key.js'
+export * as RelayActions from './viem/RelayActions.js'

package/src/internal/index.ts

@@ -0,0 +1,3 @@
+export * as z from 'zod/mini'
+export * as Call from '../core/internal/call.js'
+export * as TrustedHosts from '../trusted-hosts.js'

package/src/react-native/crypto.ts

@@ -0,0 +1,19 @@
+import * as ExpoCrypto from 'expo-crypto'
+import { Platform } from 'react-native'
+
+if (Platform.OS !== 'web')
+  Object.defineProperty(globalThis, 'crypto', {
+    enumerable: true,
+    value: {
+      digest: (algorithm, message) => ExpoCrypto.digest(algorithm, message),
+      getRandomValues: (array) => ExpoCrypto.getRandomValues(array),
+      randomUUID: () => ExpoCrypto.randomUUID(),
+    } satisfies {
+      digest: (
+        algorithm: ExpoCrypto.CryptoDigestAlgorithm,
+        message: BufferSource,
+      ) => Promise<ArrayBuffer>
+      randomUUID: () => string
+      getRandomValues: (array: Uint8Array) => Uint8Array
+    },
+  })

package/src/react-native/index.ts

@@ -0,0 +1,15 @@
+import {
+  isEnvironmentConfigured,
+  isReactNative,
+} from '../core/react-native/index.js'
+import { configure } from './register.js'
+
+if (isReactNative() && !isEnvironmentConfigured()) configure()
+
+/**
+ * React Native entrypoint
+ * @see https://reactnative.dev/docs/platform-specific-code#native-specific-extensions-ie-sharing-code-with-nodejs-and-web
+ **/
+export * as Mode from '../core/Mode.js'
+export * from '../core/react-native/index.js'
+export * as Porto from '../core/react-native/Porto.js'

package/src/react-native/register.ts

@@ -0,0 +1,24 @@
+import './crypto.js'
+import {
+  isEnvironmentConfigured,
+  isReactNative,
+} from '../core/react-native/index.js'
+
+export const configure = () =>
+  void import('../core/react-native/configure.js')
+    .then(({ configureReactNativeEnvironment }) =>
+      configureReactNativeEnvironment(),
+    )
+    .catch((error) => {
+      console.error(
+        [
+          '[porto:react-native] React Native environment not configured',
+          'You need to import the configuration entrypoint at the top of your app',
+          "import 'porto/react-native/configure'",
+          'then import `Porto` and the rest',
+        ].join('\n'),
+        error,
+      )
+    })
+
+if (isReactNative() && !isEnvironmentConfigured()) configure()

package/src/register/index.ts

@@ -0,0 +1,17 @@
+import type { ValueOf } from 'viem'
+import type * as Rpc from '../core/internal/schema/rpc.js'
+
+declare module 'viem' {
+  interface Register {
+    // biome-ignore lint/suspicious/noTsIgnore: _
+    // @ts-ignore
+    CapabilitiesSchema: {
+      getCapabilities: {
+        ReturnType: ValueOf<Rpc.wallet_getCapabilities.Response_encoded>
+      }
+      sendCalls: {
+        Request: Rpc.wallet_sendCalls.Capabilities_encoded
+      }
+    }
+  }
+}

package/src/remote/Actions.ts

@@ -0,0 +1,115 @@
+import * as Provider from 'ox/Provider'
+import * as RpcResponse from 'ox/RpcResponse'
+
+import type * as Porto from '../core/Porto.js'
+import type * as Remote from './Porto.js'
+
+/**
+ * Action to reject an RPC request.
+ *
+ * @param porto - Porto instance.
+ * @param request - Request to reject.
+ * @param error - Error to reject with.
+ */
+export async function reject(
+  porto: Pick<Remote.Porto<any>, 'messenger'>,
+  request: Porto.QueuedRequest['request'],
+  error?: Provider.ProviderRpcError | RpcResponse.BaseError | undefined,
+) {
+  const error_ = error ?? new Provider.UserRejectedRequestError()
+  const { messenger } = porto
+  messenger.send(
+    'rpc-response',
+    Object.assign(
+      RpcResponse.from({
+        error: {
+          code: error_.code,
+          message: error_.message,
+        },
+        id: request.id,
+        jsonrpc: '2.0',
+      }),
+      {
+        _request: request,
+      },
+    ),
+  )
+}
+
+/**
+ * Action to reject all RPC requests.
+ *
+ * @param porto - Porto instance.
+ * @param error - Error to reject with.
+ */
+export async function rejectAll(
+  porto: Pick<Remote.Porto<any>, 'messenger' | '_internal'>,
+  error?: Provider.ProviderRpcError | RpcResponse.BaseError | undefined,
+) {
+  const { _internal } = porto
+  const requests = _internal.remoteStore.getState().requests
+  for (const request of requests) await reject(porto, request.request, error)
+}
+
+/**
+ * Action to respond to an RPC request.
+ *
+ * @param porto - Porto instance.
+ * @param request - Request to respond to.
+ */
+export async function respond<result>(
+  porto: Pick<Remote.Porto<any>, 'messenger' | 'provider'>,
+  request: Porto.QueuedRequest['request'],
+  options?: {
+    error?: RpcResponse.ErrorObject | undefined
+    onError?: (error: RpcResponse.BaseError) =>
+      | undefined
+      | {
+          cancelResponse: boolean
+        }
+    result?: result | undefined
+    selector?: (result: result) => unknown
+  },
+) {
+  const { messenger, provider } = porto
+  const { error, selector } = options ?? {}
+  const shared = {
+    id: request.id,
+    jsonrpc: '2.0',
+  } as const
+
+  if (error) {
+    messenger.send(
+      'rpc-response',
+      Object.assign(RpcResponse.from({ ...shared, error, status: 'error' }), {
+        _request: request,
+      }),
+    )
+    return
+  }
+
+  try {
+    let result = options?.result ?? (await provider.request(request))
+    if (selector) result = selector(result as never)
+    messenger.send(
+      'rpc-response',
+      Object.assign(RpcResponse.from({ ...shared, result }), {
+        _request: request,
+      }),
+    )
+    return result
+  } catch (e) {
+    const error = e as RpcResponse.BaseError
+    if (options?.onError?.(error)?.cancelResponse === true)
+      // If the onError callback sets cancelResponse to true,
+      // we do not send a response.
+      return
+    messenger.send(
+      'rpc-response',
+      Object.assign(RpcResponse.from({ ...shared, error, status: 'error' }), {
+        _request: request,
+      }),
+    )
+    throw error
+  }
+}

package/src/remote/Events.ts

@@ -0,0 +1,193 @@
+import type * as Address from 'ox/Address'
+import type * as Hex from 'ox/Hex'
+import * as Provider from 'ox/Provider'
+import * as z from 'zod/mini'
+import * as Rpc from '../core/internal/schema/rpc.js'
+import type { Payload } from '../core/Messenger.js'
+import * as Actions from './Actions.js'
+import type * as Remote from './Porto.js'
+
+const trustedOrigins = ['id.porto.sh', 'localhost:5174', 'localhost:5173']
+
+/**
+ * Event listener which is triggered when a request is ready
+ * to be handled by the dialog.
+ *
+ * @param porto - Porto instance.
+ * @param cb - Callback function.
+ * @returns Unsubscribe function.
+ */
+export function onDialogRequest(
+  porto: Pick<
+    Remote.Porto<any>,
+    '_internal' | 'methodPolicies' | 'messenger' | 'provider'
+  >,
+  cb: (payload: onDialogRequest.Payload) => void,
+) {
+  return onRequests(porto, (requests, event) => {
+    let account: onDialogRequest.Payload['account']
+    let request_dialog: onDialogRequest.Payload['request'] | undefined
+    let requireConnection: boolean | undefined
+
+    // Process the pending requests, as well as finding the first request
+    // that requires the dialog.
+    for (const r of requests) {
+      const { request } = r ?? {}
+
+      // If this request doesn't have a JSON-RPC request, skip it.
+      if (!request) continue
+
+      // If this request is a wallet_connect request, we need to make sure
+      // the provided chain ids are supported by the dialog.
+      if (request.method === 'wallet_connect') {
+        const params = z.decode(
+          Rpc.wallet_connect.Parameters,
+          request.params?.[0] as never,
+        )
+
+        // Extract chainIds that the app has requested.
+        const chainIds_app = params?.chainIds
+        if (chainIds_app?.[0]) {
+          const chainIds = porto._internal.store.getState().chainIds
+
+          // Find the first app chain that is supported by the dialog.
+          const chainId = chainIds_app.find((chainId) =>
+            chainIds.includes(chainId),
+          )
+
+          // If the requested chain is not supported, respond with an error.
+          if (!chainId) {
+            Actions.respond(porto, request, {
+              error: new Provider.UnsupportedChainIdError(),
+            }).catch(() => {})
+            continue
+          }
+
+          // Update the dialog chainIds so that the app chain is the "active" chain.
+          porto._internal.store.setState((x) => ({
+            ...x,
+            chainIds: [chainId, ...x.chainIds.filter((x) => x !== chainId)],
+          }))
+        }
+      }
+
+      // Extract the method policy for this request. Method policies are
+      // used to determine if the request should be headless (bypassed), or
+      // if it is supported by the dialog.
+      const policy = porto.methodPolicies?.find(
+        (policy) => policy.method === request.method,
+      )
+
+      const shouldBypass = (() => {
+        if (!request) return false
+
+        const rule = policy?.modes?.headless
+        if (rule) {
+          if (
+            typeof rule === 'object' &&
+            rule.sameOrigin &&
+            event.origin !== window.location.origin
+          )
+            return false
+          return true
+        }
+
+        return false
+      })()
+      if (shouldBypass) {
+        Actions.respond(porto, request).catch(() => {})
+        continue
+      }
+
+      const rule = policy?.modes?.dialog
+      const shouldDialog = (() => {
+        if (!rule) return true
+        if (
+          typeof rule === 'object' &&
+          rule.sameOrigin &&
+          event.origin !== window.location.origin
+        )
+          return trustedOrigins.some((origin) => event.origin.endsWith(origin))
+        return rule
+      })()
+      if (!shouldDialog) {
+        Actions.respond(porto, request, {
+          error: new Provider.UnsupportedMethodError(),
+        }).catch(() => {})
+        continue
+      }
+
+      // If this requests requires a specific account, set it.
+      account ??= r.account
+      // If this request requires an account connection, set it.
+      requireConnection ??= policy?.requireConnection ?? true
+      // At this point, we know that this request should be handled by the dialog.
+      request_dialog ??= request
+    }
+
+    cb({
+      account: requireConnection ? account : undefined,
+      origin: event.origin,
+      request: request_dialog ?? null,
+    })
+  })
+}
+
+export declare namespace onDialogRequest {
+  type Payload = {
+    account?:
+      | {
+          address: Address.Address
+          key?:
+            | {
+                credentialId?: string | undefined
+                publicKey: Hex.Hex
+              }
+            | undefined
+        }
+      | undefined
+    request: Remote.RemoteState['requests'][number]['request'] | null
+    origin: string
+  }
+}
+
+/**
+ * Event listener which is triggered when the remote context receives
+ * an initialization message from the parent context.
+ *
+ * @param porto - Porto instance.
+ * @param cb - Callback function.
+ * @returns Unsubscribe function.
+ */
+export function onInitialized(
+  porto: Pick<Remote.Porto<any>, 'messenger'>,
+  cb: (
+    payload: Extract<Payload<'__internal'>, { type: 'init' }>,
+    event: MessageEvent,
+  ) => void,
+) {
+  const { messenger } = porto
+  return messenger.on('__internal', (payload, event) => {
+    if (payload.type === 'init') cb(payload, event)
+  })
+}
+
+/**
+ * Event listener which is triggered when the remote context receives
+ * an RPC request from the parent context.
+ *
+ * @param porto - Porto instance.
+ * @param cb - Callback function.
+ * @returns Unsubscribe function.
+ */
+export function onRequests(
+  porto: Pick<Remote.Porto<any>, '_internal' | 'messenger'>,
+  cb: (payload: Remote.RemoteState['requests'], event: MessageEvent) => void,
+) {
+  const { messenger, _internal } = porto
+  return messenger.on('rpc-requests', (payload, event) => {
+    const requests = payload as Remote.RemoteState['requests']
+    _internal.remoteStore.setState({ requests })
+    cb(requests, event)
+  })
+}

package/src/remote/Hooks.ts

@@ -0,0 +1,194 @@
+import { Address } from 'ox'
+import { useMemo } from 'react'
+import { useStore } from 'zustand'
+import { useShallow } from 'zustand/shallow'
+
+import type * as Chains from '../core/Chains.js'
+import type * as Porto from '../core/Porto.js'
+import * as RelayClient from '../viem/RelayClient.js'
+import * as WalletClient from '../viem/WalletClient.js'
+import type * as Remote from './Porto.js'
+
+/**
+ * Hook to access and subscribe to the current account.
+ * If an `address` is provided, it will return the account if exists.
+ *
+ * @param porto - Porto instance.
+ * @param parameters - Parameters.
+ * @returns Account.
+ */
+export function useAccount<
+  chains extends readonly [Chains.Chain, ...Chains.Chain[]],
+>(
+  porto: Pick<Remote.Porto<chains>, '_internal'>,
+  parameters: useAccount.Parameters = {},
+) {
+  const { address } = parameters
+  return usePortoStore(porto, (x) => {
+    if (!address) return x.accounts[0]
+    return x.accounts.find((x) => Address.isEqual(x.address, address))
+  })
+}
+
+export namespace useAccount {
+  export type Parameters = {
+    address?: Address.Address | undefined
+  }
+}
+
+/**
+ * Hook to access and subscribe to the current accounts.
+ *
+ * @param porto - Porto instance.
+ * @returns Accounts.
+ */
+export function useAccounts<
+  chains extends readonly [Chains.Chain, ...Chains.Chain[]],
+>(porto: Pick<Remote.Porto<chains>, '_internal'>) {
+  return usePortoStore(porto, (x) => x.accounts)
+}
+
+/**
+ * Hook to access and subscribe to the current chain.
+ * If a `chainId` is provided, it will return the chain if supported.
+ *
+ * @param porto - Porto instance.
+ * @param parameters - Parameters.
+ * @returns Chain.
+ */
+export function useChain<
+  chains extends readonly [Chains.Chain, ...Chains.Chain[]],
+>(
+  porto: Pick<Remote.Porto<chains>, '_internal'>,
+  parameters: useChain.Parameters = {},
+) {
+  return usePortoStore(porto, (state) => {
+    const chainId = parameters.chainId ?? state.chainIds[0]
+    return porto._internal.config.chains.find((x) => x.id === chainId) as
+      | chains[number]
+      | undefined
+  })
+}
+
+export namespace useChain {
+  export type Parameters = {
+    chainId?: number | undefined
+  }
+}
+
+/**
+ * Hook to access and subscribe to the store of the Porto instance.
+ *
+ * @param porto - Porto instance.
+ * @param selector - Selector function.
+ * @returns Store state.
+ */
+export function usePortoStore<
+  slice = Porto.State,
+  chains extends readonly [Chains.Chain, ...Chains.Chain[]] = readonly [
+    Chains.Chain,
+    ...Chains.Chain[],
+  ],
+>(
+  porto: Pick<Remote.Porto<chains>, '_internal'>,
+  selector: Parameters<
+    typeof useStore<typeof porto._internal.store, slice>
+  >[1] = (state) => state as slice,
+) {
+  const { store } = porto._internal
+  return useStore(store, useShallow(selector))
+}
+
+/**
+ * Hook to access and subscribe to the remote store of the Porto instance.
+ *
+ * @param porto - Porto instance.
+ * @param selector - Selector function.
+ * @returns Remote store state.
+ */
+export function useRemoteStore<
+  slice = Remote.State,
+  chains extends readonly [Chains.Chain, ...Chains.Chain[]] = readonly [
+    Chains.Chain,
+    ...Chains.Chain[],
+  ],
+>(
+  porto: Pick<Remote.Porto<chains>, '_internal'>,
+  selector: Parameters<
+    typeof useStore<typeof porto._internal.remoteStore, slice>
+  >[1] = (state) => state as slice,
+) {
+  const { remoteStore } = porto._internal
+  return useStore(remoteStore, useShallow(selector))
+}
+
+/**
+ * Hook to access and subscribe to current pending requests.
+ *
+ * @param porto - Porto instance.
+ * @returns Requests.
+ */
+export function useRequests<
+  chains extends readonly [Chains.Chain, ...Chains.Chain[]],
+>(porto: Pick<Remote.Porto<chains>, '_internal'>) {
+  return useRemoteStore(porto, (state) =>
+    state.requests.filter((x) => x.status === 'pending').map((x) => x.request),
+  )
+}
+
+/**
+ * Hook to access and subscribe to the next pending request.
+ *
+ * @param porto - Porto instance.
+ * @returns Request.
+ */
+export function useRequest<
+  chains extends readonly [Chains.Chain, ...Chains.Chain[]],
+>(porto: Pick<Remote.Porto<chains>, '_internal'>) {
+  return useRemoteStore(
+    porto,
+    (state) =>
+      state.requests.find((request) => request.status === 'pending')?.request,
+  )
+}
+
+/**
+ * Hook to access and subscribe to the Relay Client of the Porto instance.
+ *
+ * @param porto - Porto instance.
+ * @returns Relay Client.
+ */
+export function useRelayClient<
+  chains extends readonly [Chains.Chain, ...Chains.Chain[]],
+>(
+  porto: Pick<Remote.Porto<chains>, '_internal'>,
+  parameters: useRelayClient.Parameters = {},
+) {
+  const defaultChainId = useChain(porto)?.id
+  const chainId = parameters.chainId ?? defaultChainId
+  return RelayClient.fromPorto(porto, { chainId })
+}
+
+export namespace useRelayClient {
+  export type Parameters = {
+    chainId?: number | undefined
+  }
+}
+
+/**
+ * Hook to access and subscribe to the wallet client of the Porto instance.
+ *
+ * @param porto - Porto instance.
+ * @returns Wallet Client.
+ */
+export function useWalletClient<
+  chains extends readonly [Chains.Chain, ...Chains.Chain[]],
+>(porto: Pick<Remote.Porto<chains>, '_internal' | 'provider'>) {
+  return useMemo(() => WalletClient.fromPorto(porto), [porto])
+}
+
+export namespace useWalletClient {
+  export type Parameters = {
+    chainId?: number | undefined
+  }
+}