@btc-vision/transaction 1.4.0 → 1.5.1

package/src/keypair/EcKeyPair.ts

@@ -1,18 +1,23 @@
 import * as ecc from '@bitcoinerlab/secp256k1';
 import bip32, { BIP32API, BIP32Factory, BIP32Interface } from 'bip32';
-import {
+import bitcoin, {
     address,
+    fromOutputScript,
     initEccLib,
     Network,
     networks,
+    opcodes,
     payments,
+    script,
     Signer,
-    taggedHash,
     toXOnly,
 } from '@btc-vision/bitcoin';
 import { ECPairAPI, ECPairFactory, ECPairInterface } from 'ecpair';
 import { IWallet } from './interfaces/IWallet.js';
-import { CURVE, ProjectivePoint as Point } from '@noble/secp256k1';
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { bytesToNumberBE, concatBytes, utf8ToBytes } from '@noble/curves/abstract/utils';
+import { mod } from '@noble/curves/abstract/modular';
+import { sha256 } from '@noble/hashes/sha2';
 
 initEccLib(ecc);
 
@@ -21,10 +26,16 @@ if (!BIP32factory) {
     throw new Error('Failed to load BIP32 library');
 }
 
-const mod = (a: bigint, b: bigint): bigint => {
-    const result = a % b;
-    return result >= 0n ? result : result + b;
-};
+secp256k1.utils.precompute(8);
+
+const { ProjectivePoint: Point, CURVE } = secp256k1;
+
+const TAP_TAG = utf8ToBytes('TapTweak');
+const TAP_TAG_HASH = sha256(TAP_TAG);
+
+function tapTweakHash(x: Uint8Array): Uint8Array {
+    return sha256(concatBytes(TAP_TAG_HASH, TAP_TAG_HASH, x));
+}
 
 /**
  * Class for handling EC key pairs
@@ -195,6 +206,32 @@ export class EcKeyPair {
         return address;
     }
 
+    /**
+     * Generate a P2OP address
+     * @param bytes - The bytes to use for the P2OP address
+     * @param network - The network to use
+     * @param deploymentVersion - The deployment version (default is 0)
+     * @returns {string} - The generated P2OP address
+     */
+    public static p2op(
+        bytes: Buffer | Uint8Array,
+        network: Network = networks.bitcoin,
+        deploymentVersion: number = 0,
+    ): string {
+        // custom opnet contract addresses
+        const witnessProgram = Buffer.concat([
+            Buffer.from([deploymentVersion]),
+            bitcoin.crypto.hash160(Buffer.from(bytes)),
+        ]);
+
+        if (witnessProgram.length < 2 || witnessProgram.length > 40) {
+            throw new Error('Witness program must be 2-40 bytes.');
+        }
+
+        const scriptData = script.compile([opcodes.OP_16, witnessProgram]);
+        return fromOutputScript(scriptData, network);
+    }
+
     /**
      * Get the address of a xOnly tweaked public key
      * @param {string} tweakedPubKeyHex - The xOnly tweaked public key hex string
@@ -225,42 +262,44 @@ export class EcKeyPair {
 
     /**
      * Tweak a public key
-     * @param {string | Buffer} compressedPubKeyHex - The compressed public key hex string
+     * @param {Buffer | Uint8Array | string} pub - The public key to tweak
      * @returns {Buffer} - The tweaked public key hex string
      * @throws {Error} - If the public key cannot be tweaked
      */
-    public static tweakPublicKey(compressedPubKeyHex: string | Buffer): Buffer {
-        if (typeof compressedPubKeyHex === 'string' && compressedPubKeyHex.startsWith('0x')) {
-            compressedPubKeyHex = compressedPubKeyHex.slice(2);
-        }
-
-        if (typeof compressedPubKeyHex !== 'string') {
-            compressedPubKeyHex = compressedPubKeyHex.toString('hex');
-        }
+    public static tweakPublicKey(pub: Uint8Array | Buffer | string): Buffer {
+        if (typeof pub === 'string' && pub.startsWith('0x')) pub = pub.slice(2);
 
-        // Convert the compressed public key hex string to a Point on the curve
-        let P = Point.fromHex(compressedPubKeyHex);
+        const P = Point.fromHex(pub);
+        const Peven = (P.y & 1n) === 0n ? P : P.negate();
 
-        // Ensure the point has an even y-coordinate
-        if ((P.y & 1n) !== 0n) {
-            // Negate the point to get an even y-coordinate
-            P = P.negate();
-        }
-
-        // Get the x-coordinate (32 bytes) of the point
-        const x = P.toRawBytes(true).slice(1); // Remove the prefix byte
-
-        // Compute the tweak t = H_tapTweak(x)
-        const tHash = taggedHash('TapTweak', Buffer.from(x));
-        const t = mod(BigInt('0x' + Buffer.from(tHash).toString('hex')), CURVE.n);
+        const xBytes = Peven.toRawBytes(true).subarray(1);
+        const tBytes = tapTweakHash(xBytes);
+        const t = mod(bytesToNumberBE(tBytes), CURVE.n);
 
-        // Compute Q = P + t*G (where G is the generator point)
-        const Q = P.add(Point.BASE.mul(t));
-
-        // Return the tweaked public key in compressed form (hex string)
+        const Q = Peven.add(Point.BASE.multiply(t));
         return Buffer.from(Q.toRawBytes(true));
     }
 
+    /**
+     * Tweak a batch of public keys
+     * @param {readonly Uint8Array[]} pubkeys - The public keys to tweak
+     * @param {bigint} tweakScalar - The scalar to use for tweaking
+     * @returns {Uint8Array[]} - The tweaked public keys
+     */
+    public static tweakBatchSharedT(
+        pubkeys: readonly Uint8Array[],
+        tweakScalar: bigint,
+    ): Uint8Array[] {
+        const T = Point.BASE.multiply(tweakScalar);
+
+        return pubkeys.map((bytes) => {
+            const P = Point.fromHex(bytes);
+            const P_even = P.hasEvenY() ? P : P.negate();
+            const Q = P_even.add(T);
+            return Q.toRawBytes(true);
+        });
+    }
+
     /**
      * Generate a random wallet
      * @param {Network} network - The network to use
@@ -337,6 +376,24 @@ export class EcKeyPair {
         return wallet.address;
     }
 
+    /**
+     * Get the legacy address from a keypair
+     * @param publicKey
+     * @param {Network} network - The network to use
+     * @returns {string} - The legacy address
+     */
+    public static getP2PKH(
+        publicKey: Buffer | Uint8Array,
+        network: Network = networks.bitcoin,
+    ): string {
+        const wallet = payments.p2pkh({ pubkey: Buffer.from(publicKey), network: network });
+        if (!wallet.address) {
+            throw new Error('Failed to generate wallet');
+        }
+
+        return wallet.address;
+    }
+
     /**
      * Get the legacy address from a keypair
      * @param {ECPairInterface} keyPair - The keypair to get the address for

package/src/transaction/TransactionFactory.ts

@@ -30,8 +30,6 @@ export interface DeploymentResult {
 
     readonly contractAddress: string;
     readonly contractPubKey: string;
-    readonly p2trAddress: string;
-
     readonly preimage: string;
 
     readonly utxos: UTXO[];
@@ -89,13 +87,22 @@ export class TransactionFactory {
             throw new Error('Field "from" not provided.');
         }
 
+        if (!interactionParameters.utxos[0]) {
+            throw new Error('Missing at least one UTXO.');
+        }
+
+        if (!('signer' in interactionParameters)) {
+            throw new Error('Field "signer" not provided, OP_WALLET not detected.');
+        }
+
+        const inputs = this.parseOptionalInputs(interactionParameters.optionalInputs);
         const preTransaction: CustomScriptTransaction = new CustomScriptTransaction({
             ...interactionParameters,
             utxos: [interactionParameters.utxos[0]], // we simulate one input here.
+            optionalInputs: inputs,
         });
 
         // we don't sign that transaction, we just need the parameters.
-
         await preTransaction.generateTransactionMinimalSignatures();
 
         const parameters: IFundingTransactionParameters =
@@ -119,7 +126,12 @@ export class TransactionFactory {
 
         parameters.estimatedFees = feeEstimationFundingTransaction.estimatedFees;
 
-        const signedTransaction = await this.createFundTransaction(parameters);
+        const signedTransaction = await this.createFundTransaction({
+            ...parameters,
+            optionalOutputs: [],
+            optionalInputs: [],
+        });
+
         if (!signedTransaction) {
             throw new Error('Could not sign funding transaction.');
         }
@@ -132,10 +144,13 @@ export class TransactionFactory {
 
         const newParams: ICustomTransactionParameters = {
             ...interactionParameters,
-            utxos: this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.to, 0), // always 0
+            utxos: [
+                ...this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.to, 0),
+            ], // always 0
             randomBytes: preTransaction.getRndBytes(),
             nonWitnessUtxo: signedTransaction.tx.toBuffer(),
             estimatedFees: preTransaction.estimatedFees,
+            optionalInputs: inputs,
         };
 
         const finalTransaction: CustomScriptTransaction = new CustomScriptTransaction(newParams);
@@ -352,9 +367,8 @@ export class TransactionFactory {
 
         return {
             transaction: [signedTransaction.toHex(), outTx.toHex()],
-            contractAddress: finalTransaction.contractAddress.p2tr(deploymentParameters.network),
+            contractAddress: finalTransaction.getContractAddress(), //finalTransaction.contractAddress.p2tr(deploymentParameters.network),
             contractPubKey: finalTransaction.contractPubKey,
-            p2trAddress: finalTransaction.p2trAddress,
             utxos: [refundUTXO],
             preimage: preTransaction.getPreimage().toString('hex'),
         };

package/src/transaction/browser/Web3Provider.ts

@@ -4,6 +4,7 @@ import {
 } from '../interfaces/ITransactionParameters.js';
 import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { DeploymentResult, InteractionResponse } from '../TransactionFactory';
+import { ICustomTransactionParameters } from '../builders/CustomScriptTransaction.js';
 
 export type InteractionParametersWithoutSigner = Omit<
     IInteractionParameters,
@@ -15,6 +16,11 @@ export type IDeploymentParametersWithoutSigner = Omit<
     'signer' | 'network' | 'preimage'
 >;
 
+export type CustomTransactionWithoutSigner = Omit<
+    ICustomTransactionParameters,
+    'signer' | 'preimage'
+>;
+
 export interface BroadcastTransactionOptions {
     raw: string;
     psbt: boolean;

package/src/transaction/builders/CustomScriptTransaction.ts

@@ -1,6 +1,8 @@
 import {
     crypto as bitCrypto,
+    P2TRPayment,
     Payment,
+    PaymentType,
     Psbt,
     PsbtInput,
     Signer,
@@ -19,10 +21,13 @@ import { AddressGenerator } from '../../generators/AddressGenerator.js';
 import { ECPairInterface } from 'ecpair';
 
 export interface ICustomTransactionParameters extends SharedInteractionParameters {
-    readonly script: (Buffer | Stack)[];
-    readonly witnesses: Buffer[];
+    script: (Buffer | Stack)[];
+    witnesses: Buffer[];
 
-    readonly to: string;
+    /** optional Taproot annex payload (without the 0x50 prefix) */
+    annex?: Buffer;
+
+    to: string;
 }
 
 /**
@@ -46,12 +51,12 @@ export class CustomScriptTransaction extends TransactionBuilder<TransactionType.
      * The target script redeem
      * @private
      */
-    private targetScriptRedeem: Payment | null = null;
+    private targetScriptRedeem: P2TRPayment | null = null;
     /**
      * The left over funds script redeem
      * @private
      */
-    private leftOverFundsScriptRedeem: Payment | null = null;
+    private leftOverFundsScriptRedeem: P2TRPayment | null = null;
     /**
      * The compiled target script
      * @private
@@ -91,6 +96,7 @@ export class CustomScriptTransaction extends TransactionBuilder<TransactionType.
      * @private
      */
     private readonly witnesses: Buffer[];
+    private readonly annexData?: Buffer;
 
     public constructor(parameters: ICustomTransactionParameters) {
         super(parameters);
@@ -154,7 +160,7 @@ export class CustomScriptTransaction extends TransactionBuilder<TransactionType.
             this.to = this.getScriptAddress();
         }
 
-        const selectedRedeem = this.contractSigner
+        const selectedRedeem: Payment | null = this.contractSigner
             ? this.targetScriptRedeem
             : this.leftOverFundsScriptRedeem;
 
@@ -202,7 +208,10 @@ export class CustomScriptTransaction extends TransactionBuilder<TransactionType.
         for (let i = 0; i < transaction.data.inputs.length; i++) {
             if (i === 0) {
                 // multi sig input
-                transaction.signInput(0, this.contractSigner);
+                try {
+                    transaction.signInput(0, this.contractSigner);
+                } catch (e) {}
+
                 transaction.signInput(0, this.getSignerKey());
 
                 transaction.finalizeInput(0, this.customFinalizer);
@@ -217,11 +226,12 @@ export class CustomScriptTransaction extends TransactionBuilder<TransactionType.
      * Get the tap output
      * @protected
      */
-    protected override generateScriptAddress(): Payment {
+    protected override generateScriptAddress(): P2TRPayment {
         return {
             internalPubkey: this.internalPubKeyToXOnly(),
             network: this.network,
             scriptTree: this.scriptTree,
+            name: PaymentType.P2TR,
         };
     }
 
@@ -229,7 +239,7 @@ export class CustomScriptTransaction extends TransactionBuilder<TransactionType.
      * Generate the tap data
      * @protected
      */
-    protected override generateTapData(): Payment {
+    protected override generateTapData(): P2TRPayment {
         const selectedRedeem = this.contractSigner
             ? this.targetScriptRedeem
             : this.leftOverFundsScriptRedeem;
@@ -247,9 +257,25 @@ export class CustomScriptTransaction extends TransactionBuilder<TransactionType.
             network: this.network,
             scriptTree: this.scriptTree,
             redeem: selectedRedeem,
+            name: PaymentType.P2TR,
         };
     }
 
+    protected getScriptSolution(input: PsbtInput): Buffer[] {
+        if (!input.tapScriptSig) {
+            throw new Error('Tap script signature is required');
+        }
+
+        const witnesses: Buffer[] = [...this.witnesses];
+        if (input.tapScriptSig) {
+            for (const sig of input.tapScriptSig) {
+                witnesses.push(sig.signature);
+            }
+        }
+
+        return witnesses;
+    }
+
     /**
      * Generate the contract seed for the deployment
      * @private
@@ -261,18 +287,27 @@ export class CustomScriptTransaction extends TransactionBuilder<TransactionType.
     /**
      * Finalize the transaction
      * @param _inputIndex
-     * @param _input
+     * @param input
      */
-    private customFinalizer = (_inputIndex: number, _input: PsbtInput) => {
+    private customFinalizer = (_inputIndex: number, input: PsbtInput) => {
         if (!this.tapLeafScript) {
             throw new Error('Tap leaf script is required');
         }
 
-        const scriptSolution = this.witnesses;
+        const scriptSolution = this.getScriptSolution(input);
         const witness = scriptSolution
             .concat(this.tapLeafScript.script)
             .concat(this.tapLeafScript.controlBlock);
 
+        if (this.annexData && this.annexData.length > 0) {
+            const annex =
+                this.annexData[0] === 0x50
+                    ? this.annexData
+                    : Buffer.concat([Buffer.from([0x50]), this.annexData]);
+
+            witness.push(annex);
+        }
+
         return {
             finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness(witness),
         };
@@ -298,13 +333,15 @@ export class CustomScriptTransaction extends TransactionBuilder<TransactionType.
      */
     private generateRedeemScripts(): void {
         this.targetScriptRedeem = {
-            pubkeys: this.getPubKeys(),
+            name: PaymentType.P2TR,
+            //pubkeys: this.getPubKeys(),
             output: this.compiledTargetScript,
             redeemVersion: 192,
         };
 
         this.leftOverFundsScriptRedeem = {
-            pubkeys: this.getPubKeys(),
+            name: PaymentType.P2TR,
+            //pubkeys: this.getPubKeys(),
             output: this.getLeafScript(),
             redeemVersion: 192,
         };

package/src/transaction/builders/DeploymentTransaction.ts

@@ -2,7 +2,8 @@ import { TransactionType } from '../enums/TransactionType.js';
 import { IDeploymentParameters } from '../interfaces/ITransactionParameters.js';
 import {
     crypto as bitCrypto,
-    Payment,
+    P2TRPayment,
+    PaymentType,
     Psbt,
     PsbtInput,
     Signer,
@@ -15,7 +16,10 @@ import {
     TransactionBuilder,
 } from './TransactionBuilder.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
-import { DeploymentGenerator } from '../../generators/builders/DeploymentGenerator.js';
+import {
+    DeploymentGenerator,
+    versionBuffer,
+} from '../../generators/builders/DeploymentGenerator.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
 import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
 import { Compressor } from '../../bytecode/Compressor.js';
@@ -25,15 +29,13 @@ import { Address } from '../../keypair/Address.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
 import { ChallengeGenerator, IMineableReward } from '../mineable/ChallengeGenerator.js';
 
-const p = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn;
-
 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;
-
     /**
      * The contract address
      * @protected
@@ -44,16 +46,17 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
      * @private
      */
     protected tapLeafScript: TapLeafScript | null = null;
+    private readonly deploymentVersion: number = 0x00;
     /**
      * The target script redeem
      * @private
      */
-    private targetScriptRedeem: Payment | null = null;
+    private targetScriptRedeem: P2TRPayment | null = null;
     /**
      * The left over funds script redeem
      * @private
      */
-    private leftOverFundsScriptRedeem: Payment | null = null;
+    private leftOverFundsScriptRedeem: P2TRPayment | null = null;
     /**
      * The compiled target script
      * @private
@@ -105,12 +108,13 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
      * @private
      */
     private readonly randomBytes: Buffer;
+    private _computedAddress: string | undefined;
 
     public constructor(parameters: IDeploymentParameters) {
-        // TODO: Add legacy deployment, this is only p2tr.
         super(parameters);
 
-        this.bytecode = Compressor.compress(parameters.bytecode);
+        this.bytecode = Compressor.compress(Buffer.concat([versionBuffer, parameters.bytecode]));
+
         this.verifyBytecode();
 
         if (parameters.calldata) {
@@ -190,6 +194,20 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         return this.preimage;
     }
 
+    public getContractAddress(): string {
+        if (this._computedAddress) {
+            return this._computedAddress;
+        }
+
+        this._computedAddress = EcKeyPair.p2op(
+            this.contractSeed,
+            this.network,
+            this.deploymentVersion,
+        );
+
+        return this._computedAddress;
+    }
+
     /**
      * Get the contract signer public key
      * @protected
@@ -243,7 +261,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         // ALWAYS THE FIRST INPUT.
         this.addOutput({
             value: Number(amountToCA),
-            address: this.contractAddress.p2tr(this.network),
+            address: this.getContractAddress(),
         });
 
         // ALWAYS SECOND.
@@ -323,8 +341,9 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
      * Get the tap output
      * @protected
      */
-    protected override generateScriptAddress(): Payment {
+    protected override generateScriptAddress(): P2TRPayment {
         return {
+            name: PaymentType.P2TR,
             internalPubkey: this.internalPubKeyToXOnly(),
             network: this.network,
             scriptTree: this.scriptTree,
@@ -335,7 +354,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
      * Generate the tap data
      * @protected
      */
-    protected override generateTapData(): Payment {
+    protected override generateTapData(): P2TRPayment {
         const selectedRedeem = this.contractSigner
             ? this.targetScriptRedeem
             : this.leftOverFundsScriptRedeem;
@@ -349,6 +368,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         }
 
         return {
+            name: PaymentType.P2TR,
             internalPubkey: this.internalPubKeyToXOnly(),
             network: this.network,
             scriptTree: this.scriptTree,
@@ -440,13 +460,15 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
      */
     private generateRedeemScripts(): void {
         this.targetScriptRedeem = {
-            pubkeys: this.getPubKeys(),
+            name: PaymentType.P2TR,
+            //pubkeys: this.getPubKeys(),
             output: this.compiledTargetScript,
             redeemVersion: 192,
         };
 
         this.leftOverFundsScriptRedeem = {
-            pubkeys: this.getPubKeys(),
+            name: PaymentType.P2TR,
+            //pubkeys: this.getPubKeys(),
             output: this.getLeafScript(),
             redeemVersion: 192,
         };

package/src/transaction/builders/MultiSignTransaction.ts

@@ -1,7 +1,8 @@
 import {
     crypto as bitcoinCrypto,
     opcodes,
-    Payment,
+    P2TRPayment,
+    PaymentType,
     Psbt,
     PsbtInput,
     PsbtInputExtended,
@@ -58,8 +59,8 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
 
     public type: TransactionType.MULTI_SIG = TransactionType.MULTI_SIG;
 
-    protected targetScriptRedeem: Payment | null = null;
-    protected leftOverFundsScriptRedeem: Payment | null = null;
+    protected targetScriptRedeem: P2TRPayment | null = null;
+    protected leftOverFundsScriptRedeem: P2TRPayment | null = null;
 
     protected readonly compiledTargetScript: Buffer;
     protected readonly scriptTree: Taptree;
@@ -545,16 +546,16 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
      */
     protected override async signInputs(_transaction: Psbt): Promise<void> {}
 
-    protected override generateScriptAddress(): Payment {
+    protected override generateScriptAddress(): P2TRPayment {
         return {
             internalPubkey: toXOnly(MultiSignTransaction.numsPoint), //this.internalPubKeyToXOnly(),
             network: this.network,
             scriptTree: this.scriptTree,
-            //pubkeys: this.publicKeys,
+            name: PaymentType.P2TR,
         };
     }
 
-    protected override generateTapData(): Payment {
+    protected override generateTapData(): P2TRPayment {
         const selectedRedeem = this.targetScriptRedeem;
         if (!selectedRedeem) {
             throw new Error('Left over funds script redeem is required');
@@ -569,6 +570,7 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
             network: this.network,
             scriptTree: this.scriptTree,
             redeem: selectedRedeem,
+            name: PaymentType.P2TR,
         };
     }
 
@@ -662,11 +664,13 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
      */
     private generateRedeemScripts(): void {
         this.targetScriptRedeem = {
+            name: PaymentType.P2TR,
             output: this.compiledTargetScript,
             redeemVersion: 192,
         };
 
         this.leftOverFundsScriptRedeem = {
+            name: PaymentType.P2TR,
             output: MultiSignTransaction.LOCK_LEAF_SCRIPT,
             redeemVersion: 192,
         };