chore(portfolio): added records type to balance manager

packages/portfolio/src/balance-manager.test.ts

@@ -118,6 +118,7 @@ describe('hydrate', () => {
       ],
     })
     const sortedBalances = {
+      records: new Map(sorted.map((amount) => [amount.info.id, amount])),
       all: sorted,
       fts: sorted.filter(({info}) => isFt(info)),
       nfts: sorted.filter(({info}) => isNft(info)),

packages/portfolio/src/balance-manager.ts

@@ -36,10 +36,12 @@ export const portfolioBalanceManagerMaker = (
   let secondaries: Readonly<Map<Portfolio.Token.Id, Portfolio.Token.Amount>> =
     freeze(new Map())
   let sortedBalances: Readonly<{
+    records: Readonly<Map<Portfolio.Token.Id, Portfolio.Token.Amount>>
     all: ReadonlyArray<Portfolio.Token.Amount>
     nfts: ReadonlyArray<Portfolio.Token.Amount>
     fts: ReadonlyArray<Portfolio.Token.Amount>
   }> = freeze({
+    records: new Map(),
     all: [],
     nfts: [],
     fts: [],
@@ -302,6 +304,7 @@ export const portfolioBalanceManagerMaker = (
             )
             sortedBalances = freeze(
               {
+                records: new Map(),
                 all: [],
                 nfts: [],
                 fts: [],
@@ -401,6 +404,9 @@ const refreshTokenInfos = async ({
 const splitByType = (sortedBalances: ReadonlyArray<Portfolio.Token.Amount>) => {
   return freeze(
     {
+      records: new Map(
+        sortedBalances.map(({info, quantity}) => [info.id, {info, quantity}]),
+      ),
       all: sortedBalances,
       fts: sortedBalances.filter(({info}) => isFt(info)),
       nfts: sortedBalances.filter(({info}) => isNft(info)),

packages/transfer/src/helpers/calc-available-balances.ts

@@ -0,0 +1,48 @@
+import {useTransfer} from '@yoroi/transfer'
+import {Portfolio, Transfer} from '@yoroi/types'
+import {getTotalUsedByOtherTargets} from './get-total-used-by-other-targets'
+
+export const useTokenQuantities = ({
+  balances,
+  selectedTokenId,
+  primaryBreakdown,
+  targets,
+  selectedTargetIndex,
+}: {
+  targets: Readonly<Transfer.Targets>
+  id: Portfolio.Token.Id
+  balances: ReadonlyArray<Portfolio.Token.Amount>
+  primaryBreakdown: Readonly<Portfolio.PrimaryBreakdown>
+  selectedTargetIndex: number
+}) => {
+  const initialQuantity =
+    targets[selectedTargetIndex]?.entry.amounts[selectedTokenId]?.quantity ?? 0n
+
+  const used = getTotalUsedByOtherTargets({
+    targets,
+    selectedTokenId,
+    selectedTargetIndex,
+  })
+
+  const balance = balances.find((amount) => amount.info.id === selectedTokenId)
+  const available = Quantities.diff(balance, used)
+
+  const isPrimary = tokenId === wallet.primaryTokenInfo.id
+  const primaryLocked = asQuantity(
+    wallet.primaryBreakdown.lockedAsStorageCost.toString(),
+  )
+  const locked = isPrimary ? primaryLocked : Quantities.zero
+
+  const spendable = Quantities.diff(available, locked)
+
+  return {
+    balance,
+    used,
+    available,
+    initialQuantity,
+    locked,
+    spendable,
+  }
+}
+
+export function getBalanceTransferBreakdown() {}

packages/transfer/src/helpers/get-total-used-by-other-targets.test.ts

@@ -0,0 +1,135 @@
+import {tokenBalanceMocks} from '@yoroi/portfolio'
+import {getTotalUsedByOtherTargets} from './get-total-used-by-other-targets'
+import {Transfer} from '@yoroi/types'
+
+describe('getTotalUsedByOtherTargets', () => {
+  it('should return the total amount of tokens used by other targets', () => {
+    const targets: Transfer.Target[] = [
+      {
+        receiver: {
+          resolve: '',
+          as: 'address',
+          selectedNameServer: undefined,
+          addressRecords: undefined,
+        },
+        entry: {
+          address: '',
+          amounts: {
+            [tokenBalanceMocks.ftNoTicker.info.id]: {
+              ...tokenBalanceMocks.ftNoTicker,
+              quantity: 100n,
+            },
+          },
+        },
+      },
+      {
+        receiver: {
+          resolve: 'address2',
+          as: 'address',
+          addressRecords: undefined,
+          selectedNameServer: undefined,
+        },
+        entry: {
+          address: 'address2',
+          amounts: {
+            [tokenBalanceMocks.ftNoTicker.info.id]: {
+              ...tokenBalanceMocks.ftNoTicker,
+              quantity: 200n,
+            },
+          },
+        },
+      },
+    ]
+    const selectedTargetIndex = 0
+    const selectedTokenId = tokenBalanceMocks.ftNoTicker.info.id
+
+    const totalUsed = getTotalUsedByOtherTargets({
+      targets,
+      selectedTargetIndex,
+      selectedTokenId,
+    })
+
+    expect(totalUsed).toBe(200n)
+  })
+
+  it('should return 0 if there are no other targets', () => {
+    const targets: Transfer.Target[] = [
+      {
+        receiver: {
+          resolve: '',
+          as: 'address',
+          selectedNameServer: undefined,
+          addressRecords: undefined,
+        },
+        entry: {
+          address: '',
+          amounts: {
+            [tokenBalanceMocks.ftNoTicker.info.id]: {
+              ...tokenBalanceMocks.ftNoTicker,
+              quantity: 100n,
+            },
+          },
+        },
+      },
+    ]
+    const selectedTargetIndex = 0
+    const selectedTokenId = tokenBalanceMocks.ftNoTicker.info.id
+
+    const totalUsed = getTotalUsedByOtherTargets({
+      targets,
+      selectedTargetIndex,
+      selectedTokenId,
+    })
+
+    expect(totalUsed).toBe(0n)
+  })
+
+  it('should return 0 if the selected token is not used by other targets', () => {
+    const targets: Transfer.Target[] = [
+      {
+        receiver: {
+          resolve: '',
+          as: 'address',
+          selectedNameServer: undefined,
+          addressRecords: undefined,
+        },
+        entry: {
+          address: '',
+          amounts: {
+            [tokenBalanceMocks.ftNoTicker.info.id]: {
+              ...tokenBalanceMocks.ftNoTicker,
+              quantity: 100n,
+            },
+          },
+        },
+      },
+      {
+        receiver: {
+          resolve: 'address2',
+          as: 'address',
+          addressRecords: undefined,
+          selectedNameServer: undefined,
+        },
+        entry: {
+          address: 'address2',
+          amounts: {
+            [tokenBalanceMocks.ftNoTicker.info.id]: {
+              ...tokenBalanceMocks.ftNoTicker,
+              quantity: 200n,
+            },
+          },
+        },
+      },
+    ]
+    const selectedTargetIndex = 0
+    const selectedTokenId = 'anyOther.token'
+
+    const totalUsed = getTotalUsedByOtherTargets({
+      targets,
+      selectedTargetIndex,
+      selectedTokenId,
+    })
+
+    expect(totalUsed).toBe(0n)
+  })
+})

packages/transfer/src/helpers/get-total-used-by-other-targets.ts

@@ -0,0 +1,26 @@
+import {Portfolio, Transfer} from '@yoroi/types'
+
+/**
+ * @summary Returns the total amount of tokens used by other targets
+ * @returns BigInt
+ */
+export function getTotalUsedByOtherTargets({
+  targets,
+  selectedTargetIndex,
+  selectedTokenId,
+}: {
+  targets: Readonly<Transfer.Targets>
+  selectedTargetIndex: number
+  selectedTokenId: Portfolio.Token.Id
+}) {
+  const isNotTheSelectedTarget = (_: Transfer.Target, index: number) =>
+    index !== selectedTargetIndex
+
+  return targets
+    .filter(isNotTheSelectedTarget)
+    .reduce(
+      (acc, target) =>
+        acc + (target.entry.amounts[selectedTokenId]?.quantity ?? 0n),
+      0n,
+    )
+}

packages/types/src/index.ts

@@ -191,6 +191,7 @@ import {
   PortfolioManagerBalance,
   PortfolioManagerToken,
 } from './portfolio/manager'
+import {PortfolioTokenBalances} from './portfolio/balances'
 import {AppQueueTask, AppQueueTaskManager} from './app/queue-task-manager'
 
 export namespace App {
@@ -455,6 +456,7 @@ export namespace Portfolio {
   }
 
   export namespace Token {
+    export type Balances = PortfolioTokenBalances
     export type Amount = PortfolioTokenAmount
     export type AmountRecords = PortfolioTokenAmountRecords
 

packages/types/src/portfolio/balances.ts

@@ -0,0 +1,9 @@
+import {PortfolioTokenAmount} from './amount'
+import {PortfolioTokenId} from './token'
+
+export type PortfolioTokenBalances = {
+  records: Readonly<Map<PortfolioTokenId, PortfolioTokenAmount>>
+  all: ReadonlyArray<PortfolioTokenAmount>
+  fts: ReadonlyArray<PortfolioTokenAmount>
+  nfts: ReadonlyArray<PortfolioTokenAmount>
+}

packages/types/src/portfolio/manager.ts

@@ -10,6 +10,7 @@ import {
 import {PortfolioTokenInfo} from './info'
 import {PortfolioTokenId} from './token'
 import {PortfolioPrimaryBreakdown, PortfolioTokenAmount} from './amount'
+import {PortfolioTokenBalances} from './balances'
 
 export type PortfolioManagerToken = Readonly<{
   hydrate(params: PortfolioEventSourceId): void
@@ -57,11 +58,7 @@ export type PortfolioManagerBalance = Readonly<{
 
   getPrimaryBreakdown(): Readonly<PortfolioPrimaryBreakdown>
   getPrimaryBalance(): Readonly<PortfolioTokenAmount>
-  getBalances(): Readonly<{
-    all: ReadonlyArray<PortfolioTokenAmount>
-    fts: ReadonlyArray<PortfolioTokenAmount>
-    nfts: ReadonlyArray<PortfolioTokenAmount>
-  }>
+  getBalances(): Readonly<PortfolioTokenBalances>
 
   destroy(): void
   clear(): void