Add CoinSelection for specified inputs

coinlib/lib/src/coinlib_base.dart

@@ -32,6 +32,7 @@ export 'package:coinlib/src/scripts/programs/p2witness.dart';
 export 'package:coinlib/src/scripts/programs/p2wpkh.dart';
 export 'package:coinlib/src/scripts/programs/p2wsh.dart';
 
+export 'package:coinlib/src/tx/coin_selection.dart';
 export 'package:coinlib/src/tx/transaction.dart';
 export 'package:coinlib/src/tx/outpoint.dart';
 export 'package:coinlib/src/tx/output.dart';

coinlib/lib/src/crypto/random.dart

@@ -14,3 +14,8 @@ Uint8List generateRandomBytes(int size) {
  return bytes;
 }
 
+List<T> insertRandom<T>(List<T> list, T element) {
+ final newList = List<T>.from(list);
+ newList.insert(Random.secure().nextInt(newList.length+1), element);
+ return newList;
+}

coinlib/lib/src/network_params.dart

@@ -1,42 +1,47 @@
 
 class NetworkParams {
 
- final int wifPrefix;
- final int p2pkhPrefix;
- final int p2shPrefix;
- final int privHDPrefix;
- final int pubHDPrefix;
- final String bech32Hrp;
- final String messagePrefix;
+ final int wifPrefix, p2pkhPrefix, p2shPrefix, privHDPrefix, pubHDPrefix;
+ final String bech32Hrp, messagePrefix;
+ final BigInt minFee, minOutput, feePerKb;
 
- const NetworkParams({
+ NetworkParams({
  required this.wifPrefix,
  required this.p2pkhPrefix,
  required this.p2shPrefix,
  required this.privHDPrefix,
  required this.pubHDPrefix,
  required this.bech32Hrp,
  required this.messagePrefix,
+ required this.minFee,
+ required this.minOutput,
+ required this.feePerKb,
  });
 
- static const mainnet = NetworkParams(
+ static final mainnet = NetworkParams(
  wifPrefix: 183,
  p2pkhPrefix: 55,
  p2shPrefix: 117,
  privHDPrefix: 0x0488ade4,
  pubHDPrefix: 0x0488b21e,
  bech32Hrp: "pc",
  messagePrefix: "Peercoin Signed Message:\n",
+ minFee: BigInt.from(1000),
+ minOutput: BigInt.from(10000),
+ feePerKb: BigInt.from(10000),
  );
 
- static const testnet = NetworkParams(
+ static final testnet = NetworkParams(
  wifPrefix: 239,
  p2pkhPrefix: 111,
  p2shPrefix: 196,
  privHDPrefix: 0x043587CF,
  pubHDPrefix: 0x04358394,
  bech32Hrp: "tpc",
  messagePrefix: "Peercoin Signed Message:\n",
+ minFee: BigInt.from(1000),
+ minOutput: BigInt.from(10000),
+ feePerKb: BigInt.from(10000),
  );
 
 }

coinlib/lib/src/tx/coin_selection.dart

@@ -0,0 +1,153 @@
+import 'package:coinlib/src/common/serial.dart';
+import 'package:coinlib/src/crypto/random.dart';
+import 'package:coinlib/src/scripts/program.dart';
+import 'inputs/input.dart';
+import 'output.dart';
+import 'transaction.dart';
+
+class InsufficientFunds implements Exception {}
+
+/// A candidate input to spend a UTXO with the UTXO value
+class InputCandidate {
+ /// Input that can spend the UTXO
+ final Input input;
+ /// Value of UTXO to be spent
+ final BigInt value;
+ InputCandidate({ required this.input, required this.value });
+}
+
+/// Represents a selection of inputs to fund a transaction. If the inputs
+/// provide sufficient value to cover the ouputs and fee for a transaction that
+/// isn't too large, [ready] shall be true and it is possible to obtain a
+/// signable [transaction].
+class CoinSelection {
+
+ final int version;
+ final List<InputCandidate> selected;
+ final List<Output> recipients;
+ final Program changeProgram;
+ final BigInt feePerKb;
+ final BigInt minFee;
+ final BigInt minChange;
+ final int locktime;
+
+ /// The total value of selected inputs
+ late final BigInt inputValue;
+ /// The total value of all recipient outputs
+ late final BigInt recipientValue;
+ /// The fee to be paid by the transaction
+ late final BigInt fee;
+ /// The value of the change output. This is 0 for a changeless transaction or
+ /// negative if there aren't enough funds.
+ late final BigInt changeValue;
+ /// The maximum size of the transaction after being fully signed
+ late final int signedSize;
+
+ int _sizeGivenChange(int fixedSize, bool includeChange)
+ => fixedSize
+ + recipients.fold(0, (acc, output) => acc + output.size)
+ + (includeChange ? Output.fromProgram(BigInt.zero, changeProgram).size : 0)
+ + MeasureWriter.varIntSizeOfInt(
+ recipients.length + (includeChange ? 1 : 0),
+ ) as int;
+
+ BigInt _feeForSize(int size) {
+ final feeForSize = feePerKb * BigInt.from(size) ~/ BigInt.from(1000);
+ return feeForSize.compareTo(minFee) > 0 ? feeForSize : minFee;
+ }
+
+ /// Selects all the inputs from [selected] to send to the [recipients] outputs
+ /// and provide change to the [changeProgram]. The [feePerKb] specifies the
+ /// required fee in sats per KB with a minimum fee specified with
+ /// [minFee]. The [minChange] is the minimum allowed change.
+ CoinSelection({
+ this.version = Transaction.currentVersion,
+ required Iterable<InputCandidate> selected,
+ required Iterable<Output> recipients,
+ required this.changeProgram,
+ required this.feePerKb,
+ required this.minFee,
+ required this.minChange,
+ this.locktime = 0,
+ }) : selected = List.unmodifiable(selected),
+ recipients = List.unmodifiable(recipients) {
+
+ if (selected.any((candidate) => candidate.input.signedSize == null)) {
+ throw ArgumentError("Cannot select inputs without known max signed size");
+ }
+
+ // Get input and recipient values
+ inputValue = selected
+ .fold(BigInt.zero, (acc, candidate) => acc + candidate.value);
+ recipientValue = recipients
+ .fold(BigInt.zero, (acc, output) => acc + output.value);
+
+ // Get unchanging size
+ final int fixedSize
+ // Version and locktime
+ = 8
+ // Fully signed inputs
+ + MeasureWriter.varIntSizeOfInt(selected.length)
+ + selected.fold(0, (acc, candidate) => acc + candidate.input.signedSize!);
+
+ // Determine size and fee with change
+ final sizeWithChange = _sizeGivenChange(fixedSize, true);
+ final feeWithChange = _feeForSize(sizeWithChange);
+ final includedChangeValue = inputValue - recipientValue - feeWithChange;
+
+ // If change is under the required minimum, remove the change output
+ if (includedChangeValue.compareTo(minChange) < 0) {
+
+ final changelessSize = _sizeGivenChange(fixedSize, false);
+ final feeForSize = _feeForSize(changelessSize);
+ final excess = inputValue - recipientValue - feeForSize;
+
+ if (!excess.isNegative) {
+ // Exceeded without change. Fee is the input value minus the recipient
+ // value
+ signedSize = changelessSize;
+ fee = inputValue - recipientValue;
+ changeValue = BigInt.zero;
+ return;
+ }
+ // Else haven't met requirement
+
+ }
+
+ // Either haven't met requirement, or have met requirement with change so
+ // provide details of change-containing transaction
+ signedSize = sizeWithChange;
+ fee = feeWithChange;
+ changeValue = includedChangeValue;
+
+ }
+
+ /// Obtains the transaction with selected inputs and outputs including any
+ /// change at a random location, ready to be signed. Throws
+ /// [InsufficientFunds] if there is not enough input value to meet the output
+ /// value and fee, or [TransactionTooLarge] if the resulting signed
+ /// transaction would be too large.
+ Transaction get transaction {
+ if (!enoughFunds) throw InsufficientFunds();
+ if (tooLarge) throw TransactionTooLarge();
+ return Transaction(
+ version: version,
+ inputs: selected.map((candidate) => candidate.input),
+ outputs: changeless ? recipients : insertRandom(
+ recipients,
+ Output.fromProgram(changeValue, changeProgram),
+ ),
+ locktime: locktime,
+ );
+ }
+
+ /// True when the input value covers the outputs and fee
+ bool get enoughFunds => !changeValue.isNegative;
+ /// True when the change output is omitted
+ bool get changeless => changeValue.compareTo(BigInt.zero) == 0;
+ /// True if the resulting fully signed transaction will be too large
+ bool get tooLarge => signedSize > Transaction.maxSize;
+ /// True if a signable solution have been found
+ bool get ready => enoughFunds && !tooLarge;
+
+}

coinlib/test/address_test.dart

@@ -3,14 +3,17 @@ import 'package:coinlib/coinlib.dart';
 import 'package:test/test.dart';
 import 'vectors/taproot.dart';
 
-const wrongNetwork = NetworkParams(
+final wrongNetwork = NetworkParams(
  wifPrefix: 0,
  p2pkhPrefix: 0xfa,
  p2shPrefix: 0xfb,
  privHDPrefix: 0,
  pubHDPrefix: 0,
  bech32Hrp: "wrong",
  messagePrefix: "",
+ feePerKb: BigInt.from(10000),
+ minFee: BigInt.from(1000),
+ minOutput: BigInt.from(10000),
 );
 
 expectBase58Equal(Base58Address addr, Base58Address expected) {
@@ -366,6 +369,9 @@ void main() {
  wifPrefix: 0, p2shPrefix: 0, p2pkhPrefix: 0,
  privHDPrefix: 0, pubHDPrefix: 0,
  bech32Hrp: longHrp, messagePrefix: "",
+ feePerKb: BigInt.from(10000),
+ minFee: BigInt.from(1000),
+ minOutput: BigInt.from(10000),
  ),
  addr,
  );