Implement withdrawable assets

packages/backend/src/Application.ts

@@ -465,6 +465,7 @@ export class Application {
       userTransactionRepository,
       userRegistrationEventRepository,
       assetRepository,
+      withdrawableAssetRepository,
       config.starkex.tradingMode,
       config.starkex.contracts.perpetual,
       collateralAsset

packages/backend/src/api/controllers/UserController.ts

@@ -29,6 +29,7 @@ import {
   UserTransactionRepository,
 } from '../../peripherals/database/transactions/UserTransactionRepository'
 import { UserRegistrationEventRepository } from '../../peripherals/database/UserRegistrationEventRepository'
+import { WithdrawableAssetRepository } from '../../peripherals/database/WithdrawableAssetRepository'
 import { ControllerResult } from './ControllerResult'
 import { sentTransactionToEntry } from './sentTransactionToEntry'
 import { userTransactionToEntry } from './userTransactionToEntry'
@@ -45,6 +46,7 @@ export class UserController {
     private readonly userTransactionRepository: UserTransactionRepository,
     private readonly userRegistrationEventRepository: UserRegistrationEventRepository,
     private readonly assetRepository: AssetRepository,
+    private readonly withdrawableAssetRepository: WithdrawableAssetRepository,
     private readonly tradingMode: TradingMode,
     private readonly exchangeAddress: EthereumAddress,
     private readonly collateralAsset?: CollateralAsset
@@ -64,6 +66,7 @@ export class UserController {
       sentTransactions,
       userTransactions,
       userTransactionsCount,
+      withdrawableAssets,
     ] = await Promise.all([
       this.userService.getUserDetails(givenUser),
       this.userRegistrationEventRepository.findByStarkKey(starkKey),
@@ -86,13 +89,15 @@ export class UserController {
         limit: 10,
       }),
       this.userTransactionRepository.getCountByStarkKey(starkKey),
+      this.withdrawableAssetRepository.getAssetBalancesByStarkKey(starkKey),
     ])
 
     const assetDetailsMap = await this.assetDetailsService.getAssetDetailsMap({
       userAssets: userAssets,
       assetHistory: history,
       sentTransactions,
       userTransactions,
+      withdrawableAssets,
     })
 
     const assetEntries = userAssets.map((a) =>
@@ -122,8 +127,14 @@ export class UserController {
       tradingMode: this.tradingMode,
       starkKey,
       ethereumAddress: registeredUser?.ethAddress ?? EthereumAddress.ZERO,
+      withdrawableAssets: withdrawableAssets.map((asset) => ({
+        asset: {
+          hashOrId: asset.assetHash,
+          details: assetDetailsMap?.getByAssetHash(asset.assetHash),
+        },
+        amount: asset.balanceDelta,
+      })),
       exchangeAddress: this.exchangeAddress,
-      withdrawableAssets: [],
       offersToAccept: [],
       assets: assetEntries,
       totalAssets,

packages/backend/src/core/AssetDetailsService.ts

@@ -19,6 +19,7 @@ export class AssetDetailsService {
     assetHistory?: PreprocessedAssetHistoryRecord[]
     sentTransactions?: SentTransactionRecord[]
     userTransactions?: UserTransactionRecord[]
+    withdrawableAssets?: { assetHash: AssetHash; balanceDelta: bigint }[]
   }): Promise<AssetDetailsMap | undefined> {
     if (this.tradingMode !== 'spot') {
       return undefined
@@ -33,6 +34,7 @@ export class AssetDetailsService {
       ...(records.userTransactions?.map((tx) =>
         this.getUserTransactionAssetHash(tx)
       ) ?? []),
+      ...(records.withdrawableAssets?.map((a) => a.assetHash) ?? []),
     ].filter((hash): hash is AssetHash => AssetHash.check(hash))
 
     const assetTypeAndTokenIds: { assetType: AssetHash; tokenId: bigint }[] =

packages/backend/src/peripherals/database/WithdrawableAssetRepository.test.ts

@@ -224,4 +224,99 @@ describe(WithdrawableAssetRepository.name, () => {
       expect(await repository.findById(id2)).toEqual(undefined)
     })
   })
+  describe(
+    WithdrawableAssetRepository.prototype.getAssetBalancesByStarkKey.name,
+    () => {
+      it('returns all records for the given stark key', async () => {
+        const starkKey1 = StarkKey.fake()
+        const starkKey2 = StarkKey.fake()
+
+        const firstAsset = AssetHash.fake()
+        const secondAsset = AssetHash.fake()
+        const thirdAsset = AssetHash.fake()
+
+        await repository.add({
+          transactionHash: Hash256.fake(),
+          blockNumber: 123,
+          timestamp: Timestamp(123000),
+          data: fakeWithdrawalAllowedData({
+            starkKey: starkKey1,
+            assetType: firstAsset,
+          }),
+        })
+
+        await repository.add({
+          transactionHash: Hash256.fake(),
+          blockNumber: 123,
+          timestamp: Timestamp(123000),
+          data: fakeWithdrawalAllowedData({
+            starkKey: starkKey2,
+            assetType: secondAsset,
+          }),
+        })
+
+        await repository.add({
+          transactionHash: Hash256.fake(),
+          blockNumber: 123,
+          timestamp: Timestamp(123000),
+          data: fakeWithdrawalAllowedData({
+            starkKey: starkKey1,
+            assetType: firstAsset,
+          }),
+        })
+
+        await repository.add({
+          transactionHash: Hash256.fake(),
+          blockNumber: 123,
+          timestamp: Timestamp(123000),
+          data: fakeWithdrawalAllowedData({
+            starkKey: starkKey2,
+            assetType: secondAsset,
+          }),
+        })
+
+        await repository.add({
+          transactionHash: Hash256.fake(),
+          blockNumber: 123,
+          timestamp: Timestamp(123000),
+          data: fakeWithdrawalAllowedData({
+            starkKey: starkKey1,
+            assetType: secondAsset,
+          }),
+        })
+
+        await repository.add({
+          transactionHash: Hash256.fake(),
+          blockNumber: 123,
+          timestamp: Timestamp(123000),
+          data: fakeWithdrawalAllowedData({
+            starkKey: starkKey1,
+            assetType: thirdAsset,
+            quantizedAmount: 0n,
+          }),
+        })
+
+        const records1 = await repository.getAssetBalancesByStarkKey(starkKey1)
+        const records2 = await repository.getAssetBalancesByStarkKey(starkKey2)
+
+        expect(records1).toEqualUnsorted([
+          {
+            assetHash: secondAsset,
+            balanceDelta: 123n,
+          },
+          {
+            assetHash: firstAsset,
+            balanceDelta: 246n,
+          },
+        ])
+
+        expect(records2).toEqual([
+          {
+            assetHash: secondAsset,
+            balanceDelta: 246n,
+          },
+        ])
+      })
+    }
+  )
 })

packages/backend/src/peripherals/database/WithdrawableAssetRepository.ts

@@ -33,6 +33,9 @@ export class WithdrawableAssetRepository extends BaseRepository {
     /* eslint-disable @typescript-eslint/unbound-method */
 
     this.add = this.wrapAdd(this.add)
+    this.getAssetBalancesByStarkKey = this.wrapGet(
+      this.getAssetBalancesByStarkKey
+    )
     this.findById = this.wrapFind(this.findById)
     this.deleteAfter = this.wrapDelete(this.deleteAfter)
     this.deleteAll = this.wrapDelete(this.deleteAll)
@@ -63,6 +66,24 @@ export class WithdrawableAssetRepository extends BaseRepository {
     return results[0]!.id
   }
 
+  async getAssetBalancesByStarkKey(
+    starkKey: StarkKey
+  ): Promise<{ assetHash: AssetHash; balanceDelta: bigint }[]> {
+    const knex = await this.knex()
+    const results: { assetHash: string; balanceDelta: string }[] = await knex(
+      'withdrawable_assets'
+    )
+      .select('asset_hash as assetHash')
+      .where('stark_key', starkKey.toString())
+      .groupBy('asset_hash')
+      .having(knex.raw('sum(balance_delta) > 0'))
+      .sum('balance_delta as balanceDelta')
+    return results.map((x) => ({
+      assetHash: AssetHash(x.assetHash),
+      balanceDelta: BigInt(x.balanceDelta),
+    }))
+  }
+
   async findById(id: number): Promise<WithdrawableAssetRecord | undefined> {
     const knex = await this.knex()
     const result = await knex('withdrawable_assets').where('id', id).first()