@growae/reactive-react 0.0.1

package/src/hooks/useRevokeName.ts

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

package/src/hooks/useSendTransaction.test.ts

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

package/src/hooks/useSendTransaction.ts

@@ -0,0 +1,54 @@
+'use client'
+
+import { useMutation } from '@tanstack/react-query'
+import {
+  type SendTransactionParameters,
+  type SendTransactionReturnType,
+  type SendTransactionErrorType,
+  sendTransaction,
+} 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 UseSendTransactionParameters<context = unknown> = Compute<
+  ConfigParameter & {
+    mutation?: {
+      onSuccess?: (data: SendTransactionReturnType, variables: SendTransactionParameters, context: context) => void
+      onError?: (error: SendTransactionErrorType, variables: SendTransactionParameters, context: context) => void
+    }
+  }
+>
+
+export type UseSendTransactionReturnType<context = unknown> = Compute<
+  UseMutationReturnType<
+    SendTransactionReturnType,
+    SendTransactionErrorType,
+    SendTransactionParameters,
+    context
+  > & {
+    sendTransaction: (variables: SendTransactionParameters) => void
+    sendTransactionAsync: (variables: SendTransactionParameters) => Promise<SendTransactionReturnType>
+  }
+>
+
+export function useSendTransaction<context = unknown>(
+  parameters: UseSendTransactionParameters<context> = {},
+): UseSendTransactionReturnType<context> {
+  const config = useConfig(parameters)
+
+  const mutation = useMutation({
+    mutationKey: ['sendTransaction'],
+    mutationFn: (variables: SendTransactionParameters) =>
+      sendTransaction(config, variables),
+    ...parameters.mutation,
+  })
+
+  type Return = UseSendTransactionReturnType<context>
+  return {
+    ...(mutation as unknown as Return),
+    sendTransaction: mutation.mutate as Return['sendTransaction'],
+    sendTransactionAsync: mutation.mutateAsync as Return['sendTransactionAsync'],
+  }
+}

package/src/hooks/useSignMessage.test.ts

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

package/src/hooks/useSignMessage.ts

@@ -0,0 +1,54 @@
+'use client'
+
+import { useMutation } from '@tanstack/react-query'
+import {
+  type SignMessageParameters,
+  type SignMessageReturnType,
+  type SignMessageErrorType,
+  signMessage,
+} 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 UseSignMessageParameters<context = unknown> = Compute<
+  ConfigParameter & {
+    mutation?: {
+      onSuccess?: (data: SignMessageReturnType, variables: SignMessageParameters, context: context) => void
+      onError?: (error: SignMessageErrorType, variables: SignMessageParameters, context: context) => void
+    }
+  }
+>
+
+export type UseSignMessageReturnType<context = unknown> = Compute<
+  UseMutationReturnType<
+    SignMessageReturnType,
+    SignMessageErrorType,
+    SignMessageParameters,
+    context
+  > & {
+    signMessage: (variables: SignMessageParameters) => void
+    signMessageAsync: (variables: SignMessageParameters) => Promise<SignMessageReturnType>
+  }
+>
+
+export function useSignMessage<context = unknown>(
+  parameters: UseSignMessageParameters<context> = {},
+): UseSignMessageReturnType<context> {
+  const config = useConfig(parameters)
+
+  const mutation = useMutation({
+    mutationKey: ['signMessage'],
+    mutationFn: (variables: SignMessageParameters) =>
+      signMessage(config, variables),
+    ...parameters.mutation,
+  })
+
+  type Return = UseSignMessageReturnType<context>
+  return {
+    ...(mutation as unknown as Return),
+    signMessage: mutation.mutate as Return['signMessage'],
+    signMessageAsync: mutation.mutateAsync as Return['signMessageAsync'],
+  }
+}

package/src/hooks/useSignTransaction.test.ts

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

package/src/hooks/useSignTransaction.ts

@@ -0,0 +1,54 @@
+'use client'
+
+import { useMutation } from '@tanstack/react-query'
+import {
+  type SignTransactionParameters,
+  type SignTransactionReturnType,
+  type SignTransactionErrorType,
+  signTransaction,
+} 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 UseSignTransactionParameters<context = unknown> = Compute<
+  ConfigParameter & {
+    mutation?: {
+      onSuccess?: (data: SignTransactionReturnType, variables: SignTransactionParameters, context: context) => void
+      onError?: (error: SignTransactionErrorType, variables: SignTransactionParameters, context: context) => void
+    }
+  }
+>
+
+export type UseSignTransactionReturnType<context = unknown> = Compute<
+  UseMutationReturnType<
+    SignTransactionReturnType,
+    SignTransactionErrorType,
+    SignTransactionParameters,
+    context
+  > & {
+    signTransaction: (variables: SignTransactionParameters) => void
+    signTransactionAsync: (variables: SignTransactionParameters) => Promise<SignTransactionReturnType>
+  }
+>
+
+export function useSignTransaction<context = unknown>(
+  parameters: UseSignTransactionParameters<context> = {},
+): UseSignTransactionReturnType<context> {
+  const config = useConfig(parameters)
+
+  const mutation = useMutation({
+    mutationKey: ['signTransaction'],
+    mutationFn: (variables: SignTransactionParameters) =>
+      signTransaction(config, variables),
+    ...parameters.mutation,
+  })
+
+  type Return = UseSignTransactionReturnType<context>
+  return {
+    ...(mutation as unknown as Return),
+    signTransaction: mutation.mutate as Return['signTransaction'],
+    signTransactionAsync: mutation.mutateAsync as Return['signTransactionAsync'],
+  }
+}

package/src/hooks/useSignTypedData.test.ts

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

package/src/hooks/useSignTypedData.ts

@@ -0,0 +1,54 @@
+'use client'
+
+import { useMutation } from '@tanstack/react-query'
+import {
+  type SignTypedDataParameters,
+  type SignTypedDataReturnType,
+  type SignTypedDataErrorType,
+  signTypedData,
+} 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 UseSignTypedDataParameters<context = unknown> = Compute<
+  ConfigParameter & {
+    mutation?: {
+      onSuccess?: (data: SignTypedDataReturnType, variables: SignTypedDataParameters, context: context) => void
+      onError?: (error: SignTypedDataErrorType, variables: SignTypedDataParameters, context: context) => void
+    }
+  }
+>
+
+export type UseSignTypedDataReturnType<context = unknown> = Compute<
+  UseMutationReturnType<
+    SignTypedDataReturnType,
+    SignTypedDataErrorType,
+    SignTypedDataParameters,
+    context
+  > & {
+    signTypedData: (variables: SignTypedDataParameters) => void
+    signTypedDataAsync: (variables: SignTypedDataParameters) => Promise<SignTypedDataReturnType>
+  }
+>
+
+export function useSignTypedData<context = unknown>(
+  parameters: UseSignTypedDataParameters<context> = {},
+): UseSignTypedDataReturnType<context> {
+  const config = useConfig(parameters)
+
+  const mutation = useMutation({
+    mutationKey: ['signTypedData'],
+    mutationFn: (variables: SignTypedDataParameters) =>
+      signTypedData(config, variables),
+    ...parameters.mutation,
+  })
+
+  type Return = UseSignTypedDataReturnType<context>
+  return {
+    ...(mutation as unknown as Return),
+    signTypedData: mutation.mutate as Return['signTypedData'],
+    signTypedDataAsync: mutation.mutateAsync as Return['signTypedDataAsync'],
+  }
+}

package/src/hooks/useSimulateContract.test.ts

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

package/src/hooks/useSimulateContract.ts

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

package/src/hooks/useSpend.test.ts

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

package/src/hooks/useSpend.ts

@@ -0,0 +1,53 @@
+'use client'
+
+import { useMutation } from '@tanstack/react-query'
+import {
+  type SpendParameters,
+  type SpendReturnType,
+  type SpendErrorType,
+  spend,
+} 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 UseSpendParameters<context = unknown> = Compute<
+  ConfigParameter & {
+    mutation?: {
+      onSuccess?: (data: SpendReturnType, variables: SpendParameters, context: context) => void
+      onError?: (error: SpendErrorType, variables: SpendParameters, context: context) => void
+    }
+  }
+>
+
+export type UseSpendReturnType<context = unknown> = Compute<
+  UseMutationReturnType<
+    SpendReturnType,
+    SpendErrorType,
+    SpendParameters,
+    context
+  > & {
+    spend: (variables: SpendParameters) => void
+    spendAsync: (variables: SpendParameters) => Promise<SpendReturnType>
+  }
+>
+
+export function useSpend<context = unknown>(
+  parameters: UseSpendParameters<context> = {},
+): UseSpendReturnType<context> {
+  const config = useConfig(parameters)
+
+  const mutation = useMutation({
+    mutationKey: ['spend'],
+    mutationFn: (variables: SpendParameters) => spend(config, variables),
+    ...parameters.mutation,
+  })
+
+  type Return = UseSpendReturnType<context>
+  return {
+    ...(mutation as unknown as Return),
+    spend: mutation.mutate as Return['spend'],
+    spendAsync: mutation.mutateAsync as Return['spendAsync'],
+  }
+}

package/src/hooks/useSwitchNetwork.test.ts

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

package/src/hooks/useSwitchNetwork.ts

@@ -0,0 +1,57 @@
+'use client'
+
+import { useMutation } from '@tanstack/react-query'
+import {
+  type SwitchNetworkParameters,
+  type SwitchNetworkReturnType,
+  type SwitchNetworkErrorType,
+  switchNetwork,
+} 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'
+import { useNetworks } from './useNetworks.js'
+
+export type UseSwitchNetworkParameters<context = unknown> = Compute<
+  ConfigParameter & {
+    mutation?: {
+      onSuccess?: (data: SwitchNetworkReturnType, variables: SwitchNetworkParameters, context: context) => void
+      onError?: (error: SwitchNetworkErrorType, variables: SwitchNetworkParameters, context: context) => void
+    }
+  }
+>
+
+export type UseSwitchNetworkReturnType<context = unknown> = Compute<
+  UseMutationReturnType<
+    SwitchNetworkReturnType,
+    SwitchNetworkErrorType,
+    SwitchNetworkParameters,
+    context
+  > & {
+    switchNetwork: (variables: SwitchNetworkParameters) => void
+    switchNetworkAsync: (variables: SwitchNetworkParameters) => Promise<SwitchNetworkReturnType>
+    networks: ReturnType<typeof useNetworks>
+  }
+>
+
+export function useSwitchNetwork<context = unknown>(
+  parameters: UseSwitchNetworkParameters<context> = {},
+): UseSwitchNetworkReturnType<context> {
+  const config = useConfig(parameters)
+
+  const mutation = useMutation({
+    mutationKey: ['switchNetwork'],
+    mutationFn: (variables: SwitchNetworkParameters) =>
+      switchNetwork(config, variables),
+    ...parameters.mutation,
+  })
+
+  type Return = UseSwitchNetworkReturnType<context>
+  return {
+    ...(mutation as unknown as Return),
+    switchNetwork: mutation.mutate as Return['switchNetwork'],
+    switchNetworkAsync: mutation.mutateAsync as Return['switchNetworkAsync'],
+    networks: useNetworks({ config }),
+  }
+}

package/src/hooks/useTransaction.test.ts

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

package/src/hooks/useTransaction.ts

@@ -0,0 +1,41 @@
+'use client'
+
+import {
+  type GetTransactionParameters,
+  type GetTransactionReturnType,
+  type GetTransactionErrorType,
+  getTransaction,
+} 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 UseTransactionParameters = Compute<
+  GetTransactionParameters & ConfigParameter & { enabled?: boolean }
+>
+
+export type UseTransactionReturnType = UseQueryReturnType<
+  GetTransactionReturnType,
+  GetTransactionErrorType
+>
+
+export function useTransaction(
+  parameters: UseTransactionParameters = {} as UseTransactionParameters,
+): UseTransactionReturnType {
+  const config = useConfig(parameters)
+  const networkId = useNetworkId({ config })
+
+  return useQuery({
+    queryKey: ['transaction', {
+      hash: parameters.hash,
+      networkId: parameters.networkId ?? networkId,
+    }],
+    queryFn: () => getTransaction(config, {
+      ...parameters,
+      networkId: parameters.networkId ?? networkId,
+    }),
+    enabled: Boolean(parameters.hash) && (parameters.enabled ?? true),
+  }) as UseTransactionReturnType
+}

package/src/hooks/useTransactionCount.test.ts

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

package/src/hooks/useTransactionCount.ts

@@ -0,0 +1,41 @@
+'use client'
+
+import {
+  type GetTransactionCountParameters,
+  type GetTransactionCountReturnType,
+  type GetTransactionCountErrorType,
+  getTransactionCount,
+} 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 UseTransactionCountParameters = Compute<
+  GetTransactionCountParameters & ConfigParameter & { enabled?: boolean }
+>
+
+export type UseTransactionCountReturnType = UseQueryReturnType<
+  GetTransactionCountReturnType,
+  GetTransactionCountErrorType
+>
+
+export function useTransactionCount(
+  parameters: UseTransactionCountParameters = {} as UseTransactionCountParameters,
+): UseTransactionCountReturnType {
+  const config = useConfig(parameters)
+  const networkId = useNetworkId({ config })
+
+  return useQuery({
+    queryKey: ['transactionCount', {
+      address: parameters.address,
+      networkId: parameters.networkId ?? networkId,
+    }],
+    queryFn: () => getTransactionCount(config, {
+      ...parameters,
+      networkId: parameters.networkId ?? networkId,
+    }),
+    enabled: Boolean(parameters.address) && (parameters.enabled ?? true),
+  }) as UseTransactionCountReturnType
+}

package/src/hooks/useTransferName.test.ts

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