@btc-vision/transaction 1.6.0 → 1.6.4

package/browser/keypair/AddressVerificator.d.ts

@@ -5,7 +5,8 @@ export declare enum AddressTypes {
     P2SH_OR_P2SH_P2WPKH = "P2SH_OR_P2SH-P2WPKH",
     P2PK = "P2PK",
     P2TR = "P2TR",
-    P2WPKH = "P2WPKH"
+    P2WPKH = "P2WPKH",
+    P2WSH = "P2WSH"
 }
 export declare class AddressVerificator {
     static isValidP2TRAddress(inAddress: string, network: Network): boolean;

package/browser/transaction/TransactionFactory.d.ts

@@ -11,7 +11,7 @@ export interface DeploymentResult {
     readonly transaction: [string, string];
     readonly contractAddress: string;
     readonly contractPubKey: string;
-    readonly preimage: RawChallenge;
+    readonly challenge: RawChallenge;
     readonly utxos: UTXO[];
 }
 export interface FundingTransactionResponse {
@@ -30,7 +30,7 @@ export interface InteractionResponse {
     readonly interactionTransaction: string;
     readonly estimatedFees: bigint;
     readonly nextUTXOs: UTXO[];
-    readonly preimage: RawChallenge;
+    readonly challenge: RawChallenge;
 }
 export interface BitcoinTransferResponse extends BitcoinTransferBase {
     readonly original: FundingTransaction;

package/browser/transaction/builders/DeploymentTransaction.d.ts

@@ -9,7 +9,7 @@ import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';
 export declare class DeploymentTransaction extends TransactionBuilder<TransactionType.DEPLOYMENT> {
     static readonly MAXIMUM_CONTRACT_SIZE: number;
     type: TransactionType.DEPLOYMENT;
-    protected readonly preimage: ChallengeSolution;
+    protected readonly challenge: ChallengeSolution;
     protected readonly epochChallenge: ITimeLockOutput;
     protected readonly _contractAddress: Address;
     protected tapLeafScript: TapLeafScript | null;

package/browser/transaction/builders/TransactionBuilder.d.ts

@@ -8,6 +8,7 @@ import { TweakedTransaction } from '../shared/TweakedTransaction.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
 export declare const MINIMUM_AMOUNT_REWARD: bigint;
 export declare const MINIMUM_AMOUNT_CA: bigint;
+export declare const ANCHOR_SCRIPT: Buffer<ArrayBuffer>;
 export declare abstract class TransactionBuilder<T extends TransactionType> extends TweakedTransaction {
     static readonly LOCK_LEAF_SCRIPT: Buffer;
     static readonly MINIMUM_DUST: bigint;
@@ -33,11 +34,13 @@ export declare abstract class TransactionBuilder<T extends TransactionType> exte
     protected from: string;
     protected _maximumFeeRate: number;
     protected isPubKeyDestination: boolean;
+    protected anchor: boolean;
     protected note?: Buffer;
     protected constructor(parameters: ITransactionParameters);
     static getFrom(from: string | undefined, keypair: ECPairInterface | Signer, network: Network): string;
     static witnessStackToScriptWitness(witness: Buffer[]): Buffer;
     addOPReturn(buffer: Buffer): void;
+    addAnchor(): void;
     getFundingTransactionParameters(): Promise<IFundingTransactionParameters>;
     setDestinationAddress(address: string): void;
     setMaximumFeeRate(feeRate: number): void;

package/browser/transaction/interfaces/ITransactionParameters.d.ts

@@ -17,6 +17,7 @@ export interface ITransactionParameters extends ITweakedTransactionData {
     chainId?: ChainId;
     noSignatures?: boolean;
     readonly note?: string | Buffer;
+    readonly anchor?: boolean;
     readonly feeRate: number;
     readonly priorityFee: bigint;
     readonly gasSatFee: bigint;

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

@@ -5,6 +5,7 @@ import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
 import { ChainId } from '../../network/ChainId.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
+export type SupportedTransactionVersion = 1 | 2 | 3;
 export interface ITweakedTransactionData {
     readonly signer: Signer | ECPairInterface | UnisatSigner;
     readonly network: Network;
@@ -12,11 +13,16 @@ export interface ITweakedTransactionData {
     readonly nonWitnessUtxo?: Buffer;
     readonly noSignatures?: boolean;
     readonly unlockScript?: Buffer[];
+    readonly txVersion?: SupportedTransactionVersion;
 }
 export declare enum TransactionSequence {
     REPLACE_BY_FEE = 4294967293,
     FINAL = 4294967295
 }
+export declare enum CSVModes {
+    BLOCKS = 0,
+    TIMESTAMPS = 1
+}
 export declare abstract class TweakedTransaction extends Logger {
     readonly logColor: string;
     finalized: boolean;
@@ -33,10 +39,13 @@ export declare abstract class TweakedTransaction extends Logger {
     protected tapLeafScript: TapLeafScript | null;
     protected nonWitnessUtxo?: Buffer;
     protected readonly isBrowser: boolean;
+    protected csvInputIndices: Set<number>;
+    protected anchorInputIndices: Set<number>;
     protected regenerated: boolean;
     protected ignoreSignatureErrors: boolean;
     protected noSignatures: boolean;
     protected unlockScript: Buffer[] | undefined;
+    protected txVersion: SupportedTransactionVersion;
     protected constructor(data: ITweakedTransactionData);
     static readScriptWitnessToWitnessStack(Buffer: Buffer): Buffer[];
     static preEstimateTaprootTransactionFees(feeRate: bigint, numInputs: bigint, numOutputs: bigint, numWitnessElements: bigint, witnessElementSize: bigint, emptyWitness: bigint, taprootControlWitnessSize?: bigint, taprootScriptSize?: bigint): bigint;
@@ -70,11 +79,20 @@ export declare abstract class TweakedTransaction extends Logger {
         outputScript: Buffer;
     } | undefined;
     protected generatePsbtInputExtended(utxo: UTXO, i: number, _extra?: boolean): PsbtInputExtended;
+    protected processP2WSHInput(utxo: UTXO, input: PsbtInputExtended, i: number): void;
+    protected secondsToCSVTimeUnits(seconds: number): number;
+    protected createTimeBasedCSV(seconds: number): number;
+    protected isCSVEnabled(sequence: number): boolean;
+    protected extractCSVValue(sequence: number): number;
     protected customFinalizerP2SH: (inputIndex: number, input: PsbtInput, scriptA: Buffer, isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean) => {
         finalScriptSig: Buffer | undefined;
         finalScriptWitness: Buffer | undefined;
     };
     protected signInputsWalletBased(transaction: Psbt): Promise<void>;
+    protected isCSVScript(decompiled: (number | Buffer)[]): boolean;
+    protected setCSVSequence(csvBlocks: number, currentSequence: number): number;
+    protected getCSVType(csvValue: number): CSVModes;
+    private extractCSVBlocks;
     private attemptSignTaproot;
     private isTaprootScriptSpend;
     private signTaprootInput;

package/browser/utxo/OPNetLimitedProvider.d.ts

@@ -7,9 +7,6 @@ export interface WalletUTXOs {
     readonly pending: RawUTXOResponse[];
     readonly spentTransactions: RawUTXOResponse[];
 }
-export interface PreimageData {
-    readonly preimage: Buffer;
-}
 export declare class OPNetLimitedProvider {
     private readonly opnetAPIUrl;
     private readonly utxoPath;
@@ -18,7 +15,6 @@ export declare class OPNetLimitedProvider {
     fetchUTXO(settings: FetchUTXOParams): Promise<UTXO[]>;
     fetchUTXOMultiAddr(settings: FetchUTXOParamsMultiAddress): Promise<UTXO[]>;
     broadcastTransaction(transaction: string, psbt: boolean): Promise<BroadcastResponse | undefined>;
-    getPreimage(): Promise<PreimageData | undefined>;
     splitUTXOs(wallet: Wallet, network: Network, splitInputsInto: number, amountPerUTXO: bigint): Promise<BroadcastResponse | {
         error: string;
     }>;

package/build/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.6.0";
+export declare const version = "1.6.4";

package/build/_version.js

@@ -1 +1 @@
-export const version = '1.6.0';
+export const version = '1.6.4';

package/build/epoch/ChallengeSolution.d.ts

@@ -29,14 +29,14 @@ export declare class ChallengeSolution implements IChallengeSolution {
     readonly verification: ChallengeVerification;
     private readonly submission?;
     constructor(data: RawChallenge);
-    static validateRaw(data: RawChallenge): Promise<boolean>;
+    static validateRaw(data: RawChallenge): boolean;
     verifySubmissionSignature(): boolean;
     getSubmission(): ChallengeSubmission | undefined;
-    verify(): Promise<boolean>;
+    verify(): boolean;
     toBuffer(): Buffer;
     toHex(): string;
     toRaw(): RawChallenge;
-    calculateSolution(): Promise<Buffer>;
+    calculateSolution(): Buffer;
     checkDifficulty(minDifficulty: number): {
         valid: boolean;
         difficulty: number;

package/build/epoch/ChallengeSolution.js

@@ -47,7 +47,7 @@ export class ChallengeSolution {
             ? new ChallengeSubmission(data.submission, this.epochNumber + 2n)
             : data.submission;
     }
-    static async validateRaw(data) {
+    static validateRaw(data) {
         return EpochValidator.validateEpochWinner(data);
     }
     verifySubmissionSignature() {
@@ -65,8 +65,8 @@ export class ChallengeSolution {
         }
         return this.submission;
     }
-    async verify() {
-        return EpochValidator.validatePreimage(this);
+    verify() {
+        return EpochValidator.validateChallengeSolution(this);
     }
     toBuffer() {
         return this.solution;
@@ -93,7 +93,7 @@ export class ChallengeSolution {
             },
         };
     }
-    async calculateSolution() {
+    calculateSolution() {
         return EpochValidator.calculateSolution(this.verification.targetChecksum, this.publicKey.toBuffer(), this.salt);
     }
     checkDifficulty(minDifficulty) {

package/build/epoch/validator/EpochValidator.d.ts

@@ -1,17 +1,16 @@
 import { IChallengeSolution, RawChallenge } from '../interfaces/IChallengeSolution.js';
 export declare class EpochValidator {
     private static readonly BLOCKS_PER_EPOCH;
-    private static readonly GRAFFITI_LENGTH;
     static bufferToUint8Array(buffer: Buffer): Uint8Array;
     static uint8ArrayToBuffer(array: Uint8Array): Buffer;
-    static sha1(data: Uint8Array): Promise<Uint8Array>;
+    static sha1(data: Uint8Array | Buffer): Buffer;
     static calculatePreimage(checksumRoot: Buffer, publicKey: Buffer, salt: Buffer): Buffer;
     static countMatchingBits(hash1: Buffer, hash2: Buffer): number;
-    static verifySolution(preimage: IChallengeSolution, log?: boolean): Promise<boolean>;
+    static verifySolution(challenge: IChallengeSolution, log?: boolean): boolean;
     static getMiningTargetBlock(epochNumber: bigint): bigint | null;
-    static validateEpochWinner(epochData: RawChallenge): Promise<boolean>;
-    static validatePreimage(preimage: IChallengeSolution): Promise<boolean>;
-    static calculateSolution(targetChecksum: Buffer, publicKey: Buffer, salt: Buffer): Promise<Buffer>;
+    static validateEpochWinner(epochData: RawChallenge): boolean;
+    static validateChallengeSolution(challenge: IChallengeSolution): boolean;
+    static calculateSolution(targetChecksum: Buffer, publicKey: Buffer, salt: Buffer): Buffer;
     static checkDifficulty(solution: Buffer, targetHash: Buffer, minDifficulty: number): {
         valid: boolean;
         difficulty: number;

package/build/epoch/validator/EpochValidator.js

@@ -1,4 +1,5 @@
 import { ChallengeSolution } from '../ChallengeSolution.js';
+import { crypto } from '@btc-vision/bitcoin';
 export class EpochValidator {
     static bufferToUint8Array(buffer) {
         return new Uint8Array(buffer);
@@ -6,9 +7,8 @@ export class EpochValidator {
     static uint8ArrayToBuffer(array) {
         return Buffer.from(array);
     }
-    static async sha1(data) {
-        const hashBuffer = await crypto.subtle.digest('SHA-1', data);
-        return new Uint8Array(hashBuffer);
+    static sha1(data) {
+        return crypto.sha1(Buffer.isBuffer(data) ? data : Buffer.from(data));
     }
     static calculatePreimage(checksumRoot, publicKey, salt) {
         if (checksumRoot.length !== 32 || publicKey.length !== 32 || salt.length !== 32) {
@@ -45,20 +45,20 @@ export class EpochValidator {
         }
         return matchingBits;
     }
-    static async verifySolution(preimage, log = false) {
+    static verifySolution(challenge, log = false) {
         try {
-            const verification = preimage.verification;
-            const calculatedPreimage = this.calculatePreimage(verification.targetChecksum, preimage.publicKey.toBuffer(), preimage.salt);
-            const computedSolution = await this.sha1(this.bufferToUint8Array(calculatedPreimage));
+            const verification = challenge.verification;
+            const calculatedPreimage = this.calculatePreimage(verification.targetChecksum, challenge.publicKey.toBuffer(), challenge.salt);
+            const computedSolution = this.sha1(calculatedPreimage);
             const computedSolutionBuffer = this.uint8ArrayToBuffer(computedSolution);
-            if (!computedSolutionBuffer.equals(preimage.solution)) {
+            if (!computedSolutionBuffer.equals(challenge.solution)) {
                 return false;
             }
             const matchingBits = this.countMatchingBits(computedSolutionBuffer, verification.targetHash);
-            if (matchingBits !== preimage.difficulty) {
+            if (matchingBits !== challenge.difficulty) {
                 return false;
             }
-            const expectedStartBlock = preimage.epochNumber * this.BLOCKS_PER_EPOCH;
+            const expectedStartBlock = challenge.epochNumber * this.BLOCKS_PER_EPOCH;
             const expectedEndBlock = expectedStartBlock + this.BLOCKS_PER_EPOCH - 1n;
             return !(verification.startBlock !== expectedStartBlock ||
                 verification.endBlock !== expectedEndBlock);
@@ -75,16 +75,16 @@ export class EpochValidator {
         }
         return epochNumber * this.BLOCKS_PER_EPOCH - 1n;
     }
-    static async validateEpochWinner(epochData) {
+    static validateEpochWinner(epochData) {
         const preimage = new ChallengeSolution(epochData);
-        return await this.verifySolution(preimage);
+        return this.verifySolution(preimage);
     }
-    static async validatePreimage(preimage) {
-        return await this.verifySolution(preimage);
+    static validateChallengeSolution(challenge) {
+        return this.verifySolution(challenge);
     }
-    static async calculateSolution(targetChecksum, publicKey, salt) {
+    static calculateSolution(targetChecksum, publicKey, salt) {
         const preimage = this.calculatePreimage(targetChecksum, publicKey, salt);
-        const hash = await this.sha1(this.bufferToUint8Array(preimage));
+        const hash = this.sha1(this.bufferToUint8Array(preimage));
         return this.uint8ArrayToBuffer(hash);
     }
     static checkDifficulty(solution, targetHash, minDifficulty) {
@@ -96,4 +96,3 @@ export class EpochValidator {
     }
 }
 EpochValidator.BLOCKS_PER_EPOCH = 5n;
-EpochValidator.GRAFFITI_LENGTH = 16;

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

@@ -6,6 +6,6 @@ export declare const OPNET_DEPLOYMENT_VERSION = 0;
 export declare const versionBuffer: Buffer<ArrayBuffer>;
 export declare class DeploymentGenerator extends Generator {
     constructor(senderPubKey: Buffer, contractSaltPubKey: Buffer, network?: Network);
-    compile(contractBytecode: Buffer, contractSalt: Buffer, preimage: ChallengeSolution, maxPriority: bigint, calldata?: Buffer, features?: Feature<Features>[]): Buffer;
+    compile(contractBytecode: Buffer, contractSalt: Buffer, challenge: ChallengeSolution, maxPriority: bigint, calldata?: Buffer, features?: Feature<Features>[]): Buffer;
     private getAsm;
 }

package/build/generators/builders/DeploymentGenerator.js

@@ -6,8 +6,8 @@ export class DeploymentGenerator extends Generator {
     constructor(senderPubKey, contractSaltPubKey, network = networks.bitcoin) {
         super(senderPubKey, contractSaltPubKey, network);
     }
-    compile(contractBytecode, contractSalt, preimage, maxPriority, calldata, features) {
-        const asm = this.getAsm(contractBytecode, contractSalt, preimage, maxPriority, calldata, features);
+    compile(contractBytecode, contractSalt, challenge, maxPriority, calldata, features) {
+        const asm = this.getAsm(contractBytecode, contractSalt, challenge, maxPriority, calldata, features);
         const compiled = script.compile(asm);
         const decompiled = script.decompile(compiled);
         if (!decompiled) {
@@ -15,7 +15,7 @@ export class DeploymentGenerator extends Generator {
         }
         return compiled;
     }
-    getAsm(contractBytecode, contractSalt, preimage, maxPriority, calldata, features) {
+    getAsm(contractBytecode, contractSalt, challenge, maxPriority, calldata, features) {
         if (!this.contractSaltPubKey)
             throw new Error('Contract salt public key not set');
         const dataChunks = this.splitBufferIntoChunks(contractBytecode);
@@ -33,9 +33,9 @@ export class DeploymentGenerator extends Generator {
         const compiledData = [
             this.getHeader(maxPriority, featuresList),
             opcodes.OP_TOALTSTACK,
-            preimage.publicKey.originalPublicKeyBuffer(),
+            challenge.publicKey.originalPublicKeyBuffer(),
             opcodes.OP_TOALTSTACK,
-            preimage.solution,
+            challenge.solution,
             opcodes.OP_TOALTSTACK,
             this.xSenderPubKey,
             opcodes.OP_DUP,

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

@@ -4,5 +4,5 @@ import { Feature, Features } from '../Features.js';
 export declare class LegacyCalldataGenerator extends Generator {
     constructor(senderPubKey: Buffer, network?: Network);
     static getPubKeyAsBuffer(witnessKeys: Buffer[], network: Network): Buffer;
-    compile(calldata: Buffer, contractSecret: Buffer, preimage: Buffer, maxPriority: bigint, features?: Feature<Features>[]): Buffer;
+    compile(calldata: Buffer, contractSecret: Buffer, challenge: Buffer, maxPriority: bigint, features?: Feature<Features>[]): Buffer;
 }

package/build/generators/builders/LegacyCalldataGenerator.js

@@ -24,7 +24,7 @@ export class LegacyCalldataGenerator extends Generator {
         }
         return compressed;
     }
-    compile(calldata, contractSecret, preimage, maxPriority, features = []) {
+    compile(calldata, contractSecret, challenge, maxPriority, features = []) {
         const dataChunks = this.splitBufferIntoChunks(calldata);
         if (!dataChunks.length)
             throw new Error('No data chunks found');
@@ -39,7 +39,7 @@ export class LegacyCalldataGenerator extends Generator {
         let compiledData = [
             this.getHeader(maxPriority, featuresList),
             opcodes.OP_TOALTSTACK,
-            preimage,
+            challenge,
             opcodes.OP_TOALTSTACK,
             this.senderPubKey,
             opcodes.OP_DUP,

package/build/keypair/AddressVerificator.d.ts

@@ -5,7 +5,8 @@ export declare enum AddressTypes {
     P2SH_OR_P2SH_P2WPKH = "P2SH_OR_P2SH-P2WPKH",
     P2PK = "P2PK",
     P2TR = "P2TR",
-    P2WPKH = "P2WPKH"
+    P2WPKH = "P2WPKH",
+    P2WSH = "P2WSH"
 }
 export declare class AddressVerificator {
     static isValidP2TRAddress(inAddress: string, network: Network): boolean;

package/build/keypair/AddressVerificator.js

@@ -11,6 +11,7 @@ export var AddressTypes;
     AddressTypes["P2PK"] = "P2PK";
     AddressTypes["P2TR"] = "P2TR";
     AddressTypes["P2WPKH"] = "P2WPKH";
+    AddressTypes["P2WSH"] = "P2WSH";
 })(AddressTypes || (AddressTypes = {}));
 export class AddressVerificator {
     static isValidP2TRAddress(inAddress, network) {
@@ -112,6 +113,9 @@ export class AddressVerificator {
                 if (decodedBech32.version === 0 && decodedBech32.data.length === 20) {
                     return AddressTypes.P2WPKH;
                 }
+                if (decodedBech32.version === 0 && decodedBech32.data.length === 32) {
+                    return AddressTypes.P2WSH;
+                }
                 if (decodedBech32.version === 1 && decodedBech32.data.length === 32) {
                     return AddressTypes.P2TR;
                 }

package/build/transaction/TransactionFactory.d.ts

@@ -11,7 +11,7 @@ export interface DeploymentResult {
     readonly transaction: [string, string];
     readonly contractAddress: string;
     readonly contractPubKey: string;
-    readonly preimage: RawChallenge;
+    readonly challenge: RawChallenge;
     readonly utxos: UTXO[];
 }
 export interface FundingTransactionResponse {
@@ -30,7 +30,7 @@ export interface InteractionResponse {
     readonly interactionTransaction: string;
     readonly estimatedFees: bigint;
     readonly nextUTXOs: UTXO[];
-    readonly preimage: RawChallenge;
+    readonly challenge: RawChallenge;
 }
 export interface BitcoinTransferResponse extends BitcoinTransferBase {
     readonly original: FundingTransaction;

package/build/transaction/TransactionFactory.js

@@ -133,7 +133,7 @@ export class TransactionFactory {
             interactionTransaction: outTx.toHex(),
             estimatedFees: preTransaction.estimatedFees,
             nextUTXOs: this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.from, 1),
-            preimage: preTransaction.getPreimage().toRaw(),
+            challenge: preTransaction.getPreimage().toRaw(),
         };
     }
     async signDeployment(deploymentParameters) {
@@ -211,7 +211,7 @@ export class TransactionFactory {
             contractAddress: finalTransaction.getContractAddress(),
             contractPubKey: finalTransaction.contractPubKey,
             utxos: [refundUTXO],
-            preimage: preTransaction.getPreimage().toRaw(),
+            challenge: preTransaction.getPreimage().toRaw(),
         };
     }
     async createBTCTransfer(parameters) {

package/build/transaction/builders/DeploymentTransaction.d.ts

@@ -9,7 +9,7 @@ import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';
 export declare class DeploymentTransaction extends TransactionBuilder<TransactionType.DEPLOYMENT> {
     static readonly MAXIMUM_CONTRACT_SIZE: number;
     type: TransactionType.DEPLOYMENT;
-    protected readonly preimage: ChallengeSolution;
+    protected readonly challenge: ChallengeSolution;
     protected readonly epochChallenge: ITimeLockOutput;
     protected readonly _contractAddress: Address;
     protected tapLeafScript: TapLeafScript | null;

package/build/transaction/builders/DeploymentTransaction.js

@@ -45,12 +45,12 @@ export class DeploymentTransaction extends TransactionBuilder {
         if (!parameters.challenge)
             throw new Error('Challenge solution is required');
         this.randomBytes = parameters.randomBytes || BitcoinUtils.rndBytes();
-        this.preimage = parameters.challenge;
-        this.epochChallenge = TimeLockGenerator.generateTimeLockAddress(this.preimage.publicKey.originalPublicKeyBuffer(), this.network);
+        this.challenge = parameters.challenge;
+        this.epochChallenge = TimeLockGenerator.generateTimeLockAddress(this.challenge.publicKey.originalPublicKeyBuffer(), this.network);
         this.contractSeed = this.getContractSeed();
         this.contractSigner = EcKeyPair.fromSeedKeyPair(this.contractSeed, this.network);
         this.deploymentGenerator = new DeploymentGenerator(Buffer.from(this.signer.publicKey), this.contractSignerXOnlyPubKey(), this.network);
-        this.compiledTargetScript = this.deploymentGenerator.compile(this.bytecode, this.randomBytes, this.preimage, this.priorityFee, this.calldata, this.generateFeatures(parameters));
+        this.compiledTargetScript = this.deploymentGenerator.compile(this.bytecode, this.randomBytes, this.challenge, this.priorityFee, this.calldata, this.generateFeatures(parameters));
         this.scriptTree = this.getScriptTree();
         this.internalInit();
         this._contractPubKey = '0x' + this.contractSeed.toString('hex');
@@ -69,7 +69,7 @@ export class DeploymentTransaction extends TransactionBuilder {
         return this.randomBytes;
     }
     getPreimage() {
-        return this.preimage;
+        return this.challenge;
     }
     getContractAddress() {
         if (this._computedAddress) {

package/build/transaction/builders/TransactionBuilder.d.ts

@@ -8,6 +8,7 @@ import { TweakedTransaction } from '../shared/TweakedTransaction.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
 export declare const MINIMUM_AMOUNT_REWARD: bigint;
 export declare const MINIMUM_AMOUNT_CA: bigint;
+export declare const ANCHOR_SCRIPT: Buffer<ArrayBuffer>;
 export declare abstract class TransactionBuilder<T extends TransactionType> extends TweakedTransaction {
     static readonly LOCK_LEAF_SCRIPT: Buffer;
     static readonly MINIMUM_DUST: bigint;
@@ -33,11 +34,13 @@ export declare abstract class TransactionBuilder<T extends TransactionType> exte
     protected from: string;
     protected _maximumFeeRate: number;
     protected isPubKeyDestination: boolean;
+    protected anchor: boolean;
     protected note?: Buffer;
     protected constructor(parameters: ITransactionParameters);
     static getFrom(from: string | undefined, keypair: ECPairInterface | Signer, network: Network): string;
     static witnessStackToScriptWitness(witness: Buffer[]): Buffer;
     addOPReturn(buffer: Buffer): void;
+    addAnchor(): void;
     getFundingTransactionParameters(): Promise<IFundingTransactionParameters>;
     setDestinationAddress(address: string): void;
     setMaximumFeeRate(feeRate: number): void;

package/build/transaction/builders/TransactionBuilder.js

@@ -6,6 +6,7 @@ import { TweakedTransaction } from '../shared/TweakedTransaction.js';
 initEccLib(ecc);
 export const MINIMUM_AMOUNT_REWARD = 540n;
 export const MINIMUM_AMOUNT_CA = 297n;
+export const ANCHOR_SCRIPT = Buffer.from('51024e73', 'hex');
 export class TransactionBuilder extends TweakedTransaction {
     constructor(parameters) {
         super(parameters);
@@ -36,6 +37,7 @@ export class TransactionBuilder extends TweakedTransaction {
                 this.note = parameters.note;
             }
         }
+        this.anchor = parameters.anchor ?? false;
         this.isPubKeyDestination = this.to
             ? AddressVerificator.isValidPublicKey(this.to, this.network)
             : false;
@@ -48,6 +50,7 @@ export class TransactionBuilder extends TweakedTransaction {
         }
         this.transaction = new Psbt({
             network: this.network,
+            version: this.txVersion,
         });
     }
     static getFrom(from, keypair, network) {
@@ -82,6 +85,12 @@ export class TransactionBuilder extends TweakedTransaction {
             script: compileScript,
         });
     }
+    addAnchor() {
+        this.addOutput({
+            value: 0,
+            script: ANCHOR_SCRIPT,
+        });
+    }
     async getFundingTransactionParameters() {
         if (!this.estimatedFees) {
             this.estimatedFees = await this.estimateTransactionFees();
@@ -164,8 +173,8 @@ export class TransactionBuilder extends TweakedTransaction {
             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');
+            if (script.script[0] !== opcodes.OP_RETURN && !script.script.equals(ANCHOR_SCRIPT)) {
+                throw new Error('Output script must start with OP_RETURN or be an ANCHOR when value is 0');
             }
         }
         else if (output.value < TransactionBuilder.MINIMUM_DUST) {
@@ -201,7 +210,10 @@ export class TransactionBuilder extends TweakedTransaction {
         }
     }
     async rebuildFromBase64(base64) {
-        this.transaction = Psbt.fromBase64(base64, { network: this.network });
+        this.transaction = Psbt.fromBase64(base64, {
+            network: this.network,
+            version: this.txVersion,
+        });
         this.signed = false;
         this.sighashTypes = [Transaction.SIGHASH_ANYONECANPAY, Transaction.SIGHASH_ALL];
         return await this.signPSBT();
@@ -231,6 +243,9 @@ export class TransactionBuilder extends TweakedTransaction {
         if (this.note) {
             this.addOPReturn(this.note);
         }
+        if (this.anchor) {
+            this.addAnchor();
+        }
         const sendBackAmount = this.totalInputAmount - amountSpent;
         if (sendBackAmount >= TransactionBuilder.MINIMUM_DUST) {
             if (AddressVerificator.isValidP2TRAddress(this.from, this.network)) {

package/build/transaction/interfaces/ITransactionParameters.d.ts

@@ -17,6 +17,7 @@ export interface ITransactionParameters extends ITweakedTransactionData {
     chainId?: ChainId;
     noSignatures?: boolean;
     readonly note?: string | Buffer;
+    readonly anchor?: boolean;
     readonly feeRate: number;
     readonly priorityFee: bigint;
     readonly gasSatFee: bigint;

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

@@ -5,6 +5,7 @@ import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
 import { ChainId } from '../../network/ChainId.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
+export type SupportedTransactionVersion = 1 | 2 | 3;
 export interface ITweakedTransactionData {
     readonly signer: Signer | ECPairInterface | UnisatSigner;
     readonly network: Network;
@@ -12,11 +13,16 @@ export interface ITweakedTransactionData {
     readonly nonWitnessUtxo?: Buffer;
     readonly noSignatures?: boolean;
     readonly unlockScript?: Buffer[];
+    readonly txVersion?: SupportedTransactionVersion;
 }
 export declare enum TransactionSequence {
     REPLACE_BY_FEE = 4294967293,
     FINAL = 4294967295
 }
+export declare enum CSVModes {
+    BLOCKS = 0,
+    TIMESTAMPS = 1
+}
 export declare abstract class TweakedTransaction extends Logger {
     readonly logColor: string;
     finalized: boolean;
@@ -33,10 +39,13 @@ export declare abstract class TweakedTransaction extends Logger {
     protected tapLeafScript: TapLeafScript | null;
     protected nonWitnessUtxo?: Buffer;
     protected readonly isBrowser: boolean;
+    protected csvInputIndices: Set<number>;
+    protected anchorInputIndices: Set<number>;
     protected regenerated: boolean;
     protected ignoreSignatureErrors: boolean;
     protected noSignatures: boolean;
     protected unlockScript: Buffer[] | undefined;
+    protected txVersion: SupportedTransactionVersion;
     protected constructor(data: ITweakedTransactionData);
     static readScriptWitnessToWitnessStack(Buffer: Buffer): Buffer[];
     static preEstimateTaprootTransactionFees(feeRate: bigint, numInputs: bigint, numOutputs: bigint, numWitnessElements: bigint, witnessElementSize: bigint, emptyWitness: bigint, taprootControlWitnessSize?: bigint, taprootScriptSize?: bigint): bigint;
@@ -70,11 +79,20 @@ export declare abstract class TweakedTransaction extends Logger {
         outputScript: Buffer;
     } | undefined;
     protected generatePsbtInputExtended(utxo: UTXO, i: number, _extra?: boolean): PsbtInputExtended;
+    protected processP2WSHInput(utxo: UTXO, input: PsbtInputExtended, i: number): void;
+    protected secondsToCSVTimeUnits(seconds: number): number;
+    protected createTimeBasedCSV(seconds: number): number;
+    protected isCSVEnabled(sequence: number): boolean;
+    protected extractCSVValue(sequence: number): number;
     protected customFinalizerP2SH: (inputIndex: number, input: PsbtInput, scriptA: Buffer, isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean) => {
         finalScriptSig: Buffer | undefined;
         finalScriptWitness: Buffer | undefined;
     };
     protected signInputsWalletBased(transaction: Psbt): Promise<void>;
+    protected isCSVScript(decompiled: (number | Buffer)[]): boolean;
+    protected setCSVSequence(csvBlocks: number, currentSequence: number): number;
+    protected getCSVType(csvValue: number): CSVModes;
+    private extractCSVBlocks;
     private attemptSignTaproot;
     private isTaprootScriptSpend;
     private signTaprootInput;