tempo.ts 0.1.5 → 0.2.0

package/src/ox/OrdersFilters.ts

@@ -0,0 +1,125 @@
+import type * as Address from 'ox/Address'
+import * as Hex from 'ox/Hex'
+import type * as Pagination from './Pagination.js'
+import type * as Tick from './Tick.js'
+
+/**
+ * Filter configuration for orders query.
+ */
+export type OrdersFilters<bigintType = bigint> = {
+  /** Filter by specific base token. */
+  baseToken?: Address.Address | undefined
+  /** Filter by order side (true=buy, false=sell). */
+  isBid?: boolean | undefined
+  /** Filter flip orders. */
+  isFlip?: boolean | undefined
+  /** Filter by maker address. */
+  maker?: Address.Address | undefined
+  /** Filter by quote token. */
+  quoteToken?: Address.Address | undefined
+  /** Remaining amount in range. */
+  remaining?: Pagination.FilterRange<bigintType> | undefined
+  /** Tick in range (from -2000 to 2000). */
+  tick?: Pagination.FilterRange<Tick.Tick> | undefined
+}
+
+/**
+ * RPC-formatted orders filters.
+ */
+export type Rpc = OrdersFilters<Hex.Hex>
+
+/**
+ * Converts RPC-formatted orders filters to internal representation.
+ *
+ * @example
+ * ```ts twoslash
+ * import { OrdersRequest } from 'tempo.ts/ox'
+ *
+ * const filters = OrdersRequest.fromRpc({
+ *   baseToken: '0x20c0000000000000000000000000000000000001',
+ *   isBid: true,
+ *   remaining: {
+ *     min: '0x64',
+ *     max: '0x3e8',
+ *   },
+ * })
+ * // @log: { baseToken: '0x20c0...', isBid: true, remaining: { min: 100n, max: 1000n } }
+ * ```
+ *
+ * @param filters - RPC-formatted filters.
+ * @returns Internal filters representation.
+ */
+export function fromRpc(filters: Rpc): OrdersFilters {
+  const result: OrdersFilters = {}
+
+  if (filters.baseToken !== undefined) result.baseToken = filters.baseToken
+  if (filters.isBid !== undefined) result.isBid = filters.isBid
+  if (filters.isFlip !== undefined) result.isFlip = filters.isFlip
+  if (filters.maker !== undefined) result.maker = filters.maker
+  if (filters.quoteToken !== undefined) result.quoteToken = filters.quoteToken
+
+  if (filters.remaining !== undefined) {
+    const remaining: Pagination.FilterRange<bigint> = {}
+    remaining.min =
+      typeof filters.remaining.min === 'string'
+        ? Hex.toBigInt(filters.remaining.min)
+        : null
+    remaining.max =
+      typeof filters.remaining.max === 'string'
+        ? Hex.toBigInt(filters.remaining.max)
+        : null
+    result.remaining = remaining
+  }
+
+  if (filters.tick !== undefined) result.tick = filters.tick
+
+  return result
+}
+
+/**
+ * Converts internal orders filters to RPC format.
+ *
+ * @example
+ * ```ts twoslash
+ * import { OrdersRequest } from 'tempo.ts/ox'
+ *
+ * const rpcFilters = OrdersRequest.toRpc({
+ *   baseToken: '0x20c0000000000000000000000000000000000001',
+ *   isBid: true,
+ *   remaining: {
+ *     min: 100n,
+ *     max: 1000n,
+ *   },
+ * })
+ * // @log: { baseToken: '0x20c0...', isBid: true, remaining: { min: '0x64', max: '0x3e8' } }
+ * ```
+ *
+ * @param filters - Internal filters representation.
+ * @returns RPC-formatted filters.
+ */
+export function toRpc(filters: OrdersFilters): Rpc {
+  const result: Rpc = {}
+
+  if (filters.baseToken !== undefined) result.baseToken = filters.baseToken
+  if (filters.isBid !== undefined) result.isBid = filters.isBid
+  if (filters.isFlip !== undefined) result.isFlip = filters.isFlip
+  if (filters.maker !== undefined) result.maker = filters.maker
+  if (filters.quoteToken !== undefined) result.quoteToken = filters.quoteToken
+
+  if (filters.remaining !== undefined) {
+    const remaining: Pagination.FilterRange<Hex.Hex> = {}
+    remaining.min =
+      typeof filters.remaining.min === 'bigint'
+        ? Hex.fromNumber(filters.remaining.min)
+        : null
+    remaining.max =
+      typeof filters.remaining.max === 'bigint'
+        ? Hex.fromNumber(filters.remaining.max)
+        : null
+    result.remaining = remaining
+  }
+
+  if (filters.tick !== undefined) result.tick = filters.tick
+
+  return result
+}

package/src/ox/Pagination.test.ts

@@ -0,0 +1,162 @@
+import { Order, OrdersFilters, Pagination } from 'tempo.ts/ox'
+import { describe, expect, test } from 'vitest'
+
+describe('toRpcParameters', () => {
+  test('default', () => {
+    const params = Pagination.toRpcParameters(
+      {
+        cursor: '0x123',
+        limit: 50,
+        sort: {
+          on: 'orderId',
+          order: 'asc',
+        },
+        filters: {
+          baseToken: '0x20c0000000000000000000000000000000000001',
+          remaining: {
+            max: 1000n,
+          },
+        },
+      },
+      {
+        toRpcFilters: OrdersFilters.toRpc,
+      },
+    )
+
+    expect(params).toMatchInlineSnapshot(`
+      {
+        "cursor": "0x123",
+        "filters": {
+          "baseToken": "0x20c0000000000000000000000000000000000001",
+          "remaining": {
+            "max": "0x3e8",
+            "min": null,
+          },
+        },
+        "limit": 50,
+        "sort": {
+          "on": "orderId",
+          "order": "asc",
+        },
+      }
+    `)
+  })
+})
+
+describe('fromRpcResponse', () => {
+  test('default', () => {
+    const response = Pagination.fromRpcResponse(
+      {
+        nextCursor: '0x123',
+        orders: [
+          {
+            amount: '0x64',
+            baseToken: '0x20c0000000000000000000000000000000000001',
+            flipTick: 0,
+            isBid: true,
+            isFlip: false,
+            maker: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
+            next: '0x0',
+            orderId: '0x1',
+            quoteToken: '0x20c0000000000000000000000000000000000002',
+            prev: '0x0',
+            remaining: '0x64',
+            tick: 100,
+          },
+        ],
+      },
+      {
+        key: 'orders',
+        fromRpc: Order.fromRpc,
+      },
+    )
+
+    expect(response).toMatchInlineSnapshot(`
+      {
+        "nextCursor": "0x123",
+        "orders": [
+          {
+            "amount": 100n,
+            "baseToken": "0x20c0000000000000000000000000000000000001",
+            "flipTick": 0,
+            "isBid": true,
+            "isFlip": false,
+            "maker": "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb",
+            "next": 0n,
+            "orderId": 1n,
+            "prev": 0n,
+            "quoteToken": "0x20c0000000000000000000000000000000000002",
+            "remaining": 100n,
+            "tick": 100,
+          },
+        ],
+      }
+    `)
+  })
+
+  test('with multiple items', () => {
+    const response = Pagination.fromRpcResponse(
+      {
+        nextCursor: '0xabc',
+        orders: [
+          {
+            amount: '0x64',
+            baseToken: '0x20c0000000000000000000000000000000000001',
+            flipTick: 0,
+            isBid: true,
+            isFlip: false,
+            maker: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
+            next: '0x2',
+            orderId: '0x1',
+            quoteToken: '0x20c0000000000000000000000000000000000002',
+            prev: '0x0',
+            remaining: '0x64',
+            tick: 100,
+          },
+          {
+            amount: '0xc8',
+            baseToken: '0x20c0000000000000000000000000000000000001',
+            flipTick: 0,
+            isBid: false,
+            isFlip: false,
+            maker: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
+            next: '0x0',
+            orderId: '0x2',
+            quoteToken: '0x20c0000000000000000000000000000000000002',
+            prev: '0x1',
+            remaining: '0xc8',
+            tick: -100,
+          },
+        ],
+      },
+      {
+        key: 'orders',
+        fromRpc: Order.fromRpc,
+      },
+    )
+
+    expect(response.orders).toHaveLength(2)
+    expect(response.orders[0]?.orderId).toBe(1n)
+    expect(response.orders[1]?.orderId).toBe(2n)
+  })
+
+  test('with null nextCursor', () => {
+    const response = Pagination.fromRpcResponse(
+      {
+        nextCursor: null,
+        orders: [],
+      },
+      {
+        key: 'orders',
+        fromRpc: Order.fromRpc,
+      },
+    )
+
+    expect(response).toMatchInlineSnapshot(`
+      {
+        "nextCursor": null,
+        "orders": [],
+      }
+    `)
+  })
+})

package/src/ox/Pagination.ts

@@ -0,0 +1,164 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,35 @@
+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]>,
+    ]
+  : []

package/src/ox/SignatureEnvelope.ts

@@ -530,7 +530,9 @@ export function getType<
  * @returns The hex-encoded serialized signature.
  * @throws {CoercionError} If the envelope cannot be serialized.
  */
-export function serialize(envelope: SignatureEnvelope): Serialized {
+export function serialize(
+  envelope: PartialBy<SignatureEnvelope, 'prehash'>,
+): Serialized {
   const type = getType(envelope)
 
   // Backward compatibility: no type identifier for secp256k1

package/src/{viem → ox}/Tick.test.ts

@@ -1,5 +1,5 @@
+import { Tick } from 'tempo.ts/ox'
 import { describe, expect, test } from 'vitest'
-import * as Tick from './Tick.js'
 
 describe('toPrice', () => {
   test('converts tick 0 to price 1', () => {

package/src/{viem → ox}/Tick.ts

@@ -20,6 +20,11 @@ export const maxTick = 2000
  */
 export const priceScale = 100_000
 
+/**
+ * Tick type.
+ */
+export type Tick = number
+
 /**
  * Converts a tick to a price string.
  *

package/src/ox/Transaction.test.ts

@@ -124,7 +124,7 @@ describe('fromRpc', () => {
         ],
         "chainId": 1,
         "data": undefined,
-        "feePayer": "0xa5dd355188d0cd90324e13fc82ce7f3a2f3e44bc",
+        "feePayer": "0x697ac7512fe48fa16a7926f4647d9587f86997cd",
         "feePayerSignature": {
           "r": 8574245934337799659042750864278046211314109527666697413298781631396794530078n,
           "s": 22549658598721143185960614158212618570884225122794367192341714237232002247296n,

package/src/ox/Transaction.ts

@@ -193,7 +193,8 @@ export function fromRpc<
     transaction_.calls = transaction.calls.map((call) => ({
       to: call.to,
       value: call.value ? BigInt(call.value) : undefined,
-      data: call.input,
+      // @ts-expect-error
+      data: call.input || call.data || '0x',
     }))
   if (transaction.feeToken) transaction_.feeToken = transaction.feeToken
   if (transaction.nonceKey) transaction_.nonceKey = BigInt(transaction.nonceKey)