@btc-vision/transaction 1.0.0

package/build/transaction/builders/TransactionBuilder.js

@@ -0,0 +1,288 @@
+import { initEccLib, opcodes, payments, Psbt, script } from 'bitcoinjs-lib';
+import { varuint } from 'bitcoinjs-lib/src/bufferutils.js';
+import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
+import * as ecc from 'tiny-secp256k1';
+import { EcKeyPair } from '../../keypair/EcKeyPair.js';
+export class TransactionBuilder {
+    static LOCK_LEAF_SCRIPT = script.compile([opcodes.OP_0]);
+    static MINIMUM_DUST = 330n;
+    logColor = '#785def';
+    transactionFee = 0n;
+    transaction;
+    inputs = [];
+    updateInputs = [];
+    outputs = [];
+    feeOutput = null;
+    signed = false;
+    tapData = null;
+    scriptData = null;
+    totalInputAmount;
+    signer;
+    network;
+    feeRate;
+    priorityFee;
+    utxos;
+    to;
+    from;
+    _maximumFeeRate = 100000000;
+    constructor(parameters) {
+        this.signer = parameters.signer;
+        this.network = parameters.network;
+        this.feeRate = parameters.feeRate;
+        this.priorityFee = parameters.priorityFee;
+        this.utxos = parameters.utxos;
+        this.to = parameters.to;
+        this.from =
+            parameters.from ||
+                EcKeyPair.getTaprootAddress(this.signer, this.network);
+        this.totalInputAmount = this.calculateTotalUTXOAmount();
+        const totalVOut = this.calculateTotalVOutAmount();
+        if (totalVOut < this.totalInputAmount) {
+            throw new Error(`Vout value is less than the value to send`);
+        }
+        if (this.totalInputAmount < TransactionBuilder.MINIMUM_DUST) {
+            throw new Error(`Value is less than the minimum dust`);
+        }
+        this.transaction = new Psbt({
+            network: this.network,
+        });
+    }
+    getFundingTransactionParameters() {
+        return {
+            utxos: this.utxos,
+            to: this.getScriptAddress(),
+            signer: this.signer,
+            network: this.network,
+            feeRate: this.feeRate,
+            priorityFee: this.priorityFee,
+            from: this.from,
+            childTransactionRequiredFees: this.transactionFee,
+        };
+    }
+    setDestinationAddress(address) {
+        this.to = address;
+    }
+    setMaximumFeeRate(feeRate) {
+        this._maximumFeeRate = feeRate;
+    }
+    signTransaction() {
+        if (!this.to)
+            throw new Error('Transaction must have a recipient');
+        if (!EcKeyPair.verifyContractAddress(this.to, this.network)) {
+            throw new Error('Invalid contract address. The contract address must be a taproot address.');
+        }
+        if (this.signed)
+            throw new Error('Transaction is already signed');
+        this.signed = true;
+        this.buildTransaction();
+        const builtTx = this.internalBuildTransaction(this.transaction);
+        if (builtTx) {
+            return this.transaction.extractTransaction(false);
+        }
+        throw new Error('Could not sign transaction');
+    }
+    getTransaction() {
+        return this.transaction.extractTransaction(false);
+    }
+    getScriptAddress() {
+        if (!this.scriptData || !this.scriptData.address) {
+            throw new Error('Tap data is required');
+        }
+        return this.scriptData.address;
+    }
+    disableRBF() {
+        if (this.signed)
+            throw new Error('Transaction is already signed');
+        for (let input of this.inputs) {
+            input.sequence = 0xffffffff;
+        }
+    }
+    getTapAddress() {
+        if (!this.tapData || !this.tapData.address) {
+            throw new Error('Tap data is required');
+        }
+        return this.tapData.address;
+    }
+    addInput(input) {
+        this.inputs.push(input);
+    }
+    addOutput(output) {
+        if (output.value < TransactionBuilder.MINIMUM_DUST) {
+            throw new Error(`Output value is less than the minimum dust ${output.value} < ${TransactionBuilder.MINIMUM_DUST}`);
+        }
+        this.outputs.push(output);
+    }
+    addRefundOutput(amountSpent) {
+        const sendBackAmount = this.totalInputAmount - amountSpent;
+        if (sendBackAmount >= TransactionBuilder.MINIMUM_DUST) {
+            this.setFeeOutput({
+                value: Number(sendBackAmount),
+                address: this.from,
+            });
+            return;
+        }
+        console.warn(`Amount to send back is less than the minimum dust, will be consumed in fees instead.`);
+    }
+    getTransactionOPNetFee() {
+        if (this.priorityFee > TransactionBuilder.MINIMUM_DUST) {
+            return this.priorityFee;
+        }
+        return TransactionBuilder.MINIMUM_DUST;
+    }
+    calculateTotalUTXOAmount() {
+        let total = 0n;
+        for (let utxo of this.utxos) {
+            total += utxo.value;
+        }
+        return total;
+    }
+    calculateTotalVOutAmount() {
+        let total = 0n;
+        for (let utxo of this.utxos) {
+            total += utxo.value;
+        }
+        return total;
+    }
+    addInputsFromUTXO() {
+        for (let utxo of this.utxos) {
+            const input = {
+                hash: utxo.transactionId,
+                index: utxo.outputIndex,
+                witnessUtxo: {
+                    value: Number(utxo.value),
+                    script: Buffer.from(utxo.scriptPubKey.hex, 'hex'),
+                },
+                sequence: 0xfffffffd,
+            };
+            this.addInput(input);
+        }
+    }
+    witnessStackToScriptWitness(witness) {
+        let buffer = Buffer.allocUnsafe(0);
+        function writeSlice(slice) {
+            buffer = Buffer.concat([buffer, Buffer.from(slice)]);
+        }
+        function writeVarInt(i) {
+            const currentLen = buffer.length;
+            const varintLen = varuint.encodingLength(i);
+            buffer = Buffer.concat([buffer, Buffer.allocUnsafe(varintLen)]);
+            varuint.encode(i, buffer, currentLen);
+        }
+        function writeVarSlice(slice) {
+            writeVarInt(slice.length);
+            writeSlice(slice);
+        }
+        function writeVector(vector) {
+            writeVarInt(vector.length);
+            vector.forEach(writeVarSlice);
+        }
+        writeVector(witness);
+        return buffer;
+    }
+    internalInit() {
+        this.verifyUTXOValidity();
+        this.scriptData = payments.p2tr(this.generateScriptAddress());
+        this.tapData = payments.p2tr(this.generateTapData());
+    }
+    generateScriptAddress() {
+        return {
+            internalPubkey: this.internalPubKeyToXOnly(),
+            network: this.network,
+        };
+    }
+    generateTapData() {
+        return {
+            internalPubkey: this.internalPubKeyToXOnly(),
+            network: this.network,
+        };
+    }
+    updateInput(input) {
+        this.updateInputs.push(input);
+    }
+    getWitness() {
+        if (!this.tapData || !this.tapData.witness) {
+            throw new Error('Witness is required');
+        }
+        if (this.tapData.witness.length === 0) {
+            throw new Error('Witness is empty');
+        }
+        return this.tapData.witness[this.tapData.witness.length - 1];
+    }
+    getTapOutput() {
+        if (!this.tapData || !this.tapData.output) {
+            throw new Error('Tap data is required');
+        }
+        return this.tapData.output;
+    }
+    getInputs() {
+        return this.inputs;
+    }
+    getOutputs() {
+        const outputs = [...this.outputs];
+        if (this.feeOutput)
+            outputs.push(this.feeOutput);
+        return outputs;
+    }
+    verifyUTXOValidity() {
+        for (let utxo of this.utxos) {
+            if (!utxo.scriptPubKey) {
+                throw new Error('Address is required');
+            }
+        }
+    }
+    setFeeOutput(output) {
+        const initialValue = output.value;
+        this.feeOutput = output;
+        const fee = this.estimateTransactionFees();
+        if (fee > BigInt(initialValue)) {
+            throw new Error('Insufficient funds');
+        }
+        this.feeOutput.value = initialValue - Number(fee);
+        if (this.feeOutput.value < TransactionBuilder.MINIMUM_DUST) {
+            this.feeOutput = null;
+        }
+    }
+    internalPubKeyToXOnly() {
+        return toXOnly(this.signer.publicKey);
+    }
+    signInputs(transaction) {
+        transaction.signAllInputs(this.getSignerKey());
+        transaction.finalizeAllInputs();
+    }
+    internalBuildTransaction(transaction) {
+        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);
+            this.transactionFee = BigInt(transaction.getFee());
+            return true;
+        }
+        catch (e) {
+            const err = e;
+            console.error(`[internalBuildTransaction] Something went wrong while getting building the transaction: ${err.stack}`);
+        }
+        return false;
+    }
+    estimateTransactionFees() {
+        const fakeTx = new Psbt({
+            network: this.network,
+        });
+        const builtTx = this.internalBuildTransaction(fakeTx);
+        if (builtTx) {
+            const tx = fakeTx.extractTransaction(false);
+            const size = tx.virtualSize();
+            const fee = this.feeRate * size + 1;
+            return BigInt(Math.ceil(fee));
+        }
+        else {
+            throw new Error(`Could not build transaction to estimate fee. Something went wrong while building the transaction.`);
+        }
+    }
+}
+initEccLib(ecc);

package/build/transaction/enums/TransactionType.d.ts

@@ -0,0 +1,7 @@
+export declare enum TransactionType {
+    GENERIC = 0,
+    FUNDING = 1,
+    DEPLOYMENT = 2,
+    INTERACTION = 3,
+    WBTC_WRAP = 4
+}

package/build/transaction/enums/TransactionType.js

@@ -0,0 +1,8 @@
+export var TransactionType;
+(function (TransactionType) {
+    TransactionType[TransactionType["GENERIC"] = 0] = "GENERIC";
+    TransactionType[TransactionType["FUNDING"] = 1] = "FUNDING";
+    TransactionType[TransactionType["DEPLOYMENT"] = 2] = "DEPLOYMENT";
+    TransactionType[TransactionType["INTERACTION"] = 3] = "INTERACTION";
+    TransactionType[TransactionType["WBTC_WRAP"] = 4] = "WBTC_WRAP";
+})(TransactionType || (TransactionType = {}));

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

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+import { Signer } from 'bitcoinjs-lib';
+import { UTXO } from '../../utxo/interfaces/IUTXO.js';
+import { Network } from 'bitcoinjs-lib/src/networks.js';
+import { Address } from '@btc-vision/bsi-binary';
+export interface ITransactionParameters {
+    readonly from?: Address;
+    readonly to: Address;
+    utxos: UTXO[];
+    readonly signer: Signer;
+    readonly network: Network;
+    readonly feeRate: number;
+    readonly priorityFee: bigint;
+}
+export interface IFundingTransactionParameters extends ITransactionParameters {
+    readonly childTransactionRequiredFees: bigint;
+}
+export interface IInteractionParameters extends ITransactionParameters {
+    readonly calldata: Buffer;
+    readonly pubKeys?: Buffer[];
+    readonly minimumSignatures?: number;
+    readonly randomBytes?: Buffer;
+}
+export interface ITransactionDataContractInteractionWrap extends IInteractionParameters {
+    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/ITransactionParameters.js

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

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

@@ -0,0 +1,32 @@
+/// <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

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

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

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { PsbtInput, PsbtOutput } from 'bip174/src/lib/interfaces.js';
+import { TransactionInput } from 'bitcoinjs-lib/src/psbt.js';
+export interface TapLeafScript {
+    readonly leafVersion: number;
+    readonly controlBlock: Buffer;
+    readonly script: Buffer;
+}
+export interface UpdateInput {
+    tapLeafScript: TapLeafScript[];
+}
+export interface PsbtInputExtended extends PsbtInput, TransactionInput {
+}
+export interface PsbtOutputExtendedAddress extends PsbtOutput {
+    address: string;
+    value: number;
+}
+export interface PsbtOutputExtendedScript extends PsbtOutput {
+    script: Buffer;
+    value: number;
+}
+export type PsbtOutputExtended = PsbtOutputExtendedAddress | PsbtOutputExtendedScript;

package/build/transaction/interfaces/Tap.js

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

package/build/utils/BitcoinUtils.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+export declare class BitcoinUtils {
+    static btcToSatoshi(btc: number): BigInt;
+    static rndBytes(): Buffer;
+}

package/build/utils/BitcoinUtils.js

@@ -0,0 +1,9 @@
+export class BitcoinUtils {
+    static btcToSatoshi(btc) {
+        return BigInt(btc * 100000000);
+    }
+    static rndBytes() {
+        const buf = crypto.getRandomValues(new Uint8Array(64));
+        return Buffer.from(buf);
+    }
+}

package/build/utxo/IUTXO.js

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

package/build/utxo/UTXOManager.d.ts

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,47 @@
+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/interfaces/IUTXO.d.ts

@@ -0,0 +1,19 @@
+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/build/utxo/interfaces/IUTXO.js

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

package/cjs/_version.d.ts

@@ -0,0 +1 @@
+export declare const version = "1.0.0";

package/cjs/_version.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.version = void 0;
+exports.version = '1.0.0';

package/cjs/bytecode/Compressor.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+export declare class Compressor {
+    private static readonly zlibOptions;
+    static compress(data: Uint8Array | Buffer): Buffer;
+    static decompress(data: Uint8Array | Buffer): Buffer;
+}

package/cjs/bytecode/Compressor.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Compressor = void 0;
+const zlib_1 = __importDefault(require("zlib"));
+class Compressor {
+    static zlibOptions = {
+        level: zlib_1.default.constants.Z_MAX_LEVEL,
+        maxOutputLength: 1024 * 1024 * 16,
+    };
+    static compress(data) {
+        return zlib_1.default.gzipSync(data, Compressor.zlibOptions);
+    }
+    static decompress(data) {
+        return zlib_1.default.gunzipSync(data, Compressor.zlibOptions);
+    }
+}
+exports.Compressor = Compressor;

package/cjs/crypto/crypto.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export { createHash, createHmac, pbkdf2Sync, randomBytes } from 'crypto';

package/cjs/crypto/crypto.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomBytes = exports.pbkdf2Sync = exports.createHmac = exports.createHash = void 0;
+var crypto_1 = require("crypto");
+Object.defineProperty(exports, "createHash", { enumerable: true, get: function () { return crypto_1.createHash; } });
+Object.defineProperty(exports, "createHmac", { enumerable: true, get: function () { return crypto_1.createHmac; } });
+Object.defineProperty(exports, "pbkdf2Sync", { enumerable: true, get: function () { return crypto_1.pbkdf2Sync; } });
+Object.defineProperty(exports, "randomBytes", { enumerable: true, get: function () { return crypto_1.randomBytes; } });

package/cjs/generators/Generator.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { Logger } from '@btc-vision/logger';
+import { Network } from 'bitcoinjs-lib';
+export declare abstract class Generator extends Logger {
+    static readonly DATA_CHUNK_SIZE: number;
+    static readonly MAGIC: Buffer;
+    protected readonly senderPubKey: Buffer;
+    protected readonly contractSaltPubKey: Buffer;
+    protected readonly network: Network;
+    protected constructor(senderPubKey: Buffer, contractSaltPubKey: Buffer, network?: Network);
+    abstract compile(...args: unknown[]): Buffer;
+    protected splitBufferIntoChunks(buffer: Buffer, chunkSize?: number): Array<Buffer[]>;
+}

package/cjs/generators/Generator.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Generator = void 0;
+const logger_1 = require("@btc-vision/logger");
+const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+class Generator extends logger_1.Logger {
+    static DATA_CHUNK_SIZE = 512;
+    static MAGIC = Buffer.from('bsi', 'utf-8');
+    senderPubKey;
+    contractSaltPubKey;
+    network = bitcoinjs_lib_1.networks.bitcoin;
+    constructor(senderPubKey, contractSaltPubKey, network = bitcoinjs_lib_1.networks.bitcoin) {
+        super();
+        this.senderPubKey = senderPubKey;
+        this.contractSaltPubKey = contractSaltPubKey;
+        this.network = network;
+    }
+    splitBufferIntoChunks(buffer, chunkSize = Generator.DATA_CHUNK_SIZE) {
+        const chunks = [];
+        for (let i = 0; i < buffer.length; i += chunkSize) {
+            const dataLength = Math.min(chunkSize, buffer.length - i);
+            const buf2 = Buffer.alloc(dataLength);
+            for (let j = 0; j < dataLength; j++) {
+                buf2.writeUInt8(buffer[i + j], j);
+            }
+            chunks.push([buf2]);
+        }
+        return chunks;
+    }
+}
+exports.Generator = Generator;

package/cjs/generators/builders/CalldataGenerator.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { Network } from 'bitcoinjs-lib';
+import { Generator } from '../Generator.js';
+export declare class CalldataGenerator extends Generator {
+    constructor(senderPubKey: Buffer, contractSaltPubKey: Buffer, network?: Network);
+    compile(calldata: Buffer, contractSecret: Buffer, vaultPublicKeys?: Buffer[], minimumSignatures?: number): Buffer;
+    private getPubKeyAsBuffer;
+}