@btc-vision/transaction 1.0.41 → 1.0.44

package/build/tests/wbtc/wrapReg.js

@@ -0,0 +1,69 @@
+import { Wallet } from '../../keypair/Wallet.js';
+import { Regtest } from '../Regtest.js';
+import { OPNetLimitedProvider } from '../../utxo/OPNetLimitedProvider.js';
+import { networks } from 'bitcoinjs-lib';
+import { TransactionFactory } from '../../transaction/TransactionFactory.js';
+import { BitcoinRPC } from '@btc-vision/bsi-bitcoin-rpc';
+import { currentConsensusConfig } from '../../consensus/ConsensusConfig.js';
+const network = networks.regtest;
+const rpc = new BitcoinRPC();
+const wallet = new Wallet(Regtest.wallet, network);
+const opnet = new OPNetLimitedProvider('http://localhost:9001');
+const factory = new TransactionFactory();
+const shouldMineBlock = true;
+async function mineBlock() {
+    const ok = await rpc.generateToAddress(1, wallet.p2wpkh, 'default');
+    if (!ok) {
+        throw new Error('Could not mine block');
+    }
+    console.log(`Mined block`, ok);
+    return !!ok.length;
+}
+await rpc.init(Regtest.config);
+const wrapAmount = (currentConsensusConfig.VAULT_MINIMUM_AMOUNT * 30n) / 10n;
+const utxoSetting = {
+    addresses: [wallet.p2wpkh, wallet.p2tr],
+    minAmount: 10000n,
+    requestedAmount: wrapAmount + currentConsensusConfig.UNWRAP_CONSOLIDATION_PREPAID_FEES_SAT,
+};
+const utxos = await opnet.fetchUTXOMultiAddr(utxoSetting);
+if (!utxos) {
+    throw new Error('No UTXOs found');
+}
+const generationParameters = await opnet.fetchWrapParameters(wrapAmount);
+if (!generationParameters) {
+    throw new Error('No generation parameters found');
+}
+console.log(`UTXOs:`, utxos);
+const wrapParameters = {
+    from: wallet.p2wpkh,
+    utxos: utxos,
+    signer: wallet.keypair,
+    network: network,
+    feeRate: 1000,
+    priorityFee: 100000n,
+    receiver: wallet.p2tr,
+    amount: wrapAmount,
+    generationParameters: generationParameters,
+};
+const finalTx = await factory.wrap(wrapParameters);
+console.log(`Final transaction:`, finalTx);
+const firstTxBroadcast = await rpc.sendRawTransaction({
+    hexstring: finalTx.transaction[0],
+});
+console.log(`First transaction broadcasted: ${firstTxBroadcast}`);
+if (!firstTxBroadcast) {
+    throw new Error('Could not broadcast first transaction');
+}
+const secondTxBroadcast = await rpc.sendRawTransaction({
+    hexstring: finalTx.transaction[1],
+});
+console.log(`Second transaction broadcasted: ${secondTxBroadcast}`);
+if (!secondTxBroadcast) {
+    throw new Error('Could not broadcast second transaction');
+}
+if (shouldMineBlock) {
+    await mineBlock();
+}
+rpc.destroy();
+console.log(`Wrapped ${wrapAmount} sats to ${wallet.p2tr}.`);

package/build/tests/wbtc/wrapTest.d.ts

@@ -0,0 +1 @@
+export {};

package/build/tests/wbtc/wrapTest.js

@@ -0,0 +1,66 @@
+import { Wallet } from '../../keypair/Wallet.js';
+import { Testnet } from '../Regtest.js';
+import { OPNetLimitedProvider } from '../../utxo/OPNetLimitedProvider.js';
+import { networks } from 'bitcoinjs-lib';
+import { TransactionFactory } from '../../transaction/TransactionFactory.js';
+import { BitcoinRPC } from '@btc-vision/bsi-bitcoin-rpc';
+const network = networks.testnet;
+const rpc = new BitcoinRPC();
+const wallet = new Wallet(Testnet.wallet, network);
+const opnet = new OPNetLimitedProvider('https://testnet.opnet.org');
+const factory = new TransactionFactory();
+const shouldMineBlock = true;
+async function mineBlock() {
+    const ok = await rpc.generateToAddress(1, wallet.p2wpkh, 'default');
+    if (!ok) {
+        throw new Error('Could not mine block');
+    }
+    console.log(`Mined block`, ok);
+    return !!ok.length;
+}
+await rpc.init(Testnet.config);
+const wrapAmount = 1n * 100000000n;
+const utxoSetting = {
+    addresses: [wallet.p2wpkh, wallet.p2tr],
+    minAmount: 10000n,
+    requestedAmount: wrapAmount,
+};
+const utxos = await opnet.fetchUTXOMultiAddr(utxoSetting);
+if (!utxos) {
+    throw new Error('No UTXOs found');
+}
+const generationParameters = await opnet.fetchWrapParameters(wrapAmount);
+if (!generationParameters) {
+    throw new Error('No generation parameters found');
+}
+const wrapParameters = {
+    from: wallet.p2wpkh,
+    utxos: utxos,
+    signer: wallet.keypair,
+    network: network,
+    feeRate: 500,
+    priorityFee: 50000n,
+    receiver: wallet.p2tr,
+    amount: wrapAmount,
+    generationParameters: generationParameters,
+};
+const finalTx = await factory.wrap(wrapParameters);
+console.log(`Final transaction:`, finalTx);
+const firstTxBroadcast = await rpc.sendRawTransaction({
+    hexstring: finalTx.transaction[0],
+});
+console.log(`First transaction broadcasted: ${firstTxBroadcast}`);
+if (!firstTxBroadcast) {
+    throw new Error('Could not broadcast first transaction');
+}
+const secondTxBroadcast = await rpc.sendRawTransaction({
+    hexstring: finalTx.transaction[1],
+});
+console.log(`Second transaction broadcasted: ${secondTxBroadcast}`);
+if (!secondTxBroadcast) {
+    throw new Error('Could not broadcast second transaction');
+}
+if (shouldMineBlock) {
+    await mineBlock();
+}
+rpc.destroy();

package/build/tests/writers/allowance.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { Address } from '@btc-vision/bsi-binary';
+export declare function allowance(owner: Address, spender: Address): Buffer;

package/build/tests/writers/allowance.js

@@ -0,0 +1,10 @@
+import { ABICoder, BinaryWriter } from '@btc-vision/bsi-binary';
+const abiCoder = new ABICoder();
+const allowanceSelector = Number(`0x` + abiCoder.encodeSelector('allowance'));
+export function allowance(owner, spender) {
+    const calldata = new BinaryWriter();
+    calldata.writeSelector(allowanceSelector);
+    calldata.writeAddress(owner);
+    calldata.writeAddress(spender);
+    return Buffer.from(calldata.getBuffer());
+}

package/build/tests/writers/approve.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import { Address } from '@btc-vision/bsi-binary';
+export declare const MAX_UINT256: bigint;
+export declare function approve(spender: Address, amount?: bigint): Buffer;

package/build/tests/writers/approve.js

@@ -0,0 +1,11 @@
+import { ABICoder, BinaryWriter } from '@btc-vision/bsi-binary';
+const abiCoder = new ABICoder();
+const approveSelector = Number(`0x` + abiCoder.encodeSelector('approve'));
+export const MAX_UINT256 = 2n ** 256n - 2n;
+export function approve(spender, amount = MAX_UINT256) {
+    const calldata = new BinaryWriter();
+    calldata.writeSelector(approveSelector);
+    calldata.writeAddress(spender);
+    calldata.writeU256(amount);
+    return Buffer.from(calldata.getBuffer());
+}

package/build/transaction/TransactionFactory.d.ts

@@ -18,9 +18,9 @@ export interface UnwrapResult {
 }
 export declare class TransactionFactory {
     constructor();
-    signInteraction(interactionParameters: IInteractionParameters): [string, string];
-    signDeployment(deploymentParameters: IDeploymentParameters): DeploymentResult;
-    wrap(warpParameters: IWrapParameters): WrapResult;
+    signInteraction(interactionParameters: IInteractionParameters): Promise<[string, string]>;
+    signDeployment(deploymentParameters: IDeploymentParameters): Promise<DeploymentResult>;
+    wrap(warpParameters: IWrapParameters): Promise<WrapResult>;
     unwrapSegwit(unwrapParameters: IUnwrapParameters): Promise<UnwrapResult>;
     unwrap(unwrapParameters: IUnwrapParameters): Promise<UnwrapResult>;
     private calculateNumSignatures;

package/build/transaction/TransactionFactory.js

@@ -9,25 +9,26 @@ import { UnwrapTransaction } from './builders/UnwrapTransaction.js';
 import { currentConsensus, currentConsensusConfig } from '../consensus/ConsensusConfig.js';
 export class TransactionFactory {
     constructor() { }
-    signInteraction(interactionParameters) {
+    async signInteraction(interactionParameters) {
         if (!interactionParameters.to) {
             throw new Error('Field "to" not provided.');
         }
         const transaction = new InteractionTransaction(interactionParameters);
-        transaction.signTransaction();
-        const estimatedGas = transaction.estimateTransactionFees();
+        await transaction.signTransaction();
+        const estimatedGas = await transaction.estimateTransactionFees();
         const fundingParameters = {
             ...interactionParameters,
             childTransactionRequiredValue: estimatedGas,
         };
-        const preFundingTransaction = this.createFundTransaction(fundingParameters);
+        const preFundingTransaction = await this.createFundTransaction(fundingParameters);
         interactionParameters.utxos = this.getUTXOAsTransaction(preFundingTransaction.tx, interactionParameters.to, 0);
         const preTransaction = new InteractionTransaction(interactionParameters);
-        preTransaction.signTransaction();
-        const parameters = preTransaction.getFundingTransactionParameters();
+        await preTransaction.signTransaction();
+        const parameters = await preTransaction.getFundingTransactionParameters();
         parameters.utxos = fundingParameters.utxos;
-        parameters.childTransactionRequiredValue = preTransaction.estimateTransactionFees();
-        const signedTransaction = this.createFundTransaction(parameters);
+        parameters.childTransactionRequiredValue = await preTransaction.estimateTransactionFees();
+        parameters.estimatedFees = preFundingTransaction.estimatedFees;
+        const signedTransaction = await this.createFundTransaction(parameters);
         if (!signedTransaction) {
             throw new Error('Could not sign funding transaction.');
         }
@@ -36,17 +37,18 @@ export class TransactionFactory {
             utxos: this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.to, 0),
             randomBytes: preTransaction.getRndBytes(),
             nonWitnessUtxo: signedTransaction.tx.toBuffer(),
+            estimatedFees: preTransaction.estimatedFees,
         };
         const finalTransaction = new InteractionTransaction(newParams);
-        const outTx = finalTransaction.signTransaction();
+        const outTx = await finalTransaction.signTransaction();
         return [signedTransaction.tx.toHex(), outTx.toHex()];
     }
-    signDeployment(deploymentParameters) {
+    async signDeployment(deploymentParameters) {
         const preTransaction = new DeploymentTransaction(deploymentParameters);
-        preTransaction.signTransaction();
-        const parameters = preTransaction.getFundingTransactionParameters();
+        await preTransaction.signTransaction();
+        const parameters = await preTransaction.getFundingTransactionParameters();
         const fundingTransaction = new FundingTransaction(parameters);
-        const signedTransaction = fundingTransaction.signTransaction();
+        const signedTransaction = await fundingTransaction.signTransaction();
         if (!signedTransaction) {
             throw new Error('Could not sign funding transaction.');
         }
@@ -67,14 +69,14 @@ export class TransactionFactory {
             nonWitnessUtxo: signedTransaction.toBuffer(),
         };
         const finalTransaction = new DeploymentTransaction(newParams);
-        const outTx = finalTransaction.signTransaction();
+        const outTx = await finalTransaction.signTransaction();
         return {
             transaction: [signedTransaction.toHex(), outTx.toHex()],
             contractAddress: finalTransaction.contractAddress,
             p2trAddress: finalTransaction.p2trAddress,
         };
     }
-    wrap(warpParameters) {
+    async wrap(warpParameters) {
         if (warpParameters.amount < currentConsensusConfig.VAULT_MINIMUM_AMOUNT) {
             throw new Error(`Amount is too low. Minimum consolidation is ${currentConsensusConfig.VAULT_MINIMUM_AMOUNT} sat. Received ${warpParameters.amount} sat. Make sure that you cover the unwrap consolidation fees of ${currentConsensusConfig.UNWRAP_CONSOLIDATION_PREPAID_FEES_SAT}sat.`);
         }
@@ -86,14 +88,14 @@ export class TransactionFactory {
             childTransactionRequiredValue: childTransactionRequiredValue,
             to: to,
         };
-        const preFundingTransaction = this.createFundTransaction(fundingParameters);
+        const preFundingTransaction = await this.createFundTransaction(fundingParameters);
         warpParameters.utxos = this.getUTXOAsTransaction(preFundingTransaction.tx, to, 0);
         const preTransaction = new WrapTransaction(warpParameters);
-        preTransaction.signTransaction();
-        const parameters = preTransaction.getFundingTransactionParameters();
+        await preTransaction.signTransaction();
+        const parameters = await preTransaction.getFundingTransactionParameters();
         parameters.childTransactionRequiredValue += childTransactionRequiredValue;
         parameters.utxos = fundingParameters.utxos;
-        const signedTransaction = this.createFundTransaction(parameters);
+        const signedTransaction = await this.createFundTransaction(parameters);
         if (!signedTransaction) {
             throw new Error('Could not sign funding transaction.');
         }
@@ -104,7 +106,7 @@ export class TransactionFactory {
             nonWitnessUtxo: signedTransaction.tx.toBuffer(),
         };
         const finalTransaction = new WrapTransaction(newParams);
-        const outTx = finalTransaction.signTransaction();
+        const outTx = await finalTransaction.signTransaction();
         return {
             transaction: [signedTransaction.tx.toHex(), outTx.toHex()],
             vaultAddress: finalTransaction.vault,
@@ -115,29 +117,29 @@ export class TransactionFactory {
     async unwrapSegwit(unwrapParameters) {
         console.error('The "unwrap" method is deprecated. Use unwrapTap instead.');
         const transaction = new UnwrapSegwitTransaction(unwrapParameters);
-        transaction.signTransaction();
+        await transaction.signTransaction();
         const to = transaction.toAddress();
         if (!to)
             throw new Error('To address is required');
-        const estimatedGas = transaction.estimateTransactionFees();
+        const estimatedGas = await transaction.estimateTransactionFees();
         const estimatedFees = transaction.preEstimateTransactionFees(BigInt(unwrapParameters.feeRate), this.calculateNumInputs(unwrapParameters.unwrapUTXOs), 2n, this.calculateNumSignatures(unwrapParameters.unwrapUTXOs), this.maxPubKeySize(unwrapParameters.unwrapUTXOs));
         const fundingParameters = {
             ...unwrapParameters,
             childTransactionRequiredValue: estimatedGas + estimatedFees,
             to: to,
         };
-        const preFundingTransaction = this.createFundTransaction(fundingParameters);
+        const preFundingTransaction = await this.createFundTransaction(fundingParameters);
         unwrapParameters.utxos = this.getUTXOAsTransaction(preFundingTransaction.tx, to, 0);
         const preTransaction = new UnwrapSegwitTransaction({
             ...unwrapParameters,
             randomBytes: transaction.getRndBytes(),
         });
-        preTransaction.signTransaction();
-        const parameters = preTransaction.getFundingTransactionParameters();
+        await preTransaction.signTransaction();
+        const parameters = await preTransaction.getFundingTransactionParameters();
         parameters.utxos = fundingParameters.utxos;
         parameters.childTransactionRequiredValue =
-            preTransaction.estimateTransactionFees() + estimatedFees;
-        const signedTransaction = this.createFundTransaction(parameters);
+            (await preTransaction.estimateTransactionFees()) + estimatedFees;
+        const signedTransaction = await this.createFundTransaction(parameters);
         if (!signedTransaction) {
             throw new Error('Could not sign funding transaction.');
         }
@@ -148,7 +150,7 @@ export class TransactionFactory {
             nonWitnessUtxo: signedTransaction.tx.toBuffer(),
         };
         const finalTransaction = new UnwrapSegwitTransaction(newParams);
-        const outTx = finalTransaction.signPSBT();
+        const outTx = await finalTransaction.signPSBT();
         const asBase64 = outTx.toBase64();
         const psbt = this.writePSBTHeader(PSBTTypes.UNWRAP, asBase64);
         return {
@@ -159,27 +161,27 @@ export class TransactionFactory {
     }
     async unwrap(unwrapParameters) {
         const transaction = new UnwrapTransaction(unwrapParameters);
-        transaction.signTransaction();
+        await transaction.signTransaction();
         const to = transaction.toAddress();
         if (!to)
             throw new Error('To address is required');
-        const estimatedGas = transaction.estimateTransactionFees();
+        const estimatedGas = await transaction.estimateTransactionFees();
         const fundingParameters = {
             ...unwrapParameters,
             childTransactionRequiredValue: estimatedGas,
             to: to,
         };
-        const preFundingTransaction = this.createFundTransaction(fundingParameters);
+        const preFundingTransaction = await this.createFundTransaction(fundingParameters);
         unwrapParameters.utxos = this.getUTXOAsTransaction(preFundingTransaction.tx, to, 0);
         const preTransaction = new UnwrapTransaction({
             ...unwrapParameters,
             randomBytes: transaction.getRndBytes(),
         });
-        preTransaction.signTransaction();
-        const parameters = preTransaction.getFundingTransactionParameters();
+        await preTransaction.signTransaction();
+        const parameters = await preTransaction.getFundingTransactionParameters();
         parameters.utxos = fundingParameters.utxos;
-        parameters.childTransactionRequiredValue = preTransaction.estimateTransactionFees();
-        const signedTransaction = this.createFundTransaction(parameters);
+        parameters.childTransactionRequiredValue = await preTransaction.estimateTransactionFees();
+        const signedTransaction = await this.createFundTransaction(parameters);
         if (!signedTransaction) {
             throw new Error('Could not sign funding transaction.');
         }
@@ -190,7 +192,7 @@ export class TransactionFactory {
             nonWitnessUtxo: signedTransaction.tx.toBuffer(),
         };
         const finalTransaction = new UnwrapTransaction(newParams);
-        const outTx = finalTransaction.signPSBT();
+        const outTx = await finalTransaction.signPSBT();
         const asBase64 = outTx.toBase64();
         const psbt = this.writePSBTHeader(PSBTTypes.UNWRAP, asBase64);
         return {
@@ -240,15 +242,16 @@ export class TransactionFactory {
         };
         return [newUtxo];
     }
-    createFundTransaction(parameters) {
+    async createFundTransaction(parameters) {
         const fundingTransaction = new FundingTransaction(parameters);
-        const signedTransaction = fundingTransaction.signTransaction();
+        const signedTransaction = await fundingTransaction.signTransaction();
         if (!signedTransaction) {
             throw new Error('Could not sign funding transaction.');
         }
         return {
             tx: signedTransaction,
             original: fundingTransaction,
+            estimatedFees: await fundingTransaction.estimateTransactionFees(),
         };
     }
 }

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

@@ -0,0 +1,11 @@
+import { Psbt, Transaction } from 'bitcoinjs-lib';
+import { Unisat } from './types/Unisat.js';
+declare global {
+    interface Window {
+        unisat?: Unisat;
+    }
+}
+export declare abstract class BrowserSigner {
+    signTransaction(transaction: Psbt): Promise<Transaction>;
+    generateSigner(): Promise<void>;
+}

package/build/transaction/browser/BrowserSigner.js

@@ -0,0 +1,10 @@
+export class BrowserSigner {
+    async signTransaction(transaction) {
+        if (!window) {
+            throw new Error('BrowserSigner can only be used in a browser environment');
+        }
+        throw new Error('Not implemented');
+    }
+    async generateSigner() {
+    }
+}

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

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+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 p2pkh: Address;
+    protected constructor();
+    abstract signTaprootInput(transaction: Psbt, i: number, sighashTypes: number[]): Promise<void>;
+    abstract signInput(transaction: Psbt, i: number, sighashTypes: number[]): Promise<void>;
+    abstract getPublicKey(): Buffer;
+    abstract sign(hash: Buffer, lowR?: boolean): Buffer;
+    abstract signSchnorr(hash: Buffer): Buffer;
+    abstract verify(hash: Buffer, signature: Buffer): boolean;
+    abstract init(): Promise<void>;
+}

package/build/transaction/browser/BrowserSignerBase.js

@@ -0,0 +1,3 @@
+export class CustomKeypair {
+    constructor() { }
+}

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

@@ -0,0 +1,54 @@
+import { Address } from '@btc-vision/bsi-binary';
+export declare enum UnisatNetwork {
+    testnet = "testnet",
+    mainnet = "livenet",
+    regtest = "regtest"
+}
+export interface Balance {
+    readonly confirmed: number;
+    readonly unconfirmed: number;
+    readonly total: number;
+}
+export declare enum MessageType {
+    ecdsa = "ecdsa",
+    bip322 = "bip322-simple"
+}
+interface ToSignInputBase {
+    readonly index: number;
+    readonly sighashTypes?: number[];
+    readonly disableTweakSigner?: boolean;
+}
+export interface ToSignInputPublicKey extends ToSignInputBase {
+    readonly publicKey: string;
+}
+export interface ToSignInputAddress extends ToSignInputBase {
+    readonly address: Address;
+}
+export type ToSignInput = ToSignInputPublicKey | ToSignInputAddress;
+export interface PsbtSignatureOptions {
+    readonly autoFinalized?: boolean;
+    readonly toSignInputs?: ToSignInput[];
+}
+export interface Unisat {
+    sendBitcoin(toAddress: Address, satoshis: number, options: {
+        feeRate: number;
+    }): Promise<string>;
+    requestAccounts(): Promise<string[]>;
+    getNetwork(): Promise<UnisatNetwork>;
+    getAccounts(): Promise<string[]>;
+    switchNetwork(network: UnisatNetwork): Promise<void>;
+    getPublicKey(): Promise<string>;
+    getBalance(): Promise<Balance>;
+    signMessage(message: string, type?: MessageType): Promise<string>;
+    pushTx(options: {
+        rawtx: string;
+    }): Promise<string>;
+    signPsbt(psbtHex: string, psbtOptions: PsbtSignatureOptions): Promise<string>;
+    signPsbts(psbtHex: string[], psbtOptions: PsbtSignatureOptions): Promise<string[]>;
+    pushPsbt(psbtHex: string): Promise<string>;
+    on(event: 'accountsChanged', listener: (accounts: string[]) => void): void;
+    on(event: 'networkChanged', listener: (network: UnisatNetwork) => void): void;
+    removeListener(event: 'accountsChanged', listener: (accounts: string[]) => void): void;
+    removeListener(event: 'networkChanged', listener: (network: UnisatNetwork) => void): void;
+}
+export {};

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

@@ -0,0 +1,11 @@
+export var UnisatNetwork;
+(function (UnisatNetwork) {
+    UnisatNetwork["testnet"] = "testnet";
+    UnisatNetwork["mainnet"] = "livenet";
+    UnisatNetwork["regtest"] = "regtest";
+})(UnisatNetwork || (UnisatNetwork = {}));
+export var MessageType;
+(function (MessageType) {
+    MessageType["ecdsa"] = "ecdsa";
+    MessageType["bip322"] = "bip322-simple";
+})(MessageType || (MessageType = {}));

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

@@ -0,0 +1,35 @@
+/// <reference types="node" />
+import { CustomKeypair } from '../BrowserSignerBase.js';
+import { Network, Psbt } from 'bitcoinjs-lib';
+import { Unisat } from '../types/Unisat.js';
+import { Address } from '@btc-vision/bsi-binary';
+declare global {
+    interface Window {
+        unisat?: Unisat;
+    }
+}
+export declare class UnisatSigner extends CustomKeypair {
+    private isInitialized;
+    constructor();
+    private _p2tr;
+    get p2tr(): Address;
+    private _p2pkh;
+    get p2pkh(): Address;
+    private _addresses;
+    get addresses(): Address[];
+    private _publicKey;
+    get publicKey(): Buffer;
+    _network: Network | undefined;
+    get network(): Network;
+    get unisat(): Unisat;
+    init(): Promise<void>;
+    getPublicKey(): Buffer;
+    sign(hash: Buffer, lowR?: boolean): Buffer;
+    signSchnorr(hash: Buffer): Buffer;
+    verify(hash: Buffer, signature: Buffer): boolean;
+    signTaprootInput(transaction: Psbt, i: number, sighashTypes: number[]): Promise<void>;
+    signInput(transaction: Psbt, i: number, sighashTypes: number[]): Promise<void>;
+    private combine;
+    private signTweaked;
+    private getNonDuplicateScriptSig;
+}