@opcat-labs/bip174 1.0.0

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

@@ -0,0 +1,58 @@
+import * as convert from '../converter/index.js';
+import { keyValsToBuffer } from '../converter/tools.js';
+import * as tools from 'uint8array-tools';
+export function psbtToBuffer({ globalMap, inputs, outputs, }) {
+    const { globalKeyVals, inputKeyVals, outputKeyVals } = psbtToKeyVals({
+        globalMap,
+        inputs,
+        outputs,
+    });
+    const globalBuffer = keyValsToBuffer(globalKeyVals);
+    const keyValsOrEmptyToBuffer = (keyVals) => keyVals.length === 0
+        ? [Uint8Array.from([0])]
+        : keyVals.map(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));
+}
+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);
+}
+export 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)),
+    };
+}

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

@@ -0,0 +1,26 @@
+import { KeyValue, PsbtGlobal, PsbtGlobalUpdate, PsbtInput, PsbtInputExtended, PsbtInputUpdate, PsbtOutput, PsbtOutputExtended, PsbtOutputUpdate, Transaction, TransactionFromBuffer } from './interfaces.js';
+export declare class Psbt {
+    static fromBase64<T extends typeof Psbt>(this: T, data: string, txFromBuffer: TransactionFromBuffer): InstanceType<T>;
+    static fromHex<T extends typeof Psbt>(this: T, data: string, txFromBuffer: TransactionFromBuffer): InstanceType<T>;
+    static fromBuffer<T extends typeof Psbt>(this: T, buffer: Uint8Array, txFromBuffer: TransactionFromBuffer): InstanceType<T>;
+    readonly inputs: PsbtInput[];
+    readonly outputs: PsbtOutput[];
+    readonly globalMap: PsbtGlobal;
+    constructor(tx: Transaction);
+    toBase64(): string;
+    toHex(): string;
+    toBuffer(): Uint8Array;
+    updateGlobal(updateData: PsbtGlobalUpdate): this;
+    updateInput(inputIndex: number, updateData: PsbtInputUpdate): this;
+    updateOutput(outputIndex: number, updateData: PsbtOutputUpdate): this;
+    addUnknownKeyValToGlobal(keyVal: KeyValue): this;
+    addUnknownKeyValToInput(inputIndex: number, keyVal: KeyValue): this;
+    addUnknownKeyValToOutput(outputIndex: number, keyVal: KeyValue): this;
+    addInput(inputData: PsbtInputExtended): this;
+    addOutput(outputData: PsbtOutputExtended): this;
+    clearFinalizedInput(inputIndex: number): this;
+    combine(...those: this[]): this;
+    getTransaction(): Uint8Array;
+}
+export { Bip32Derivation, NonWitnessUtxo, ControlBlock, FinalScriptSig, FinalScriptWitness, GlobalXpub, KeyValue, PartialSig, PorCommitment, PsbtGlobal, PsbtGlobalUpdate, PsbtInput, PsbtInputExtended, PsbtInputUpdate, PsbtOutput, PsbtOutputExtended, PsbtOutputUpdate, RedeemScript, SighashType, TapBip32Derivation, TapInternalKey, TapKeySig, TapLeaf, TapLeafScript, TapMerkleRoot, TapScriptSig, TapTree, Transaction, TransactionFromBuffer, TransactionIOCountGetter, TransactionLocktimeSetter, TransactionVersionSetter, WitnessScript, WitnessUtxo, OpcatUtxo, } from './interfaces.js';
+export { checkForInput, checkForOutput } from './utils.js';

package/src/esm/lib/psbt.js

@@ -0,0 +1,133 @@
+import { combine } from './combiner/index.js';
+import { psbtFromBuffer, psbtToBuffer } from './parser/index.js';
+import { GlobalTypes, InputTypes, OutputTypes } from './typeFields.js';
+import { addInputAttributes, addOutputAttributes, checkForInput, checkForOutput, checkHasKey, getEnumLength, inputCheckUncleanFinalized, updateGlobal, updateInput, updateOutput, } from './utils.js';
+import * as tools from 'uint8array-tools';
+export 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 = 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 psbtToBuffer(this);
+    }
+    updateGlobal(updateData) {
+        updateGlobal(updateData, this.globalMap);
+        return this;
+    }
+    updateInput(inputIndex, updateData) {
+        const input = checkForInput(this.inputs, inputIndex);
+        updateInput(updateData, input);
+        return this;
+    }
+    updateOutput(outputIndex, updateData) {
+        const output = checkForOutput(this.outputs, outputIndex);
+        updateOutput(updateData, output);
+        return this;
+    }
+    addUnknownKeyValToGlobal(keyVal) {
+        checkHasKey(keyVal, this.globalMap.unknownKeyVals, getEnumLength(GlobalTypes));
+        if (!this.globalMap.unknownKeyVals)
+            this.globalMap.unknownKeyVals = [];
+        this.globalMap.unknownKeyVals.push(keyVal);
+        return this;
+    }
+    addUnknownKeyValToInput(inputIndex, keyVal) {
+        const input = checkForInput(this.inputs, inputIndex);
+        checkHasKey(keyVal, input.unknownKeyVals, getEnumLength(InputTypes));
+        if (!input.unknownKeyVals)
+            input.unknownKeyVals = [];
+        input.unknownKeyVals.push(keyVal);
+        return this;
+    }
+    addUnknownKeyValToOutput(outputIndex, keyVal) {
+        const output = checkForOutput(this.outputs, outputIndex);
+        checkHasKey(keyVal, output.unknownKeyVals, getEnumLength(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));
+        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));
+        addOutputAttributes(this.outputs, outputData);
+        return this;
+    }
+    clearFinalizedInput(inputIndex) {
+        const input = checkForInput(this.inputs, inputIndex);
+        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 = combine([this].concat(those));
+        Object.assign(this, result);
+        return this;
+    }
+    getTransaction() {
+        return this.globalMap.unsignedTx.toBuffer();
+    }
+}
+export { checkForInput, checkForOutput } from './utils.js';

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

@@ -0,0 +1,34 @@
+export declare enum GlobalTypes {
+    UNSIGNED_TX = 0,
+    GLOBAL_XPUB = 1
+}
+export declare const GLOBAL_TYPE_NAMES: string[];
+export declare enum InputTypes {
+    NON_WITNESS_UTXO = 0,
+    WITNESS_UTXO = 1,
+    PARTIAL_SIG = 2,
+    SIGHASH_TYPE = 3,
+    REDEEM_SCRIPT = 4,
+    WITNESS_SCRIPT = 5,
+    BIP32_DERIVATION = 6,
+    FINAL_SCRIPTSIG = 7,
+    FINAL_SCRIPTWITNESS = 8,
+    POR_COMMITMENT = 9,
+    TAP_KEY_SIG = 19,
+    TAP_SCRIPT_SIG = 20,
+    TAP_LEAF_SCRIPT = 21,
+    TAP_BIP32_DERIVATION = 22,
+    TAP_INTERNAL_KEY = 23,
+    TAP_MERKLE_ROOT = 24,
+    OPCAT_UTXO = 25
+}
+export declare const INPUT_TYPE_NAMES: string[];
+export declare enum OutputTypes {
+    REDEEM_SCRIPT = 0,
+    WITNESS_SCRIPT = 1,
+    BIP32_DERIVATION = 2,
+    TAP_INTERNAL_KEY = 5,
+    TAP_TREE = 6,
+    TAP_BIP32_DERIVATION = 7
+}
+export declare const OUTPUT_TYPE_NAMES: string[];

package/src/esm/lib/typeFields.js

@@ -0,0 +1,62 @@
+export var GlobalTypes;
+(function (GlobalTypes) {
+    GlobalTypes[GlobalTypes["UNSIGNED_TX"] = 0] = "UNSIGNED_TX";
+    GlobalTypes[GlobalTypes["GLOBAL_XPUB"] = 1] = "GLOBAL_XPUB";
+})(GlobalTypes || (GlobalTypes = {}));
+export const GLOBAL_TYPE_NAMES = ['unsignedTx', 'globalXpub'];
+export 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 || (InputTypes = {}));
+export const INPUT_TYPE_NAMES = [
+    'nonWitnessUtxo',
+    'witnessUtxo',
+    'partialSig',
+    'sighashType',
+    'redeemScript',
+    'witnessScript',
+    'bip32Derivation',
+    'finalScriptSig',
+    'finalScriptWitness',
+    'porCommitment',
+    'tapKeySig',
+    'tapScriptSig',
+    'tapLeafScript',
+    'tapBip32Derivation',
+    'tapInternalKey',
+    'tapMerkleRoot',
+    'opcatUtxo',
+];
+export 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 || (OutputTypes = {}));
+export const OUTPUT_TYPE_NAMES = [
+    'redeemScript',
+    'witnessScript',
+    'bip32Derivation',
+    'tapInternalKey',
+    'tapTree',
+    'tapBip32Derivation',
+];

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

@@ -0,0 +1,13 @@
+import { KeyValue, PsbtGlobal, PsbtGlobalUpdate, PsbtInput, PsbtInputUpdate, PsbtOutput, PsbtOutputUpdate } from './interfaces.js';
+export declare function checkForInput(inputs: PsbtInput[], inputIndex: number): PsbtInput;
+export declare function checkForOutput(outputs: PsbtOutput[], outputIndex: number): PsbtOutput;
+export declare function checkHasKey(checkKeyVal: KeyValue, keyVals: KeyValue[] | undefined, enumLength: number): void;
+export declare function getEnumLength(myenum: any): number;
+export declare function inputCheckUncleanFinalized(inputIndex: number, input: PsbtInput): void;
+export declare const updateGlobal: (updateData: PsbtGlobalUpdate, mainData: PsbtGlobal) => void;
+export declare const updateInput: (updateData: PsbtInputUpdate, mainData: PsbtInput) => void;
+export declare const updateOutput: (updateData: PsbtOutputUpdate, mainData: PsbtOutput) => void;
+export declare function addInputAttributes(inputs: PsbtInput[], data: any): void;
+export declare function addOutputAttributes(outputs: PsbtOutput[], data: any): void;
+export declare function defaultVersionSetter(version: number, txBuf: Uint8Array): Uint8Array;
+export declare function defaultLocktimeSetter(locktime: number, txBuf: Uint8Array): Uint8Array;

package/src/esm/lib/utils.js

@@ -0,0 +1,123 @@
+import * as converter from './converter/index.js';
+import * as tools from 'uint8array-tools';
+export function checkForInput(inputs, inputIndex) {
+    const input = inputs[inputIndex];
+    if (input === undefined)
+        throw new Error(`No input #${inputIndex}`);
+    return input;
+}
+export function checkForOutput(outputs, outputIndex) {
+    const output = outputs[outputIndex];
+    if (output === undefined)
+        throw new Error(`No output #${outputIndex}`);
+    return output;
+}
+export 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)}`);
+    }
+}
+export function getEnumLength(myenum) {
+    let count = 0;
+    Object.keys(myenum).forEach(val => {
+        if (Number(isNaN(Number(val)))) {
+            count++;
+        }
+    });
+    return count;
+}
+export 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`);
+    }
+}
+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;
+                }
+            }
+        }
+    };
+}
+export const updateGlobal = updateMaker('global');
+export const updateInput = updateMaker('input');
+export const updateOutput = updateMaker('output');
+export function addInputAttributes(inputs, data) {
+    const index = inputs.length - 1;
+    const input = checkForInput(inputs, index);
+    updateInput(data, input);
+}
+export function addOutputAttributes(outputs, data) {
+    const index = outputs.length - 1;
+    const output = checkForOutput(outputs, index);
+    updateOutput(data, output);
+}
+export 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;
+}
+export 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;
+}