Predict multi signature transaction size

Question

I was looking for answer everywhere. Basically is there any way of calculate multi-sig transaction size when the transaction is creating, before the signing procedure? I was trying to find any pattern for that, with no results.

Informations I have:

• num of inputs;
• num of outputs;
• num of required signatures

I will appreciate any clue to solve this problem.

Answer 1

pubkeySize=33
sigSize=72


SizeOfRedeemScript = 1+n*pubkeySize+1+1
SizeOfScriptSig = 1+m*(1+sigSize)+SizeOfVarIntFor(RedeemScript)+SizeOfRedeemScript
sizeOf(input) = 32+4+SizeOfVarIntFor(SizeOfScriptSig) + SizeOfScriptSig + 4

SizeOfScriptPubKey = SizeOfVarIntFor(SizeOfRedeemScript) + len(script)
sizeOf(output) = 8 + SizeOfScriptPubKey

sizeOf(tx) = 4 + SizeOfVarIntFor(numInputs) + sum(SizeOfInputsArray) + SizeOfVarIntFor(numOutputs) + sum(SizeOfOutputsArray) + 4

Basically, once you know m & n (for your multisig), whether public keys are compressed (pubkeySize), plus the number of inputs and outputs, plus the types of outputs, you can come up with a pretty accurate figure for the size.

Answer 2

I stepped over this while trying to solve a similiar question: "how much tx fees do I need to prepare?"... Though this is an older question, I thought it would be good still be ok to reply, so that others might benefit from the same research.

https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm

... Signatures are either 73, 72, or 71 bytes long, with probabilities approximately 25%, 50% and 25% respectively, although sizes even smaller than that are possible with exponentially decreasing probability.

Behind the Sigs there is normally the pubkey in hex, adding 33 Bytes for compressed, and 65 Bytes for uncompressed keys. So I calculate for a standard TX roughly 100 Bytes per sig. You already have your figures for inputs and outputs. My std 2 inputs/2 outputs TX is roughly 400Bytes. The Inputs part of a TX depends on the number of

Answer 3

I wrote some code to calculate an estimate for multisig transaction size based on Karimkorun's almost unreadable answer and based off the (incomplete) documentation here.

The code:

var pubkeySize = 33
var sigSize = 72
// An approximation based on the example in
// https://en.bitcoin.it/wiki/Protocol_documentation#tx
var pubkeyScriptSize = 25 

var m = 2, n = 3

var result = tx([input(m,n)], [output(1,1), output(m,n)])
console.log(result)


// All functions calculate sizes

function input(m, n) {
  var outpoint = 32 + 4
  var sequence = 4
  return outpoint + varIntAndValue(sigScript(m, n)) + sequence
}
function sigScript(m, n) {
  return 1 + m * (1 + sigSize) + varIntAndValue(redeemScript(n))
}
function redeemScript(n) {
  return 1 + n * pubkeySize + 1 + 1
}

function output(m, n) {
  var outputValue = 8
  return outputValue + pubkeyScript(m, n)
}
function pubkeyScript(m, n) {
  return varIntAndValue(pubkeyScriptSize)
}

function tx(inputs, outputs) {
  var versionSize = 4
  var lockTime = 4
  return versionSize + varInt(inputs.length) + sum(inputs)
       + varInt(outputs.length) + sum(outputs) + lockTime
}

// The size of a variable integer for the given value.
// See https://en.bitcoin.it/wiki/Protocol_documentation#Variable_length_integer
function varInt(value) {
  if (value < 0xFD) {
    return 1
  } else if (value <= 0xFFFF) {
    return 3
  } else if (value <= 0xFFFFFFFF) {
    return 5
  } else {
    return 9
  }
}
function varIntAndValue(value) {
  return varInt(value) + value    
}
function sum(list) {
  return list.reduce((acc, x) => acc + x, 0) 
}