@ledgerhq/live-common 34.39.0-nightly.2 → 34.40.0-nightly.0

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

@@ -0,0 +1,38 @@
+import { AccountBridge, TransactionCommon } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import { getAlpacaApi } from "./alpaca";
+
+// => alpaca validateIntent
+export function genericGetTransactionStatus(
+  network: string,
+  kind: "local" | "remote",
+): 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

@@ -0,0 +1,26 @@
+import { Account, AccountBridge, TransactionCommon } from "@ledgerhq/types-live";
+import { getAlpacaApi } from "./alpaca";
+import { transactionToIntent } from "./utils";
+import BigNumber from "bignumber.js";
+
+function bnEq(a: BigNumber | null | undefined, b: BigNumber | null | undefined): boolean {
+  return !a && !b ? true : !a || !b ? false : a.eq(b);
+}
+
+export function genericPrepareTransaction(
+  network: string,
+  kind: "local" | "remote",
+): 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 (!bnEq(transaction.fees, bnFee)) {
+      return { ...transaction, fees: bnFee };
+    }
+
+    return transaction;
+  };
+}

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

@@ -0,0 +1,98 @@
+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: string, kind: "local" | "remote") =>
+  (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();
+
+        const signedInfo = await signerContext(deviceId, async signer => {
+          const derivationPath = account.freshAddressPath;
+
+          const { publicKey } = (await signer.getAddress(derivationPath)) 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);
+          }
+
+          /* Craft unsigned blob via Alpaca */
+          const unsigned: string = await getAlpacaApi(network, kind).craftTransaction(
+            transactionIntent,
+          );
+
+          // TODO: should compute it and pass it down to craftTransaction (duplicate call right now)
+          const accountInfo = await getAlpacaApi(network, kind).getAccountInfo(
+            transactionIntent.sender,
+          );
+          const sequenceNumber = accountInfo.sequence;
+
+          /* Notify UI that the device is now showing the tx */
+          o.next({ type: "device-signature-requested" });
+          /* Sign on Ledger device */
+          const txnSig = await signer.signTransaction(derivationPath, unsigned);
+          return { unsigned, txnSig, publicKey, sequence: sequenceNumber };
+        });
+
+        /* If the user cancelled inside signerContext */
+        if (!signedInfo) return;
+        o.next({ type: "device-signature-granted" });
+
+        /* Combine payload + signature for broadcast */
+        const combined = await getAlpacaApi(network, kind).combine(
+          signedInfo.unsigned,
+          signedInfo.txnSig,
+          signedInfo.publicKey,
+        );
+
+        const operation = buildOptimisticOperation(account, transaction, signedInfo.sequence);
+        // 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: combined,
+          },
+        });
+      }
+
+      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: string): 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,92 @@
+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).toBe(baseTransaction);
+  });
+
+  it("sets fee if original fees are undefined", async () => {
+    const newFee = new BigNumber(1234);
+    (getAlpacaApi as jest.Mock).mockReturnValue({
+      estimateFees: jest.fn().mockResolvedValue({ value: newFee }),
+    });
+
+    const txWithoutFees = { ...baseTransaction, fees: undefined as any };
+    const prepareTransaction = genericPrepareTransaction(network, kind);
+    const result = await prepareTransaction(account, txWithoutFees);
+
+    expect((result as any).fees.toString()).toBe(newFee.toString());
+    expect(result).not.toBe(txWithoutFees);
+  });
+
+  it("returns original if fees are BigNumber-equal but different instance", async () => {
+    const sameValue = new BigNumber(baseTransaction.fees.toString()); // different instance
+    (getAlpacaApi as jest.Mock).mockReturnValue({
+      estimateFees: jest.fn().mockResolvedValue({ value: sameValue }),
+    });
+
+    const prepareTransaction = genericPrepareTransaction(network, kind);
+    const result = await prepareTransaction(account, baseTransaction);
+
+    expect(result).toBe(baseTransaction); // still same reference
+  });
+});

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

@@ -0,0 +1,97 @@
+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),
+      getAccountInfo: jest.fn().mockResolvedValue(pubKey),
+      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,65 @@
+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,
+  sequenceNumber?: number,
+): 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],
+    transactionSequenceNumber: sequenceNumber ?? 0,
+    accountId: account.id,
+    date: new Date(),
+    extra: {},
+  };
+};

package/src/bridge/impl.ts

@@ -6,6 +6,16 @@ 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 { getAlpacaAccountBridge } from "./generic-alpaca/accountBridge";
+import { getAlpacaCurrencyBridge } from "./generic-alpaca/currencyBridge";
+
+const alpacaized = {
+  xrp: true,
+};
+
+// let accountBridgeInstance: AccountBridge<any> | null = null;
+const bridgeCache: Record<string, AccountBridge<any>> = {};
+let currencyBridgeInstance: CurrencyBridge | null = null;
 
 export const getCurrencyBridge = (currency: CryptoCurrency): CurrencyBridge => {
   if (getEnv("MOCK")) {
@@ -16,6 +26,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 +74,16 @@ export function getAccountBridgeByFamily(family: string, accountId?: string): Ac
     }
   }
 
+  if (alpacaized[family]) {
+    if (!bridgeCache[family]) {
+      bridgeCache[family] = getAlpacaAccountBridge(family, "local");
+    }
+    return bridgeCache[family];
+  }
+
   const jsBridge = jsBridges[family];
   if (!jsBridge) {
-    throw new CurrencyNotSupported("currency bridge not found " + family);
+    throw new CurrencyNotSupported("account bridge not found " + family);
   }
   return jsBridge.accountBridge;
 }

package/src/exchange/providers/swap.integration.test.ts

@@ -247,6 +247,15 @@ describe("fetchAndMergeProviderData", () => {
         ),
         version: 1,
       },
+      velora: {
+        type: "DEX",
+        useInExchangeApp: false,
+        displayName: "Velora",
+        termsOfUseUrl: "https://files.paraswap.io/tos_v4.pdf",
+        supportUrl: "https://help.paraswap.io/en/",
+        mainUrl: "https://www.velora.xyz/",
+        needsKYC: false,
+      },
     });
   });
 });

package/src/exchange/providers/swap.ts

@@ -194,6 +194,14 @@ const DEFAULT_SWAP_PROVIDERS: Record<string, ProviderConfig & Partial<Additional
       "hex",
     ),
   },
+  velora: {
+    type: "DEX",
+    needsKYC: false,
+    needsBearerToken: false,
+    termsOfUseUrl: "https://files.paraswap.io/tos_v4.pdf",
+    supportUrl: "https://help.paraswap.io/en/",
+    mainUrl: "https://www.velora.xyz/",
+  },
 };
 
 export const dexProvidersContractAddress: { [key: string]: string } = {

package/src/families/evm/config.ts

@@ -359,8 +359,8 @@ const evmConfig: CurrencyLiveConfigDefinition = {
         uri: "https://rpcapi.fantom.network",
       },
       explorer: {
-        type: "etherscan",
-        uri: "https://proxyetherscan.api.live.ledger.com/v2/api/250",
+        type: "blockscout",
+        uri: "https://ftmscout.com/api",
       },
       showNfts: false,
     },