utxo-lib 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2011-2017 bitcoinjs-lib contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,59 @@
+# BitGo UTXO library
+
+This library is a wrapper around [bitcoinjs-lib](https://github.com/bitcoinjs/bitcoinjs-lib) adding altcoin support.
+
+## Features
+- Multicoin support: Configurable behaviour based on [network](https://github.com/BitGo/bitgo-utxo-lib/blob/master/src/networks.js) objects.
+- Backed by [BitGo](https://www.bitgo.com/info/)
+
+## Installation
+
+``` bash
+# using npm
+npm install @bitgo/utxo-lib
+
+# using yarn
+yarn add @bitgo/utxo-lib
+```
+
+## Setup
+
+JavaScript (ESM)
+``` javascript
+import * as utxolib from '@bitgo/utxo-lib'
+```
+
+NodeJS (CJS)
+``` javascript
+const utxolib = require('@bitgo/utxo-lib')
+```
+
+## Usage
+
+Support for parsing and building altcoin transactions is provided by the following methods
+
+``` typescript
+utxolib.bitgo.createTransactionFromBuffer(buffer, network): UtxoTransaction
+// (similarly `createTransactionFromHex(string, network)`)
+
+utxolib.bitgo.createTransactionBuilderForNetwork(network): UtxoTransactionBuilder
+
+utxolib.bitgo.createTransactionBuilderFromTransaction(tx): UtxoTransactionBuilder
+```
+
+The `UtxoTransaction(Builder)` classes have the same interface as the `Transaction` type in `bitcoinjs-lib` .
+
+## Supported coins
+
+|Network|Mainnet|Testnet|
+|---|---|---|
+|Bitcoin|`utxolib.networks.bitcoin`|`utxolib.networks.testnet`|
+|Bitcoin Cash|`utxolib.networks.bitcoincash`|`utxolib.networks.bitcoincashTestnet`|
+|Bitcoin Gold|`utxolib.networks.bitcoingold`|`utxolib.networks.bitcoingoldTestnet`|
+|Bitcoin SV (Satoshi Vision)|`utxolib.networks.bitcoinsv`|`utxolib.networks.bitcoinsvTestnet`|
+|Dash|`utxolib.networks.dash`|`utxolib.networks.dash`|
+|eCash|`utxolib.networks.ecash`|`utxolib.networks.ecashTestnet`|
+|Litecoin|`utxolib.networks.litecoin`|`utxolib.networks.litecoinTest`|
+|Zcash|`utxolib.networks.zcash`|`utxolib.networks.zcashTest`|
+
+> [Bitcoin SV](https://blog.bitgo.com/bsv-deprecation-6b3fff4df34c) no longer supports sending funds to BitGo wallets. Existing customers with Bitcoin SV in BitGo wallets will still be able to access and sweep funds to an external Bitcoin SV wallet.

package/dist/src/address.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import * as bitcoinjs from 'bitcoinjs-lib';
+import { Base58CheckResult, Bech32Result } from 'bitcoinjs-lib/src/address';
+import { Network } from './networks';
+export declare function fromOutputScript(outputScript: Buffer, network: Network): string;
+export declare function toOutputScript(address: string, network: Network): Buffer;
+export declare function toBase58Check(hash: Buffer, version: number, network: Network): string;
+export declare function fromBase58Check(address: string, network: Network): Base58CheckResult;
+export declare const fromBech32: typeof bitcoinjs.address.fromBech32, toBech32: typeof bitcoinjs.address.toBech32;
+export { Base58CheckResult, Bech32Result };
+//# sourceMappingURL=address.d.ts.map

package/dist/src/address.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["../../src/address.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,SAAS,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAG5E,OAAO,EAA2B,OAAO,EAAE,MAAM,YAAY,CAAC;AAE9D,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAK/E;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAKxE;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAKrF;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,iBAAiB,CAKpF;AAED,eAAO,MAAQ,UAAU,uCAAE,QAAQ,mCAAsB,CAAC;AAE1D,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,CAAC"}

package/dist/src/address.js

@@ -0,0 +1,37 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBech32 = exports.fromBech32 = exports.fromBase58Check = exports.toBase58Check = exports.toOutputScript = exports.fromOutputScript = void 0;
+const bitcoinjs = require("bitcoinjs-lib");
+const zcashAddress = require("../src/bitgo/zcash/address");
+const networks_1 = require("./networks");
+function fromOutputScript(outputScript, network) {
+    if (networks_1.isValidNetwork(network) && networks_1.isZcash(network)) {
+        return zcashAddress.fromOutputScript(outputScript, network);
+    }
+    return bitcoinjs.address.fromOutputScript(outputScript, network);
+}
+exports.fromOutputScript = fromOutputScript;
+function toOutputScript(address, network) {
+    if (networks_1.isValidNetwork(network) && networks_1.isZcash(network)) {
+        return zcashAddress.toOutputScript(address, network);
+    }
+    return bitcoinjs.address.toOutputScript(address, network);
+}
+exports.toOutputScript = toOutputScript;
+function toBase58Check(hash, version, network) {
+    if (networks_1.isValidNetwork(network) && networks_1.isZcash(network)) {
+        return zcashAddress.toBase58Check(hash, version);
+    }
+    return bitcoinjs.address.toBase58Check(hash, version);
+}
+exports.toBase58Check = toBase58Check;
+function fromBase58Check(address, network) {
+    if (networks_1.isValidNetwork(network) && networks_1.isZcash(network)) {
+        return zcashAddress.fromBase58Check(address);
+    }
+    return bitcoinjs.address.fromBase58Check(address);
+}
+exports.fromBase58Check = fromBase58Check;
+_a = bitcoinjs.address, exports.fromBech32 = _a.fromBech32, exports.toBech32 = _a.toBech32;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/addressFormat.d.ts

@@ -0,0 +1,53 @@
+/// <reference types="node" />
+/**
+ * Implements methods for nonstandard (non-canonical) address formats.
+ *
+ * Use `toOutputScriptTryFormats()` instead of `toOutputScript()` to parse addresses in
+ * non-canonical formats
+ */
+import { Network } from './networks';
+export declare const addressFormats: readonly ["default", "cashaddr"];
+export declare type AddressFormat = typeof addressFormats[number];
+/**
+ * @param format
+ * @param network
+ * @return true iff format is supported for network
+ */
+export declare function isSupportedAddressFormat(format: AddressFormat, network: Network): boolean;
+/**
+ * @param outputScript
+ * @param format
+ * @param network
+ * @return address formatted using provided AddressFormat
+ */
+export declare function fromOutputScriptWithFormat(outputScript: Buffer, format: AddressFormat, network: Network): string;
+/**
+ * @param address
+ * @param format
+ * @param network
+ * @return output script parsed with provided AddressFormat
+ */
+export declare function toOutputScriptWithFormat(address: string, format: AddressFormat, network: Network): Buffer;
+/**
+ * Attempts to parse address with different address formats, returns first hit.
+ * @param address
+ * @param network
+ * @param formats - defaults to all supported address formats for network
+ * @return tuple with [AddressFormat, Buffer] containing format and parsed output script
+ */
+export declare function toOutputScriptAndFormat(address: string, network: Network, formats?: AddressFormat[]): [AddressFormat, Buffer];
+/**
+ * Same as `toOutputScriptAndFormat`, only returning script
+ * @param address - {@see toOutputScriptAndFormat}
+ * @param network - {@see toOutputScriptAndFormat}
+ * @param formats - {@see toOutputScriptAndFormat}
+ * @return parsed output script
+ */
+export declare function toOutputScriptTryFormats(address: string, network: Network, formats?: AddressFormat[]): Buffer;
+/**
+ * @param address
+ * @param network
+ * @return address in canonical format
+ */
+export declare function toCanonicalFormat(address: string, network: Network): string;
+//# sourceMappingURL=addressFormat.d.ts.map

package/dist/src/addressFormat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addressFormat.d.ts","sourceRoot":"","sources":["../../src/addressFormat.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;AACH,OAAO,EAA8B,OAAO,EAAY,MAAM,YAAY,CAAC;AAK3E,eAAO,MAAM,cAAc,kCAAmC,CAAC;AAE/D,oBAAY,aAAa,GAAG,OAAO,cAAc,CAAC,MAAM,CAAC,CAAC;AAE1D;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAQzF;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAYhH;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAYzG;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,EAChB,OAAO,CAAC,EAAE,aAAa,EAAE,GACxB,CAAC,aAAa,EAAE,MAAM,CAAC,CAczB;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,aAAa,EAAE,GAAG,MAAM,CAG7G;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAE3E"}

package/dist/src/addressFormat.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCanonicalFormat = exports.toOutputScriptTryFormats = exports.toOutputScriptAndFormat = exports.toOutputScriptWithFormat = exports.fromOutputScriptWithFormat = exports.isSupportedAddressFormat = exports.addressFormats = void 0;
+/**
+ * Implements methods for nonstandard (non-canonical) address formats.
+ *
+ * Use `toOutputScriptTryFormats()` instead of `toOutputScript()` to parse addresses in
+ * non-canonical formats
+ */
+const networks_1 = require("./networks");
+const address_1 = require("./address");
+const bitgo_1 = require("./bitgo");
+exports.addressFormats = ['default', 'cashaddr'];
+/**
+ * @param format
+ * @param network
+ * @return true iff format is supported for network
+ */
+function isSupportedAddressFormat(format, network) {
+    switch (format) {
+        case 'default':
+            return true;
+        case 'cashaddr':
+            return [networks_1.networks.bitcoincash, networks_1.networks.ecash].includes(networks_1.getMainnet(network));
+    }
+    throw new Error(`unknown address format ${format}`);
+}
+exports.isSupportedAddressFormat = isSupportedAddressFormat;
+/**
+ * @param outputScript
+ * @param format
+ * @param network
+ * @return address formatted using provided AddressFormat
+ */
+function fromOutputScriptWithFormat(outputScript, format, network) {
+    if (!isSupportedAddressFormat(format, network)) {
+        throw new Error(`unsupported address format ${format} for network ${networks_1.getNetworkName(network)}`);
+    }
+    switch (networks_1.getMainnet(network)) {
+        case networks_1.networks.bitcoincash:
+        case networks_1.networks.ecash:
+            return bitgo_1.bcashAddress.fromOutputScriptWithFormat(outputScript, format, network);
+        default:
+            return address_1.fromOutputScript(outputScript, network);
+    }
+}
+exports.fromOutputScriptWithFormat = fromOutputScriptWithFormat;
+/**
+ * @param address
+ * @param format
+ * @param network
+ * @return output script parsed with provided AddressFormat
+ */
+function toOutputScriptWithFormat(address, format, network) {
+    if (!isSupportedAddressFormat(format, network)) {
+        throw new Error(`unsupported address format ${format} for network ${networks_1.getNetworkName(network)}`);
+    }
+    switch (networks_1.getMainnet(network)) {
+        case networks_1.networks.bitcoincash:
+        case networks_1.networks.ecash:
+            return bitgo_1.bcashAddress.toOutputScriptWithFormat(address, format, network);
+        default:
+            return address_1.toOutputScript(address, network);
+    }
+}
+exports.toOutputScriptWithFormat = toOutputScriptWithFormat;
+/**
+ * Attempts to parse address with different address formats, returns first hit.
+ * @param address
+ * @param network
+ * @param formats - defaults to all supported address formats for network
+ * @return tuple with [AddressFormat, Buffer] containing format and parsed output script
+ */
+function toOutputScriptAndFormat(address, network, formats) {
+    if (!formats) {
+        formats = exports.addressFormats.filter((f) => isSupportedAddressFormat(f, network));
+    }
+    for (const format of formats) {
+        try {
+            return [format, toOutputScriptWithFormat(address, format, network)];
+        }
+        catch (e) {
+            // try next
+        }
+    }
+    throw new Error(`could not parse outputScript [formats=${formats}]`);
+}
+exports.toOutputScriptAndFormat = toOutputScriptAndFormat;
+/**
+ * Same as `toOutputScriptAndFormat`, only returning script
+ * @param address - {@see toOutputScriptAndFormat}
+ * @param network - {@see toOutputScriptAndFormat}
+ * @param formats - {@see toOutputScriptAndFormat}
+ * @return parsed output script
+ */
+function toOutputScriptTryFormats(address, network, formats) {
+    const [, outputScript] = toOutputScriptAndFormat(address, network, formats);
+    return outputScript;
+}
+exports.toOutputScriptTryFormats = toOutputScriptTryFormats;
+/**
+ * @param address
+ * @param network
+ * @return address in canonical format
+ */
+function toCanonicalFormat(address, network) {
+    return address_1.fromOutputScript(toOutputScriptTryFormats(address, network), network);
+}
+exports.toCanonicalFormat = toCanonicalFormat;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"addressFormat.js","sourceRoot":"","sources":["../../src/addressFormat.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Implements methods for nonstandard (non-canonical) address formats.\n *\n * Use `toOutputScriptTryFormats()` instead of `toOutputScript()` to parse addresses in\n * non-canonical formats\n */\nimport { getMainnet, getNetworkName, Network, networks } from './networks';\nimport { fromOutputScript, toOutputScript } from './address';\n\nimport { bcashAddress } from './bitgo';\n\nexport const addressFormats = ['default', 'cashaddr'] as const;\n\nexport type AddressFormat = typeof addressFormats[number];\n\n/**\n * @param format\n * @param network\n * @return true iff format is supported for network\n */\nexport function isSupportedAddressFormat(format: AddressFormat, network: Network): boolean {\n  switch (format) {\n    case 'default':\n      return true;\n    case 'cashaddr':\n      return [networks.bitcoincash, networks.ecash].includes(getMainnet(network));\n  }\n  throw new Error(`unknown address format ${format}`);\n}\n\n/**\n * @param outputScript\n * @param format\n * @param network\n * @return address formatted using provided AddressFormat\n */\nexport function fromOutputScriptWithFormat(outputScript: Buffer, format: AddressFormat, network: Network): string {\n  if (!isSupportedAddressFormat(format, network)) {\n    throw new Error(`unsupported address format ${format} for network ${getNetworkName(network)}`);\n  }\n\n  switch (getMainnet(network)) {\n    case networks.bitcoincash:\n    case networks.ecash:\n      return bcashAddress.fromOutputScriptWithFormat(outputScript, format, network);\n    default:\n      return fromOutputScript(outputScript, network);\n  }\n}\n\n/**\n * @param address\n * @param format\n * @param network\n * @return output script parsed with provided AddressFormat\n */\nexport function toOutputScriptWithFormat(address: string, format: AddressFormat, network: Network): Buffer {\n  if (!isSupportedAddressFormat(format, network)) {\n    throw new Error(`unsupported address format ${format} for network ${getNetworkName(network)}`);\n  }\n\n  switch (getMainnet(network)) {\n    case networks.bitcoincash:\n    case networks.ecash:\n      return bcashAddress.toOutputScriptWithFormat(address, format, network);\n    default:\n      return toOutputScript(address, network);\n  }\n}\n\n/**\n * Attempts to parse address with different address formats, returns first hit.\n * @param address\n * @param network\n * @param formats - defaults to all supported address formats for network\n * @return tuple with [AddressFormat, Buffer] containing format and parsed output script\n */\nexport function toOutputScriptAndFormat(\n  address: string,\n  network: Network,\n  formats?: AddressFormat[]\n): [AddressFormat, Buffer] {\n  if (!formats) {\n    formats = addressFormats.filter((f) => isSupportedAddressFormat(f, network));\n  }\n\n  for (const format of formats) {\n    try {\n      return [format, toOutputScriptWithFormat(address, format, network)];\n    } catch (e) {\n      // try next\n    }\n  }\n\n  throw new Error(`could not parse outputScript [formats=${formats}]`);\n}\n\n/**\n * Same as `toOutputScriptAndFormat`, only returning script\n * @param address - {@see toOutputScriptAndFormat}\n * @param network - {@see toOutputScriptAndFormat}\n * @param formats - {@see toOutputScriptAndFormat}\n * @return parsed output script\n */\nexport function toOutputScriptTryFormats(address: string, network: Network, formats?: AddressFormat[]): Buffer {\n  const [, outputScript] = toOutputScriptAndFormat(address, network, formats);\n  return outputScript;\n}\n\n/**\n * @param address\n * @param network\n * @return address in canonical format\n */\nexport function toCanonicalFormat(address: string, network: Network): string {\n  return fromOutputScript(toOutputScriptTryFormats(address, network), network);\n}\n"]}

package/dist/src/bitgo/Musig2.d.ts

@@ -0,0 +1,51 @@
+/// <reference types="node" />
+import { ProprietaryKeyValueData, UtxoPsbt } from './UtxoPsbt';
+import { BIP32Interface } from 'bip32';
+import { Tuple } from './types';
+/**
+ *  Participant key value object.
+ */
+export interface PsbtMusig2ParticipantsKeyValueData {
+    tapOutputKey: Buffer;
+    tapInternalKey: Buffer;
+    participantPubKeys: Tuple<Buffer>;
+}
+/**
+ *  Nonce key value object.
+ */
+export interface PsbtMusig2NoncesKeyValueData {
+    participantPubKey: Buffer;
+    tapOutputKey: Buffer;
+    pubNonces: Buffer;
+}
+/**
+ * Psbt proprietary key val util function for participants pub keys. SubType is 0x01
+ * Ref: https://gist.github.com/sanket1729/4b525c6049f4d9e034d27368c49f28a6
+ * @return x-only tapOutputKey||tapInternalKey as sub keydata, plain sigining participant keys as valuedata
+ */
+export declare function encodePsbtMusig2ParticipantsKeyValData(participantsKeyValData: PsbtMusig2ParticipantsKeyValueData): ProprietaryKeyValueData;
+/**
+ * Psbt proprietary key val util function for pub nonce. SubType is 0x02
+ * Ref: https://gist.github.com/sanket1729/4b525c6049f4d9e034d27368c49f28a6
+ * @return plain-participantPubKey||x-only-tapOutputKey as sub keydata, 66 bytes of 2 pub nonces as valuedata
+ */
+export declare function encodePsbtMusig2PubNonceKeyValData(noncesKeyValueData: PsbtMusig2NoncesKeyValueData): ProprietaryKeyValueData;
+/**
+ * Decodes proprietary key value data for participant pub keys
+ * @param kv
+ */
+export declare function decodePsbtMusig2ParticipantsKeyValData(kv: ProprietaryKeyValueData): PsbtMusig2ParticipantsKeyValueData;
+export declare function createTapInternalKey(plainPubKeys: Buffer[]): Buffer;
+export declare function createTapOutputKey(internalPubKey: Buffer, tapTreeRoot: Buffer): Buffer;
+/**
+ * Generates and sets Musig2 nonces to p2trMusig2 key path spending inputs.
+ * tapInternalkey, tapMerkleRoot, tapBip32Derivation for rootWalletKey are required per p2trMusig2 key path input.
+ * Also participant keys are required from psbt proprietary key values.
+ * Ref: https://gist.github.com/sanket1729/4b525c6049f4d9e034d27368c49f28a6
+ * @param psbt
+ * @param rootWalletKey
+ * @param sessionId If provided it must either be a counter unique to this secret key,
+ * (converted to an array of 32 bytes), or 32 uniformly random bytes.
+ */
+export declare function setMusig2Nonces(psbt: UtxoPsbt, rootWalletKey: BIP32Interface, sessionId?: Buffer): void;
+//# sourceMappingURL=Musig2.d.ts.map

package/dist/src/bitgo/Musig2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Musig2.d.ts","sourceRoot":"","sources":["../../../src/bitgo/Musig2.ts"],"names":[],"mappings":";AAAA,OAAO,EAA+B,uBAAuB,EAAE,QAAQ,EAAyB,MAAM,YAAY,CAAC;AAEnH,OAAO,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAKhC;;GAEG;AACH,MAAM,WAAW,kCAAkC;IACjD,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,4BAA4B;IAC3C,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,wBAAgB,sCAAsC,CACpD,sBAAsB,EAAE,kCAAkC,GACzD,uBAAuB,CAWzB;AAED;;;;GAIG;AACH,wBAAgB,kCAAkC,CAChD,kBAAkB,EAAE,4BAA4B,GAC/C,uBAAuB,CAczB;AAED;;;GAGG;AACH,wBAAgB,sCAAsC,CACpD,EAAE,EAAE,uBAAuB,GAC1B,kCAAkC,CAuBpC;AAED,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,MAAM,CAGnE;AAED,wBAAgB,kBAAkB,CAAC,cAAc,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAKtF;AA6FD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAE,aAAa,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAavG"}

package/dist/src/bitgo/Musig2.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setMusig2Nonces = exports.createTapOutputKey = exports.createTapInternalKey = exports.decodePsbtMusig2ParticipantsKeyValData = exports.encodePsbtMusig2PubNonceKeyValData = exports.encodePsbtMusig2ParticipantsKeyValData = void 0;
+const UtxoPsbt_1 = require("./UtxoPsbt");
+const outputScripts_1 = require("./outputScripts");
+const noble_ecc_1 = require("../noble_ecc");
+const taproot_1 = require("../taproot");
+const utils_1 = require("bip174/src/lib/utils");
+/**
+ * Psbt proprietary key val util function for participants pub keys. SubType is 0x01
+ * Ref: https://gist.github.com/sanket1729/4b525c6049f4d9e034d27368c49f28a6
+ * @return x-only tapOutputKey||tapInternalKey as sub keydata, plain sigining participant keys as valuedata
+ */
+function encodePsbtMusig2ParticipantsKeyValData(participantsKeyValData) {
+    const keydata = [participantsKeyValData.tapOutputKey, participantsKeyValData.tapInternalKey].map((pubkey) => outputScripts_1.checkXOnlyPublicKey(pubkey));
+    const value = participantsKeyValData.participantPubKeys.map((pubkey) => outputScripts_1.checkPlainPublicKey(pubkey));
+    const key = {
+        identifier: UtxoPsbt_1.PSBT_PROPRIETARY_IDENTIFIER,
+        subtype: UtxoPsbt_1.ProprietaryKeySubtype.MUSIG2_PARTICIPANT_PUB_KEYS,
+        keydata: Buffer.concat(keydata),
+    };
+    return { key, value: Buffer.concat(value) };
+}
+exports.encodePsbtMusig2ParticipantsKeyValData = encodePsbtMusig2ParticipantsKeyValData;
+/**
+ * Psbt proprietary key val util function for pub nonce. SubType is 0x02
+ * Ref: https://gist.github.com/sanket1729/4b525c6049f4d9e034d27368c49f28a6
+ * @return plain-participantPubKey||x-only-tapOutputKey as sub keydata, 66 bytes of 2 pub nonces as valuedata
+ */
+function encodePsbtMusig2PubNonceKeyValData(noncesKeyValueData) {
+    if (noncesKeyValueData.pubNonces.length !== 66) {
+        throw new Error(`Invalid pubNonces length ${noncesKeyValueData.pubNonces.length}`);
+    }
+    const keydata = Buffer.concat([
+        outputScripts_1.checkPlainPublicKey(noncesKeyValueData.participantPubKey),
+        outputScripts_1.checkXOnlyPublicKey(noncesKeyValueData.tapOutputKey),
+    ]);
+    const key = {
+        identifier: UtxoPsbt_1.PSBT_PROPRIETARY_IDENTIFIER,
+        subtype: UtxoPsbt_1.ProprietaryKeySubtype.MUSIG2_PUB_NONCE,
+        keydata,
+    };
+    return { key, value: noncesKeyValueData.pubNonces };
+}
+exports.encodePsbtMusig2PubNonceKeyValData = encodePsbtMusig2PubNonceKeyValData;
+/**
+ * Decodes proprietary key value data for participant pub keys
+ * @param kv
+ */
+function decodePsbtMusig2ParticipantsKeyValData(kv) {
+    if (kv.key.identifier !== UtxoPsbt_1.PSBT_PROPRIETARY_IDENTIFIER ||
+        kv.key.subtype !== UtxoPsbt_1.ProprietaryKeySubtype.MUSIG2_PARTICIPANT_PUB_KEYS) {
+        throw new Error(`Invalid identifier ${kv.key.identifier} or subtype ${kv.key.subtype} for participants pub keys`);
+    }
+    const key = kv.key.keydata;
+    if (key.length !== 64) {
+        throw new Error(`Invalid keydata size ${key.length} for participant pub keys`);
+    }
+    const value = kv.value;
+    if (value.length !== 66) {
+        throw new Error(`Invalid valuedata size ${value.length} for participant pub keys`);
+    }
+    const participantPubKeys = [value.subarray(0, 33), value.subarray(33)];
+    if (participantPubKeys[0].equals(participantPubKeys[1])) {
+        throw new Error(`Duplicate participant pub keys found`);
+    }
+    return { tapOutputKey: key.subarray(0, 32), tapInternalKey: key.subarray(32), participantPubKeys };
+}
+exports.decodePsbtMusig2ParticipantsKeyValData = decodePsbtMusig2ParticipantsKeyValData;
+function createTapInternalKey(plainPubKeys) {
+    plainPubKeys.forEach((pubKey) => outputScripts_1.checkPlainPublicKey(pubKey));
+    return Buffer.from(noble_ecc_1.musig.getXOnlyPubkey(noble_ecc_1.musig.keyAgg(noble_ecc_1.musig.keySort(plainPubKeys))));
+}
+exports.createTapInternalKey = createTapInternalKey;
+function createTapOutputKey(internalPubKey, tapTreeRoot) {
+    if (tapTreeRoot.length !== 32) {
+        throw new Error(`Invalid tapTreeRoot size ${tapTreeRoot.length}`);
+    }
+    return Buffer.from(taproot_1.tapTweakPubkey(noble_ecc_1.ecc, outputScripts_1.toXOnlyPublicKey(internalPubKey), tapTreeRoot).xOnlyPubkey);
+}
+exports.createTapOutputKey = createTapOutputKey;
+function deriveWalletPubKey(tapBip32Derivations, rootWalletKey) {
+    const myDerivations = tapBip32Derivations.filter((bipDv) => {
+        return bipDv.masterFingerprint.equals(rootWalletKey.fingerprint);
+    });
+    if (!myDerivations.length) {
+        throw new Error('Need one tapBip32Derivation masterFingerprint to match the rootWalletKey fingerprint');
+    }
+    const myDerivation = myDerivations.filter((bipDv) => {
+        const publicKey = rootWalletKey.derivePath(bipDv.path).publicKey;
+        return bipDv.pubkey.equals(outputScripts_1.toXOnlyPublicKey(publicKey));
+    });
+    if (myDerivation.length !== 1) {
+        throw new Error('root wallet key should derive one tapBip32Derivation');
+    }
+    return rootWalletKey.derivePath(myDerivation[0].path).publicKey;
+}
+function getMusig2NonceKeyValueData(psbt, inputIndex, rootWalletKey, sessionId) {
+    var _a;
+    const input = utils_1.checkForInput(psbt.data.inputs, inputIndex);
+    if (!input.tapInternalKey) {
+        return;
+    }
+    if (!input.tapMerkleRoot) {
+        throw new Error('tapMerkleRoot is required to generate nonce');
+    }
+    if (!((_a = input.tapBip32Derivation) === null || _a === void 0 ? void 0 : _a.length)) {
+        throw new Error('tapBip32Derivation is required to generate nonce');
+    }
+    const participantsKeyVals = psbt.getProprietaryKeyVals(inputIndex, {
+        identifier: UtxoPsbt_1.PSBT_PROPRIETARY_IDENTIFIER,
+        subtype: UtxoPsbt_1.ProprietaryKeySubtype.MUSIG2_PARTICIPANT_PUB_KEYS,
+    });
+    if (participantsKeyVals.length !== 1) {
+        throw new Error(`Found ${participantsKeyVals.length} matching participant key value instead of 1`);
+    }
+    const participantKeyValData = decodePsbtMusig2ParticipantsKeyValData(participantsKeyVals[0]);
+    const participantPubKeys = participantKeyValData.participantPubKeys;
+    const tapInternalKey = createTapInternalKey(participantPubKeys);
+    if (!tapInternalKey.equals(participantKeyValData.tapInternalKey)) {
+        throw new Error('Invalid participants keyata tapInternalKey');
+    }
+    const tapOutputKey = createTapOutputKey(tapInternalKey, input.tapMerkleRoot);
+    if (!tapOutputKey.equals(participantKeyValData.tapOutputKey)) {
+        throw new Error('Invalid participants keyata tapOutputKey');
+    }
+    if (!tapInternalKey.equals(input.tapInternalKey)) {
+        throw new Error('tapInternalKey and aggregated participant pub keys does not match');
+    }
+    const derivedPubKey = deriveWalletPubKey(input.tapBip32Derivation, rootWalletKey);
+    const participantPubKey = participantPubKeys.find((pubKey) => pubKey.equals(derivedPubKey));
+    if (!Buffer.isBuffer(participantPubKey)) {
+        throw new Error('participant plain pub key should match one tapBip32Derivation plain pub key');
+    }
+    const { hash } = psbt.getTaprootHashForSigChecked(inputIndex);
+    const nonceGenArgs = {
+        sessionId,
+        publicKey: participantPubKey,
+        xOnlyPublicKey: tapOutputKey,
+        msg: hash,
+        secretKey: rootWalletKey.privateKey,
+    };
+    const pubNonces = Buffer.from(noble_ecc_1.musig.nonceGen(nonceGenArgs));
+    return encodePsbtMusig2PubNonceKeyValData({
+        participantPubKey,
+        tapOutputKey,
+        pubNonces,
+    });
+}
+/**
+ * Generates and sets Musig2 nonces to p2trMusig2 key path spending inputs.
+ * tapInternalkey, tapMerkleRoot, tapBip32Derivation for rootWalletKey are required per p2trMusig2 key path input.
+ * Also participant keys are required from psbt proprietary key values.
+ * Ref: https://gist.github.com/sanket1729/4b525c6049f4d9e034d27368c49f28a6
+ * @param psbt
+ * @param rootWalletKey
+ * @param sessionId If provided it must either be a counter unique to this secret key,
+ * (converted to an array of 32 bytes), or 32 uniformly random bytes.
+ */
+function setMusig2Nonces(psbt, rootWalletKey, sessionId) {
+    if (rootWalletKey.isNeutered()) {
+        throw new Error('private key is required to generate nonce');
+    }
+    if (Buffer.isBuffer(sessionId) && sessionId.length !== 32) {
+        throw new Error(`Invalid sessionId size ${sessionId.length}`);
+    }
+    psbt.data.inputs.forEach((input, inputIndex) => {
+        const noncesKeyValueData = getMusig2NonceKeyValueData(psbt, inputIndex, rootWalletKey, sessionId);
+        if (noncesKeyValueData) {
+            psbt.addProprietaryKeyValToInput(inputIndex, noncesKeyValueData);
+        }
+    });
+}
+exports.setMusig2Nonces = setMusig2Nonces;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Musig2.js","sourceRoot":"","sources":["../../../src/bitgo/Musig2.ts"],"names":[],"mappings":"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","sourcesContent":["import { PSBT_PROPRIETARY_IDENTIFIER, ProprietaryKeyValueData, UtxoPsbt, ProprietaryKeySubtype } from './UtxoPsbt';\nimport { checkPlainPublicKey, checkXOnlyPublicKey, toXOnlyPublicKey } from './outputScripts';\nimport { BIP32Interface } from 'bip32';\nimport { ecc, musig } from '../noble_ecc';\nimport { Tuple } from './types';\nimport { tapTweakPubkey } from '../taproot';\nimport { TapBip32Derivation } from 'bip174/src/lib/interfaces';\nimport { checkForInput } from 'bip174/src/lib/utils';\n\n/**\n *  Participant key value object.\n */\nexport interface PsbtMusig2ParticipantsKeyValueData {\n  tapOutputKey: Buffer;\n  tapInternalKey: Buffer;\n  participantPubKeys: Tuple<Buffer>;\n}\n\n/**\n *  Nonce key value object.\n */\nexport interface PsbtMusig2NoncesKeyValueData {\n  participantPubKey: Buffer;\n  tapOutputKey: Buffer;\n  pubNonces: Buffer;\n}\n\n/**\n * Psbt proprietary key val util function for participants pub keys. SubType is 0x01\n * Ref: https://gist.github.com/sanket1729/4b525c6049f4d9e034d27368c49f28a6\n * @return x-only tapOutputKey||tapInternalKey as sub keydata, plain sigining participant keys as valuedata\n */\nexport function encodePsbtMusig2ParticipantsKeyValData(\n  participantsKeyValData: PsbtMusig2ParticipantsKeyValueData\n): ProprietaryKeyValueData {\n  const keydata = [participantsKeyValData.tapOutputKey, participantsKeyValData.tapInternalKey].map((pubkey) =>\n    checkXOnlyPublicKey(pubkey)\n  );\n  const value = participantsKeyValData.participantPubKeys.map((pubkey) => checkPlainPublicKey(pubkey));\n  const key = {\n    identifier: PSBT_PROPRIETARY_IDENTIFIER,\n    subtype: ProprietaryKeySubtype.MUSIG2_PARTICIPANT_PUB_KEYS,\n    keydata: Buffer.concat(keydata),\n  };\n  return { key, value: Buffer.concat(value) };\n}\n\n/**\n * Psbt proprietary key val util function for pub nonce. SubType is 0x02\n * Ref: https://gist.github.com/sanket1729/4b525c6049f4d9e034d27368c49f28a6\n * @return plain-participantPubKey||x-only-tapOutputKey as sub keydata, 66 bytes of 2 pub nonces as valuedata\n */\nexport function encodePsbtMusig2PubNonceKeyValData(\n  noncesKeyValueData: PsbtMusig2NoncesKeyValueData\n): ProprietaryKeyValueData {\n  if (noncesKeyValueData.pubNonces.length !== 66) {\n    throw new Error(`Invalid pubNonces length ${noncesKeyValueData.pubNonces.length}`);\n  }\n  const keydata = Buffer.concat([\n    checkPlainPublicKey(noncesKeyValueData.participantPubKey),\n    checkXOnlyPublicKey(noncesKeyValueData.tapOutputKey),\n  ]);\n  const key = {\n    identifier: PSBT_PROPRIETARY_IDENTIFIER,\n    subtype: ProprietaryKeySubtype.MUSIG2_PUB_NONCE,\n    keydata,\n  };\n  return { key, value: noncesKeyValueData.pubNonces };\n}\n\n/**\n * Decodes proprietary key value data for participant pub keys\n * @param kv\n */\nexport function decodePsbtMusig2ParticipantsKeyValData(\n  kv: ProprietaryKeyValueData\n): PsbtMusig2ParticipantsKeyValueData {\n  if (\n    kv.key.identifier !== PSBT_PROPRIETARY_IDENTIFIER ||\n    kv.key.subtype !== ProprietaryKeySubtype.MUSIG2_PARTICIPANT_PUB_KEYS\n  ) {\n    throw new Error(`Invalid identifier ${kv.key.identifier} or subtype ${kv.key.subtype} for participants pub keys`);\n  }\n\n  const key = kv.key.keydata;\n  if (key.length !== 64) {\n    throw new Error(`Invalid keydata size ${key.length} for participant pub keys`);\n  }\n\n  const value = kv.value;\n  if (value.length !== 66) {\n    throw new Error(`Invalid valuedata size ${value.length} for participant pub keys`);\n  }\n  const participantPubKeys: Tuple<Buffer> = [value.subarray(0, 33), value.subarray(33)];\n  if (participantPubKeys[0].equals(participantPubKeys[1])) {\n    throw new Error(`Duplicate participant pub keys found`);\n  }\n\n  return { tapOutputKey: key.subarray(0, 32), tapInternalKey: key.subarray(32), participantPubKeys };\n}\n\nexport function createTapInternalKey(plainPubKeys: Buffer[]): Buffer {\n  plainPubKeys.forEach((pubKey) => checkPlainPublicKey(pubKey));\n  return Buffer.from(musig.getXOnlyPubkey(musig.keyAgg(musig.keySort(plainPubKeys))));\n}\n\nexport function createTapOutputKey(internalPubKey: Buffer, tapTreeRoot: Buffer): Buffer {\n  if (tapTreeRoot.length !== 32) {\n    throw new Error(`Invalid tapTreeRoot size ${tapTreeRoot.length}`);\n  }\n  return Buffer.from(tapTweakPubkey(ecc, toXOnlyPublicKey(internalPubKey), tapTreeRoot).xOnlyPubkey);\n}\n\nfunction deriveWalletPubKey(tapBip32Derivations: TapBip32Derivation[], rootWalletKey: BIP32Interface): Buffer {\n  const myDerivations = tapBip32Derivations.filter((bipDv) => {\n    return bipDv.masterFingerprint.equals(rootWalletKey.fingerprint);\n  });\n\n  if (!myDerivations.length) {\n    throw new Error('Need one tapBip32Derivation masterFingerprint to match the rootWalletKey fingerprint');\n  }\n\n  const myDerivation = myDerivations.filter((bipDv) => {\n    const publicKey = rootWalletKey.derivePath(bipDv.path).publicKey;\n    return bipDv.pubkey.equals(toXOnlyPublicKey(publicKey));\n  });\n\n  if (myDerivation.length !== 1) {\n    throw new Error('root wallet key should derive one tapBip32Derivation');\n  }\n  return rootWalletKey.derivePath(myDerivation[0].path).publicKey;\n}\n\nfunction getMusig2NonceKeyValueData(\n  psbt: UtxoPsbt,\n  inputIndex: number,\n  rootWalletKey: BIP32Interface,\n  sessionId?: Buffer\n): ProprietaryKeyValueData | undefined {\n  const input = checkForInput(psbt.data.inputs, inputIndex);\n  if (!input.tapInternalKey) {\n    return;\n  }\n\n  if (!input.tapMerkleRoot) {\n    throw new Error('tapMerkleRoot is required to generate nonce');\n  }\n\n  if (!input.tapBip32Derivation?.length) {\n    throw new Error('tapBip32Derivation is required to generate nonce');\n  }\n\n  const participantsKeyVals = psbt.getProprietaryKeyVals(inputIndex, {\n    identifier: PSBT_PROPRIETARY_IDENTIFIER,\n    subtype: ProprietaryKeySubtype.MUSIG2_PARTICIPANT_PUB_KEYS,\n  });\n\n  if (participantsKeyVals.length !== 1) {\n    throw new Error(`Found ${participantsKeyVals.length} matching participant key value instead of 1`);\n  }\n\n  const participantKeyValData = decodePsbtMusig2ParticipantsKeyValData(participantsKeyVals[0]);\n  const participantPubKeys = participantKeyValData.participantPubKeys;\n\n  const tapInternalKey = createTapInternalKey(participantPubKeys);\n  if (!tapInternalKey.equals(participantKeyValData.tapInternalKey)) {\n    throw new Error('Invalid participants keyata tapInternalKey');\n  }\n\n  const tapOutputKey = createTapOutputKey(tapInternalKey, input.tapMerkleRoot);\n  if (!tapOutputKey.equals(participantKeyValData.tapOutputKey)) {\n    throw new Error('Invalid participants keyata tapOutputKey');\n  }\n\n  if (!tapInternalKey.equals(input.tapInternalKey)) {\n    throw new Error('tapInternalKey and aggregated participant pub keys does not match');\n  }\n\n  const derivedPubKey = deriveWalletPubKey(input.tapBip32Derivation, rootWalletKey);\n  const participantPubKey = participantPubKeys.find((pubKey) => pubKey.equals(derivedPubKey));\n\n  if (!Buffer.isBuffer(participantPubKey)) {\n    throw new Error('participant plain pub key should match one tapBip32Derivation plain pub key');\n  }\n\n  const { hash } = psbt.getTaprootHashForSigChecked(inputIndex);\n\n  const nonceGenArgs = {\n    sessionId,\n    publicKey: participantPubKey,\n    xOnlyPublicKey: tapOutputKey,\n    msg: hash,\n    secretKey: rootWalletKey.privateKey,\n  };\n\n  const pubNonces = Buffer.from(musig.nonceGen(nonceGenArgs));\n\n  return encodePsbtMusig2PubNonceKeyValData({\n    participantPubKey,\n    tapOutputKey,\n    pubNonces,\n  });\n}\n\n/**\n * Generates and sets Musig2 nonces to p2trMusig2 key path spending inputs.\n * tapInternalkey, tapMerkleRoot, tapBip32Derivation for rootWalletKey are required per p2trMusig2 key path input.\n * Also participant keys are required from psbt proprietary key values.\n * Ref: https://gist.github.com/sanket1729/4b525c6049f4d9e034d27368c49f28a6\n * @param psbt\n * @param rootWalletKey\n * @param sessionId If provided it must either be a counter unique to this secret key,\n * (converted to an array of 32 bytes), or 32 uniformly random bytes.\n */\nexport function setMusig2Nonces(psbt: UtxoPsbt, rootWalletKey: BIP32Interface, sessionId?: Buffer): void {\n  if (rootWalletKey.isNeutered()) {\n    throw new Error('private key is required to generate nonce');\n  }\n  if (Buffer.isBuffer(sessionId) && sessionId.length !== 32) {\n    throw new Error(`Invalid sessionId size ${sessionId.length}`);\n  }\n  psbt.data.inputs.forEach((input, inputIndex) => {\n    const noncesKeyValueData = getMusig2NonceKeyValueData(psbt, inputIndex, rootWalletKey, sessionId);\n    if (noncesKeyValueData) {\n      psbt.addProprietaryKeyValToInput(inputIndex, noncesKeyValueData);\n    }\n  });\n}\n"]}