@ledgerhq/coin-bitcoin 0.29.0-nightly.20260115024415 → 0.29.0-nightly.20260116124336

package/src/buildOptimisticOperation.ts

@@ -0,0 +1,34 @@
+import { BigNumber } from "bignumber.js";
+import type { Operation } from "@ledgerhq/types-live";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+
+type BuildOptimisticOperationParams = {
+  accountId: string;
+  fee: BigNumber;
+  value?: BigNumber;
+  senders?: string[];
+  recipients?: string[];
+  extra?: Record<string, unknown>;
+};
+
+export const buildOptimisticOperation = ({
+  accountId,
+  fee,
+  value,
+  senders = [],
+  recipients = [],
+  extra = {},
+}: BuildOptimisticOperationParams): Operation => ({
+  id: encodeOperationId(accountId, "", "OUT"),
+  hash: "",
+  type: "OUT",
+  value: value ?? fee,
+  fee,
+  blockHash: null,
+  blockHeight: null,
+  senders,
+  recipients,
+  accountId,
+  date: new Date(),
+  extra,
+});

package/src/explorer.ts

@@ -9,14 +9,6 @@ type LedgerExplorer = {
 };
 
 const findCurrencyExplorer = (currency: CryptoCurrency): LedgerExplorer | null | undefined => {
-  if (getEnv("SATSTACK") && currency.id === "bitcoin") {
-    return {
-      endpoint: getEnv("EXPLORER_SATSTACK"),
-      id: "btc",
-      version: "v3",
-    };
-  }
-
   if (!currency.explorerId) {
     console.warn("no explorerId for", currency.id);
   }

package/src/hw-signMessage.test.ts

@@ -15,6 +15,7 @@ describe("signMessage", () => {
       }),
       splitTransaction: jest.fn(),
       createPaymentTransaction: jest.fn(),
+      signPsbtBuffer: jest.fn(),
     };
     const signerContext = <T>(
       _deviceId: string,

package/src/observable.ts

@@ -0,0 +1,12 @@
+import { Observable } from "rxjs";
+import type { Observer } from "rxjs";
+
+export const fromAsyncOperation = <T>(
+  main: (observer: Observer<T>) => Promise<void>,
+): Observable<T> =>
+  new Observable<T>(observer => {
+    main(observer).then(
+      () => observer.complete(),
+      error => observer.error(error),
+    );
+  });

package/src/observable.unit.test.ts

@@ -0,0 +1,27 @@
+import { firstValueFrom, toArray } from "rxjs";
+import { fromAsyncOperation } from "./observable";
+
+describe("fromAsyncOperation", () => {
+  test("emits values and completes when the async function resolves", async () => {
+    const values = await firstValueFrom(
+      fromAsyncOperation<number>(async observer => {
+        observer.next(1);
+        observer.next(2);
+      }).pipe(toArray()),
+    );
+
+    expect(values).toEqual([1, 2]);
+  });
+
+  test("propagates errors when the async function rejects", async () => {
+    const error = new Error("boom");
+
+    await expect(
+      firstValueFrom(
+        fromAsyncOperation(async () => {
+          throw error;
+        }),
+      ),
+    ).rejects.toThrow("boom");
+  });
+});

package/src/psbtFees.ts

@@ -0,0 +1,77 @@
+import { BigNumber } from "bignumber.js";
+import { Transaction } from "bitcoinjs-lib";
+import { PsbtV2 } from "@ledgerhq/psbtv2";
+
+/** read uint64 little-endian into JS number (safe for BTC amounts) */
+function readUInt64LE(buf: Buffer): bigint {
+  const lo = buf.readUInt32LE(0);
+  const hi = buf.readUInt32LE(4);
+  const loBig = BigInt(lo);
+  const hiBig = BigInt(hi);
+  const value = loBig + (hiBig << 32n);
+
+  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error("readUInt64LE: value exceeds Number.MAX_SAFE_INTEGER");
+  }
+
+  return value;
+}
+
+/**
+ * Compute fee from a PSBT (v2 preferred).
+ * Returns:
+ *  - BigNumber(fee) on success
+ *  - null if cannot parse (caller should fallback to calculateFees()).
+ */
+export function feeFromPsbt(buf: Buffer): BigNumber | null {
+  if (!buf || buf.length < 5) return null;
+
+  try {
+    // Check PSBT version and use appropriate deserialization method
+    const psbtVersion = PsbtV2.getPsbtVersionNumber(buf);
+    const psbt = psbtVersion === 2 ? new PsbtV2() : PsbtV2.fromV0(buf, true);
+
+    if (psbtVersion === 2) {
+      psbt.deserialize(buf);
+    }
+
+    // Sum inputs (prefer WITNESS_UTXO; fall back to NON_WITNESS_UTXO)
+    let inSum = 0n;
+    const nIn: number = psbt.getGlobalInputCount();
+    for (let i = 0; i < nIn; i++) {
+      const w = psbt.getInputWitnessUtxo(i);
+      if (w) {
+        inSum += readUInt64LE(w.amount);
+        continue;
+      }
+      const nonWitness = psbt.getInputNonWitnessUtxo(i);
+      if (!nonWitness) {
+        return null;
+      }
+
+      // NON_WITNESS_UTXO is the full previous transaction. Use the PSBT
+      // input's referenced output index to locate the amount.
+      const prevTx = Transaction.fromBuffer(nonWitness);
+      const prevOutIndex = psbt.getInputOutputIndex(i);
+
+      const prevOut = prevTx.outs[prevOutIndex];
+      if (!prevOut) {
+        return null;
+      }
+
+      inSum += BigInt(prevOut.value);
+    }
+
+    // Sum outputs
+    let outSum = 0n;
+    const nOut: number = psbt.getGlobalOutputCount();
+    for (let i = 0; i < nOut; i++) {
+      outSum += BigInt(psbt.getOutputAmount(i)); // number
+    }
+
+    if (inSum < outSum) return null;
+    return new BigNumber((inSum - outSum).toString());
+  } catch {
+    return null;
+  }
+}

package/src/signOperation.ts

@@ -1,142 +1,156 @@
 import { BigNumber } from "bignumber.js";
-import { Observable } from "rxjs";
 import { log } from "@ledgerhq/logs";
 import { isSegwitDerivationMode } from "@ledgerhq/coin-framework/derivation";
-import type { AccountBridge, DerivationMode, Operation } from "@ledgerhq/types-live";
-import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import type { Account, AccountBridge, Operation } from "@ledgerhq/types-live";
+import type { Observer } from "rxjs";
 import type { Transaction } from "./types";
 import { getNetworkParameters } from "./networks";
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
 import { buildTransaction } from "./buildTransaction";
 import { calculateFees } from "./cache";
 import wallet, { getWalletAccount } from "./wallet-btc";
 import { perCoinLogic } from "./logic";
 import { SignerContext } from "./signer";
+import { fromAsyncOperation } from "./observable";
+
+type SignOperationObserverEvent =
+  | { type: "device-signature-granted" }
+  | { type: "device-signature-requested" }
+  | { type: "device-streaming"; progress: number; index: number; total: number }
+  | { type: "signed"; signedOperation: { operation: Operation; signature: string } };
+
+function buildAdditionals(
+  currencyId: string,
+  derivationMode: string,
+  transaction: Transaction,
+): string[] {
+  const perCoin = perCoinLogic[currencyId];
+  let additionals: string[] = [currencyId];
+
+  if (derivationMode === "native_segwit") {
+    additionals.push("bech32");
+  }
+
+  if (derivationMode === "taproot") {
+    additionals.push("bech32m");
+  }
+
+  if (perCoin?.getAdditionals) {
+    additionals = additionals.concat(
+      perCoin.getAdditionals({
+        transaction,
+      }),
+    );
+  }
+
+  return additionals;
+}
+
+async function executeSignOperation(
+  o: Observer<SignOperationObserverEvent>,
+  account: Account,
+  deviceId: string,
+  transaction: Transaction,
+  signerContext: SignerContext,
+): Promise<void> {
+  const { currency } = account;
+  const walletAccount = getWalletAccount(account);
+
+  log("hw", `signTransaction ${currency.id} for account ${account.id}`);
+  const txInfo = await buildTransaction(account, transaction);
+
+  // Maybe better not re-calculate these fields here, instead include them
+  // in Transaction type and set them in prepareTransaction?
+  const res = await calculateFees({
+    account,
+    transaction,
+  });
+
+  const senders = res.txInputs.reduce((acc, i) => {
+    if (i.address) acc.add(i.address);
+    return acc;
+  }, new Set<string>());
+
+  const recipients = res.txOutputs.reduce<string[]>((acc, o) => {
+    if (!o.isChange && o.address) acc.push(o.address);
+    return acc;
+  }, []);
+
+  const fee = res.fees;
+
+  let lockTime: number | undefined;
+
+  // (legacy) Set lockTime for Komodo to enable reward claiming on UTXOs created by
+  // Ledger Live. We should only set this if the currency is Komodo and
+  // lockTime isn't already defined.
+  if (currency.id === "komodo" && lockTime === undefined) {
+    const unixtime = Math.floor(Date.now() / 1000);
+    lockTime = unixtime - 777;
+  }
+
+  const networkParams = getNetworkParameters(currency.id);
+  const sigHashType = networkParams.sigHash;
+  if (isNaN(sigHashType)) {
+    throw new Error("sigHashType should not be NaN");
+  }
+
+  const segwit = isSegwitDerivationMode(account.derivationMode);
+  const additionals = buildAdditionals(currency.id, account.derivationMode, transaction);
+
+  const perCoin = perCoinLogic[currency.id];
+  const expiryHeight = perCoin?.hasExpiryHeight ? Buffer.from([0x00, 0x00, 0x00, 0x00]) : undefined;
+
+  const hasExtraData = perCoin?.hasExtraData || false;
+
+  const signature: string = await signerContext(deviceId, currency, signer =>
+    wallet.signAccountTx({
+      btc: signer,
+      fromAccount: walletAccount,
+      txInfo,
+      lockTime,
+      sigHashType,
+      segwit,
+      additionals,
+      expiryHeight,
+      hasExtraData,
+      onDeviceSignatureGranted: () =>
+        o.next({
+          type: "device-signature-granted",
+        }),
+      onDeviceSignatureRequested: () =>
+        o.next({
+          type: "device-signature-requested",
+        }),
+      onDeviceStreaming: ({ progress, index, total }) =>
+        o.next({
+          type: "device-streaming",
+          progress,
+          index,
+          total,
+        }),
+    }),
+  );
+
+  const operation = buildOptimisticOperation({
+    accountId: account.id,
+    fee,
+    value: new BigNumber(transaction.amount).plus(fee),
+    senders: Array.from(senders),
+    recipients,
+  });
+
+  o.next({
+    type: "signed",
+    signedOperation: {
+      operation,
+      signature,
+    },
+  });
+}
 
 export const buildSignOperation =
   (signerContext: SignerContext): AccountBridge<Transaction>["signOperation"] =>
   ({ account, deviceId, transaction }) =>
-    new Observable(o => {
-      async function main() {
-        const { currency } = account;
-        const walletAccount = getWalletAccount(account);
-
-        log("hw", `signTransaction ${currency.id} for account ${account.id}`);
-        const txInfo = await buildTransaction(account, transaction);
-        let senders = new Set<string>();
-        let recipients: string[] = [];
-        let fee = new BigNumber(0);
-        // Maybe better not re-calculate these fields here, instead include them
-        // in Transaction type and set them in prepareTransaction?
-        await calculateFees({
-          account,
-          transaction,
-        }).then(res => {
-          senders = new Set(res.txInputs.map(i => i.address).filter(Boolean) as string[]);
-          recipients = res.txOutputs
-            .filter(o => o.address && !o.isChange)
-            .map(o => o.address) as string[];
-          fee = res.fees;
-        });
-
-        let lockTime: number | undefined;
-
-        // (legacy) Set lockTime for Komodo to enable reward claiming on UTXOs created by
-        // Ledger Live. We should only set this if the currency is Komodo and
-        // lockTime isn't already defined.
-        if (currency.id === "komodo" && lockTime === undefined) {
-          const unixtime = Math.floor(Date.now() / 1000);
-          lockTime = unixtime - 777;
-        }
-
-        const networkParams = getNetworkParameters(currency.id);
-        const sigHashType = networkParams.sigHash;
-        if (isNaN(sigHashType)) {
-          throw new Error("sigHashType should not be NaN");
-        }
-
-        const segwit = isSegwitDerivationMode(account.derivationMode as DerivationMode);
-
-        const perCoin = perCoinLogic[currency.id];
-        let additionals: string[] = [currency.id];
-
-        if (account.derivationMode === "native_segwit") {
-          additionals.push("bech32");
-        }
-
-        if (account.derivationMode === "taproot") {
-          additionals.push("bech32m");
-        }
-
-        if (perCoin?.getAdditionals) {
-          additionals = additionals.concat(
-            perCoin.getAdditionals({
-              transaction,
-            }),
-          );
-        }
-
-        const expiryHeight = perCoin?.hasExpiryHeight
-          ? Buffer.from([0x00, 0x00, 0x00, 0x00])
-          : undefined;
-
-        const hasExtraData = perCoin?.hasExtraData || false;
-
-        const signature: string = await signerContext(deviceId, currency, signer =>
-          wallet.signAccountTx({
-            btc: signer,
-            fromAccount: walletAccount,
-            txInfo,
-            lockTime,
-            sigHashType,
-            segwit,
-            additionals,
-            expiryHeight,
-            hasExtraData,
-            onDeviceSignatureGranted: () =>
-              o.next({
-                type: "device-signature-granted",
-              }),
-            onDeviceSignatureRequested: () =>
-              o.next({
-                type: "device-signature-requested",
-              }),
-            onDeviceStreaming: ({ progress, index, total }) =>
-              o.next({
-                type: "device-streaming",
-                progress,
-                index,
-                total,
-              }),
-          }),
-        );
-        // Build the optimistic operation
-        const operation: Operation = {
-          id: encodeOperationId(account.id, "", "OUT"),
-          hash: "", // Will be resolved in broadcast()
-          type: "OUT",
-          value: new BigNumber(transaction.amount).plus(fee),
-          fee,
-          blockHash: null,
-          blockHeight: null,
-          senders: Array.from(senders),
-          recipients,
-          accountId: account.id,
-          date: new Date(),
-          extra: {},
-        };
-        o.next({
-          type: "signed",
-          signedOperation: {
-            operation,
-            signature,
-          },
-        });
-      }
-
-      main().then(
-        () => o.complete(),
-        e => o.error(e),
-      );
-    });
+    fromAsyncOperation(o => executeSignOperation(o, account, deviceId, transaction, signerContext));
 
 export default buildSignOperation;

package/src/signRawOperation.ts

@@ -0,0 +1,104 @@
+import { BigNumber } from "bignumber.js";
+import { log } from "@ledgerhq/logs";
+import { getAddressFormatDerivationMode } from "@ledgerhq/coin-framework/derivation";
+import type { AccountBridge } from "@ledgerhq/types-live";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { parsePsbt } from "@ledgerhq/psbtv2";
+import type { Transaction } from "./types";
+import { getNetworkParameters } from "./networks";
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
+import { getWalletAccount } from "./wallet-btc";
+import { AddressFormat, SignerContext } from "./signer";
+import { feeFromPsbt } from "./psbtFees";
+import { fromAsyncOperation } from "./observable";
+
+type SignPsbtOptions = {
+  accountPath: string;
+  addressFormat: string;
+  onDeviceSignatureRequested?: () => void;
+  onDeviceSignatureGranted?: () => void;
+  onDeviceStreaming?: (arg: { progress: number; total: number; index: number }) => void;
+};
+
+const signPsbtWithDevice = async (
+  signerContext: SignerContext,
+  deviceId: string,
+  currency: CryptoCurrency,
+  psbtBuffer: Buffer,
+  options: SignPsbtOptions,
+) =>
+  signerContext(deviceId, currency, signer => {
+    if (!signer.signPsbtBuffer) {
+      throw new Error("signPsbtBuffer not available");
+    }
+
+    return signer.signPsbtBuffer(psbtBuffer, {
+      accountPath: options.accountPath,
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      addressFormat: options.addressFormat as AddressFormat,
+      finalizePsbt: true,
+      onDeviceSignatureRequested: options.onDeviceSignatureRequested,
+      onDeviceSignatureGranted: options.onDeviceSignatureGranted,
+      onDeviceStreaming: options.onDeviceStreaming,
+    });
+  });
+
+export const buildSignRawOperation =
+  (signerContext: SignerContext): AccountBridge<Transaction>["signRawOperation"] =>
+  ({ account, deviceId, transaction: psbt }) =>
+    fromAsyncOperation(async o => {
+      const { currency } = account;
+      const walletAccount = getWalletAccount(account);
+
+      log("hw", `signRawTransaction ${currency.id} for account ${account.id}`);
+
+      const networkParams = getNetworkParameters(currency.id);
+      const sigHashType = networkParams.sigHash;
+      if (Number.isNaN(sigHashType)) {
+        throw new TypeError("sigHashType should not be NaN");
+      }
+
+      const psbtBuffer = parsePsbt(psbt);
+
+      const psbtResult = await signPsbtWithDevice(signerContext, deviceId, currency, psbtBuffer, {
+        accountPath: `${walletAccount.params.path}/${walletAccount.params.index}'`,
+        addressFormat: getAddressFormatDerivationMode(account.derivationMode),
+        onDeviceSignatureRequested: () => o.next({ type: "device-signature-requested" }),
+        onDeviceSignatureGranted: () => o.next({ type: "device-signature-granted" }),
+        onDeviceStreaming: arg => o.next({ type: "device-streaming", ...arg }),
+      });
+
+      if (!psbtResult) {
+        throw new Error(
+          `PSBT signing failed: no result from device for account ${account.id} (${currency.id})`,
+        );
+      }
+
+      const parsedPsbtFee = feeFromPsbt(psbtBuffer);
+      if (!parsedPsbtFee) {
+        log(
+          "hw",
+          `Failed to extract fee from PSBT for account ${account.id} (${currency.id}); falling back to fee=0`,
+        );
+      }
+      const psbtFee = parsedPsbtFee || BigNumber(0);
+
+      // Optimistic operation for PSBT (we don't know recipients/amount here)
+      const operation = buildOptimisticOperation({
+        accountId: account.id,
+        fee: psbtFee,
+        extra: { psbt: true },
+      });
+
+      o.next({
+        type: "signed",
+        signedOperation: {
+          operation,
+          // Ensure non-empty signature: if not finalized, fall back to the PSBT (base64)
+          signature: psbtResult.tx || psbtResult.psbt.toString("base64"),
+          rawData: { psbtSigned: psbtResult.psbt.toString("base64") },
+        },
+      });
+    });
+
+export default buildSignRawOperation;

package/src/signer.ts

@@ -31,6 +31,19 @@ export interface BitcoinSigner {
     additionals: Array<string> | null | undefined,
   ): SignerTransaction;
   createPaymentTransaction(arg: CreateTransaction): Promise<string>;
+  signPsbtBuffer?(
+    psbtBuffer: Buffer,
+    options?: {
+      finalizePsbt?: boolean;
+      accountPath?: string;
+      addressFormat?: AddressFormat;
+      onDeviceSignatureRequested: (() => void) | undefined;
+      onDeviceSignatureGranted: (() => void) | undefined;
+      onDeviceStreaming:
+        | ((arg: { progress: number; total: number; index: number }) => void)
+        | undefined;
+    },
+  ): Promise<{ psbt: Buffer; tx: string }>;
 }
 
 export type SignerResult = BitcoinXPub | BitcoinAddress | BitcoinSignature;

package/src/types.ts

@@ -146,6 +146,8 @@ export type Transaction = TransactionCommon & {
   networkInfo: NetworkInfo | null | undefined;
   opReturnData?: Buffer | undefined;
   changeAddress?: string | undefined;
+  psbt?: string;
+  finalizePsbt?: boolean;
 };
 
 export type TransactionRaw = TransactionCommonRaw & {

package/src/wallet-btc/__tests__/fixtures/common.fixtures.ts

@@ -1,6 +1,14 @@
 import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
-
+import hash from "object-hash";
+import type {
+  AddressFormat,
+  BitcoinSignature,
+  BitcoinSigner,
+  BitcoinXPub,
+  CreateTransaction,
+  SignerTransaction,
+} from "../../../signer";
 import { Account } from "../../account";
 import { ICrypto } from "../../crypto/types";
 import Xpub from "../../xpub";
@@ -84,3 +92,58 @@ export const mockStorage = {
   exportSync: jest.fn(),
   loadSync: jest.fn(),
 } as unknown as jest.Mocked<IStorage>;
+
+export class MockBtcSigner implements BitcoinSigner {
+  // eslint-disable-next-line class-methods-use-this
+  async getWalletPublicKey(
+    path: string,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _opts: { verify?: boolean; format?: AddressFormat },
+  ) {
+    switch (path) {
+      case "44'/0'":
+        return {
+          publicKey:
+            "04c621f37493d99f39ca12fb02ba7fe1687b1650b875dcb6733f386a98958e6556fc95dcecb6ac41af0a5296965751b1598aa475a537474bab5b316fcdc1196568",
+          chainCode: "a45d311c31a80bf06cc38d8ed7934bd1e8a7b2d48b2868a70258a86e094bacfb",
+          bitcoinAddress: "1BKWjmA9swxRKMH9NgXpSz8YZfVMnWWU9D",
+        };
+      case "44'/0'/0'":
+        return {
+          publicKey:
+            "04d52d1ad9311c5a3d542fa652fbd7d7b0be70109e329d359704d9f2946f8eb52a829c23f8b980c5f7b6c51bf446b21f3dc80c865095243c9215dbf9f3cb6403b8",
+          chainCode: "0bd3e45edca4d8a466f523a2c4094c412d25c36d5298b2d3a29938151a8d37fe",
+          bitcoinAddress: "1FHa4cuKdea21ByTngP9vz3KYDqqQe9SsA",
+        };
+      default:
+        throw new Error("not supported");
+    }
+  }
+
+  async createPaymentTransaction(arg: CreateTransaction) {
+    return hash(arg);
+  }
+
+  getWalletXpub(_arg: { path: string; xpubVersion: number }): Promise<BitcoinXPub> {
+    return Promise.reject(new Error("not implemented"));
+  }
+  signMessage(_path: string, _messageHex: string): Promise<BitcoinSignature> {
+    return Promise.reject(new Error("not implemented"));
+  }
+  signPsbtBuffer(_psbtBuffer: Buffer): Promise<{ psbt: Buffer; tx: string }> {
+    return Promise.reject(new Error("not implemented"));
+  }
+  splitTransaction(
+    _transactionHex: string,
+    _isSegwitSupported: boolean | null | undefined,
+    _hasExtraData: boolean | null | undefined,
+    _additionals: Array<string> | null | undefined,
+  ): SignerTransaction {
+    // Stub
+    return {
+      version: Buffer.from(""),
+      inputs: [],
+      outputs: [],
+    };
+  }
+}

package/src/wallet-btc/__tests__/wallet.integration.test.ts

@@ -4,7 +4,7 @@ import { DerivationModes } from "../types";
 import BitcoinLikeWallet from "../wallet";
 import { Account } from "../account";
 import { Merge } from "../pickingstrategies/Merge";
-import MockBtcSigner from "../../mockBtcSigner";
+import { MockBtcSigner } from "./fixtures/common.fixtures";
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
 
 jest.setTimeout(180000);

package/src/wallet-btc/__tests__/xpub.txs.dogecoin.integration.test.ts

@@ -7,7 +7,7 @@ import BitcoinLikeExplorer from "../explorer";
 import BitcoinLikeStorage from "../storage";
 import { Merge } from "../pickingstrategies/Merge";
 import BitcoinLikeWallet from "../wallet";
-import MockBtcSigner from "../../mockBtcSigner";
+import { MockBtcSigner } from "./fixtures/common.fixtures";
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
 
 describe("testing dogecoin transactions", () => {