@opcat-labs/bip174 1.0.0

package/src/cjs/lib/typeFields.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var GlobalTypes;
+(function (GlobalTypes) {
+    GlobalTypes[GlobalTypes["UNSIGNED_TX"] = 0] = "UNSIGNED_TX";
+    GlobalTypes[GlobalTypes["GLOBAL_XPUB"] = 1] = "GLOBAL_XPUB";
+})(GlobalTypes = exports.GlobalTypes || (exports.GlobalTypes = {}));
+exports.GLOBAL_TYPE_NAMES = ['unsignedTx', 'globalXpub'];
+var InputTypes;
+(function (InputTypes) {
+    InputTypes[InputTypes["NON_WITNESS_UTXO"] = 0] = "NON_WITNESS_UTXO";
+    InputTypes[InputTypes["WITNESS_UTXO"] = 1] = "WITNESS_UTXO";
+    InputTypes[InputTypes["PARTIAL_SIG"] = 2] = "PARTIAL_SIG";
+    InputTypes[InputTypes["SIGHASH_TYPE"] = 3] = "SIGHASH_TYPE";
+    InputTypes[InputTypes["REDEEM_SCRIPT"] = 4] = "REDEEM_SCRIPT";
+    InputTypes[InputTypes["WITNESS_SCRIPT"] = 5] = "WITNESS_SCRIPT";
+    InputTypes[InputTypes["BIP32_DERIVATION"] = 6] = "BIP32_DERIVATION";
+    InputTypes[InputTypes["FINAL_SCRIPTSIG"] = 7] = "FINAL_SCRIPTSIG";
+    InputTypes[InputTypes["FINAL_SCRIPTWITNESS"] = 8] = "FINAL_SCRIPTWITNESS";
+    InputTypes[InputTypes["POR_COMMITMENT"] = 9] = "POR_COMMITMENT";
+    InputTypes[InputTypes["TAP_KEY_SIG"] = 19] = "TAP_KEY_SIG";
+    InputTypes[InputTypes["TAP_SCRIPT_SIG"] = 20] = "TAP_SCRIPT_SIG";
+    InputTypes[InputTypes["TAP_LEAF_SCRIPT"] = 21] = "TAP_LEAF_SCRIPT";
+    InputTypes[InputTypes["TAP_BIP32_DERIVATION"] = 22] = "TAP_BIP32_DERIVATION";
+    InputTypes[InputTypes["TAP_INTERNAL_KEY"] = 23] = "TAP_INTERNAL_KEY";
+    InputTypes[InputTypes["TAP_MERKLE_ROOT"] = 24] = "TAP_MERKLE_ROOT";
+    InputTypes[InputTypes["OPCAT_UTXO"] = 25] = "OPCAT_UTXO";
+})(InputTypes = exports.InputTypes || (exports.InputTypes = {}));
+exports.INPUT_TYPE_NAMES = [
+    'nonWitnessUtxo',
+    'witnessUtxo',
+    'partialSig',
+    'sighashType',
+    'redeemScript',
+    'witnessScript',
+    'bip32Derivation',
+    'finalScriptSig',
+    'finalScriptWitness',
+    'porCommitment',
+    'tapKeySig',
+    'tapScriptSig',
+    'tapLeafScript',
+    'tapBip32Derivation',
+    'tapInternalKey',
+    'tapMerkleRoot',
+    'opcatUtxo',
+];
+var OutputTypes;
+(function (OutputTypes) {
+    OutputTypes[OutputTypes["REDEEM_SCRIPT"] = 0] = "REDEEM_SCRIPT";
+    OutputTypes[OutputTypes["WITNESS_SCRIPT"] = 1] = "WITNESS_SCRIPT";
+    OutputTypes[OutputTypes["BIP32_DERIVATION"] = 2] = "BIP32_DERIVATION";
+    OutputTypes[OutputTypes["TAP_INTERNAL_KEY"] = 5] = "TAP_INTERNAL_KEY";
+    OutputTypes[OutputTypes["TAP_TREE"] = 6] = "TAP_TREE";
+    OutputTypes[OutputTypes["TAP_BIP32_DERIVATION"] = 7] = "TAP_BIP32_DERIVATION";
+})(OutputTypes = exports.OutputTypes || (exports.OutputTypes = {}));
+exports.OUTPUT_TYPE_NAMES = [
+    'redeemScript',
+    'witnessScript',
+    'bip32Derivation',
+    'tapInternalKey',
+    'tapTree',
+    'tapBip32Derivation',
+];

package/src/cjs/lib/utils.js

@@ -0,0 +1,141 @@
+"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 converter = __importStar(require("./converter/index.js"));
+const tools = __importStar(require("uint8array-tools"));
+function checkForInput(inputs, inputIndex) {
+    const input = inputs[inputIndex];
+    if (input === undefined)
+        throw new Error(`No input #${inputIndex}`);
+    return input;
+}
+exports.checkForInput = checkForInput;
+function checkForOutput(outputs, outputIndex) {
+    const output = outputs[outputIndex];
+    if (output === undefined)
+        throw new Error(`No output #${outputIndex}`);
+    return output;
+}
+exports.checkForOutput = checkForOutput;
+function checkHasKey(checkKeyVal, keyVals, enumLength) {
+    if (checkKeyVal.key[0] < enumLength) {
+        throw new Error(`Use the method for your specific key instead of addUnknownKeyVal*`);
+    }
+    if (keyVals &&
+        keyVals.filter(kv => tools.compare(kv.key, checkKeyVal.key) === 0)
+            .length !== 0) {
+        throw new Error(`Duplicate Key: ${tools.toHex(checkKeyVal.key)}`);
+    }
+}
+exports.checkHasKey = checkHasKey;
+function getEnumLength(myenum) {
+    let count = 0;
+    Object.keys(myenum).forEach(val => {
+        if (Number(isNaN(Number(val)))) {
+            count++;
+        }
+    });
+    return count;
+}
+exports.getEnumLength = getEnumLength;
+function inputCheckUncleanFinalized(inputIndex, input) {
+    let result = false;
+    if (input.nonWitnessUtxo || input.witnessUtxo || input.opcatUtxo) {
+        const needScriptSig = !!input.redeemScript;
+        const needWitnessScript = !!input.witnessScript;
+        const scriptSigOK = !needScriptSig || !!input.finalScriptSig;
+        const witnessScriptOK = !needWitnessScript || !!input.finalScriptWitness;
+        const hasOneFinal = !!input.finalScriptSig || !!input.finalScriptWitness;
+        result = scriptSigOK && witnessScriptOK && hasOneFinal;
+    }
+    if (result === false) {
+        throw new Error(`Input #${inputIndex} has too much or too little data to clean`);
+    }
+}
+exports.inputCheckUncleanFinalized = inputCheckUncleanFinalized;
+function throwForUpdateMaker(typeName, name, expected, data) {
+    throw new Error(`Data for ${typeName} key ${name} is incorrect: Expected ` +
+        `${expected} and got ${JSON.stringify(data)}`);
+}
+function updateMaker(typeName) {
+    return (updateData, mainData) => {
+        // @ts-ignore
+        for (const name of Object.keys(updateData)) {
+            // @ts-ignore
+            const data = updateData[name];
+            // @ts-ignore
+            const { canAdd, canAddToArray, check, expected } = 
+            // @ts-ignore
+            converter[typeName + 's'][name] || {};
+            const isArray = !!canAddToArray;
+            // If unknown data. ignore and do not add
+            if (check) {
+                if (isArray) {
+                    if (!Array.isArray(data) ||
+                        // @ts-ignore
+                        (mainData[name] && !Array.isArray(mainData[name]))) {
+                        throw new Error(`Key type ${name} must be an array`);
+                    }
+                    if (!data.every(check)) {
+                        throwForUpdateMaker(typeName, name, expected, data);
+                    }
+                    // @ts-ignore
+                    const arr = mainData[name] || [];
+                    const dupeCheckSet = new Set();
+                    if (!data.every(v => canAddToArray(arr, v, dupeCheckSet))) {
+                        throw new Error('Can not add duplicate data to array');
+                    }
+                    // @ts-ignore
+                    mainData[name] = arr.concat(data);
+                }
+                else {
+                    if (!check(data)) {
+                        throwForUpdateMaker(typeName, name, expected, data);
+                    }
+                    if (!canAdd(mainData, data)) {
+                        throw new Error(`Can not add duplicate data to ${typeName}`);
+                    }
+                    // @ts-ignore
+                    mainData[name] = data;
+                }
+            }
+        }
+    };
+}
+exports.updateGlobal = updateMaker('global');
+exports.updateInput = updateMaker('input');
+exports.updateOutput = updateMaker('output');
+function addInputAttributes(inputs, data) {
+    const index = inputs.length - 1;
+    const input = checkForInput(inputs, index);
+    exports.updateInput(data, input);
+}
+exports.addInputAttributes = addInputAttributes;
+function addOutputAttributes(outputs, data) {
+    const index = outputs.length - 1;
+    const output = checkForOutput(outputs, index);
+    exports.updateOutput(data, output);
+}
+exports.addOutputAttributes = addOutputAttributes;
+function defaultVersionSetter(version, txBuf) {
+    if (!(txBuf instanceof Uint8Array) || txBuf.length < 4) {
+        throw new Error('Set Version: Invalid Transaction');
+    }
+    tools.writeUInt32(txBuf, 0, version, 'LE');
+    return txBuf;
+}
+exports.defaultVersionSetter = defaultVersionSetter;
+function defaultLocktimeSetter(locktime, txBuf) {
+    if (!(txBuf instanceof Uint8Array) || txBuf.length < 4) {
+        throw new Error('Set Locktime: Invalid Transaction');
+    }
+    tools.writeUInt32(txBuf, txBuf.length - 4, locktime, 'LE');
+    return txBuf;
+}
+exports.defaultLocktimeSetter = defaultLocktimeSetter;

package/src/esm/lib/combiner/index.d.ts

@@ -0,0 +1,2 @@
+import { PsbtAttributes } from '../parser/index.js';
+export declare function combine(psbts: PsbtAttributes[]): PsbtAttributes;

package/src/esm/lib/combiner/index.js

@@ -0,0 +1,57 @@
+import { psbtFromKeyVals, psbtToKeyVals, } from '../parser/index.js';
+import * as tools from 'uint8array-tools';
+export function combine(psbts) {
+    const self = psbts[0];
+    const selfKeyVals = psbtToKeyVals(self);
+    const others = psbts.slice(1);
+    if (others.length === 0)
+        throw new Error('Combine: Nothing to combine');
+    const selfTx = getTx(self);
+    if (selfTx === undefined) {
+        throw new Error('Combine: Self missing transaction');
+    }
+    const selfGlobalSet = getKeySet(selfKeyVals.globalKeyVals);
+    const selfInputSets = selfKeyVals.inputKeyVals.map(getKeySet);
+    const selfOutputSets = selfKeyVals.outputKeyVals.map(getKeySet);
+    for (const other of others) {
+        const otherTx = getTx(other);
+        if (otherTx === undefined ||
+            tools.compare(otherTx.toBuffer(), selfTx.toBuffer()) !== 0) {
+            throw new Error('Combine: One of the Psbts does not have the same transaction.');
+        }
+        const otherKeyVals = psbtToKeyVals(other);
+        const otherGlobalSet = getKeySet(otherKeyVals.globalKeyVals);
+        otherGlobalSet.forEach(keyPusher(selfGlobalSet, selfKeyVals.globalKeyVals, otherKeyVals.globalKeyVals));
+        const otherInputSets = otherKeyVals.inputKeyVals.map(getKeySet);
+        otherInputSets.forEach((inputSet, idx) => inputSet.forEach(keyPusher(selfInputSets[idx], selfKeyVals.inputKeyVals[idx], otherKeyVals.inputKeyVals[idx])));
+        const otherOutputSets = otherKeyVals.outputKeyVals.map(getKeySet);
+        otherOutputSets.forEach((outputSet, idx) => outputSet.forEach(keyPusher(selfOutputSets[idx], selfKeyVals.outputKeyVals[idx], otherKeyVals.outputKeyVals[idx])));
+    }
+    return psbtFromKeyVals(selfTx, {
+        globalMapKeyVals: selfKeyVals.globalKeyVals,
+        inputKeyVals: selfKeyVals.inputKeyVals,
+        outputKeyVals: selfKeyVals.outputKeyVals,
+    });
+}
+function keyPusher(selfSet, selfKeyVals, otherKeyVals) {
+    return (key) => {
+        if (selfSet.has(key))
+            return;
+        const newKv = otherKeyVals.filter(kv => tools.toHex(kv.key) === key)[0];
+        selfKeyVals.push(newKv);
+        selfSet.add(key);
+    };
+}
+function getTx(psbt) {
+    return psbt.globalMap.unsignedTx;
+}
+function getKeySet(keyVals) {
+    const set = new Set();
+    keyVals.forEach(keyVal => {
+        const hex = tools.toHex(keyVal.key);
+        if (set.has(hex))
+            throw new Error('Combine: KeyValue Map keys should be unique');
+        set.add(hex);
+    });
+    return set;
+}

package/src/esm/lib/converter/global/globalXpub.d.ts

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

package/src/esm/lib/converter/global/globalXpub.js

@@ -0,0 +1,70 @@
+import { GlobalTypes } from '../../typeFields.js';
+import * as tools from 'uint8array-tools';
+const range = (n) => [...Array(n).keys()];
+export function decode(keyVal) {
+    if (keyVal.key[0] !== GlobalTypes.GLOBAL_XPUB) {
+        throw new Error('Decode Error: could not decode globalXpub with key 0x' +
+            tools.toHex(keyVal.key));
+    }
+    if (keyVal.key.length !== 79 || ![2, 3].includes(keyVal.key[46])) {
+        throw new Error('Decode Error: globalXpub has invalid extended pubkey in key 0x' +
+            tools.toHex(keyVal.key));
+    }
+    if ((keyVal.value.length / 4) % 1 !== 0) {
+        throw new Error('Decode Error: Global GLOBAL_XPUB value length should be multiple of 4');
+    }
+    const extendedPubkey = keyVal.key.slice(1);
+    const data = {
+        masterFingerprint: keyVal.value.slice(0, 4),
+        extendedPubkey,
+        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;
+}
+export function encode(data) {
+    const head = new Uint8Array([GlobalTypes.GLOBAL_XPUB]);
+    const key = tools.concat([head, data.extendedPubkey]);
+    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,
+    };
+}
+export const expected = '{ masterFingerprint: Uint8Array; extendedPubkey: Uint8Array; path: string; }';
+export function check(data) {
+    const epk = data.extendedPubkey;
+    const mfp = data.masterFingerprint;
+    const p = data.path;
+    return (epk instanceof Uint8Array &&
+        epk.length === 78 &&
+        [2, 3].indexOf(epk[45]) > -1 &&
+        mfp instanceof Uint8Array &&
+        mfp.length === 4 &&
+        typeof p === 'string' &&
+        !!p.match(/^m(\/\d+'?)*$/));
+}
+export function canAddToArray(array, item, dupeSet) {
+    const dupeString = tools.toHex(item.extendedPubkey);
+    if (dupeSet.has(dupeString))
+        return false;
+    dupeSet.add(dupeString);
+    return (array.filter(v => tools.compare(v.extendedPubkey, item.extendedPubkey))
+        .length === 0);
+}

package/src/esm/lib/converter/global/unsignedTx.d.ts

@@ -0,0 +1,2 @@
+import { KeyValue, Transaction } from '../../interfaces';
+export declare function encode(data: Transaction): KeyValue;

package/src/esm/lib/converter/global/unsignedTx.js

@@ -0,0 +1,7 @@
+import { GlobalTypes } from '../../typeFields.js';
+export function encode(data) {
+    return {
+        key: new Uint8Array([GlobalTypes.UNSIGNED_TX]),
+        value: data.toBuffer(),
+    };
+}

package/src/esm/lib/converter/index.d.ts

@@ -0,0 +1,110 @@
+import * as globalXpub from './global/globalXpub.js';
+import * as unsignedTx from './global/unsignedTx.js';
+import * as finalScriptSig from './input/finalScriptSig.js';
+import * as finalScriptWitness from './input/finalScriptWitness.js';
+import * as nonWitnessUtxo from './input/nonWitnessUtxo.js';
+import * as partialSig from './input/partialSig.js';
+import * as porCommitment from './input/porCommitment.js';
+import * as sighashType from './input/sighashType.js';
+import * as tapKeySig from './input/tapKeySig.js';
+import * as tapLeafScript from './input/tapLeafScript.js';
+import * as tapMerkleRoot from './input/tapMerkleRoot.js';
+import * as tapScriptSig from './input/tapScriptSig.js';
+import * as witnessUtxo from './input/witnessUtxo.js';
+import * as opcatUtxo from './input/opcatUtxo.js';
+import * as tapTree from './output/tapTree.js';
+declare const globals: {
+    unsignedTx: typeof unsignedTx;
+    globalXpub: typeof globalXpub;
+    checkPubkey: (keyVal: import("../interfaces.js").KeyValue) => Uint8Array | undefined;
+};
+declare const inputs: {
+    nonWitnessUtxo: typeof nonWitnessUtxo;
+    partialSig: typeof partialSig;
+    sighashType: typeof sighashType;
+    finalScriptSig: typeof finalScriptSig;
+    finalScriptWitness: typeof finalScriptWitness;
+    porCommitment: typeof porCommitment;
+    witnessUtxo: typeof witnessUtxo;
+    opcatUtxo: typeof opcatUtxo;
+    bip32Derivation: {
+        decode: (keyVal: import("../interfaces.js").KeyValue) => import("../interfaces.js").Bip32Derivation;
+        encode: (data: import("../interfaces.js").Bip32Derivation) => import("../interfaces.js").KeyValue;
+        check: (data: any) => data is import("../interfaces.js").Bip32Derivation;
+        expected: string;
+        canAddToArray: (array: import("../interfaces.js").Bip32Derivation[], item: import("../interfaces.js").Bip32Derivation, dupeSet: Set<string>) => boolean;
+    };
+    redeemScript: {
+        decode: (keyVal: import("../interfaces.js").KeyValue) => Uint8Array;
+        encode: (data: Uint8Array) => import("../interfaces.js").KeyValue;
+        check: (data: any) => data is Uint8Array;
+        expected: string;
+        canAdd: (currentData: any, newData: any) => boolean;
+    };
+    witnessScript: {
+        decode: (keyVal: import("../interfaces.js").KeyValue) => Uint8Array;
+        encode: (data: Uint8Array) => import("../interfaces.js").KeyValue;
+        check: (data: any) => data is Uint8Array;
+        expected: string;
+        canAdd: (currentData: any, newData: any) => boolean;
+    };
+    checkPubkey: (keyVal: import("../interfaces.js").KeyValue) => Uint8Array | undefined;
+    tapKeySig: typeof tapKeySig;
+    tapScriptSig: typeof tapScriptSig;
+    tapLeafScript: typeof tapLeafScript;
+    tapBip32Derivation: {
+        decode: (keyVal: import("../interfaces.js").KeyValue) => import("../interfaces.js").TapBip32Derivation;
+        encode: (data: import("../interfaces.js").TapBip32Derivation) => import("../interfaces.js").KeyValue;
+        check: (data: any) => data is import("../interfaces.js").TapBip32Derivation;
+        expected: string;
+        canAddToArray: (array: import("../interfaces.js").TapBip32Derivation[], item: import("../interfaces.js").TapBip32Derivation, dupeSet: Set<string>) => boolean;
+    };
+    tapInternalKey: {
+        decode: (keyVal: import("../interfaces.js").KeyValue) => Uint8Array;
+        encode: (data: Uint8Array) => import("../interfaces.js").KeyValue;
+        check: (data: any) => data is Uint8Array;
+        expected: string;
+        canAdd: (currentData: any, newData: any) => boolean;
+    };
+    tapMerkleRoot: typeof tapMerkleRoot;
+};
+declare const outputs: {
+    bip32Derivation: {
+        decode: (keyVal: import("../interfaces.js").KeyValue) => import("../interfaces.js").Bip32Derivation;
+        encode: (data: import("../interfaces.js").Bip32Derivation) => import("../interfaces.js").KeyValue;
+        check: (data: any) => data is import("../interfaces.js").Bip32Derivation;
+        expected: string;
+        canAddToArray: (array: import("../interfaces.js").Bip32Derivation[], item: import("../interfaces.js").Bip32Derivation, dupeSet: Set<string>) => boolean;
+    };
+    redeemScript: {
+        decode: (keyVal: import("../interfaces.js").KeyValue) => Uint8Array;
+        encode: (data: Uint8Array) => import("../interfaces.js").KeyValue;
+        check: (data: any) => data is Uint8Array;
+        expected: string;
+        canAdd: (currentData: any, newData: any) => boolean;
+    };
+    witnessScript: {
+        decode: (keyVal: import("../interfaces.js").KeyValue) => Uint8Array;
+        encode: (data: Uint8Array) => import("../interfaces.js").KeyValue;
+        check: (data: any) => data is Uint8Array;
+        expected: string;
+        canAdd: (currentData: any, newData: any) => boolean;
+    };
+    checkPubkey: (keyVal: import("../interfaces.js").KeyValue) => Uint8Array | undefined;
+    tapBip32Derivation: {
+        decode: (keyVal: import("../interfaces.js").KeyValue) => import("../interfaces.js").TapBip32Derivation;
+        encode: (data: import("../interfaces.js").TapBip32Derivation) => import("../interfaces.js").KeyValue;
+        check: (data: any) => data is import("../interfaces.js").TapBip32Derivation;
+        expected: string;
+        canAddToArray: (array: import("../interfaces.js").TapBip32Derivation[], item: import("../interfaces.js").TapBip32Derivation, dupeSet: Set<string>) => boolean;
+    };
+    tapTree: typeof tapTree;
+    tapInternalKey: {
+        decode: (keyVal: import("../interfaces.js").KeyValue) => Uint8Array;
+        encode: (data: Uint8Array) => import("../interfaces.js").KeyValue;
+        check: (data: any) => data is Uint8Array;
+        expected: string;
+        canAdd: (currentData: any, newData: any) => boolean;
+    };
+};
+export { globals, inputs, outputs };

package/src/esm/lib/converter/index.js

@@ -0,0 +1,61 @@
+import { InputTypes, OutputTypes } from '../typeFields.js';
+import * as globalXpub from './global/globalXpub.js';
+import * as unsignedTx from './global/unsignedTx.js';
+import * as finalScriptSig from './input/finalScriptSig.js';
+import * as finalScriptWitness from './input/finalScriptWitness.js';
+import * as nonWitnessUtxo from './input/nonWitnessUtxo.js';
+import * as partialSig from './input/partialSig.js';
+import * as porCommitment from './input/porCommitment.js';
+import * as sighashType from './input/sighashType.js';
+import * as tapKeySig from './input/tapKeySig.js';
+import * as tapLeafScript from './input/tapLeafScript.js';
+import * as tapMerkleRoot from './input/tapMerkleRoot.js';
+import * as tapScriptSig from './input/tapScriptSig.js';
+import * as witnessUtxo from './input/witnessUtxo.js';
+import * as opcatUtxo from './input/opcatUtxo.js';
+import * as tapTree from './output/tapTree.js';
+import * as bip32Derivation from './shared/bip32Derivation.js';
+import * as checkPubkey from './shared/checkPubkey.js';
+import * as redeemScript from './shared/redeemScript.js';
+import * as tapBip32Derivation from './shared/tapBip32Derivation.js';
+import * as tapInternalKey from './shared/tapInternalKey.js';
+import * as witnessScript from './shared/witnessScript.js';
+const globals = {
+    unsignedTx,
+    globalXpub,
+    // pass an Array of key bytes that require pubkey beside the key
+    checkPubkey: checkPubkey.makeChecker([]),
+};
+const inputs = {
+    nonWitnessUtxo,
+    partialSig,
+    sighashType,
+    finalScriptSig,
+    finalScriptWitness,
+    porCommitment,
+    witnessUtxo,
+    opcatUtxo,
+    bip32Derivation: bip32Derivation.makeConverter(InputTypes.BIP32_DERIVATION),
+    redeemScript: redeemScript.makeConverter(InputTypes.REDEEM_SCRIPT),
+    witnessScript: witnessScript.makeConverter(InputTypes.WITNESS_SCRIPT),
+    checkPubkey: checkPubkey.makeChecker([
+        InputTypes.PARTIAL_SIG,
+        InputTypes.BIP32_DERIVATION,
+    ]),
+    tapKeySig,
+    tapScriptSig,
+    tapLeafScript,
+    tapBip32Derivation: tapBip32Derivation.makeConverter(InputTypes.TAP_BIP32_DERIVATION),
+    tapInternalKey: tapInternalKey.makeConverter(InputTypes.TAP_INTERNAL_KEY),
+    tapMerkleRoot,
+};
+const outputs = {
+    bip32Derivation: bip32Derivation.makeConverter(OutputTypes.BIP32_DERIVATION),
+    redeemScript: redeemScript.makeConverter(OutputTypes.REDEEM_SCRIPT),
+    witnessScript: witnessScript.makeConverter(OutputTypes.WITNESS_SCRIPT),
+    checkPubkey: checkPubkey.makeChecker([OutputTypes.BIP32_DERIVATION]),
+    tapBip32Derivation: tapBip32Derivation.makeConverter(OutputTypes.TAP_BIP32_DERIVATION),
+    tapTree,
+    tapInternalKey: tapInternalKey.makeConverter(OutputTypes.TAP_INTERNAL_KEY),
+};
+export { globals, inputs, outputs };

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

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

package/src/esm/lib/converter/input/finalScriptSig.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.FINAL_SCRIPTSIG) {
+        throw new Error('Decode Error: could not decode finalScriptSig with key 0x' +
+            tools.toHex(keyVal.key));
+    }
+    return keyVal.value;
+}
+export function encode(data) {
+    const key = new Uint8Array([InputTypes.FINAL_SCRIPTSIG]);
+    return {
+        key,
+        value: data,
+    };
+}
+export const expected = 'Uint8Array';
+export function check(data) {
+    return data instanceof Uint8Array;
+}
+export function canAdd(currentData, newData) {
+    return !!currentData && !!newData && currentData.finalScriptSig === undefined;
+}

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

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

package/src/esm/lib/converter/input/finalScriptWitness.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.FINAL_SCRIPTWITNESS) {
+        throw new Error('Decode Error: could not decode finalScriptWitness with key 0x' +
+            tools.toHex(keyVal.key));
+    }
+    return keyVal.value;
+}
+export function encode(data) {
+    const key = new Uint8Array([InputTypes.FINAL_SCRIPTWITNESS]);
+    return {
+        key,
+        value: data,
+    };
+}
+export const expected = 'Uint8Array';
+export function check(data) {
+    return data instanceof Uint8Array;
+}
+export function canAdd(currentData, newData) {
+    return (!!currentData && !!newData && currentData.finalScriptWitness === undefined);
+}

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

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

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

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

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

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