@btc-vision/transaction 1.0.112 → 1.0.114

package/src/keypair/EcKeyPair.ts

@@ -1,10 +1,11 @@
 import * as ecc from '@bitcoinerlab/secp256k1';
-import { Address } from '@btc-vision/bsi-binary';
 import bip32, { BIP32API, BIP32Factory, BIP32Interface } from 'bip32';
-import { address, initEccLib, Network, networks, payments } from 'bitcoinjs-lib';
+import { address, initEccLib, Network, networks, payments, Signer } from 'bitcoinjs-lib';
 import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
 import { ECPairAPI, ECPairFactory, ECPairInterface } from 'ecpair';
 import { IWallet } from './interfaces/IWallet.js';
+import { CURVE, Point, utils } from '@noble/secp256k1';
+import { taggedHash } from 'bitcoinjs-lib/src/crypto.js';
 
 initEccLib(ecc);
 
@@ -42,23 +43,28 @@ export class EcKeyPair {
      * @returns {ECPairInterface} - The generated keypair
      */
     public static fromPrivateKey(
-        privateKey: Buffer,
+        privateKey: Buffer | Uint8Array,
         network: Network = networks.bitcoin,
     ): ECPairInterface {
-        return this.ECPair.fromPrivateKey(privateKey, { network });
+        return this.ECPair.fromPrivateKey(
+            !Buffer.isBuffer(privateKey) ? Buffer.from(privateKey) : privateKey,
+            { network },
+        );
     }
 
     /**
      * Generate a keypair from a public key
-     * @param {Buffer} publicKey - The public key to use
+     * @param {Buffer | Uint8Array} publicKey - The public key to use
      * @param {Network} network - The network to use
      * @returns {ECPairInterface} - The generated keypair
      */
     public static fromPublicKey(
-        publicKey: Buffer,
+        publicKey: Buffer | Uint8Array,
         network: Network = networks.bitcoin,
     ): ECPairInterface {
-        return this.ECPair.fromPublicKey(publicKey, { network });
+        const buf = !Buffer.isBuffer(publicKey) ? Buffer.from(publicKey) : publicKey;
+
+        return this.ECPair.fromPublicKey(buf, { network });
     }
 
     /**
@@ -66,14 +72,14 @@ export class EcKeyPair {
      * @param {Buffer[]} pubKeys - The public keys to use
      * @param {number} minimumSignatureRequired - The minimum number of signatures required
      * @param {Network} network - The network to use
-     * @returns {Address} - The generated address
+     * @returns {string} - The generated address
      * @throws {Error} - If the address cannot be generated
      */
     public static generateMultiSigAddress(
         pubKeys: Buffer[],
         minimumSignatureRequired: number,
         network: Network = networks.bitcoin,
-    ): Address {
+    ): string {
         const publicKeys: Buffer[] = this.verifyPubKeys(pubKeys, network);
         if (publicKeys.length !== pubKeys.length) throw new Error(`Contains invalid public keys`);
 
@@ -86,20 +92,6 @@ export class EcKeyPair {
         const p2wsh = payments.p2wsh({ redeem: p2ms, network: network });
         const address = p2wsh.address;
 
-        // fake params
-        /*const multiSignParams: MultiSignParameters = {
-            network: network,
-            utxos: [],
-            pubkeys: pubKeys,
-            minimumSignatures: minimumSignatureRequired,
-            feeRate: 100,
-            receiver: 'a',
-            requestedAmount: 1n,
-            refundVault: 'a',
-        };
-
-        const address = new MultiSignTransaction(multiSignParams).getScriptAddress();
-        */
         if (!address) {
             throw new Error('Failed to generate address');
         }
@@ -122,7 +114,7 @@ export class EcKeyPair {
                 throw new Error('Failed to regenerate key');
             }
 
-            return key.publicKey;
+            return Buffer.from(key.publicKey);
         });
     }
 
@@ -130,13 +122,13 @@ export class EcKeyPair {
      * Get a P2WPKH address from a keypair
      * @param {ECPairInterface} keyPair - The keypair to get the address for
      * @param {Network} network - The network to use
-     * @returns {Address} - The address
+     * @returns {string} - The address
      */
     public static getP2WPKHAddress(
         keyPair: ECPairInterface,
         network: Network = networks.bitcoin,
-    ): Address {
-        const res = payments.p2wpkh({ pubkey: keyPair.publicKey, network: network });
+    ): string {
+        const res = payments.p2wpkh({ pubkey: Buffer.from(keyPair.publicKey), network: network });
 
         if (!res.address) {
             throw new Error('Failed to generate wallet');
@@ -145,6 +137,113 @@ export class EcKeyPair {
         return res.address;
     }
 
+    /**
+     * Get the address of a tweaked public key
+     * @param {string} tweakedPubKeyHex - The tweaked public key hex string
+     * @param {Network} network - The network to use
+     * @returns {string} - The address
+     * @throws {Error} - If the address cannot be generated
+     */
+    public static tweakedPubKeyToAddress(tweakedPubKeyHex: string, network: Network): string {
+        if (tweakedPubKeyHex.startsWith('0x')) {
+            tweakedPubKeyHex = tweakedPubKeyHex.slice(2);
+        }
+
+        // Convert the tweaked public key hex string to a Buffer
+        let tweakedPubKeyBuffer = Buffer.from(tweakedPubKeyHex, 'hex');
+        if (tweakedPubKeyBuffer.length !== 32) tweakedPubKeyBuffer = toXOnly(tweakedPubKeyBuffer);
+
+        return EcKeyPair.tweakedPubKeyBufferToAddress(tweakedPubKeyBuffer, network);
+    }
+
+    /**
+     * Get the address of a tweaked public key
+     * @param {Buffer | Uint8Array} tweakedPubKeyBuffer - The tweaked public key buffer
+     * @param {Network} network - The network to use
+     * @returns {string} - The address
+     * @throws {Error} - If the address cannot be generated
+     */
+    public static tweakedPubKeyBufferToAddress(
+        tweakedPubKeyBuffer: Buffer | Uint8Array,
+        network: Network,
+    ): string {
+        // Generate the Taproot address using the p2tr payment method
+        const { address } = payments.p2tr({
+            pubkey: Buffer.isBuffer(tweakedPubKeyBuffer)
+                ? tweakedPubKeyBuffer
+                : Buffer.from(tweakedPubKeyBuffer),
+            network: network,
+        });
+
+        if (!address) {
+            throw new Error('Failed to generate Taproot address');
+        }
+
+        return address;
+    }
+
+    /**
+     * Get the address of a xOnly tweaked public key
+     * @param {string} tweakedPubKeyHex - The xOnly tweaked public key hex string
+     * @param {Network} network - The network to use
+     * @returns {string} - The address
+     * @throws {Error} - If the address cannot be generated
+     */
+    public static xOnlyTweakedPubKeyToAddress(tweakedPubKeyHex: string, network: Network): string {
+        if (tweakedPubKeyHex.startsWith('0x')) {
+            tweakedPubKeyHex = tweakedPubKeyHex.slice(2);
+        }
+
+        // Convert the tweaked public key hex string to a Buffer
+        const tweakedPubKeyBuffer = Buffer.from(tweakedPubKeyHex, 'hex');
+
+        // Generate the Taproot address using the p2tr payment method
+        const { address } = payments.p2tr({
+            pubkey: tweakedPubKeyBuffer,
+            network: network,
+        });
+
+        if (!address) {
+            throw new Error('Failed to generate Taproot address');
+        }
+
+        return address;
+    }
+
+    /**
+     * Tweak a public key
+     * @param {string} compressedPubKeyHex - The compressed public key hex string
+     * @returns {string} - The tweaked public key hex string
+     * @throws {Error} - If the public key cannot be tweaked
+     */
+    public static tweakPublicKey(compressedPubKeyHex: string): string {
+        if (compressedPubKeyHex.startsWith('0x')) {
+            compressedPubKeyHex = compressedPubKeyHex.slice(2);
+        }
+
+        // Convert the compressed public key hex string to a Point on the curve
+        let P = Point.fromHex(compressedPubKeyHex);
+
+        // Ensure the point has an even y-coordinate
+        if (!P.hasEvenY()) {
+            // 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 = utils.mod(BigInt('0x' + Buffer.from(tHash).toString('hex')), CURVE.n);
+
+        // Compute Q = P + t*G (where G is the generator point)
+        const Q = P.add(Point.BASE.multiply(t));
+
+        // Return the tweaked public key in compressed form (hex string)
+        return Q.toHex(true);
+    }
+
     /**
      * Generate a random wallet
      * @param {Network} network - The network to use
@@ -164,18 +263,18 @@ export class EcKeyPair {
         return {
             address: wallet,
             privateKey: keyPair.toWIF(),
-            publicKey: keyPair.publicKey.toString('hex'),
+            publicKey: Buffer.from(keyPair.publicKey).toString('hex'),
         };
     }
 
     /**
      * Verify that a contract address is a valid p2tr address
-     * @param {Address} contractAddress - The contract address to verify
+     * @param {string} contractAddress - The contract address to verify
      * @param {Network} network - The network to use
      * @returns {boolean} - Whether the address is valid
      */
     public static verifyContractAddress(
-        contractAddress: Address,
+        contractAddress: string,
         network: Network = networks.bitcoin,
     ): boolean {
         return !!address.toOutputScript(contractAddress, network);
@@ -185,14 +284,14 @@ export class EcKeyPair {
      * Get the legacy segwit address from a keypair
      * @param {ECPairInterface} keyPair - The keypair to get the address for
      * @param {Network} network - The network to use
-     * @returns {Address} - The legacy address
+     * @returns {string} - The legacy address
      */
     public static getLegacySegwitAddress(
         keyPair: ECPairInterface,
         network: Network = networks.bitcoin,
-    ): Address {
+    ): string {
         const wallet = payments.p2sh({
-            redeem: payments.p2wpkh({ pubkey: keyPair.publicKey, network: network }),
+            redeem: payments.p2wpkh({ pubkey: Buffer.from(keyPair.publicKey), network: network }),
             network: network,
         });
 
@@ -207,13 +306,13 @@ export class EcKeyPair {
      * Get the legacy address from a keypair
      * @param {ECPairInterface} keyPair - The keypair to get the address for
      * @param {Network} network - The network to use
-     * @returns {Address} - The legacy address
+     * @returns {string} - The legacy address
      */
     public static getLegacyAddress(
         keyPair: ECPairInterface,
         network: Network = networks.bitcoin,
-    ): Address {
-        const wallet = payments.p2pkh({ pubkey: keyPair.publicKey, network: network });
+    ): string {
+        const wallet = payments.p2pkh({ pubkey: Buffer.from(keyPair.publicKey), network: network });
         if (!wallet.address) {
             throw new Error('Failed to generate wallet');
         }
@@ -225,13 +324,13 @@ export class EcKeyPair {
      * Get the legacy address from a keypair
      * @param {ECPairInterface} keyPair - The keypair to get the address for
      * @param {Network} network - The network to use
-     * @returns {Address} - The legacy address
+     * @returns {string} - The legacy address
      */
     public static getP2PKAddress(
         keyPair: ECPairInterface,
         network: Network = networks.bitcoin,
-    ): Address {
-        const wallet = payments.p2pk({ pubkey: keyPair.publicKey, network: network });
+    ): string {
+        const wallet = payments.p2pk({ pubkey: Buffer.from(keyPair.publicKey), network: network });
         if (!wallet.output) {
             throw new Error('Failed to generate wallet');
         }
@@ -264,14 +363,14 @@ export class EcKeyPair {
      * Get taproot address from keypair
      * @param {ECPairInterface} keyPair - The keypair to get the taproot address for
      * @param {Network} network - The network to use
-     * @returns {Address} - The taproot address
+     * @returns {string} - The taproot address
      */
     public static getTaprootAddress(
-        keyPair: ECPairInterface,
+        keyPair: ECPairInterface | Signer,
         network: Network = networks.bitcoin,
-    ): Address {
+    ): string {
         const { address } = payments.p2tr({
-            internalPubkey: toXOnly(keyPair.publicKey),
+            internalPubkey: toXOnly(Buffer.from(keyPair.publicKey)),
             network: network,
         });
 
@@ -284,14 +383,14 @@ export class EcKeyPair {
 
     /**
      * Get taproot address from address
-     * @param {Address} inAddr - The address to convert to taproot
+     * @param {string} inAddr - The address to convert to taproot
      * @param {Network} network - The network to use
-     * @returns {Address} - The taproot address
+     * @returns {string} - The taproot address
      */
     public static getTaprootAddressFromAddress(
-        inAddr: Address,
+        inAddr: string,
         network: Network = networks.bitcoin,
-    ): Address {
+    ): string {
         const { address } = payments.p2tr({
             address: inAddr,
             network: network,

package/src/keypair/Wallet.ts

@@ -2,8 +2,8 @@ import { IWallet } from './interfaces/IWallet.js';
 import { ECPairInterface } from 'ecpair';
 import { EcKeyPair } from './EcKeyPair.js';
 import { Network, networks } from 'bitcoinjs-lib';
-import { Address } from '@btc-vision/bsi-binary';
 import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
+import { Address } from './Address.js';
 
 /**
  * Wallet class
@@ -19,19 +19,43 @@ export class Wallet {
      * P2WPKH address for the wallet
      * @private
      */
-    private readonly _p2wpkh: Address;
+    private readonly _p2wpkh: string;
 
     /**
      * P2TR address for the wallet
      * @private
      */
-    private readonly _p2tr: Address;
+    private readonly _p2tr: string;
 
     /**
      * Legacy address for the wallet
      * @private
      */
-    private readonly _legacy: Address;
+    private readonly _legacy: string;
+
+    /**
+     * Legacy address for the wallet
+     * @private
+     */
+    private readonly _segwitLegacy: string;
+
+    /**
+     * Buffer public key
+     * @private
+     */
+    private readonly _bufferPubKey: Buffer;
+
+    /**
+     * Tweaked key
+     * @private
+     */
+    private readonly _tweakedKey: Buffer;
+
+    /**
+     * Address corresponding to the wallet
+     * @private
+     */
+    private readonly _address: Address;
 
     constructor(
         wallet: IWallet,
@@ -42,6 +66,31 @@ export class Wallet {
         this._p2wpkh = EcKeyPair.getP2WPKHAddress(this._keypair, this.network);
         this._p2tr = EcKeyPair.getTaprootAddress(this._keypair, this.network);
         this._legacy = EcKeyPair.getLegacyAddress(this._keypair, this.network);
+        this._segwitLegacy = EcKeyPair.getLegacySegwitAddress(this._keypair, this.network);
+
+        this._tweakedKey = Buffer.from(
+            EcKeyPair.tweakPublicKey(this._keypair.publicKey.toString('hex')),
+            'hex',
+        );
+
+        this._bufferPubKey = Buffer.from(wallet.publicKey, 'hex');
+        this._address = new Address(this._keypair.publicKey);
+    }
+
+    /**
+     * Get the address for the wallet
+     * @returns {Address}
+     */
+    public get address(): Address {
+        return this._address;
+    }
+
+    /**
+     * Get the tweaked key
+     * @returns {Buffer}
+     */
+    public get tweakedPubKeyKey(): Buffer {
+        return this._tweakedKey;
     }
 
     /**
@@ -56,25 +105,25 @@ export class Wallet {
 
     /**
      * Get the P2WPKH address for the wallet
-     * @returns {Address}
+     * @returns {string}
      */
-    public get p2wpkh(): Address {
+    public get p2wpkh(): string {
         return this._p2wpkh;
     }
 
     /**
      * Get the P2TR address for the wallet
-     * @returns {Address}
+     * @returns {string}
      */
-    public get p2tr(): Address {
+    public get p2tr(): string {
         return this._p2tr;
     }
 
     /**
      * Get the legacy address for the wallet
-     * @returns {Address}
+     * @returns {string}
      */
-    public get legacy(): Address {
+    public get legacy(): string {
         return this._legacy;
     }
 
@@ -82,8 +131,16 @@ export class Wallet {
      * Get the addresses for the wallet
      * @returns {Address[]}
      */
-    public get addresses(): Address[] {
-        return [this.p2wpkh, this.p2tr, this.legacy];
+    public get addresses(): string[] {
+        return [this.p2wpkh, this.p2tr, this.legacy, this.segwitLegacy];
+    }
+
+    /**
+     * Get the segwit legacy address for the wallet
+     * @returns {string}
+     */
+    public get segwitLegacy(): string {
+        return this._segwitLegacy;
     }
 
     /**
@@ -92,9 +149,9 @@ export class Wallet {
      * @returns {Buffer}
      */
     public get publicKey(): Buffer {
-        if (!this.keypair) throw new Error('Keypair not set');
+        if (!this._bufferPubKey) throw new Error('Public key not set');
 
-        return this.keypair.publicKey;
+        return this._bufferPubKey;
     }
 
     /**
@@ -105,7 +162,7 @@ export class Wallet {
     public get xOnly(): Buffer {
         if (!this.keypair) throw new Error('Keypair not set');
 
-        return toXOnly(this.keypair.publicKey);
+        return toXOnly(this._bufferPubKey);
     }
 
     /**

package/src/metadata/ContractBaseMetadata.ts

@@ -1,8 +1,7 @@
-import { Address } from '@btc-vision/bsi-binary';
 import { Network, networks } from 'bitcoinjs-lib';
 
 export abstract class ContractBaseMetadata {
-    protected abstract readonly address: Address;
+    protected abstract readonly address: string;
 
     protected constructor(protected network: Network = networks.bitcoin) {}
 
@@ -10,14 +9,14 @@ export abstract class ContractBaseMetadata {
      * @description Get the contract address
      * @param {Network} network - The network to get the address for
      */
-    public static getAddress(network: Network = networks.bitcoin): Address {
+    public static getAddress(network: Network = networks.bitcoin): string {
         throw new Error('Method not implemented.');
     }
 
     /**
      * @description Get the contract address
      */
-    public getAddress(): Address {
+    public getAddress(): string {
         return this.address;
     }
 }

package/src/metadata/contracts/wBTC.ts

@@ -1,8 +1,8 @@
-import { Address } from '@btc-vision/bsi-binary';
 import { Network, networks } from 'bitcoinjs-lib';
 import { ChainId } from '../../network/ChainId.js';
 import { ContractBaseMetadata } from '../ContractBaseMetadata.js';
 import { WBTC_ADDRESS_FRACTAL, WBTC_ADDRESS_REGTEST, WBTC_ADDRESS_TESTNET } from '../tokens.js';
+import { Address } from '../../keypair/Address.js';
 
 /**
  * @description Wrapped Bitcoin (wBTC) contract metadata.
@@ -23,7 +23,7 @@ export class wBTC extends ContractBaseMetadata {
      */
     public readonly decimals: number = 8;
 
-    protected readonly address: Address;
+    protected readonly address: string;
 
     constructor(
         protected network: Network = networks.bitcoin,
@@ -34,14 +34,14 @@ export class wBTC extends ContractBaseMetadata {
         this.address = wBTC.getAddress(network, chainId);
     }
 
-    public static getAddress(network: Network = networks.bitcoin, chainId?: ChainId): Address {
+    public static getAddress(network: Network = networks.bitcoin, chainId?: ChainId): string {
         switch (network.bech32) {
             case networks.bitcoin.bech32:
-                return this.getWBTCAddressForChain(chainId ?? ChainId.Bitcoin);
+                return this.getWBTCAddressForChain(chainId ?? ChainId.Bitcoin).p2tr(network);
             case networks.regtest.bech32:
-                return WBTC_ADDRESS_REGTEST;
+                return WBTC_ADDRESS_REGTEST.p2tr(network);
             case networks.testnet.bech32:
-                return WBTC_ADDRESS_TESTNET;
+                return WBTC_ADDRESS_TESTNET.p2tr(network);
             default:
                 throw new Error(`Invalid network: ${network.bech32}`);
         }
@@ -49,12 +49,11 @@ export class wBTC extends ContractBaseMetadata {
 
     private static getWBTCAddressForChain(chainId: ChainId): Address {
         switch (chainId) {
-            case ChainId.Bitcoin:
-                return 'unknown';
+            //case ChainId.Bitcoin:
             case ChainId.Fractal:
                 return WBTC_ADDRESS_FRACTAL;
             default:
-                throw new Error(`Invalid chainId: ${chainId}`);
+                throw new Error(`Unsupported chainId: ${chainId}`);
         }
     }
 }

package/src/metadata/tokens.ts

@@ -1,26 +1,31 @@
-import { Address } from '@btc-vision/bsi-binary';
 import { ChainId } from '../network/ChainId.js';
+import { Address } from '../keypair/Address.js';
+
+function deadAddress(): Address {
+    return Address.dead();
+}
 
 // Addresses Regtest
-export const FACTORY_ADDRESS_REGTEST: Address = 'bcrt1q9pf9fnpch9z2qrp5e3dgr2avzu3mypq3km2k40';
-export const POOL_ADDRESS_REGTEST: Address = 'bcrt1qg87nx9v9ln3qyadcn0llekzjn0hx8js46ztwky';
-export const WBTC_ADDRESS_REGTEST: Address = 'bcrt1qamv2ejattjgsc6k3yf3zqrp0wpuyedqgjmwx0v';
-export const MOTO_ADDRESS_REGTEST: Address = 'bcrt1qw8w4ejas2k22y54avv7hgrslg3cd0hme58h28r';
-export const ROUTER_ADDRESS_REGTEST: Address = 'bcrt1q9yd6mk324k0q4krmlxjky0pk65ul6hkf4u35e6';
+export const FACTORY_ADDRESS_REGTEST: Address = deadAddress();
+
+export const POOL_ADDRESS_REGTEST: Address = deadAddress();
+export const WBTC_ADDRESS_REGTEST: Address = deadAddress();
+export const MOTO_ADDRESS_REGTEST: Address = deadAddress();
+export const ROUTER_ADDRESS_REGTEST: Address = deadAddress();
 
 // Addresses Testnet
-export const FACTORY_ADDRESS_TESTNET: Address = 'tb1qgev5kldhp5zvg6j8t9vl6x4phkrwn8nk9felxh';
-export const POOL_ADDRESS_TESTNET: Address = 'tb1q6a7yw353hjmresphupytw5vczpqxtg4yrupayk';
-export const WBTC_ADDRESS_TESTNET: Address = 'tb1qp28xna6pv47x6wflcplhu0a9hkld5shtvjx6xv';
-export const MOTO_ADDRESS_TESTNET: Address = 'tb1q4tyhf8hpu04qjj3qaag20knun0spctultxzakw';
-export const ROUTER_ADDRESS_TESTNET: Address = 'tb1qnh9mj95nnej25dwhjvvsppwmdm0myhxv7tllgt';
+export const FACTORY_ADDRESS_TESTNET: Address = deadAddress();
+export const POOL_ADDRESS_TESTNET: Address = deadAddress();
+export const WBTC_ADDRESS_TESTNET: Address = deadAddress();
+export const MOTO_ADDRESS_TESTNET: Address = deadAddress();
+export const ROUTER_ADDRESS_TESTNET: Address = deadAddress();
 
 // Addresses Fractal
-export const FACTORY_ADDRESS_FRACTAL: Address = 'bc1qr4g85824m58wu0zffjtnf56n425fp0e8azhc7q';
-export const POOL_ADDRESS_FRACTAL: Address = 'bc1qv55cht4zzlt29ea7vdgwsedsn63a2sxtkgpv6h';
-export const WBTC_ADDRESS_FRACTAL: Address = 'bc1qdtzlucslvrvu4useyh9r69supqrw3w4xn9t4yv';
-export const MOTO_ADDRESS_FRACTAL: Address = 'bc1qfzq6w5uvgg5489egv0lj4shlqx4dagqt0ewdnu';
-export const ROUTER_ADDRESS_FRACTAL: Address = 'bc1q9w2zvmkzlezt2fu34u57y9vuw6rll5sp2090kn';
+export const FACTORY_ADDRESS_FRACTAL: Address = deadAddress();
+export const POOL_ADDRESS_FRACTAL: Address = deadAddress();
+export const WBTC_ADDRESS_FRACTAL: Address = deadAddress();
+export const MOTO_ADDRESS_FRACTAL: Address = deadAddress();
+export const ROUTER_ADDRESS_FRACTAL: Address = deadAddress();
 
 export enum OPNetNetwork {
     Mainnet = 'mainnet',

package/src/opnet.ts

@@ -73,6 +73,19 @@ export * from './consensus/ConsensusConfig.js';
 export * from './consensus/Consensus.js';
 export * from './consensus/metadata/RoswellConsensus.js';
 
+/** Binary */
+export * from './utils/BufferHelper.js';
+export * from './utils/types.js';
+export * from './keypair/Address.js';
+export * from './event/NetEvent.js';
+export * from './deterministic/DeterministicMap.js';
+export * from './deterministic/DeterministicSet.js';
+export * from './deterministic/AddressMap.js';
+export * from './deterministic/AddressSet.js';
+export * from './abi/ABICoder.js';
+export * from './buffer/BinaryWriter.js';
+export * from './buffer/BinaryReader.js';
+
 /** Custom signers */
 export * from './transaction/browser/BrowserSignerBase.js';
 export * from './transaction/browser/extensions/UnisatSigner.js';

package/src/signer/TweakedSigner.ts

@@ -31,8 +31,9 @@ export class TweakedSigner {
      * Tweak a signer
      * @param {Signer} signer - The signer to tweak
      * @param {TweakSettings} opts - The tweak settings
+     * @returns {ECPairInterface} - The tweaked signer
      */
-    public static tweakSigner(signer: ECPairInterface, opts: TweakSettings = {}): Signer {
+    public static tweakSigner(signer: ECPairInterface, opts: TweakSettings = {}): ECPairInterface {
         let privateKey: Uint8Array | undefined = signer.privateKey;
         if (!privateKey) {
             throw new Error('Private key is required for tweaking signer!');
@@ -44,7 +45,7 @@ export class TweakedSigner {
 
         const tweakedPrivateKey = ecc.privateAdd(
             privateKey,
-            tapTweakHash(toXOnly(signer.publicKey), opts.tweakHash),
+            tapTweakHash(toXOnly(Buffer.from(signer.publicKey)), opts.tweakHash),
         );
 
         if (!tweakedPrivateKey) {