tempo.ts 0.6.2 → 0.7.0

package/src/wagmi/Actions/amm.ts

@@ -192,119 +192,6 @@ export namespace getLiquidityBalance {
   }
 }
 
-/**
- * Performs a rebalance swap from validator token to user token.
- *
- * @example
- * ```ts
- * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'tempo.ts/chains'
- * import { Actions } from 'tempo.ts/wagmi'
- *
- * const config = createConfig({
- *   chains: [tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })],
- *   transports: {
- *     [tempo.id]: http(),
- *   },
- * })
- *
- * const hash = await Actions.amm.rebalanceSwap(config, {
- *   userToken: '0x...',
- *   validatorToken: '0x...',
- *   amountOut: 100n,
- *   to: '0x...',
- * })
- * ```
- *
- * @param config - Config.
- * @param parameters - Parameters.
- * @returns The transaction hash.
- */
-export async function rebalanceSwap<config extends Config>(
-  config: config,
-  parameters: rebalanceSwap.Parameters<config>,
-): Promise<viem_Actions.rebalanceSwap.ReturnValue> {
-  const { account, chainId, connector } = parameters
-
-  const client = await getConnectorClient(config, {
-    account,
-    assertChainId: false,
-    chainId,
-    connector,
-  })
-
-  return viem_Actions.rebalanceSwap(client, parameters as never)
-}
-
-export declare namespace rebalanceSwap {
-  export type Parameters<config extends Config> = ChainIdParameter<config> &
-    ConnectorParameter &
-    UnionOmit<
-      viem_Actions.rebalanceSwap.Parameters<config['chains'][number], Account>,
-      'chain'
-    >
-
-  export type ReturnValue = viem_Actions.rebalanceSwap.ReturnValue
-}
-
-/**
- * Performs a rebalance swap from validator token to user token.
- *
- * @example
- * ```ts
- * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'tempo.ts/chains'
- * import { Actions } from 'tempo.ts/wagmi'
- *
- * const config = createConfig({
- *   chains: [tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })],
- *   transports: {
- *     [tempo.id]: http(),
- *   },
- * })
- *
- * const result = await Actions.amm.rebalanceSwapSync(config, {
- *   userToken: '0x...',
- *   validatorToken: '0x...',
- *   amountOut: 100n,
- *   to: '0x...',
- * })
- * ```
- *
- * @param config - Config.
- * @param parameters - Parameters.
- * @returns The transaction receipt and event data.
- */
-export async function rebalanceSwapSync<config extends Config>(
-  config: config,
-  parameters: rebalanceSwapSync.Parameters<config>,
-): Promise<viem_Actions.rebalanceSwapSync.ReturnValue> {
-  const { account, chainId, connector } = parameters
-
-  const client = await getConnectorClient(config, {
-    account,
-    assertChainId: false,
-    chainId,
-    connector,
-  })
-
-  return viem_Actions.rebalanceSwapSync(client, parameters as never)
-}
-
-export declare namespace rebalanceSwapSync {
-  export type Parameters<config extends Config> = ChainIdParameter<config> &
-    ConnectorParameter &
-    UnionOmit<
-      viem_Actions.rebalanceSwapSync.Parameters<
-        config['chains'][number],
-        Account
-      >,
-      'chain'
-    >
-
-  export type ReturnValue = viem_Actions.rebalanceSwapSync.ReturnValue
-}
-
 /**
  * Adds liquidity to a pool.
  *
@@ -425,198 +312,6 @@ export declare namespace mintSync {
   export type ReturnValue = viem_Actions.mintSync.ReturnValue
 }
 
-/**
- * Removes liquidity from a pool.
- *
- * @example
- * ```ts
- * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'tempo.ts/chains'
- * import { Actions } from 'tempo.ts/wagmi'
- *
- * const config = createConfig({
- *   chains: [tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })],
- *   transports: {
- *     [tempo.id]: http(),
- *   },
- * })
- *
- * const hash = await Actions.amm.burn(config, {
- *   userToken: '0x20c0...beef',
- *   validatorToken: '0x20c0...babe',
- *   liquidity: 50n,
- *   to: '0xfeed...fede',
- * })
- * ```
- *
- * @param config - Config.
- * @param parameters - Parameters.
- * @returns The transaction hash.
- */
-export async function burn<config extends Config>(
-  config: config,
-  parameters: burn.Parameters<config>,
-): Promise<viem_Actions.burn.ReturnValue> {
-  const { account, chainId, connector } = parameters
-
-  const client = await getConnectorClient(config, {
-    account,
-    assertChainId: false,
-    chainId,
-    connector,
-  })
-
-  return viem_Actions.burn(client, parameters as never)
-}
-
-export declare namespace burn {
-  export type Parameters<config extends Config> = ChainIdParameter<config> &
-    ConnectorParameter &
-    UnionOmit<
-      viem_Actions.burn.Parameters<config['chains'][number], Account>,
-      'chain'
-    >
-
-  export type ReturnValue = viem_Actions.burn.ReturnValue
-}
-
-/**
- * Removes liquidity from a pool.
- *
- * @example
- * ```ts
- * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'tempo.ts/chains'
- * import { Actions } from 'tempo.ts/wagmi'
- *
- * const config = createConfig({
- *   chains: [tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })],
- *   transports: {
- *     [tempo.id]: http(),
- *   },
- * })
- *
- * const result = await Actions.amm.burnSync(config, {
- *   userToken: '0x20c0...beef',
- *   validatorToken: '0x20c0...babe',
- *   liquidity: 50n,
- *   to: '0xfeed...fede',
- * })
- * ```
- *
- * @param config - Config.
- * @param parameters - Parameters.
- * @returns The transaction receipt and event data.
- */
-export async function burnSync<config extends Config>(
-  config: config,
-  parameters: burnSync.Parameters<config>,
-): Promise<viem_Actions.burnSync.ReturnValue> {
-  const { account, chainId, connector } = parameters
-
-  const client = await getConnectorClient(config, {
-    account,
-    assertChainId: false,
-    chainId,
-    connector,
-  })
-
-  return viem_Actions.burnSync(client, parameters as never)
-}
-
-export declare namespace burnSync {
-  export type Parameters<config extends Config> = ChainIdParameter<config> &
-    ConnectorParameter &
-    UnionOmit<
-      viem_Actions.burnSync.Parameters<config['chains'][number], Account>,
-      'chain'
-    >
-
-  export type ReturnValue = viem_Actions.burnSync.ReturnValue
-}
-
-/**
- * Watches for rebalance swap events.
- *
- * @example
- * ```ts
- * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'tempo.ts/chains'
- * import { Actions } from 'tempo.ts/wagmi'
- *
- * const config = createConfig({
- *   chains: [tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })],
- *   transports: {
- *     [tempo.id]: http(),
- *   },
- * })
- *
- * const unwatch = Actions.amm.watchRebalanceSwap(config, {
- *   onRebalanceSwap: (args, log) => {
- *     console.log('Rebalance swap:', args)
- *   },
- * })
- * ```
- *
- * @param config - Config.
- * @param parameters - Parameters.
- * @returns A function to unsubscribe from the event.
- */
-export function watchRebalanceSwap<config extends Config>(
-  config: config,
-  parameters: watchRebalanceSwap.Parameters<config>,
-) {
-  const { chainId, ...rest } = parameters
-  const client = config.getClient({ chainId })
-  return viem_Actions.watchRebalanceSwap(client, rest)
-}
-
-export declare namespace watchRebalanceSwap {
-  export type Parameters<config extends Config> = ChainIdParameter<config> &
-    viem_Actions.watchRebalanceSwap.Parameters
-}
-
-/**
- * Watches for fee swap events.
- *
- * @example
- * ```ts
- * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'tempo.ts/chains'
- * import { Actions } from 'tempo.ts/wagmi'
- *
- * const config = createConfig({
- *   chains: [tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })],
- *   transports: {
- *     [tempo.id]: http(),
- *   },
- * })
- *
- * const unwatch = Actions.amm.watchFeeSwap(config, {
- *   onFeeSwap: (args, log) => {
- *     console.log('Fee swap:', args)
- *   },
- * })
- * ```
- *
- * @param config - Config.
- * @param parameters - Parameters.
- * @returns A function to unsubscribe from the event.
- */
-export function watchFeeSwap<config extends Config>(
-  config: config,
-  parameters: watchFeeSwap.Parameters<config>,
-) {
-  const { chainId, ...rest } = parameters
-  const client = config.getClient({ chainId })
-  return viem_Actions.watchFeeSwap(client, rest)
-}
-
-export declare namespace watchFeeSwap {
-  export type Parameters<config extends Config> = ChainIdParameter<config> &
-    viem_Actions.watchFeeSwap.Parameters
-}
-
 /**
  * Watches for liquidity mint events.
  *
@@ -657,44 +352,3 @@ export declare namespace watchMint {
   export type Parameters<config extends Config> = ChainIdParameter<config> &
     viem_Actions.watchMint.Parameters
 }
-
-/**
- * Watches for liquidity burn events.
- *
- * @example
- * ```ts
- * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'tempo.ts/chains'
- * import { Actions } from 'tempo.ts/wagmi'
- *
- * const config = createConfig({
- *   chains: [tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })],
- *   transports: {
- *     [tempo.id]: http(),
- *   },
- * })
- *
- * const unwatch = Actions.amm.watchBurn(config, {
- *   onBurn: (args, log) => {
- *     console.log('Liquidity removed:', args)
- *   },
- * })
- * ```
- *
- * @param config - Config.
- * @param parameters - Parameters.
- * @returns A function to unsubscribe from the event.
- */
-export function watchBurn<config extends Config>(
-  config: config,
-  parameters: watchBurn.Parameters<config>,
-) {
-  const { chainId, ...rest } = parameters
-  const client = config.getClient({ chainId })
-  return viem_Actions.watchBurn(client, rest)
-}
-
-export declare namespace watchBurn {
-  export type Parameters<config extends Config> = ChainIdParameter<config> &
-    viem_Actions.watchBurn.Parameters
-}

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

@@ -5,31 +5,6 @@ import { config, queryClient, setupToken } from '../../../test/wagmi/config.js'
 import * as actions from './reward.js'
 import * as tokenActions from './token.js'
 
-describe('cancelSync', () => {
-  test('default', async () => {
-    const { token } = await setupToken()
-
-    // Start a reward stream
-    const rewardAmount = parseUnits('100', 6)
-    const { id: streamId } = await actions.startSync(config, {
-      amount: rewardAmount,
-      seconds: 3600,
-      token,
-    })
-
-    // Cancel the reward
-    const { receipt, refund, ...result } = await actions.cancelSync(config, {
-      id: streamId,
-      token,
-    })
-
-    expect(refund).toBeGreaterThan(0n)
-    expect(receipt).toBeDefined()
-    expect(result.funder).toBeDefined()
-    expect(result.id).toBe(streamId)
-  })
-})
-
 // TODO: unskip
 describe.skip('claimSync', () => {
   test('default', async () => {
@@ -59,7 +34,6 @@ describe.skip('claimSync', () => {
     // Start immediate reward
     await actions.startSync(config, {
       amount: rewardAmount,
-      seconds: 0,
       token,
     })
 
@@ -89,55 +63,6 @@ describe.skip('claimSync', () => {
   })
 })
 
-describe('getStream', () => {
-  test('default', async () => {
-    const { token } = await setupToken()
-
-    // Start a reward stream
-    const rewardAmount = parseUnits('100', 6)
-    const { id: streamId } = await actions.startSync(config, {
-      amount: rewardAmount,
-      seconds: 10,
-      token,
-    })
-
-    // Get the stream
-    const stream = await actions.getStream(config, {
-      id: streamId,
-      token,
-    })
-
-    expect(stream.funder).toBeDefined()
-    expect(stream.amountTotal).toBe(rewardAmount)
-    expect(stream.endTime).toBeGreaterThan(stream.startTime)
-    expect(stream.ratePerSecondScaled).toBeGreaterThan(0n)
-  })
-
-  describe('queryOptions', () => {
-    test('default', async () => {
-      const { token } = await setupToken()
-
-      // Start a reward stream
-      const rewardAmount = parseUnits('100', 6)
-      const { id: streamId } = await actions.startSync(config, {
-        amount: rewardAmount,
-        seconds: 10,
-        token,
-      })
-
-      const options = actions.getStream.queryOptions(config, {
-        id: streamId,
-        token,
-      })
-
-      const stream = await queryClient.fetchQuery(options)
-
-      expect(stream.funder).toBeDefined()
-      expect(stream.amountTotal).toBe(rewardAmount)
-    })
-  })
-})
-
 describe('getTotalPerSecond', () => {
   test('default', async () => {
     const { token } = await setupToken()
@@ -184,27 +109,3 @@ describe('setRecipientSync', () => {
     expect(recipient).toBe(account.address)
   })
 })
-
-describe('startSync', () => {
-  test('default', async () => {
-    const { token } = await setupToken()
-
-    const account = getAccount(config)
-
-    // Start a reward stream
-    const rewardAmount = parseUnits('100', 6)
-    const duration = 10
-    const { amount, durationSeconds, funder, id, receipt } =
-      await actions.startSync(config, {
-        amount: rewardAmount,
-        seconds: duration,
-        token,
-      })
-
-    expect(receipt).toBeDefined()
-    expect(funder).toBe(account.address)
-    expect(id).toBeGreaterThan(0n)
-    expect(amount).toBe(rewardAmount)
-    expect(durationSeconds).toBe(duration)
-  })
-})

package/src/wagmi/Actions/reward.ts

@@ -5,118 +5,6 @@ import type { Account } from 'viem'
 import type { RequiredBy, UnionOmit } from '../../internal/types.js'
 import * as viem_Actions from '../../viem/Actions/reward.js'
 
-/**
- * Cancels an active reward stream and refunds remaining tokens.
- *
- * @example
- * ```ts
- * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'tempo.ts/chains'
- * import { Actions } from 'tempo.ts/wagmi'
- *
- * const config = createConfig({
- *   chains: [tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })],
- *   transports: {
- *     [tempo.id]: http(),
- *   },
- * })
- *
- * const hash = await Actions.reward.cancel(config, {
- *   id: 1n,
- *   token: '0x20c0000000000000000000000000000000000001',
- * })
- * ```
- *
- * @param config - Config.
- * @param parameters - Parameters.
- * @returns The transaction hash.
- */
-export async function cancel<config extends Config>(
-  config: config,
-  parameters: cancel.Parameters<config>,
-): Promise<viem_Actions.cancel.ReturnValue> {
-  const { account, chainId, connector } = parameters
-
-  const client = await getConnectorClient(config, {
-    account,
-    assertChainId: false,
-    chainId,
-    connector,
-  })
-
-  return viem_Actions.cancel(client, parameters as never)
-}
-
-export declare namespace cancel {
-  export type Parameters<config extends Config = Config> =
-    ChainIdParameter<config> &
-      ConnectorParameter &
-      UnionOmit<
-        viem_Actions.cancel.Parameters<config['chains'][number], Account>,
-        'chain'
-      >
-
-  export type ReturnValue = viem_Actions.cancel.ReturnValue
-
-  export type ErrorType = viem_Actions.cancel.ErrorType
-}
-
-/**
- * Cancels an active reward stream and waits for confirmation.
- *
- * @example
- * ```ts
- * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'tempo.ts/chains'
- * import { Actions } from 'tempo.ts/wagmi'
- *
- * const config = createConfig({
- *   chains: [tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })],
- *   transports: {
- *     [tempo.id]: http(),
- *   },
- * })
- *
- * const result = await Actions.reward.cancelSync(config, {
- *   id: 1n,
- *   token: '0x20c0000000000000000000000000000000000001',
- * })
- * ```
- *
- * @param config - Config.
- * @param parameters - Parameters.
- * @returns The transaction receipt and event data.
- */
-export async function cancelSync<config extends Config>(
-  config: config,
-  parameters: cancelSync.Parameters<config>,
-): Promise<viem_Actions.cancelSync.ReturnValue> {
-  const { account, chainId, connector } = parameters
-
-  const client = await getConnectorClient(config, {
-    account,
-    assertChainId: false,
-    chainId,
-    connector,
-  })
-
-  return viem_Actions.cancelSync(client, parameters as never)
-}
-
-export declare namespace cancelSync {
-  export type Parameters<config extends Config = Config> =
-    ChainIdParameter<config> &
-      ConnectorParameter &
-      UnionOmit<
-        viem_Actions.cancelSync.Parameters<config['chains'][number], Account>,
-        'chain'
-      >
-
-  export type ReturnValue = viem_Actions.cancelSync.ReturnValue
-
-  export type ErrorType = viem_Actions.cancelSync.ErrorType
-}
-
 /**
  * Claims accumulated rewards for a recipient.
  *
@@ -227,97 +115,6 @@ export declare namespace claimSync {
   export type ErrorType = viem_Actions.claimSync.ErrorType
 }
 
-/**
- * Gets a reward stream by its ID.
- *
- * @example
- * ```ts
- * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'tempo.ts/chains'
- * import { Actions } from 'tempo.ts/wagmi'
- *
- * const config = createConfig({
- *   chains: [tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })],
- *   transports: {
- *     [tempo.id]: http(),
- *   },
- * })
- *
- * const stream = await Actions.reward.getStream(config, {
- *   id: 1n,
- *   token: '0x20c0000000000000000000000000000000000001',
- * })
- * ```
- *
- * @param config - Config.
- * @param parameters - Parameters.
- * @returns The reward stream details.
- */
-export function getStream<config extends Config>(
-  config: config,
-  parameters: getStream.Parameters<config>,
-) {
-  const { chainId, ...rest } = parameters
-  const client = config.getClient({ chainId })
-  return viem_Actions.getStream(client, rest)
-}
-
-export namespace getStream {
-  export type Parameters<config extends Config> = ChainIdParameter<config> &
-    viem_Actions.getStream.Parameters
-
-  export type ReturnValue = viem_Actions.getStream.ReturnValue
-
-  export function queryKey<config extends Config>(
-    parameters: Parameters<config>,
-  ) {
-    return ['getStream', parameters] as const
-  }
-
-  export type QueryKey<config extends Config> = ReturnType<
-    typeof queryKey<config>
-  >
-
-  export function queryOptions<config extends Config, selectData = ReturnValue>(
-    config: Config,
-    parameters: queryOptions.Parameters<config, selectData>,
-  ): queryOptions.ReturnValue<config, selectData> {
-    const { query, ...rest } = parameters
-    return {
-      ...query,
-      queryKey: queryKey(rest),
-      async queryFn({ queryKey }) {
-        const [, parameters] = queryKey
-        return await getStream(config, parameters)
-      },
-    }
-  }
-
-  export declare namespace queryOptions {
-    export type Parameters<
-      config extends Config,
-      selectData = getStream.ReturnValue,
-    > = getStream.Parameters<config> & {
-      query?:
-        | Omit<ReturnValue<config, selectData>, 'queryKey' | 'queryFn'>
-        | undefined
-    }
-
-    export type ReturnValue<
-      config extends Config,
-      selectData = getStream.ReturnValue,
-    > = RequiredBy<
-      Query.QueryOptions<
-        getStream.ReturnValue,
-        Query.DefaultError,
-        selectData,
-        getStream.QueryKey<config>
-      >,
-      'queryKey' | 'queryFn'
-    >
-  }
-}
-
 /**
  * Gets the total reward per second rate for all active streams.
  *

package/src/wagmi/Connector.test.ts

@@ -3,6 +3,7 @@ import { cdp } from 'vitest/browser'
 import { useAccount, useConnect } from 'wagmi'
 import { renderHook } from '../../test/wagmi/config.js'
 import { webAuthn } from './Connector.js'
+import * as KeyManager from './KeyManager.js'
 
 async function setupWebAuthn() {
   const client = cdp()
@@ -39,7 +40,9 @@ test('connect', async (context) => {
   expect(result.current.useAccount.status).toEqual('disconnected')
 
   result.current.useConnect.connect({
-    connector: webAuthn(),
+    connector: webAuthn({
+      keyManager: KeyManager.localStorage(),
+    }),
     capabilities: { createAccount: { label: 'Test Account' } },
   })