@ledgerhq/live-common 34.36.0 → 34.37.0-next.1

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

@@ -0,0 +1,83 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,13 @@
+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

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

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

@@ -0,0 +1,76 @@
+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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,96 @@
+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

@@ -0,0 +1,63 @@
+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/bridge/impl.ts

@@ -1,11 +1,29 @@
+import { isAddressSanctioned } from "../sanction";
 import { CurrencyNotSupported } from "@ledgerhq/errors";
-import { decodeAccountId, getMainAccount } from "../account";
 import { getEnv } from "@ledgerhq/live-env";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import {
+  Account,
+  AccountBridge,
+  AccountLike,
+  CurrencyBridge,
+  TransactionStatusCommon,
+} from "@ledgerhq/types-live";
+import { decodeAccountId, getMainAccount } from "../account";
 import { checkAccountSupported } from "../account/index";
 import jsBridges from "../generated/bridge/js";
 import mockBridges from "../generated/bridge/mock";
-import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-import { Account, AccountBridge, AccountLike, CurrencyBridge } from "@ledgerhq/types-live";
+import { RecipientAddressSanctionedError, UserAddressSanctionedError } from "../sanction/errors";
+import { getAlpacaCurrencyBridge } from "./generic-alpaca/currencyBridge";
+import { getAlpacaAccountBridge } from "./generic-alpaca/accountBridge";
+import { TransactionCommon } from "@ledgerhq/types-live";
+
+const alpacaized = {
+  xrp: true,
+};
+
+let accountBridgeInstance: AccountBridge<any> | null = null;
+let currencyBridgeInstance: CurrencyBridge | null = null;
 
 export const getCurrencyBridge = (currency: CryptoCurrency): CurrencyBridge => {
   if (getEnv("MOCK")) {
@@ -16,6 +34,13 @@ export const getCurrencyBridge = (currency: CryptoCurrency): CurrencyBridge => {
     });
   }
 
+  if (alpacaized[currency.family]) {
+    if (!currencyBridgeInstance) {
+      currencyBridgeInstance = getAlpacaCurrencyBridge(currency.family, "local");
+    }
+    return currencyBridgeInstance;
+  }
+
   const jsBridge = jsBridges[currency.family];
   if (jsBridge) {
     return jsBridge.currencyBridge;
@@ -57,9 +82,66 @@ export function getAccountBridgeByFamily(family: string, accountId?: string): Ac
     }
   }
 
+  if (alpacaized[family]) {
+    if (!accountBridgeInstance) {
+      accountBridgeInstance = getAlpacaAccountBridge(family, "local");
+    }
+    return accountBridgeInstance;
+  }
+
   const jsBridge = jsBridges[family];
   if (!jsBridge) {
-    throw new CurrencyNotSupported("currency bridge not found " + family);
+    throw new CurrencyNotSupported("account currency bridge not found " + family);
   }
-  return jsBridge.accountBridge;
+  return wrapAccountBridge(jsBridge.accountBridge);
+}
+
+function wrapAccountBridge<T extends TransactionCommon>(
+  bridge: AccountBridge<T>,
+): AccountBridge<T> {
+  return {
+    ...bridge,
+    getTransactionStatus: async (...args) => {
+      const blockchainSpecific = await bridge.getTransactionStatus(...args);
+      const common = await commonGetTransactionStatus(...args);
+      const merged = mergeResults(blockchainSpecific, common);
+      return merged;
+    },
+  };
+}
+
+function mergeResults(
+  blockchainSpecific: TransactionStatusCommon,
+  common: Partial<TransactionStatusCommon>,
+): TransactionStatusCommon {
+  const errors = { ...blockchainSpecific.errors, ...common.errors };
+  const warnings = { ...blockchainSpecific.warnings, ...common.warnings };
+  return { ...blockchainSpecific, errors, warnings };
+}
+
+async function commonGetTransactionStatus(
+  account: Account,
+  transaction: TransactionCommon,
+): Promise<Partial<TransactionStatusCommon>> {
+  const errors: Record<string, Error> = {};
+  const warnings: Record<string, Error> = {};
+
+  let recipientIsBlacklisted = false;
+  if (transaction.recipient && transaction.recipient !== "") {
+    recipientIsBlacklisted = await isAddressSanctioned(account.currency, transaction.recipient);
+    if (recipientIsBlacklisted) {
+      errors.recipient = new RecipientAddressSanctionedError();
+    }
+  }
+
+  const userIsBlacklisted = await isAddressSanctioned(account.currency, account.freshAddress);
+  if (userIsBlacklisted) {
+    errors.amount = new UserAddressSanctionedError();
+  }
+
+  if (userIsBlacklisted || recipientIsBlacklisted) {
+    // Send log
+  }
+
+  return { errors, warnings };
 }

package/src/config/index.ts

@@ -1,11 +1,20 @@
 import { CryptoCurrency, CryptoCurrencyId } from "@ledgerhq/types-cryptoassets";
 import { ConfigInfo, LiveConfig } from "@ledgerhq/live-config/LiveConfig";
-import { CurrencyConfig } from "@ledgerhq/coin-framework/config";
+import { CurrencyConfig, SharedConfig } from "@ledgerhq/coin-framework/config";
 
 export type CurrencyLiveConfigDefinition = Partial<
   Record<`config_currency_${CryptoCurrencyId}`, ConfigInfo>
 >;
 
+const getSharedConfiguration = (): SharedConfig => {
+  const config = LiveConfig.getValueByKey("config_currency");
+  if (!config) {
+    throw new Error("Configuration config_currency not found, please check Firebase Remote Config");
+  }
+
+  return config;
+};
+
 const getCurrencyConfiguration = <T extends CurrencyConfig>(
   currency: CryptoCurrency,
 ): T & Record<string, unknown> => {
@@ -17,4 +26,4 @@ const getCurrencyConfiguration = <T extends CurrencyConfig>(
   return currencyData;
 };
 
-export { getCurrencyConfiguration };
+export { getCurrencyConfiguration, getSharedConfiguration };

package/src/config/sharedConfig.ts

@@ -36,6 +36,13 @@ const countervaluesConfig: ConfigSchema = {
   },
 };
 
+const sharedCurrencyConfig: ConfigSchema = {
+  config_currency: {
+    type: "object",
+    default: {},
+  },
+};
+
 const liveCommonConfig: ConfigSchema = {
   ...appConfig,
 };
@@ -67,4 +74,5 @@ export const liveConfig: ConfigSchema = {
   ...iconConfig,
   ...tonConfig,
   ...suiConfig,
+  ...sharedCurrencyConfig,
 };

package/src/e2e/enum/OperationType.ts

@@ -0,0 +1,4 @@
+export enum OperationType {
+  Buy = "Buy",
+  Sell = "Sell",
+}

package/src/e2e/enum/{Swap.ts → Provider.ts}

@@ -15,6 +15,7 @@ export class Provider {
   static readonly UNISWAP = new Provider("uniswap", "Uniswap", false, false, false);
   static readonly LIFI = new Provider("lifi", "LI.FI", false, true, false);
   static readonly CIC = new Provider("cic", "CIC", false, true, true);
+  static readonly COINBASE = new Provider("coinbase", "Coinbase", false, true, true);
 
   static getNameByUiName(uiName: string): string {
     const provider = Object.values(Provider).find(p => p.uiName === uiName);

package/src/e2e/models/BuySell.ts

@@ -1,4 +1,5 @@
 import { AccountType } from "../enum/Account";
+import { OperationType } from "../enum/OperationType";
 
 export interface Fiat {
   locale: string;
@@ -9,4 +10,5 @@ export interface BuySell {
   crypto: AccountType;
   fiat: Fiat;
   amount: string;
+  operation: OperationType;
 }

package/src/families/casper/bridge.integration.test.ts

@@ -1,5 +1,5 @@
 import "../../__tests__/test-helpers/setup";
 import { testBridge } from "../../__tests__/test-helpers/bridge";
-import { dataset } from "@ledgerhq/coin-casper/test/index";
+import { dataset } from "@ledgerhq/coin-casper/test";
 
 testBridge(dataset);

package/src/families/casper/config.ts

@@ -1,12 +1,16 @@
-import { ConfigInfo } from "@ledgerhq/live-config/LiveConfig";
+import { CurrencyLiveConfigDefinition } from "../../config";
 
-export const casperConfig: Record<string, ConfigInfo> = {
+export const casperConfig: CurrencyLiveConfigDefinition = {
   config_currency_casper: {
     type: "object",
     default: {
       status: {
         type: "active",
       },
+      infra: {
+        API_CASPER_NODE_ENDPOINT: "https://casper.coin.ledger.com/node/",
+        API_CASPER_INDEXER: "https://casper.coin.ledger.com/indexer/",
+      },
     },
   },
 };