@btc-vision/transaction 1.0.117 → 1.0.119

package/src/keypair/Address.ts

@@ -82,6 +82,14 @@ export class Address extends Uint8Array {
         return '0x' + Buffer.from(this).toString('hex');
     }
 
+    /**
+     * Converts the address to a buffer
+     * @returns {Buffer} The buffer
+     */
+    public toBuffer(): Buffer {
+        return Buffer.from(this);
+    }
+
     public equals(a: Address): boolean {
         const b = this.isP2TROnly ? this : (this.#tweakedBytes as Uint8Array);
         const c = a.isP2TROnly ? a : (a.#tweakedBytes as Uint8Array);

package/src/keypair/AddressVerificator.ts

@@ -6,8 +6,6 @@ initEccLib(ecc);
 
 export enum AddressTypes {
     P2PKH = 'P2PKH',
-    P2SH = 'P2SH',
-    P2SH_P2WPKH = 'P2SH-P2WPKH',
     P2SH_OR_P2SH_P2WPKH = 'P2SH_OR_P2SH-P2WPKH',
     P2PK = 'P2PK',
     P2TR = 'P2TR',
@@ -118,14 +116,34 @@ export class AddressVerificator {
 
                 return true;
             }
-        } catch (error) {
-            // If any error occurs (invalid public key, etc.), return false
+        } catch {
             return false;
         }
 
         return false; // Not a valid public key
     }
 
+    /**
+     * Checks if the address requires a redeem script to spend funds.
+     * @param {string} addy - The address to check.
+     * @param {Network} network - The network to validate against.
+     * @returns {boolean} - True if the address requires a redeem script, false otherwise.
+     */
+    public static requireRedeemScript(addy: string, network: Network): boolean {
+        try {
+            // First, try to decode as a Base58Check address (P2PKH, P2SH, or P2SH-P2WPKH)
+            const decodedBase58 = address.fromBase58Check(addy);
+
+            if (decodedBase58.version === network.pubKeyHash) {
+                return false;
+            }
+
+            return decodedBase58.version === network.scriptHash;
+        } catch {
+            return false;
+        }
+    }
+
     /**
      * Validates if a given Bitcoin address is of the specified type and network.
      * - P2PKH (Legacy address starting with '1' for mainnet or 'm/n' for testnet)
@@ -139,7 +157,7 @@ export class AddressVerificator {
      * @param network - The Bitcoin network to validate against (mainnet, testnet, etc.).
      * @returns - The type of the valid Bitcoin address, or null if invalid.
      */
-    public static validateBitcoinAddress(addy: string, network: Network): AddressTypes | null {
+    public static detectAddressType(addy: string, network: Network): AddressTypes | null {
         if (AddressVerificator.isValidPublicKey(addy, network)) {
             return AddressTypes.P2PK;
         }
@@ -156,9 +174,7 @@ export class AddressVerificator {
                 // P2SH: Could be P2SH (general) or P2SH-P2WPKH (wrapped SegWit)
                 return AddressTypes.P2SH_OR_P2SH_P2WPKH;
             }
-        } catch (error) {
-            // Ignore errors from Base58 decoding, it could be a Bech32 address
-        }
+        } catch {}
 
         try {
             // Try to decode as a Bech32 or Bech32m address (P2WPKH or P2TR)
@@ -174,10 +190,7 @@ export class AddressVerificator {
                     return AddressTypes.P2TR;
                 }
             }
-        } catch (error) {
-            console.log(error);
-            // Ignore errors from Bech32/Bech32m decoding
-        }
+        } catch {}
 
         return null; // Not a valid or recognized Bitcoin address type
     }

package/src/opnet.ts

@@ -6,6 +6,7 @@ export * from './bytecode/Compressor.js';
 /** Generators */
 export * from './generators/Generator.js';
 export * from './generators/builders/CalldataGenerator.js';
+export * from './generators/builders/LegacyCalldataGenerator.js';
 export * from './generators/builders/DeploymentGenerator.js';
 export * from './generators/builders/CustomGenerator.js';
 export * from './generators/builders/MultiSignGenerator.js';

package/src/transaction/builders/TransactionBuilder.ts

@@ -37,7 +37,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
         //opcodes.OP_VERIFY, - verify that this is not needed.
     ]);
 
-    public static readonly MINIMUM_DUST: bigint = 330n;
+    public static readonly MINIMUM_DUST: bigint = 50n;
 
     public abstract readonly type: T;
     public readonly logColor: string = '#785def';

package/src/transaction/shared/TweakedTransaction.ts

@@ -1,11 +1,16 @@
 import { Logger } from '@btc-vision/logger';
 import {
+    address as bitAddress,
+    crypto as bitCrypto,
+    getFinalScripts,
     Network,
+    opcodes,
     Payment,
     payments,
     Psbt,
     PsbtInput,
     PsbtInputExtended,
+    script,
     Signer,
     Transaction,
 } from 'bitcoinjs-lib';
@@ -14,7 +19,7 @@ import { ECPairInterface } from 'ecpair';
 import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
 import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
-import { AddressVerificator } from '../../keypair/AddressVerificator.js';
+import { AddressTypes, AddressVerificator } from '../../keypair/AddressVerificator.js';
 import { ChainId } from '../../network/ChainId.js';
 import { varuint } from 'bitcoinjs-lib/src/bufferutils.js';
 
@@ -474,6 +479,8 @@ export abstract class TweakedTransaction extends Logger {
             await Promise.all(promises);
         }
 
+        transaction.finalizeInput(0, this.customFinalizerP2SH);
+
         try {
             transaction.finalizeAllInputs();
 
@@ -536,6 +543,65 @@ export abstract class TweakedTransaction extends Logger {
         return TweakedSigner.tweakSigner(signer as unknown as ECPairInterface, settings);
     }
 
+    protected generateP2SHRedeemScript(customWitnessScript: Buffer): Buffer | undefined {
+        const p2wsh = payments.p2wsh({
+            redeem: { output: customWitnessScript },
+            network: this.network,
+        });
+
+        // Step 2: Wrap the P2WSH inside a P2SH (Pay-to-Script-Hash)
+        const p2sh = payments.p2sh({
+            redeem: p2wsh,
+            network: this.network,
+        });
+
+        return p2sh.output;
+    }
+
+    protected generateP2SHRedeemScriptLegacy(inputAddr: string):
+        | {
+              redeemScript: Buffer;
+              outputScript: Buffer;
+          }
+        | undefined {
+        const pubKeyHash = bitCrypto.hash160(this.signer.publicKey);
+        const redeemScript: Buffer = script.compile([
+            opcodes.OP_DUP,
+            opcodes.OP_HASH160,
+            pubKeyHash,
+            opcodes.OP_EQUALVERIFY,
+            opcodes.OP_CHECKSIG,
+        ]);
+
+        const redeemScriptHash = bitCrypto.hash160(redeemScript);
+        const outputScript = script.compile([
+            opcodes.OP_HASH160,
+            redeemScriptHash,
+            opcodes.OP_EQUAL,
+        ]);
+
+        const p2wsh = payments.p2wsh({
+            redeem: { output: redeemScript }, // Use the custom redeem script
+            network: this.network,
+        });
+
+        // Step 3: Wrap the P2WSH in a P2SH
+        const p2sh = payments.p2sh({
+            redeem: p2wsh, // The P2WSH is wrapped inside the P2SH
+            network: this.network,
+        });
+
+        const address = bitAddress.fromOutputScript(outputScript, this.network);
+        if (address === inputAddr && p2sh.redeem && p2sh.redeem.output) {
+            return {
+                redeemScript,
+                outputScript: p2sh.redeem.output,
+            };
+        }
+
+        return;
+    }
+
     /**
      * Generate the PSBT input extended
      * @param {UTXO} utxo The UTXO
@@ -547,13 +613,60 @@ export abstract class TweakedTransaction extends Logger {
         const input: PsbtInputExtended = {
             hash: utxo.transactionId,
             index: utxo.outputIndex,
+            sequence: this.sequence,
             witnessUtxo: {
                 value: Number(utxo.value),
                 script: Buffer.from(utxo.scriptPubKey.hex, 'hex'),
             },
-            sequence: this.sequence,
         };
 
+        if (utxo.scriptPubKey.address) {
+            // auto detect for potential p2sh utxos
+            try {
+                const addressType: AddressTypes | null = AddressVerificator.detectAddressType(
+                    utxo.scriptPubKey.address,
+                    this.network,
+                );
+
+                if (addressType === AddressTypes.P2SH_OR_P2SH_P2WPKH) {
+                    // We can automatically reconstruct the redeem script.
+                    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;
+                }
+            } catch (e) {
+                this.error(`Failed to detect address type for ${utxo.scriptPubKey.address} - ${e}`);
+            }
+        }
+
+        // LEGACY P2SH SUPPORT
+        if (utxo.nonWitnessUtxo) {
+            input.nonWitnessUtxo = Buffer.isBuffer(utxo.nonWitnessUtxo)
+                ? utxo.nonWitnessUtxo
+                : Buffer.from(utxo.nonWitnessUtxo, 'hex');
+        }
+
+        // SEGWIT SUPPORT
+        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');
+            }
+        }
+
+        // TAPROOT.
         if (this.sighashTypes) {
             const inputSign = TweakedTransaction.calculateSignHash(this.sighashTypes);
             if (inputSign) input.sighashType = inputSign;
@@ -580,4 +693,46 @@ export abstract class TweakedTransaction extends Logger {
 
         return input;
     }
+
+    protected customFinalizerP2SH = (
+        inputIndex: number, // Which input is it?
+        input: PsbtInput, // The PSBT input contents
+        scriptA: Buffer, // The "meaningful" locking script Buffer (redeemScript for P2SH etc.)
+        isSegwit: boolean, // Is it segwit?
+        isP2SH: boolean, // Is it P2SH?
+        isP2WSH: boolean,
+    ): {
+        finalScriptSig: Buffer | undefined;
+        finalScriptWitness: Buffer | undefined;
+    } => {
+        const inputDecoded = this.inputs[inputIndex];
+        if (isP2SH && input.partialSig && inputDecoded && inputDecoded.redeemScript) {
+            const signatures = input.partialSig.map((sig) => sig.signature);
+
+            /*const fakeSignature = Buffer.from([
+                0x30,
+                0x45, // DER prefix: 0x30 (Compound), 0x45 (length = 69 bytes)
+                0x02,
+                0x20, // Integer marker: 0x02 (integer), 0x20 (length = 32 bytes)
+                ...Buffer.alloc(32, 0x00), // 32-byte fake 'r' value (all zeros)
+                0x02,
+                0x21, // Integer marker: 0x02 (integer), 0x21 (length = 33 bytes)
+                ...Buffer.alloc(33, 0x00), // 33-byte fake 's' value (all zeros)
+                0x01, // SIGHASH_ALL flag (0x01)
+            ]);*/
+
+            const scriptSig = script.compile([
+                ...signatures,
+                //fakeSignature,
+                inputDecoded.redeemScript,
+            ]);
+
+            return {
+                finalScriptSig: scriptSig, // Manually set the final scriptSig
+                finalScriptWitness: undefined, // Manually set the final scriptWitness
+            };
+        }
+
+        return getFinalScripts(inputIndex, input, scriptA, isSegwit, isP2SH, isP2WSH);
+    };
 }

package/src/utxo/interfaces/IUTXO.ts

@@ -5,6 +5,9 @@ export interface UTXO {
     readonly outputIndex: number;
     readonly value: bigint;
     readonly scriptPubKey: ScriptPubKey;
+    redeemScript?: string | Buffer;
+    witnessScript?: string | Buffer;
+    nonWitnessUtxo?: string | Buffer;
 }
 
 export interface FetchUTXOParams {