@ledgerhq/live-common 21.36.2 → 22.0.0

package/src/families/bitcoin/types.ts

@@ -8,12 +8,6 @@ import type {
   TransactionCommon,
   TransactionCommonRaw,
 } from "../../types/transaction";
-import type {
-  CoreBigInt,
-  CoreAmount,
-  CoreDerivationPath,
-  Spec,
-} from "../../libcore/types";
 
 export type BitcoinInput = {
   address: string | null | undefined;
@@ -32,7 +26,6 @@ export type BitcoinOutput = {
   outputIndex: number;
   blockHeight: number | null | undefined;
   address: string | null | undefined;
-  path: string | null | undefined; // DEPRECATED - used only by legacy libcore implementation
   value: BigNumber;
   rbf: boolean;
   isChange: boolean;
@@ -42,7 +35,6 @@ export type BitcoinOutputRaw = [
   number,
   number | null | undefined,
   string | null | undefined,
-  string | null | undefined,
   string,
   number, // rbf 0/1 for compression
   number
@@ -154,220 +146,3 @@ export type TransactionRaw = TransactionCommonRaw & {
   feePerByte: string | null | undefined;
   networkInfo: NetworkInfoRaw | null | undefined;
 };
-
-// vvvvv DEPRECATED - used only by legacy libcore implementation vvvvv
-
-declare class CoreBitcoinLikeInput {
-  getPreviousTransaction(): Promise<string>;
-  getPreviousTxHash(): Promise<string | null | undefined>;
-  getPreviousOutputIndex(): Promise<number>;
-  getValue(): Promise<CoreAmount | null | undefined>;
-  getSequence(): Promise<number>;
-  getDerivationPath(): Promise<CoreDerivationPath[]>;
-  getAddress(): Promise<string | null | undefined>;
-}
-
-declare class CoreBitcoinLikeOutput {
-  getTransactionHash(): Promise<string>;
-  getOutputIndex(): Promise<number>;
-  getValue(): Promise<CoreAmount>;
-  getBlockHeight(): Promise<number | null | undefined>;
-  getDerivationPath(): Promise<CoreDerivationPath | null | undefined>;
-  getAddress(): Promise<string | null | undefined>;
-  isReplaceable(): Promise<boolean>;
-}
-
-declare class CoreBitcoinLikeTransaction {
-  getHash(): Promise<string>;
-  getFees(): Promise<CoreAmount | null | undefined>;
-  getInputs(): Promise<CoreBitcoinLikeInput[]>;
-  getOutputs(): Promise<CoreBitcoinLikeOutput[]>;
-  serializeOutputs(): Promise<string>;
-  getTimestamp(): Promise<number | null | undefined>;
-}
-
-declare class CoreBitcoinLikeOperation {
-  getTransaction(): Promise<CoreBitcoinLikeTransaction>;
-}
-
-declare class CoreBitcoinLikeTransactionBuilder {
-  wipeToAddress(address: string): Promise<void>;
-  sendToAddress(amount: CoreAmount, recipient: string): Promise<void>;
-  excludeUtxo(transactionHash: string, outputIndex: number): Promise<void>;
-  pickInputs(arg0: number, arg1: number): Promise<void>;
-  setFeesPerByte(feesPerByte: CoreAmount): Promise<void>;
-  build(): Promise<CoreBitcoinLikeTransaction>;
-}
-
-declare class CoreBitcoinLikeAccount {
-  getUTXO(from: number, to: number): Promise<CoreBitcoinLikeOutput[]>;
-  getUTXOCount(): Promise<number>;
-  buildTransaction(
-    isPartial: boolean
-  ): Promise<CoreBitcoinLikeTransactionBuilder>;
-  broadcastRawTransaction(signed: string): Promise<string>;
-  getFees(): Promise<CoreBigInt[]>;
-}
-
-declare class CoreBitcoinLikeNetworkParameters {
-  getSigHash(): Promise<string>;
-  getUsesTimestampedTransaction(): Promise<boolean>;
-}
-
-export type CoreStatics = {
-  BitcoinLikeAccount: CoreBitcoinLikeAccount;
-  BitcoinLikeInput: CoreBitcoinLikeInput;
-  BitcoinLikeNetworkParameters: CoreBitcoinLikeNetworkParameters;
-  BitcoinLikeOperation: CoreBitcoinLikeOperation;
-  BitcoinLikeOutput: CoreBitcoinLikeOutput;
-  BitcoinLikeTransaction: CoreBitcoinLikeTransaction;
-  BitcoinLikeTransactionBuilder: CoreBitcoinLikeTransactionBuilder;
-};
-export type {
-  CoreBitcoinLikeAccount,
-  CoreBitcoinLikeInput,
-  CoreBitcoinLikeNetworkParameters,
-  CoreBitcoinLikeOperation,
-  CoreBitcoinLikeOutput,
-  CoreBitcoinLikeTransaction,
-  CoreBitcoinLikeTransactionBuilder,
-};
-export type CoreAccountSpecifics = {
-  asBitcoinLikeAccount(): Promise<CoreBitcoinLikeAccount>;
-};
-export type CoreOperationSpecifics = {
-  asBitcoinLikeOperation(): Promise<CoreBitcoinLikeOperation>;
-};
-export type CoreCurrencySpecifics = {
-  getBitcoinLikeNetworkParameters(): Promise<CoreBitcoinLikeNetworkParameters>;
-};
-
-export const reflect = (
-  declare: (arg0: string, arg1: Spec) => void
-): {
-  OperationMethods: {
-    asBitcoinLikeOperation: {
-      returns: "BitcoinLikeOperation";
-    };
-  };
-  AccountMethods: {
-    asBitcoinLikeAccount: {
-      returns: "BitcoinLikeAccount";
-    };
-  };
-} => {
-  declare("BitcoinLikeInput", {
-    methods: {
-      getPreviousTransaction: {
-        returns: "hex",
-      },
-      getPreviousTxHash: {},
-      getValue: {
-        returns: "Amount",
-      },
-      getPreviousOutputIndex: {},
-      getSequence: {},
-      getDerivationPath: {
-        returns: ["DerivationPath"],
-      },
-      getAddress: {},
-    },
-  });
-  declare("BitcoinLikeOutput", {
-    methods: {
-      getTransactionHash: {},
-      getOutputIndex: {},
-      getValue: {
-        returns: "Amount",
-      },
-      getBlockHeight: {},
-      getDerivationPath: {
-        returns: "DerivationPath",
-      },
-      getAddress: {},
-      isReplaceable: {},
-    },
-  });
-  declare("BitcoinLikeTransaction", {
-    methods: {
-      getHash: {},
-      getFees: {
-        returns: "Amount",
-      },
-      getInputs: {
-        returns: ["BitcoinLikeInput"],
-      },
-      getOutputs: {
-        returns: ["BitcoinLikeOutput"],
-      },
-      serializeOutputs: {
-        returns: "hex",
-      },
-      getTimestamp: {},
-    },
-  });
-  declare("BitcoinLikeOperation", {
-    methods: {
-      getTransaction: {
-        returns: "BitcoinLikeTransaction",
-      },
-    },
-  });
-  declare("BitcoinLikeTransactionBuilder", {
-    methods: {
-      wipeToAddress: {},
-      sendToAddress: {
-        params: ["Amount"],
-      },
-      excludeUtxo: {},
-      pickInputs: {},
-      setFeesPerByte: {
-        params: ["Amount"],
-      },
-      build: {
-        returns: "BitcoinLikeTransaction",
-      },
-    },
-  });
-  declare("BitcoinLikeAccount", {
-    methods: {
-      getUTXO: {
-        returns: ["BitcoinLikeOutput"],
-      },
-      getUTXOCount: {},
-      buildTransaction: {
-        returns: "BitcoinLikeTransactionBuilder",
-      },
-      broadcastRawTransaction: {
-        params: ["hex"],
-      },
-      getFees: {
-        returns: ["BigInt"],
-      },
-    },
-  });
-  declare("BitcoinLikeNetworkParameters", {
-    njsUsesPlainObject: true,
-    methods: {
-      getSigHash: {
-        returns: "hex",
-        njsField: "SigHash",
-      },
-      getUsesTimestampedTransaction: {
-        njsField: "UsesTimestampedTransaction",
-      },
-    },
-  });
-  return {
-    OperationMethods: {
-      asBitcoinLikeOperation: {
-        returns: "BitcoinLikeOperation",
-      },
-    },
-    AccountMethods: {
-      asBitcoinLikeAccount: {
-        returns: "BitcoinLikeAccount",
-      },
-    },
-  };
-};

package/src/families/bitcoin/wallet-btc/explorer/index.ts

@@ -207,28 +207,29 @@ class BitcoinLikeExplorer extends EventEmitter implements IExplorer {
 
     // TODO add a test for failure (at the sync level)
     const client = await this.client.acquire();
-    const res = (
-      await client.client.get(url, {
-        params,
-        // some altcoin may have outputs with values > MAX_SAFE_INTEGER
-        transformResponse: (string) =>
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          JSONBigNumber.parse(string, (key: string, value: any) => {
-            if (BigNumber.isBigNumber(value)) {
-              if (key === "value") {
-                return value.toString();
+    let res: { txs: TX[] } = { txs: [] };
+    try {
+      res = (
+        await client.client.get(url, {
+          params,
+          // some altcoin may have outputs with values > MAX_SAFE_INTEGER
+          transformResponse: (string) =>
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            JSONBigNumber.parse(string, (key: string, value: any) => {
+              if (BigNumber.isBigNumber(value)) {
+                if (key === "value") {
+                  return value.toString();
+                }
+                return value.toNumber();
               }
-
-              return value.toNumber();
-            }
-            return value;
-          }),
-      })
-    ).data as { txs: TX[] };
-    await this.client.release(client);
-
+              return value;
+            }),
+        })
+      ).data;
+    } finally {
+      await this.client.release(client);
+    }
     this.emit("fetched-address-transaction", { url, params, res });
-
     return res;
   }
 
@@ -305,7 +306,6 @@ class BitcoinLikeExplorer extends EventEmitter implements IExplorer {
         params.block_hash = lastTx.block.hash;
       }
     }
-
     const res = await this.fetchTxs(address, params);
 
     const hydratedTxs: TX[] = [];

package/src/families/bitcoin/wallet-btc/utils.ts

@@ -138,7 +138,7 @@ function outputWeight(derivationMode: string): number {
 export function outputSize(currency: ICrypto, addr: string): number {
   const scriptLen = currency.toOutputScript(addr).length;
   let size = 1 + 8 + scriptLen;
-  // More bytes for decred, refer to https://github.com/LedgerHQ/lib-ledger-core/blob/fc9d762b83fc2b269d072b662065747a64ab2816/core/src/wallet/bitcoin/api_impl/BitcoinLikeTransactionApi.cpp#L478
+  // More bytes for decred
   if (currency.network.name === "Decred") {
     size += 8;
   }

package/src/families/celo/types.ts

@@ -12,9 +12,3 @@ export type TransactionRaw = TransactionCommonRaw & {
   family: "celo";
   fees: string | null | undefined;
 };
-
-export type CoreStatics = Record<string, never>;
-export type CoreAccountSpecifics = Record<string, never>;
-export type CoreOperationSpecifics = Record<string, never>;
-export type CoreCurrencySpecifics = Record<string, never>;
-export const reflect = (_declare: any) => {};