@ledgerhq/live-common 34.37.0-nightly.4 → 34.37.0

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

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

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

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

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

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

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