@opcat-labs/bip174 1.0.0

package/src/cjs/lib/converter/shared/tapInternalKey.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 || keyVal.key.length !== 1) {
+            throw new Error('Decode Error: could not decode tapInternalKey with key 0x' +
+                tools.toHex(keyVal.key));
+        }
+        if (keyVal.value.length !== 32) {
+            throw new Error('Decode Error: tapInternalKey not a 32-byte x-only pubkey');
+        }
+        return keyVal.value;
+    }
+    function encode(value) {
+        const key = Uint8Array.from([TYPE_BYTE]);
+        return { key, value };
+    }
+    const expected = 'Uint8Array';
+    function check(data) {
+        return data instanceof Uint8Array && data.length === 32;
+    }
+    function canAdd(currentData, newData) {
+        return (!!currentData && !!newData && currentData.tapInternalKey === undefined);
+    }
+    return {
+        decode,
+        encode,
+        check,
+        expected,
+        canAdd,
+    };
+}
+exports.makeConverter = makeConverter;

package/src/cjs/lib/converter/shared/witnessScript.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 witnessScript 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.witnessScript === undefined);
+    }
+    return {
+        decode,
+        encode,
+        check,
+        expected,
+        canAdd,
+    };
+}
+exports.makeConverter = makeConverter;

package/src/cjs/lib/converter/tools.js

@@ -0,0 +1,45 @@
+"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"));
+exports.range = (n) => [...Array(n).keys()];
+function reverseBuffer(buffer) {
+    if (buffer.length < 1)
+        return buffer;
+    let j = buffer.length - 1;
+    let tmp = 0;
+    for (let i = 0; i < buffer.length / 2; i++) {
+        tmp = buffer[i];
+        buffer[i] = buffer[j];
+        buffer[j] = tmp;
+        j--;
+    }
+    return buffer;
+}
+exports.reverseBuffer = reverseBuffer;
+function keyValsToBuffer(keyVals) {
+    const buffers = keyVals.map(keyValToBuffer);
+    buffers.push(Uint8Array.from([0]));
+    return tools.concat(buffers);
+}
+exports.keyValsToBuffer = keyValsToBuffer;
+function keyValToBuffer(keyVal) {
+    const keyLen = keyVal.key.length;
+    const valLen = keyVal.value.length;
+    const keyVarIntLen = varuint.encodingLength(keyLen);
+    const valVarIntLen = varuint.encodingLength(valLen);
+    const buffer = new Uint8Array(keyVarIntLen + keyLen + valVarIntLen + valLen);
+    varuint.encode(keyLen, buffer, 0);
+    buffer.set(keyVal.key, keyVarIntLen);
+    varuint.encode(valLen, buffer, keyVarIntLen + keyLen);
+    buffer.set(keyVal.value, keyVarIntLen + keyLen + valVarIntLen);
+    return buffer;
+}
+exports.keyValToBuffer = keyValToBuffer;

package/src/cjs/lib/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/cjs/lib/parser/fromBuffer.js

@@ -0,0 +1,325 @@
+"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 convert = __importStar(require("../converter/index.js"));
+const tools_js_1 = require("../converter/tools.js");
+const varuint = __importStar(require("varuint-bitcoin"));
+const tools = __importStar(require("uint8array-tools"));
+const typeFields_js_1 = require("../typeFields.js");
+function psbtFromBuffer(buffer, txGetter) {
+    let offset = 0;
+    function varSlice() {
+        const { numberValue: keyLen, bytes } = varuint.decode(buffer, offset);
+        offset += bytes;
+        const key = buffer.slice(offset, offset + Number(keyLen));
+        offset += Number(keyLen);
+        return key;
+    }
+    function readUInt32BE() {
+        const num = tools.readUInt32(buffer, offset, 'BE');
+        offset += 4;
+        return num;
+    }
+    function readUInt8() {
+        const num = tools.readUInt8(buffer, offset);
+        offset += 1;
+        return num;
+    }
+    function getKeyValue() {
+        const key = varSlice();
+        const value = varSlice();
+        return {
+            key,
+            value,
+        };
+    }
+    function checkEndOfKeyValPairs() {
+        if (offset >= buffer.length) {
+            throw new Error('Format Error: Unexpected End of PSBT');
+        }
+        const isEnd = tools.readUInt8(buffer, offset) === 0;
+        if (isEnd) {
+            offset++;
+        }
+        return isEnd;
+    }
+    if (readUInt32BE() !== 0x70736274) {
+        throw new Error('Format Error: Invalid Magic Number');
+    }
+    if (readUInt8() !== 0xff) {
+        throw new Error('Format Error: Magic Number must be followed by 0xff separator');
+    }
+    const globalMapKeyVals = [];
+    const globalKeyIndex = {};
+    while (!checkEndOfKeyValPairs()) {
+        const keyVal = getKeyValue();
+        const hexKey = tools.toHex(keyVal.key);
+        if (globalKeyIndex[hexKey]) {
+            throw new Error('Format Error: Keys must be unique for global keymap: key ' + hexKey);
+        }
+        globalKeyIndex[hexKey] = 1;
+        globalMapKeyVals.push(keyVal);
+    }
+    const unsignedTxMaps = globalMapKeyVals.filter(keyVal => keyVal.key[0] === typeFields_js_1.GlobalTypes.UNSIGNED_TX);
+    if (unsignedTxMaps.length !== 1) {
+        throw new Error('Format Error: Only one UNSIGNED_TX allowed');
+    }
+    const unsignedTx = txGetter(unsignedTxMaps[0].value);
+    // Get input and output counts to loop the respective fields
+    const { inputCount, outputCount } = unsignedTx.getInputOutputCounts();
+    const inputKeyVals = [];
+    const outputKeyVals = [];
+    // Get input fields
+    for (const index of tools_js_1.range(inputCount)) {
+        const inputKeyIndex = {};
+        const input = [];
+        while (!checkEndOfKeyValPairs()) {
+            const keyVal = getKeyValue();
+            const hexKey = tools.toHex(keyVal.key);
+            if (inputKeyIndex[hexKey]) {
+                throw new Error('Format Error: Keys must be unique for each input: ' +
+                    'input index ' +
+                    index +
+                    ' key ' +
+                    hexKey);
+            }
+            inputKeyIndex[hexKey] = 1;
+            input.push(keyVal);
+        }
+        inputKeyVals.push(input);
+    }
+    for (const index of tools_js_1.range(outputCount)) {
+        const outputKeyIndex = {};
+        const output = [];
+        while (!checkEndOfKeyValPairs()) {
+            const keyVal = getKeyValue();
+            const hexKey = tools.toHex(keyVal.key);
+            if (outputKeyIndex[hexKey]) {
+                throw new Error('Format Error: Keys must be unique for each output: ' +
+                    'output index ' +
+                    index +
+                    ' key ' +
+                    hexKey);
+            }
+            outputKeyIndex[hexKey] = 1;
+            output.push(keyVal);
+        }
+        outputKeyVals.push(output);
+    }
+    return psbtFromKeyVals(unsignedTx, {
+        globalMapKeyVals,
+        inputKeyVals,
+        outputKeyVals,
+    });
+}
+exports.psbtFromBuffer = psbtFromBuffer;
+function checkKeyBuffer(type, keyBuf, keyNum) {
+    if (tools.compare(keyBuf, Uint8Array.from([keyNum]))) {
+        throw new Error(
+        // `Format Error: Invalid ${type} key: ${keyBuf.toString('hex')}`,
+        `Format Error: Invalid ${type} key: ${tools.toHex(keyBuf)}`);
+    }
+}
+exports.checkKeyBuffer = checkKeyBuffer;
+function psbtFromKeyVals(unsignedTx, { globalMapKeyVals, inputKeyVals, outputKeyVals }) {
+    // That was easy :-)
+    const globalMap = {
+        unsignedTx,
+    };
+    let txCount = 0;
+    for (const keyVal of globalMapKeyVals) {
+        // If a globalMap item needs pubkey, uncomment
+        // const pubkey = convert.globals.checkPubkey(keyVal);
+        switch (keyVal.key[0]) {
+            case typeFields_js_1.GlobalTypes.UNSIGNED_TX:
+                checkKeyBuffer('global', keyVal.key, typeFields_js_1.GlobalTypes.UNSIGNED_TX);
+                if (txCount > 0) {
+                    throw new Error('Format Error: GlobalMap has multiple UNSIGNED_TX');
+                }
+                txCount++;
+                break;
+            case typeFields_js_1.GlobalTypes.GLOBAL_XPUB:
+                if (globalMap.globalXpub === undefined) {
+                    globalMap.globalXpub = [];
+                }
+                globalMap.globalXpub.push(convert.globals.globalXpub.decode(keyVal));
+                break;
+            default:
+                // This will allow inclusion during serialization.
+                if (!globalMap.unknownKeyVals)
+                    globalMap.unknownKeyVals = [];
+                globalMap.unknownKeyVals.push(keyVal);
+        }
+    }
+    // Get input and output counts to loop the respective fields
+    const inputCount = inputKeyVals.length;
+    const outputCount = outputKeyVals.length;
+    const inputs = [];
+    const outputs = [];
+    // Get input fields
+    for (const index of tools_js_1.range(inputCount)) {
+        const input = {};
+        for (const keyVal of inputKeyVals[index]) {
+            convert.inputs.checkPubkey(keyVal);
+            switch (keyVal.key[0]) {
+                case typeFields_js_1.InputTypes.NON_WITNESS_UTXO:
+                    checkKeyBuffer('input', keyVal.key, typeFields_js_1.InputTypes.NON_WITNESS_UTXO);
+                    if (input.nonWitnessUtxo !== undefined) {
+                        throw new Error('Format Error: Input has multiple NON_WITNESS_UTXO');
+                    }
+                    input.nonWitnessUtxo = convert.inputs.nonWitnessUtxo.decode(keyVal);
+                    break;
+                case typeFields_js_1.InputTypes.WITNESS_UTXO:
+                    checkKeyBuffer('input', keyVal.key, typeFields_js_1.InputTypes.WITNESS_UTXO);
+                    if (input.witnessUtxo !== undefined) {
+                        throw new Error('Format Error: Input has multiple WITNESS_UTXO');
+                    }
+                    input.witnessUtxo = convert.inputs.witnessUtxo.decode(keyVal);
+                    break;
+                case typeFields_js_1.InputTypes.PARTIAL_SIG:
+                    if (input.partialSig === undefined) {
+                        input.partialSig = [];
+                    }
+                    input.partialSig.push(convert.inputs.partialSig.decode(keyVal));
+                    break;
+                case typeFields_js_1.InputTypes.SIGHASH_TYPE:
+                    checkKeyBuffer('input', keyVal.key, typeFields_js_1.InputTypes.SIGHASH_TYPE);
+                    if (input.sighashType !== undefined) {
+                        throw new Error('Format Error: Input has multiple SIGHASH_TYPE');
+                    }
+                    input.sighashType = convert.inputs.sighashType.decode(keyVal);
+                    break;
+                case typeFields_js_1.InputTypes.REDEEM_SCRIPT:
+                    checkKeyBuffer('input', keyVal.key, typeFields_js_1.InputTypes.REDEEM_SCRIPT);
+                    if (input.redeemScript !== undefined) {
+                        throw new Error('Format Error: Input has multiple REDEEM_SCRIPT');
+                    }
+                    input.redeemScript = convert.inputs.redeemScript.decode(keyVal);
+                    break;
+                case typeFields_js_1.InputTypes.WITNESS_SCRIPT:
+                    checkKeyBuffer('input', keyVal.key, typeFields_js_1.InputTypes.WITNESS_SCRIPT);
+                    if (input.witnessScript !== undefined) {
+                        throw new Error('Format Error: Input has multiple WITNESS_SCRIPT');
+                    }
+                    input.witnessScript = convert.inputs.witnessScript.decode(keyVal);
+                    break;
+                case typeFields_js_1.InputTypes.BIP32_DERIVATION:
+                    if (input.bip32Derivation === undefined) {
+                        input.bip32Derivation = [];
+                    }
+                    input.bip32Derivation.push(convert.inputs.bip32Derivation.decode(keyVal));
+                    break;
+                case typeFields_js_1.InputTypes.FINAL_SCRIPTSIG:
+                    checkKeyBuffer('input', keyVal.key, typeFields_js_1.InputTypes.FINAL_SCRIPTSIG);
+                    input.finalScriptSig = convert.inputs.finalScriptSig.decode(keyVal);
+                    break;
+                case typeFields_js_1.InputTypes.FINAL_SCRIPTWITNESS:
+                    checkKeyBuffer('input', keyVal.key, typeFields_js_1.InputTypes.FINAL_SCRIPTWITNESS);
+                    input.finalScriptWitness = convert.inputs.finalScriptWitness.decode(keyVal);
+                    break;
+                case typeFields_js_1.InputTypes.POR_COMMITMENT:
+                    checkKeyBuffer('input', keyVal.key, typeFields_js_1.InputTypes.POR_COMMITMENT);
+                    input.porCommitment = convert.inputs.porCommitment.decode(keyVal);
+                    break;
+                case typeFields_js_1.InputTypes.TAP_KEY_SIG:
+                    checkKeyBuffer('input', keyVal.key, typeFields_js_1.InputTypes.TAP_KEY_SIG);
+                    input.tapKeySig = convert.inputs.tapKeySig.decode(keyVal);
+                    break;
+                case typeFields_js_1.InputTypes.TAP_SCRIPT_SIG:
+                    if (input.tapScriptSig === undefined) {
+                        input.tapScriptSig = [];
+                    }
+                    input.tapScriptSig.push(convert.inputs.tapScriptSig.decode(keyVal));
+                    break;
+                case typeFields_js_1.InputTypes.TAP_LEAF_SCRIPT:
+                    if (input.tapLeafScript === undefined) {
+                        input.tapLeafScript = [];
+                    }
+                    input.tapLeafScript.push(convert.inputs.tapLeafScript.decode(keyVal));
+                    break;
+                case typeFields_js_1.InputTypes.TAP_BIP32_DERIVATION:
+                    if (input.tapBip32Derivation === undefined) {
+                        input.tapBip32Derivation = [];
+                    }
+                    input.tapBip32Derivation.push(convert.inputs.tapBip32Derivation.decode(keyVal));
+                    break;
+                case typeFields_js_1.InputTypes.TAP_INTERNAL_KEY:
+                    checkKeyBuffer('input', keyVal.key, typeFields_js_1.InputTypes.TAP_INTERNAL_KEY);
+                    input.tapInternalKey = convert.inputs.tapInternalKey.decode(keyVal);
+                    break;
+                case typeFields_js_1.InputTypes.TAP_MERKLE_ROOT:
+                    checkKeyBuffer('input', keyVal.key, typeFields_js_1.InputTypes.TAP_MERKLE_ROOT);
+                    input.tapMerkleRoot = convert.inputs.tapMerkleRoot.decode(keyVal);
+                    break;
+                case typeFields_js_1.InputTypes.OPCAT_UTXO:
+                    checkKeyBuffer('input', keyVal.key, typeFields_js_1.InputTypes.OPCAT_UTXO);
+                    if (input.opcatUtxo !== undefined) {
+                        throw new Error('Format Error: Input has multiple OPCAT_UTXO');
+                    }
+                    input.opcatUtxo = convert.inputs.opcatUtxo.decode(keyVal);
+                    break;
+                default:
+                    // This will allow inclusion during serialization.
+                    if (!input.unknownKeyVals)
+                        input.unknownKeyVals = [];
+                    input.unknownKeyVals.push(keyVal);
+            }
+        }
+        inputs.push(input);
+    }
+    for (const index of tools_js_1.range(outputCount)) {
+        const output = {};
+        for (const keyVal of outputKeyVals[index]) {
+            convert.outputs.checkPubkey(keyVal);
+            switch (keyVal.key[0]) {
+                case typeFields_js_1.OutputTypes.REDEEM_SCRIPT:
+                    checkKeyBuffer('output', keyVal.key, typeFields_js_1.OutputTypes.REDEEM_SCRIPT);
+                    if (output.redeemScript !== undefined) {
+                        throw new Error('Format Error: Output has multiple REDEEM_SCRIPT');
+                    }
+                    output.redeemScript = convert.outputs.redeemScript.decode(keyVal);
+                    break;
+                case typeFields_js_1.OutputTypes.WITNESS_SCRIPT:
+                    checkKeyBuffer('output', keyVal.key, typeFields_js_1.OutputTypes.WITNESS_SCRIPT);
+                    if (output.witnessScript !== undefined) {
+                        throw new Error('Format Error: Output has multiple WITNESS_SCRIPT');
+                    }
+                    output.witnessScript = convert.outputs.witnessScript.decode(keyVal);
+                    break;
+                case typeFields_js_1.OutputTypes.BIP32_DERIVATION:
+                    if (output.bip32Derivation === undefined) {
+                        output.bip32Derivation = [];
+                    }
+                    output.bip32Derivation.push(convert.outputs.bip32Derivation.decode(keyVal));
+                    break;
+                case typeFields_js_1.OutputTypes.TAP_INTERNAL_KEY:
+                    checkKeyBuffer('output', keyVal.key, typeFields_js_1.OutputTypes.TAP_INTERNAL_KEY);
+                    output.tapInternalKey = convert.outputs.tapInternalKey.decode(keyVal);
+                    break;
+                case typeFields_js_1.OutputTypes.TAP_TREE:
+                    checkKeyBuffer('output', keyVal.key, typeFields_js_1.OutputTypes.TAP_TREE);
+                    output.tapTree = convert.outputs.tapTree.decode(keyVal);
+                    break;
+                case typeFields_js_1.OutputTypes.TAP_BIP32_DERIVATION:
+                    if (output.tapBip32Derivation === undefined) {
+                        output.tapBip32Derivation = [];
+                    }
+                    output.tapBip32Derivation.push(convert.outputs.tapBip32Derivation.decode(keyVal));
+                    break;
+                default:
+                    if (!output.unknownKeyVals)
+                        output.unknownKeyVals = [];
+                    output.unknownKeyVals.push(keyVal);
+            }
+        }
+        outputs.push(output);
+    }
+    return { globalMap, inputs, outputs };
+}
+exports.psbtFromKeyVals = psbtFromKeyVals;

package/src/cjs/lib/parser/index.js

@@ -0,0 +1,7 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./fromBuffer.js"));
+__export(require("./toBuffer.js"));

package/src/cjs/lib/parser/toBuffer.js

@@ -0,0 +1,69 @@
+"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 convert = __importStar(require("../converter/index.js"));
+const tools_js_1 = require("../converter/tools.js");
+const tools = __importStar(require("uint8array-tools"));
+function psbtToBuffer({ globalMap, inputs, outputs, }) {
+    const { globalKeyVals, inputKeyVals, outputKeyVals } = psbtToKeyVals({
+        globalMap,
+        inputs,
+        outputs,
+    });
+    const globalBuffer = tools_js_1.keyValsToBuffer(globalKeyVals);
+    const keyValsOrEmptyToBuffer = (keyVals) => keyVals.length === 0
+        ? [Uint8Array.from([0])]
+        : keyVals.map(tools_js_1.keyValsToBuffer);
+    const inputBuffers = keyValsOrEmptyToBuffer(inputKeyVals);
+    const outputBuffers = keyValsOrEmptyToBuffer(outputKeyVals);
+    const header = new Uint8Array(5);
+    header.set([0x70, 0x73, 0x62, 0x74, 0xff], 0);
+    return tools.concat([header, globalBuffer].concat(inputBuffers, outputBuffers));
+}
+exports.psbtToBuffer = psbtToBuffer;
+const sortKeyVals = (a, b) => {
+    return tools.compare(a.key, b.key);
+};
+function keyValsFromMap(keyValMap, converterFactory) {
+    const keyHexSet = new Set();
+    const keyVals = Object.entries(keyValMap).reduce((result, [key, value]) => {
+        if (key === 'unknownKeyVals')
+            return result;
+        // We are checking for undefined anyways. So ignore TS error
+        // @ts-ignore
+        const converter = converterFactory[key];
+        if (converter === undefined)
+            return result;
+        const encodedKeyVals = (Array.isArray(value) ? value : [value]).map(converter.encode);
+        const keyHexes = encodedKeyVals.map(kv => tools.toHex(kv.key));
+        keyHexes.forEach(hex => {
+            if (keyHexSet.has(hex))
+                throw new Error('Serialize Error: Duplicate key: ' + hex);
+            keyHexSet.add(hex);
+        });
+        return result.concat(encodedKeyVals);
+    }, []);
+    // Get other keyVals that have not yet been gotten
+    const otherKeyVals = keyValMap.unknownKeyVals
+        ? keyValMap.unknownKeyVals.filter((keyVal) => {
+            return !keyHexSet.has(tools.toHex(keyVal.key));
+        })
+        : [];
+    return keyVals.concat(otherKeyVals).sort(sortKeyVals);
+}
+function psbtToKeyVals({ globalMap, inputs, outputs, }) {
+    // First parse the global keyVals
+    // Get any extra keyvals to pass along
+    return {
+        globalKeyVals: keyValsFromMap(globalMap, convert.globals),
+        inputKeyVals: inputs.map(i => keyValsFromMap(i, convert.inputs)),
+        outputKeyVals: outputs.map(o => keyValsFromMap(o, convert.outputs)),
+    };
+}
+exports.psbtToKeyVals = psbtToKeyVals;

package/src/cjs/lib/psbt.js

@@ -0,0 +1,145 @@
+"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 index_js_1 = require("./combiner/index.js");
+const index_js_2 = require("./parser/index.js");
+const typeFields_js_1 = require("./typeFields.js");
+const utils_js_1 = require("./utils.js");
+const tools = __importStar(require("uint8array-tools"));
+class Psbt {
+    constructor(tx) {
+        this.inputs = [];
+        this.outputs = [];
+        this.globalMap = {
+            unsignedTx: tx,
+        };
+    }
+    static fromBase64(data, txFromBuffer) {
+        const buffer = tools.fromBase64(data);
+        return this.fromBuffer(buffer, txFromBuffer);
+    }
+    static fromHex(data, txFromBuffer) {
+        const buffer = tools.fromHex(data);
+        return this.fromBuffer(buffer, txFromBuffer);
+    }
+    static fromBuffer(buffer, txFromBuffer) {
+        const results = index_js_2.psbtFromBuffer(buffer, txFromBuffer);
+        const psbt = new this(results.globalMap.unsignedTx);
+        Object.assign(psbt, results);
+        return psbt;
+    }
+    toBase64() {
+        const buffer = this.toBuffer();
+        return tools.toBase64(buffer);
+    }
+    toHex() {
+        const buffer = this.toBuffer();
+        return tools.toHex(buffer);
+    }
+    toBuffer() {
+        return index_js_2.psbtToBuffer(this);
+    }
+    updateGlobal(updateData) {
+        utils_js_1.updateGlobal(updateData, this.globalMap);
+        return this;
+    }
+    updateInput(inputIndex, updateData) {
+        const input = utils_js_1.checkForInput(this.inputs, inputIndex);
+        utils_js_1.updateInput(updateData, input);
+        return this;
+    }
+    updateOutput(outputIndex, updateData) {
+        const output = utils_js_1.checkForOutput(this.outputs, outputIndex);
+        utils_js_1.updateOutput(updateData, output);
+        return this;
+    }
+    addUnknownKeyValToGlobal(keyVal) {
+        utils_js_1.checkHasKey(keyVal, this.globalMap.unknownKeyVals, utils_js_1.getEnumLength(typeFields_js_1.GlobalTypes));
+        if (!this.globalMap.unknownKeyVals)
+            this.globalMap.unknownKeyVals = [];
+        this.globalMap.unknownKeyVals.push(keyVal);
+        return this;
+    }
+    addUnknownKeyValToInput(inputIndex, keyVal) {
+        const input = utils_js_1.checkForInput(this.inputs, inputIndex);
+        utils_js_1.checkHasKey(keyVal, input.unknownKeyVals, utils_js_1.getEnumLength(typeFields_js_1.InputTypes));
+        if (!input.unknownKeyVals)
+            input.unknownKeyVals = [];
+        input.unknownKeyVals.push(keyVal);
+        return this;
+    }
+    addUnknownKeyValToOutput(outputIndex, keyVal) {
+        const output = utils_js_1.checkForOutput(this.outputs, outputIndex);
+        utils_js_1.checkHasKey(keyVal, output.unknownKeyVals, utils_js_1.getEnumLength(typeFields_js_1.OutputTypes));
+        if (!output.unknownKeyVals)
+            output.unknownKeyVals = [];
+        output.unknownKeyVals.push(keyVal);
+        return this;
+    }
+    addInput(inputData) {
+        this.globalMap.unsignedTx.addInput(inputData);
+        this.inputs.push({
+            unknownKeyVals: [],
+        });
+        const addKeyVals = inputData.unknownKeyVals || [];
+        const inputIndex = this.inputs.length - 1;
+        if (!Array.isArray(addKeyVals)) {
+            throw new Error('unknownKeyVals must be an Array');
+        }
+        addKeyVals.forEach((keyVal) => this.addUnknownKeyValToInput(inputIndex, keyVal));
+        utils_js_1.addInputAttributes(this.inputs, inputData);
+        return this;
+    }
+    addOutput(outputData) {
+        this.globalMap.unsignedTx.addOutput(outputData);
+        this.outputs.push({
+            unknownKeyVals: [],
+        });
+        const addKeyVals = outputData.unknownKeyVals || [];
+        const outputIndex = this.outputs.length - 1;
+        if (!Array.isArray(addKeyVals)) {
+            throw new Error('unknownKeyVals must be an Array');
+        }
+        addKeyVals.forEach((keyVal) => this.addUnknownKeyValToOutput(outputIndex, keyVal));
+        utils_js_1.addOutputAttributes(this.outputs, outputData);
+        return this;
+    }
+    clearFinalizedInput(inputIndex) {
+        const input = utils_js_1.checkForInput(this.inputs, inputIndex);
+        utils_js_1.inputCheckUncleanFinalized(inputIndex, input);
+        for (const key of Object.keys(input)) {
+            if (![
+                'witnessUtxo',
+                'opcatUtxo',
+                'nonWitnessUtxo',
+                'finalScriptSig',
+                'finalScriptWitness',
+                'unknownKeyVals',
+            ].includes(key)) {
+                // @ts-ignore
+                delete input[key];
+            }
+        }
+        return this;
+    }
+    combine(...those) {
+        // Combine this with those.
+        // Return self for chaining.
+        const result = index_js_1.combine([this].concat(those));
+        Object.assign(this, result);
+        return this;
+    }
+    getTransaction() {
+        return this.globalMap.unsignedTx.toBuffer();
+    }
+}
+exports.Psbt = Psbt;
+var utils_js_2 = require("./utils.js");
+exports.checkForInput = utils_js_2.checkForInput;
+exports.checkForOutput = utils_js_2.checkForOutput;