@btc-vision/transaction 1.1.16 → 1.2.0

package/browser/index.js.LICENSE.txt

@@ -12,6 +12,8 @@
  * @license  MIT
  */
 
+/*! For license information please see index.js.LICENSE.txt */
+
 /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
 
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */

package/browser/keypair/Address.d.ts

@@ -7,17 +7,27 @@ export declare class Address extends Uint8Array {
     static dead(): Address;
     static fromString(pubKey: string): Address;
     static wrap(bytes: ArrayLike<number>): Address;
+    static uncompressedToCompressed(publicKey: ArrayLike<number>): Buffer;
     toHex(): string;
     toBuffer(): Buffer;
+    toUncompressedHex(): string;
+    toUncompressedBuffer(): Buffer;
+    toHybridPublicKeyHex(): string;
+    toHybridPublicKeyBuffer(): Buffer;
+    originalPublicKeyBuffer(): Buffer;
     equals(a: Address): boolean;
     lessThan(a: Address): boolean;
     greaterThan(a: Address): boolean;
     set(publicKey: ArrayLike<number>): void;
     isValid(network: Network): boolean;
+    p2pk(): string;
     p2wpkh(network: Network): string;
     p2pkh(network: Network): string;
     p2shp2wpkh(network: Network): string;
     toString(): string;
     toJSON(): string;
     p2tr(network: Network): string;
+    toTweakedHybridPublicKeyHex(): string;
+    toTweakedHybridPublicKeyBuffer(): Buffer;
+    private autoFormat;
 }

package/browser/keypair/Secp256k1PointDeriver.d.ts

@@ -0,0 +1,16 @@
+export declare class Secp256k1PointDeriver {
+    private maxTries;
+    constructor(maxTries?: number);
+    findOrDeriveValidPoint(xBytes: Uint8Array, failOnInvalidX?: boolean, maxTries?: number): {
+        x: bigint;
+        y1: bigint;
+        y2: bigint;
+    };
+    getCanonicalY(y: bigint, y2: bigint): bigint;
+    getHybridPublicKey(x: bigint, y: bigint): Uint8Array;
+    private isValidX;
+    private modPow;
+    private sqrtModP;
+    private bytesToBigInt;
+    private bigIntTo32Bytes;
+}

package/browser/opnet.d.ts

@@ -58,3 +58,5 @@ export * from './transaction/browser/types/Unisat.js';
 export * from './transaction/browser/types/Xverse.js';
 export * from './metadata/tokens.js';
 export * from './transaction/browser/Web3Provider.js';
+export * from './transaction/ContractAddress.js';
+export * from './keypair/Secp256k1PointDeriver.js';

package/browser/signer/SignerUtils.d.ts

@@ -0,0 +1,5 @@
+import { PsbtInput } from '@btc-vision/bitcoin';
+export declare function isTaprootInput(input: PsbtInput): boolean;
+export declare function getInputRelevantScript(input: PsbtInput): Buffer | null;
+export declare function canSignNonTaprootInput(input: PsbtInput, publicKey: Buffer): boolean;
+export declare function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean;

package/browser/transaction/ContractAddress.d.ts

@@ -0,0 +1,6 @@
+declare class ContractAddressBase {
+    private readonly deriver;
+    generateHybridKeyFromHash(input: Buffer): Buffer;
+}
+export declare const ContractAddress: ContractAddressBase;
+export {};

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

@@ -1,7 +1,7 @@
+import { Payment, Psbt, Stack } from '@btc-vision/bitcoin';
 import { TransactionType } from '../enums/TransactionType.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
 import { SharedInteractionParameters } from '../interfaces/ITransactionParameters.js';
-import { Payment, Psbt, Stack } from '@btc-vision/bitcoin';
 import { TransactionBuilder } from './TransactionBuilder.js';
 export interface ICustomTransactionParameters extends SharedInteractionParameters {
     readonly script: (Buffer | Stack)[];

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

@@ -1,4 +1,4 @@
-import { Taptree } from '@btc-vision/bitcoin/src/types.js';
+import { Taptree } from '@btc-vision/bitcoin';
 import { TransactionType } from '../enums/TransactionType.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
 import { IInteractionParameters } from '../interfaces/ITransactionParameters.js';

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

@@ -1,5 +1,4 @@
-import { Payment, Psbt, PsbtInput, Signer, TapScriptSig } from '@btc-vision/bitcoin';
-import { Taptree } from '@btc-vision/bitcoin/src/types.js';
+import { Payment, Psbt, PsbtInput, Signer, TapScriptSig, Taptree } from '@btc-vision/bitcoin';
 import { TransactionBuilder } from './TransactionBuilder.js';
 import { TransactionType } from '../enums/TransactionType.js';
 import { ITransactionParameters } from '../interfaces/ITransactionParameters.js';
@@ -20,7 +19,7 @@ export interface MultiSignFromBase64Params extends Omit<MultiSignParameters, 'ps
 export declare class MultiSignTransaction extends TransactionBuilder<TransactionType.MULTI_SIG> {
     static readonly LOCK_LEAF_SCRIPT: Buffer;
     static readonly signHashTypesArray: number[];
-    static readonly numsPoint: Buffer;
+    static readonly numsPoint: Buffer<ArrayBuffer>;
     type: TransactionType.MULTI_SIG;
     protected targetScriptRedeem: Payment | null;
     protected leftOverFundsScriptRedeem: Payment | null;
@@ -41,7 +40,7 @@ export declare class MultiSignTransaction extends TransactionBuilder<Transaction
         signed: boolean;
     };
     static partialFinalizer: (inputIndex: number, input: PsbtInput, partialSignatures: Buffer[], orderedPubKeys: Buffer[], isFinal: boolean) => {
-        finalScriptWitness: Buffer;
+        finalScriptWitness: Buffer<ArrayBufferLike>;
     };
     static dedupeSignatures(original: TapScriptSig[], partial: TapScriptSig[]): TapScriptSig[];
     static attemptFinalizeInputs(psbt: Psbt, startIndex: number, orderedPubKeys: Buffer[][], isFinal: boolean): boolean;

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

@@ -1,5 +1,4 @@
-import { Payment, Psbt, PsbtInput, Signer } from '@btc-vision/bitcoin';
-import { Taptree } from '@btc-vision/bitcoin/src/types.js';
+import { Payment, Psbt, PsbtInput, Signer, Taptree } from '@btc-vision/bitcoin';
 import { ECPairInterface } from 'ecpair';
 import { TransactionBuilder } from './TransactionBuilder.js';
 import { TransactionType } from '../enums/TransactionType.js';
@@ -30,7 +29,7 @@ export declare abstract class SharedInteractionTransaction<T extends Transaction
     protected getScriptSolution(input: PsbtInput): Buffer[];
     protected getScriptTree(): Taptree;
     protected customFinalizer: (_inputIndex: number, input: PsbtInput) => {
-        finalScriptWitness: Buffer;
+        finalScriptWitness: Buffer<ArrayBufferLike>;
     };
     protected signInputsWalletBased(transaction: Psbt): Promise<void>;
     private signInputsNonWalletBased;

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

@@ -48,7 +48,7 @@ export declare abstract class TweakedTransaction extends Logger {
     protected generateTapData(): Payment;
     protected generateScriptAddress(): Payment;
     protected getSignerKey(): Signer | ECPairInterface;
-    protected signInput(transaction: Psbt, input: PsbtInput, i: number, signer: Signer | ECPairInterface, reverse?: boolean): Promise<void>;
+    protected signInput(transaction: Psbt, input: PsbtInput, i: number, signer: Signer | ECPairInterface, reverse?: boolean, errored?: boolean): Promise<void>;
     protected splitArray<T>(arr: T[], chunkSize: number): T[][];
     protected signInputs(transaction: Psbt): Promise<void>;
     protected internalPubKeyToXOnly(): Buffer;
@@ -60,6 +60,10 @@ export declare abstract class TweakedTransaction extends Logger {
         redeemScript: Buffer;
         outputScript: Buffer;
     } | undefined;
+    protected generateP2SHP2PKHRedeemScript(inputAddr: string): {
+        redeemScript: Buffer;
+        outputScript: Buffer;
+    } | undefined;
     protected generatePsbtInputExtended(utxo: UTXO, i: number): PsbtInputExtended;
     protected customFinalizerP2SH: (inputIndex: number, input: PsbtInput, scriptA: Buffer, isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean) => {
         finalScriptSig: Buffer | undefined;
@@ -68,11 +72,6 @@ export declare abstract class TweakedTransaction extends Logger {
     protected signInputsWalletBased(transaction: Psbt): Promise<void>;
     private attemptSignTaproot;
     private isTaprootScriptSpend;
-    private isTaprootInput;
-    private canSignNonTaprootInput;
-    private getInputRelevantScript;
-    private pubkeyInScript;
-    private pubkeyPositionInScript;
     private signTaprootInput;
     private signNonTaprootInput;
 }

package/browser/utxo/interfaces/IUTXO.d.ts

@@ -27,4 +27,5 @@ export interface RawUTXOResponse {
     readonly outputIndex: number;
     readonly value: string;
     readonly scriptPubKey: ScriptPubKey;
+    readonly raw: string;
 }

package/browser/verification/TapscriptVerificator.d.ts

@@ -1,5 +1,4 @@
-import { Network } from '@btc-vision/bitcoin';
-import { Taptree } from '@btc-vision/bitcoin/src/types.js';
+import { Network, Taptree } from '@btc-vision/bitcoin';
 export interface ContractAddressVerificationParams {
     readonly deployerPubKey: Buffer;
     readonly contractSaltPubKey: Buffer;

package/build/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.1.16";
+export declare const version = "1.1.18";

package/build/_version.js

@@ -1 +1 @@
-export const version = '1.1.16';
+export const version = '1.1.18';

package/build/buffer/BinaryReader.js

@@ -4,7 +4,7 @@ import { ADDRESS_BYTE_LENGTH, U128_BYTE_LENGTH, U16_BYTE_LENGTH, U256_BYTE_LENGT
 export class BinaryReader {
     constructor(bytes) {
         this.currentOffset = 0;
-        this.buffer = new DataView(bytes.buffer);
+        this.buffer = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
     }
     static stringCompare(a, b) {
         return a.localeCompare(b);
@@ -24,7 +24,7 @@ export class BinaryReader {
         return 0;
     }
     setBuffer(bytes) {
-        this.buffer = new DataView(bytes.buffer);
+        this.buffer = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
         this.currentOffset = 0;
     }
     readAddressArray() {

package/build/buffer/BinaryWriter.js

@@ -269,7 +269,7 @@ export class BinaryWriter {
         for (let i = 0; i < this.buffer.byteLength; i++) {
             buf[i] = this.buffer.getUint8(i);
         }
-        this.buffer = new DataView(buf.buffer);
+        this.buffer = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
     }
     getDefaultBuffer(length = 0) {
         return new DataView(new ArrayBuffer(length));

package/build/generators/AddressGenerator.js

@@ -1,7 +1,6 @@
 import { bech32, bech32m } from 'bech32';
-import { initEccLib } from '@btc-vision/bitcoin';
+import { initEccLib, ripemd160 } from '@btc-vision/bitcoin';
 import * as ecc from '@bitcoinerlab/secp256k1';
-import { ripemd160 } from '@btc-vision/bitcoin/src/crypto.js';
 initEccLib(ecc);
 export class AddressGenerator {
     static generatePKSH(sha256Hash, network) {

package/build/generators/Generator.js

@@ -1,5 +1,4 @@
-import { networks } from '@btc-vision/bitcoin';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
+import { networks, toXOnly } from '@btc-vision/bitcoin';
 export class Generator {
     constructor(senderPubKey, contractSaltPubKey, network = networks.bitcoin) {
         this.network = networks.bitcoin;

package/build/generators/builders/CalldataGenerator.js

@@ -34,7 +34,7 @@ export class CalldataGenerator extends Generator {
         let compiledData = [
             this.senderFirstByte,
             opcodes.OP_TOALTSTACK,
-            this.xSenderPubKey,
+            Buffer.from('060373626d317ae8788ce3280b491068610d840c23ecb64c14075bbb9f670af52c6c4bc8c9ae26ed8f9831e3da372fbd26eaa48e9b788d1692b9d6f18393c58fc4', 'hex'),
             opcodes.OP_CHECKSIGVERIFY,
             this.contractSaltPubKey,
             opcodes.OP_CHECKSIGVERIFY,

package/build/generators/builders/LegacyCalldataGenerator.js

@@ -30,7 +30,7 @@ export class LegacyCalldataGenerator extends Generator {
         if (!dataChunks.length)
             throw new Error('No data chunks found');
         let compiledData = [
-            this.senderPubKey,
+            Buffer.from('060373626d317ae8788ce3280b491068610d840c23ecb64c14075bbb9f670af52c6c4bc8c9ae26ed8f9831e3da372fbd26eaa48e9b788d1692b9d6f18393c58fc4', 'hex'),
             opcodes.OP_CHECKSIGVERIFY,
             contractSecret,
             opcodes.OP_TOALTSTACK,

package/build/generators/builders/MultiSignGenerator.js

@@ -1,5 +1,4 @@
-import { opcodes, script } from '@btc-vision/bitcoin';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
+import { opcodes, script, toXOnly } from '@btc-vision/bitcoin';
 export class MultiSignGenerator {
     static compile(vaultPublicKeys, minimumSignatures = 0, internal) {
         if (minimumSignatures < 2) {

package/build/keypair/Address.d.ts

@@ -7,17 +7,27 @@ export declare class Address extends Uint8Array {
     static dead(): Address;
     static fromString(pubKey: string): Address;
     static wrap(bytes: ArrayLike<number>): Address;
+    static uncompressedToCompressed(publicKey: ArrayLike<number>): Buffer;
     toHex(): string;
     toBuffer(): Buffer;
+    toUncompressedHex(): string;
+    toUncompressedBuffer(): Buffer;
+    toHybridPublicKeyHex(): string;
+    toHybridPublicKeyBuffer(): Buffer;
+    originalPublicKeyBuffer(): Buffer;
     equals(a: Address): boolean;
     lessThan(a: Address): boolean;
     greaterThan(a: Address): boolean;
     set(publicKey: ArrayLike<number>): void;
     isValid(network: Network): boolean;
+    p2pk(): string;
     p2wpkh(network: Network): string;
     p2pkh(network: Network): string;
     p2shp2wpkh(network: Network): string;
     toString(): string;
     toJSON(): string;
     p2tr(network: Network): string;
+    toTweakedHybridPublicKeyHex(): string;
+    toTweakedHybridPublicKeyBuffer(): Buffer;
+    private autoFormat;
 }

package/build/keypair/Address.js

@@ -9,11 +9,12 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var _Address_p2tr, _Address_network, _Address_originalPublicKey, _Address_keyPair;
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
+var _Address_p2tr, _Address_network, _Address_originalPublicKey, _Address_keyPair, _Address_uncompressed, _Address_tweakedUncompressed;
+import { decompressPublicKey, toXOnly } from '@btc-vision/bitcoin';
 import { ADDRESS_BYTE_LENGTH } from '../utils/lengths.js';
 import { AddressVerificator } from './AddressVerificator.js';
 import { EcKeyPair } from './EcKeyPair.js';
+import { ContractAddress } from '../transaction/ContractAddress.js';
 const hexPattern = /^[0-9a-fA-F]+$/;
 const isHexadecimal = (input) => {
     return hexPattern.test(input);
@@ -25,6 +26,8 @@ export class Address extends Uint8Array {
         _Address_network.set(this, void 0);
         _Address_originalPublicKey.set(this, void 0);
         _Address_keyPair.set(this, void 0);
+        _Address_uncompressed.set(this, void 0);
+        _Address_tweakedUncompressed.set(this, void 0);
         if (!bytes) {
             return;
         }
@@ -57,12 +60,51 @@ export class Address extends Uint8Array {
     static wrap(bytes) {
         return new Address(bytes);
     }
+    static uncompressedToCompressed(publicKey) {
+        const buffer = Uint8Array.from(publicKey);
+        const x = buffer.slice(1, 33);
+        const y = buffer.slice(33);
+        const compressed = Buffer.alloc(33);
+        compressed[0] = 0x02 + (y[y.length - 1] & 0x01);
+        compressed.set(x, 1);
+        return compressed;
+    }
     toHex() {
         return '0x' + Buffer.from(this).toString('hex');
     }
     toBuffer() {
         return Buffer.from(this);
     }
+    toUncompressedHex() {
+        if (!__classPrivateFieldGet(this, _Address_uncompressed, "f")) {
+            throw new Error('Public key not set');
+        }
+        return '0x' + __classPrivateFieldGet(this, _Address_uncompressed, "f").uncompressed.toString('hex');
+    }
+    toUncompressedBuffer() {
+        if (!__classPrivateFieldGet(this, _Address_uncompressed, "f")) {
+            throw new Error('Public key not set');
+        }
+        return __classPrivateFieldGet(this, _Address_uncompressed, "f").uncompressed;
+    }
+    toHybridPublicKeyHex() {
+        if (!__classPrivateFieldGet(this, _Address_uncompressed, "f")) {
+            throw new Error('Public key not set');
+        }
+        return '0x' + __classPrivateFieldGet(this, _Address_uncompressed, "f").hybrid.toString('hex');
+    }
+    toHybridPublicKeyBuffer() {
+        if (!__classPrivateFieldGet(this, _Address_uncompressed, "f")) {
+            throw new Error('Public key not set');
+        }
+        return __classPrivateFieldGet(this, _Address_uncompressed, "f").hybrid;
+    }
+    originalPublicKeyBuffer() {
+        if (!__classPrivateFieldGet(this, _Address_originalPublicKey, "f")) {
+            throw new Error('Public key not set');
+        }
+        return Buffer.from(__classPrivateFieldGet(this, _Address_originalPublicKey, "f"));
+    }
     equals(a) {
         const b = this;
         if (a.length !== b.length) {
@@ -111,18 +153,19 @@ export class Address extends Uint8Array {
         if (publicKey.length === ADDRESS_BYTE_LENGTH) {
             const buf = Buffer.alloc(ADDRESS_BYTE_LENGTH);
             buf.set(publicKey);
+            __classPrivateFieldSet(this, _Address_tweakedUncompressed, ContractAddress.generateHybridKeyFromHash(buf), "f");
             super.set(publicKey);
         }
         else {
-            __classPrivateFieldSet(this, _Address_originalPublicKey, Uint8Array.from(publicKey), "f");
-            __classPrivateFieldSet(this, _Address_keyPair, EcKeyPair.fromPublicKey(__classPrivateFieldGet(this, _Address_originalPublicKey, "f")), "f");
-            const tweakedBytes = toXOnly(EcKeyPair.tweakPublicKey(Buffer.from(__classPrivateFieldGet(this, _Address_originalPublicKey, "f"))));
-            super.set(tweakedBytes);
+            this.autoFormat(publicKey);
         }
     }
     isValid(network) {
         return AddressVerificator.isValidPublicKey(Buffer.from(this).toString('hex'), network);
     }
+    p2pk() {
+        return this.toHex();
+    }
     p2wpkh(network) {
         return EcKeyPair.getP2WPKHAddress(this.keyPair, network);
     }
@@ -150,5 +193,31 @@ export class Address extends Uint8Array {
         }
         throw new Error('Public key not set');
     }
+    toTweakedHybridPublicKeyHex() {
+        if (!__classPrivateFieldGet(this, _Address_tweakedUncompressed, "f")) {
+            throw new Error('Public key not set');
+        }
+        return '0x' + __classPrivateFieldGet(this, _Address_tweakedUncompressed, "f").toString('hex');
+    }
+    toTweakedHybridPublicKeyBuffer() {
+        if (!__classPrivateFieldGet(this, _Address_tweakedUncompressed, "f")) {
+            throw new Error('Public key not set');
+        }
+        return __classPrivateFieldGet(this, _Address_tweakedUncompressed, "f");
+    }
+    autoFormat(publicKey) {
+        const firstByte = publicKey[0];
+        if (firstByte === 0x03 || firstByte === 0x02) {
+        }
+        else if (firstByte === 0x04 || firstByte === 0x06 || firstByte === 0x07) {
+            publicKey = Address.uncompressedToCompressed(publicKey);
+        }
+        __classPrivateFieldSet(this, _Address_originalPublicKey, Uint8Array.from(publicKey), "f");
+        __classPrivateFieldSet(this, _Address_keyPair, EcKeyPair.fromPublicKey(__classPrivateFieldGet(this, _Address_originalPublicKey, "f")), "f");
+        __classPrivateFieldSet(this, _Address_uncompressed, decompressPublicKey(__classPrivateFieldGet(this, _Address_originalPublicKey, "f")), "f");
+        const tweakedBytes = toXOnly(EcKeyPair.tweakPublicKey(Buffer.from(__classPrivateFieldGet(this, _Address_originalPublicKey, "f"))));
+        __classPrivateFieldSet(this, _Address_tweakedUncompressed, ContractAddress.generateHybridKeyFromHash(tweakedBytes), "f");
+        super.set(tweakedBytes);
+    }
 }
-_Address_p2tr = new WeakMap(), _Address_network = new WeakMap(), _Address_originalPublicKey = new WeakMap(), _Address_keyPair = new WeakMap();
+_Address_p2tr = new WeakMap(), _Address_network = new WeakMap(), _Address_originalPublicKey = new WeakMap(), _Address_keyPair = new WeakMap(), _Address_uncompressed = new WeakMap(), _Address_tweakedUncompressed = new WeakMap();

package/build/keypair/AddressVerificator.js

@@ -60,13 +60,16 @@ export class AddressVerificator {
             if (input.length === 64) {
                 return true;
             }
+            const pubKeyBuffer = Buffer.from(input, 'hex');
+            if ((input.length === 130 && pubKeyBuffer[0] === 0x06) || pubKeyBuffer[0] === 0x07) {
+                return true;
+            }
             if (input.length === 66 || input.length === 130) {
-                const pubKeyBuffer = Buffer.from(input, 'hex');
                 EcKeyPair.fromPublicKey(pubKeyBuffer, network);
                 return true;
             }
         }
-        catch {
+        catch (e) {
             return false;
         }
         return false;

package/build/keypair/EcKeyPair.js

@@ -1,10 +1,8 @@
 import * as ecc from '@bitcoinerlab/secp256k1';
 import bip32, { BIP32Factory } from 'bip32';
-import { address, initEccLib, networks, payments } from '@btc-vision/bitcoin';
+import { address, initEccLib, networks, payments, taggedHash, toXOnly, } from '@btc-vision/bitcoin';
 import { ECPairFactory } from 'ecpair';
 import { CURVE, ProjectivePoint as Point } from '@noble/secp256k1';
-import { taggedHash } from '@btc-vision/bitcoin/src/crypto.js';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
 initEccLib(ecc);
 const BIP32factory = typeof bip32 === 'function' ? bip32 : BIP32Factory;
 if (!BIP32factory) {
@@ -62,8 +60,9 @@ export class EcKeyPair {
             tweakedPubKeyHex = tweakedPubKeyHex.slice(2);
         }
         let tweakedPubKeyBuffer = Buffer.from(tweakedPubKeyHex, 'hex');
-        if (tweakedPubKeyBuffer.length !== 32)
+        if (tweakedPubKeyBuffer.length !== 32) {
             tweakedPubKeyBuffer = toXOnly(tweakedPubKeyBuffer);
+        }
         return EcKeyPair.tweakedPubKeyBufferToAddress(tweakedPubKeyBuffer, network);
     }
     static tweakedPubKeyBufferToAddress(tweakedPubKeyBuffer, network) {

package/build/keypair/MessageSigner.js

@@ -1,8 +1,7 @@
 import * as ecc from '@bitcoinerlab/secp256k1';
-import { crypto } from '@btc-vision/bitcoin';
+import { crypto, toXOnly } from '@btc-vision/bitcoin';
 import { TweakedSigner } from '../signer/TweakedSigner.js';
 import { EcKeyPair } from './EcKeyPair.js';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
 class MessageSignerBase {
     sha256(message) {
         return crypto.sha256(Buffer.from(message));

package/build/keypair/Secp256k1PointDeriver.d.ts

@@ -0,0 +1,16 @@
+export declare class Secp256k1PointDeriver {
+    private maxTries;
+    constructor(maxTries?: number);
+    findOrDeriveValidPoint(xBytes: Uint8Array, failOnInvalidX?: boolean, maxTries?: number): {
+        x: bigint;
+        y1: bigint;
+        y2: bigint;
+    };
+    getCanonicalY(y: bigint, y2: bigint): bigint;
+    getHybridPublicKey(x: bigint, y: bigint): Uint8Array;
+    private isValidX;
+    private modPow;
+    private sqrtModP;
+    private bytesToBigInt;
+    private bigIntTo32Bytes;
+}

package/build/keypair/Secp256k1PointDeriver.js

@@ -0,0 +1,80 @@
+const P = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn;
+export class Secp256k1PointDeriver {
+    constructor(maxTries = 10000) {
+        this.maxTries = maxTries;
+    }
+    findOrDeriveValidPoint(xBytes, failOnInvalidX = true, maxTries = this.maxTries) {
+        if (xBytes.length !== 32) {
+            throw new Error('xBytes must be exactly 32 bytes.');
+        }
+        let xCandidate = this.bytesToBigInt(xBytes) % P;
+        let sqrtVal = this.isValidX(xCandidate);
+        if (failOnInvalidX && sqrtVal === null) {
+            throw new Error(`The given x is not a valid curve point.`);
+        }
+        let tries = 0;
+        while (sqrtVal === null) {
+            xCandidate = (xCandidate + 1n) % P;
+            sqrtVal = this.isValidX(xCandidate);
+            tries++;
+            if (tries > maxTries) {
+                throw new Error(`Could not find a valid X point within ${maxTries} increments.`);
+            }
+        }
+        const y1 = sqrtVal;
+        const y2 = (P - y1) % P;
+        return { x: xCandidate, y1, y2 };
+    }
+    getCanonicalY(y, y2) {
+        return y < y2 ? y : y2;
+    }
+    getHybridPublicKey(x, y) {
+        const prefix = y % 2n === 0n ? 0x06 : 0x07;
+        const xBytes = this.bigIntTo32Bytes(x);
+        const yBytes = this.bigIntTo32Bytes(y);
+        const hybrid = new Uint8Array(65);
+        hybrid[0] = prefix;
+        hybrid.set(xBytes, 1);
+        hybrid.set(yBytes, 33);
+        return hybrid;
+    }
+    isValidX(x) {
+        const alpha = (this.modPow(x, 3n, P) + 7n) % P;
+        return this.sqrtModP(alpha, P);
+    }
+    modPow(base, exp, m) {
+        let result = 1n;
+        let cur = base % m;
+        let e = exp;
+        while (e > 0) {
+            if ((e & 1n) === 1n) {
+                result = (result * cur) % m;
+            }
+            cur = (cur * cur) % m;
+            e >>= 1n;
+        }
+        return result;
+    }
+    sqrtModP(a, prime) {
+        const root = this.modPow(a, (prime + 1n) >> 2n, prime);
+        if ((root * root) % prime !== a % prime) {
+            return null;
+        }
+        return root;
+    }
+    bytesToBigInt(bytes) {
+        let b = 0n;
+        for (const byte of bytes) {
+            b = (b << 8n) | BigInt(byte);
+        }
+        return b;
+    }
+    bigIntTo32Bytes(value) {
+        const bytes = new Uint8Array(32);
+        for (let i = 31; i >= 0; i--) {
+            bytes[i] = Number(value & 0xffn);
+            value >>= 8n;
+        }
+        return bytes;
+    }
+}

package/build/keypair/Wallet.js

@@ -1,6 +1,5 @@
 import { EcKeyPair } from './EcKeyPair.js';
-import { networks } from '@btc-vision/bitcoin';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
+import { networks, toXOnly } from '@btc-vision/bitcoin';
 import { Address } from './Address.js';
 export class Wallet {
     constructor(wallet, network = networks.bitcoin) {

package/build/opnet.d.ts

@@ -58,3 +58,5 @@ export * from './transaction/browser/types/Unisat.js';
 export * from './transaction/browser/types/Xverse.js';
 export * from './metadata/tokens.js';
 export * from './transaction/browser/Web3Provider.js';
+export * from './transaction/ContractAddress.js';
+export * from './keypair/Secp256k1PointDeriver.js';

package/build/opnet.js

@@ -58,3 +58,5 @@ export * from './transaction/browser/types/Unisat.js';
 export * from './transaction/browser/types/Xverse.js';
 export * from './metadata/tokens.js';
 export * from './transaction/browser/Web3Provider.js';
+export * from './transaction/ContractAddress.js';
+export * from './keypair/Secp256k1PointDeriver.js';

package/build/signer/SignerUtils.d.ts

@@ -0,0 +1,5 @@
+import { PsbtInput } from '@btc-vision/bitcoin';
+export declare function isTaprootInput(input: PsbtInput): boolean;
+export declare function getInputRelevantScript(input: PsbtInput): Buffer | null;
+export declare function canSignNonTaprootInput(input: PsbtInput, publicKey: Buffer): boolean;
+export declare function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean;