@btc-vision/transaction 1.0.112 → 1.0.114

package/build/keypair/EcKeyPair.d.ts

@@ -1,25 +1,28 @@
-import { Address } from '@btc-vision/bsi-binary';
 import { BIP32API, BIP32Interface } from 'bip32';
-import { Network } from 'bitcoinjs-lib';
+import { Network, Signer } from 'bitcoinjs-lib';
 import { ECPairAPI, ECPairInterface } from 'ecpair';
 import { IWallet } from './interfaces/IWallet.js';
 export declare class EcKeyPair {
     static BIP32: BIP32API;
     static ECPair: ECPairAPI;
     static fromWIF(wif: string, network?: Network): ECPairInterface;
-    static fromPrivateKey(privateKey: Buffer, network?: Network): ECPairInterface;
-    static fromPublicKey(publicKey: Buffer, network?: Network): ECPairInterface;
-    static generateMultiSigAddress(pubKeys: Buffer[], minimumSignatureRequired: number, network?: Network): Address;
+    static fromPrivateKey(privateKey: Buffer | Uint8Array, network?: Network): ECPairInterface;
+    static fromPublicKey(publicKey: Buffer | Uint8Array, network?: Network): ECPairInterface;
+    static generateMultiSigAddress(pubKeys: Buffer[], minimumSignatureRequired: number, network?: Network): string;
     static verifyPubKeys(pubKeys: Buffer[], network?: Network): Buffer[];
-    static getP2WPKHAddress(keyPair: ECPairInterface, network?: Network): Address;
+    static getP2WPKHAddress(keyPair: ECPairInterface, network?: Network): string;
+    static tweakedPubKeyToAddress(tweakedPubKeyHex: string, network: Network): string;
+    static tweakedPubKeyBufferToAddress(tweakedPubKeyBuffer: Buffer | Uint8Array, network: Network): string;
+    static xOnlyTweakedPubKeyToAddress(tweakedPubKeyHex: string, network: Network): string;
+    static tweakPublicKey(compressedPubKeyHex: string): string;
     static generateWallet(network?: Network): IWallet;
-    static verifyContractAddress(contractAddress: Address, network?: Network): boolean;
-    static getLegacySegwitAddress(keyPair: ECPairInterface, network?: Network): Address;
-    static getLegacyAddress(keyPair: ECPairInterface, network?: Network): Address;
-    static getP2PKAddress(keyPair: ECPairInterface, network?: Network): Address;
+    static verifyContractAddress(contractAddress: string, network?: Network): boolean;
+    static getLegacySegwitAddress(keyPair: ECPairInterface, network?: Network): string;
+    static getLegacyAddress(keyPair: ECPairInterface, network?: Network): string;
+    static getP2PKAddress(keyPair: ECPairInterface, network?: Network): string;
     static generateRandomKeyPair(network?: Network): ECPairInterface;
     static fromSeed(seed: Buffer, network?: Network): BIP32Interface;
-    static getTaprootAddress(keyPair: ECPairInterface, network?: Network): Address;
-    static getTaprootAddressFromAddress(inAddr: Address, network?: Network): Address;
+    static getTaprootAddress(keyPair: ECPairInterface | Signer, network?: Network): string;
+    static getTaprootAddressFromAddress(inAddr: string, network?: Network): string;
     static fromSeedKeyPair(seed: Buffer, network?: Network): ECPairInterface;
 }

package/build/keypair/EcKeyPair.js

@@ -3,6 +3,8 @@ import bip32, { BIP32Factory } from 'bip32';
 import { address, initEccLib, networks, payments } from 'bitcoinjs-lib';
 import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
 import { ECPairFactory } from 'ecpair';
+import { CURVE, Point, utils } from '@noble/secp256k1';
+import { taggedHash } from 'bitcoinjs-lib/src/crypto.js';
 initEccLib(ecc);
 const BIP32factory = typeof bip32 === 'function' ? bip32 : BIP32Factory;
 if (!BIP32factory) {
@@ -13,10 +15,11 @@ export class EcKeyPair {
         return this.ECPair.fromWIF(wif, network);
     }
     static fromPrivateKey(privateKey, network = networks.bitcoin) {
-        return this.ECPair.fromPrivateKey(privateKey, { network });
+        return this.ECPair.fromPrivateKey(!Buffer.isBuffer(privateKey) ? Buffer.from(privateKey) : privateKey, { network });
     }
     static fromPublicKey(publicKey, network = networks.bitcoin) {
-        return this.ECPair.fromPublicKey(publicKey, { network });
+        const buf = !Buffer.isBuffer(publicKey) ? Buffer.from(publicKey) : publicKey;
+        return this.ECPair.fromPublicKey(buf, { network });
     }
     static generateMultiSigAddress(pubKeys, minimumSignatureRequired, network = networks.bitcoin) {
         const publicKeys = this.verifyPubKeys(pubKeys, network);
@@ -40,16 +43,65 @@ export class EcKeyPair {
             if (!key) {
                 throw new Error('Failed to regenerate key');
             }
-            return key.publicKey;
+            return Buffer.from(key.publicKey);
         });
     }
     static getP2WPKHAddress(keyPair, network = networks.bitcoin) {
-        const res = payments.p2wpkh({ pubkey: keyPair.publicKey, network: network });
+        const res = payments.p2wpkh({ pubkey: Buffer.from(keyPair.publicKey), network: network });
         if (!res.address) {
             throw new Error('Failed to generate wallet');
         }
         return res.address;
     }
+    static tweakedPubKeyToAddress(tweakedPubKeyHex, network) {
+        if (tweakedPubKeyHex.startsWith('0x')) {
+            tweakedPubKeyHex = tweakedPubKeyHex.slice(2);
+        }
+        let tweakedPubKeyBuffer = Buffer.from(tweakedPubKeyHex, 'hex');
+        if (tweakedPubKeyBuffer.length !== 32)
+            tweakedPubKeyBuffer = toXOnly(tweakedPubKeyBuffer);
+        return EcKeyPair.tweakedPubKeyBufferToAddress(tweakedPubKeyBuffer, network);
+    }
+    static tweakedPubKeyBufferToAddress(tweakedPubKeyBuffer, network) {
+        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;
+    }
+    static xOnlyTweakedPubKeyToAddress(tweakedPubKeyHex, network) {
+        if (tweakedPubKeyHex.startsWith('0x')) {
+            tweakedPubKeyHex = tweakedPubKeyHex.slice(2);
+        }
+        const tweakedPubKeyBuffer = Buffer.from(tweakedPubKeyHex, 'hex');
+        const { address } = payments.p2tr({
+            pubkey: tweakedPubKeyBuffer,
+            network: network,
+        });
+        if (!address) {
+            throw new Error('Failed to generate Taproot address');
+        }
+        return address;
+    }
+    static tweakPublicKey(compressedPubKeyHex) {
+        if (compressedPubKeyHex.startsWith('0x')) {
+            compressedPubKeyHex = compressedPubKeyHex.slice(2);
+        }
+        let P = Point.fromHex(compressedPubKeyHex);
+        if (!P.hasEvenY()) {
+            P = P.negate();
+        }
+        const x = P.toRawBytes(true).slice(1);
+        const tHash = taggedHash('TapTweak', Buffer.from(x));
+        const t = utils.mod(BigInt('0x' + Buffer.from(tHash).toString('hex')), CURVE.n);
+        const Q = P.add(Point.BASE.multiply(t));
+        return Q.toHex(true);
+    }
     static generateWallet(network = networks.bitcoin) {
         const keyPair = this.ECPair.makeRandom({
             network: network,
@@ -61,7 +113,7 @@ export class EcKeyPair {
         return {
             address: wallet,
             privateKey: keyPair.toWIF(),
-            publicKey: keyPair.publicKey.toString('hex'),
+            publicKey: Buffer.from(keyPair.publicKey).toString('hex'),
         };
     }
     static verifyContractAddress(contractAddress, network = networks.bitcoin) {
@@ -69,7 +121,7 @@ export class EcKeyPair {
     }
     static getLegacySegwitAddress(keyPair, network = networks.bitcoin) {
         const wallet = payments.p2sh({
-            redeem: payments.p2wpkh({ pubkey: keyPair.publicKey, network: network }),
+            redeem: payments.p2wpkh({ pubkey: Buffer.from(keyPair.publicKey), network: network }),
             network: network,
         });
         if (!wallet.address) {
@@ -78,14 +130,14 @@ export class EcKeyPair {
         return wallet.address;
     }
     static getLegacyAddress(keyPair, network = networks.bitcoin) {
-        const wallet = payments.p2pkh({ pubkey: keyPair.publicKey, network: network });
+        const wallet = payments.p2pkh({ pubkey: Buffer.from(keyPair.publicKey), network: network });
         if (!wallet.address) {
             throw new Error('Failed to generate wallet');
         }
         return wallet.address;
     }
     static getP2PKAddress(keyPair, network = networks.bitcoin) {
-        const wallet = payments.p2pk({ pubkey: keyPair.publicKey, network: network });
+        const wallet = payments.p2pk({ pubkey: Buffer.from(keyPair.publicKey), network: network });
         if (!wallet.output) {
             throw new Error('Failed to generate wallet');
         }
@@ -101,7 +153,7 @@ export class EcKeyPair {
     }
     static getTaprootAddress(keyPair, network = networks.bitcoin) {
         const { address } = payments.p2tr({
-            internalPubkey: toXOnly(keyPair.publicKey),
+            internalPubkey: toXOnly(Buffer.from(keyPair.publicKey)),
             network: network,
         });
         if (!address) {

package/build/keypair/Wallet.d.ts

@@ -1,19 +1,26 @@
 import { IWallet } from './interfaces/IWallet.js';
 import { ECPairInterface } from 'ecpair';
 import { Network } from 'bitcoinjs-lib';
-import { Address } from '@btc-vision/bsi-binary';
+import { Address } from './Address.js';
 export declare class Wallet {
     readonly network: Network;
     private readonly _keypair;
     private readonly _p2wpkh;
     private readonly _p2tr;
     private readonly _legacy;
+    private readonly _segwitLegacy;
+    private readonly _bufferPubKey;
+    private readonly _tweakedKey;
+    private readonly _address;
     constructor(wallet: IWallet, network?: Network);
+    get address(): Address;
+    get tweakedPubKeyKey(): Buffer;
     get keypair(): ECPairInterface;
-    get p2wpkh(): Address;
-    get p2tr(): Address;
-    get legacy(): Address;
-    get addresses(): Address[];
+    get p2wpkh(): string;
+    get p2tr(): string;
+    get legacy(): string;
+    get addresses(): string[];
+    get segwitLegacy(): string;
     get publicKey(): Buffer;
     get xOnly(): Buffer;
     static fromWif(wif: string, network?: Network): Wallet;

package/build/keypair/Wallet.js

@@ -1,6 +1,7 @@
 import { EcKeyPair } from './EcKeyPair.js';
 import { networks } from 'bitcoinjs-lib';
 import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
+import { Address } from './Address.js';
 export class Wallet {
     constructor(wallet, network = networks.bitcoin) {
         this.network = network;
@@ -8,6 +9,16 @@ 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 address() {
+        return this._address;
+    }
+    get tweakedPubKeyKey() {
+        return this._tweakedKey;
     }
     get keypair() {
         if (!this._keypair)
@@ -24,17 +35,20 @@ export class Wallet {
         return this._legacy;
     }
     get addresses() {
-        return [this.p2wpkh, this.p2tr, this.legacy];
+        return [this.p2wpkh, this.p2tr, this.legacy, this.segwitLegacy];
+    }
+    get segwitLegacy() {
+        return this._segwitLegacy;
     }
     get publicKey() {
-        if (!this.keypair)
-            throw new Error('Keypair not set');
-        return this.keypair.publicKey;
+        if (!this._bufferPubKey)
+            throw new Error('Public key not set');
+        return this._bufferPubKey;
     }
     get xOnly() {
         if (!this.keypair)
             throw new Error('Keypair not set');
-        return toXOnly(this.keypair.publicKey);
+        return toXOnly(this._bufferPubKey);
     }
     static fromWif(wif, network = networks.bitcoin) {
         return new Wallet({ privateKey: wif, address: '', publicKey: '' }, network);

package/build/metadata/ContractBaseMetadata.d.ts

@@ -1,9 +1,8 @@
-import { Address } from '@btc-vision/bsi-binary';
 import { Network } from 'bitcoinjs-lib';
 export declare abstract class ContractBaseMetadata {
     protected network: Network;
-    protected abstract readonly address: Address;
+    protected abstract readonly address: string;
     protected constructor(network?: Network);
-    static getAddress(network?: Network): Address;
-    getAddress(): Address;
+    static getAddress(network?: Network): string;
+    getAddress(): string;
 }

package/build/metadata/contracts/wBTC.d.ts

@@ -1,4 +1,3 @@
-import { Address } from '@btc-vision/bsi-binary';
 import { Network } from 'bitcoinjs-lib';
 import { ChainId } from '../../network/ChainId.js';
 import { ContractBaseMetadata } from '../ContractBaseMetadata.js';
@@ -7,8 +6,8 @@ export declare class wBTC extends ContractBaseMetadata {
     readonly tokenName: string;
     readonly tokenSymbol: string;
     readonly decimals: number;
-    protected readonly address: Address;
+    protected readonly address: string;
     constructor(network?: Network, chainId?: ChainId);
-    static getAddress(network?: Network, chainId?: ChainId): Address;
+    static getAddress(network?: Network, chainId?: ChainId): string;
     private static getWBTCAddressForChain;
 }

package/build/metadata/contracts/wBTC.js

@@ -14,23 +14,21 @@ export class wBTC extends ContractBaseMetadata {
     static getAddress(network = networks.bitcoin, chainId) {
         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}`);
         }
     }
     static getWBTCAddressForChain(chainId) {
         switch (chainId) {
-            case ChainId.Bitcoin:
-                return 'unknown';
             case ChainId.Fractal:
                 return WBTC_ADDRESS_FRACTAL;
             default:
-                throw new Error(`Invalid chainId: ${chainId}`);
+                throw new Error(`Unsupported chainId: ${chainId}`);
         }
     }
 }

package/build/metadata/tokens.d.ts

@@ -1,5 +1,5 @@
-import { Address } from '@btc-vision/bsi-binary';
 import { ChainId } from '../network/ChainId.js';
+import { Address } from '../keypair/Address.js';
 export declare const FACTORY_ADDRESS_REGTEST: Address;
 export declare const POOL_ADDRESS_REGTEST: Address;
 export declare const WBTC_ADDRESS_REGTEST: Address;

package/build/metadata/tokens.js

@@ -1,19 +1,23 @@
 import { ChainId } from '../network/ChainId.js';
-export const FACTORY_ADDRESS_REGTEST = 'bcrt1q9pf9fnpch9z2qrp5e3dgr2avzu3mypq3km2k40';
-export const POOL_ADDRESS_REGTEST = 'bcrt1qg87nx9v9ln3qyadcn0llekzjn0hx8js46ztwky';
-export const WBTC_ADDRESS_REGTEST = 'bcrt1qamv2ejattjgsc6k3yf3zqrp0wpuyedqgjmwx0v';
-export const MOTO_ADDRESS_REGTEST = 'bcrt1qw8w4ejas2k22y54avv7hgrslg3cd0hme58h28r';
-export const ROUTER_ADDRESS_REGTEST = 'bcrt1q9yd6mk324k0q4krmlxjky0pk65ul6hkf4u35e6';
-export const FACTORY_ADDRESS_TESTNET = 'tb1qgev5kldhp5zvg6j8t9vl6x4phkrwn8nk9felxh';
-export const POOL_ADDRESS_TESTNET = 'tb1q6a7yw353hjmresphupytw5vczpqxtg4yrupayk';
-export const WBTC_ADDRESS_TESTNET = 'tb1qp28xna6pv47x6wflcplhu0a9hkld5shtvjx6xv';
-export const MOTO_ADDRESS_TESTNET = 'tb1q4tyhf8hpu04qjj3qaag20knun0spctultxzakw';
-export const ROUTER_ADDRESS_TESTNET = 'tb1qnh9mj95nnej25dwhjvvsppwmdm0myhxv7tllgt';
-export const FACTORY_ADDRESS_FRACTAL = 'bc1qr4g85824m58wu0zffjtnf56n425fp0e8azhc7q';
-export const POOL_ADDRESS_FRACTAL = 'bc1qv55cht4zzlt29ea7vdgwsedsn63a2sxtkgpv6h';
-export const WBTC_ADDRESS_FRACTAL = 'bc1qdtzlucslvrvu4useyh9r69supqrw3w4xn9t4yv';
-export const MOTO_ADDRESS_FRACTAL = 'bc1qfzq6w5uvgg5489egv0lj4shlqx4dagqt0ewdnu';
-export const ROUTER_ADDRESS_FRACTAL = 'bc1q9w2zvmkzlezt2fu34u57y9vuw6rll5sp2090kn';
+import { Address } from '../keypair/Address.js';
+function deadAddress() {
+    return Address.dead();
+}
+export const FACTORY_ADDRESS_REGTEST = deadAddress();
+export const POOL_ADDRESS_REGTEST = deadAddress();
+export const WBTC_ADDRESS_REGTEST = deadAddress();
+export const MOTO_ADDRESS_REGTEST = deadAddress();
+export const ROUTER_ADDRESS_REGTEST = deadAddress();
+export const FACTORY_ADDRESS_TESTNET = deadAddress();
+export const POOL_ADDRESS_TESTNET = deadAddress();
+export const WBTC_ADDRESS_TESTNET = deadAddress();
+export const MOTO_ADDRESS_TESTNET = deadAddress();
+export const ROUTER_ADDRESS_TESTNET = deadAddress();
+export const FACTORY_ADDRESS_FRACTAL = deadAddress();
+export const POOL_ADDRESS_FRACTAL = deadAddress();
+export const WBTC_ADDRESS_FRACTAL = deadAddress();
+export const MOTO_ADDRESS_FRACTAL = deadAddress();
+export const ROUTER_ADDRESS_FRACTAL = deadAddress();
 export var OPNetNetwork;
 (function (OPNetNetwork) {
     OPNetNetwork["Mainnet"] = "mainnet";

package/build/opnet.d.ts

@@ -43,6 +43,17 @@ export * from './wbtc/UnwrapGeneration.js';
 export * from './consensus/ConsensusConfig.js';
 export * from './consensus/Consensus.js';
 export * from './consensus/metadata/RoswellConsensus.js';
+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';
 export * from './transaction/browser/BrowserSignerBase.js';
 export * from './transaction/browser/extensions/UnisatSigner.js';
 export * from './transaction/browser/types/Unisat.js';

package/build/opnet.js

@@ -43,6 +43,17 @@ export * from './wbtc/UnwrapGeneration.js';
 export * from './consensus/ConsensusConfig.js';
 export * from './consensus/Consensus.js';
 export * from './consensus/metadata/RoswellConsensus.js';
+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';
 export * from './transaction/browser/BrowserSignerBase.js';
 export * from './transaction/browser/extensions/UnisatSigner.js';
 export * from './transaction/browser/types/Unisat.js';

package/build/signer/TweakedSigner.d.ts

@@ -1,9 +1,9 @@
-import { Network, Signer } from 'bitcoinjs-lib';
+import { Network } from 'bitcoinjs-lib';
 import { ECPairInterface } from 'ecpair';
 export interface TweakSettings {
     readonly network?: Network;
     tweakHash?: Buffer;
 }
 export declare class TweakedSigner {
-    static tweakSigner(signer: ECPairInterface, opts?: TweakSettings): Signer;
+    static tweakSigner(signer: ECPairInterface, opts?: TweakSettings): ECPairInterface;
 }

package/build/signer/TweakedSigner.js

@@ -13,7 +13,7 @@ export class TweakedSigner {
         if (signer.publicKey[0] === 3) {
             privateKey = ecc.privateNegate(privateKey);
         }
-        const tweakedPrivateKey = ecc.privateAdd(privateKey, tapTweakHash(toXOnly(signer.publicKey), opts.tweakHash));
+        const tweakedPrivateKey = ecc.privateAdd(privateKey, tapTweakHash(toXOnly(Buffer.from(signer.publicKey)), opts.tweakHash));
         if (!tweakedPrivateKey) {
             throw new Error('Invalid tweaked private key!');
         }

package/build/transaction/TransactionFactory.d.ts

@@ -1,4 +1,3 @@
-import { Address } from '@btc-vision/bsi-binary';
 import { Transaction } from 'bitcoinjs-lib';
 import { UTXO } from '../utxo/interfaces/IUTXO.js';
 import { ICustomTransactionParameters } from './builders/CustomScriptTransaction.js';
@@ -8,15 +7,16 @@ import { TransactionType } from './enums/TransactionType.js';
 import { IDeploymentParameters, IFundingTransactionParameters, IInteractionParameters, IUnwrapParameters, IWrapParameters } from './interfaces/ITransactionParameters.js';
 export interface DeploymentResult {
     readonly transaction: [string, string];
-    readonly contractAddress: Address;
-    readonly p2trAddress: Address;
+    readonly contractAddress: string;
+    readonly contractPubKey: string;
+    readonly p2trAddress: string;
     readonly utxos: UTXO[];
 }
 export interface WrapResult {
     readonly transaction: [string, string];
-    readonly vaultAddress: Address;
+    readonly vaultAddress: string;
     readonly amount: bigint;
-    readonly receiverAddress: Address;
+    readonly receiverAddress: string;
     readonly utxos: UTXO[];
 }
 export interface FundingTransactionResponse {
@@ -45,7 +45,7 @@ export declare class TransactionFactory {
     unwrapSegwit(unwrapParameters: IUnwrapParameters): Promise<UnwrapResult>;
     unwrap(unwrapParameters: IUnwrapParameters): Promise<UnwrapResult>;
     createBTCTransfer(parameters: IFundingTransactionParameters): Promise<BitcoinTransferResponse>;
-    getAllNewUTXOs(original: TransactionBuilder<TransactionType>, tx: Transaction, to: Address): UTXO[];
+    getAllNewUTXOs(original: TransactionBuilder<TransactionType>, tx: Transaction, to: string): UTXO[];
     private createFundTransaction;
     private calculateNumSignatures;
     private calculateNumInputs;

package/build/transaction/TransactionFactory.js

@@ -137,7 +137,8 @@ export class TransactionFactory {
         };
         return {
             transaction: [signedTransaction.toHex(), outTx.toHex()],
-            contractAddress: finalTransaction.contractAddress,
+            contractAddress: finalTransaction.contractAddress.p2tr(deploymentParameters.network),
+            contractPubKey: finalTransaction.contractPubKey,
             p2trAddress: finalTransaction.p2trAddress,
             utxos: [refundUTXO],
         };
@@ -179,7 +180,7 @@ export class TransactionFactory {
             transaction: [signedTransaction.tx.toHex(), outTx.toHex()],
             vaultAddress: finalTransaction.vault,
             amount: finalTransaction.amount,
-            receiverAddress: finalTransaction.receiver,
+            receiverAddress: finalTransaction.receiver.p2tr(wrapParameters.network),
             utxos: this.getUTXOAsTransaction(signedTransaction.tx, wrapParameters.from, 1),
         };
     }

package/build/transaction/browser/BrowserSignerBase.d.ts

@@ -1,11 +1,10 @@
 import { Network, Psbt, Signer } from 'bitcoinjs-lib';
-import { Address } from '@btc-vision/bsi-binary';
 export declare abstract class CustomKeypair implements Signer {
     abstract network: Network;
     abstract publicKey: Buffer;
-    abstract addresses: Address[];
-    abstract p2tr: Address;
-    abstract p2wpkh: Address;
+    abstract addresses: string[];
+    abstract p2tr: string;
+    abstract p2wpkh: string;
     protected constructor();
     abstract signTaprootInput(transaction: Psbt, i: number, sighashTypes: number[]): Promise<void>;
     abstract signInput(transaction: Psbt, i: number, sighashTypes: number[]): Promise<void>;

package/build/transaction/browser/extensions/UnisatSigner.d.ts

@@ -1,4 +1,3 @@
-import { Address } from '@btc-vision/bsi-binary';
 import { Network, Psbt } from 'bitcoinjs-lib';
 import { CustomKeypair } from '../BrowserSignerBase.js';
 import { Unisat } from '../types/Unisat.js';
@@ -12,11 +11,11 @@ export declare class UnisatSigner extends CustomKeypair {
     private isInitialized;
     constructor();
     private _p2tr;
-    get p2tr(): Address;
+    get p2tr(): string;
     private _p2wpkh;
-    get p2wpkh(): Address;
+    get p2wpkh(): string;
     private _addresses;
-    get addresses(): Address[];
+    get addresses(): string[];
     private _publicKey;
     get publicKey(): Buffer;
     _network: Network | undefined;

package/build/transaction/browser/types/Unisat.d.ts

@@ -1,4 +1,3 @@
-import { Address } from '@btc-vision/bsi-binary';
 import { Web3Provider } from '../Web3Provider.js';
 export declare enum UnisatNetwork {
     testnet = "testnet",
@@ -37,7 +36,7 @@ export interface ToSignInputPublicKey extends ToSignInputBase {
     readonly publicKey: string;
 }
 export interface ToSignInputAddress extends ToSignInputBase {
-    readonly address: Address;
+    readonly address: string;
 }
 export type ToSignInput = ToSignInputPublicKey | ToSignInputAddress;
 export interface PsbtSignatureOptions {
@@ -46,7 +45,7 @@ export interface PsbtSignatureOptions {
 }
 export interface Unisat {
     web3?: Web3Provider;
-    sendBitcoin(toAddress: Address, satoshis: number, options: {
+    sendBitcoin(toAddress: string, satoshis: number, options: {
         feeRate: number;
         memo?: string;
         memos?: string[];

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

@@ -1,17 +1,16 @@
 import { TransactionType } from '../enums/TransactionType.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
 import { SharedInteractionParameters } from '../interfaces/ITransactionParameters.js';
-import { Address } from '@btc-vision/bsi-binary';
 import { Payment, Psbt, Stack } from 'bitcoinjs-lib';
 import { TransactionBuilder } from './TransactionBuilder.js';
 export interface ICustomTransactionParameters extends SharedInteractionParameters {
     readonly script: (Buffer | Stack)[];
     readonly witnesses: Buffer[];
-    readonly to: Address;
+    readonly to: string;
 }
 export declare class CustomScriptTransaction extends TransactionBuilder<TransactionType.CUSTOM_CODE> {
     type: TransactionType.CUSTOM_CODE;
-    protected readonly _scriptAddress: Address;
+    protected readonly _scriptAddress: string;
     protected tapLeafScript: TapLeafScript | null;
     private targetScriptRedeem;
     private leftOverFundsScriptRedeem;
@@ -23,8 +22,8 @@ export declare class CustomScriptTransaction extends TransactionBuilder<Transact
     private readonly randomBytes;
     private readonly witnesses;
     constructor(parameters: ICustomTransactionParameters);
-    get scriptAddress(): Address;
-    get p2trAddress(): Address;
+    get scriptAddress(): string;
+    get p2trAddress(): string;
     getRndBytes(): Buffer;
     protected contractSignerXOnlyPubKey(): Buffer;
     protected buildTransaction(): Promise<void>;

package/build/transaction/builders/CustomScriptTransaction.js

@@ -49,7 +49,7 @@ export class CustomScriptTransaction extends TransactionBuilder {
         return this.randomBytes;
     }
     contractSignerXOnlyPubKey() {
-        return toXOnly(this.contractSigner.publicKey);
+        return toXOnly(Buffer.from(this.contractSigner.publicKey));
     }
     async buildTransaction() {
         if (!this.to) {
@@ -125,9 +125,9 @@ export class CustomScriptTransaction extends TransactionBuilder {
         return bitCrypto.hash256(this.randomBytes);
     }
     getPubKeys() {
-        const pubkeys = [this.signer.publicKey];
+        const pubkeys = [Buffer.from(this.signer.publicKey)];
         if (this.contractSigner) {
-            pubkeys.push(this.contractSigner.publicKey);
+            pubkeys.push(Buffer.from(this.contractSigner.publicKey));
         }
         return pubkeys;
     }

package/build/transaction/builders/DeploymentTransaction.d.ts

@@ -3,7 +3,7 @@ import { IDeploymentParameters } from '../interfaces/ITransactionParameters.js';
 import { Payment, Psbt } from 'bitcoinjs-lib';
 import { TransactionBuilder } from './TransactionBuilder.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
-import { Address } from '@btc-vision/bsi-binary';
+import { Address } from '../../keypair/Address.js';
 export declare class DeploymentTransaction extends TransactionBuilder<TransactionType.DEPLOYMENT> {
     static readonly MAXIMUM_CONTRACT_SIZE: number;
     type: TransactionType.DEPLOYMENT;
@@ -18,10 +18,12 @@ export declare class DeploymentTransaction extends TransactionBuilder<Transactio
     private readonly bytecode;
     private readonly calldata?;
     private readonly contractSigner;
+    private readonly _contractPubKey;
     private readonly randomBytes;
     constructor(parameters: IDeploymentParameters);
+    get contractPubKey(): string;
     get contractAddress(): Address;
-    get p2trAddress(): Address;
+    get p2trAddress(): string;
     getRndBytes(): Buffer;
     protected contractSignerXOnlyPubKey(): Buffer;
     protected buildTransaction(): Promise<void>;