viem 2.47.12 → 2.47.15

package/actions/wallet/prepareTransactionRequest.ts

@@ -31,6 +31,7 @@ import {
 } from '../../errors/fee.js'
 import type { DeriveAccount, GetAccountParameter } from '../../types/account.js'
 import type { Block } from '../../types/block.js'
+import type { ExtractCapabilities } from '../../types/capabilities.js'
 import type {
   Chain,
   DeriveChain,
@@ -191,7 +192,12 @@ export type PrepareTransactionRequestReturnType<
         : (typeof defaultParameters)[number]
     >
   > &
-    (unknown extends request['kzg'] ? {} : Pick<request, 'kzg'>)
+    (unknown extends request['kzg'] ? {} : Pick<request, 'kzg'>) & {
+      // TODO(v3): Extract `prepareTransactionRequest` response into a named object of `{ capabilities, request }.
+      _capabilities?:
+        | ExtractCapabilities<'fillTransaction', 'ReturnType'>
+        | undefined
+    }
 >
 
 export type PrepareTransactionRequestErrorType =
@@ -426,6 +432,9 @@ export async function prepareTransactionRequest<
             rest.feePayerSignature !== null
               ? { feePayerSignature: rest.feePayerSignature }
               : {}),
+            ...(result.capabilities
+              ? { _capabilities: result.capabilities }
+              : {}),
           }
         })
         .catch((e) => {

package/actions/wallet/sendTransaction.ts

@@ -336,9 +336,12 @@ export async function sendTransaction<
       } as any)
 
       const serializer = chain?.serializers?.transaction
-      const serializedTransaction = (await account.signTransaction(request, {
-        serializer,
-      })) as Hash
+      const serializedTransaction = (await account.signTransaction(
+        request as never,
+        {
+          serializer,
+        },
+      )) as Hash
       return await getAction(
         client,
         sendRawTransaction,

package/actions/wallet/sendTransactionSync.ts

@@ -375,9 +375,12 @@ export async function sendTransactionSync<
       } as any)
 
       const serializer = chain?.serializers?.transaction
-      const serializedTransaction = (await account.signTransaction(request, {
-        serializer,
-      })) as Hash
+      const serializedTransaction = (await account.signTransaction(
+        request as never,
+        {
+          serializer,
+        },
+      )) as Hash
       return (await getAction(
         client,
         sendRawTransactionSync,

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.47.12'
+export const version = '2.47.15'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "2.47.12",
+  "version": "2.47.15",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",
@@ -217,7 +217,7 @@
     "@scure/bip39": "1.6.0",
     "abitype": "1.2.3",
     "isows": "1.0.7",
-    "ox": "0.14.13",
+    "ox": "0.14.15",
     "ws": "8.18.3"
   },
   "license": "MIT",

package/tempo/Capabilities.ts

@@ -1,9 +1,61 @@
+import type { Address } from 'abitype'
 import type { DefaultCapabilitiesSchema } from '../types/capabilities.js'
+import type { Hex } from '../types/misc.js'
 import type { ExactPartial } from '../types/utils.js'
 import type { TransactionRequestTempo } from './Transaction.js'
 
 export type Schema = Omit<DefaultCapabilitiesSchema, 'sendCalls'> & {
+  fillTransaction: {
+    ReturnType: FillTransactionCapabilities
+  }
   sendCalls: {
     Request: ExactPartial<TransactionRequestTempo>
   }
 }
+
+export type FillTransactionCapabilities = {
+  autoSwap?:
+    | {
+        maxIn: SwapAmount
+        minOut: SwapAmount
+        slippage: number
+      }
+    | undefined
+  balanceDiffs?: Readonly<Record<Address, readonly BalanceDiff[]>> | undefined
+  fee?:
+    | {
+        amount: Hex
+        decimals: number
+        formatted: string
+        symbol: string
+      }
+    | undefined
+  sponsor?:
+    | {
+        address: Address
+        name?: string | undefined
+        url?: string | undefined
+      }
+    | undefined
+  sponsored?: boolean | undefined
+}
+
+export type BalanceDiff = {
+  address: Address
+  decimals: number
+  direction: 'incoming' | 'outgoing'
+  formatted: string
+  name: string
+  recipients: readonly Address[]
+  symbol: string
+  value: Hex
+}
+
+export type SwapAmount = {
+  decimals: number
+  formatted: string
+  name: string
+  symbol: string
+  token: Address
+  value: Hex
+}

package/tempo/Decorator.ts

@@ -1,3 +1,4 @@
+import type { Address } from 'abitype'
 import type { Account } from '../accounts/types.js'
 import type { Client } from '../clients/createClient.js'
 import type { Transport } from '../clients/transports/createTransport.js'
@@ -10,6 +11,7 @@ import * as feeActions from './actions/fee.js'
 import * as nonceActions from './actions/nonce.js'
 import * as policyActions from './actions/policy.js'
 import * as rewardActions from './actions/reward.js'
+import * as simulateActions from './actions/simulate.js'
 import * as tokenActions from './actions/token.js'
 import * as validatorActions from './actions/validator.js'
 
@@ -2136,6 +2138,90 @@ export type Decorator<
       parameters: rewardActions.watchRewardRecipientSet.Parameters,
     ) => () => void
   }
+  simulate: {
+    /**
+     * Simulates a set of calls on block(s) via `tempo_simulateV1`.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http, parseUnits } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { Actions, tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({
+     *   account: '0x...',
+     *   chain: tempo,
+     *   transport: http(),
+     * }).extend(tempoActions())
+     *
+     * const { blocks, tokenMetadata } = await client.simulate.simulateBlocks({
+     *   blocks: [{
+     *     calls: [
+     *       Actions.token.transfer.call({
+     *         token: '0x20c0...01',
+     *         to: '0x...',
+     *         amount: parseUnits('100', 6),
+     *       }),
+     *     ],
+     *   }],
+     *   traceTransfers: true,
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns Simulated blocks and token metadata.
+     */
+    simulateBlocks: <const calls extends readonly unknown[]>(
+      parameters: simulateActions.simulateBlocks.Parameters<calls>,
+    ) => Promise<simulateActions.simulateBlocks.ReturnType<calls>>
+    /**
+     * Simulates execution of a batch of calls via `tempo_simulateV1`.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http, parseUnits } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { Actions, Addresses, tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({
+     *   account: '0x...',
+     *   chain: tempo,
+     *   transport: http(),
+     * }).extend(tempoActions())
+     *
+     * const { results, tokenMetadata } = await client.simulate.simulateCalls({
+     *   calls: [
+     *     Actions.token.approve.call({
+     *       token: '0x20c0...01',
+     *       spender: Addresses.stablecoinDex,
+     *       amount: parseUnits('100', 6),
+     *     }),
+     *     Actions.dex.buy.call({
+     *       tokenIn: '0x20c0...01',
+     *       tokenOut: '0x20c0...02',
+     *       amountOut: parseUnits('10', 6),
+     *       maxAmountIn: parseUnits('100', 6),
+     *     }),
+     *     Actions.token.transfer.call({
+     *       token: '0x20c0...02',
+     *       to: '0x...',
+     *       amount: parseUnits('10', 6),
+     *     }),
+     *   ],
+     *   traceTransfers: true,
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns Results, block, and token metadata.
+     */
+    simulateCalls: <
+      const calls extends readonly unknown[],
+      account extends Account | Address | undefined = undefined,
+    >(
+      parameters: simulateActions.simulateCalls.Parameters<calls, account>,
+    ) => Promise<simulateActions.simulateCalls.ReturnType<calls>>
+  }
   token: {
     /**
      * Approves a spender to transfer TIP20 tokens on behalf of the caller.
@@ -3866,6 +3952,12 @@ export function decorator() {
         watchRewardRecipientSet: (parameters) =>
           rewardActions.watchRewardRecipientSet(client, parameters),
       },
+      simulate: {
+        simulateBlocks: (parameters) =>
+          simulateActions.simulateBlocks(client, parameters),
+        simulateCalls: (parameters) =>
+          simulateActions.simulateCalls(client, parameters),
+      },
       token: {
         approve: (parameters) => tokenActions.approve(client, parameters),
         approveSync: (parameters) =>

package/tempo/Formatters.ts

@@ -126,6 +126,8 @@ export function formatTransactionRequest(
       ? account.accessKeyAddress
       : undefined
 
+  if (account) rpc.from = account.address
+
   return {
     ...rpc,
     ...(keyData ? { keyData } : {}),

package/tempo/actions/index.ts

@@ -7,5 +7,6 @@ export * as fee from './fee.js'
 export * as nonce from './nonce.js'
 export * as policy from './policy.js'
 export * as reward from './reward.js'
+export * as simulate from './simulate.js'
 export * as token from './token.js'
 export * as validator from './validator.js'