@btc-vision/transaction 1.1.15 → 1.1.17

package/build/transaction/shared/TweakedTransaction.js

@@ -2,9 +2,9 @@ import { Logger } from '@btc-vision/logger';
 import { address as bitAddress, crypto as bitCrypto, getFinalScripts, opcodes, payments, script, } 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';
+import { isP2MS, isP2PK, isP2PKH, isP2SHScript, isP2TR, isP2WPKH, isP2WSHScript, } from '@btc-vision/bitcoin/src/psbt/psbtutils.js';
 export var TransactionSequence;
 (function (TransactionSequence) {
     TransactionSequence[TransactionSequence["REPLACE_BY_FEE"] = 4294967293] = "REPLACE_BY_FEE";
@@ -154,36 +154,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 +302,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 +430,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 +466,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/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/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.1.15",
+    "version": "1.1.17",
     "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",
@@ -94,7 +91,7 @@
     "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.1",
         "@btc-vision/bsi-bitcoin-rpc": "^1.0.29",
         "@btc-vision/logger": "^1.0.6",
         "@eslint/js": "^9.14.0",

package/src/_version.ts

@@ -1 +1 @@
-export const version = '1.1.14';
+export const version = '1.1.17';

package/src/keypair/Address.ts

@@ -104,6 +104,14 @@ export class Address extends Uint8Array {
         return Buffer.from(this);
     }
 
+    public originalPublicKeyBuffer(): Buffer {
+        if (!this.#originalPublicKey) {
+            throw new Error('Public key not set');
+        }
+
+        return Buffer.from(this.#originalPublicKey);
+    }
+
     public equals(a: Address): boolean {
         const b: Address = this as Address;
 
@@ -200,6 +208,13 @@ export class Address extends Uint8Array {
         return AddressVerificator.isValidPublicKey(Buffer.from(this).toString('hex'), network);
     }
 
+    /**
+     * Get the public key as address
+     */
+    public p2pk(): string {
+        return this.toHex();
+    }
+
     /**
      * Get the address in p2wpkh format
      * @param {Network} network The network

package/src/opnet.ts

@@ -47,6 +47,7 @@ export * from './transaction/builders/TransactionBuilder.js';
 
 /** Utils */
 export * from './utils/BitcoinUtils.js';
+export * from './utils/lengths.js';
 
 /** UTXO */
 export * from './utxo/interfaces/IUTXO.js';
@@ -89,3 +90,4 @@ export * from './transaction/browser/types/Xverse.js';
 
 export * from './metadata/tokens.js';
 export * from './transaction/browser/Web3Provider.js';
+

package/src/signer/SignerUtils.ts

@@ -0,0 +1,78 @@
+// Helper functions
+import { crypto as bitCrypto, PsbtInput } from '@btc-vision/bitcoin';
+import { isP2TR } from '@btc-vision/bitcoin/src/psbt/psbtutils.js';
+import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
+import * as bscript from '@btc-vision/bitcoin/src/script.js';
+
+export function isTaprootInput(input: PsbtInput): boolean {
+    return (
+        input &&
+        !!(
+            input.tapInternalKey ||
+            input.tapMerkleRoot ||
+            (input.tapLeafScript && input.tapLeafScript.length) ||
+            (input.tapBip32Derivation && input.tapBip32Derivation.length) ||
+            (input.witnessUtxo && isP2TR(input.witnessUtxo.script))
+        )
+    );
+}
+
+export function getInputRelevantScript(input: PsbtInput): Buffer | null {
+    if (input.redeemScript) {
+        return input.redeemScript;
+    }
+    if (input.witnessScript) {
+        return input.witnessScript;
+    }
+    if (input.witnessUtxo) {
+        return input.witnessUtxo.script;
+    }
+    if (input.nonWitnessUtxo) {
+        // Parse the full transaction from nonWitnessUtxo
+        /*const tx = Transaction.fromBuffer(input.nonWitnessUtxo);
+        // Retrieve the output referenced by the input index
+        const out = tx.outs[input.index];
+        if (!out) {
+            throw new Error(`No output at index ${input.index} in nonWitnessUtxo`);
+        }
+        return out.script;*/
+    }
+    return null;
+}
+
+export function canSignNonTaprootInput(input: PsbtInput, publicKey: Buffer): boolean {
+    if (
+        (input.nonWitnessUtxo &&
+            !input.redeemScript &&
+            !input.witnessScript &&
+            !input.witnessUtxo) ||
+        input.redeemScript
+    ) {
+        return true;
+    }
+
+    const script = getInputRelevantScript(input);
+    if (script) {
+        return pubkeyInScript(publicKey, script);
+    }
+    return false;
+}
+
+export function pubkeyPositionInScript(pubkey: Buffer, script: Buffer): number {
+    const pubkeyHash = bitCrypto.hash160(pubkey);
+    const pubkeyXOnly = toXOnly(pubkey);
+
+    const decompiled = bscript.decompile(script);
+    if (decompiled === null) throw new Error('Unknown script error');
+
+    const a = decompiled.findIndex((element) => {
+        if (typeof element === 'number') return false;
+        return element.equals(pubkey) || element.equals(pubkeyHash) || element.equals(pubkeyXOnly);
+    });
+
+    return a;
+}
+
+export function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean {
+    return pubkeyPositionInScript(pubkey, script) !== -1;
+}