@ledgerhq/live-common 34.48.0-nightly.0 → 34.48.0-nightly.10

package/src/exchange/swap/transactionStrategies.ts

@@ -1,16 +1,7 @@
 import { BigNumber } from "bignumber.js";
 
-import {
-  CosmosTransaction,
-  ElrondTransaction,
-  RippleTransaction,
-  SolanaTransaction,
-  StellarTransaction,
-  TonTransaction,
-  Transaction,
-  TransactionCommon,
-} from "@ledgerhq/wallet-api-client";
-
+import { Transaction } from "../../generated/types";
+import { TransactionCommon } from "@ledgerhq/types-live";
 export type { SwapLiveError } from "@ledgerhq/wallet-api-exchange-module";
 
 export function defaultTransaction({
@@ -18,35 +9,81 @@ export function defaultTransaction({
   amount,
   recipient,
   customFeeConfig,
-}: TransactionWithCustomFee): Transaction {
-  return <Transaction>{
+}: TransactionWithCustomFee): Partial<Transaction> {
+  // Type assertion needed because each Transaction family has different required properties
+  // This function provides base properties that are then extended by family-specific functions
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return {
     family,
     amount,
     recipient,
     ...customFeeConfig,
+  } as Partial<Transaction>;
+}
+
+export function cardanoTransaction({
+  amount,
+  recipient,
+  customFeeConfig,
+}: TransactionWithCustomFee): Partial<Extract<Transaction, { family: "cardano" }>> {
+  return {
+    family: "cardano",
+    amount,
+    recipient,
+    mode: "send",
+    ...customFeeConfig,
   };
 }
 
-export function modeSendTransaction({
-  family,
+export function nearTransaction({
   amount,
   recipient,
   customFeeConfig,
-}: TransactionWithCustomFee): Transaction {
+}: TransactionWithCustomFee): Extract<Transaction, { family: "near" }> {
   return {
-    ...defaultTransaction({ family, amount, recipient, customFeeConfig }),
+    family: "near",
+    amount,
+    recipient,
     mode: "send",
+    ...customFeeConfig,
+  };
+}
+
+export function tezosTransaction({
+  amount,
+  recipient,
+  customFeeConfig,
+}: TransactionWithCustomFee): Partial<Extract<Transaction, { family: "tezos" }>> {
+  return {
+    family: "tezos",
+    amount,
+    recipient,
+    mode: "send",
+    ...customFeeConfig,
+  };
+}
+
+export function tronTransaction({
+  amount,
+  recipient,
+  customFeeConfig,
+}: TransactionWithCustomFee): Partial<Extract<Transaction, { family: "tron" }>> {
+  return {
+    family: "tron",
+    amount,
+    recipient,
+    mode: "send",
+    ...customFeeConfig,
   };
 }
 
 export function stellarTransaction({
-  family,
   amount,
   recipient,
   customFeeConfig,
   payinExtraId,
   customErrorType,
-}: TransactionWithCustomFee): StellarTransaction {
+}: TransactionWithCustomFee): Extract<Transaction, { family: "stellar" }> {
   if (!payinExtraId)
     throw {
       error: new Error("Missing payinExtraId"),
@@ -55,8 +92,11 @@ export function stellarTransaction({
     };
 
   return {
-    ...defaultTransaction({ family, amount, recipient, customFeeConfig }),
     family: "stellar",
+    mode: "send",
+    amount,
+    recipient,
+    ...customFeeConfig,
     memoValue: payinExtraId,
     memoType: "MEMO_TEXT",
   };
@@ -68,7 +108,7 @@ export function rippleTransaction({
   customFeeConfig,
   payinExtraId,
   customErrorType,
-}: TransactionWithCustomFee): RippleTransaction {
+}: TransactionWithCustomFee): Partial<Extract<Transaction, { family: "xrp" }>> {
   if (!payinExtraId)
     throw {
       error: new Error("Missing payinExtraId"),
@@ -76,38 +116,40 @@ export function rippleTransaction({
       customErrorType,
     };
 
-  const transaction: RippleTransaction = {
-    family: "ripple",
+  return {
+    family: "xrp",
     amount,
     recipient,
     ...customFeeConfig,
     tag: new BigNumber(payinExtraId).toNumber(),
   };
-  return transaction;
 }
 
-// Function to remove gasLimit from customFeeConfig for Ethereum or Bitcoin
-export function withoutGasLimitTransaction({
-  family,
+export function evmTransaction({
   amount,
   recipient,
   customFeeConfig,
   extraTransactionParameters,
-}: TransactionWithCustomFee): Transaction {
+}: TransactionWithCustomFee): Partial<Extract<Transaction, { family: "evm" }>> {
   if (customFeeConfig?.gasLimit) {
     delete customFeeConfig.gasLimit;
   }
 
   if (extraTransactionParameters) {
-    return <Transaction>{
-      family,
+    return {
+      family: "evm" as const,
       amount,
       recipient,
       ...customFeeConfig,
       data: Buffer.from(extraTransactionParameters, "hex"),
     };
   }
-  return defaultTransaction({ family, amount, recipient, customFeeConfig });
+  return {
+    family: "evm" as const,
+    amount,
+    recipient,
+    ...customFeeConfig,
+  };
 }
 
 export function bitcoinTransaction({
@@ -115,33 +157,33 @@ export function bitcoinTransaction({
   recipient,
   customFeeConfig,
   extraTransactionParameters,
-}: TransactionWithCustomFee): Transaction {
+}: TransactionWithCustomFee): Partial<Extract<Transaction, { family: "bitcoin" }>> {
+  const baseTransaction = {
+    family: "bitcoin" as const,
+    amount,
+    recipient,
+    ...customFeeConfig,
+  };
+
   if (extraTransactionParameters) {
     return {
-      family: "bitcoin",
-      amount,
-      recipient,
-      ...customFeeConfig,
+      ...baseTransaction,
       opReturnData: Buffer.from(extraTransactionParameters, "utf-8"),
     };
   }
-  return {
-    family: "bitcoin",
-    amount,
-    recipient,
-    ...customFeeConfig,
-  };
+
+  return baseTransaction;
 }
 
 export function solanaTransaction({
-  family,
   amount,
   recipient,
-  customFeeConfig,
-}: TransactionWithCustomFee): SolanaTransaction {
+  customFeeConfig: _customFeeConfig,
+}: TransactionWithCustomFee): Extract<Transaction, { family: "solana" }> {
   return {
-    ...defaultTransaction({ family, amount, recipient, customFeeConfig }),
     family: "solana",
+    amount,
+    recipient,
     model: { kind: "transfer", uiState: {} },
   };
 }
@@ -150,43 +192,44 @@ export function elrondTransaction({
   amount,
   recipient,
   customFeeConfig,
-}: TransactionWithCustomFee): ElrondTransaction {
-  const transaction: ElrondTransaction = {
-    family: "elrond",
+}: TransactionWithCustomFee): Extract<Transaction, { family: "multiversx" }> {
+  return {
+    family: "multiversx",
     amount,
     recipient,
     mode: "send",
-    ...customFeeConfig,
-    gasLimit: 0, // FIXME: Placeholder, adjust as needed
+    fees: customFeeConfig.fees || null,
+    gasLimit: customFeeConfig.gasLimit ? Number(customFeeConfig.gasLimit) : 0,
   };
-  return transaction;
 }
 
 function tonTransaction({
-  family,
   amount,
   recipient,
-  customFeeConfig,
-}: TransactionWithCustomFee): TonTransaction {
+  customFeeConfig: _customFeeConfig,
+}: TransactionWithCustomFee): Extract<Transaction, { family: "ton" }> {
   return {
-    ...defaultTransaction({ family, amount, recipient, customFeeConfig }),
     family: "ton",
+    amount,
+    recipient,
     comment: { isEncrypted: false, text: "" },
     fees: new BigNumber(0), // Set default value as completeExchange call prepareTransaction, which set again fees.
   };
 }
 
 export function cosmosTransaction({
-  family,
   amount,
   recipient,
   customFeeConfig,
   payinExtraId,
-}: TransactionWithCustomFee): CosmosTransaction {
-  return <CosmosTransaction>{
-    ...defaultTransaction({ family, amount, recipient, customFeeConfig }),
+}: TransactionWithCustomFee): Partial<Extract<Transaction, { family: "cosmos" }>> {
+  return {
     family: "cosmos",
+    amount,
+    recipient,
     mode: "send",
+    networkInfo: null,
+    ...customFeeConfig,
     memo: payinExtraId ?? undefined,
   };
 }
@@ -198,10 +241,13 @@ export type TransactionWithCustomFee = TransactionCommon & {
   payinExtraId?: string;
   customErrorType?: "swap";
   extraTransactionParameters?: string;
+  family: string;
 };
 
 // Define a specific type for the strategy functions, assuming they might need parameters
-export type TransactionStrategyFunction = (params: TransactionWithCustomFee) => Transaction;
+export type TransactionStrategyFunction = (
+  params: TransactionWithCustomFee,
+) => Partial<Transaction>;
 
 export const transactionStrategy: {
   [K in Transaction["family"]]: TransactionStrategyFunction;
@@ -209,26 +255,28 @@ export const transactionStrategy: {
   algorand: defaultTransaction,
   aptos: defaultTransaction,
   bitcoin: bitcoinTransaction,
-  cardano: modeSendTransaction,
+  canton: defaultTransaction,
+  cardano: cardanoTransaction,
+  casper: defaultTransaction,
   celo: defaultTransaction,
   cosmos: cosmosTransaction,
-  crypto_org: defaultTransaction,
-  elrond: elrondTransaction,
-  ethereum: withoutGasLimitTransaction,
+  evm: evmTransaction,
   filecoin: defaultTransaction,
   hedera: defaultTransaction,
-  near: modeSendTransaction,
-  neo: defaultTransaction,
+  icon: defaultTransaction,
+  internet_computer: defaultTransaction,
+  mina: defaultTransaction,
+  multiversx: elrondTransaction,
+  near: nearTransaction,
   polkadot: defaultTransaction,
-  ripple: rippleTransaction,
   solana: solanaTransaction,
   stacks: defaultTransaction,
   stellar: stellarTransaction,
-  tezos: modeSendTransaction,
+  sui: defaultTransaction,
+  tezos: tezosTransaction,
   ton: tonTransaction,
-  tron: modeSendTransaction,
+  tron: tronTransaction,
   vechain: defaultTransaction,
-  casper: defaultTransaction,
-  sui: defaultTransaction,
-  internet_computer: defaultTransaction,
+  kaspa: defaultTransaction,
+  xrp: rippleTransaction,
 };

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,
+};