@btc-vision/transaction 1.2.1 → 1.2.3

package/src/transaction/TransactionFactory.ts

@@ -11,12 +11,14 @@ import { InteractionTransaction } from './builders/InteractionTransaction.js';
 import { TransactionBuilder } from './builders/TransactionBuilder.js';
 import { TransactionType } from './enums/TransactionType.js';
 import {
+    IChallengeSolutionTransactionParameters,
     IDeploymentParameters,
     IFundingTransactionParameters,
     IInteractionParameters,
     ITransactionParameters,
 } from './interfaces/ITransactionParameters.js';
 import { PSBTTypes } from './psbt/PSBTTypes.js';
+import { ChallengeSolutionTransaction } from './builders/ChallengeSolutionTransaction.js';
 
 export interface DeploymentResult {
     readonly transaction: [string, string];
@@ -25,6 +27,8 @@ export interface DeploymentResult {
     readonly contractPubKey: string;
     readonly p2trAddress: string;
 
+    readonly preimage: string;
+
     readonly utxos: UTXO[];
 }
 
@@ -43,13 +47,27 @@ export interface FundingTransactionResponse {
     readonly nextUTXOs: UTXO[];
 }
 
-export interface BitcoinTransferResponse {
+export interface ChallengeSolutionResponse {
+    readonly tx: Transaction;
+    readonly original: ChallengeSolutionTransaction;
+    readonly estimatedFees: bigint;
+    readonly nextUTXOs: UTXO[];
+}
+
+export interface BitcoinTransferBase {
     readonly tx: string;
-    readonly original: FundingTransaction;
     readonly estimatedFees: bigint;
     readonly nextUTXOs: UTXO[];
 }
 
+export interface ChallengeSolution extends BitcoinTransferBase {
+    readonly original: ChallengeSolutionTransaction;
+}
+
+export interface BitcoinTransferResponse extends BitcoinTransferBase {
+    readonly original: FundingTransaction;
+}
+
 export class TransactionFactory {
     /**
      * @description Generate a transaction with a custom script.
@@ -127,7 +145,7 @@ export class TransactionFactory {
      */
     public async signInteraction(
         interactionParameters: IInteractionParameters,
-    ): Promise<[string, string, UTXO[]]> {
+    ): Promise<[string, string, UTXO[], string]> {
         if (!interactionParameters.to) {
             throw new Error('Field "to" not provided.');
         }
@@ -185,6 +203,7 @@ export class TransactionFactory {
             ...interactionParameters,
             utxos: this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.to, 0), // always 0
             randomBytes: preTransaction.getRndBytes(),
+            preimage: preTransaction.getPreimage(),
             nonWitnessUtxo: signedTransaction.tx.toBuffer(),
             estimatedFees: preTransaction.estimatedFees,
         };
@@ -197,6 +216,7 @@ export class TransactionFactory {
             signedTransaction.tx.toHex(),
             outTx.toHex(),
             this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.from, 1), // always 1
+            preTransaction.getPreimage().toString('hex'),
         ];
     }
 
@@ -244,6 +264,7 @@ export class TransactionFactory {
             ...deploymentParameters,
             utxos: [newUtxo],
             randomBytes: preTransaction.getRndBytes(),
+            preimage: preTransaction.getPreimage(),
             nonWitnessUtxo: signedTransaction.toBuffer(),
             optionalOutputs: [],
         };
@@ -270,6 +291,7 @@ export class TransactionFactory {
             contractPubKey: finalTransaction.contractPubKey,
             p2trAddress: finalTransaction.p2trAddress,
             utxos: [refundUTXO],
+            preimage: preTransaction.getPreimage().toString('hex'),
         };
     }
 
@@ -286,7 +308,27 @@ export class TransactionFactory {
         }
 
         const resp = await this.createFundTransaction(parameters);
+        return {
+            estimatedFees: resp.estimatedFees,
+            original: resp.original,
+            tx: resp.tx.toHex(),
+            nextUTXOs: this.getAllNewUTXOs(resp.original, resp.tx, parameters.from),
+        };
+    }
 
+    /**
+     * @description Creates a challenge solution transaction.
+     * @param {IChallengeSolutionTransactionParameters} parameters - The challenge solution transaction parameters
+     * @returns {Promise<ChallengeSolution>} - The signed transaction
+     */
+    public async createChallengeSolution(
+        parameters: IChallengeSolutionTransactionParameters,
+    ): Promise<ChallengeSolution> {
+        if (!parameters.from) {
+            throw new Error('Field "from" not provided.');
+        }
+
+        const resp = await this._createChallengeSolution(parameters);
         return {
             estimatedFees: resp.estimatedFees,
             original: resp.original,
@@ -323,6 +365,27 @@ export class TransactionFactory {
         return utxos;
     }
 
+    private async _createChallengeSolution(
+        parameters: IChallengeSolutionTransactionParameters,
+    ): Promise<ChallengeSolutionResponse> {
+        if (!parameters.to) throw new Error('Field "to" not provided.');
+
+        const challengeTransaction: ChallengeSolutionTransaction = new ChallengeSolutionTransaction(
+            parameters,
+        );
+        const signedTransaction: Transaction = await challengeTransaction.signTransaction();
+        if (!signedTransaction) {
+            throw new Error('Could not sign funding transaction.');
+        }
+
+        return {
+            tx: signedTransaction,
+            original: challengeTransaction,
+            estimatedFees: challengeTransaction.estimatedFees,
+            nextUTXOs: this.getUTXOAsTransaction(signedTransaction, parameters.to, 0),
+        };
+    }
+
     private async createFundTransaction(
         parameters: IFundingTransactionParameters,
     ): Promise<FundingTransactionResponse> {

package/src/transaction/browser/WalletConnection.ts

@@ -0,0 +1,110 @@
+import { Address } from '../../opnet.js';
+import { UnisatSigner } from './extensions/UnisatSigner.js';
+import { XverseSigner } from './extensions/XverseSigner.js';
+
+export enum SupportedWallets {
+    Unisat = 'unisat',
+    Xverse = 'xverse',
+}
+
+export class WalletConnection {
+    public wallet_type: SupportedWallets | null = null;
+
+    private unisatSigner: UnisatSigner | null = null; // OP_WALLET and Unisat wallet
+    private xverseSigner: XverseSigner | null = null;
+
+    public async connect(): Promise<void> {
+        if (this.wallet_type) {
+            throw new Error('Wallet already connected');
+        }
+
+        this.unisatSigner = new UnisatSigner();
+        this.xverseSigner = new XverseSigner();
+
+        if (window.opnet || window.unisat) {
+            try {
+                await this.unisatSigner.init();
+                this.wallet_type = SupportedWallets.Unisat;
+                return;
+            } catch (error: unknown) {
+                if (error instanceof Error) {
+                    throw new Error(error.message);
+                }
+
+                throw new Error('Error connecting wallet');
+            }
+        }
+
+        if (window.BitcoinProvider) {
+            try {
+                await this.xverseSigner.init();
+                this.wallet_type = SupportedWallets.Xverse;
+                return;
+            } catch (error: unknown) {
+                if (error instanceof Error) {
+                    throw new Error(error.message);
+                }
+
+                throw new Error('Error connecting wallet');
+            }
+        }
+
+        throw new Error('Wallet not found');
+    }
+
+    public async disconnect(): Promise<void> {
+        if (!this.unisatSigner || !this.xverseSigner) {
+            throw new Error('Wallet not connected');
+        }
+
+        if (this.wallet_type === SupportedWallets.Unisat) {
+            this.unisatSigner.unisat.disconnect();
+        } else {
+            await this.xverseSigner.BitcoinProvider.request('wallet_disconnect', null);
+        }
+
+        this.wallet_type = null;
+    }
+
+    public async switchTo(walletType: SupportedWallets): Promise<void> {
+        if (!this.unisatSigner || !this.xverseSigner) {
+            throw new Error('Wallet not connected');
+        }
+
+        if (this.wallet_type === walletType) return;
+
+        if (walletType === SupportedWallets.Unisat) {
+            await this.unisatSigner.init();
+            this.wallet_type = SupportedWallets.Unisat;
+        } else {
+            await this.xverseSigner.init();
+            this.wallet_type = SupportedWallets.Xverse;
+        }
+    }
+
+    public getAddress(): Address {
+        if (!this.unisatSigner || !this.xverseSigner) {
+            throw new Error('Wallet not connected');
+        }
+
+        if (this.wallet_type === SupportedWallets.Unisat) {
+            return Address.fromString(this.unisatSigner.getPublicKey().toString('hex'));
+        }
+
+        return Address.fromString(this.xverseSigner.getPublicKey().toString('hex'));
+    }
+
+    public getSigner(): UnisatSigner | XverseSigner {
+        if (!this.unisatSigner || !this.xverseSigner) {
+            throw new Error('Wallet not connected');
+        }
+
+        if (this.wallet_type === SupportedWallets.Unisat) {
+            return this.unisatSigner;
+        }
+
+        return this.xverseSigner;
+    }
+}
+
+export default WalletConnection;

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

@@ -1,18 +1,18 @@
 import {
     crypto as bitCrypto,
+    script as bitScript,
     Network,
     networks,
     Psbt,
-    script as bitScript,
     TapScriptSig,
     toXOnly,
 } from '@btc-vision/bitcoin';
+import { PartialSig } from 'bip174/src/lib/interfaces.js';
 import { ECPairInterface } from 'ecpair';
 import { EcKeyPair } from '../../../keypair/EcKeyPair.js';
+import { canSignNonTaprootInput, isTaprootInput } from '../../../signer/SignerUtils.js';
 import { CustomKeypair } from '../BrowserSignerBase.js';
 import { PsbtSignatureOptions, Unisat, UnisatNetwork } from '../types/Unisat.js';
-import { PartialSig } from 'bip174/src/lib/interfaces.js';
-import { canSignNonTaprootInput, isTaprootInput } from '../../../signer/SignerUtils.js';
 
 declare global {
     interface Window {
@@ -112,6 +112,10 @@ export class UnisatSigner extends CustomKeypair {
         }
 
         const publicKey = await this.unisat.getPublicKey();
+        if (publicKey === '') {
+            throw new Error('Unlock your wallet first');
+        }
+
         this._publicKey = Buffer.from(publicKey, 'hex');
 
         this._p2wpkh = EcKeyPair.getP2WPKHAddress(this as unknown as ECPairInterface, this.network);

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

@@ -2,14 +2,14 @@ import { Network, networks, Psbt, TapScriptSig, toXOnly } from '@btc-vision/bitc
 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';
 import {
     canSignNonTaprootInput,
     isTaprootInput,
     pubkeyInScript,
 } from '../../../signer/SignerUtils.js';
+import { CustomKeypair } from '../BrowserSignerBase.js';
+import { PsbtSignatureOptions } from '../types/Unisat.js';
+import { Xverse } from '../types/Xverse.js';
 
 declare global {
     interface Window {
@@ -90,10 +90,7 @@ export class XverseSigner extends CustomKeypair {
     public async init(): Promise<void> {
         if (this.isInitialized) return;
 
-        const connectResult = (await this.BitcoinProvider.request(
-            'wallet_connect',
-            null,
-        )) as XverseRPCGetAccountResponse;
+        const connectResult = await this.BitcoinProvider.request('wallet_connect', null);
 
         if ('error' in connectResult) throw new Error(connectResult.error.message);
 
@@ -193,7 +190,7 @@ export class XverseSigner extends CustomKeypair {
         const options: PsbtSignatureOptions[] = [];
 
         for (const psbt of transactions) {
-            const hex = psbt.toHex();
+            const hex = psbt.toBase64();
             toSignPsbts.push(hex);
 
             const toSignInputs = psbt.data.inputs
@@ -245,23 +242,20 @@ export class XverseSigner extends CustomKeypair {
             });
         }
 
-        // const signed = await this.unisat.signPsbt(toSignPsbts[0], options[0]);
+        const toSignInputs: {
+            [x: string]: number[];
+        } = {
+            [this.p2wpkh]: options[0].toSignInputs?.map((input) => input.index) || [],
+        };
 
-        const callSign = (await this.BitcoinProvider.request('signPsbt', {
+        const callSign = await this.BitcoinProvider.request('signPsbt', {
             psbt: toSignPsbts[0],
-            signInputs: options[0].toSignInputs,
-        })) as XverseRPCSignPsbtResponse;
+            signInputs: toSignInputs,
+        });
 
         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);
-        }*/
+        const signedPsbts = Psbt.fromBase64(callSign.result.psbt);
 
         transactions[0].combine(signedPsbts);
     }
@@ -342,10 +336,17 @@ export class XverseSigner extends CustomKeypair {
         };
 
         const psbt = transaction.toBase64();
-        const callSign = (await this.BitcoinProvider.request('signPsbt', {
+
+        const toSignInputs: {
+            [x: string]: number[];
+        } = {
+            [this.p2wpkh]: opts.toSignInputs?.map((input) => input.index) || [],
+        };
+
+        const callSign = await this.BitcoinProvider.request('signPsbt', {
             psbt,
-            signInputs: opts.toSignInputs,
-        })) as XverseRPCSignPsbtResponse;
+            signInputs: toSignInputs,
+        });
 
         if ('error' in callSign) throw new Error(callSign.error.message);
 

package/src/transaction/browser/types/Xverse.ts

@@ -4,38 +4,50 @@ export enum XverseNetwork {
     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;
-    };
+type XverseRPCResponse<T = unknown> =
+    | {
+          id: string;
+          jsonrpc: string;
+          result: T;
+      }
+    | {
+          id: string;
+          jsonrpc: string;
+          error: {
+              code: number;
+              message: string;
+          };
+      };
+
+type XverseRPCGetAccountResponse = XverseRPCResponse<{
+    addresses: {
+        address: string;
+        addressType: string;
+        publicKey: string;
+        purpose: 'stacks' | 'payment' | 'ordinals'; // we only care about payment
+    }[];
+    walletType: string;
+}>;
+
+type XverseRPCSignPsbtResponse = XverseRPCResponse<{
+    psbt: string;
+}>;
+
+type XverseRPCGetBalanceResponse = XverseRPCResponse<{
+    confirmed: string;
+    total: string;
+    unconfirmed: string;
+}>;
+
+export type XVersePSBTInput = {
+    psbt: string;
+    signInputs:
+        | {
+              [x: string]: number[];
+          }
+        | undefined;
 };
 
-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;
@@ -82,23 +94,25 @@ interface SignedTransactionResult {
 }
 
 export interface Xverse {
-    connect: () => Promise<void>;
+    request(method: string, params: unknown): Promise<XverseRPCResponse>;
+    request(
+        method: 'wallet_connect' | 'wallet_getAccount',
+        params: null,
+    ): Promise<XverseRPCGetAccountResponse>;
+    request(method: 'wallet_disconnect', params: null): Promise<XverseRPCResponse<null>>;
+    request(method: 'getBalance', params: null): Promise<XverseRPCGetBalanceResponse>;
+    request(method: 'signPsbt', params: XVersePSBTInput): Promise<XverseRPCSignPsbtResponse>;
 
     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/transaction/builders/ChallengeSolutionTransaction.ts

@@ -0,0 +1,88 @@
+import { TransactionType } from '../enums/TransactionType.js';
+import { IChallengeSolutionTransactionParameters } from '../interfaces/ITransactionParameters.js';
+import { getFinalScripts, opcodes, Psbt, PsbtInput, script, Signer } from '@btc-vision/bitcoin';
+import { TransactionBuilder } from './TransactionBuilder.js';
+import { ECPairInterface } from 'ecpair';
+
+export class ChallengeSolutionTransaction extends TransactionBuilder<TransactionType.CHALLENGE_SOLUTION> {
+    public readonly type: TransactionType.CHALLENGE_SOLUTION = TransactionType.CHALLENGE_SOLUTION;
+
+    protected amount: bigint;
+    protected readonly challengeSolution: Buffer;
+
+    constructor(parameters: IChallengeSolutionTransactionParameters) {
+        super(parameters);
+
+        this.amount = parameters.amount;
+        this.challengeSolution = parameters.challengeSolution;
+
+        this.internalInit();
+    }
+
+    protected override async buildTransaction(): Promise<void> {
+        if (!this.to) {
+            throw new Error('Recipient address is required');
+        }
+
+        this.addInputsFromUTXO();
+
+        if (this.isPubKeyDestination) {
+            const pubKeyScript = script.compile([
+                Buffer.from(this.to.replace('0x', ''), 'hex'),
+                opcodes.OP_CHECKSIG,
+            ]);
+
+            this.addOutput({
+                value: Number(this.amount),
+                script: pubKeyScript,
+            });
+        } else {
+            this.addOutput({
+                value: Number(this.amount),
+                address: this.to,
+            });
+        }
+
+        await this.addRefundOutput(this.amount + this.addOptionalOutputsAndGetAmount());
+    }
+
+    protected override async signInput(
+        transaction: Psbt,
+        input: PsbtInput,
+        i: number,
+        signer: Signer | ECPairInterface,
+        reverse: boolean = false,
+        errored: boolean = false,
+    ): Promise<void> {
+        // do nothing.
+    }
+
+    protected override customFinalizerP2SH = (
+        inputIndex: number,
+        input: PsbtInput,
+        scriptA: Buffer,
+        isSegwit: boolean,
+        isP2SH: boolean,
+        isP2WSH: boolean,
+    ): {
+        finalScriptSig: Buffer | undefined;
+        finalScriptWitness: Buffer | undefined;
+    } => {
+        const inputDecoded = this.inputs[inputIndex];
+        
+        if (isP2SH && inputDecoded && inputDecoded.redeemScript) {
+            const scriptSig = script.compile([this.challengeSolution, inputDecoded.redeemScript]);
+
+            return {
+                finalScriptSig: scriptSig,
+                finalScriptWitness: undefined,
+            };
+        }
+
+        return getFinalScripts(inputIndex, input, scriptA, isSegwit, isP2SH, isP2WSH, false);
+    };
+
+    protected override getSignerKey(): Signer | ECPairInterface {
+        return this.signer;
+    }
+}

package/src/transaction/builders/DeploymentTransaction.ts

@@ -9,7 +9,11 @@ import {
     Taptree,
     toXOnly,
 } from '@btc-vision/bitcoin';
-import { TransactionBuilder } from './TransactionBuilder.js';
+import {
+    MINIMUM_AMOUNT_CA,
+    MINIMUM_AMOUNT_REWARD,
+    TransactionBuilder,
+} from './TransactionBuilder.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
 import { DeploymentGenerator } from '../../generators/builders/DeploymentGenerator.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
@@ -19,12 +23,17 @@ import { SharedInteractionTransaction } from './SharedInteractionTransaction.js'
 import { ECPairInterface } from 'ecpair';
 import { Address } from '../../keypair/Address.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
+import { ChallengeGenerator, IMineableReward } from '../mineable/ChallengeGenerator.js';
 
 const p = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn;
 
 export class DeploymentTransaction extends TransactionBuilder<TransactionType.DEPLOYMENT> {
     public static readonly MAXIMUM_CONTRACT_SIZE = 128 * 1024;
     public type: TransactionType.DEPLOYMENT = TransactionType.DEPLOYMENT;
+
+    protected readonly preimage: Buffer; // ALWAYS 128 bytes for the preimage
+    protected readonly rewardChallenge: IMineableReward;
+
     /**
      * The contract address
      * @protected
@@ -110,6 +119,12 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         }
 
         this.randomBytes = parameters.randomBytes || BitcoinUtils.rndBytes();
+        this.preimage = parameters.preimage || BitcoinUtils.getSafeRandomValues(128);
+
+        this.rewardChallenge = ChallengeGenerator.generateMineableReward(
+            this.preimage,
+            this.network,
+        );
 
         this.contractSeed = this.getContractSeed();
         this.contractSigner = EcKeyPair.fromSeedKeyPair(this.contractSeed, this.network);
@@ -123,6 +138,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         this.compiledTargetScript = this.deploymentGenerator.compile(
             this.bytecode,
             this.randomBytes,
+            this.preimage,
             this.calldata,
         );
 
@@ -163,6 +179,14 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         return this.randomBytes;
     }
 
+    /**
+     * Get the contract bytecode
+     * @returns {Buffer} The contract bytecode
+     */
+    public getPreimage(): Buffer {
+        return this.preimage;
+    }
+
     /**
      * Get the contract signer public key
      * @protected
@@ -205,11 +229,31 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         this.addInputsFromUTXO();
 
         const amountSpent: bigint = this.getTransactionOPNetFee();
+
+        let amountToCA: bigint;
+        if (amountSpent > MINIMUM_AMOUNT_REWARD + MINIMUM_AMOUNT_CA) {
+            amountToCA = MINIMUM_AMOUNT_CA;
+        } else {
+            amountToCA = amountSpent;
+        }
+
+        // ALWAYS THE FIRST INPUT.
         this.addOutput({
-            value: Number(amountSpent),
+            value: Number(amountToCA),
             address: this.contractAddress.p2tr(this.network),
         });
 
+        // ALWAYS SECOND.
+        if (
+            amountToCA === MINIMUM_AMOUNT_CA &&
+            amountSpent - MINIMUM_AMOUNT_CA > MINIMUM_AMOUNT_REWARD
+        ) {
+            this.addOutput({
+                value: Number(amountSpent - amountToCA),
+                address: this.rewardChallenge.address,
+            });
+        }
+
         await this.addRefundOutput(amountSpent + this.addOptionalOutputsAndGetAmount());
     }
 
@@ -351,7 +395,6 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
 
         const scriptSolution = [
             this.randomBytes,
-            this.internalPubKeyToXOnly(),
             input.tapScriptSig[0].signature,
             input.tapScriptSig[1].signature,
         ];