@sidhujag/sysweb3-keyring 1.0.544 → 1.0.547

package/src/ledger/bitcoin_client/lib/clientCommands.ts

@@ -0,0 +1,356 @@
+/* eslint-disable camelcase */
+import CryptoJS from 'crypto-js';
+
+// Helper function for SHA256 hashing (browser-compatible)
+function sha256(data: Buffer): Buffer {
+  const wordArray = CryptoJS.lib.WordArray.create(data);
+  const hash = CryptoJS.SHA256(wordArray);
+  const hashBuffer = Buffer.from(hash.toString(CryptoJS.enc.Hex), 'hex');
+  return hashBuffer;
+}
+
+import { BufferReader } from './buffertools';
+import { hashLeaf, Merkle } from './merkle';
+import { MerkleMap } from './merkleMap';
+import { WalletPolicy } from './policy';
+import { createVarint, sanitizeBigintToNumber } from './varint';
+
+enum ClientCommandCode {
+  YIELD = 0x10,
+  GET_PREIMAGE = 0x40,
+  GET_MERKLE_LEAF_PROOF = 0x41,
+  GET_MERKLE_LEAF_INDEX = 0x42,
+  GET_MORE_ELEMENTS = 0xa0,
+}
+
+abstract class ClientCommand {
+  abstract code: ClientCommandCode;
+  abstract execute(request: Buffer): Buffer;
+}
+
+export class YieldCommand extends ClientCommand {
+  private results: Buffer[];
+
+  readonly code = ClientCommandCode.YIELD;
+
+  constructor(
+    results: Buffer[],
+    private readonly progressCallback?: () => void
+  ) {
+    super();
+    this.results = results;
+  }
+
+  execute(request: Buffer): Buffer {
+    this.results.push(Buffer.from(request.subarray(1)));
+    if (this.progressCallback) {
+      this.progressCallback();
+    }
+    return Buffer.from('');
+  }
+}
+
+export class GetPreimageCommand extends ClientCommand {
+  private readonly known_preimages: ReadonlyMap<string, Buffer>;
+  private queue: Buffer[];
+
+  readonly code = ClientCommandCode.GET_PREIMAGE;
+
+  constructor(known_preimages: ReadonlyMap<string, Buffer>, queue: Buffer[]) {
+    super();
+    this.known_preimages = known_preimages;
+    this.queue = queue;
+  }
+
+  execute(request: Buffer): Buffer {
+    const req = Buffer.from(request.subarray(1));
+
+    // we expect no more data to read
+    if (req.length != 1 + 32) {
+      throw new Error('Invalid request, unexpected trailing data');
+    }
+
+    if (req[0] != 0) {
+      throw new Error('Unsupported request, the first byte should be 0');
+    }
+
+    // read the hash
+    const hash = Buffer.alloc(32);
+    for (let i = 0; i < 32; i++) {
+      hash[i] = req[1 + i];
+    }
+    const req_hash_hex = hash.toString('hex');
+
+    const known_preimage = this.known_preimages.get(req_hash_hex);
+    if (known_preimage != undefined) {
+      const preimage_len_varint = createVarint(known_preimage.length);
+
+      // We can send at most 255 - len(preimage_len_out) - 1 bytes in a single message;
+      // the rest will be stored in the queue for GET_MORE_ELEMENTS
+      const max_payload_size = 255 - preimage_len_varint.length - 1;
+
+      const payload_size = Math.min(max_payload_size, known_preimage.length);
+
+      if (payload_size < known_preimage.length) {
+        for (let i = payload_size; i < known_preimage.length; i++) {
+          this.queue.push(Buffer.from([known_preimage[i]]));
+        }
+      }
+
+      return Buffer.concat([
+        preimage_len_varint,
+        Buffer.from([payload_size]),
+        Buffer.from(known_preimage.subarray(0, payload_size)),
+      ]);
+    }
+
+    throw Error(`Requested unknown preimage for: ${req_hash_hex}`);
+  }
+}
+
+export class GetMerkleLeafProofCommand extends ClientCommand {
+  private readonly known_trees: ReadonlyMap<string, Merkle>;
+  private queue: Buffer[];
+
+  readonly code = ClientCommandCode.GET_MERKLE_LEAF_PROOF;
+
+  constructor(known_trees: ReadonlyMap<string, Merkle>, queue: Buffer[]) {
+    super();
+    this.known_trees = known_trees;
+    this.queue = queue;
+  }
+
+  execute(request: Buffer): Buffer {
+    const req = Buffer.from(request.subarray(1));
+
+    if (req.length < 32 + 1 + 1) {
+      throw new Error('Invalid request, expected at least 34 bytes');
+    }
+
+    const reqBuf = new BufferReader(req);
+    const hash = reqBuf.readSlice(32);
+    const hash_hex = hash.toString('hex');
+
+    let tree_size: number;
+    let leaf_index: number;
+    try {
+      tree_size = sanitizeBigintToNumber(reqBuf.readVarInt());
+      leaf_index = sanitizeBigintToNumber(reqBuf.readVarInt());
+    } catch (e) {
+      throw new Error(
+        "Invalid request, couldn't parse tree_size or leaf_index"
+      );
+    }
+
+    const mt = this.known_trees.get(hash_hex);
+    if (!mt) {
+      throw Error(`Requested Merkle leaf proof for unknown tree: ${hash_hex}`);
+    }
+
+    if (leaf_index >= tree_size || mt.size() != tree_size) {
+      throw Error('Invalid index or tree size.');
+    }
+
+    if (this.queue.length != 0) {
+      throw Error(
+        'This command should not execute when the queue is not empty.'
+      );
+    }
+
+    const proof = mt.getProof(leaf_index);
+
+    const n_response_elements = Math.min(
+      Math.floor((255 - 32 - 1 - 1) / 32),
+      proof.length
+    );
+    const n_leftover_elements = proof.length - n_response_elements;
+
+    // Add to the queue any proof elements that do not fit the response
+    if (n_leftover_elements > 0) {
+      this.queue.push(...proof.slice(-n_leftover_elements));
+    }
+
+    return Buffer.concat([
+      mt.getLeafHash(leaf_index),
+      Buffer.from([proof.length]),
+      Buffer.from([n_response_elements]),
+      ...proof.slice(0, n_response_elements),
+    ]);
+  }
+}
+
+export class GetMerkleLeafIndexCommand extends ClientCommand {
+  private readonly known_trees: ReadonlyMap<string, Merkle>;
+
+  readonly code = ClientCommandCode.GET_MERKLE_LEAF_INDEX;
+
+  constructor(known_trees: ReadonlyMap<string, Merkle>) {
+    super();
+    this.known_trees = known_trees;
+  }
+
+  execute(request: Buffer): Buffer {
+    const req = Buffer.from(request.subarray(1));
+
+    if (req.length != 32 + 32) {
+      throw new Error('Invalid request, unexpected trailing data');
+    }
+
+    // read the root hash
+    const root_hash = Buffer.alloc(32);
+    for (let i = 0; i < 32; i++) {
+      root_hash[i] = req.readUInt8(i);
+    }
+    const root_hash_hex = root_hash.toString('hex');
+
+    // read the leaf hash
+    const leef_hash = Buffer.alloc(32);
+    for (let i = 0; i < 32; i++) {
+      leef_hash[i] = req.readUInt8(32 + i);
+    }
+    const leef_hash_hex = leef_hash.toString('hex');
+
+    const mt = this.known_trees.get(root_hash_hex);
+    if (!mt) {
+      throw Error(
+        `Requested Merkle leaf index for unknown root: ${root_hash_hex}`
+      );
+    }
+
+    let leaf_index = 0;
+    let found = 0;
+    for (let i = 0; i < mt.size(); i++) {
+      if (mt.getLeafHash(i).toString('hex') == leef_hash_hex) {
+        found = 1;
+        leaf_index = i;
+        break;
+      }
+    }
+    return Buffer.concat([Buffer.from([found]), createVarint(leaf_index)]);
+  }
+}
+
+export class GetMoreElementsCommand extends ClientCommand {
+  queue: Buffer[];
+
+  readonly code = ClientCommandCode.GET_MORE_ELEMENTS;
+
+  constructor(queue: Buffer[]) {
+    super();
+    this.queue = queue;
+  }
+
+  execute(request: Buffer): Buffer {
+    if (request.length != 1) {
+      throw new Error('Invalid request, unexpected trailing data');
+    }
+
+    if (this.queue.length === 0) {
+      throw new Error('No elements to get');
+    }
+
+    // all elements should have the same length
+    const element_len = this.queue[0].length;
+    if (this.queue.some((el) => el.length != element_len)) {
+      throw new Error(
+        'The queue contains elements with different byte length, which is not expected'
+      );
+    }
+
+    const max_elements = Math.floor(253 / element_len);
+    const n_returned_elements = Math.min(max_elements, this.queue.length);
+
+    const returned_elements = this.queue.splice(0, n_returned_elements);
+
+    return Buffer.concat([
+      Buffer.from([n_returned_elements]),
+      Buffer.from([element_len]),
+      ...returned_elements,
+    ]);
+  }
+}
+
+/**
+ * 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 readonly roots: Map<string, Merkle> = new Map();
+  private readonly preimages: Map<string, Buffer> = new Map();
+
+  private yielded: Buffer[] = [];
+
+  private queue: Buffer[] = [];
+
+  private readonly commands: Map<ClientCommandCode, ClientCommand> = new Map();
+
+  constructor(progressCallback?: () => void) {
+    const commands = [
+      new YieldCommand(this.yielded, progressCallback),
+      new GetPreimageCommand(this.preimages, this.queue),
+      new GetMerkleLeafIndexCommand(this.roots),
+      new GetMerkleLeafProofCommand(this.roots, this.queue),
+      new GetMoreElementsCommand(this.queue),
+    ];
+
+    for (const cmd of commands) {
+      if (this.commands.has(cmd.code)) {
+        throw new Error(`Multiple commands with code ${cmd.code}`);
+      }
+      this.commands.set(cmd.code, cmd);
+    }
+  }
+
+  getYielded(): readonly Buffer[] {
+    return this.yielded;
+  }
+
+  addKnownPreimage(preimage: Buffer): void {
+    this.preimages.set(sha256(preimage).toString('hex'), preimage);
+  }
+
+  addKnownList(elements: readonly Buffer[]): void {
+    for (const el of elements) {
+      const preimage = Buffer.concat([Buffer.from([0]), el]);
+      this.addKnownPreimage(preimage);
+    }
+    const mt = new Merkle(elements.map((el) => hashLeaf(el)));
+    this.roots.set(mt.getRoot().toString('hex'), mt);
+  }
+
+  addKnownMapping(mm: MerkleMap): void {
+    this.addKnownList(mm.keys);
+    this.addKnownList(mm.values);
+  }
+
+  addKnownWalletPolicy(wp: WalletPolicy): void {
+    this.addKnownPreimage(wp.serialize());
+    this.addKnownList(wp.keys.map((k) => Buffer.from(k, 'ascii')));
+    this.addKnownPreimage(Buffer.from(wp.descriptorTemplate));
+  }
+
+  execute(request: Buffer): Buffer {
+    if (request.length == 0) {
+      throw new Error('Unexpected empty command');
+    }
+
+    const cmdCode = request[0];
+    const cmd = this.commands.get(cmdCode);
+    if (!cmd) {
+      throw new Error(`Unexpected command code ${cmdCode}`);
+    }
+
+    return cmd.execute(request);
+  }
+}

package/src/ledger/bitcoin_client/lib/constants.ts

@@ -0,0 +1,12 @@
+export const MAX_SCRIPT_BLOCK = 50;
+export const DEFAULT_VERSION = 1;
+export const DEFAULT_LOCKTIME = 0;
+export const DEFAULT_SEQUENCE = 0xffffffff;
+export const SIGHASH_ALL = 1;
+export const OP_DUP = 0x76;
+export const OP_HASH160 = 0xa9;
+export const HASH_SIZE = 0x14;
+export const OP_EQUAL = 0x87;
+export const OP_EQUALVERIFY = 0x88;
+export const OP_CHECKSIG = 0xac;
+export const OP_RETURN = 0x6a;

package/src/ledger/bitcoin_client/lib/merkelizedPsbt.ts

@@ -0,0 +1,65 @@
+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 readonly globalMerkleMap: MerkleMap;
+  public inputMerkleMaps: MerkleMap[] = [];
+  public outputMerkleMaps: MerkleMap[] = [];
+  public inputMapCommitments: Buffer[];
+  public outputMapCommitments: Buffer[];
+  constructor(psbt: PsbtV2) {
+    super();
+    psbt.copy(this);
+    this.globalMerkleMap = MerkelizedPsbt.createMerkleMap(this.globalMap);
+
+    for (let i = 0; i < this.getGlobalInputCount(); i++) {
+      this.inputMerkleMaps.push(
+        MerkelizedPsbt.createMerkleMap(this.inputMaps[i])
+      );
+    }
+    this.inputMapCommitments = [...this.inputMerkleMaps.values()].map((v) =>
+      v.commitment()
+    );
+
+    for (let i = 0; i < this.getGlobalOutputCount(); i++) {
+      this.outputMerkleMaps.push(
+        MerkelizedPsbt.createMerkleMap(this.outputMaps[i])
+      );
+    }
+    this.outputMapCommitments = [...this.outputMerkleMaps.values()].map((v) =>
+      v.commitment()
+    );
+  }
+  // These public functions are for MerkelizedPsbt.
+  getGlobalSize(): number {
+    return this.globalMap.size;
+  }
+  getGlobalKeysValuesRoot(): Buffer {
+    return this.globalMerkleMap.commitment();
+  }
+
+  private static createMerkleMap(map: ReadonlyMap<string, Buffer>): MerkleMap {
+    const sortedKeysStrings = [...map.keys()].sort();
+    const values = sortedKeysStrings.map((k) => {
+      const v = map.get(k);
+      if (!v) {
+        throw new Error('No value for key ' + k);
+      }
+      return v;
+    });
+    const sortedKeys = sortedKeysStrings.map((k) => Buffer.from(k, 'hex'));
+
+    return new MerkleMap(sortedKeys, values);
+  }
+}

package/src/ledger/bitcoin_client/lib/merkle.ts

@@ -0,0 +1,136 @@
+import CryptoJS from 'crypto-js';
+
+// Helper function for SHA256 hashing (browser-compatible)
+function sha256(data: Buffer): Buffer {
+  const wordArray = CryptoJS.lib.WordArray.create(data);
+  const hash = CryptoJS.SHA256(wordArray);
+  const hashBuffer = Buffer.from(hash.toString(CryptoJS.enc.Hex), 'hex');
+  return hashBuffer;
+}
+
+/**
+ * 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;
+  private leafNodes: Node[];
+  private h: (buf: Buffer) => Buffer;
+  constructor(leaves: Buffer[], hasher: (buf: Buffer) => Buffer = sha256) {
+    this.leaves = leaves;
+    this.h = hasher;
+    const nodes = this.calculateRoot(leaves);
+    this.rootNode = nodes.root;
+    this.leafNodes = nodes.leaves;
+  }
+  getRoot(): Buffer {
+    return this.rootNode.hash;
+  }
+  size(): number {
+    return this.leaves.length;
+  }
+  getLeaves(): Buffer[] {
+    return this.leaves;
+  }
+  getLeafHash(index: number): Buffer {
+    return this.leafNodes[index].hash;
+  }
+  getProof(index: number): Buffer[] {
+    if (index >= this.leaves.length) throw Error('Index out of bounds');
+    return proveNode(this.leafNodes[index]);
+  }
+
+  calculateRoot(leaves: Buffer[]): {
+    leaves: Node[];
+    root: Node;
+  } {
+    const n = leaves.length;
+    if (n == 0) {
+      return {
+        root: new Node(undefined, undefined, Buffer.alloc(32, 0)),
+        leaves: [],
+      };
+    }
+    if (n == 1) {
+      const newNode = new Node(undefined, undefined, leaves[0]);
+      return { root: newNode, leaves: [newNode] };
+    }
+    const leftCount = highestPowerOf2LessThan(n);
+    const leftBranch = this.calculateRoot(leaves.slice(0, leftCount));
+    const rightBranch = this.calculateRoot(leaves.slice(leftCount));
+    const leftChild = leftBranch.root;
+    const rightChild = rightBranch.root;
+    const hash = this.hashNode(leftChild.hash, rightChild.hash);
+    const node = new Node(leftChild, rightChild, hash);
+    leftChild.parent = node;
+    rightChild.parent = node;
+    return { root: node, leaves: leftBranch.leaves.concat(rightBranch.leaves) };
+  }
+
+  hashNode(left: Buffer, right: Buffer): Buffer {
+    return this.h(Buffer.concat([Buffer.from([1]), left, right]));
+  }
+}
+
+export function hashLeaf(
+  buf: Buffer,
+  hashFunction: (buf: Buffer) => Buffer = sha256
+): Buffer {
+  return hashConcat(Buffer.from([0]), buf, hashFunction);
+}
+
+function hashConcat(
+  bufA: Buffer,
+  bufB: Buffer,
+  hashFunction: (buf: Buffer) => Buffer
+): Buffer {
+  return hashFunction(Buffer.concat([bufA, bufB]));
+}
+
+class Node {
+  leftChild?: Node;
+  rightChild?: Node;
+  parent?: Node;
+  hash: Buffer;
+  constructor(left: Node | undefined, right: Node | undefined, hash: Buffer) {
+    this.leftChild = left;
+    this.rightChild = right;
+    this.hash = hash;
+  }
+  isLeaf(): boolean {
+    return this.leftChild == undefined;
+  }
+}
+
+function proveNode(node: Node): Buffer[] {
+  if (!node.parent) {
+    return [];
+  }
+  if (node.parent.leftChild == node) {
+    if (!node.parent.rightChild) {
+      throw new Error('Expected right child to exist');
+    }
+    return [node.parent.rightChild.hash, ...proveNode(node.parent)];
+  } else {
+    if (!node.parent.leftChild) {
+      throw new Error('Expected left child to exist');
+    }
+    return [node.parent.leftChild.hash, ...proveNode(node.parent)];
+  }
+}
+
+function highestPowerOf2LessThan(n: number) {
+  if (n < 2) {
+    throw Error('Expected n >= 2');
+  }
+  if (isPowerOf2(n)) {
+    return n / 2;
+  }
+  return 1 << Math.floor(Math.log2(n));
+}
+
+function isPowerOf2(n: number): boolean {
+  return (n & (n - 1)) == 0;
+}

package/src/ledger/bitcoin_client/lib/merkleMap.ts

@@ -0,0 +1,49 @@
+import { hashLeaf, Merkle } from './merkle';
+import { createVarint } from './varint';
+
+/**
+ * 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 {
+  readonly keys: readonly Buffer[];
+  readonly keysTree: Merkle;
+  readonly values: readonly Buffer[];
+  readonly valuesTree: Merkle;
+  /**
+   * @param keys Sorted list of (unhashed) keys
+   * @param values values, in corresponding order as the keys, and of equal length
+   */
+  constructor(keys: readonly Buffer[], values: readonly Buffer[]) {
+    if (keys.length != values.length) {
+      throw new Error('keys and values should have the same length');
+    }
+
+    // Sanity check: verify that keys are actually sorted and with no duplicates
+    for (let i = 0; i < keys.length - 1; i++) {
+      if (keys[i].toString('hex') >= keys[i + 1].toString('hex')) {
+        throw new Error('keys must be in strictly increasing order');
+      }
+    }
+
+    this.keys = keys;
+    this.keysTree = new Merkle(keys.map((k) => hashLeaf(k)));
+    this.values = values;
+    this.valuesTree = new Merkle(values.map((v) => hashLeaf(v)));
+  }
+
+  commitment(): Buffer {
+    // returns a buffer between 65 and 73 (included) bytes long
+    return Buffer.concat([
+      createVarint(this.keys.length),
+      this.keysTree.getRoot(),
+      this.valuesTree.getRoot(),
+    ]);
+  }
+}

package/src/ledger/bitcoin_client/lib/policy.ts

@@ -0,0 +1,91 @@
+import CryptoJS from 'crypto-js';
+
+// Helper function for SHA256 hashing (browser-compatible)
+function sha256(data: Buffer): Buffer {
+  const wordArray = CryptoJS.lib.WordArray.create(data);
+  const hash = CryptoJS.SHA256(wordArray);
+  const hashBuffer = Buffer.from(hash.toString(CryptoJS.enc.Hex), 'hex');
+  return hashBuffer;
+}
+
+import { BufferWriter } from './buffertools';
+import { hashLeaf, Merkle } from './merkle';
+
+const WALLET_POLICY_V2 = 2;
+
+/**
+ * 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 {
+  readonly name: string;
+  readonly descriptorTemplate: string;
+  readonly keys: readonly string[];
+  /**
+   * Creates and instance of a wallet policy.
+   * @param name an ascii string, up to 16 bytes long; it must be an empty string for default wallet policies
+   * @param descriptorTemplate the wallet policy template
+   * @param keys and array of the keys, with the key derivation information
+   */
+  constructor(
+    name: string,
+    descriptorTemplate: string,
+    keys: readonly string[]
+  ) {
+    this.name = name;
+    this.descriptorTemplate = descriptorTemplate;
+    this.keys = keys;
+  }
+
+  /**
+   * Returns the unique 32-bytes id of this wallet policy.
+   */
+  getId(): Buffer {
+    return sha256(this.serialize());
+  }
+
+  /**
+   * Serializes the wallet policy for transmission via the hardware wallet protocol.
+   * @returns the serialized wallet policy
+   */
+  serialize(): Buffer {
+    const keyBuffers = this.keys.map((k) => Buffer.from(k, 'ascii'));
+    const m = new Merkle(keyBuffers.map((k) => hashLeaf(k)));
+
+    const buf = new BufferWriter();
+    buf.writeUInt8(WALLET_POLICY_V2); // wallet version
+
+    // length of wallet name, and wallet name
+    buf.writeVarSlice(Buffer.from(this.name, 'ascii'));
+
+    // length of descriptor template
+    buf.writeVarInt(this.descriptorTemplate.length);
+    // sha256 hash of descriptor template
+    buf.writeSlice(sha256(Buffer.from(this.descriptorTemplate)));
+
+    // number of keys
+    buf.writeVarInt(this.keys.length);
+    // root of Merkle tree of keys
+    buf.writeSlice(m.getRoot());
+    return buf.buffer();
+  }
+}
+
+export type DefaultDescriptorTemplate =
+  | 'pkh(@0/**)'
+  | 'sh(wpkh(@0/**))'
+  | 'wpkh(@0/**)'
+  | 'tr(@0/**)';
+
+/**
+ * Simplified class to handle default wallet policies that can be used without policy registration.
+ */
+export class DefaultWalletPolicy extends WalletPolicy {
+  constructor(descriptorTemplate: DefaultDescriptorTemplate, key: string) {
+    super('', descriptorTemplate, [key]);
+  }
+}