@ledgerhq/live-common 34.48.0-nightly.1 → 34.48.0-nightly.3

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

@@ -0,0 +1,70 @@
+import { filter, firstValueFrom } from "rxjs";
+import { EvmAddress, EvmSignature, EvmSigner } from "@ledgerhq/coin-evm/types/signer";
+import { CreateSigner } from "../../setup";
+import { DeviceManagementKit } from "@ledgerhq/device-management-kit";
+import { DmkSignerEth, LegacySignerEth } from "@ledgerhq/live-signer-evm";
+import Transport from "@ledgerhq/hw-transport";
+import { getEnv } from "@ledgerhq/live-env";
+import { ResolutionConfig, LoadConfig } from "@ledgerhq/hw-app-eth/lib/services/types";
+import { Signature } from "ethers";
+
+export type Signer = {
+  getAddress: (path: string) => Promise<EvmAddress>;
+  signTransaction: (path: string, tx: string) => Promise<string>;
+};
+
+const isDmkTransport = (
+  transport: Transport,
+): transport is Transport & { dmk: DeviceManagementKit; sessionId: string } => {
+  return (
+    "dmk" in transport &&
+    transport.dmk !== undefined &&
+    "sessionId" in transport &&
+    transport.sessionId !== undefined
+  );
+};
+
+const createLiveSigner: CreateSigner<EvmSigner> = (transport: Transport) => {
+  if (isDmkTransport(transport)) {
+    return new DmkSignerEth(transport.dmk, transport.sessionId);
+  }
+
+  return new LegacySignerEth(transport);
+};
+
+export const createSigner: CreateSigner<Signer> = (transport: Transport) => {
+  const signer = createLiveSigner(transport);
+
+  return {
+    getAddress: signer.getAddress.bind(signer),
+    signTransaction: async (path, tx) => {
+      // Configure type of resolutions necessary for the clear signing
+      const resolutionConfig: ResolutionConfig = {
+        externalPlugins: true,
+        erc20: true,
+        nft: false,
+        uniswapV3: true,
+      };
+      const loadConfig: LoadConfig = {
+        cryptoassetsBaseURL: getEnv("DYNAMIC_CAL_BASE_URL"),
+        nftExplorerBaseURL: getEnv("NFT_METADATA_SERVICE") + "/v1/ethereum",
+      };
+
+      signer.setLoadConfig(loadConfig);
+
+      const observable = signer.clearSignTransaction(path, tx.substring(2), resolutionConfig, true);
+      const event = observable.pipe(
+        filter((event): event is { type: "signer.evm.signed"; value: EvmSignature } => {
+          return event.type === "signer.evm.signed";
+        }),
+      );
+      const { value } = await firstValueFrom(event);
+
+      return Signature.from({
+        r: "0x" + value.r,
+        s: "0x" + value.s,
+        v: typeof value.v === "number" ? value.v : parseInt(value.v, 16),
+      }).serialized;
+    },
+  };
+};

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

@@ -1,22 +1,12 @@
-import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
 import xrpGetAddress from "@ledgerhq/coin-xrp/signer/getAddress";
 import stellarGetAddress from "@ledgerhq/coin-stellar/signer/getAddress";
-import { CreateSigner, executeWithSigner } from "../../setup";
-import Xrp from "@ledgerhq/hw-app-xrp";
 import Stellar from "@ledgerhq/hw-app-str";
-
-import Transport from "@ledgerhq/hw-transport";
 import { signTransaction, stellarSignTransaction } from "./signTransaction";
-import { SignerContext } from "@ledgerhq/coin-framework/signer";
-import { SignTransactionOptions } from "./types";
 import { StrKey } from "@stellar/stellar-sdk";
-
-export type AlpacaSigner = {
-  getAddress: GetAddressFn;
-  signTransaction?: (deviceId: string, opts: SignTransactionOptions) => Promise<string>;
-  signMessage?: (message: string) => Promise<string>;
-  context: SignerContext<any>;
-};
+import { CreateSigner, executeWithSigner } from "../../setup";
+import Xrp from "@ledgerhq/hw-app-xrp";
+import Transport from "@ledgerhq/hw-transport";
+import { AlpacaSigner } from "./types";
 
 const createSignerXrp: CreateSigner<Xrp> = (transport: Transport) => {
   return new Xrp(transport);
@@ -47,7 +37,7 @@ const createSignerStellar: CreateSigner<Stellar> = (transport: Transport) => {
 
 const signerContextStellar = executeWithSigner(createSignerStellar);
 
-export function getSigner(network): AlpacaSigner {
+export function getSigner(network: string): AlpacaSigner {
   switch (network) {
     case "ripple":
     case "xrp": {

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

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

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

@@ -1,3 +1,17 @@
+import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+
+export type LegacySigner = {
+  signTransaction: (path: string, rawTxHex: string) => Promise<string>;
+};
+
+export type AlpacaSigner<S = unknown> = {
+  getAddress: GetAddressFn;
+  signTransaction?: (deviceId: string, opts: SignTransactionOptions) => Promise<string>;
+  signMessage?: (message: string) => Promise<string>;
+  context: SignerContext<S>;
+};
+
 export type SignTransactionOptions = {
   rawTxHex: string;
   path: string;

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

@@ -1,8 +1,36 @@
-import { adaptCoreOperationToLiveOperation, extractBalance } from "./utils";
+import {
+  adaptCoreOperationToLiveOperation,
+  extractBalance,
+  findCryptoCurrencyByNetwork,
+} from "./utils";
 import BigNumber from "bignumber.js";
 import { Operation as CoreOperation } from "@ledgerhq/coin-framework/api/types";
 
 describe("Alpaca utils", () => {
+  describe("findCryptoCurrencyByNetwork", () => {
+    it("finds a crypto currency by id", () => {
+      expect(findCryptoCurrencyByNetwork("ethereum")).toMatchObject({
+        id: "ethereum",
+        family: "evm",
+      });
+    });
+
+    it("takes currency remapping into account", () => {
+      expect(findCryptoCurrencyByNetwork("ripple")).toMatchObject({
+        id: "ripple",
+        family: "xrp",
+      });
+      expect(findCryptoCurrencyByNetwork("xrp")).toMatchObject({
+        id: "ripple",
+        family: "xrp",
+      });
+    });
+
+    it("does not find non existing currencies", () => {
+      expect(findCryptoCurrencyByNetwork("non_existing_currency")).toBeUndefined();
+    });
+  });
+
   describe("extractBalance", () => {
     it("extracts an existing balance", () => {
       expect(extractBalance([{ value: 4n, asset: { type: "type1" } }], "type1")).toEqual({

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

@@ -7,6 +7,15 @@ import {
   Operation as CoreOperation,
   TransactionIntent,
 } from "@ledgerhq/coin-framework/api/types";
+import { findCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+
+export function findCryptoCurrencyByNetwork(network: string): CryptoCurrency | undefined {
+  const networksRemap = {
+    xrp: "ripple",
+  };
+  return findCryptoCurrencyById(networksRemap[network] ?? network);
+}
 
 export function extractBalance(balances: Balance[], type: string): Balance {
   return (
@@ -110,6 +119,12 @@ export function transactionToIntent(
       case "send":
         transactionType = "send";
         break;
+      case "send-legacy":
+        transactionType = "send-legacy";
+        break;
+      case "send-eip1559":
+        transactionType = "send-eip1559";
+        break;
       default:
         throw new Error(`Unsupported transaction mode: ${transaction.mode}`);
     }

package/src/config/sharedConfig.ts

@@ -11,6 +11,7 @@ import { evmConfig } from "../families/evm/config";
 import { fileCoinConfig } from "../families/filecoin/config";
 import { hederaConfig } from "../families/hedera/config";
 import { internetComputerConfig } from "../families/internet_computer/config";
+import { kaspaConfig } from "../families/kaspa/config";
 import { nearConfig } from "../families/near/config";
 import { minaConfig } from "../families/mina/config";
 import { polkadotConfig } from "../families/polkadot/config";
@@ -24,6 +25,7 @@ import { tronConfig } from "../families/tron/config";
 import { vechainConfig } from "../families/vechain/config";
 import { iconConfig } from "../families/icon/config";
 import { suiConfig } from "../families/sui/config";
+import { cantonConfig } from "../families/canton/config";
 
 const countervaluesConfig: ConfigSchema = {
   config_countervalues_refreshRate: {
@@ -54,6 +56,7 @@ export const liveConfig: ConfigSchema = {
   ...fileCoinConfig,
   ...hederaConfig,
   ...internetComputerConfig,
+  ...kaspaConfig,
   ...nearConfig,
   ...minaConfig,
   ...polkadotConfig,
@@ -67,4 +70,5 @@ export const liveConfig: ConfigSchema = {
   ...iconConfig,
   ...tonConfig,
   ...suiConfig,
+  ...cantonConfig,
 };

package/src/e2e/enum/Account.ts

@@ -276,6 +276,20 @@ export class Account {
     0,
   );
 
+  static readonly KASPA_1 = new Account(
+    Currency.KAS,
+    "KASPA 1",
+    "kaspa:kaspa:qqpqtujclz2usyj7rgmhghfu8e5echrh8t2pkz69tq37uclfrpu3g0w6laqqk",
+    0,
+  );
+
+  static readonly KASPA_2 = new Account(
+    Currency.KAS,
+    "KASPA 2",
+    "kaspa:qrx2agwk93qyjvlcuzz5jy37knt298zupvw2ls05p4te55c29uwuyzzra5qkv",
+    1,
+  );
+
   static readonly LTC_1 = new Account(
     Currency.LTC,
     "Litecoin 1",

package/src/e2e/enum/AppInfos.ts

@@ -60,4 +60,6 @@ export class AppInfos {
   static readonly CELO = new AppInfos("Celo");
 
   static readonly LTC = new AppInfos("Litecoin");
+
+  static readonly KASPA = new AppInfos("Kaspa");
 }

package/src/e2e/enum/Currency.ts

@@ -25,6 +25,8 @@ export class Currency {
 
   static readonly APT = new Currency("Aptos", "APT", "aptos", AppInfos.APTOS, [Network.APTOS]);
 
+  static readonly KAS = new Currency("Kaspa", "KAS", "kaspa", AppInfos.KASPA, [Network.KASPA]);
+
   static readonly tBTC = new Currency(
     "Bitcoin Testnet",
     "𝚝BTC",

package/src/e2e/enum/Network.ts

@@ -30,4 +30,5 @@ export enum Network {
   OSMOSIS = "Osmosis",
   MULTIVERS_X = "MultiversX",
   LITECOIN = "Litecoin",
+  KASPA = "Kaspa",
 }

package/src/e2e/families/kaspa.ts

@@ -0,0 +1,17 @@
+import expect from "expect";
+import { pressBoth, pressUntilTextFound, waitFor, containsSubstringInEvent } from "../speculos";
+import { DeviceLabels } from "../enum/DeviceLabels";
+import { Delegate } from "../models/Delegate";
+
+export async function sendKaspa() {
+  await pressUntilTextFound(DeviceLabels.APPROVE);
+  await pressBoth();
+}
+
+export async function delegateKaspa(delegatingAccount: Delegate) {
+  await waitFor(DeviceLabels.REVIEW_OPERATION);
+  const events = await pressUntilTextFound(DeviceLabels.APPROVE);
+  const isAmountCorrect = containsSubstringInEvent(delegatingAccount.amount, events);
+  expect(isAmountCorrect).toBeTruthy();
+  await pressBoth();
+}

package/src/e2e/speculos.ts

@@ -30,6 +30,7 @@ import { sendXRP } from "./families/xrp";
 import { delegateAptos, sendAptos } from "./families/aptos";
 import { delegateNear } from "./families/near";
 import { delegateCosmos, sendCosmos } from "./families/cosmos";
+import { sendKaspa } from "./families/kaspa";
 import { delegateSolana, sendSolana } from "./families/solana";
 import { delegateTezos } from "./families/tezos";
 import { delegateCelo } from "./families/celo";
@@ -325,6 +326,14 @@ export const specs: Specs = {
     },
     dependency: "",
   },
+  Kaspa: {
+    currency: getCryptoCurrencyById("kaspa"),
+    appQuery: {
+      model: getSpeculosModel(),
+      appName: "Kaspa",
+    },
+    dependency: "",
+  },
 };
 
 export async function startSpeculos(
@@ -677,6 +686,9 @@ export async function signSendTransaction(tx: Transaction) {
     case Currency.APT:
       await sendAptos();
       break;
+    case Currency.KAS:
+      await sendKaspa();
+      break;
     default:
       throw new Error(`Unsupported currency: ${currencyName.ticker}`);
   }

package/src/families/canton/bridge/mock-data.ts

@@ -0,0 +1,175 @@
+type MockTransactionOperation = {
+  meta: {
+    delivered_amount: string;
+  };
+  tx: {
+    Account: string;
+    Amount: string;
+    Destination: string;
+    Fee: string;
+    Memo: string;
+    Sequence: number;
+    SigningPubKey: string;
+    TransactionType: string;
+    TxnSignature: string;
+    date: number;
+    hash: string;
+    inLedger: number;
+  };
+  validated: boolean;
+};
+
+const generateMockTransaction = (
+  account: string,
+  destination: string,
+  amount: string,
+  fee: string,
+  hash: string,
+  sequence: number,
+  timestamp: number,
+  inLedger: number,
+): MockTransactionOperation => ({
+  meta: {
+    delivered_amount: amount,
+  },
+  tx: {
+    Account: account,
+    Amount: amount,
+    Destination: destination,
+    Fee: fee,
+    Memo: "",
+    Sequence: sequence,
+    SigningPubKey: "ED" + account.slice(0, 32),
+    TransactionType: "Payment",
+    TxnSignature: hash.slice(0, 32),
+    date: timestamp,
+    hash,
+    inLedger,
+  },
+  validated: true,
+});
+
+export const getMockedMethods = (): {
+  method: string;
+  params: unknown[];
+  answer: unknown;
+}[] => [
+  // Account balance lookup
+  {
+    method: "getBalance",
+    params: ["rLSn6Z3T5uGRdL5jzKLj2rKqRfQMT5JZRG"],
+    answer: {
+      account_data: {
+        Account: "rLSn6Z3T5uGRdL5jzKLj2rKqRfQMT5JZRG",
+        Balance: "1000000000",
+      },
+      ledger_hash: "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652",
+      ledger_index: 32570,
+      validated: true,
+      status: "success",
+    },
+  },
+
+  // Empty account (new account)
+  {
+    method: "getBalance",
+    params: ["rKj2N4jSSB8QMLq3VnvLcZj4QdKhzSkTZW"],
+    answer: {
+      error: "actNotFound",
+    },
+  },
+
+  // Account transactions
+  {
+    method: "getTransactions",
+    params: ["rLSn6Z3T5uGRdL5jzKLj2rKqRfQMT5JZRG", { from: 0, size: 100 }],
+    answer: [
+      generateMockTransaction(
+        "rLSn6Z3T5uGRdL5jzKLj2rKqRfQMT5JZRG",
+        "rKj2N4jSSB8QMLq3VnvLcZj4QdKhzSkTZW",
+        "100000000",
+        "10000",
+        "E3FE6EA3C48F0C2B639448020EA4F03D4F4F8BDCFDC8882B7B20DBD3A3A5B3A6",
+        1,
+        Date.now() - 3600000, // 1 hour ago
+        32569,
+      ),
+      generateMockTransaction(
+        "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
+        "rLSn6Z3T5uGRdL5jzKLj2rKqRfQMT5JZRG",
+        "200000000",
+        "10000",
+        "B7FDE3B1D3C2F4A9638448020EA4F03D4F4F8BDCFDC8882B7B20DBD3A3A5B3C8",
+        5,
+        Date.now() - 7200000, // 2 hours ago
+        32568,
+      ),
+    ],
+  },
+
+  // Empty transactions for new account
+  {
+    method: "getTransactions",
+    params: ["rKj2N4jSSB8QMLq3VnvLcZj4QdKhzSkTZW", { from: 0, size: 100 }],
+    answer: [],
+  },
+
+  // Fee estimation
+  {
+    method: "estimateFees",
+    params: ["12000400020000000000000000"], // sample serialized transaction
+    answer: "12000",
+  },
+
+  // Transaction submission
+  {
+    method: "submitTransaction",
+    params: ["12000400020000000000000000"], // sample signed transaction
+    answer: {
+      accepted: true,
+      tx_hash: "F4AB442A6D4CBB935D66E1DA7309A5FC71C7143ED4049053EC14E3875B0CF9BF",
+    },
+  },
+
+  // Network info
+  {
+    method: "getServerInfo",
+    params: [],
+    answer: {
+      info: {
+        complete_ledgers: "32570-32570",
+        ledger_index: 32570,
+        validated_ledger: {
+          hash: "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652",
+          seq: 32570,
+        },
+      },
+      status: "success",
+    },
+  },
+
+  // Account sequence number
+  {
+    method: "getNextValidSequence",
+    params: ["rLSn6Z3T5uGRdL5jzKLj2rKqRfQMT5JZRG"],
+    answer: 2,
+  },
+
+  // New account sequence
+  {
+    method: "getNextValidSequence",
+    params: ["rKj2N4jSSB8QMLq3VnvLcZj4QdKhzSkTZW"],
+    answer: 1,
+  },
+
+  // Last block
+  {
+    method: "lastBlock",
+    params: [],
+    answer: {
+      height: 32570,
+      hash: "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652",
+      time: Date.now(),
+    },
+  },
+];

package/src/families/canton/bridge/mock.ts

@@ -0,0 +1,180 @@
+import { makeLRUCache, minutes } from "@ledgerhq/live-network/cache";
+import { createApi } from "@ledgerhq/coin-canton/api/index";
+import { Transaction as CantonTransaction } from "@ledgerhq/coin-canton/types";
+import type { AccountBridge } from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
+
+// The calls data can be copied to mock-data.ts from the file.
+// This function creates a live API with logging for generating mock data
+/* eslint-disable-next-line @typescript-eslint/no-unused-vars */
+function createMockDataForAPI() {
+  const signerContext = {};
+
+  const apiGetter = makeLRUCache(
+    config => Promise.resolve(createApi(config)),
+    config => config.nodeUrl || "",
+    minutes(1000),
+  );
+
+  return {
+    getAPI: apiGetter,
+    getQueuedAPI: apiGetter,
+    getQueuedAndCachedAPI: apiGetter,
+    signerContext,
+  };
+}
+
+const createTransaction = (): CantonTransaction => {
+  return {
+    family: "canton",
+    amount: new BigNumber(0),
+    recipient: "",
+    fee: null,
+  };
+};
+
+const updateTransaction = (
+  t: CantonTransaction,
+  patch: Partial<CantonTransaction>,
+): CantonTransaction => {
+  return { ...t, ...patch };
+};
+
+const getTransactionStatus = async (): Promise<any> => {
+  return {
+    errors: {},
+    warnings: {},
+    estimatedFees: new BigNumber(0),
+    amount: new BigNumber(0),
+    totalSpent: new BigNumber(0),
+  };
+};
+
+const estimateMaxSpendable = ({ account }: { account: any }): Promise<BigNumber> => {
+  return Promise.resolve(account.balance || new BigNumber(0));
+};
+
+const prepareTransaction = async (
+  _account: any,
+  transaction: CantonTransaction,
+): Promise<CantonTransaction> => {
+  return {
+    ...transaction,
+    fee: transaction.fee || new BigNumber(100),
+  };
+};
+
+const sync = (_initialAccount: any): any => {
+  return {
+    subscribe: (observer: any) => {
+      observer.next((acc: any) => acc);
+      observer.complete();
+      return { unsubscribe: () => {} };
+    },
+  };
+};
+
+const receive = (_account: any, _opts: { deviceId: string }): any => {
+  return {
+    subscribe: (observer: any) => {
+      observer.next({
+        address: "mock-address",
+        path: "44'/60'/0'/0/0",
+        publicKey: "mock-public-key",
+      });
+      observer.complete();
+      return { unsubscribe: () => {} };
+    },
+  };
+};
+
+const signOperation = (): any => {
+  return {
+    subscribe: (observer: any) => {
+      observer.next({
+        operation: {
+          id: "mock-operation-id",
+          hash: "mock-hash",
+          type: "OUT",
+          value: new BigNumber(0),
+          fee: new BigNumber(100),
+          blockHash: "mock-block-hash",
+          blockHeight: 12345,
+          accountId: "mock-account-id",
+          date: new Date(),
+          extra: {},
+        },
+        signature: "mock-signature",
+      });
+      observer.complete();
+      return { unsubscribe: () => {} };
+    },
+  };
+};
+
+const broadcast = async (): Promise<any> => {
+  return {
+    id: "mock-operation-id",
+    hash: "mock-hash",
+    type: "OUT",
+    value: new BigNumber(0),
+    fee: new BigNumber(100),
+    blockHash: "mock-block-hash",
+    blockHeight: 12345,
+    accountId: "mock-account-id",
+    date: new Date(),
+    extra: {},
+  };
+};
+
+const scanAccounts = (): any => {
+  return {
+    subscribe: (observer: any) => {
+      observer.next({
+        type: "discovered",
+        account: {
+          id: "mock-account-id",
+          name: "Mock Canton Account",
+          address: "mock-address",
+          currency: { id: "canton_network_devnet" },
+          balance: new BigNumber(0),
+          spendableBalance: new BigNumber(0),
+          blockHeight: 0,
+          lastSyncDate: new Date(),
+          operations: [],
+          pendingOperations: [],
+        },
+      });
+      observer.complete();
+      return { unsubscribe: () => {} };
+    },
+  };
+};
+
+const getSerializedAddressParameters = (): Buffer => {
+  return Buffer.from("mock-address-params");
+};
+
+const accountBridge: AccountBridge<CantonTransaction> = {
+  createTransaction,
+  updateTransaction,
+  getTransactionStatus,
+  estimateMaxSpendable,
+  prepareTransaction,
+  sync,
+  receive,
+  signOperation,
+  broadcast,
+  getSerializedAddressParameters,
+};
+
+const currencyBridge = {
+  preload: () => Promise.resolve({}),
+  hydrate: () => {},
+  scanAccounts,
+};
+
+export default {
+  accountBridge,
+  currencyBridge,
+};