@sidhujag/sysweb3-keyring 1.0.547 → 1.0.549

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

@@ -1,356 +0,0 @@
-/* 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

@@ -1,12 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,136 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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]);
-  }
-}