@btc-vision/transaction 1.0.0

package/src/metadata/contracts/wBTC.ts

@@ -0,0 +1,44 @@
+import { Network, networks } from 'bitcoinjs-lib';
+import { ContractBaseMetadata } from '../ContractBaseMetadata.js';
+import { Address } from '@btc-vision/bsi-binary';
+
+/**
+ * @description Wrapped Bitcoin (wBTC) contract metadata.
+ * */
+export class wBTC extends ContractBaseMetadata {
+    /**
+     * @description Token Name
+     */
+    public readonly tokenName: string = 'Wrapped Bitcoin';
+
+    /**
+     * @description Token Symbol
+     */
+    public readonly tokenSymbol: string = 'wBTC';
+
+    /**
+     * @description Token Decimals, same as Bitcoin
+     */
+    public readonly decimals: number = 8;
+
+    protected readonly address: Address;
+
+    constructor(protected network: Network = networks.bitcoin) {
+        super(network);
+
+        this.address = wBTC.getAddress(network);
+    }
+
+    public static getAddress(network: Network = networks.bitcoin): Address {
+        switch (network) {
+            case networks.bitcoin:
+                return 'bcrt1pcw0828yjrtlrc6mkp3lkq30j7wc7slsh7k7dyh53mrs4f8d74l6qumhqp4';
+            case networks.regtest:
+                return 'bcrt1pcw0828yjrtlrc6mkp3lkq30j7wc7slsh7k7dyh53mrs4f8d74l6qumhqp4';
+            case networks.testnet:
+                return 'tb1pq64lx73fwyrdp4asvl7xt5r5qvxvt9wy82x75taqtzvd64f58nasansurj';
+            default:
+                throw new Error(`Invalid network: ${network}`);
+        }
+    }
+}

package/src/network/NetworkInformation.ts

@@ -0,0 +1,7 @@
+import { IWallet } from '../keypair/interfaces/IWallet.js';
+import { BlockchainConfig } from '@btc-vision/bsi-common';
+
+export interface NetworkInformation {
+    readonly wallet: IWallet;
+    readonly config: BlockchainConfig;
+}

package/src/opnet.ts

@@ -0,0 +1,42 @@
+export { version } from './_version.js';
+
+/** Bytecode */
+export * from './bytecode/Compressor.js';
+
+/** Generators */
+export * from './generators/Generator.js';
+export * from './generators/builders/CalldataGenerator.js';
+export * from './generators/builders/DeploymentGenerator.js';
+
+/** Key Pair */
+export * from './keypair/EcKeyPair.js';
+export * from './keypair/Wallet.js';
+export * from './keypair/interfaces/IWallet.js';
+
+/** Metadata */
+export * from './metadata/contracts/wBTC.js';
+export * from './metadata/ContractBaseMetadata.js';
+
+/** Network */
+export * from './network/NetworkInformation.js';
+
+/** Signer */
+export * from './signer/TweakedSigner.js';
+
+/** Transaction */
+export * from './transaction/TransactionFactory.js';
+export * from './transaction/interfaces/ITransactionParameters.js';
+export * from './transaction/interfaces/Tap.js';
+export * from './transaction/enums/TransactionType.js';
+
+/** Builders */
+export * from './transaction/builders/InteractionTransaction.js';
+export * from './transaction/builders/FundingTransaction.js';
+export * from './transaction/builders/TransactionBuilder.js';
+
+/** Utils */
+export * from './utils/BitcoinUtils.js';
+
+/** UTXO */
+export * from './utxo/interfaces/IUTXO.js';
+export * from './utxo/UTXOManager.js';

package/src/scripts/Regtest.ts

@@ -0,0 +1,19 @@
+import { NetworkInformation } from '../network/NetworkInformation.js';
+import { BitcoinNetwork } from '@btc-vision/bsi-common';
+
+export const Regtest: NetworkInformation = {
+    wallet: {
+        address: 'bcrt1qfqsr3m7vjxheghcvw4ks0fryqxfq8qzjf8fxes',
+        publicKey: '020373626d317ae8788ce3280b491068610d840c23ecb64c14075bbb9f670af52c',
+        privateKey: 'cRCiYAgCBrU7hSaJBRuPqKVYXQqM5CKXbMfWHb25X4FDAWJ8Ai92',
+    },
+
+    config: {
+        BITCOIND_NETWORK: BitcoinNetwork.Regtest,
+        BITCOIND_HOST: '51.81.67.34',
+        BITCOIND_PORT: 9242,
+
+        BITCOIND_USERNAME: 'HJSiowseujhs',
+        BITCOIND_PASSWORD: 'YHEFHSDJ23JOIhjjef2ied9u290efu2930u90U',
+    },
+};

package/src/scripts/test.ts

@@ -0,0 +1,98 @@
+import { wBTC } from '../metadata/contracts/wBTC.js';
+import { Wallet } from '../keypair/Wallet.js';
+import { Regtest } from './Regtest.js';
+import { UTXOManager } from '../utxo/UTXOManager.js';
+import { FetchUTXOParams, UTXO } from '../utxo/interfaces/IUTXO.js';
+import { IInteractionParameters } from '../transaction/interfaces/ITransactionParameters.js';
+import { networks } from 'bitcoinjs-lib';
+import { TransactionFactory } from '../transaction/TransactionFactory.js';
+import { BitcoinRPC } from '@btc-vision/bsi-bitcoin-rpc';
+import { ABICoder, BinaryWriter } from '@btc-vision/bsi-binary';
+
+const network: networks.Network = networks.regtest;
+const rpc: BitcoinRPC = new BitcoinRPC();
+const wBtc: wBTC = new wBTC(network);
+const wallet: Wallet = new Wallet(Regtest.wallet, network);
+
+const utxoManager: UTXOManager = new UTXOManager('http://localhost:9001');
+const factory: TransactionFactory = new TransactionFactory();
+
+const abiCoder: ABICoder = new ABICoder();
+const transferSelector = Number(`0x` + abiCoder.encodeSelector('transfer'));
+
+function getTransferToCalldata(to: string, amount: bigint): Buffer {
+    const addCalldata: BinaryWriter = new BinaryWriter();
+    addCalldata.writeSelector(transferSelector);
+    addCalldata.writeAddress(to);
+    addCalldata.writeU256(amount);
+
+    return Buffer.from(addCalldata.getBuffer());
+}
+
+const shouldMineBlock: boolean = true;
+
+async function mineBlock(): Promise<boolean> {
+    // lets mine 1 block.
+    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;
+}
+
+(async () => {
+    await rpc.init(Regtest.config);
+
+    const utxoSetting: FetchUTXOParams = {
+        address: wallet.p2wpkh,
+        minAmount: 10000n,
+        requestedAmount: 100000n,
+    };
+
+    const utxos: UTXO[] = await utxoManager.fetchUTXO(utxoSetting);
+    console.log(`UTXOs:`, utxos);
+
+    if (!utxos) {
+        throw new Error('No UTXOs found');
+    }
+
+    const calldata: Buffer = getTransferToCalldata(wBtc.getAddress(), 5000000n);
+    const interactionParameters: IInteractionParameters = {
+        from: wallet.p2wpkh,
+        to: wBtc.getAddress(),
+        utxos: utxos,
+        signer: wallet.keypair,
+        network: network,
+        feeRate: 150,
+        priorityFee: 50000n,
+        calldata: calldata,
+    };
+
+    const finalTx = factory.signInteraction(interactionParameters);
+    const firstTxBroadcast = await rpc.sendRawTransaction({
+        hexstring: finalTx[0],
+    });
+
+    console.log(`First transaction broadcasted: ${firstTxBroadcast}`);
+
+    if (!firstTxBroadcast) {
+        throw new Error('Could not broadcast first transaction');
+    }
+
+    const secondTxBroadcast = await rpc.sendRawTransaction({
+        hexstring: finalTx[1],
+    });
+
+    console.log(`Second transaction broadcasted: ${secondTxBroadcast}`);
+
+    if (!secondTxBroadcast) {
+        throw new Error('Could not broadcast second transaction');
+    }
+
+    if (shouldMineBlock) {
+        await mineBlock();
+    }
+})();

package/src/signer/TweakedSigner.ts

@@ -0,0 +1,57 @@
+import { initEccLib, Network, Signer } from 'bitcoinjs-lib';
+import { tapTweakHash } from 'bitcoinjs-lib/src/payments/bip341.js';
+import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
+import * as ecc from 'tiny-secp256k1';
+import { EcKeyPair } from '../keypair/EcKeyPair.js';
+
+initEccLib(ecc);
+
+/**
+ * Tweak settings
+ */
+export interface TweakSettings {
+    /**
+     * The network to use
+     */
+    readonly network?: Network;
+
+    /**
+     * The tweak hash to use
+     */
+    tweakHash?: Buffer;
+}
+
+/**
+ * Class for tweaking signers
+ * @class TweakedSigner
+ */
+export class TweakedSigner {
+    /**
+     * Tweak a signer
+     * @param {Signer} signer - The signer to tweak
+     * @param {TweakSettings} opts - The tweak settings
+     */
+    public static tweakSigner(signer: Signer, opts: TweakSettings = {}): Signer {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        let privateKey: Uint8Array | undefined = signer.privateKey!;
+        if (!privateKey) {
+            throw new Error('Private key is required for tweaking signer!');
+        }
+
+        if (signer.publicKey[0] === 3) {
+            privateKey = ecc.privateNegate(privateKey);
+        }
+
+        const tweakedPrivateKey = ecc.privateAdd(
+            privateKey,
+            tapTweakHash(toXOnly(signer.publicKey), opts.tweakHash),
+        );
+
+        if (!tweakedPrivateKey) {
+            throw new Error('Invalid tweaked private key!');
+        }
+
+        return EcKeyPair.fromPrivateKey(Buffer.from(tweakedPrivateKey), opts.network);
+    }
+}

package/src/transaction/TransactionFactory.ts

@@ -0,0 +1,57 @@
+import { Transaction } from 'bitcoinjs-lib';
+import {
+    IFundingTransactionParameters,
+    IInteractionParameters,
+} from './interfaces/ITransactionParameters.js';
+import { FundingTransaction } from './builders/FundingTransaction.js';
+import { Output } from 'bitcoinjs-lib/src/transaction.js';
+import { UTXO } from '../utxo/interfaces/IUTXO.js';
+import { InteractionTransaction } from './builders/InteractionTransaction.js';
+
+export class TransactionFactory {
+    /**
+     * @description Generates the required transactions.
+     * @returns {[Transaction, Transaction]} - The signed transaction
+     */
+    public signInteraction(interactionParameters: IInteractionParameters): [string, string] {
+        const preTransaction: InteractionTransaction = new InteractionTransaction(
+            interactionParameters,
+        );
+
+        // Initial generation
+        preTransaction.signTransaction();
+
+        const parameters: IFundingTransactionParameters =
+            preTransaction.getFundingTransactionParameters();
+
+        const fundingTransaction: FundingTransaction = new FundingTransaction(parameters);
+        const signedTransaction: Transaction = fundingTransaction.signTransaction();
+        if (!signedTransaction) {
+            throw new Error('Could not sign funding transaction.');
+        }
+
+        const out: Output = signedTransaction.outs[0];
+        const newUtxo: UTXO = {
+            transactionId: signedTransaction.getId(),
+            outputIndex: 0,
+            scriptPubKey: {
+                hex: out.script.toString('hex'),
+                address: preTransaction.getScriptAddress(),
+            },
+            value: BigInt(out.value),
+        };
+
+        const newParams: IInteractionParameters = {
+            ...interactionParameters,
+            utxos: [newUtxo],
+            randomBytes: preTransaction.getRndBytes(),
+        };
+
+        const finalTransaction: InteractionTransaction = new InteractionTransaction(newParams);
+
+        // We have to regenerate using the new utxo
+        const outTx: Transaction = finalTransaction.signTransaction();
+
+        return [signedTransaction.toHex(), outTx.toHex()];
+    }
+}

package/src/transaction/builders/FundingTransaction.ts

@@ -0,0 +1,36 @@
+import { TransactionType } from '../enums/TransactionType.js';
+import { IFundingTransactionParameters } from '../interfaces/ITransactionParameters.js';
+import { Signer } from 'bitcoinjs-lib';
+import { TransactionBuilder } from './TransactionBuilder.js';
+
+export class FundingTransaction extends TransactionBuilder<TransactionType.FUNDING> {
+    public readonly type: TransactionType.FUNDING = TransactionType.FUNDING;
+
+    protected childTransactionRequiredFees: bigint;
+
+    constructor(parameters: IFundingTransactionParameters) {
+        super(parameters);
+
+        this.childTransactionRequiredFees = parameters.childTransactionRequiredFees;
+
+        this.internalInit();
+    }
+
+    protected override buildTransaction(): void {
+        this.addInputsFromUTXO();
+
+        const amountSpent: bigint =
+            this.getTransactionOPNetFee() + this.childTransactionRequiredFees;
+
+        this.addOutput({
+            value: Number(amountSpent),
+            address: this.to,
+        });
+
+        this.addRefundOutput(amountSpent);
+    }
+
+    protected override getSignerKey(): Signer {
+        return this.signer;
+    }
+}