@growae/reactive-react 0.0.1

package/src/hooks/useOracleQueries.ts

@@ -0,0 +1,40 @@
+'use client'
+
+import {
+  type GetOracleQueriesParameters,
+  type GetOracleQueriesReturnType,
+  getOracleQueries,
+} 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 UseOracleQueriesParameters = Compute<
+  GetOracleQueriesParameters & ConfigParameter & { enabled?: boolean }
+>
+
+export type UseOracleQueriesReturnType = UseQueryReturnType<
+  GetOracleQueriesReturnType,
+  Error
+>
+
+export function useOracleQueries(
+  parameters: UseOracleQueriesParameters = {} as UseOracleQueriesParameters,
+): UseOracleQueriesReturnType {
+  const config = useConfig(parameters)
+  const networkId = useNetworkId({ config })
+
+  return useQuery({
+    queryKey: ['oracleQueries', {
+      oracleId: parameters.oracleId,
+      networkId: parameters.networkId ?? networkId,
+    }],
+    queryFn: () => getOracleQueries(config, {
+      ...parameters,
+      networkId: parameters.networkId ?? networkId,
+    }),
+    enabled: Boolean(parameters.oracleId) && (parameters.enabled ?? true),
+  }) as UseOracleQueriesReturnType
+}

package/src/hooks/useOracleState.test.ts

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

package/src/hooks/useOracleState.ts

@@ -0,0 +1,40 @@
+'use client'
+
+import {
+  type GetOracleStateParameters,
+  type GetOracleStateReturnType,
+  getOracleState,
+} 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 UseOracleStateParameters = Compute<
+  GetOracleStateParameters & ConfigParameter & { enabled?: boolean }
+>
+
+export type UseOracleStateReturnType = UseQueryReturnType<
+  GetOracleStateReturnType,
+  Error
+>
+
+export function useOracleState(
+  parameters: UseOracleStateParameters = {} as UseOracleStateParameters,
+): UseOracleStateReturnType {
+  const config = useConfig(parameters)
+  const networkId = useNetworkId({ config })
+
+  return useQuery({
+    queryKey: ['oracleState', {
+      oracleId: parameters.oracleId,
+      networkId: parameters.networkId ?? networkId,
+    }],
+    queryFn: () => getOracleState(config, {
+      ...parameters,
+      networkId: parameters.networkId ?? networkId,
+    }),
+    enabled: Boolean(parameters.oracleId) && (parameters.enabled ?? true),
+  }) as UseOracleStateReturnType
+}

package/src/hooks/usePayForTransaction.test.ts

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

package/src/hooks/usePayForTransaction.ts

@@ -0,0 +1,54 @@
+'use client'
+
+import { useMutation } from '@tanstack/react-query'
+import {
+  type PayForTransactionParameters,
+  type PayForTransactionReturnType,
+  type PayForTransactionErrorType,
+  payForTransaction,
+} 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 UsePayForTransactionParameters<context = unknown> = Compute<
+  ConfigParameter & {
+    mutation?: {
+      onSuccess?: (data: PayForTransactionReturnType, variables: PayForTransactionParameters, context: context) => void
+      onError?: (error: PayForTransactionErrorType, variables: PayForTransactionParameters, context: context) => void
+    }
+  }
+>
+
+export type UsePayForTransactionReturnType<context = unknown> = Compute<
+  UseMutationReturnType<
+    PayForTransactionReturnType,
+    PayForTransactionErrorType,
+    PayForTransactionParameters,
+    context
+  > & {
+    payForTransaction: (variables: PayForTransactionParameters) => void
+    payForTransactionAsync: (variables: PayForTransactionParameters) => Promise<PayForTransactionReturnType>
+  }
+>
+
+export function usePayForTransaction<context = unknown>(
+  parameters: UsePayForTransactionParameters<context> = {},
+): UsePayForTransactionReturnType<context> {
+  const config = useConfig(parameters)
+
+  const mutation = useMutation({
+    mutationKey: ['payForTransaction'],
+    mutationFn: (variables: PayForTransactionParameters) =>
+      payForTransaction(config, variables),
+    ...parameters.mutation,
+  })
+
+  type Return = UsePayForTransactionReturnType<context>
+  return {
+    ...(mutation as unknown as Return),
+    payForTransaction: mutation.mutate as Return['payForTransaction'],
+    payForTransactionAsync: mutation.mutateAsync as Return['payForTransactionAsync'],
+  }
+}

package/src/hooks/usePreclaimName.test.ts

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

package/src/hooks/usePreclaimName.ts

@@ -0,0 +1,53 @@
+'use client'
+
+import { useMutation } from '@tanstack/react-query'
+import {
+  type PreclaimNameParameters,
+  type PreclaimNameReturnType,
+  preclaimName,
+} 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 UsePreclaimNameParameters<context = unknown> = Compute<
+  ConfigParameter & {
+    mutation?: {
+      onSuccess?: (data: PreclaimNameReturnType, variables: PreclaimNameParameters, context: context) => void
+      onError?: (error: Error, variables: PreclaimNameParameters, context: context) => void
+    }
+  }
+>
+
+export type UsePreclaimNameReturnType<context = unknown> = Compute<
+  UseMutationReturnType<
+    PreclaimNameReturnType,
+    Error,
+    PreclaimNameParameters,
+    context
+  > & {
+    preclaimName: (variables: PreclaimNameParameters) => void
+    preclaimNameAsync: (variables: PreclaimNameParameters) => Promise<PreclaimNameReturnType>
+  }
+>
+
+export function usePreclaimName<context = unknown>(
+  parameters: UsePreclaimNameParameters<context> = {},
+): UsePreclaimNameReturnType<context> {
+  const config = useConfig(parameters)
+
+  const mutation = useMutation({
+    mutationKey: ['preclaimName'],
+    mutationFn: (variables: PreclaimNameParameters) =>
+      preclaimName(config, variables),
+    ...parameters.mutation,
+  })
+
+  type Return = UsePreclaimNameReturnType<context>
+  return {
+    ...(mutation as unknown as Return),
+    preclaimName: mutation.mutate as Return['preclaimName'],
+    preclaimNameAsync: mutation.mutateAsync as Return['preclaimNameAsync'],
+  }
+}

package/src/hooks/useQueryOracle.test.ts

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

package/src/hooks/useQueryOracle.ts

@@ -0,0 +1,53 @@
+'use client'
+
+import { useMutation } from '@tanstack/react-query'
+import {
+  type QueryOracleParameters,
+  type QueryOracleReturnType,
+  queryOracle,
+} 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 UseQueryOracleParameters<context = unknown> = Compute<
+  ConfigParameter & {
+    mutation?: {
+      onSuccess?: (data: QueryOracleReturnType, variables: QueryOracleParameters, context: context) => void
+      onError?: (error: Error, variables: QueryOracleParameters, context: context) => void
+    }
+  }
+>
+
+export type UseQueryOracleReturnType<context = unknown> = Compute<
+  UseMutationReturnType<
+    QueryOracleReturnType,
+    Error,
+    QueryOracleParameters,
+    context
+  > & {
+    queryOracle: (variables: QueryOracleParameters) => void
+    queryOracleAsync: (variables: QueryOracleParameters) => Promise<QueryOracleReturnType>
+  }
+>
+
+export function useQueryOracle<context = unknown>(
+  parameters: UseQueryOracleParameters<context> = {},
+): UseQueryOracleReturnType<context> {
+  const config = useConfig(parameters)
+
+  const mutation = useMutation({
+    mutationKey: ['queryOracle'],
+    mutationFn: (variables: QueryOracleParameters) =>
+      queryOracle(config, variables),
+    ...parameters.mutation,
+  })
+
+  type Return = UseQueryOracleReturnType<context>
+  return {
+    ...(mutation as unknown as Return),
+    queryOracle: mutation.mutate as Return['queryOracle'],
+    queryOracleAsync: mutation.mutateAsync as Return['queryOracleAsync'],
+  }
+}

package/src/hooks/useReadContract.test.ts

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

package/src/hooks/useReadContract.ts

@@ -0,0 +1,43 @@
+'use client'
+
+import {
+  type ReadContractParameters,
+  type ReadContractReturnType,
+  readContract,
+} 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 UseReadContractParameters = Compute<
+  ReadContractParameters & ConfigParameter & { enabled?: boolean }
+>
+
+export type UseReadContractReturnType = UseQueryReturnType<
+  ReadContractReturnType,
+  Error
+>
+
+export function useReadContract(
+  parameters: UseReadContractParameters = {} as UseReadContractParameters,
+): UseReadContractReturnType {
+  const config = useConfig(parameters)
+  const networkId = useNetworkId({ config })
+
+  return useQuery({
+    queryKey: ['readContract', {
+      address: parameters.address,
+      method: parameters.method,
+      args: parameters.args,
+      networkId: parameters.networkId ?? networkId,
+    }],
+    queryFn: () => readContract(config, {
+      ...parameters,
+      networkId: parameters.networkId ?? networkId,
+    }),
+    enabled: Boolean(parameters.address && parameters.aci && parameters.method) &&
+      (parameters.enabled ?? true),
+  }) as UseReadContractReturnType
+}

package/src/hooks/useReadContracts.test.ts

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

package/src/hooks/useReadContracts.ts

@@ -0,0 +1,38 @@
+'use client'
+
+import {
+  type ReadContractsParameters,
+  type ReadContractsReturnType,
+  readContracts,
+} 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'
+
+export type UseReadContractsParameters = Compute<
+  ReadContractsParameters & ConfigParameter & { enabled?: boolean }
+>
+
+export type UseReadContractsReturnType = UseQueryReturnType<
+  ReadContractsReturnType,
+  Error
+>
+
+export function useReadContracts(
+  parameters: UseReadContractsParameters = {} as UseReadContractsParameters,
+): UseReadContractsReturnType {
+  const config = useConfig(parameters)
+
+  return useQuery({
+    queryKey: ['readContracts', {
+      contracts: parameters.contracts?.map((c) => ({
+        address: c.address,
+        method: c.method,
+        args: c.args,
+      })),
+    }],
+    queryFn: () => readContracts(config, parameters),
+    enabled: Boolean(parameters.contracts?.length) && (parameters.enabled ?? true),
+  }) as UseReadContractsReturnType
+}

package/src/hooks/useReconnect.test.ts

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

package/src/hooks/useReconnect.ts

@@ -0,0 +1,54 @@
+'use client'
+
+import { useMutation } from '@tanstack/react-query'
+import {
+  type ReconnectParameters,
+  type ReconnectReturnType,
+  type ReconnectErrorType,
+  reconnect,
+} 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 UseReconnectParameters<context = unknown> = Compute<
+  ConfigParameter & {
+    mutation?: {
+      onSuccess?: (data: ReconnectReturnType, variables: ReconnectParameters, context: context) => void
+      onError?: (error: ReconnectErrorType, variables: ReconnectParameters, context: context) => void
+    }
+  }
+>
+
+export type UseReconnectReturnType<context = unknown> = Compute<
+  UseMutationReturnType<
+    ReconnectReturnType,
+    ReconnectErrorType,
+    ReconnectParameters,
+    context
+  > & {
+    reconnect: (variables?: ReconnectParameters) => void
+    reconnectAsync: (variables?: ReconnectParameters) => Promise<ReconnectReturnType>
+  }
+>
+
+export function useReconnect<context = unknown>(
+  parameters: UseReconnectParameters<context> = {},
+): UseReconnectReturnType<context> {
+  const config = useConfig(parameters)
+
+  const mutation = useMutation({
+    mutationKey: ['reconnect'],
+    mutationFn: (variables: ReconnectParameters = {}) =>
+      reconnect(config, variables),
+    ...parameters.mutation,
+  })
+
+  type Return = UseReconnectReturnType<context>
+  return {
+    ...(mutation as unknown as Return),
+    reconnect: mutation.mutate as Return['reconnect'],
+    reconnectAsync: mutation.mutateAsync as Return['reconnectAsync'],
+  }
+}

package/src/hooks/useRegisterOracle.test.ts

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

package/src/hooks/useRegisterOracle.ts

@@ -0,0 +1,53 @@
+'use client'
+
+import { useMutation } from '@tanstack/react-query'
+import {
+  type RegisterOracleParameters,
+  type RegisterOracleReturnType,
+  registerOracle,
+} 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 UseRegisterOracleParameters<context = unknown> = Compute<
+  ConfigParameter & {
+    mutation?: {
+      onSuccess?: (data: RegisterOracleReturnType, variables: RegisterOracleParameters, context: context) => void
+      onError?: (error: Error, variables: RegisterOracleParameters, context: context) => void
+    }
+  }
+>
+
+export type UseRegisterOracleReturnType<context = unknown> = Compute<
+  UseMutationReturnType<
+    RegisterOracleReturnType,
+    Error,
+    RegisterOracleParameters,
+    context
+  > & {
+    registerOracle: (variables: RegisterOracleParameters) => void
+    registerOracleAsync: (variables: RegisterOracleParameters) => Promise<RegisterOracleReturnType>
+  }
+>
+
+export function useRegisterOracle<context = unknown>(
+  parameters: UseRegisterOracleParameters<context> = {},
+): UseRegisterOracleReturnType<context> {
+  const config = useConfig(parameters)
+
+  const mutation = useMutation({
+    mutationKey: ['registerOracle'],
+    mutationFn: (variables: RegisterOracleParameters) =>
+      registerOracle(config, variables),
+    ...parameters.mutation,
+  })
+
+  type Return = UseRegisterOracleReturnType<context>
+  return {
+    ...(mutation as unknown as Return),
+    registerOracle: mutation.mutate as Return['registerOracle'],
+    registerOracleAsync: mutation.mutateAsync as Return['registerOracleAsync'],
+  }
+}

package/src/hooks/useResolveName.test.ts

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

package/src/hooks/useResolveName.ts

@@ -0,0 +1,41 @@
+'use client'
+
+import {
+  type ResolveNameParameters,
+  type ResolveNameReturnType,
+  resolveName,
+} 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 UseResolveNameParameters = Compute<
+  ResolveNameParameters & ConfigParameter & { enabled?: boolean }
+>
+
+export type UseResolveNameReturnType = UseQueryReturnType<
+  ResolveNameReturnType,
+  Error
+>
+
+export function useResolveName(
+  parameters: UseResolveNameParameters = {} as UseResolveNameParameters,
+): UseResolveNameReturnType {
+  const config = useConfig(parameters)
+  const networkId = useNetworkId({ config })
+
+  return useQuery({
+    queryKey: ['resolveName', {
+      name: parameters.name,
+      key: parameters.key,
+      networkId: parameters.networkId ?? networkId,
+    }],
+    queryFn: () => resolveName(config, {
+      ...parameters,
+      networkId: parameters.networkId ?? networkId,
+    }),
+    enabled: Boolean(parameters.name) && (parameters.enabled ?? true),
+  }) as UseResolveNameReturnType
+}

package/src/hooks/useRespondToQuery.test.ts

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

package/src/hooks/useRespondToQuery.ts

@@ -0,0 +1,53 @@
+'use client'
+
+import { useMutation } from '@tanstack/react-query'
+import {
+  type RespondToQueryParameters,
+  type RespondToQueryReturnType,
+  respondToQuery,
+} 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 UseRespondToQueryParameters<context = unknown> = Compute<
+  ConfigParameter & {
+    mutation?: {
+      onSuccess?: (data: RespondToQueryReturnType, variables: RespondToQueryParameters, context: context) => void
+      onError?: (error: Error, variables: RespondToQueryParameters, context: context) => void
+    }
+  }
+>
+
+export type UseRespondToQueryReturnType<context = unknown> = Compute<
+  UseMutationReturnType<
+    RespondToQueryReturnType,
+    Error,
+    RespondToQueryParameters,
+    context
+  > & {
+    respondToQuery: (variables: RespondToQueryParameters) => void
+    respondToQueryAsync: (variables: RespondToQueryParameters) => Promise<RespondToQueryReturnType>
+  }
+>
+
+export function useRespondToQuery<context = unknown>(
+  parameters: UseRespondToQueryParameters<context> = {},
+): UseRespondToQueryReturnType<context> {
+  const config = useConfig(parameters)
+
+  const mutation = useMutation({
+    mutationKey: ['respondToQuery'],
+    mutationFn: (variables: RespondToQueryParameters) =>
+      respondToQuery(config, variables),
+    ...parameters.mutation,
+  })
+
+  type Return = UseRespondToQueryReturnType<context>
+  return {
+    ...(mutation as unknown as Return),
+    respondToQuery: mutation.mutate as Return['respondToQuery'],
+    respondToQueryAsync: mutation.mutateAsync as Return['respondToQueryAsync'],
+  }
+}

package/src/hooks/useRevokeName.test.ts

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