@btc-vision/transaction 1.1.12 → 1.1.14

package/build/transaction/TransactionFactory.js

@@ -21,7 +21,8 @@ export class TransactionFactory {
         parameters.utxos = interactionParameters.utxos;
         parameters.amount =
             (await preTransaction.estimateTransactionFees()) +
-                this.getPriorityFee(interactionParameters);
+                this.getPriorityFee(interactionParameters) +
+                preTransaction.getOptionalOutputValue();
         const feeEstimationFundingTransaction = await this.createFundTransaction({ ...parameters });
         if (!feeEstimationFundingTransaction) {
             throw new Error('Could not sign funding transaction.');
@@ -54,6 +55,9 @@ export class TransactionFactory {
         if (!interactionParameters.from) {
             throw new Error('Field "from" not provided.');
         }
+        if (!interactionParameters.utxos[0]) {
+            throw new Error('Missing at least one UTXO.');
+        }
         const preTransaction = new InteractionTransaction({
             ...interactionParameters,
             utxos: [interactionParameters.utxos[0]],
@@ -63,13 +67,20 @@ export class TransactionFactory {
         parameters.utxos = interactionParameters.utxos;
         parameters.amount =
             (await preTransaction.estimateTransactionFees()) +
-                this.getPriorityFee(interactionParameters);
-        const feeEstimationFundingTransaction = await this.createFundTransaction({ ...parameters });
+                this.getPriorityFee(interactionParameters) +
+                preTransaction.getOptionalOutputValue();
+        const feeEstimationFundingTransaction = await this.createFundTransaction({
+            ...parameters,
+            optionalOutputs: [],
+        });
         if (!feeEstimationFundingTransaction) {
             throw new Error('Could not sign funding transaction.');
         }
         parameters.estimatedFees = feeEstimationFundingTransaction.estimatedFees;
-        const signedTransaction = await this.createFundTransaction(parameters);
+        const signedTransaction = await this.createFundTransaction({
+            ...parameters,
+            optionalOutputs: [],
+        });
         if (!signedTransaction) {
             throw new Error('Could not sign funding transaction.');
         }
@@ -95,7 +106,8 @@ export class TransactionFactory {
         const parameters = await preTransaction.getFundingTransactionParameters();
         parameters.amount =
             (await preTransaction.estimateTransactionFees()) +
-                this.getPriorityFee(deploymentParameters);
+                this.getPriorityFee(deploymentParameters) +
+                preTransaction.getOptionalOutputValue();
         const fundingTransaction = new FundingTransaction(parameters);
         const signedTransaction = await fundingTransaction.signTransaction();
         if (!signedTransaction) {

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

@@ -0,0 +1,36 @@
+import { Network, Psbt } from '@btc-vision/bitcoin';
+import { CustomKeypair } from '../BrowserSignerBase.js';
+import { Xverse } from '../types/Xverse.js';
+declare global {
+    interface Window {
+        BitcoinProvider?: Xverse;
+    }
+}
+export declare class XverseSigner extends CustomKeypair {
+    private isInitialized;
+    constructor();
+    private _p2tr;
+    get p2tr(): string;
+    private _p2wpkh;
+    get p2wpkh(): string;
+    private _addresses;
+    get addresses(): string[];
+    private _publicKey;
+    get publicKey(): Buffer;
+    _network: Network | undefined;
+    get network(): Network;
+    get BitcoinProvider(): Xverse;
+    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>;
+    multiSignPsbt(transactions: Psbt[]): Promise<void>;
+    private hasAlreadySignedTapScriptSig;
+    private hasAlreadyPartialSig;
+    private combine;
+    private signAllTweaked;
+    private getNonDuplicateScriptSig;
+}

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

@@ -0,0 +1,299 @@
+import { crypto as bitCrypto, script as bitScript, networks, opcodes, Psbt, } from '@btc-vision/bitcoin';
+import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
+import { EcKeyPair } from '../../../keypair/EcKeyPair.js';
+import { CustomKeypair } from '../BrowserSignerBase.js';
+export class XverseSigner extends CustomKeypair {
+    constructor() {
+        super();
+        this.isInitialized = false;
+        if (!window) {
+            throw new Error('XverseSigner can only be used in a browser environment');
+        }
+    }
+    get p2tr() {
+        if (!this._p2tr) {
+            throw new Error('P2TR address not set');
+        }
+        return this._p2tr;
+    }
+    get p2wpkh() {
+        if (!this._p2wpkh) {
+            throw new Error('P2PKH address not set');
+        }
+        return this._p2wpkh;
+    }
+    get addresses() {
+        if (!this._addresses) {
+            throw new Error('Addresses not set');
+        }
+        return this._addresses;
+    }
+    get publicKey() {
+        if (!this._publicKey) {
+            throw new Error('Public key not set');
+        }
+        return this._publicKey;
+    }
+    get network() {
+        if (!this._network) {
+            throw new Error('Network not set');
+        }
+        return this._network;
+    }
+    get BitcoinProvider() {
+        const module = window.BitcoinProvider;
+        if (!module) {
+            throw new Error('Xverse Wallet extension not found');
+        }
+        return module;
+    }
+    async init() {
+        if (this.isInitialized)
+            return;
+        const connectResult = (await this.BitcoinProvider.request('wallet_connect', null));
+        if ('error' in connectResult)
+            throw new Error(connectResult.error.message);
+        const payementAddress = connectResult.result.addresses.find((address) => address.purpose === 'payment');
+        if (!payementAddress) {
+            throw new Error('Payment address not found');
+        }
+        const network = payementAddress.address.startsWith('tb')
+            ? networks.testnet
+            : payementAddress.address.startsWith('bc')
+                ? networks.bitcoin
+                : null;
+        if (!network)
+            throw new Error('Network not supported');
+        this._network = network;
+        this._publicKey = Buffer.from(payementAddress.publicKey, 'hex');
+        this._p2wpkh = EcKeyPair.getP2WPKHAddress(this, this.network);
+        this._p2tr = EcKeyPair.getTaprootAddress(this, this.network);
+        this._addresses = [this._p2wpkh, this._p2tr];
+        this.isInitialized = true;
+    }
+    getPublicKey() {
+        if (!this.isInitialized) {
+            throw new Error('UnisatSigner not initialized');
+        }
+        return this.publicKey;
+    }
+    sign(_hash, _lowR) {
+        throw new Error('Not implemented: sign');
+    }
+    signSchnorr(_hash) {
+        throw new Error('Not implemented: signSchnorr');
+    }
+    verify(_hash, _signature) {
+        throw new Error('Not implemented: verify');
+    }
+    async signTaprootInput(transaction, i, sighashTypes) {
+        const input = transaction.data.inputs[i];
+        if (input.tapKeySig ||
+            input.finalScriptSig ||
+            (Array.isArray(input.partialSig) &&
+                input.partialSig.length &&
+                this.hasAlreadyPartialSig(input.partialSig)) ||
+            (Array.isArray(input.tapScriptSig) &&
+                input.tapScriptSig.length &&
+                this.hasAlreadySignedTapScriptSig(input.tapScriptSig))) {
+            return;
+        }
+        const firstSignature = await this.signAllTweaked(transaction, sighashTypes, false);
+        this.combine(transaction, firstSignature, i);
+    }
+    async signInput(transaction, i, sighashTypes) {
+        const input = transaction.data.inputs[i];
+        if (input.tapKeySig ||
+            input.finalScriptSig ||
+            (Array.isArray(input.partialSig) &&
+                input.partialSig.length &&
+                this.hasAlreadyPartialSig(input.partialSig)) ||
+            (Array.isArray(input.tapScriptSig) &&
+                input.tapScriptSig.length &&
+                this.hasAlreadySignedTapScriptSig(input.tapScriptSig))) {
+            return;
+        }
+        const firstSignature = await this.signAllTweaked(transaction, sighashTypes, true);
+        this.combine(transaction, firstSignature, i);
+    }
+    async multiSignPsbt(transactions) {
+        const toSignPsbts = [];
+        const options = [];
+        for (const psbt of transactions) {
+            const hex = psbt.toHex();
+            toSignPsbts.push(hex);
+            const toSignInputs = psbt.data.inputs
+                .map((input, i) => {
+                let needsToSign = false;
+                let viaTaproot = false;
+                if (isTaprootInput(input)) {
+                    if (input.tapLeafScript && input.tapLeafScript.length > 0) {
+                        for (const tapLeafScript of input.tapLeafScript) {
+                            if (pubkeyInScript(this.publicKey, tapLeafScript.script)) {
+                                needsToSign = true;
+                                viaTaproot = false;
+                                break;
+                            }
+                        }
+                    }
+                    if (!needsToSign && input.tapInternalKey) {
+                        const tapInternalKey = input.tapInternalKey;
+                        const xOnlyPubKey = toXOnly(this.publicKey);
+                        if (tapInternalKey.equals(xOnlyPubKey)) {
+                            needsToSign = true;
+                            viaTaproot = true;
+                        }
+                    }
+                }
+                else {
+                    const script = getInputRelevantScript(input);
+                    if (script && pubkeyInScript(this.publicKey, script)) {
+                        needsToSign = true;
+                        viaTaproot = false;
+                    }
+                }
+                if (needsToSign) {
+                    return {
+                        index: i,
+                        publicKey: this.publicKey.toString('hex'),
+                        disableTweakSigner: !viaTaproot,
+                    };
+                }
+                else {
+                    return null;
+                }
+            })
+                .filter((v) => v !== null);
+            options.push({
+                autoFinalized: false,
+                toSignInputs: toSignInputs,
+            });
+        }
+        const callSign = (await this.BitcoinProvider.request('signPsbt', {
+            psbt: toSignPsbts[0],
+            signInputs: options[0].toSignInputs,
+        }));
+        if ('error' in callSign)
+            throw new Error(callSign.error.message);
+        const signedPsbts = Psbt.fromBase64(callSign.result.psbt);
+        transactions[0].combine(signedPsbts);
+    }
+    hasAlreadySignedTapScriptSig(input) {
+        for (let i = 0; i < input.length; i++) {
+            const item = input[i];
+            const buf = Buffer.from(item.pubkey);
+            if (buf.equals(this.publicKey) && item.signature) {
+                return true;
+            }
+        }
+        return false;
+    }
+    hasAlreadyPartialSig(input) {
+        for (let i = 0; i < input.length; i++) {
+            const item = input[i];
+            const buf = Buffer.from(item.pubkey);
+            if (buf.equals(this.publicKey) && item.signature) {
+                return true;
+            }
+        }
+        return false;
+    }
+    combine(transaction, newPsbt, i) {
+        const signedInput = newPsbt.data.inputs[i];
+        const originalInput = transaction.data.inputs[i];
+        if (signedInput.partialSig) {
+            transaction.updateInput(i, { partialSig: signedInput.partialSig });
+        }
+        if (signedInput.tapKeySig && !originalInput.tapKeySig) {
+            transaction.updateInput(i, { tapKeySig: signedInput.tapKeySig });
+        }
+        if (signedInput.tapScriptSig?.length) {
+            const lastScriptSig = originalInput.tapScriptSig;
+            if (lastScriptSig) {
+                const getNonDuplicate = this.getNonDuplicateScriptSig(lastScriptSig, signedInput.tapScriptSig);
+                if (getNonDuplicate.length) {
+                    transaction.updateInput(i, { tapScriptSig: getNonDuplicate });
+                }
+            }
+            else {
+                transaction.updateInput(i, { tapScriptSig: signedInput.tapScriptSig });
+            }
+        }
+    }
+    async signAllTweaked(transaction, sighashTypes, disableTweakSigner = false) {
+        const pubKey = this.publicKey.toString('hex');
+        const toSign = transaction.data.inputs.map((_, i) => {
+            return [
+                {
+                    index: i,
+                    publicKey: pubKey,
+                    sighashTypes,
+                    disableTweakSigner: disableTweakSigner,
+                },
+            ];
+        });
+        const opts = {
+            autoFinalized: false,
+            toSignInputs: toSign.flat(),
+        };
+        const psbt = transaction.toBase64();
+        const callSign = (await this.BitcoinProvider.request('signPsbt', {
+            psbt,
+            signInputs: opts.toSignInputs,
+        }));
+        if ('error' in callSign)
+            throw new Error(callSign.error.message);
+        return Psbt.fromBase64(callSign.result.psbt);
+    }
+    getNonDuplicateScriptSig(scriptSig1, scriptSig2) {
+        const nonDuplicate = [];
+        for (let i = 0; i < scriptSig2.length; i++) {
+            const found = scriptSig1.find((item) => item.pubkey.equals(scriptSig2[i].pubkey));
+            if (!found) {
+                nonDuplicate.push(scriptSig2[i]);
+            }
+        }
+        return nonDuplicate;
+    }
+}
+function isTaprootInput(input) {
+    if (input.tapInternalKey || input.tapKeySig || input.tapScriptSig || input.tapLeafScript) {
+        return true;
+    }
+    if (input.witnessUtxo) {
+        const script = input.witnessUtxo.script;
+        return script.length === 34 && script[0] === opcodes.OP_1 && script[1] === 0x20;
+    }
+    return false;
+}
+function getInputRelevantScript(input) {
+    if (input.redeemScript) {
+        return input.redeemScript;
+    }
+    if (input.witnessScript) {
+        return input.witnessScript;
+    }
+    if (input.witnessUtxo) {
+        return input.witnessUtxo.script;
+    }
+    if (input.nonWitnessUtxo) {
+        return null;
+    }
+    return null;
+}
+function pubkeyInScript(pubkey, script) {
+    return pubkeyPositionInScript(pubkey, script) !== -1;
+}
+function pubkeyPositionInScript(pubkey, script) {
+    const pubkeyHash = bitCrypto.hash160(pubkey);
+    const pubkeyXOnly = toXOnly(pubkey);
+    const decompiled = bitScript.decompile(script);
+    if (decompiled === null)
+        throw new Error('Unknown script error');
+    return decompiled.findIndex((element) => {
+        if (typeof element === 'number')
+            return false;
+        return (Buffer.isBuffer(element) &&
+            (element.equals(pubkey) || element.equals(pubkeyHash) || element.equals(pubkeyXOnly)));
+    });
+}

package/build/transaction/browser/types/Xverse.d.ts

@@ -0,0 +1,79 @@
+export declare enum XverseNetwork {
+    mainnet = "mainnet",
+    testnet = "testnet",
+    signet = "Signet"
+}
+export type XverseRPCResponse<T = unknown> = {
+    id: string;
+    jsonrpc: string;
+    result: T;
+};
+export type XverseRPCError = {
+    id: string;
+    jsonrpc: string;
+    error: {
+        code: number;
+        message: string;
+    };
+};
+export type XverseRPCGetAccountResponse = XverseRPCResponse<{
+    addresses: {
+        address: string;
+        addressType: string;
+        publicKey: string;
+        purpose: string;
+    }[];
+}> | XverseRPCError;
+export type XverseRPCSignPsbtResponse = XverseRPCResponse<{
+    psbt: string;
+}> | XverseRPCError;
+interface InscriptionData {
+    address: string;
+    amount: number;
+    asset: string;
+    fee: number;
+    nonce: number;
+    recipient: string;
+}
+interface InscriptionResult {
+    txid: string;
+}
+interface RepeatInscriptionsData {
+    inscriptions: InscriptionData[];
+}
+interface TransactionResult {
+    txid: string;
+}
+interface SignedMessageResult {
+    signature: string;
+}
+interface BtcTransaction {
+    inputs: {
+        address: string;
+        amount: number;
+        asset: string;
+        nonce: number;
+    }[];
+    outputs: {
+        address: string;
+        amount: number;
+        asset: string;
+    }[];
+    fee: number;
+}
+interface SignedTransactionResult {
+    txid: string;
+    raw: string;
+}
+export interface Xverse {
+    connect: () => Promise<void>;
+    addListener: (event: string, callback: (...args: unknown[]) => void) => void;
+    createInscription: (data: InscriptionData) => Promise<InscriptionResult>;
+    createRepeatInscriptions: (data: RepeatInscriptionsData) => Promise<InscriptionResult[]>;
+    request: (method: string, params: unknown) => Promise<XverseRPCResponse>;
+    sendBtcTransaction: (transaction: BtcTransaction) => Promise<TransactionResult>;
+    signMessage: (message: string) => Promise<SignedMessageResult>;
+    signMultipleTransactions: (transactions: BtcTransaction[]) => Promise<SignedTransactionResult[]>;
+    signTransaction: (transaction: BtcTransaction) => Promise<SignedTransactionResult>;
+}
+export {};

package/build/transaction/browser/types/Xverse.js

@@ -0,0 +1,6 @@
+export var XverseNetwork;
+(function (XverseNetwork) {
+    XverseNetwork["mainnet"] = "mainnet";
+    XverseNetwork["testnet"] = "testnet";
+    XverseNetwork["signet"] = "Signet";
+})(XverseNetwork || (XverseNetwork = {}));

package/build/transaction/builders/CustomScriptTransaction.js

@@ -78,7 +78,7 @@ export class CustomScriptTransaction extends TransactionBuilder {
             value: Number(amountSpent),
             address: this.to,
         });
-        await this.addRefundOutput(amountSpent);
+        await this.addRefundOutput(amountSpent + this.addOptionalOutputsAndGetAmount());
     }
     async signInputs(transaction) {
         if (!this.contractSigner) {

package/build/transaction/builders/DeploymentTransaction.js

@@ -93,7 +93,7 @@ export class DeploymentTransaction extends TransactionBuilder {
             value: Number(amountSpent),
             address: this.contractAddress.p2tr(this.network),
         });
-        await this.addRefundOutput(amountSpent);
+        await this.addRefundOutput(amountSpent + this.addOptionalOutputsAndGetAmount());
     }
     async signInputsWalletBased(transaction) {
         const signer = this.signer;

package/build/transaction/builders/FundingTransaction.js

@@ -28,7 +28,7 @@ export class FundingTransaction extends TransactionBuilder {
                 address: this.to,
             });
         }
-        await this.addRefundOutput(this.amount);
+        await this.addRefundOutput(this.amount + this.addOptionalOutputsAndGetAmount());
     }
     splitInputs(amountSpent) {
         if (!this.to) {

package/build/transaction/builders/SharedInteractionTransaction.js

@@ -79,8 +79,9 @@ export class SharedInteractionTransaction extends TransactionBuilder {
             value: Number(amountSpent),
             address: this.to,
         });
+        const amount = this.addOptionalOutputsAndGetAmount();
         if (!this.disableAutoRefund) {
-            await this.addRefundOutput(amountSpent);
+            await this.addRefundOutput(amountSpent + amount);
         }
     }
     async signInputs(transaction) {

package/build/transaction/builders/TransactionBuilder.d.ts

@@ -47,6 +47,7 @@ export declare abstract class TransactionBuilder<T extends TransactionType> exte
     setPSBT(psbt: Psbt): void;
     getInputs(): PsbtInputExtended[];
     getOutputs(): PsbtOutputExtended[];
+    getOptionalOutputValue(): bigint;
     protected addRefundOutput(amountSpent: bigint): Promise<void>;
     protected addValueToToOutput(value: number | bigint): void;
     protected getTransactionOPNetFee(): bigint;

package/build/transaction/builders/TransactionBuilder.js

@@ -186,8 +186,17 @@ export class TransactionBuilder extends TweakedTransaction {
             outputs.push(this.feeOutput);
         return outputs;
     }
+    getOptionalOutputValue() {
+        if (!this.optionalOutputs)
+            return 0n;
+        let total = 0n;
+        for (let i = 0; i < this.optionalOutputs.length; i++) {
+            total += BigInt(this.optionalOutputs[i].value);
+        }
+        return total;
+    }
     async addRefundOutput(amountSpent) {
-        const sendBackAmount = this.totalInputAmount - amountSpent - this.addOptionalOutputsAndGetAmount();
+        const sendBackAmount = this.totalInputAmount - amountSpent;
         if (sendBackAmount >= TransactionBuilder.MINIMUM_DUST) {
             if (AddressVerificator.isValidP2TRAddress(this.from, this.network)) {
                 await this.setFeeOutput({

package/build/utils/BufferHelper.js

@@ -1,3 +1,4 @@
+import { U256_BYTE_LENGTH } from './lengths.js';
 export class BufferHelper {
     static bufferToUint8Array(buffer) {
         if (Buffer.isBuffer(buffer)) {
@@ -36,7 +37,7 @@ export class BufferHelper {
         const hex = BufferHelper.uint8ArrayToHex(input);
         return BigInt('0x' + hex);
     }
-    static valueToUint8Array(value, length = 32) {
+    static valueToUint8Array(value, length = U256_BYTE_LENGTH) {
         const valueHex = value.toString(16).padStart(length * 2, '0');
         return BufferHelper.hexToUint8Array(valueHex);
     }

package/build/utils/lengths.d.ts

@@ -0,0 +1,16 @@
+import { i32 } from './types';
+export declare const ADDRESS_BYTE_LENGTH: i32;
+export declare const SELECTOR_BYTE_LENGTH: i32;
+export declare const U256_BYTE_LENGTH: i32;
+export declare const U128_BYTE_LENGTH: i32;
+export declare const U64_BYTE_LENGTH: i32;
+export declare const U32_BYTE_LENGTH: i32;
+export declare const U16_BYTE_LENGTH: i32;
+export declare const U8_BYTE_LENGTH: i32;
+export declare const I256_BYTE_LENGTH: i32;
+export declare const I128_BYTE_LENGTH: i32;
+export declare const I64_BYTE_LENGTH: i32;
+export declare const I32_BYTE_LENGTH: i32;
+export declare const I16_BYTE_LENGTH: i32;
+export declare const I8_BYTE_LENGTH: i32;
+export declare const BOOLEAN_BYTE_LENGTH: i32;

package/build/utils/lengths.js

@@ -0,0 +1,15 @@
+export const ADDRESS_BYTE_LENGTH = 32;
+export const SELECTOR_BYTE_LENGTH = 4;
+export const U256_BYTE_LENGTH = 32;
+export const U128_BYTE_LENGTH = 16;
+export const U64_BYTE_LENGTH = 8;
+export const U32_BYTE_LENGTH = 4;
+export const U16_BYTE_LENGTH = 2;
+export const U8_BYTE_LENGTH = 1;
+export const I256_BYTE_LENGTH = 32;
+export const I128_BYTE_LENGTH = 16;
+export const I64_BYTE_LENGTH = 8;
+export const I32_BYTE_LENGTH = 4;
+export const I16_BYTE_LENGTH = 2;
+export const I8_BYTE_LENGTH = 1;
+export const BOOLEAN_BYTE_LENGTH = 1;

package/build/utils/types.d.ts

@@ -1,5 +1,4 @@
 import { DeterministicMap } from '../deterministic/DeterministicMap.js';
-export declare const ADDRESS_BYTE_LENGTH: number;
 export type MemorySlotPointer = bigint;
 export type BufferLike = Uint8Array | Buffer;
 export type MemorySlotData<T> = T;

package/build/utils/types.js

@@ -1 +1 @@
-export const ADDRESS_BYTE_LENGTH = 32;
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.1.12",
+    "version": "1.1.14",
     "author": "BlobMaster41",
     "description": "OPNet transaction library allows you to create and sign transactions for the OPNet network.",
     "engines": {

package/src/_version.ts

@@ -1 +1 @@
-export const version = '1.1.12';
+export const version = '1.1.14';