@exodus/ethereum-api 8.35.0 → 8.36.0

package/CHANGELOG.md

@@ -3,6 +3,34 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.36.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.35.1...@exodus/ethereum-api@8.36.0) (2025-06-11)
+
+
+### Features
+
+
+* feat: ethereum api use balances and nonces data (#5727)
+
+
+### Bug Fixes
+
+
+* fix: ethereum api cleaning up (#5832)
+
+* fix: improve evm gas estimation when using arbitrary addresses (#5842)
+
+
+
+## [8.35.1](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.35.0...@exodus/ethereum-api@8.35.1) (2025-06-06)
+
+
+### Bug Fixes
+
+
+* fix: hardcode gasLimit in client (#5815)
+
+
+
 ## [8.35.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.34.4...@exodus/ethereum-api@8.35.0) (2025-05-28)
 
 
@@ -399,7 +427,7 @@ See [Conventional Commits](https://conventionalcommits.org) for commit guideline
 ### Bug Fixes
 
 
-* fix: use gasPriceMultipler when setting up min/max/recommended (#4700)
+* fix: use gasPriceMultiplier when setting up min/max/recommended (#4700)
 
 
 

package/README.md

@@ -13,7 +13,7 @@ Excluding custom fees, `feeData.gasPrice` is used to resolve the transaction's g
 The `gasPrice` value is, in preference order, loaded from:
 
 1. Remote config
-2. The node via the fee data monitor and web socket. `gasPrice = baseFeePerGas * gasPriceMultipler + tipGasPrice`
+2. The node via the fee data monitor and web socket. `gasPrice = baseFeePerGas * gasPriceMultiplier + tipGasPrice`
 3. The default configuration.
 
 Using remote config is never recommended, as manually updating this value won't keep up with network activity.
@@ -42,7 +42,7 @@ The base gas price (or base fee) is the minimum amount of gas required to be pai
 
 It can be found in `feeData.baseFeePerGas`. The fee monitor keeps it up to date by monitoring the latest block's information. It could be tuned by remote config, but this is not recommended.
 
-The `feeData.baseFeePerGas` is used when showing an "estimated fee" in the UI and to calculate the max gas price. `gasPrice = baseFeePerGas * gasPriceMultipler + tipGasPrice`
+The `feeData.baseFeePerGas` is used when showing an "estimated fee" in the UI and to calculate the max gas price. `gasPrice = baseFeePerGas * gasPriceMultiplier + tipGasPrice`
 
 ### Gas Limit
 
@@ -69,7 +69,7 @@ The L2 extra fee needs to be considered when showing the fee to the user, resolv
 
 Custom fees allow users to set a custom `gasPrice`. The wallet allows a range, as follows:
 
-Note: `gasPrice = baseFeePerGas * gasPriceMultipler + tipGasPrice`
+Note: `gasPrice = baseFeePerGas * gasPriceMultiplier + tipGasPrice`
 
 - `recommended: gasPrice`
 - `min: gasPrice * gasPriceMinimumRate`
@@ -88,7 +88,7 @@ Min and max values can be tuned by changing `gasPriceMinimumRate` and `gasPriceM
 
 ### TX formulas
 
-Note: `gasPrice = baseFeePerGas * gasPriceMultipler + tipGasPrice`
+Note: `gasPrice = baseFeePerGas * gasPriceMultiplier + tipGasPrice`
 
 Table shows how the txs are create for both legacy and 1559 logic for major use case:
 
@@ -108,7 +108,7 @@ This is the default fee data configuration for Ethereum. Other EVMs have differe
 All these values can be tuned via remote config, although it may not be recommended as they are also tuned by the fee monitors:
 
 - **`baseFeePerGas`:** `50 Gwei` – Reference value for the base gas price. It is quickly updated by the fee monitor.
-- **`gasPrice`:** `77 Gwei` – `baseFeePerGas * gasPriceMultipler + tipGasPrice`
+- **`gasPrice`:** `77 Gwei` – `baseFeePerGas * gasPriceMultiplier + tipGasPrice`
 - **`severGasPrice`:** `75 Gwei` – Reference value for the network gas price. It is quickly updated by the fee monitor.
 - **`tipGasPrice`:** `2 Gwei` – Controls the `maxPriorityFeePerGas` for all transactions when EIP-1559 is enabled.
 - **`eip1559Enabled`:** `true` – Enables or disables EIP-1559. A value of `false` means legacy fees and transactions.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.35.0",
+  "version": "8.36.0",
   "description": "Transaction monitors, fee monitors, RPC with the blockchain node, and other networking code for Ethereum and EVM-based blockchains",
   "type": "module",
   "main": "src/index.js",
@@ -28,12 +28,12 @@
     "@exodus/bip44-constants": "^195.0.0",
     "@exodus/crypto": "^1.0.0-rc.13",
     "@exodus/currency": "^6.0.1",
-    "@exodus/ethereum-lib": "^5.10.2",
+    "@exodus/ethereum-lib": "^5.12.0",
     "@exodus/ethereum-meta": "^2.5.0",
     "@exodus/ethereumholesky-meta": "^2.0.2",
     "@exodus/ethereumjs": "^1.0.0",
     "@exodus/fetch": "^1.3.0",
-    "@exodus/models": "^12.0.1",
+    "@exodus/models": "^12.13.0",
     "@exodus/simple-retry": "^0.0.6",
     "@exodus/solidity-contract": "^1.1.3",
     "@exodus/web3-ethereum-utils": "^4.2.1",
@@ -64,5 +64,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "1dd642f94e801034ff66828f519579911a2dca18"
+  "gitHead": "2172464a34a03cb2c2401f80db89d4609cb0528f"
 }

package/src/create-asset.js

@@ -65,6 +65,7 @@ export const createAssetFactory = ({
   useEip1191ChainIdChecksum = false,
   forceGasLimitEstimation = false,
   supportsCustomFees: defaultSupportsCustomFees = false,
+  useAbsoluteBalanceAndNonce = false,
 }) => {
   assert(assetsList, 'assetsList is required')
   assert(providedFeeData || feeDataConfig, 'feeData or feeDataConfig is required')
@@ -106,6 +107,7 @@ export const createAssetFactory = ({
       monitorType: overrideMonitorType,
       serverUrl: overrideServerUrl,
       monitorInterval: overrideMonitorInterval,
+      useAbsoluteBalanceAndNonce: overrideUseAbsoluteBalanceAndNonce,
     } = {
       ...defaultConfig,
       ...config,
@@ -126,6 +128,10 @@ export const createAssetFactory = ({
       }
     }
 
+    if (overrideUseAbsoluteBalanceAndNonce !== undefined) {
+      useAbsoluteBalanceAndNonce = overrideUseAbsoluteBalanceAndNonce
+    }
+
     monitorType = overrideMonitorType || monitorType
     const server = createEvmServer({ assetName: asset.name, serverUrl, monitorType })
 
@@ -149,6 +155,7 @@ export const createAssetFactory = ({
     const getBalances = getBalancesFactory({
       monitorType,
       config,
+      useAbsoluteBalance: useAbsoluteBalanceAndNonce,
     })
 
     const { createToken, getTokens } = createTokenFactory(
@@ -254,6 +261,7 @@ export const createAssetFactory = ({
     const sendTx = txSendFactory({
       assetClientInterface,
       createUnsignedTx,
+      useAbsoluteBalanceAndNonce,
     })
 
     const estimateL1DataFee = l1GasOracleAddress

package/src/exodus-eth-server/clarity-v2.js

@@ -130,4 +130,14 @@ export default class ClarityServerV2 extends ClarityServer {
       body: request,
     })
   }
+
+  async getTransactionCount(...params) {
+    // nonce is called during tx send, use it in rest api
+    const request = this.getTransactionCountRequest(...params)
+    return this.sendHttpRequest({
+      path: '/rpc',
+      method: 'POST',
+      body: request,
+    })
+  }
 }

package/src/fee-utils.js

@@ -3,8 +3,8 @@ import assert from 'minimalistic-assert'
 const applyMultiplierToPriceInWei = ({ feeAsset, feeData, priceInWei }) => {
   assert(typeof priceInWei === 'string', 'gasPriceInWei should be a string')
 
-  const multipler = feeData.gasPriceMultiplier || 1
-  return feeAsset.currency.parse(priceInWei).mul(multipler).toBaseString({ unit: true })
+  const gasPriceMultiplier = feeData.gasPriceMultiplier || 1
+  return feeAsset.currency.parse(priceInWei).mul(gasPriceMultiplier).toBaseString({ unit: true })
 }
 
 /**

package/src/gas-estimation.js

@@ -15,6 +15,15 @@ export const DEFAULT_CONTRACT_GAS_LIMIT = 1e6
 export const scaleGasLimitEstimate = ({ estimatedGasLimit, extraPercentage = EXTRA_PERCENTAGE }) =>
   Number((BigInt(estimatedGasLimit) * BigInt(100 + extraPercentage)) / BigInt(100))
 
+const hardcodedGasLimits = new Map([
+  ['amp', 151_000],
+  ['tetherusd', 70_000],
+  ['usdcoin', 70_000],
+  ['snx', 220_000],
+  ['geminidollar', 75_000],
+  ['aave', 250_000],
+])
+
 // Starting with geth v1.9.14, if gasPrice is set for eth_estimateGas call, the call allowance will
 // be calculated with account's balance divided by gasPrice. If user's balance is too low,
 // the gasEstimation will fail. If gasPrice is set to '0x0', the account's balance is not
@@ -28,6 +37,11 @@ export async function estimateGasLimit(
   gasPrice = '0x',
   extraPercentage
 ) {
+  // move this to remote config
+  if (hardcodedGasLimits.has(asset.name)) {
+    return hardcodedGasLimits.get(asset.name)
+  }
+
   const opts = {
     from: fromAddress,
     to: toAddress,
@@ -74,18 +88,7 @@ export async function fetchGasLimit({
   if (isEthereumLikeToken(asset)) {
     amount = asset.baseAsset.currency.ZERO
     toAddress = asset.contract.address
-  } else if (
-    !isContract &&
-    !asset.forceGasLimitEstimation &&
-    ![
-      // back compatiblity until all plugins are updated. Then remove this array
-      'ethereumarbone',
-      'ethereumarbonesepolia',
-      'ethereumarbnova',
-      'mantle',
-      'mantlesepolia',
-    ].includes(asset.name)
-  ) {
+  } else if (!isContract && !asset.forceGasLimitEstimation) {
     return defaultGasLimit()
   }
 

package/src/get-balances.js

@@ -7,6 +7,44 @@ import {
 import { isRpcBalanceAsset } from '@exodus/ethereum-lib'
 import assert from 'minimalistic-assert'
 
+export const getAbsoluteBalance = ({ asset, txLog }) => {
+  assert(asset, 'asset is required')
+  assert(txLog, 'txLog is required')
+
+  if (txLog.size === 0) {
+    return asset.currency.ZERO
+  }
+
+  let balance = asset.currency.ZERO
+  let hasAbsoluteBalance = false
+
+  for (const tx of txLog.reverse()) {
+    if (tx.data.balanceChange) {
+      hasAbsoluteBalance = true
+      balance = balance.add(asset.currency.baseUnit(tx.data.balanceChange.to))
+
+      break
+    }
+
+    if (!(tx.dropped || tx.data.replacedBy)) {
+      if (!tx.error) {
+        balance = balance.add(tx.coinAmount)
+      }
+
+      if (tx.feeAmount?.unitType.equals(tx.coinAmount.unitType)) {
+        balance = balance.sub(tx.feeAmount)
+      }
+    }
+  }
+
+  if (!hasAbsoluteBalance) {
+    console.warn('No absolute balance found', { assetName: asset.name, txLogSize: txLog.size })
+    return
+  }
+
+  return balance
+}
+
 const getStaked = ({ accountState, asset }) => {
   return accountState?.staking?.[asset.name]?.activeStakedBalance || asset.currency.ZERO
 }
@@ -73,7 +111,11 @@ const getSpendable = ({ asset, balance, txLog, unconfirmedReceived }) => {
  * @param accountState the account state when the balance is loaded from RPC
  * @returns {{balance}|null} an object with the balance or null if the balance is unknown
  */
-export const getBalancesFactory = ({ monitorType, config = Object.create(null) }) => {
+export const getBalancesFactory = ({
+  monitorType,
+  config = Object.create(null),
+  useAbsoluteBalance,
+}) => {
   const { useAccountStateBalanceOnly } = config
 
   assert(monitorType, 'monitorType is required')
@@ -101,12 +143,19 @@ export const getBalancesFactory = ({ monitorType, config = Object.create(null) }
     } else {
       // Balance from txLog does not include staking rewards
       // spendable and total are calculated differently based on staking txs
-      spendable = getSpendable({
-        asset,
-        balance: getBalanceFromTxLog({ txLog, asset }),
-        txLog,
-        unconfirmedReceived,
-      })
+      const absoluteBalance = useAbsoluteBalance && getAbsoluteBalance({ asset, txLog })
+
+      if (absoluteBalance) {
+        spendable = absoluteBalance
+      } else {
+        spendable = getSpendable({
+          asset,
+          balance: getBalanceFromTxLog({ txLog, asset }),
+          txLog,
+          unconfirmedReceived,
+        })
+      }
+
       total = spendable.add(staked).add(staking).add(unstaking).add(unstaked)
     }
 

package/src/get-fee-async.js

@@ -31,7 +31,22 @@ export async function resolveExtraPercentage({ asset, fromAddress, toAddress })
   return EXTRA_PERCENTAGE
 }
 
-const ARBITRARY_ADDRESS = '0xffffffffffffffffffffffffffffffffffffffff'
+// HACK: If a recipient address is not defined, we usually fall back to
+//       default address so gas estimation can still complete successfully
+//       without knowledge of which accounts are involved.
+//
+//       However, we must be careful to select addresses which are unlikely
+//       to have existing obligations, such as popular dead addresses or the
+//       reserved addresses of precompiles, since these can influence gas
+//       estimation.
+//
+//       Here, we use an address which is mostly all `1`s to make sure we can
+//       exaggerate the worst-case calldata cost (which is priced per high bit)
+//       whilst being unlikely to have any token balances.
+//
+//       Unfortunately, we can't use `0xffffffffffffffffffffffffffffffffffffffff`,
+//       since this address is a whale.
+const ARBITRARY_ADDRESS = '0xfffFfFfFfFfFFFFFfeFfFFFffFffFFFFfFFFFFFF'.toLowerCase()
 
 const getFeeAsyncFactory = ({
   assetClientInterface,
@@ -51,8 +66,8 @@ const getFeeAsyncFactory = ({
     txInput: txInputPram,
     isExchange,
     customFee,
-    calculateEffectiveFee,
     gasLimit: providedGasLimit,
+    feeData,
   }) => {
     const fromAddress = providedFromAddress || ARBITRARY_ADDRESS // sending from a random address
     const toAddress = providedToAddress || ARBITRARY_ADDRESS // sending to a random address,
@@ -86,15 +101,12 @@ const getFeeAsyncFactory = ({
 
     const { txInput, gasLimit, contractAddress } = await resolveGasLimit()
 
-    const feeData = await assetClientInterface.getFeeConfig({ assetName: asset.baseAsset.name })
-
     const { fee, gasPrice, ...rest } = getFee({
       asset,
       feeData,
       gasLimit,
       isExchange,
       amount,
-      calculateEffectiveFee,
       customFee,
     })
 

package/src/get-fee.js

@@ -41,17 +41,9 @@ export const getFeeFactoryGasPrices = ({ customFee, feeData }) => {
 
 export const getFeeFactory =
   ({ gasLimit: defaultGasLimit }) =>
-  ({
-    asset,
-    feeData,
-    customFee,
-    gasLimit: providedGasLimit,
-    isExchange,
-    amount,
-    calculateEffectiveFee,
-  }) => {
+  ({ asset, feeData, customFee, gasLimit: providedGasLimit, isExchange, amount }) => {
     const {
-      feeData: { baseFeePerGas, tipGasPrice, eip1559Enabled },
+      feeData: { tipGasPrice, eip1559Enabled },
       gasPrice,
     } = getFeeFactoryGasPrices({
       customFee,
@@ -65,19 +57,6 @@ export const getFeeFactory =
     const maybeReturnTipGasPrice = eip1559Enabled ? { tipGasPrice } : null
 
     const extraFeeData = getExtraFeeData({ asset, amount })
-    if (calculateEffectiveFee && eip1559Enabled) {
-      const maxFeePerGas = gasPrice
-      // effective_gas_price = min(base_fee_per_gas + tip_gas_price, max_fee_per_gas)
-      const feePerGas = baseFeePerGas.add(tipGasPrice)
-      const effectiveGasPrice = feePerGas.lt(maxFeePerGas) ? feePerGas : maxFeePerGas
-
-      return {
-        ...maybeReturnTipGasPrice,
-        fee: effectiveGasPrice.mul(gasLimit),
-        gasPrice,
-        extraFeeData,
-      }
-    }
 
     const fee = gasPrice.mul(gasLimit)
     return { ...maybeReturnTipGasPrice, fee, gasPrice, extraFeeData }

package/src/tx-log/clarity-utils/get-log-items-from-server-tx.js

@@ -1,5 +1,6 @@
 import lodash from 'lodash'
 
+import { getWalletUpdates } from '../monitor-utils/get-balance-updates.js'
 import getFeeAmount from '../monitor-utils/get-fee-amount.js'
 import getTransfersByTokenName from '../monitor-utils/get-transfers-by-token-name.js'
 import getValueOfTransfers from '../monitor-utils/get-value-of-transfers.js'
@@ -36,6 +37,8 @@ export default function getLogItemsFromServerTx({
     methodId: serverTx.input.slice(0, Math.max(0, METHOD_ID_LENGTH)),
   }
   const data = serverTx.input || '0x'
+  const walletUpdates = getWalletUpdates(ourWalletAddress, serverTx.walletChanges || [])
+  const { baseBalanceUpdate, nonceUpdate, tokenBalancesUpdate } = walletUpdates
 
   const logItemCommonProperties = {
     confirmations,
@@ -51,7 +54,10 @@ export default function getLogItemsFromServerTx({
     const sendingTransferPresent = ethereumTransfers.some(({ from }) => from === ourWalletAddress)
     const receivingTransferPresent = ethereumTransfers.some(({ to }) => to === ourWalletAddress)
 
-    if (sendingTransferPresent || receivingTransferPresent) {
+    const shouldAttachTx =
+      sendingTransferPresent || receivingTransferPresent || baseBalanceUpdate || nonceUpdate // need to also include if there's a base balance change
+
+    if (shouldAttachTx) {
       const coinAmount = getValueOfTransfers(ourWalletAddress, asset, ethereumTransfers)
       const selfSend = isSelfSendTx({
         coinAmount,
@@ -81,6 +87,8 @@ export default function getLogItemsFromServerTx({
             data,
             nonce,
             gasLimit,
+            balanceChange: baseBalanceUpdate,
+            nonceChange: nonceUpdate,
             ...methodId,
             ...(sent?.length > 0 ? { sent } : undefined),
           },
@@ -109,12 +117,15 @@ export default function getLogItemsFromServerTx({
   Object.entries(tokenTransfersByTokenName).forEach(([tokenName, tokenTransfers]) => {
     const sendingTransferPresent = tokenTransfers.some(({ from }) => from === ourWalletAddress)
     const receivingTransferPresent = tokenTransfers.some(({ to }) => to === ourWalletAddress)
-    if (!sendingTransferPresent && !receivingTransferPresent) return
-
     const token = assets[tokenName]
-    const tokenTransferToAddress = tryFindExternalRecipient(tokenTransfers, ourWalletAddress)
+    const tokenAddress = token.addresses.current.toLowerCase()
+    const balanceChange = tokenBalancesUpdate[tokenAddress]
 
+    if (!sendingTransferPresent && !receivingTransferPresent && !balanceChange) return
+
+    const tokenTransferToAddress = tryFindExternalRecipient(tokenTransfers, ourWalletAddress)
     const coinAmount = getValueOfTransfers(ourWalletAddress, token, tokenTransfers)
+
     const tokenFromAddresses = lodash.uniq(
       tokenTransfers.filter(({ to }) => to === ourWalletAddress).map(({ from }) => from)
     )
@@ -138,7 +149,7 @@ export default function getLogItemsFromServerTx({
         ...logItemCommonProperties,
         coinAmount,
         coinName: tokenName,
-        data: { data, nonce, gasLimit, ...methodId },
+        data: { data, nonce, gasLimit, balanceChange, ...methodId },
         ...(isConsideredSent
           ? { from: [], to: tokenTransferToAddress, feeAmount, feeCoinName: token.feeAsset.name }
           : { from: tokenFromAddresses }),

package/src/tx-log/monitor-utils/get-balance-updates.js

@@ -0,0 +1,44 @@
+export const getWalletUpdates = (ourWalletAddress, walletChanges) => {
+  return walletChanges.reduce(
+    (acc, walletChange) => {
+      const { wallet: walletAddress, type, from, to, contract: contractAddress } = walletChange
+
+      if (walletAddress !== ourWalletAddress) {
+        return acc
+      }
+
+      switch (type) {
+        case 'balance':
+          acc.baseBalanceUpdate = {
+            from,
+            to,
+          }
+          break
+        case 'nonce':
+          acc.nonceUpdate = {
+            from,
+            to,
+          }
+          break
+        case 'token':
+          acc.tokenBalancesUpdate = {
+            ...acc.tokenBalancesUpdate,
+            [contractAddress]: {
+              from,
+              to,
+            },
+          }
+          break
+        default:
+          break
+      }
+
+      return acc
+    },
+    {
+      baseBalanceUpdate: undefined,
+      nonceUpdate: undefined,
+      tokenBalancesUpdate: Object.create(null),
+    }
+  )
+}

package/src/tx-send/nonce-utils.js

@@ -8,15 +8,14 @@ export const resolveNonce = async ({
   txLog,
   triedNonce,
   tag = 'latest', // use 'pending' for unconfirmed txs
+  useAbsoluteNonce,
 }) => {
   const nonceFromNode =
     asset.baseAsset?.api?.features?.noHistory || forceFromNode
       ? await getNonce({ asset: asset.baseAsset, address: fromAddress, tag })
       : 0
 
-  const nonceFromLog = [...txLog]
-    .filter((tx) => tx.sent && !tx.dropped && tx.data.nonce != null)
-    .reduce((nonce, tx) => Math.max(tx.data.nonce + 1, nonce), 0)
+  const nonceFromLog = getNonceFromTxLog({ txLog, useAbsoluteNonce })
 
   return Math.max(
     nonceFromNode,
@@ -25,3 +24,20 @@ export const resolveNonce = async ({
     triedNonce === undefined ? 0 : triedNonce + 1
   )
 }
+
+export const getNonceFromTxLog = ({ txLog, useAbsoluteNonce }) => {
+  let absoluteNonce = 0
+  if (useAbsoluteNonce) {
+    for (const tx of txLog.reverse()) {
+      if (tx.data.nonceChange) {
+        absoluteNonce = parseInt(tx.data.nonceChange.to, 10)
+      }
+    }
+  }
+
+  const nonceFromLog = [...txLog]
+    .filter((tx) => tx.sent && !tx.dropped && tx.data.nonce != null)
+    .reduce((nonce, tx) => Math.max(tx.data.nonce + 1, nonce), 0)
+
+  return Math.max(absoluteNonce, nonceFromLog)
+}

package/src/tx-send/tx-send.js

@@ -67,7 +67,7 @@ export const HACK_maybeRefineSendAllAmount = async ({
   }
 }
 
-const txSendFactory = ({ assetClientInterface, createUnsignedTx }) => {
+const txSendFactory = ({ assetClientInterface, createUnsignedTx, useAbsoluteBalanceAndNonce }) => {
   assert(assetClientInterface, 'assetClientInterface is required')
   assert(createUnsignedTx, 'createUnsignedTx is required')
   return async ({ asset, walletAccount, address, amount, feeData: maybeFeeData, options = {} }) => {
@@ -207,6 +207,7 @@ const txSendFactory = ({ assetClientInterface, createUnsignedTx }) => {
         // we'll fall back to the `TxLog` since this also has a knowledge
         // of which transactions are currently in pending.
         tag: 'pending',
+        useAbsoluteNonce: useAbsoluteBalanceAndNonce,
       }))
 
     const createTxParams = {