@btc-vision/transaction 1.0.96 → 1.0.99

package/build/transaction/builders/UnwarpTransaction.js

@@ -1,199 +0,0 @@
-import { TransactionType } from '../enums/TransactionType.js';
-import { SharedInteractionTransaction } from './SharedInteractionTransaction.js';
-import { TransactionBuilder } from './TransactionBuilder.js';
-import { ABICoder, BinaryWriter } from '@btc-vision/bsi-binary';
-import { wBTC } from '../../metadata/contracts/wBTC.js';
-import { payments } from 'bitcoinjs-lib';
-import { EcKeyPair } from '../../keypair/EcKeyPair.js';
-import { PsbtTransaction } from '../processor/PsbtTransaction.js';
-const abiCoder = new ABICoder();
-export class UnwrapTransaction extends SharedInteractionTransaction {
-    static MINIMUM_CONSOLIDATION_AMOUNT = 200000n;
-    static UNWRAP_SELECTOR = Number('0x' + abiCoder.encodeSelector('burn'));
-    type = TransactionType.WBTC_UNWRAP;
-    amount;
-    compiledTargetScript;
-    scriptTree;
-    sighashTypes = [];
-    contractSecret;
-    vaultUTXOs;
-    wbtc;
-    calculatedSignHash = PsbtTransaction.calculateSignHash(this.sighashTypes);
-    constructor(parameters) {
-        if (parameters.amount < TransactionBuilder.MINIMUM_DUST) {
-            throw new Error('Amount is below dust limit');
-        }
-        parameters.disableAutoRefund = true;
-        parameters.calldata = UnwrapTransaction.generateBurnCalldata(parameters.amount);
-        super(parameters);
-        this.wbtc = new wBTC(parameters.network);
-        this.to = this.wbtc.getAddress();
-        this.vaultUTXOs = parameters.unwrapUTXOs;
-        this.amount = parameters.amount;
-        this.contractSecret = this.generateSecret();
-        this.compiledTargetScript = this.calldataGenerator.compile(this.calldata, this.contractSecret);
-        this.scriptTree = this.getScriptTree();
-        this.internalInit();
-    }
-    static generateBurnCalldata(amount) {
-        if (!amount)
-            throw new Error('Amount is required');
-        const bufWriter = new BinaryWriter();
-        bufWriter.writeSelector(UnwrapTransaction.UNWRAP_SELECTOR);
-        bufWriter.writeU256(amount);
-        return Buffer.from(bufWriter.getBuffer());
-    }
-    signPSBT() {
-        if (this.to && !EcKeyPair.verifyContractAddress(this.to, this.network)) {
-            throw new Error('Invalid contract address. The contract address must be a taproot address.');
-        }
-        if (!this.vaultUTXOs.length) {
-            throw new Error('No vault UTXOs provided');
-        }
-        if (this.signed)
-            throw new Error('Transaction is already signed');
-        this.signed = true;
-        this.buildTransaction();
-        this.ignoreSignatureError();
-        this.mergeVaults(this.vaultUTXOs);
-        const builtTx = this.internalBuildTransaction(this.transaction);
-        if (builtTx) {
-            return this.transaction;
-        }
-        throw new Error('Could not sign transaction');
-    }
-    mergeVaults(input) {
-        const firstVault = input[0];
-        if (!firstVault) {
-            throw new Error('No vaults provided');
-        }
-        const total = this.getVaultTotalOutputAmount(input);
-        if (total < this.amount) {
-            throw new Error(`Total vault amount (${total} sat) is less than the amount to unwrap (${this.amount} sat)`);
-        }
-        const outputLeftAmount = this.calculateOutputLeftAmountFromVaults(input);
-        console.log('outputLeftAmount', outputLeftAmount, this.amount);
-        if (outputLeftAmount < UnwrapTransaction.MINIMUM_CONSOLIDATION_AMOUNT) {
-            throw new Error(`Output left amount is below minimum consolidation (${UnwrapTransaction.MINIMUM_CONSOLIDATION_AMOUNT} sat) amount ${outputLeftAmount} for vault ${firstVault.vault}`);
-        }
-        this.addOutput({
-            address: firstVault.vault,
-            value: Number(outputLeftAmount),
-        });
-        this.addOutput({
-            address: this.from,
-            value: Number(this.amount),
-        });
-        for (const vault of input) {
-            this.addVaultInputs(vault);
-        }
-    }
-    estimateVaultFees(feeRate, numInputs, numOutputs, numSignatures, numPubkeys) {
-        const txHeaderSize = 10n;
-        const inputBaseSize = 41n;
-        const outputSize = 68n;
-        const signatureSize = 144n;
-        const pubkeySize = 34n;
-        const baseTxSize = txHeaderSize + inputBaseSize * numInputs + outputSize * numOutputs;
-        const redeemScriptSize = 1n + numPubkeys * (1n + pubkeySize) + 1n + numSignatures;
-        const witnessSize = numSignatures * signatureSize + numPubkeys * pubkeySize + redeemScriptSize;
-        const weight = baseTxSize * 3n + (baseTxSize + witnessSize);
-        const vSize = weight / 4n;
-        return vSize * feeRate;
-    }
-    internalBuildTransaction(transaction) {
-        if (transaction.data.inputs.length === 0) {
-            const inputs = this.getInputs();
-            const outputs = this.getOutputs();
-            transaction.setMaximumFeeRate(this._maximumFeeRate);
-            transaction.addInputs(inputs);
-            for (let i = 0; i < this.updateInputs.length; i++) {
-                transaction.updateInput(i, this.updateInputs[i]);
-            }
-            transaction.addOutputs(outputs);
-        }
-        try {
-            this.signInputs(transaction);
-            if (this.finalized) {
-                this.transactionFee = BigInt(transaction.getFee());
-            }
-            return true;
-        }
-        catch (e) {
-            const err = e;
-            this.error(`[internalBuildTransaction] Something went wrong while getting building the transaction: ${err.stack}`);
-        }
-        return false;
-    }
-    generateMultiSignRedeemScript(publicKeys, minimum) {
-        const p2ms = payments.p2ms({
-            m: minimum,
-            pubkeys: publicKeys.map((key) => Buffer.from(key, 'base64')),
-            network: this.network,
-        });
-        const p2wsh = payments.p2wsh({
-            redeem: p2ms,
-            network: this.network,
-        });
-        const witnessUtxo = p2wsh.output;
-        const redeemScript = p2wsh.redeem?.output;
-        const witnessScript = p2ms.output;
-        if (!witnessUtxo || !redeemScript || !witnessScript) {
-            throw new Error('Failed to generate redeem script');
-        }
-        return {
-            witnessUtxo,
-            redeemScript,
-            witnessScript,
-        };
-    }
-    addVaultUTXO(utxo, witness) {
-        console.log(Number(utxo.value), utxo.hash, utxo.outputIndex);
-        const input = {
-            hash: utxo.hash,
-            index: utxo.outputIndex,
-            witnessUtxo: {
-                script: Buffer.from(utxo.output, 'base64'),
-                value: Number(utxo.value),
-            },
-            witnessScript: witness.witnessScript,
-            sequence: this.sequence,
-        };
-        if (this.calculatedSignHash) {
-            input.sighashType = this.calculatedSignHash;
-        }
-        this.addInput(input);
-    }
-    addVaultInputs(vault, firstSigner = this.signer) {
-        const p2wshOutput = this.generateMultiSignRedeemScript(vault.publicKeys, vault.minimum);
-        for (const utxo of vault.utxos) {
-            const inputIndex = this.transaction.inputCount;
-            this.addVaultUTXO(utxo, p2wshOutput);
-            if (firstSigner) {
-                this.log(`Signing input ${inputIndex} with ${firstSigner.publicKey.toString('hex')}`);
-                try {
-                    this.signInput(this.transaction, this.transaction.data.inputs[inputIndex], inputIndex, this.signer);
-                    this.log(`Signed input ${inputIndex} with ${firstSigner.publicKey.toString('hex')}`);
-                }
-                catch (e) {
-                    if (!this.ignoreSignatureErrors) {
-                        this.warn(`Failed to sign input ${inputIndex} with ${firstSigner.publicKey.toString('hex')} ${e.message}`);
-                    }
-                }
-            }
-        }
-    }
-    calculateOutputLeftAmountFromVaults(vaults) {
-        const total = this.getVaultTotalOutputAmount(vaults);
-        return total - this.amount;
-    }
-    getVaultTotalOutputAmount(vaults) {
-        let total = BigInt(0);
-        for (const vault of vaults) {
-            for (const utxo of vault.utxos) {
-                total += BigInt(utxo.value);
-            }
-        }
-        return total;
-    }
-}

package/build/transaction/interfaces/ITransactions.d.ts

@@ -1,32 +0,0 @@
-/// <reference types="node" />
-import { Signer } from 'bitcoinjs-lib';
-import { UTXO } from '../../utxo/interfaces/IUTXO.js';
-import { ECPairInterface } from 'ecpair';
-import { Network } from 'bitcoinjs-lib/src/networks.js';
-export interface ITransactionParameters {
-    readonly from: string;
-    readonly utxos: UTXO[];
-    readonly signer: ECPairInterface;
-    readonly network: Network;
-    readonly feeRate: number;
-    readonly priorityFee: bigint;
-}
-export interface SewgitTransactionParameters extends ITransactionParameters {
-}
-export interface ITransactionDataContractInteraction extends ITransactionParameters {
-    readonly contractSecret: Buffer;
-    readonly calldata: Buffer;
-    readonly customSigner: Signer;
-    readonly pubKeys?: Buffer[];
-    readonly minimumSignatures?: number;
-}
-export interface ITransactionDataContractInteractionWrap extends ITransactionDataContractInteraction {
-    readonly amount: bigint;
-    readonly minimumSignatures: number;
-    readonly pubKeys: Buffer[];
-}
-export interface ITransactionDataContractDeployment extends ITransactionParameters {
-    readonly bytecode: Buffer;
-    readonly salt: Buffer;
-    readonly customSigner: Signer;
-}

package/build/transaction/interfaces/ITransactions.js

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

package/build/utxo/IUTXO.js

@@ -1 +0,0 @@
-"use strict";

package/build/utxo/OPNetUtils.d.ts

@@ -1,7 +0,0 @@
-import { FetchUTXOParams, UTXO } from './interfaces/IUTXO.js';
-export declare class UTXOManager {
-    private readonly opnetAPIUrl;
-    private readonly utxoPath;
-    constructor(opnetAPIUrl: string);
-    fetchUTXO(settings: FetchUTXOParams): Promise<UTXO[]>;
-}

package/build/utxo/OPNetUtils.js

@@ -1,47 +0,0 @@
-export class UTXOManager {
-    opnetAPIUrl;
-    utxoPath = 'address/utxos';
-    constructor(opnetAPIUrl) {
-        this.opnetAPIUrl = opnetAPIUrl;
-    }
-    async fetchUTXO(settings) {
-        const params = {
-            method: 'GET',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-        };
-        const url = `${this.opnetAPIUrl}/api/v1/${this.utxoPath}?address=${settings.address}`;
-        const resp = await fetch(url, params);
-        if (!resp.ok) {
-            throw new Error(`Failed to fetch UTXO data: ${resp.statusText}`);
-        }
-        const fetchedData = await resp.json();
-        if (fetchedData.length === 0) {
-            throw new Error('No UTXO found');
-        }
-        const meetCriteria = fetchedData.filter((utxo) => {
-            return BigInt(utxo.value) >= settings.minAmount;
-        });
-        if (meetCriteria.length === 0) {
-            throw new Error('No UTXO found (minAmount)');
-        }
-        let finalUTXOs = [];
-        let currentAmount = 0n;
-        const amountRequested = settings.requestedAmount;
-        for (const utxo of meetCriteria) {
-            const utxoValue = BigInt(utxo.value);
-            currentAmount += utxoValue;
-            finalUTXOs.push({
-                transactionId: utxo.transactionId,
-                outputIndex: utxo.outputIndex,
-                value: utxoValue,
-                scriptPubKey: utxo.scriptPubKey,
-            });
-            if (currentAmount + utxoValue > amountRequested) {
-                break;
-            }
-        }
-        return finalUTXOs;
-    }
-}

package/build/utxo/UTXOManager.d.ts

@@ -1,7 +0,0 @@
-import { FetchUTXOParams, UTXO } from './interfaces/IUTXO.js';
-export declare class UTXOManager {
-    private readonly opnetAPIUrl;
-    private readonly utxoPath;
-    constructor(opnetAPIUrl: string);
-    fetchUTXO(settings: FetchUTXOParams): Promise<UTXO[]>;
-}

package/build/utxo/UTXOManager.js

@@ -1,47 +0,0 @@
-export class UTXOManager {
-    opnetAPIUrl;
-    utxoPath = 'address/utxos';
-    constructor(opnetAPIUrl) {
-        this.opnetAPIUrl = opnetAPIUrl;
-    }
-    async fetchUTXO(settings) {
-        const params = {
-            method: 'GET',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-        };
-        const url = `${this.opnetAPIUrl}/api/v1/${this.utxoPath}?address=${settings.address}`;
-        const resp = await fetch(url, params);
-        if (!resp.ok) {
-            throw new Error(`Failed to fetch UTXO data: ${resp.statusText}`);
-        }
-        const fetchedData = await resp.json();
-        if (fetchedData.length === 0) {
-            throw new Error('No UTXO found');
-        }
-        const meetCriteria = fetchedData.filter((utxo) => {
-            return BigInt(utxo.value) >= settings.minAmount;
-        });
-        if (meetCriteria.length === 0) {
-            throw new Error('No UTXO found (minAmount)');
-        }
-        let finalUTXOs = [];
-        let currentAmount = 0n;
-        const amountRequested = settings.requestedAmount;
-        for (const utxo of meetCriteria) {
-            const utxoValue = BigInt(utxo.value);
-            currentAmount += utxoValue;
-            finalUTXOs.push({
-                transactionId: utxo.transactionId,
-                outputIndex: utxo.outputIndex,
-                value: utxoValue,
-                scriptPubKey: utxo.scriptPubKey,
-            });
-            if (currentAmount + utxoValue > amountRequested) {
-                break;
-            }
-        }
-        return finalUTXOs;
-    }
-}

package/build/wbtc/BroadcastResponse.js

@@ -1 +0,0 @@
-"use strict";

package/examples/Deploy.md

@@ -1,188 +0,0 @@
-# Deploying a Smart Contract on OPNet
-
-WARNING: POSSIBLY OUTDATED
-
-This guide will walk you through the process of deploying a smart contract on the OPNet protocol. OPNet allows for the
-execution of smart contracts on the Bitcoin network, leveraging the security and stability of Bitcoin.
-
-## Prerequisites
-
-- Node.js and npm installed
-- Bitcoin regtest wallet
-- Access to an OPNet node
-- Bitcoin RPC configured for regtest
-- Contract bytecode in WebAssembly format
-
-## Setup
-
-First, ensure you have the necessary dependencies installed in your project:
-
-```sh
-npm i
-```
-
-## Step-by-Step Guide
-
-### 1. Import Required Libraries
-
-```typescript
-import { Wallet } from '../keypair/Wallet.js';
-import { OPNetLimitedProvider } from '../utxo/OPNetLimitedProvider.js';
-import { networks, Network } from 'bitcoinjs-lib';
-import { TransactionFactory } from '../transaction/TransactionFactory.js';
-import { BitcoinRPC } from '@btc-vision/bsi-bitcoin-rpc';
-import { IDeploymentParameters } from '../transaction/interfaces/ITransactionParameters.js';
-import { FetchUTXOParams, UTXO } from '../utxo/interfaces/IUTXO.js';
-import * as fs from 'fs';
-```
-
-### Setting Up configurations
-
-We must provide the necessary configurations for the network, wallet, and RPC connection:
-
-- The opnetNode variable is the URL of the OP_NET node.
-- The Testnet variable contains the wallet address, public key, and private key.
-- The config variable inside the testnet object contains the network, host, port, username, and password for the RPC
-  connection.
-
-```typescript
-const network: Network = networks.testnet;
-const opnetNode: string = 'https://testnet.opnet.org';
-const Testnet: NetworkInformation = {
-    wallet: {
-        address: '', // as BECH32
-        publicKey: '', // as HEX
-        privateKey: '', // as WIF
-    },
-
-    config: {
-        BITCOIND_NETWORK: BitcoinNetwork.TestNet, // Bitcoin network
-        BITCOIND_HOST: '', // Bitcoin RPC host
-        BITCOIND_PORT: 9242, // Bitcoin RPC port
-
-        BITCOIND_USERNAME: '', // Bitcoin RPC username
-        BITCOIND_PASSWORD: '', // Bitcoin RPC password
-    },
-};
-```
-
-### 2. Initialize Network and RPC
-
-```typescript
-const rpc: BitcoinRPC = new BitcoinRPC();
-const wallet: Wallet = new Wallet(Testnet.wallet, network);
-```
-
-### 3. Connect to OPNet
-
-```typescript
-const utxoManager: OPNetLimitedProvider = new OPNetLimitedProvider(opnetNode);
-const factory: TransactionFactory = new TransactionFactory();
-```
-
-### 4. Mining a Block (Optional)
-
-If you are using a regtest or need to mine a block to proceed:
-
-```typescript
-const shouldMineBlock: boolean = true;
-
-async function mineBlock(): Promise<boolean> {
-    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;
-}
-```
-
-### 5. Initialize RPC with Testnet Configuration
-
-```typescript
-await rpc.init(Testnet.config);
-```
-
-### 6. Define UTXO Settings and Fetch UTXOs
-
-```typescript
-const utxoSetting: FetchUTXOParams = {
-    address: wallet.p2wpkh,
-    minAmount: 10000n,
-    requestedAmount: 100000n,
-};
-
-const utxos: UTXO[] = await utxoManager.fetchUTXO(utxoSetting);
-if (!utxos) {
-    throw new Error('No UTXOs found');
-}
-```
-
-### 7. Read Contract Bytecode
-
-```typescript
-const bytecode = fs.readFileSync('./bytecode/contract.wasm');
-```
-
-### 8. Create Deployment Parameters and Finalize Transaction
-
-Let's create the deployment parameters and finalize the transaction:
-
-```typescript
-const deploymentParameters: IDeploymentParameters = {
-    from: wallet.p2wpkh,
-    utxos: utxos,
-    signer: wallet.keypair,
-    network: network,
-    feeRate: 150,
-    priorityFee: 50000n,
-    bytecode: bytecode,
-};
-
-const finalTx = factory.signDeployment(deploymentParameters);
-console.log(`Final transaction:`, finalTx);
-```
-
-### 9. Broadcast the Transactions
-
-Broadcast the transactions to the network:
-
-```typescript
-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');
-}
-```
-
-### 10. (Optional) Mine a Block
-
-If you need to mine a block after broadcasting the transactions:
-
-```typescript
-if (shouldMineBlock) {
-    await mineBlock();
-}
-```
-
-## Conclusion
-
-You have now successfully deployed a smart contract on the OPNet protocol. This contract can interact with the Bitcoin
-network, enabling complex functionalities and decentralized applications.
-
-For any further questions or issues, please refer to the official documentation or reach out to the community for
-support.