tempo.ts 0.7.5 → 0.8.0

package/src/viem/Decorator.ts

@@ -100,6 +100,66 @@ export type Decorator<
     getLiquidityBalance: (
       parameters: ammActions.getLiquidityBalance.Parameters,
     ) => Promise<ammActions.getLiquidityBalance.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 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 { receipt, ...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>
     /**
      * Adds liquidity to a pool.
      *
@@ -117,14 +177,9 @@ export type Decorator<
      * }).extend(tempoActions())
      *
      * const hash = await client.amm.mint({
-     *   userToken: {
-     *     address: '0x...',
-     *     amount: 100n,
-     *   },
-     *   validatorToken: {
-     *     address: '0x...',
-     *     amount: 100n,
-     *   },
+     *   userTokenAddress: '0x...',
+     *   validatorTokenAddress: '0x...',
+     *   validatorTokenAmount: 100n,
      *   to: '0x...',
      * })
      * ```
@@ -152,14 +207,9 @@ export type Decorator<
      * }).extend(tempoActions())
      *
      * const result = await client.amm.mintSync({
-     *   userToken: {
-     *     address: '0x...',
-     *     amount: 100n,
-     *   },
-     *   validatorToken: {
-     *     address: '0x...',
-     *     amount: 100n,
-     *   },
+     *   userTokenAddress: '0x...',
+     *   validatorTokenAddress: '0x...',
+     *   validatorTokenAmount: 100n,
      *   to: '0x...',
      * })
      * ```
@@ -170,6 +220,116 @@ export type Decorator<
     mintSync: (
       parameters: ammActions.mintSync.Parameters<chain, account>,
     ) => Promise<ammActions.mintSync.ReturnValue>
+    /**
+     * Swaps tokens during a rebalance operation.
+     *
+     * @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>
+    /**
+     * Swaps tokens during a rebalance operation 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 { receipt, ...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>
+    /**
+     * Watches for burn (liquidity removal) 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
+    /**
+     * 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.
      *
@@ -195,6 +355,33 @@ export type Decorator<
      * @returns A function to unsubscribe from the event.
      */
     watchMint: (parameters: ammActions.watchMint.Parameters) => () => void
+    /**
+     * 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
   }
   dex: {
     /**
@@ -2706,9 +2893,20 @@ export function decorator() {
         getPool: (parameters) => ammActions.getPool(client, parameters),
         getLiquidityBalance: (parameters) =>
           ammActions.getLiquidityBalance(client, parameters),
+        burn: (parameters) => ammActions.burn(client, parameters),
+        burnSync: (parameters) => ammActions.burnSync(client, parameters),
         mint: (parameters) => ammActions.mint(client, parameters),
         mintSync: (parameters) => ammActions.mintSync(client, parameters),
+        rebalanceSwap: (parameters) =>
+          ammActions.rebalanceSwap(client, parameters),
+        rebalanceSwapSync: (parameters) =>
+          ammActions.rebalanceSwapSync(client, parameters),
+        watchBurn: (parameters) => ammActions.watchBurn(client, parameters),
+        watchFeeSwap: (parameters) =>
+          ammActions.watchFeeSwap(client, parameters),
         watchMint: (parameters) => ammActions.watchMint(client, parameters),
+        watchRebalanceSwap: (parameters) =>
+          ammActions.watchRebalanceSwap(client, parameters),
       },
       dex: {
         buy: (parameters) => dexActions.buy(client, parameters),

package/src/viem/Formatters.ts

@@ -12,6 +12,7 @@ import { parseAccount } from 'viem/accounts'
 import type { UnionOmit } from '../internal/types.js'
 import * as ox_Transaction from '../ox/Transaction.js'
 import * as ox_TransactionRequest from '../ox/TransactionRequest.js'
+import type { Account } from './Account.js'
 import type { GetFeeTokenParameter } from './internal/types.js'
 import {
   isTempo,
@@ -77,6 +78,7 @@ export function formatTransactionRequest<chain extends Chain | undefined>(
   action?: string | undefined,
 ): TransactionRequestRpc {
   const request = r as Request<chain>
+  const account = request.account as Account | undefined
 
   // Convert EIP-1559 transactions to AA transactions.
   if (request.type === 'eip1559') (request as any).type = 'aa'
@@ -91,7 +93,7 @@ export function formatTransactionRequest<chain extends Chain | undefined>(
   if (action)
     request.calls = request.calls ?? [
       {
-        to: r.to || undefined,
+        to: r.to || '0x0000000000000000000000000000000000000000',
         value: r.value,
         data: r.data,
       },
@@ -106,11 +108,10 @@ export function formatTransactionRequest<chain extends Chain | undefined>(
       s: BigInt(auth.s!),
       yParity: Number(auth.yParity),
     })),
-    nonce: request.nonce ? BigInt(request.nonce) : undefined,
     type: 'aa',
   } as never)
 
-  if (action === 'estimateGas' || action === 'fillTransaction') {
+  if (action === 'estimateGas') {
     rpc.maxFeePerGas = undefined
     rpc.maxPriorityFeePerGas = undefined
   }
@@ -140,12 +141,12 @@ export function formatTransactionRequest<chain extends Chain | undefined>(
   }
 
   const [keyType, keyData] = (() => {
-    if (!r.account?.source) return [undefined, undefined]
-    if (r.account.source === 'webAuthn')
+    const type = account?.keyType || account?.source
+    if (!type) return [undefined, undefined]
+    if (type === 'webAuthn')
       // TODO: derive correct bytes size of key data based on webauthn create metadata.
       return ['webAuthn', `0x${'ff'.repeat(1400)}`]
-    if (['p256', 'secp256k1'].includes(r.account.source))
-      return [r.account.source, undefined]
+    if (['p256', 'secp256k1'].includes(type)) return [type, undefined]
     return [undefined, undefined]
   })()
 

package/src/viem/Storage.ts

@@ -1,6 +1,8 @@
+import { createStore, del, get, set } from 'idb-keyval'
 import * as Json from 'ox/Json'
 
 import type { MaybePromise } from '../internal/types.js'
+import { normalizeValue } from './internal/utils.js'
 
 export type Storage<
   schema extends Record<string, unknown> = Record<string, unknown>,
@@ -33,6 +35,26 @@ export namespace from {
   }
 }
 
+export function idb<schema extends Record<string, unknown>>() {
+  const store =
+    typeof indexedDB !== 'undefined'
+      ? createStore('tempo.ts', 'store')
+      : undefined
+  return from<schema>({
+    async getItem(name) {
+      const value = await get(name, store)
+      if (value === null) return null
+      return value
+    },
+    async removeItem(name) {
+      await del(name, store)
+    },
+    async setItem(name, value) {
+      await set(name, normalizeValue(value), store)
+    },
+  })
+}
+
 export function localStorage<schema extends Record<string, unknown>>(
   options: localStorage.Options = {},
 ) {

package/src/viem/TokenIds.ts

@@ -1 +1 @@
-export const linkingUsd = 0n
+export const pathUsd = 0n

package/src/viem/Transaction.ts

@@ -29,6 +29,7 @@ import {
   type TransactionType as viem_TransactionType,
 } from 'viem'
 import type { ExactPartial, OneOf, PartialBy } from '../internal/types.js'
+import type * as KeyAuthorization from '../ox/KeyAuthorization.js'
 import * as SignatureEnvelope from '../ox/SignatureEnvelope.js'
 import * as TxAA from '../ox/TransactionEnvelopeAA.js'
 import type * as ox_TransactionReceipt from '../ox/TransactionReceipt.js'
@@ -43,7 +44,11 @@ export type Transaction<
 >
 export type TransactionRpc<pending extends boolean = false> = OneOf<
   | viem_RpcTransaction<pending>
-  | (Omit<TransactionAA<Hex.Hex, Hex.Hex, pending, '0x76'>, 'signature'> & {
+  | (Omit<
+      TransactionAA<Hex.Hex, Hex.Hex, pending, '0x76'>,
+      'keyAuthorization' | 'signature'
+    > & {
+      keyAuthorization?: KeyAuthorization.Rpc | null | undefined
       signature: SignatureEnvelope.SignatureEnvelopeRpc
     })
 >
@@ -66,6 +71,7 @@ export type TransactionAA<
   chainId: index
   feeToken?: Address | undefined
   feePayerSignature?: viem_Signature | undefined
+  keyAuthorization?: KeyAuthorization.Signed<quantity, index> | null | undefined
   nonceKey?: quantity | undefined
   signature: SignatureEnvelope.SignatureEnvelope
   type: type
@@ -109,9 +115,13 @@ export type TransactionRequestAA<
   ExactPartial<FeeValuesEIP1559<quantity>> & {
     accessList?: AccessList | undefined
     authorizationList?: AuthorizationList<index, boolean> | undefined
+    keyAuthorization?: KeyAuthorization.Signed<quantity, index> | undefined
     calls?: readonly TxAA.Call<quantity>[] | undefined
     feePayer?: Account | true | undefined
     feeToken?: Address | bigint | undefined
+    nonceKey?: 'random' | quantity | undefined
+    validBefore?: index | undefined
+    validAfter?: index | undefined
   }
 
 export type TransactionSerializable = OneOf<
@@ -129,6 +139,7 @@ export type TransactionSerializableAA<
     chainId: number
     feeToken?: Address | bigint | undefined
     feePayerSignature?: viem_Signature | null | undefined
+    keyAuthorization?: KeyAuthorization.Signed<quantity, index> | undefined
     nonceKey?: quantity | undefined
     signature?: SignatureEnvelope.SignatureEnvelope<quantity, index> | undefined
     validBefore?: index | undefined
@@ -151,6 +162,7 @@ export function getType(
     typeof transaction.calls !== 'undefined' ||
     typeof transaction.feePayer !== 'undefined' ||
     typeof transaction.feeToken !== 'undefined' ||
+    typeof transaction.nonceKey !== 'undefined' ||
     typeof transaction.signature !== 'undefined' ||
     typeof transaction.validBefore !== 'undefined' ||
     typeof transaction.validAfter !== 'undefined'
@@ -303,7 +315,7 @@ async function serializeAA(
       ? rest.calls
       : [
           {
-            to: rest.to || undefined,
+            to: rest.to || '0x0000000000000000000000000000000000000000',
             value: rest.value,
             data: rest.data,
           },

package/src/viem/WebAuthnP256.ts

@@ -117,15 +117,17 @@ export declare namespace createCredential {
 export async function getCredential(
   parameters: getCredential.Parameters,
 ): Promise<getCredential.ReturnValue> {
-  const { raw } = await WebAuthnP256.sign({
+  const { metadata, raw, signature } = await WebAuthnP256.sign({
     ...parameters,
     challenge: parameters.hash ?? '0x',
   })
   const publicKey = await parameters.getPublicKey(raw)
   return {
     id: raw.id,
+    metadata,
     publicKey,
     raw,
+    signature,
   }
 }
 
@@ -136,5 +138,9 @@ export declare namespace getCredential {
       credential: WebAuthnP256.P256Credential['raw'],
     ) => Promise<Hex.Hex>
   }
-  export type ReturnValue = P256Credential
+
+  export type ReturnValue = WebAuthnP256.sign.ReturnType & {
+    id: string
+    publicKey: Hex.Hex
+  }
 }