accounts 0.19.0 → 0.19.1

package/src/server/internal/handlers/feeLiquidity.localnet.test.ts

@@ -0,0 +1,398 @@
+import {
+  encodeFunctionData,
+  http as viem_http,
+  isAddressEqual,
+  parseUnits,
+  toFunctionSelector,
+} from 'viem'
+import { generatePrivateKey } from 'viem/accounts'
+import { fillTransaction, sendTransactionSync } from 'viem/actions'
+import { Abis, Account, Actions, Addresses } from 'viem/tempo'
+import { afterEach, expect, test } from 'vp/test'
+
+import {
+  accounts,
+  addresses,
+  chain as localnetChain,
+  getClient,
+  rpcUrl,
+} from '../../../../test/config.js'
+import { createServer, type Server } from '../../../../test/utils.js'
+import * as Kv from '../../Kv.js'
+import * as FeeLiquidity from './feeLiquidity.js'
+import { relay } from './relay.js'
+
+const servers: Server[] = []
+const chain = { ...localnetChain, hardfork: 't5' as const }
+const balanceSelector = toFunctionSelector('balanceOf(address)').slice(2)
+const poolSelector = toFunctionSelector('getPool(address,address)').slice(2)
+
+afterEach(async () => {
+  await Promise.all(servers.splice(0).map((server) => server.closeAsync()))
+})
+
+async function fixture() {
+  const rpc = getClient({ account: accounts[0]! })
+  const sender = Account.fromSecp256k1(generatePrivateKey())
+  const { token } = await Actions.token.createSync(rpc, {
+    name: 'Localnet MACH',
+    symbol: 'MACH',
+    currency: 'USD',
+    quoteToken: addresses.alphaUsd,
+  })
+  await sendTransactionSync(rpc, {
+    feeToken: Addresses.pathUsd,
+    calls: [
+      Actions.token.grantRoles.call({ token, role: 'issuer', to: rpc.account.address }),
+      Actions.token.mint.call({ token, amount: parseUnits('500', 6), to: sender.address }),
+      Actions.token.mint.call({
+        token: addresses.alphaUsd,
+        amount: parseUnits('100', 6),
+        to: sender.address,
+      }),
+    ],
+  })
+  await sendTransactionSync(rpc, {
+    account: sender,
+    feeToken: addresses.alphaUsd,
+    calls: [Actions.fee.setUserToken.call({ token })],
+    throwOnReceiptRevert: true,
+  })
+  const calls = [
+    Actions.token.transfer.call({
+      token: addresses.alphaUsd,
+      to: accounts[7]!.address,
+      amount: 1n,
+    }),
+  ]
+  const tokens = [token, addresses.alphaUsd].map((address) => ({
+    address,
+    decimals: 6,
+    name: 'Localnet USD',
+    symbol: 'USD',
+  }))
+  return { rpc, sender, token, calls, tokens }
+}
+
+function observe(
+  options: {
+    beforeBalance?: (() => Promise<void>) | undefined
+    beforeProducer?: (() => Promise<void>) | undefined
+    onProducer?: (() => void) | undefined
+    onPool?: (() => void) | undefined
+  } = {},
+) {
+  const events: string[] = []
+  const pools: string[] = []
+  let balances = 0
+  const transport = viem_http(rpcUrl, {
+    retryCount: 0,
+    timeout: 5_000,
+    fetchFn: async (url, init) => {
+      const body = JSON.parse(init?.body as string) as
+        | { method: string; params?: { data?: string }[] }
+        | { method: string; params?: { data?: string }[] }[]
+      const requests = Array.isArray(body) ? body : [body]
+      let balance = false
+      let pool = false
+      let producer = false
+      for (const request of requests) {
+        if (request.method === 'eth_getBlockByNumber') producer = true
+        if (request.method === 'eth_fillTransaction') events.push('fill')
+        if (request.method !== 'eth_call') continue
+        const data = request.params?.[0]?.data?.toLowerCase() ?? ''
+        const matches = data.match(new RegExp(balanceSelector, 'g')) ?? []
+        if (matches.length > 0) {
+          balances += matches.length
+          balance = true
+          events.push('balance')
+        }
+        for (const match of data.matchAll(new RegExp(`${poolSelector}[0-9a-f]{128}`, 'g'))) {
+          pool = true
+          pools.push(match[0])
+          events.push('pool')
+        }
+      }
+      if (producer) {
+        await options.beforeProducer?.()
+        events.push('producer')
+        options.onProducer?.()
+      }
+      if (pool) options.onPool?.()
+      if (balance) await options.beforeBalance?.()
+      const response = await fetch(url, init)
+      if (balance) events.push('balance-complete')
+      return response
+    },
+  })
+  return {
+    transport,
+    events,
+    pools,
+    get balances() {
+      return balances
+    },
+  }
+}
+
+async function serve(options: relay.Options) {
+  const server = await createServer(relay({ autoSwap: false, ...options }).listener)
+  servers.push(server)
+  return getClient({ transport: viem_http(server.url, { retryCount: 0 }) })
+}
+
+test('fee liquidity: producer discovery overlaps real pending balance RPCs', async () => {
+  const state = await fixture()
+  const balance = Promise.withResolvers<void>()
+  const producer = Promise.withResolvers<void>()
+  const observed = observe({
+    beforeBalance: () => {
+      balance.resolve()
+      return producer.promise
+    },
+    beforeProducer: () => balance.promise,
+    onProducer: () => producer.resolve(),
+  })
+  const client = await serve({
+    chains: [chain],
+    features: 'all',
+    resolveTokens: () => state.tokens,
+    transports: { [chain.id]: observed.transport },
+  })
+  const { transaction } = await fillTransaction(client, {
+    account: state.sender.address,
+    calls: state.calls,
+  })
+  const receipt = await sendTransactionSync(getClient(), {
+    type: 'tempo',
+    calls: transaction.calls!,
+    feeToken: transaction.feeToken!,
+    gas: transaction.gas,
+    maxFeePerGas: transaction.maxFeePerGas,
+    maxPriorityFeePerGas: transaction.maxPriorityFeePerGas,
+    nonce: transaction.nonce,
+    account: state.sender,
+  })
+  expect({
+    overlaps: observed.events.indexOf('producer') < observed.events.indexOf('balance-complete'),
+    balanceStarted: observed.events.indexOf('balance') < observed.events.indexOf('producer'),
+    skippedMach: isAddressEqual(transaction.feeToken!, addresses.alphaUsd),
+    balances: observed.balances,
+    status: receipt.status,
+  }).toMatchInlineSnapshot(`
+    {
+      "balanceStarted": true,
+      "balances": 2,
+      "overlaps": true,
+      "skippedMach": true,
+      "status": "success",
+    }
+  `)
+})
+
+test('fee liquidity: pool reads overlap real pending balances and are reused across retries', async () => {
+  const state = await fixture()
+  const pool = Promise.withResolvers<void>()
+  const observed = observe({ beforeBalance: () => pool.promise, onPool: () => pool.resolve() })
+  const client = await serve({
+    chains: [chain],
+    features: 'all',
+    resolveTokens: () => state.tokens,
+    transports: { [chain.id]: observed.transport },
+  })
+  const { transaction } = await fillTransaction(client, {
+    account: state.sender.address,
+    calls: state.calls,
+  })
+  const direct = encodeFunctionData({
+    abi: Abis.feeAmm,
+    functionName: 'getPool',
+    args: [state.token, Addresses.pathUsd],
+  })
+    .slice(2)
+    .toLowerCase()
+  expect({
+    overlaps: observed.events.indexOf('pool') < observed.events.indexOf('balance-complete'),
+    balanceStarted: observed.events.indexOf('balance') < observed.events.indexOf('pool'),
+    directReads: observed.pools.filter((call) => call === direct).length,
+    balances: observed.balances,
+    skippedMach: isAddressEqual(transaction.feeToken!, addresses.alphaUsd),
+  }).toMatchInlineSnapshot(`
+    {
+      "balanceStarted": true,
+      "balances": 2,
+      "directReads": 1,
+      "overlaps": true,
+      "skippedMach": true,
+    }
+  `)
+})
+
+test('fee liquidity: reads an unlisted on-chain preference without rediscovering balances', async () => {
+  const state = await fixture()
+  const observed = observe()
+  const client = await serve({
+    chains: [chain],
+    features: 'all',
+    resolveTokens: () =>
+      state.tokens.filter((token) => isAddressEqual(token.address, addresses.alphaUsd)),
+    transports: { [chain.id]: observed.transport },
+  })
+  const { transaction } = await fillTransaction(client, {
+    account: state.sender.address,
+    calls: state.calls,
+  })
+  expect({
+    balances: observed.balances,
+    skippedMach: isAddressEqual(transaction.feeToken!, addresses.alphaUsd),
+  }).toMatchInlineSnapshot(`
+    {
+      "balances": 2,
+      "skippedMach": true,
+    }
+  `)
+})
+
+test('fee liquidity: explicit fee tokens do not trigger user balance or reserve discovery', async () => {
+  const state = await fixture()
+  const observed = observe()
+  const client = await serve({
+    chains: [chain],
+    features: 'all',
+    resolveTokens: () => state.tokens,
+    transports: { [chain.id]: observed.transport },
+  })
+  const { transaction } = await fillTransaction(client, {
+    account: state.sender.address,
+    calls: state.calls,
+    feeToken: addresses.alphaUsd,
+    capabilities: { balanceDiffs: false },
+  })
+  expect({
+    balances: observed.balances,
+    pools: observed.pools.length,
+    preserved: isAddressEqual(transaction.feeToken!, addresses.alphaUsd),
+  }).toMatchInlineSnapshot(`
+    {
+      "balances": 0,
+      "pools": 0,
+      "preserved": true,
+    }
+  `)
+})
+
+test('fee liquidity: sponsored fills do not probe user balances or pools', async () => {
+  const state = await fixture()
+  const observed = observe()
+  const client = await serve({
+    chains: [chain],
+    features: 'all',
+    feePayer: { account: accounts[0]!, feeToken: Addresses.pathUsd },
+    resolveTokens: () => state.tokens,
+    transports: { [chain.id]: observed.transport },
+  })
+  const { transaction } = await fillTransaction(client, {
+    account: state.sender.address,
+    calls: state.calls,
+    capabilities: { balanceDiffs: false },
+  })
+  expect({
+    balances: observed.balances,
+    pools: observed.pools.length,
+    sponsorToken: isAddressEqual(transaction.feeToken!, Addresses.pathUsd),
+  }).toMatchInlineSnapshot(`
+    {
+      "balances": 0,
+      "pools": 0,
+      "sponsorToken": true,
+    }
+  `)
+})
+
+test('fee liquidity: reserve snapshots stay request-scoped after on-chain pool funding', async () => {
+  const state = await fixture()
+  const observed = observe()
+  const client = getClient({ transport: observed.transport })
+  const check = await FeeLiquidity.prepare(client, { token: state.token })
+  expect(await check(2057n)).toMatchInlineSnapshot(`false`)
+  await Actions.amm.mintSync(state.rpc, {
+    feeToken: Addresses.pathUsd,
+    userTokenAddress: state.token,
+    validatorTokenAddress: Addresses.pathUsd,
+    validatorTokenAmount: 2050n,
+    to: state.rpc.account.address,
+  })
+  const reads = observed.pools.length
+  expect({ stale: await check(2057n), rereads: observed.pools.length - reads })
+    .toMatchInlineSnapshot(`
+    {
+      "rereads": 0,
+      "stale": false,
+    }
+  `)
+  const fresh = await FeeLiquidity.prepare(client, { token: state.token })
+  expect({ covered: await fresh(2057n), insufficient: await fresh(2058n) }).toMatchInlineSnapshot(`
+    {
+      "covered": true,
+      "insufficient": false,
+    }
+  `)
+})
+
+test('fee liquidity: a real two-hop pool settles the selected fee token at broadcast', async () => {
+  const state = await fixture()
+  await Actions.amm.mintSync(state.rpc, {
+    feeToken: Addresses.pathUsd,
+    userTokenAddress: state.token,
+    validatorTokenAddress: addresses.alphaUsd,
+    validatorTokenAmount: parseUnits('1', 6),
+    to: state.rpc.account.address,
+  })
+  const client = await serve({
+    chains: [chain],
+    features: 'all',
+    resolveTokens: () => state.tokens,
+    transports: { [chain.id]: viem_http(rpcUrl) },
+  })
+  const { transaction } = await fillTransaction(client, {
+    account: state.sender.address,
+    calls: state.calls,
+  })
+  const receipt = await sendTransactionSync(getClient(), {
+    account: state.sender,
+    type: 'tempo',
+    calls: transaction.calls!,
+    feeToken: transaction.feeToken!,
+    gas: transaction.gas,
+    maxFeePerGas: transaction.maxFeePerGas,
+    maxPriorityFeePerGas: transaction.maxPriorityFeePerGas,
+    nonce: transaction.nonce,
+  })
+  expect({
+    selectedMach: isAddressEqual(transaction.feeToken!, state.token),
+    status: receipt.status,
+  }).toMatchInlineSnapshot(`
+    {
+      "selectedMach": true,
+      "status": "success",
+    }
+  `)
+})
+
+test('fee liquidity: validator tokens need no pool reads', async () => {
+  const observed = observe()
+  const client = getClient({ transport: observed.transport })
+  const kv = Kv.memory()
+  const checks = await Promise.all([
+    FeeLiquidity.prepare(client, { token: Addresses.pathUsd, kv }),
+    FeeLiquidity.prepare(client, { token: addresses.alphaUsd, kv }),
+  ])
+  expect({ validator: await checks[0]!(206n), alpha: await checks[1]!(206n) })
+    .toMatchInlineSnapshot(`
+    {
+      "alpha": true,
+      "validator": true,
+    }
+  `)
+  expect(observed.events.filter((event) => event === 'producer').length).toMatchInlineSnapshot(`10`)
+})

package/src/server/internal/handlers/feeLiquidity.ts

@@ -0,0 +1,117 @@
+import { type Address, type Client, isAddressEqual, zeroAddress } from 'viem'
+import { getBlock, readContract } from 'viem/actions'
+import { Abis, Actions, Addresses, Hardfork } from 'viem/tempo'
+
+import type * as Kv from '../../Kv.js'
+import { cached } from '../kv.js'
+
+/** Number of recent block producers the node's pool admission considers. */
+const producerWindow = 10
+
+/**
+ * Checks whether the fee AMM can settle the fee for at least one recent block
+ * producer's preferred token. Mirrors the node's pool admission check, so a
+ * token is only rejected here when the node would reject it too.
+ */
+export async function has(client: Client, options: has.Options): Promise<boolean> {
+  const check = await prepare(client, options)
+  return check(options.amount)
+}
+
+/** Reads fee reserves ahead of filling and returns a reusable maximum-fee check. */
+export async function prepare(client: Client, options: prepare.Options) {
+  const { kv, token } = options
+  const validatorTokens = await getValidatorTokens(client, { kv })
+  if (validatorTokens.some((validatorToken) => isAddressEqual(validatorToken, token)))
+    return async (_amount: bigint) => true
+
+  const hardfork = (client.chain as { hardfork?: string } | undefined)?.hardfork
+  const twoHop = !hardfork || !Hardfork.lt(hardfork, 't5')
+
+  const [direct, quote] = await Promise.all([
+    Promise.all(
+      validatorTokens.map((validatorToken) =>
+        Actions.amm.getPool(client, { userToken: token, validatorToken }),
+      ),
+    ),
+    twoHop
+      ? readContract(client, { address: token, abi: Abis.tip20, functionName: 'quoteToken' })
+      : undefined,
+  ])
+  const targets = quote
+    ? validatorTokens.filter((validatorToken) => !isAddressEqual(validatorToken, quote))
+    : []
+  const route =
+    quote && quote !== zeroAddress && targets.length > 0
+      ? Promise.all([
+          Actions.amm.getPool(client, { userToken: token, validatorToken: quote }),
+          ...targets.map((validatorToken) =>
+            Actions.amm.getPool(client, { userToken: quote, validatorToken }),
+          ),
+        ])
+      : undefined
+  void route?.catch(() => {})
+  return async (amount: bigint) => {
+    const output = (amount * 9970n) / 10000n
+    if (direct.some((pool) => pool.reserveValidatorToken >= output)) return true
+    if (!route) return false
+    const [first, ...second] = await route
+    if (first!.reserveValidatorToken < output) return false
+    return second.some((pool) => pool.reserveValidatorToken >= (output * 9970n) / 10000n)
+  }
+}
+
+/** Parameters for prefetching a token's fee reserves. */
+export declare namespace prepare {
+  /** Fee token and producer-preference cache. */
+  type Options = Pick<has.Options, 'token' | 'kv'>
+}
+
+/** Parameters for the fee-liquidity check. */
+export declare namespace has {
+  /** Fee token and maximum fee, in TIP-20 base units. */
+  type Options = {
+    /** User's fee token. */
+    token: Address
+    /** Maximum transaction fee, rounded up to microdollars. */
+    amount: bigint
+    /** Caches the recent producers' fee tokens across fills. */
+    kv?: Kv.Kv | undefined
+  }
+}
+
+/** Resolves the unique fee tokens preferred by the producers of the latest blocks. */
+async function getValidatorTokens(
+  client: Client,
+  options: { kv?: Kv.Kv | undefined },
+): Promise<readonly Address[]> {
+  async function load() {
+    const latest = await getBlock(client)
+    const number = latest.number ?? 0n
+    const previous = await Promise.all(
+      Array.from({ length: producerWindow - 1 }, (_, index) => number - BigInt(index + 1))
+        .filter((blockNumber) => blockNumber >= 0n)
+        .map((blockNumber) => getBlock(client, { blockNumber })),
+    )
+    const validators = unique([latest, ...previous].map((block) => block.miner))
+    const tokens = await Promise.all(
+      validators.map(async (validator) => {
+        const preference = await Actions.fee.getValidatorToken(client, { validator })
+        return preference?.address ?? Addresses.pathUsd
+      }),
+    )
+    return unique(tokens)
+  }
+
+  // Producer preferences rarely change, and a stale entry only delays picking
+  // up a new producer's token until the cache expires.
+  const { kv } = options
+  if (!kv) return load()
+  return cached(kv, `fee.validatorTokens:${client.chain?.id ?? 0}`, load, { ttl: 60 })
+}
+
+function unique(addresses: readonly Address[]): Address[] {
+  const seen = new Map<string, Address>()
+  for (const address of addresses) seen.set(address.toLowerCase(), address)
+  return [...seen.values()]
+}

package/src/server/internal/handlers/relay.localnet.test.ts

@@ -938,7 +938,11 @@ describe('behavior: capabilities', () => {
       amount: parseUnits('1000', 6),
       to: sender.address,
     })
-    await Actions.fee.setUserToken(getClient({ account: sender }), { token: addresses.alphaUsd })
+    await sendTransactionSync(getClient({ account: sender }), {
+      feeToken: addresses.alphaUsd,
+      calls: [Actions.fee.setUserToken.call({ token: addresses.alphaUsd })],
+      throwOnReceiptRevert: true,
+    })
 
     const buyAmount = parseUnits('10', 6)
     const result = await fillTransaction(client, {
@@ -965,6 +969,9 @@ describe('behavior: capabilities', () => {
     const meta = result.capabilities
 
     const diffs = findDiffs(meta?.balanceDiffs, sender.address)!
+    expect(result.transaction.feeToken).toMatchInlineSnapshot(
+      `"0x20c0000000000000000000000000000000000001"`,
+    )
     expect(diffs).toHaveLength(1)
 
     const quoteDiff = diffs[0]!
@@ -1698,7 +1705,7 @@ describe('behavior: fee token resolution', () => {
     expect(transaction.feeToken).toBe(preferredToken)
   })
 
-  test('behavior: resolves to highest-balance token from token list', async () => {
+  test('behavior: skips highest-balance token until its fee pool has liquidity', async () => {
     // Create a fresh TIP20 token "betaUsd" so we can test highest-balance
     // selection without depending on a pre-deployed second token.
     const freshAccount = accounts[5]!
@@ -1751,10 +1758,23 @@ describe('behavior: fee token resolution', () => {
       account: freshAccount.address,
       calls: [transferCall()],
     })
-    customServer.close()
+    // betaUsd has the larger balance but no fee pool yet.
+    expect(transaction.feeToken?.toLowerCase()).toBe(addresses.alphaUsd.toLowerCase())
 
-    // betaUsd has higher balance (500 > 100).
-    expect(transaction.feeToken?.toLowerCase()).toBe(betaUsd.toLowerCase())
+    await Actions.amm.mintSync(rpc, {
+      account: accounts[0]!,
+      feeToken: Addresses.pathUsd,
+      userTokenAddress: betaUsd,
+      validatorTokenAddress: Addresses.pathUsd,
+      validatorTokenAmount: parseUnits('1', 6),
+      to: accounts[0]!.address,
+    })
+    const funded = await fillTransaction(customClient, {
+      account: freshAccount.address,
+      calls: [transferCall()],
+    })
+    customServer.close()
+    expect(funded.transaction.feeToken?.toLowerCase()).toBe(betaUsd.toLowerCase())
   })
 
   test('behavior: falls back to pathUSD when no preference or balances', async () => {
@@ -1970,13 +1990,16 @@ describe('behavior: mainnet autoSwap with USDC.e → PathUSD', () => {
   const mainnetUsdce = '0x20c000000000000000000000b9537d11c60e8b50' as const
   const mainnetPathUsd = '0x20c0000000000000000000000000000000000000' as const
   const mainnetSender = '0xb472f3ca15f34Db22d43FA503043F1e6541AC085' as const
+  const mainnetRpcUrl = 'https://rpc.presto.tempo.xyz'
+  // Keep the swap small: this runs against live mainnet DEX liquidity.
+  const amount = parseUnits('0.001', 6)
 
   beforeAll(async () => {
     server = await createServer(
       relay({
         chains: [tempo],
         features: 'all',
-        transports: { [tempo.id]: http('https://rpc.presto.tempo.xyz') },
+        transports: { [tempo.id]: http(mainnetRpcUrl) },
       }).listener,
     )
     mainnetClient = getClient({ chain: tempo, transport: http(server.url) })
@@ -1986,14 +2009,27 @@ describe('behavior: mainnet autoSwap with USDC.e → PathUSD', () => {
     server.close()
   })
 
-  test('behavior: auto-swaps USDC.e → PathUSD when sender has USDC.e but no PathUSD', async () => {
+  test('behavior: auto-swaps USDC.e → PathUSD when sender has USDC.e but no PathUSD', async (context) => {
+    // Skip rather than fail when live mainnet DEX liquidity can't cover the swap.
+    const quotable = await Actions.dex
+      .getBuyQuote(getClient({ chain: tempo, transport: http(mainnetRpcUrl) }), {
+        amountOut: amount,
+        tokenIn: mainnetUsdce,
+        tokenOut: mainnetPathUsd,
+      })
+      .then(
+        () => true,
+        () => false,
+      )
+    if (!quotable) context.skip('mainnet DEX has insufficient USDC.e → PathUSD liquidity')
+
     const result = await fillTransaction(mainnetClient, {
       account: mainnetSender,
       calls: [
         Actions.token.transfer.call({
           token: mainnetPathUsd,
           to: recipient.address,
-          amount: parseUnits('0.5', 6),
+          amount,
         }),
       ],
     })