Bitcoin Testnet - Compile with signatures returns Error_signing

[0xharsha]

I'm using an external wallet that returns a signature when provided with pre-sign transaction data (i.e., pre-image data hash). The signature verification with the public key returning true. However, when the signature is compiled to get the signed transaction, it returns Error_signing (i.e., error_code = 7). My code is shown below:

Signature (Testnet) : b1459be98b30136d4ea94dcdb9f1482e7f1a1a7620d82af30af9cedb824abae32e69d6510518d0da9e6525ced4d21614db244bbe0418d46acb08e319e2554d5201

const walletCore = await initWasm();

export const getSignedTxHashBtc = async (signature: string, txObject: any) => {
    if (signature == "") {
        return "";
    }

    const inputEncoded = await getEncodedInput(txObject);

    const pubKey = localStorageService.generatedPublicKey.get();

    const pubData = walletCore.HexCoding.decode(pubKey ?? "");

    const publicKey = walletCore.PublicKey.createWithData(
        pubData,
        walletCore.PublicKeyType.secp256k1
    );

    const preimageOutputEncoded = await generatePreSignTxHash(txObject);

    const preimageOutput = walletCore.HexCoding.decode(preimageOutputEncoded);

    const isValid = publicKey.verify(Buffer.from(signature, "hex"), preimageOutput); // isValid returns true

    const signData = walletCore.HexCoding.decode(signature);

    const signatures = walletCore.DataVector.createWithData(signData);

    const publicKeys = walletCore.DataVector.createWithData(pubData);

    const outputData = walletCore.TransactionCompiler.compileWithSignatures(
        walletCore.CoinType.bitcoin,
        inputEncoded,
        signatures,
        publicKeys
    );

    const output = TW.Bitcoin.Proto.SigningOutput.decode(outputData);

    const outputBytes = output.toJSON();

    return outputBytes;
};


export const getEncodedInput = async (inputs: any) => {
    const { utxos, fromAddress, outputAmmount, toAddress } = inputs;
        
    const utxo = utxos[0];

    const utxo1 = TW.Bitcoin.Proto.UnspentTransaction.create({
        outPoint: {
            hash: Buffer.from(utxo.txid, "hex").reverse(),
            index: utxo.vout,
            sequence: 4294967295 // default sequence
        },
        amount: new Long(utxo.satoshis),
        script: walletCore.BitcoinScript.lockScriptForAddress(
            fromAddress,
            walletCore.CoinType.bitcoin
        ).data()
    });

    const txInput = TW.Bitcoin.Proto.SigningInput.create({
        hashType: walletCore.BitcoinSigHashType.all.value,
        coinType: walletCore.CoinType.bitcoin.value,
        amount: new Long(outputAmmount),
        toAddress: toAddress,
        lockTime: 0,
        changeAddress: fromAddress,
        utxo: [utxo1]
    });

    return TW.Bitcoin.Proto.SigningInput.encode(txInput).finish();
};

export const generatePreSignTxHash = async (txObject: any) => {
    const {
        version,
        utxos,
        outputs,
        lockTime,
        fromAddress,
        forFeeAmount,
        feeRate,
        outputAmmount,
        toAddress
    } = txObject;

    const inputEncoded = await getEncodedInput({
        utxos,
        fromAddress,
        outputAmmount,
        toAddress
    });

    const preimageOutputData = walletCore.TransactionCompiler.preImageHashes(
        walletCore.CoinType.bitcoin,
        inputEncoded
    );

    const preimageOutput =
        TW.TxCompiler.Proto.PreSigningOutput.decode(preimageOutputData);

    const inputDataHashHex = walletCore.HexCoding.encode(preimageOutput.dataHash);

    return inputDataHashHex;
};

[0xharsha]

@satoshiotomakan signature verification against public key returns true. i'm missing something here

    const signData = walletCore.HexCoding.decode(signature);

    const signatures = walletCore.DataVector.createWithData(signData);

    const publicKeys = walletCore.DataVector.createWithData(pubData);

    const outputData = walletCore.TransactionCompiler.compileWithSignatures(
        walletCore.CoinType.bitcoin,
        inputEncoded,
        signatures,
        publicKeys
    );

[satoshiotomakan]

Hi @harshavnaik, I think the error should be due to the wrong PreSigningOutput message type.
For almost all chains TransactionCompiler.preImageHashes() returns TxCompiler::PreSigningOutput with one hash, but for Bitcoin it returns Bitcoin::PreSigningOutput with a list of sig hashes.

[satoshiotomakan]

Hi @harshavnaik, sorry for the late answer. I'm checking what can be the reason

[satoshiotomakan]

@harshavnaik looks like Bitcoin.Entry.compile expects secp256k1 signatures as DER: https://crypto.stackexchange.com/questions/57731/ecdsa-signature-rs-to-asn1-der-encoding-question

You can sign the hash and get it encoded as DER via PrivateKey.signAsDER

[0xharsha]

@satoshiotomakan thanks for the response. In my case, I'm getting a signature from the external wallet. which looks something like this
b1459be98b30136d4ea94dcdb9f1482e7f1a1a7620d82af30af9cedb824abae32e69d6510518d0da9e6525ced4d21614db244bbe0418d46acb08e319e2554d5201
for the
address tb1qahmvrcf6cxy0ahpev4ev3kp3n2mz7ntn7ffmae
I have input data and a signature from the external wallet separately. how can combine these two to broadcast?

[satoshiotomakan]

Unfortunately, WalletCore doesn't provide a function to convert an ECDSA signature to DER, but DER to ECDSA only.
Please consider using an external tool

[0xharsha]

@satoshiotomakan, it's working after converting ECDSA signature to DER.
Thank you so much @satoshiotomakan :)

[0xharsha]

@satoshiotomakan, the above code does not work properly when the sent amount is 0.01BTC. it works fine when the amount is 0.001BTC. I'm wondering what could be going wrong here?
Got the same error (Error_signing) when tried to send 0.01BTC.

[satoshiotomakan]

Hi @harshavnaik, probably I know the reason for the error.
If you do not set SigningInput.dust_policy.fixed_dust_threshold, we calculate the dust threshold automatically but incorrectly depending on SigningInput.byte_fee value. So because of that we probably filter 0.01BTC UTXO out.
Please consider trying to set SigningInput.dust_policy.fixed_dust_threshold to 1000.

I don't see the reason why lower amount works and bigger not. Please make sure if you don't change the SigningInput between TransactionCompiler.preImageHashes and TransactionCompiler.compileWithSignatures calls.

[0xharsha]

@satoshiotomakan tried for multiple values. works fine for 0.001, 0.002, 0.003 and 0.004. above 0.004 its not working.
signature validation returns it as valid signature.

 const outputData = walletCore.TransactionCompiler.compileWithSignatures(
    walletCore.CoinType.bitcoin,
    inputEncoded,
    signatures,
    publicKeys
  )

compileWithSignatures returns error_signing (error code 7).

[satoshiotomakan]

Error_signing error can be due to only two cases: either the count of provided signatures is less than required (for example, 3 UTXOs were selected but 2 signatures provided only), or one of the provided signatures is not valid for the given sighash and public key. Please make sure if you sign and pass signatures in the same order as the given PreSigningOutput.hash_public_keys

[0xharsha]

My final code looks as below which works fine for lower values.
public key and signature are verified and it's a valid signature.

Sighash Example: b1459be98b30136d4ea94dcdb9f1482e7f1a1a7620d82af30af9cedb824abae32e69d6510518d0da9e6525ced4d21614db244bbe0418d46acb08e319e2554d5201

Wondering where I'm doing wrong here.

export const getSignedTxHashBtc = async (signature: string, txObject: any) => {
  if (signature == '') {
    return ''
  }

  const _signature = signature.slice(0, -2)

  const walletCore = await initWasm()

  const inputEncoded = await getEncodedInput(txObject)

  const pubKey = localStorageService.generatedPublicKey.get()

  const pubData = walletCore.HexCoding.decode(pubKey ?? '')

  const publicKey = walletCore.PublicKey.createWithData(
    pubData,
    walletCore.PublicKeyType.secp256k1
  )

  const preimageOutputEncoded = await generatePreSignTxHash(txObject)

  const preimageOutput = walletCore.HexCoding.decode(preimageOutputEncoded)

  const isValid = publicKey.verify(
    Buffer.from(_signature, 'hex'),
    preimageOutput
  )

  const signData = walletCore.HexCoding.decode(_signature)

  const publicKeys = walletCore.DataVector.createWithData(pubData)

  const rawSignature = _signature

  const joseSignature = Buffer.from(rawSignature, 'hex')

  const derSignature = ecdsaSigFormatter.joseToDer(joseSignature, 'ES256')

  const signatures = walletCore.DataVector.createWithData(derSignature)

  const outputData = walletCore.TransactionCompiler.compileWithSignatures(
    walletCore.CoinType.bitcoin,
    inputEncoded,
    signatures,
    publicKeys
  )

  const output = TW.Bitcoin.Proto.SigningOutput.decode(outputData)

  const rawTx = walletCore.HexCoding.encode(output.encoded)

  const data = await pushTx(rawTx.substring(2))

  return data
}


export const getEncodedInput = async (inputs: any) => {
  const { utxos, fromAddress, outputAmmount, toAddress, feeRate } = inputs
  const walletCore = await initWasm()

  const utxo = utxos.map(
    (utxo: { txid: any; vout: any; value: any; satoshis: number }) => {
      return TW.Bitcoin.Proto.UnspentTransaction.create({
        outPoint: {
          hash: Buffer.from(utxo.txid, 'hex').reverse(),
          index: utxo.vout,
          sequence: 4294967295, // default sequence
        },
        amount: new Long(utxo.value),
        script: walletCore.BitcoinScript.lockScriptForAddress(
          fromAddress,
          walletCore.CoinType.bitcoin
        ).data(),
      })
    }
  )

  const txInput = TW.Bitcoin.Proto.SigningInput.create({
    hashType: walletCore.BitcoinSigHashType.all.value,
    coinType: walletCore.CoinType.bitcoin.value,
    amount: new Long(outputAmmount),
    toAddress: toAddress,
    lockTime: 0,
    changeAddress: fromAddress,
    utxo: utxo,
    byteFee: new Long(9),
  })

  return TW.Bitcoin.Proto.SigningInput.encode(txInput).finish()
}


export const generatePreSignTxHash = async (txObject: any) => {
  const {
    version,
    utxos,
    outputs,
    lockTime,
    fromAddress,
    forFeeAmount,
    feeRate,
    outputAmmount,
    toAddress,
  } = txObject

  const walletCore = await initWasm()
  
  const inputEncoded = await getEncodedInput({
    utxos,
    fromAddress,
    outputAmmount,
    toAddress,
  })

  const preimageOutputData = walletCore.TransactionCompiler.preImageHashes(
    walletCore.CoinType.bitcoin,
    inputEncoded
  )

  const preimageOutput =
    TW.Bitcoin.Proto.PreSigningOutput.decode(preimageOutputData)

  const inputDataHashHex = walletCore.HexCoding.encode(
    preimageOutput.hashPublicKeys[0].dataHash as Uint8Array
  )

  return inputDataHashHex
}

[0xharsha]

@satoshiotomakan, did you have a chance to go through it?

[0xharsha]

@satoshiotomakan can you go through my code and let me know? what going wrong here?

[0xharsha]

I have uploaded screen recordings of both transactions. you can check the error in console.

Screen.Recording.2024-07-03.at.6.48.22.PM.mov

Screen.Recording.2024-07-03.at.6.49.50.PM.mov

[0xharsha]

@satoshiotomakan this issue happening when selected utxo's count is 2 or more. if utxo's count is equal to one then it works fine.

[punithbm]

Whenever there are multiple UTXOs, Each UTXO needs to be signed separately