The call to the constructor `create`  extracts some information from the unspent outputs and store it within the instance (in `ins[]`). `.inputMap{}` seemed to be just more information, needed for each input to be signed later.

Which seems unacceptable is the fact that you need to call `.create` before calling `.sign`. i.e. if you generate a Transaction using the default constructor, you wont be able to sign it using `.sign`.

IIUC the alternative would imply to passing the same parameter to so consecutive calls:
```
  var tx = Transaction.create(utxos, outs, opts);
  tx.sign(utxos, keys);
```

## Other schemas I can think of are:

1) make `create` a wrapper call, to `prepare` and `sign` so the usage will be:

(create and sign)
```
  var tx = Transaction.create(utxos, outs, keys, opts);
```

and a more customized usage could be:
``` 
  var tx = Transaction.prepare(utxos, outs, opts);
  tx.sign(utxos, keys); // can be called many times. Returns completeness.
```

or using the default constructor:
```
  var tx = Transaction.new();
  /* prepare tx */
  tx.sign(utxos, keys);
```

2) Add an inteface to .inputMap

Normal usage:
```
  var tx = Transaction.create(utxos, outs, opts);
  tx.sign(keys);
```

and using the default constructor:
```
  var tx= new Transaction();
  /* prepare tx */
 tx.sign(keys,utxos); 
 //or
 tx.setInputMap(utxos);
 tx.sign(keys);
```

I am inclined to 1). Comments?