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

package/src/descriptor.ts

@@ -1,204 +0,0 @@
-import { Observable, from, of, EMPTY } from "rxjs";
-import { concatMap } from "rxjs/operators";
-import invariant from "invariant";
-import bs58 from "bs58";
-import type {
-  GetAddressOptions,
-  StepAddressInput,
-  Result,
-} from "@ledgerhq/coin-framework/derivation";
-import { hash256, hash160 } from "./crypto-util";
-import {
-  walletDerivation,
-  getDerivationModesForCurrency,
-  runAccountDerivationScheme,
-  getDerivationScheme,
-} from "@ledgerhq/coin-framework/derivation";
-import getAddress from "./hw-getAddress";
-import type { Account, DerivationMode } from "@ledgerhq/types-live";
-import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-import { decodeAccountId } from "@ledgerhq/coin-framework/account/index";
-import { SignerContext } from "./signer";
-
-export type AccountDescriptor = {
-  internal: string;
-  external: string;
-};
-const perDerivation: Partial<
-  Record<DerivationMode, ((arg0: string) => string) | null | undefined>
-> = {
-  "": fragment => `pkh(${fragment})`,
-  segwit: fragment => `sh(wpkh(${fragment}))`,
-  native_segwit: fragment => `wpkh(${fragment})`,
-  taproot: fragment => `tr(${fragment})`,
-};
-
-function makeFingerprint(compressedPubKey: Buffer) {
-  return hash160(compressedPubKey).slice(0, 4);
-}
-
-function makeDescriptor({
-  currency,
-  index,
-  derivationMode,
-  fingerprint,
-  xpub,
-}: {
-  currency: CryptoCurrency;
-  index: number;
-  derivationMode: DerivationMode;
-  fingerprint: Buffer;
-  xpub: string;
-}) {
-  const tmpl = perDerivation[derivationMode];
-  if (!tmpl || !xpub) return;
-  const keyOrigin = fingerprint.toString("hex");
-  const scheme = getDerivationScheme({
-    currency,
-    derivationMode,
-  });
-  const accountPath = runAccountDerivationScheme(scheme, currency, {
-    account: index,
-  });
-  return {
-    external: tmpl(`[${keyOrigin}/${accountPath}]${xpub}/0/*`),
-    internal: tmpl(`[${keyOrigin}/${accountPath}]${xpub}/1/*`),
-  };
-}
-
-export function inferDescriptorFromAccount(account: Account): AccountDescriptor | null | undefined {
-  if (account.currency.family !== "bitcoin") return;
-  const { id, derivationMode, seedIdentifier, currency, index } = account;
-  const xpub = decodeAccountId(id).xpubOrAddress;
-  const fingerprint = makeFingerprint(compressPublicKeySECP256(Buffer.from(seedIdentifier, "hex")));
-  return makeDescriptor({
-    derivationMode,
-    currency,
-    fingerprint,
-    xpub,
-    index,
-  });
-}
-
-function asBufferUInt32BE(n: number) {
-  const buf = Buffer.allocUnsafe(4);
-  buf.writeUInt32BE(n, 0);
-  return buf;
-}
-
-const compressPublicKeySECP256 = (publicKey: Buffer) =>
-  Buffer.concat([Buffer.from([0x02 + (publicKey[64] & 0x01)]), publicKey.slice(1, 33)]);
-
-function makeXpub({
-  version,
-  depth,
-  parentFingerprint,
-  index,
-  chainCode,
-  pubKey,
-}: {
-  version: number;
-  depth: number;
-  parentFingerprint: Buffer;
-  index: number;
-  chainCode: Buffer;
-  pubKey: Buffer;
-}) {
-  const indexBuffer = asBufferUInt32BE(index);
-  indexBuffer[0] |= 0x80;
-  const extendedKeyBytes = Buffer.concat([
-    asBufferUInt32BE(version),
-    Buffer.from([depth]),
-    parentFingerprint,
-    indexBuffer,
-    chainCode,
-    pubKey,
-  ]);
-  const checksum = hash256(extendedKeyBytes).slice(0, 4);
-  return bs58.encode(Buffer.concat([extendedKeyBytes, checksum]));
-}
-
-export function inferDescriptorFromDeviceInfo({
-  derivationMode,
-  currency,
-  index,
-  parentDerivation,
-  accountDerivation,
-}: {
-  derivationMode: DerivationMode;
-  currency: CryptoCurrency;
-  index: number;
-  parentDerivation: Result;
-  accountDerivation: Result;
-}): AccountDescriptor | null | undefined {
-  invariant(currency.bitcoinLikeInfo, "bitcoin currency expected");
-  const { bitcoinLikeInfo } = currency;
-  const { XPUBVersion } = bitcoinLikeInfo as {
-    P2PKH: number;
-    P2SH: number;
-    XPUBVersion?: number;
-  };
-  invariant(XPUBVersion, "unsupported bitcoin fork %s", currency.id);
-  const { chainCode } = accountDerivation;
-  invariant(chainCode, "chainCode is required");
-  const fingerprint = makeFingerprint(
-    compressPublicKeySECP256(Buffer.from(parentDerivation.publicKey, "hex")),
-  );
-  const xpub = makeXpub({
-    version: XPUBVersion,
-    depth: 3,
-    parentFingerprint: fingerprint,
-    index,
-    chainCode: Buffer.from(chainCode as string, "hex"),
-    pubKey: compressPublicKeySECP256(Buffer.from(accountDerivation.publicKey, "hex")),
-  });
-  return makeDescriptor({
-    derivationMode,
-    currency,
-    fingerprint,
-    xpub,
-    index,
-  });
-}
-export function scanDescriptors(
-  deviceId: string,
-  currency: CryptoCurrency,
-  signerContext: SignerContext,
-  limit = 10,
-): Observable<AccountDescriptor> {
-  const derivateAddress = (opts: GetAddressOptions) =>
-    from(getAddress(signerContext)(deviceId, opts));
-
-  function stepAddress({
-    index,
-    accountDerivation,
-    parentDerivation,
-    derivationMode,
-  }: StepAddressInput) {
-    const result = inferDescriptorFromDeviceInfo({
-      derivationMode,
-      currency,
-      index,
-      parentDerivation,
-      accountDerivation,
-    });
-    return !result
-      ? EMPTY
-      : of({
-          result,
-          complete: index >= limit,
-        });
-  }
-
-  return from(getDerivationModesForCurrency(currency)).pipe(
-    concatMap(derivationMode =>
-      walletDerivation({
-        currency,
-        derivationMode,
-        derivateAddress,
-        stepAddress,
-        shouldDerivesOnAccount: true,
-      }),
-    ),
-  );
-}

package/src/mockBtcSigner.ts

@@ -1,65 +0,0 @@
-import hash from "object-hash";
-import type {
-  AddressFormat,
-  BitcoinSignature,
-  BitcoinSigner,
-  BitcoinXPub,
-  CreateTransaction,
-  SignerTransaction,
-} from "./signer";
-
-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",
-        };
-        break;
-      case "44'/0'/0'":
-        return {
-          publicKey:
-            "04d52d1ad9311c5a3d542fa652fbd7d7b0be70109e329d359704d9f2946f8eb52a829c23f8b980c5f7b6c51bf446b21f3dc80c865095243c9215dbf9f3cb6403b8",
-          chainCode: "0bd3e45edca4d8a466f523a2c4094c412d25c36d5298b2d3a29938151a8d37fe",
-          bitcoinAddress: "1FHa4cuKdea21ByTngP9vz3KYDqqQe9SsA",
-        };
-        break;
-      default:
-        throw new Error("not supported");
-    }
-  }
-
-  async createPaymentTransaction(arg: CreateTransaction) {
-    return hash(arg);
-  }
-
-  getWalletXpub(_arg: { path: string; xpubVersion: number }): Promise<BitcoinXPub> {
-    return Promise.reject();
-  }
-  signMessage(_path: string, _messageHex: string): Promise<BitcoinSignature> {
-    return Promise.reject();
-  }
-  splitTransaction(
-    _transactionHex: string,
-    _isSegwitSupported: boolean | null | undefined,
-    _hasExtraData: boolean | null | undefined,
-    _additionals: Array<string> | null | undefined,
-  ): SignerTransaction {
-    // Stub
-    return {
-      version: Buffer.from(""),
-      inputs: [],
-      outputs: [],
-    };
-  }
-}
-
-export default MockBtcSigner;