@opcat-labs/bip174 1.0.0

package/src/cjs/lib/converter/input/partialSig.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeFields_js_1 = require("../../typeFields.js");
+const tools = __importStar(require("uint8array-tools"));
+function decode(keyVal) {
+    if (keyVal.key[0] !== typeFields_js_1.InputTypes.PARTIAL_SIG) {
+        throw new Error('Decode Error: could not decode partialSig with key 0x' +
+            tools.toHex(keyVal.key));
+    }
+    if (!(keyVal.key.length === 34 || keyVal.key.length === 66) ||
+        ![2, 3, 4].includes(keyVal.key[1])) {
+        throw new Error('Decode Error: partialSig has invalid pubkey in key 0x' +
+            tools.toHex(keyVal.key));
+    }
+    const pubkey = keyVal.key.slice(1);
+    return {
+        pubkey,
+        signature: keyVal.value,
+    };
+}
+exports.decode = decode;
+function encode(pSig) {
+    const head = new Uint8Array([typeFields_js_1.InputTypes.PARTIAL_SIG]);
+    return {
+        key: tools.concat([head, pSig.pubkey]),
+        value: pSig.signature,
+    };
+}
+exports.encode = encode;
+exports.expected = '{ pubkey: Uint8Array; signature: Uint8Array; }';
+function check(data) {
+    return (data.pubkey instanceof Uint8Array &&
+        data.signature instanceof Uint8Array &&
+        [33, 65].includes(data.pubkey.length) &&
+        [2, 3, 4].includes(data.pubkey[0]) &&
+        isDerSigWithSighash(data.signature));
+}
+exports.check = check;
+function isDerSigWithSighash(buf) {
+    if (!(buf instanceof Uint8Array) || buf.length < 9)
+        return false;
+    if (buf[0] !== 0x30)
+        return false;
+    if (buf.length !== buf[1] + 3)
+        return false;
+    if (buf[2] !== 0x02)
+        return false;
+    const rLen = buf[3];
+    if (rLen > 33 || rLen < 1)
+        return false;
+    if (buf[3 + rLen + 1] !== 0x02)
+        return false;
+    const sLen = buf[3 + rLen + 2];
+    if (sLen > 33 || sLen < 1)
+        return false;
+    if (buf.length !== 3 + rLen + 2 + sLen + 2)
+        return false;
+    return true;
+}
+function canAddToArray(array, item, dupeSet) {
+    const dupeString = tools.toHex(item.pubkey);
+    if (dupeSet.has(dupeString))
+        return false;
+    dupeSet.add(dupeString);
+    return (array.filter(v => tools.compare(v.pubkey, item.pubkey) === 0).length === 0);
+}
+exports.canAddToArray = canAddToArray;

package/src/cjs/lib/converter/input/porCommitment.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeFields_js_1 = require("../../typeFields.js");
+const tools = __importStar(require("uint8array-tools"));
+function decode(keyVal) {
+    if (keyVal.key[0] !== typeFields_js_1.InputTypes.POR_COMMITMENT) {
+        throw new Error('Decode Error: could not decode porCommitment with key 0x' +
+            tools.toHex(keyVal.key));
+    }
+    return tools.toUtf8(keyVal.value);
+}
+exports.decode = decode;
+function encode(data) {
+    const key = new Uint8Array([typeFields_js_1.InputTypes.POR_COMMITMENT]);
+    return {
+        key,
+        value: tools.fromUtf8(data),
+    };
+}
+exports.encode = encode;
+exports.expected = 'string';
+function check(data) {
+    return typeof data === 'string';
+}
+exports.check = check;
+function canAdd(currentData, newData) {
+    return !!currentData && !!newData && currentData.porCommitment === undefined;
+}
+exports.canAdd = canAdd;

package/src/cjs/lib/converter/input/sighashType.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeFields_js_1 = require("../../typeFields.js");
+const tools = __importStar(require("uint8array-tools"));
+function decode(keyVal) {
+    if (keyVal.key[0] !== typeFields_js_1.InputTypes.SIGHASH_TYPE) {
+        throw new Error('Decode Error: could not decode sighashType with key 0x' +
+            tools.toHex(keyVal.key));
+    }
+    return Number(tools.readUInt32(keyVal.value, 0, 'LE'));
+}
+exports.decode = decode;
+function encode(data) {
+    const key = Uint8Array.from([typeFields_js_1.InputTypes.SIGHASH_TYPE]);
+    const value = new Uint8Array(4);
+    tools.writeUInt32(value, 0, data, 'LE');
+    return {
+        key,
+        value,
+    };
+}
+exports.encode = encode;
+exports.expected = 'number';
+function check(data) {
+    return typeof data === 'number';
+}
+exports.check = check;
+function canAdd(currentData, newData) {
+    return !!currentData && !!newData && currentData.sighashType === undefined;
+}
+exports.canAdd = canAdd;

package/src/cjs/lib/converter/input/tapKeySig.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeFields_js_1 = require("../../typeFields.js");
+const tools = __importStar(require("uint8array-tools"));
+function decode(keyVal) {
+    if (keyVal.key[0] !== typeFields_js_1.InputTypes.TAP_KEY_SIG || keyVal.key.length !== 1) {
+        throw new Error('Decode Error: could not decode tapKeySig with key 0x' +
+            tools.toHex(keyVal.key));
+    }
+    if (!check(keyVal.value)) {
+        throw new Error('Decode Error: tapKeySig not a valid 64-65-byte BIP340 signature');
+    }
+    return keyVal.value;
+}
+exports.decode = decode;
+function encode(value) {
+    const key = Uint8Array.from([typeFields_js_1.InputTypes.TAP_KEY_SIG]);
+    return { key, value };
+}
+exports.encode = encode;
+exports.expected = 'Uint8Array';
+function check(data) {
+    return (data instanceof Uint8Array && (data.length === 64 || data.length === 65));
+}
+exports.check = check;
+function canAdd(currentData, newData) {
+    return !!currentData && !!newData && currentData.tapKeySig === undefined;
+}
+exports.canAdd = canAdd;

package/src/cjs/lib/converter/input/tapLeafScript.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeFields_js_1 = require("../../typeFields.js");
+const tools = __importStar(require("uint8array-tools"));
+function decode(keyVal) {
+    if (keyVal.key[0] !== typeFields_js_1.InputTypes.TAP_LEAF_SCRIPT) {
+        throw new Error('Decode Error: could not decode tapLeafScript with key 0x' +
+            tools.toHex(keyVal.key));
+    }
+    if ((keyVal.key.length - 2) % 32 !== 0) {
+        throw new Error('Decode Error: tapLeafScript has invalid control block in key 0x' +
+            tools.toHex(keyVal.key));
+    }
+    const leafVersion = keyVal.value[keyVal.value.length - 1];
+    if ((keyVal.key[1] & 0xfe) !== leafVersion) {
+        throw new Error('Decode Error: tapLeafScript bad leaf version in key 0x' +
+            tools.toHex(keyVal.key));
+    }
+    const script = keyVal.value.slice(0, -1);
+    const controlBlock = keyVal.key.slice(1);
+    return { controlBlock, script, leafVersion };
+}
+exports.decode = decode;
+function encode(tScript) {
+    const head = Uint8Array.from([typeFields_js_1.InputTypes.TAP_LEAF_SCRIPT]);
+    const verBuf = Uint8Array.from([tScript.leafVersion]);
+    return {
+        key: tools.concat([head, tScript.controlBlock]),
+        value: tools.concat([tScript.script, verBuf]),
+    };
+}
+exports.encode = encode;
+exports.expected = '{ controlBlock: Uint8Array; leafVersion: number, script: Uint8Array; }';
+function check(data) {
+    return (data.controlBlock instanceof Uint8Array &&
+        (data.controlBlock.length - 1) % 32 === 0 &&
+        (data.controlBlock[0] & 0xfe) === data.leafVersion &&
+        data.script instanceof Uint8Array);
+}
+exports.check = check;
+function canAddToArray(array, item, dupeSet) {
+    const dupeString = tools.toHex(item.controlBlock);
+    if (dupeSet.has(dupeString))
+        return false;
+    dupeSet.add(dupeString);
+    return (array.filter(v => tools.compare(v.controlBlock, item.controlBlock) === 0)
+        .length === 0);
+}
+exports.canAddToArray = canAddToArray;

package/src/cjs/lib/converter/input/tapMerkleRoot.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeFields_js_1 = require("../../typeFields.js");
+const tools = __importStar(require("uint8array-tools"));
+function decode(keyVal) {
+    if (keyVal.key[0] !== typeFields_js_1.InputTypes.TAP_MERKLE_ROOT || keyVal.key.length !== 1) {
+        throw new Error('Decode Error: could not decode tapMerkleRoot with key 0x' +
+            tools.toHex(keyVal.key));
+    }
+    if (!check(keyVal.value)) {
+        throw new Error('Decode Error: tapMerkleRoot not a 32-byte hash');
+    }
+    return keyVal.value;
+}
+exports.decode = decode;
+function encode(value) {
+    const key = Uint8Array.from([typeFields_js_1.InputTypes.TAP_MERKLE_ROOT]);
+    return { key, value };
+}
+exports.encode = encode;
+exports.expected = 'Uint8Array';
+function check(data) {
+    return data instanceof Uint8Array && data.length === 32;
+}
+exports.check = check;
+function canAdd(currentData, newData) {
+    return !!currentData && !!newData && currentData.tapMerkleRoot === undefined;
+}
+exports.canAdd = canAdd;

package/src/cjs/lib/converter/input/tapScriptSig.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeFields_js_1 = require("../../typeFields.js");
+const tools = __importStar(require("uint8array-tools"));
+function decode(keyVal) {
+    if (keyVal.key[0] !== typeFields_js_1.InputTypes.TAP_SCRIPT_SIG) {
+        throw new Error('Decode Error: could not decode tapScriptSig with key 0x' +
+            tools.toHex(keyVal.key));
+    }
+    if (keyVal.key.length !== 65) {
+        throw new Error('Decode Error: tapScriptSig has invalid key 0x' + tools.toHex(keyVal.key));
+    }
+    if (keyVal.value.length !== 64 && keyVal.value.length !== 65) {
+        throw new Error('Decode Error: tapScriptSig has invalid signature in key 0x' +
+            tools.toHex(keyVal.key));
+    }
+    const pubkey = keyVal.key.slice(1, 33);
+    const leafHash = keyVal.key.slice(33);
+    return {
+        pubkey,
+        leafHash,
+        signature: keyVal.value,
+    };
+}
+exports.decode = decode;
+function encode(tSig) {
+    const head = Uint8Array.from([typeFields_js_1.InputTypes.TAP_SCRIPT_SIG]);
+    return {
+        key: tools.concat([head, tSig.pubkey, tSig.leafHash]),
+        value: tSig.signature,
+    };
+}
+exports.encode = encode;
+exports.expected = '{ pubkey: Uint8Array; leafHash: Uint8Array; signature: Uint8Array; }';
+function check(data) {
+    return (data.pubkey instanceof Uint8Array &&
+        data.leafHash instanceof Uint8Array &&
+        data.signature instanceof Uint8Array &&
+        data.pubkey.length === 32 &&
+        data.leafHash.length === 32 &&
+        (data.signature.length === 64 || data.signature.length === 65));
+}
+exports.check = check;
+function canAddToArray(array, item, dupeSet) {
+    const dupeString = tools.toHex(item.pubkey) + tools.toHex(item.leafHash);
+    if (dupeSet.has(dupeString))
+        return false;
+    dupeSet.add(dupeString);
+    return (array.filter(v => tools.compare(v.pubkey, item.pubkey) === 0 &&
+        tools.compare(v.leafHash, item.leafHash) === 0).length === 0);
+}
+exports.canAddToArray = canAddToArray;

package/src/cjs/lib/converter/input/witnessUtxo.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeFields_js_1 = require("../../typeFields.js");
+const tools = __importStar(require("uint8array-tools"));
+const varuint = __importStar(require("varuint-bitcoin"));
+function decode(keyVal) {
+    if (keyVal.key[0] !== typeFields_js_1.InputTypes.WITNESS_UTXO) {
+        throw new Error('Decode Error: could not decode witnessUtxo with key 0x' +
+            tools.toHex(keyVal.key));
+    }
+    const value = tools.readInt64(keyVal.value, 0, 'LE');
+    let _offset = 8;
+    const { numberValue: scriptLen, bytes } = varuint.decode(keyVal.value, _offset);
+    _offset += bytes;
+    const script = keyVal.value.slice(_offset);
+    if (script.length !== scriptLen) {
+        throw new Error('Decode Error: WITNESS_UTXO script is not proper length');
+    }
+    return {
+        script,
+        value,
+    };
+}
+exports.decode = decode;
+function encode(data) {
+    const { script, value } = data;
+    const varuintlen = varuint.encodingLength(script.length);
+    const result = new Uint8Array(8 + varuintlen + script.length);
+    tools.writeInt64(result, 0, BigInt(value), 'LE');
+    varuint.encode(script.length, result, 8);
+    result.set(script, 8 + varuintlen);
+    return {
+        key: Uint8Array.from([typeFields_js_1.InputTypes.WITNESS_UTXO]),
+        value: result,
+    };
+}
+exports.encode = encode;
+exports.expected = '{ script: Uint8Array; value: bigint; }';
+function check(data) {
+    return data.script instanceof Uint8Array && typeof data.value === 'bigint';
+}
+exports.check = check;
+function canAdd(currentData, newData) {
+    return !!currentData && !!newData && currentData.witnessUtxo === undefined;
+}
+exports.canAdd = canAdd;

package/src/cjs/lib/converter/output/tapTree.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeFields_js_1 = require("../../typeFields.js");
+const varuint = __importStar(require("varuint-bitcoin"));
+const tools = __importStar(require("uint8array-tools"));
+function decode(keyVal) {
+    if (keyVal.key[0] !== typeFields_js_1.OutputTypes.TAP_TREE || keyVal.key.length !== 1) {
+        throw new Error('Decode Error: could not decode tapTree with key 0x' +
+            tools.toHex(keyVal.key));
+    }
+    let _offset = 0;
+    const data = [];
+    while (_offset < keyVal.value.length) {
+        const depth = keyVal.value[_offset++];
+        const leafVersion = keyVal.value[_offset++];
+        const { numberValue: scriptLen, bytes } = varuint.decode(keyVal.value, _offset);
+        _offset += bytes;
+        data.push({
+            depth,
+            leafVersion,
+            script: keyVal.value.slice(_offset, _offset + scriptLen),
+        });
+        _offset += scriptLen;
+    }
+    return { leaves: data };
+}
+exports.decode = decode;
+function encode(tree) {
+    const key = Uint8Array.from([typeFields_js_1.OutputTypes.TAP_TREE]);
+    const bufs = [].concat(...tree.leaves.map(tapLeaf => [
+        Uint8Array.of(tapLeaf.depth, tapLeaf.leafVersion),
+        varuint.encode(BigInt(tapLeaf.script.length)).buffer,
+        tapLeaf.script,
+    ]));
+    return {
+        key,
+        value: tools.concat(bufs),
+    };
+}
+exports.encode = encode;
+exports.expected = '{ leaves: [{ depth: number; leafVersion: number, script: Uint8Array; }] }';
+function check(data) {
+    return (Array.isArray(data.leaves) &&
+        data.leaves.every((tapLeaf) => tapLeaf.depth >= 0 &&
+            tapLeaf.depth <= 128 &&
+            (tapLeaf.leafVersion & 0xfe) === tapLeaf.leafVersion &&
+            tapLeaf.script instanceof Uint8Array));
+}
+exports.check = check;
+function canAdd(currentData, newData) {
+    return !!currentData && !!newData && currentData.tapTree === undefined;
+}
+exports.canAdd = canAdd;

package/src/cjs/lib/converter/shared/bip32Derivation.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const tools = __importStar(require("uint8array-tools"));
+const range = (n) => [...Array(n).keys()];
+const isValidDERKey = (pubkey) => (pubkey.length === 33 && [2, 3].includes(pubkey[0])) ||
+    (pubkey.length === 65 && 4 === pubkey[0]);
+function makeConverter(TYPE_BYTE, isValidPubkey = isValidDERKey) {
+    function decode(keyVal) {
+        if (keyVal.key[0] !== TYPE_BYTE) {
+            throw new Error('Decode Error: could not decode bip32Derivation with key 0x' +
+                tools.toHex(keyVal.key));
+        }
+        const pubkey = keyVal.key.slice(1);
+        if (!isValidPubkey(pubkey)) {
+            throw new Error('Decode Error: bip32Derivation has invalid pubkey in key 0x' +
+                tools.toHex(keyVal.key));
+        }
+        if ((keyVal.value.length / 4) % 1 !== 0) {
+            throw new Error('Decode Error: Input BIP32_DERIVATION value length should be multiple of 4');
+        }
+        const data = {
+            masterFingerprint: keyVal.value.slice(0, 4),
+            pubkey,
+            path: 'm',
+        };
+        for (const i of range(keyVal.value.length / 4 - 1)) {
+            const val = tools.readUInt32(keyVal.value, i * 4 + 4, 'LE');
+            const isHard = !!(val & 0x80000000);
+            const idx = val & 0x7fffffff;
+            data.path += '/' + idx.toString(10) + (isHard ? "'" : '');
+        }
+        return data;
+    }
+    function encode(data) {
+        const head = Uint8Array.from([TYPE_BYTE]);
+        const key = tools.concat([head, data.pubkey]);
+        const splitPath = data.path.split('/');
+        const value = new Uint8Array(splitPath.length * 4);
+        value.set(data.masterFingerprint, 0);
+        let offset = 4;
+        splitPath.slice(1).forEach(level => {
+            const isHard = level.slice(-1) === "'";
+            let num = 0x7fffffff & parseInt(isHard ? level.slice(0, -1) : level, 10);
+            if (isHard)
+                num += 0x80000000;
+            tools.writeUInt32(value, offset, num, 'LE');
+            offset += 4;
+        });
+        return {
+            key,
+            value,
+        };
+    }
+    const expected = '{ masterFingerprint: Uint8Array; pubkey: Uint8Array; path: string; }';
+    function check(data) {
+        return (data.pubkey instanceof Uint8Array &&
+            data.masterFingerprint instanceof Uint8Array &&
+            typeof data.path === 'string' &&
+            isValidPubkey(data.pubkey) &&
+            data.masterFingerprint.length === 4);
+    }
+    function canAddToArray(array, item, dupeSet) {
+        const dupeString = tools.toHex(item.pubkey);
+        if (dupeSet.has(dupeString))
+            return false;
+        dupeSet.add(dupeString);
+        return (array.filter(v => tools.compare(v.pubkey, item.pubkey) === 0).length === 0);
+    }
+    return {
+        decode,
+        encode,
+        check,
+        expected,
+        canAddToArray,
+    };
+}
+exports.makeConverter = makeConverter;

package/src/cjs/lib/converter/shared/checkPubkey.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const tools = __importStar(require("uint8array-tools"));
+function makeChecker(pubkeyTypes) {
+    return checkPubkey;
+    function checkPubkey(keyVal) {
+        let pubkey;
+        if (pubkeyTypes.includes(keyVal.key[0])) {
+            pubkey = keyVal.key.slice(1);
+            if (!(pubkey.length === 33 || pubkey.length === 65) ||
+                ![2, 3, 4].includes(pubkey[0])) {
+                throw new Error('Format Error: invalid pubkey in key 0x' + tools.toHex(keyVal.key));
+            }
+        }
+        return pubkey;
+    }
+}
+exports.makeChecker = makeChecker;

package/src/cjs/lib/converter/shared/redeemScript.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const tools = __importStar(require("uint8array-tools"));
+function makeConverter(TYPE_BYTE) {
+    function decode(keyVal) {
+        if (keyVal.key[0] !== TYPE_BYTE) {
+            throw new Error('Decode Error: could not decode redeemScript with key 0x' +
+                tools.toHex(keyVal.key));
+        }
+        return keyVal.value;
+    }
+    function encode(data) {
+        const key = Uint8Array.from([TYPE_BYTE]);
+        return {
+            key,
+            value: data,
+        };
+    }
+    const expected = 'Uint8Array';
+    function check(data) {
+        return data instanceof Uint8Array;
+    }
+    function canAdd(currentData, newData) {
+        return !!currentData && !!newData && currentData.redeemScript === undefined;
+    }
+    return {
+        decode,
+        encode,
+        check,
+        expected,
+        canAdd,
+    };
+}
+exports.makeConverter = makeConverter;

package/src/cjs/lib/converter/shared/tapBip32Derivation.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const varuint = __importStar(require("varuint-bitcoin"));
+const tools = __importStar(require("uint8array-tools"));
+const bip32Derivation = __importStar(require("./bip32Derivation.js"));
+const isValidBIP340Key = (pubkey) => pubkey.length === 32;
+function makeConverter(TYPE_BYTE) {
+    const parent = bip32Derivation.makeConverter(TYPE_BYTE, isValidBIP340Key);
+    function decode(keyVal) {
+        const { numberValue: nHashes, bytes: nHashesLen } = varuint.decode(keyVal.value);
+        const base = parent.decode({
+            key: keyVal.key,
+            value: keyVal.value.slice(nHashesLen + Number(nHashes) * 32),
+        });
+        const leafHashes = new Array(Number(nHashes));
+        for (let i = 0, _offset = nHashesLen; i < nHashes; i++, _offset += 32) {
+            leafHashes[i] = keyVal.value.slice(_offset, _offset + 32);
+        }
+        return { ...base, leafHashes };
+    }
+    function encode(data) {
+        const base = parent.encode(data);
+        const nHashesLen = varuint.encodingLength(data.leafHashes.length);
+        const nHashesBuf = new Uint8Array(nHashesLen);
+        varuint.encode(data.leafHashes.length, nHashesBuf);
+        const value = tools.concat([nHashesBuf, ...data.leafHashes, base.value]);
+        return { ...base, value };
+    }
+    const expected = '{ ' +
+        'masterFingerprint: Uint8Array; ' +
+        'pubkey: Uint8Array; ' +
+        'path: string; ' +
+        'leafHashes: Uint8Array[]; ' +
+        '}';
+    function check(data) {
+        return (Array.isArray(data.leafHashes) &&
+            data.leafHashes.every((leafHash) => leafHash instanceof Uint8Array && leafHash.length === 32) &&
+            parent.check(data));
+    }
+    return {
+        decode,
+        encode,
+        check,
+        expected,
+        canAddToArray: parent.canAddToArray,
+    };
+}
+exports.makeConverter = makeConverter;