@opcat-labs/bip174 1.0.0

package/src/esm/lib/converter/input/opcatUtxo.js

@@ -0,0 +1,61 @@
+import { InputTypes } from '../../typeFields.js';
+import * as tools from 'uint8array-tools';
+import * as varuint from 'varuint-bitcoin';
+export function decode(keyVal) {
+    if (keyVal.key[0] !== InputTypes.OPCAT_UTXO) {
+        throw new Error('Decode Error: could not decode opcatUtxo with key 0x' +
+            tools.toHex(keyVal.key));
+    }
+    let offset = 0;
+    const value = tools.readInt64(keyVal.value, offset, 'LE');
+    offset += 8;
+    const { numberValue: scriptLen, bytes: scriptLenBytes } = varuint.decode(keyVal.value, offset);
+    if (scriptLen == null)
+        throw new Error('Decode Error: scriptLen is null');
+    offset += scriptLenBytes;
+    const script = keyVal.value.slice(offset, offset + scriptLen);
+    offset += scriptLen;
+    const { numberValue: dataLen, bytes: dataLenBytes } = varuint.decode(keyVal.value, offset);
+    if (dataLen == null)
+        throw new Error('Decode Error: dataLen is null');
+    offset += dataLenBytes;
+    const data = keyVal.value.slice(offset, offset + dataLen);
+    offset += dataLen;
+    return {
+        script,
+        data,
+        value,
+    };
+}
+export function encode(data) {
+    const { script, data: opcatData, value } = data;
+    const scriptLen = script.length;
+    const dataLen = opcatData.length;
+    const scriptLenVar = varuint.encodingLength(scriptLen);
+    const dataLenVar = varuint.encodingLength(dataLen);
+    const totalLen = 8 + scriptLenVar + scriptLen + dataLenVar + dataLen;
+    const result = new Uint8Array(totalLen);
+    let offset = 0;
+    tools.writeInt64(result, offset, BigInt(value), 'LE');
+    offset += 8;
+    varuint.encode(scriptLen, result, offset);
+    offset += scriptLenVar;
+    result.set(script, offset);
+    offset += scriptLen;
+    varuint.encode(dataLen, result, offset);
+    offset += dataLenVar;
+    result.set(opcatData, offset);
+    return {
+        key: Uint8Array.from([InputTypes.OPCAT_UTXO]),
+        value: result,
+    };
+}
+export const expected = '{ script: Uint8Array; data: Uint8Array; value: bigint; }';
+export function check(data) {
+    return (data.script instanceof Uint8Array &&
+        data.data instanceof Uint8Array &&
+        typeof data.value === 'bigint');
+}
+export function canAdd(currentData, newData) {
+    return !!currentData && !!newData && currentData.opcatUtxo === undefined;
+}

package/src/esm/lib/converter/input/partialSig.d.ts

@@ -0,0 +1,6 @@
+import { KeyValue, PartialSig } from '../../interfaces';
+export declare function decode(keyVal: KeyValue): PartialSig;
+export declare function encode(pSig: PartialSig): KeyValue;
+export declare const expected = "{ pubkey: Uint8Array; signature: Uint8Array; }";
+export declare function check(data: any): data is PartialSig;
+export declare function canAddToArray(array: PartialSig[], item: PartialSig, dupeSet: Set<string>): boolean;

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

@@ -0,0 +1,61 @@
+import { InputTypes } from '../../typeFields.js';
+import * as tools from 'uint8array-tools';
+export function decode(keyVal) {
+    if (keyVal.key[0] !== 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,
+    };
+}
+export function encode(pSig) {
+    const head = new Uint8Array([InputTypes.PARTIAL_SIG]);
+    return {
+        key: tools.concat([head, pSig.pubkey]),
+        value: pSig.signature,
+    };
+}
+export const expected = '{ pubkey: Uint8Array; signature: Uint8Array; }';
+export 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));
+}
+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;
+}
+export 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);
+}

package/src/esm/lib/converter/input/porCommitment.d.ts

@@ -0,0 +1,6 @@
+import { KeyValue, PorCommitment } from '../../interfaces';
+export declare function decode(keyVal: KeyValue): PorCommitment;
+export declare function encode(data: PorCommitment): KeyValue;
+export declare const expected = "string";
+export declare function check(data: any): data is PorCommitment;
+export declare function canAdd(currentData: any, newData: any): boolean;

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

@@ -0,0 +1,23 @@
+import { InputTypes } from '../../typeFields.js';
+import * as tools from 'uint8array-tools';
+export function decode(keyVal) {
+    if (keyVal.key[0] !== InputTypes.POR_COMMITMENT) {
+        throw new Error('Decode Error: could not decode porCommitment with key 0x' +
+            tools.toHex(keyVal.key));
+    }
+    return tools.toUtf8(keyVal.value);
+}
+export function encode(data) {
+    const key = new Uint8Array([InputTypes.POR_COMMITMENT]);
+    return {
+        key,
+        value: tools.fromUtf8(data),
+    };
+}
+export const expected = 'string';
+export function check(data) {
+    return typeof data === 'string';
+}
+export function canAdd(currentData, newData) {
+    return !!currentData && !!newData && currentData.porCommitment === undefined;
+}

package/src/esm/lib/converter/input/sighashType.d.ts

@@ -0,0 +1,6 @@
+import { KeyValue, SighashType } from '../../interfaces';
+export declare function decode(keyVal: KeyValue): SighashType;
+export declare function encode(data: SighashType): KeyValue;
+export declare const expected = "number";
+export declare function check(data: any): data is SighashType;
+export declare function canAdd(currentData: any, newData: any): boolean;

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

@@ -0,0 +1,25 @@
+import { InputTypes } from '../../typeFields.js';
+import * as tools from 'uint8array-tools';
+export function decode(keyVal) {
+    if (keyVal.key[0] !== 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'));
+}
+export function encode(data) {
+    const key = Uint8Array.from([InputTypes.SIGHASH_TYPE]);
+    const value = new Uint8Array(4);
+    tools.writeUInt32(value, 0, data, 'LE');
+    return {
+        key,
+        value,
+    };
+}
+export const expected = 'number';
+export function check(data) {
+    return typeof data === 'number';
+}
+export function canAdd(currentData, newData) {
+    return !!currentData && !!newData && currentData.sighashType === undefined;
+}

package/src/esm/lib/converter/input/tapKeySig.d.ts

@@ -0,0 +1,6 @@
+import { KeyValue, TapKeySig } from '../../interfaces';
+export declare function decode(keyVal: KeyValue): TapKeySig;
+export declare function encode(value: TapKeySig): KeyValue;
+export declare const expected = "Uint8Array";
+export declare function check(data: any): data is TapKeySig;
+export declare function canAdd(currentData: any, newData: any): boolean;

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

@@ -0,0 +1,23 @@
+import { InputTypes } from '../../typeFields.js';
+import * as tools from 'uint8array-tools';
+export function decode(keyVal) {
+    if (keyVal.key[0] !== 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;
+}
+export function encode(value) {
+    const key = Uint8Array.from([InputTypes.TAP_KEY_SIG]);
+    return { key, value };
+}
+export const expected = 'Uint8Array';
+export function check(data) {
+    return (data instanceof Uint8Array && (data.length === 64 || data.length === 65));
+}
+export function canAdd(currentData, newData) {
+    return !!currentData && !!newData && currentData.tapKeySig === undefined;
+}

package/src/esm/lib/converter/input/tapLeafScript.d.ts

@@ -0,0 +1,6 @@
+import { KeyValue, TapLeafScript } from '../../interfaces';
+export declare function decode(keyVal: KeyValue): TapLeafScript;
+export declare function encode(tScript: TapLeafScript): KeyValue;
+export declare const expected = "{ controlBlock: Uint8Array; leafVersion: number, script: Uint8Array; }";
+export declare function check(data: any): data is TapLeafScript;
+export declare function canAddToArray(array: TapLeafScript[], item: TapLeafScript, dupeSet: Set<string>): boolean;

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

@@ -0,0 +1,43 @@
+import { InputTypes } from '../../typeFields.js';
+import * as tools from 'uint8array-tools';
+export function decode(keyVal) {
+    if (keyVal.key[0] !== 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 };
+}
+export function encode(tScript) {
+    const head = Uint8Array.from([InputTypes.TAP_LEAF_SCRIPT]);
+    const verBuf = Uint8Array.from([tScript.leafVersion]);
+    return {
+        key: tools.concat([head, tScript.controlBlock]),
+        value: tools.concat([tScript.script, verBuf]),
+    };
+}
+export const expected = '{ controlBlock: Uint8Array; leafVersion: number, script: Uint8Array; }';
+export function check(data) {
+    return (data.controlBlock instanceof Uint8Array &&
+        (data.controlBlock.length - 1) % 32 === 0 &&
+        (data.controlBlock[0] & 0xfe) === data.leafVersion &&
+        data.script instanceof Uint8Array);
+}
+export 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);
+}

package/src/esm/lib/converter/input/tapMerkleRoot.d.ts

@@ -0,0 +1,6 @@
+import { KeyValue, TapMerkleRoot } from '../../interfaces';
+export declare function decode(keyVal: KeyValue): TapMerkleRoot;
+export declare function encode(value: TapMerkleRoot): KeyValue;
+export declare const expected = "Uint8Array";
+export declare function check(data: any): data is TapMerkleRoot;
+export declare function canAdd(currentData: any, newData: any): boolean;

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

@@ -0,0 +1,23 @@
+import { InputTypes } from '../../typeFields.js';
+import * as tools from 'uint8array-tools';
+export function decode(keyVal) {
+    if (keyVal.key[0] !== 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;
+}
+export function encode(value) {
+    const key = Uint8Array.from([InputTypes.TAP_MERKLE_ROOT]);
+    return { key, value };
+}
+export const expected = 'Uint8Array';
+export function check(data) {
+    return data instanceof Uint8Array && data.length === 32;
+}
+export function canAdd(currentData, newData) {
+    return !!currentData && !!newData && currentData.tapMerkleRoot === undefined;
+}

package/src/esm/lib/converter/input/tapScriptSig.d.ts

@@ -0,0 +1,6 @@
+import { KeyValue, TapScriptSig } from '../../interfaces';
+export declare function decode(keyVal: KeyValue): TapScriptSig;
+export declare function encode(tSig: TapScriptSig): KeyValue;
+export declare const expected = "{ pubkey: Uint8Array; leafHash: Uint8Array; signature: Uint8Array; }";
+export declare function check(data: any): data is TapScriptSig;
+export declare function canAddToArray(array: TapScriptSig[], item: TapScriptSig, dupeSet: Set<string>): boolean;

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

@@ -0,0 +1,46 @@
+import { InputTypes } from '../../typeFields.js';
+import * as tools from 'uint8array-tools';
+export function decode(keyVal) {
+    if (keyVal.key[0] !== 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,
+    };
+}
+export function encode(tSig) {
+    const head = Uint8Array.from([InputTypes.TAP_SCRIPT_SIG]);
+    return {
+        key: tools.concat([head, tSig.pubkey, tSig.leafHash]),
+        value: tSig.signature,
+    };
+}
+export const expected = '{ pubkey: Uint8Array; leafHash: Uint8Array; signature: Uint8Array; }';
+export 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));
+}
+export 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);
+}

package/src/esm/lib/converter/input/witnessUtxo.d.ts

@@ -0,0 +1,6 @@
+import { KeyValue, WitnessUtxo } from '../../interfaces';
+export declare function decode(keyVal: KeyValue): WitnessUtxo;
+export declare function encode(data: WitnessUtxo): KeyValue;
+export declare const expected = "{ script: Uint8Array; value: bigint; }";
+export declare function check(data: any): data is WitnessUtxo;
+export declare function canAdd(currentData: any, newData: any): boolean;

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

@@ -0,0 +1,40 @@
+import { InputTypes } from '../../typeFields.js';
+import * as tools from 'uint8array-tools';
+import * as varuint from 'varuint-bitcoin';
+export function decode(keyVal) {
+    if (keyVal.key[0] !== 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,
+    };
+}
+export 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([InputTypes.WITNESS_UTXO]),
+        value: result,
+    };
+}
+export const expected = '{ script: Uint8Array; value: bigint; }';
+export function check(data) {
+    return data.script instanceof Uint8Array && typeof data.value === 'bigint';
+}
+export function canAdd(currentData, newData) {
+    return !!currentData && !!newData && currentData.witnessUtxo === undefined;
+}

package/src/esm/lib/converter/output/tapTree.d.ts

@@ -0,0 +1,6 @@
+import { KeyValue, TapTree } from '../../interfaces';
+export declare function decode(keyVal: KeyValue): TapTree;
+export declare function encode(tree: TapTree): KeyValue;
+export declare const expected = "{ leaves: [{ depth: number; leafVersion: number, script: Uint8Array; }] }";
+export declare function check(data: any): data is TapTree;
+export declare function canAdd(currentData: any, newData: any): boolean;

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

@@ -0,0 +1,47 @@
+import { OutputTypes } from '../../typeFields.js';
+import * as varuint from 'varuint-bitcoin';
+import * as tools from 'uint8array-tools';
+export function decode(keyVal) {
+    if (keyVal.key[0] !== 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 };
+}
+export function encode(tree) {
+    const key = Uint8Array.from([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),
+    };
+}
+export const expected = '{ leaves: [{ depth: number; leafVersion: number, script: Uint8Array; }] }';
+export 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));
+}
+export function canAdd(currentData, newData) {
+    return !!currentData && !!newData && currentData.tapTree === undefined;
+}

package/src/esm/lib/converter/shared/bip32Derivation.d.ts

@@ -0,0 +1,8 @@
+import { Bip32Derivation, KeyValue } from '../../interfaces';
+export declare function makeConverter(TYPE_BYTE: number, isValidPubkey?: (pubkey: Uint8Array) => boolean): {
+    decode: (keyVal: KeyValue) => Bip32Derivation;
+    encode: (data: Bip32Derivation) => KeyValue;
+    check: (data: any) => data is Bip32Derivation;
+    expected: string;
+    canAddToArray: (array: Bip32Derivation[], item: Bip32Derivation, dupeSet: Set<string>) => boolean;
+};

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

@@ -0,0 +1,74 @@
+import * as tools from '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]);
+export 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,
+    };
+}

package/src/esm/lib/converter/shared/checkPubkey.d.ts

@@ -0,0 +1,2 @@
+import { KeyValue } from '../../interfaces';
+export declare function makeChecker(pubkeyTypes: number[]): (keyVal: KeyValue) => Uint8Array | undefined;

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

@@ -0,0 +1,15 @@
+import * as tools from 'uint8array-tools';
+export 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;
+    }
+}

package/src/esm/lib/converter/shared/redeemScript.d.ts

@@ -0,0 +1,8 @@
+import { KeyValue, RedeemScript } from '../../interfaces';
+export declare function makeConverter(TYPE_BYTE: number): {
+    decode: (keyVal: KeyValue) => RedeemScript;
+    encode: (data: RedeemScript) => KeyValue;
+    check: (data: any) => data is RedeemScript;
+    expected: string;
+    canAdd: (currentData: any, newData: any) => boolean;
+};

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

@@ -0,0 +1,31 @@
+import * as tools from 'uint8array-tools';
+export 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,
+    };
+}

package/src/esm/lib/converter/shared/tapBip32Derivation.d.ts

@@ -0,0 +1,8 @@
+import { KeyValue, TapBip32Derivation } from '../../interfaces';
+export declare function makeConverter(TYPE_BYTE: number): {
+    decode: (keyVal: KeyValue) => TapBip32Derivation;
+    encode: (data: TapBip32Derivation) => KeyValue;
+    check: (data: any) => data is TapBip32Derivation;
+    expected: string;
+    canAddToArray: (array: TapBip32Derivation[], item: TapBip32Derivation, dupeSet: Set<string>) => boolean;
+};