utxo-lib 1.0.1

package/dist/src/noble_ecc.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.musig = exports.bip32 = exports.ECPair = exports.ecc = void 0;
+const createHash = require("create-hash");
+const createHmac = require("create-hmac");
+const ecpair_1 = require("ecpair");
+const necc = require("@noble/secp256k1");
+const bip32_1 = require("bip32");
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore base_crypto is exported as a subPath export, ignoring since compiler complains about importing like this
+const baseCrypto = require("@brandonblack/musig/base_crypto");
+const musig_1 = require("@brandonblack/musig");
+necc.utils.sha256Sync = (...messages) => {
+    const sha256 = createHash('sha256');
+    for (const message of messages)
+        sha256.update(message);
+    return sha256.digest();
+};
+necc.utils.hmacSha256Sync = (key, ...messages) => {
+    const hash = createHmac('sha256', Buffer.from(key));
+    messages.forEach((m) => hash.update(m));
+    return Uint8Array.from(hash.digest());
+};
+const defaultTrue = (param) => param !== false;
+function throwToNull(fn) {
+    try {
+        return fn();
+    }
+    catch (e) {
+        return null;
+    }
+}
+function isPoint(p, xOnly) {
+    if ((p.length === 32) !== xOnly)
+        return false;
+    try {
+        return !!necc.Point.fromHex(p);
+    }
+    catch (e) {
+        return false;
+    }
+}
+function toBigInt(b) {
+    return Buffer.from(b).readBigUint64BE();
+}
+const ecc = {
+    isPoint: (p) => isPoint(p, false),
+    isPrivate: (d) => necc.utils.isValidPrivateKey(d),
+    isXOnlyPoint: (p) => isPoint(p, true),
+    xOnlyPointAddTweak: (p, tweak) => throwToNull(() => {
+        const P = necc.utils.pointAddScalar(p, tweak, true);
+        const parity = P[0] % 2 === 1 ? 1 : 0;
+        return { parity, xOnlyPubkey: P.slice(1) };
+    }),
+    pointFromScalar: (sk, compressed) => throwToNull(() => necc.getPublicKey(sk, defaultTrue(compressed))),
+    pointCompress: (p, compressed) => {
+        return necc.Point.fromHex(p).toRawBytes(defaultTrue(compressed));
+    },
+    pointMultiply: (a, tweak, compressed) => throwToNull(() => necc.utils.pointMultiply(a, tweak, defaultTrue(compressed))),
+    pointAdd: (a, b, compressed) => throwToNull(() => {
+        const A = necc.Point.fromHex(a);
+        const B = necc.Point.fromHex(b);
+        return A.add(B).toRawBytes(defaultTrue(compressed));
+    }),
+    pointAddScalar: (p, tweak, compressed) => throwToNull(() => necc.utils.pointAddScalar(p, tweak, defaultTrue(compressed))),
+    privateAdd: (d, tweak) => throwToNull(() => {
+        const res = necc.utils.privateAdd(d, tweak);
+        // tiny-secp256k1 returns null rather than allowing a 0 private key to be returned
+        // ECPair.testEcc() requires that behavior.
+        if (res === null || res === void 0 ? void 0 : res.every((i) => i === 0))
+            return null;
+        return res;
+    }),
+    privateNegate: (d) => necc.utils.privateNegate(d),
+    sign: (h, d, e) => {
+        return necc.signSync(h, d, { der: false, extraEntropy: e });
+    },
+    signSchnorr: (h, d, e = Buffer.alloc(32, 0x00)) => {
+        return necc.schnorr.signSync(h, d, e);
+    },
+    verify: (h, Q, signature, strict) => {
+        return necc.verify(signature, h, Q, { strict });
+    },
+    verifySchnorr: (h, Q, signature) => {
+        return necc.schnorr.verifySync(signature, h, Q);
+    },
+};
+exports.ecc = ecc;
+const crypto = {
+    ...baseCrypto,
+    pointMultiplyUnsafe(p, a, compress) {
+        try {
+            const product = necc.Point.fromHex(p).multiplyAndAddUnsafe(necc.Point.ZERO, toBigInt(a), BigInt(1));
+            if (!product)
+                return null;
+            return product.toRawBytes(compress);
+        }
+        catch {
+            return null;
+        }
+    },
+    pointMultiplyAndAddUnsafe(p1, a, p2, compress) {
+        try {
+            const p2p = necc.Point.fromHex(p2);
+            const p = necc.Point.fromHex(p1).multiplyAndAddUnsafe(p2p, toBigInt(a), BigInt(1));
+            if (!p)
+                return null;
+            return p.toRawBytes(compress);
+        }
+        catch {
+            return null;
+        }
+    },
+    pointAdd(a, b, compress) {
+        try {
+            return necc.Point.fromHex(a).add(necc.Point.fromHex(b)).toRawBytes(compress);
+        }
+        catch {
+            return null;
+        }
+    },
+    pointAddTweak(p, tweak, compress) {
+        try {
+            const P = necc.Point.fromHex(p);
+            const t = baseCrypto.readSecret(tweak);
+            const Q = necc.Point.BASE.multiplyAndAddUnsafe(P, t, BigInt(1));
+            if (!Q)
+                throw new Error('Tweaked point at infinity');
+            return Q.toRawBytes(compress);
+        }
+        catch {
+            return null;
+        }
+    },
+    pointCompress(p, compress = true) {
+        return necc.Point.fromHex(p).toRawBytes(compress);
+    },
+    liftX(p) {
+        try {
+            return necc.Point.fromHex(p).toRawBytes(false);
+        }
+        catch {
+            return null;
+        }
+    },
+    getPublicKey(s, compress) {
+        try {
+            return necc.getPublicKey(s, compress);
+        }
+        catch {
+            return null;
+        }
+    },
+    taggedHash: necc.utils.taggedHashSync,
+    sha256(...messages) {
+        const sha256 = createHash('sha256');
+        for (const message of messages)
+            sha256.update(message);
+        return sha256.digest();
+    },
+};
+const ECPair = ecpair_1.ECPairFactory(ecc);
+exports.ECPair = ECPair;
+const bip32 = bip32_1.BIP32Factory(ecc);
+exports.bip32 = bip32;
+const musig = musig_1.MuSigFactory(crypto);
+exports.musig = musig;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"noble_ecc.js","sourceRoot":"","sources":["../../src/noble_ecc.ts"],"names":[],"mappings":";;;AAAA,0CAA0C;AAC1C,0CAA0C;AAC1C,mCAAmE;AACnE,yCAAyC;AACzC,iCAA+D;AAC/D,6DAA6D;AAC7D,sHAAsH;AACtH,8DAA8D;AAC9D,+CAA0D;AAE1D,IAAI,CAAC,KAAK,CAAC,UAAU,GAAG,CAAC,GAAG,QAAsB,EAAc,EAAE;IAChE,MAAM,MAAM,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC;IACpC,KAAK,MAAM,OAAO,IAAI,QAAQ;QAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACvD,OAAO,MAAM,CAAC,MAAM,EAAE,CAAC;AACzB,CAAC,CAAC;AAEF,IAAI,CAAC,KAAK,CAAC,cAAc,GAAG,CAAC,GAAe,EAAE,GAAG,QAAsB,EAAc,EAAE;IACrF,MAAM,IAAI,GAAG,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IACpD,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IACxC,OAAO,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;AACxC,CAAC,CAAC;AAEF,MAAM,WAAW,GAAG,CAAC,KAAe,EAAW,EAAE,CAAC,KAAK,KAAK,KAAK,CAAC;AAElE,SAAS,WAAW,CAAO,EAAc;IACvC,IAAI;QACF,OAAO,EAAE,EAAE,CAAC;KACb;IAAC,OAAO,CAAC,EAAE;QACV,OAAO,IAAI,CAAC;KACb;AACH,CAAC;AAED,SAAS,OAAO,CAAC,CAAa,EAAE,KAAc;IAC5C,IAAI,CAAC,CAAC,CAAC,MAAM,KAAK,EAAE,CAAC,KAAK,KAAK;QAAE,OAAO,KAAK,CAAC;IAC9C,IAAI;QACF,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;KAChC;IAAC,OAAO,CAAC,EAAE;QACV,OAAO,KAAK,CAAC;KACd;AACH,CAAC;AAED,SAAS,QAAQ,CAAC,CAAsB;IACtC,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,eAAe,EAAE,CAAC;AAC1C,CAAC;AAED,MAAM,GAAG,GAAG;IACV,OAAO,EAAE,CAAC,CAAa,EAAW,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC;IACtD,SAAS,EAAE,CAAC,CAAa,EAAW,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC;IACtE,YAAY,EAAE,CAAC,CAAa,EAAW,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,IAAI,CAAC;IAE1D,kBAAkB,EAAE,CAAC,CAAa,EAAE,KAAiB,EAAqD,EAAE,CAC1G,WAAW,CAAC,GAAG,EAAE;QACf,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;QACpD,MAAM,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACtC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;IAC7C,CAAC,CAAC;IAEJ,eAAe,EAAE,CAAC,EAAc,EAAE,UAAoB,EAAqB,EAAE,CAC3E,WAAW,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,EAAE,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC;IAEnE,aAAa,EAAE,CAAC,CAAa,EAAE,UAAoB,EAAc,EAAE;QACjE,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC;IACnE,CAAC;IAED,aAAa,EAAE,CAAC,CAAa,EAAE,KAAiB,EAAE,UAAoB,EAAqB,EAAE,CAC3F,WAAW,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC;IAEhF,QAAQ,EAAE,CAAC,CAAa,EAAE,CAAa,EAAE,UAAoB,EAAqB,EAAE,CAClF,WAAW,CAAC,GAAG,EAAE;QACf,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QAChC,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QAChC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC;IACtD,CAAC,CAAC;IAEJ,cAAc,EAAE,CAAC,CAAa,EAAE,KAAiB,EAAE,UAAoB,EAAqB,EAAE,CAC5F,WAAW,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC;IAEjF,UAAU,EAAE,CAAC,CAAa,EAAE,KAAiB,EAAqB,EAAE,CAClE,WAAW,CAAC,GAAG,EAAE;QACf,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;QAC5C,kFAAkF;QAClF,2CAA2C;QAC3C,IAAI,GAAG,aAAH,GAAG,uBAAH,GAAG,CAAE,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;YAAE,OAAO,IAAI,CAAC;QAC5C,OAAO,GAAG,CAAC;IACb,CAAC,CAAC;IAEJ,aAAa,EAAE,CAAC,CAAa,EAAc,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC;IAEzE,IAAI,EAAE,CAAC,CAAa,EAAE,CAAa,EAAE,CAAc,EAAc,EAAE;QACjE,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC,EAAE,CAAC,CAAC;IAC9D,CAAC;IAED,WAAW,EAAE,CAAC,CAAa,EAAE,CAAa,EAAE,IAAgB,MAAM,CAAC,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,EAAc,EAAE;QAChG,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IACxC,CAAC;IAED,MAAM,EAAE,CAAC,CAAa,EAAE,CAAa,EAAE,SAAqB,EAAE,MAAgB,EAAW,EAAE;QACzF,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;IAClD,CAAC;IAED,aAAa,EAAE,CAAC,CAAa,EAAE,CAAa,EAAE,SAAqB,EAAW,EAAE;QAC9E,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAClD,CAAC;CACF,CAAC;AAsEO,kBAAG;AApEZ,MAAM,MAAM,GAAG;IACb,GAAG,UAAU;IACb,mBAAmB,CAAC,CAAa,EAAE,CAAa,EAAE,QAAiB;QACjE,IAAI;YACF,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,oBAAoB,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;YACpG,IAAI,CAAC,OAAO;gBAAE,OAAO,IAAI,CAAC;YAC1B,OAAO,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;SACrC;QAAC,MAAM;YACN,OAAO,IAAI,CAAC;SACb;IACH,CAAC;IACD,yBAAyB,CAAC,EAAc,EAAE,CAAa,EAAE,EAAc,EAAE,QAAiB;QACxF,IAAI;YACF,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;YACnC,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,oBAAoB,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;YACnF,IAAI,CAAC,CAAC;gBAAE,OAAO,IAAI,CAAC;YACpB,OAAO,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;SAC/B;QAAC,MAAM;YACN,OAAO,IAAI,CAAC;SACb;IACH,CAAC;IACD,QAAQ,CAAC,CAAa,EAAE,CAAa,EAAE,QAAiB;QACtD,IAAI;YACF,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;SAC9E;QAAC,MAAM;YACN,OAAO,IAAI,CAAC;SACb;IACH,CAAC;IACD,aAAa,CAAC,CAAa,EAAE,KAAiB,EAAE,QAAiB;QAC/D,IAAI;YACF,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;YAChC,MAAM,CAAC,GAAG,UAAU,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;YACvC,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;YAChE,IAAI,CAAC,CAAC;gBAAE,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;YACrD,OAAO,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;SAC/B;QAAC,MAAM;YACN,OAAO,IAAI,CAAC;SACb;IACH,CAAC;IACD,aAAa,CAAC,CAAa,EAAE,QAAQ,GAAG,IAAI;QAC1C,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;IACpD,CAAC;IACD,KAAK,CAAC,CAAa;QACjB,IAAI;YACF,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;SAChD;QAAC,MAAM;YACN,OAAO,IAAI,CAAC;SACb;IACH,CAAC;IACD,YAAY,CAAC,CAAa,EAAE,QAAiB;QAC3C,IAAI;YACF,OAAO,IAAI,CAAC,YAAY,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;SACvC;QAAC,MAAM;YACN,OAAO,IAAI,CAAC;SACb;IACH,CAAC;IACD,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,cAAc;IACrC,MAAM,CAAC,GAAG,QAAsB;QAC9B,MAAM,MAAM,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC;QACpC,KAAK,MAAM,OAAO,IAAI,QAAQ;YAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACvD,OAAO,MAAM,CAAC,MAAM,EAAE,CAAC;IACzB,CAAC;CACF,CAAC;AAEF,MAAM,MAAM,GAAc,sBAAa,CAAC,GAAG,CAAC,CAAC;AAI/B,wBAAM;AAHpB,MAAM,KAAK,GAAa,oBAAY,CAAC,GAAG,CAAC,CAAC;AAGQ,sBAAK;AAFvD,MAAM,KAAK,GAAU,oBAAY,CAAC,MAAM,CAAC,CAAC;AAEyC,sBAAK","sourcesContent":["import * as createHash from 'create-hash';\nimport * as createHmac from 'create-hmac';\nimport { ECPairAPI, ECPairFactory, ECPairInterface } from 'ecpair';\nimport * as necc from '@noble/secp256k1';\nimport { BIP32API, BIP32Factory, BIP32Interface } from 'bip32';\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore base_crypto is exported as a subPath export, ignoring since compiler complains about importing like this\nimport * as baseCrypto from '@brandonblack/musig/base_crypto';\nimport { MuSig, MuSigFactory } from '@brandonblack/musig';\n\nnecc.utils.sha256Sync = (...messages: Uint8Array[]): Uint8Array => {\n  const sha256 = createHash('sha256');\n  for (const message of messages) sha256.update(message);\n  return sha256.digest();\n};\n\nnecc.utils.hmacSha256Sync = (key: Uint8Array, ...messages: Uint8Array[]): Uint8Array => {\n  const hash = createHmac('sha256', Buffer.from(key));\n  messages.forEach((m) => hash.update(m));\n  return Uint8Array.from(hash.digest());\n};\n\nconst defaultTrue = (param?: boolean): boolean => param !== false;\n\nfunction throwToNull<Type>(fn: () => Type): Type | null {\n  try {\n    return fn();\n  } catch (e) {\n    return null;\n  }\n}\n\nfunction isPoint(p: Uint8Array, xOnly: boolean): boolean {\n  if ((p.length === 32) !== xOnly) return false;\n  try {\n    return !!necc.Point.fromHex(p);\n  } catch (e) {\n    return false;\n  }\n}\n\nfunction toBigInt(b: Uint8Array | Buffer): bigint {\n  return Buffer.from(b).readBigUint64BE();\n}\n\nconst ecc = {\n  isPoint: (p: Uint8Array): boolean => isPoint(p, false),\n  isPrivate: (d: Uint8Array): boolean => necc.utils.isValidPrivateKey(d),\n  isXOnlyPoint: (p: Uint8Array): boolean => isPoint(p, true),\n\n  xOnlyPointAddTweak: (p: Uint8Array, tweak: Uint8Array): { parity: 0 | 1; xOnlyPubkey: Uint8Array } | null =>\n    throwToNull(() => {\n      const P = necc.utils.pointAddScalar(p, tweak, true);\n      const parity = P[0] % 2 === 1 ? 1 : 0;\n      return { parity, xOnlyPubkey: P.slice(1) };\n    }),\n\n  pointFromScalar: (sk: Uint8Array, compressed?: boolean): Uint8Array | null =>\n    throwToNull(() => necc.getPublicKey(sk, defaultTrue(compressed))),\n\n  pointCompress: (p: Uint8Array, compressed?: boolean): Uint8Array => {\n    return necc.Point.fromHex(p).toRawBytes(defaultTrue(compressed));\n  },\n\n  pointMultiply: (a: Uint8Array, tweak: Uint8Array, compressed?: boolean): Uint8Array | null =>\n    throwToNull(() => necc.utils.pointMultiply(a, tweak, defaultTrue(compressed))),\n\n  pointAdd: (a: Uint8Array, b: Uint8Array, compressed?: boolean): Uint8Array | null =>\n    throwToNull(() => {\n      const A = necc.Point.fromHex(a);\n      const B = necc.Point.fromHex(b);\n      return A.add(B).toRawBytes(defaultTrue(compressed));\n    }),\n\n  pointAddScalar: (p: Uint8Array, tweak: Uint8Array, compressed?: boolean): Uint8Array | null =>\n    throwToNull(() => necc.utils.pointAddScalar(p, tweak, defaultTrue(compressed))),\n\n  privateAdd: (d: Uint8Array, tweak: Uint8Array): Uint8Array | null =>\n    throwToNull(() => {\n      const res = necc.utils.privateAdd(d, tweak);\n      // tiny-secp256k1 returns null rather than allowing a 0 private key to be returned\n      // ECPair.testEcc() requires that behavior.\n      if (res?.every((i) => i === 0)) return null;\n      return res;\n    }),\n\n  privateNegate: (d: Uint8Array): Uint8Array => necc.utils.privateNegate(d),\n\n  sign: (h: Uint8Array, d: Uint8Array, e?: Uint8Array): Uint8Array => {\n    return necc.signSync(h, d, { der: false, extraEntropy: e });\n  },\n\n  signSchnorr: (h: Uint8Array, d: Uint8Array, e: Uint8Array = Buffer.alloc(32, 0x00)): Uint8Array => {\n    return necc.schnorr.signSync(h, d, e);\n  },\n\n  verify: (h: Uint8Array, Q: Uint8Array, signature: Uint8Array, strict?: boolean): boolean => {\n    return necc.verify(signature, h, Q, { strict });\n  },\n\n  verifySchnorr: (h: Uint8Array, Q: Uint8Array, signature: Uint8Array): boolean => {\n    return necc.schnorr.verifySync(signature, h, Q);\n  },\n};\n\nconst crypto = {\n  ...baseCrypto,\n  pointMultiplyUnsafe(p: Uint8Array, a: Uint8Array, compress: boolean): Uint8Array | null {\n    try {\n      const product = necc.Point.fromHex(p).multiplyAndAddUnsafe(necc.Point.ZERO, toBigInt(a), BigInt(1));\n      if (!product) return null;\n      return product.toRawBytes(compress);\n    } catch {\n      return null;\n    }\n  },\n  pointMultiplyAndAddUnsafe(p1: Uint8Array, a: Uint8Array, p2: Uint8Array, compress: boolean): Uint8Array | null {\n    try {\n      const p2p = necc.Point.fromHex(p2);\n      const p = necc.Point.fromHex(p1).multiplyAndAddUnsafe(p2p, toBigInt(a), BigInt(1));\n      if (!p) return null;\n      return p.toRawBytes(compress);\n    } catch {\n      return null;\n    }\n  },\n  pointAdd(a: Uint8Array, b: Uint8Array, compress: boolean): Uint8Array | null {\n    try {\n      return necc.Point.fromHex(a).add(necc.Point.fromHex(b)).toRawBytes(compress);\n    } catch {\n      return null;\n    }\n  },\n  pointAddTweak(p: Uint8Array, tweak: Uint8Array, compress: boolean): Uint8Array | null {\n    try {\n      const P = necc.Point.fromHex(p);\n      const t = baseCrypto.readSecret(tweak);\n      const Q = necc.Point.BASE.multiplyAndAddUnsafe(P, t, BigInt(1));\n      if (!Q) throw new Error('Tweaked point at infinity');\n      return Q.toRawBytes(compress);\n    } catch {\n      return null;\n    }\n  },\n  pointCompress(p: Uint8Array, compress = true): Uint8Array {\n    return necc.Point.fromHex(p).toRawBytes(compress);\n  },\n  liftX(p: Uint8Array): Uint8Array | null {\n    try {\n      return necc.Point.fromHex(p).toRawBytes(false);\n    } catch {\n      return null;\n    }\n  },\n  getPublicKey(s: Uint8Array, compress: boolean): Uint8Array | null {\n    try {\n      return necc.getPublicKey(s, compress);\n    } catch {\n      return null;\n    }\n  },\n  taggedHash: necc.utils.taggedHashSync,\n  sha256(...messages: Uint8Array[]): Uint8Array {\n    const sha256 = createHash('sha256');\n    for (const message of messages) sha256.update(message);\n    return sha256.digest();\n  },\n};\n\nconst ECPair: ECPairAPI = ECPairFactory(ecc);\nconst bip32: BIP32API = BIP32Factory(ecc);\nconst musig: MuSig = MuSigFactory(crypto);\n\nexport { ecc, ECPair, ECPairAPI, ECPairInterface, bip32, BIP32API, BIP32Interface, musig, MuSig };\n"]}

package/dist/src/payments/index.d.ts

@@ -0,0 +1,4 @@
+import { p2tr_ns } from './p2tr_ns';
+import { p2tr } from './p2tr';
+export { p2tr_ns, p2tr };
+//# sourceMappingURL=index.d.ts.map

package/dist/src/payments/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/payments/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE9B,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC"}

package/dist/src/payments/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.p2tr = exports.p2tr_ns = void 0;
+const p2tr_ns_1 = require("./p2tr_ns");
+Object.defineProperty(exports, "p2tr_ns", { enumerable: true, get: function () { return p2tr_ns_1.p2tr_ns; } });
+const p2tr_1 = require("./p2tr");
+Object.defineProperty(exports, "p2tr", { enumerable: true, get: function () { return p2tr_1.p2tr; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcGF5bWVudHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsdUNBQW9DO0FBRzNCLHdGQUhBLGlCQUFPLE9BR0E7QUFGaEIsaUNBQThCO0FBRVoscUZBRlQsV0FBSSxPQUVTIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgcDJ0cl9ucyB9IGZyb20gJy4vcDJ0cl9ucyc7XG5pbXBvcnQgeyBwMnRyIH0gZnJvbSAnLi9wMnRyJztcblxuZXhwb3J0IHsgcDJ0cl9ucywgcDJ0ciB9O1xuIl19

package/dist/src/payments/p2tr.d.ts

@@ -0,0 +1,3 @@
+import { Payment, PaymentOpts } from 'bitcoinjs-lib';
+export declare function p2tr(a: Payment, opts?: PaymentOpts): Payment;
+//# sourceMappingURL=p2tr.d.ts.map

package/dist/src/payments/p2tr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"p2tr.d.ts","sourceRoot":"","sources":["../../../src/payments/p2tr.ts"],"names":[],"mappings":"AAIA,OAAO,EAAqB,OAAO,EAAE,WAAW,EAAQ,MAAM,eAAe,CAAC;AAgC9E,wBAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,OAAO,CAwU5D"}

package/dist/src/payments/p2tr.js

@@ -0,0 +1,348 @@
+"use strict";
+// SegWit version 1 P2TR output type for Taproot defined in
+// https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.p2tr = void 0;
+const networks_1 = require("../networks");
+const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+const taproot = require("../taproot");
+const noble_ecc_1 = require("../noble_ecc");
+const necc = require("@noble/secp256k1");
+const typef = require('typeforce');
+const OPS = bitcoinjs_lib_1.script.OPS;
+const { bech32m } = require('bech32');
+const BITCOIN_NETWORK = networks_1.networks.bitcoin;
+/**
+ * A secp256k1 x coordinate with unknown discrete logarithm used for eliminating
+ * keypath spends, equal to SHA256(uncompressedDER(SECP256K1_GENERATOR_POINT)).
+ */
+const H = Buffer.from('50929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0', 'hex');
+const EMPTY_BUFFER = Buffer.alloc(0);
+function isPlainPubkey(pubKey) {
+    if (pubKey.length !== 33)
+        return false;
+    try {
+        return !!necc.Point.fromHex(pubKey);
+    }
+    catch (e) {
+        return false;
+    }
+}
+function isPlainPubkeys(pubkeys) {
+    return pubkeys.every(isPlainPubkey);
+}
+// output: OP_1 {witnessProgram}
+function p2tr(a, opts) {
+    var _a, _b, _c, _d;
+    if (!a.address && !a.pubkey && !a.pubkeys && !(a.redeems && a.redeems.length) && !a.output && !a.witness) {
+        throw new TypeError('Not enough data');
+    }
+    opts = Object.assign({ validate: true }, opts || {});
+    if (!opts.eccLib)
+        throw new Error('ECC Library is required for p2tr.');
+    const ecc = opts.eccLib;
+    typef({
+        network: typef.maybe(typef.Object),
+        address: typef.maybe(typef.String),
+        // the output script should be a fixed 34 bytes.
+        // 1 byte for OP_1 indicating segwit version 1, one byte for 0x20 to push
+        // the next 32 bytes, followed by the 32 byte witness program
+        output: typef.maybe(typef.BufferN(34)),
+        // a single pubkey
+        pubkey: typef.maybe(ecc.isXOnlyPoint),
+        // the pub key(s) used for keypath signing.
+        // aggregated with MuSig2* if > 1
+        pubkeys: typef.maybe(typef.anyOf(typef.arrayOf(ecc.isXOnlyPoint), typef.arrayOf(isPlainPubkey))),
+        redeems: typef.maybe(typef.arrayOf({
+            network: typef.maybe(typef.Object),
+            output: typef.maybe(typef.Buffer),
+            weight: typef.maybe(typef.Number),
+            depth: typef.maybe(typef.Number),
+            witness: typef.maybe(typef.arrayOf(typef.Buffer)),
+        })),
+        redeemIndex: typef.maybe(typef.Number),
+        signature: typef.maybe(bitcoinjs_lib_1.script.isCanonicalSchnorrSignature),
+        controlBlock: typef.maybe(typef.Buffer),
+        annex: typef.maybe(typef.Buffer),
+    }, a);
+    const _address = bitcoinjs_lib_1.lazy.value(() => {
+        if (!a.address)
+            return undefined;
+        const result = bech32m.decode(a.address);
+        const version = result.words.shift();
+        const data = bech32m.fromWords(result.words);
+        return {
+            version,
+            prefix: result.prefix,
+            data: Buffer.from(data),
+        };
+    });
+    const _outputPubkey = bitcoinjs_lib_1.lazy.value(() => {
+        // we remove the first two bytes (OP_1 0x20) from the output script to
+        // extract the 32 byte taproot pubkey (aka witness program)
+        return a.output && a.output.slice(2);
+    });
+    const network = a.network || BITCOIN_NETWORK;
+    const o = { network };
+    const _taprootPaths = bitcoinjs_lib_1.lazy.value(() => {
+        if (!a.redeems)
+            return;
+        if (o.tapTree) {
+            return taproot.getDepthFirstTaptree(o.tapTree);
+        }
+        const outputs = a.redeems.map(({ output }) => output);
+        if (!outputs.every((output) => output))
+            return;
+        return taproot.getHuffmanTaptree(outputs, a.redeems.map(({ weight }) => weight));
+    });
+    const _parsedWitness = bitcoinjs_lib_1.lazy.value(() => {
+        if (!a.witness)
+            return;
+        return taproot.parseTaprootWitness(a.witness);
+    });
+    const _parsedControlBlock = bitcoinjs_lib_1.lazy.value(() => {
+        // Can't use o.controlBlock, because it could be circular
+        if (a.controlBlock)
+            return taproot.parseControlBlock(ecc, a.controlBlock);
+        const parsedWitness = _parsedWitness();
+        if (parsedWitness && parsedWitness.spendType === 'Script') {
+            return taproot.parseControlBlock(ecc, parsedWitness.controlBlock);
+        }
+    });
+    bitcoinjs_lib_1.lazy.prop(o, 'internalPubkey', () => {
+        var _a;
+        if (a.pubkey) {
+            // single pubkey
+            return a.pubkey;
+        }
+        else if (a.pubkeys && a.pubkeys.length === 1) {
+            return a.pubkeys[0];
+        }
+        else if (a.pubkeys && a.pubkeys.length > 1) {
+            // multiple pubkeys
+            if (isPlainPubkeys(a.pubkeys)) {
+                return Buffer.from(noble_ecc_1.musig.getXOnlyPubkey(noble_ecc_1.musig.keyAgg(noble_ecc_1.musig.keySort(a.pubkeys))));
+            }
+            return Buffer.from(taproot.aggregateMuSigPubkeys(ecc, a.pubkeys));
+        }
+        else if (_parsedControlBlock()) {
+            return (_a = _parsedControlBlock()) === null || _a === void 0 ? void 0 : _a.internalPubkey;
+        }
+        else {
+            // If there is no key path spending condition, we use an internal key with unknown secret key.
+            // TODO: In order to avoid leaking the information that key path spending is not possible it
+            // is recommended to pick a fresh integer r in the range 0...n-1 uniformly at random and use
+            // H + rG as internal key. It is possible to prove that this internal key does not have a
+            // known discrete logarithm with respect to G by revealing r to a verifier who can then
+            // reconstruct how the internal key was created.
+            return H;
+        }
+    });
+    const _taprootPubkey = bitcoinjs_lib_1.lazy.value(() => {
+        var _a;
+        const parsedControlBlock = _parsedControlBlock();
+        const parsedWitness = _parsedWitness();
+        // Refuse to create an unspendable key
+        if (!a.pubkey && !(a.pubkeys && a.pubkeys.length) && !a.redeems && !parsedControlBlock) {
+            return;
+        }
+        let taptreeRoot;
+        // Prefer to get the root via the control block because not all redeems may
+        // be available
+        if (parsedControlBlock) {
+            let tapscript;
+            if (parsedWitness && parsedWitness.spendType === 'Script') {
+                tapscript = parsedWitness.tapscript;
+            }
+            else if (o.redeem && o.redeem.output) {
+                tapscript = o.redeem.output;
+            }
+            if (tapscript)
+                taptreeRoot = taproot.getTaptreeRoot(ecc, parsedControlBlock, tapscript);
+        }
+        if (!taptreeRoot && _taprootPaths())
+            taptreeRoot = (_a = _taprootPaths()) === null || _a === void 0 ? void 0 : _a.root;
+        return taproot.tapTweakPubkey(ecc, o === null || o === void 0 ? void 0 : o.internalPubkey, taptreeRoot);
+    });
+    bitcoinjs_lib_1.lazy.prop(o, 'tapTree', () => {
+        if (!a.redeems)
+            return;
+        if (a.redeems.find(({ depth }) => depth === undefined)) {
+            console.warn('Deprecation Warning: Weight-based tap tree construction will be removed in the future. ' +
+                'Please use depth-first coding as specified in BIP-0371.');
+            return;
+        }
+        if (!a.redeems.every(({ output }) => output))
+            return;
+        return {
+            leaves: a.redeems.map(({ output, depth }) => {
+                return {
+                    script: output,
+                    leafVersion: taproot.INITIAL_TAPSCRIPT_VERSION,
+                    depth,
+                };
+            }),
+        };
+    });
+    bitcoinjs_lib_1.lazy.prop(o, 'address', () => {
+        var _a;
+        const pubkey = _outputPubkey() || (_taprootPubkey() && ((_a = _taprootPubkey()) === null || _a === void 0 ? void 0 : _a.xOnlyPubkey));
+        // only encode the 32 byte witness program as bech32m
+        const words = bech32m.toWords(pubkey);
+        words.unshift(0x01);
+        return bech32m.encode(network.bech32, words);
+    });
+    bitcoinjs_lib_1.lazy.prop(o, 'controlBlock', () => {
+        const parsedWitness = _parsedWitness();
+        if (parsedWitness && parsedWitness.spendType === 'Script') {
+            return parsedWitness.controlBlock;
+        }
+        const taprootPubkey = _taprootPubkey();
+        const taprootPaths = _taprootPaths();
+        if (!taprootPaths || !taprootPubkey || a.redeemIndex === undefined)
+            return;
+        return taproot.getControlBlock(taprootPubkey.parity, o.internalPubkey, taprootPaths.paths[a.redeemIndex]);
+    });
+    bitcoinjs_lib_1.lazy.prop(o, 'signature', () => {
+        const parsedWitness = _parsedWitness();
+        if (parsedWitness && parsedWitness.spendType === 'Key') {
+            return parsedWitness.signature;
+        }
+    });
+    bitcoinjs_lib_1.lazy.prop(o, 'annex', () => {
+        if (!_parsedWitness())
+            return;
+        return _parsedWitness().annex;
+    });
+    bitcoinjs_lib_1.lazy.prop(o, 'output', () => {
+        if (a.address) {
+            const { data } = _address();
+            return bitcoinjs_lib_1.script.compile([OPS.OP_1, data]);
+        }
+        const taprootPubkey = _taprootPubkey();
+        if (!taprootPubkey)
+            return;
+        // OP_1 indicates segwit version 1
+        return bitcoinjs_lib_1.script.compile([OPS.OP_1, Buffer.from(taprootPubkey.xOnlyPubkey)]);
+    });
+    bitcoinjs_lib_1.lazy.prop(o, 'witness', () => {
+        if (!a.redeems) {
+            if (a.signature)
+                return [a.signature]; // Keypath spend
+            return;
+        }
+        else if (!o.redeem) {
+            return; // No chosen redeem script, can't make witness
+        }
+        else if (!o.controlBlock) {
+            return;
+        }
+        let redeemWitness;
+        // some callers may provide witness elements in the input script
+        if (o.redeem.input && o.redeem.input.length > 0 && o.redeem.output && o.redeem.output.length > 0) {
+            // transform redeem input to witness stack
+            redeemWitness = bitcoinjs_lib_1.script.toStack(bitcoinjs_lib_1.script.decompile(o.redeem.input));
+            // assigns a new object to o.redeem
+            o.redeems[a.redeemIndex] = Object.assign({ witness: redeemWitness }, o.redeem);
+            o.redeem.input = EMPTY_BUFFER;
+        }
+        else if (o.redeem.output && o.redeem.output.length > 0 && o.redeem.witness && o.redeem.witness.length > 0) {
+            redeemWitness = o.redeem.witness;
+        }
+        else {
+            return;
+        }
+        const witness = [...redeemWitness, o.redeem.output, o.controlBlock];
+        if (a.annex) {
+            witness.push(a.annex);
+        }
+        return witness;
+    });
+    bitcoinjs_lib_1.lazy.prop(o, 'name', () => {
+        const nameParts = ['p2tr'];
+        return nameParts.join('-');
+    });
+    bitcoinjs_lib_1.lazy.prop(o, 'redeem', () => {
+        if (a.redeems) {
+            if (a.redeemIndex === undefined)
+                return;
+            return a.redeems[a.redeemIndex];
+        }
+        const parsedWitness = _parsedWitness();
+        if (parsedWitness && parsedWitness.spendType === 'Script') {
+            return {
+                witness: parsedWitness.scriptSig,
+                output: parsedWitness.tapscript,
+            };
+        }
+    });
+    // extended validation
+    if (opts.validate) {
+        const taprootPubkey = _taprootPubkey();
+        if (a.output) {
+            if (a.output[0] !== OPS.OP_1 || a.output[1] !== 0x20) {
+                throw new TypeError('Output is invalid');
+            }
+            // if we're passed both an output script and an address, ensure they match
+            if (a.address && _outputPubkey && !((_a = _outputPubkey()) === null || _a === void 0 ? void 0 : _a.equals((_b = _address()) === null || _b === void 0 ? void 0 : _b.data))) {
+                throw new TypeError('mismatch between address & output');
+            }
+            if (taprootPubkey && _outputPubkey && !((_c = _outputPubkey()) === null || _c === void 0 ? void 0 : _c.equals(taprootPubkey.xOnlyPubkey))) {
+                throw new TypeError('mismatch between output and taproot pubkey');
+            }
+        }
+        if (a.address) {
+            if (taprootPubkey && !((_d = _address()) === null || _d === void 0 ? void 0 : _d.data.equals(taprootPubkey.xOnlyPubkey))) {
+                throw new TypeError('mismatch between address and taproot pubkey');
+            }
+        }
+        const parsedControlBlock = _parsedControlBlock();
+        if (parsedControlBlock) {
+            if (!parsedControlBlock.internalPubkey.equals(o === null || o === void 0 ? void 0 : o.internalPubkey)) {
+                throw new TypeError('Internal pubkey mismatch');
+            }
+            if (taprootPubkey && parsedControlBlock.parity !== taprootPubkey.parity) {
+                throw new TypeError('Parity mismatch');
+            }
+        }
+        if (a.redeems) {
+            if (!a.redeems.length)
+                throw new TypeError('Empty redeems');
+            if (a.redeemIndex !== undefined && (a.redeemIndex < 0 || a.redeemIndex >= a.redeems.length)) {
+                throw new TypeError('invalid redeem index');
+            }
+            a.redeems.forEach((redeem) => {
+                if (redeem.network && redeem.network !== network) {
+                    throw new TypeError('Network mismatch');
+                }
+            });
+        }
+        const chosenRedeem = a.redeems && a.redeemIndex !== undefined && a.redeems[a.redeemIndex];
+        const parsedWitness = _parsedWitness();
+        if (parsedWitness && parsedWitness.spendType === 'Key') {
+            if (a.controlBlock) {
+                throw new TypeError('unexpected control block for key path');
+            }
+            if (a.signature && !a.signature.equals(parsedWitness.signature)) {
+                throw new TypeError('mismatch between witness & signature');
+            }
+        }
+        if (parsedWitness && parsedWitness.spendType === 'Script') {
+            if (a.signature) {
+                throw new TypeError('unexpected signature with script path witness');
+            }
+            if (a.controlBlock && !a.controlBlock.equals(parsedWitness.controlBlock)) {
+                throw new TypeError('control block mismatch');
+            }
+            if (a.annex && parsedWitness.annex && !a.annex.equals(parsedWitness.annex)) {
+                throw new TypeError('annex mismatch');
+            }
+            if (chosenRedeem && chosenRedeem.output && !chosenRedeem.output.equals(parsedWitness.tapscript)) {
+                throw new TypeError('tapscript mismatch');
+            }
+        }
+    }
+    return Object.assign(o, a);
+}
+exports.p2tr = p2tr;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"p2tr.js","sourceRoot":"","sources":["../../../src/payments/p2tr.ts"],"names":[],"mappings":"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","sourcesContent":["// SegWit version 1 P2TR output type for Taproot defined in\n// https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki\n\nimport { networks } from '../networks';\nimport { script as bscript, Payment, PaymentOpts, lazy } from 'bitcoinjs-lib';\nimport * as taproot from '../taproot';\nimport { musig } from '../noble_ecc';\nimport * as necc from '@noble/secp256k1';\nconst typef = require('typeforce');\nconst OPS = bscript.OPS;\n\nconst { bech32m } = require('bech32');\n\nconst BITCOIN_NETWORK = networks.bitcoin;\n\n/**\n * A secp256k1 x coordinate with unknown discrete logarithm used for eliminating\n * keypath spends, equal to SHA256(uncompressedDER(SECP256K1_GENERATOR_POINT)).\n */\nconst H = Buffer.from('50929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0', 'hex');\nconst EMPTY_BUFFER = Buffer.alloc(0);\n\nfunction isPlainPubkey(pubKey: Uint8Array): boolean {\n  if (pubKey.length !== 33) return false;\n  try {\n    return !!necc.Point.fromHex(pubKey);\n  } catch (e) {\n    return false;\n  }\n}\n\nfunction isPlainPubkeys(pubkeys: Buffer[]) {\n  return pubkeys.every(isPlainPubkey);\n}\n\n// output: OP_1 {witnessProgram}\nexport function p2tr(a: Payment, opts?: PaymentOpts): Payment {\n  if (!a.address && !a.pubkey && !a.pubkeys && !(a.redeems && a.redeems.length) && !a.output && !a.witness) {\n    throw new TypeError('Not enough data');\n  }\n  opts = Object.assign({ validate: true }, opts || {});\n\n  if (!opts.eccLib) throw new Error('ECC Library is required for p2tr.');\n  const ecc = opts.eccLib;\n\n  typef(\n    {\n      network: typef.maybe(typef.Object),\n\n      address: typef.maybe(typef.String),\n      // the output script should be a fixed 34 bytes.\n      // 1 byte for OP_1 indicating segwit version 1, one byte for 0x20 to push\n      // the next 32 bytes, followed by the 32 byte witness program\n      output: typef.maybe(typef.BufferN(34)),\n      // a single pubkey\n      pubkey: typef.maybe(ecc.isXOnlyPoint),\n      // the pub key(s) used for keypath signing.\n      // aggregated with MuSig2* if > 1\n      pubkeys: typef.maybe(typef.anyOf(typef.arrayOf(ecc.isXOnlyPoint), typef.arrayOf(isPlainPubkey))),\n\n      redeems: typef.maybe(\n        typef.arrayOf({\n          network: typef.maybe(typef.Object),\n          output: typef.maybe(typef.Buffer),\n          weight: typef.maybe(typef.Number),\n          depth: typef.maybe(typef.Number),\n          witness: typef.maybe(typef.arrayOf(typef.Buffer)),\n        })\n      ),\n      redeemIndex: typef.maybe(typef.Number), // Selects the redeem to spend\n\n      signature: typef.maybe(bscript.isCanonicalSchnorrSignature),\n      controlBlock: typef.maybe(typef.Buffer),\n      annex: typef.maybe(typef.Buffer),\n    },\n    a\n  );\n\n  const _address = lazy.value(() => {\n    if (!a.address) return undefined;\n\n    const result = bech32m.decode(a.address);\n    const version = result.words.shift();\n    const data = bech32m.fromWords(result.words);\n    return {\n      version,\n      prefix: result.prefix,\n      data: Buffer.from(data),\n    };\n  });\n  const _outputPubkey = lazy.value(() => {\n    // we remove the first two bytes (OP_1 0x20) from the output script to\n    // extract the 32 byte taproot pubkey (aka witness program)\n    return a.output && a.output.slice(2);\n  });\n\n  const network = a.network || BITCOIN_NETWORK;\n\n  const o: Payment = { network };\n\n  const _taprootPaths = lazy.value(() => {\n    if (!a.redeems) return;\n    if (o.tapTree) {\n      return taproot.getDepthFirstTaptree(o.tapTree);\n    }\n    const outputs: Array<Buffer | undefined> = a.redeems.map(({ output }) => output);\n    if (!outputs.every((output) => output)) return;\n    return taproot.getHuffmanTaptree(\n      outputs as Buffer[],\n      a.redeems.map(({ weight }) => weight)\n    );\n  });\n  const _parsedWitness = lazy.value(() => {\n    if (!a.witness) return;\n    return taproot.parseTaprootWitness(a.witness);\n  });\n  const _parsedControlBlock = lazy.value(() => {\n    // Can't use o.controlBlock, because it could be circular\n    if (a.controlBlock) return taproot.parseControlBlock(ecc, a.controlBlock);\n    const parsedWitness = _parsedWitness();\n    if (parsedWitness && parsedWitness.spendType === 'Script') {\n      return taproot.parseControlBlock(ecc, parsedWitness.controlBlock);\n    }\n  });\n\n  lazy.prop(o, 'internalPubkey', () => {\n    if (a.pubkey) {\n      // single pubkey\n      return a.pubkey;\n    } else if (a.pubkeys && a.pubkeys.length === 1) {\n      return a.pubkeys[0];\n    } else if (a.pubkeys && a.pubkeys.length > 1) {\n      // multiple pubkeys\n      if (isPlainPubkeys(a.pubkeys)) {\n        return Buffer.from(musig.getXOnlyPubkey(musig.keyAgg(musig.keySort(a.pubkeys))));\n      }\n\n      return Buffer.from(taproot.aggregateMuSigPubkeys(ecc, a.pubkeys));\n    } else if (_parsedControlBlock()) {\n      return _parsedControlBlock()?.internalPubkey;\n    } else {\n      // If there is no key path spending condition, we use an internal key with unknown secret key.\n      // TODO: In order to avoid leaking the information that key path spending is not possible it\n      // is recommended to pick a fresh integer r in the range 0...n-1 uniformly at random and use\n      // H + rG as internal key. It is possible to prove that this internal key does not have a\n      // known discrete logarithm with respect to G by revealing r to a verifier who can then\n      // reconstruct how the internal key was created.\n      return H;\n    }\n  });\n\n  const _taprootPubkey = lazy.value(() => {\n    const parsedControlBlock = _parsedControlBlock();\n    const parsedWitness = _parsedWitness();\n    // Refuse to create an unspendable key\n    if (!a.pubkey && !(a.pubkeys && a.pubkeys.length) && !a.redeems && !parsedControlBlock) {\n      return;\n    }\n    let taptreeRoot;\n    // Prefer to get the root via the control block because not all redeems may\n    // be available\n    if (parsedControlBlock) {\n      let tapscript;\n      if (parsedWitness && parsedWitness.spendType === 'Script') {\n        tapscript = parsedWitness.tapscript;\n      } else if (o.redeem && o.redeem.output) {\n        tapscript = o.redeem.output;\n      }\n      if (tapscript) taptreeRoot = taproot.getTaptreeRoot(ecc, parsedControlBlock, tapscript);\n    }\n    if (!taptreeRoot && _taprootPaths()) taptreeRoot = _taprootPaths()?.root;\n\n    return taproot.tapTweakPubkey(ecc, o?.internalPubkey as Uint8Array, taptreeRoot);\n  });\n\n  lazy.prop(o, 'tapTree', () => {\n    if (!a.redeems) return;\n    if (a.redeems.find(({ depth }) => depth === undefined)) {\n      console.warn(\n        'Deprecation Warning: Weight-based tap tree construction will be removed in the future. ' +\n          'Please use depth-first coding as specified in BIP-0371.'\n      );\n      return;\n    }\n    if (!a.redeems.every(({ output }) => output)) return;\n    return {\n      leaves: a.redeems.map(({ output, depth }) => {\n        return {\n          script: output,\n          leafVersion: taproot.INITIAL_TAPSCRIPT_VERSION,\n          depth,\n        };\n      }),\n    };\n  });\n  lazy.prop(o, 'address', () => {\n    const pubkey = _outputPubkey() || (_taprootPubkey() && _taprootPubkey()?.xOnlyPubkey);\n    // only encode the 32 byte witness program as bech32m\n    const words = bech32m.toWords(pubkey);\n    words.unshift(0x01);\n    return bech32m.encode(network.bech32, words);\n  });\n  lazy.prop(o, 'controlBlock', () => {\n    const parsedWitness = _parsedWitness();\n    if (parsedWitness && parsedWitness.spendType === 'Script') {\n      return parsedWitness.controlBlock;\n    }\n    const taprootPubkey = _taprootPubkey();\n    const taprootPaths = _taprootPaths();\n    if (!taprootPaths || !taprootPubkey || a.redeemIndex === undefined) return;\n    return taproot.getControlBlock(taprootPubkey.parity, o.internalPubkey!, taprootPaths.paths[a.redeemIndex]);\n  });\n  lazy.prop(o, 'signature', () => {\n    const parsedWitness = _parsedWitness();\n    if (parsedWitness && parsedWitness.spendType === 'Key') {\n      return parsedWitness.signature;\n    }\n  });\n  lazy.prop(o, 'annex', () => {\n    if (!_parsedWitness()) return;\n    return _parsedWitness()!.annex;\n  });\n  lazy.prop(o, 'output', () => {\n    if (a.address) {\n      const { data } = _address()!;\n      return bscript.compile([OPS.OP_1, data]);\n    }\n\n    const taprootPubkey = _taprootPubkey();\n    if (!taprootPubkey) return;\n\n    // OP_1 indicates segwit version 1\n    return bscript.compile([OPS.OP_1, Buffer.from(taprootPubkey.xOnlyPubkey)]);\n  });\n  lazy.prop(o, 'witness', () => {\n    if (!a.redeems) {\n      if (a.signature) return [a.signature]; // Keypath spend\n      return;\n    } else if (!o.redeem) {\n      return; // No chosen redeem script, can't make witness\n    } else if (!o.controlBlock) {\n      return;\n    }\n\n    let redeemWitness;\n    // some callers may provide witness elements in the input script\n    if (o.redeem.input && o.redeem.input.length > 0 && o.redeem.output && o.redeem.output.length > 0) {\n      // transform redeem input to witness stack\n      redeemWitness = bscript.toStack(bscript.decompile(o.redeem.input)!);\n\n      // assigns a new object to o.redeem\n      o.redeems![a.redeemIndex!] = Object.assign({ witness: redeemWitness }, o.redeem);\n      o.redeem.input = EMPTY_BUFFER;\n    } else if (o.redeem.output && o.redeem.output.length > 0 && o.redeem.witness && o.redeem.witness.length > 0) {\n      redeemWitness = o.redeem.witness;\n    } else {\n      return;\n    }\n\n    const witness = [...redeemWitness, o.redeem.output, o.controlBlock];\n\n    if (a.annex) {\n      witness.push(a.annex);\n    }\n\n    return witness;\n  });\n  lazy.prop(o, 'name', () => {\n    const nameParts = ['p2tr'];\n    return nameParts.join('-');\n  });\n  lazy.prop(o, 'redeem', () => {\n    if (a.redeems) {\n      if (a.redeemIndex === undefined) return;\n      return a.redeems[a.redeemIndex];\n    }\n    const parsedWitness = _parsedWitness();\n    if (parsedWitness && parsedWitness.spendType === 'Script') {\n      return {\n        witness: parsedWitness.scriptSig,\n        output: parsedWitness.tapscript,\n      };\n    }\n  });\n\n  // extended validation\n  if (opts.validate) {\n    const taprootPubkey = _taprootPubkey();\n\n    if (a.output) {\n      if (a.output[0] !== OPS.OP_1 || a.output[1] !== 0x20) {\n        throw new TypeError('Output is invalid');\n      }\n\n      // if we're passed both an output script and an address, ensure they match\n      if (a.address && _outputPubkey && !_outputPubkey()?.equals(_address()?.data as Buffer)) {\n        throw new TypeError('mismatch between address & output');\n      }\n\n      if (taprootPubkey && _outputPubkey && !_outputPubkey()?.equals(taprootPubkey.xOnlyPubkey)) {\n        throw new TypeError('mismatch between output and taproot pubkey');\n      }\n    }\n\n    if (a.address) {\n      if (taprootPubkey && !_address()?.data.equals(taprootPubkey.xOnlyPubkey)) {\n        throw new TypeError('mismatch between address and taproot pubkey');\n      }\n    }\n\n    const parsedControlBlock = _parsedControlBlock();\n    if (parsedControlBlock) {\n      if (!parsedControlBlock.internalPubkey.equals(o?.internalPubkey as Uint8Array)) {\n        throw new TypeError('Internal pubkey mismatch');\n      }\n      if (taprootPubkey && parsedControlBlock.parity !== taprootPubkey.parity) {\n        throw new TypeError('Parity mismatch');\n      }\n    }\n\n    if (a.redeems) {\n      if (!a.redeems.length) throw new TypeError('Empty redeems');\n      if (a.redeemIndex !== undefined && (a.redeemIndex < 0 || a.redeemIndex >= a.redeems.length)) {\n        throw new TypeError('invalid redeem index');\n      }\n      a.redeems.forEach((redeem) => {\n        if (redeem.network && redeem.network !== network) {\n          throw new TypeError('Network mismatch');\n        }\n      });\n    }\n\n    const chosenRedeem = a.redeems && a.redeemIndex !== undefined && a.redeems[a.redeemIndex];\n\n    const parsedWitness = _parsedWitness();\n    if (parsedWitness && parsedWitness.spendType === 'Key') {\n      if (a.controlBlock) {\n        throw new TypeError('unexpected control block for key path');\n      }\n\n      if (a.signature && !a.signature.equals(parsedWitness.signature)) {\n        throw new TypeError('mismatch between witness & signature');\n      }\n    }\n    if (parsedWitness && parsedWitness.spendType === 'Script') {\n      if (a.signature) {\n        throw new TypeError('unexpected signature with script path witness');\n      }\n\n      if (a.controlBlock && !a.controlBlock.equals(parsedWitness.controlBlock)) {\n        throw new TypeError('control block mismatch');\n      }\n\n      if (a.annex && parsedWitness.annex && !a.annex.equals(parsedWitness.annex)) {\n        throw new TypeError('annex mismatch');\n      }\n\n      if (chosenRedeem && chosenRedeem.output && !chosenRedeem.output.equals(parsedWitness.tapscript)) {\n        throw new TypeError('tapscript mismatch');\n      }\n    }\n  }\n\n  return Object.assign(o, a);\n}\n"]}

package/dist/src/payments/p2tr_ns.d.ts

@@ -0,0 +1,3 @@
+import { Payment, PaymentOpts } from 'bitcoinjs-lib';
+export declare function p2tr_ns(a: Payment, opts?: PaymentOpts): Payment;
+//# sourceMappingURL=p2tr_ns.d.ts.map

package/dist/src/payments/p2tr_ns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"p2tr_ns.d.ts","sourceRoot":"","sources":["../../../src/payments/p2tr_ns.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,OAAO,EAAE,WAAW,EAAe,MAAM,eAAe,CAAC;AAiBrF,wBAAgB,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,OAAO,CAgI/D"}