viem 3.0.0-next.10 → 3.0.0-next.13

package/src/tempo/actions/propAmm.ts

@@ -0,0 +1,985 @@
+import { AbiEvent, Address, Hex } from 'ox'
+import type { Errors } from 'ox'
+import * as Account from '../../core/Account.js'
+import type * as Chain from '../../core/Chain.js'
+import type * as Client from '../../core/Client.js'
+import { estimateGas as core_estimateGas } from '../../core/actions/transaction/estimateGas.js'
+import { read } from '../../core/actions/contract/read.js'
+import { send } from '../../core/actions/transaction/send.js'
+import { sendSync } from '../../core/actions/transaction/sendSync.js'
+import { multicall } from '../../core/actions/multicall.js'
+import type { Compute, UnionOmit } from '../../core/internal/types.js'
+import * as Abis from '../Abis.js'
+import * as Expiry from '../Expiry.js'
+import type { ReadParameters, WriteParameters } from '../internal/types.js'
+import {
+  defineCall,
+  dispatchSend,
+  pickWriteParameters,
+} from '../internal/utils.js'
+import type { TransactionReceipt } from '../chainConfig.js'
+import * as tokenActions from './token/index.js'
+
+/**
+ * Reads the base token of a propAMM pool.
+ *
+ * @example
+ * ```ts
+ * import { Client, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = Client.create({ chain: tempo, transport: http() })
+ *
+ * const token = await Actions.propAmm.baseToken(client, { pool: '0x...' })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Pool and read options.
+ * @returns Base token address.
+ */
+export async function baseToken<chain extends Chain.Chain | undefined>(
+  client: Client.Client<chain>,
+  parameters: baseToken.Parameters,
+): Promise<baseToken.ReturnValue> {
+  const { pool, ...rest } = parameters
+  return read(client, { ...rest, ...baseToken.call({ pool }) })
+}
+
+export namespace baseToken {
+  export type Args = {
+    /** Pool address. */
+    pool: Address.Address
+  }
+
+  export type Parameters = ReadParameters & Args
+
+  export type ReturnValue = read.ReturnType<
+    typeof Abis.directPropAmm,
+    'baseToken'
+  >
+
+  /**
+   * Defines the pool's `baseToken` call.
+   */
+  export function call({ pool }: Args) {
+    return defineCall({
+      abi: Abis.directPropAmm,
+      address: pool,
+      functionName: 'baseToken',
+    })
+  }
+}
+
+/**
+ * Reads the quote token of a propAMM pool.
+ *
+ * @example
+ * ```ts
+ * import { Client, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = Client.create({ chain: tempo, transport: http() })
+ *
+ * const token = await Actions.propAmm.quoteToken(client, { pool: '0x...' })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Pool and read options.
+ * @returns Quote token address.
+ */
+export async function quoteToken<chain extends Chain.Chain | undefined>(
+  client: Client.Client<chain>,
+  parameters: quoteToken.Parameters,
+): Promise<quoteToken.ReturnValue> {
+  const { pool, ...rest } = parameters
+  return read(client, { ...rest, ...quoteToken.call({ pool }) })
+}
+
+export namespace quoteToken {
+  export type Args = {
+    /** Pool address. */
+    pool: Address.Address
+  }
+
+  export type Parameters = ReadParameters & Args
+
+  export type ReturnValue = read.ReturnType<
+    typeof Abis.directPropAmm,
+    'quoteToken'
+  >
+
+  /**
+   * Defines the pool's `quoteToken` call.
+   */
+  export function call({ pool }: Args) {
+    return defineCall({
+      abi: Abis.directPropAmm,
+      address: pool,
+      functionName: 'quoteToken',
+    })
+  }
+}
+
+/**
+ * Reads whether a propAMM pool is paused.
+ *
+ * @example
+ * ```ts
+ * import { Client, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = Client.create({ chain: tempo, transport: http() })
+ *
+ * const isPaused = await Actions.propAmm.paused(client, { pool: '0x...' })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Pool and read options.
+ * @returns Whether swaps are paused.
+ */
+export async function paused<chain extends Chain.Chain | undefined>(
+  client: Client.Client<chain>,
+  parameters: paused.Parameters,
+): Promise<paused.ReturnValue> {
+  const { pool, ...rest } = parameters
+  return read(client, { ...rest, ...paused.call({ pool }) })
+}
+
+export namespace paused {
+  export type Args = {
+    /** Pool address. */
+    pool: Address.Address
+  }
+
+  export type Parameters = ReadParameters & Args
+
+  export type ReturnValue = read.ReturnType<typeof Abis.directPropAmm, 'paused'>
+
+  /**
+   * Defines the pool's `paused` call.
+   */
+  export function call({ pool }: Args) {
+    return defineCall({
+      abi: Abis.directPropAmm,
+      address: pool,
+      functionName: 'paused',
+    })
+  }
+}
+
+/**
+ * Reads whether an address may call swaps on a pool.
+ *
+ * @example
+ * ```ts
+ * import { Client, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = Client.create({ chain: tempo, transport: http() })
+ *
+ * const allowed = await Actions.propAmm.takerAllowed(client, { pool: '0x...', taker: '0x...' })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Pool, taker, and read options.
+ * @returns Whether the taker is allowed.
+ */
+export async function takerAllowed<chain extends Chain.Chain | undefined>(
+  client: Client.Client<chain>,
+  parameters: takerAllowed.Parameters,
+): Promise<takerAllowed.ReturnValue> {
+  const { pool, taker, ...rest } = parameters
+  return read(client, {
+    ...rest,
+    ...takerAllowed.call({ pool, taker }),
+  })
+}
+
+export namespace takerAllowed {
+  export type Args = {
+    /** Pool address. */
+    pool: Address.Address
+    /** Address that calls the swap. */
+    taker: Address.Address
+  }
+
+  export type Parameters = ReadParameters & Args
+
+  export type ReturnValue = read.ReturnType<
+    typeof Abis.directPropAmm,
+    'takerAllowed'
+  >
+
+  /**
+   * Defines the pool's `takerAllowed` call.
+   */
+  export function call({ pool, taker }: Args) {
+    return defineCall({
+      abi: Abis.directPropAmm,
+      address: pool,
+      args: [taker],
+      functionName: 'takerAllowed',
+    })
+  }
+}
+
+/**
+ * Reads whether a resolved address may receive swap output.
+ *
+ * @example
+ * ```ts
+ * import { Client, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = Client.create({ chain: tempo, transport: http() })
+ *
+ * const allowed = await Actions.propAmm.recipientAllowed(client, { pool: '0x...', recipient: '0x...' })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Pool, resolved recipient, and read options.
+ * @returns Whether the resolved recipient is allowed.
+ */
+export async function recipientAllowed<chain extends Chain.Chain | undefined>(
+  client: Client.Client<chain>,
+  parameters: recipientAllowed.Parameters,
+): Promise<recipientAllowed.ReturnValue> {
+  const { pool, recipient, ...rest } = parameters
+  return read(client, {
+    ...rest,
+    ...recipientAllowed.call({ pool, recipient }),
+  })
+}
+
+export namespace recipientAllowed {
+  export type Args = {
+    /** Pool address. */
+    pool: Address.Address
+    /** Resolved address to check. */
+    recipient: Address.Address
+  }
+
+  export type Parameters = ReadParameters & Args
+
+  export type ReturnValue = read.ReturnType<
+    typeof Abis.directPropAmm,
+    'recipientAllowed'
+  >
+
+  /**
+   * Defines the pool's `recipientAllowed` call.
+   */
+  export function call({ pool, recipient }: Args) {
+    return defineCall({
+      abi: Abis.directPropAmm,
+      address: pool,
+      args: [recipient],
+      functionName: 'recipientAllowed',
+    })
+  }
+}
+
+/**
+ * Resolves a Tempo recipient to the address checked by the pool's allowlist.
+ *
+ * @example
+ * ```ts
+ * import { Client, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = Client.create({ chain: tempo, transport: http() })
+ *
+ * const resolved = await Actions.propAmm.resolveRecipient(client, { pool: '0x...', recipient: '0x...' })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Pool, recipient, and read options.
+ * @returns Resolved recipient address.
+ */
+export async function resolveRecipient<chain extends Chain.Chain | undefined>(
+  client: Client.Client<chain>,
+  parameters: resolveRecipient.Parameters,
+): Promise<resolveRecipient.ReturnValue> {
+  const { pool, recipient, ...rest } = parameters
+  return read(client, {
+    ...rest,
+    ...resolveRecipient.call({ pool, recipient }),
+  })
+}
+
+export namespace resolveRecipient {
+  export type Args = {
+    /** Pool address. */
+    pool: Address.Address
+    /** Destination provided to the swap. */
+    recipient: Address.Address
+  }
+
+  export type Parameters = ReadParameters & Args
+
+  export type ReturnValue = read.ReturnType<
+    typeof Abis.directPropAmm,
+    'resolveRecipient'
+  >
+
+  /**
+   * Defines the pool's `resolveRecipient` call.
+   */
+  export function call({ pool, recipient }: Args) {
+    return defineCall({
+      abi: Abis.directPropAmm,
+      address: pool,
+      args: [recipient],
+      functionName: 'resolveRecipient',
+    })
+  }
+}
+
+/**
+ * Quotes an exact input or exact output for a caller, recipient, and customer route.
+ *
+ * @example
+ * ```ts
+ * import { Client, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = Client.create({ chain: tempo, transport: http() })
+ *
+ * const { amountOut, price, updatedAt } = await Actions.propAmm.getSwapQuote(client, {
+ *   pool: '0x...',
+ *   taker: '0x...',
+ *   recipient: '0x...',
+ *   mode: 'exactInput',
+ *   amountIn: 1_000_000n,
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Route, swap mode, amount, and read options. Taker defaults to the read or client account.
+ * @returns Quoted amount, oracle observation, rounding credit, and swap request.
+ */
+export async function getSwapQuote<
+  chain extends Chain.Chain | undefined,
+  const parameters extends getSwapQuote.Parameters,
+>(
+  client: Client.Client<chain>,
+  parameters: parameters,
+): Promise<getSwapQuote.ReturnValue<parameters>>
+export async function getSwapQuote(
+  client: Client.Client,
+  parameters: getSwapQuote.Parameters,
+): Promise<getSwapQuote.ReturnValue> {
+  const account = parameters.account ?? client.account
+  const taker = parameters.taker ?? (account && Account.from(account).address)
+  if (!taker) throw new Error('A taker or client account is required to quote.')
+  const recipient =
+    parameters.recipient ?? (account && Account.from(account).address)
+  if (!recipient) throw new Account.NotFoundError()
+  const baseToQuote = parameters.baseToQuote ?? true
+  const customerId = parameters.customerId ?? Hex.padLeft(taker, 32)
+  const quote = {
+    ...parameters,
+    baseToQuote,
+    customerId,
+    recipient,
+    taker,
+  }
+  const [amount, price, updatedAt, creditAfter] =
+    quote.mode === 'exactInput'
+      ? await read(client, {
+          ...parameters,
+          ...getSwapQuote.call(quote),
+          as: 'Array',
+        })
+      : await read(client, {
+          ...parameters,
+          ...getSwapQuote.call(quote),
+          as: 'Array',
+        })
+  const request = {
+    baseToQuote,
+    customerId,
+    expectedOraclePrice: price,
+    minimumOracleUpdatedAt: updatedAt,
+    oraclePriceToleranceBps: 0n,
+    pool: parameters.pool,
+    recipient,
+  }
+  if (parameters.mode === 'exactInput')
+    return {
+      amountOut: amount,
+      price,
+      updatedAt,
+      creditAfter,
+      request: {
+        ...request,
+        amountIn: parameters.amountIn,
+        minAmountOut: amount,
+        mode: parameters.mode,
+      },
+    }
+  return {
+    amountIn: amount,
+    price,
+    updatedAt,
+    creditAfter,
+    request: {
+      ...request,
+      amountOut: parameters.amountOut,
+      maxAmountIn: amount,
+      mode: parameters.mode,
+    },
+  }
+}
+
+export namespace getSwapQuote {
+  export type Args = {
+    /** True sends base and receives quote; false sends quote and receives base. */
+    baseToQuote: boolean
+    /** Nonzero attribution and rounding-route identifier. */
+    customerId: Hex.Hex
+    /** Pool address. */
+    pool: Address.Address
+    /** Destination of the output token. */
+    recipient: Address.Address
+    /** Address that will call the swap. */
+    taker: Address.Address
+  } & (
+    | {
+        /** Exact-input quote. */
+        mode: 'exactInput'
+        /** Input amount in token base units. */
+        amountIn: bigint
+      }
+    | {
+        /** Exact-output quote. */
+        mode: 'exactOutput'
+        /** Output amount in token base units. */
+        amountOut: bigint
+      }
+  )
+
+  export type Parameters = ReadParameters &
+    UnionOmit<Args, 'baseToQuote' | 'customerId' | 'recipient' | 'taker'> & {
+      /** True sends base and receives quote. Defaults to true. */
+      baseToQuote?: boolean | undefined
+      /** Route identifier. Defaults to the taker address left-padded to 32 bytes. */
+      customerId?: Hex.Hex | undefined
+      /** Output destination. Defaults to the read account or client account. */
+      recipient?: Address.Address | undefined
+      /** Address that will call the swap. Defaults to the read account or client account. */
+      taker?: Address.Address | undefined
+    }
+
+  /** Quoted amount, oracle observation, rounding credit, and swap request. */
+
+  export type ReturnValue<parameters extends Parameters = Parameters> = Compute<
+    {
+      /** Oracle price used for the quote. */
+      price: bigint
+      /** Oracle observation timestamp. */
+      updatedAt: bigint
+      /** Route's remaining rounding credit. */
+      creditAfter: bigint
+    } & (parameters extends { mode: 'exactInput' }
+      ? {
+          /** Quoted output amount in token base units. */
+          amountOut: bigint
+          /** Swap inputs bound to this quote. */
+          request: Omit<
+            Extract<swap.Args, { mode: 'exactInput' }>,
+            'deadline' | 'tradeId'
+          >
+        }
+      : {
+          /** Required input amount in token base units. */
+          amountIn: bigint
+          /** Swap inputs bound to this quote. */
+          request: Omit<
+            Extract<swap.Args, { mode: 'exactOutput' }>,
+            'deadline' | 'tradeId'
+          >
+        })
+  >
+
+  /**
+   * Defines a route-aware quote call.
+   */
+  export function call(
+    parameters: Extract<Args, { mode: 'exactInput' }>,
+  ): ReturnType<typeof quoteExactInputCall>
+  export function call(
+    parameters: Extract<Args, { mode: 'exactOutput' }>,
+  ): ReturnType<typeof quoteExactOutputCall>
+  export function call(
+    parameters: Args,
+  ):
+    | ReturnType<typeof quoteExactInputCall>
+    | ReturnType<typeof quoteExactOutputCall>
+  export function call(parameters: Args) {
+    if (parameters.mode === 'exactInput') return quoteExactInputCall(parameters)
+    return quoteExactOutputCall(parameters)
+  }
+}
+
+function quoteExactInputCall(
+  parameters: Extract<getSwapQuote.Args, { mode: 'exactInput' }>,
+) {
+  const { amountIn, baseToQuote, customerId, pool, recipient, taker } =
+    parameters
+  return defineCall({
+    abi: Abis.directPropAmm,
+    address: pool,
+    args: [taker, recipient, customerId, baseToQuote, amountIn],
+    functionName: 'quoteExactInputFor',
+  })
+}
+
+function quoteExactOutputCall(
+  parameters: Extract<getSwapQuote.Args, { mode: 'exactOutput' }>,
+) {
+  const { amountOut, baseToQuote, customerId, pool, recipient, taker } =
+    parameters
+  return defineCall({
+    abi: Abis.directPropAmm,
+    address: pool,
+    args: [taker, recipient, customerId, baseToQuote, amountOut],
+    functionName: 'quoteExactOutputFor',
+  })
+}
+
+/**
+ * Internal exact-input contract call.
+ */
+namespace exactInput {
+  export type Args = {
+    amountIn: bigint
+    baseToQuote: boolean
+    customerId: Hex.Hex
+    deadline: bigint
+    expectedOraclePrice: bigint
+    minAmountOut: bigint
+    minimumOracleUpdatedAt: bigint
+    oraclePriceToleranceBps: bigint
+    pool: Address.Address
+    recipient: Address.Address
+    tradeId: Hex.Hex
+  }
+
+  export function call({
+    amountIn,
+    baseToQuote,
+    customerId,
+    deadline,
+    expectedOraclePrice,
+    minAmountOut,
+    minimumOracleUpdatedAt,
+    oraclePriceToleranceBps,
+    pool,
+    recipient,
+    tradeId,
+  }: Args) {
+    return defineCall({
+      abi: Abis.directPropAmm,
+      address: pool,
+      args: [
+        baseToQuote,
+        amountIn,
+        minAmountOut,
+        recipient,
+        customerId,
+        tradeId,
+        deadline,
+        expectedOraclePrice,
+        oraclePriceToleranceBps,
+        minimumOracleUpdatedAt,
+      ],
+      functionName: 'swapExactInput',
+    })
+  }
+}
+
+/**
+ * Internal exact-output contract call.
+ */
+namespace exactOutput {
+  export type Args = {
+    amountOut: bigint
+    baseToQuote: boolean
+    customerId: Hex.Hex
+    deadline: bigint
+    expectedOraclePrice: bigint
+    maxAmountIn: bigint
+    minimumOracleUpdatedAt: bigint
+    oraclePriceToleranceBps: bigint
+    pool: Address.Address
+    recipient: Address.Address
+    tradeId: Hex.Hex
+  }
+
+  export function call({
+    amountOut,
+    baseToQuote,
+    customerId,
+    deadline,
+    expectedOraclePrice,
+    maxAmountIn,
+    minimumOracleUpdatedAt,
+    oraclePriceToleranceBps,
+    pool,
+    recipient,
+    tradeId,
+  }: Args) {
+    return defineCall({
+      abi: Abis.directPropAmm,
+      address: pool,
+      args: [
+        baseToQuote,
+        amountOut,
+        maxAmountIn,
+        recipient,
+        customerId,
+        tradeId,
+        deadline,
+        expectedOraclePrice,
+        oraclePriceToleranceBps,
+        minimumOracleUpdatedAt,
+      ],
+      functionName: 'swapExactOutput',
+    })
+  }
+}
+
+/**
+ * Approves the input token and swaps through an allowed propAMM pool in one transaction.
+ *
+ * @example
+ * ```ts
+ * import { Client, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = Client.create({ chain: tempo, transport: http(), account: '0x...' })
+ *
+ * const hash = await Actions.propAmm.swap(client, {
+ *   pool: '0x...',
+ *   mode: 'exactInput',
+ *   amountIn: 1_000_000n,
+ *   minAmountOut: 1_000_000n,
+ *   expectedOraclePrice: 1_000_000_000_000_000_000n,
+ *   minimumOracleUpdatedAt: 1_799_999_000n,
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Swap and transaction options.
+ * @returns Transaction hash.
+ */
+export async function swap<
+  chain extends Chain.Chain | undefined,
+  account extends Account.Account | undefined,
+>(
+  client: Client.Client<chain, account>,
+  parameters: swap.Parameters<chain, account>,
+): Promise<swap.ReturnValue> {
+  return swap.inner(send, client, parameters)
+}
+
+export namespace swap {
+  export type Args = {
+    /** True sends base and receives quote; false sends quote and receives base. */
+    baseToQuote: boolean
+    /** Nonzero attribution and rounding-route identifier. */
+    customerId: Hex.Hex
+    /** Last accepted execution timestamp in seconds. */
+    deadline: bigint
+    /** Oracle price returned by the quote. */
+    expectedOraclePrice: bigint
+    /** Earliest accepted oracle observation timestamp. */
+    minimumOracleUpdatedAt: bigint
+    /** Accepted oracle-price movement in basis points. Zero binds exactly. */
+    oraclePriceToleranceBps: bigint
+    /** Pool address. */
+    pool: Address.Address
+    /** Destination of the output token. */
+    recipient: Address.Address
+    /** Trade attribution value, not replay protection. */
+    tradeId: Hex.Hex
+  } & (
+    | {
+        /** Exact-input swap. */
+        mode: 'exactInput'
+        /** Exact input amount in token base units. */
+        amountIn: bigint
+        /** Lowest accepted output in token base units. */
+        minAmountOut: bigint
+      }
+    | {
+        /** Exact-output swap. */
+        mode: 'exactOutput'
+        /** Exact output amount in token base units. */
+        amountOut: bigint
+        /** Highest accepted input in token base units; unused approval remains. */
+        maxAmountIn: bigint
+      }
+  )
+
+  export type InputArgs = UnionOmit<
+    Args,
+    | 'baseToQuote'
+    | 'customerId'
+    | 'deadline'
+    | 'oraclePriceToleranceBps'
+    | 'recipient'
+    | 'tradeId'
+  > & {
+    /** True sends base and receives quote. Defaults to true. */
+    baseToQuote?: boolean | undefined
+    /** Route identifier. Defaults to the sender address left-padded to 32 bytes. */
+    customerId?: Hex.Hex | undefined
+    /** Last accepted execution timestamp. Defaults to five minutes from now. */
+    deadline?: bigint | undefined
+    /** Output destination. Defaults to the sending account. */
+    recipient?: Address.Address | undefined
+    /** Accepted oracle-price movement in basis points. Defaults to zero. */
+    oraclePriceToleranceBps?: bigint | undefined
+    /** Trade attribution value. Defaults to a random 32-byte value per swap. */
+    tradeId?: Hex.Hex | undefined
+  }
+
+  export type Parameters<
+    chain extends Chain.Chain | undefined = Chain.Chain | undefined,
+    account extends Account.Account | undefined = Account.Account | undefined,
+  > = WriteParameters &
+    InputArgs &
+    ([chain, account] extends [unknown, unknown] ? unknown : never)
+
+  export type ReturnValue = send.ReturnType
+
+  export type ErrorType = Errors.GlobalErrorType
+
+  /** @internal */
+  export async function inner<
+    action extends typeof send | typeof sendSync,
+    chain extends Chain.Chain | undefined,
+    account extends Account.Account | undefined,
+  >(
+    action: action,
+    client: Client.Client<chain, account>,
+    parameters: Parameters<chain, account>,
+  ): Promise<dispatchSend.ReturnType<action>> {
+    return await dispatchSend(action, client, {
+      ...parameters,
+      calls: await getCalls(client, parameters),
+    })
+  }
+
+  async function getCalls<
+    chain extends Chain.Chain | undefined,
+    account extends Account.Account | undefined,
+  >(
+    client: Client.Client<chain, account>,
+    parameters: InputArgs & {
+      account?: Account.Account | Address.Address | null | undefined
+    },
+  ) {
+    const account = parameters.account ?? client.account
+    const recipient =
+      parameters.recipient ?? (account && Account.from(account).address)
+    if (!recipient) throw new Account.NotFoundError()
+    const customerId =
+      parameters.customerId ??
+      (account && Hex.padLeft(Account.from(account).address, 32))
+    if (!customerId) throw new Account.NotFoundError()
+    const baseToQuote = parameters.baseToQuote ?? true
+    const tokenIn = await (baseToQuote
+      ? baseToken(client, { pool: parameters.pool })
+      : quoteToken(client, { pool: parameters.pool }))
+    const amount =
+      parameters.mode === 'exactInput'
+        ? parameters.amountIn
+        : parameters.maxAmountIn
+    return [
+      tokenActions.approve.call(client, {
+        amount,
+        spender: parameters.pool,
+        token: tokenIn,
+      }),
+      swap.call({
+        ...parameters,
+        baseToQuote,
+        customerId,
+        deadline: parameters.deadline ?? BigInt(Expiry.minutes(5)),
+        tradeId: parameters.tradeId ?? Hex.random(32),
+        recipient,
+        oraclePriceToleranceBps: parameters.oraclePriceToleranceBps ?? 0n,
+      }),
+    ] as const
+  }
+
+  /**
+   * Estimates gas for the approval and swap transaction.
+   *
+   * @param client - Client.
+   * @param parameters - Swap and transaction options.
+   * @returns The gas estimate.
+   */
+  export async function estimateGas<
+    chain extends Chain.Chain | undefined,
+    account extends Account.Account | undefined,
+  >(
+    client: Client.Client<chain, account>,
+    parameters: Parameters<chain, account>,
+  ): Promise<bigint> {
+    return core_estimateGas(client, {
+      ...pickWriteParameters(parameters),
+      calls: await getCalls(client, parameters),
+    } as core_estimateGas.Options & {
+      calls: Awaited<ReturnType<typeof getCalls>>
+    })
+  }
+
+  /**
+   * Simulates the approval and swap calls without submitting a transaction.
+   *
+   * @param client - Client.
+   * @param parameters - Swap and simulation options.
+   * @returns The approval and swap simulation results.
+   */
+  export async function simulate<
+    chain extends Chain.Chain | undefined,
+    account extends Account.Account | undefined,
+  >(client: Client.Client<chain, account>, parameters: simulate.Parameters) {
+    const { blockNumber, blockTag, stateOverride, traceTransfers, validation } =
+      parameters
+    return multicall(client, {
+      mode: 'simulate',
+      account: parameters.account ?? client.account,
+      ...(blockNumber === undefined ? { blockTag } : { blockNumber }),
+      calls: await getCalls(client, parameters),
+      stateOverride,
+      traceTransfers,
+      validation,
+    })
+  }
+
+  export namespace simulate {
+    /** Swap inputs and batch simulation options. */
+    export type Parameters = InputArgs &
+      Omit<multicall.Options<readonly unknown[], 'simulate'>, 'calls' | 'mode'>
+  }
+
+  /**
+   * Defines the raw swap call without its input-token approval.
+   */
+  export function call(
+    parameters: Extract<Args, { mode: 'exactInput' }>,
+  ): ReturnType<typeof exactInput.call>
+  export function call(
+    parameters: Extract<Args, { mode: 'exactOutput' }>,
+  ): ReturnType<typeof exactOutput.call>
+  export function call(
+    parameters: Args,
+  ): ReturnType<typeof exactInput.call> | ReturnType<typeof exactOutput.call>
+  export function call(parameters: Args) {
+    if (parameters.mode === 'exactInput') return exactInput.call(parameters)
+    return exactOutput.call(parameters)
+  }
+
+  /**
+   * Extracts the unique matching trade event from a receipt.
+   */
+  export function extractEvent(
+    logs: readonly (AbiEvent.extractLogs.Log & { address: Address.Address })[],
+    args: { pool: Address.Address; tradeId: Hex.Hex },
+  ) {
+    const matching = AbiEvent.extractLogs(Abis.directPropAmm, logs, {
+      eventName: 'TradeExecuted',
+      strict: true,
+    }).filter(
+      (log) =>
+        Address.isEqual(log.address, args.pool) &&
+        log.args.tradeId.toLowerCase() === args.tradeId.toLowerCase(),
+    )
+    if (matching.length !== 1)
+      throw new Error(
+        `Expected one TradeExecuted event for pool ${args.pool} and trade ${args.tradeId}; found ${matching.length}.`,
+      )
+    return matching[0]!
+  }
+}
+
+/**
+ * Approves the input token, swaps, and returns the confirmed trade and receipt.
+ *
+ * @example
+ * ```ts
+ * import { Client, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = Client.create({ chain: tempo, transport: http(), account: '0x...' })
+ *
+ * const trade = await Actions.propAmm.swapSync(client, {
+ *   pool: '0x...',
+ *   mode: 'exactInput',
+ *   amountIn: 1_000_000n,
+ *   minAmountOut: 1_000_000n,
+ *   expectedOraclePrice: 1_000_000_000_000_000_000n,
+ *   minimumOracleUpdatedAt: 1_799_999_000n,
+ * })
+ * console.log(trade.amountOut, trade.receipt.transactionHash)
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Swap and transaction options.
+ * @returns Confirmed trade data and receipt.
+ */
+export async function swapSync<
+  chain extends Chain.Chain | undefined,
+  account extends Account.Account | undefined,
+>(
+  client: Client.Client<chain, account>,
+  parameters: swapSync.Parameters<chain, account>,
+): Promise<swapSync.ReturnValue> {
+  const {
+    tradeId = Hex.random(32),
+    throwOnReceiptRevert = true,
+    ...rest
+  } = parameters
+  const receipt = await swap.inner(sendSync, client, {
+    ...rest,
+    throwOnReceiptRevert,
+    tradeId,
+  })
+  if ((receipt as TransactionReceipt).status === 'pending')
+    return { receipt } as swapSync.ReturnValue
+  const { args } = swap.extractEvent(receipt.logs, {
+    pool: parameters.pool,
+    tradeId,
+  })
+  return { ...args, receipt }
+}
+
+export namespace swapSync {
+  export type Args = swap.InputArgs
+
+  export type Parameters<
+    chain extends Chain.Chain | undefined = Chain.Chain | undefined,
+    account extends Account.Account | undefined = Account.Account | undefined,
+  > = swap.Parameters<chain, account>
+
+  export type ReturnValue = Compute<
+    ReturnType<typeof swap.extractEvent>['args'] & {
+      /** Confirmed receipt. */
+      receipt: TransactionReceipt
+    }
+  >
+}