@btc-vision/transaction 1.1.13 → 1.1.15

package/src/transaction/browser/extensions/XverseSigner.ts

@@ -0,0 +1,429 @@
+import {
+    crypto as bitCrypto,
+    script as bitScript,
+    Network,
+    networks,
+    opcodes,
+    Psbt,
+    PsbtInput,
+    TapScriptSig,
+} from '@btc-vision/bitcoin';
+import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
+import { PartialSig } from 'bip174/src/lib/interfaces.js';
+import { ECPairInterface } from 'ecpair';
+import { EcKeyPair } from '../../../keypair/EcKeyPair.js';
+import { CustomKeypair } from '../BrowserSignerBase.js';
+import { PsbtSignatureOptions } from '../types/Unisat.js';
+import { Xverse, XverseRPCGetAccountResponse, XverseRPCSignPsbtResponse } from '../types/Xverse.js';
+
+declare global {
+    interface Window {
+        BitcoinProvider?: Xverse;
+    }
+}
+
+export class XverseSigner extends CustomKeypair {
+    private isInitialized: boolean = false;
+
+    constructor() {
+        super();
+
+        if (!window) {
+            throw new Error('XverseSigner can only be used in a browser environment');
+        }
+    }
+
+    private _p2tr: string | undefined;
+
+    public get p2tr(): string {
+        if (!this._p2tr) {
+            throw new Error('P2TR address not set');
+        }
+
+        return this._p2tr;
+    }
+
+    private _p2wpkh: string | undefined;
+
+    public get p2wpkh(): string {
+        if (!this._p2wpkh) {
+            throw new Error('P2PKH address not set');
+        }
+
+        return this._p2wpkh;
+    }
+
+    private _addresses: string[] | undefined;
+
+    public get addresses(): string[] {
+        if (!this._addresses) {
+            throw new Error('Addresses not set');
+        }
+
+        return this._addresses;
+    }
+
+    private _publicKey: Buffer | undefined;
+
+    public get publicKey(): Buffer {
+        if (!this._publicKey) {
+            throw new Error('Public key not set');
+        }
+
+        return this._publicKey;
+    }
+
+    public _network: Network | undefined;
+
+    public get network(): Network {
+        if (!this._network) {
+            throw new Error('Network not set');
+        }
+
+        return this._network;
+    }
+
+    public get BitcoinProvider(): Xverse {
+        const module = window.BitcoinProvider;
+        if (!module) {
+            throw new Error('Xverse Wallet extension not found');
+        }
+
+        return module;
+    }
+
+    public async init(): Promise<void> {
+        if (this.isInitialized) return;
+
+        const connectResult = (await this.BitcoinProvider.request(
+            'wallet_connect',
+            null,
+        )) as XverseRPCGetAccountResponse;
+
+        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 as unknown as ECPairInterface, this.network);
+
+        this._p2tr = EcKeyPair.getTaprootAddress(this as unknown as ECPairInterface, this.network);
+
+        this._addresses = [this._p2wpkh, this._p2tr];
+
+        this.isInitialized = true;
+    }
+
+    public getPublicKey(): Buffer {
+        if (!this.isInitialized) {
+            throw new Error('UnisatSigner not initialized');
+        }
+
+        return this.publicKey;
+    }
+
+    public sign(_hash: Buffer, _lowR?: boolean): Buffer {
+        throw new Error('Not implemented: sign');
+    }
+
+    public signSchnorr(_hash: Buffer): Buffer {
+        throw new Error('Not implemented: signSchnorr');
+    }
+
+    public verify(_hash: Buffer, _signature: Buffer): boolean {
+        throw new Error('Not implemented: verify');
+    }
+
+    public async signTaprootInput(
+        transaction: Psbt,
+        i: number,
+        sighashTypes: number[],
+    ): Promise<void> {
+        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);
+    }
+
+    public async signInput(transaction: Psbt, i: number, sighashTypes: number[]): Promise<void> {
+        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);
+    }
+
+    public async multiSignPsbt(transactions: Psbt[]): Promise<void> {
+        const toSignPsbts: string[] = [];
+        const options: PsbtSignatureOptions[] = [];
+
+        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; // for opnet, we use original keys.
+                                    break;
+                                }
+                            }
+                        }
+
+                        if (!needsToSign && input.tapInternalKey) {
+                            const tapInternalKey = input.tapInternalKey;
+                            const xOnlyPubKey = toXOnly(this.publicKey);
+
+                            if (tapInternalKey.equals(xOnlyPubKey)) {
+                                needsToSign = true;
+                                viaTaproot = true;
+                            }
+                        }
+                    } else {
+                        // Non-Taproot input
+                        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 signed = await this.unisat.signPsbt(toSignPsbts[0], options[0]);
+
+        const callSign = (await this.BitcoinProvider.request('signPsbt', {
+            psbt: toSignPsbts[0],
+            signInputs: options[0].toSignInputs,
+        })) as XverseRPCSignPsbtResponse;
+
+        if ('error' in callSign) throw new Error(callSign.error.message);
+
+        const signedPsbts = Psbt.fromBase64(callSign.result.psbt); //signed.map((hex) => Psbt.fromHex(hex));
+
+        /*for (let i = 0; i < signedPsbts.length; i++) {
+            const psbtOriginal = transactions[i];
+            const psbtSigned = signedPsbts[i];
+
+            psbtOriginal.combine(psbtSigned);
+        }*/
+
+        transactions[0].combine(signedPsbts);
+    }
+
+    private hasAlreadySignedTapScriptSig(input: TapScriptSig[]): boolean {
+        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;
+    }
+
+    private hasAlreadyPartialSig(input: PartialSig[]): boolean {
+        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;
+    }
+
+    private combine(transaction: Psbt, newPsbt: Psbt, i: number): void {
+        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 });
+            }
+        }
+    }
+
+    private async signAllTweaked(
+        transaction: Psbt,
+        sighashTypes: number[],
+        disableTweakSigner: boolean = false,
+    ): Promise<Psbt> {
+        const pubKey = this.publicKey.toString('hex');
+        const toSign = transaction.data.inputs.map((_, i) => {
+            return [
+                {
+                    index: i,
+                    publicKey: pubKey,
+                    sighashTypes,
+                    disableTweakSigner: disableTweakSigner,
+                },
+            ];
+        });
+
+        const opts: PsbtSignatureOptions = {
+            autoFinalized: false,
+            toSignInputs: toSign.flat(),
+        };
+
+        const psbt = transaction.toBase64();
+        const callSign = (await this.BitcoinProvider.request('signPsbt', {
+            psbt,
+            signInputs: opts.toSignInputs,
+        })) as XverseRPCSignPsbtResponse;
+
+        if ('error' in callSign) throw new Error(callSign.error.message);
+
+        return Psbt.fromBase64(callSign.result.psbt);
+    }
+
+    private getNonDuplicateScriptSig(
+        scriptSig1: TapScriptSig[],
+        scriptSig2: TapScriptSig[],
+    ): TapScriptSig[] {
+        const nonDuplicate: TapScriptSig[] = [];
+        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;
+    }
+}
+
+// Helper functions
+function isTaprootInput(input: PsbtInput): boolean {
+    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: PsbtInput): Buffer | null {
+    if (input.redeemScript) {
+        return input.redeemScript;
+    }
+    if (input.witnessScript) {
+        return input.witnessScript;
+    }
+    if (input.witnessUtxo) {
+        return input.witnessUtxo.script;
+    }
+    if (input.nonWitnessUtxo) {
+        // Additional logic can be added here if needed
+        return null;
+    }
+    return null;
+}
+
+function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean {
+    return pubkeyPositionInScript(pubkey, script) !== -1;
+}
+
+function pubkeyPositionInScript(pubkey: Buffer, script: Buffer): number {
+    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/src/transaction/browser/types/Xverse.ts

@@ -0,0 +1,104 @@
+export 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; // ordinals, payment or stacks (we only care about payment)
+          }[];
+      }>
+    | 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>;
+}

package/src/utils/BufferHelper.ts

@@ -1,3 +1,4 @@
+import { U256_BYTE_LENGTH } from './lengths.js';
 import { MemorySlotPointer } from './types.js';
 
 export class BufferHelper {
@@ -54,7 +55,7 @@ export class BufferHelper {
         return BigInt('0x' + hex);
     }
 
-    public static valueToUint8Array(value: bigint, length: number = 32): Uint8Array {
+    public static valueToUint8Array(value: bigint, length: number = U256_BYTE_LENGTH): Uint8Array {
         const valueHex = value.toString(16).padStart(length * 2, '0');
 
         return BufferHelper.hexToUint8Array(valueHex);

package/src/utils/lengths.ts

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

package/src/utils/types.ts

@@ -1,7 +1,5 @@
 import { DeterministicMap } from '../deterministic/DeterministicMap.js';
 
-export const ADDRESS_BYTE_LENGTH: number = 32;
-
 export type MemorySlotPointer = bigint;
 
 export type BufferLike = Uint8Array | Buffer;