@opcat-labs/bip174 1.0.0

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

@@ -0,0 +1,45 @@
+import * as varuint from 'varuint-bitcoin';
+import * as tools from 'uint8array-tools';
+import * as bip32Derivation from './bip32Derivation.js';
+const isValidBIP340Key = (pubkey) => pubkey.length === 32;
+export 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,
+    };
+}

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

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

package/src/esm/lib/converter/shared/tapInternalKey.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 || 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,
+    };
+}

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

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

package/src/esm/lib/converter/shared/witnessScript.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 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,
+    };
+}

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

@@ -0,0 +1,5 @@
+import { KeyValue } from '../interfaces';
+export declare const range: (n: number) => number[];
+export declare function reverseBuffer(buffer: Uint8Array): Uint8Array;
+export declare function keyValsToBuffer(keyVals: KeyValue[]): Uint8Array;
+export declare function keyValToBuffer(keyVal: KeyValue): Uint8Array;

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

@@ -0,0 +1,33 @@
+import * as varuint from 'varuint-bitcoin';
+import * as tools from 'uint8array-tools';
+export const range = (n) => [...Array(n).keys()];
+export 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;
+}
+export function keyValsToBuffer(keyVals) {
+    const buffers = keyVals.map(keyValToBuffer);
+    buffers.push(Uint8Array.from([0]));
+    return tools.concat(buffers);
+}
+export 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;
+}

package/src/esm/lib/interfaces.d.ts

@@ -0,0 +1,120 @@
+export declare type TransactionFromBuffer = (buffer: Uint8Array) => Transaction;
+export interface Transaction {
+    getInputOutputCounts(): {
+        inputCount: number;
+        outputCount: number;
+    };
+    addInput(objectArg: any): void;
+    addOutput(objectArg: any): void;
+    toBuffer(): Uint8Array;
+}
+export interface KeyValue {
+    key: Uint8Array;
+    value: Uint8Array;
+}
+export interface PsbtGlobal extends PsbtGlobalUpdate {
+    unsignedTx: Transaction;
+    unknownKeyVals?: KeyValue[];
+}
+export interface PsbtGlobalUpdate {
+    globalXpub?: GlobalXpub[];
+}
+export interface PsbtInput extends PsbtInputUpdate {
+    unknownKeyVals?: KeyValue[];
+}
+export interface PsbtInputUpdate {
+    partialSig?: PartialSig[];
+    nonWitnessUtxo?: NonWitnessUtxo;
+    witnessUtxo?: WitnessUtxo;
+    sighashType?: SighashType;
+    redeemScript?: RedeemScript;
+    witnessScript?: WitnessScript;
+    bip32Derivation?: Bip32Derivation[];
+    finalScriptSig?: FinalScriptSig;
+    finalScriptWitness?: FinalScriptWitness;
+    porCommitment?: PorCommitment;
+    tapKeySig?: TapKeySig;
+    tapScriptSig?: TapScriptSig[];
+    tapLeafScript?: TapLeafScript[];
+    tapBip32Derivation?: TapBip32Derivation[];
+    tapInternalKey?: TapInternalKey;
+    tapMerkleRoot?: TapMerkleRoot;
+    opcatUtxo?: OpcatUtxo;
+}
+export interface PsbtInputExtended extends PsbtInput {
+    [index: string]: any;
+}
+export interface PsbtOutput extends PsbtOutputUpdate {
+    unknownKeyVals?: KeyValue[];
+}
+export interface PsbtOutputUpdate {
+    redeemScript?: RedeemScript;
+    witnessScript?: WitnessScript;
+    bip32Derivation?: Bip32Derivation[];
+    tapBip32Derivation?: TapBip32Derivation[];
+    tapTree?: TapTree;
+    tapInternalKey?: TapInternalKey;
+}
+export interface PsbtOutputExtended extends PsbtOutput {
+    [index: string]: any;
+}
+export interface GlobalXpub {
+    extendedPubkey: Uint8Array;
+    masterFingerprint: Uint8Array;
+    path: string;
+}
+export interface PartialSig {
+    pubkey: Uint8Array;
+    signature: Uint8Array;
+}
+export interface Bip32Derivation {
+    masterFingerprint: Uint8Array;
+    pubkey: Uint8Array;
+    path: string;
+}
+export interface WitnessUtxo {
+    script: Uint8Array;
+    value: bigint;
+}
+export declare type NonWitnessUtxo = Uint8Array;
+export declare type SighashType = number;
+export declare type RedeemScript = Uint8Array;
+export declare type WitnessScript = Uint8Array;
+export declare type FinalScriptSig = Uint8Array;
+export declare type FinalScriptWitness = Uint8Array;
+export declare type PorCommitment = string;
+export declare type TapKeySig = Uint8Array;
+export interface TapScriptSig extends PartialSig {
+    leafHash: Uint8Array;
+}
+interface TapScript {
+    leafVersion: number;
+    script: Uint8Array;
+}
+export declare type ControlBlock = Uint8Array;
+export interface TapLeafScript extends TapScript {
+    controlBlock: ControlBlock;
+}
+export interface TapBip32Derivation extends Bip32Derivation {
+    leafHashes: Uint8Array[];
+}
+export declare type TapInternalKey = Uint8Array;
+export declare type TapMerkleRoot = Uint8Array;
+export interface TapLeaf extends TapScript {
+    depth: number;
+}
+export interface TapTree {
+    leaves: TapLeaf[];
+}
+export declare type TransactionIOCountGetter = (txBuffer: Uint8Array) => {
+    inputCount: number;
+    outputCount: number;
+};
+export declare type TransactionVersionSetter = (version: number, txBuffer: Uint8Array) => Uint8Array;
+export declare type TransactionLocktimeSetter = (locktime: number, txBuffer: Uint8Array) => Uint8Array;
+export interface OpcatUtxo {
+    script: Uint8Array;
+    data: Uint8Array;
+    value: bigint;
+}
+export {};

package/src/esm/lib/parser/fromBuffer.d.ts

@@ -0,0 +1,11 @@
+import { KeyValue, Transaction, TransactionFromBuffer } from '../interfaces';
+import { PsbtAttributes } from './index.js';
+export declare function psbtFromBuffer(buffer: Uint8Array, txGetter: TransactionFromBuffer): PsbtAttributes;
+interface PsbtFromKeyValsArg {
+    globalMapKeyVals: KeyValue[];
+    inputKeyVals: KeyValue[][];
+    outputKeyVals: KeyValue[][];
+}
+export declare function checkKeyBuffer(type: string, keyBuf: Uint8Array, keyNum: number): void;
+export declare function psbtFromKeyVals(unsignedTx: Transaction, { globalMapKeyVals, inputKeyVals, outputKeyVals }: PsbtFromKeyValsArg): PsbtAttributes;
+export {};

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

@@ -0,0 +1,313 @@
+import * as convert from '../converter/index.js';
+import { range } from '../converter/tools.js';
+import * as varuint from 'varuint-bitcoin';
+import * as tools from 'uint8array-tools';
+import { GlobalTypes, InputTypes, OutputTypes } from '../typeFields.js';
+export 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] === 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 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 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,
+    });
+}
+export 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)}`);
+    }
+}
+export 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 GlobalTypes.UNSIGNED_TX:
+                checkKeyBuffer('global', keyVal.key, GlobalTypes.UNSIGNED_TX);
+                if (txCount > 0) {
+                    throw new Error('Format Error: GlobalMap has multiple UNSIGNED_TX');
+                }
+                txCount++;
+                break;
+            case 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 range(inputCount)) {
+        const input = {};
+        for (const keyVal of inputKeyVals[index]) {
+            convert.inputs.checkPubkey(keyVal);
+            switch (keyVal.key[0]) {
+                case InputTypes.NON_WITNESS_UTXO:
+                    checkKeyBuffer('input', keyVal.key, 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 InputTypes.WITNESS_UTXO:
+                    checkKeyBuffer('input', keyVal.key, 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 InputTypes.PARTIAL_SIG:
+                    if (input.partialSig === undefined) {
+                        input.partialSig = [];
+                    }
+                    input.partialSig.push(convert.inputs.partialSig.decode(keyVal));
+                    break;
+                case InputTypes.SIGHASH_TYPE:
+                    checkKeyBuffer('input', keyVal.key, 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 InputTypes.REDEEM_SCRIPT:
+                    checkKeyBuffer('input', keyVal.key, 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 InputTypes.WITNESS_SCRIPT:
+                    checkKeyBuffer('input', keyVal.key, 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 InputTypes.BIP32_DERIVATION:
+                    if (input.bip32Derivation === undefined) {
+                        input.bip32Derivation = [];
+                    }
+                    input.bip32Derivation.push(convert.inputs.bip32Derivation.decode(keyVal));
+                    break;
+                case InputTypes.FINAL_SCRIPTSIG:
+                    checkKeyBuffer('input', keyVal.key, InputTypes.FINAL_SCRIPTSIG);
+                    input.finalScriptSig = convert.inputs.finalScriptSig.decode(keyVal);
+                    break;
+                case InputTypes.FINAL_SCRIPTWITNESS:
+                    checkKeyBuffer('input', keyVal.key, InputTypes.FINAL_SCRIPTWITNESS);
+                    input.finalScriptWitness = convert.inputs.finalScriptWitness.decode(keyVal);
+                    break;
+                case InputTypes.POR_COMMITMENT:
+                    checkKeyBuffer('input', keyVal.key, InputTypes.POR_COMMITMENT);
+                    input.porCommitment = convert.inputs.porCommitment.decode(keyVal);
+                    break;
+                case InputTypes.TAP_KEY_SIG:
+                    checkKeyBuffer('input', keyVal.key, InputTypes.TAP_KEY_SIG);
+                    input.tapKeySig = convert.inputs.tapKeySig.decode(keyVal);
+                    break;
+                case InputTypes.TAP_SCRIPT_SIG:
+                    if (input.tapScriptSig === undefined) {
+                        input.tapScriptSig = [];
+                    }
+                    input.tapScriptSig.push(convert.inputs.tapScriptSig.decode(keyVal));
+                    break;
+                case InputTypes.TAP_LEAF_SCRIPT:
+                    if (input.tapLeafScript === undefined) {
+                        input.tapLeafScript = [];
+                    }
+                    input.tapLeafScript.push(convert.inputs.tapLeafScript.decode(keyVal));
+                    break;
+                case InputTypes.TAP_BIP32_DERIVATION:
+                    if (input.tapBip32Derivation === undefined) {
+                        input.tapBip32Derivation = [];
+                    }
+                    input.tapBip32Derivation.push(convert.inputs.tapBip32Derivation.decode(keyVal));
+                    break;
+                case InputTypes.TAP_INTERNAL_KEY:
+                    checkKeyBuffer('input', keyVal.key, InputTypes.TAP_INTERNAL_KEY);
+                    input.tapInternalKey = convert.inputs.tapInternalKey.decode(keyVal);
+                    break;
+                case InputTypes.TAP_MERKLE_ROOT:
+                    checkKeyBuffer('input', keyVal.key, InputTypes.TAP_MERKLE_ROOT);
+                    input.tapMerkleRoot = convert.inputs.tapMerkleRoot.decode(keyVal);
+                    break;
+                case InputTypes.OPCAT_UTXO:
+                    checkKeyBuffer('input', keyVal.key, 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 range(outputCount)) {
+        const output = {};
+        for (const keyVal of outputKeyVals[index]) {
+            convert.outputs.checkPubkey(keyVal);
+            switch (keyVal.key[0]) {
+                case OutputTypes.REDEEM_SCRIPT:
+                    checkKeyBuffer('output', keyVal.key, 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 OutputTypes.WITNESS_SCRIPT:
+                    checkKeyBuffer('output', keyVal.key, 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 OutputTypes.BIP32_DERIVATION:
+                    if (output.bip32Derivation === undefined) {
+                        output.bip32Derivation = [];
+                    }
+                    output.bip32Derivation.push(convert.outputs.bip32Derivation.decode(keyVal));
+                    break;
+                case OutputTypes.TAP_INTERNAL_KEY:
+                    checkKeyBuffer('output', keyVal.key, OutputTypes.TAP_INTERNAL_KEY);
+                    output.tapInternalKey = convert.outputs.tapInternalKey.decode(keyVal);
+                    break;
+                case OutputTypes.TAP_TREE:
+                    checkKeyBuffer('output', keyVal.key, OutputTypes.TAP_TREE);
+                    output.tapTree = convert.outputs.tapTree.decode(keyVal);
+                    break;
+                case 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 };
+}

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

@@ -0,0 +1,8 @@
+import { PsbtGlobal, PsbtInput, PsbtOutput } from '../interfaces';
+export * from './fromBuffer.js';
+export * from './toBuffer.js';
+export interface PsbtAttributes {
+    globalMap: PsbtGlobal;
+    inputs: PsbtInput[];
+    outputs: PsbtOutput[];
+}

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

@@ -0,0 +1,2 @@
+export * from './fromBuffer.js';
+export * from './toBuffer.js';

package/src/esm/lib/parser/toBuffer.d.ts

@@ -0,0 +1,8 @@
+import { KeyValue } from '../interfaces';
+import { PsbtAttributes } from './index.js';
+export declare function psbtToBuffer({ globalMap, inputs, outputs, }: PsbtAttributes): Uint8Array;
+export declare function psbtToKeyVals({ globalMap, inputs, outputs, }: PsbtAttributes): {
+    globalKeyVals: KeyValue[];
+    inputKeyVals: KeyValue[][];
+    outputKeyVals: KeyValue[][];
+};