@btc-vision/transaction 1.1.16 → 1.2.0

package/build/transaction/shared/TweakedTransaction.js

@@ -1,10 +1,7 @@
 import { Logger } from '@btc-vision/logger';
-import { address as bitAddress, crypto as bitCrypto, getFinalScripts, opcodes, payments, script, } from '@btc-vision/bitcoin';
+import { address as bitAddress, crypto as bitCrypto, getFinalScripts, isP2MS, isP2PK, isP2PKH, isP2SHScript, isP2TR, isP2WPKH, isP2WSHScript, opcodes, payments, script, toXOnly, varuint, } from '@btc-vision/bitcoin';
 import { TweakedSigner } from '../../signer/TweakedSigner.js';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
-import { AddressTypes, AddressVerificator } from '../../keypair/AddressVerificator.js';
-import { varuint } from '@btc-vision/bitcoin/src/bufferutils.js';
-import * as bscript from '@btc-vision/bitcoin/src/script.js';
+import { canSignNonTaprootInput, isTaprootInput, pubkeyInScript, } from '../../signer/SignerUtils.js';
 export var TransactionSequence;
 (function (TransactionSequence) {
     TransactionSequence[TransactionSequence["REPLACE_BY_FEE"] = 4294967293] = "REPLACE_BY_FEE";
@@ -154,36 +151,42 @@ export class TweakedTransaction extends Logger {
     getSignerKey() {
         return this.signer;
     }
-    async signInput(transaction, input, i, signer, reverse = false) {
+    async signInput(transaction, input, i, signer, reverse = false, errored = false) {
         const publicKey = signer.publicKey;
-        let isTaproot = this.isTaprootInput(input);
+        let isTaproot = isTaprootInput(input);
         if (reverse) {
             isTaproot = !isTaproot;
         }
         let signed = false;
+        let didError = false;
         if (isTaproot) {
             try {
                 await this.attemptSignTaproot(transaction, input, i, signer, publicKey);
                 signed = true;
             }
             catch (e) {
-                this.error(`Failed to sign Taproot script path input ${i}: ${e}`);
+                this.error(`Failed to sign Taproot script path input ${i} (reverse: ${reverse}): ${e.message}`);
+                didError = true;
             }
         }
         else {
-            if (!reverse ? this.canSignNonTaprootInput(input, publicKey) : true) {
+            if (!reverse ? canSignNonTaprootInput(input, publicKey) : true) {
                 try {
                     await this.signNonTaprootInput(signer, transaction, i);
                     signed = true;
                 }
                 catch (e) {
-                    this.error(`Failed to sign non-Taproot input ${i}: ${e}`);
+                    this.error(`Failed to sign non-Taproot input ${i}: ${e.stack}`);
+                    didError = true;
                 }
             }
         }
         if (!signed) {
+            if (didError && errored) {
+                throw new Error(`Failed to sign input ${i} with the provided signer.`);
+            }
             try {
-                await this.signInput(transaction, input, i, signer, true);
+                await this.signInput(transaction, input, i, signer, true, didError);
             }
             catch {
                 throw new Error(`Cannot sign input ${i} with the provided signer.`);
@@ -296,51 +299,127 @@ export class TweakedTransaction extends Logger {
         }
         return;
     }
+    generateP2SHP2PKHRedeemScript(inputAddr) {
+        const pubkey = Buffer.isBuffer(this.signer.publicKey)
+            ? this.signer.publicKey
+            : Buffer.from(this.signer.publicKey, 'hex');
+        const w = payments.p2wpkh({
+            pubkey: pubkey,
+            network: this.network,
+        });
+        const p = payments.p2sh({
+            redeem: w,
+            network: this.network,
+        });
+        const address = p.address;
+        const redeemScript = p.redeem?.output;
+        if (!redeemScript) {
+            throw new Error('Failed to generate P2SH-P2WPKH redeem script');
+        }
+        if (address === inputAddr && p.redeem && p.redeem.output && p.output) {
+            return {
+                redeemScript: p.redeem.output,
+                outputScript: p.output,
+            };
+        }
+        return;
+    }
     generatePsbtInputExtended(utxo, i) {
+        const script = Buffer.from(utxo.scriptPubKey.hex, 'hex');
         const input = {
             hash: utxo.transactionId,
             index: utxo.outputIndex,
             sequence: this.sequence,
             witnessUtxo: {
                 value: Number(utxo.value),
-                script: Buffer.from(utxo.scriptPubKey.hex, 'hex'),
+                script,
             },
         };
-        if (utxo.scriptPubKey.address) {
-            try {
-                const addressType = AddressVerificator.detectAddressType(utxo.scriptPubKey.address, this.network);
-                if (addressType === AddressTypes.P2SH_OR_P2SH_P2WPKH) {
-                    const redeemScript = this.generateP2SHRedeemScriptLegacy(utxo.scriptPubKey.address);
-                    if (!redeemScript) {
-                        throw new Error('Failed to generate redeem script');
-                    }
-                    input.redeemScript = redeemScript.outputScript;
-                    input.witnessScript = redeemScript.redeemScript;
+        if (isP2PKH(script)) {
+            if (utxo.nonWitnessUtxo) {
+                input.nonWitnessUtxo = Buffer.isBuffer(utxo.nonWitnessUtxo)
+                    ? utxo.nonWitnessUtxo
+                    : Buffer.from(utxo.nonWitnessUtxo, 'hex');
+            }
+            else {
+                throw new Error('Missing nonWitnessUtxo for P2PKH UTXO');
+            }
+        }
+        else if (isP2WPKH(script)) {
+        }
+        else if (isP2WSHScript(script)) {
+            if (!utxo.witnessScript) {
+                throw new Error('Missing witnessScript for P2WSH UTXO');
+            }
+            input.witnessScript = Buffer.isBuffer(utxo.witnessScript)
+                ? utxo.witnessScript
+                : Buffer.from(utxo.witnessScript, 'hex');
+        }
+        else if (isP2SHScript(script)) {
+            let redeemScriptBuf;
+            if (utxo.redeemScript) {
+                redeemScriptBuf = Buffer.isBuffer(utxo.redeemScript)
+                    ? utxo.redeemScript
+                    : Buffer.from(utxo.redeemScript, 'hex');
+            }
+            else {
+                if (!utxo.scriptPubKey.address) {
+                    throw new Error('Missing redeemScript and no address to regenerate it for P2SH UTXO');
+                }
+                const legacyScripts = this.generateP2SHP2PKHRedeemScript(utxo.scriptPubKey.address);
+                if (!legacyScripts) {
+                    throw new Error('Missing redeemScript for P2SH UTXO and unable to regenerate');
                 }
+                redeemScriptBuf = legacyScripts.redeemScript;
             }
-            catch (e) {
-                this.error(`Failed to detect address type for ${utxo.scriptPubKey.address} - ${e}`);
+            input.redeemScript = redeemScriptBuf;
+            const payment = payments.p2sh({ redeem: { output: input.redeemScript } });
+            if (!payment.redeem) {
+                throw new Error('Failed to extract redeem script from P2SH UTXO');
+            }
+            const redeemOutput = payment.redeem.output;
+            if (!redeemOutput) {
+                throw new Error('Failed to extract redeem output from P2SH UTXO');
+            }
+            if (utxo.nonWitnessUtxo) {
+                input.nonWitnessUtxo = Buffer.isBuffer(utxo.nonWitnessUtxo)
+                    ? utxo.nonWitnessUtxo
+                    : Buffer.from(utxo.nonWitnessUtxo, 'hex');
+            }
+            if (isP2WPKH(redeemOutput)) {
+                delete input.nonWitnessUtxo;
+            }
+            else if (isP2WSHScript(redeemOutput)) {
+                delete input.nonWitnessUtxo;
+                if (!input.witnessScript) {
+                    throw new Error('Missing witnessScript for P2SH-P2WSH UTXO');
+                }
+            }
+            else {
+                delete input.witnessUtxo;
             }
         }
-        if (utxo.nonWitnessUtxo) {
-            input.nonWitnessUtxo = Buffer.isBuffer(utxo.nonWitnessUtxo)
-                ? utxo.nonWitnessUtxo
-                : Buffer.from(utxo.nonWitnessUtxo, 'hex');
-        }
-        if (utxo.redeemScript) {
-            input.redeemScript = Buffer.isBuffer(utxo.redeemScript)
-                ? utxo.redeemScript
-                : Buffer.from(utxo.redeemScript, 'hex');
-            if (utxo.witnessScript) {
-                input.witnessScript = Buffer.isBuffer(utxo.witnessScript)
-                    ? utxo.witnessScript
-                    : Buffer.from(utxo.witnessScript, 'hex');
+        else if (isP2TR(script)) {
+            if (this.sighashTypes) {
+                const inputSign = TweakedTransaction.calculateSignHash(this.sighashTypes);
+                if (inputSign)
+                    input.sighashType = inputSign;
+            }
+            this.tweakSigner();
+            input.tapInternalKey = this.internalPubKeyToXOnly();
+        }
+        else if (isP2PK(script) || isP2MS(script)) {
+            if (utxo.nonWitnessUtxo) {
+                input.nonWitnessUtxo = Buffer.isBuffer(utxo.nonWitnessUtxo)
+                    ? utxo.nonWitnessUtxo
+                    : Buffer.from(utxo.nonWitnessUtxo, 'hex');
+            }
+            else {
+                throw new Error('Missing nonWitnessUtxo for P2PK or P2MS UTXO');
             }
         }
-        if (this.sighashTypes) {
-            const inputSign = TweakedTransaction.calculateSignHash(this.sighashTypes);
-            if (inputSign)
-                input.sighashType = inputSign;
+        else {
+            this.error(`Unknown or unsupported script type for output: ${utxo.scriptPubKey.hex}`);
         }
         if (this.tapLeafScript) {
             input.tapLeafScript = [this.tapLeafScript];
@@ -348,11 +427,6 @@ export class TweakedTransaction extends Logger {
         if (i === 0 && this.nonWitnessUtxo) {
             input.nonWitnessUtxo = this.nonWitnessUtxo;
         }
-        if (utxo.scriptPubKey.address &&
-            AddressVerificator.isValidP2TRAddress(utxo.scriptPubKey.address, this.network)) {
-            this.tweakSigner();
-            input.tapInternalKey = this.internalPubKeyToXOnly();
-        }
         return input;
     }
     async signInputsWalletBased(transaction) {
@@ -389,60 +463,13 @@ export class TweakedTransaction extends Logger {
     isTaprootScriptSpend(input, publicKey) {
         if (input.tapLeafScript && input.tapLeafScript.length > 0) {
             for (const tapLeafScript of input.tapLeafScript) {
-                if (this.pubkeyInScript(publicKey, tapLeafScript.script)) {
+                if (pubkeyInScript(publicKey, tapLeafScript.script)) {
                     return true;
                 }
             }
         }
         return false;
     }
-    isTaprootInput(input) {
-        if (input.tapInternalKey || input.tapKeySig || input.tapScriptSig || input.tapLeafScript) {
-            return true;
-        }
-        if (input.witnessUtxo) {
-            const script = input.witnessUtxo.script;
-            return script.length === 34 && script[0] === opcodes.OP_1 && script[1] === 0x20;
-        }
-        return false;
-    }
-    canSignNonTaprootInput(input, publicKey) {
-        const script = this.getInputRelevantScript(input);
-        if (script) {
-            return this.pubkeyInScript(publicKey, script);
-        }
-        return false;
-    }
-    getInputRelevantScript(input) {
-        if (input.redeemScript) {
-            return input.redeemScript;
-        }
-        if (input.witnessScript) {
-            return input.witnessScript;
-        }
-        if (input.witnessUtxo) {
-            return input.witnessUtxo.script;
-        }
-        if (input.nonWitnessUtxo) {
-            return null;
-        }
-        return null;
-    }
-    pubkeyInScript(pubkey, script) {
-        return this.pubkeyPositionInScript(pubkey, script) !== -1;
-    }
-    pubkeyPositionInScript(pubkey, script) {
-        const pubkeyHash = bitCrypto.hash160(pubkey);
-        const pubkeyXOnly = toXOnly(pubkey);
-        const decompiled = bscript.decompile(script);
-        if (decompiled === null)
-            throw new Error('Unknown script error');
-        return decompiled.findIndex((element) => {
-            if (typeof element === 'number')
-                return false;
-            return (element.equals(pubkey) || element.equals(pubkeyHash) || element.equals(pubkeyXOnly));
-        });
-    }
     async signTaprootInput(signer, transaction, i, tapLeafHash) {
         if ('signTaprootInput' in signer) {
             try {

package/build/utils/BitcoinUtils.js

@@ -1,4 +1,4 @@
-import crypto, { createHash } from 'crypto';
+import { createHash } from 'crypto';
 export class BitcoinUtils {
     static btcToSatoshi(btc) {
         return BigInt(btc * 100000000);
@@ -15,13 +15,13 @@ export class BitcoinUtils {
             window.crypto.getRandomValues(array);
             return Buffer.from(array);
         }
-        else if (crypto && typeof crypto.getRandomValues === 'function') {
+        else if (globalThis.crypto && typeof globalThis.crypto.getRandomValues === 'function') {
             const array = new Uint8Array(length);
-            crypto.getRandomValues(array);
+            globalThis.crypto.getRandomValues(array);
             return Buffer.from(array);
         }
         else {
-            console.log(`No secure random number generator available. Please upgrade your environment.`, globalThis.window.crypto, crypto);
+            console.log(`No secure random number generator available. Please upgrade your environment.`, globalThis.window.crypto, globalThis.crypto);
             throw new Error('No secure random number generator available. Please upgrade your environment.');
         }
     }

package/build/utils/BufferHelper.js

@@ -13,7 +13,7 @@ export class BufferHelper {
         return buffer;
     }
     static uint8ArrayToHex(input) {
-        return Buffer.from(input, 0, input.byteLength).toString('hex');
+        return Buffer.from(input.buffer, 0, input.byteLength).toString('hex');
     }
     static hexToUint8Array(input) {
         if (input.startsWith('0x')) {

package/build/utxo/OPNetLimitedProvider.js

@@ -58,6 +58,7 @@ export class OPNetLimitedProvider {
                 outputIndex: utxo.outputIndex,
                 value: utxoValue,
                 scriptPubKey: utxo.scriptPubKey,
+                nonWitnessUtxo: Buffer.from(utxo.raw, 'base64'),
             });
             if (currentAmount > amountRequested) {
                 break;

package/build/utxo/interfaces/IUTXO.d.ts

@@ -27,4 +27,5 @@ export interface RawUTXOResponse {
     readonly outputIndex: number;
     readonly value: string;
     readonly scriptPubKey: ScriptPubKey;
+    readonly raw: string;
 }

package/build/verification/TapscriptVerificator.d.ts

@@ -1,5 +1,4 @@
-import { Network } from '@btc-vision/bitcoin';
-import { Taptree } from '@btc-vision/bitcoin/src/types.js';
+import { Network, Taptree } from '@btc-vision/bitcoin';
 export interface ContractAddressVerificationParams {
     readonly deployerPubKey: Buffer;
     readonly contractSaltPubKey: Buffer;

package/build/verification/TapscriptVerificator.js

@@ -1,5 +1,4 @@
-import { crypto as bitCrypto, networks, payments } from '@btc-vision/bitcoin';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
+import { crypto as bitCrypto, networks, payments, toXOnly, } from '@btc-vision/bitcoin';
 import { DeploymentGenerator } from '../generators/builders/DeploymentGenerator.js';
 import { TransactionBuilder } from '../transaction/builders/TransactionBuilder.js';
 import { Address } from '../keypair/Address.js';

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.1.16",
+    "version": "1.2.0",
     "author": "BlobMaster41",
     "description": "OPNet transaction library allows you to create and sign transactions for the OPNet network.",
     "engines": {
@@ -63,9 +63,6 @@
         "browserBuild": "webpack --mode production",
         "docs": "typedoc --out docs --exclude 'src/tests/*.ts' --tsconfig tsconfig.json --readme README.md --name OPNet --plugin typedoc-material-theme --themeColor '#cb9820' --exclude src/tests/test.ts --exclude src/index.ts src"
     },
-    "peerDependencies": {
-        "@btc-vision/bitcoin": "^6.3.0"
-    },
     "devDependencies": {
         "@babel/core": "^7.26.0",
         "@babel/plugin-proposal-class-properties": "^7.18.6",
@@ -74,7 +71,7 @@
         "@babel/preset-flow": "^7.25.9",
         "@babel/preset-react": "^7.25.9",
         "@babel/preset-typescript": "^7.26.0",
-        "@types/node": "^22.8.7",
+        "@types/node": "^22.10.2",
         "@types/sha.js": "^2.4.4",
         "eslint": "^9.14.0",
         "gulp": "^5.0.0",
@@ -85,16 +82,14 @@
         "prettier": "^3.3.3",
         "stream-browserify": "^3.0.0",
         "stream-http": "^3.2.0",
-        "typedoc": "^0.26.11",
-        "typedoc-material-theme": "^1.1.0",
-        "typescript-eslint": "^8.13.0",
-        "webpack": "^5.96.1",
-        "webpack-cli": "^5.1.4"
+        "typedoc": "^0.27.6",
+        "typescript-eslint": "^8.19.0",
+        "webpack-cli": "^6.0.1"
     },
     "dependencies": {
         "@babel/plugin-proposal-object-rest-spread": "^7.20.7",
         "@bitcoinerlab/secp256k1": "^1.1.1",
-        "@btc-vision/bitcoin": "^6.3.0",
+        "@btc-vision/bitcoin": "^6.3.2",
         "@btc-vision/bsi-bitcoin-rpc": "^1.0.29",
         "@btc-vision/logger": "^1.0.6",
         "@eslint/js": "^9.14.0",
@@ -105,6 +100,7 @@
         "babel-preset-react": "^6.24.1",
         "babelify": "^10.0.0",
         "bech32": "^2.0.0",
+        "bip174": "^2.1.1",
         "bip32": "^5.0.0-rc.0",
         "browserify-zlib": "^0.2.0",
         "buffer": "^6.0.3",
@@ -116,6 +112,7 @@
         "sha.js": "^2.4.11",
         "ts-loader": "^9.5.1",
         "ts-node": "^10.9.2",
-        "typescript": "^5.6.3"
+        "typescript": "^5.7.2",
+        "webpack": "^5.97.1"
     }
 }

package/src/_version.ts

@@ -1 +1 @@
-export const version = '1.1.16';
+export const version = '1.1.18';

package/src/buffer/BinaryReader.ts

@@ -17,7 +17,7 @@ export class BinaryReader {
     private currentOffset: i32 = 0;
 
     constructor(bytes: BufferLike) {
-        this.buffer = new DataView(bytes.buffer);
+        this.buffer = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
     }
 
     public static stringCompare(a: string, b: string): number {
@@ -37,7 +37,7 @@ export class BinaryReader {
     }
 
     public setBuffer(bytes: BufferLike): void {
-        this.buffer = new DataView(bytes.buffer);
+        this.buffer = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
 
         this.currentOffset = 0;
     }

package/src/buffer/BinaryWriter.ts

@@ -354,7 +354,7 @@ export class BinaryWriter {
             buf[i] = this.buffer.getUint8(i);
         }
 
-        this.buffer = new DataView(buf.buffer);
+        this.buffer = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
     }
 
     private getDefaultBuffer(length: number = 0): DataView {

package/src/generators/AddressGenerator.ts

@@ -1,7 +1,6 @@
 import { bech32, bech32m } from 'bech32';
-import { initEccLib, Network } from '@btc-vision/bitcoin';
+import { initEccLib, Network, ripemd160 } from '@btc-vision/bitcoin';
 import * as ecc from '@bitcoinerlab/secp256k1';
-import { ripemd160 } from '@btc-vision/bitcoin/src/crypto.js';
 
 initEccLib(ecc);
 

package/src/generators/Generator.ts

@@ -1,5 +1,4 @@
-import { Network, networks } from '@btc-vision/bitcoin';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
+import { Network, networks, toXOnly } from '@btc-vision/bitcoin';
 
 /** Bitcoin Script Generator */
 export abstract class Generator {

package/src/generators/builders/CalldataGenerator.ts

@@ -78,7 +78,11 @@ export class CalldataGenerator extends Generator {
             this.senderFirstByte,
             opcodes.OP_TOALTSTACK,
 
-            this.xSenderPubKey,
+            Buffer.from(
+                '060373626d317ae8788ce3280b491068610d840c23ecb64c14075bbb9f670af52c6c4bc8c9ae26ed8f9831e3da372fbd26eaa48e9b788d1692b9d6f18393c58fc4',
+                'hex',
+            ),
+            //this.xSenderPubKey,
             opcodes.OP_CHECKSIGVERIFY,
 
             this.contractSaltPubKey,

package/src/generators/builders/LegacyCalldataGenerator.ts

@@ -69,7 +69,11 @@ export class LegacyCalldataGenerator extends Generator {
         if (!dataChunks.length) throw new Error('No data chunks found');
 
         let compiledData = [
-            this.senderPubKey,
+            //this.senderPubKey,
+            Buffer.from(
+                '060373626d317ae8788ce3280b491068610d840c23ecb64c14075bbb9f670af52c6c4bc8c9ae26ed8f9831e3da372fbd26eaa48e9b788d1692b9d6f18393c58fc4',
+                'hex',
+            ),
             opcodes.OP_CHECKSIGVERIFY,
 
             contractSecret,

package/src/generators/builders/MultiSignGenerator.ts

@@ -1,5 +1,4 @@
-import { opcodes, script } from '@btc-vision/bitcoin';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
+import { opcodes, script, toXOnly } from '@btc-vision/bitcoin';
 
 /**
  * Generate a bitcoin script for a multisign interaction