tempo.ts 0.6.1 → 0.7.0

package/src/viem/Decorator.ts

@@ -1,4 +1,7 @@
 import type { Account, Chain, Client, Transport } from 'viem'
+import type { VerifyHashParameters, VerifyHashReturnType } from 'viem/actions'
+import type { PartialBy } from '../internal/types.js'
+import * as accountActions from './Actions/account.js'
 import * as ammActions from './Actions/amm.js'
 import * as dexActions from './Actions/dex.js'
 import * as faucetActions from './Actions/faucet.js'
@@ -11,6 +14,34 @@ export type Decorator<
   chain extends Chain | undefined = Chain | undefined,
   account extends Account | undefined = Account | undefined,
 > = {
+  /**
+   * Verifies that a signature is valid for a given hash and address.
+   * Supports Secp256k1, P256, WebCrypto P256, and WebAuthn signatures.
+   *
+   * @example
+   * ```ts
+   * import { createClient, http } from 'viem'
+   * import { tempo } from 'tempo.ts/chains'
+   * import { tempoActions } from 'tempo.ts/viem'
+   *
+   * const client = createClient({
+   *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
+   *   transport: http(),
+   * }).extend(tempoActions())
+   *
+   * const valid = await client.verifyHash({
+   *   address: '0x...',
+   *   hash: '0x...',
+   *   signature: '0x...',
+   * })
+   * ```
+   *
+   * @param parameters - Parameters.
+   * @returns Whether the signature is valid.
+   */
+  verifyHash: (
+    parameters: PartialBy<VerifyHashParameters, 'address'>,
+  ) => Promise<VerifyHashReturnType>
   amm: {
     /**
      * Gets the reserves for a liquidity pool.
@@ -69,66 +100,6 @@ export type Decorator<
     getLiquidityBalance: (
       parameters: ammActions.getLiquidityBalance.Parameters,
     ) => Promise<ammActions.getLiquidityBalance.ReturnValue>
-    /**
-     * Performs a rebalance swap from validator token to user token.
-     *
-     * @example
-     * ```ts
-     * import { createClient, http } from 'viem'
-     * import { privateKeyToAccount } from 'viem/accounts'
-     * import { tempo } from 'tempo.ts/chains'
-     * import { tempoActions } from 'tempo.ts/viem'
-     *
-     * const client = createClient({
-     *   account: privateKeyToAccount('0x...'),
-     *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
-     *   transport: http(),
-     * }).extend(tempoActions())
-     *
-     * const hash = await client.amm.rebalanceSwap({
-     *   userToken: '0x...',
-     *   validatorToken: '0x...',
-     *   amountOut: 100n,
-     *   to: '0x...',
-     * })
-     * ```
-     *
-     * @param parameters - Parameters.
-     * @returns The transaction hash.
-     */
-    rebalanceSwap: (
-      parameters: ammActions.rebalanceSwap.Parameters<chain, account>,
-    ) => Promise<ammActions.rebalanceSwap.ReturnValue>
-    /**
-     * Performs a rebalance swap from validator token to user token.
-     *
-     * @example
-     * ```ts
-     * import { createClient, http } from 'viem'
-     * import { privateKeyToAccount } from 'viem/accounts'
-     * import { tempo } from 'tempo.ts/chains'
-     * import { tempoActions } from 'tempo.ts/viem'
-     *
-     * const client = createClient({
-     *   account: privateKeyToAccount('0x...'),
-     *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
-     *   transport: http(),
-     * }).extend(tempoActions())
-     *
-     * const result = await client.amm.rebalanceSwapSync({
-     *   userToken: '0x...',
-     *   validatorToken: '0x...',
-     *   amountOut: 100n,
-     *   to: '0x...',
-     * })
-     * ```
-     *
-     * @param parameters - Parameters.
-     * @returns The transaction receipt and event data.
-     */
-    rebalanceSwapSync: (
-      parameters: ammActions.rebalanceSwapSync.Parameters<chain, account>,
-    ) => Promise<ammActions.rebalanceSwapSync.ReturnValue>
     /**
      * Adds liquidity to a pool.
      *
@@ -199,118 +170,6 @@ export type Decorator<
     mintSync: (
       parameters: ammActions.mintSync.Parameters<chain, account>,
     ) => Promise<ammActions.mintSync.ReturnValue>
-    /**
-     * Removes liquidity from a pool.
-     *
-     * @example
-     * ```ts
-     * import { createClient, http } from 'viem'
-     * import { privateKeyToAccount } from 'viem/accounts'
-     * import { tempo } from 'tempo.ts/chains'
-     * import { tempoActions } from 'tempo.ts/viem'
-     *
-     * const client = createClient({
-     *   account: privateKeyToAccount('0x...'),
-     *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
-     *   transport: http(),
-     * }).extend(tempoActions())
-     *
-     * const hash = await client.amm.burn({
-     *   userToken: '0x...',
-     *   validatorToken: '0x...',
-     *   liquidity: 50n,
-     *   to: '0x...',
-     * })
-     * ```
-     *
-     * @param parameters - Parameters.
-     * @returns The transaction hash.
-     */
-    burn: (
-      parameters: ammActions.burn.Parameters<chain, account>,
-    ) => Promise<ammActions.burn.ReturnValue>
-    /**
-     * Removes liquidity from a pool.
-     *
-     * @example
-     * ```ts
-     * import { createClient, http } from 'viem'
-     * import { privateKeyToAccount } from 'viem/accounts'
-     * import { tempo } from 'tempo.ts/chains'
-     * import { tempoActions } from 'tempo.ts/viem'
-     *
-     * const client = createClient({
-     *   account: privateKeyToAccount('0x...'),
-     *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
-     *   transport: http(),
-     * }).extend(tempoActions())
-     *
-     * const result = await client.amm.burnSync({
-     *   userToken: '0x...',
-     *   validatorToken: '0x...',
-     *   liquidity: 50n,
-     *   to: '0x...',
-     * })
-     * ```
-     *
-     * @param parameters - Parameters.
-     * @returns The transaction receipt and event data.
-     */
-    burnSync: (
-      parameters: ammActions.burnSync.Parameters<chain, account>,
-    ) => Promise<ammActions.burnSync.ReturnValue>
-    /**
-     * Watches for rebalance swap events.
-     *
-     * @example
-     * ```ts
-     * import { createClient, http } from 'viem'
-     * import { tempo } from 'tempo.ts/chains'
-     * import { tempoActions } from 'tempo.ts/viem'
-     *
-     * const client = createClient({
-     *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
-     *   transport: http(),
-     * }).extend(tempoActions())
-     *
-     * const unwatch = client.amm.watchRebalanceSwap({
-     *   onRebalanceSwap: (args, log) => {
-     *     console.log('Rebalance swap:', args)
-     *   },
-     * })
-     * ```
-     *
-     * @param parameters - Parameters.
-     * @returns A function to unsubscribe from the event.
-     */
-    watchRebalanceSwap: (
-      parameters: ammActions.watchRebalanceSwap.Parameters,
-    ) => () => void
-    /**
-     * Watches for fee swap events.
-     *
-     * @example
-     * ```ts
-     * import { createClient, http } from 'viem'
-     * import { tempo } from 'tempo.ts/chains'
-     * import { tempoActions } from 'tempo.ts/viem'
-     *
-     * const client = createClient({
-     *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
-     *   transport: http(),
-     * }).extend(tempoActions())
-     *
-     * const unwatch = client.amm.watchFeeSwap({
-     *   onFeeSwap: (args, log) => {
-     *     console.log('Fee swap:', args)
-     *   },
-     * })
-     * ```
-     *
-     * @param parameters - Parameters.
-     * @returns A function to unsubscribe from the event.
-     */
-    watchFeeSwap: (parameters: ammActions.watchFeeSwap.Parameters) => () => void
     /**
      * Watches for liquidity mint events.
      *
@@ -336,31 +195,6 @@ export type Decorator<
      * @returns A function to unsubscribe from the event.
      */
     watchMint: (parameters: ammActions.watchMint.Parameters) => () => void
-    /**
-     * Watches for liquidity burn events.
-     *
-     * @example
-     * ```ts
-     * import { createClient, http } from 'viem'
-     * import { tempo } from 'tempo.ts/chains'
-     * import { tempoActions } from 'tempo.ts/viem'
-     *
-     * const client = createClient({
-     *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
-     *   transport: http(),
-     * }).extend(tempoActions())
-     *
-     * const unwatch = client.amm.watchBurn({
-     *   onBurn: (args, log) => {
-     *     console.log('Liquidity removed:', args)
-     *   },
-     * })
-     * ```
-     *
-     * @param parameters - Parameters.
-     * @returns A function to unsubscribe from the event.
-     */
-    watchBurn: (parameters: ammActions.watchBurn.Parameters) => () => void
   }
   dex: {
     /**
@@ -1570,88 +1404,6 @@ export type Decorator<
     ) => () => void
   }
   reward: {
-    /**
-     * Cancels an active reward stream and refunds remaining tokens.
-     *
-     * @example
-     * ```ts
-     * import { createClient, http } from 'viem'
-     * import { privateKeyToAccount } from 'viem/accounts'
-     * import { tempo } from 'tempo.ts/chains'
-     * import { tempoActions } from 'tempo.ts/viem'
-     *
-     * const client = createClient({
-     *   account: privateKeyToAccount('0x...'),
-     *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
-     *   transport: http(),
-     * }).extend(tempoActions())
-     *
-     * const hash = await client.reward.cancel({
-     *   id: 1n,
-     *   token: '0x20c0000000000000000000000000000000000001',
-     * })
-     * ```
-     *
-     * @param parameters - Parameters.
-     * @returns The transaction hash.
-     */
-    cancel: (
-      parameters: rewardActions.cancel.Parameters<chain, account>,
-    ) => Promise<rewardActions.cancel.ReturnValue>
-    /**
-     * Cancels an active reward stream and waits for confirmation.
-     *
-     * @example
-     * ```ts
-     * import { createClient, http } from 'viem'
-     * import { privateKeyToAccount } from 'viem/accounts'
-     * import { tempo } from 'tempo.ts/chains'
-     * import { tempoActions } from 'tempo.ts/viem'
-     *
-     * const client = createClient({
-     *   account: privateKeyToAccount('0x...'),
-     *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
-     *   transport: http(),
-     * }).extend(tempoActions())
-     *
-     * const result = await client.reward.cancelSync({
-     *   id: 1n,
-     *   token: '0x20c0000000000000000000000000000000000001',
-     * })
-     * ```
-     *
-     * @param parameters - Parameters.
-     * @returns The transaction receipt and event data.
-     */
-    cancelSync: (
-      parameters: rewardActions.cancelSync.Parameters<chain, account>,
-    ) => Promise<rewardActions.cancelSync.ReturnValue>
-    /**
-     * Gets a reward stream by its ID.
-     *
-     * @example
-     * ```ts
-     * import { createClient, http } from 'viem'
-     * import { tempo } from 'tempo.ts/chains'
-     * import { tempoActions } from 'tempo.ts/viem'
-     *
-     * const client = createClient({
-     *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
-     *   transport: http(),
-     * }).extend(tempoActions())
-     *
-     * const stream = await client.reward.getStream({
-     *   id: 1n,
-     *   token: '0x20c0000000000000000000000000000000000001',
-     * })
-     * ```
-     *
-     * @param parameters - Parameters.
-     * @returns The reward stream details.
-     */
-    getStream: (
-      parameters: rewardActions.getStream.Parameters,
-    ) => Promise<rewardActions.getStream.ReturnValue>
     /**
      * Gets the total reward per second rate for all active streams.
      *
@@ -2949,24 +2701,14 @@ export function decorator() {
     client: Client<transport, chain, account>,
   ): Decorator<chain, account> => {
     return {
+      verifyHash: (parameters) => accountActions.verifyHash(client, parameters),
       amm: {
         getPool: (parameters) => ammActions.getPool(client, parameters),
         getLiquidityBalance: (parameters) =>
           ammActions.getLiquidityBalance(client, parameters),
-        rebalanceSwap: (parameters) =>
-          ammActions.rebalanceSwap(client, parameters),
-        rebalanceSwapSync: (parameters) =>
-          ammActions.rebalanceSwapSync(client, parameters),
         mint: (parameters) => ammActions.mint(client, parameters),
         mintSync: (parameters) => ammActions.mintSync(client, parameters),
-        burn: (parameters) => ammActions.burn(client, parameters),
-        burnSync: (parameters) => ammActions.burnSync(client, parameters),
-        watchRebalanceSwap: (parameters) =>
-          ammActions.watchRebalanceSwap(client, parameters),
-        watchFeeSwap: (parameters) =>
-          ammActions.watchFeeSwap(client, parameters),
         watchMint: (parameters) => ammActions.watchMint(client, parameters),
-        watchBurn: (parameters) => ammActions.watchBurn(client, parameters),
       },
       dex: {
         buy: (parameters) => dexActions.buy(client, parameters),
@@ -3046,10 +2788,6 @@ export function decorator() {
           policyActions.watchBlacklistUpdated(client, parameters),
       },
       reward: {
-        cancel: (parameters) => rewardActions.cancel(client, parameters),
-        cancelSync: (parameters) =>
-          rewardActions.cancelSync(client, parameters),
-        getStream: (parameters) => rewardActions.getStream(client, parameters),
         getTotalPerSecond: (parameters) =>
           rewardActions.getTotalPerSecond(client, parameters),
         setRecipient: (parameters) =>

package/src/viem/Storage.ts

@@ -0,0 +1,88 @@
+import * as Json from 'ox/Json'
+
+import type { MaybePromise } from '../internal/types.js'
+
+export type Storage<
+  schema extends Record<string, unknown> = Record<string, unknown>,
+> = {
+  getItem: <name extends keyof schema>(
+    name: name,
+  ) => MaybePromise<schema[name] | null>
+  removeItem: <name extends keyof schema>(name: name) => MaybePromise<void>
+  setItem: <name extends keyof schema>(
+    name: name,
+    value: schema[name],
+  ) => MaybePromise<void>
+}
+
+export function from<schema extends Record<string, unknown>>(
+  storage: Storage,
+  options: { key?: string | undefined } = {},
+): Storage<schema> {
+  const key = (name: any) => `${options.key ? `${options.key}:` : ''}${name}`
+  return {
+    getItem: (name) => storage.getItem(key(name)) as never,
+    removeItem: (name) => storage.removeItem(key(name)),
+    setItem: (name, value) => storage.setItem(key(name), value),
+  }
+}
+
+export namespace from {
+  export type Options = {
+    key?: string | undefined
+  }
+}
+
+export function localStorage<schema extends Record<string, unknown>>(
+  options: localStorage.Options = {},
+) {
+  if (typeof window === 'undefined') return memory<schema>()
+  return from<schema>(
+    {
+      async getItem(name) {
+        const item = window.localStorage.getItem(name)
+        if (item === null) return null
+        try {
+          return Json.parse(item)
+        } catch {
+          return null
+        }
+      },
+      async removeItem(name) {
+        window.localStorage.removeItem(name)
+      },
+      async setItem(name, value) {
+        window.localStorage.setItem(name, Json.stringify(value))
+      },
+    },
+    options,
+  )
+}
+
+export namespace localStorage {
+  export type Options = from.Options
+}
+
+const store = new Map<string, any>()
+export function memory<schema extends Record<string, unknown>>(
+  options: memory.Options = {},
+) {
+  return from<schema>(
+    {
+      getItem(name) {
+        return store.get(name) ?? null
+      },
+      removeItem(name) {
+        store.delete(name)
+      },
+      setItem(name, value) {
+        store.set(name, value)
+      },
+    },
+    options,
+  )
+}
+
+export namespace memory {
+  export type Options = from.Options
+}

package/src/viem/Transport.ts

@@ -18,14 +18,22 @@ export type FeePayer = Transport<typeof withFeePayer.type>
  * Creates a fee payer transport that routes requests between
  * the default transport or the fee payer transport.
  *
+ * The policy parameter controls how the fee payer handles transactions:
+ * - `'sign-only'`: Fee payer co-signs the transaction and returns it to the client transport, which then broadcasts it via the default transport
+ * - `'sign-and-broadcast'`: Fee payer co-signs and broadcasts the transaction directly
+ *
  * @param defaultTransport - The default transport to use.
  * @param feePayerTransport - The fee payer transport to use.
+ * @param parameters - Configuration parameters.
  * @returns A relay transport.
  */
 export function withFeePayer(
   defaultTransport: Transport,
   relayTransport: Transport,
+  parameters?: withFeePayer.Parameters,
 ): withFeePayer.ReturnValue {
+  const { policy = 'sign-only' } = parameters ?? {}
+
   return (config) => {
     const transport_default = defaultTransport(config)
     const transport_relay = relayTransport(config)
@@ -40,9 +48,34 @@ export function withFeePayer(
         ) {
           const serialized = (params as any)[0] as `0x76${string}`
           const transaction = Transaction.deserialize(serialized)
+
           // If the transaction is intended to be sponsored, forward it to the relay.
-          if (transaction.feePayerSignature === null)
-            return transport_relay.request({ method, params }, options) as never
+          if (transaction.feePayerSignature === null) {
+            // For 'sign-and-broadcast', relay signs and broadcasts
+            if (policy === 'sign-and-broadcast')
+              return transport_relay.request(
+                { method, params },
+                options,
+              ) as never
+
+            // For 'sign-only', request signature from relay using eth_signRawTransaction
+            {
+              // Request signature from relay using eth_signRawTransaction
+              const signedTransaction = await transport_relay.request(
+                {
+                  method: 'eth_signRawTransaction',
+                  params: [serialized],
+                },
+                options,
+              )
+
+              // Broadcast the signed transaction via the default transport
+              return transport_default.request(
+                { method, params: [signedTransaction] },
+                options,
+              ) as never
+            }
+          }
         }
         return transport_default.request({ method, params }, options) as never
       },
@@ -54,6 +87,11 @@ export function withFeePayer(
 export declare namespace withFeePayer {
   export const type = 'feePayer'
 
+  export type Parameters = {
+    /** Policy for how the fee payer should handle transactions. Defaults to `'sign-only'`. */
+    policy?: 'sign-only' | 'sign-and-broadcast' | undefined
+  }
+
   export type ReturnValue = FeePayer
 }