@ledgerhq/hw-app-btc 6.9.1-taproot.0 → 6.11.1

package/src/newops/appClient.ts

@@ -23,6 +23,10 @@ enum FrameworkIns {
   CONTINUE_INTERRUPTED = 0x01,
 }
 
+/**
+ * This class encapsulates the APDU protocol documented at
+ * https://github.com/LedgerHQ/app-bitcoin-new/blob/master/doc/bitcoin.md
+ */
 export class AppClient {
   transport: Transport;
 
@@ -59,7 +63,10 @@ export class AppClient {
     return response.slice(0, -2); // drop the status word (can only be 0x9000 at this point)
   }
 
-  async getPubkey(display: boolean, pathElements: number[]): Promise<string> {
+  async getExtendedPubkey(
+    display: boolean,
+    pathElements: number[]
+  ): Promise<string> {
     if (pathElements.length > 6) {
       throw new Error("Path too long. At most 6 levels allowed.");
     }
@@ -89,7 +96,7 @@ export class AppClient {
       throw new Error("Invalid HMAC length");
     }
 
-    const clientInterpreter = new ClientCommandInterpreter();
+    const clientInterpreter = new ClientCommandInterpreter(() => {});
     clientInterpreter.addKnownList(
       walletPolicy.keys.map((k) => Buffer.from(k, "ascii"))
     );
@@ -116,7 +123,8 @@ export class AppClient {
   async signPsbt(
     psbt: PsbtV2,
     walletPolicy: WalletPolicy,
-    walletHMAC: Buffer | null
+    walletHMAC: Buffer | null,
+    progressCallback: () => void
   ): Promise<Map<number, Buffer>> {
     const merkelizedPsbt = new MerkelizedPsbt(psbt);
 
@@ -124,7 +132,7 @@ export class AppClient {
       throw new Error("Invalid HMAC length");
     }
 
-    const clientInterpreter = new ClientCommandInterpreter();
+    const clientInterpreter = new ClientCommandInterpreter(progressCallback);
 
     // prepare ClientCommandInterpreter
     clientInterpreter.addKnownList(
@@ -167,7 +175,7 @@ export class AppClient {
 
     const ret: Map<number, Buffer> = new Map();
     for (const inputAndSig of yielded) {
-      ret[inputAndSig[0]] = inputAndSig.slice(1);
+      ret.set(inputAndSig[0], inputAndSig.slice(1));
     }
     return ret;
   }

package/src/newops/clientCommands.ts

@@ -21,13 +21,14 @@ export class YieldCommand extends ClientCommand {
 
   code = ClientCommandCode.YIELD;
 
-  constructor(results: Buffer[]) {
+  constructor(results: Buffer[], private progressCallback: () => void) {
     super();
     this.results = results;
   }
 
   execute(request: Buffer): Buffer {
     this.results.push(Buffer.from(request.subarray(1)));
+    this.progressCallback();
     return Buffer.from("");
   }
 }
@@ -247,6 +248,21 @@ export class GetMoreElementsCommand extends ClientCommand {
   }
 }
 
+/**
+ * This class will dispatch a client command coming from the hardware device to
+ * the appropriate client command implementation. Those client commands
+ * typically requests data from a merkle tree or merkelized maps.
+ *
+ * A ClientCommandInterpreter is prepared by adding the merkle trees and
+ * merkelized maps it should be able to serve to the hardware device. This class
+ * doesn't know anything about the semantics of the data it holds, it just
+ * serves merkle data. It doesn't even know in what context it is being
+ * executed, ie SignPsbt, getWalletAddress, etc.
+ *
+ * If the command yelds results to the client, as signPsbt does, the yielded
+ * data will be accessible after the command completed by calling getYielded(),
+ * which will return the yields in the same order as they came in.
+ */
 export class ClientCommandInterpreter {
   private roots: Map<string, Merkle> = new Map();
   private preimages: Map<string, Buffer> = new Map();
@@ -257,9 +273,9 @@ export class ClientCommandInterpreter {
 
   private commands: Map<ClientCommandCode, ClientCommand> = new Map();
 
-  constructor() {
+  constructor(progressCallback: () => void) {
     const commands = [
-      new YieldCommand(this.yielded),
+      new YieldCommand(this.yielded, progressCallback),
       new GetPreimageCommand(this.preimages, this.queue),
       new GetMerkleLeafIndexCommand(this.roots),
       new GetMerkleLeafProofCommand(this.roots, this.queue),

package/src/newops/merkelizedPsbt.ts

@@ -1,6 +1,17 @@
 import { MerkleMap } from "./merkleMap";
 import { PsbtV2 } from "./psbtv2";
 
+/**
+ * This class merkelizes a PSBTv2, by merkelizing the different
+ * maps of the psbt. This is used during the transaction signing process,
+ * where the hardware app can request specific parts of the psbt from the
+ * client code and be sure that the response data actually belong to the psbt.
+ * The reason for this is the limited amount of memory available to the app,
+ * so it can't always store the full psbt in memory.
+ *
+ * The signing process is documented at
+ * https://github.com/LedgerHQ/app-bitcoin-new/blob/master/doc/bitcoin.md#sign_psbt
+ */
 export class MerkelizedPsbt extends PsbtV2 {
   public globalMerkleMap: MerkleMap;
   public inputMerkleMaps: MerkleMap[] = [];

package/src/newops/merkle.ts

@@ -1,5 +1,10 @@
 import { crypto } from "bitcoinjs-lib";
 
+/**
+ * This class implements the merkle tree used by Ledger Bitcoin app v2+,
+ * which is documented at
+ * https://github.com/LedgerHQ/app-bitcoin-new/blob/master/doc/merkle.md
+ */
 export class Merkle {
   private leaves: Buffer[];
   private rootNode: Node;

package/src/newops/merkleMap.ts

@@ -1,6 +1,16 @@
 import { createVarint } from "../varint";
 import { hashLeaf, Merkle } from "./merkle";
 
+/**
+ * This implements "Merkelized Maps", documented at
+ * https://github.com/LedgerHQ/app-bitcoin-new/blob/master/doc/merkle.md#merkleized-maps
+ *
+ * A merkelized map consist of two merkle trees, one for the keys of
+ * a map and one for the values of the same map, thus the two merkle
+ * trees have the same shape. The commitment is the number elements
+ * in the map followed by the keys' merkle root followed by the
+ * values' merkle root.
+ */
 export class MerkleMap {
   keys: Buffer[];
   keysTree: Merkle;

package/src/newops/policy.ts

@@ -1,7 +1,7 @@
+import { crypto } from "bitcoinjs-lib";
 import { pathArrayToString } from "../bip32";
 import { BufferWriter } from "../buffertools";
-import { crypto } from "bitcoinjs-lib";
-import { Merkle, hashLeaf } from "./merkle";
+import { hashLeaf, Merkle } from "./merkle";
 
 export type DefaultDescriptorTemplate =
   | "pkh(@0)"
@@ -9,6 +9,14 @@ export type DefaultDescriptorTemplate =
   | "wpkh(@0)"
   | "tr(@0)";
 
+/**
+ * The Bitcon hardware app uses a descriptors-like thing to describe
+ * how to construct output scripts from keys. A "Wallet Policy" consists
+ * of a "Descriptor Template" and a list of "keys". A key is basically
+ * a serialized BIP32 extended public key with some added derivation path
+ * information. This is documented at
+ * https://github.com/LedgerHQ/app-bitcoin-new/blob/master/doc/wallet.md
+ */
 export class WalletPolicy {
   descriptorTemplate: string;
   keys: string[];

package/src/newops/psbtExtractor.ts

@@ -1,6 +1,12 @@
 import { BufferWriter } from "../buffertools";
 import { PsbtV2 } from "./psbtv2";
 
+/**
+ * This implements the "Transaction Extractor" role of BIP370 (PSBTv2
+ * https://github.com/bitcoin/bips/blob/master/bip-0370.mediawiki#transaction-extractor). However
+ * the role is partially documented in BIP174 (PSBTv0
+ * https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki#transaction-extractor).
+ */
 export function extract(psbt: PsbtV2): Buffer {
   const tx = new BufferWriter();
   tx.writeUInt32(psbt.getGlobalTxVersion());

package/src/newops/psbtFinalizer.ts

@@ -2,8 +2,18 @@ import { BufferWriter } from "../buffertools";
 import { psbtIn, PsbtV2 } from "./psbtv2";
 
 /**
+ * This roughly implements the "input finalizer" role of BIP370 (PSBTv2
+ * https://github.com/bitcoin/bips/blob/master/bip-0370.mediawiki). However
+ * the role is documented in BIP174 (PSBTv0
+ * https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki).
  *
- * @param psbt The psbt with all signatures added as partial sigs, either through PSBT_IN_PARTIAL_SIG or PSBT_IN_TAP_KEY_SIG
+ * Verify that all inputs have a signature, and set inputFinalScriptwitness
+ * and/or inputFinalScriptSig depending on the type of the spent outputs. Clean
+ * fields that aren't useful anymore, partial signatures, redeem script and
+ * derivation paths.
+ *
+ * @param psbt The psbt with all signatures added as partial sigs, either
+ * through PSBT_IN_PARTIAL_SIG or PSBT_IN_TAP_KEY_SIG
  */
 export function finalize(psbt: PsbtV2): void {
   // First check that each input has a signature
@@ -63,19 +73,25 @@ export function finalize(psbt: PsbtV2): void {
       if (!signature) {
         throw Error("No taproot signature found");
       }
-      if (signature.length != 64) {
+      if (signature.length != 64 && signature.length != 65) {
         throw Error("Unexpected length of schnorr signature.");
       }
       const witnessBuf = new BufferWriter();
       witnessBuf.writeVarInt(1);
-      witnessBuf.writeVarInt(64);
-      witnessBuf.writeSlice(signature);
+      witnessBuf.writeVarSlice(signature);
       psbt.setInputFinalScriptwitness(i, witnessBuf.buffer());
     }
     clearFinalizedInput(psbt, i);
   }
 }
 
+/**
+ * Deletes fields that are no longer neccesary from the psbt.
+ *
+ * Note, the spec doesn't say anything about removing ouput fields
+ * like PSBT_OUT_BIP32_DERIVATION_PATH and others, so we keep them
+ * without actually knowing why. I think we should remove them too.
+ */
 function clearFinalizedInput(psbt: PsbtV2, inputIndex: number) {
   const keyTypes = [
     psbtIn.BIP32_DERIVATION,
@@ -94,6 +110,14 @@ function clearFinalizedInput(psbt: PsbtV2, inputIndex: number) {
   psbt.deleteInputEntries(inputIndex, keyTypes);
 }
 
+/**
+ * Writes a script push operation to buf, which looks different
+ * depending on the size of the data. See
+ * https://en.bitcoin.it/wiki/Script#Constants
+ *
+ * @param buf the BufferWriter to write to
+ * @param data the Buffer to be pushed.
+ */
 function writePush(buf: BufferWriter, data: Buffer) {
   if (data.length <= 75) {
     buf.writeUInt8(data.length);

package/src/newops/psbtv2.ts

@@ -14,6 +14,7 @@ export enum psbtIn {
   NON_WITNESS_UTXO = 0x00,
   WITNESS_UTXO = 0x01,
   PARTIAL_SIG = 0x02,
+  SIGHASH_TYPE = 0x03,
   REDEEM_SCRIPT = 0x04,
   BIP32_DERIVATION = 0x06,
   FINAL_SCRIPTSIG = 0x07,
@@ -36,6 +37,24 @@ const PSBT_MAGIC_BYTES = Buffer.of(0x70, 0x73, 0x62, 0x74, 0xff);
 
 export class NoSuchEntry extends Error {}
 
+/**
+ * Implements Partially Signed Bitcoin Transaction version 2, BIP370, as
+ * documented at https://github.com/bitcoin/bips/blob/master/bip-0370.mediawiki
+ * and https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki
+ *
+ * A psbt is a data structure that can carry all relevant information about a
+ * transaction through all stages of the signing process. From constructing an
+ * unsigned transaction to extracting the final serialized transaction ready for
+ * broadcast.
+ *
+ * This implementation is limited to what's needed in ledgerjs to carry out its
+ * duties, which means that support for features like multisig or taproot script
+ * path spending are not implemented. Specifically, it supports p2pkh,
+ * p2wpkhWrappedInP2sh, p2wpkh and p2tr key path spending.
+ *
+ * This class is made purposefully dumb, so it's easy to add support for
+ * complemantary fields as needed in the future.
+ */
 export class PsbtV2 {
   protected globalMap: Map<string, Buffer> = new Map();
   protected inputMaps: Map<string, Buffer>[] = [];
@@ -110,6 +129,14 @@ export class PsbtV2 {
   getInputPartialSig(inputIndex: number, pubkey: Buffer): Buffer | undefined {
     return this.getInputOptional(inputIndex, psbtIn.PARTIAL_SIG, pubkey);
   }
+  setInputSighashType(inputIndex: number, sigHashtype: number) {
+    this.setInput(inputIndex, psbtIn.SIGHASH_TYPE, b(), uint32LE(sigHashtype));
+  }
+  getInputSighashType(inputIndex: number): number | undefined {
+    const result = this.getInputOptional(inputIndex, psbtIn.SIGHASH_TYPE, b());
+    if (!result) return undefined;
+    return result.readUInt32LE(0);
+  }
   setInputRedeemScript(inputIndex: number, redeemScript: Buffer) {
     this.setInput(inputIndex, psbtIn.REDEEM_SCRIPT, b(), redeemScript);
   }
@@ -122,6 +149,8 @@ export class PsbtV2 {
     masterFingerprint: Buffer,
     path: number[]
   ) {
+    if (pubkey.length != 33)
+      throw new Error("Invalid pubkey length: " + pubkey.length);
     this.setInput(
       inputIndex,
       psbtIn.BIP32_DERIVATION,
@@ -188,6 +217,8 @@ export class PsbtV2 {
     masterFingerprint: Buffer,
     path: number[]
   ) {
+    if (pubkey.length != 32)
+      throw new Error("Invalid pubkey length: " + pubkey.length);
     const buf = this.encodeTapBip32Derivation(hashes, masterFingerprint, path);
     this.setInput(inputIndex, psbtIn.TAP_BIP32_DERIVATION, pubkey, buf);
   }
@@ -357,15 +388,6 @@ export class PsbtV2 {
   ) {
     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)!;
   }
@@ -387,12 +409,14 @@ export class PsbtV2 {
   private getOutput(index: number, keyType: KeyType, keyData: Buffer): Buffer {
     return get(this.outputMaps[index], keyType, keyData, false)!;
   }
-  private getOutputOptional(
+  private getMap(
     index: number,
-    keyType: KeyType,
-    keyData: Buffer
-  ): Buffer | undefined {
-    return get(this.outputMaps[index], keyType, keyData, true);
+    maps: Map<string, Buffer>[]
+  ): Map<string, Buffer> {
+    if (maps[index]) {
+      return maps[index];
+    }
+    return (maps[index] = new Map());
   }
   private encodeBip32Derivation(masterFingerprint: Buffer, path: number[]) {
     const buf = new BufferWriter();

package/tests/Btc.integration.test.ts

@@ -1,11 +1,22 @@
 // import Transport from "@ledgerhq/hw-transport-node-hid";
+import Transport from "@ledgerhq/hw-transport";
 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 Btc from "../src/Btc";
+import BtcNew from "../src/BtcNew";
 import { compressPublicKey } from "../src/compressPublicKey";
-import Transport from "@ledgerhq/hw-transport";
+import { AppClient } from "../src/newops/appClient";
+import { runSignTransaction, TestingClient } from "./newops/integrationtools";
+import {
+  CoreTx,
+  p2wpkhWrapped2in2out as p2wpkhWrapped2inWithChange,
+  speculosP2pkh,
+  speculosP2pkhWithChange,
+  speculosP2tr,
+  speculosP2trWithChange,
+  speculosP2wpkh2inWithChange,
+} from "./newops/testtx";
+import { approveTransaction } from "./speculosclient";
 
 const xpubs = {
   "m/44'/1'/0'":
@@ -23,23 +34,122 @@ const xpubs = {
   "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 () => {
+
+// async function listAddresses(paths: string[], addressFormat: AddressFormat) {
+//   const tr = await transport();
+//   const client = new AppClient(tr);
+//   const btc = new BtcNew(client);
+//   let result = "";
+//   for (let i = 0; i < paths.length; i++) {
+//     const addr = await btc.getWalletPublicKey(paths[i], {
+//       format: addressFormat,
+//     });
+//     result += paths[i] + ": " + addr.bitcoinAddress + "\n";
+//   }
+//   await tr.close();
+//   console.log(result);
+// }
+
+jest.setTimeout(1000000);
+test("Speculos p2pkh", async () => {
+  const ins = ["m/44'/1'/0'/0/0"];
+  const tx = await testSigning(speculosP2pkh, { ins });
+  expect(tx).toEqual(speculosP2pkh.hex);
+});
+
+test("Speculos p2tr", async () => {
+  const ins = ["m/86'/1'/0'/0/0"];
+  const tx = await testSigning(speculosP2tr, { ins });
+  checkIgnoreWitness(speculosP2tr, tx);
+});
+
+test("Speculos p2tr with change", async () => {
+  const ins = ["m/86'/1'/0'/0/1"];
+  const out = "m/86'/1'/0'/1/0";
+  const tx = await testSigning(speculosP2trWithChange, { ins, out });
+  checkIgnoreWitness(speculosP2trWithChange, tx);
+});
+
+test("Speculos p2wpkhWrapped with change", async () => {
+  const ins = ["m/49'/1'/0'/1/0", "m/49'/1'/0'/0/2"];
+  const out = "m/49'/1'/0'/1/1";
+  const tx = await testSigning(p2wpkhWrapped2inWithChange, { ins, out });
+  expect(tx).toEqual(p2wpkhWrapped2inWithChange.hex);
+});
+
+test("Speculoas p2wpkh with change", async () => {
+  const ins = ["m/84'/1'/0'/0/1", "m/84'/1'/0'/1/4"];
+  const out = "m/84'/1'/0'/1/5";
+  const tx = await testSigning(speculosP2wpkh2inWithChange, { ins, out });
+  expect(tx).toEqual(speculosP2wpkh2inWithChange.hex);
+});
+
+test("Speculos p2pkh with change", async () => {
+  const ins = ["m/44'/1'/0'/1/0", "m/44'/1'/0'/0/3"];
+  const out = "m/44'/1'/0'/1/2";
+  // Pay 0.005 tBTC to mz5vLWdM1wHVGSmXUkhKVvZbJ2g4epMXSm
+  const tx = await testSigning(speculosP2pkhWithChange, { ins, out });
+  expect(tx).toEqual(speculosP2pkhWithChange.hex);
+});
+
+async function testSigning(
+  testTx: CoreTx,
+  paths: { ins: string[]; out?: string }
+): Promise<string> {
+  let tr;
+  try {
+    tr = await transport();
+  } catch (e) {
+    console.error("FIXME: SPECULOS TEST IGNORED BECAUSE INSTANCE IS NOT UP", e);
+    return testTx.hex;
+  }
+  const client = new TestingClient(tr);
+  // Automatically accept a transaction
+  //acceptTx(tr, testTx.vout.length - (paths.out ? 1 : 0));
+  await approveTransaction();
+  const tx = await runSignTransaction(testTx, paths, client, tr);
+  await tr.close();
+  return tx;
+}
+
+/**
+ * Schnorr signatures use a true random nonce, which makes two
+ * signatures of the same message and key different, so we can't
+ * compare the witness data in full, hence this function.
+ */
+function checkIgnoreWitness(testTx: CoreTx, actualTx: string) {
+  expect(actualTx.length).toEqual(testTx.hex.length);
+  let expBaseTx = testTx.hex;
+  let actBaseTx = actualTx;
+  // Clean out the witness data items, but not the witness as a whole,
+  // meaning we will compare number of witness items for example.
+  testTx.vin.forEach((input) => {
+    if (!input.txinwitness) {
+      return;
+    }
+    input.txinwitness.forEach((value) => {
+      const index = expBaseTx.indexOf(value);
+      expBaseTx =
+        expBaseTx.substring(0, index) +
+        expBaseTx.substring(index + value.length);
+      actBaseTx =
+        actBaseTx.substring(0, index) +
+        actBaseTx.substring(index + value.length);
+    });
+  });
+  expect(actBaseTx).toEqual(expBaseTx);
+}
+
+test("getWalletPublicKey BtcOld", async () => {
   await runGetWalletPublicKey("old");
 });
 
-test("Basic happypath BtcNew test", async () => {
+test("getWalletPublicKey BtcNew", async () => {
   await runGetWalletPublicKey("new");
 });
 
-async function transport() {
-  return await SpeculosTransport.open({ apduPort: 9999 });
+async function transport(): Promise<SpeculosTransport> {
+  return await SpeculosTransport.open({ apduPort: 9999, buttonPort: 9998 });
 }
 
 async function impl(

package/tests/Btc.test.ts

@@ -1,8 +1,13 @@
+import Transport from "@ledgerhq/hw-transport";
 import {
   openTransportReplayer,
   RecordStore,
 } from "@ledgerhq/hw-transport-mocker";
 import Btc from "../src/Btc";
+import BtcNew from "../src/BtcNew";
+import BtcOld, { AddressFormat } from "../src/BtcOld";
+import { AppAndVersion, getAppAndVersion } from "../src/getAppAndVersion";
+import { TestingClient } from "./newops/integrationtools";
 
 test("btc.getWalletXpub", async () => {
   /*
@@ -421,3 +426,81 @@ test("signMessage", async () => {
     s: "385d83273c9d03c469596292fb354b07d193034f83c2633a4c1f057838e12a5b",
   });
 });
+
+function testBackend(s: string): any {
+  return async () => {
+    return { publicKey: s, bitcoinAddress: "", chainCode: "" };
+  }
+}
+
+class TestBtc extends Btc {
+  n: BtcNew;
+  o: BtcOld;
+  constructor(public tr: Transport) {
+    super(tr);
+    this.n = new BtcNew(new TestingClient(tr));
+    this.n.getWalletPublicKey = testBackend("new");
+    this.o = new BtcOld(tr);
+    this.o.getWalletPublicKey = testBackend("old");
+  }
+  protected new(): BtcNew {
+    return this.n;
+  }
+  protected old(): BtcOld {
+    return this.o;
+  }
+}
+
+// test.each`
+// a    | b    | expected
+// ${1} | ${1} | ${2}
+// ${1} | ${2} | ${3}
+// ${2} | ${1} | ${3}
+// `('returns $expected when $a is added $c', ({ a, c, expected }) => {
+//   expect(a + c).toBe(expected);
+// });
+
+test.each`
+app          | ver          | path             | format       | display | exp
+${"Bitcoin"} | ${"1.99.99"} | ${"m/44'/0'/1'"} | ${"bech32m"} | ${false} | ${""}
+${"Bitcoin"} | ${"1.99.99"} | ${"m/44'/0'"} | ${"bech32m"} | ${false} | ${""}
+${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'/1'"} | ${"bech32m"} | ${false} | ${"new"}
+${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'"} | ${"bech32m"} | ${false} | ${"new"}
+${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'/1'"} | ${"bech32"} | ${false} | ${"new"}
+${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'"} | ${"bech32"} | ${undefined} | ${"old"}   
+${"Bitcoin"} | ${"2.0.0-alpha1"} | ${"m/44'/0'"} | ${"bech32"} | ${true} | ${"new"}   
+`("dispatch $app $ver $path $format $display to $exp", async ({ app, ver, path, format, display, exp }) => {
+  const appName = Buffer.of(app.length)
+    .toString("hex")
+    .concat(Buffer.from(app, "ascii").toString("hex"));
+  const appVersion = Buffer.of(ver.length)
+    .toString("hex")
+    .concat(Buffer.from(ver, "ascii").toString("hex"));
+  const resp = `01${appName}${appVersion}01029000`;
+  const tr = await openTransportReplayer(RecordStore.fromString(`=> b001000000\n <= ${resp}`));
+  const btc = new TestBtc(tr);
+  try {
+    const key = await btc.getWalletPublicKey(path, { format: format, verify: display });
+    if (exp === "") {
+      expect(1).toEqual(0); // Allways fail. Don't know how to do that properly
+    }
+    expect(key.publicKey).toEqual(exp);
+  } catch (e: any) {
+    if (exp != "") {
+      throw e;
+    }
+    expect(exp).toEqual("");
+  }
+})
+
+// test("getWalletPublicKey compatibility for internal hardened keys", async () => {
+//   await testDispatch("Bitcoin", "1.99.99", "m/44'/0'/1'", "bech32m", "");
+//   await testDispatch("Bitcoin", "1.99.99", "m/44'/0'", "bech32m", "");
+//   await testDispatch("Bitcoin", "2.0.0-alpha1", "m/44'/0'/1'", "bech32m", "new");
+//   await testDispatch("Bitcoin", "2.0.0-alpha1", "m/44'/0'", "bech32m", "new");
+//   await testDispatch("Bitcoin", "2.0.0-alpha1", "m/44'/0'/1'", "bech32", "new");
+//   await testDispatch("Bitcoin", "2.0.0-alpha1", "m/44'/0'", "bech32", "old");
+// });
+
+async function testDispatch(name: string, version: string, path: string, addressFormat: AddressFormat | undefined, exp: string): Promise<void> {
+}