@btc-vision/transaction 1.1.17 → 1.2.1

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,8 +7,13 @@ 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;
@@ -22,4 +27,7 @@ export declare class Address extends Uint8Array {
     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

@@ -2,5 +2,4 @@ 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 pubkeyPositionInScript(pubkey: Buffer, script: Buffer): number;
 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/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.17";
+export declare const version = "1.2.1";

package/build/_version.js

@@ -1 +1 @@
-export const version = '1.1.17';
+export const version = '1.2.1';

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/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,8 +7,13 @@ 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;
@@ -22,4 +27,7 @@ export declare class Address extends Uint8Array {
     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,45 @@ 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');
@@ -117,13 +153,11 @@ 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) {
@@ -159,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

@@ -2,5 +2,4 @@ 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 pubkeyPositionInScript(pubkey: Buffer, script: Buffer): number;
 export declare function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean;

package/build/signer/SignerUtils.js

@@ -1,7 +1,4 @@
-import { crypto as bitCrypto } from '@btc-vision/bitcoin';
-import { isP2TR } from '@btc-vision/bitcoin/src/psbt/psbtutils.js';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
-import * as bscript from '@btc-vision/bitcoin/src/script.js';
+import { isP2TR, pubkeyPositionInScript } from '@btc-vision/bitcoin';
 export function isTaprootInput(input) {
     return (input &&
         !!(input.tapInternalKey ||
@@ -38,19 +35,6 @@ export function canSignNonTaprootInput(input, publicKey) {
     }
     return false;
 }
-export function pubkeyPositionInScript(pubkey, script) {
-    const pubkeyHash = bitCrypto.hash160(pubkey);
-    const pubkeyXOnly = toXOnly(pubkey);
-    const decompiled = bscript.decompile(script);
-    if (decompiled === null)
-        throw new Error('Unknown script error');
-    const a = decompiled.findIndex((element) => {
-        if (typeof element === 'number')
-            return false;
-        return element.equals(pubkey) || element.equals(pubkeyHash) || element.equals(pubkeyXOnly);
-    });
-    return a;
-}
 export function pubkeyInScript(pubkey, script) {
     return pubkeyPositionInScript(pubkey, script) !== -1;
 }

package/build/signer/TweakedSigner.js

@@ -1,7 +1,5 @@
 import * as ecc from '@bitcoinerlab/secp256k1';
-import { initEccLib } from '@btc-vision/bitcoin';
-import { tapTweakHash } from '@btc-vision/bitcoin/src/payments/bip341.js';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
+import { initEccLib, tapTweakHash, toXOnly } from '@btc-vision/bitcoin';
 import { EcKeyPair } from '../keypair/EcKeyPair.js';
 initEccLib(ecc);
 export class TweakedSigner {

package/build/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/build/transaction/ContractAddress.js

@@ -0,0 +1,12 @@
+import { Secp256k1PointDeriver } from '../keypair/Secp256k1PointDeriver.js';
+class ContractAddressBase {
+    constructor() {
+        this.deriver = new Secp256k1PointDeriver();
+    }
+    generateHybridKeyFromHash(input) {
+        const p = this.deriver.findOrDeriveValidPoint(Buffer.copyBytesFrom(input), false);
+        const y = this.deriver.getCanonicalY(p.y1, p.y2);
+        return Buffer.from(this.deriver.getHybridPublicKey(p.x, y));
+    }
+}
+export const ContractAddress = new ContractAddressBase();

package/build/transaction/browser/extensions/UnisatSigner.js

@@ -1,8 +1,7 @@
-import { crypto as bitCrypto, networks, Psbt, script as bitScript, } from '@btc-vision/bitcoin';
+import { crypto as bitCrypto, networks, Psbt, script as bitScript, toXOnly, } from '@btc-vision/bitcoin';
 import { EcKeyPair } from '../../../keypair/EcKeyPair.js';
 import { CustomKeypair } from '../BrowserSignerBase.js';
 import { UnisatNetwork } from '../types/Unisat.js';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
 import { canSignNonTaprootInput, isTaprootInput } from '../../../signer/SignerUtils.js';
 export class UnisatSigner extends CustomKeypair {
     constructor() {

package/build/transaction/browser/extensions/XverseSigner.js

@@ -1,5 +1,4 @@
-import { networks, Psbt } from '@btc-vision/bitcoin';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
+import { networks, Psbt, toXOnly } from '@btc-vision/bitcoin';
 import { EcKeyPair } from '../../../keypair/EcKeyPair.js';
 import { CustomKeypair } from '../BrowserSignerBase.js';
 import { canSignNonTaprootInput, isTaprootInput, pubkeyInScript, } from '../../../signer/SignerUtils.js';

package/build/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/build/transaction/builders/CustomScriptTransaction.js

@@ -1,11 +1,10 @@
+import { crypto as bitCrypto, toXOnly, } from '@btc-vision/bitcoin';
 import { TransactionType } from '../enums/TransactionType.js';
-import { crypto as bitCrypto } from '@btc-vision/bitcoin';
 import { TransactionBuilder } from './TransactionBuilder.js';
 import { CustomGenerator } from '../../generators/builders/CustomGenerator.js';
 import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
 import { AddressGenerator } from '../../generators/AddressGenerator.js';
-import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
 export class CustomScriptTransaction extends TransactionBuilder {
     constructor(parameters) {
         super(parameters);