@btc-vision/transaction 1.8.0-beta.0 → 1.8.0-beta.10

package/src/signer/AddressRotation.ts

@@ -1,4 +1,4 @@
-import { RotationSignerBase } from './IRotationSigner.js';
+import type { RotationSignerBase } from './IRotationSigner.js';
 import { UnisatSigner } from '../transaction/browser/extensions/UnisatSigner.js';
 
 /**

package/src/signer/IRotationSigner.ts

@@ -1,12 +1,12 @@
-import { Signer } from '@btc-vision/bitcoin';
-import { ECPairInterface } from 'ecpair';
+import type { Signer } from '@btc-vision/bitcoin';
+import { type UniversalSigner } from '@btc-vision/ecpair';
 
 /**
  * Base signer type for address rotation.
  * This is the minimal interface required for UTXO signing.
  * UnisatSigner extends this through the CustomKeypair base class.
  */
-export type RotationSignerBase = Signer | ECPairInterface;
+export type RotationSignerBase = Signer | UniversalSigner;
 
 /**
  * Map of addresses to their respective signers for address rotation mode.

package/src/signer/ParallelSignerAdapter.ts

@@ -0,0 +1,59 @@
+import type { PsbtParallelKeyPair } from '@btc-vision/bitcoin';
+import type { UniversalSigner } from '@btc-vision/ecpair';
+import { createPrivateKey, createPublicKey } from '@btc-vision/ecpair';
+
+/**
+ * Wraps an untweaked UniversalSigner as PsbtParallelKeyPair.
+ * Used for script-path signing (raw private key needed).
+ */
+export function toParallelKeyPair(signer: UniversalSigner): PsbtParallelKeyPair {
+    return {
+        publicKey: signer.publicKey,
+        getPrivateKey(): Uint8Array {
+            if (!signer.privateKey) {
+                throw new Error('Signer does not have a private key');
+            }
+            return createPrivateKey(signer.privateKey);
+        },
+        sign(hash: Uint8Array, lowR?: boolean): Uint8Array {
+            return signer.sign(hash as Parameters<typeof signer.sign>[0], lowR);
+        },
+        signSchnorr(hash: Uint8Array): Uint8Array {
+            if (!signer.signSchnorr) {
+                throw new Error('Signer does not support Schnorr signing');
+            }
+            return signer.signSchnorr(hash as Parameters<typeof signer.signSchnorr>[0]);
+        },
+    };
+}
+
+/**
+ * Creates a hybrid adapter with untweaked publicKey (for PSBT input matching)
+ * but tweaked privateKey (for correct key-path Schnorr signatures).
+ * Uses createPrivateKey/createPublicKey for branded type validation.
+ */
+export function toTweakedParallelKeyPair(
+    untweakedSigner: UniversalSigner,
+    tweakedSigner: UniversalSigner,
+): PsbtParallelKeyPair {
+    return {
+        publicKey: createPublicKey(untweakedSigner.publicKey),
+        getPrivateKey(): Uint8Array {
+            if (!tweakedSigner.privateKey) {
+                throw new Error('Tweaked signer does not have a private key');
+            }
+            return createPrivateKey(tweakedSigner.privateKey);
+        },
+        sign(hash: Uint8Array, lowR?: boolean): Uint8Array {
+            return tweakedSigner.sign(hash as Parameters<typeof tweakedSigner.sign>[0], lowR);
+        },
+        signSchnorr(hash: Uint8Array): Uint8Array {
+            if (!tweakedSigner.signSchnorr) {
+                throw new Error('Tweaked signer does not support Schnorr signing');
+            }
+            return tweakedSigner.signSchnorr(
+                hash as Parameters<typeof tweakedSigner.signSchnorr>[0],
+            );
+        },
+    };
+}

package/src/signer/SignerUtils.ts

@@ -1,5 +1,5 @@
 // Helper functions
-import { isP2TR, PsbtInput, pubkeyPositionInScript } from '@btc-vision/bitcoin';
+import { isP2TR, type PsbtInput, pubkeyPositionInScript } from '@btc-vision/bitcoin';
 
 export function isTaprootInput(input: PsbtInput): boolean {
     return (
@@ -14,7 +14,7 @@ export function isTaprootInput(input: PsbtInput): boolean {
     );
 }
 
-export function getInputRelevantScript(input: PsbtInput): Buffer | null {
+export function getInputRelevantScript(input: PsbtInput): Uint8Array | null {
     if (input.redeemScript) {
         return input.redeemScript;
     }
@@ -37,7 +37,7 @@ export function getInputRelevantScript(input: PsbtInput): Buffer | null {
     return null;
 }
 
-export function canSignNonTaprootInput(input: PsbtInput, publicKey: Buffer): boolean {
+export function canSignNonTaprootInput(input: PsbtInput, publicKey: Uint8Array): boolean {
     if (
         (input.nonWitnessUtxo &&
             !input.redeemScript &&
@@ -61,6 +61,6 @@ export function canSignNonTaprootInput(input: PsbtInput, publicKey: Buffer): boo
  * @param script The script to search in.
  * @returns A boolean indicating whether the public key is present in the script.
  */
-export function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean {
+export function pubkeyInScript(pubkey: Uint8Array, script: Uint8Array): boolean {
     return pubkeyPositionInScript(pubkey, script) !== -1;
 }

package/src/signer/TweakedSigner.ts

@@ -1,10 +1,15 @@
-import * as ecc from '@bitcoinerlab/secp256k1';
-import { initEccLib, Network, Signer, tapTweakHash, toXOnly } from '@btc-vision/bitcoin';
-import { ECPairInterface } from 'ecpair';
+import { backend } from '../ecc/backend.js';
+import {
+    type Bytes32,
+    type Network,
+    type PrivateKey,
+    type Signer,
+    tapTweakHash,
+    toXOnly,
+} from '@btc-vision/bitcoin';
+import { type UniversalSigner } from '@btc-vision/ecpair';
 import { EcKeyPair } from '../keypair/EcKeyPair.js';
 
-initEccLib(ecc);
-
 /**
  * Tweak settings
  */
@@ -17,7 +22,14 @@ export interface TweakSettings {
     /**
      * The tweak hash to use
      */
-    tweakHash?: Buffer;
+    tweakHash?: Bytes32;
+}
+
+/**
+ * Type guard to check if a Signer is a UniversalSigner (has privateKey).
+ */
+export function isUniversalSigner(signer: Signer): signer is UniversalSigner {
+    return 'privateKey' in signer && signer.privateKey != null;
 }
 
 /**
@@ -27,29 +39,29 @@ export interface TweakSettings {
 export class TweakedSigner {
     /**
      * Tweak a signer
-     * @param {Signer} signer - The signer to tweak
+     * @param {UniversalSigner} signer - The signer to tweak (must have privateKey)
      * @param {TweakSettings} opts - The tweak settings
-     * @returns {ECPairInterface} - The tweaked signer
+     * @returns {UniversalSigner} - The tweaked signer
      */
-    public static tweakSigner(signer: ECPairInterface, opts: TweakSettings = {}): ECPairInterface {
-        let privateKey: Uint8Array | undefined = signer.privateKey;
+    public static tweakSigner(signer: UniversalSigner, opts: TweakSettings = {}): UniversalSigner {
+        let privateKey: PrivateKey | undefined = signer.privateKey;
         if (!privateKey) {
             throw new Error('Private key is required for tweaking signer!');
         }
 
         if (signer.publicKey[0] === 3) {
-            privateKey = ecc.privateNegate(privateKey);
+            privateKey = backend.privateNegate(privateKey);
         }
 
-        const tweakedPrivateKey = ecc.privateAdd(
+        const tweakedPrivateKey = backend.privateAdd(
             privateKey,
-            tapTweakHash(toXOnly(Buffer.from(signer.publicKey)), opts.tweakHash),
+            tapTweakHash(toXOnly(signer.publicKey), opts.tweakHash),
         );
 
         if (!tweakedPrivateKey) {
             throw new Error('Invalid tweaked private key!');
         }
 
-        return EcKeyPair.fromPrivateKey(Buffer.from(tweakedPrivateKey), opts.network);
+        return EcKeyPair.fromPrivateKey(tweakedPrivateKey, opts.network);
     }
 }

package/src/transaction/ContractAddress.ts

@@ -3,14 +3,10 @@ import { Secp256k1PointDeriver } from '../keypair/Secp256k1PointDeriver.js';
 class ContractAddressBase {
     private readonly deriver: Secp256k1PointDeriver = new Secp256k1PointDeriver();
 
-    public generateHybridKeyFromHash(input: Buffer): Buffer {
-        const p = this.deriver.findOrDeriveValidPoint(this.cloneBuffer(input), false);
+    public generateHybridKeyFromHash(input: Uint8Array): Uint8Array {
+        const p = this.deriver.findOrDeriveValidPoint(new Uint8Array(input), false);
         const y = this.deriver.getCanonicalY(p.y1, p.y2);
-        return Buffer.from(this.deriver.getHybridPublicKey(p.x, y));
-    }
-
-    private cloneBuffer(buffer: Buffer): Buffer {
-        return Buffer.from(buffer);
+        return new Uint8Array(this.deriver.getHybridPublicKey(p.x, y));
     }
 }
 

package/src/transaction/TransactionFactory.ts

@@ -1,41 +1,46 @@
-import { Transaction, TxOutput } from '@btc-vision/bitcoin';
-import { currentConsensus } from '../consensus/ConsensusConfig.js';
-import { UTXO } from '../utxo/interfaces/IUTXO.js';
+import {
+    type PsbtOutputExtended,
+    type Script,
+    toHex,
+    toSatoshi,
+    Transaction,
+    type TxOutput,
+} from '@btc-vision/bitcoin';
+import type { UTXO } from '../utxo/interfaces/IUTXO.js';
 import { CustomScriptTransaction } from './builders/CustomScriptTransaction.js';
 import { DeploymentTransaction } from './builders/DeploymentTransaction.js';
 import { FundingTransaction } from './builders/FundingTransaction.js';
 import { InteractionTransaction } from './builders/InteractionTransaction.js';
 import { TransactionBuilder } from './builders/TransactionBuilder.js';
 import { TransactionType } from './enums/TransactionType.js';
-import {
+import type {
     IDeploymentParameters,
     IFundingTransactionParameters,
     IInteractionParameters,
     ITransactionParameters,
 } from './interfaces/ITransactionParameters.js';
-import { PSBTTypes } from './psbt/PSBTTypes.js';
-import {
+import type {
     ICancelTransactionParametersWithoutSigner,
     ICustomTransactionWithoutSigner,
     IDeploymentParametersWithoutSigner,
     InteractionParametersWithoutSigner,
 } from './interfaces/IWeb3ProviderTypes.js';
-import { WindowWithWallets } from './browser/extensions/UnisatSigner.js';
-import { IChallengeSolution, RawChallenge } from '../epoch/interfaces/IChallengeSolution.js';
+import type { WindowWithWallets } from './browser/extensions/UnisatSigner.js';
+import type { IChallengeSolution, RawChallenge } from '../epoch/interfaces/IChallengeSolution.js';
 import { P2WDADetector } from '../p2wda/P2WDADetector.js';
 import { InteractionTransactionP2WDA } from './builders/InteractionTransactionP2WDA.js';
 import { Address } from '../keypair/Address.js';
 import { BitcoinUtils } from '../utils/BitcoinUtils.js';
 import { CancelTransaction } from './builders/CancelTransaction.js';
 import { ConsolidatedInteractionTransaction } from './builders/ConsolidatedInteractionTransaction.js';
-import { IConsolidatedInteractionParameters } from './interfaces/IConsolidatedTransactionParameters.js';
-import {
+import type { IConsolidatedInteractionParameters } from './interfaces/IConsolidatedTransactionParameters.js';
+import type {
     CancelledTransaction,
     DeploymentResult,
     InteractionResponse,
 } from './interfaces/ITransactionResponses.js';
-import { ICancelTransactionParameters } from './interfaces/ICancelTransactionParameters.js';
-import { ICustomTransactionParameters } from './interfaces/ICustomTransactionParameters.js';
+import type { ICancelTransactionParameters } from './interfaces/ICancelTransactionParameters.js';
+import type { ICustomTransactionParameters } from './interfaces/ICustomTransactionParameters.js';
 
 export interface FundingTransactionResponse {
     readonly tx: Transaction;
@@ -86,8 +91,8 @@ export interface ConsolidatedInteractionResponse {
 export class TransactionFactory {
     public debug: boolean = false;
 
-    private readonly DUMMY_PUBKEY = Buffer.alloc(32, 1);
-    private readonly P2TR_SCRIPT = Buffer.concat([Buffer.from([0x51, 0x20]), this.DUMMY_PUBKEY]);
+    private readonly DUMMY_PUBKEY = new Uint8Array(32).fill(1);
+    private readonly P2TR_SCRIPT = Uint8Array.from([0x51, 0x20, ...this.DUMMY_PUBKEY]) as Script;
     private readonly INITIAL_FUNDING_ESTIMATE = 2000n;
     private readonly MAX_ITERATIONS = 10;
 
@@ -152,7 +157,7 @@ export class TransactionFactory {
 
         const inputs = this.parseOptionalInputs(interactionParameters.optionalInputs);
 
-        const { finalTransaction, estimatedAmount, challenge } = await this.iterateFundingAmount(
+        const { finalTransaction, estimatedAmount } = await this.iterateFundingAmount(
             { ...interactionParameters, optionalInputs: inputs },
             CustomScriptTransaction,
             async (tx) => {
@@ -322,7 +327,7 @@ export class TransactionFactory {
             challenge: challenge.toRaw(),
             fundingUTXOs: fundingUTXO,
             fundingInputUtxos: interactionParameters.utxos,
-            compiledTargetScript: interactionTx.exportCompiledTargetScript().toString('hex'),
+            compiledTargetScript: toHex(interactionTx.exportCompiledTargetScript()),
         };
     }
 
@@ -380,7 +385,7 @@ export class TransactionFactory {
             dataSize: result.setup.totalDataSize,
             challenge: consolidatedTx.getChallenge().toRaw(),
             inputUtxos: interactionParameters.utxos,
-            compiledTargetScript: consolidatedTx.exportCompiledTargetScript().toString('hex'),
+            compiledTargetScript: toHex(consolidatedTx.exportCompiledTargetScript()),
         };
     }
 
@@ -448,12 +453,12 @@ export class TransactionFactory {
             throw new Error('Could not sign funding transaction.');
         }
 
-        const out = signedTransaction.outs[0];
+        const out = signedTransaction.outs[0] as TxOutput;
         const newUtxo: UTXO = {
             transactionId: signedTransaction.getId(),
             outputIndex: 0,
             scriptPubKey: {
-                hex: out.script.toString('hex'),
+                hex: toHex(out.script),
                 address: finalTransaction.getScriptAddress(),
             },
             value: BigInt(out.value),
@@ -473,13 +478,13 @@ export class TransactionFactory {
         const deploymentTx = new DeploymentTransaction(newParams);
         const outTx = await deploymentTx.signTransaction();
 
-        const out2 = signedTransaction.outs[1];
+        const out2 = signedTransaction.outs[1] as TxOutput;
         const refundUTXO: UTXO = {
             transactionId: signedTransaction.getId(),
             outputIndex: 1,
             scriptPubKey: {
-                hex: out2.script.toString('hex'),
-                address: deploymentParameters.from,
+                hex: toHex(out2.script),
+                address: deploymentParameters.from as string,
             },
             value: BigInt(out2.value),
         };
@@ -532,7 +537,7 @@ export class TransactionFactory {
 
         const utxos: UTXO[] = [];
         for (let i = 0; i < tx.outs.length; i++) {
-            const output = outputs[i];
+            const output = outputs[i] as PsbtOutputExtended;
             if ('address' in output) {
                 if (output.address !== to) continue;
             } else {
@@ -558,17 +563,13 @@ export class TransactionFactory {
                 !(nonWitness instanceof Uint8Array) &&
                 typeof nonWitness === 'object'
             ) {
-                nonWitness = Buffer.from(
-                    Uint8Array.from(
-                        Object.values(input.nonWitnessUtxo as unknown as Record<number, number>),
-                    ),
-                );
+                nonWitness = Uint8Array.from(Object.values(nonWitness as Record<string, number>));
             }
 
             return {
                 ...input,
                 nonWitnessUtxo: nonWitness,
-            };
+            } as UTXO;
         });
     }
 
@@ -715,22 +716,6 @@ export class TransactionFactory {
         return utxos.some((utxo) => P2WDADetector.isP2WDAUTXO(utxo));
     }
 
-    /**
-     * Write PSBT header with type and consensus version.
-     * @param {PSBTTypes} type - The PSBT type
-     * @param {string} psbt - The base64 encoded PSBT
-     * @returns {string} - The hex encoded PSBT with header
-     */
-    private writePSBTHeader(type: PSBTTypes, psbt: string): string {
-        const buf = Buffer.from(psbt, 'base64');
-
-        const header = Buffer.alloc(2);
-        header.writeUInt8(type, 0);
-        header.writeUInt8(currentConsensus, 1);
-
-        return Buffer.concat([header, buf]).toString('hex');
-    }
-
     /**
      * Sign a P2WDA interaction transaction
      *
@@ -807,11 +792,11 @@ export class TransactionFactory {
      * This method iteratively estimates the required funding amount by simulating
      * transactions until the amount converges or max iterations is reached.
      *
-     * @param {P} params - The transaction parameters
+     * @param {P extends IInteractionParameters | IDeploymentParameters | ICustomTransactionParameters} params - The transaction parameters
      * @param {new (params: P) => T} TransactionClass - The transaction class constructor
-     * @param {(tx: T) => Promise<bigint>} calculateAmount - Function to calculate required amount
+     * @param {(tx: T extends InteractionTransaction | DeploymentTransaction | CustomScriptTransaction) => Promise<bigint>} calculateAmount - Function to calculate required amount
      * @param {string} debugPrefix - Prefix for debug logging
-     * @returns {Promise<{finalTransaction: T, estimatedAmount: bigint, challenge: IChallengeSolution | null}>} - The final transaction and estimated amount
+     * @returns {Promise<{finalTransaction: T extends InteractionTransaction | DeploymentTransaction | CustomScriptTransaction, estimatedAmount: bigint, challenge: IChallengeSolution | null}>} - The final transaction and estimated amount
      */
     private async iterateFundingAmount<
         T extends InteractionTransaction | DeploymentTransaction | CustomScriptTransaction,
@@ -843,13 +828,13 @@ export class TransactionFactory {
             previousAmount = estimatedFundingAmount;
 
             const dummyTx = new Transaction();
-            dummyTx.addOutput(this.P2TR_SCRIPT, Number(estimatedFundingAmount));
+            dummyTx.addOutput(this.P2TR_SCRIPT, toSatoshi(estimatedFundingAmount));
 
             const simulatedFundedUtxo: UTXO = {
-                transactionId: Buffer.alloc(32, 0).toString('hex'),
+                transactionId: toHex(new Uint8Array(32)),
                 outputIndex: 0,
                 scriptPubKey: {
-                    hex: this.P2TR_SCRIPT.toString('hex'),
+                    hex: toHex(this.P2TR_SCRIPT),
                     address: dummyAddress,
                 },
                 value: estimatedFundingAmount,
@@ -883,7 +868,7 @@ export class TransactionFactory {
                 if (error instanceof Error) {
                     const match = error.message.match(/need (\d+) sats but only have (\d+) sats/);
                     if (match) {
-                        estimatedFundingAmount = BigInt(match[1]);
+                        estimatedFundingAmount = BigInt(match[1] as string);
                         if (this.debug) {
                             console.log(
                                 `${debugPrefix}: Caught insufficient funds, updating to ${estimatedFundingAmount}`,
@@ -941,7 +926,7 @@ export class TransactionFactory {
             transactionId: tx.getId(),
             outputIndex: index,
             scriptPubKey: {
-                hex: out.script.toString('hex'),
+                hex: toHex(out.script),
                 address: to,
             },
             value: BigInt(out.value),

package/src/transaction/browser/BrowserSignerBase.ts

@@ -1,4 +1,10 @@
-import { Network, Psbt, Signer } from '@btc-vision/bitcoin';
+import { type Network, Psbt, type Signer } from '@btc-vision/bitcoin';
+import {
+    type MessageHash,
+    type PublicKey,
+    type SchnorrSignature,
+    type Signature,
+} from '@btc-vision/ecpair';
 
 /**
  * Create a custom keypair.
@@ -7,7 +13,7 @@ import { Network, Psbt, Signer } from '@btc-vision/bitcoin';
 export abstract class CustomKeypair implements Signer {
     public abstract network: Network;
 
-    public abstract publicKey: Buffer;
+    public abstract publicKey: PublicKey;
 
     public abstract addresses: string[];
 
@@ -24,13 +30,13 @@ export abstract class CustomKeypair implements Signer {
 
     public abstract signInput(transaction: Psbt, i: number, sighashTypes: number[]): Promise<void>;
 
-    public abstract getPublicKey(): Buffer;
+    public abstract getPublicKey(): PublicKey;
 
-    public abstract sign(hash: Buffer, lowR?: boolean): Buffer;
+    public abstract sign(hash: MessageHash, lowR?: boolean): Signature;
 
-    public abstract signSchnorr(hash: Buffer): Buffer;
+    public abstract signSchnorr(hash: MessageHash): SchnorrSignature;
 
-    public abstract verify(hash: Buffer, signature: Buffer): boolean | Buffer;
+    public abstract verify(hash: MessageHash, signature: Signature): boolean;
 
     public abstract init(): Promise<void>;
 }

package/src/transaction/browser/Web3Provider.ts

@@ -1,10 +1,10 @@
-import { UTXO } from '../../utxo/interfaces/IUTXO.js';
-import {
+import type { UTXO } from '../../utxo/interfaces/IUTXO.js';
+import type {
     CancelledTransaction,
     DeploymentResult,
     InteractionResponse,
 } from '../interfaces/ITransactionResponses.js';
-import {
+import type {
     BroadcastedTransaction,
     BroadcastTransactionOptions,
     ICancelTransactionParametersWithoutSigner,