@ledgerhq/live-common 34.45.0-nightly.2 → 34.45.0

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

@@ -1,24 +1,19 @@
 import { createApi as createXrpApi } from "@ledgerhq/coin-xrp/api/index";
-import { createApi as createStellarApi } from "@ledgerhq/coin-stellar/api/index";
 import { getCurrencyConfiguration } from "../../../config";
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
 import { getNetworkAlpacaApi } from "./network/network-alpaca";
 import { Api } from "@ledgerhq/coin-framework/api/types";
 import { XrpCoinConfig } from "@ledgerhq/coin-xrp/config";
-import { StellarCoinConfig } from "@ledgerhq/coin-stellar/config";
 
-export function getAlpacaApi(network, kind): Api<any> {
+export function getAlpacaApi(network: string, kind: "local" | "remote"): Api<any> {
   if (kind === "local") {
     switch (network) {
       case "ripple":
       case "xrp":
         return createXrpApi(
           getCurrencyConfiguration<XrpCoinConfig>(getCryptoCurrencyById("ripple")),
-        ) as Api<any>; // FIXME: createXrpApi returns a strongly typed Api<XrpSender>, fix Api<any> to allow it
-      case "stellar":
-        return createStellarApi(
-          getCurrencyConfiguration<StellarCoinConfig>(getCryptoCurrencyById("stellar")),
         ) as Api<any>;
+      // as unknown as Api<any>; // FIXME: createXrpApi returns a strongly typed Api<XrpSender>, fix Api<any> to allow it
     }
   }
   return getNetworkAlpacaApi(network) satisfies Partial<Api<any>> as Api<any>;

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

@@ -1,4 +1,5 @@
-import type {
+import {
+  Account,
   Balance,
   Block,
   BlockInfo,
@@ -6,9 +7,10 @@ import type {
   FeeEstimation,
   Pagination,
   TransactionIntent,
+  Transaction,
   TransactionValidation,
+  AccountInfo,
   Api,
-  AssetInfo,
   Cursor,
   Page,
   Stake,
@@ -16,7 +18,7 @@ import type {
 } from "@ledgerhq/coin-framework/api/index";
 import network from "@ledgerhq/live-network";
 
-function adaptOp<T extends AssetInfo>(backendOp: Operation<T>): Operation<T> {
+function adaptOp(backendOp: any): Operation<any> {
   const { date } = backendOp.tx;
   const newDate = new Date(date);
 
@@ -29,7 +31,7 @@ function adaptOp<T extends AssetInfo>(backendOp: Operation<T>): Operation<T> {
 
 const ALPACA_URL = "http://0.0.0.0:3000";
 
-const buildBroadcast = networkFamily =>
+const buildBroadcast = (networkFamily: string) =>
   async function broadcast(signedOperation: string): Promise<string> {
     const { data } = await network<
       {
@@ -48,7 +50,7 @@ const buildBroadcast = networkFamily =>
     return data.transactionIdentifier;
   };
 
-const buildCombine = networkFamily =>
+const buildCombine = (networkFamily: string) =>
   async function combine(tx: string, signature: string, pubKey?: string): Promise<string> {
     const { data } = await network<
       {
@@ -67,7 +69,7 @@ const buildCombine = networkFamily =>
     return data.signedTransaction;
   };
 
-const buildEstimateFees = networkFamily =>
+const buildEstimateFees = (networkFamily: string) =>
   async function estimateFees(intent: TransactionIntent<any>): Promise<FeeEstimation> {
     const { data } = await network<{ fee: string }, unknown>({
       method: "POST",
@@ -84,8 +86,11 @@ const buildEstimateFees = networkFamily =>
     };
   };
 
-const buildValidateIntent = networkFamily =>
-  async function validateIntent(transaction: TransactionIntent): Promise<TransactionValidation> {
+const buildValidateIntent = (networkFamily: string) =>
+  async function validateIntent(
+    account: Account,
+    transaction: Transaction,
+  ): Promise<TransactionValidation> {
     const { data } = await network<
       {
         errors: Record<string, Error>;
@@ -100,6 +105,7 @@ const buildValidateIntent = networkFamily =>
       url: `${ALPACA_URL}/${networkFamily}/transaction/validate`,
       data: {
         transaction,
+        account,
       },
     });
     return data;
@@ -116,14 +122,13 @@ const buildGetBalance = (networkFamily: string) =>
       {
         value: BigInt(data.value),
         asset: data.asset,
-        locked: BigInt(data?.locked ?? "0"),
       },
     ];
   };
 
-const buildGetSequence = (networkFamily: string) =>
-  async function getSequence(address: string): Promise<number> {
-    const { data } = await network<number, unknown>({
+const buildGetAccountInfo = (networkFamily: string) =>
+  async function getBalance(address: string): Promise<AccountInfo> {
+    const { data } = await network<AccountInfo, unknown>({
       method: "GET",
       url: `${ALPACA_URL}/${networkFamily}/account/${address}/info`,
     });
@@ -131,10 +136,10 @@ const buildGetSequence = (networkFamily: string) =>
     return data;
   };
 
-const buildListOperations = networkFamily =>
+const buildListOperations = (networkFamily: string) =>
   async function listOperations(
     address: string,
-    pagination: Pagination = { minHeight: 0 },
+    pagination: Pagination,
   ): Promise<[Operation<any>[], string]> {
     const { data } = await network<{ operations: Operation<any>[] }, unknown>({
       method: "GET",
@@ -146,7 +151,7 @@ const buildListOperations = networkFamily =>
     return [data.operations.map(op => adaptOp(op)), ""];
   };
 
-const buildLastBlock = networkFamily =>
+const buildLastBlock = (networkFamily: string) =>
   async function lastBlock(): Promise<BlockInfo> {
     const { data } = await network<any, unknown>({
       method: "GET",
@@ -159,7 +164,7 @@ const buildLastBlock = networkFamily =>
     };
   };
 
-const buildCraftTransaction = networkFamily =>
+const buildCraftTransaction = (networkFamily: string) =>
   async function craftTransaction(intent: TransactionIntent<any>): Promise<string> {
     const { data } = await network<any, unknown>({
       method: "POST",
@@ -181,7 +186,7 @@ export const getNetworkAlpacaApi = (networkFamily: string) =>
     validateIntent: buildValidateIntent(networkFamily),
     estimateFees: buildEstimateFees(networkFamily),
     getBalance: buildGetBalance(networkFamily),
-    getSequence: buildGetSequence(networkFamily),
+    getAccountInfo: buildGetAccountInfo(networkFamily),
     listOperations: buildListOperations(networkFamily),
     lastBlock: buildLastBlock(networkFamily),
     craftTransaction: buildCraftTransaction(networkFamily),

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

@@ -2,7 +2,10 @@ import { AccountBridge, TransactionCommon } from "@ledgerhq/types-live";
 import { patchOperationWithHash } from "../../operation";
 import { getAlpacaApi } from "./alpaca";
 
-export const genericBroadcast: (network, kind) => AccountBridge<TransactionCommon>["broadcast"] =
+export const genericBroadcast: (
+  network: string,
+  kind: "local" | "remote",
+) => AccountBridge<TransactionCommon>["broadcast"] =
   (network, kind) =>
   async ({ signedOperation: { signature, operation } }) => {
     const hash = await getAlpacaApi(network, kind).broadcast(signature);

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

@@ -1,57 +1,27 @@
-import { Account, TokenAccount, TransactionCommon } from "@ledgerhq/types-live";
+import { Account, TransactionCommon } from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
 import type { Unit } from "@ledgerhq/types-cryptoassets";
 
-export enum NetworkCongestionLevel {
-  LOW = "LOW",
-  MEDIUM = "MEDIUM",
-  HIGH = "HIGH",
-}
-
 export type NetworkInfo = {
-  fees: BigNumber;
+  family: "xrp";
+  serverFee: BigNumber;
+  baseReserve: BigNumber;
 };
 
-export function createTransaction(account: Account | TokenAccount): TransactionCommon & {
+export function createTransaction(account: Account): TransactionCommon & {
   family: string;
-  fees?: BigNumber | null;
-  tag?: number | null | undefined;
-  feeCustomUnit?: Unit | null | undefined;
-  memoType?: string | null;
-  memoValue?: string | null;
-  mode?: "send" | "changeTrust";
-  assetReference?: string;
-  assetOwner?: string;
-  networkInfo?: NetworkInfo | null;
+  fee: BigNumber | null | undefined;
+  networkInfo: NetworkInfo | null | undefined;
+  tag: number | null | undefined;
+  feeCustomUnit: Unit | null | undefined;
 } {
-  const currency =
-    account.type === "TokenAccount" ? account.token.parentCurrency : account.currency;
-  switch (currency.family) {
-    case "xrp":
-    case "ripple":
-      return {
-        family: currency.family,
-        amount: BigNumber(0),
-        recipient: "",
-        fees: null,
-        tag: undefined,
-        feeCustomUnit: null, // NOTE: XRP does not use custom units for fees anymore
-      };
-    case "stellar":
-      return {
-        family: currency.family,
-        amount: new BigNumber(0),
-        fees: null,
-        recipient: "",
-        memoValue: null,
-        memoType: null,
-        useAllAmount: false,
-        mode: "send",
-        assetReference: "",
-        assetOwner: "",
-        networkInfo: null,
-      };
-    default:
-      throw new Error(`Unsupported currency family: ${currency.family}`);
-  }
+  return {
+    family: account.currency.family,
+    amount: BigNumber(0),
+    recipient: "",
+    fee: null,
+    tag: undefined,
+    networkInfo: null,
+    feeCustomUnit: null,
+  };
 }

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

@@ -3,7 +3,7 @@ import { CurrencyBridge } from "@ledgerhq/types-live";
 import { genericGetAccountShape } from "./getAccountShape";
 import { getSigner } from "./signer";
 
-export function getAlpacaCurrencyBridge(network: string, kind: string): CurrencyBridge {
+export function getAlpacaCurrencyBridge(network: string, kind: "local" | "remote"): CurrencyBridge {
   return {
     preload: () => Promise.resolve({}),
     hydrate: () => {

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

@@ -6,30 +6,21 @@ import { transactionToIntent } from "./utils";
 import BigNumber from "bignumber.js";
 
 export function genericEstimateMaxSpendable(
-  network,
-  kind,
+  network: string,
+  kind: "local" | "remote",
 ): AccountBridge<any>["estimateMaxSpendable"] {
   return async ({ account, parentAccount, transaction }) => {
-    if (account.type === "TokenAccount") {
-      return account.spendableBalance;
-    }
     const mainAccount = getMainAccount(account, parentAccount);
+
     const draftTransaction = {
       ...createTransaction(account as any),
       ...transaction,
       amount: mainAccount.spendableBalance,
-      useAllAmount: true,
-      fees: transaction?.fees ? BigInt(transaction.fees.toString()) : 0n,
     };
     const fees = await getAlpacaApi(network, kind).estimateFees(
       transactionToIntent(mainAccount, draftTransaction),
     );
-    const { amount } = await getAlpacaApi(network, kind).validateIntent(
-      transactionToIntent(account, { ...draftTransaction }),
-    );
-    if (network === "stellar") {
-      return amount > 0 ? new BigNumber(amount.toString()) : new BigNumber(0);
-    }
+
     const bnFee = BigNumber(fees.value.toString());
     return BigNumber.max(0, account.spendableBalance.minus(bnFee));
   };

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

@@ -3,97 +3,59 @@ 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: 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);
+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;
       }
-    }
-
-    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 oldOperations = initialAccount?.operations || [];
 
-    const oldOps = (initialAccount?.operations || []) as OperationCommon[];
-    const lastPagingToken = oldOps[0]?.extra?.pagingToken || "";
+      const blockHeight = oldOperations.length ? (oldOperations[0].blockHeight ?? 0) + 1 : 0;
 
-    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 [newOperations] = await getAlpacaApi(network, kind).listOperations(address, {
+        minHeight: blockHeight,
+      });
 
-    const subAccounts =
-      buildSubAccounts({
-        currency,
-        accountId,
-        assetsBalance,
-        syncConfig,
-        operations: assetOperations,
-      }) || [];
-
-    const operationsWithSubs = mergedOps.map(op => {
-      const subOperations = inferSubOperations(op.hash, subAccounts);
+      const operations = mergeOps(
+        oldOperations,
+        newOperations.map(op => adaptCoreOperationToLiveOperation(accountId, op)),
+      );
 
       return {
-        ...op,
-        subOperations,
+        id: accountId,
+        xpub: address,
+        blockHeight: operations.length === 0 ? 0 : blockInfo.height || initialAccount?.blockHeight,
+        balance,
+        spendableBalance,
+        operations,
+        operationsCount: operations.length,
       };
-    });
-
-    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;
+    } catch (e) {
+      console.error("Error in getAccountShape", e);
+      throw e;
+    }
   };
 }

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

@@ -1,62 +1,38 @@
 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,
-  kind,
+  network: string,
+  kind: "local" | "remote",
 ): AccountBridge<any>["getTransactionStatus"] {
-  return async (
-    account,
-    transaction: TransactionCommon & {
-      fees: BigNumber | null | undefined;
-      assetReference?: string;
-      assetOwner?: string;
-      mode?: string;
-      subAccountId?: string;
-      memoType?: string;
-      memoValue?: string;
-    },
-  ) => {
+  return async (account, transaction: TransactionCommon & { fees: BigNumber }) => {
+    const { freshAddress, balance, currency } = account;
     const alpacaApi = getAlpacaApi(network, kind);
-    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 { errors, warnings, estimatedFees, amount, totalSpent } = await alpacaApi.validateIntent(
-      transactionToIntent(account, draftTransaction),
+    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 estimatedFees = transaction.fees || new BigNumber(0);
+
     return Promise.resolve({
       errors,
       warnings,
-      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()),
+      estimatedFees,
+      amount: transaction.amount,
+      totalSpent: transaction.amount.plus(transaction.fees),
     });
   };
 }

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

@@ -2,7 +2,6 @@ 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);
@@ -10,51 +9,18 @@ function bnEq(a: BigNumber | null | undefined, b: BigNumber | null | undefined):
 
 export function genericPrepareTransaction(
   network: string,
-  kind,
+  kind: "local" | "remote",
 ): AccountBridge<TransactionCommon, Account, any, any>["prepareTransaction"] {
-  return async (
-    account,
-    transaction: TransactionCommon & {
-      fees: BigNumber | null | undefined;
-      assetReference?: string;
-      assetOwner?: string;
-      subAccountId?: string;
-      networkInfo?: NetworkInfo | null;
-    },
-  ) => {
-    const [assetReference, assetOwner] = getAssetInfos(transaction);
+  return async (account, transaction: TransactionCommon & { fees: BigNumber }) => {
     const fees = await getAlpacaApi(network, kind).estimateFees(
-      transactionToIntent(account, {
-        ...transaction,
-        fees: transaction.fees ? BigInt(transaction.fees.toString()) : 0n,
-      }),
+      transactionToIntent(account, transaction),
     );
-    // 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()),
-        },
-      };
+    const bnFee = BigNumber(fees.value.toString());
+
+    if (!bnEq(transaction.fees, bnFee)) {
+      return { ...transaction, fees: bnFee };
     }
 
     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 || ""];
-}