Rebalance AMM Swap

Performs a rebalance swap from validator token to user token.

The swap pulls the validator token from the caller without requiring an approval.

Usage

import { client } from './viem.config'
 
const { receipt, ...event } = await client.amm.rebalanceSwapSync({
  amountOut: 1000000n,
  to: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbb',
  userToken: '0x20c0000000000000000000000000000000000001',
  validatorToken: '0x20c0000000000000000000000000000000000002',
})
 
console.log('Rebalance swap:', event)
Rebalance swap: { userToken: '0x20c0000000000000000000000000000000000001', validatorToken: '0x20c0000000000000000000000000000000000002', swapper: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266', amountIn: 1001000n, amountOut: 1000000n }

import { Account, Client } from 'viem/tempo'
 
export const client = Client.create({
  account: Account.fromSecp256k1('0x...'),
})

Asynchronous Usage

The examples above use a *Sync variant of the action, that will wait for the transaction to be included before returning.

If you are optimizing for performance, you should use the non-sync amm.rebalanceSwap action and wait for inclusion manually:

import { Actions } from 'viem/tempo'
import { client } from './viem.config'
 
const hash = await client.amm.rebalanceSwap({
  amountOut: 1000000n,
  to: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbb',
  userToken: '0x20c0000000000000000000000000000000000001',
  validatorToken: '0x20c0000000000000000000000000000000000002',
})
const receipt = await client.transaction.waitForReceipt({ hash }).receipt
 
const { args } = Actions.amm.rebalanceSwap.extractEvent(receipt.logs)

Recipes

Size a Rebalance from Pool Reserves

Combine amm.getPool with rebalanceSwapSync to withdraw the user tokens that fee flows accumulated and restore the pool's validator reserve.

import { client } from './viem.config'
 
const userToken = '0x20c0000000000000000000000000000000000001'
const validatorToken = '0x20c0000000000000000000000000000000000002'
 
const pool = await client.amm.getPool({ userToken, validatorToken })
 
// Half the reserve gap restores parity: the swap adds validator
// tokens and removes user tokens in roughly equal measure.
const amountOut =
  (pool.reserveUserToken - pool.reserveValidatorToken) / 2n
 
if (amountOut > 0n) {
  await client.amm.rebalanceSwapSync({
    amountOut,
    to: client.account.address,
    userToken,
    validatorToken,
  })
}

import { Account, Client } from 'viem/tempo'
 
export const client = Client.create({
  account: Account.fromSecp256k1('0x...'),
})

Record the Cost of a Rebalance

Read amountIn from the result to book the validator tokens the swap pulled against the user tokens received.

import { client } from './viem.config'
 
const { amountIn, amountOut } = await client.amm.rebalanceSwapSync({
  amountOut: 1_000_000000n,
  to: '0x8ba1f109551bD432803012645Ac136ddd64DBA72',
  userToken: '0x20c0000000000000000000000000000000000001',
  validatorToken: '0x20c0000000000000000000000000000000000002',
})
 
console.log('Spent:', amountIn, 'Received:', amountOut)
Spent: 1001000000n Received: 1000000000n

import { Account, Client } from 'viem/tempo'
 
export const client = Client.create({
  account: Account.fromSecp256k1('0x...'),
})

Return Value

type ReturnType = {
  /** User token address. */
  userToken: Address
  /** Validator token address. */
  validatorToken: Address
  /** Address that performed the swap. */
  swapper: Address
  /** Amount of validator token spent. */
  amountIn: bigint
  /** Amount of user token received. */
  amountOut: bigint
  /** Transaction receipt. */
  receipt: TransactionReceipt
}

The transaction receipt and decoded RebalanceSwap event data.

Parameters

amountOut

• Type: bigint

Amount of user token to receive.

to

• Type: Address

Address to send the user token to.

userToken

• Type: Address | bigint

Address or ID of the user token.

validatorToken

• Type: Address | bigint

Address or ID of the validator token.

account (optional)

• Type: Account | Address

Account that will be used to send the transaction.

feePayer (optional)

• Type: Account | boolean

Fee payer for the transaction (TIP-1 gas sponsorship).

Pass true to defer the fee token to an external fee payer (e.g. a relay), or a local Account to co-sign the transaction as the fee payer.

feeToken (optional)

• Type: Address | bigint

Fee token for the transaction.

Can be an unpaused USD-denominated TIP-20 token address or ID.

gas (optional)

• Type: bigint

Gas limit for the transaction.

keyAuthorization (optional)

• Type: KeyAuthorization

Signed key authorization to include with the transaction, authorizing an access key to act for the sending account.

maxFeePerGas (optional)

• Type: bigint

Max fee per gas for the transaction.

maxPriorityFeePerGas (optional)

• Type: bigint

Max priority fee per gas for the transaction.

nonce (optional)

• Type: number

Nonce for the transaction.

nonceKey (optional)

• Type: 'expiring' | 'random' | bigint

Nonce key for the transaction (TIP-1009 2D nonces).

Use 'expiring' to select an expiring nonce, which enables concurrent transaction submission without nonce ordering. Use 'random' to select a random key.

throwOnReceiptRevert (optional)

• Type: boolean
• Default: true

Whether a Sync action throws when the receipt reports a revert.

validAfter (optional)

• Type: number

Unix timestamp after which the transaction can be included.

validBefore (optional)

• Type: number

Unix timestamp before which the transaction must be included.