@ledgerhq/live-common 34.45.0 → 34.45.1-nightly.1

package/src/bridge/generic-alpaca/getAccountShape.ts

@@ -3,59 +3,97 @@ import { GetAccountShape, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHel
 import BigNumber from "bignumber.js";
 import { getAlpacaApi } from "./alpaca";
 import { adaptCoreOperationToLiveOperation, extractBalance } from "./utils";
+import { inferSubOperations } from "@ledgerhq/coin-framework/serialization";
+import { findToken } from "./buildSubAccounts";
+import { buildSubAccounts, OperationCommon } from "./buildSubAccounts";
 
-export function genericGetAccountShape(network: string, kind: "local" | "remote"): GetAccountShape {
-  return async info => {
-    try {
-      const { address, initialAccount, currency, derivationMode } = info;
-      const accountId = encodeAccountId({
-        type: "js",
-        version: "2",
-        currencyId: currency.id,
-        xpubOrAddress: address,
-        derivationMode,
-      });
-
-      const blockInfo = await getAlpacaApi(network, kind).lastBlock();
-
-      const balances = await getAlpacaApi(network, kind).getBalance(address);
-      const nativeBalance = extractBalance(balances, "native");
-      const balance = BigNumber(nativeBalance.value.toString());
-
-      let spendableBalance: BigNumber;
-      if (nativeBalance.locked) {
-        spendableBalance = BigNumber.max(
-          balance.minus(BigNumber(nativeBalance.locked.toString())),
-          BigNumber(0),
-        );
-      } else {
-        spendableBalance = initialAccount?.spendableBalance || balance;
+export function genericGetAccountShape(network: string, kind: string): GetAccountShape {
+  return async (info, syncConfig) => {
+    const { address, initialAccount, currency, derivationMode } = info;
+    const alpacaApi = getAlpacaApi(network, kind);
+
+    if (alpacaApi.getChainSpecificRules) {
+      const chainSpecificValidation = alpacaApi.getChainSpecificRules();
+      if (chainSpecificValidation.getAccountShape) {
+        chainSpecificValidation.getAccountShape(address);
       }
-      const oldOperations = initialAccount?.operations || [];
+    }
+
+    const accountId = encodeAccountId({
+      type: "js",
+      version: "2",
+      currencyId: currency.id,
+      xpubOrAddress: address,
+      derivationMode,
+    });
+
+    const blockInfo = await alpacaApi.lastBlock();
+    const balanceRes = await alpacaApi.getBalance(address);
+    const nativeAsset = extractBalance(balanceRes, "native");
+
+    const assetsBalance = balanceRes
+      .filter(b => b.asset.type !== "native")
+      .filter(b => findToken(currency, b));
+
+    const nativeBalance = BigInt(nativeAsset?.value ?? "0");
+
+    const spendableBalance = BigInt(nativeBalance - BigInt(nativeAsset?.locked ?? "0"));
 
-      const blockHeight = oldOperations.length ? (oldOperations[0].blockHeight ?? 0) + 1 : 0;
+    const oldOps = (initialAccount?.operations || []) as OperationCommon[];
+    const lastPagingToken = oldOps[0]?.extra?.pagingToken || "";
 
-      const [newOperations] = await getAlpacaApi(network, kind).listOperations(address, {
-        minHeight: blockHeight,
-      });
+    const blockHeight = oldOps.length ? (oldOps[0].blockHeight ?? 0) + 1 : 0;
+    const paginationParams: any = { minHeight: blockHeight };
+    if (lastPagingToken) {
+      paginationParams.lastPagingToken = lastPagingToken;
+    }
+
+    const [newCoreOps] = await alpacaApi.listOperations(address, paginationParams);
+    const newOps = newCoreOps.map(op =>
+      adaptCoreOperationToLiveOperation(accountId, op),
+    ) as OperationCommon[];
+    const mergedOps = mergeOps(oldOps, newOps) as OperationCommon[];
+
+    const assetOperations: OperationCommon[] = [];
+    mergedOps.forEach(operation => {
+      if (
+        operation?.extra?.assetReference &&
+        operation?.extra?.assetOwner &&
+        !["OPT_IN", "OPT_OUT"].includes(operation.type)
+      ) {
+        assetOperations.push(operation);
+      }
+    });
 
-      const operations = mergeOps(
-        oldOperations,
-        newOperations.map(op => adaptCoreOperationToLiveOperation(accountId, op)),
-      );
+    const subAccounts =
+      buildSubAccounts({
+        currency,
+        accountId,
+        assetsBalance,
+        syncConfig,
+        operations: assetOperations,
+      }) || [];
+
+    const operationsWithSubs = mergedOps.map(op => {
+      const subOperations = inferSubOperations(op.hash, subAccounts);
 
       return {
-        id: accountId,
-        xpub: address,
-        blockHeight: operations.length === 0 ? 0 : blockInfo.height || initialAccount?.blockHeight,
-        balance,
-        spendableBalance,
-        operations,
-        operationsCount: operations.length,
+        ...op,
+        subOperations,
       };
-    } catch (e) {
-      console.error("Error in getAccountShape", e);
-      throw e;
-    }
+    });
+
+    const res = {
+      id: accountId,
+      xpub: address,
+      blockHeight:
+        operationsWithSubs.length === 0 ? 0 : blockInfo.height || initialAccount?.blockHeight,
+      balance: new BigNumber(nativeBalance.toString()),
+      spendableBalance: new BigNumber(spendableBalance.toString()),
+      operations: operationsWithSubs,
+      subAccounts,
+      operationsCount: operationsWithSubs.length,
+    };
+    return res;
   };
 }

package/src/bridge/generic-alpaca/getTransactionStatus.ts

@@ -1,38 +1,62 @@
 import { AccountBridge, TransactionCommon } from "@ledgerhq/types-live";
+import { AccountAwaitingSendPendingOperations } from "@ledgerhq/errors";
 import BigNumber from "bignumber.js";
 import { getAlpacaApi } from "./alpaca";
+import { transactionToIntent } from "./utils";
 
 // => alpaca validateIntent
 export function genericGetTransactionStatus(
-  network: string,
-  kind: "local" | "remote",
+  network,
+  kind,
 ): AccountBridge<any>["getTransactionStatus"] {
-  return async (account, transaction: TransactionCommon & { fees: BigNumber }) => {
-    const { freshAddress, balance, currency } = account;
+  return async (
+    account,
+    transaction: TransactionCommon & {
+      fees: BigNumber | null | undefined;
+      assetReference?: string;
+      assetOwner?: string;
+      mode?: string;
+      subAccountId?: string;
+      memoType?: string;
+      memoValue?: string;
+    },
+  ) => {
     const alpacaApi = getAlpacaApi(network, kind);
-    const { errors, warnings } = await alpacaApi.validateIntent(
-      {
-        currencyName: currency.name,
-        address: freshAddress,
-        balance: BigInt(balance.toString()),
-        currencyUnit: currency.units[0],
-      },
-      {
-        type: "PAYMENT", // NOTE: assuming payment by default here
-        recipient: transaction.recipient,
-        amount: BigInt(transaction.amount?.toString() ?? "0"),
-        fee: BigInt(transaction.fees?.toString() ?? "0"),
-      },
-    );
+    const draftTransaction = {
+      mode: transaction?.mode,
+      recipient: transaction.recipient,
+      amount: transaction.amount ?? new BigNumber(0),
+      fees: transaction.fees ? BigInt(transaction.fees.toString()) : 0n,
+      useAllAmount: !!transaction.useAllAmount,
+      assetReference: transaction.assetReference || "",
+      assetOwner: transaction.assetOwner || "",
+      subAccountId: transaction.subAccountId || "",
+      memoType: transaction.memoType || "",
+      memoValue: transaction.memoValue || "",
+    };
+
+    if (alpacaApi.getChainSpecificRules) {
+      const chainSpecificValidation = alpacaApi.getChainSpecificRules();
+      if (chainSpecificValidation.getTransactionStatus.throwIfPendingOperation) {
+        if (account.pendingOperations.length > 0) {
+          throw new AccountAwaitingSendPendingOperations();
+        }
+      }
+    }
 
-    const estimatedFees = transaction.fees || new BigNumber(0);
+    const { errors, warnings, estimatedFees, amount, totalSpent } = await alpacaApi.validateIntent(
+      transactionToIntent(account, draftTransaction),
+    );
 
     return Promise.resolve({
       errors,
       warnings,
-      estimatedFees,
-      amount: transaction.amount,
-      totalSpent: transaction.amount.plus(transaction.fees),
+      estimatedFees:
+        !transaction.fees || transaction.fees.isZero()
+          ? new BigNumber(estimatedFees.toString())
+          : transaction.fees,
+      amount: transaction.amount.eq(0) ? new BigNumber(amount.toString()) : transaction.amount,
+      totalSpent: new BigNumber(totalSpent.toString()),
     });
   };
 }

package/src/bridge/generic-alpaca/prepareTransaction.ts

@@ -2,6 +2,7 @@ import { Account, AccountBridge, TransactionCommon } from "@ledgerhq/types-live"
 import { getAlpacaApi } from "./alpaca";
 import { transactionToIntent } from "./utils";
 import BigNumber from "bignumber.js";
+import { NetworkInfo } from "./createTransaction";
 
 function bnEq(a: BigNumber | null | undefined, b: BigNumber | null | undefined): boolean {
   return !a && !b ? true : !a || !b ? false : a.eq(b);
@@ -9,18 +10,51 @@ function bnEq(a: BigNumber | null | undefined, b: BigNumber | null | undefined):
 
 export function genericPrepareTransaction(
   network: string,
-  kind: "local" | "remote",
+  kind,
 ): AccountBridge<TransactionCommon, Account, any, any>["prepareTransaction"] {
-  return async (account, transaction: TransactionCommon & { fees: BigNumber }) => {
+  return async (
+    account,
+    transaction: TransactionCommon & {
+      fees: BigNumber | null | undefined;
+      assetReference?: string;
+      assetOwner?: string;
+      subAccountId?: string;
+      networkInfo?: NetworkInfo | null;
+    },
+  ) => {
+    const [assetReference, assetOwner] = getAssetInfos(transaction);
     const fees = await getAlpacaApi(network, kind).estimateFees(
-      transactionToIntent(account, transaction),
+      transactionToIntent(account, {
+        ...transaction,
+        fees: transaction.fees ? BigInt(transaction.fees.toString()) : 0n,
+      }),
     );
-    const bnFee = BigNumber(fees.value.toString());
-
-    if (!bnEq(transaction.fees, bnFee)) {
-      return { ...transaction, fees: bnFee };
+    // NOTE: this is problematic, we should maybe have a method / object that lists what field warrant an update per chain
+    // for reference, stellar checked this:
+    // transaction.networkInfo !== networkInfo ||
+    // transaction.baseReserve !== baseReserve
+    if (!bnEq(transaction.fees, new BigNumber(fees.value.toString()))) {
+      return {
+        ...transaction,
+        fees: new BigNumber(fees.value.toString()),
+        assetReference,
+        assetOwner,
+        networkInfo: {
+          fees: new BigNumber(fees.value.toString()),
+        },
+      };
     }
 
     return transaction;
   };
 }
+
+export function getAssetInfos(
+  tr: TransactionCommon & { assetReference?: string; assetOwner?: string },
+): string[] {
+  if (tr.subAccountId) {
+    const assetString = tr.subAccountId.split("+")[1];
+    return assetString.split(":");
+  }
+  return [tr.assetReference || "", tr.assetOwner || ""];
+}

package/src/bridge/generic-alpaca/signOperation.ts

@@ -12,12 +12,70 @@ import { buildOptimisticOperation, transactionToIntent } from "./utils";
 import { FeeNotLoaded } from "@ledgerhq/errors";
 import { Result } from "@ledgerhq/coin-framework/derivation";
 import { MapMemo, TransactionIntent } from "@ledgerhq/coin-framework/api/types";
+import { StellarMemo } from "@ledgerhq/coin-stellar/types/bridge";
+import { log } from "@ledgerhq/logs";
+import BigNumber from "bignumber.js";
 
+/**
+ * Applies memo information to transaction intent
+ * Handles both destination tags (XRP-like) and Stellar-style memos
+ */
+function applyMemoToIntent(
+  transactionIntent: TransactionIntent<any>,
+  transaction: TransactionCommon,
+): TransactionIntent<any> {
+  // Handle destination tag memo (for XRP-like chains)
+  if (transaction["tag"]) {
+    const txWithMemoTag = transactionIntent as TransactionIntent<MapMemo<string, string>>;
+    const txMemo = String(transaction["tag"]);
+
+    txWithMemoTag.memo = {
+      type: "map",
+      memos: new Map(),
+    };
+    txWithMemoTag.memo.memos.set("destinationTag", txMemo);
+
+    return txWithMemoTag;
+  }
+
+  // Handle Stellar-style memo
+  if (transaction["memoType"] && transaction["memoValue"]) {
+    const txWithMemo = transactionIntent as TransactionIntent<StellarMemo>;
+    const txMemoType = String(transaction["memoType"]);
+    const txMemoValue = String(transaction["memoValue"]);
+
+    txWithMemo.memo = {
+      type: txMemoType as "NO_MEMO" | "MEMO_TEXT" | "MEMO_ID" | "MEMO_HASH" | "MEMO_RETURN",
+      value: txMemoValue,
+    };
+
+    return txWithMemo;
+  }
+
+  return transactionIntent;
+}
+
+/**
+ * Enriches transaction intent with memo and asset information
+ */
+function enrichTransactionIntent(
+  transactionIntent: TransactionIntent<any>,
+  transaction: TransactionCommon,
+  publicKey: string,
+): TransactionIntent<any> {
+  // Set sender public key
+  transactionIntent.senderPublicKey = publicKey;
+
+  // Apply memo information
+  transactionIntent = applyMemoToIntent(transactionIntent, transaction);
+
+  return transactionIntent;
+}
 /**
  * Sign Transaction with Ledger hardware
  */
 export const genericSignOperation =
-  (network: string, kind: "local" | "remote") =>
+  (network, kind) =>
   (signerContext: SignerContext<any>): AccountBridge<TransactionCommon>["signOperation"] =>
   ({
     account,
@@ -30,30 +88,40 @@ export const genericSignOperation =
   }): Observable<SignOperationEvent> =>
     new Observable(o => {
       async function main() {
+        // NOTE: checking field that's not inside TransactionCommon, improve
         if (!transaction["fees"]) throw new FeeNotLoaded();
-
+        const fees = BigInt(transaction["fees"]?.toString() || "0");
+        if (transaction["useAllAmount"]) {
+          const draftTransaction = {
+            recipient: transaction.recipient,
+            amount: transaction.amount ?? 0,
+            fees: fees,
+            useAllAmount: !!transaction.useAllAmount,
+            assetReference: transaction?.["assetReference"] || "",
+            assetOwner: transaction?.["assetOwner"] || "",
+            subAccountId: transaction.subAccountId || "",
+          };
+          const { amount } = await getAlpacaApi(network, kind).validateIntent(
+            transactionToIntent(account, draftTransaction),
+          );
+          transaction.amount = new BigNumber(amount.toString());
+        }
         const signedInfo = await signerContext(deviceId, async signer => {
           const derivationPath = account.freshAddressPath;
-
           const { publicKey } = (await signer.getAddress(derivationPath)) as Result;
 
-          const transactionIntent = transactionToIntent(account, transaction);
+          let transactionIntent = transactionToIntent(account, { ...transaction, fees });
           transactionIntent.senderPublicKey = publicKey;
-          // NOTE: is setting the memo here instead of transactionToIntent sensible?
-          const txWithMemo = transactionIntent as TransactionIntent<MapMemo<string, string>>;
-          if (transaction["tag"]) {
-            const txMemo = String(transaction["tag"]);
-            txWithMemo.memo = {
-              type: "map",
-              memos: new Map(),
-            };
-            txWithMemo.memo.memos.set("destinationTag", txMemo);
-          }
-
-          const accountInfo = await getAlpacaApi(network, kind).getAccountInfo(
+
+          // Enrich with memo and asset information
+          transactionIntent = enrichTransactionIntent(transactionIntent, transaction, publicKey);
+
+          // TODO: should compute it and pass it down to craftTransaction (duplicate call right now)
+          const sequenceNumber = await getAlpacaApi(network, kind).getSequence(
             transactionIntent.sender,
           );
-          transactionIntent.sequence = accountInfo.sequence;
+          transactionIntent.sequence = sequenceNumber;
+
           /* Craft unsigned blob via Alpaca */
           const unsigned: string = await getAlpacaApi(network, kind).craftTransaction(
             transactionIntent,
@@ -76,8 +144,10 @@ export const genericSignOperation =
           signedInfo.txnSig,
           signedInfo.publicKey,
         );
-
         const operation = buildOptimisticOperation(account, transaction, signedInfo.sequence);
+        if (!operation.id) {
+          log("Generic alpaca", "buildOptimisticOperation", operation);
+        }
         // NOTE: we set the transactionSequenceNumber before on the operation
         // now that we create it in craftTransaction, we might need to return it back from craftTransaction also
         o.next({

package/src/bridge/generic-alpaca/signer/index.ts

@@ -1,12 +1,15 @@
 import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
 import xrpGetAddress from "@ledgerhq/coin-xrp/signer/getAddress";
+import stellarGetAddress from "@ledgerhq/coin-stellar/signer/getAddress";
 import { CreateSigner, executeWithSigner } from "../../setup";
 import Xrp from "@ledgerhq/hw-app-xrp";
+import Stellar from "@ledgerhq/hw-app-str";
 
 import Transport from "@ledgerhq/hw-transport";
-import { signTransaction } from "./signTransaction";
+import { signTransaction, stellarSignTransaction } from "./signTransaction";
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import { SignTransactionOptions } from "./types";
+import { StrKey } from "@stellar/stellar-sdk";
 
 export type AlpacaSigner = {
   getAddress: GetAddressFn;
@@ -15,17 +18,50 @@ export type AlpacaSigner = {
   context: SignerContext<any>;
 };
 
-export function getSigner(network: string): AlpacaSigner {
+const createSignerXrp: CreateSigner<Xrp> = (transport: Transport) => {
+  return new Xrp(transport);
+};
+const signerContextXrp = executeWithSigner(createSignerXrp);
+
+const createSignerStellar: CreateSigner<Stellar> = (transport: Transport) => {
+  const stellar = new Stellar(transport);
+  const originalSignTransaction = stellar.signTransaction;
+  // Return the original Stellar instance with overridden methods
+  return Object.assign(stellar, {
+    signTransaction: async (path: string, transaction: string) => {
+      const unsignedPayload: Buffer = Buffer.from(transaction, "base64");
+      const { signature } = await originalSignTransaction(path, unsignedPayload);
+      return signature.toString("base64");
+    },
+    getAddress: async (path: string, verify?: boolean) => {
+      const { rawPublicKey } = await stellar.getPublicKey(path, verify);
+      const publicKey = StrKey.encodeEd25519PublicKey(rawPublicKey);
+      return {
+        path,
+        address: publicKey,
+        publicKey: publicKey,
+      };
+    },
+  });
+};
+
+const signerContextStellar = executeWithSigner(createSignerStellar);
+
+export function getSigner(network): AlpacaSigner {
   switch (network) {
     case "ripple":
     case "xrp": {
-      const createSigner: CreateSigner<Xrp> = (transport: Transport) => {
-        return new Xrp(transport);
+      return {
+        getAddress: xrpGetAddress(signerContextXrp),
+        signTransaction: signTransaction(signerContextXrp),
+        context: signerContextXrp,
       };
+    }
+    case "stellar": {
       return {
-        getAddress: xrpGetAddress(executeWithSigner(createSigner)),
-        signTransaction: signTransaction(executeWithSigner(createSigner)),
-        context: executeWithSigner(createSigner),
+        getAddress: stellarGetAddress(signerContextStellar),
+        signTransaction: stellarSignTransaction(signerContextStellar),
+        context: signerContextStellar,
       };
     }
   }

package/src/bridge/generic-alpaca/signer/signTransaction.ts

@@ -1,6 +1,7 @@
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
 import { XrpSigner } from "@ledgerhq/coin-xrp/index";
 import { SignTransactionOptions } from "./types";
+import { StellarSigner } from "@ledgerhq/coin-stellar/types/signer";
 
 export const signTransaction = (signerContext: SignerContext<XrpSigner>) => {
   return async (deviceId: string, { path, rawTxHex }: SignTransactionOptions) => {
@@ -11,3 +12,13 @@ export const signTransaction = (signerContext: SignerContext<XrpSigner>) => {
     return signedTx;
   };
 };
+
+export const stellarSignTransaction = (signerContext: SignerContext<StellarSigner>) => {
+  return async (deviceId: string, { path, transaction }: SignTransactionOptions) => {
+    const signedTx = await signerContext(deviceId, signer =>
+      signer.signTransaction(path, transaction),
+    );
+
+    return signedTx.signature.toString("base64"); // It should return a Buffer
+  };
+};

package/src/bridge/generic-alpaca/signer/types.ts

@@ -1,4 +1,5 @@
 export type SignTransactionOptions = {
   rawTxHex: string;
   path: string;
+  transaction: Buffer;
 };