@btc-vision/transaction 1.5.3 → 1.6.0

package/src/keypair/EcKeyPair.ts

@@ -26,9 +26,8 @@ if (!BIP32factory) {
     throw new Error('Failed to load BIP32 library');
 }
 
-secp256k1.utils.precompute(8);
-
-const { ProjectivePoint: Point, CURVE } = secp256k1;
+const Point = secp256k1.Point;
+const CURVE_N = Point.Fn.ORDER;
 
 const TAP_TAG = utf8ToBytes('TapTweak');
 const TAP_TAG_HASH = sha256(TAP_TAG);
@@ -48,6 +47,12 @@ export class EcKeyPair {
     public static BIP32: BIP32API = BIP32factory(ecc);
     public static ECPair: ECPairAPI = ECPairFactory(ecc);
 
+    // Initialize precomputation for better performance
+    static {
+        // Precompute tables for the base point for better performance
+        Point.BASE.precompute(8);
+    }
+
     /**
      * Generate a keypair from a WIF
      * @param {string} wif - The WIF to use
@@ -272,12 +277,12 @@ export class EcKeyPair {
         const P = Point.fromHex(pub);
         const Peven = (P.y & 1n) === 0n ? P : P.negate();
 
-        const xBytes = Peven.toRawBytes(true).subarray(1);
+        const xBytes = Peven.toBytes(true).subarray(1);
         const tBytes = tapTweakHash(xBytes);
-        const t = mod(bytesToNumberBE(tBytes), CURVE.n);
+        const t = mod(bytesToNumberBE(tBytes), CURVE_N);
 
         const Q = Peven.add(Point.BASE.multiply(t));
-        return Buffer.from(Q.toRawBytes(true));
+        return Buffer.from(Q.toBytes(true));
     }
 
     /**
@@ -294,9 +299,9 @@ export class EcKeyPair {
 
         return pubkeys.map((bytes) => {
             const P = Point.fromHex(bytes);
-            const P_even = P.hasEvenY() ? P : P.negate();
+            const P_even = P.y % 2n === 0n ? P : P.negate();
             const Q = P_even.add(T);
-            return Q.toRawBytes(true);
+            return Q.toBytes(true);
         });
     }
 

package/src/opnet.ts

@@ -10,12 +10,11 @@ export * from './generators/builders/CalldataGenerator.js';
 export * from './generators/builders/CustomGenerator.js';
 export * from './generators/builders/DeploymentGenerator.js';
 export * from './generators/builders/LegacyCalldataGenerator.js';
-export * from './generators/builders/MineableReward.js';
 export * from './generators/builders/MultiSignGenerator.js';
 export * from './generators/Features.js';
 export * from './generators/Generator.js';
 
-export * from './transaction/mineable/ChallengeGenerator.js';
+export * from './transaction/mineable/TimelockGenerator.js';
 
 /** Address */
 export * from './generators/AddressGenerator.js';
@@ -42,7 +41,6 @@ export * from './transaction/interfaces/Tap.js';
 export * from './transaction/TransactionFactory.js';
 
 /** Builders */
-export * from './transaction/builders/ChallengeSolutionTransaction.js';
 export * from './transaction/builders/CustomScriptTransaction.js';
 export * from './transaction/builders/DeploymentTransaction.js';
 export * from './transaction/builders/FundingTransaction.js';
@@ -51,6 +49,11 @@ export * from './transaction/builders/MultiSignTransaction.js';
 export * from './transaction/builders/SharedInteractionTransaction.js';
 export * from './transaction/builders/TransactionBuilder.js';
 
+/** Epoch */
+export * from './epoch/interfaces/IChallengeSolution.js';
+export * from './epoch/validator/EpochValidator.js';
+export * from './epoch/ChallengeSolution.js';
+
 /** Utils */
 export * from './utils/BitcoinUtils.js';
 export * from './utils/lengths.js';

package/src/transaction/TransactionFactory.ts

@@ -11,26 +11,25 @@ import { InteractionTransaction } from './builders/InteractionTransaction.js';
 import { TransactionBuilder } from './builders/TransactionBuilder.js';
 import { TransactionType } from './enums/TransactionType.js';
 import {
-    IChallengeSolutionTransactionParameters,
     IDeploymentParameters,
     IFundingTransactionParameters,
     IInteractionParameters,
     ITransactionParameters,
 } from './interfaces/ITransactionParameters.js';
 import { PSBTTypes } from './psbt/PSBTTypes.js';
-import { ChallengeSolutionTransaction } from './builders/ChallengeSolutionTransaction.js';
 import {
     IDeploymentParametersWithoutSigner,
     InteractionParametersWithoutSigner,
 } from './browser/Web3Provider.js';
 import { WindowWithWallets } from './browser/extensions/UnisatSigner.js';
+import { RawChallenge } from '../epoch/interfaces/IChallengeSolution.js';
 
 export interface DeploymentResult {
     readonly transaction: [string, string];
 
     readonly contractAddress: string;
     readonly contractPubKey: string;
-    readonly preimage: string;
+    readonly preimage: RawChallenge;
 
     readonly utxos: UTXO[];
 }
@@ -42,13 +41,6 @@ export interface FundingTransactionResponse {
     readonly nextUTXOs: UTXO[];
 }
 
-export interface ChallengeSolutionResponse {
-    readonly tx: Transaction;
-    readonly original: ChallengeSolutionTransaction;
-    readonly estimatedFees: bigint;
-    readonly nextUTXOs: UTXO[];
-}
-
 export interface BitcoinTransferBase {
     readonly tx: string;
     readonly estimatedFees: bigint;
@@ -60,11 +52,7 @@ export interface InteractionResponse {
     readonly interactionTransaction: string;
     readonly estimatedFees: bigint;
     readonly nextUTXOs: UTXO[];
-    readonly preimage: string;
-}
-
-export interface ChallengeSolution extends BitcoinTransferBase {
-    readonly original: ChallengeSolutionTransaction;
+    readonly preimage: RawChallenge;
 }
 
 export interface BitcoinTransferResponse extends BitcoinTransferBase {
@@ -246,7 +234,7 @@ export class TransactionFactory {
                 ...this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.to, 0),
             ], // always 0
             randomBytes: preTransaction.getRndBytes(),
-            preimage: preTransaction.getPreimage(),
+            challenge: preTransaction.getPreimage(),
             nonWitnessUtxo: signedTransaction.tx.toBuffer(),
             estimatedFees: preTransaction.estimatedFees,
             optionalInputs: inputs,
@@ -265,7 +253,7 @@ export class TransactionFactory {
                 interactionParameters.from,
                 1,
             ), // always 1
-            preimage: preTransaction.getPreimage().toString('hex'),
+            preimage: preTransaction.getPreimage().toRaw(),
         };
     }
 
@@ -343,7 +331,7 @@ export class TransactionFactory {
             ...deploymentParameters,
             utxos: [newUtxo], // always 0
             randomBytes: preTransaction.getRndBytes(),
-            preimage: preTransaction.getPreimage(),
+            challenge: preTransaction.getPreimage(),
             nonWitnessUtxo: signedTransaction.toBuffer(),
             estimatedFees: preTransaction.estimatedFees,
             optionalInputs: inputs,
@@ -370,7 +358,7 @@ export class TransactionFactory {
             contractAddress: finalTransaction.getContractAddress(), //finalTransaction.contractAddress.p2tr(deploymentParameters.network),
             contractPubKey: finalTransaction.contractPubKey,
             utxos: [refundUTXO],
-            preimage: preTransaction.getPreimage().toString('hex'),
+            preimage: preTransaction.getPreimage().toRaw(),
         };
     }
 
@@ -395,27 +383,6 @@ export class TransactionFactory {
         };
     }
 
-    /**
-     * @description Creates a challenge solution transaction.
-     * @param {IChallengeSolutionTransactionParameters} parameters - The challenge solution transaction parameters
-     * @returns {Promise<ChallengeSolution>} - The signed transaction
-     */
-    public async createChallengeSolution(
-        parameters: IChallengeSolutionTransactionParameters,
-    ): Promise<ChallengeSolution> {
-        if (!parameters.from) {
-            throw new Error('Field "from" not provided.');
-        }
-
-        const resp = await this._createChallengeSolution(parameters);
-        return {
-            estimatedFees: resp.estimatedFees,
-            original: resp.original,
-            tx: resp.tx.toHex(),
-            nextUTXOs: this.getAllNewUTXOs(resp.original, resp.tx, parameters.from),
-        };
-    }
-
     /**
      * Get all new UTXOs of a generated transaction.
      * @param {TransactionBuilder<TransactionType>} original - The original transaction
@@ -520,28 +487,6 @@ export class TransactionFactory {
         return deployment;
     }
 
-    private async _createChallengeSolution(
-        parameters: IChallengeSolutionTransactionParameters,
-    ): Promise<ChallengeSolutionResponse> {
-        if (!parameters.to) throw new Error('Field "to" not provided.');
-
-        const challengeTransaction: ChallengeSolutionTransaction = new ChallengeSolutionTransaction(
-            parameters,
-        );
-
-        const signedTransaction: Transaction = await challengeTransaction.signTransaction();
-        if (!signedTransaction) {
-            throw new Error('Could not sign funding transaction.');
-        }
-
-        return {
-            tx: signedTransaction,
-            original: challengeTransaction,
-            estimatedFees: challengeTransaction.estimatedFees,
-            nextUTXOs: this.getUTXOAsTransaction(signedTransaction, parameters.to, 0),
-        };
-    }
-
     private async createFundTransaction(
         parameters: IFundingTransactionParameters,
     ): Promise<FundingTransactionResponse> {

package/src/transaction/browser/Web3Provider.ts

@@ -8,17 +8,17 @@ import { ICustomTransactionParameters } from '../builders/CustomScriptTransactio
 
 export type InteractionParametersWithoutSigner = Omit<
     IInteractionParameters,
-    'signer' | 'preimage'
+    'signer' | 'challenge'
 >;
 
 export type IDeploymentParametersWithoutSigner = Omit<
     IDeploymentParameters,
-    'signer' | 'network' | 'preimage'
+    'signer' | 'network' | 'challenge'
 >;
 
 export type CustomTransactionWithoutSigner = Omit<
     ICustomTransactionParameters,
-    'signer' | 'preimage'
+    'signer' | 'challenge'
 >;
 
 export interface BroadcastTransactionOptions {

package/src/transaction/browser/types/Unisat.ts

@@ -85,7 +85,7 @@ export interface Unisat {
 
     getBalance(): Promise<Balance>;
 
-    signMessage(message: string, type?: MessageType): Promise<string>;
+    signMessage(message: string | Buffer, type?: MessageType): Promise<string>;
 
     signData(hex: string, type?: SignatureType): Promise<string>;
 

package/src/transaction/builders/ChallengeSolutionTransaction.ts

@@ -1,5 +1,4 @@
-import { TransactionType } from '../enums/TransactionType.js';
-import { IChallengeSolutionTransactionParameters } from '../interfaces/ITransactionParameters.js';
+/*import { TransactionType } from '../enums/TransactionType.js';
 import { getFinalScripts, opcodes, Psbt, PsbtInput, script, Signer } from '@btc-vision/bitcoin';
 import { TransactionBuilder } from './TransactionBuilder.js';
 import { ECPairInterface } from 'ecpair';
@@ -69,7 +68,7 @@ export class ChallengeSolutionTransaction extends TransactionBuilder<Transaction
         finalScriptWitness: Buffer | undefined;
     } => {
         const inputDecoded = this.inputs[inputIndex];
-        
+
         if (isP2SH && inputDecoded && inputDecoded.redeemScript) {
             const scriptSig = script.compile([this.challengeSolution, inputDecoded.redeemScript]);
 
@@ -85,4 +84,4 @@ export class ChallengeSolutionTransaction extends TransactionBuilder<Transaction
     protected override getSignerKey(): Signer | ECPairInterface {
         return this.signer;
     }
-}
+}*/

package/src/transaction/builders/CustomScriptTransaction.ts

@@ -20,7 +20,8 @@ import { EcKeyPair } from '../../keypair/EcKeyPair.js';
 import { AddressGenerator } from '../../generators/AddressGenerator.js';
 import { ECPairInterface } from 'ecpair';
 
-export interface ICustomTransactionParameters extends SharedInteractionParameters {
+export interface ICustomTransactionParameters
+    extends Omit<SharedInteractionParameters, 'challenge'> {
     script: (Buffer | Stack)[];
     witnesses: Buffer[];
 

package/src/transaction/builders/DeploymentTransaction.ts

@@ -27,15 +27,18 @@ import { SharedInteractionTransaction } from './SharedInteractionTransaction.js'
 import { ECPairInterface } from 'ecpair';
 import { Address } from '../../keypair/Address.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
-import { ChallengeGenerator, IMineableReward } from '../mineable/ChallengeGenerator.js';
+import { ITimeLockOutput, TimeLockGenerator } from '../mineable/TimelockGenerator.js';
+import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';
+import { Feature, Features } from '../../generators/Features.js';
 
 export class DeploymentTransaction extends TransactionBuilder<TransactionType.DEPLOYMENT> {
     public static readonly MAXIMUM_CONTRACT_SIZE = 128 * 1024;
 
     public type: TransactionType.DEPLOYMENT = TransactionType.DEPLOYMENT;
 
-    protected readonly preimage: Buffer; // ALWAYS 128 bytes for the preimage
-    protected readonly rewardChallenge: IMineableReward;
+    protected readonly preimage: ChallengeSolution;
+    protected readonly epochChallenge: ITimeLockOutput;
+
     /**
      * The contract address
      * @protected
@@ -122,13 +125,13 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
             this.verifyCalldata();
         }
 
-        if (!parameters.preimage) throw new Error('Preimage is required');
+        if (!parameters.challenge) throw new Error('Challenge solution is required');
 
         this.randomBytes = parameters.randomBytes || BitcoinUtils.rndBytes();
-        this.preimage = parameters.preimage;
+        this.preimage = parameters.challenge;
 
-        this.rewardChallenge = ChallengeGenerator.generateMineableReward(
-            this.preimage,
+        this.epochChallenge = TimeLockGenerator.generateTimeLockAddress(
+            this.preimage.publicKey.originalPublicKeyBuffer(),
             this.network,
         );
 
@@ -147,6 +150,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
             this.preimage,
             this.priorityFee,
             this.calldata,
+            this.generateFeatures(parameters),
         );
 
         this.scriptTree = this.getScriptTree();
@@ -190,7 +194,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
      * Get the contract bytecode
      * @returns {Buffer} The contract bytecode
      */
-    public getPreimage(): Buffer {
+    public getPreimage(): ChallengeSolution {
         return this.preimage;
     }
 
@@ -271,7 +275,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         ) {
             this.addOutput({
                 value: Number(amountSpent - amountToCA),
-                address: this.rewardChallenge.address,
+                address: this.epochChallenge.address,
             });
         }
 
@@ -376,6 +380,20 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         };
     }
 
+    private generateFeatures(parameters: IDeploymentParameters): Feature<Features>[] {
+        const features: Feature<Features>[] = [];
+
+        const submission = parameters.challenge.getSubmission();
+        if (submission) {
+            features.push({
+                opcode: Features.EPOCH_SUBMISSION,
+                data: submission,
+            });
+        }
+
+        return features;
+    }
+
     private verifyCalldata(): void {
         if (
             this.calldata &&

package/src/transaction/builders/InteractionTransaction.ts

@@ -31,7 +31,7 @@ export class InteractionTransaction extends SharedInteractionTransaction<Transac
         }
 
         this.contractSecret = Buffer.from(parameters.contract.replace('0x', ''), 'hex');
-        
+
         if (this.contractSecret.length !== 32) {
             throw new Error('Invalid contract secret length. Expected 32 bytes.');
         }
@@ -39,7 +39,7 @@ export class InteractionTransaction extends SharedInteractionTransaction<Transac
         this.compiledTargetScript = this.calldataGenerator.compile(
             this.calldata,
             this.contractSecret,
-            this.preimage,
+            this.challenge,
             this.priorityFee,
             this.generateFeatures(parameters),
         );
@@ -58,6 +58,14 @@ export class InteractionTransaction extends SharedInteractionTransaction<Transac
             });
         }
 
+        const submission = parameters.challenge.getSubmission();
+        if (submission) {
+            features.push({
+                opcode: Features.EPOCH_SUBMISSION,
+                data: submission,
+            });
+        }
+
         return features;
     }
 }

package/src/transaction/builders/SharedInteractionTransaction.ts

@@ -8,7 +8,8 @@ import { Compressor } from '../../bytecode/Compressor.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
 import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
-import { ChallengeGenerator, IMineableReward } from '../mineable/ChallengeGenerator.js';
+import { ITimeLockOutput, TimeLockGenerator } from '../mineable/TimelockGenerator.js';
+import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';
 
 /**
  * Shared interaction transaction
@@ -31,8 +32,8 @@ export abstract class SharedInteractionTransaction<
     protected abstract readonly compiledTargetScript: Buffer;
     protected abstract readonly scriptTree: Taptree;
 
-    protected readonly preimage: Buffer; // ALWAYS 128 bytes for the preimage
-    protected readonly rewardChallenge: IMineableReward;
+    protected readonly challenge: ChallengeSolution;
+    protected readonly epochChallenge: ITimeLockOutput;
 
     protected calldataGenerator: CalldataGenerator;
 
@@ -67,15 +68,15 @@ export abstract class SharedInteractionTransaction<
             throw new Error('Calldata is required');
         }
 
-        if (!parameters.preimage) {
-            throw new Error('Preimage is required');
+        if (!parameters.challenge) {
+            throw new Error('Challenge solution is required');
         }
 
-        this.preimage = parameters.preimage;
+        this.challenge = parameters.challenge;
 
         this.disableAutoRefund = parameters.disableAutoRefund || false;
-        this.rewardChallenge = ChallengeGenerator.generateMineableReward(
-            this.preimage,
+        this.epochChallenge = TimeLockGenerator.generateTimeLockAddress(
+            this.challenge.publicKey.originalPublicKeyBuffer(),
             this.network,
         );
 
@@ -110,27 +111,10 @@ export abstract class SharedInteractionTransaction<
     /**
      * Get the preimage
      */
-    public getPreimage(): Buffer {
-        return this.preimage;
+    public getPreimage(): ChallengeSolution {
+        return this.challenge;
     }
 
-    /**
-     * Generate the secret for the interaction
-     * @protected
-     * @returns {Buffer} The secret
-     * @throws {Error} If the to address is invalid
-     */
-
-    /*protected generateSecret(): Buffer {
-        if (!this.to) throw new Error('To address is required');
-
-        if (this.to.startsWith('0x')) {
-            throw new Error(`Legacy not support at this time. Reserved for future use.`);
-        }
-
-        return address.fromBech32(this.to).data;
-    }*/
-
     /**
      * Get the internal pubkey as an x-only key
      * @protected
@@ -381,7 +365,7 @@ export abstract class SharedInteractionTransaction<
         ) {
             this.addOutput({
                 value: Number(amountSpent - amountToCA),
-                address: this.rewardChallenge.address,
+                address: this.epochChallenge.address,
             });
         }
 

package/src/transaction/builders/TransactionBuilder.ts

@@ -148,6 +148,8 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
      */
     protected isPubKeyDestination: boolean;
 
+    protected note?: Buffer;
+
     protected constructor(parameters: ITransactionParameters) {
         super(parameters);
 
@@ -164,6 +166,14 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
         this.optionalInputs = parameters.optionalInputs || [];
         this.to = parameters.to || undefined;
 
+        if (parameters.note) {
+            if (typeof parameters.note === 'string') {
+                this.note = Buffer.from(parameters.note, 'utf8');
+            } else {
+                this.note = parameters.note;
+            }
+        }
+
         this.isPubKeyDestination = this.to
             ? AddressVerificator.isValidPublicKey(this.to, this.network)
             : false;
@@ -228,6 +238,15 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
         return buffer;
     }
 
+    public addOPReturn(buffer: Buffer): void {
+        const compileScript = script.compile([opcodes.OP_RETURN, buffer]);
+
+        this.addOutput({
+            value: 0,
+            script: compileScript,
+        });
+    }
+
     public async getFundingTransactionParameters(): Promise<IFundingTransactionParameters> {
         if (!this.estimatedFees) {
             this.estimatedFees = await this.estimateTransactionFees();
@@ -368,8 +387,23 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
      * @returns {void}
      */
     public addOutput(output: PsbtOutputExtended): void {
-        if (output.value === 0) return;
-        if (output.value < TransactionBuilder.MINIMUM_DUST) {
+        if (output.value === 0) {
+            const script = output as {
+                script: Buffer;
+            };
+
+            if (!script.script || script.script.length === 0) {
+                throw new Error('Output value is 0 and no script provided');
+            }
+
+            if (script.script.length < 2) {
+                throw new Error('Output script is too short');
+            }
+
+            if (script.script[0] !== opcodes.OP_RETURN) {
+                throw new Error('Output script must start with OP_RETURN when value is 0');
+            }
+        } else if (output.value < TransactionBuilder.MINIMUM_DUST) {
             throw new Error(
                 `Output value is less than the minimum dust ${output.value} < ${TransactionBuilder.MINIMUM_DUST}`,
             );
@@ -479,6 +513,10 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
      * @returns {Promise<void>}
      */
     protected async addRefundOutput(amountSpent: bigint): Promise<void> {
+        if (this.note) {
+            this.addOPReturn(this.note);
+        }
+
         /** Add the refund output */
         const sendBackAmount: bigint = this.totalInputAmount - amountSpent;
         if (sendBackAmount >= TransactionBuilder.MINIMUM_DUST) {

package/src/transaction/interfaces/ITransactionParameters.ts

@@ -2,6 +2,7 @@ import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { ITweakedTransactionData } from '../shared/TweakedTransaction.js';
 import { ChainId } from '../../network/ChainId.js';
 import { PsbtOutputExtended } from '@btc-vision/bitcoin';
+import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';
 
 export interface LoadedStorage {
     [key: string]: string[];
@@ -22,6 +23,8 @@ export interface ITransactionParameters extends ITweakedTransactionData {
     chainId?: ChainId;
     noSignatures?: boolean;
 
+    readonly note?: string | Buffer;
+
     readonly feeRate: number;
     readonly priorityFee: bigint;
     readonly gasSatFee: bigint;
@@ -33,17 +36,11 @@ export interface IFundingTransactionParameters extends ITransactionParameters {
     splitInputsInto?: number;
 }
 
-export interface IChallengeSolutionTransactionParameters extends ITransactionParameters {
-    amount: bigint;
-
-    readonly challengeSolution: Buffer;
-}
-
 export interface SharedInteractionParameters extends ITransactionParameters {
     calldata?: Buffer;
     disableAutoRefund?: boolean;
 
-    readonly preimage: Buffer;
+    readonly challenge: ChallengeSolution;
     readonly randomBytes?: Buffer;
 
     readonly loadedStorage?: LoadedStorage;
@@ -61,5 +58,5 @@ export interface IDeploymentParameters extends Omit<ITransactionParameters, 'to'
     readonly calldata?: Buffer;
 
     readonly randomBytes?: Buffer;
-    readonly preimage: Buffer;
+    readonly challenge: ChallengeSolution;
 }

package/src/transaction/mineable/TimelockGenerator.ts

@@ -0,0 +1,42 @@
+import bitcoin, { Network, networks, opcodes, script } from '@btc-vision/bitcoin';
+
+export interface ITimeLockOutput {
+    address: string;
+    witnessScript: Buffer;
+}
+
+export class TimeLockGenerator {
+    private static readonly CSV_BLOCKS = 75;
+
+    /**
+     * Generate a P2WSH address with CSV timelock
+     * Note: This uses ECDSA, not Schnorr (Schnorr only available in Taproot)
+     */
+    public static generateTimeLockAddress(
+        publicKey: Buffer,
+        network: Network = networks.bitcoin,
+        csvBlocks: number = TimeLockGenerator.CSV_BLOCKS,
+    ): ITimeLockOutput {
+        const witnessScript = script.compile([
+            script.number.encode(csvBlocks),
+            opcodes.OP_CHECKSEQUENCEVERIFY,
+            opcodes.OP_DROP,
+            publicKey,
+            opcodes.OP_CHECKSIG,
+        ]);
+
+        const p2wsh = bitcoin.payments.p2wsh({
+            redeem: { output: witnessScript },
+            network,
+        });
+
+        if (!p2wsh.address) {
+            throw new Error('Failed to generate P2WSH address');
+        }
+
+        return {
+            address: p2wsh.address,
+            witnessScript: witnessScript,
+        };
+    }
+}

package/src/utils/StringToBuffer.ts

@@ -0,0 +1,3 @@
+export function stringToBuffer(str: string): Buffer {
+    return Buffer.from(str.replace('0x', ''), 'hex');
+}