@btc-vision/transaction 1.0.118 → 1.0.119

package/browser/keypair/Address.d.ts

@@ -11,6 +11,7 @@ export declare class Address extends Uint8Array {
     static fromString(pubKey: string): Address;
     static wrap(bytes: ArrayLike<number>): Address;
     toHex(): string;
+    toBuffer(): Buffer;
     equals(a: Address): boolean;
     lessThan(a: Address): boolean;
     greaterThan(a: Address): boolean;

package/browser/keypair/AddressVerificator.d.ts

@@ -1,8 +1,6 @@
 import { Network } from 'bitcoinjs-lib';
 export declare enum AddressTypes {
     P2PKH = "P2PKH",
-    P2SH = "P2SH",
-    P2SH_P2WPKH = "P2SH-P2WPKH",
     P2SH_OR_P2SH_P2WPKH = "P2SH_OR_P2SH-P2WPKH",
     P2PK = "P2PK",
     P2TR = "P2TR",
@@ -13,5 +11,6 @@ export declare class AddressVerificator {
     static isP2WPKHAddress(inAddress: string, network: Network): boolean;
     static isP2PKHOrP2SH(addy: string, network: Network): boolean;
     static isValidPublicKey(input: string, network: Network): boolean;
-    static validateBitcoinAddress(addy: string, network: Network): AddressTypes | null;
+    static requireRedeemScript(addy: string, network: Network): boolean;
+    static detectAddressType(addy: string, network: Network): AddressTypes | null;
 }

package/browser/opnet.d.ts

@@ -2,6 +2,7 @@ export { version } from './_version.js';
 export * from './bytecode/Compressor.js';
 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/browser/transaction/shared/TweakedTransaction.d.ts

@@ -54,5 +54,14 @@ export declare abstract class TweakedTransaction extends Logger {
     protected internalInit(): void;
     protected tweakSigner(): void;
     protected getTweakedSigner(useTweakedHash?: boolean, signer?: Signer | ECPairInterface): ECPairInterface | undefined;
+    protected generateP2SHRedeemScript(customWitnessScript: Buffer): Buffer | undefined;
+    protected generateP2SHRedeemScriptLegacy(inputAddr: string): {
+        redeemScript: Buffer;
+        outputScript: Buffer;
+    } | undefined;
     protected generatePsbtInputExtended(utxo: UTXO, i: number): PsbtInputExtended;
+    protected customFinalizerP2SH: (inputIndex: number, input: PsbtInput, scriptA: Buffer, isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean) => {
+        finalScriptSig: Buffer | undefined;
+        finalScriptWitness: Buffer | undefined;
+    };
 }

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

@@ -4,6 +4,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 {
     readonly address: string;

package/build/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.0.118";
+export declare const version = "1.0.119";

package/build/_version.js

@@ -1 +1 @@
-export const version = '1.0.118';
+export const version = '1.0.119';

package/build/event/NetEvent.d.ts

@@ -1,5 +1,5 @@
 export declare class NetEvent {
-    readonly eventType: string;
-    readonly eventData: Uint8Array;
-    constructor(eventType: string, eventData: Uint8Array);
+    readonly type: string;
+    readonly data: Uint8Array;
+    constructor(type: string, data: Uint8Array);
 }

package/build/event/NetEvent.js

@@ -1,6 +1,6 @@
 export class NetEvent {
-    constructor(eventType, eventData) {
-        this.eventType = eventType;
-        this.eventData = eventData;
+    constructor(type, data) {
+        this.type = type;
+        this.data = data;
     }
 }

package/build/generators/builders/LegacyCalldataGenerator.d.ts

@@ -0,0 +1,8 @@
+import { Network } from 'bitcoinjs-lib';
+import { Features } from '../Features.js';
+import { Generator } from '../Generator.js';
+export declare class LegacyCalldataGenerator extends Generator {
+    constructor(senderPubKey: Buffer, network?: Network);
+    static getPubKeyAsBuffer(witnessKeys: Buffer[], network: Network): Buffer;
+    compile(calldata: Buffer, contractSecret: Buffer, features?: Features[], vaultPublicKeys?: Buffer[], minimumSignatures?: number): Buffer;
+}

package/build/generators/builders/LegacyCalldataGenerator.js

@@ -0,0 +1,75 @@
+import { networks, opcodes, script } from 'bitcoinjs-lib';
+import { Compressor } from '../../bytecode/Compressor.js';
+import { EcKeyPair } from '../../keypair/EcKeyPair.js';
+import { FeatureOpCodes } from '../Features.js';
+import { Generator } from '../Generator.js';
+export class LegacyCalldataGenerator extends Generator {
+    constructor(senderPubKey, network = networks.bitcoin) {
+        super(senderPubKey, Buffer.alloc(0), network);
+    }
+    static getPubKeyAsBuffer(witnessKeys, network) {
+        let finalBuffer = Buffer.alloc(0);
+        for (const pubKey of witnessKeys) {
+            const key = EcKeyPair.fromPublicKey(pubKey, network);
+            if (!key.compressed) {
+                throw new Error('Public key must be compressed');
+            }
+            if (pubKey.byteLength !== 33) {
+                throw new Error(`Public key must be 33 bytes, got ${pubKey.byteLength} bytes.`);
+            }
+            finalBuffer = Buffer.concat([finalBuffer, pubKey]);
+        }
+        const compressed = Compressor.compress(finalBuffer);
+        if (compressed.byteLength >= finalBuffer.byteLength) {
+            return finalBuffer;
+        }
+        return compressed;
+    }
+    compile(calldata, contractSecret, features = [], vaultPublicKeys = [], minimumSignatures = 0) {
+        const dataChunks = this.splitBufferIntoChunks(calldata);
+        if (!dataChunks.length)
+            throw new Error('No data chunks found');
+        let compiledData = [
+            this.senderPubKey,
+            opcodes.OP_CHECKSIGVERIFY,
+            contractSecret,
+            opcodes.OP_TOALTSTACK,
+            opcodes.OP_DEPTH,
+            opcodes.OP_1,
+            opcodes.OP_NUMEQUAL,
+            opcodes.OP_IF,
+            Generator.MAGIC,
+        ];
+        if (vaultPublicKeys.length > 0) {
+            const pubKeyBuffer = LegacyCalldataGenerator.getPubKeyAsBuffer(vaultPublicKeys, this.network);
+            const pubKeyDataChunks = this.splitBufferIntoChunks(pubKeyBuffer);
+            compiledData = compiledData.concat(...[
+                opcodes.OP_0,
+                ...pubKeyDataChunks,
+            ]);
+            if (minimumSignatures) {
+                if (minimumSignatures > 255) {
+                    throw new Error('Minimum signatures cannot exceed 255');
+                }
+                const minSigBuffer = Buffer.alloc(2);
+                minSigBuffer.writeUint16LE(minimumSignatures, 0);
+                compiledData = compiledData.concat(...[
+                    opcodes.OP_1,
+                    minSigBuffer,
+                ]);
+            }
+            else {
+                throw new Error('Minimum signatures must be provided');
+            }
+        }
+        const featureOpcodes = features.map((feature) => FeatureOpCodes[feature]);
+        compiledData = compiledData.concat(...featureOpcodes, ...[opcodes.OP_1NEGATE, ...dataChunks, opcodes.OP_ELSE, opcodes.OP_1, opcodes.OP_ENDIF]);
+        const asm = compiledData.flat();
+        const compiled = script.compile(asm);
+        const decompiled = script.decompile(compiled);
+        if (!decompiled) {
+            throw new Error('Failed to decompile script??');
+        }
+        return compiled;
+    }
+}

package/build/keypair/Address.d.ts

@@ -11,6 +11,7 @@ export declare class Address extends Uint8Array {
     static fromString(pubKey: string): Address;
     static wrap(bytes: ArrayLike<number>): Address;
     toHex(): string;
+    toBuffer(): Buffer;
     equals(a: Address): boolean;
     lessThan(a: Address): boolean;
     greaterThan(a: Address): boolean;

package/build/keypair/Address.js

@@ -53,6 +53,9 @@ export class Address extends Uint8Array {
     toHex() {
         return '0x' + Buffer.from(this).toString('hex');
     }
+    toBuffer() {
+        return Buffer.from(this);
+    }
     equals(a) {
         const b = this.isP2TROnly ? this : __classPrivateFieldGet(this, _Address_tweakedBytes, "f");
         const c = a.isP2TROnly ? a : __classPrivateFieldGet(a, _Address_tweakedBytes, "f");

package/build/keypair/AddressVerificator.d.ts

@@ -1,8 +1,6 @@
 import { Network } from 'bitcoinjs-lib';
 export declare enum AddressTypes {
     P2PKH = "P2PKH",
-    P2SH = "P2SH",
-    P2SH_P2WPKH = "P2SH-P2WPKH",
     P2SH_OR_P2SH_P2WPKH = "P2SH_OR_P2SH-P2WPKH",
     P2PK = "P2PK",
     P2TR = "P2TR",
@@ -13,5 +11,6 @@ export declare class AddressVerificator {
     static isP2WPKHAddress(inAddress: string, network: Network): boolean;
     static isP2PKHOrP2SH(addy: string, network: Network): boolean;
     static isValidPublicKey(input: string, network: Network): boolean;
-    static validateBitcoinAddress(addy: string, network: Network): AddressTypes | null;
+    static requireRedeemScript(addy: string, network: Network): boolean;
+    static detectAddressType(addy: string, network: Network): AddressTypes | null;
 }

package/build/keypair/AddressVerificator.js

@@ -5,8 +5,6 @@ initEccLib(ecc);
 export var AddressTypes;
 (function (AddressTypes) {
     AddressTypes["P2PKH"] = "P2PKH";
-    AddressTypes["P2SH"] = "P2SH";
-    AddressTypes["P2SH_P2WPKH"] = "P2SH-P2WPKH";
     AddressTypes["P2SH_OR_P2SH_P2WPKH"] = "P2SH_OR_P2SH-P2WPKH";
     AddressTypes["P2PK"] = "P2PK";
     AddressTypes["P2TR"] = "P2TR";
@@ -73,7 +71,19 @@ export class AddressVerificator {
         }
         return false;
     }
-    static validateBitcoinAddress(addy, network) {
+    static requireRedeemScript(addy, network) {
+        try {
+            const decodedBase58 = address.fromBase58Check(addy);
+            if (decodedBase58.version === network.pubKeyHash) {
+                return false;
+            }
+            return decodedBase58.version === network.scriptHash;
+        }
+        catch {
+            return false;
+        }
+    }
+    static detectAddressType(addy, network) {
         if (AddressVerificator.isValidPublicKey(addy, network)) {
             return AddressTypes.P2PK;
         }

package/build/opnet.d.ts

@@ -2,6 +2,7 @@ export { version } from './_version.js';
 export * from './bytecode/Compressor.js';
 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/build/opnet.js

@@ -2,6 +2,7 @@ export { version } from './_version.js';
 export * from './bytecode/Compressor.js';
 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/build/transaction/builders/TransactionBuilder.js

@@ -343,4 +343,4 @@ export class TransactionBuilder extends TweakedTransaction {
 TransactionBuilder.LOCK_LEAF_SCRIPT = script.compile([
     opcodes.OP_0,
 ]);
-TransactionBuilder.MINIMUM_DUST = 330n;
+TransactionBuilder.MINIMUM_DUST = 50n;

package/build/transaction/shared/TweakedTransaction.d.ts

@@ -54,5 +54,14 @@ export declare abstract class TweakedTransaction extends Logger {
     protected internalInit(): void;
     protected tweakSigner(): void;
     protected getTweakedSigner(useTweakedHash?: boolean, signer?: Signer | ECPairInterface): ECPairInterface | undefined;
+    protected generateP2SHRedeemScript(customWitnessScript: Buffer): Buffer | undefined;
+    protected generateP2SHRedeemScriptLegacy(inputAddr: string): {
+        redeemScript: Buffer;
+        outputScript: Buffer;
+    } | undefined;
     protected generatePsbtInputExtended(utxo: UTXO, i: number): PsbtInputExtended;
+    protected customFinalizerP2SH: (inputIndex: number, input: PsbtInput, scriptA: Buffer, isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean) => {
+        finalScriptSig: Buffer | undefined;
+        finalScriptWitness: Buffer | undefined;
+    };
 }

package/build/transaction/shared/TweakedTransaction.js

@@ -1,8 +1,8 @@
 import { Logger } from '@btc-vision/logger';
-import { payments, } from 'bitcoinjs-lib';
+import { address as bitAddress, crypto as bitCrypto, getFinalScripts, opcodes, payments, script, } from 'bitcoinjs-lib';
 import { TweakedSigner } from '../../signer/TweakedSigner.js';
 import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
-import { AddressVerificator } from '../../keypair/AddressVerificator.js';
+import { AddressTypes, AddressVerificator } from '../../keypair/AddressVerificator.js';
 import { varuint } from 'bitcoinjs-lib/src/bufferutils.js';
 export var TransactionSequence;
 (function (TransactionSequence) {
@@ -23,6 +23,21 @@ export class TweakedTransaction extends Logger {
         this.isBrowser = false;
         this.regenerated = false;
         this.ignoreSignatureErrors = false;
+        this.customFinalizerP2SH = (inputIndex, input, scriptA, isSegwit, isP2SH, isP2WSH) => {
+            const inputDecoded = this.inputs[inputIndex];
+            if (isP2SH && input.partialSig && inputDecoded && inputDecoded.redeemScript) {
+                const signatures = input.partialSig.map((sig) => sig.signature);
+                const scriptSig = script.compile([
+                    ...signatures,
+                    inputDecoded.redeemScript,
+                ]);
+                return {
+                    finalScriptSig: scriptSig,
+                    finalScriptWitness: undefined,
+                };
+            }
+            return getFinalScripts(inputIndex, input, scriptA, isSegwit, isP2SH, isP2WSH);
+        };
         this.signer = data.signer;
         this.network = data.network;
         this.nonWitnessUtxo = data.nonWitnessUtxo;
@@ -223,6 +238,7 @@ export class TweakedTransaction extends Logger {
             }
             await Promise.all(promises);
         }
+        transaction.finalizeInput(0, this.customFinalizerP2SH);
         try {
             transaction.finalizeAllInputs();
             this.finalized = true;
@@ -255,16 +271,90 @@ export class TweakedTransaction extends Logger {
         }
         return TweakedSigner.tweakSigner(signer, settings);
     }
+    generateP2SHRedeemScript(customWitnessScript) {
+        const p2wsh = payments.p2wsh({
+            redeem: { output: customWitnessScript },
+            network: this.network,
+        });
+        const p2sh = payments.p2sh({
+            redeem: p2wsh,
+            network: this.network,
+        });
+        return p2sh.output;
+    }
+    generateP2SHRedeemScriptLegacy(inputAddr) {
+        const pubKeyHash = bitCrypto.hash160(this.signer.publicKey);
+        const redeemScript = 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 },
+            network: this.network,
+        });
+        const p2sh = payments.p2sh({
+            redeem: p2wsh,
+            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;
+    }
     generatePsbtInputExtended(utxo, i) {
         const input = {
             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) {
+            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;
+                }
+            }
+            catch (e) {
+                this.error(`Failed to detect address type for ${utxo.scriptPubKey.address} - ${e}`);
+            }
+        }
+        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');
+            }
+        }
         if (this.sighashTypes) {
             const inputSign = TweakedTransaction.calculateSignHash(this.sighashTypes);
             if (inputSign)

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

@@ -4,6 +4,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 {
     readonly address: string;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.0.118",
+    "version": "1.0.119",
     "author": "BlobMaster41",
     "description": "OPNet transaction library allows you to create and sign transactions for the OPNet network.",
     "engines": {

package/src/_version.ts

@@ -1 +1 @@
-export const version = '1.0.118';
+export const version = '1.0.119';

package/src/event/NetEvent.ts

@@ -1,6 +1,6 @@
 export class NetEvent {
     public constructor(
-        public readonly eventType: string,
-        public readonly eventData: Uint8Array,
+        public readonly type: string,
+        public readonly data: Uint8Array,
     ) {}
 }

package/src/generators/builders/LegacyCalldataGenerator.ts

@@ -0,0 +1,141 @@
+import { Network, networks, opcodes, script } from 'bitcoinjs-lib';
+import { ECPairInterface } from 'ecpair';
+import { Compressor } from '../../bytecode/Compressor.js';
+import { EcKeyPair } from '../../keypair/EcKeyPair.js';
+import { FeatureOpCodes, Features } from '../Features.js';
+import { Generator } from '../Generator.js';
+
+/**
+ * Class to generate bitcoin script for interaction transactions
+ */
+export class LegacyCalldataGenerator extends Generator {
+    constructor(senderPubKey: Buffer, network: Network = networks.bitcoin) {
+        super(senderPubKey, Buffer.alloc(0), network);
+    }
+
+    /**
+     * Get the public key as a buffer
+     * @param {Buffer[]} witnessKeys - The public keys
+     * @param {Network} network - The network to use
+     * @private
+     * @returns {Buffer} - The public key as a buffer
+     */
+    public static getPubKeyAsBuffer(witnessKeys: Buffer[], network: Network): Buffer {
+        let finalBuffer: Buffer = Buffer.alloc(0);
+
+        for (const pubKey of witnessKeys) {
+            const key: ECPairInterface = EcKeyPair.fromPublicKey(pubKey, network);
+
+            if (!key.compressed) {
+                throw new Error('Public key must be compressed');
+            }
+
+            if (pubKey.byteLength !== 33) {
+                throw new Error(`Public key must be 33 bytes, got ${pubKey.byteLength} bytes.`);
+            }
+
+            finalBuffer = Buffer.concat([finalBuffer, pubKey]);
+        }
+
+        // compress the public keys
+        const compressed: Buffer = Compressor.compress(finalBuffer);
+        if (compressed.byteLength >= finalBuffer.byteLength) {
+            // we ensure that the user pays the smallest amount of fees. [micro-optimization]
+            return finalBuffer;
+        }
+
+        // if compressed is smaller, return compressed.
+        return compressed;
+    }
+
+    /**
+     * Compile an interaction bitcoin script
+     * @param {Buffer} calldata - The calldata to use
+     * @param {Buffer} contractSecret - The contract secret
+     * @param {number[]} [features=[]] - The features to use (optional)
+     * @param {Buffer[]} [vaultPublicKeys=[]] - The public keys of the vault (optional)
+     * @param {number} [minimumSignatures=0] - The minimum number of signatures (optional)
+     * @returns {Buffer} - The compiled script
+     * @throws {Error} - If something goes wrong
+     */
+    public compile(
+        calldata: Buffer,
+        contractSecret: Buffer,
+        features: Features[] = [],
+        vaultPublicKeys: Buffer[] = [],
+        minimumSignatures: number = 0,
+    ): Buffer {
+        const dataChunks: Buffer[][] = this.splitBufferIntoChunks(calldata);
+        if (!dataChunks.length) throw new Error('No data chunks found');
+
+        let compiledData = [
+            this.senderPubKey,
+            opcodes.OP_CHECKSIGVERIFY,
+
+            contractSecret,
+            opcodes.OP_TOALTSTACK,
+
+            opcodes.OP_DEPTH,
+            opcodes.OP_1,
+            opcodes.OP_NUMEQUAL,
+            opcodes.OP_IF,
+
+            Generator.MAGIC,
+        ];
+
+        // write pub keys, when requested.
+        if (vaultPublicKeys.length > 0) {
+            const pubKeyBuffer = LegacyCalldataGenerator.getPubKeyAsBuffer(
+                vaultPublicKeys,
+                this.network,
+            );
+            const pubKeyDataChunks: Buffer[][] = this.splitBufferIntoChunks(pubKeyBuffer);
+
+            compiledData = compiledData.concat(
+                ...[
+                    opcodes.OP_0, // provide opnet public keys
+                    ...pubKeyDataChunks,
+                ],
+            );
+
+            if (minimumSignatures) {
+                // verify that the minimum is not greater than 255
+                if (minimumSignatures > 255) {
+                    throw new Error('Minimum signatures cannot exceed 255');
+                }
+
+                // we use a 2 bytes buffer even if we limit to 255 so it does not use an opcode for the number
+                const minSigBuffer = Buffer.alloc(2);
+                minSigBuffer.writeUint16LE(minimumSignatures, 0);
+
+                compiledData = compiledData.concat(
+                    ...[
+                        opcodes.OP_1, // provide minimum signatures
+                        minSigBuffer,
+                    ],
+                );
+            } else {
+                throw new Error('Minimum signatures must be provided');
+            }
+        }
+
+        const featureOpcodes = features.map((feature) => FeatureOpCodes[feature]); // Get the opcodes for the features
+
+        // Write calldata
+        compiledData = compiledData.concat(
+            ...featureOpcodes,
+            ...[opcodes.OP_1NEGATE, ...dataChunks, opcodes.OP_ELSE, opcodes.OP_1, opcodes.OP_ENDIF],
+        );
+
+        const asm = compiledData.flat();
+        const compiled = script.compile(asm);
+
+        /** Verify the validity of the script */
+        const decompiled = script.decompile(compiled);
+        if (!decompiled) {
+            throw new Error('Failed to decompile script??');
+        }
+
+        return compiled;
+    }
+}

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',
@@ -125,6 +123,27 @@ export class AddressVerificator {
         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)
@@ -138,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;
         }