Merge pull request #14647 from LedgerHQ/feat/aleo-private-balance

feat(LIVE-25440) aleo private balance

Author: mateuszpalosz-ext

.changeset/gold-radios-marry.md

@@ -0,0 +1,6 @@
+---
+"@ledgerhq/coin-aleo": minor
+"ledger-live-desktop": minor
+---
+
+aleo private balance integration

apps/ledger-live-desktop/src/renderer/families/aleo/AccountBalanceSummaryFooter.test.tsx

@@ -23,6 +23,9 @@ describe("AccountBalanceSummaryFooter", () => {
     aleoResources: {
       transparentBalance: mockTransparentBalance,
       provableApi: null,
+      privateBalance: null,
+      unspentPrivateRecords: [],
+      lastPrivateSyncDate: new Date(),
     },
   };
 

apps/ledger-live-desktop/src/renderer/families/aleo/AccountBalanceSummaryFooter.tsx

@@ -36,7 +36,7 @@ const AccountBalanceSummaryFooter = ({ account }: Readonly<Props>) => {
 
   const spendableBalance = account.spendableBalance;
   const transparentBalance = account.aleoResources.transparentBalance;
-  const privateBalance = null; // private sync will be added later
+  const privateBalance = account.aleoResources.privateBalance;
 
   const formattedAvailableBalance = formatCurrencyUnit(unit, spendableBalance, formatConfig);
   const formattedTransparentBalance = formatCurrencyUnit(unit, transparentBalance, formatConfig);

libs/coin-modules/coin-aleo/src/__tests__/fixtures/account.fixture.ts

@@ -8,13 +8,31 @@ const defaultMockAccountId =
   "js:2:aleo:aleo1zcwqycj02lccfuu57dzjhva7w5dpzc7pngl0sxjhp58t6vlnnqxs6lnp6f::AViewKey123";
 
 export const mockAleoResources: AleoResources = {
-  transparentBalance: new BigNumber(0),
-  provableApi: null,
+  transparentBalance: new BigNumber(1000),
+  provableApi: {
+    apiKey: "abc",
+    consumerId: "consumer123",
+    jwt: {
+      token: "jwt_token",
+      exp: Math.floor(Date.now() / 1000) + 3600,
+    },
+    uuid: "uuid-1234",
+    scannerStatus: {
+      percentage: 50,
+      synced: false,
+    },
+  },
+  privateBalance: new BigNumber(1),
+  unspentPrivateRecords: [],
+  lastPrivateSyncDate: new Date(),
 };
 
 export const mockAleoResourcesRaw: AleoResourcesRaw = {
-  transparentBalance: "0",
-  provableApi: null,
+  transparentBalance: mockAleoResources.transparentBalance.toString(),
+  provableApi: JSON.stringify(mockAleoResources.provableApi),
+  privateBalance: mockAleoResources.privateBalance?.toString() ?? null,
+  unspentPrivateRecords: JSON.stringify(mockAleoResources.unspentPrivateRecords),
+  lastPrivateSyncDate: mockAleoResources.lastPrivateSyncDate?.toISOString() ?? null,
 };
 
 export const getMockedAccount = (overrides?: Partial<AleoAccount>): AleoAccount => {

libs/coin-modules/coin-aleo/src/__tests__/fixtures/api.fixture.ts

@@ -1,6 +1,10 @@
 import { PROGRAM_ID } from "../../constants";
-import { EnrichedTransaction } from "../../types";
-import type { AleoPublicTransaction, AleoPublicTransactionDetailsResponse } from "../../types/api";
+import {
+  AleoPrivateRecord,
+  AleoPublicTransaction,
+  AleoPublicTransactionDetailsResponse,
+  EnrichedTransaction,
+} from "../../types";
 
 export const getMockedTransaction = (
   overrides?: Partial<AleoPublicTransaction>,
@@ -63,3 +67,26 @@ export function getMockedEnrichedTransaction(
     ...overrides,
   };
 }
+
+export const testnetViewKey = "AViewKey1tTb4WYnMFnDWjSgTSA5VkiyLKNZH1szDcMyEuzSu1zbk";
+
+// this record has `microcredits: "800000u64.private"` in the decrypted data
+export const testnetPrivateRecord: AleoPrivateRecord = {
+  block_height: 14192647,
+  block_timestamp: 1770127220,
+  commitment: "5577911026701224136131721605774668283349812508334064746703596134075753528694field",
+  function_name: "transfer_public_to_private",
+  output_index: 0,
+  owner: "4061324383530370528773115724536366126386700749943799382889243452721616108297field",
+  program_name: "credits.aleo",
+  record_ciphertext:
+    "record1qvqsps6wqrka73247spvsvdlgwr8qhmn5f4uze4t8zutp4k8mwm3zdgtqyxx66trwfhkxun9v35hguerqqpqzqrpdge64jwzyz32aknuxc800uugfwv52pqse4dk4p32datlzpd8z95td5t0dhdm4dfhtq9w285uj2arltzky4u6hmdv2xpdnkv365l3qg9hn0g",
+  record_name: "credits",
+  sender: "aleo1zcwqycj02lccfuu57dzjhva7w5dpzc7pngl0sxjhp58t6vlnnqxs6lnp6f",
+  spent: false,
+  tag: "4138557248634429596246575371443174357174703200753459213664031563822892655489field",
+  transaction_id: "at144lgzzq73r38hx4jvtecxteg8v32creg2pxpazs9n4xcduu5jsfqv43lx9    ",
+  transition_id: "au1mxddgfe8yl0yadjrm6qaz6wqljtlqth885muwxvrzvpd9852cyqqxhxr76    ",
+  transaction_index: 0,
+  transition_index: 0,
+};

libs/coin-modules/coin-aleo/src/bridge/index.ts

@@ -15,14 +15,15 @@ import type {
 import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
 import type { Observable } from "rxjs";
 import aleoCoinConfig, { type AleoCoinConfig } from "../config";
-import type { Transaction as AleoTransaction } from "../types/index";
+import type { AleoAccount, Transaction as AleoTransaction } from "../types/index";
 import type { AleoSigner } from "../types/signer";
 import resolver from "../signer/getAddress";
 import { validateAddress } from "../logic/validateAddress";
 import { estimateMaxSpendable } from "./estimateMaxSpendable";
 import { getAccountShape, sync } from "./sync";
 import { createTransaction } from "./createTransaction";
 import { prepareTransaction } from "./prepareTransaction";
+import { assignFromAccountRaw, assignToAccountRaw } from "./serialization";
 import { getTransactionStatus } from "./getTransactionStatus";
 
 export function buildCurrencyBridge(signerContext: SignerContext<AleoSigner>): CurrencyBridge {
@@ -42,7 +43,7 @@ export function buildCurrencyBridge(signerContext: SignerContext<AleoSigner>): C
 
 export function buildAccountBridge(
   signerContext: SignerContext<AleoSigner>,
-): AccountBridge<AleoTransaction> {
+): AccountBridge<AleoTransaction, AleoAccount> {
   const getAddress = resolver(signerContext);
   const receive = makeAccountBridgeReceive(getAddressWrapper(getAddress));
 
@@ -63,6 +64,8 @@ export function buildAccountBridge(
       throw new Error("broadcast is not supported");
     },
     estimateMaxSpendable,
+    assignFromAccountRaw,
+    assignToAccountRaw,
     getSerializedAddressParameters,
     validateAddress,
   };
@@ -71,7 +74,7 @@ export function buildAccountBridge(
 export function createBridges(
   signerContext: SignerContext<AleoSigner>,
   coinConfig: CoinConfig<AleoCoinConfig>,
-): Bridge<AleoTransaction> {
+): Bridge<AleoTransaction, AleoAccount> {
   aleoCoinConfig.setCoinConfig(coinConfig);
 
   return {

libs/coin-modules/coin-aleo/src/bridge/serialization.test.ts

@@ -0,0 +1,47 @@
+import {
+  getMockedAccount,
+  getMockedAccountRaw,
+  mockAleoResources,
+  mockAleoResourcesRaw,
+} from "../__tests__/fixtures/account.fixture";
+import type { AleoAccount, AleoAccountRaw } from "../types";
+import {
+  assignFromAccountRaw,
+  assignToAccountRaw,
+  toAleoResourcesRaw,
+  fromAleoResourcesRaw,
+} from "./serialization";
+
+describe("serialization", () => {
+  let mockedAccount: AleoAccount;
+  let mockedAccountRaw: AleoAccountRaw;
+
+  beforeEach(() => {
+    mockedAccount = getMockedAccount();
+    mockedAccountRaw = getMockedAccountRaw();
+  });
+
+  it("should serialize AleoResources to raw format", () => {
+    const result = toAleoResourcesRaw(mockAleoResources);
+
+    expect(result).toEqual(mockAleoResourcesRaw);
+  });
+
+  it("should deserialize raw format back to AleoResources", () => {
+    const result = fromAleoResourcesRaw(mockAleoResourcesRaw);
+
+    expect(result).toEqual(mockAleoResources);
+  });
+
+  it("should write serialized resources onto AccountRaw", () => {
+    assignToAccountRaw(mockedAccount, mockedAccountRaw);
+
+    expect(mockedAccountRaw.aleoResources).toEqual(mockAleoResourcesRaw);
+  });
+
+  it("should read and deserialize resources from AccountRaw onto Account", () => {
+    assignFromAccountRaw(mockedAccountRaw, mockedAccount);
+
+    expect(mockedAccount.aleoResources).toEqual(mockAleoResources);
+  });
+});

libs/coin-modules/coin-aleo/src/bridge/serialization.ts

@@ -0,0 +1,49 @@
+import BigNumber from "bignumber.js";
+import type { AccountRaw, Account } from "@ledgerhq/types-live";
+import type { AleoAccount, AleoAccountRaw, AleoResources, AleoResourcesRaw } from "../types";
+
+export function toAleoResourcesRaw(resources: AleoResources): AleoResourcesRaw {
+  return {
+    transparentBalance: resources.transparentBalance.toString(),
+    privateBalance: resources.privateBalance?.toString() ?? null,
+    provableApi: resources.provableApi ? JSON.stringify(resources.provableApi) : null,
+    lastPrivateSyncDate: resources.lastPrivateSyncDate
+      ? resources.lastPrivateSyncDate.toISOString()
+      : null,
+    unspentPrivateRecords: resources.unspentPrivateRecords
+      ? JSON.stringify(resources.unspentPrivateRecords)
+      : null,
+  };
+}
+
+export function fromAleoResourcesRaw(rawResources: AleoResourcesRaw): AleoResources {
+  return {
+    transparentBalance: new BigNumber(rawResources.transparentBalance),
+    privateBalance: rawResources.privateBalance ? new BigNumber(rawResources.privateBalance) : null,
+    provableApi: rawResources.provableApi ? JSON.parse(rawResources.provableApi) : null,
+    lastPrivateSyncDate: rawResources.lastPrivateSyncDate
+      ? new Date(rawResources.lastPrivateSyncDate)
+      : null,
+    unspentPrivateRecords: rawResources.unspentPrivateRecords
+      ? JSON.parse(rawResources.unspentPrivateRecords)
+      : null,
+  };
+}
+
+export function assignToAccountRaw(account: Account, accountRaw: AccountRaw): void {
+  const aleoAccount = account as AleoAccount;
+  const aleoAccountRaw = accountRaw as AleoAccountRaw;
+
+  if (aleoAccount.aleoResources) {
+    aleoAccountRaw.aleoResources = toAleoResourcesRaw(aleoAccount.aleoResources);
+  }
+}
+
+export function assignFromAccountRaw(accountRaw: AccountRaw, account: Account) {
+  const aleoAccount = account as AleoAccount;
+  const aleoAccountRaw = accountRaw as AleoAccountRaw;
+
+  if (aleoAccountRaw.aleoResources) {
+    aleoAccount.aleoResources = fromAleoResourcesRaw(aleoAccountRaw.aleoResources);
+  }
+}

libs/coin-modules/coin-aleo/src/bridge/sync.ts

@@ -9,7 +9,10 @@ import { decodeAccountId, encodeAccountId } from "@ledgerhq/coin-framework/accou
 import { log } from "@ledgerhq/logs";
 import { getBalance, lastBlock, listOperations } from "../logic";
 import { accessProvableApi } from "../network/utils";
-import type { AleoAccount, ProvableApi } from "../types";
+import type { AleoAccount, ProvableApi, AleoUnspentRecord } from "../types";
+import { getPrivateBalance } from "../logic/getPrivateBalance";
+import { isProvableApiConfigured } from "../logic/utils";
+import { apiClient } from "../network/api";
 
 export const getAccountShape: GetAccountShape<AleoAccount> = async infos => {
   const { initialAccount, address, derivationMode, currency } = infos;
@@ -69,6 +72,32 @@ export const getAccountShape: GetAccountShape<AleoAccount> = async infos => {
     },
   });
 
+  let privateBalance = initialAccount?.aleoResources?.privateBalance ?? null;
+  let unspentPrivateRecords: AleoUnspentRecord[] | null = null;
+  let lastPrivateSyncDate = initialAccount?.aleoResources?.lastPrivateSyncDate ?? null;
+
+  if (viewKey && isProvableApiConfigured(provableApi)) {
+    const rawUnspentPrivateRecords = await apiClient.getAccountOwnedRecords({
+      currency,
+      jwtToken: provableApi.jwt.token,
+      uuid: provableApi.uuid,
+      apiKey: provableApi.apiKey,
+      unspent: true,
+    });
+
+    const privateBalanceResult = await getPrivateBalance({
+      currency,
+      viewKey,
+      privateRecords: rawUnspentPrivateRecords,
+    });
+
+    privateBalance = privateBalanceResult.balance;
+    unspentPrivateRecords = privateBalanceResult.unspentRecords;
+    lastPrivateSyncDate = new Date();
+  }
+
+  const totalBalance = transparentBalance.plus(privateBalance ?? 0);
+
   // sort by date desc
   latestAccountPublicOperations.operations.sort((a, b) => b.date.getTime() - a.date.getTime());
 
@@ -80,15 +109,18 @@ export const getAccountShape: GetAccountShape<AleoAccount> = async infos => {
   return {
     type: "Account",
     id: ledgerAccountId,
-    balance: transparentBalance,
-    spendableBalance: transparentBalance,
+    balance: totalBalance,
+    spendableBalance: totalBalance,
     blockHeight,
     operations,
     operationsCount: operations.length,
     lastSyncDate: new Date(),
     aleoResources: {
       transparentBalance,
       provableApi,
+      privateBalance,
+      unspentPrivateRecords,
+      lastPrivateSyncDate,
     },
   };
 };