@opcat-labs/bip174 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Jonathan Underwood and BitcoinJS team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,109 @@
+# bip174
+[![Build Status](https://github.com/bitcoinjs/bip174/actions/workflows/main_ci.yml/badge.svg)](https://github.com/bitcoinjs/bip174/actions/workflows/main_ci.yml)
+[![NPM](https://img.shields.io/npm/v/bip174.svg)](https://www.npmjs.org/package/bip174)
+
+[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
+
+A [BIP174](https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki) compatible partial Transaction encoding library.
+
+## Bitcoin users, use bitcoinjs-lib's Psbt class.
+
+This library is separate as an attempt to separate Bitcoin specific logic from the encoding format.
+
+I apologize if this library is hard to use. Removing Bitcoin specific logic from "Partially Signed BITCOIN Transaction" format was kind of hard.
+
+## Responsibilities Covered
+
+1. Creator: You can create a new psbt and add inputs and outputs, then add extra info to the inputs using each individual method.
+  (Note: Psbt.fromTransaction can create a PSBT from a serialized transaction, but all scriptSigs and witnessStacks must be empty,
+    and the transaction should not have the segwit marker and flagbyte.)
+2. Updater: You can add one of all types of the input and output information. Each function has strict type checking at runtime.
+3. Combiner: using Psbt.combine(...Psbt[]), it will do a dumb merge gathering all the new key value pairs from the subsequent PSBTs into itself. The psbt calling `combine` has highest priority.
+
+## Responsibilities NOT Covered
+
+In order to keep this library as separate from Bitcoin logic as possible, This library will not implement the following responsibilities. But rather, down the road bitcoinjs-lib will adopt this class and extend it internally to allow for the following:
+
+1. Signer: This class has no way to sign. You may add a PartialSig object though.
+2. Extractor: This class has minimal knowledge of Bitcoin transactions, so creating a full transaction from a PSBT must be done with a bitcoin aware extended class.
+3. Input Finalizer: This class, again, has no knowledge of whether an input is finished.
+
+## Static methods and addInput / addOutput require an abstract Transaction object
+
+* Static methods: You must pass a `TransactionFromBuffer` typed function. See `ts_src/lib/interfaces.ts` for info on the `Transaction` interface and the `TransactionFromBuffer` function.
+* addInput/addOutput methods: The constructor takes a `Transaction` abstract interface that has an addInput/addOutput method which will be called.
+
+## Example
+```javascript
+const { Psbt } = require('bip174')
+const { PsbtTransaction , pTxFromBuffer } = require('./someImplementation')
+// Psbt requires a Transaction interface to create an instance, as well as
+// A function that turns a buffer into that interface. See Transaction and TransactionFromBuffer
+// in ts_src/lib/interfaces.ts ...
+
+// See tests/utils/txTools file for an example of a simple Bitcoin Transaction.
+// Also see BitcoinJS-lib for an extended class that uses the Transaction class internally.
+// Anyone using this library for Bitcoin specifically should use bitcoinjs-lib
+
+// Your PsbtTransaction will have a toBuffer function to allow for serialization
+const tx = pTxFromBuffer(someTransactionBuffer);
+const psbt = new Psbt(tx)
+
+// OR
+
+// This will parse the PSBT, and use the function you pass to parse the Transaction part
+// the function should throw if the scriptSig section is not empty
+const psbt = Psbt.fromBuffer(somePsbtBuffer, pTxFromBuffer)
+
+psbt.addInput({
+  hash: '865dce988413971fd812d0e81a3395ed916a87ea533e1a16c0f4e15df96fa7d4',
+  index: 3,
+})
+psbt.addInput({
+  hash: 'ff5dce988413971fd812d0e81a3395ed916a87ea533e1a16c0f4e15df96fa7d4',
+  index: 1,
+})
+psbt.addOutput({
+  script: Buffer.from(
+    'a914e18870f2c297fbfca54c5c6f645c7745a5b66eda87',
+    'hex',
+  ),
+  value: 1234567890,
+})
+psbt.addOutput({
+  script: Buffer.from(
+    'a914e18870f2c297fbfca54c5c6f645c7745a5b66eda87',
+    'hex',
+  ),
+  value: 987654321,
+})
+psbt.addRedeemScriptToInput(0, Buffer.from(
+  '00208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b2028903',
+  'hex',
+))
+psbt.addWitnessScriptToInput(0, Buffer.from(
+  '522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b9903' +
+    '0b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e861519268' +
+    '60221f0e7352ae',
+  'hex',
+))
+psbt.addBip32DerivationToInput(0, {
+  masterFingerprint: Buffer.from('d90c6a4f', 'hex'),
+  pubkey: Buffer.from(
+    '023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e73',
+    'hex',
+  ),
+  path: "m/0'/0'/3'",
+})
+psbt.addBip32DerivationToInput(0, {
+  masterFingerprint: Buffer.from('d90c6a4f', 'hex'),
+  pubkey: Buffer.from(
+    '03089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc',
+    'hex',
+  ),
+  path: "m/0'/0'/2'",
+})
+const b64 = psbt.toBase64();
+```
+
+## LICENSE [MIT](LICENSE)

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@opcat-labs/bip174",
+  "version": "1.0.0",
+  "description": "",
+  "main": "src/cjs/lib/psbt.cjs",
+  "module": "src/esm/lib/psbt.js",
+  "types": "src/esm/lib/psbt.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/esm/lib/psbt.d.ts",
+      "import": "./src/esm/lib/psbt.js",
+      "require": "./src/cjs/lib/psbt.cjs"
+    }
+  },
+  "type": "module",
+  "files": [
+    "src/cjs/lib",
+    "src/esm/lib"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "npm run clean && tsc -p ./tsconfig.json && tsc -p ./tsconfig.cjs.json",
+    "checkHybrid": "chmod +x test.cjs && node test.cjs",
+    "clean": "rimraf src types",
+    "coverage": "c8 --check-coverage --include='src/esm/lib/**/*.js' --reporter=lcov --reporter=text --branches 90 --functions 90 --lines 90 npm run unit",
+    "flb": "npm run format && npm run lint && npm run build",
+    "format": "npm run prettier -- --write",
+    "formatjs": "npm run prettierjs -- --write > /dev/null 2>&1",
+    "format:ci": "npm run prettier -- --check && npm run prettierjs -- --check",
+    "gitdiff:ci": "npm run build && git diff --exit-code",
+    "lint": "tslint -p tsconfig.json -c tslint.json",
+    "postbuild": "node fixup.cjs",
+    "prettier": "prettier 'ts_src/**/*.ts' --ignore-path ./.prettierignore",
+    "prettierjs": "prettier 'src/**/*.js' --ignore-path ./.prettierignore",
+    "test": "npm run format:ci && npm run lint && npm run build && npm run coverage",
+    "unit": "tape src/esm/tests/*.js src/esm/tests/fromBIP/*.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bitcoinjs/bip174.git"
+  },
+  "dependencies": {
+    "uint8array-tools": "^0.0.9",
+    "varuint-bitcoin": "^2.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "12.0.8",
+    "@types/tape": "4.2.33",
+    "bitcoinjs-lib": "^6.1.6",
+    "c8": "^10.1.2",
+    "prettier": "^1.18.2",
+    "rimraf": "^2.6.3",
+    "tape": "^5.3.0",
+    "tslint": "5.17.0",
+    "typescript": "3.5.2"
+  },
+  "author": "Jonathan Underwood",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/bitcoinjs/bip174/issues"
+  },
+  "homepage": "https://github.com/bitcoinjs/bip174#readme",
+  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
+}

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

@@ -0,0 +1,67 @@
+"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("../parser/index.js");
+const tools = __importStar(require("uint8array-tools"));
+function combine(psbts) {
+    const self = psbts[0];
+    const selfKeyVals = index_js_1.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 = index_js_1.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 index_js_1.psbtFromKeyVals(selfTx, {
+        globalMapKeyVals: selfKeyVals.globalKeyVals,
+        inputKeyVals: selfKeyVals.inputKeyVals,
+        outputKeyVals: selfKeyVals.outputKeyVals,
+    });
+}
+exports.combine = combine;
+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/cjs/lib/converter/global/globalXpub.js

@@ -0,0 +1,83 @@
+"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 typeFields_js_1 = require("../../typeFields.js");
+const tools = __importStar(require("uint8array-tools"));
+const range = (n) => [...Array(n).keys()];
+function decode(keyVal) {
+    if (keyVal.key[0] !== typeFields_js_1.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;
+}
+exports.decode = decode;
+function encode(data) {
+    const head = new Uint8Array([typeFields_js_1.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,
+    };
+}
+exports.encode = encode;
+exports.expected = '{ masterFingerprint: Uint8Array; extendedPubkey: Uint8Array; path: string; }';
+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+'?)*$/));
+}
+exports.check = check;
+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);
+}
+exports.canAddToArray = canAddToArray;

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeFields_js_1 = require("../../typeFields.js");
+function encode(data) {
+    return {
+        key: new Uint8Array([typeFields_js_1.GlobalTypes.UNSIGNED_TX]),
+        value: data.toBuffer(),
+    };
+}
+exports.encode = encode;

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

@@ -0,0 +1,72 @@
+"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 typeFields_js_1 = require("../typeFields.js");
+const globalXpub = __importStar(require("./global/globalXpub.js"));
+const unsignedTx = __importStar(require("./global/unsignedTx.js"));
+const finalScriptSig = __importStar(require("./input/finalScriptSig.js"));
+const finalScriptWitness = __importStar(require("./input/finalScriptWitness.js"));
+const nonWitnessUtxo = __importStar(require("./input/nonWitnessUtxo.js"));
+const partialSig = __importStar(require("./input/partialSig.js"));
+const porCommitment = __importStar(require("./input/porCommitment.js"));
+const sighashType = __importStar(require("./input/sighashType.js"));
+const tapKeySig = __importStar(require("./input/tapKeySig.js"));
+const tapLeafScript = __importStar(require("./input/tapLeafScript.js"));
+const tapMerkleRoot = __importStar(require("./input/tapMerkleRoot.js"));
+const tapScriptSig = __importStar(require("./input/tapScriptSig.js"));
+const witnessUtxo = __importStar(require("./input/witnessUtxo.js"));
+const opcatUtxo = __importStar(require("./input/opcatUtxo.js"));
+const tapTree = __importStar(require("./output/tapTree.js"));
+const bip32Derivation = __importStar(require("./shared/bip32Derivation.js"));
+const checkPubkey = __importStar(require("./shared/checkPubkey.js"));
+const redeemScript = __importStar(require("./shared/redeemScript.js"));
+const tapBip32Derivation = __importStar(require("./shared/tapBip32Derivation.js"));
+const tapInternalKey = __importStar(require("./shared/tapInternalKey.js"));
+const witnessScript = __importStar(require("./shared/witnessScript.js"));
+const globals = {
+    unsignedTx,
+    globalXpub,
+    // pass an Array of key bytes that require pubkey beside the key
+    checkPubkey: checkPubkey.makeChecker([]),
+};
+exports.globals = globals;
+const inputs = {
+    nonWitnessUtxo,
+    partialSig,
+    sighashType,
+    finalScriptSig,
+    finalScriptWitness,
+    porCommitment,
+    witnessUtxo,
+    opcatUtxo,
+    bip32Derivation: bip32Derivation.makeConverter(typeFields_js_1.InputTypes.BIP32_DERIVATION),
+    redeemScript: redeemScript.makeConverter(typeFields_js_1.InputTypes.REDEEM_SCRIPT),
+    witnessScript: witnessScript.makeConverter(typeFields_js_1.InputTypes.WITNESS_SCRIPT),
+    checkPubkey: checkPubkey.makeChecker([
+        typeFields_js_1.InputTypes.PARTIAL_SIG,
+        typeFields_js_1.InputTypes.BIP32_DERIVATION,
+    ]),
+    tapKeySig,
+    tapScriptSig,
+    tapLeafScript,
+    tapBip32Derivation: tapBip32Derivation.makeConverter(typeFields_js_1.InputTypes.TAP_BIP32_DERIVATION),
+    tapInternalKey: tapInternalKey.makeConverter(typeFields_js_1.InputTypes.TAP_INTERNAL_KEY),
+    tapMerkleRoot,
+};
+exports.inputs = inputs;
+const outputs = {
+    bip32Derivation: bip32Derivation.makeConverter(typeFields_js_1.OutputTypes.BIP32_DERIVATION),
+    redeemScript: redeemScript.makeConverter(typeFields_js_1.OutputTypes.REDEEM_SCRIPT),
+    witnessScript: witnessScript.makeConverter(typeFields_js_1.OutputTypes.WITNESS_SCRIPT),
+    checkPubkey: checkPubkey.makeChecker([typeFields_js_1.OutputTypes.BIP32_DERIVATION]),
+    tapBip32Derivation: tapBip32Derivation.makeConverter(typeFields_js_1.OutputTypes.TAP_BIP32_DERIVATION),
+    tapTree,
+    tapInternalKey: tapInternalKey.makeConverter(typeFields_js_1.OutputTypes.TAP_INTERNAL_KEY),
+};
+exports.outputs = outputs;

package/src/cjs/lib/converter/input/finalScriptSig.js

@@ -0,0 +1,36 @@
+"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 typeFields_js_1 = require("../../typeFields.js");
+const tools = __importStar(require("uint8array-tools"));
+function decode(keyVal) {
+    if (keyVal.key[0] !== typeFields_js_1.InputTypes.FINAL_SCRIPTSIG) {
+        throw new Error('Decode Error: could not decode finalScriptSig with key 0x' +
+            tools.toHex(keyVal.key));
+    }
+    return keyVal.value;
+}
+exports.decode = decode;
+function encode(data) {
+    const key = new Uint8Array([typeFields_js_1.InputTypes.FINAL_SCRIPTSIG]);
+    return {
+        key,
+        value: data,
+    };
+}
+exports.encode = encode;
+exports.expected = 'Uint8Array';
+function check(data) {
+    return data instanceof Uint8Array;
+}
+exports.check = check;
+function canAdd(currentData, newData) {
+    return !!currentData && !!newData && currentData.finalScriptSig === undefined;
+}
+exports.canAdd = canAdd;

package/src/cjs/lib/converter/input/finalScriptWitness.js

@@ -0,0 +1,36 @@
+"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 typeFields_js_1 = require("../../typeFields.js");
+const tools = __importStar(require("uint8array-tools"));
+function decode(keyVal) {
+    if (keyVal.key[0] !== typeFields_js_1.InputTypes.FINAL_SCRIPTWITNESS) {
+        throw new Error('Decode Error: could not decode finalScriptWitness with key 0x' +
+            tools.toHex(keyVal.key));
+    }
+    return keyVal.value;
+}
+exports.decode = decode;
+function encode(data) {
+    const key = new Uint8Array([typeFields_js_1.InputTypes.FINAL_SCRIPTWITNESS]);
+    return {
+        key,
+        value: data,
+    };
+}
+exports.encode = encode;
+exports.expected = 'Uint8Array';
+function check(data) {
+    return data instanceof Uint8Array;
+}
+exports.check = check;
+function canAdd(currentData, newData) {
+    return (!!currentData && !!newData && currentData.finalScriptWitness === undefined);
+}
+exports.canAdd = canAdd;

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

@@ -0,0 +1,35 @@
+"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 typeFields_js_1 = require("../../typeFields.js");
+const tools = __importStar(require("uint8array-tools"));
+function decode(keyVal) {
+    if (keyVal.key[0] !== typeFields_js_1.InputTypes.NON_WITNESS_UTXO) {
+        throw new Error('Decode Error: could not decode nonWitnessUtxo with key 0x' +
+            tools.toHex(keyVal.key));
+    }
+    return keyVal.value;
+}
+exports.decode = decode;
+function encode(data) {
+    return {
+        key: new Uint8Array([typeFields_js_1.InputTypes.NON_WITNESS_UTXO]),
+        value: data,
+    };
+}
+exports.encode = encode;
+exports.expected = 'Uint8Array';
+function check(data) {
+    return data instanceof Uint8Array;
+}
+exports.check = check;
+function canAdd(currentData, newData) {
+    return !!currentData && !!newData && currentData.nonWitnessUtxo === undefined;
+}
+exports.canAdd = canAdd;

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

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