@growae/reactive-react 0.0.1

package/src/hooks/useConnectors.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest'
+import { useConnectors } from './useConnectors.js'
+
+describe('useConnectors', () => {
+  it('should be a function', () => {
+    expect(typeof useConnectors).toBe('function')
+  })
+
+  it('should be exported', () => {
+    expect(useConnectors).toBeDefined()
+  })
+})

package/src/hooks/useConnectors.ts

@@ -0,0 +1,26 @@
+'use client'
+
+import {
+  type GetConnectorsReturnType,
+  getConnectors,
+  watchConnectors,
+} from '@growae/reactive'
+import { useSyncExternalStore } from 'react'
+import type { ConfigParameter } from '../types/properties.js'
+import { useConfig } from './useConfig.js'
+
+export type UseConnectorsParameters = ConfigParameter
+
+export type UseConnectorsReturnType = GetConnectorsReturnType
+
+export function useConnectors(
+  parameters: UseConnectorsParameters = {},
+): UseConnectorsReturnType {
+  const config = useConfig(parameters)
+
+  return useSyncExternalStore(
+    (onChange) => watchConnectors(config, { onChange }),
+    () => getConnectors(config),
+    () => getConnectors(config),
+  )
+}

package/src/hooks/useContractBytecode.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest'
+import { useContractBytecode } from './useContractBytecode.js'
+
+describe('useContractBytecode', () => {
+  it('should be a function', () => {
+    expect(typeof useContractBytecode).toBe('function')
+  })
+
+  it('should be exported', () => {
+    expect(useContractBytecode).toBeDefined()
+  })
+})

package/src/hooks/useContractBytecode.ts

@@ -0,0 +1,41 @@
+'use client'
+
+import {
+  type GetContractBytecodeParameters,
+  type GetContractBytecodeReturnType,
+  type GetContractBytecodeErrorType,
+  getContractBytecode,
+} from '@growae/reactive'
+import type { Compute } from '@growae/reactive'
+import { type UseQueryReturnType, useQuery } from '../utils/query.js'
+import type { ConfigParameter } from '../types/properties.js'
+import { useConfig } from './useConfig.js'
+import { useNetworkId } from './useNetworkId.js'
+
+export type UseContractBytecodeParameters = Compute<
+  GetContractBytecodeParameters & ConfigParameter & { enabled?: boolean }
+>
+
+export type UseContractBytecodeReturnType = UseQueryReturnType<
+  GetContractBytecodeReturnType,
+  GetContractBytecodeErrorType
+>
+
+export function useContractBytecode(
+  parameters: UseContractBytecodeParameters = {} as UseContractBytecodeParameters,
+): UseContractBytecodeReturnType {
+  const config = useConfig(parameters)
+  const networkId = useNetworkId({ config })
+
+  return useQuery({
+    queryKey: ['contractBytecode', {
+      contractId: parameters.contractId,
+      networkId: parameters.networkId ?? networkId,
+    }],
+    queryFn: () => getContractBytecode(config, {
+      ...parameters,
+      networkId: parameters.networkId ?? networkId,
+    }),
+    enabled: Boolean(parameters.contractId) && (parameters.enabled ?? true),
+  }) as UseContractBytecodeReturnType
+}

package/src/hooks/useContractEvents.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest'
+import { useContractEvents } from './useContractEvents.js'
+
+describe('useContractEvents', () => {
+  it('should be a function', () => {
+    expect(typeof useContractEvents).toBe('function')
+  })
+
+  it('should be exported', () => {
+    expect(useContractEvents).toBeDefined()
+  })
+})

package/src/hooks/useContractEvents.ts

@@ -0,0 +1,42 @@
+'use client'
+
+import {
+  type GetContractEventsParameters,
+  type GetContractEventsReturnType,
+  getContractEvents,
+} from '@growae/reactive'
+import type { Compute } from '@growae/reactive'
+import { type UseQueryReturnType, useQuery } from '../utils/query.js'
+import type { ConfigParameter } from '../types/properties.js'
+import { useConfig } from './useConfig.js'
+import { useNetworkId } from './useNetworkId.js'
+
+export type UseContractEventsParameters = Compute<
+  GetContractEventsParameters & ConfigParameter & { enabled?: boolean }
+>
+
+export type UseContractEventsReturnType = UseQueryReturnType<
+  GetContractEventsReturnType,
+  Error
+>
+
+export function useContractEvents(
+  parameters: UseContractEventsParameters = {} as UseContractEventsParameters,
+): UseContractEventsReturnType {
+  const config = useConfig(parameters)
+  const networkId = useNetworkId({ config })
+
+  return useQuery({
+    queryKey: ['contractEvents', {
+      address: parameters.address,
+      fromHeight: parameters.fromHeight,
+      toHeight: parameters.toHeight,
+      networkId: parameters.networkId ?? networkId,
+    }],
+    queryFn: () => getContractEvents(config, {
+      ...parameters,
+      networkId: parameters.networkId ?? networkId,
+    }),
+    enabled: Boolean(parameters.address) && (parameters.enabled ?? true),
+  }) as UseContractEventsReturnType
+}

package/src/hooks/useDeployContract.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest'
+import { useDeployContract } from './useDeployContract.js'
+
+describe('useDeployContract', () => {
+  it('should be a function', () => {
+    expect(typeof useDeployContract).toBe('function')
+  })
+
+  it('should be exported', () => {
+    expect(useDeployContract).toBeDefined()
+  })
+})

package/src/hooks/useDeployContract.ts

@@ -0,0 +1,54 @@
+'use client'
+
+import { useMutation } from '@tanstack/react-query'
+import {
+  type DeployContractParameters,
+  type DeployContractReturnType,
+  type DeployContractErrorType,
+  deployContract,
+} from '@growae/reactive'
+import type { Compute } from '@growae/reactive'
+import type { ConfigParameter } from '../types/properties.js'
+import type { UseMutationReturnType } from '../utils/query.js'
+import { useConfig } from './useConfig.js'
+
+export type UseDeployContractParameters<context = unknown> = Compute<
+  ConfigParameter & {
+    mutation?: {
+      onSuccess?: (data: DeployContractReturnType, variables: DeployContractParameters, context: context) => void
+      onError?: (error: DeployContractErrorType, variables: DeployContractParameters, context: context) => void
+    }
+  }
+>
+
+export type UseDeployContractReturnType<context = unknown> = Compute<
+  UseMutationReturnType<
+    DeployContractReturnType,
+    DeployContractErrorType,
+    DeployContractParameters,
+    context
+  > & {
+    deployContract: (variables: DeployContractParameters) => void
+    deployContractAsync: (variables: DeployContractParameters) => Promise<DeployContractReturnType>
+  }
+>
+
+export function useDeployContract<context = unknown>(
+  parameters: UseDeployContractParameters<context> = {},
+): UseDeployContractReturnType<context> {
+  const config = useConfig(parameters)
+
+  const mutation = useMutation({
+    mutationKey: ['deployContract'],
+    mutationFn: (variables: DeployContractParameters) =>
+      deployContract(config, variables),
+    ...parameters.mutation,
+  })
+
+  type Return = UseDeployContractReturnType<context>
+  return {
+    ...(mutation as unknown as Return),
+    deployContract: mutation.mutate as Return['deployContract'],
+    deployContractAsync: mutation.mutateAsync as Return['deployContractAsync'],
+  }
+}

package/src/hooks/useDisconnect.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest'
+import { useDisconnect } from './useDisconnect.js'
+
+describe('useDisconnect', () => {
+  it('should be a function', () => {
+    expect(typeof useDisconnect).toBe('function')
+  })
+
+  it('should be exported', () => {
+    expect(useDisconnect).toBeDefined()
+  })
+})

package/src/hooks/useDisconnect.ts

@@ -0,0 +1,54 @@
+'use client'
+
+import { useMutation } from '@tanstack/react-query'
+import {
+  type DisconnectParameters,
+  type DisconnectReturnType,
+  type DisconnectErrorType,
+  disconnect,
+} from '@growae/reactive'
+import type { Compute } from '@growae/reactive'
+import type { ConfigParameter } from '../types/properties.js'
+import type { UseMutationReturnType } from '../utils/query.js'
+import { useConfig } from './useConfig.js'
+
+export type UseDisconnectParameters<context = unknown> = Compute<
+  ConfigParameter & {
+    mutation?: {
+      onSuccess?: (data: DisconnectReturnType, variables: DisconnectParameters, context: context) => void
+      onError?: (error: DisconnectErrorType, variables: DisconnectParameters, context: context) => void
+    }
+  }
+>
+
+export type UseDisconnectReturnType<context = unknown> = Compute<
+  UseMutationReturnType<
+    DisconnectReturnType,
+    DisconnectErrorType,
+    DisconnectParameters,
+    context
+  > & {
+    disconnect: (variables?: DisconnectParameters) => void
+    disconnectAsync: (variables?: DisconnectParameters) => Promise<DisconnectReturnType>
+  }
+>
+
+export function useDisconnect<context = unknown>(
+  parameters: UseDisconnectParameters<context> = {},
+): UseDisconnectReturnType<context> {
+  const config = useConfig(parameters)
+
+  const mutation = useMutation({
+    mutationKey: ['disconnect'],
+    mutationFn: (variables: DisconnectParameters = {}) =>
+      disconnect(config, variables),
+    ...parameters.mutation,
+  })
+
+  type Return = UseDisconnectReturnType<context>
+  return {
+    ...(mutation as unknown as Return),
+    disconnect: mutation.mutate as Return['disconnect'],
+    disconnectAsync: mutation.mutateAsync as Return['disconnectAsync'],
+  }
+}

package/src/hooks/useEstimateGas.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest'
+import { useEstimateGas } from './useEstimateGas.js'
+
+describe('useEstimateGas', () => {
+  it('should be a function', () => {
+    expect(typeof useEstimateGas).toBe('function')
+  })
+
+  it('should be exported', () => {
+    expect(useEstimateGas).toBeDefined()
+  })
+})

package/src/hooks/useEstimateGas.ts

@@ -0,0 +1,42 @@
+'use client'
+
+import {
+  type EstimateGasParameters,
+  type EstimateGasReturnType,
+  type EstimateGasErrorType,
+  estimateGas,
+} from '@growae/reactive'
+import type { Compute } from '@growae/reactive'
+import { type UseQueryReturnType, useQuery } from '../utils/query.js'
+import type { ConfigParameter } from '../types/properties.js'
+import { useConfig } from './useConfig.js'
+import { useNetworkId } from './useNetworkId.js'
+
+export type UseEstimateGasParameters = Compute<
+  EstimateGasParameters & ConfigParameter & { enabled?: boolean }
+>
+
+export type UseEstimateGasReturnType = UseQueryReturnType<
+  EstimateGasReturnType,
+  EstimateGasErrorType
+>
+
+export function useEstimateGas(
+  parameters: UseEstimateGasParameters = {} as UseEstimateGasParameters,
+): UseEstimateGasReturnType {
+  const config = useConfig(parameters)
+  const networkId = useNetworkId({ config })
+
+  return useQuery({
+    queryKey: ['estimateGas', {
+      tx: parameters.tx,
+      accountAddress: parameters.accountAddress,
+      networkId: parameters.networkId ?? networkId,
+    }],
+    queryFn: () => estimateGas(config, {
+      ...parameters,
+      networkId: parameters.networkId ?? networkId,
+    }),
+    enabled: Boolean(parameters.tx && parameters.accountAddress) && (parameters.enabled ?? true),
+  }) as UseEstimateGasReturnType
+}

package/src/hooks/useHeight.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest'
+import { useHeight } from './useHeight.js'
+
+describe('useHeight', () => {
+  it('should be a function', () => {
+    expect(typeof useHeight).toBe('function')
+  })
+
+  it('should be exported', () => {
+    expect(useHeight).toBeDefined()
+  })
+})

package/src/hooks/useHeight.ts

@@ -0,0 +1,39 @@
+'use client'
+
+import {
+  type GetHeightParameters,
+  type GetHeightReturnType,
+  type GetHeightErrorType,
+  getHeight,
+} from '@growae/reactive'
+import type { Compute } from '@growae/reactive'
+import { type UseQueryReturnType, useQuery } from '../utils/query.js'
+import type { ConfigParameter } from '../types/properties.js'
+import { useConfig } from './useConfig.js'
+import { useNetworkId } from './useNetworkId.js'
+
+export type UseHeightParameters = Compute<
+  GetHeightParameters & ConfigParameter & { enabled?: boolean }
+>
+
+export type UseHeightReturnType = UseQueryReturnType<
+  GetHeightReturnType,
+  GetHeightErrorType
+>
+
+export function useHeight(
+  parameters: UseHeightParameters = {},
+): UseHeightReturnType {
+  const config = useConfig(parameters)
+  const networkId = useNetworkId({ config })
+
+  return useQuery({
+    queryKey: ['height', {
+      networkId: parameters.networkId ?? networkId,
+    }],
+    queryFn: () => getHeight(config, {
+      networkId: parameters.networkId ?? networkId,
+    }),
+    enabled: parameters.enabled ?? true,
+  }) as UseHeightReturnType
+}

package/src/hooks/useNetworkId.test.ts

@@ -0,0 +1,54 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi } from 'vitest'
+
+vi.mock('@aeternity/aepp-sdk', () => ({
+  Node: vi.fn().mockImplementation(() => ({})),
+}))
+
+import { createElement } from 'react'
+import { renderHook } from '@testing-library/react'
+import { useNetworkId } from './useNetworkId.js'
+import { ReactiveProvider } from '../context.js'
+import { createConfig } from '@growae/reactive'
+import { testnet, mainnet } from '@growae/reactive'
+import { mock } from '@growae/reactive'
+
+const TEST_ACCOUNTS = [
+  'ak_2swhLkgBPeeADxVTABy7tt6d2HgBQFnGJELkBUMY4FUa8RVLM',
+] as const
+
+function createTestConfig() {
+  return createConfig({
+    networks: [testnet, mainnet],
+    connectors: [mock({ accounts: [...TEST_ACCOUNTS] })],
+    storage: null,
+  })
+}
+
+describe('useNetworkId', () => {
+  it('should return current network id', () => {
+    const config = createTestConfig()
+    const { result } = renderHook(() => useNetworkId(), {
+      wrapper: ({ children }) =>
+        createElement(
+          ReactiveProvider,
+          { config, reconnectOnMount: false },
+          children,
+        ),
+    })
+    expect(result.current).toBe('ae_uat')
+  })
+
+  it('should accept config parameter directly', () => {
+    const config = createTestConfig()
+    const { result } = renderHook(() => useNetworkId({ config }), {
+      wrapper: ({ children }) =>
+        createElement(
+          ReactiveProvider,
+          { config, reconnectOnMount: false },
+          children,
+        ),
+    })
+    expect(result.current).toBe('ae_uat')
+  })
+})

package/src/hooks/useNetworkId.ts

@@ -0,0 +1,26 @@
+'use client'
+
+import {
+  type GetNetworkIdReturnType,
+  getNetworkId,
+  watchNetworkId,
+} from '@growae/reactive'
+import { useSyncExternalStore } from 'react'
+import type { ConfigParameter } from '../types/properties.js'
+import { useConfig } from './useConfig.js'
+
+export type UseNetworkIdParameters = ConfigParameter
+
+export type UseNetworkIdReturnType = GetNetworkIdReturnType
+
+export function useNetworkId(
+  parameters: UseNetworkIdParameters = {},
+): UseNetworkIdReturnType {
+  const config = useConfig(parameters)
+
+  return useSyncExternalStore(
+    (onChange) => watchNetworkId(config, { onChange }),
+    () => getNetworkId(config),
+    () => getNetworkId(config),
+  )
+}

package/src/hooks/useNetworks.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest'
+import { useNetworks } from './useNetworks.js'
+
+describe('useNetworks', () => {
+  it('should be a function', () => {
+    expect(typeof useNetworks).toBe('function')
+  })
+
+  it('should be exported', () => {
+    expect(useNetworks).toBeDefined()
+  })
+})

package/src/hooks/useNetworks.ts

@@ -0,0 +1,19 @@
+'use client'
+
+import {
+  type GetNetworksReturnType,
+  getNetworks,
+} from '@growae/reactive'
+import type { ConfigParameter } from '../types/properties.js'
+import { useConfig } from './useConfig.js'
+
+export type UseNetworksParameters = ConfigParameter
+
+export type UseNetworksReturnType = GetNetworksReturnType
+
+export function useNetworks(
+  parameters: UseNetworksParameters = {},
+): UseNetworksReturnType {
+  const config = useConfig(parameters)
+  return getNetworks(config)
+}

package/src/hooks/useNodeClient.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest'
+import { useNodeClient } from './useNodeClient.js'
+
+describe('useNodeClient', () => {
+  it('should be a function', () => {
+    expect(typeof useNodeClient).toBe('function')
+  })
+
+  it('should be exported', () => {
+    expect(useNodeClient).toBeDefined()
+  })
+})

package/src/hooks/useNodeClient.ts

@@ -0,0 +1,30 @@
+'use client'
+
+import {
+  type GetNodeClientParameters,
+  type GetNodeClientReturnType,
+  getNodeClient,
+  watchNodeClient,
+} from '@growae/reactive'
+import type { Compute } from '@growae/reactive'
+import { useSyncExternalStore } from 'react'
+import type { ConfigParameter } from '../types/properties.js'
+import { useConfig } from './useConfig.js'
+
+export type UseNodeClientParameters = Compute<
+  GetNodeClientParameters & ConfigParameter
+>
+
+export type UseNodeClientReturnType = GetNodeClientReturnType
+
+export function useNodeClient(
+  parameters: UseNodeClientParameters = {},
+): UseNodeClientReturnType {
+  const config = useConfig(parameters)
+
+  return useSyncExternalStore(
+    (onChange) => watchNodeClient(config, { onChange }),
+    () => getNodeClient(config, parameters),
+    () => getNodeClient(config, parameters),
+  )
+}

package/src/hooks/useOpenChannel.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest'
+import { useOpenChannel } from './useOpenChannel.js'
+
+describe('useOpenChannel', () => {
+  it('should be a function', () => {
+    expect(typeof useOpenChannel).toBe('function')
+  })
+
+  it('should be exported', () => {
+    expect(useOpenChannel).toBeDefined()
+  })
+})

package/src/hooks/useOpenChannel.ts

@@ -0,0 +1,53 @@
+'use client'
+
+import { useMutation } from '@tanstack/react-query'
+import {
+  type OpenChannelParameters,
+  type OpenChannelReturnType,
+  openChannel,
+} from '@growae/reactive'
+import type { Compute } from '@growae/reactive'
+import type { ConfigParameter } from '../types/properties.js'
+import type { UseMutationReturnType } from '../utils/query.js'
+import { useConfig } from './useConfig.js'
+
+export type UseOpenChannelParameters<context = unknown> = Compute<
+  ConfigParameter & {
+    mutation?: {
+      onSuccess?: (data: OpenChannelReturnType, variables: OpenChannelParameters, context: context) => void
+      onError?: (error: Error, variables: OpenChannelParameters, context: context) => void
+    }
+  }
+>
+
+export type UseOpenChannelReturnType<context = unknown> = Compute<
+  UseMutationReturnType<
+    OpenChannelReturnType,
+    Error,
+    OpenChannelParameters,
+    context
+  > & {
+    openChannel: (variables: OpenChannelParameters) => void
+    openChannelAsync: (variables: OpenChannelParameters) => Promise<OpenChannelReturnType>
+  }
+>
+
+export function useOpenChannel<context = unknown>(
+  parameters: UseOpenChannelParameters<context> = {},
+): UseOpenChannelReturnType<context> {
+  const config = useConfig(parameters)
+
+  const mutation = useMutation({
+    mutationKey: ['openChannel'],
+    mutationFn: (variables: OpenChannelParameters) =>
+      openChannel(config, variables),
+    ...parameters.mutation,
+  })
+
+  type Return = UseOpenChannelReturnType<context>
+  return {
+    ...(mutation as unknown as Return),
+    openChannel: mutation.mutate as Return['openChannel'],
+    openChannelAsync: mutation.mutateAsync as Return['openChannelAsync'],
+  }
+}

package/src/hooks/useOracleQueries.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest'
+import { useOracleQueries } from './useOracleQueries.js'
+
+describe('useOracleQueries', () => {
+  it('should be a function', () => {
+    expect(typeof useOracleQueries).toBe('function')
+  })
+
+  it('should be exported', () => {
+    expect(useOracleQueries).toBeDefined()
+  })
+})