tempo.ts 0.10.5 → 0.11.1

package/src/viem/internal/types.ts

@@ -1,3 +1,4 @@
+import type { TokenId } from 'ox/tempo'
 import type {
   Account,
   Address,
@@ -10,7 +11,6 @@ import type {
   MaybeRequired,
   UnionPick,
 } from '../../internal/types.js'
-import type * as TokenId from '../../ox/TokenId.js'
 import type { TransactionRequestTempo } from '../Transaction.js'
 
 export type GetAccountParameter<

package/src/wagmi/Actions/dex.test.ts

@@ -7,7 +7,6 @@ import { addresses } from '../../../test/config.js'
 import { accounts } from '../../../test/viem/config.js'
 import {
   config,
-  queryClient,
   setupOrders,
   setupTokenPair,
 } from '../../../test/wagmi/config.js'
@@ -453,31 +452,6 @@ describe('getOrder', () => {
   })
 })
 
-describe('getOrders', () => {
-  test('default', async () => {
-    const response = await Actions.dex.getOrders(config, {
-      limit: 10,
-    })
-
-    expect(response).matchSnapshot()
-  })
-
-  describe('infiniteQueryOptions', () => {
-    test('default', async () => {
-      const options = Actions.dex.getOrders.infiniteQueryOptions(config, {
-        limit: 5,
-        query: {
-          pages: 2,
-        },
-      })
-
-      const result = await queryClient.fetchInfiniteQuery(options)
-
-      expect(result).matchSnapshot()
-    })
-  })
-})
-
 describe('getOrderbook', () => {
   test('default', async () => {
     const { base, quote } = await setupTokenPair()

package/src/wagmi/Actions/dex.ts

@@ -1,14 +1,8 @@
 import type * as Query from '@tanstack/query-core'
 import { type Config, getConnectorClient } from '@wagmi/core'
 import type { ChainIdParameter, ConnectorParameter } from '@wagmi/core/internal'
-import type * as Hex from 'ox/Hex'
 import type { Account } from 'viem'
-import type {
-  PartialBy,
-  RequiredBy,
-  UnionOmit,
-  UnionRequiredBy,
-} from '../../internal/types.js'
+import type { PartialBy, RequiredBy, UnionOmit } from '../../internal/types.js'
 import * as viem_Actions from '../../viem/Actions/dex.js'
 
 /**
@@ -624,110 +618,6 @@ export namespace getOrder {
   }
 }
 
-/**
- * Gets paginated orders from the orderbook.
- *
- * @example
- * ```ts
- * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'tempo.ts/chains'
- * import { Actions } from 'tempo.ts/wagmi'
- *
- * const config = createConfig({
- *   chains: [tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })],
- *   transports: {
- *     [tempo.id]: http(),
- *   },
- * })
- *
- * const { orders, nextCursor } = await Actions.dex.getOrders(config, {
- *   limit: 100,
- *   filters: {
- *     baseToken: '0x20c0...',
- *     isBid: true,
- *   }
- * })
- * ```
- *
- * @param config - Config.
- * @param parameters - Parameters.
- * @returns Paginated orders and next cursor.
- */
-export function getOrders<config extends Config>(
-  config: config,
-  parameters: getOrders.Parameters<config> = {},
-): Promise<getOrders.ReturnValue> {
-  const { chainId, ...rest } = parameters
-  const client = config.getClient({ chainId })
-  return viem_Actions.getOrders(client, rest)
-}
-
-export namespace getOrders {
-  export type Parameters<config extends Config> = ChainIdParameter<config> &
-    viem_Actions.getOrders.Parameters
-
-  export type ReturnValue = viem_Actions.getOrders.ReturnValue
-
-  export function queryKey<config extends Config>(
-    parameters: Parameters<config>,
-  ) {
-    return ['getOrders', parameters] as const
-  }
-
-  export type QueryKey<config extends Config> = ReturnType<
-    typeof queryKey<config>
-  >
-
-  export function infiniteQueryOptions<
-    config extends Config,
-    selectData = ReturnValue,
-  >(
-    config: Config,
-    parameters: infiniteQueryOptions.Parameters<config, selectData>,
-  ): infiniteQueryOptions.ReturnValue<config, selectData> {
-    const { cursor, query, ...rest } = parameters
-    return {
-      pages: 1,
-      ...query,
-      getNextPageParam: (x) => x.nextCursor,
-      initialPageParam: cursor ?? undefined,
-      queryKey: queryKey(rest),
-      async queryFn({ queryKey, pageParam: cursor }) {
-        const [, parameters] = queryKey
-        return await getOrders(config, { ...parameters, cursor })
-      },
-    }
-  }
-
-  export declare namespace infiniteQueryOptions {
-    export type Parameters<
-      config extends Config,
-      selectData = getOrders.ReturnValue,
-    > = getOrders.Parameters<config> & {
-      query?:
-        | Omit<
-            ReturnValue<config, selectData>,
-            'initialPageParam' | 'queryKey' | 'queryFn'
-          >
-        | undefined
-    }
-
-    export type ReturnValue<
-      config extends Config,
-      selectData = getOrders.ReturnValue,
-    > = UnionRequiredBy<
-      Query.FetchInfiniteQueryOptions<
-        getOrders.ReturnValue,
-        Query.DefaultError,
-        selectData,
-        getOrders.QueryKey<config>,
-        Hex.Hex | undefined
-      >,
-      'queryKey' | 'queryFn'
-    >
-  }
-}
-
 /**
  * Gets orderbook information for a trading pair.
  *

package/src/wagmi/Actions/nonce.test.ts

@@ -21,7 +21,7 @@ describe('getNonce', () => {
       account: account.address,
       nonceKey: 1n,
     })
-    expect(result).toBe(1n)
+    expect(result).toBe(0n)
   })
 
   describe('queryOptions', () => {
@@ -31,7 +31,7 @@ describe('getNonce', () => {
         nonceKey: 1n,
       })
       const result = await queryClient.fetchQuery(options)
-      expect(result).toBe(1n)
+      expect(result).toBe(0n)
     })
   })
 })
@@ -112,6 +112,10 @@ describe('watchActiveKeyCountChanged', () => {
       },
     })
 
+    const priorKeyCount = await getNonceKeyCount(config, {
+      account: account.address,
+    })
+
     // First use of nonceKey 10 should increment active key count
     await token.transferSync(config, {
       to: account2.address,
@@ -134,8 +138,8 @@ describe('watchActiveKeyCountChanged', () => {
 
     expect(events).toHaveLength(2)
     expect(events[0]?.account).toBe(account.address)
-    expect(events[0]?.newCount).toBe(1n)
-    expect(events[1]?.newCount).toBe(2n)
+    expect(events[0]?.newCount - priorKeyCount).toBe(1n)
+    expect(events[1]?.newCount - priorKeyCount).toBe(2n)
     unwatch()
   })
 })

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

@@ -74,7 +74,7 @@ describe('getMetadata', () => {
         "quoteToken": "0x20C0000000000000000000000000000000000000",
         "supplyCap": 340282366920938463463374607431768211455n,
         "symbol": "AlphaUSD",
-        "totalSupply": 36893488147419103230n,
+        "totalSupply": 202914184810805067765n,
         "transferPolicyId": 1n,
       }
     `)
@@ -96,7 +96,7 @@ describe('getMetadata', () => {
           "quoteToken": "0x20C0000000000000000000000000000000000000",
           "supplyCap": 340282366920938463463374607431768211455n,
           "symbol": "AlphaUSD",
-          "totalSupply": 36893488147419103230n,
+          "totalSupply": 202914184810805067765n,
           "transferPolicyId": 1n,
         }
       `)

package/src/wagmi/Connector.ts

@@ -1,6 +1,7 @@
 import * as Address from 'ox/Address'
 import type * as Hex from 'ox/Hex'
 import * as PublicKey from 'ox/PublicKey'
+import { KeyAuthorization, SignatureEnvelope } from 'ox/tempo'
 import {
   createClient,
   type EIP1193Provider,
@@ -11,8 +12,6 @@ import {
 import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
 import { ChainNotConfiguredError, createConnector } from 'wagmi'
 import type { OneOf } from '../internal/types.js'
-import * as KeyAuthorization from '../ox/KeyAuthorization.js'
-import * as SignatureEnvelope from '../ox/SignatureEnvelope.js'
 import * as Account from '../viem/Account.js'
 import type * as tempo_Chain from '../viem/Chain.js'
 import { normalizeValue } from '../viem/internal/utils.js'

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

@@ -8,7 +8,6 @@ import { accounts } from '../../../test/viem/config.js'
 import {
   config,
   renderHook,
-  setupOrders,
   setupTokenPair,
 } from '../../../test/wagmi/config.js'
 
@@ -421,31 +420,6 @@ describe('useOrder', () => {
   })
 })
 
-describe('useGetOrders', () => {
-  test('default', async () => {
-    await setupOrders()
-
-    const { result } = await renderHook(() =>
-      Hooks.dex.useGetOrders({
-        limit: 10,
-      }),
-    )
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
-
-    expect(result.current.data).matchSnapshot()
-
-    // fetch next page
-    result.current.fetchNextPage()
-
-    await vi.waitFor(() => {
-      expect(result.current.data?.pages.length).toBe(2)
-    })
-
-    expect(result.current.data).matchSnapshot()
-  })
-})
-
 describe('useOrderbook', () => {
   test('default', async () => {
     const { base, quote } = await setupTokenPair()

package/src/wagmi/Hooks/dex.ts

@@ -1,14 +1,12 @@
-import type { DefaultError, InfiniteData } from '@tanstack/query-core'
+import type { DefaultError } from '@tanstack/query-core'
 import type { UseMutationResult } from '@tanstack/react-query'
 import type { Config, ResolvedRegister } from '@wagmi/core'
 import { useEffect } from 'react'
 import { useChainId, useConfig } from 'wagmi'
 import type { ConfigParameter, QueryParameter } from 'wagmi/internal'
 import {
-  type UseInfiniteQueryReturnType,
   type UseMutationParameters,
   type UseQueryReturnType,
-  useInfiniteQuery,
   useMutation,
   useQuery,
 } from 'wagmi/query'
@@ -25,7 +23,6 @@ import {
   getBuyQuote,
   getOrder,
   getOrderbook,
-  getOrders,
   getSellQuote,
   getTickLevel,
   place,
@@ -641,90 +638,6 @@ export declare namespace useOrder {
     UseQueryReturnType<selectData, Error>
 }
 
-/**
- * Hook for getting paginated orders from the orderbook.
- *
- * @example
- * ```tsx
- * import { Hooks } from 'tempo.ts/wagmi'
- *
- * function App() {
- *   const { data, fetchNextPage, hasNextPage, isFetchingNextPage } = Hooks.dex.useGetOrders({
- *     limit: 10,
- *     filters: {
- *       baseToken: '0x20c0...',
- *       isBid: true,
- *     }
- *   })
- *
- *   return (
- *     <div>
- *       {data?.pages.map((page, i) => (
- *         <div key={i}>
- *           {page.orders.map((order) => (
- *             <div key={order.orderId.toString()}>{order.amount.toString()}</div>
- *           ))}
- *         </div>
- *       ))}
- *       {hasNextPage && (
- *         <button onClick={() => fetchNextPage()} disabled={isFetchingNextPage}>
- *           Load More
- *         </button>
- *       )}
- *     </div>
- *   )
- * }
- * ```
- *
- * @param parameters - Parameters.
- * @returns Infinite query result with paginated orders.
- */
-export function useGetOrders<
-  config extends Config = ResolvedRegister['config'],
-  selectData = getOrders.ReturnValue,
->(parameters: useGetOrders.Parameters<config, selectData> = {}) {
-  const { query = {}, ...rest } = parameters
-
-  const config = useConfig(parameters)
-  const chainId = useChainId({ config })
-
-  const options = getOrders.infiniteQueryOptions(config, {
-    ...rest,
-    chainId: parameters.chainId ?? chainId,
-    query: undefined,
-  })
-
-  return useInfiniteQuery({
-    ...query,
-    ...options,
-  } as never) as useGetOrders.ReturnValue<selectData>
-}
-
-export declare namespace useGetOrders {
-  export type Parameters<
-    config extends Config = ResolvedRegister['config'],
-    selectData = getOrders.ReturnValue,
-  > = ConfigParameter<config> &
-    Omit<
-      QueryParameter<
-        getOrders.ReturnValue,
-        DefaultError,
-        selectData,
-        getOrders.QueryKey<config>
-      >,
-      'queryFn' | 'queryKey'
-    > &
-    ExactPartial<
-      Omit<
-        getOrders.infiniteQueryOptions.Parameters<config, selectData>,
-        'query'
-      >
-    >
-
-  export type ReturnValue<selectData = getOrders.ReturnValue> =
-    UseInfiniteQueryReturnType<InfiniteData<selectData>, Error>
-}
-
 /**
  * Hook for getting orderbook information for a trading pair.
  *

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

@@ -38,7 +38,7 @@ describe('useNonce', () => {
 
     // Should now be enabled and have data
     expect(result.current.isEnabled).toBe(true)
-    expect(result.current.data).toBe(1n)
+    expect(result.current.data).toBe(0n)
   })
 
   test('reactivity: account parameter', async () => {
@@ -62,7 +62,7 @@ describe('useNonce', () => {
     })
 
     expect(result.current.isEnabled).toBe(true)
-    expect(result.current.data).toBe(1n)
+    expect(result.current.data).toBe(0n)
   })
 
   test('reactivity: nonceKey parameter', async () => {
@@ -86,7 +86,7 @@ describe('useNonce', () => {
     })
 
     expect(result.current.isEnabled).toBe(true)
-    expect(result.current.data).toBe(1n)
+    expect(result.current.data).toBe(0n)
   })
 })
 

package/src/wagmi/index.ts

@@ -1,4 +1,7 @@
 export * as Actions from './Actions/index.js'
-export { dangerous_secp256k1, webAuthn } from './Connector.js'
+export {
+  dangerous_secp256k1,
+  webAuthn,
+} from './Connector.js'
 export * as Hooks from './Hooks/index.js'
 export * as KeyManager from './KeyManager.js'