tempo.ts 0.10.5 → 0.11.0

package/src/ox/Pagination.ts

@@ -1,164 +0,0 @@
-import type * as Hex from 'ox/Hex'
-
-/**
- * Filter range for numeric values.
- */
-export type FilterRange<type> = {
-  /** Maximum value (inclusive). */
-  max?: type | null | undefined
-  /** Minimum value (inclusive). */
-  min?: type | null | undefined
-}
-
-/**
- * Sort order direction.
- */
-export type SortOrder = 'asc' | 'desc'
-
-/**
- * Sort configuration.
- */
-export type Sort<on extends string = string> = {
-  /** A field the items are compared with. */
-  on: on
-  /** An ordering direction. */
-  order: SortOrder
-}
-
-/**
- * Pagination parameters.
- */
-export type Params<
-  filters extends Record<string, unknown> = Record<string, unknown>,
-  cursor = Hex.Hex,
-  sortOn extends string = string,
-> = {
-  /**
-   * Cursor for pagination.
-   *
-   * Defaults to first entry based on the sort and filter configuration.
-   * Use the `nextCursor` in response to get the next set of results.
-   */
-  cursor?: cursor | undefined
-  /** Determines which items should be yielded in the response. */
-  filters?: filters | undefined
-  /**
-   * Maximum number of items to return.
-   *
-   * Defaults to 10.
-   * Maximum is 100.
-   */
-  limit?: number | undefined
-  /** Determines the order of the items yielded in the response. */
-  sort?: Sort<sortOn> | undefined
-}
-
-/**
- * Pagination response.
- */
-export type Response<key extends string, type, cursor = Hex.Hex> = {
-  /** Cursor for next page, null if no more results. */
-  nextCursor: cursor | null
-} & {
-  [K in key]: readonly type[]
-}
-
-/**
- * Converts internal pagination parameters to RPC format.
- *
- * @example
- * ```ts twoslash
- * import { OrdersFilters, Pagination } from 'tempo.ts/ox'
- *
- * const rpcParameters = Pagination.toRpcParameters({
- *   cursor: '0x123',
- *   limit: 50,
- *   filters: {
- *     baseToken: '0x20c0000000000000000000000000000000000001',
- *     remaining: {
- *       min: 100n,
- *       max: 1000n,
- *     },
- *   },
- * }, {
- *   toRpcFilters: OrdersFilters.toRpc,
- * })
- * // @log: { cursor: '0x123', limit: 50, filters: { baseToken: '0x20c0...', remaining: { min: '0x64', max: '0x3e8' } } }
- * ```
- *
- * @param request - Internal request representation.
- * @returns RPC-formatted request.
- */
-export function toRpcParameters<toRpcFilters extends (args: any) => any>(
-  request: Params<Parameters<toRpcFilters>[0]>,
-  options: toRpcParameters.Options<toRpcFilters>,
-): Params<ReturnType<toRpcFilters>> {
-  const result: Params<ReturnType<toRpcFilters>> = {}
-
-  if (request.cursor !== undefined) result.cursor = request.cursor
-  if (request.limit !== undefined) result.limit = request.limit
-  if (request.sort !== undefined) result.sort = request.sort
-  if (request.filters !== undefined)
-    result.filters = options.toRpcFilters(request.filters)
-
-  return result
-}
-
-export declare namespace toRpcParameters {
-  type Options<toRpcFilters extends (args: any) => any> = {
-    toRpcFilters: toRpcFilters
-  }
-}
-
-/**
- * Converts RPC-formatted pagination response to internal representation.
- *
- * @example
- * ```ts twoslash
- * import { Order, Pagination } from 'tempo.ts/ox'
- *
- * const response = Pagination.fromRpcResponse({
- *   nextCursor: '0x123',
- *   items: [{
- *     amount: '0x64',
- *     baseToken: '0x20c0000000000000000000000000000000000001',
- *     flipTick: 0,
- *     isBid: true,
- *     isFlip: false,
- *     maker: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
- *     next: '0x0',
- *     orderId: '0x1',
- *     quoteToken: '0x20c0000000000000000000000000000000000002',
- *     prev: '0x0',
- *     remaining: '0x64',
- *     tick: 100,
- *   }],
- * }, {
- *   fromRpc: Order.fromRpc,
- * })
- * // @log: { nextCursor: '0x123', items: [{ amount: 100n, orderId: 1n, ... }] }
- * ```
- *
- * @param response - RPC-formatted response.
- * @param options - Conversion options.
- * @returns Internal response representation.
- */
-export function fromRpcResponse<
-  key extends string,
-  fromRpc extends (args: any) => any,
->(
-  response: Response<key, Parameters<fromRpc>[0]>,
-  options: fromRpcResponse.Options<key, fromRpc>,
-): Response<key, ReturnType<fromRpc>> {
-  return {
-    nextCursor: response.nextCursor,
-    [options.key]: response[options.key].map(options.fromRpc),
-  } as never
-}
-
-export declare namespace fromRpcResponse {
-  type Options<key extends string, fromRpc extends (args: any) => any> = {
-    key: key
-    fromRpc: fromRpc
-  }
-}

package/src/ox/PoolId.test.ts

@@ -1,33 +0,0 @@
-import { PoolId } from 'tempo.ts/ox'
-import { expect, test } from 'vitest'
-
-test('from', () => {
-  // Test with bigint token IDs
-  const poolId1 = PoolId.from({
-    userToken: 0n,
-    validatorToken: 1n,
-  })
-  expect(poolId1).toMatchInlineSnapshot(
-    `"0x24fc92718dfd933b7f831893444e0dc6072ce0fff68198eaf48e86cb1f2ee2dc"`,
-  )
-
-  // Test with address token IDs
-  const poolId2 = PoolId.from({
-    userToken: '0x20c0000000000000000000000000000000000000',
-    validatorToken: '0x20c0000000000000000000000000000000000001',
-  })
-  expect(poolId2).toBe(poolId1)
-
-  // Test with mixed types
-  const poolId3 = PoolId.from({
-    userToken: 0n,
-    validatorToken: '0x20c0000000000000000000000000000000000001',
-  })
-  expect(poolId3).toBe(poolId1)
-
-  const poolId4 = PoolId.from({
-    userToken: '0x20c0000000000000000000000000000000000000',
-    validatorToken: 1n,
-  })
-  expect(poolId4).toBe(poolId1)
-})

package/src/ox/PoolId.ts

@@ -1,27 +0,0 @@
-import * as Hash from 'ox/Hash'
-import * as Hex from 'ox/Hex'
-import * as TokenId from './TokenId.js'
-
-/**
- * Converts a user token and validator token to a pool ID.
- *
- * @param value - User token and validator token.
- * @returns The pool ID.
- */
-export function from(value: from.Value): Hex.Hex {
-  return Hash.keccak256(
-    Hex.concat(
-      Hex.padLeft(TokenId.toAddress(value.userToken), 32),
-      Hex.padLeft(TokenId.toAddress(value.validatorToken), 32),
-    ),
-  )
-}
-
-export declare namespace from {
-  export type Value = {
-    /** User token. */
-    userToken: TokenId.TokenIdOrAddress
-    /** Validator token. */
-    validatorToken: TokenId.TokenIdOrAddress
-  }
-}

package/src/ox/RpcSchema.ts

@@ -1,35 +0,0 @@
-import type * as RpcSchema from 'ox/RpcSchema'
-import type { UnionToTuple } from '../internal/types.js'
-import type * as Order from './Order.js'
-import type * as OrdersFilters from './OrdersFilters.js'
-import type * as Pagination from './Pagination.js'
-
-/**
- * Union of all JSON-RPC Methods for the `dex_` namespace.
- */
-export type Dex = RpcSchema.From<{
-  Request: {
-    method: 'dex_getOrders'
-    params: Pagination.Params<OrdersFilters.Rpc>
-  }
-  ReturnType: Pagination.Response<'orders', Order.Rpc>
-}>
-
-/**
- * Viem-compatible RPC schema for the `dex_` namespace.
- */
-export type DexViem = ToViem<Dex>
-
-type ToViem<schema extends RpcSchema.Generic> = UnionToTuple<schema> extends [
-  infer head extends RpcSchema.Generic,
-  ...infer tail extends RpcSchema.Generic[],
-]
-  ? [
-      {
-        Method: head['Request']['method']
-        Parameters: head['Request']['params']
-        ReturnType: head['ReturnType']
-      },
-      ...ToViem<tail[number]>,
-    ]
-  : []