Fix unstake queue fetching

welldan97 · welldan97 · commit 624eb588f90b · 2025-02-24T18:38:47.000Z
diff --git a/packages/ethereum/src/lib/methods/buildWithdrawTx.ts b/packages/ethereum/src/lib/methods/buildWithdrawTx.ts
@@ -24,7 +24,7 @@ export async function buildWithdrawTx (request: {
       return positionTickets.includes(item.positionTicket.toString())
     })
     .map((item) => {
-      const timestamp = Math.floor(item.when.getTime() / 1000)
+      const timestamp = item.timestamp / 1000
       if (item.exitQueueIndex === undefined) {
         throw new Error('Exit queue index is missing')
       }
diff --git a/packages/ethereum/src/lib/methods/getUnstakeQueue.ts b/packages/ethereum/src/lib/methods/getUnstakeQueue.ts
@@ -1,144 +1,57 @@
 import { Hex } from 'viem'
 import { StakewiseConnector } from '../connector'
-import { VaultABI } from '../contracts/vaultAbi'
-import { UnstakeQueueItem } from '../types/unstakeQueue'
 
 export const getUnstakeQueue = async (params: { connector: StakewiseConnector; userAccount: Hex; vault: Hex }) => {
   const { connector, vault, userAccount } = params
   const queueData = await connector.graphqlRequest({
     type: 'graph',
     op: 'exitQueue',
     query: `
-            query exitQueue($receiver: Bytes, $vault: String!) {
-              exitRequests(where: {
-                receiver: $receiver,
-                vault: $vault,
-              }) {
-                positionTicket
-                totalShares
+            query exitQueue($where: ExitRequest_filter) {
+              exitRequests(where: $where) {
+                receiver
+                isClaimed
                 timestamp
+                totalAssets
+                isClaimed
+                isClaimable
+                exitedAssets
+                isV2Position
+                positionTicket
+                exitQueueIndex
+                withdrawalTimestamp
               }
             }
             `,
     variables: {
-      vault: vault.toLowerCase(),
-      receiver: userAccount
+      where: {
+        vault: vault.toLowerCase(),
+        receiver: userAccount.toLowerCase()
+      }
     }
   })
 
   if (!queueData.data.exitRequests) {
     throw new Error('Queue data is missing the exitRequests field')
   }
 
-  return parseQueueData({
-    exitRequests: queueData.data.exitRequests.map((r: any) => ({
-      positionTicket: BigInt(r.positionTicket),
-      totalShares: BigInt(r.totalShares),
-      when: new Date(Number(r.timestamp) * 1000)
-    })),
-    connector,
-    userAddress: userAccount,
-    vaultAddress: vault
-  })
-}
-
-const getIs24HoursPassed = async (when: Date, connector: StakewiseConnector) => {
-  const lastBlock = await connector.eth.getBlock()
-
-  const current = lastBlock ? lastBlock.timestamp : Number((new Date().getTime() / 1000).toFixed(0))
-
-  const diff = Number(current) - Number(when.getTime() / 1000)
-
-  return diff > 86_400 // 24 hours
-}
-
-type ParseQueueDataArgs = {
-  connector: StakewiseConnector
-  userAddress: Hex
-  vaultAddress: Hex
-  exitRequests: Array<{
-    positionTicket: bigint
-    totalShares: bigint
-    when: Date
-  }>
-}
-
-const parseQueueData = async ({ connector, userAddress, vaultAddress, exitRequests }: ParseQueueDataArgs) => {
-  const unstakeQueue = await Promise.all(
-    exitRequests.map(async (exitRequest): Promise<UnstakeQueueItem> => {
-      const { positionTicket, when, totalShares } = exitRequest
-
-      // We must fetch the exit queue index for every position.
-      // Based on the response we can determine if we can claim exited assets.
-      const baseExitQueueIndex = await connector.eth.readContract({
-        abi: VaultABI,
-        address: vaultAddress,
-        functionName: 'getExitQueueIndex',
-        args: [positionTicket]
-      })
-
-      const exitQueueIndex = baseExitQueueIndex > -1n ? baseExitQueueIndex : undefined
-
-      // 24 hours must have elapsed since the position was created
-      const is24HoursPassed = await getIs24HoursPassed(when, connector)
-
-      // If the index is -1 then we cannot claim anything. Otherwise, the value is >= 0.
-      const isValid = exitQueueIndex !== undefined
-
-      const isWithdrawable = isValid && is24HoursPassed
-
-      const totalAssets = await connector.eth.readContract({
-        abi: VaultABI,
-        address: vaultAddress,
-        functionName: 'convertToAssets',
-        args: [totalShares]
-      })
-
-      if (!isWithdrawable || exitQueueIndex === undefined) {
-        const nonWithdrawable: UnstakeQueueItem = {
-          exitQueueIndex,
-          positionTicket,
-          when,
-          isWithdrawable: false,
-          totalShares,
-          totalAssets,
-          leftShares: totalShares,
-          leftAssets: totalAssets,
-          withdrawableShares: 0n,
-          withdrawableAssets: 0n
-        }
-        return nonWithdrawable
-      }
-
-      const [leftShares, withdrawableShares, withdrawableAssets] = await connector.eth.readContract({
-        abi: VaultABI,
-        address: vaultAddress,
-        functionName: 'calculateExitedAssets',
-        args: [userAddress, positionTicket, BigInt(Number(when) / 1000), exitQueueIndex] as const
-      })
-
-      const leftAssets = await connector.eth.readContract({
-        abi: VaultABI,
-        address: vaultAddress,
-        functionName: 'convertToAssets',
-        args: [leftShares]
-      })
-
-      const fullPosition: UnstakeQueueItem = {
-        positionTicket,
-        when,
-        totalShares,
-        isWithdrawable: true,
-        exitQueueIndex,
-        totalAssets,
-        leftShares,
-        leftAssets,
-        withdrawableShares,
-        withdrawableAssets
-      }
-      return fullPosition
-    })
-  )
-
-  return unstakeQueue.sort((a, b) => Number(b.when) - Number(a.when))
+  const data = queueData.data.exitRequests as {
+    timestamp: string
+    isClaimable: boolean
+    isClaimed: boolean
+    totalAssets: string
+    exitedAssets: string
+    positionTicket: string
+    exitQueueIndex: string | null
+  }[]
+
+  return data.map((queueItem) => ({
+    positionTicket: BigInt(queueItem.positionTicket),
+    exitQueueIndex: queueItem.exitQueueIndex ? BigInt(queueItem.exitQueueIndex) : undefined,
+    isWithdrawable: queueItem.isClaimable,
+    wasWithdrawn: queueItem.isClaimed,
+    timestamp: Number(queueItem.timestamp) * 1000,
+    totalAssets: BigInt(queueItem.totalAssets),
+    exitedAssets: BigInt(queueItem.exitedAssets || 0)
+  }))
 }
diff --git a/packages/ethereum/src/staker.ts b/packages/ethereum/src/staker.ts
@@ -346,10 +346,11 @@ export class EthereumStaker {
 
     return queue.map((item) => ({
       positionTicket: item.positionTicket.toString(),
-      timestamp: item.when.getTime(),
+      exitQueueIndex: item.exitQueueIndex?.toString(),
+      timestamp: item.timestamp,
       isWithdrawable: item.isWithdrawable,
       totalAmount: formatEther(item.totalAssets),
-      withdrawableAmount: formatEther(item.withdrawableAssets)
+      withdrawableAmount: formatEther(item.totalAssets - item.exitedAssets)
     }))
   }
 
diff --git a/packages/ethereum/test/getUnstakeQueue.spec.ts b/packages/ethereum/test/getUnstakeQueue.spec.ts
@@ -1,177 +1,36 @@
-import { Hex, PublicClient, WalletClient, decodeEventLog, formatEther, parseEther } from 'viem'
+import { Hex } from 'viem'
 import { assert } from 'chai'
 import { EthereumStaker } from '../dist/mjs'
-import { prepareTests, stake } from './lib/utils'
-import { VaultABI } from '../src/lib/contracts/vaultAbi'
-const amountToStake = parseEther('5')
-const amountToUnstake = parseEther('1')
-
-const originalFetch = global.fetch
-
-// https://github.com/tc39/proposal-promise-with-resolvers/blob/main/polyfills.js
-const withResolvers = <V = unknown, Err = unknown>() => {
-  const out: {
-    resolve: (value: V) => void
-    reject: (reason: Err) => void
-    promise: Promise<V>
-  } = {
-    resolve: () => {},
-    reject: () => {},
-    promise: Promise.resolve() as Promise<V>
-  }
-
-  out.promise = new Promise<V>((resolve, reject) => {
-    out.resolve = resolve
-    out.reject = reject
-  })
-
-  return out
-}
-
-type VaultEvent = ReturnType<typeof decodeEventLog<typeof VaultABI, 'ExitQueueEntered'>>
+import { prepareTests } from './lib/utils'
 
 describe('EthereumStaker.getUnstakeQueue', () => {
   let delegatorAddress: Hex
   let validatorAddress: Hex
-  let walletClient: WalletClient
-  let publicClient: PublicClient
   let staker: EthereumStaker
-  let unwatch: () => void = () => {}
-
-  const unstake = async (amount: string) => {
-    const { tx } = await staker.buildUnstakeTx({
-      delegatorAddress,
-      validatorAddress,
-      amount
-    })
-
-    const request = await walletClient.prepareTransactionRequest({
-      ...tx,
-      chain: undefined
-    })
-    const hash = await walletClient.sendTransaction({
-      ...request,
-      account: delegatorAddress
-    })
-
-    const receipt = await publicClient.waitForTransactionReceipt({ hash })
-    assert.equal(receipt.status, 'success')
-  }
 
   beforeEach(async () => {
     const setup = await prepareTests()
-
-    delegatorAddress = setup.walletClient.account.address
+    // Use stale delegator address which never unstaked
+    delegatorAddress = '0x15e4287B086f0a8556A5B578a8d8284F19F2c9aC'
     validatorAddress = setup.validatorAddress
-    publicClient = setup.publicClient
-    walletClient = setup.walletClient
     staker = setup.staker
-
-    await stake({
-      delegatorAddress,
-      validatorAddress,
-      amountToStake,
-      publicClient,
-      walletClient,
-      staker
-    })
-  })
-
-  afterEach(() => {
-    unwatch()
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    global.fetch = originalFetch
   })
 
   it('should return the unstake queue', async () => {
-    // Subscribe to the ExitQueueEntered events
-    const { resolve: eventsResolve, promise: eventsPromise } = withResolvers<VaultEvent[]>()
-    const passedEvents: VaultEvent[] = []
-
-    unwatch = publicClient.watchEvent({
-      onLogs: (logs) => {
-        const nextEvents = logs
-          .map((l) =>
-            decodeEventLog({
-              abi: VaultABI,
-              data: l.data,
-              topics: l.topics
-            })
-          )
-          .filter((e): e is VaultEvent => e.eventName === 'ExitQueueEntered')
-        passedEvents.push(...nextEvents)
-        if (passedEvents.length === 2) {
-          eventsResolve(passedEvents.sort((a, b) => Number(a.args.shares) - Number(b.args.shares)))
-        }
-      }
-    })
-
-    // Unstake
-
-    await unstake(formatEther(amountToUnstake))
-    await unstake('2')
-
-    // Wait for the events to be processed
-
-    const events = await eventsPromise
-
-    assert.strictEqual(events.length, 2)
-    // The shares are not exactly the same as the amount to unstake
-    assert.closeTo(Number(events[0].args.shares), Number(parseEther('1')), Number(parseEther('0.1')))
-    assert.isTrue(typeof events[0].args.positionTicket === 'bigint')
-
-    // mock the request to Stakewise with positionTicket and totalShares from the events
-
-    const day = 24 * 60 * 60
-    const mockExitRequests = [
-      {
-        positionTicket: events[0].args.positionTicket.toString(),
-        totalShares: events[0].args.shares.toString(),
-        // earlier
-        timestamp: Math.round((new Date().getTime() - 60000) / 1000 - day * 2).toString()
-      },
-      {
-        positionTicket: events[1].args.positionTicket.toString(),
-        totalShares: events[1].args.shares.toString(),
-        // later
-        timestamp: Math.round(new Date().getTime() / 1000 - day * 2).toString()
-      }
-    ]
-
-    const mockFetch = (input, init) => {
-      if (input === 'https://holesky-graph.stakewise.io/subgraphs/name/stakewise/stakewise?opName=exitQueue') {
-        return Promise.resolve({
-          ok: true,
-          json: () =>
-            Promise.resolve({
-              data: {
-                exitRequests: mockExitRequests
-              }
-            })
-        })
-      } else {
-        return originalFetch(input, init) // Fallback to the original fetch for other URLs
-      }
-    }
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    global.fetch = mockFetch
-
     const unstakeQueue = await staker.getUnstakeQueue({
       validatorAddress,
       delegatorAddress
     })
 
-    assert.strictEqual(unstakeQueue.length, 2)
-    // The queue is sorted by the timestamp from latest to earliest
-    const earlierItem = unstakeQueue[1]
-    const earlierMock = mockExitRequests[0]
-
-    assert.equal(earlierItem.timestamp, new Date(Number(earlierMock.timestamp) * 1000).getTime())
-    // Take into account 1 wei assets conversion issues on the contract
-    assert.closeTo(Number(parseEther(earlierItem.totalAmount)), Number(amountToUnstake), 1)
-
-    assert.isFalse(earlierItem.isWithdrawable)
+    assert.deepEqual(unstakeQueue, [
+      {
+        exitQueueIndex: '47',
+        positionTicket: '112811942030831899448',
+        timestamp: 1711727436000,
+        isWithdrawable: true,
+        totalAmount: '0.500019229644855834',
+        withdrawableAmount: '0'
+      }
+    ])
   })
 })
diff --git a/packages/ethereum/test/getVault.spec.ts b/packages/ethereum/test/getVault.spec.ts

Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ export async function buildWithdrawTx (request: {`
`24`	`24`	`return positionTickets.includes(item.positionTicket.toString())`
`25`	`25`	`})`
`26`	`26`	`.map((item) => {`
`27`		`- const timestamp = Math.floor(item.when.getTime() / 1000)`
	`27`	`+ const timestamp = item.timestamp / 1000`
`28`	`28`	`if (item.exitQueueIndex === undefined) {`
`29`	`29`	`throw new Error('Exit queue index is missing')`
`30`	`30`	`}`