@btc-vision/transaction 1.6.1 → 1.6.5

package/build/transaction/builders/InteractionTransactionP2WDA.js

@@ -0,0 +1,205 @@
+import { Buffer } from 'buffer';
+import { toXOnly } from '@btc-vision/bitcoin';
+import { TransactionType } from '../enums/TransactionType.js';
+import { MINIMUM_AMOUNT_CA, MINIMUM_AMOUNT_REWARD, TransactionBuilder, } from './TransactionBuilder.js';
+import { MessageSigner } from '../../keypair/MessageSigner.js';
+import { Compressor } from '../../bytecode/Compressor.js';
+import { P2WDAGenerator } from '../../generators/builders/P2WDAGenerator.js';
+import { Features } from '../../generators/Features.js';
+import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
+import { EcKeyPair } from '../../keypair/EcKeyPair.js';
+import { P2WDADetector } from '../../p2wda/P2WDADetector.js';
+import { TimeLockGenerator } from '../mineable/TimelockGenerator.js';
+export class InteractionTransactionP2WDA extends TransactionBuilder {
+    constructor(parameters) {
+        super(parameters);
+        this.type = TransactionType.INTERACTION;
+        this.p2wdaInputIndices = new Set();
+        this.compiledOperationData = null;
+        if (!parameters.to) {
+            throw new Error('Contract address (to) is required');
+        }
+        if (!parameters.contract) {
+            throw new Error('Contract secret is required');
+        }
+        if (!parameters.calldata) {
+            throw new Error('Calldata is required');
+        }
+        if (!parameters.challenge) {
+            throw new Error('Challenge solution is required');
+        }
+        this.disableAutoRefund = parameters.disableAutoRefund || false;
+        this.contractAddress = parameters.to;
+        this.contractSecret = Buffer.from(parameters.contract.replace('0x', ''), 'hex');
+        this.calldata = Compressor.compress(parameters.calldata);
+        this.challenge = parameters.challenge;
+        this.randomBytes = parameters.randomBytes || BitcoinUtils.rndBytes();
+        this.scriptSigner = this.generateKeyPairFromSeed();
+        this.p2wdaGenerator = new P2WDAGenerator(Buffer.from(this.signer.publicKey), this.scriptSignerXOnlyPubKey(), this.network);
+        if (this.contractSecret.length !== 32) {
+            throw new Error('Invalid contract secret length. Expected 32 bytes.');
+        }
+        this.epochChallenge = TimeLockGenerator.generateTimeLockAddress(this.challenge.publicKey.originalPublicKeyBuffer(), this.network);
+        this.validateP2WDAInputs();
+        this.compiledOperationData = this.p2wdaGenerator.compile(this.calldata, this.contractSecret, this.challenge, this.priorityFee, this.generateFeatures(parameters));
+        this.validateOperationDataSize();
+        this.internalInit();
+    }
+    getRndBytes() {
+        return this.randomBytes;
+    }
+    getChallenge() {
+        return this.challenge;
+    }
+    getContractSecret() {
+        return this.contractSecret;
+    }
+    async buildTransaction() {
+        if (!this.regenerated) {
+            this.addInputsFromUTXO();
+        }
+        await this.createMineableRewardOutputs();
+    }
+    async createMineableRewardOutputs() {
+        if (!this.to)
+            throw new Error('To address is required');
+        const amountSpent = this.getTransactionOPNetFee();
+        let amountToCA;
+        if (amountSpent > MINIMUM_AMOUNT_REWARD + MINIMUM_AMOUNT_CA) {
+            amountToCA = MINIMUM_AMOUNT_CA;
+        }
+        else {
+            amountToCA = amountSpent;
+        }
+        this.addOutput({
+            value: Number(amountToCA),
+            address: this.to,
+        });
+        if (amountToCA === MINIMUM_AMOUNT_CA &&
+            amountSpent - MINIMUM_AMOUNT_CA > MINIMUM_AMOUNT_REWARD) {
+            this.addOutput({
+                value: Number(amountSpent - amountToCA),
+                address: this.epochChallenge.address,
+            });
+        }
+        const amount = this.addOptionalOutputsAndGetAmount();
+        if (!this.disableAutoRefund) {
+            await this.addRefundOutput(amountSpent + amount);
+        }
+    }
+    async signInputs(transaction) {
+        for (let i = 0; i < transaction.data.inputs.length; i++) {
+            await this.signInput(transaction, transaction.data.inputs[i], i, this.signer);
+        }
+        for (let i = 0; i < transaction.data.inputs.length; i++) {
+            if (this.p2wdaInputIndices.has(i)) {
+                if (i === 0) {
+                    transaction.finalizeInput(i, this.finalizePrimaryP2WDA.bind(this));
+                }
+                else {
+                    transaction.finalizeInput(i, this.finalizeSecondaryP2WDA.bind(this));
+                }
+            }
+            else {
+                transaction.finalizeInput(i, this.customFinalizerP2SH.bind(this));
+            }
+        }
+        this.finalized = true;
+    }
+    generateFeatures(parameters) {
+        const features = [];
+        if (parameters.loadedStorage) {
+            features.push({
+                opcode: Features.ACCESS_LIST,
+                data: parameters.loadedStorage,
+            });
+        }
+        const submission = parameters.challenge.getSubmission();
+        if (submission) {
+            features.push({
+                opcode: Features.EPOCH_SUBMISSION,
+                data: submission,
+            });
+        }
+        return features;
+    }
+    generateKeyPairFromSeed() {
+        return EcKeyPair.fromSeedKeyPair(this.randomBytes, this.network);
+    }
+    scriptSignerXOnlyPubKey() {
+        return toXOnly(Buffer.from(this.scriptSigner.publicKey));
+    }
+    validateP2WDAInputs() {
+        if (this.utxos.length === 0 || !P2WDADetector.isP2WDAUTXO(this.utxos[0])) {
+            throw new Error('Input 0 must be a P2WDA UTXO');
+        }
+        for (let i = 0; i < this.utxos.length; i++) {
+            if (P2WDADetector.isP2WDAUTXO(this.utxos[i])) {
+                this.p2wdaInputIndices.add(i);
+            }
+        }
+        for (let i = 0; i < this.optionalInputs.length; i++) {
+            const actualIndex = this.utxos.length + i;
+            if (P2WDADetector.isP2WDAUTXO(this.optionalInputs[i])) {
+                this.p2wdaInputIndices.add(actualIndex);
+            }
+        }
+    }
+    validateOperationDataSize() {
+        if (!this.compiledOperationData) {
+            throw new Error('Operation data not compiled');
+        }
+        const estimatedSize = this.compiledOperationData.length;
+        if (!P2WDAGenerator.validateWitnessSize(estimatedSize)) {
+            const signatureSize = 64;
+            const totalSize = estimatedSize + signatureSize;
+            const compressedEstimate = Math.ceil(totalSize * 0.7);
+            const requiredFields = Math.ceil(compressedEstimate / InteractionTransactionP2WDA.MAX_BYTES_PER_WITNESS);
+            throw new Error(`Please dont use P2WDA for this operation. Data too large. Raw size: ${estimatedSize} bytes, ` +
+                `estimated compressed: ${compressedEstimate} bytes, ` +
+                `needs ${requiredFields} witness fields, max is ${InteractionTransactionP2WDA.MAX_WITNESS_FIELDS}`);
+        }
+    }
+    finalizePrimaryP2WDA(inputIndex, input) {
+        if (!input.partialSig || input.partialSig.length === 0) {
+            throw new Error(`No signature for P2WDA input #${inputIndex}`);
+        }
+        if (!input.witnessScript) {
+            throw new Error(`No witness script for P2WDA input #${inputIndex}`);
+        }
+        if (!this.compiledOperationData) {
+            throw new Error('Operation data not compiled');
+        }
+        const txSignature = input.partialSig[0].signature;
+        const messageToSign = Buffer.concat([txSignature, this.compiledOperationData]);
+        const signedMessage = MessageSigner.signMessage(this.signer, messageToSign);
+        const schnorrSignature = Buffer.from(signedMessage.signature);
+        const fullData = Buffer.concat([schnorrSignature, this.compiledOperationData]);
+        const compressedData = Compressor.compress(fullData);
+        const chunks = this.splitIntoWitnessChunks(compressedData);
+        if (chunks.length > InteractionTransactionP2WDA.MAX_WITNESS_FIELDS) {
+            throw new Error(`Compressed data needs ${chunks.length} witness fields, max is ${InteractionTransactionP2WDA.MAX_WITNESS_FIELDS}`);
+        }
+        const witnessStack = [txSignature];
+        for (let i = 0; i < InteractionTransactionP2WDA.MAX_WITNESS_FIELDS; i++) {
+            witnessStack.push(i < chunks.length ? chunks[i] : Buffer.alloc(0));
+        }
+        witnessStack.push(input.witnessScript);
+        return {
+            finalScriptSig: undefined,
+            finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness(witnessStack),
+        };
+    }
+    splitIntoWitnessChunks(data) {
+        const chunks = [];
+        let offset = 0;
+        while (offset < data.length) {
+            const size = Math.min(InteractionTransactionP2WDA.MAX_BYTES_PER_WITNESS, data.length - offset);
+            chunks.push(data.subarray(offset, offset + size));
+            offset += size;
+        }
+        return chunks;
+    }
+}
+InteractionTransactionP2WDA.MAX_WITNESS_FIELDS = 10;
+InteractionTransactionP2WDA.MAX_BYTES_PER_WITNESS = 80;

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

@@ -4,8 +4,8 @@ import { TransactionBuilder } from './TransactionBuilder.js';
 import { TransactionType } from '../enums/TransactionType.js';
 import { CalldataGenerator } from '../../generators/builders/CalldataGenerator.js';
 import { SharedInteractionParameters } from '../interfaces/ITransactionParameters.js';
-import { ITimeLockOutput } from '../mineable/TimelockGenerator.js';
 import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';
+import { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
 export declare abstract class SharedInteractionTransaction<T extends TransactionType> extends TransactionBuilder<T> {
     static readonly MAXIMUM_CALLDATA_SIZE: number;
     readonly randomBytes: Buffer;
@@ -14,7 +14,7 @@ export declare abstract class SharedInteractionTransaction<T extends Transaction
     protected abstract readonly compiledTargetScript: Buffer;
     protected abstract readonly scriptTree: Taptree;
     protected readonly challenge: ChallengeSolution;
-    protected readonly epochChallenge: ITimeLockOutput;
+    protected readonly epochChallenge: IP2WSHAddress;
     protected calldataGenerator: CalldataGenerator;
     protected readonly calldata: Buffer;
     protected abstract readonly contractSecret: Buffer;
@@ -23,7 +23,7 @@ export declare abstract class SharedInteractionTransaction<T extends Transaction
     protected constructor(parameters: SharedInteractionParameters);
     getContractSecret(): Buffer;
     getRndBytes(): Buffer;
-    getPreimage(): ChallengeSolution;
+    getChallenge(): ChallengeSolution;
     protected scriptSignerXOnlyPubKey(): Buffer;
     protected generateKeyPairFromSeed(): ECPairInterface;
     protected buildTransaction(): Promise<void>;
@@ -37,7 +37,7 @@ export declare abstract class SharedInteractionTransaction<T extends Transaction
     };
     protected signInputsWalletBased(transaction: Psbt): Promise<void>;
     protected signInputsNonWalletBased(transaction: Psbt): Promise<void>;
-    private createMineableRewardOutputs;
+    protected createMineableRewardOutputs(): Promise<void>;
     private getPubKeys;
     private generateRedeemScripts;
 }

package/build/transaction/builders/SharedInteractionTransaction.js

@@ -1,5 +1,5 @@
-import { PaymentType, toXOnly } from '@btc-vision/bitcoin';
-import { MINIMUM_AMOUNT_CA, MINIMUM_AMOUNT_REWARD, TransactionBuilder } from './TransactionBuilder.js';
+import { PaymentType, toXOnly, } from '@btc-vision/bitcoin';
+import { MINIMUM_AMOUNT_CA, MINIMUM_AMOUNT_REWARD, TransactionBuilder, } from './TransactionBuilder.js';
 import { CalldataGenerator } from '../../generators/builders/CalldataGenerator.js';
 import { Compressor } from '../../bytecode/Compressor.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
@@ -45,7 +45,7 @@ export class SharedInteractionTransaction extends TransactionBuilder {
     getRndBytes() {
         return this.randomBytes;
     }
-    getPreimage() {
+    getChallenge() {
         return this.challenge;
     }
     scriptSignerXOnlyPubKey() {

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/mineable/IP2WSHAddress.d.ts

@@ -0,0 +1,4 @@
+export interface IP2WSHAddress {
+    address: string;
+    witnessScript: Buffer;
+}

package/build/transaction/mineable/IP2WSHAddress.js

@@ -0,0 +1 @@
+export {};

package/build/transaction/mineable/TimelockGenerator.d.ts

@@ -1,9 +1,6 @@
 import { Network } from '@btc-vision/bitcoin';
-export interface ITimeLockOutput {
-    address: string;
-    witnessScript: Buffer;
-}
+import { IP2WSHAddress } from './IP2WSHAddress.js';
 export declare class TimeLockGenerator {
     private static readonly CSV_BLOCKS;
-    static generateTimeLockAddress(publicKey: Buffer, network?: Network, csvBlocks?: number): ITimeLockOutput;
+    static generateTimeLockAddress(publicKey: Buffer, network?: Network, csvBlocks?: number): IP2WSHAddress;
 }

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

@@ -5,6 +5,8 @@ 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';
+import { Buffer } from 'buffer';
+export type SupportedTransactionVersion = 1 | 2 | 3;
 export interface ITweakedTransactionData {
     readonly signer: Signer | ECPairInterface | UnisatSigner;
     readonly network: Network;
@@ -12,11 +14,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 +40,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 +80,24 @@ 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 finalizeSecondaryP2WDA(inputIndex: number, input: PsbtInput): {
+        finalScriptWitness: Buffer | undefined;
+        finalScriptSig: 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;