tempo.ts 0.6.2 → 0.7.1

package/src/viem/Actions/amm.ts

@@ -491,20 +491,12 @@ export namespace mint {
   export type Args = {
     /** Address to mint LP tokens to. */
     to: Address
-    /** User token address and amount. */
-    userToken: {
-      /** Address or ID of the user token. */
-      address: TokenId.TokenIdOrAddress
-      /** Amount of user token to add. */
-      amount?: bigint | undefined
-    }
-    /** Validator token address and amount. */
-    validatorToken: {
-      /** Address or ID of the validator token. */
-      address: TokenId.TokenIdOrAddress
-      /** Amount of validator token to add. */
-      amount: bigint
-    }
+    /** User token address. */
+    userTokenAddress: TokenId.TokenIdOrAddress
+    /** Validator token address. */
+    validatorTokenAddress: TokenId.TokenIdOrAddress
+    /** Amount of validator token to add. */
+    validatorTokenAmount: bigint
   }
 
   export type ReturnValue = WriteContractReturnType
@@ -519,8 +511,19 @@ export namespace mint {
     client: Client<Transport, chain, account>,
     parameters: mint.Parameters<chain, account>,
   ): Promise<ReturnType<action>> {
-    const { to, userToken, validatorToken, ...rest } = parameters
-    const call = mint.call({ to, userToken, validatorToken })
+    const {
+      to,
+      userTokenAddress,
+      validatorTokenAddress,
+      validatorTokenAmount,
+      ...rest
+    } = parameters
+    const call = mint.call({
+      to,
+      userTokenAddress,
+      validatorTokenAddress,
+      validatorTokenAmount,
+    })
     return (await action(client, {
       ...rest,
       ...call,
@@ -578,33 +581,22 @@ export namespace mint {
    * @returns The call.
    */
   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
-    })()
+    const {
+      to,
+      userTokenAddress,
+      validatorTokenAddress,
+      validatorTokenAmount,
+    } = args
     return defineCall({
       address: Addresses.feeManager,
       abi: Abis.feeAmm,
-      ...callArgs,
+      functionName: 'mintWithValidatorToken',
+      args: [
+        TokenId.toAddress(userTokenAddress),
+        TokenId.toAddress(validatorTokenAddress),
+        validatorTokenAmount,
+        to,
+      ],
     })
   }
 

package/src/viem/Actions/reward.test.ts

@@ -1,44 +1,11 @@
-import { parseEther, parseUnits } from 'viem'
+import { parseUnits } from 'viem'
 import { describe, expect, test } from 'vitest'
 import { clientWithAccount, setupToken } from '../../../test/viem/config.js'
 import * as actions from './index.js'
 
 const account = clientWithAccount.account
 
-describe('cancelSync', () => {
-  test('default', async () => {
-    const { token } = await setupToken(clientWithAccount)
-
-    // Start a reward stream with longer duration
-    const rewardAmount = parseUnits('100', 6)
-    const { id: streamId } = await actions.reward.startSync(clientWithAccount, {
-      amount: rewardAmount,
-      seconds: 3600, // 1 hour to avoid stream ending during test
-      token,
-    })
-
-    // Cancel the reward
-    const { receipt, refund, ...result } = await actions.reward.cancelSync(
-      clientWithAccount,
-      {
-        id: streamId,
-        token,
-      },
-    )
-
-    expect(refund).toBeGreaterThan(0n)
-    expect(receipt).toBeDefined()
-    expect(result).toMatchInlineSnapshot(`
-      {
-        "funder": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-        "id": 1n,
-      }
-    `)
-  })
-})
-
-// TODO: unskip
-describe.skip('claimSync', () => {
+describe('claimSync', () => {
   test('default', async () => {
     const { token } = await setupToken(clientWithAccount)
 
@@ -63,7 +30,6 @@ describe.skip('claimSync', () => {
     // Start immediate reward to distribute rewards
     await actions.reward.startSync(clientWithAccount, {
       amount: rewardAmount,
-      seconds: 0,
       token,
     })
 
@@ -120,7 +86,6 @@ describe.skip('claimSync', () => {
     // Start a streaming reward (not immediate)
     await actions.reward.startSync(clientWithAccount, {
       amount: rewardAmount,
-      seconds: 10,
       token,
     })
 
@@ -146,73 +111,6 @@ describe.skip('claimSync', () => {
   })
 })
 
-describe('getStream', () => {
-  test('default', async () => {
-    const { token } = await setupToken(clientWithAccount)
-
-    // Start a reward stream
-    const rewardAmount = parseUnits('100', 6)
-    const duration = 10
-    const { id: streamId } = await actions.reward.startSync(clientWithAccount, {
-      amount: rewardAmount,
-      seconds: duration,
-      token,
-    })
-
-    // Get the stream
-    const { endTime, startTime, ...stream } = await actions.reward.getStream(
-      clientWithAccount,
-      {
-        id: streamId,
-        token,
-      },
-    )
-
-    expect(startTime).toBeGreaterThan(0)
-    expect(endTime).toBeGreaterThan(startTime)
-    expect(stream).toMatchInlineSnapshot(`
-      {
-        "amountTotal": 100000000n,
-        "funder": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-        "ratePerSecondScaled": 10000000000000000000000000n,
-      }
-    `)
-  })
-
-  test('behavior: canceled stream has zero funder', async () => {
-    const { token } = await setupToken(clientWithAccount)
-
-    // Start and cancel a reward stream
-    const rewardAmount = parseUnits('100', 6)
-    const { id: streamId } = await actions.reward.startSync(clientWithAccount, {
-      amount: rewardAmount,
-      seconds: 3600, // 1 hour to avoid stream ending during test
-      token,
-    })
-
-    await actions.reward.cancelSync(clientWithAccount, {
-      id: streamId,
-      token,
-    })
-
-    // Get the canceled stream
-    const stream = await actions.reward.getStream(clientWithAccount, {
-      id: streamId,
-      token,
-    })
-
-    expect(stream).toMatchInlineSnapshot(`
-      {
-        "amountTotal": 0n,
-        "endTime": 0n,
-        "funder": "0x0000000000000000000000000000000000000000",
-        "ratePerSecondScaled": 0n,
-        "startTime": 0n,
-      }
-    `)
-  })
-})
-
 describe('getTotalPerSecond', () => {
   test('default', async () => {
     const { token } = await setupToken(clientWithAccount)
@@ -223,29 +121,6 @@ describe('getTotalPerSecond', () => {
 
     expect(rate).toBe(0n)
   })
-
-  test('behavior: increases after starting stream', async () => {
-    const { token } = await setupToken(clientWithAccount)
-
-    // Start a reward stream
-    const rewardAmount = parseUnits('100', 6)
-    const duration = 100
-    await actions.reward.startSync(clientWithAccount, {
-      amount: rewardAmount,
-      seconds: duration,
-      token,
-    })
-
-    // Check total reward per second
-    const rate = await actions.reward.getTotalPerSecond(clientWithAccount, {
-      token,
-    })
-
-    // Expected rate = (amount * ACC_PRECISION) / seconds
-    // ACC_PRECISION = 1e18
-    const expectedRate = (rewardAmount * parseEther('1')) / BigInt(duration)
-    expect(rate).toBe(expectedRate)
-  })
 })
 
 describe('setRecipientSync', () => {
@@ -288,88 +163,7 @@ describe('setRecipientSync', () => {
 })
 
 describe('startSync', () => {
-  test('default', async () => {
-    const { token } = await setupToken(clientWithAccount)
-
-    // Start a reward stream
-    const duration = 10
-    const rewardAmount = parseUnits('100', 6)
-    const { id, receipt, ...result } = await actions.reward.startSync(
-      clientWithAccount,
-      {
-        amount: rewardAmount,
-        seconds: duration,
-        token,
-      },
-    )
-
-    expect(receipt).toBeDefined()
-    expect(result).toMatchInlineSnapshot(`
-      {
-        "amount": 100000000n,
-        "durationSeconds": 10,
-        "funder": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-      }
-    `)
-
-    // Verify the stream was created
-    const { endTime, startTime, ...stream } = await actions.reward.getStream(
-      clientWithAccount,
-      {
-        id,
-        token,
-      },
-    )
-
-    expect(startTime).toBeGreaterThan(0)
-    expect(endTime).toBeGreaterThan(startTime)
-    expect(stream).toMatchInlineSnapshot(`
-      {
-        "amountTotal": 100000000n,
-        "funder": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-        "ratePerSecondScaled": 10000000000000000000000000n,
-      }
-    `)
-
-    // Verify total reward per second
-    const totalRate = await actions.reward.getTotalPerSecond(
-      clientWithAccount,
-      {
-        token,
-      },
-    )
-    const expectedRate = (rewardAmount * parseEther('1')) / BigInt(duration)
-    expect(totalRate).toBe(expectedRate)
-  })
-
-  test('behavior: streaming distribution', async () => {
-    const { token } = await setupToken(clientWithAccount)
-
-    // Start a streaming reward
-    const duration = 3600
-    const rewardAmount = parseUnits('100', 6)
-    const { id } = await actions.reward.startSync(clientWithAccount, {
-      amount: rewardAmount,
-      seconds: duration,
-      token,
-    })
-
-    expect(id).toBeGreaterThan(0n) // Streaming distributions return ID > 0
-
-    // Verify the stream was created with correct rate
-    const totalRate = await actions.reward.getTotalPerSecond(
-      clientWithAccount,
-      {
-        token,
-      },
-    )
-
-    const expectedRate = (rewardAmount * parseEther('1')) / BigInt(duration)
-    expect(totalRate).toBe(expectedRate)
-  })
-
-  // TODO: unskip
-  test.skip('behavior: immediate distribution (seconds = 0)', async () => {
+  test('behavior: immediate distribution (seconds = 0)', async () => {
     const { token } = await setupToken(clientWithAccount)
 
     // Opt in to rewards
@@ -393,10 +187,9 @@ describe('startSync', () => {
       token,
     })
 
-    // Start immediate reward (seconds = 0)
+    // Start immediate reward
     const { id } = await actions.reward.startSync(clientWithAccount, {
       amount: rewardAmount,
-      seconds: 0,
       token,
     })
 
@@ -454,7 +247,6 @@ describe('startSync', () => {
     const { amount, durationSeconds, funder, id } =
       await actions.reward.startSync(clientWithAccount, {
         amount: rewardAmount,
-        seconds: 0,
         token,
       })
 

package/src/viem/Actions/reward.ts

@@ -15,215 +15,6 @@ import * as Abis from '../Abis.js'
 import type { ReadParameters, WriteParameters } from '../internal/types.js'
 import { defineCall } from '../internal/utils.js'
 
-/**
- * Cancels an active reward stream and refunds remaining tokens.
- *
- * - Callable only by the stream's funder.
- * - Stops future emission for the stream at the current block timestamp.
- * - Computes the refund as `amountTotal - distributedSoFar` and attempts to transfer it back to the funder.
- * - If the refund transfer is forbidden by TIP-403, the stream is still canceled but `refund` will be 0 in the event.
- * - Reverts with `StreamInactive` if the stream doesn't exist, is already canceled, or has already ended.
- * - Reverts with `NotStreamFunder` if the caller is not the stream's funder.
- *
- * @example
- * ```ts
- * import { createClient, http } from 'viem'
- * import { tempo } from 'tempo.ts/chains'
- * import { Actions } from 'tempo.ts/viem'
- * import { privateKeyToAccount } from 'viem/accounts'
- *
- * const client = createClient({
- *   account: privateKeyToAccount('0x...'),
- *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
- *   transport: http(),
- * })
- *
- * const hash = await Actions.rewards.cancel(client, {
- *   id: 1n,
- *   token: '0x20c0000000000000000000000000000000000001',
- * })
- * ```
- *
- * @param client - Client.
- * @param parameters - Parameters.
- * @returns The transaction hash.
- */
-export async function cancel<
-  chain extends Chain | undefined,
-  account extends Account | undefined,
->(
-  client: Client<Transport, chain, account>,
-  parameters: cancel.Parameters<chain, account>,
-): Promise<cancel.ReturnValue> {
-  return cancel.inner(writeContract, client, parameters)
-}
-
-/**
- * Cancels an active reward stream and waits for confirmation.
- *
- * - Callable only by the stream's funder.
- * - Stops future emission for the stream at the current block timestamp.
- * - Computes the refund as `amountTotal - distributedSoFar` and attempts to transfer it back to the funder.
- * - If the refund transfer is forbidden by TIP-403, the stream is still canceled but `refund` will be 0.
- * - Reverts with `StreamInactive` if the stream doesn't exist, is already canceled, or has already ended.
- * - Reverts with `NotStreamFunder` if the caller is not the stream's funder.
- *
- * @example
- * ```ts
- * import { createClient, http } from 'viem'
- * import { tempo } from 'tempo.ts/chains'
- * import { Actions } from 'tempo.ts/viem'
- * import { privateKeyToAccount } from 'viem/accounts'
- *
- * const client = createClient({
- *   account: privateKeyToAccount('0x...'),
- *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
- *   transport: http(),
- * })
- *
- * const { funder, id, refund, receipt } = await Actions.rewards.cancelSync(client, {
- *   id: 1n,
- *   token: '0x20c0000000000000000000000000000000000001',
- * })
- * ```
- *
- * @param client - Client.
- * @param parameters - Parameters.
- * @returns The funder, stream ID, refund amount, and transaction receipt.
- */
-export async function cancelSync<
-  chain extends Chain | undefined,
-  account extends Account | undefined,
->(
-  client: Client<Transport, chain, account>,
-  parameters: cancelSync.Parameters<chain, account>,
-): Promise<cancelSync.ReturnValue> {
-  const { throwOnReceiptRevert = true, ...rest } = parameters
-  const receipt = await cancel.inner(writeContractSync, client, {
-    ...rest,
-    throwOnReceiptRevert,
-  } as never)
-  const { args } = cancel.extractEvent(receipt.logs)
-  return {
-    ...args,
-    receipt,
-  } as never
-}
-
-export namespace cancel {
-  export type Args = {
-    /** The unique stream ID to cancel (must be owned by the caller) */
-    id: bigint
-    /** The TIP20 token address containing the reward stream */
-    token: Address
-  }
-
-  export type Parameters<
-    chain extends Chain | undefined = Chain | undefined,
-    account extends Account | undefined = Account | undefined,
-  > = WriteParameters<chain, account> & Args
-
-  export type ReturnValue = WriteContractReturnType
-
-  // TODO: exhaustive error type
-  export type ErrorType = BaseErrorType
-
-  /** @internal */
-  export async function inner<
-    action extends typeof writeContract | typeof writeContractSync,
-    chain extends Chain | undefined,
-    account extends Account | undefined,
-  >(
-    action: action,
-    client: Client<Transport, chain, account>,
-    parameters: Parameters<chain, account>,
-  ): Promise<ReturnType<action>> {
-    const { id, token, ...rest } = parameters
-    const call = cancel.call({ id, token })
-    return (await action(client, {
-      ...rest,
-      ...call,
-    } as never)) as never
-  }
-
-  /**
-   * Defines a call to the `cancel` function.
-   *
-   * Can be passed as a parameter to:
-   * - [`estimateContractGas`](https://viem.sh/docs/contract/estimateContractGas): estimate the gas cost of the call
-   * - [`simulateContract`](https://viem.sh/docs/contract/simulateContract): simulate the call
-   * - [`sendCalls`](https://viem.sh/docs/actions/wallet/sendCalls): send multiple calls
-   *
-   * @example
-   * ```ts
-   * import { createClient, http, walletActions } from 'viem'
-   * import { tempo } from 'tempo.ts/chains'
-   * import { Actions } from 'tempo.ts/viem'
-   *
-   * const client = createClient({
-   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
-   *   transport: http(),
-   * }).extend(walletActions)
-   *
-   * const hash = await client.sendTransaction({
-   *   calls: [actions.rewards.cancel.call({
-   *     id: 1n,
-   *     token: '0x20c0000000000000000000000000000000000001',
-   *   })],
-   * })
-   * ```
-   *
-   * @param args - Arguments.
-   * @returns The call.
-   */
-  export function call(args: Args) {
-    const { id, token } = args
-    return defineCall({
-      address: token,
-      abi: Abis.tip20,
-      args: [id],
-      functionName: 'cancelReward',
-    })
-  }
-
-  /**
-   * Extracts the `RewardCanceled` event from logs.
-   *
-   * @param logs - The logs.
-   * @returns The `RewardCanceled` event.
-   */
-  export function extractEvent(logs: Log[]) {
-    const [log] = parseEventLogs({
-      abi: Abis.tip20,
-      logs,
-      eventName: 'RewardCanceled',
-      strict: true,
-    })
-    if (!log) throw new Error('`RewardCanceled` event not found.')
-    return log
-  }
-}
-
-export declare namespace cancelSync {
-  export type Parameters<
-    chain extends Chain | undefined = Chain | undefined,
-    account extends Account | undefined = Account | undefined,
-  > = WriteParameters<chain, account> & cancel.Args
-
-  export type ReturnValue = {
-    /** The address that funded the stream */
-    funder: Address
-    /** The stream ID that was canceled */
-    id: bigint
-    /** The transaction receipt */
-    receipt: Awaited<ReturnType<typeof writeContractSync>>
-    /** The amount refunded to the funder (0 if TIP-403 policy forbids the refund transfer) */
-    refund: bigint
-  }
-
-  export type ErrorType = cancel.ErrorType
-}
-
 /**
  * Claims accumulated rewards for a recipient.
  *
@@ -417,82 +208,6 @@ export namespace claimSync {
   export type ErrorType = claim.ErrorType
 }
 
-/**
- * Gets a reward stream by its ID.
- *
- * Returns the stream details including:
- * - `funder`: The address that funded the stream
- * - `startTime`: When the stream started (block timestamp)
- * - `endTime`: When the stream is scheduled to end
- * - `ratePerSecondScaled`: The per-second emission rate (scaled by ACC_PRECISION = 1e18)
- * - `amountTotal`: The total amount allocated to the stream
- *
- * Note: If the stream has been canceled or doesn't exist, `funder` will be the zero address.
- *
- * @example
- * ```ts
- * import { createClient, http } from 'viem'
- * import { tempo } from 'tempo.ts/chains'
- * import { Actions } from 'tempo.ts/viem'
- *
- * const client = createClient({
- *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
- *   transport: http(),
- * })
- *
- * const stream = await Actions.rewards.getStream(client, {
- *   id: 1n,
- *   token: '0x20c0000000000000000000000000000000000001',
- * })
- * ```
- *
- * @param client - Client.
- * @param parameters - Parameters.
- * @returns The reward stream details.
- */
-export async function getStream<chain extends Chain | undefined>(
-  client: Client<Transport, chain>,
-  parameters: getStream.Parameters,
-): Promise<getStream.ReturnValue> {
-  return readContract(client, {
-    ...parameters,
-    ...getStream.call(parameters),
-  })
-}
-
-export namespace getStream {
-  export type Parameters = ReadParameters & Args
-
-  export type Args = {
-    /** The stream ID to query (0 is never used for streams, only for immediate distributions) */
-    id: bigint
-    /** The TIP20 token address */
-    token: Address
-  }
-
-  export type ReturnValue = ReadContractReturnType<
-    typeof Abis.tip20,
-    'getStream',
-    never
-  >
-
-  /**
-   * Defines a call to the `getStream` function.
-   *
-   * @param args - Arguments.
-   * @returns The call.
-   */
-  export function call(args: Args) {
-    const { id, token } = args
-    return defineCall({
-      address: token,
-      abi: Abis.tip20,
-      args: [id],
-      functionName: 'getStream',
-    })
-  }
-}
-
 /**
  * Gets the total reward per second rate for all active streams.
  *
@@ -883,8 +598,6 @@ export namespace start {
   export type Args = {
     /** The amount of tokens to distribute (must be > 0) */
     amount: bigint
-    /** The duration in seconds (0 for immediate distribution, >0 for linear streaming) */
-    seconds: number
     /** The TIP20 token address */
     token: Address
   }
@@ -909,8 +622,8 @@ export namespace start {
     client: Client<Transport, chain, account>,
     parameters: Parameters<chain, account>,
   ): Promise<ReturnType<action>> {
-    const { amount, seconds, token, ...rest } = parameters
-    const call = start.call({ amount, seconds, token })
+    const { amount, token, ...rest } = parameters
+    const call = start.call({ amount, token })
     return (await action(client, {
       ...rest,
       ...call,
@@ -949,11 +662,11 @@ export namespace start {
    * @returns The call.
    */
   export function call(args: Args) {
-    const { amount, seconds, token } = args
+    const { amount, token } = args
     return defineCall({
       address: token,
       abi: Abis.tip20,
-      args: [amount, seconds],
+      args: [amount, 0],
       functionName: 'startReward',
     })
   }