@ledgerhq/hw-app-btc 6.2.0 → 6.9.1-6.9.1-taproot.0.0

package/src/newops/psbtv2.ts

@@ -0,0 +1,548 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+import { BufferReader, BufferWriter } from "../buffertools";
+
+export enum psbtGlobal {
+  TX_VERSION = 0x02,
+  FALLBACK_LOCKTIME = 0x03,
+  INPUT_COUNT = 0x04,
+  OUTPUT_COUNT = 0x05,
+  TX_MODIFIABLE = 0x06,
+  VERSION = 0xfb,
+}
+export enum psbtIn {
+  NON_WITNESS_UTXO = 0x00,
+  WITNESS_UTXO = 0x01,
+  PARTIAL_SIG = 0x02,
+  REDEEM_SCRIPT = 0x04,
+  BIP32_DERIVATION = 0x06,
+  FINAL_SCRIPTSIG = 0x07,
+  FINAL_SCRIPTWITNESS = 0x08,
+  PREVIOUS_TXID = 0x0e,
+  OUTPUT_INDEX = 0x0f,
+  SEQUENCE = 0x10,
+  TAP_KEY_SIG = 0x13,
+  TAP_BIP32_DERIVATION = 0x16,
+}
+export enum psbtOut {
+  REDEEM_SCRIPT = 0x00,
+  BIP_32_DERIVATION = 0x02,
+  AMOUNT = 0x03,
+  SCRIPT = 0x04,
+  TAP_BIP32_DERIVATION = 0x07,
+}
+
+const PSBT_MAGIC_BYTES = Buffer.of(0x70, 0x73, 0x62, 0x74, 0xff);
+
+export class NoSuchEntry extends Error {}
+
+export class PsbtV2 {
+  protected globalMap: Map<string, Buffer> = new Map();
+  protected inputMaps: Map<string, Buffer>[] = [];
+  protected outputMaps: Map<string, Buffer>[] = [];
+
+  setGlobalTxVersion(version: number) {
+    this.setGlobal(psbtGlobal.TX_VERSION, uint32LE(version));
+  }
+  getGlobalTxVersion(): number {
+    return this.getGlobal(psbtGlobal.TX_VERSION).readUInt32LE(0);
+  }
+  setGlobalFallbackLocktime(locktime: number) {
+    this.setGlobal(psbtGlobal.FALLBACK_LOCKTIME, uint32LE(locktime));
+  }
+  getGlobalFallbackLocktime(): number | undefined {
+    return this.getGlobalOptional(psbtGlobal.FALLBACK_LOCKTIME)?.readUInt32LE(
+      0
+    );
+  }
+  setGlobalInputCount(inputCount: number) {
+    this.setGlobal(psbtGlobal.INPUT_COUNT, varint(inputCount));
+  }
+  getGlobalInputCount(): number {
+    return fromVarint(this.getGlobal(psbtGlobal.INPUT_COUNT));
+  }
+  setGlobalOutputCount(outputCount: number) {
+    this.setGlobal(psbtGlobal.OUTPUT_COUNT, varint(outputCount));
+  }
+  getGlobalOutputCount(): number {
+    return fromVarint(this.getGlobal(psbtGlobal.OUTPUT_COUNT));
+  }
+  setGlobalTxModifiable(byte: Buffer) {
+    this.setGlobal(psbtGlobal.TX_MODIFIABLE, byte);
+  }
+  getGlobalTxModifiable(): Buffer | undefined {
+    return this.getGlobalOptional(psbtGlobal.TX_MODIFIABLE);
+  }
+  setGlobalPsbtVersion(psbtVersion: number) {
+    this.setGlobal(psbtGlobal.VERSION, uint32LE(psbtVersion));
+  }
+  getGlobalPsbtVersion(): number {
+    return this.getGlobal(psbtGlobal.VERSION).readUInt32LE(0);
+  }
+
+  setInputNonWitnessUtxo(inputIndex: number, transaction: Buffer) {
+    this.setInput(inputIndex, psbtIn.NON_WITNESS_UTXO, b(), transaction);
+  }
+  getInputNonWitnessUtxo(inputIndex: number): Buffer | undefined {
+    return this.getInputOptional(inputIndex, psbtIn.NON_WITNESS_UTXO, b());
+  }
+  setInputWitnessUtxo(
+    inputIndex: number,
+    amount: Buffer,
+    scriptPubKey: Buffer
+  ) {
+    const buf = new BufferWriter();
+    buf.writeSlice(amount);
+    buf.writeVarSlice(scriptPubKey);
+    this.setInput(inputIndex, psbtIn.WITNESS_UTXO, b(), buf.buffer());
+  }
+  getInputWitnessUtxo(
+    inputIndex: number
+  ): { amount: Buffer; scriptPubKey: Buffer } | undefined {
+    const utxo = this.getInputOptional(inputIndex, psbtIn.WITNESS_UTXO, b());
+    if (!utxo) return undefined;
+    const buf = new BufferReader(utxo);
+    return { amount: buf.readSlice(8), scriptPubKey: buf.readVarSlice() };
+  }
+  setInputPartialSig(inputIndex: number, pubkey: Buffer, signature: Buffer) {
+    this.setInput(inputIndex, psbtIn.PARTIAL_SIG, pubkey, signature);
+  }
+  getInputPartialSig(inputIndex: number, pubkey: Buffer): Buffer | undefined {
+    return this.getInputOptional(inputIndex, psbtIn.PARTIAL_SIG, pubkey);
+  }
+  setInputRedeemScript(inputIndex: number, redeemScript: Buffer) {
+    this.setInput(inputIndex, psbtIn.REDEEM_SCRIPT, b(), redeemScript);
+  }
+  getInputRedeemScript(inputIndex: number): Buffer | undefined {
+    return this.getInputOptional(inputIndex, psbtIn.REDEEM_SCRIPT, b());
+  }
+  setInputBip32Derivation(
+    inputIndex: number,
+    pubkey: Buffer,
+    masterFingerprint: Buffer,
+    path: number[]
+  ) {
+    this.setInput(
+      inputIndex,
+      psbtIn.BIP32_DERIVATION,
+      pubkey,
+      this.encodeBip32Derivation(masterFingerprint, path)
+    );
+  }
+  getInputBip32Derivation(
+    inputIndex: number,
+    pubkey: Buffer
+  ): { masterFingerprint: Buffer; path: number[] } | undefined {
+    const buf = this.getInputOptional(
+      inputIndex,
+      psbtIn.BIP32_DERIVATION,
+      pubkey
+    );
+    if (!buf) return undefined;
+    return this.decodeBip32Derivation(buf);
+  }
+  setInputFinalScriptsig(inputIndex: number, scriptSig: Buffer) {
+    this.setInput(inputIndex, psbtIn.FINAL_SCRIPTSIG, b(), scriptSig);
+  }
+  getInputFinalScriptsig(inputIndex: number): Buffer | undefined {
+    return this.getInputOptional(inputIndex, psbtIn.FINAL_SCRIPTSIG, b());
+  }
+  setInputFinalScriptwitness(inputIndex: number, scriptWitness: Buffer) {
+    this.setInput(inputIndex, psbtIn.FINAL_SCRIPTWITNESS, b(), scriptWitness);
+  }
+  getInputFinalScriptwitness(inputIndex: number): Buffer {
+    return this.getInput(inputIndex, psbtIn.FINAL_SCRIPTWITNESS, b());
+  }
+  setInputPreviousTxId(inputIndex: number, txid: Buffer) {
+    this.setInput(inputIndex, psbtIn.PREVIOUS_TXID, b(), txid);
+  }
+  getInputPreviousTxid(inputIndex: number): Buffer {
+    return this.getInput(inputIndex, psbtIn.PREVIOUS_TXID, b());
+  }
+  setInputOutputIndex(inputIndex: number, outputIndex: number) {
+    this.setInput(inputIndex, psbtIn.OUTPUT_INDEX, b(), uint32LE(outputIndex));
+  }
+  getInputOutputIndex(inputIndex: number): number {
+    return this.getInput(inputIndex, psbtIn.OUTPUT_INDEX, b()).readUInt32LE(0);
+  }
+  setInputSequence(inputIndex: number, sequence: number) {
+    this.setInput(inputIndex, psbtIn.SEQUENCE, b(), uint32LE(sequence));
+  }
+  getInputSequence(inputIndex: number): number {
+    return (
+      this.getInputOptional(inputIndex, psbtIn.SEQUENCE, b())?.readUInt32LE(
+        0
+      ) ?? 0xffffffff
+    );
+  }
+  setInputTapKeySig(inputIndex: number, sig: Buffer) {
+    this.setInput(inputIndex, psbtIn.TAP_KEY_SIG, b(), sig);
+  }
+  getInputTapKeySig(inputIndex: number): Buffer | undefined {
+    return this.getInputOptional(inputIndex, psbtIn.TAP_KEY_SIG, b());
+  }
+  setInputTapBip32Derivation(
+    inputIndex: number,
+    pubkey: Buffer,
+    hashes: Buffer[],
+    masterFingerprint: Buffer,
+    path: number[]
+  ) {
+    const buf = this.encodeTapBip32Derivation(hashes, masterFingerprint, path);
+    this.setInput(inputIndex, psbtIn.TAP_BIP32_DERIVATION, pubkey, buf);
+  }
+  getInputTapBip32Derivation(
+    inputIndex: number,
+    pubkey: Buffer
+  ): { hashes: Buffer[]; masterFingerprint: Buffer; path: number[] } {
+    const buf = this.getInput(inputIndex, psbtIn.TAP_BIP32_DERIVATION, pubkey);
+    return this.decodeTapBip32Derivation(buf);
+  }
+  getInputKeyDatas(inputIndex: number, keyType: KeyType): Buffer[] {
+    return this.getKeyDatas(this.inputMaps[inputIndex], keyType);
+  }
+
+  setOutputRedeemScript(outputIndex: number, redeemScript: Buffer) {
+    this.setOutput(outputIndex, psbtOut.REDEEM_SCRIPT, b(), redeemScript);
+  }
+  getOutputRedeemScript(outputIndex: number): Buffer {
+    return this.getOutput(outputIndex, psbtOut.REDEEM_SCRIPT, b());
+  }
+  setOutputBip32Derivation(
+    outputIndex: number,
+    pubkey: Buffer,
+    masterFingerprint: Buffer,
+    path: number[]
+  ) {
+    this.setOutput(
+      outputIndex,
+      psbtOut.BIP_32_DERIVATION,
+      pubkey,
+      this.encodeBip32Derivation(masterFingerprint, path)
+    );
+  }
+  getOutputBip32Derivation(
+    outputIndex: number,
+    pubkey: Buffer
+  ): { masterFingerprint: Buffer; path: number[] } {
+    const buf = this.getOutput(outputIndex, psbtOut.BIP_32_DERIVATION, pubkey);
+    return this.decodeBip32Derivation(buf);
+  }
+  setOutputAmount(outputIndex: number, amount: number) {
+    this.setOutput(outputIndex, psbtOut.AMOUNT, b(), uint64LE(amount));
+  }
+  getOutputAmount(outputIndex: number): number {
+    return Number(
+      this.getOutput(outputIndex, psbtOut.AMOUNT, b()).readBigUInt64LE(0)
+    );
+  }
+  setOutputScript(outputIndex: number, scriptPubKey: Buffer) {
+    this.setOutput(outputIndex, psbtOut.SCRIPT, b(), scriptPubKey);
+  }
+  getOutputScript(outputIndex: number): Buffer {
+    return this.getOutput(outputIndex, psbtOut.SCRIPT, b());
+  }
+  setOutputTapBip32Derivation(
+    outputIndex: number,
+    pubkey: Buffer,
+    hashes: Buffer[],
+    fingerprint: Buffer,
+    path: number[]
+  ) {
+    const buf = this.encodeTapBip32Derivation(hashes, fingerprint, path);
+    this.setOutput(outputIndex, psbtOut.TAP_BIP32_DERIVATION, pubkey, buf);
+  }
+  getOutputTapBip32Derivation(
+    outputIndex: number,
+    pubkey: Buffer
+  ): { hashes: Buffer[]; masterFingerprint: Buffer; path: number[] } {
+    const buf = this.getOutput(
+      outputIndex,
+      psbtOut.TAP_BIP32_DERIVATION,
+      pubkey
+    );
+    return this.decodeTapBip32Derivation(buf);
+  }
+
+  deleteInputEntries(inputIndex: number, keyTypes: psbtIn[]) {
+    const map = this.inputMaps[inputIndex];
+    map.forEach((_v, k, m) => {
+      if (this.isKeyType(k, keyTypes)) {
+        m.delete(k);
+      }
+    });
+  }
+
+  copy(to: PsbtV2) {
+    this.copyMap(this.globalMap, to.globalMap);
+    this.copyMaps(this.inputMaps, to.inputMaps);
+    this.copyMaps(this.outputMaps, to.outputMaps);
+  }
+  copyMaps(from: Map<string, Buffer>[], to: Map<string, Buffer>[]) {
+    from.forEach((m, index) => {
+      const to_index = new Map();
+      this.copyMap(m, to_index);
+      to[index] = to_index;
+    });
+  }
+  copyMap(from: Map<string, Buffer>, to: Map<string, Buffer>) {
+    from.forEach((v, k) => to.set(k, Buffer.from(v)));
+  }
+  serialize(): Buffer {
+    const buf = new BufferWriter();
+    buf.writeSlice(Buffer.of(0x70, 0x73, 0x62, 0x74, 0xff));
+    serializeMap(buf, this.globalMap);
+    this.inputMaps.forEach((map) => {
+      serializeMap(buf, map);
+    });
+    this.outputMaps.forEach((map) => {
+      serializeMap(buf, map);
+    });
+    return buf.buffer();
+  }
+  deserialize(psbt: Buffer) {
+    const buf = new BufferReader(psbt);
+    if (!buf.readSlice(5).equals(PSBT_MAGIC_BYTES)) {
+      throw new Error("Invalid magic bytes");
+    }
+    while (this.readKeyPair(this.globalMap, buf));
+    for (let i = 0; i < this.getGlobalInputCount(); i++) {
+      this.inputMaps[i] = new Map();
+      while (this.readKeyPair(this.inputMaps[i], buf));
+    }
+    for (let i = 0; i < this.getGlobalOutputCount(); i++) {
+      this.outputMaps[i] = new Map();
+      while (this.readKeyPair(this.outputMaps[i], buf));
+    }
+  }
+  private readKeyPair(map: Map<string, Buffer>, buf: BufferReader): boolean {
+    const keyLen = buf.readVarInt();
+    if (keyLen == 0) {
+      return false;
+    }
+    const keyType = buf.readUInt8();
+    const keyData = buf.readSlice(keyLen - 1);
+    const value = buf.readVarSlice();
+    set(map, keyType, keyData, value);
+    return true;
+  }
+  private getKeyDatas(map: Map<string, Buffer>, keyType: KeyType): Buffer[] {
+    const result: Buffer[] = [];
+    map.forEach((_v, k) => {
+      if (this.isKeyType(k, [keyType])) {
+        result.push(Buffer.from(k.substring(2), "hex"));
+      }
+    });
+    return result;
+  }
+  private isKeyType(hexKey: string, keyTypes: KeyType[]): boolean {
+    const keyType = Buffer.from(hexKey.substring(0, 2), "hex").readUInt8(0);
+    return keyTypes.some((k) => k == keyType);
+  }
+  private setGlobal(keyType: KeyType, value: Buffer) {
+    const key = new Key(keyType, Buffer.of());
+    this.globalMap.set(key.toString(), value);
+  }
+  private getGlobal(keyType: KeyType): Buffer {
+    return get(this.globalMap, keyType, b(), false)!;
+  }
+  private getGlobalOptional(keyType: KeyType): Buffer | undefined {
+    return get(this.globalMap, keyType, b(), true);
+  }
+  private setInput(
+    index: number,
+    keyType: KeyType,
+    keyData: Buffer,
+    value: Buffer
+  ) {
+    set(this.getMap(index, this.inputMaps), keyType, keyData, value);
+  }
+  private getMap(
+    index: number,
+    maps: Map<string, Buffer>[]
+  ): Map<string, Buffer> {
+    if (maps[index]) {
+      return maps[index];
+    }
+    return (maps[index] = new Map());
+  }
+  private getInput(index: number, keyType: KeyType, keyData: Buffer): Buffer {
+    return get(this.inputMaps[index], keyType, keyData, false)!;
+  }
+  private getInputOptional(
+    index: number,
+    keyType: KeyType,
+    keyData: Buffer
+  ): Buffer | undefined {
+    return get(this.inputMaps[index], keyType, keyData, true);
+  }
+  private setOutput(
+    index: number,
+    keyType: KeyType,
+    keyData: Buffer,
+    value: Buffer
+  ) {
+    set(this.getMap(index, this.outputMaps), keyType, keyData, value);
+  }
+  private getOutput(index: number, keyType: KeyType, keyData: Buffer): Buffer {
+    return get(this.outputMaps[index], keyType, keyData, false)!;
+  }
+  private getOutputOptional(
+    index: number,
+    keyType: KeyType,
+    keyData: Buffer
+  ): Buffer | undefined {
+    return get(this.outputMaps[index], keyType, keyData, true);
+  }
+  private encodeBip32Derivation(masterFingerprint: Buffer, path: number[]) {
+    const buf = new BufferWriter();
+    this.writeBip32Derivation(buf, masterFingerprint, path);
+    return buf.buffer();
+  }
+  private decodeBip32Derivation(
+    buffer: Buffer
+  ): { masterFingerprint: Buffer; path: number[] } {
+    const buf = new BufferReader(buffer);
+    return this.readBip32Derivation(buf);
+  }
+  private writeBip32Derivation(
+    buf: BufferWriter,
+    masterFingerprint: Buffer,
+    path: number[]
+  ) {
+    buf.writeSlice(masterFingerprint);
+    path.forEach((element) => {
+      buf.writeUInt32(element);
+    });
+  }
+  private readBip32Derivation(
+    buf: BufferReader
+  ): { masterFingerprint: Buffer; path: number[] } {
+    const masterFingerprint = buf.readSlice(4);
+    const path: number[] = [];
+    while (buf.offset < buf.buffer.length) {
+      path.push(buf.readUInt32());
+    }
+    return { masterFingerprint, path };
+  }
+  private encodeTapBip32Derivation(
+    hashes: Buffer[],
+    masterFingerprint: Buffer,
+    path: number[]
+  ): Buffer {
+    const buf = new BufferWriter();
+    buf.writeVarInt(hashes.length);
+    hashes.forEach((h) => {
+      buf.writeSlice(h);
+    });
+    this.writeBip32Derivation(buf, masterFingerprint, path);
+    return buf.buffer();
+  }
+  private decodeTapBip32Derivation(
+    buffer: Buffer
+  ): { hashes: Buffer[]; masterFingerprint: Buffer; path: number[] } {
+    const buf = new BufferReader(buffer);
+    const hashCount = buf.readVarInt();
+    const hashes: Buffer[] = [];
+    for (let i = 0; i < hashCount; i++) {
+      hashes.push(buf.readSlice(32));
+    }
+    const deriv = this.readBip32Derivation(buf);
+    return { hashes, ...deriv };
+  }
+}
+function get(
+  map: Map<string, Buffer>,
+  keyType: KeyType,
+  keyData: Buffer,
+  acceptUndefined: boolean
+): Buffer | undefined {
+  if (!map) throw Error("No such map");
+  const key = new Key(keyType, keyData);
+  const value = map.get(key.toString());
+  if (!value) {
+    if (acceptUndefined) {
+      return undefined;
+    }
+    throw new NoSuchEntry(key.toString());
+  }
+  // Make sure to return a copy, to protect the underlying data.
+  return Buffer.from(value);
+}
+type KeyType = number;
+
+class Key {
+  keyType: KeyType;
+  keyData: Buffer;
+  constructor(keyType: KeyType, keyData: Buffer) {
+    this.keyType = keyType;
+    this.keyData = keyData;
+  }
+  toString(): string {
+    const buf = new BufferWriter();
+    this.toBuffer(buf);
+    return buf.buffer().toString("hex");
+  }
+  serialize(buf: BufferWriter) {
+    buf.writeVarInt(1 + this.keyData.length);
+    this.toBuffer(buf);
+  }
+  private toBuffer(buf: BufferWriter) {
+    buf.writeUInt8(this.keyType);
+    buf.writeSlice(this.keyData);
+  }
+}
+class KeyPair {
+  key: Key;
+  value: Buffer;
+  constructor(key: Key, value: Buffer) {
+    this.key = key;
+    this.value = value;
+  }
+  serialize(buf: BufferWriter) {
+    this.key.serialize(buf);
+    buf.writeVarSlice(this.value);
+  }
+}
+function createKey(buf: Buffer): Key {
+  return new Key(buf.readUInt8(0), buf.slice(1));
+}
+function serializeMap(buf: BufferWriter, map: Map<string, Buffer>) {
+  for (const k in map.keys) {
+    const value = map.get(k)!;
+    const keyPair = new KeyPair(createKey(Buffer.from(k, "hex")), value);
+    keyPair.serialize(buf);
+  }
+  buf.writeUInt8(0);
+}
+
+function b(): Buffer {
+  return Buffer.of();
+}
+function set(
+  map: Map<string, Buffer>,
+  keyType: KeyType,
+  keyData: Buffer,
+  value: Buffer
+) {
+  const key = new Key(keyType, keyData);
+  map.set(key.toString(), value);
+}
+function uint32LE(n: number): Buffer {
+  const b = Buffer.alloc(4);
+  b.writeUInt32LE(n, 0);
+  return b;
+}
+function uint64LE(n: number): Buffer {
+  const b = Buffer.alloc(8);
+  b.writeBigUInt64LE(BigInt(n), 0);
+  return b;
+}
+function varint(n: number): Buffer {
+  const b = new BufferWriter();
+  b.writeVarInt(n);
+  return b.buffer();
+}
+function fromVarint(buf: Buffer): number {
+  return new BufferReader(buf).readVarInt();
+}

package/src/varint.ts

@@ -1,3 +1,5 @@
+// TODO: this does not support 64-bit varints!
+
 export function getVarint(data: Buffer, offset: number): [number, number] {
   if (data[offset] < 0xfd) {
     return [data[offset], 1];

package/tests/Btc.integration.test.ts

@@ -0,0 +1,89 @@
+// import Transport from "@ledgerhq/hw-transport-node-hid";
+import SpeculosTransport from "@ledgerhq/hw-transport-node-speculos";
+import BtcNew from "../src/BtcNew";
+import Btc from "../src/Btc";
+import { AppClient } from "../src/newops/appClient";
+import { getXpubComponents } from "../src/bip32";
+import { compressPublicKey } from "../src/compressPublicKey";
+import Transport from "@ledgerhq/hw-transport";
+
+const xpubs = {
+  "m/44'/1'/0'":
+    "tpubDCwYjpDhUdPGP5rS3wgNg13mTrrjBuG8V9VpWbyptX6TRPbNoZVXsoVUSkCjmQ8jJycjuDKBb9eataSymXakTTaGifxR6kmVsfFehH1ZgJT",
+  "m/44'/1'/10'":
+    "tpubDCwYjpDhUdPGp21gSpVay2QPJVh6WNySWMXPhbcu1DsxH31dF7mY18oibbu5RxCLBc1Szerjscuc3D5HyvfYqfRvc9mesewnFqGmPjney4d",
+  "m/44'/1'/2'/1/42":
+    "tpubDGF9YgHKv6qh777rcqVhpmDrbNzgophJM9ec7nHiSfrbss7fVBXoqhmZfohmJSvhNakDHAspPHjVVNL657tLbmTXvSeGev2vj5kzjMaeupT",
+  "m/48'/1'/4'/1'/0/7":
+    "tpubDK8WPFx4WJo1R9mEL7Wq325wBiXvkAe8ipgb9Q1QBDTDUD2YeCfutWtzY88NPokZqJyRPKHLGwTNLT7jBG59aC6VH8q47LDGQitPB6tX2d7",
+  "m/49'/1'/1'/1/3":
+    "tpubDGnetmJDCL18TyaaoyRAYbkSE9wbHktSdTS4mfsR6inC8c2r6TjdBt3wkqEQhHYPtXpa46xpxDaCXU2PRNUGVvDzAHPG6hHRavYbwAGfnFr",
+  "m/84'/1'/2'/0/10":
+    "tpubDG9YpSUwScWJBBSrhnAT47NcT4NZGLcY18cpkaiWHnkUCi19EtCh8Heeox268NaFF6o56nVeSXuTyK6jpzTvV1h68Kr3edA8AZp27MiLUNt",
+  "m/86'/1'/4'/1/12":
+    "tpubDHTZ815MvTaRmo6Qg1rnU6TEU4ZkWyA56jA1UgpmMcBGomnSsyo34EZLoctzZY9MTJ6j7bhccceUeXZZLxZj5vgkVMYfcZ7DNPsyRdFpS3f",
+};
+/*
+const addresses = {
+  "m/44'/1'/0'/0/0": "mz5vLWdM1wHVGSmXUkhKVvZbJ2g4epMXSm",
+  "m/84'/1'/0'/0/0": "tb1qzdr7s2sr0dwmkwx033r4nujzk86u0cy6fmzfjk",
+  "m/49'/1'/0'/0/0": "2MyHkbusvLomaarGYMqyq7q9pSBYJRwWcsw",
+};
+*/
+test("Basic happypath BtcOld test", async () => {
+  await runGetWalletPublicKey("old");
+});
+
+test("Basic happypath BtcNew test", async () => {
+  await runGetWalletPublicKey("new");
+});
+
+async function transport() {
+  return await SpeculosTransport.open({ apduPort: 9999 });
+}
+
+async function impl(
+  variant: "old" | "new",
+  transport: Transport
+): Promise<Btc | BtcNew> {
+  if (variant === "old") {
+    return new Btc(transport);
+  }
+  const client = new AppClient(transport);
+  const btc = new BtcNew(client);
+  return btc;
+}
+
+async function runGetWalletPublicKey(variant: "old" | "new") {
+  let tr;
+  try {
+    tr = await transport();
+  } catch (e) {
+    console.error("FIXME: SPECULOS TEST IGNORED BECAUSE INSTANCE IS NOT UP", e);
+    return;
+  }
+  try {
+    const btc = await impl(variant, tr);
+
+    const account = await btc.getWalletPublicKey("m/44'/1'/0'");
+    const expectedAccount = getXpubComponents(xpubs["m/44'/1'/0'"]);
+
+    const uncompressesPubkey =
+      "04e84c7f4b7662faed9f5eb2d812d9b7bcf0e0bf2a33b17ac45e38b8459669c321816e33dd5541f01ac4e9dbee1ad25fccf2bdc1dc16336b3ae66463c093d612ed";
+    expect(compressPublicKey(Buffer.from(uncompressesPubkey, "hex"))).toEqual(
+      expectedAccount.pubkey
+    );
+
+    expect(account.chainCode).toEqual(
+      expectedAccount.chaincode.toString("hex")
+    );
+    expect(account.publicKey).toEqual(uncompressesPubkey);
+
+    const keydata = await btc.getWalletPublicKey("m/44'/1'/0'/0/0");
+    expect(keydata.bitcoinAddress).toEqual(
+      "mz5vLWdM1wHVGSmXUkhKVvZbJ2g4epMXSm"
+    );
+  } finally {
+    tr.close();
+  }
+}

package/tests/Btc.test.ts

@@ -7,6 +7,8 @@ import Btc from "../src/Btc";
 test("btc.getWalletPublicKey", async () => {
   const transport = await openTransportReplayer(
     RecordStore.fromString(`
+      => b001000000
+      <= 0107426974636f696e06312e332e323301029000
       => e040000011048000002c800000008000000000000000
       <= 410486b865b52b753d0a84d09bc20063fab5d8453ec33c215d4019a5801c9c6438b917770b2782e29a9ecc6edb67cd1f0fbf05ec4c1236884b6d686d6be3b1588abb2231334b453654666641724c683466564d36756f517a7673597135767765744a63564dbce80dd580792cd18af542790e56aa813178dc28644bb5f03dbd44c85f2d2e7a9000
     `)
@@ -27,6 +29,8 @@ test("btc 2", async () => {
     RecordStore.fromString(`
     => b001000000
     <= 0107426974636f696e06312e332e323301029000
+    => b001000000
+    <= 0107426974636f696e06312e332e323301029000
     => e042000009000000010100000001
     <= 9000
     => e0428000254ea60aeac5252c14291d428915bd7ccd1bfc4af009f4d4dc57ae597ed0420b71010000008a
@@ -160,6 +164,8 @@ test("btc seg multi", async () => {
   const transport = await openTransportReplayer(
     RecordStore.fromString(`
     => b001000000
+    <= 0107426974636f696e06312e332e323301029000
+    => b001000000
     <= 0107426974636f696e06312e332e323201029000
     => e040000015058000003180000001800000050000000000000000
     <= 4104f004370a593b3cde1511801a1151c86dd09a2f246a3f9ac3ef0b0240c0aeb506feddb0a785f5039c3e3e829db9692364e333256284d0fe312177cb12b88551162131764a4336523431416334685a61704a7863334c5a6e69334e7169445837514562141c248b44b74cbe35a3a92801cfebaf895df8d65f5830264097260c863fc1e59000