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

package/src/apps/config.ts

@@ -68,6 +68,12 @@ const appConfig: Record<string, ConfigInfo> = {
       minVersion: "2.4.5",
     },
   },
+  config_nanoapp_casper: {
+    type: "object",
+    default: {
+      minVersion: "3.0.7",
+    },
+  },
 };
 
 export { appConfig };

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

@@ -0,0 +1,32 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import { makeSync } from "../jsHelpers";
+import { genericGetAccountShape } from "./getAccountShape";
+import {
+  getSerializedAddressParameters,
+  makeAccountBridgeReceive,
+  updateTransaction,
+} from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { getSigner } from "./signer";
+import { genericPrepareTransaction } from "./prepareTransaction";
+import { genericGetTransactionStatus } from "./getTransactionStatus";
+import { genericEstimateMaxSpendable } from "./estimateMaxSpendable";
+import { createTransaction } from "./createTransaction";
+import { genericBroadcast } from "./broadcast";
+import { genericSignOperation } from "./signOperation";
+
+export function getAlpacaAccountBridge(network: string, kind: string): AccountBridge<any> {
+  const signer = getSigner(network);
+  return {
+    sync: makeSync({ getAccountShape: genericGetAccountShape(network, kind) }),
+    receive: makeAccountBridgeReceive(getAddressWrapper(signer.getAddress)),
+    createTransaction: createTransaction,
+    updateTransaction: updateTransaction<any>,
+    prepareTransaction: genericPrepareTransaction(network, kind),
+    getTransactionStatus: genericGetTransactionStatus(network, kind),
+    estimateMaxSpendable: genericEstimateMaxSpendable(network, kind),
+    broadcast: genericBroadcast(network, kind),
+    signOperation: genericSignOperation(network, kind)(signer.context),
+    getSerializedAddressParameters, // NOTE: check wether it should be exposed by coin-module's api instead?
+  } satisfies Partial<AccountBridge<any>> as AccountBridge<any>;
+}

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

@@ -0,0 +1,20 @@
+import { createApi as createXrpApi } from "@ledgerhq/coin-xrp/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";
+
+export function getAlpacaApi(network: string, kind: "local" | "remote"): Api<any, any> {
+  if (kind === "local") {
+    switch (network) {
+      case "ripple":
+      case "xrp":
+        return createXrpApi(
+          getCurrencyConfiguration<XrpCoinConfig>(getCryptoCurrencyById("ripple")),
+        ) as Api<any, 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, any>> as Api<any, any>;
+}

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

@@ -0,0 +1,182 @@
+import type {
+  // Api,
+  Account,
+  Balance,
+  BlockInfo,
+  Operation,
+  FeeEstimation,
+  Pagination,
+  TransactionIntent,
+  Transaction,
+  TransactionValidation,
+  Api,
+} from "@ledgerhq/coin-framework/api/index";
+import network from "@ledgerhq/live-network";
+
+function adaptOp(backendOp: any): Operation<any> {
+  const { date } = backendOp.tx;
+  const newDate = new Date(date);
+
+  return {
+    ...backendOp,
+    value: BigInt(backendOp.value),
+    tx: { ...backendOp.tx, fees: BigInt(backendOp.tx.fees), date: newDate },
+  };
+}
+
+const ALPACA_URL = "https://localhost:3000";
+
+const buildBroadcast = networkFamily =>
+  async function broadcast(signedOperation: string): Promise<string> {
+    const { data } = await network<
+      {
+        transactionIdentifier: string;
+      },
+      {
+        rawTransaction: string;
+      }
+    >({
+      method: "POST",
+      url: `${ALPACA_URL}/${networkFamily}/transaction/broadcast`,
+      data: {
+        rawTransaction: signedOperation,
+      },
+    });
+    return data.transactionIdentifier;
+  };
+
+const buildCombine = networkFamily =>
+  async function combine(tx: string, signature: string, pubKey?: string): Promise<string> {
+    const { data } = await network<
+      {
+        signedTransaction: string;
+      },
+      unknown
+    >({
+      method: "POST",
+      url: `${ALPACA_URL}/${networkFamily}/transaction/combine`,
+      data: {
+        raw_transaction: tx,
+        signature: signature,
+        pubkey: pubKey,
+      },
+    });
+    return data.signedTransaction;
+  };
+
+const buildEstimateFees = networkFamily =>
+  async function estimateFees(intent: TransactionIntent<any>): Promise<FeeEstimation> {
+    const { data } = await network<{ fee: string }, unknown>({
+      method: "POST",
+      url: `${ALPACA_URL}/${networkFamily}/transaction/estimate`,
+      data: {
+        intent: {
+          ...intent,
+          amount: intent.amount.toString(10),
+        },
+      },
+    });
+    return {
+      value: BigInt(data.fee),
+    };
+  };
+
+const buildValidateIntent = networkFamily =>
+  async function validateIntent(
+    account: Account,
+    transaction: Transaction,
+  ): Promise<TransactionValidation> {
+    const { data } = await network<
+      {
+        errors: Record<string, Error>;
+        warnings: Record<string, Error>;
+        estimatedFees: bigint;
+        amount: bigint;
+        totalSpent: bigint;
+      },
+      unknown
+    >({
+      method: "POST",
+      url: `${ALPACA_URL}/${networkFamily}/transaction/validate`,
+      data: {
+        transaction,
+        account,
+      },
+    });
+    return data;
+  };
+
+// FIXME: shouldn't hardcode
+type AssetInfo = {
+  type: "native"; // or "token" if applicable
+};
+
+const buildGetBalance = (networkFamily: string) =>
+  async function getBalance(address: string): Promise<Balance<AssetInfo>[]> {
+    const { data } = await network<Balance<AssetInfo>, unknown>({
+      method: "GET",
+      url: `${ALPACA_URL}/${networkFamily}/account/${address}/balance`,
+    });
+
+    return [
+      {
+        value: BigInt(data.value),
+        asset: data.asset,
+      },
+    ];
+  };
+
+const buildListOperations = networkFamily =>
+  async function listOperations(
+    address: string,
+    pagination: Pagination,
+  ): Promise<[Operation<any>[], string]> {
+    const { data } = await network<{ operations: Operation<any>[] }, unknown>({
+      method: "GET",
+      url: `${ALPACA_URL}/${networkFamily}/account/${address}/operations`,
+      data: {
+        from: pagination.minHeight,
+      },
+    });
+    return [data.operations.map(op => adaptOp(op)), ""];
+  };
+
+const buildLastBlock = networkFamily =>
+  async function lastBlock(): Promise<BlockInfo> {
+    const { data } = await network<any, unknown>({
+      method: "GET",
+      url: `${ALPACA_URL}/${networkFamily}/lastblock`,
+    });
+    return {
+      height: data.height,
+      time: new Date(data.time),
+      hash: data.hash,
+    };
+  };
+
+const buildCraftTransaction = networkFamily =>
+  async function craftTransaction(intent: TransactionIntent<any>): Promise<string> {
+    const { data } = await network<any, unknown>({
+      method: "POST",
+      url: `${ALPACA_URL}/${networkFamily}/transaction/encode`,
+      data: {
+        intent: {
+          ...intent,
+          amount: intent.amount.toString(10),
+        },
+      },
+    });
+    return data.rawTransaction;
+  };
+
+export const getNetworkAlpacaApi = (networkFamily: string) =>
+  ({
+    broadcast: buildBroadcast(networkFamily),
+    combine: buildCombine(networkFamily),
+    validateIntent: buildValidateIntent(networkFamily),
+    estimateFees: buildEstimateFees(networkFamily),
+    getBalance: buildGetBalance(networkFamily),
+    listOperations: buildListOperations(networkFamily),
+    lastBlock: buildLastBlock(networkFamily),
+    craftTransaction: buildCraftTransaction(networkFamily),
+  }) satisfies Api<any>;

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

@@ -0,0 +1,11 @@
+import { AccountBridge, TransactionCommon } from "@ledgerhq/types-live";
+import { patchOperationWithHash } from "../../operation";
+import { getAlpacaApi } from "./alpaca";
+
+export const genericBroadcast: (network, kind) => AccountBridge<TransactionCommon>["broadcast"] =
+  (network, kind) =>
+  async ({ signedOperation: { signature, operation } }) => {
+    const hash = await getAlpacaApi(network, kind).broadcast(signature);
+
+    return patchOperationWithHash(operation, hash);
+  };

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

@@ -0,0 +1,27 @@
+import { Account, TransactionCommon } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import type { Unit } from "@ledgerhq/types-cryptoassets";
+
+export type NetworkInfo = {
+  family: "xrp";
+  serverFee: BigNumber;
+  baseReserve: BigNumber;
+};
+
+export function createTransaction(account: Account): TransactionCommon & {
+  family: string;
+  fee: BigNumber | null | undefined;
+  networkInfo: NetworkInfo | null | undefined;
+  tag: number | null | undefined;
+  feeCustomUnit: Unit | null | undefined;
+} {
+  return {
+    family: account.currency.family,
+    amount: BigNumber(0),
+    recipient: "",
+    fee: null,
+    tag: undefined,
+    networkInfo: null,
+    feeCustomUnit: null,
+  };
+}

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

@@ -0,0 +1,17 @@
+import { makeScanAccounts } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { CurrencyBridge } from "@ledgerhq/types-live";
+import { genericGetAccountShape } from "./getAccountShape";
+import { getSigner } from "./signer";
+
+export function getAlpacaCurrencyBridge(network: string, kind: string): CurrencyBridge {
+  return {
+    preload: () => Promise.resolve({}),
+    hydrate: () => {
+      return;
+    },
+    scanAccounts: makeScanAccounts({
+      getAccountShape: genericGetAccountShape(network, kind),
+      getAddressFn: getSigner(network).getAddress,
+    }),
+  };
+}

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

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

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

@@ -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,
+  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

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

@@ -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");
+  });
+});