tempo.ts 0.0.6 → 0.1.0

package/src/viem/{decorator.ts → Decorator.ts}

@@ -1,8 +1,9 @@
 import type { Account, Chain, Client, Transport } from 'viem'
-import * as ammActions from './actions/amm.js'
-import * as feeActions from './actions/fee.js'
-import * as policyActions from './actions/policy.js'
-import * as tokenActions from './actions/token.js'
+import * as ammActions from './Actions/amm.js'
+import * as dexActions from './Actions/dex.js'
+import * as feeActions from './Actions/fee.js'
+import * as policyActions from './Actions/policy.js'
+import * as tokenActions from './Actions/token.js'
 
 export type Decorator<
   chain extends Chain | undefined = Chain | undefined,
@@ -349,6 +350,553 @@ export type Decorator<
      */
     watchBurn: (parameters: ammActions.watchBurn.Parameters) => () => void
   }
+  dex: {
+    /**
+     * Buys a specific amount of tokens.
+     *
+     * @example
+     * ```ts
+     * import { createTempoClient } from 'tempo.ts/viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     *
+     * const client = createTempoClient({
+     *   account: privateKeyToAccount('0x...')
+     * })
+     *
+     * const hash = await client.dex.buy({
+     *   tokenIn: '0x20c...11',
+     *   tokenOut: '0x20c...20',
+     *   amountOut: 100n,
+     *   maxAmountIn: 105n,
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction hash.
+     */
+    buy: (
+      parameters: dexActions.buy.Parameters<chain, account>,
+    ) => Promise<dexActions.buy.ReturnValue>
+    /**
+     * Buys a specific amount of tokens.
+     *
+     * @example
+     * ```ts
+     * import { createTempoClient } from 'tempo.ts/viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     *
+     * const client = createTempoClient({
+     *   account: privateKeyToAccount('0x...')
+     * })
+     *
+     * const result = await client.dex.buySync({
+     *   tokenIn: '0x20c...11',
+     *   tokenOut: '0x20c...20',
+     *   amountOut: 100n,
+     *   maxAmountIn: 105n,
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction receipt.
+     */
+    buySync: (
+      parameters: dexActions.buySync.Parameters<chain, account>,
+    ) => Promise<dexActions.buySync.ReturnValue>
+    /**
+     * Cancels an order from the orderbook.
+     *
+     * @example
+     * ```ts
+     * import { createTempoClient } from 'tempo.ts/viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     *
+     * const client = createTempoClient({
+     *   account: privateKeyToAccount('0x...')
+     * })
+     *
+     * const hash = await client.dex.cancel({
+     *   orderId: 123n,
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction hash.
+     */
+    cancel: (
+      parameters: dexActions.cancel.Parameters<chain, account>,
+    ) => Promise<dexActions.cancel.ReturnValue>
+    /**
+     * Cancels an order from the orderbook.
+     *
+     * @example
+     * ```ts
+     * import { createTempoClient } from 'tempo.ts/viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     *
+     * const client = createTempoClient({
+     *   account: privateKeyToAccount('0x...')
+     * })
+     *
+     * const result = await client.dex.cancelSync({
+     *   orderId: 123n,
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction receipt and event data.
+     */
+    cancelSync: (
+      parameters: dexActions.cancelSync.Parameters<chain, account>,
+    ) => Promise<dexActions.cancelSync.ReturnValue>
+    /**
+     * Creates a new trading pair on the DEX.
+     *
+     * @example
+     * ```ts
+     * import { createTempoClient } from 'tempo.ts/viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     *
+     * const client = createTempoClient({
+     *   account: privateKeyToAccount('0x...')
+     * })
+     *
+     * const hash = await client.dex.createPair({
+     *   base: '0x20c...11',
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction hash.
+     */
+    createPair: (
+      parameters: dexActions.createPair.Parameters<chain, account>,
+    ) => Promise<dexActions.createPair.ReturnValue>
+    /**
+     * Creates a new trading pair on the DEX.
+     *
+     * @example
+     * ```ts
+     * import { createTempoClient } from 'tempo.ts/viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     *
+     * const client = createTempoClient({
+     *   account: privateKeyToAccount('0x...')
+     * })
+     *
+     * const result = await client.dex.createPairSync({
+     *   base: '0x20c...11',
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction receipt and event data.
+     */
+    createPairSync: (
+      parameters: dexActions.createPairSync.Parameters<chain, account>,
+    ) => Promise<dexActions.createPairSync.ReturnValue>
+    /**
+     * Gets a user's token balance on the DEX.
+     *
+     * @example
+     * ```ts
+     * import { createTempoClient } from 'tempo.ts/viem'
+     *
+     * const client = createTempoClient()
+     *
+     * const balance = await client.dex.getBalance({
+     *   account: '0x...',
+     *   token: '0x20c...11',
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The user's token balance on the DEX.
+     */
+    getBalance: (
+      parameters: dexActions.getBalance.Parameters<account>,
+    ) => Promise<dexActions.getBalance.ReturnValue>
+    /**
+     * Gets the quote for buying a specific amount of tokens.
+     *
+     * @example
+     * ```ts
+     * import { createTempoClient } from 'tempo.ts/viem'
+     *
+     * const client = createTempoClient()
+     *
+     * const amountIn = await client.dex.getBuyQuote({
+     *   tokenIn: '0x20c...11',
+     *   tokenOut: '0x20c...20',
+     *   amountOut: 100n,
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The amount of tokenIn needed to buy the specified amountOut.
+     */
+    getBuyQuote: (
+      parameters: dexActions.getBuyQuote.Parameters,
+    ) => Promise<dexActions.getBuyQuote.ReturnValue>
+    /**
+     * Gets an order's details from the orderbook.
+     *
+     * @example
+     * ```ts
+     * import { createTempoClient } from 'tempo.ts/viem'
+     *
+     * const client = createTempoClient()
+     *
+     * const order = await client.dex.getOrder({
+     *   orderId: 123n,
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The order details.
+     */
+    getOrder: (
+      parameters: dexActions.getOrder.Parameters,
+    ) => Promise<dexActions.getOrder.ReturnValue>
+    /**
+     * Gets the price level information at a specific tick.
+     *
+     * @example
+     * ```ts
+     * import { createTempoClient, Tick } from 'tempo.ts/viem'
+     *
+     * const client = createTempoClient()
+     *
+     * const level = await client.dex.getPriceLevel({
+     *   base: '0x20c...11',
+     *   tick: Tick.fromPrice('1.001'),
+     *   isBid: true,
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The price level information.
+     */
+    getPriceLevel: (
+      parameters: dexActions.getPriceLevel.Parameters,
+    ) => Promise<dexActions.getPriceLevel.ReturnValue>
+    /**
+     * Gets the quote for selling a specific amount of tokens.
+     *
+     * @example
+     * ```ts
+     * import { createTempoClient } from 'tempo.ts/viem'
+     *
+     * const client = createTempoClient()
+     *
+     * const amountOut = await client.dex.getSellQuote({
+     *   tokenIn: '0x20c...11',
+     *   tokenOut: '0x20c...20',
+     *   amountIn: 100n,
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The amount of tokenOut received for selling the specified amountIn.
+     */
+    getSellQuote: (
+      parameters: dexActions.getSellQuote.Parameters,
+    ) => Promise<dexActions.getSellQuote.ReturnValue>
+    /**
+     * Places a limit order on the orderbook.
+     *
+     * @example
+     * ```ts
+     * import { createTempoClient, Tick } from 'tempo.ts/viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     *
+     * const client = createTempoClient({
+     *   account: privateKeyToAccount('0x...')
+     * })
+     *
+     * const hash = await client.dex.place({
+     *   token: '0x20c...11',
+     *   amount: 100n,
+     *   type: 'buy',
+     *   tick: Tick.fromPrice('0.99'),
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction hash.
+     */
+    place: (
+      parameters: dexActions.place.Parameters<chain, account>,
+    ) => Promise<dexActions.place.ReturnValue>
+    /**
+     * Places a limit order on the orderbook.
+     *
+     * @example
+     * ```ts
+     * import { createTempoClient, Tick } from 'tempo.ts/viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     *
+     * const client = createTempoClient({
+     *   account: privateKeyToAccount('0x...')
+     * })
+     *
+     * const result = await client.dex.placeSync({
+     *   token: '0x20c...11',
+     *   amount: 100n,
+     *   type: 'buy',
+     *   tick: Tick.fromPrice('0.99'),
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction receipt and event data.
+     */
+    placeSync: (
+      parameters: dexActions.placeSync.Parameters<chain, account>,
+    ) => Promise<dexActions.placeSync.ReturnValue>
+    /**
+     * Places a flip order that automatically flips when filled.
+     *
+     * @example
+     * ```ts
+     * import { createTempoClient, Tick } from 'tempo.ts/viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     *
+     * const client = createTempoClient({
+     *   account: privateKeyToAccount('0x...')
+     * })
+     *
+     * const hash = await client.dex.placeFlip({
+     *   token: '0x20c...11',
+     *   amount: 100n,
+     *   type: 'buy',
+     *   tick: Tick.fromPrice('0.99'),
+     *   flipTick: Tick.fromPrice('1.01'),
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction hash.
+     */
+    placeFlip: (
+      parameters: dexActions.placeFlip.Parameters<chain, account>,
+    ) => Promise<dexActions.placeFlip.ReturnValue>
+    /**
+     * Places a flip order that automatically flips when filled.
+     *
+     * @example
+     * ```ts
+     * import { createTempoClient, Tick } from 'tempo.ts/viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     *
+     * const client = createTempoClient({
+     *   account: privateKeyToAccount('0x...')
+     * })
+     *
+     * const result = await client.dex.placeFlipSync({
+     *   token: '0x20c...11',
+     *   amount: 100n,
+     *   type: 'buy',
+     *   tick: Tick.fromPrice('0.99'),
+     *   flipTick: Tick.fromPrice('1.01'),
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction receipt and event data.
+     */
+    placeFlipSync: (
+      parameters: dexActions.placeFlipSync.Parameters<chain, account>,
+    ) => Promise<dexActions.placeFlipSync.ReturnValue>
+    /**
+     * Sells a specific amount of tokens.
+     *
+     * @example
+     * ```ts
+     * import { createTempoClient } from 'tempo.ts/viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     *
+     * const client = createTempoClient({
+     *   account: privateKeyToAccount('0x...')
+     * })
+     *
+     * const hash = await client.dex.sell({
+     *   tokenIn: '0x20c...11',
+     *   tokenOut: '0x20c...20',
+     *   amountIn: 100n,
+     *   minAmountOut: 95n,
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction hash.
+     */
+    sell: (
+      parameters: dexActions.sell.Parameters<chain, account>,
+    ) => Promise<dexActions.sell.ReturnValue>
+    /**
+     * Sells a specific amount of tokens.
+     *
+     * @example
+     * ```ts
+     * import { createTempoClient } from 'tempo.ts/viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     *
+     * const client = createTempoClient({
+     *   account: privateKeyToAccount('0x...')
+     * })
+     *
+     * const result = await client.dex.sellSync({
+     *   tokenIn: '0x20c...11',
+     *   tokenOut: '0x20c...20',
+     *   amountIn: 100n,
+     *   minAmountOut: 95n,
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction receipt.
+     */
+    sellSync: (
+      parameters: dexActions.sellSync.Parameters<chain, account>,
+    ) => Promise<dexActions.sellSync.ReturnValue>
+    /**
+     * Withdraws tokens from the DEX to the caller's wallet.
+     *
+     * @example
+     * ```ts
+     * import { createTempoClient } from 'tempo.ts/viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     *
+     * const client = createTempoClient({
+     *   account: privateKeyToAccount('0x...')
+     * })
+     *
+     * const hash = await client.dex.withdraw({
+     *   token: '0x20c...11',
+     *   amount: 100n,
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction hash.
+     */
+    withdraw: (
+      parameters: dexActions.withdraw.Parameters<chain, account>,
+    ) => Promise<dexActions.withdraw.ReturnValue>
+    /**
+     * Withdraws tokens from the DEX to the caller's wallet.
+     *
+     * @example
+     * ```ts
+     * import { createTempoClient } from 'tempo.ts/viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     *
+     * const client = createTempoClient({
+     *   account: privateKeyToAccount('0x...')
+     * })
+     *
+     * const result = await client.dex.withdrawSync({
+     *   token: '0x20c...11',
+     *   amount: 100n,
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The transaction receipt.
+     */
+    withdrawSync: (
+      parameters: dexActions.withdrawSync.Parameters<chain, account>,
+    ) => Promise<dexActions.withdrawSync.ReturnValue>
+    /**
+     * Watches for flip order placed events.
+     *
+     * @example
+     * ```ts
+     * import { createTempoClient } from 'tempo.ts/viem'
+     *
+     * const client = createTempoClient()
+     *
+     * const unwatch = client.dex.watchFlipOrderPlaced({
+     *   onFlipOrderPlaced: (args, log) => {
+     *     console.log('Flip order placed:', args)
+     *   },
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns A function to unsubscribe from the event.
+     */
+    watchFlipOrderPlaced: (
+      parameters: dexActions.watchFlipOrderPlaced.Parameters,
+    ) => () => void
+    /**
+     * Watches for order cancelled events.
+     *
+     * @example
+     * ```ts
+     * import { createTempoClient } from 'tempo.ts/viem'
+     *
+     * const client = createTempoClient()
+     *
+     * const unwatch = client.dex.watchOrderCancelled({
+     *   onOrderCancelled: (args, log) => {
+     *     console.log('Order cancelled:', args)
+     *   },
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns A function to unsubscribe from the event.
+     */
+    watchOrderCancelled: (
+      parameters: dexActions.watchOrderCancelled.Parameters,
+    ) => () => void
+    /**
+     * Watches for order filled events.
+     *
+     * @example
+     * ```ts
+     * import { createTempoClient } from 'tempo.ts/viem'
+     *
+     * const client = createTempoClient()
+     *
+     * const unwatch = client.dex.watchOrderFilled({
+     *   onOrderFilled: (args, log) => {
+     *     console.log('Order filled:', args)
+     *   },
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns A function to unsubscribe from the event.
+     */
+    watchOrderFilled: (
+      parameters: dexActions.watchOrderFilled.Parameters,
+    ) => () => void
+    /**
+     * Watches for order placed events.
+     *
+     * @example
+     * ```ts
+     * import { createTempoClient } from 'tempo.ts/viem'
+     *
+     * const client = createTempoClient()
+     *
+     * const unwatch = client.dex.watchOrderPlaced({
+     *   onOrderPlaced: (args, log) => {
+     *     console.log('Order placed:', args)
+     *   },
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns A function to unsubscribe from the event.
+     */
+    watchOrderPlaced: (
+      parameters: dexActions.watchOrderPlaced.Parameters,
+    ) => () => void
+  }
   fee: {
     /**
      * Gets the user's default fee token.
@@ -1830,6 +2378,40 @@ export function decorator() {
         watchMint: (parameters) => ammActions.watchMint(client, parameters),
         watchBurn: (parameters) => ammActions.watchBurn(client, parameters),
       },
+      dex: {
+        buy: (parameters) => dexActions.buy(client, parameters),
+        buySync: (parameters) => dexActions.buySync(client, parameters),
+        cancel: (parameters) => dexActions.cancel(client, parameters),
+        cancelSync: (parameters) => dexActions.cancelSync(client, parameters),
+        createPair: (parameters) => dexActions.createPair(client, parameters),
+        createPairSync: (parameters) =>
+          dexActions.createPairSync(client, parameters),
+        getBalance: (parameters) => dexActions.getBalance(client, parameters),
+        getBuyQuote: (parameters) => dexActions.getBuyQuote(client, parameters),
+        getOrder: (parameters) => dexActions.getOrder(client, parameters),
+        getPriceLevel: (parameters) =>
+          dexActions.getPriceLevel(client, parameters),
+        getSellQuote: (parameters) =>
+          dexActions.getSellQuote(client, parameters),
+        place: (parameters) => dexActions.place(client, parameters),
+        placeSync: (parameters) => dexActions.placeSync(client, parameters),
+        placeFlip: (parameters) => dexActions.placeFlip(client, parameters),
+        placeFlipSync: (parameters) =>
+          dexActions.placeFlipSync(client, parameters),
+        sell: (parameters) => dexActions.sell(client, parameters),
+        sellSync: (parameters) => dexActions.sellSync(client, parameters),
+        withdraw: (parameters) => dexActions.withdraw(client, parameters),
+        withdrawSync: (parameters) =>
+          dexActions.withdrawSync(client, parameters),
+        watchFlipOrderPlaced: (parameters) =>
+          dexActions.watchFlipOrderPlaced(client, parameters),
+        watchOrderCancelled: (parameters) =>
+          dexActions.watchOrderCancelled(client, parameters),
+        watchOrderFilled: (parameters) =>
+          dexActions.watchOrderFilled(client, parameters),
+        watchOrderPlaced: (parameters) =>
+          dexActions.watchOrderPlaced(client, parameters),
+      },
       fee: {
         // @ts-expect-error
         getUserToken: (parameters) =>

package/src/viem/{formatters.ts → Formatters.ts}

@@ -7,30 +7,30 @@ import { parseAccount } from 'viem/accounts'
 import * as ox_Transaction from '../ox/Transaction.js'
 import * as ox_TransactionRequest from '../ox/TransactionRequest.js'
 import {
-  isTempoTransaction,
+  isTempo,
   type Transaction,
   type TransactionRequest,
-  type TransactionRequestFeeToken,
+  type TransactionRequestAA,
   type TransactionRequestRpc,
   type TransactionRpc,
-} from './transaction.js'
+} from './Transaction.js'
 
 export const formatTransaction = (
   transaction: TransactionRpc,
 ): Transaction<bigint, number, boolean> => {
-  if (!isTempoTransaction(transaction))
-    return viem_formatTransaction(transaction as never)
+  if (!isTempo(transaction)) return viem_formatTransaction(transaction as never)
 
   const {
     feePayerSignature,
     gasPrice: _,
     nonce,
     ...tx
-  } = ox_Transaction.fromRpc(transaction as never) as ox_Transaction.FeeToken
+  } = ox_Transaction.fromRpc(transaction as never) as ox_Transaction.AA
+
   return {
     ...tx,
     accessList: tx.accessList!,
-    authorizationList: tx.authorizationList!.map((auth) => ({
+    authorizationList: tx.authorizationList?.map((auth) => ({
       ...auth,
       nonce: Number(auth.nonce),
       r: Hex.fromNumber(auth.r, { size: 32 }),
@@ -49,10 +49,7 @@ export const formatTransaction = (
       ox_Transaction.toRpcType[
         tx.type as keyof typeof ox_Transaction.toRpcType
       ],
-    type: tx.type as 'feeToken',
-    r: Hex.fromNumber(tx.r, { size: 32 }),
-    s: Hex.fromNumber(tx.s, { size: 32 }),
-    v: BigInt(tx.v ?? 27),
+    type: tx.type as 'aa',
   }
 }
 
@@ -60,14 +57,23 @@ export const formatTransactionRequest = (
   r: TransactionRequest,
   action?: string | undefined,
 ): TransactionRequestRpc => {
-  const request = r as TransactionRequestFeeToken
+  const request = r as TransactionRequestAA
 
-  if (!isTempoTransaction(request))
+  if (!isTempo(request))
     return viem_formatTransactionRequest(
       r as never,
       action,
     ) as TransactionRequestRpc
 
+  if (action)
+    request.calls = request.calls ?? [
+      {
+        to: r.to || undefined,
+        value: r.value,
+        data: r.data,
+      },
+    ]
+
   const rpc = ox_TransactionRequest.toRpc({
     ...request,
     authorizationList: request.authorizationList?.map((auth) => ({
@@ -78,8 +84,19 @@ export const formatTransactionRequest = (
       yParity: Number(auth.yParity),
     })),
     nonce: request.nonce ? BigInt(request.nonce) : undefined,
-    type: 'feeToken',
+    type: 'aa',
   })
+
+  if (action === 'estimateGas') {
+    rpc.maxFeePerGas = undefined
+    rpc.maxPriorityFeePerGas = undefined
+  }
+
+  // We rely on `calls` for AA transactions.
+  rpc.to = undefined
+  rpc.data = undefined
+  rpc.value = undefined
+
   return {
     ...rpc,
     ...(request.feePayer
@@ -90,11 +107,5 @@ export const formatTransactionRequest = (
               : request.feePayer,
         }
       : {}),
-    ...(action === 'estimateGas'
-      ? {
-          maxFeePerGas: undefined,
-          maxPriorityFeePerGas: undefined,
-        }
-      : {}),
   } as never
 }