@btc-vision/transaction 1.1.13 → 1.1.14

package/build/transaction/TransactionFactory.js

@@ -55,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]],
@@ -66,12 +69,18 @@ export class TransactionFactory {
             (await preTransaction.estimateTransactionFees()) +
                 this.getPriorityFee(interactionParameters) +
                 preTransaction.getOptionalOutputValue();
-        const feeEstimationFundingTransaction = await this.createFundTransaction({ ...parameters });
+        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.');
         }

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/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.13",
+    "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.13';
+export const version = '1.1.14';

package/src/buffer/BinaryReader.ts

@@ -1,6 +1,15 @@
-import { ADDRESS_BYTE_LENGTH, BufferLike, i32, Selector, u16, u32, u8 } from '../utils/types.js';
-import { Address } from '../keypair/Address.js';
 import { AddressMap } from '../deterministic/AddressMap.js';
+import { Address } from '../keypair/Address.js';
+import {
+    ADDRESS_BYTE_LENGTH,
+    U128_BYTE_LENGTH,
+    U16_BYTE_LENGTH,
+    U256_BYTE_LENGTH,
+    U32_BYTE_LENGTH,
+    U64_BYTE_LENGTH,
+    U8_BYTE_LENGTH,
+} from '../utils/lengths.js';
+import { BufferLike, i32, Selector, u16, u32, u8 } from '../utils/types.js';
 
 export class BinaryReader {
     private buffer: DataView;
@@ -154,34 +163,34 @@ export class BinaryReader {
     }
 
     public readU8(): u8 {
-        this.verifyEnd(this.currentOffset + 1);
+        this.verifyEnd(this.currentOffset + U8_BYTE_LENGTH);
 
-        return this.buffer.getUint8(this.currentOffset++);
+        return this.buffer.getUint8(this.currentOffset + U8_BYTE_LENGTH);
     }
 
     public readU16(): u16 {
-        this.verifyEnd(this.currentOffset + 2);
+        this.verifyEnd(this.currentOffset + U16_BYTE_LENGTH);
 
         const value = this.buffer.getUint16(this.currentOffset, true);
-        this.currentOffset += 2;
+        this.currentOffset += U16_BYTE_LENGTH;
 
         return value;
     }
 
     public readU32(le: boolean = true): u32 {
-        this.verifyEnd(this.currentOffset + 4);
+        this.verifyEnd(this.currentOffset + U32_BYTE_LENGTH);
 
         const value = this.buffer.getUint32(this.currentOffset, le);
-        this.currentOffset += 4;
+        this.currentOffset += U32_BYTE_LENGTH;
 
         return value;
     }
 
     public readU64(): bigint {
-        this.verifyEnd(this.currentOffset + 8);
+        this.verifyEnd(this.currentOffset + U64_BYTE_LENGTH);
 
         const value: bigint = this.buffer.getBigUint64(this.currentOffset, true);
-        this.currentOffset += 8;
+        this.currentOffset += U64_BYTE_LENGTH;
 
         return value;
     }
@@ -203,7 +212,7 @@ export class BinaryReader {
     }
 
     public readU128(): bigint {
-        const next16Bytes = this.readBytes(16);
+        const next16Bytes = this.readBytes(U128_BYTE_LENGTH);
 
         return BigInt(
             '0x' + next16Bytes.reduce((acc, byte) => acc + byte.toString(16).padStart(2, '0'), ''),
@@ -211,7 +220,7 @@ export class BinaryReader {
     }
 
     public readU256(): bigint {
-        const next32Bytes = this.readBytes(32);
+        const next32Bytes = this.readBytes(U256_BYTE_LENGTH);
 
         return BigInt(
             '0x' + next32Bytes.reduce((acc, byte) => acc + byte.toString(16).padStart(2, '0'), ''),