@ledgerhq/live-common 34.37.0-nightly.4 → 34.38.0-next.0

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

@@ -1,27 +0,0 @@
-import { AccountBridge } from "@ledgerhq/types-live";
-import { getMainAccount } from "../../account";
-import { getAlpacaApi } from "./alpaca";
-import { createTransaction } from "./createTransaction";
-import { transactionToIntent } from "./utils";
-import BigNumber from "bignumber.js";
-
-export function genericEstimateMaxSpendable(
-  network,
-  kind,
-): AccountBridge<any>["estimateMaxSpendable"] {
-  return async ({ account, parentAccount, transaction }) => {
-    const mainAccount = getMainAccount(account, parentAccount);
-
-    const draftTransaction = {
-      ...createTransaction(account as any),
-      ...transaction,
-      amount: mainAccount.spendableBalance,
-    };
-    const fees = await getAlpacaApi(network, kind).estimateFees(
-      transactionToIntent(mainAccount, draftTransaction),
-    );
-
-    const bnFee = BigNumber(fees.value.toString());
-    return BigNumber.max(0, account.spendableBalance.minus(bnFee));
-  };
-}

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

@@ -1,62 +0,0 @@
-import { encodeAccountId } from "@ledgerhq/coin-framework/account/index";
-import { GetAccountShape, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
-import BigNumber from "bignumber.js";
-import { getAlpacaApi } from "./alpaca";
-import { adaptCoreOperationToLiveOperation } from "./utils";
-
-export function genericGetAccountShape(network, kind): 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 balanceRes = await getAlpacaApi(network, kind).getBalance(address);
-      // FIXME: fix type Balance -> check "native" balance
-      // is balance[0] always the native ?
-      const balance = BigNumber(balanceRes[0].value.toString());
-
-      let spendableBalance: BigNumber;
-      if (balanceRes[0]?.locked) {
-        spendableBalance = BigNumber.max(
-          balance.minus(BigNumber(balanceRes[0].locked.toString())),
-          BigNumber(0),
-        );
-      } else {
-        spendableBalance = initialAccount?.spendableBalance || balance;
-      }
-      const oldOperations = initialAccount?.operations || [];
-
-      const blockHeight = oldOperations.length ? (oldOperations[0].blockHeight ?? 0) + 1 : 0;
-
-      const [newOperations, _] = await getAlpacaApi(network, kind).listOperations(address, {
-        minHeight: blockHeight,
-      });
-
-      const operations = mergeOps(
-        oldOperations,
-        newOperations.map(op => adaptCoreOperationToLiveOperation(accountId, op)),
-      );
-
-      return {
-        id: accountId,
-        xpub: address,
-        blockHeight: initialAccount?.blockHeight || blockInfo.height,
-        balance,
-        spendableBalance,
-        operations,
-        operationsCount: operations.length,
-      };
-    } catch (e) {
-      console.error("Error in getAccountShape", e);
-      throw e;
-    }
-  };
-}

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

@@ -1,38 +0,0 @@
-import { AccountBridge, TransactionCommon } from "@ledgerhq/types-live";
-import BigNumber from "bignumber.js";
-import { getAlpacaApi } from "./alpaca";
-
-// => alpaca validateIntent
-export function genericGetTransactionStatus(
-  network,
-  kind,
-): AccountBridge<any>["getTransactionStatus"] {
-  return async (account, transaction: TransactionCommon & { fees: BigNumber }) => {
-    const { freshAddress, balance, currency } = account;
-    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 estimatedFees = transaction.fees || new BigNumber(0);
-
-    return Promise.resolve({
-      errors,
-      warnings,
-      estimatedFees,
-      amount: transaction.amount,
-      totalSpent: transaction.amount.plus(transaction.fees),
-    });
-  };
-}

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

@@ -1,22 +0,0 @@
-import { Account, AccountBridge, TransactionCommon } from "@ledgerhq/types-live";
-import { getAlpacaApi } from "./alpaca";
-import { transactionToIntent } from "./utils";
-import BigNumber from "bignumber.js";
-
-export function genericPrepareTransaction(
-  network,
-  kind,
-): AccountBridge<TransactionCommon, Account, any, any>["prepareTransaction"] {
-  return async (_account, transaction: TransactionCommon & { fees: BigNumber }) => {
-    const fees = await getAlpacaApi(network, kind).estimateFees(
-      transactionToIntent(_account, transaction),
-    );
-    const bnFee = BigNumber(fees.value.toString());
-
-    if (transaction.fees !== bnFee) {
-      return { ...transaction, fees: bnFee };
-    }
-
-    return transaction;
-  };
-}

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

@@ -1,83 +0,0 @@
-import { Observable } from "rxjs";
-import { SignerContext } from "@ledgerhq/coin-framework/signer";
-import type {
-  Account,
-  DeviceId,
-  SignOperationEvent,
-  AccountBridge,
-  TransactionCommon,
-} from "@ledgerhq/types-live";
-import { getAlpacaApi } from "./alpaca";
-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";
-
-/**
- * Sign Transaction with Ledger hardware
- */
-export const genericSignOperation =
-  (network, kind) =>
-  (signerContext: SignerContext<any>): AccountBridge<TransactionCommon>["signOperation"] =>
-  ({
-    account,
-    transaction,
-    deviceId,
-  }: {
-    account: Account;
-    transaction: TransactionCommon;
-    deviceId: DeviceId;
-  }): Observable<SignOperationEvent> =>
-    new Observable(o => {
-      async function main() {
-        if (!transaction["fees"]) throw new FeeNotLoaded();
-        o.next({ type: "device-signature-requested" });
-
-        const { publicKey } = (await signerContext(deviceId, signer =>
-          signer.getAddress(account.freshAddressPath),
-        )) as Result;
-
-        const transactionIntent = transactionToIntent(account, transaction);
-        transactionIntent.senderPublicKey = publicKey;
-        // NOTE: is setting the memo here instead of transactionToIntent sensible?
-        const txWithMemo = transactionIntent as TransactionIntent<any, 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 unsigned = await getAlpacaApi(network, kind).craftTransaction({
-          ...txWithMemo,
-        });
-        const transactionSignature: string = await signerContext(deviceId, signer =>
-          signer.signTransaction(account.freshAddressPath, unsigned),
-        );
-        o.next({ type: "device-signature-granted" });
-
-        const signed = await getAlpacaApi(network, kind).combine(
-          unsigned,
-          transactionSignature,
-          publicKey,
-        );
-
-        const operation = buildOptimisticOperation(account, transaction);
-        // 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({
-          type: "signed",
-          signedOperation: {
-            operation,
-            signature: signed,
-          },
-        });
-      }
-
-      main().then(
-        () => o.complete(),
-        e => o.error(e),
-      );
-    });

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

@@ -1,33 +0,0 @@
-import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
-import xrpGetAddress from "@ledgerhq/coin-xrp/signer/getAddress";
-import { CreateSigner, executeWithSigner } from "../../setup";
-import Xrp from "@ledgerhq/hw-app-xrp";
-
-import Transport from "@ledgerhq/hw-transport";
-import { signTransaction } from "./signTransaction";
-import { SignerContext } from "@ledgerhq/coin-framework/signer";
-import { SignTransactionOptions } from "./types";
-
-export type AlpacaSigner = {
-  getAddress: GetAddressFn;
-  signTransaction?: (deviceId: string, opts: SignTransactionOptions) => Promise<string>;
-  signMessage?: (message: string) => Promise<string>;
-  context: SignerContext<any>;
-};
-
-export function getSigner(network): AlpacaSigner {
-  switch (network) {
-    case "ripple":
-    case "xrp": {
-      const createSigner: CreateSigner<Xrp> = (transport: Transport) => {
-        return new Xrp(transport);
-      };
-      return {
-        getAddress: xrpGetAddress(executeWithSigner(createSigner)),
-        signTransaction: signTransaction(executeWithSigner(createSigner)),
-        context: executeWithSigner(createSigner),
-      };
-    }
-  }
-  throw new Error(`signer for ${network} not implemented`);
-}

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

@@ -1,13 +0,0 @@
-import { SignerContext } from "@ledgerhq/coin-framework/signer";
-import { XrpSigner } from "@ledgerhq/coin-xrp/index";
-import { SignTransactionOptions } from "./types";
-
-export const signTransaction = (signerContext: SignerContext<XrpSigner>) => {
-  return async (deviceId: string, { path, rawTxHex }: SignTransactionOptions) => {
-    const signedTx = await signerContext(deviceId, signer =>
-      signer.signTransaction(path, rawTxHex),
-    );
-
-    return signedTx;
-  };
-};

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

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

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

@@ -1,76 +0,0 @@
-import BigNumber from "bignumber.js";
-import { genericEstimateMaxSpendable } from "../estimateMaxSpendable";
-import * as alpaca from "../alpaca";
-import { Account } from "@ledgerhq/types-live";
-
-// Mock the alpaca API
-jest.mock("../alpaca", () => ({
-  getAlpacaApi: jest.fn(),
-}));
-
-const mockedGetAlpacaApi = alpaca.getAlpacaApi as jest.Mock;
-
-// Dummy data
-const dummyAccount = {
-  id: "js:2:ripple:r123:",
-  type: "Account", // <-- this is mandatory for getMainAccount to work
-  spendableBalance: new BigNumber(50000000),
-  currency: { id: "ripple", name: "XRP", units: [{ name: "XRP", magnitude: 6 }] },
-  freshAddress: "r123",
-} as unknown as Account;
-
-describe("genericEstimateMaxSpendable", () => {
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it("subtracts estimated fee from spendable balance", async () => {
-    mockedGetAlpacaApi.mockReturnValue({
-      estimateFees: jest.fn().mockResolvedValue({ value: 10000n }), // 0.01 XRP
-    });
-
-    const estimate = genericEstimateMaxSpendable("xrp", "local");
-    const result = await estimate({
-      account: dummyAccount,
-      parentAccount: null,
-      transaction: {},
-    });
-
-    expect(result.toString()).toBe("49990000"); // 50_000_000 - 10_000
-  });
-
-  it("returns 0 if fee is higher than spendable", async () => {
-    const poorAccount = {
-      ...dummyAccount,
-      spendableBalance: new BigNumber(5000), // very low
-    };
-
-    mockedGetAlpacaApi.mockReturnValue({
-      estimateFees: jest.fn().mockResolvedValue({ value: 10000n }),
-    });
-
-    const estimate = genericEstimateMaxSpendable("xrp", "local");
-    const result = await estimate({
-      account: poorAccount,
-      parentAccount: null,
-      transaction: {},
-    });
-
-    expect(result.toString()).toBe("0");
-  });
-
-  it("returns full spendable balance if fee is 0", async () => {
-    mockedGetAlpacaApi.mockReturnValue({
-      estimateFees: jest.fn().mockResolvedValue({ value: 0n }),
-    });
-
-    const estimate = genericEstimateMaxSpendable("xrp", "local");
-    const result = await estimate({
-      account: dummyAccount,
-      parentAccount: null,
-      transaction: {},
-    });
-
-    expect(result.toString()).toBe("50000000");
-  });
-});

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

@@ -1,66 +0,0 @@
-import { genericPrepareTransaction } from "../prepareTransaction";
-import { getAlpacaApi } from "../alpaca";
-import { transactionToIntent } from "../utils";
-import BigNumber from "bignumber.js";
-import type { TransactionCommon } from "@ledgerhq/types-live";
-
-jest.mock("../alpaca", () => ({
-  getAlpacaApi: jest.fn(),
-}));
-
-jest.mock("../utils", () => ({
-  transactionToIntent: jest.fn(),
-}));
-
-describe("genericPrepareTransaction", () => {
-  const network = "testnet";
-  const kind = "local";
-
-  const account = {
-    id: "test-account",
-    address: "0xabc",
-  } as any;
-
-  const baseTransaction: TransactionCommon & { fees: BigNumber } = {
-    amount: new BigNumber(100_000),
-    fees: new BigNumber(500),
-    recipient: "0xrecipient",
-  };
-
-  const txIntent = { mock: "intent" };
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    (transactionToIntent as jest.Mock).mockReturnValue(txIntent);
-  });
-
-  it("updates fees if they differ", async () => {
-    const newFee = new BigNumber(700);
-
-    (getAlpacaApi as jest.Mock).mockReturnValue({
-      estimateFees: jest.fn().mockResolvedValue({ value: newFee }),
-    });
-
-    const prepareTransaction = genericPrepareTransaction(network, kind);
-    const result = await prepareTransaction(account, { ...baseTransaction });
-
-    expect((result as any).fees.toString()).toBe(newFee.toString());
-    expect(transactionToIntent).toHaveBeenCalledWith(
-      account,
-      expect.objectContaining(baseTransaction),
-    );
-  });
-
-  it("returns original transaction if fees are the same", async () => {
-    const sameFee = baseTransaction.fees;
-
-    (getAlpacaApi as jest.Mock).mockReturnValue({
-      estimateFees: jest.fn().mockResolvedValue({ value: sameFee }),
-    });
-
-    const prepareTransaction = genericPrepareTransaction(network, kind);
-    const result = await prepareTransaction(account, { ...baseTransaction });
-
-    expect(result).toStrictEqual(baseTransaction);
-  });
-});

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

@@ -1,96 +0,0 @@
-import { lastValueFrom } from "rxjs";
-import { toArray } from "rxjs/operators";
-import { genericSignOperation } from "../signOperation";
-import { FeeNotLoaded } from "@ledgerhq/errors";
-import { getAlpacaApi } from "../alpaca";
-import { buildOptimisticOperation, transactionToIntent } from "../utils";
-
-jest.mock("../alpaca", () => ({
-  getAlpacaApi: jest.fn(),
-}));
-
-jest.mock("../utils", () => ({
-  buildOptimisticOperation: jest.fn(),
-  transactionToIntent: jest.fn(),
-}));
-
-describe("genericSignOperation", () => {
-  const network = "xrp";
-  const kind = "local";
-
-  const mockSignerContext = jest.fn();
-  const mockSigner = {
-    getAddress: jest.fn(),
-    signTransaction: jest.fn(),
-  };
-
-  const account = {
-    freshAddressPath: "44'/144'/0'/0/0",
-    address: "rTestAddress",
-  } as any;
-
-  const transaction = {
-    amount: 100_000n,
-    fees: 500n,
-    tag: 1234,
-  } as any;
-
-  const deviceId = "mockDevice";
-
-  const txIntent = {
-    memo: {
-      type: "map",
-      memos: new Map(),
-    },
-  };
-
-  const unsignedTx = "unsignedTx";
-  const signedTx = "signedTx";
-  const pubKey = "pubKey";
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-
-    (getAlpacaApi as jest.Mock).mockReturnValue({
-      craftTransaction: jest.fn().mockResolvedValue(unsignedTx),
-      combine: jest.fn().mockResolvedValue(signedTx),
-    });
-
-    (transactionToIntent as jest.Mock).mockReturnValue(txIntent);
-    (buildOptimisticOperation as jest.Mock).mockReturnValue({ id: "mock-op" });
-
-    mockSigner.getAddress.mockResolvedValue({ publicKey: pubKey });
-    mockSigner.signTransaction.mockResolvedValue("sig");
-    mockSignerContext.mockImplementation(async (_deviceId, cb) => cb(mockSigner));
-  });
-
-  it("emits full sign operation flow", async () => {
-    const signOperation = genericSignOperation(network, kind)(mockSignerContext);
-    const observable = signOperation({ account, transaction, deviceId });
-
-    const events = await lastValueFrom(observable.pipe(toArray()));
-
-    expect(events[0]).toEqual({ type: "device-signature-requested" });
-    expect(events[1]).toEqual({ type: "device-signature-granted" });
-    expect(events[2]).toEqual({
-      type: "signed",
-      signedOperation: {
-        operation: { id: "mock-op" },
-        signature: signedTx,
-      },
-    });
-
-    expect(transactionToIntent).toHaveBeenCalledWith(account, transaction);
-    expect(txIntent.memo.memos.get("destinationTag")).toBe("1234");
-  });
-
-  it("throws FeeNotLoaded if fees are missing", async () => {
-    const txWithoutFees = { ...transaction };
-    delete txWithoutFees.fees;
-
-    const signOperation = genericSignOperation(network, kind)(mockSignerContext);
-    const observable = signOperation({ account, transaction: txWithoutFees, deviceId });
-
-    await expect(observable.toPromise()).rejects.toThrow(FeeNotLoaded);
-  });
-});

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

@@ -1,63 +0,0 @@
-import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
-import { Account, Operation, OperationType, TransactionCommon } from "@ledgerhq/types-live";
-import {
-  Operation as CoreOperation,
-  Asset,
-  TransactionIntent,
-} from "@ledgerhq/coin-framework/api/types";
-import BigNumber from "bignumber.js";
-import { fromBigNumberToBigInt } from "@ledgerhq/coin-framework/utils";
-
-export function adaptCoreOperationToLiveOperation(
-  accountId: string,
-  op: CoreOperation<Asset>,
-): Operation {
-  return {
-    id: encodeOperationId(accountId, op.tx.hash, op.type),
-    hash: op.tx.hash,
-    accountId,
-    type: op.type as OperationType,
-    value: new BigNumber(op.value.toString()),
-    fee: new BigNumber(op.tx.fees.toString()),
-    blockHash: op.tx.block.hash,
-    blockHeight: op.tx.block.height,
-    senders: op.senders,
-    recipients: op.recipients,
-    date: op.tx.date,
-    transactionSequenceNumber: op.details?.sequence as number,
-    extra: {},
-  };
-}
-
-export function transactionToIntent(
-  _account: Account,
-  transaction: TransactionCommon,
-): TransactionIntent<any> {
-  return {
-    type: "Payment",
-    sender: _account.freshAddress,
-    recipient: transaction.recipient,
-    amount: fromBigNumberToBigInt(transaction.amount, BigInt(0)),
-    asset: null,
-  };
-}
-
-export const buildOptimisticOperation = (
-  account: Account,
-  transaction: TransactionCommon,
-): Operation => {
-  return {
-    id: encodeOperationId(account.id, "", "OUT"),
-    hash: "",
-    type: "OUT",
-    value: transaction.amount,
-    fee: transaction["fees"] ?? BigNumber(0),
-    blockHash: null,
-    blockHeight: null,
-    senders: [account.freshAddress.toString()],
-    recipients: [transaction.recipient],
-    accountId: account.id,
-    date: new Date(),
-    extra: {},
-  };
-};

package/src/sanction/errors.ts

@@ -1,31 +0,0 @@
-export class UserAddressSanctionedError extends Error {
-  constructor() {
-    super();
-    this.message = this.constructor.name;
-    this.name = this.constructor.name;
-  }
-}
-
-export class UserAddressSanctionedForSendError extends Error {
-  constructor() {
-    super();
-    this.message = this.constructor.name;
-    this.name = this.constructor.name;
-  }
-}
-
-export class UserAddressSanctionedForStakingError extends Error {
-  constructor() {
-    super();
-    this.message = this.constructor.name;
-    this.name = this.constructor.name;
-  }
-}
-
-export class RecipientAddressSanctionedError extends Error {
-  constructor() {
-    super();
-    this.message = this.constructor.name;
-    this.name = this.constructor.name;
-  }
-}

package/src/sanction/index.ts

@@ -1,59 +0,0 @@
-import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
-import axios from "axios";
-import { hours, makeLRUCache } from "@ledgerhq/live-network/cache";
-import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-import { getCurrencyConfiguration, getSharedConfiguration } from "../config";
-import { CurrencyConfig } from "@ledgerhq/coin-framework/config";
-
-const cache = makeLRUCache(fetchSanctionedAddresses, () => "all_sanctioned_addresses", hours(12));
-
-async function fetchSanctionedAddresses(): Promise<Record<string, string[]>> {
-  const { data } = await axios.get(
-    "https://ofac-compliance.pages.dev/all_sanctioned_addresses.json",
-  );
-  return data;
-}
-
-export async function isAddressSanctioned(
-  currency: CryptoCurrency,
-  address: string,
-): Promise<boolean> {
-  if (!isCheckBlacklistAddressEnabled(currency)) {
-    return false;
-  }
-
-  // Only for testing, should be deleted after
-  const temporarySanctionedAddresses: string[] | undefined =
-    LiveConfig.getValueByKey(`tmp_sanctioned_addresses`);
-
-  const data: Record<string, string[]> = await cache();
-  const addresses = data[currency.ticker] || [];
-
-  if (temporarySanctionedAddresses) {
-    return addresses.concat(temporarySanctionedAddresses).includes(address);
-  }
-
-  return addresses.includes(address);
-}
-
-function isCheckBlacklistAddressEnabled(currency: CryptoCurrency): boolean {
-  const currencyConfig = tryGetCurrencyConfig(currency);
-  if (currencyConfig && "checkBlacklistAddress" in currencyConfig) {
-    return currencyConfig.checkBlacklistAddress === true;
-  } else {
-    const sharedConfiguration = getSharedConfiguration();
-    if ("checkBlacklistAddress" in sharedConfiguration) {
-      return sharedConfiguration.checkBlacklistAddress === true;
-    }
-  }
-
-  return false;
-}
-
-function tryGetCurrencyConfig(currency: CryptoCurrency): CurrencyConfig | undefined {
-  try {
-    return getCurrencyConfiguration(currency);
-  } catch (error) {
-    return undefined;
-  }
-}