tempo.ts 0.1.5 → 0.2.1

package/src/viem/Actions/amm.ts

@@ -7,6 +7,7 @@ import {
   type GetEventArgs,
   type Hex,
   type Log,
+  type MulticallParameters,
   parseEventLogs,
   type ReadContractReturnType,
   type TransactionReceipt,
@@ -16,86 +17,20 @@ import {
   type WriteContractReturnType,
 } from 'viem'
 import {
+  multicall,
   readContract,
   watchContractEvent,
   writeContract,
   writeContractSync,
 } from 'viem/actions'
-import type { Compute, UnionOmit } from '../../internal/types.js'
+import type { Compute, OneOf, UnionOmit } from '../../internal/types.js'
+import * as PoolId from '../../ox/PoolId.js'
 import * as TokenId from '../../ox/TokenId.js'
 import * as Abis from '../Abis.js'
 import * as Addresses from '../Addresses.js'
 import type { ReadParameters, WriteParameters } from '../internal/types.js'
 import { defineCall } from '../internal/utils.js'
 
-/**
- * Gets the pool ID for a token pair.
- *
- * @example
- * ```ts
- * import { createClient, http } from 'viem'
- * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
- *
- * const client = createClient({
- *   chain: tempo,
- *   transport: http(),
- * })
- *
- * const poolId = await actions.amm.getPoolId(client, {
- *   userToken: '0x...',
- *   validatorToken: '0x...',
- * })
- * ```
- *
- * @param client - Client.
- * @param parameters - Parameters.
- * @returns The pool ID.
- */
-export async function getPoolId<chain extends Chain | undefined>(
-  client: Client<Transport, chain>,
-  parameters: getPoolId.Parameters,
-): Promise<getPoolId.ReturnValue> {
-  const { userToken, validatorToken, ...rest } = parameters
-  return readContract(client, {
-    ...rest,
-    ...getPoolId.call({ userToken, validatorToken }),
-  })
-}
-
-export namespace getPoolId {
-  export type Parameters = ReadParameters & Args
-
-  export type Args = {
-    /** Address or ID of the user token. */
-    userToken: TokenId.TokenIdOrAddress
-    /** Address or ID of the validator token. */
-    validatorToken: TokenId.TokenIdOrAddress
-  }
-
-  export type ReturnValue = ReadContractReturnType<
-    typeof Abis.feeAmm,
-    'getPoolId',
-    never
-  >
-
-  /**
-   * Defines a call to the `getPoolId` function.
-   *
-   * @param args - Arguments.
-   * @returns The call.
-   */
-  export function call(args: Args) {
-    const { userToken, validatorToken } = args
-    return defineCall({
-      address: Addresses.feeManager,
-      abi: Abis.feeAmm,
-      args: [TokenId.toAddress(userToken), TokenId.toAddress(validatorToken)],
-      functionName: 'getPoolId',
-    })
-  }
-}
-
 /**
  * Gets the reserves for a liquidity pool.
  *
@@ -103,14 +38,14 @@ export namespace getPoolId {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  *
  * const client = createClient({
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const pool = await actions.amm.getPool(client, {
+ * const pool = await Actions.amm.getPool(client, {
  *   userToken: '0x...',
  *   validatorToken: '0x...',
  * })
@@ -125,14 +60,25 @@ export async function getPool<chain extends Chain | undefined>(
   parameters: getPool.Parameters,
 ): Promise<getPool.ReturnValue> {
   const { userToken, validatorToken, ...rest } = parameters
-  return readContract(client, {
+  const [pool, totalSupply] = await multicall(client, {
     ...rest,
-    ...getPool.call({ userToken, validatorToken }),
+    contracts: getPool.calls({ userToken, validatorToken }),
+    allowFailure: false,
+    deployless: true,
   })
+  return {
+    reserveUserToken: pool.reserveUserToken,
+    reserveValidatorToken: pool.reserveValidatorToken,
+    totalSupply,
+  }
 }
 
 export namespace getPool {
-  export type Parameters = ReadParameters & Args
+  export type Parameters = UnionOmit<
+    MulticallParameters,
+    'allowFailure' | 'contracts' | 'deployless'
+  > &
+    Args
 
   export type Args = {
     /** Address or ID of the user token. */
@@ -146,90 +92,32 @@ export namespace getPool {
     reserveUserToken: bigint
     /** Reserve of validator token. */
     reserveValidatorToken: bigint
+    /** Total supply of LP tokens. */
+    totalSupply: bigint
   }>
 
   /**
-   * Defines a call to the `getPool` function.
+   * Defines calls to the `getPool` and `totalSupply` functions.
    *
    * @param args - Arguments.
-   * @returns The call.
+   * @returns The calls.
    */
-  export function call(args: Args) {
+  export function calls(args: Args) {
     const { userToken, validatorToken } = args
-    return defineCall({
-      address: Addresses.feeManager,
-      abi: Abis.feeAmm,
-      args: [TokenId.toAddress(userToken), TokenId.toAddress(validatorToken)],
-      functionName: 'getPool',
-    })
-  }
-}
-
-/**
- * Gets the total supply of LP tokens for a pool.
- *
- * @example
- * ```ts
- * import { createClient, http } from 'viem'
- * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
- *
- * const client = createClient({
- *   chain: tempo,
- *   transport: http(),
- * })
- *
- * const poolId = await actions.amm.getPoolId(client, {
- *   userToken: '0x...',
- *   validatorToken: '0x...',
- * })
- *
- * const totalSupply = await actions.amm.getTotalSupply(client, { poolId })
- * ```
- *
- * @param client - Client.
- * @param parameters - Parameters.
- * @returns The total supply of LP tokens.
- */
-export async function getTotalSupply<chain extends Chain | undefined>(
-  client: Client<Transport, chain>,
-  parameters: getTotalSupply.Parameters,
-): Promise<getTotalSupply.ReturnValue> {
-  const { poolId, ...rest } = parameters
-  return readContract(client, {
-    ...rest,
-    ...getTotalSupply.call({ poolId }),
-  })
-}
-
-export namespace getTotalSupply {
-  export type Parameters = ReadParameters & Args
-
-  export type Args = {
-    /** Pool ID. */
-    poolId: Hex
-  }
-
-  export type ReturnValue = ReadContractReturnType<
-    typeof Abis.feeAmm,
-    'totalSupply',
-    never
-  >
-
-  /**
-   * Defines a call to the `totalSupply` function.
-   *
-   * @param args - Arguments.
-   * @returns The call.
-   */
-  export function call(args: Args) {
-    const { poolId } = args
-    return defineCall({
-      address: Addresses.feeManager,
-      abi: Abis.feeAmm,
-      args: [poolId],
-      functionName: 'totalSupply',
-    })
+    return [
+      defineCall({
+        address: Addresses.feeManager,
+        abi: Abis.feeAmm,
+        args: [TokenId.toAddress(userToken), TokenId.toAddress(validatorToken)],
+        functionName: 'getPool',
+      }),
+      defineCall({
+        address: Addresses.feeManager,
+        abi: Abis.feeAmm,
+        args: [PoolId.from({ userToken, validatorToken })],
+        functionName: 'totalSupply',
+      }),
+    ] as const
   }
 }
 
@@ -240,19 +128,19 @@ export namespace getTotalSupply {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  *
  * const client = createClient({
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const poolId = await actions.amm.getPoolId(client, {
+ * const poolId = await Actions.amm.getPoolId(client, {
  *   userToken: '0x...',
  *   validatorToken: '0x...',
  * })
  *
- * const balance = await actions.amm.getLiquidityBalance(client, {
+ * const balance = await Actions.amm.getLiquidityBalance(client, {
  *   poolId,
  *   address: '0x...',
  * })
@@ -266,10 +154,15 @@ export async function getLiquidityBalance<chain extends Chain | undefined>(
   client: Client<Transport, chain>,
   parameters: getLiquidityBalance.Parameters,
 ): Promise<getLiquidityBalance.ReturnValue> {
-  const { address, poolId, ...rest } = parameters
+  const { address, poolId, userToken, validatorToken, ...rest } = parameters
   return readContract(client, {
     ...rest,
-    ...getLiquidityBalance.call({ address, poolId }),
+    ...getLiquidityBalance.call({
+      address,
+      poolId,
+      userToken,
+      validatorToken,
+    } as never),
   })
 }
 
@@ -279,9 +172,18 @@ export namespace getLiquidityBalance {
   export type Args = {
     /** Address to check balance for. */
     address: Address
-    /** Pool ID. */
-    poolId: Hex
-  }
+  } & OneOf<
+    | {
+        /** Pool ID. */
+        poolId: Hex
+      }
+    | {
+        /** User token. */
+        userToken: TokenId.TokenIdOrAddress
+        /** Validator token. */
+        validatorToken: TokenId.TokenIdOrAddress
+      }
+  >
 
   export type ReturnValue = ReadContractReturnType<
     typeof Abis.feeAmm,
@@ -296,7 +198,18 @@ export namespace getLiquidityBalance {
    * @returns The call.
    */
   export function call(args: Args) {
-    const { address, poolId } = args
+    const { address } = args
+    const poolId = (() => {
+      if ('poolId' in args && args.poolId) return args.poolId!
+      if ('userToken' in args && 'validatorToken' in args)
+        return PoolId.from({
+          userToken: args.userToken,
+          validatorToken: args.validatorToken,
+        })
+      throw new Error(
+        '`poolId`, or `userToken` and `validatorToken` must be provided.',
+      )
+    })()
     return defineCall({
       address: Addresses.feeManager,
       abi: Abis.feeAmm,
@@ -313,16 +226,16 @@ export namespace getLiquidityBalance {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const hash = await actions.amm.rebalanceSwap(client, {
+ * const hash = await Actions.amm.rebalanceSwap(client, {
  *   userToken: '0x...',
  *   validatorToken: '0x...',
  *   amountOut: 100n,
@@ -398,10 +311,10 @@ export namespace rebalanceSwap {
    * ```ts
    * import { createClient, http, walletActions } from 'viem'
    * import { tempo } from 'tempo.ts/chains'
-   * import * as actions from 'tempo.ts/viem/actions'
+   * import { Actions } from 'tempo.ts/viem'
    *
    * const client = createClient({
-   *   chain: tempo,
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
    *   transport: http(),
    * }).extend(walletActions)
    *
@@ -466,16 +379,16 @@ export namespace rebalanceSwap {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.amm.rebalanceSwapSync(client, {
+ * const result = await Actions.amm.rebalanceSwapSync(client, {
  *   userToken: '0x...',
  *   validatorToken: '0x...',
  *   amountOut: 100n,
@@ -533,16 +446,16 @@ export namespace rebalanceSwapSync {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const hash = await actions.amm.mint(client, {
+ * const hash = await Actions.amm.mint(client, {
  *   userToken: {
  *     address: '0x20c0...beef',
  *     amount: 100n,
@@ -583,7 +496,7 @@ export namespace mint {
       /** Address or ID of the user token. */
       address: TokenId.TokenIdOrAddress
       /** Amount of user token to add. */
-      amount: bigint
+      amount?: bigint | undefined
     }
     /** Validator token address and amount. */
     validatorToken: {
@@ -626,10 +539,10 @@ export namespace mint {
    * ```ts
    * import { createClient, http, walletActions } from 'viem'
    * import { tempo } from 'tempo.ts/chains'
-   * import * as actions from 'tempo.ts/viem/actions'
+   * import { Actions } from 'tempo.ts/viem'
    *
    * const client = createClient({
-   *   chain: tempo,
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
    *   transport: http(),
    * }).extend(walletActions)
    *
@@ -666,17 +579,32 @@ export namespace mint {
    */
   export function call(args: Args) {
     const { to, userToken, validatorToken } = args
+    const callArgs = (() => {
+      if (userToken.amount)
+        return {
+          functionName: 'mint',
+          args: [
+            TokenId.toAddress(userToken.address),
+            TokenId.toAddress(validatorToken.address),
+            userToken.amount,
+            validatorToken.amount,
+            to,
+          ],
+        } as const
+      return {
+        functionName: 'mintWithValidatorToken',
+        args: [
+          TokenId.toAddress(userToken.address),
+          TokenId.toAddress(validatorToken.address),
+          validatorToken.amount,
+          to,
+        ],
+      } as const
+    })()
     return defineCall({
       address: Addresses.feeManager,
       abi: Abis.feeAmm,
-      functionName: 'mint',
-      args: [
-        TokenId.toAddress(userToken.address),
-        TokenId.toAddress(validatorToken.address),
-        userToken.amount,
-        validatorToken.amount,
-        to,
-      ],
+      ...callArgs,
     })
   }
 
@@ -705,16 +633,16 @@ export namespace mint {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const hash = await actions.amm.mint(client, {
+ * const hash = await Actions.amm.mint(client, {
  *   userToken: {
  *     address: '0x20c0...beef',
  *     amount: 100n,
@@ -777,16 +705,16 @@ export namespace mintSync {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const hash = await actions.amm.burn(client, {
+ * const hash = await Actions.amm.burn(client, {
  *   userToken: '0x20c0...beef',
  *   validatorToken: '0x20c0...babe',
  *   liquidity: 50n,
@@ -857,10 +785,10 @@ export namespace burn {
    * ```ts
    * import { createClient, http, walletActions } from 'viem'
    * import { tempo } from 'tempo.ts/chains'
-   * import * as actions from 'tempo.ts/viem/actions'
+   * import { Actions } from 'tempo.ts/viem'
    *
    * const client = createClient({
-   *   chain: tempo,
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
    *   transport: http(),
    * }).extend(walletActions)
    *
@@ -925,16 +853,16 @@ export namespace burn {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  * import { privateKeyToAccount } from 'viem/accounts'
  *
  * const client = createClient({
  *   account: privateKeyToAccount('0x...'),
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
- * const result = await actions.amm.burnSync(client, {
+ * const result = await Actions.amm.burnSync(client, {
  *   userToken: '0x20c0...beef',
  *   validatorToken: '0x20c0...babe',
  *   liquidity: 50n,
@@ -992,10 +920,10 @@ export namespace burnSync {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  *
  * const client = createClient({
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
@@ -1072,10 +1000,10 @@ export declare namespace watchRebalanceSwap {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  *
  * const client = createClient({
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
@@ -1152,10 +1080,10 @@ export declare namespace watchFeeSwap {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  *
  * const client = createClient({
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *
@@ -1257,10 +1185,10 @@ export declare namespace watchMint {
  * ```ts
  * import { createClient, http } from 'viem'
  * import { tempo } from 'tempo.ts/chains'
- * import * as actions from 'tempo.ts/viem/actions'
+ * import { Actions } from 'tempo.ts/viem'
  *
  * const client = createClient({
- *   chain: tempo,
+ *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
  *   transport: http(),
  * })
  *