@btc-vision/transaction 1.0.0

package/src/utxo/UTXOManager.ts

@@ -0,0 +1,67 @@
+import { FetchUTXOParams, RawUTXOResponse, UTXO } from './interfaces/IUTXO.js';
+
+/**
+ * Allows to fetch UTXO data from any OPNET node
+ */
+export class UTXOManager {
+    private readonly utxoPath: string = 'address/utxos';
+
+    constructor(private readonly opnetAPIUrl: string) {}
+
+    /**
+     * Fetches UTXO data from the OPNET node
+     * @param {FetchUTXOParams} settings - The settings to fetch UTXO data
+     * @returns {Promise<UTXO[]>} - The UTXOs fetched
+     * @throws {Error} - If UTXOs could not be fetched
+     */
+    public async fetchUTXO(settings: FetchUTXOParams): Promise<UTXO[]> {
+        const params = {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        };
+
+        const url: string = `${this.opnetAPIUrl}/api/v1/${this.utxoPath}?address=${settings.address}`;
+        const resp: Response = await fetch(url, params);
+
+        if (!resp.ok) {
+            throw new Error(`Failed to fetch UTXO data: ${resp.statusText}`);
+        }
+
+        const fetchedData: RawUTXOResponse[] = await resp.json();
+        if (fetchedData.length === 0) {
+            throw new Error('No UTXO found');
+        }
+
+        const meetCriteria: RawUTXOResponse[] = fetchedData.filter((utxo: RawUTXOResponse) => {
+            return BigInt(utxo.value) >= settings.minAmount;
+        });
+
+        if (meetCriteria.length === 0) {
+            throw new Error('No UTXO found (minAmount)');
+        }
+
+        let finalUTXOs: UTXO[] = [];
+        let currentAmount: bigint = 0n;
+
+        const amountRequested: bigint = settings.requestedAmount;
+        for (const utxo of meetCriteria) {
+            const utxoValue: bigint = 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/src/utxo/interfaces/IUTXO.ts

@@ -0,0 +1,22 @@
+import { ScriptPubKey } from '@btc-vision/bsi-bitcoin-rpc';
+
+export interface UTXO {
+    readonly transactionId: string;
+    readonly outputIndex: number;
+    readonly value: bigint;
+    readonly scriptPubKey: ScriptPubKey;
+}
+
+export interface FetchUTXOParams {
+    readonly address: string;
+    readonly minAmount: bigint;
+    readonly requestedAmount: bigint;
+    readonly optimized?: boolean;
+}
+
+export interface RawUTXOResponse {
+    readonly transactionId: string;
+    readonly outputIndex: number;
+    readonly value: string;
+    readonly scriptPubKey: ScriptPubKey;
+}

package/tests/TransactionBuilder.test.ts

@@ -0,0 +1,58 @@
+import 'jest';
+import { Regtest } from '../src/scripts/Regtest.js';
+import { Logger } from '@btc-vision/logger';
+import { networks } from 'bitcoinjs-lib';
+import {
+    FetchUTXOParams,
+    IInteractionParameters,
+    TransactionFactory,
+    UTXO,
+    UTXOManager,
+    Wallet,
+    wBTC,
+} from '../src/index.js';
+
+const logger: Logger = new Logger();
+const network: networks.Network = networks.regtest;
+
+describe('Transaction Builder', () => {
+    const wBtc: wBTC = new wBTC(network);
+
+    const wallet: Wallet = new Wallet(Regtest.wallet, network);
+    logger.log(`Loaded wallet: ${wallet.p2tr} - ${wallet.p2wpkh}`);
+
+    const utxoManager: UTXOManager = new UTXOManager('http://localhost:9001');
+    const factory: TransactionFactory = new TransactionFactory();
+
+    /** @test {TransactionBuilder#build} */
+    test('should be able to build a transaction', async () => {
+        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');
+        }
+
+        logger.log(`UTXOs fetched. Count: ${utxos.length}`);
+
+        const interactionParameters: IInteractionParameters = {
+            from: wallet.p2wpkh,
+            to: wBtc.getAddress(),
+            utxos: utxos,
+            signer: wallet.keypair,
+            network: network,
+            feeRate: 150,
+            priorityFee: 500n,
+            calldata: Buffer.from('test'),
+        };
+
+        const finalTx = factory.signInteraction(interactionParameters);
+        console.log(`Transaction:`, finalTx);
+    });
+});

package/tsconfig.base.json

@@ -0,0 +1,43 @@
+{
+    "compilerOptions": {
+        "declaration": true,
+        "noImplicitAny": true,
+        "removeComments": true,
+        "suppressImplicitAnyIndexErrors": false,
+        "preserveConstEnums": true,
+        "resolveJsonModule": true,
+        "skipLibCheck": true,
+        "sourceMap": false,
+        "moduleDetection": "force",
+        "experimentalDecorators": true,
+        "lib": [
+            "es6",
+            "es2020",
+            "es2021",
+            "es2022",
+            "esnext",
+            "webworker",
+            "dom",
+            "scripthost"
+        ],
+        "strict": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "strictBindCallApply": true,
+        "strictPropertyInitialization": true,
+        "alwaysStrict": true,
+        "moduleResolution": "node",
+        "allowJs": true,
+        "incremental": true,
+        "allowSyntheticDefaultImports": true,
+        "esModuleInterop": true
+    },
+    "include": [
+        "src/**/*.ts",
+        "src/*",
+        "src/**/*.js",
+        "src/*.ts",
+        "src/*.js",
+        "src/*.cjs"
+    ]
+}

package/tsconfig.cjs.json

@@ -0,0 +1,9 @@
+{
+    "extends": "./tsconfig.base.json",
+    "compilerOptions": {
+        "module": "CommonJS",
+        "outDir": "cjs",
+        "esModuleInterop": true,
+        "target": "esnext"
+    }
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+	"extends": "./tsconfig.base.json",
+	"compilerOptions": {
+		"module": "esnext",
+		"outDir": "build",
+		"target": "esnext"
+	}
+}

package/tsconfig.webpack.json

@@ -0,0 +1,11 @@
+{
+    "extends": "./tsconfig.json",
+    "compilerOptions": {
+        "module": "esnext",
+        "outDir": "browser",
+        "target": "esnext",
+        "declaration": true,
+        "esModuleInterop": true,
+        "moduleResolution": "bundler"
+    }
+}

package/webpack.config.js

@@ -0,0 +1,77 @@
+import webpack from 'webpack';
+
+export default {
+    mode: 'production',
+    entry: {
+        index: {
+            import: './src/index.ts',
+        },
+    },
+    watch: false,
+    output: {
+        filename: 'index.js',
+        path: import.meta.dirname + '/browser',
+        libraryTarget: 'module',
+    },
+    node: {
+        __dirname: false,
+    },
+    experiments: {
+        outputModule: true,
+        asyncWebAssembly: true,
+        syncWebAssembly: true,
+    },
+    resolve: {
+        extensionAlias: {
+            '.js': ['.js', '.ts'],
+        },
+        modules: ['.', 'node_modules'],
+        extensions: ['.*', '.js', '.jsx', '.tsx', '.ts', '.wasm'],
+        fallback: {
+            buffer: import.meta.resolve('buffer/'),
+
+            assert: import.meta.resolve('assert/'),
+            crypto: import.meta.resolve('./src/crypto/crypto-browser.js'),
+            http: import.meta.resolve('stream-http/'),
+            https: import.meta.resolve('https-browserify/'),
+            os: import.meta.resolve('os-browserify/browser/'),
+            stream: import.meta.resolve('stream-browserify'),
+            process: import.meta.resolve('process/browser'),
+            zlib: import.meta.resolve('browserify-zlib'),
+        },
+    },
+    cache: false,
+    module: {
+        rules: [
+            {
+                test: /\.(js|jsx|tsx|ts)$/,
+                exclude: /node_modules/,
+                resolve: {
+                    fullySpecified: false,
+                },
+                use: [
+                    {
+                        loader: 'babel-loader',
+                    },
+                    {
+                        loader: 'ts-loader',
+                        options: {
+                            configFile: 'tsconfig.webpack.json',
+                        },
+                    },
+                ],
+            },
+        ],
+    },
+    optimization: {
+        usedExports: true,
+    },
+    plugins: [
+        new webpack.ProvidePlugin({
+            Buffer: ['buffer', 'Buffer'],
+            process: 'process/browser',
+            stream: 'stream-browserify',
+            zlib: 'browserify-zlib',
+        }),
+    ],
+};