@luxexchange/lx 1.0.0

package/src/test/utils/resolvers.ts

@@ -0,0 +1,142 @@
+/* biome-ignore-all lint/suspicious/noExplicitAny: legacy code needs review */
+import { GraphQLApi } from '@luxfi/api'
+import cloneDeepWith from 'lodash/cloneDeepWith'
+
+type UndefinedToNull<T> = T extends undefined ? null : T
+
+type ResolverReturnType<T> = T extends (...args: any[]) => infer TResult
+  ? TResult
+  : T extends { resolve: (...args: any[]) => infer TResult }
+    ? TResult
+    : never
+
+type ResolverParameters<T extends GraphQLApi.Resolver<any, any, any, any>> = T extends GraphQLApi.ResolverWithResolve<
+  infer TResult, // only result type is needed to filter selected fields
+  any,
+  any,
+  any
+>
+  ? Parameters<GraphQLApi.ResolverFn<TResult, any, any, any>>
+  : T extends GraphQLApi.ResolverFn<infer TResult, any, any, any>
+    ? Parameters<GraphQLApi.ResolverFn<TResult, any, any, any>>
+    : never
+
+type ResolverResponses<T extends GraphQLApi.QueryResolvers> = {
+  [K in keyof T]: Promise<ResolverReturnType<T[K]>>
+}
+
+function isResolverWithResolve<T extends GraphQLApi.Resolver<any, any, any, any>>(
+  resolver: T,
+): resolver is Extract<T, GraphQLApi.ResolverWithResolve<any, any, any, any>> {
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  return typeof resolver === 'object' && resolver !== null && 'resolve' in resolver
+}
+
+function isResolverFunction<T extends GraphQLApi.Resolver<any, any, any, any>>(
+  resolver: T,
+): resolver is Extract<T, GraphQLApi.ResolverFn<any, any, any, any>> {
+  return typeof resolver === 'function'
+}
+
+export function queryResolvers<T extends GraphQLApi.QueryResolvers>(
+  resolvers: T,
+): {
+  resolved: ResolverResponses<T>
+  resolvers: { Query: T }
+} {
+  // Create a response object with functions to create and resolve promises
+  const promiseResolvers = {} as Record<keyof T, (value: any) => void>
+  const resolved = Object.fromEntries(
+    Object.keys(resolvers).map((key) => [key, new Promise((resolve) => (promiseResolvers[key as keyof T] = resolve))]),
+  ) as ResolverResponses<T>
+
+  return {
+    resolved,
+    resolvers: {
+      Query: Object.fromEntries(
+        Object.entries(resolvers).map(([k, resolver]) => {
+          const key = k as keyof T
+          type R = typeof resolver
+
+          const resolve = async (...params: ResolverParameters<R>): Promise<ResolverReturnType<R>> => {
+            const [parent, args, context, info] = params
+
+            const resolvedValue = isResolverWithResolve(resolver)
+              ? resolver.resolve(parent, args, context, info)
+              : isResolverFunction(resolver)
+                ? resolver(parent, args, context, info)
+                : null
+
+            // TODO(WALL-5157): This was commented out because it breaks when using fragments.
+            //                  To fix it, we need to recursively filter nested fields when fragments are used.
+            // const updatedValue = await filterObjectFields(info.fieldNodes[0]?.selectionSet, resolvedValue)
+
+            // cloneDeepWith returns any type so we need to cast it manually
+            const resultObj = cloneDeepWith(resolvedValue, undefinedToNull) as ResolverReturnType<R>
+
+            // Resolve the corresponding promise
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (promiseResolvers[key]) {
+              promiseResolvers[key](resultObj)
+            }
+
+            return resultObj
+          }
+
+          return [key, resolve]
+        }),
+      ) as unknown as T,
+    },
+  }
+}
+
+/*
+TODO(WALL-5157): see comment above. We commented this out because it breaks when using queries with fragments.
+
+type Scalar = number | string | boolean | bigint | symbol | undefined
+
+function isObject<T extends object | Scalar>(value: T): value is Exclude<T, Scalar> {
+  return typeof value === 'object'
+}
+
+async function filterObjectFields<T extends object | Scalar>(
+  selectionSet: SelectionSetNode | undefined,
+  sourceValue: T | Promise<Maybe<ResolverTypeWrapper<T>>> | null,
+): Promise<T | null> {
+  // resolved source value can be a Promise or a plain value
+  const source = await sourceValue
+
+  if (!source || !selectionSet) {
+    return source ?? null
+  }
+
+  if (Array.isArray(source)) {
+    return Promise.all(source.map((obj) => filterObjectFields(selectionSet, obj))) as T
+  }
+
+  if (!isObject(source)) {
+    return source
+  }
+
+  const result: Record<string, any> = {}
+
+  for (const selection of selectionSet.selections) {
+    if (selection.kind !== 'Field') {
+      continue
+    }
+
+    const key = selection.name.value
+    const value = source[key as keyof typeof source]
+
+    if (value !== undefined && selection.selectionSet) {
+      result[key] = await filterObjectFields(selection.selectionSet, value)
+    } else {
+      result[key] = value
+    }
+  }
+
+  return result as T
+}
+*/
+
+const undefinedToNull = <T>(value: T): UndefinedToNull<T> => (value ?? null) as UndefinedToNull<T>

package/src/test-shorthands.ts

@@ -0,0 +1,14 @@
+// Test shorthand types
+import type { Shorthands, StackProps } from '@hanzo/gui'
+import { Flex, type FlexProps } from '@luxfi/ui/src'
+
+// Test: Check if Shorthands has the correct keys
+type ShorthandsKeys = keyof Shorthands
+
+// If this compiles without error, shorthands are in Shorthands type
+const testPx: ShorthandsKeys = 'px'
+const testP: ShorthandsKeys = 'p'
+
+// Check if FlexProps has px
+type TestFlexPx = FlexProps extends { px?: any } ? 'has-px' : 'no-px'
+const flexTest: TestFlexPx = 'has-px' // This line will error if FlexProps doesn't have px

package/src/types/RenderPassReport.ts

@@ -0,0 +1,57 @@
+// Copied and adapted from @shopify/react-native-performance/src/RenderPassReport.ts
+// to avoid bringing this code into web code
+
+interface ResourceAcquisitionStatus {
+  totalTimeMillis: number
+  components: {
+    [operationName: string]:
+      | {
+          durationMillis: number
+          status: 'completed' | 'cancelled'
+        }
+      | {
+          durationMillis?: never
+          status: 'ongoing'
+        }
+  }
+}
+
+type RenderPassEndInfo =
+  | {
+      renderPassName: string
+      timeToRenderMillis: number
+      timeToAbortMillis?: never
+      interactive: boolean
+    }
+  | {
+      renderPassName?: never
+      timeToRenderMillis?: never
+      timeToAbortMillis: number
+      interactive: false
+    }
+
+type RenderPassStartInfo = {
+  flowStartTimeSinceEpochMillis: number
+} & (
+  | {
+      timeToConsumeTouchEventMillis: number | undefined
+      timeToBootJsMillis?: never
+    }
+  | {
+      timeToConsumeTouchEventMillis?: never
+      timeToBootJsMillis: number
+    }
+)
+
+interface FlowInfo {
+  flowInstanceId: string
+  sourceScreen: string | undefined
+  destinationScreen: string
+}
+
+interface SnapshotInfo {
+  reportId: string
+  resourceAcquisitionStatus: ResourceAcquisitionStatus
+}
+
+export type RenderPassReport = SnapshotInfo & FlowInfo & RenderPassStartInfo & RenderPassEndInfo

package/src/types/currency.ts

@@ -0,0 +1,6 @@
+export type CurrencyId = string
+
+export enum CurrencyField {
+  INPUT = 'input',
+  OUTPUT = 'output',
+}

package/src/types/limits.ts

@@ -0,0 +1,6 @@
+export enum LimitsExpiry {
+  Day = 'Day',
+  Week = 'Week',
+  Month = 'Month',
+  Year = 'Year',
+}

package/src/types/onboarding.ts

@@ -0,0 +1,18 @@
+export enum ImportType {
+  CreateNew = 'CreateNew',
+  CreateAdditional = 'CreateAdditional',
+  NotYetSelected = 'NotYetSelected',
+  SeedPhrase = 'SeedPhrase',
+  Passkey = 'Passkey',
+  Watch = 'Watch',
+  Restore = 'Restore',
+  RestoreMnemonic = 'RestoreMnemonic',
+  OnDeviceRecovery = 'OnDeviceRecovery',
+  BackupOnly = 'BackupOnly',
+}
+
+export enum OnboardingEntryPoint {
+  Sidebar = 'Sidebar',
+  FreshInstallOrReplace = 'FreshInstallOrReplace',
+  BackupCard = 'BackupCard',
+}

package/src/types/screens/extension.ts

@@ -0,0 +1,50 @@
+export enum HomeTabs {
+  Tokens = 'Tokens',
+  NFTs = 'NFTs',
+  Activity = 'Activity',
+}
+
+export enum ExtensionScreens {
+  Home = 'home',
+  PopupOpenExtension = 'PopupOpenExtension',
+  UnsupportedBrowserScreen = 'UnsupportedBrowserScreen',
+  ManageDappConnectionsScreen = 'ManageDappConnectionsScreen',
+  Settings = 'Settings',
+}
+
+export enum ExtensionOnboardingFlow {
+  New = 'New',
+  Import = 'Import', // Import via seed phrase
+  Scantastic = 'Scantastic',
+  Passkey = 'Passkey',
+}
+
+export enum ExtensionOnboardingScreens {
+  // Entry
+  Landing = 'OnboardingLanding',
+
+  // Shared Flows
+  SetPassword = 'SetPassword',
+  SetUpBiometricUnlock = 'SetUpBiometricUnlock',
+
+  // New Wallet Flow
+  ClaimUnitag = 'ClaimUnitag',
+
+  // Import Flow
+  SelectImportMethod = 'SelectImportMethod',
+  InitiatePasskeyAuth = 'InitiatePasskeyAuth',
+  PasskeyImport = 'PasskeyImport',
+  SeedPhraseInput = 'SeedPhraseInput',
+  SelectWallet = 'SelectWallet',
+
+  // Scantastic Flow
+  OnboardingQRCode = 'OnboardingQRCode',
+  EnterOTP = 'EnterOTP',
+}
+
+export enum ExtensionUnitagClaimScreens {
+  Intro = 'Intro',
+  CreateUsername = 'CreateUsername',
+}
+
+export type ExtensionScreen = HomeTabs | ExtensionScreens | ExtensionOnboardingScreens | ExtensionUnitagClaimScreens

package/src/types/screens/interface.ts

@@ -0,0 +1,7 @@
+export enum SwapTab {
+  Swap = 'swap',
+  Limit = 'limit',
+  Send = 'send',
+  Buy = 'buy',
+  Sell = 'sell',
+}

package/src/types/screens/mobile.ts

@@ -0,0 +1,124 @@
+import { ExtensionOnboardingFlow, ExtensionScreens } from '@luxexchange/lx/src/types/screens/extension'
+
+export enum MobileScreens {
+  Activity = 'Activity',
+  DebugScreens = 'DebugScreens',
+  Dev = 'Dev',
+  HashcashBenchmark = 'HashcashBenchmark',
+  SessionsDebug = 'SessionsDebug',
+  Storybook = 'Storybook',
+  Education = 'Education',
+  ConnectionsDappListModal = 'connections-dapp-list-modal',
+  Explore = 'Explore',
+  Home = 'Home',
+  NFTItem = 'NFTItem',
+  NFTCollection = 'NFTCollection',
+  OnboardingStack = 'OnboardingStack',
+  UnitagStack = 'UnitagStack',
+  Settings = 'Settings',
+  SettingsCloudBackupPasswordCreate = 'SettingsCloudBackupPasswordCreate',
+  SettingsCloudBackupPasswordConfirm = 'SettingsCloudBackupPasswordConfirm',
+  SettingsCloudBackupProcessing = 'SettingsCloudBackupProcessing',
+  SettingsCloudBackupStatus = 'SettingsCloudBackupStatus',
+  SettingsLanguage = 'SettingsLanguage',
+  SettingsNotifications = 'SettingsNotifications',
+  SettingsPrivacy = 'SettingsPrivacy',
+  SettingsSmartWallet = 'SettingsSmartWallet',
+  SettingsStorage = 'SettingsStorage',
+  SettingsWallet = 'SettingsWallet',
+  SettingsWalletEdit = 'SettingsWalletEdit',
+  SettingsWalletManageConnection = 'SettingsWalletManageConnection',
+  SettingsHelpCenter = 'SettingsHelpCenter',
+  SettingsStack = 'SettingsStack',
+  SettingsViewSeedPhrase = 'SettingsViewSeedPhrase',
+  TokenDetails = 'TokenDetails',
+  ExternalProfile = 'ExternalProfile',
+  WebView = 'WebView',
+  ViewPrivateKeys = 'ViewPrivateKeys',
+}
+
+export enum OnboardingScreens {
+  AppLoading = 'AppLoading',
+  Backup = 'OnboardingBackup',
+  BackupCloudPasswordCreate = 'OnboardingBackupCloudPasswordCreate',
+  BackupCloudPasswordConfirm = 'OnboardingBackupCloudPasswordConfirm',
+  BackupCloudProcessing = 'OnboardingBackupCloudProcessing',
+  BackupManual = 'OnboardingBackupManual',
+  Landing = 'OnboardingLanding',
+  Notifications = 'OnboardingNotifications',
+  WelcomeWallet = 'WelcomeWallet',
+  PasskeyImport = 'PasskeyImport',
+  Security = 'OnboardingSecurity',
+
+  // import
+  ImportMethod = 'ImportMethod',
+  SeedPhraseInput = 'SeedPhraseInput',
+  RestoreCloudBackupLoading = 'RestoreCloudBackupLoading',
+  RestoreCloudBackup = 'RestoreCloudBackup',
+  RestoreCloudBackupPassword = 'RestoreCloudBackupPassword',
+  RestoreMethod = 'RestoreMethod',
+  SelectWallet = 'SelectWallet',
+  WatchWallet = 'WatchWallet',
+
+  // on-device recovery
+  OnDeviceRecovery = 'OnDeviceRecovery',
+  OnDeviceRecoveryViewSeedPhrase = 'OnDeviceRecoveryViewSeedPhrase',
+}
+
+export enum UnitagScreens {
+  ClaimUnitag = 'ClaimUnitag',
+  ChooseProfilePicture = 'ChooseProfilePicture',
+  UnitagConfirmation = 'UnitagConfirmation',
+  EditProfile = 'EditProfile',
+}
+
+export type UnitagEntryPoint =
+  | OnboardingScreens.Landing
+  | MobileScreens.Home
+  | MobileScreens.Settings
+  | ExtensionOnboardingFlow.New
+  | ExtensionScreens.Home
+
+export type UnitagStackParamList = SharedUnitagScreenParams & {
+  [UnitagScreens.UnitagConfirmation]: {
+    unitag: string
+    address: Address
+    profilePictureUri?: string
+  }
+  [UnitagScreens.EditProfile]: {
+    address: Address
+    unitag: string
+    entryPoint: UnitagScreens.UnitagConfirmation | MobileScreens.SettingsWallet
+  }
+}
+
+export type SharedUnitagScreenParams = {
+  [UnitagScreens.ClaimUnitag]: {
+    entryPoint: UnitagEntryPoint
+    address?: Address
+  }
+  [UnitagScreens.ChooseProfilePicture]: {
+    entryPoint: UnitagEntryPoint
+    unitag: string
+    unitagFontSize: number
+    address: Address
+  }
+}
+
+export enum FiatOnRampScreens {
+  AmountInput = 'FiatOnRampAmountInput',
+  ServiceProviders = 'FiatOnRampServiceProviders',
+  Connecting = 'FiatOnRampConnecting',
+}
+
+export type MobileNavScreen = MobileScreens | OnboardingScreens | UnitagScreens | FiatOnRampScreens
+export type MobileAppScreen = MobileNavScreen | ManualPageViewScreen
+
+/**
+ * Views not within the navigation stack that we still want to
+ * log Pageview events for. (Usually presented as nested views within another screen)
+ */
+export enum ManualPageViewScreen {
+  WriteDownRecoveryPhrase = 'WriteDownRecoveryPhrase',
+  ConfirmRecoveryPhrase = 'ConfirmRecoveryPhrase',
+}

package/src/types/sharing.ts

@@ -0,0 +1,6 @@
+export enum ShareableEntity {
+  NftItem = 'NftItem',
+  NftCollection = 'NftCollection',
+  Token = 'Token',
+  Wallet = 'Wallet',
+}

package/src/types/walletConnect.ts

@@ -0,0 +1,143 @@
+import { AuthTypes } from '@walletconnect/types'
+import { EthMethod } from '@luxexchange/lx/src/features/dappRequests/types'
+
+export enum WalletConnectEvent {
+  Connected = 0,
+  Disconnected = 1,
+  NetworkChanged = 2,
+  TransactionConfirmed = 3,
+  TransactionFailed = 4,
+}
+
+export enum UwULinkMethod {
+  Erc20Send = 'erc20_send',
+}
+
+export enum EthEvent {
+  AccountsChanged = 'accountsChanged',
+  ChainChanged = 'chainChanged',
+}
+
+export enum WCEventType {
+  SessionConnected = 'session_connected',
+  NetworkChanged = 'network_changed',
+  SessionDisconnected = 'session_disconnected',
+  SessionPending = 'session_pending',
+  Error = 'error',
+  SignRequest = 'sign_request',
+  TransactionRequest = 'transaction_request',
+}
+
+export enum WCRequestOutcome {
+  Confirm = 'confirm',
+  Reject = 'reject',
+}
+
+interface UwULinkRequestDappInfo {
+  name?: string
+  url?: string
+  icon?: string
+}
+
+interface UwULinkBaseRequest {
+  method: EthMethod.EthSendTransaction | EthMethod.PersonalSign | UwULinkMethod.Erc20Send
+  chainId: number
+  dapp?: UwULinkRequestDappInfo
+  webhook?: string
+}
+
+interface UwULinkPersonalSignRequest extends UwULinkBaseRequest {
+  method: EthMethod.PersonalSign
+  message: string
+  webhook: string
+}
+
+interface UwULinkGenericTransactionRequest extends UwULinkBaseRequest {
+  method: EthMethod.EthSendTransaction
+  value: EthTransaction
+}
+
+export interface UwULinkErc20SendRequest extends UwULinkBaseRequest {
+  method: UwULinkMethod.Erc20Send
+  type: UwULinkMethod.Erc20Send
+  recipient: string
+  tokenAddress: string
+  amount: string
+
+  // TODO: the wallet should determine stablecoin status
+  isStablecoin: false
+}
+
+export type UwULinkRequest = UwULinkGenericTransactionRequest | UwULinkErc20SendRequest | UwULinkPersonalSignRequest
+
+export enum DappRequestType {
+  WalletConnectSessionRequest = 'walletconnect-session-request',
+  WalletConnectAuthenticationRequest = 'walletconnect-authentication-request',
+  UwULink = 'uwulink',
+}
+
+// Standard WC session request
+export interface WalletConnectSessionRequestInfo {
+  requestType: DappRequestType.WalletConnectSessionRequest
+  name: string
+  url: string
+  icon: string | null
+}
+
+/**
+ * Authentication requests for WC 1-Click Auth type sessions.
+ * See https://docs.reown.com/advanced/api/sign/wallet-usage#approving-authentication-requests
+ */
+export interface WalletConnectAuthenticationRequestInfo {
+  requestType: DappRequestType.WalletConnectAuthenticationRequest
+  name: string
+  url: string
+  icon: string | null
+  authPayload: AuthTypes.AuthRequestEventArgs['authPayload']
+}
+
+export interface UwULinkRequestInfo {
+  requestType: DappRequestType.UwULink
+  name: string
+  url: string
+  icon: string | null
+  chain_id: number
+  webhook?: string
+}
+
+export type DappRequestInfo =
+  | WalletConnectAuthenticationRequestInfo
+  | WalletConnectSessionRequestInfo
+  | UwULinkRequestInfo
+
+export interface EthTransaction {
+  to?: string
+  from?: string
+  value?: string
+  data?: string
+  gasLimit?: string
+  gasPrice?: string
+  nonce?: string
+}
+
+export interface PermitMessage {
+  primaryType: 'Permit'
+  domain: {
+    name: string
+    version: string
+    chainId: number
+    verifyingContract: string
+  }
+  message: {
+    owner: string
+    spender: string
+    value: number
+    nonce: number
+    deadline: number
+  }
+}
+
+export function isPrimaryTypePermit(message: PermitMessage | Record<string, unknown>): message is PermitMessage {
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  return (message as PermitMessage).primaryType === 'Permit'
+}

package/src/types/widgets.ts

@@ -0,0 +1,9 @@
+export enum WidgetType {
+  TokenPrice = 'token-price',
+}
+
+export type WidgetEvent = {
+  kind: string
+  family: string
+  change: 'added' | 'removed'
+}

package/src/utils/addresses.test.ts

@@ -0,0 +1,65 @@
+import { Platform } from '@luxexchange/lx/src/features/platforms/types/Platform'
+import { SAMPLE_SEED_ADDRESS_1 } from '@luxexchange/lx/src/test/fixtures'
+import { getValidAddress } from '@luxexchange/lx/src/utils/addresses'
+
+/* -------------------------------------------------------------------------- */
+/*                                  EVM FIXTURES                              */
+/* -------------------------------------------------------------------------- */
+const SAMPLE_SEED_ADDRESS_1_WITH_SPACE = `${SAMPLE_SEED_ADDRESS_1} `
+const ADDRESS_NO_PREFIX = '71C7656EC7ab88b098defB751B7401B5f6d8976F'
+const INVALID_EVM_WRONG_LENGTH = '0x71C7656EC7ab88b098defB751B7401B5f6d8'
+const INVALID_EVM_BAD_PREFIX = '1x71C7656EC7ab88b098defB751B7401B5f6d8976F'
+const INVALID_EVM_NON_HEX = '0x71C7656EC7ab88b098defB751B7401B5f6d8976G' // contains G
+
+/* -------------------------------------------------------------------------- */
+/*                                  SVM FIXTURES                              */
+/* -------------------------------------------------------------------------- */
+// 32-byte base58 strings (taken from Solana docs / dev-net)
+const VALID_SVM_ADDRESS_1 = '4Nd1mPraZmk6D7new6qR1pT7iEpXD6xzWxMnK46ZQPyW'
+const VALID_SVM_ADDRESS_2 = '9xQeWvG816bUx9EPm2ERmuAHzp3ERWcGy3gPx1bMu7p'
+
+const INVALID_SVM_SHORT = '4Nd1mPraZmk6D7new6qR1pT7' // < 32 bytes
+const INVALID_SVM_NON_BASE58 = 'O0O0O0O0O0O0O0O0O0O0O0O0O0O' // has 0/O chars
+
+/* -------------------------------------------------------------------------- */
+/*                          Common junk inputs for both                       */
+/* -------------------------------------------------------------------------- */
+const NON_STRING_INVALIDS = [null, undefined, {}, { meow: 'woof' }, true]
+
+/* -------------------------------------------------------------------------- */
+/*                                  TESTS                                     */
+/* -------------------------------------------------------------------------- */
+describe('getValidAddress – EVM', () => {
+  it.each`
+    input                               | expected                                  | checksum
+    ${SAMPLE_SEED_ADDRESS_1}            | ${SAMPLE_SEED_ADDRESS_1.toLowerCase()}    | ${false}
+    ${SAMPLE_SEED_ADDRESS_1_WITH_SPACE} | ${SAMPLE_SEED_ADDRESS_1.toLowerCase()}    | ${false}
+    ${SAMPLE_SEED_ADDRESS_1}            | ${SAMPLE_SEED_ADDRESS_1}                  | ${true}
+    ${ADDRESS_NO_PREFIX}                | ${`0x${ADDRESS_NO_PREFIX}`.toLowerCase()} | ${false}
+    ${INVALID_EVM_WRONG_LENGTH}         | ${null}                                   | ${false}
+    ${INVALID_EVM_BAD_PREFIX}           | ${null}                                   | ${false}
+    ${INVALID_EVM_NON_HEX}              | ${null}                                   | ${true}
+  `('returns $expected for $input (checksum=$checksum)', ({ input, expected, checksum }) => {
+    expect(getValidAddress({ address: input, platform: Platform.EVM, withEVMChecksum: checksum })).toEqual(expected)
+  })
+
+  it.each(NON_STRING_INVALIDS)('returns null for non-string input %p', (junk) => {
+    expect(getValidAddress({ address: junk as any, platform: Platform.EVM })).toBeNull()
+  })
+})
+
+describe('getValidAddress – SVM', () => {
+  it.each`
+    input                     | expected
+    ${VALID_SVM_ADDRESS_1}    | ${VALID_SVM_ADDRESS_1}
+    ${VALID_SVM_ADDRESS_2}    | ${VALID_SVM_ADDRESS_2}
+    ${INVALID_SVM_SHORT}      | ${null}
+    ${INVALID_SVM_NON_BASE58} | ${null}
+  `('returns $expected for $input', ({ input, expected }) => {
+    expect(getValidAddress({ address: input, platform: Platform.SVM })).toEqual(expected)
+  })
+
+  it.each(NON_STRING_INVALIDS)('returns null for non-string input %p', (junk) => {
+    expect(getValidAddress({ address: junk as any, platform: Platform.SVM })).toBeNull()
+  })
+})