tempo.ts 0.7.6 → 0.8.1

package/src/wagmi/Hooks/reward.ts

@@ -205,6 +205,74 @@ export declare namespace useGetTotalPerSecond {
     UseQueryReturnType<selectData, Error>
 }
 
+/**
+ * Hook for getting the reward information for a specific account.
+ *
+ * @example
+ * ```tsx
+ * import { Hooks } from 'tempo.ts/wagmi'
+ *
+ * function App() {
+ *   const { data, isLoading } = Hooks.reward.useUserRewardInfo({
+ *     token: '0x20c0000000000000000000000000000000000001',
+ *     account: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+ *   })
+ *
+ *   if (isLoading) return <div>Loading...</div>
+ *   return (
+ *     <div>
+ *       <div>Recipient: {data?.rewardRecipient}</div>
+ *       <div>Reward per token: {data?.rewardPerToken.toString()}</div>
+ *       <div>Reward balance: {data?.rewardBalance.toString()}</div>
+ *     </div>
+ *   )
+ * }
+ * ```
+ *
+ * @param parameters - Parameters.
+ * @returns Query result with reward information (recipient, rewardPerToken, rewardBalance).
+ */
+export function useUserRewardInfo<
+  config extends Config = ResolvedRegister['config'],
+  selectData = Actions.getUserRewardInfo.ReturnValue,
+>(parameters: useUserRewardInfo.Parameters<config, selectData> = {}) {
+  const { account, query = {}, token } = parameters
+
+  const config = useConfig(parameters)
+  const chainId = useChainId({ config })
+
+  const options = Actions.getUserRewardInfo.queryOptions(config, {
+    ...parameters,
+    chainId: parameters.chainId ?? chainId,
+    query: undefined,
+  } as never)
+  const enabled = Boolean(token && account && (query.enabled ?? true))
+
+  return useQuery({ ...query, ...options, enabled })
+}
+
+export declare namespace useUserRewardInfo {
+  export type Parameters<
+    config extends Config = ResolvedRegister['config'],
+    selectData = Actions.getUserRewardInfo.ReturnValue,
+  > = ConfigParameter<config> &
+    QueryParameter<
+      Actions.getUserRewardInfo.ReturnValue,
+      DefaultError,
+      selectData,
+      Actions.getUserRewardInfo.QueryKey<config>
+    > &
+    ExactPartial<
+      Omit<
+        Actions.getUserRewardInfo.queryOptions.Parameters<config, selectData>,
+        'query'
+      >
+    >
+
+  export type ReturnValue<selectData = Actions.getUserRewardInfo.ReturnValue> =
+    UseQueryReturnType<selectData, Error>
+}
+
 /**
  * Hook for setting the reward recipient for a token holder.
  *

package/src/wagmi/Hooks/token.test.ts

@@ -241,30 +241,6 @@ describe('useHasRole', () => {
   })
 })
 
-describe('useApprove', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      approve: hooks.useApprove(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    const hash = await result.current.approve.mutateAsync({
-      spender: account2.address,
-      amount: parseUnits('100', 6),
-      token: addresses.alphaUsd,
-    })
-    expect(hash).toBeDefined()
-
-    await vi.waitFor(() =>
-      expect(result.current.approve.isSuccess).toBeTruthy(),
-    )
-  })
-})
-
 describe('useApproveSync', () => {
   test('default', async () => {
     const { result } = await renderHook(() => ({
@@ -290,51 +266,6 @@ describe('useApproveSync', () => {
   })
 })
 
-describe('useBurn', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      createSync: hooks.useCreateSync(),
-      grantRolesSync: hooks.useGrantRolesSync(),
-      mintSync: hooks.useMintSync(),
-      burn: hooks.useBurn(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    // Create a new token
-    const { token: tokenAddr } = await result.current.createSync.mutateAsync({
-      currency: 'USD',
-      name: 'Burnable Hook Token',
-      symbol: 'BURNHOOK',
-    })
-
-    // Grant issuer role
-    await result.current.grantRolesSync.mutateAsync({
-      token: tokenAddr,
-      roles: ['issuer'],
-      to: account.address,
-    })
-
-    // Mint some tokens
-    await result.current.mintSync.mutateAsync({
-      token: tokenAddr,
-      to: account.address,
-      amount: parseUnits('1000', 6),
-    })
-
-    const hash = await result.current.burn.mutateAsync({
-      token: tokenAddr,
-      amount: parseUnits('1', 6),
-    })
-    expect(hash).toBeDefined()
-
-    await vi.waitFor(() => expect(result.current.burn.isSuccess).toBeTruthy())
-  })
-})
-
 describe('useBurnSync', () => {
   test('default', async () => {
     const { result } = await renderHook(() => ({
@@ -381,37 +312,6 @@ describe('useBurnSync', () => {
   })
 })
 
-describe('useChangeTransferPolicy', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      createSync: hooks.useCreateSync(),
-      changeTransferPolicy: hooks.useChangeTransferPolicy(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    // Create a new token
-    const { token: tokenAddr } = await result.current.createSync.mutateAsync({
-      currency: 'USD',
-      name: 'Policy Hook Token',
-      symbol: 'POLICYHOOK',
-    })
-
-    const hash = await result.current.changeTransferPolicy.mutateAsync({
-      token: tokenAddr,
-      policyId: 0n,
-    })
-    expect(hash).toBeDefined()
-
-    await vi.waitFor(() =>
-      expect(result.current.changeTransferPolicy.isSuccess).toBeTruthy(),
-    )
-  })
-})
-
 describe('useChangeTransferPolicySync', () => {
   test('default', async () => {
     const { result } = await renderHook(() => ({
@@ -444,28 +344,6 @@ describe('useChangeTransferPolicySync', () => {
   })
 })
 
-describe('useCreate', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      create: hooks.useCreate(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    const hash = await result.current.create.mutateAsync({
-      name: 'Hook Test Token',
-      symbol: 'HOOKTEST',
-      currency: 'USD',
-    })
-    expect(hash).toBeDefined()
-
-    await vi.waitFor(() => expect(result.current.create.isSuccess).toBeTruthy())
-  })
-})
-
 describe('useCreateSync', () => {
   test('default', async () => {
     const { result } = await renderHook(() => ({
@@ -491,50 +369,6 @@ describe('useCreateSync', () => {
   })
 })
 
-describe('useUpdateQuoteToken', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      createSync: hooks.useCreateSync(),
-      prepareUpdateQuoteTokenSync: hooks.usePrepareUpdateQuoteTokenSync(),
-      updateQuoteToken: hooks.useUpdateQuoteToken(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    // Create quote token
-    const { token: quoteToken } = await result.current.createSync.mutateAsync({
-      currency: 'USD',
-      name: 'Finalize Quote Hook',
-      symbol: 'FQHOOK',
-    })
-
-    // Create main token
-    const { token: tokenAddr } = await result.current.createSync.mutateAsync({
-      currency: 'USD',
-      name: 'Finalize Main Hook',
-      symbol: 'FMHOOK',
-    })
-
-    // Prepare quote token update first
-    await result.current.prepareUpdateQuoteTokenSync.mutateAsync({
-      token: tokenAddr,
-      quoteToken,
-    })
-
-    const hash = await result.current.updateQuoteToken.mutateAsync({
-      token: tokenAddr,
-    })
-    expect(hash).toBeDefined()
-
-    await vi.waitFor(() =>
-      expect(result.current.updateQuoteToken.isSuccess).toBeTruthy(),
-    )
-  })
-})
-
 describe('useUpdateQuoteTokenSync', () => {
   test('default', async () => {
     const { result } = await renderHook(() => ({
@@ -646,44 +480,6 @@ describe('useGrantRolesSync', () => {
   })
 })
 
-describe('useMint', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      createSync: hooks.useCreateSync(),
-      grantRolesSync: hooks.useGrantRolesSync(),
-      mint: hooks.useMint(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    // Create a new token
-    const { token: tokenAddr } = await result.current.createSync.mutateAsync({
-      currency: 'USD',
-      name: 'Mint Hook Token',
-      symbol: 'MINTHOOK',
-    })
-
-    // Grant issuer role
-    await result.current.grantRolesSync.mutateAsync({
-      token: tokenAddr,
-      roles: ['issuer'],
-      to: account.address,
-    })
-
-    const hash = await result.current.mint.mutateAsync({
-      token: tokenAddr,
-      to: account.address,
-      amount: parseUnits('100', 6),
-    })
-    expect(hash).toBeDefined()
-
-    await vi.waitFor(() => expect(result.current.mint.isSuccess).toBeTruthy())
-  })
-})
-
 describe('useMintSync', () => {
   test('default', async () => {
     const { result } = await renderHook(() => ({
@@ -723,42 +519,6 @@ describe('useMintSync', () => {
   })
 })
 
-describe('usePause', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      createSync: hooks.useCreateSync(),
-      grantRolesSync: hooks.useGrantRolesSync(),
-      pause: hooks.usePause(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    // Create a new token
-    const { token: tokenAddr } = await result.current.createSync.mutateAsync({
-      currency: 'USD',
-      name: 'Pause Hook Token',
-      symbol: 'PAUSEHOOK',
-    })
-
-    // Grant pause role
-    await result.current.grantRolesSync.mutateAsync({
-      token: tokenAddr,
-      roles: ['pause'],
-      to: account.address,
-    })
-
-    const hash = await result.current.pause.mutateAsync({
-      token: tokenAddr,
-    })
-    expect(hash).toBeDefined()
-
-    await vi.waitFor(() => expect(result.current.pause.isSuccess).toBeTruthy())
-  })
-})
-
 describe('usePauseSync', () => {
   test('default', async () => {
     const { result } = await renderHook(() => ({
@@ -796,45 +556,6 @@ describe('usePauseSync', () => {
   })
 })
 
-describe('useRenounceRoles', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      createSync: hooks.useCreateSync(),
-      grantRolesSync: hooks.useGrantRolesSync(),
-      renounceRoles: hooks.useRenounceRoles(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    // Create a new token
-    const { token: tokenAddr } = await result.current.createSync.mutateAsync({
-      currency: 'USD',
-      name: 'Renounce Hook Token',
-      symbol: 'RENOUNCEHOOK',
-    })
-
-    // Grant issuer role to ourselves
-    await result.current.grantRolesSync.mutateAsync({
-      token: tokenAddr,
-      roles: ['issuer'],
-      to: account.address,
-    })
-
-    const hash = await result.current.renounceRoles.mutateAsync({
-      token: tokenAddr,
-      roles: ['issuer'],
-    })
-    expect(hash).toBeDefined()
-
-    await vi.waitFor(() =>
-      expect(result.current.renounceRoles.isSuccess).toBeTruthy(),
-    )
-  })
-})
-
 describe('useRenounceRolesSync', () => {
   test('default', async () => {
     const { result } = await renderHook(() => ({
@@ -876,46 +597,6 @@ describe('useRenounceRolesSync', () => {
   })
 })
 
-describe('useRevokeRoles', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      createSync: hooks.useCreateSync(),
-      grantRolesSync: hooks.useGrantRolesSync(),
-      revokeRoles: hooks.useRevokeRoles(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    // Create a new token
-    const { token: tokenAddr } = await result.current.createSync.mutateAsync({
-      currency: 'USD',
-      name: 'Revoke Hook Token',
-      symbol: 'REVOKEHOOK',
-    })
-
-    // Grant issuer role to account2
-    await result.current.grantRolesSync.mutateAsync({
-      token: tokenAddr,
-      roles: ['issuer'],
-      to: account2.address,
-    })
-
-    const hash = await result.current.revokeRoles.mutateAsync({
-      token: tokenAddr,
-      roles: ['issuer'],
-      from: account2.address,
-    })
-    expect(hash).toBeDefined()
-
-    await vi.waitFor(() =>
-      expect(result.current.revokeRoles.isSuccess).toBeTruthy(),
-    )
-  })
-})
-
 describe('useRevokeRolesSync', () => {
   test('default', async () => {
     const { result } = await renderHook(() => ({
@@ -958,38 +639,6 @@ describe('useRevokeRolesSync', () => {
   })
 })
 
-describe('useSetRoleAdmin', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      createSync: hooks.useCreateSync(),
-      setRoleAdmin: hooks.useSetRoleAdmin(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    // Create a new token
-    const { token: tokenAddr } = await result.current.createSync.mutateAsync({
-      currency: 'USD',
-      name: 'Role Admin Hook Token',
-      symbol: 'ROLEADMINHOOK',
-    })
-
-    const hash = await result.current.setRoleAdmin.mutateAsync({
-      token: tokenAddr,
-      role: 'issuer',
-      adminRole: 'pause',
-    })
-    expect(hash).toBeDefined()
-
-    await vi.waitFor(() =>
-      expect(result.current.setRoleAdmin.isSuccess).toBeTruthy(),
-    )
-  })
-})
-
 describe('useSetRoleAdminSync', () => {
   test('default', async () => {
     const { result } = await renderHook(() => ({
@@ -1023,37 +672,6 @@ describe('useSetRoleAdminSync', () => {
   })
 })
 
-describe('useSetSupplyCap', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      createSync: hooks.useCreateSync(),
-      setSupplyCap: hooks.useSetSupplyCap(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    // Create a new token
-    const { token: tokenAddr } = await result.current.createSync.mutateAsync({
-      currency: 'USD',
-      name: 'Supply Cap Hook Token',
-      symbol: 'SUPPLYCAPHOOK',
-    })
-
-    const hash = await result.current.setSupplyCap.mutateAsync({
-      token: tokenAddr,
-      supplyCap: parseUnits('1000000', 6),
-    })
-    expect(hash).toBeDefined()
-
-    await vi.waitFor(() =>
-      expect(result.current.setSupplyCap.isSuccess).toBeTruthy(),
-    )
-  })
-})
-
 describe('useSetSupplyCapSync', () => {
   test('default', async () => {
     const { result } = await renderHook(() => ({
@@ -1086,30 +704,6 @@ describe('useSetSupplyCapSync', () => {
   })
 })
 
-describe('useTransfer', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      transfer: hooks.useTransfer(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    const hash = await result.current.transfer.mutateAsync({
-      to: account2.address,
-      amount: parseUnits('1', 6),
-      token: addresses.alphaUsd,
-    })
-    expect(hash).toBeDefined()
-
-    await vi.waitFor(() =>
-      expect(result.current.transfer.isSuccess).toBeTruthy(),
-    )
-  })
-})
-
 describe('useTransferSync', () => {
   test('default', async () => {
     const { result } = await renderHook(() => ({
@@ -1135,50 +729,6 @@ describe('useTransferSync', () => {
   })
 })
 
-describe('useUnpause', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      createSync: hooks.useCreateSync(),
-      grantRolesSync: hooks.useGrantRolesSync(),
-      pauseSync: hooks.usePauseSync(),
-      unpause: hooks.useUnpause(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    // Create a new token
-    const { token: tokenAddr } = await result.current.createSync.mutateAsync({
-      currency: 'USD',
-      name: 'Unpause Hook Token',
-      symbol: 'UNPAUSEHOOK',
-    })
-
-    // Grant pause and unpause roles
-    await result.current.grantRolesSync.mutateAsync({
-      token: tokenAddr,
-      roles: ['pause', 'unpause'],
-      to: account.address,
-    })
-
-    // First pause it
-    await result.current.pauseSync.mutateAsync({
-      token: tokenAddr,
-    })
-
-    const hash = await result.current.unpause.mutateAsync({
-      token: tokenAddr,
-    })
-    expect(hash).toBeDefined()
-
-    await vi.waitFor(() =>
-      expect(result.current.unpause.isSuccess).toBeTruthy(),
-    )
-  })
-})
-
 describe('useUnpauseSync', () => {
   test('default', async () => {
     const { result } = await renderHook(() => ({
@@ -1224,44 +774,6 @@ describe('useUnpauseSync', () => {
   })
 })
 
-describe('usePrepareUpdateQuoteToken', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      createSync: hooks.useCreateSync(),
-      prepareUpdateQuoteToken: hooks.usePrepareUpdateQuoteToken(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    // Create quote token
-    const { token: quoteToken } = await result.current.createSync.mutateAsync({
-      currency: 'USD',
-      name: 'Update Quote Hook',
-      symbol: 'UQHOOK',
-    })
-
-    // Create main token
-    const { token: tokenAddr } = await result.current.createSync.mutateAsync({
-      currency: 'USD',
-      name: 'Update Main Hook',
-      symbol: 'UMHOOK',
-    })
-
-    const hash = await result.current.prepareUpdateQuoteToken.mutateAsync({
-      token: tokenAddr,
-      quoteToken,
-    })
-    expect(hash).toBeDefined()
-
-    await vi.waitFor(() =>
-      expect(result.current.prepareUpdateQuoteToken.isSuccess).toBeTruthy(),
-    )
-  })
-})
-
 describe('usePrepareUpdateQuoteTokenSync', () => {
   test('default', async () => {
     const { result } = await renderHook(() => ({

package/dist/viem/internal/account.d.ts

@@ -1,21 +0,0 @@
-import * as Hex from 'ox/Hex';
-import * as PublicKey from 'ox/PublicKey';
-import type { LocalAccount } from 'viem';
-import type { RequiredBy } from '../../internal/types.js';
-export type Account = RequiredBy<LocalAccount, 'sign' | 'signAuthorization'>;
-/** @internal */
-export declare function toPrivateKeyAccount(parameters: toPrivateKeyAccount.Parameters): toPrivateKeyAccount.ReturnValue;
-export declare namespace toPrivateKeyAccount {
-    type Parameters = {
-        /** Address. */
-        address: Hex.Hex;
-        /** Public key. */
-        publicKey: PublicKey.PublicKey;
-        /** Sign function. */
-        sign: NonNullable<LocalAccount['sign']>;
-        /** Source. */
-        source?: string | undefined;
-    };
-    type ReturnValue = Account;
-}
-//# sourceMappingURL=account.d.ts.map

package/dist/viem/internal/account.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"account.d.ts","sourceRoot":"","sources":["../../../src/viem/internal/account.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,QAAQ,CAAA;AAC7B,OAAO,KAAK,SAAS,MAAM,cAAc,CAAA;AACzC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAOxC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAIzD,MAAM,MAAM,OAAO,GAAG,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,mBAAmB,CAAC,CAAA;AAG5E,gBAAgB;AAChB,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,mBAAmB,CAAC,UAAU,GACzC,mBAAmB,CAAC,WAAW,CAsDjC;AAED,MAAM,CAAC,OAAO,WAAW,mBAAmB,CAAC;IAC3C,KAAY,UAAU,GAAG;QACvB,eAAe;QACf,OAAO,EAAE,GAAG,CAAC,GAAG,CAAA;QAChB,kBAAkB;QAClB,SAAS,EAAE,SAAS,CAAC,SAAS,CAAA;QAC9B,qBAAqB;QACrB,IAAI,EAAE,WAAW,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAA;QACvC,cAAc;QACd,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KAC5B,CAAA;IAED,KAAY,WAAW,GAAG,OAAO,CAAA;CAClC"}