Add confirmed balance

Author: dguenther

packages/mobile-app/app/(tabs)/index.tsx

@@ -47,7 +47,10 @@ export default function Balances() {
       </ScrollView>
       <Text style={{ fontWeight: 700, fontSize: 24 }}>Balance</Text>
       {getAccountResult.data && (
-        <Text>{`IRON ${getAccountResult.data.balances.iron.unconfirmed}`}</Text>
+        <>
+          <Text>{`Unconfirmed: IRON ${getAccountResult.data.balances.iron.unconfirmed}`}</Text>
+          <Text>{`Confirmed: IRON ${getAccountResult.data.balances.iron.confirmed}`}</Text>
+        </>
       )}
       <StatusBar style="auto" />
     </View>

packages/mobile-app/data/api/walletServer.ts

@@ -16,8 +16,23 @@ const WALLET_SERVER_URLS: Record<Network, string> = {
 class WalletServer {
   transformers: WalletServerTransformer[] = [ForkTester];
 
+  private latestBlockCache: Map<
+    Network,
+    { time: number; response: GetLatestBlockResponse }
+  > = new Map();
+  private LATEST_BLOCK_CACHE_MS = 5000;
+
   async getLatestBlock(network: Network): Promise<GetLatestBlockResponse> {
     const url = WALLET_SERVER_URLS[network] + "latest-block";
+
+    const cached = this.latestBlockCache.get(network);
+    if (
+      cached &&
+      performance.now() - cached.time < this.LATEST_BLOCK_CACHE_MS
+    ) {
+      return cached.response;
+    }
+
     console.log("requesting latest block");
 
     const fetchResult = await fetch(url);
@@ -27,6 +42,11 @@ class WalletServer {
       latestBlock = await transformer.getLatestBlock(network, latestBlock);
     }
 
+    this.latestBlockCache.set(network, {
+      time: performance.now(),
+      response: latestBlock,
+    });
+
     return latestBlock;
   }
 

packages/mobile-app/data/facades/wallet/handlers.ts

@@ -86,24 +86,24 @@ export const walletHandlers = f.facade<WalletHandlers>({
           "51f33a2f14f92735e562dc658a5639279ddca3d5079a6d1242b2a588a9cbf44c",
         // TODO: Implement available balance in Wallet
         available: "0",
-        // TODO: Implement confirmed balance in Wallet
-        confirmed: "0",
         // TODO: Implement pending balance in Wallet
         pending: "0",
         unconfirmed: "0",
+        confirmed: "0",
       };
       const customBalances: AccountBalance[] = [];
 
       for (const balance of balances) {
         if (Uint8ArrayUtils.toHex(balance.assetId) === ironBalance.assetId) {
-          ironBalance.unconfirmed = balance.value;
+          ironBalance.unconfirmed = balance.unconfirmed;
+          ironBalance.confirmed = balance.confirmed;
         } else {
           customBalances.push({
             assetId: Uint8ArrayUtils.toHex(balance.assetId),
             available: "0",
-            confirmed: "0",
             pending: "0",
-            unconfirmed: balance.value,
+            confirmed: balance.confirmed,
+            unconfirmed: balance.unconfirmed,
           });
         }
       }

packages/mobile-app/data/wallet/db.ts

@@ -38,6 +38,14 @@ interface AccountTransactionsTable {
   transactionType: string;
 }
 
+interface TransactionBalanceDeltasTable {
+  id: Generated<number>;
+  accountId: number;
+  transactionHash: Uint8Array;
+  assetId: Uint8Array;
+  value: string;
+}
+
 interface NotesTable {
   id: Generated<number>;
   accountId: number;
@@ -85,6 +93,7 @@ interface Database {
   accountNetworkHeads: AccountNetworkHeadsTable;
   transactions: TransactionsTable;
   accountTransactions: AccountTransactionsTable;
+  transactionBalanceDeltas: TransactionBalanceDeltasTable;
   notes: NotesTable;
   nullifiers: NullifiersTable;
   balances: BalancesTable;
@@ -295,6 +304,30 @@ export class WalletDb {
               console.log("created balances");
             },
           },
+          ["008_createTransactionBalanceDeltas"]: {
+            up: async (db: Kysely<Database>) => {
+              console.log("creating transaction balance deltas");
+              await db.schema
+                .createTable("transactionBalanceDeltas")
+                .addColumn("id", SQLiteType.Integer, (col) =>
+                  col.primaryKey().autoIncrement(),
+                )
+                .addColumn("accountId", SQLiteType.Integer, (col) =>
+                  col.notNull().references("accounts.id"),
+                )
+                .addColumn("transactionHash", SQLiteType.Blob, (col) =>
+                  col.notNull().references("transactions.hash"),
+                )
+                .addColumn("assetId", SQLiteType.Blob, (col) => col.notNull())
+                .addColumn("value", SQLiteType.String, (col) => col.notNull())
+                .addUniqueConstraint(
+                  "transactionbalancedeltas_accountId_hash_assetId",
+                  ["accountId", "transactionHash", "assetId"],
+                )
+                .execute();
+              console.log("created transaction balance deltas");
+            },
+          },
         },
       }),
     });
@@ -658,6 +691,16 @@ export class WalletDb {
               .doUpdateSet({ value: (existingBalance + delta[1]).toString() }),
           )
           .executeTakeFirstOrThrow();
+
+        await db
+          .insertInto("transactionBalanceDeltas")
+          .values({
+            accountId: values.accountId,
+            assetId: Uint8ArrayUtils.fromHex(delta[0]),
+            transactionHash: values.hash,
+            value: delta[1].toString(),
+          })
+          .executeTakeFirstOrThrow();
       }
     });
   }
@@ -773,4 +816,29 @@ export class WalletDb {
       )
       .execute();
   }
+
+  async getTransactionBalanceDeltasBySequence(
+    accountId: number,
+    network: Network,
+    startSequence: number,
+    endSequence: number,
+  ) {
+    return await this.db
+      .selectFrom("transactionBalanceDeltas")
+      .innerJoin(
+        "transactions",
+        "transactions.hash",
+        "transactionBalanceDeltas.transactionHash",
+      )
+      .selectAll()
+      .where((eb) =>
+        eb.and([
+          eb("transactions.blockSequence", ">=", startSequence),
+          eb("transactions.blockSequence", "<=", endSequence),
+          eb("transactions.network", "=", network),
+          eb("transactionBalanceDeltas.accountId", "=", accountId),
+        ]),
+      )
+      .execute();
+  }
 }

packages/mobile-app/data/wallet/wallet.ts

@@ -12,6 +12,7 @@ import { Network } from "../constants";
 import * as Uint8ArrayUtils from "../../utils/uint8Array";
 import { LightBlock, LightTransaction } from "../api/lightstreamer";
 import { WriteCache } from "./writeCache";
+import { WalletServerApi } from "../api/walletServer";
 
 type StartedState = { type: "STARTED"; db: WalletDb };
 type WalletState = { type: "STOPPED" } | { type: "LOADING" } | StartedState;
@@ -80,7 +81,61 @@ class Wallet {
   async getBalances(accountId: number, network: Network) {
     assertStarted(this.state);
 
-    return this.state.db.getBalances(accountId, network);
+    const unconfirmed = await this.state.db.getBalances(accountId, network);
+
+    const deltas = await this.getUnconfirmedDeltas(accountId, network);
+    const confirmed: { assetId: Uint8Array; value: string }[] = unconfirmed.map(
+      (balance) => {
+        const assetDeltas = deltas.filter((d) =>
+          Uint8ArrayUtils.areEqual(d.assetId, balance.assetId),
+        );
+
+        return {
+          assetId: balance.assetId,
+          value: assetDeltas
+            .reduce((a, b) => {
+              return a - BigInt(b.value);
+            }, BigInt(balance.value))
+            .toString(),
+        };
+      },
+    );
+
+    // Caution, this makes the assumption that unconfirmed and confirmed are ordered the same
+    const balanceReturns = [];
+    for (let i = 0; i < unconfirmed.length; i++) {
+      balanceReturns.push({
+        assetId: unconfirmed[i].assetId,
+        confirmed: confirmed[i].value,
+        unconfirmed: unconfirmed[i].value,
+      });
+    }
+
+    return balanceReturns;
+  }
+
+  /**
+   * Returns transaction balance deltas from head - confirmationRange + 1 to head, inclusive.
+   */
+  private async getUnconfirmedDeltas(accountId: number, network: Network) {
+    assertStarted(this.state);
+
+    const chainHead = (await WalletServerApi.getLatestBlock(network)).sequence;
+    // TODO: Make confirmation range configurable
+    const confirmationRange = 2;
+
+    if (confirmationRange <= 0) {
+      return [];
+    }
+
+    const deltas = await this.state.db.getTransactionBalanceDeltasBySequence(
+      accountId,
+      network,
+      chainHead - confirmationRange + 1,
+      chainHead,
+    );
+
+    return deltas;
   }
 
   async exportAccount(