@bitgo-beta/abstract-utxo 1.6.1-alpha.419 → 1.6.1-alpha.420

package/dist/esm/address/fixedScript.d.ts

@@ -0,0 +1,51 @@
+import { CreateAddressFormat } from '@bitgo-beta/sdk-core';
+import * as utxolib from '@bitgo-beta/utxo-lib';
+import { bitgo } from '@bitgo-beta/utxo-lib';
+type ScriptType2Of3 = bitgo.outputScripts.ScriptType2Of3;
+export interface FixedScriptAddressCoinSpecific {
+    outputScript?: string;
+    redeemScript?: string;
+    witnessScript?: string;
+}
+export interface GenerateAddressOptions {
+    addressType?: ScriptType2Of3;
+    chain?: number;
+    index?: number;
+    segwit?: boolean;
+    bech32?: boolean;
+}
+interface GenerateFixedScriptAddressOptions extends GenerateAddressOptions {
+    format?: CreateAddressFormat;
+    keychains: {
+        pub: string;
+    }[];
+}
+export declare function generateAddressWithChainAndIndex(network: utxolib.Network, keychains: {
+    pub: string;
+}[], chain: bitgo.ChainCode, index: number, format: CreateAddressFormat | undefined): string;
+/**
+ * Generate an address for a wallet based on a set of configurations
+ * @param params.addressType {string}   Deprecated
+ * @param params.keychains   {[object]} Array of objects with xpubs
+ * @param params.threshold   {number}   Minimum number of signatures
+ * @param params.chain       {number}   Derivation chain (see https://github.com/BitGo/unspents/blob/master/src/codes.ts for
+ *                                                 the corresponding address type of a given chain code)
+ * @param params.index       {number}   Derivation index
+ * @param params.segwit      {boolean}  Deprecated
+ * @param params.bech32      {boolean}  Deprecated
+ * @returns {string} The generated address
+ */
+export declare function generateAddress(network: utxolib.Network, params: GenerateFixedScriptAddressOptions): string;
+type Keychain = {
+    pub: string;
+};
+export declare function assertFixedScriptWalletAddress(network: utxolib.Network, { chain, index, keychains, format, addressType, address, }: {
+    chain: number | undefined;
+    index: number;
+    keychains: Keychain[];
+    format: CreateAddressFormat;
+    addressType: string | undefined;
+    address: string;
+}): void;
+export {};
+//# sourceMappingURL=fixedScript.d.ts.map

package/dist/esm/address/fixedScript.js

@@ -0,0 +1,109 @@
+import _ from 'lodash';
+import { AddressTypeChainMismatchError, InvalidAddressDerivationPropertyError, UnexpectedAddressError, P2shP2wshUnsupportedError, P2trMusig2UnsupportedError, P2trUnsupportedError, P2wshUnsupportedError, UnsupportedAddressTypeError, sanitizeLegacyPath, } from '@bitgo-beta/sdk-core';
+import * as utxolib from '@bitgo-beta/utxo-lib';
+import { bitgo } from '@bitgo-beta/utxo-lib';
+import { bip32 } from '@bitgo-beta/secp256k1';
+import * as wasmUtxo from '@bitgo/wasm-utxo';
+function canonicalAddress(network, address, format) {
+    if (format === 'cashaddr') {
+        const script = utxolib.addressFormat.toOutputScriptTryFormats(address, network);
+        return utxolib.addressFormat.fromOutputScriptWithFormat(script, format, network);
+    }
+    // Default to canonical format (base58 for most coins)
+    return utxolib.addressFormat.toCanonicalFormat(address, network);
+}
+function supportsAddressType(network, addressType) {
+    return utxolib.bitgo.outputScripts.isSupportedScriptType(network, addressType);
+}
+export function generateAddressWithChainAndIndex(network, keychains, chain, index, format) {
+    if (utxolib.isTestnet(network)) {
+        // Convert CreateAddressFormat to AddressFormat for wasm-utxo
+        // 'base58' -> 'default', 'cashaddr' -> 'cashaddr'
+        const wasmFormat = format === 'base58' ? 'default' : format;
+        return wasmUtxo.fixedScriptWallet.address(keychains.map((k) => k.pub), chain, index, network, wasmFormat);
+    }
+    const path = '0/0/' + chain + '/' + index;
+    const hdNodes = keychains.map(({ pub }) => bip32.fromBase58(pub));
+    const derivedKeys = hdNodes.map((hdNode) => hdNode.derivePath(sanitizeLegacyPath(path)).publicKey);
+    const addressType = bitgo.scriptTypeForChain(chain);
+    const { scriptPubKey: outputScript } = utxolib.bitgo.outputScripts.createOutputScript2of3(derivedKeys, addressType);
+    const address = utxolib.address.fromOutputScript(outputScript, network);
+    return canonicalAddress(network, address, format);
+}
+/**
+ * Generate an address for a wallet based on a set of configurations
+ * @param params.addressType {string}   Deprecated
+ * @param params.keychains   {[object]} Array of objects with xpubs
+ * @param params.threshold   {number}   Minimum number of signatures
+ * @param params.chain       {number}   Derivation chain (see https://github.com/BitGo/unspents/blob/master/src/codes.ts for
+ *                                                 the corresponding address type of a given chain code)
+ * @param params.index       {number}   Derivation index
+ * @param params.segwit      {boolean}  Deprecated
+ * @param params.bech32      {boolean}  Deprecated
+ * @returns {string} The generated address
+ */
+export function generateAddress(network, params) {
+    let derivationIndex = 0;
+    if (_.isInteger(params.index) && params.index > 0) {
+        derivationIndex = params.index;
+    }
+    const { keychains, chain, segwit = false, bech32 = false } = params;
+    let derivationChain = bitgo.getExternalChainCode('p2sh');
+    if (_.isNumber(chain) && _.isInteger(chain) && bitgo.isChainCode(chain)) {
+        derivationChain = chain;
+    }
+    function convertFlagsToAddressType() {
+        if (bitgo.isChainCode(chain)) {
+            return bitgo.scriptTypeForChain(chain);
+        }
+        if (_.isBoolean(segwit) && segwit) {
+            return 'p2shP2wsh';
+        }
+        else if (_.isBoolean(bech32) && bech32) {
+            return 'p2wsh';
+        }
+        else {
+            return 'p2sh';
+        }
+    }
+    const addressType = params.addressType || convertFlagsToAddressType();
+    if (addressType !== utxolib.bitgo.scriptTypeForChain(derivationChain)) {
+        throw new AddressTypeChainMismatchError(addressType, derivationChain);
+    }
+    if (!supportsAddressType(network, addressType)) {
+        switch (addressType) {
+            case 'p2sh':
+                throw new Error(`internal error: p2sh should always be supported`);
+            case 'p2shP2wsh':
+                throw new P2shP2wshUnsupportedError();
+            case 'p2wsh':
+                throw new P2wshUnsupportedError();
+            case 'p2tr':
+                throw new P2trUnsupportedError();
+            case 'p2trMusig2':
+                throw new P2trMusig2UnsupportedError();
+            default:
+                throw new UnsupportedAddressTypeError();
+        }
+    }
+    return generateAddressWithChainAndIndex(network, keychains, derivationChain, derivationIndex, params.format);
+}
+export function assertFixedScriptWalletAddress(network, { chain, index, keychains, format, addressType, address, }) {
+    if ((_.isUndefined(chain) && _.isUndefined(index)) || !(_.isFinite(chain) && _.isFinite(index))) {
+        throw new InvalidAddressDerivationPropertyError(`address validation failure: invalid chain (${chain}) or index (${index})`);
+    }
+    if (!keychains) {
+        throw new Error('missing required param keychains');
+    }
+    const expectedAddress = generateAddress(network, {
+        format,
+        addressType: addressType,
+        keychains,
+        chain,
+        index,
+    });
+    if (expectedAddress !== address) {
+        throw new UnexpectedAddressError(`address validation failure: expected ${expectedAddress} but got ${address}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fixedScript.js","sourceRoot":"","sources":["../../../src/address/fixedScript.ts"],"names":[],"mappings":"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","sourcesContent":["import _ from 'lodash';\nimport {\n  AddressTypeChainMismatchError,\n  CreateAddressFormat,\n  InvalidAddressDerivationPropertyError,\n  UnexpectedAddressError,\n  P2shP2wshUnsupportedError,\n  P2trMusig2UnsupportedError,\n  P2trUnsupportedError,\n  P2wshUnsupportedError,\n  UnsupportedAddressTypeError,\n  sanitizeLegacyPath,\n} from '@bitgo-beta/sdk-core';\nimport * as utxolib from '@bitgo-beta/utxo-lib';\nimport { bitgo } from '@bitgo-beta/utxo-lib';\nimport { bip32 } from '@bitgo-beta/secp256k1';\nimport * as wasmUtxo from '@bitgo/wasm-utxo';\n\ntype ScriptType2Of3 = bitgo.outputScripts.ScriptType2Of3;\n\nexport interface FixedScriptAddressCoinSpecific {\n  outputScript?: string;\n  redeemScript?: string;\n  witnessScript?: string;\n}\n\nexport interface GenerateAddressOptions {\n  addressType?: ScriptType2Of3;\n  chain?: number;\n  index?: number;\n  segwit?: boolean;\n  bech32?: boolean;\n}\n\ninterface GenerateFixedScriptAddressOptions extends GenerateAddressOptions {\n  format?: CreateAddressFormat;\n  keychains: { pub: string }[];\n}\n\nfunction canonicalAddress(network: utxolib.Network, address: string, format?: CreateAddressFormat): string {\n  if (format === 'cashaddr') {\n    const script = utxolib.addressFormat.toOutputScriptTryFormats(address, network);\n    return utxolib.addressFormat.fromOutputScriptWithFormat(script, format, network);\n  }\n  // Default to canonical format (base58 for most coins)\n  return utxolib.addressFormat.toCanonicalFormat(address, network);\n}\n\nfunction supportsAddressType(network: utxolib.Network, addressType: ScriptType2Of3): boolean {\n  return utxolib.bitgo.outputScripts.isSupportedScriptType(network, addressType);\n}\n\nexport function generateAddressWithChainAndIndex(\n  network: utxolib.Network,\n  keychains: { pub: string }[],\n  chain: bitgo.ChainCode,\n  index: number,\n  format: CreateAddressFormat | undefined\n): string {\n  if (utxolib.isTestnet(network)) {\n    // Convert CreateAddressFormat to AddressFormat for wasm-utxo\n    // 'base58' -> 'default', 'cashaddr' -> 'cashaddr'\n    const wasmFormat = format === 'base58' ? 'default' : format;\n    return wasmUtxo.fixedScriptWallet.address(\n      keychains.map((k) => k.pub) as [string, string, string],\n      chain,\n      index,\n      network,\n      wasmFormat\n    );\n  }\n\n  const path = '0/0/' + chain + '/' + index;\n  const hdNodes = keychains.map(({ pub }) => bip32.fromBase58(pub));\n  const derivedKeys = hdNodes.map((hdNode) => hdNode.derivePath(sanitizeLegacyPath(path)).publicKey);\n  const addressType = bitgo.scriptTypeForChain(chain);\n\n  const { scriptPubKey: outputScript } = utxolib.bitgo.outputScripts.createOutputScript2of3(derivedKeys, addressType);\n\n  const address = utxolib.address.fromOutputScript(outputScript, network);\n\n  return canonicalAddress(network, address, format);\n}\n\n/**\n * Generate an address for a wallet based on a set of configurations\n * @param params.addressType {string}   Deprecated\n * @param params.keychains   {[object]} Array of objects with xpubs\n * @param params.threshold   {number}   Minimum number of signatures\n * @param params.chain       {number}   Derivation chain (see https://github.com/BitGo/unspents/blob/master/src/codes.ts for\n *                                                 the corresponding address type of a given chain code)\n * @param params.index       {number}   Derivation index\n * @param params.segwit      {boolean}  Deprecated\n * @param params.bech32      {boolean}  Deprecated\n * @returns {string} The generated address\n */\nexport function generateAddress(network: utxolib.Network, params: GenerateFixedScriptAddressOptions): string {\n  let derivationIndex = 0;\n  if (_.isInteger(params.index) && (params.index as number) > 0) {\n    derivationIndex = params.index as number;\n  }\n\n  const { keychains, chain, segwit = false, bech32 = false } = params as GenerateFixedScriptAddressOptions;\n\n  let derivationChain = bitgo.getExternalChainCode('p2sh');\n  if (_.isNumber(chain) && _.isInteger(chain) && bitgo.isChainCode(chain)) {\n    derivationChain = chain;\n  }\n\n  function convertFlagsToAddressType(): ScriptType2Of3 {\n    if (bitgo.isChainCode(chain)) {\n      return bitgo.scriptTypeForChain(chain);\n    }\n    if (_.isBoolean(segwit) && segwit) {\n      return 'p2shP2wsh';\n    } else if (_.isBoolean(bech32) && bech32) {\n      return 'p2wsh';\n    } else {\n      return 'p2sh';\n    }\n  }\n\n  const addressType = params.addressType || convertFlagsToAddressType();\n\n  if (addressType !== utxolib.bitgo.scriptTypeForChain(derivationChain)) {\n    throw new AddressTypeChainMismatchError(addressType, derivationChain);\n  }\n\n  if (!supportsAddressType(network, addressType)) {\n    switch (addressType) {\n      case 'p2sh':\n        throw new Error(`internal error: p2sh should always be supported`);\n      case 'p2shP2wsh':\n        throw new P2shP2wshUnsupportedError();\n      case 'p2wsh':\n        throw new P2wshUnsupportedError();\n      case 'p2tr':\n        throw new P2trUnsupportedError();\n      case 'p2trMusig2':\n        throw new P2trMusig2UnsupportedError();\n      default:\n        throw new UnsupportedAddressTypeError();\n    }\n  }\n\n  return generateAddressWithChainAndIndex(network, keychains, derivationChain, derivationIndex, params.format);\n}\n\ntype Keychain = {\n  pub: string;\n};\n\nexport function assertFixedScriptWalletAddress(\n  network: utxolib.Network,\n  {\n    chain,\n    index,\n    keychains,\n    format,\n    addressType,\n    address,\n  }: {\n    chain: number | undefined;\n    index: number;\n    keychains: Keychain[];\n    format: CreateAddressFormat;\n    addressType: string | undefined;\n    address: string;\n  }\n): void {\n  if ((_.isUndefined(chain) && _.isUndefined(index)) || !(_.isFinite(chain) && _.isFinite(index))) {\n    throw new InvalidAddressDerivationPropertyError(\n      `address validation failure: invalid chain (${chain}) or index (${index})`\n    );\n  }\n\n  if (!keychains) {\n    throw new Error('missing required param keychains');\n  }\n\n  const expectedAddress = generateAddress(network, {\n    format,\n    addressType: addressType as ScriptType2Of3,\n    keychains,\n    chain,\n    index,\n  });\n\n  if (expectedAddress !== address) {\n    throw new UnexpectedAddressError(`address validation failure: expected ${expectedAddress} but got ${address}`);\n  }\n}\n"]}

package/dist/esm/address/index.d.ts

@@ -0,0 +1,2 @@
+export { generateAddress, generateAddressWithChainAndIndex, assertFixedScriptWalletAddress, FixedScriptAddressCoinSpecific, } from './fixedScript';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/address/index.js

@@ -0,0 +1,2 @@
+export { generateAddress, generateAddressWithChainAndIndex, assertFixedScriptWalletAddress, } from './fixedScript';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYWRkcmVzcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsZUFBZSxFQUNmLGdDQUFnQyxFQUNoQyw4QkFBOEIsR0FFL0IsTUFBTSxlQUFlLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQge1xuICBnZW5lcmF0ZUFkZHJlc3MsXG4gIGdlbmVyYXRlQWRkcmVzc1dpdGhDaGFpbkFuZEluZGV4LFxuICBhc3NlcnRGaXhlZFNjcmlwdFdhbGxldEFkZHJlc3MsXG4gIEZpeGVkU2NyaXB0QWRkcmVzc0NvaW5TcGVjaWZpYyxcbn0gZnJvbSAnLi9maXhlZFNjcmlwdCc7XG4iXX0=

package/dist/esm/config.d.ts

@@ -0,0 +1,9 @@
+export declare const supportedCrossChainRecoveries: {
+    btc: string[];
+    bch: string[];
+    ltc: string[];
+    bsv: string[];
+    doge: string[];
+    bcha: string[];
+};
+//# sourceMappingURL=config.d.ts.map

package/dist/esm/config.js

@@ -0,0 +1,11 @@
+// Supported cross-chain recovery routes. The object index is the coin to be recovered, and the value is
+// an array of valid coins for recipient wallets of the original accidental/unintentional deposit.
+export const supportedCrossChainRecoveries = {
+    btc: ['bch', 'ltc', 'bsv', 'doge'],
+    bch: ['btc', 'ltc', 'bsv', 'doge'],
+    ltc: ['btc', 'bch', 'bsv', 'doge'],
+    bsv: ['btc', 'ltc', 'bch', 'doge'],
+    doge: ['btc', 'bch', 'ltc', 'bsv'],
+    bcha: ['btc', 'bch'],
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSx3R0FBd0c7QUFDeEcsa0dBQWtHO0FBQ2xHLE1BQU0sQ0FBQyxNQUFNLDZCQUE2QixHQUFHO0lBQzNDLEdBQUcsRUFBRSxDQUFDLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLE1BQU0sQ0FBQztJQUNsQyxHQUFHLEVBQUUsQ0FBQyxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLENBQUM7SUFDbEMsR0FBRyxFQUFFLENBQUMsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsTUFBTSxDQUFDO0lBQ2xDLEdBQUcsRUFBRSxDQUFDLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLE1BQU0sQ0FBQztJQUNsQyxJQUFJLEVBQUUsQ0FBQyxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLENBQUM7SUFDbEMsSUFBSSxFQUFFLENBQUMsS0FBSyxFQUFFLEtBQUssQ0FBQztDQUNyQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gU3VwcG9ydGVkIGNyb3NzLWNoYWluIHJlY292ZXJ5IHJvdXRlcy4gVGhlIG9iamVjdCBpbmRleCBpcyB0aGUgY29pbiB0byBiZSByZWNvdmVyZWQsIGFuZCB0aGUgdmFsdWUgaXNcbi8vIGFuIGFycmF5IG9mIHZhbGlkIGNvaW5zIGZvciByZWNpcGllbnQgd2FsbGV0cyBvZiB0aGUgb3JpZ2luYWwgYWNjaWRlbnRhbC91bmludGVudGlvbmFsIGRlcG9zaXQuXG5leHBvcnQgY29uc3Qgc3VwcG9ydGVkQ3Jvc3NDaGFpblJlY292ZXJpZXMgPSB7XG4gIGJ0YzogWydiY2gnLCAnbHRjJywgJ2JzdicsICdkb2dlJ10sXG4gIGJjaDogWydidGMnLCAnbHRjJywgJ2JzdicsICdkb2dlJ10sXG4gIGx0YzogWydidGMnLCAnYmNoJywgJ2JzdicsICdkb2dlJ10sXG4gIGJzdjogWydidGMnLCAnbHRjJywgJ2JjaCcsICdkb2dlJ10sXG4gIGRvZ2U6IFsnYnRjJywgJ2JjaCcsICdsdGMnLCAnYnN2J10sXG4gIGJjaGE6IFsnYnRjJywgJ2JjaCddLFxufTtcbiJdfQ==

package/dist/esm/descriptor/NamedDescriptor.d.ts

@@ -0,0 +1,20 @@
+import * as t from 'io-ts';
+import { Descriptor, DescriptorPkType } from '@bitgo/wasm-utxo';
+import { BIP32Interface } from '@bitgo-beta/utxo-lib';
+export declare const NamedDescriptor: t.IntersectionC<[t.TypeC<{
+    name: t.StringC;
+    value: t.StringC;
+}>, t.PartialC<{
+    signatures: t.UnionC<[t.ArrayC<t.StringC>, t.UndefinedC]>;
+}>]>;
+export type NamedDescriptor<T = string> = {
+    name: string;
+    value: T;
+    signatures?: string[];
+};
+export type NamedDescriptorNative = NamedDescriptor<Descriptor>;
+export declare function createNamedDescriptorWithSignature(name: string, descriptor: string | Descriptor, signingKey: BIP32Interface): NamedDescriptor;
+export declare function toNamedDescriptorNative(e: NamedDescriptor, pkType: DescriptorPkType): NamedDescriptorNative;
+export declare function hasValidSignature(descriptor: string | Descriptor, key: BIP32Interface, signatures: string[]): boolean;
+export declare function assertHasValidSignature(namedDescriptor: NamedDescriptor, key: BIP32Interface): void;
+//# sourceMappingURL=NamedDescriptor.d.ts.map

package/dist/esm/descriptor/NamedDescriptor.js

@@ -0,0 +1,39 @@
+import * as t from 'io-ts';
+import { Descriptor } from '@bitgo/wasm-utxo';
+import { networks } from '@bitgo-beta/utxo-lib';
+import { signMessage, verifyMessage } from '@bitgo-beta/sdk-core';
+export const NamedDescriptor = t.intersection([
+    t.type({
+        name: t.string,
+        value: t.string,
+    }),
+    t.partial({
+        signatures: t.union([t.array(t.string), t.undefined]),
+    }),
+], 'NamedDescriptor');
+export function createNamedDescriptorWithSignature(name, descriptor, signingKey) {
+    if (typeof descriptor === 'string') {
+        descriptor = 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, pkType) {
+    return { ...e, value: Descriptor.fromString(e.value, pkType) };
+}
+export function hasValidSignature(descriptor, key, signatures) {
+    if (typeof descriptor === 'string') {
+        descriptor = Descriptor.fromString(descriptor, 'derivable');
+    }
+    const message = descriptor.toString();
+    return signatures.some((signature) => {
+        return verifyMessage(message, key, Buffer.from(signature, 'hex'), networks.bitcoin);
+    });
+}
+export function assertHasValidSignature(namedDescriptor, key) {
+    if (!hasValidSignature(namedDescriptor.value, key, namedDescriptor.signatures ?? [])) {
+        throw new Error(`Descriptor ${namedDescriptor.name} does not have a valid signature (key=${key.toBase58()})`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/descriptor/assertDescriptorWalletAddress.d.ts

@@ -0,0 +1,5 @@
+import * as utxolib from '@bitgo-beta/utxo-lib';
+import { DescriptorMap } from '@bitgo-beta/utxo-core/descriptor';
+import { UtxoCoinSpecific, VerifyAddressOptions } from '../abstractUtxoCoin';
+export declare function assertDescriptorWalletAddress(network: utxolib.Network, params: VerifyAddressOptions<UtxoCoinSpecific>, descriptors: DescriptorMap): void;
+//# sourceMappingURL=assertDescriptorWalletAddress.d.ts.map

package/dist/esm/descriptor/assertDescriptorWalletAddress.js

@@ -0,0 +1,27 @@
+import assert from 'assert';
+import * as utxolib from '@bitgo-beta/utxo-lib';
+class DescriptorAddressMismatchError extends Error {
+    constructor(descriptor, index, derivedAddress, expectedAddress) {
+        super(`Address mismatch for descriptor ${descriptor.toString()} at index ${index}: ${derivedAddress} !== ${expectedAddress}`);
+    }
+}
+export function assertDescriptorWalletAddress(network, params, descriptors) {
+    assert(params.coinSpecific);
+    assert('descriptorName' in params.coinSpecific);
+    assert('descriptorChecksum' in params.coinSpecific);
+    const { descriptorName, descriptorChecksum } = params.coinSpecific;
+    const descriptor = descriptors.get(params.coinSpecific.descriptorName);
+    if (!descriptor) {
+        throw new Error(`Descriptor ${descriptorName} not found`);
+    }
+    const checksum = descriptor.toString().slice(-8);
+    if (checksum !== descriptorChecksum) {
+        throw new Error(`Descriptor checksum mismatch for descriptor name=${descriptorName}: ${checksum} !== ${descriptorChecksum}`);
+    }
+    const derivedScript = Buffer.from(descriptor.atDerivationIndex(params.index).scriptPubkey());
+    const derivedAddress = utxolib.address.fromOutputScript(derivedScript, network);
+    if (params.address !== derivedAddress) {
+        throw new DescriptorAddressMismatchError(descriptor, params.index, derivedAddress, params.address);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/descriptor/builder/builder.d.ts

@@ -0,0 +1,13 @@
+import { BIP32Interface } from '@bitgo-beta/utxo-lib';
+import { Descriptor } from '@bitgo/wasm-utxo';
+type DescriptorWithKeys<TName extends string> = {
+    name: TName;
+    keys: BIP32Interface[];
+    path: string;
+};
+export type DescriptorBuilder = DescriptorWithKeys<'Wsh2Of2'> | DescriptorWithKeys<'Wsh2Of3'> | (DescriptorWithKeys<'ShWsh2Of3CltvDrop' | 'Wsh2Of3CltvDrop'> & {
+    locktime: number;
+});
+export declare function getDescriptorFromBuilder(builder: DescriptorBuilder): Descriptor;
+export {};
+//# sourceMappingURL=builder.d.ts.map

package/dist/esm/descriptor/builder/builder.js

@@ -0,0 +1,34 @@
+import { Descriptor } from '@bitgo/wasm-utxo';
+function toXPub(k) {
+    if (typeof k === 'string') {
+        return k;
+    }
+    return k.neutered().toBase58();
+}
+function multi(m, n, keys, path) {
+    if (n < m) {
+        throw new Error(`Cannot create ${m} of ${n} multisig`);
+    }
+    if (keys.length < n) {
+        throw new Error(`Not enough keys for ${m} of ${n} multisig: keys.length=${keys.length}`);
+    }
+    keys = keys.slice(0, n);
+    return `multi(${m},${keys.map((k) => `${toXPub(k)}/${path}`).join(',')})`;
+}
+function getDescriptorString(builder) {
+    switch (builder.name) {
+        case 'Wsh2Of3':
+            return `wsh(${multi(2, 3, builder.keys, builder.path)})`;
+        case 'Wsh2Of2':
+            return `wsh(${multi(2, 2, builder.keys, builder.path)})`;
+        case 'Wsh2Of3CltvDrop':
+            return `wsh(and_v(r:after(${builder.locktime}),${multi(2, 3, builder.keys, builder.path)}))`;
+        case 'ShWsh2Of3CltvDrop':
+            return `sh(${getDescriptorString({ ...builder, name: 'Wsh2Of3CltvDrop' })})`;
+    }
+    throw new Error(`Unknown descriptor template: ${builder}`);
+}
+export function getDescriptorFromBuilder(builder) {
+    return Descriptor.fromString(getDescriptorString(builder), 'derivable');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/descriptor/builder/index.d.ts

@@ -0,0 +1,3 @@
+export { getDescriptorFromBuilder, DescriptorBuilder } from './builder';
+export { parseDescriptor } from './parse';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/descriptor/builder/index.js

@@ -0,0 +1,3 @@
+export { getDescriptorFromBuilder } from './builder';
+export { parseDescriptor } from './parse';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZGVzY3JpcHRvci9idWlsZGVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx3QkFBd0IsRUFBcUIsTUFBTSxXQUFXLENBQUM7QUFDeEUsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IGdldERlc2NyaXB0b3JGcm9tQnVpbGRlciwgRGVzY3JpcHRvckJ1aWxkZXIgfSBmcm9tICcuL2J1aWxkZXInO1xuZXhwb3J0IHsgcGFyc2VEZXNjcmlwdG9yIH0gZnJvbSAnLi9wYXJzZSc7XG4iXX0=

package/dist/esm/descriptor/builder/parse.d.ts

@@ -0,0 +1,5 @@
+import { Descriptor } from '@bitgo/wasm-utxo';
+import { DescriptorBuilder } from './builder';
+export declare function parseDescriptorNode(node: unknown): DescriptorBuilder;
+export declare function parseDescriptor(descriptor: Descriptor): DescriptorBuilder;
+//# sourceMappingURL=parse.d.ts.map

package/dist/esm/descriptor/builder/parse.js

@@ -0,0 +1,112 @@
+import { bip32 } from '@bitgo-beta/secp256k1';
+import { getDescriptorFromBuilder } from './builder';
+function isUnaryNode(node, key) {
+    if (typeof node !== 'object' || node === null) {
+        return false;
+    }
+    const keys = Object.keys(node);
+    return keys.length === 1 && keys[0] === key;
+}
+function unwrapNode(node, path) {
+    let current = node;
+    for (const key of path) {
+        if (!isUnaryNode(current, key)) {
+            return undefined;
+        }
+        current = current[key];
+    }
+    return current;
+}
+function parseMulti(node) {
+    if (!Array.isArray(node)) {
+        throw new Error('Unexpected node');
+    }
+    const [threshold, ...keyNodes] = node;
+    if (typeof threshold !== 'number') {
+        throw new Error('Expected threshold number');
+    }
+    const keyWithPath = keyNodes.map((keyNode) => {
+        if (!isUnaryNode(keyNode, 'XPub')) {
+            throw new Error('Expected XPub node');
+        }
+        if (typeof keyNode.XPub !== 'string') {
+            throw new Error('Expected XPub string');
+        }
+        const parts = keyNode.XPub.split('/');
+        return { xpub: parts[0], path: parts.slice(1).join('/') };
+    });
+    const paths = keyWithPath.map((k) => k.path);
+    paths.forEach((path, i) => {
+        if (path !== paths[0]) {
+            throw new Error(`Expected all paths to be the same: ${path} !== ${paths[0]}`);
+        }
+    });
+    return {
+        threshold,
+        keys: keyWithPath.map((k) => bip32.fromBase58(k.xpub)),
+        path: paths[0],
+    };
+}
+function parseWshMulti(node) {
+    const wshMsMulti = unwrapNode(node, ['Wsh', 'Ms', 'Multi']);
+    if (wshMsMulti) {
+        const { threshold, keys, path } = parseMulti(wshMsMulti);
+        let name;
+        if (threshold === 2 && keys.length === 2) {
+            name = 'Wsh2Of2';
+        }
+        else if (threshold === 2 && keys.length === 3) {
+            name = 'Wsh2Of3';
+        }
+        else {
+            throw new Error('Unexpected multisig');
+        }
+        return {
+            name,
+            keys,
+            path,
+        };
+    }
+}
+function parseCltvDrop(node, name, wrapping) {
+    const unwrapped = unwrapNode(node, wrapping);
+    if (!unwrapped) {
+        return;
+    }
+    if (Array.isArray(unwrapped) && unwrapped.length === 2) {
+        const [a, b] = unwrapped;
+        const dropAfterAbsLocktime = unwrapNode(a, ['Drop', 'After', 'absLockTime']);
+        if (typeof dropAfterAbsLocktime !== 'number') {
+            throw new Error('Expected absLockTime number');
+        }
+        if (!isUnaryNode(b, 'Multi')) {
+            throw new Error('Expected Multi node');
+        }
+        const multi = parseMulti(b.Multi);
+        if (multi.threshold === 2 && multi.keys.length === 3) {
+            return {
+                name,
+                locktime: dropAfterAbsLocktime,
+                keys: multi.keys,
+                path: multi.path,
+            };
+        }
+    }
+}
+export function parseDescriptorNode(node) {
+    const parsed = parseWshMulti(node) ??
+        parseCltvDrop(node, 'ShWsh2Of3CltvDrop', ['Sh', 'Wsh', 'Ms', 'AndV']) ??
+        parseCltvDrop(node, 'Wsh2Of3CltvDrop', ['Wsh', 'Ms', 'AndV']);
+    if (!parsed) {
+        throw new Error('Failed to parse descriptor node');
+    }
+    return parsed;
+}
+export function parseDescriptor(descriptor) {
+    const builder = parseDescriptorNode(descriptor.node());
+    if (getDescriptorFromBuilder(builder).toString() !== descriptor.toString()) {
+        throw new Error('Failed to parse descriptor');
+    }
+    return builder;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parse.js","sourceRoot":"","sources":["../../../../src/descriptor/builder/parse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAG9D,OAAO,EAAqB,wBAAwB,EAAE,MAAM,WAAW,CAAC;AAIxE,SAAS,WAAW,CAAsB,IAAa,EAAE,GAAS;IAChE,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;QAC9C,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC/B,OAAO,IAAI,CAAC,MAAM,KAAK,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC;AAC9C,CAAC;AAED,SAAS,UAAU,CAAC,IAAa,EAAE,IAAc;IAC/C,IAAI,OAAO,GAAG,IAAI,CAAC;IACnB,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,GAAG,CAAC,EAAE,CAAC;YAC/B,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,SAAS,UAAU,CAAC,IAAa;IAK/B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;IACrC,CAAC;IACD,MAAM,CAAC,SAAS,EAAE,GAAG,QAAQ,CAAC,GAAG,IAAI,CAAC;IACtC,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE,CAAC;QAClC,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;IAC/C,CAAC;IACD,MAAM,WAAW,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE;QAC3C,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,EAAE,CAAC;YAClC,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC;QACxC,CAAC;QACD,IAAI,OAAO,OAAO,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YACrC,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;QAC1C,CAAC;QACD,MAAM,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACtC,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;IAC5D,CAAC,CAAC,CAAC;IACH,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IAC7C,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE;QACxB,IAAI,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;YACtB,MAAM,IAAI,KAAK,CAAC,sCAAsC,IAAI,QAAQ,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAChF,CAAC;IACH,CAAC,CAAC,CAAC;IACH,OAAO;QACL,SAAS;QACT,IAAI,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACtD,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC;KACf,CAAC;AACJ,CAAC;AAED,SAAS,aAAa,CAAC,IAAa;IAClC,MAAM,UAAU,GAAG,UAAU,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;IAC5D,IAAI,UAAU,EAAE,CAAC;QACf,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,UAAU,CAAC,UAAU,CAAC,CAAC;QACzD,IAAI,IAAI,CAAC;QACT,IAAI,SAAS,KAAK,CAAC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACzC,IAAI,GAAG,SAAS,CAAC;QACnB,CAAC;aAAM,IAAI,SAAS,KAAK,CAAC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAChD,IAAI,GAAG,SAAS,CAAC;QACnB,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;QACzC,CAAC;QACD,OAAO;YACL,IAAI;YACJ,IAAI;YACJ,IAAI;SACL,CAAC;IACJ,CAAC;AACH,CAAC;AAED,SAAS,aAAa,CACpB,IAAa,EACb,IAA6C,EAC7C,QAAkB;IAElB,MAAM,SAAS,GAAG,UAAU,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;IAC7C,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,OAAO;IACT,CAAC;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvD,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,CAAC;QACzB,MAAM,oBAAoB,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC;QAC7E,IAAI,OAAO,oBAAoB,KAAK,QAAQ,EAAE,CAAC;YAC7C,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;QACjD,CAAC;QACD,IAAI,CAAC,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;QACzC,CAAC;QACD,MAAM,KAAK,GAAG,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QAClC,IAAI,KAAK,CAAC,SAAS,KAAK,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACrD,OAAO;gBACL,IAAI;gBACJ,QAAQ,EAAE,oBAAoB;gBAC9B,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,IAAI,EAAE,KAAK,CAAC,IAAI;aACjB,CAAC;QACJ,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,IAAa;IAC/C,MAAM,MAAM,GACV,aAAa,CAAC,IAAI,CAAC;QACnB,aAAa,CAAC,IAAI,EAAE,mBAAmB,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;QACrE,aAAa,CAAC,IAAI,EAAE,iBAAiB,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC;IAChE,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;IACrD,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,UAAsB;IACpD,MAAM,OAAO,GAAG,mBAAmB,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC;IACvD,IAAI,wBAAwB,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,KAAK,UAAU,CAAC,QAAQ,EAAE,EAAE,CAAC;QAC3E,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;IAChD,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC","sourcesContent":["import { BIP32Interface, bip32 } from '@bitgo-beta/secp256k1';\nimport { Descriptor } from '@bitgo/wasm-utxo';\n\nimport { DescriptorBuilder, getDescriptorFromBuilder } from './builder';\n\ntype NodeUnary<Key extends string> = { [k in Key]: unknown };\n\nfunction isUnaryNode<TKey extends string>(node: unknown, key: TKey): node is NodeUnary<TKey> {\n  if (typeof node !== 'object' || node === null) {\n    return false;\n  }\n  const keys = Object.keys(node);\n  return keys.length === 1 && keys[0] === key;\n}\n\nfunction unwrapNode(node: unknown, path: string[]): unknown {\n  let current = node;\n  for (const key of path) {\n    if (!isUnaryNode(current, key)) {\n      return undefined;\n    }\n    current = current[key];\n  }\n  return current;\n}\n\nfunction parseMulti(node: unknown): {\n  threshold: number;\n  keys: BIP32Interface[];\n  path: string;\n} {\n  if (!Array.isArray(node)) {\n    throw new Error('Unexpected node');\n  }\n  const [threshold, ...keyNodes] = node;\n  if (typeof threshold !== 'number') {\n    throw new Error('Expected threshold number');\n  }\n  const keyWithPath = keyNodes.map((keyNode) => {\n    if (!isUnaryNode(keyNode, 'XPub')) {\n      throw new Error('Expected XPub node');\n    }\n    if (typeof keyNode.XPub !== 'string') {\n      throw new Error('Expected XPub string');\n    }\n    const parts = keyNode.XPub.split('/');\n    return { xpub: parts[0], path: parts.slice(1).join('/') };\n  });\n  const paths = keyWithPath.map((k) => k.path);\n  paths.forEach((path, i) => {\n    if (path !== paths[0]) {\n      throw new Error(`Expected all paths to be the same: ${path} !== ${paths[0]}`);\n    }\n  });\n  return {\n    threshold,\n    keys: keyWithPath.map((k) => bip32.fromBase58(k.xpub)),\n    path: paths[0],\n  };\n}\n\nfunction parseWshMulti(node: unknown): DescriptorBuilder | undefined {\n  const wshMsMulti = unwrapNode(node, ['Wsh', 'Ms', 'Multi']);\n  if (wshMsMulti) {\n    const { threshold, keys, path } = parseMulti(wshMsMulti);\n    let name;\n    if (threshold === 2 && keys.length === 2) {\n      name = 'Wsh2Of2';\n    } else if (threshold === 2 && keys.length === 3) {\n      name = 'Wsh2Of3';\n    } else {\n      throw new Error('Unexpected multisig');\n    }\n    return {\n      name,\n      keys,\n      path,\n    };\n  }\n}\n\nfunction parseCltvDrop(\n  node: unknown,\n  name: 'Wsh2Of3CltvDrop' | 'ShWsh2Of3CltvDrop',\n  wrapping: string[]\n): DescriptorBuilder | undefined {\n  const unwrapped = unwrapNode(node, wrapping);\n  if (!unwrapped) {\n    return;\n  }\n  if (Array.isArray(unwrapped) && unwrapped.length === 2) {\n    const [a, b] = unwrapped;\n    const dropAfterAbsLocktime = unwrapNode(a, ['Drop', 'After', 'absLockTime']);\n    if (typeof dropAfterAbsLocktime !== 'number') {\n      throw new Error('Expected absLockTime number');\n    }\n    if (!isUnaryNode(b, 'Multi')) {\n      throw new Error('Expected Multi node');\n    }\n    const multi = parseMulti(b.Multi);\n    if (multi.threshold === 2 && multi.keys.length === 3) {\n      return {\n        name,\n        locktime: dropAfterAbsLocktime,\n        keys: multi.keys,\n        path: multi.path,\n      };\n    }\n  }\n}\n\nexport function parseDescriptorNode(node: unknown): DescriptorBuilder {\n  const parsed =\n    parseWshMulti(node) ??\n    parseCltvDrop(node, 'ShWsh2Of3CltvDrop', ['Sh', 'Wsh', 'Ms', 'AndV']) ??\n    parseCltvDrop(node, 'Wsh2Of3CltvDrop', ['Wsh', 'Ms', 'AndV']);\n  if (!parsed) {\n    throw new Error('Failed to parse descriptor node');\n  }\n  return parsed;\n}\n\nexport function parseDescriptor(descriptor: Descriptor): DescriptorBuilder {\n  const builder = parseDescriptorNode(descriptor.node());\n  if (getDescriptorFromBuilder(builder).toString() !== descriptor.toString()) {\n    throw new Error('Failed to parse descriptor');\n  }\n  return builder;\n}\n"]}

package/dist/esm/descriptor/createWallet/createDescriptorWallet.d.ts

@@ -0,0 +1,20 @@
+import { BitGoAPI } from '@bitgo-beta/sdk-api';
+import { AbstractUtxoCoin } from '../../abstractUtxoCoin';
+import { IDescriptorWallet } from '../descriptorWallet';
+import { NamedDescriptor } from '../NamedDescriptor';
+import { DescriptorFromKeys } from './createDescriptors';
+export declare function createDescriptorWallet(bitgo: BitGoAPI, coin: AbstractUtxoCoin, { descriptors, ...params }: {
+    type: 'hot';
+    label: string;
+    enterprise: string;
+    keys: string[];
+    descriptors: NamedDescriptor[];
+}): Promise<IDescriptorWallet>;
+export declare function createDescriptorWalletWithWalletPassphrase(bitgo: BitGoAPI, coin: AbstractUtxoCoin, { enterprise, walletPassphrase, descriptorsFromKeys, ...params }: {
+    label: string;
+    enterprise: string;
+    walletPassphrase: string;
+    descriptorsFromKeys: DescriptorFromKeys;
+    [key: string]: unknown;
+}): Promise<IDescriptorWallet>;
+//# sourceMappingURL=createDescriptorWallet.d.ts.map

package/dist/esm/descriptor/createWallet/createDescriptorWallet.js

@@ -0,0 +1,37 @@
+import { bip32 } from '@bitgo-beta/secp256k1';
+import { Wallet } from '@bitgo-beta/sdk-core';
+export async function createDescriptorWallet(bitgo, coin, { descriptors, ...params }) {
+    // We don't use `coin.wallets().add` here because it does a bunch of validation that does not make sense
+    // for descriptor wallets.
+    const newWallet = await bitgo
+        .post(coin.url('/wallet/add'))
+        .send({
+        ...params,
+        coinSpecific: { descriptors },
+    })
+        .result();
+    return new Wallet(bitgo, coin, newWallet);
+}
+export async function createDescriptorWalletWithWalletPassphrase(bitgo, coin, { enterprise, walletPassphrase, descriptorsFromKeys, ...params }) {
+    const userKeychain = await coin.keychains().createUserKeychain(walletPassphrase);
+    const backupKeychain = await coin.keychains().createBackup();
+    const bitgoKeychain = await coin.keychains().createBitGo({ enterprise });
+    if (!userKeychain.prv) {
+        throw new Error('Missing private key');
+    }
+    const userKey = bip32.fromBase58(userKeychain.prv);
+    const cosigners = [backupKeychain, bitgoKeychain].map((keychain) => {
+        if (!keychain.pub) {
+            throw new Error('Missing public key');
+        }
+        return bip32.fromBase58(keychain.pub);
+    });
+    return createDescriptorWallet(bitgo, coin, {
+        ...params,
+        type: 'hot',
+        enterprise,
+        keys: [userKeychain.id, backupKeychain.id, bitgoKeychain.id],
+        descriptors: descriptorsFromKeys(userKey, cosigners),
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/descriptor/createWallet/createDescriptors.d.ts

@@ -0,0 +1,12 @@
+import { BIP32Interface } from '@bitgo-beta/utxo-lib';
+import { NamedDescriptor } from '../NamedDescriptor';
+export type DescriptorFromKeys = (userKey: BIP32Interface, cosigners: BIP32Interface[]) => NamedDescriptor[];
+/**
+ * Create a pair of external and internal descriptors for a 2-of-3 multisig wallet.
+ *
+ * @param userKey
+ * @param cosigners
+ * @constructor
+ */
+export declare const DefaultWsh2Of3: DescriptorFromKeys;
+//# sourceMappingURL=createDescriptors.d.ts.map