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

package/src/core/internal/types.ts

@@ -0,0 +1,448 @@
+/** Combines members of an intersection into a readable type. */
+// https://twitter.com/mattpocockuk/status/1622730173446557697?s=20&t=NdpAcmEFXY01xkqU3KO0Mg
+export type Compute<type> = { [key in keyof type]: type[key] } & unknown
+
+declare const symbol: unique symbol
+
+/**
+ * Creates a branded type of `T` with the brand `U`.
+ *
+ * @example
+ * ```ts
+ * type Result = Branded<string, 'foo'>
+ * //   ^? type Result = string & { [symbol]: 'foo' }
+ * ```
+ */
+export type Branded<T, U> = T & { [symbol]: U }
+
+/**
+ * Filters out all members of `T` that are not `P`
+ *
+ * @example
+ * ```ts
+ * type Result = Filter<['a', 'b', 'c'], 'b'>
+ * //   ^? type Result = ['a', 'c']
+ * ```
+ *
+ * @internal
+ */
+export type Filter<
+  T extends readonly unknown[],
+  P,
+  Acc extends readonly unknown[] = [],
+> = T extends readonly [infer F, ...infer Rest extends readonly unknown[]]
+  ? [F] extends [P]
+    ? Filter<Rest, P, [...Acc, F]>
+    : Filter<Rest, P, Acc>
+  : readonly [...Acc]
+
+/**
+ * Creates a fixed array of `count` elements of type `type`.
+ *
+ * @example
+ * ```ts
+ * type Result = FixedArray<string, 3>
+ * //   ^? type Result = readonly [string, string, string]
+ * ```
+ */
+export type FixedArray<
+  type,
+  count extends number,
+  result extends readonly type[] = [],
+> = result['length'] extends count
+  ? result
+  : FixedArray<type, count, readonly [...result, type]>
+
+/**
+ * Checks if `T` can be narrowed further than `U`
+ *
+ * @example
+ * ```ts
+ * type Result = IsNarrowable<'foo', string>
+ * //   ^? true
+ * ```
+ */
+export type IsNarrowable<T, U> = IsNever<
+  (T extends U ? true : false) & (U extends T ? false : true)
+> extends true
+  ? false
+  : true
+
+/**
+ * Checks if `T` is `never`
+ *
+ * @example
+ * ```ts
+ * type Result = IsNever<never>
+ * //   ^? type Result = true
+ * ```
+ */
+export type IsNever<T> = [T] extends [never] ? true : false
+
+/**
+ * Removes `readonly` from all properties of an object.
+ *
+ * @internal
+ */
+export type Mutable<type extends object> = {
+  -readonly [key in keyof type]: type[key]
+}
+
+/**
+ * Evaluates boolean "or" condition for `T` properties.
+ *
+ * * @example
+ * ```ts
+ * type Result = Or<[false, true, false]>
+ * //   ^? type Result = true
+ * ```
+ *
+ * @example
+ * ```ts
+ * type Result = Or<[false, false, false]>
+ * //   ^? type Result = false
+ * ```
+ *
+ * @internal
+ */
+export type Or<T extends readonly unknown[]> = T extends readonly [
+  infer Head,
+  ...infer Tail,
+]
+  ? Head extends true
+    ? true
+    : Or<Tail>
+  : false
+
+/**
+ * Checks if `T` is `undefined`
+ *
+ * @example
+ * ```ts
+ * type Result = IsUndefined<undefined>
+ * //   ^? type Result = true
+ * ```
+ *
+ * @internal
+ */
+export type IsUndefined<T> = [undefined] extends [T] ? true : false
+
+/**
+ * Checks if type `T` is the `unknown` type.
+ *
+ * @internal
+ */
+export type IsUnknown<T> = unknown extends T
+  ? [T] extends [null]
+    ? false
+    : true
+  : false
+
+/** @internal */
+export type MaybePromise<T> = T | Promise<T>
+
+/**
+ * Makes attributes on the type T required if required is true.
+ *
+ * @example
+ * ```ts
+ * MaybeRequired<{ a: string, b?: number }, true>
+ * // { a: string, b: number }
+ *
+ * MaybeRequired<{ a: string, b?: number }, false>
+ * // { a: string, b?: number }
+ * ```
+ *
+ * @internal
+ */
+export type MaybeRequired<T, required extends boolean> = required extends true
+  ? ExactRequired<T>
+  : T
+
+/**
+ * Assigns the properties of U onto T.
+ *
+ * @example
+ * ```ts
+ * Assign<{ a: string, b: number }, { a: undefined, c: boolean }>
+ * // { a: undefined, b: number, c: boolean }
+ * ```
+ *
+ * @internal
+ */
+export type Assign<T, U> = Assign_inner<T, U> & U
+
+/** @internal */
+export type Assign_inner<T, U> = {
+  [K in keyof T as K extends keyof U
+    ? U[K] extends void
+      ? never
+      : K
+    : K]: K extends keyof U ? U[K] : T[K]
+}
+
+/**
+ * Constructs a type by excluding `undefined` from `T`.
+ *
+ * @example
+ * ```ts
+ * NoUndefined<string | undefined>
+ * // string
+ * ```
+ *
+ * @internal
+ */
+export type NoUndefined<T> = T extends undefined ? never : T
+
+/**
+ * Strict version of built-in Omit type
+ *
+ * @internal
+ */
+export type Omit<type, keys extends keyof type> = Pick<
+  type,
+  Exclude<keyof type, keys>
+>
+
+/**
+ * Creates a type that is a partial of T, but with the required keys K.
+ *
+ * @example
+ * ```ts
+ * PartialBy<{ a: string, b: number }, 'a'>
+ * // { a?: string, b: number }
+ * ```
+ *
+ * @internal
+ */
+export type PartialBy<T, K extends keyof T> = Omit<T, K> &
+  ExactPartial<Pick<T, K>>
+
+export type RecursiveArray<T> = T | readonly RecursiveArray<T>[]
+
+/**
+ * Creates a type that is T with the required keys K.
+ *
+ * @example
+ * ```ts
+ * RequiredBy<{ a?: string, b: number }, 'a'>
+ * // { a: string, b: number }
+ * ```
+ *
+ * @internal
+ */
+export type RequiredBy<T, K extends keyof T> = Omit<T, K> &
+  ExactRequired<Pick<T, K>>
+
+/**
+ * Returns truthy if `array` contains `value`.
+ *
+ * @example
+ * ```ts
+ * Some<[1, 2, 3], 2>
+ * // true
+ * ```
+ *
+ * @internal
+ */
+export type Some<
+  array extends readonly unknown[],
+  value,
+> = array extends readonly [value, ...unknown[]]
+  ? true
+  : array extends readonly [unknown, ...infer rest]
+    ? Some<rest, value>
+    : false
+
+/**
+ * Prints custom error message
+ *
+ * @param messages - Error message
+ * @returns Custom error message
+ *
+ * @example
+ * ```ts
+ * type Result = TypeErrorMessage<'Custom error message'>
+ * //   ^? type Result = ['Error: Custom error message']
+ * ```
+ */
+export type TypeErrorMessage<messages extends string | string[]> =
+  messages extends string
+    ? [
+        // Surrounding with array to prevent `messages` from being widened to `string`
+        `Error: ${messages}`,
+      ]
+    : {
+        [key in keyof messages]: messages[key] extends infer message extends
+          string
+          ? `Error: ${message}`
+          : never
+      }
+
+/** @internal */
+export type UnionToTuple<
+  union,
+  ///
+  last = LastInUnion<union>,
+> = [union] extends [never] ? [] : [...UnionToTuple<Exclude<union, last>>, last]
+
+/** @internal */
+export type LastInUnion<U> = UnionToIntersection<
+  U extends unknown ? (x: U) => 0 : never
+> extends (x: infer l) => 0
+  ? l
+  : never
+
+/** @internal */
+export type UnionToIntersection<union> = (
+  union extends unknown
+    ? (arg: union) => 0
+    : never
+) extends (arg: infer i) => 0
+  ? i
+  : never
+
+/** @internal */
+export type IsUnion<
+  union,
+  ///
+  union2 = union,
+> = union extends union2 ? ([union2] extends [union] ? false : true) : never
+
+/** @internal */
+export type MaybePartial<
+  type,
+  enabled extends boolean | undefined,
+> = enabled extends true ? Compute<ExactPartial<type>> : type
+
+export type ExactPartial<type> = {
+  [key in keyof type]?: type[key] | undefined
+}
+
+/** @internal */
+export type ExactRequired<type> = {
+  [key in keyof type]-?: Exclude<type[key], undefined>
+}
+
+export type OneOf<
+  union extends object,
+  fallback extends object | undefined = undefined,
+  ///
+  keys extends KeyofUnion<union> = KeyofUnion<union>,
+> = union extends infer item
+  ? Compute<
+      item & {
+        [key in Exclude<keys, keyof item>]?: fallback extends object
+          ? key extends keyof fallback
+            ? fallback[key]
+            : undefined
+          : undefined
+      }
+    >
+  : never
+
+/** @internal */
+export type KeyofUnion<type> = type extends type ? keyof type : never
+
+/** @internal */
+export type Undefined<type> = {
+  [key in keyof type]?: undefined
+}
+
+///////////////////////////////////////////////////////////////////////////
+// Loose types
+
+/**
+ * Loose version of {@link Omit}
+ * @internal
+ */
+export type LooseOmit<type, keys extends string> = Pick<
+  type,
+  Exclude<keyof type, keys>
+>
+
+///////////////////////////////////////////////////////////////////////////
+// Union types
+
+/** @internal */
+export type UnionCompute<type> = type extends object ? Compute<type> : type
+
+/** @internal */
+export type UnionLooseOmit<type, keys extends string> = type extends any
+  ? LooseOmit<type, keys>
+  : never
+
+/**
+ * Construct a type with the properties of union type T except for those in type K.
+ * @example
+ * ```ts
+ * type Result = UnionOmit<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * // { b: number } | { b: undefined, c: number }
+ * ```
+ *
+ * @internal
+ */
+export type UnionOmit<type, keys extends keyof type> = type extends any
+  ? Omit<type, keys>
+  : never
+
+/**
+ * Construct a type with the properties of union type T except for those in type K.
+ * @example
+ * ```ts
+ * type Result = UnionOmit<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * // { b: number } | { b: undefined, c: number }
+ * ```
+ *
+ * @internal
+ */
+export type UnionPick<type, keys extends keyof type> = type extends any
+  ? Pick<type, keys>
+  : never
+
+/**
+ * Creates a type that is a partial of T, but with the required keys K.
+ *
+ * @example
+ * ```ts
+ * PartialBy<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * // { a?: string, b: number } | { a?: string, b: undefined, c: number }
+ * ```
+ *
+ * @internal
+ */
+export type UnionPartialBy<T, K extends keyof T> = T extends any
+  ? PartialBy<T, K>
+  : never
+
+/**
+ * Creates a type that is T with the required keys K.
+ *
+ * @example
+ * ```ts
+ * RequiredBy<{ a?: string, b: number } | { a?: string, c?: number }, 'a'>
+ * // { a: string, b: number } | { a: string, c?: number }
+ * ```
+ *
+ * @internal
+ */
+export type UnionRequiredBy<T, K extends keyof T> = T extends any
+  ? RequiredBy<T, K>
+  : never
+
+type Primitive = string | number | boolean | bigint | symbol | undefined | null
+type Builtin = Primitive | Date | Error | RegExp
+
+export type DeepReadonly<T> = T extends Builtin
+  ? T
+  : IsUnknown<T> extends true
+    ? T
+    : T extends object
+      ? Readonly<{
+          [K in keyof T]: T[K] extends Primitive ? T[K] : DeepReadonly<T[K]>
+        }>
+      : T extends Array<infer U>
+        ? U extends Primitive
+          ? Readonly<Array<U>>
+          : Readonly<Array<DeepReadonly<U>>>
+        : never

package/src/core/internal/urlString.ts

@@ -0,0 +1,5 @@
+export function toAbsolute(url: string | undefined) {
+  if (!url) return undefined
+  if (url.startsWith('/')) return `${window.location.origin}${url}`
+  return url
+}

package/src/core/internal/userAgent.ts

@@ -0,0 +1,35 @@
+declare global {
+  interface Navigator {
+    userAgentData?: {
+      mobile?: boolean
+    }
+  }
+}
+
+export function isSafari() {
+  const ua = navigator.userAgent.toLowerCase()
+  return ua.includes('safari') && !ua.includes('chrome')
+}
+
+export function isFirefox() {
+  const ua = navigator.userAgent.toLowerCase()
+  return (
+    (ua.includes('firefox') || ua.includes('fxios')) &&
+    !ua.includes('seamonkey')
+  )
+}
+
+export function isMobile() {
+  if (window.navigator?.userAgentData?.mobile) return true
+
+  return (
+    // https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/Browser_detection_using_the_user_agent#alternatives_to_ua_sniffing
+    navigator.maxTouchPoints > 1 ||
+    /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i.test(
+      navigator.userAgent,
+    ) ||
+    /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw-(n|u)|c55\/|capi|ccwa|cdm-|cell|chtm|cldc|cmd-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc-s|devi|dica|dmob|do(c|p)o|ds(12|-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(-|_)|g1 u|g560|gene|gf-5|g-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd-(m|p|t)|hei-|hi(pt|ta)|hp( i|ip)|hs-c|ht(c(-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i-(20|go|ma)|i230|iac( |-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|-[a-w])|libw|lynx|m1-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|-([1-8]|c))|phil|pire|pl(ay|uc)|pn-2|po(ck|rt|se)|prox|psio|pt-g|qa-a|qc(07|12|21|32|60|-[2-7]|i-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h-|oo|p-)|sdk\/|se(c(-|0|1)|47|mc|nd|ri)|sgh-|shar|sie(-|m)|sk-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h-|v-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl-|tdg-|tel(i|m)|tim-|t-mo|to(pl|sh)|ts(70|m-|m3|m5)|tx-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas-|your|zeto|zte-/i.test(
+      navigator.userAgent.slice(0, 4),
+    )
+  )
+}

package/src/core/internal/utils.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from 'vitest'
+import * as Utils from './utils.js'
+
+describe('normalizeValue', () => {
+  test('default', () => {
+    const value = {
+      id: '1',
+      payload: { a: 1, b: new Function(), c: [new Date('2025-05-29'), 'foo'] },
+      topic: 'test',
+    }
+    const normalized = Utils.normalizeValue(value)
+    expect(normalized).toMatchInlineSnapshot(`
+      {
+        "id": "1",
+        "payload": {
+          "a": 1,
+          "b": undefined,
+          "c": [
+            2025-05-29T00:00:00.000Z,
+            "foo",
+          ],
+        },
+        "topic": "test",
+      }
+    `)
+  })
+})
+
+describe('uniqBy', () => {
+  test('default', () => {
+    const data = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 2 }]
+    const result = Utils.uniqBy(data, (item) => item.id)
+    expect(result).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }])
+  })
+})

package/src/core/internal/utils.ts

@@ -0,0 +1,67 @@
+/**
+ * Normalizes a value into a structured-clone compatible format.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/structuredClone
+ */
+export function normalizeValue<type>(value: type): type {
+  if (Array.isArray(value)) return value.map(normalizeValue) as never
+  if (typeof value === 'function') return undefined as never
+  if (typeof value !== 'object' || value === null) return value
+  if (Object.getPrototypeOf(value) !== Object.prototype)
+    try {
+      return structuredClone(value)
+    } catch {
+      return undefined as never
+    }
+
+  const normalized: Record<string, unknown> = {}
+  for (const [k, v] of Object.entries(value)) normalized[k] = normalizeValue(v)
+  return normalized as never
+}
+
+/**
+ * Returns a new array containing only one copy of each element in the original
+ * list transformed by a function.
+ *
+ * @param data - Array.
+ * @param fn - Extracts a value to be used to compare elements.
+ */
+export function uniqBy<data>(data: data[], fn: (item: data) => unknown) {
+  const result: data[] = []
+  const seen = new Set()
+  for (const item of data) {
+    const key = fn(item)
+    if (!seen.has(key)) {
+      seen.add(key)
+      result.push(item)
+    }
+  }
+  return result
+}
+
+export function uuidv4() {
+  if (typeof globalThis !== 'undefined' && 'crypto' in globalThis)
+    return globalThis.crypto.randomUUID()
+  return crypto.randomUUID()
+}
+
+/** Deduplicates in-flight promises. */
+export function withDedupe<data>(
+  fn: () => Promise<data>,
+  { enabled = true, id }: withDedupe.Options,
+): Promise<data> {
+  if (!enabled || !id) return fn()
+  if (withDedupe.cache.get(id)) return withDedupe.cache.get(id)!
+  const promise = fn().finally(() => withDedupe.cache.delete(id))
+  withDedupe.cache.set(id, promise)
+  return promise
+}
+
+export namespace withDedupe {
+  export type Options = {
+    enabled?: boolean | undefined
+    id?: string | undefined
+  }
+
+  export const cache = new Map<string, Promise<any>>()
+}

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

@@ -0,0 +1,22 @@
+import type { ExactPartial } from '../internal/types.js'
+import * as Mode from '../Mode.js'
+import * as Porto from '../Porto.js'
+
+export const defaultConfig = {
+  ...Porto.defaultConfig,
+  mode: Mode.reactNative(),
+} as const satisfies Partial<Porto.Config>
+
+/**
+ * Instantiates a Porto instance with React Native mode.
+ */
+export function create(
+  parameters: ExactPartial<Porto.Config> | undefined = {},
+): Porto.RiseWallet {
+  return Porto.create({
+    ...parameters,
+    mode: parameters.mode ?? defaultConfig.mode,
+  })
+}
+
+export { Porto }

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

@@ -0,0 +1,31 @@
+import * as AuthSession from 'expo-auth-session'
+import * as WebBrowser from 'expo-web-browser'
+import { Platform } from 'react-native'
+
+import {
+  isEnvironmentConfigured,
+  type ReactNativeEnvironment,
+  reactNative,
+} from './environment.js'
+import { isReactNative } from './utils.js'
+
+export function configureReactNativeEnvironment() {
+  if (isEnvironmentConfigured()) return reactNative.environment
+
+  WebBrowser.maybeCompleteAuthSession()
+
+  const environment = {
+    dismissAuthSession() {
+      if (Platform.OS !== 'android') WebBrowser.dismissAuthSession()
+    },
+    makeRedirectUri: AuthSession.makeRedirectUri,
+    maybeCompleteAuthSession: WebBrowser.maybeCompleteAuthSession,
+    openAuthSessionAsync: WebBrowser.openAuthSessionAsync,
+  } satisfies ReactNativeEnvironment
+
+  reactNative.environment = environment
+  return environment
+}
+
+if (isReactNative() && !isEnvironmentConfigured())
+  configureReactNativeEnvironment()

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

@@ -0,0 +1,43 @@
+import type * as AuthSession from 'expo-auth-session'
+import type * as WebBrowser from 'expo-web-browser'
+
+let environment: ReactNativeEnvironment
+
+export const isEnvironmentConfigured = () => environment !== undefined
+
+export const reactNative = {
+  get environment() {
+    if (!environment)
+      throw new Error('React Native environment is not configured')
+    return environment
+  },
+  set environment(env) {
+    environment = env
+  },
+} satisfies {
+  environment: ReactNativeEnvironment
+}
+
+export type AuthSessionOpenOptions = WebBrowser.AuthSessionOpenOptions
+
+export type ReactNativeEnvironment = {
+  redirectUri?:
+    | {
+        /**
+         * the app scheme, usually defined in `app.json` / `app.config.ts`
+         * run `npx uri-scheme list` to get your app's scheme
+         */
+        scheme: string
+        /**
+         * the path to redirect to
+         *
+         * @default '/'
+         */
+        path?: string
+      }
+    | undefined
+  makeRedirectUri: typeof AuthSession.makeRedirectUri
+  openAuthSessionAsync: typeof WebBrowser.openAuthSessionAsync
+  dismissAuthSession: typeof WebBrowser.dismissAuthSession
+  maybeCompleteAuthSession?: typeof WebBrowser.maybeCompleteAuthSession
+}

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

@@ -0,0 +1,4 @@
+export * from './configure.js'
+export * from './environment.js'
+export * from './Porto.js'
+export * from './utils.js'