chore: shim for loading wasm miniscript async

modules/abstract-utxo/src/descriptor/NamedDescriptor.ts

@@ -1,6 +1,6 @@
 import * as t from 'io-ts';
-import { Descriptor, DescriptorPkType } from '@bitgo/wasm-miniscript';
-import { BIP32Interface, networks } from '@bitgo/utxo-lib';
+import type { Descriptor, DescriptorPkType } from '@bitgo/wasm-miniscript';
+import { BIP32Interface, miniscript, networks } from '@bitgo/utxo-lib';
 import { signMessage, verifyMessage } from '@bitgo/sdk-core';
 
 export const NamedDescriptor = t.intersection(
@@ -30,20 +30,20 @@ export function createNamedDescriptorWithSignature(
   signingKey: BIP32Interface
 ): NamedDescriptor {
   if (typeof descriptor === 'string') {
-    descriptor = Descriptor.fromString(descriptor, 'derivable');
+    descriptor = miniscript.Descriptor.fromString(descriptor, 'derivable');
   }
   const value = descriptor.toString();
   const signature = signMessage(value, signingKey, networks.bitcoin).toString('hex');
   return { name, value, signatures: [signature] };
 }
 
 export function toNamedDescriptorNative(e: NamedDescriptor, pkType: DescriptorPkType): NamedDescriptorNative {
-  return { ...e, value: Descriptor.fromString(e.value, pkType) };
+  return { ...e, value: miniscript.Descriptor.fromString(e.value, pkType) };
 }
 
 export function hasValidSignature(descriptor: string | Descriptor, key: BIP32Interface, signatures: string[]): boolean {
   if (typeof descriptor === 'string') {
-    descriptor = Descriptor.fromString(descriptor, 'derivable');
+    descriptor = miniscript.Descriptor.fromString(descriptor, 'derivable');
   }
 
   const message = descriptor.toString();

modules/abstract-utxo/src/descriptor/assertDescriptorWalletAddress.ts

@@ -1,7 +1,7 @@
 import assert from 'assert';
 
 import * as utxolib from '@bitgo/utxo-lib';
-import { Descriptor } from '@bitgo/wasm-miniscript';
+import type { Descriptor } from '@bitgo/wasm-miniscript';
 import { DescriptorMap } from '@bitgo/utxo-core/descriptor';
 
 import { UtxoCoinSpecific, VerifyAddressOptions } from '../abstractUtxoCoin';

modules/abstract-utxo/src/descriptor/builder/builder.ts

@@ -1,5 +1,5 @@
-import { BIP32Interface } from '@bitgo/utxo-lib';
-import { Descriptor } from '@bitgo/wasm-miniscript';
+import { BIP32Interface, miniscript } from '@bitgo/utxo-lib';
+import type { Descriptor } from '@bitgo/wasm-miniscript';
 
 type DescriptorWithKeys<TName extends string> = {
   name: TName;
@@ -50,5 +50,5 @@ function getDescriptorString(builder: DescriptorBuilder): string {
 }
 
 export function getDescriptorFromBuilder(builder: DescriptorBuilder): Descriptor {
-  return Descriptor.fromString(getDescriptorString(builder), 'derivable');
+  return miniscript.Descriptor.fromString(getDescriptorString(builder), 'derivable');
 }

modules/abstract-utxo/src/descriptor/builder/parse.ts

@@ -1,6 +1,6 @@
 import { BIP32Interface } from '@bitgo/utxo-lib';
 import * as utxolib from '@bitgo/utxo-lib';
-import { Descriptor } from '@bitgo/wasm-miniscript';
+import type { Descriptor } from '@bitgo/wasm-miniscript';
 
 import { DescriptorBuilder, getDescriptorFromBuilder } from './builder';
 

modules/abstract-utxo/src/descriptor/index.ts

@@ -1,4 +1,3 @@
-export { Miniscript, Descriptor } from '@bitgo/wasm-miniscript';
 export { DescriptorMap } from '@bitgo/utxo-core/descriptor';
 export { assertDescriptorWalletAddress } from './assertDescriptorWalletAddress';
 export {

modules/abstract-utxo/test/transaction/descriptor/parse.ts

@@ -1,7 +1,7 @@
 import assert from 'assert';
 
 import * as utxolib from '@bitgo/utxo-lib';
-import { Descriptor } from '@bitgo/wasm-miniscript';
+import * as WasmMiniscript from '@bitgo/wasm-miniscript';
 import {
   getDefaultXPubs,
   getDescriptor,
@@ -23,6 +23,8 @@ import { BaseOutput } from '../../../src';
 
 import { getFixtureRoot } from './fixtures.utils';
 
+utxolib.initializeMiniscript(WasmMiniscript);
+
 const { assertEqualFixture } = getFixtureRoot(__dirname + '/fixtures');
 
 type OutputWithValue<T = number | bigint | string> = {
@@ -58,7 +60,7 @@ describe('parse', function () {
   const descriptorOther = getDescriptor('Wsh2Of3', getDefaultXPubs('b'));
   const psbt = mockPsbtDefault({ descriptorSelf, descriptorOther });
 
-  function recipient(descriptor: Descriptor, index: number, value = 1000) {
+  function recipient(descriptor: WasmMiniscript.Descriptor, index: number, value = 1000) {
     return { value, address: createAddressFromDescriptor(descriptor, index, utxolib.networks.bitcoin) };
   }
 

modules/abstract-utxo/tsconfig.json

@@ -9,7 +9,7 @@
     "module": "node16",
     "typeRoots": ["../../types", "./node_modules/@types", "../../node_modules/@types"]
   },
-  "include": ["src/**/*", "test/**/*"],
+  "include": ["src/**/*", "test/**/*", "../utxo-lib/src/shim"],
   "exclude": ["node_modules"],
   "references": [
     {

modules/bitgo/package.json

@@ -127,6 +127,7 @@
     "@bitgo/statics": "^54.5.0",
     "@bitgo/unspents": "^0.48.3",
     "@bitgo/utxo-lib": "^11.6.1",
+    "@bitgo/wasm-miniscript": "2.0.0-beta.7",
     "@types/superagent": "^4.1.3",
     "bignumber.js": "^9.1.1",
     "fs-extra": "^9.1.0",

modules/bitgo/test/v2/unit/coins/utxo/descriptorAddress.ts

@@ -4,12 +4,15 @@ import { TestBitGo } from '@bitgo/sdk-test';
 import { AbstractUtxoCoin, descriptor as utxod } from '@bitgo/abstract-utxo';
 import * as utxolib from '@bitgo/utxo-lib';
 import { IWallet, WalletCoinSpecific } from '@bitgo/sdk-core';
+import * as WasmMiniscript from '@bitgo/wasm-miniscript';
 
 import { BitGo } from '../../../../../src';
 
+utxolib.initializeMiniscript(WasmMiniscript);
+
 export function getDescriptorAddress(d: string, index: number, network: utxolib.Network): string {
   const derivedScript = Buffer.from(
-    utxod.Descriptor.fromString(d, 'derivable').atDerivationIndex(index).scriptPubkey()
+    utxolib.miniscript.Descriptor.fromString(d, 'derivable').atDerivationIndex(index).scriptPubkey()
   );
   return utxolib.address.fromOutputScript(derivedScript, network);
 }
@@ -20,7 +23,7 @@ describe('descriptor wallets', function () {
   const xpubs = utxolib.testutil.getKeyTriple('setec astronomy').map((k) => k.neutered().toBase58());
 
   function withChecksum(descriptor: string): string {
-    return utxod.Descriptor.fromString(descriptor, 'derivable').toString();
+    return utxolib.miniscript.Descriptor.fromString(descriptor, 'derivable').toString();
   }
 
   function getNamedDescriptor2Of2(name: string, a: string, b: string): utxod.NamedDescriptor {

modules/utxo-bin/test/cmdPsbt.ts

@@ -3,13 +3,15 @@ import * as fs from 'fs/promises';
 
 import yargs from 'yargs';
 import * as utxolib from '@bitgo/utxo-lib';
-import { Descriptor } from '@bitgo/wasm-miniscript';
+import * as WasmMiniscript from '@bitgo/wasm-miniscript';
 
 import { cmdPsbt } from '../src/commands';
 import { formatTreeNoColor, getFixtureString } from './fixtures';
 import { getKeyTriple } from './bip32.util';
 import { TxParser } from '../src/TxParser';
 
+utxolib.initializeMiniscript(WasmMiniscript);
+
 async function runPsbtCommand(args: string[]) {
   return cmdPsbt.builder(yargs([])).strict().exitProcess(false).parse(args);
 }
@@ -30,15 +32,15 @@ function multi(n: number, xpubs: string[], path: string) {
   return 'multi(' + n + ',' + xpubs.map((xpub) => xpub + path).join(',') + ')';
 }
 
-function getAddressFromDescriptor(descriptor: Descriptor, network: utxolib.Network) {
+function getAddressFromDescriptor(descriptor: WasmMiniscript.Descriptor, network: utxolib.Network) {
   return utxolib.address.fromOutputScript(Buffer.from(descriptor.scriptPubkey()), network);
 }
 
 describe('cmdPsbt commands', function () {
   const keys = getKeyTriple('cmdPsbt');
   const xpubs = keys.map((k) => k.neutered().toBase58());
   const descriptorString = `wsh(${multi(2, xpubs, '/*')})`;
-  const descriptor = Descriptor.fromString(descriptorString, 'derivable');
+  const descriptor = WasmMiniscript.Descriptor.fromString(descriptorString, 'derivable');
 
   it('creates empty psbt', async function () {
     await fs.rm('/tmp/test.psbt', { force: true });

modules/utxo-core/src/descriptor/DescriptorMap.ts

@@ -1,11 +1,15 @@
-import { Descriptor } from '@bitgo/wasm-miniscript';
+import type { Descriptor } from '@bitgo/wasm-miniscript';
+import { miniscript } from '@bitgo/utxo-lib';
 
 /** Map from descriptor name to descriptor */
 export type DescriptorMap = Map<string, Descriptor>;
 
 /** Convert an array of descriptor name-value pairs to a descriptor map */
 export function toDescriptorMap(descriptors: { name: string; value: Descriptor | string }[]): DescriptorMap {
   return new Map(
-    descriptors.map((d) => [d.name, d.value instanceof Descriptor ? d.value : Descriptor.fromStringDetectType(d.value)])
+    descriptors.map((d) => [
+      d.name,
+      d.value instanceof miniscript.Descriptor ? d.value : miniscript.Descriptor.fromStringDetectType(d.value),
+    ])
   );
 }

modules/utxo-core/src/descriptor/Output.ts

@@ -1,6 +1,7 @@
 import assert from 'assert';
 
-import { Descriptor } from '@bitgo/wasm-miniscript';
+import type { Descriptor } from '@bitgo/wasm-miniscript';
+import { miniscript } from '@bitgo/utxo-lib';
 
 import { getFixedOutputSum, MaxOutput, Output, PrevOutput } from '../Output';
 
@@ -46,7 +47,7 @@ export function toDerivedDescriptorWalletOutput(
   if (!descriptor) {
     throw new Error(`Descriptor not found: ${output.descriptorName}`);
   }
-  assert(descriptor instanceof Descriptor);
+  assert(descriptor instanceof miniscript.Descriptor);
   const descriptorAtIndex = getDescriptorAtIndexCheckScript(
     descriptor,
     output.descriptorIndex,

modules/utxo-core/src/descriptor/VirtualSize.ts

@@ -1,6 +1,7 @@
 import * as utxolib from '@bitgo/utxo-lib';
 import { Dimensions, VirtualSizes } from '@bitgo/unspents';
-import { Descriptor } from '@bitgo/wasm-miniscript';
+import type { Descriptor } from '@bitgo/wasm-miniscript';
+import { miniscript } from '@bitgo/utxo-lib';
 
 import { DescriptorMap } from './DescriptorMap';
 import { findDescriptorForInput } from './psbt';
@@ -86,7 +87,7 @@ export function getVirtualSize(
 ): number {
   const lookup = descriptorMap ? getInputVSizesForDescriptors(descriptorMap) : undefined;
   const inputVSize = tx.inputs.reduce((sum, input) => {
-    if (input instanceof Descriptor) {
+    if (input instanceof miniscript.Descriptor) {
       return sum + getInputVSizeForDescriptor(input);
     }
     if ('descriptorName' in input) {

modules/utxo-core/src/descriptor/address.ts

@@ -1,4 +1,4 @@
-import { Descriptor } from '@bitgo/wasm-miniscript';
+import type { Descriptor } from '@bitgo/wasm-miniscript';
 import * as utxolib from '@bitgo/utxo-lib';
 
 export function createScriptPubKeyFromDescriptor(descriptor: Descriptor, index: number | undefined): Buffer {

modules/utxo-core/src/descriptor/derive.ts

@@ -1,6 +1,7 @@
 import assert from 'assert';
 
-import { Descriptor } from '@bitgo/wasm-miniscript';
+import type { Descriptor } from '@bitgo/wasm-miniscript';
+import { miniscript } from '@bitgo/utxo-lib';
 
 /**
  * Get a descriptor at a specific derivation index.
@@ -12,9 +13,9 @@ import { Descriptor } from '@bitgo/wasm-miniscript';
  * @throws {Error} If index is undefined for a wildcard descriptor or if index is provided for a definite descriptor
  */
 export function getDescriptorAtIndex(descriptor: Descriptor, index: number | undefined): Descriptor {
-  assert(descriptor instanceof Descriptor);
-  Descriptor.fromString(descriptor.toString(), 'derivable');
-  descriptor = Descriptor.fromStringDetectType(descriptor.toString());
+  assert(descriptor instanceof miniscript.Descriptor);
+  miniscript.Descriptor.fromString(descriptor.toString(), 'derivable');
+  descriptor = miniscript.Descriptor.fromStringDetectType(descriptor.toString());
   if (descriptor.hasWildcard()) {
     if (index === undefined) {
       throw new Error('Derivable descriptor requires an index');
@@ -34,11 +35,11 @@ export function getDescriptorAtIndexCheckScript(
   script: Buffer,
   descriptorString = descriptor.toString()
 ): Descriptor {
-  assert(descriptor instanceof Descriptor);
+  assert(descriptor instanceof miniscript.Descriptor);
   const descriptorAtIndex = getDescriptorAtIndex(descriptor, index);
   if (!script.equals(descriptorAtIndex.scriptPubkey())) {
     throw new Error(`Script mismatch: descriptor ${descriptorString} script=${script.toString('hex')}`);
   }
-  assert(descriptorAtIndex instanceof Descriptor);
+  assert(descriptorAtIndex instanceof miniscript.Descriptor);
   return descriptorAtIndex;
 }

modules/utxo-core/src/descriptor/fromFixedScriptWallet.ts

@@ -1,5 +1,6 @@
 import * as utxolib from '@bitgo/utxo-lib';
-import { Descriptor, ast } from '@bitgo/wasm-miniscript';
+import type { Descriptor, ast } from '@bitgo/wasm-miniscript';
+import { miniscript } from '@bitgo/utxo-lib';
 
 /** Expand a template with the given root wallet keys and chain code */
 function expand(rootWalletKeys: utxolib.bitgo.RootWalletKeys, keyIndex: number, chainCode: number): string {
@@ -30,11 +31,11 @@ export function getDescriptorForScriptType(
   };
   switch (scriptType) {
     case 'p2sh':
-      return Descriptor.fromString(ast.formatNode({ sh: multi }), 'derivable');
+      return miniscript.Descriptor.fromString(miniscript.ast.formatNode({ sh: multi }), 'derivable');
     case 'p2shP2wsh':
-      return Descriptor.fromString(ast.formatNode({ sh: { wsh: multi } }), 'derivable');
+      return miniscript.Descriptor.fromString(miniscript.ast.formatNode({ sh: { wsh: multi } }), 'derivable');
     case 'p2wsh':
-      return Descriptor.fromString(ast.formatNode({ wsh: multi }), 'derivable');
+      return miniscript.Descriptor.fromString(miniscript.ast.formatNode({ wsh: multi }), 'derivable');
     default:
       throw new Error(`Unsupported script type ${scriptType}`);
   }

modules/utxo-core/src/descriptor/psbt/assertSatisfiable.ts

@@ -8,8 +8,9 @@
  *
  * The goal is not an exhaustive check, but to catch common mistakes.
  */
-import { Descriptor } from '@bitgo/wasm-miniscript';
+import type { Descriptor } from '@bitgo/wasm-miniscript';
 import * as utxolib from '@bitgo/utxo-lib';
+import { miniscript } from '@bitgo/utxo-lib';
 
 export const FINAL_SEQUENCE = 0xffffffff;
 
@@ -18,7 +19,7 @@ export const FINAL_SEQUENCE = 0xffffffff;
  * @param descriptor
  */
 export function getRequiredLocktime(descriptor: Descriptor | unknown): number | undefined {
-  if (descriptor instanceof Descriptor) {
+  if (descriptor instanceof miniscript.Descriptor) {
     return getRequiredLocktime(descriptor.node());
   }
   if (typeof descriptor !== 'object' || descriptor === null) {

modules/utxo-core/src/descriptor/psbt/createPsbt.ts

@@ -1,5 +1,5 @@
 import * as utxolib from '@bitgo/utxo-lib';
-import { Descriptor } from '@bitgo/wasm-miniscript';
+import type { Descriptor } from '@bitgo/wasm-miniscript';
 
 import { DerivedDescriptorWalletOutput, WithOptDescriptor } from '../Output';
 import { Output } from '../../Output';

modules/utxo-core/src/descriptor/psbt/findDescriptors.ts

@@ -10,7 +10,7 @@ We should take a look at a more robust and standard approach like this: https://
 
  */
 import { PsbtInput, PsbtOutput } from 'bip174/src/lib/interfaces';
-import { Descriptor } from '@bitgo/wasm-miniscript';
+import type { Descriptor } from '@bitgo/wasm-miniscript';
 
 import { DescriptorMap } from '../DescriptorMap';
 

modules/utxo-core/src/descriptor/psbt/parse.ts

@@ -1,4 +1,4 @@
-import { Descriptor } from '@bitgo/wasm-miniscript';
+import type { Descriptor } from '@bitgo/wasm-miniscript';
 import * as utxolib from '@bitgo/utxo-lib';
 
 import { DescriptorMap } from '../DescriptorMap';

modules/utxo-core/src/descriptor/psbt/sign.ts

@@ -1,7 +1,7 @@
 import assert from 'assert';
 
 import * as utxolib from '@bitgo/utxo-lib';
-import { Psbt as WasmPsbt } from '@bitgo/wasm-miniscript';
+import type { Psbt as WasmPsbt } from '@bitgo/wasm-miniscript';
 
 /** These can be replaced when @bitgo/wasm-miniscript is updated */
 export type SignPsbtInputResult = { Schnorr: string[] } | { Ecdsa: string[] };

modules/utxo-core/src/descriptor/psbt/wrap.ts

@@ -1,18 +1,19 @@
-import { Psbt as WasmPsbt } from '@bitgo/wasm-miniscript';
+import type { Psbt as WasmPsbt } from '@bitgo/wasm-miniscript';
 import * as utxolib from '@bitgo/utxo-lib';
+import { miniscript } from '@bitgo/utxo-lib';
 
 export function toWrappedPsbt(psbt: utxolib.bitgo.UtxoPsbt | utxolib.Psbt | Buffer | Uint8Array): WasmPsbt {
   if (psbt instanceof utxolib.bitgo.UtxoPsbt || psbt instanceof utxolib.Psbt) {
     psbt = psbt.toBuffer();
   }
   if (psbt instanceof Buffer || psbt instanceof Uint8Array) {
-    return WasmPsbt.deserialize(psbt);
+    return miniscript.Psbt.deserialize(psbt);
   }
   throw new Error('Invalid input');
 }
 
 export function toUtxoPsbt(psbt: WasmPsbt | Buffer | Uint8Array, network: utxolib.Network): utxolib.bitgo.UtxoPsbt {
-  if (psbt instanceof WasmPsbt) {
+  if (psbt instanceof miniscript.Psbt) {
     psbt = psbt.serialize();
   }
   if (psbt instanceof Buffer || psbt instanceof Uint8Array) {